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 <svx/AccessibleControlShape.hxx>
21 : #include <svx/AccessibleShapeInfo.hxx>
22 : #include "svx/DescriptionGenerator.hxx"
23 : #include <com/sun/star/drawing/XControlShape.hpp>
24 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
25 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
26 : #include <com/sun/star/form/FormComponentType.hpp>
27 : #include <com/sun/star/reflection/ProxyFactory.hpp>
28 : #include <com/sun/star/container/XContainer.hpp>
29 : #include <comphelper/processfactory.hxx>
30 : #include <unotools/accessiblestatesethelper.hxx>
31 : #include <svx/svdouno.hxx>
32 : #include "svx/unoapi.hxx"
33 : #include <svx/ShapeTypeHandler.hxx>
34 : #include <svx/SvxShapeTypes.hxx>
35 : #include <toolkit/helper/vclunohelper.hxx>
36 : #include <comphelper/accessiblewrapper.hxx>
37 : #include <svx/svdview.hxx>
38 : #include <svx/svdpagv.hxx>
39 : #include "svx/svdstr.hrc"
40 : #include <algorithm>
41 :
42 : using namespace ::comphelper;
43 : using namespace ::accessibility;
44 : using namespace ::com::sun::star::accessibility;
45 : using namespace ::com::sun::star::uno;
46 : using namespace ::com::sun::star::awt;
47 : using namespace ::com::sun::star::beans;
48 : using namespace ::com::sun::star::util;
49 : using namespace ::com::sun::star::lang;
50 : using namespace ::com::sun::star::reflection;
51 : using namespace ::com::sun::star::drawing;
52 : using namespace ::com::sun::star::container;
53 :
54 : //--------------------------------------------------------------------
55 : namespace
56 : {
57 : //................................................................
58 0 : const ::rtl::OUString& lcl_getNamePropertyName( )
59 : {
60 0 : static ::rtl::OUString s_sNamePropertyName( RTL_CONSTASCII_USTRINGPARAM( "Name" ) );
61 0 : return s_sNamePropertyName;
62 : }
63 : //................................................................
64 0 : const ::rtl::OUString& lcl_getDescPropertyName( )
65 : {
66 0 : static ::rtl::OUString s_sDescPropertyDesc( RTL_CONSTASCII_USTRINGPARAM( "HelpText" ) );
67 0 : return s_sDescPropertyDesc;
68 : }
69 : //................................................................
70 0 : const ::rtl::OUString& lcl_getLabelPropertyName( )
71 : {
72 0 : static ::rtl::OUString s_sLabelPropertyLabel( RTL_CONSTASCII_USTRINGPARAM( "Label" ) );
73 0 : return s_sLabelPropertyLabel;
74 : }
75 : //................................................................
76 : // return the property which should be used as AccessibleName
77 0 : const ::rtl::OUString& lcl_getPreferredAccNameProperty( const Reference< XPropertySetInfo >& _rxPSI )
78 : {
79 0 : if ( _rxPSI.is() && _rxPSI->hasPropertyByName( lcl_getLabelPropertyName() ) )
80 0 : return lcl_getLabelPropertyName();
81 : else
82 0 : return lcl_getNamePropertyName();
83 : }
84 :
85 : //................................................................
86 : // determines whether or not a state which belongs to the inner context needs to be forwarded to the "composed"
87 : // context
88 0 : sal_Bool isComposedState( const sal_Int16 _nState )
89 : {
90 : return ( ( AccessibleStateType::INVALID != _nState )
91 : && ( AccessibleStateType::DEFUNC != _nState )
92 : && ( AccessibleStateType::ICONIFIED != _nState )
93 : && ( AccessibleStateType::RESIZABLE != _nState )
94 : && ( AccessibleStateType::SELECTABLE != _nState )
95 : && ( AccessibleStateType::SHOWING != _nState )
96 : && ( AccessibleStateType::MANAGES_DESCENDANTS != _nState )
97 : && ( AccessibleStateType::VISIBLE != _nState )
98 0 : );
99 : }
100 :
101 : //................................................................
102 : /** determines whether the given control is in alive mode
103 : */
104 0 : inline sal_Bool isAliveMode( const Reference< XControl >& _rxControl )
105 : {
106 : OSL_PRECOND( _rxControl.is(), "AccessibleControlShape::isAliveMode: invalid control" );
107 0 : return _rxControl.is() && !_rxControl->isDesignMode();
108 : }
109 : }
110 :
111 : //=============================================================================
112 : //= AccessibleControlShape
113 : //=============================================================================
114 :
115 : //-----------------------------------------------------------------------------
116 0 : AccessibleControlShape::AccessibleControlShape (
117 : const AccessibleShapeInfo& rShapeInfo,
118 : const AccessibleShapeTreeInfo& rShapeTreeInfo)
119 : : AccessibleShape (rShapeInfo, rShapeTreeInfo)
120 : , m_bListeningForName( sal_False )
121 : , m_bListeningForDesc( sal_False )
122 : , m_bMultiplexingStates( sal_False )
123 : , m_bDisposeNativeContext( sal_False )
124 0 : , m_bWaitingForControl( sal_False )
125 : {
126 0 : m_pChildManager = new OWrappedAccessibleChildrenManager( getProcessComponentContext() );
127 0 : m_pChildManager->acquire();
128 :
129 0 : osl_atomic_increment( &m_refCount );
130 : {
131 0 : m_pChildManager->setOwningAccessible( this );
132 : }
133 0 : osl_atomic_decrement( &m_refCount );
134 0 : }
135 :
136 : //-----------------------------------------------------------------------------
137 0 : AccessibleControlShape::~AccessibleControlShape (void)
138 : {
139 0 : m_pChildManager->release();
140 0 : m_pChildManager = NULL;
141 :
142 0 : if ( m_xControlContextProxy.is() )
143 0 : m_xControlContextProxy->setDelegator( NULL );
144 0 : m_xControlContextProxy.clear();
145 0 : m_xControlContextTypeAccess.clear();
146 0 : m_xControlContextComponent.clear();
147 : // this should remove the _only_ three "real" reference (means not delegated to
148 : // ourself) to this proxy, and thus delete it
149 0 : }
150 :
151 : //-----------------------------------------------------------------------------
152 0 : SdrObject* AccessibleControlShape::getSdrObject() const
153 : {
154 0 : return GetSdrObjectFromXShape (mxShape);
155 : }
156 :
157 : namespace {
158 0 : Reference< XContainer > lcl_getControlContainer( const Window* _pWin, const SdrView* _pView )
159 : {
160 0 : Reference< XContainer > xReturn;
161 : DBG_ASSERT( _pView, "lcl_getControlContainer: invalid view!" );
162 0 : if ( _pView && _pView->GetSdrPageView())
163 : {
164 0 : xReturn = xReturn.query( _pView->GetSdrPageView()->GetControlContainer( *_pWin ) );
165 : }
166 0 : return xReturn;
167 : }
168 : }
169 :
170 : //-----------------------------------------------------------------------------
171 0 : void AccessibleControlShape::Init()
172 : {
173 0 : AccessibleShape::Init();
174 :
175 : OSL_ENSURE( !m_xControlContextProxy.is(), "AccessibleControlShape::Init: already initialized!" );
176 : try
177 : {
178 : // What we need to do here is merge the functionality of the AccessibleContext of our UNO control
179 : // with our own AccessibleContext-related functionality.
180 : //
181 : // The problem is that we do not know the interfaces our "inner" context supports - this may be any
182 : // XAccessibleXXX interface (or even any other) which makes sense for it.
183 : //
184 : // In theory, we could implement all possible interfaces ourself, and re-route all functionality to
185 : // the inner context (except those we implement ourself, like XAccessibleComponent). But this is in no
186 : // way future-proof - as soon as an inner context appears which implements an additional interface,
187 : // we would need to adjust our implementation to support this new interface, too. Bad idea.
188 : //
189 : // The usual solution for such a problem is aggregation. Aggregation means using UNO's own meachnisms
190 : // for merging an inner with an outer component, and get a component which behaves as it is exactly one.
191 : // This is what XAggregation is for. Unfortunately, aggregation requires _exact_ control over the ref count
192 : // of the inner object, which we do not have at all.
193 : // Bad, too.
194 : //
195 : // But there is a solution: com.sun.star.reflection.ProxyFactory. This service is able to create a proxy
196 : // for any component, which supports _exactly_ the same interfaces as the component. In addition, it can
197 : // be aggregated, as by definition the proxy's ref count is exactly 1 when returned from the factory.
198 : // Sounds better. Though this yields the problem of slightly degraded performance, it's the only solution
199 : // I'm aware of at the moment .....
200 :
201 : // get the control which belongs to our model (relative to our view)
202 0 : const Window* pViewWindow = maShapeTreeInfo.GetWindow();
203 0 : SdrUnoObj* pUnoObjectImpl = PTR_CAST( SdrUnoObj, getSdrObject() );
204 0 : SdrView* pView = maShapeTreeInfo.GetSdrView();
205 : OSL_ENSURE( pView && pViewWindow && pUnoObjectImpl, "AccessibleControlShape::Init: no view, or no view window, no SdrUnoObj!" );
206 :
207 0 : if ( pView && pViewWindow && pUnoObjectImpl )
208 : {
209 : // .................................................................
210 : // get the context of the control - it will be our "inner" context
211 0 : m_xUnoControl = pUnoObjectImpl->GetUnoControl( *pView, *pViewWindow );
212 :
213 0 : if ( !m_xUnoControl.is() )
214 : {
215 : // the control has not yet been created. Though speaking strictly, it is a bug that
216 : // our instance here is created without an existing control (because an AccessibleControlShape
217 : // is a representation of a view object, and can only live if the view it should represent
218 : // is complete, which implies a living control), it's by far the easiest and most riskless way
219 : // to fix this here in this class.
220 : // Okay, we will add as listener to the control container where we expect our control to appear.
221 : OSL_ENSURE( !m_bWaitingForControl, "AccessibleControlShape::Init: already waiting for the control!" );
222 :
223 0 : Reference< XContainer > xControlContainer = lcl_getControlContainer( pViewWindow, maShapeTreeInfo.GetSdrView() );
224 : OSL_ENSURE( xControlContainer.is(), "AccessibleControlShape::Init: unable to find my ControlContainer!" );
225 0 : if ( xControlContainer.is() )
226 : {
227 0 : xControlContainer->addContainerListener( this );
228 0 : m_bWaitingForControl = sal_True;
229 0 : }
230 : }
231 : else
232 : {
233 0 : Reference< XModeChangeBroadcaster > xControlModes( m_xUnoControl, UNO_QUERY );
234 0 : Reference< XAccessible > xControlAccessible( xControlModes, UNO_QUERY );
235 0 : Reference< XAccessibleContext > xNativeControlContext;
236 0 : if ( xControlAccessible.is() )
237 0 : xNativeControlContext = xControlAccessible->getAccessibleContext();
238 : OSL_ENSURE( xNativeControlContext.is(), "AccessibleControlShape::Init: no AccessibleContext for the control!" );
239 0 : m_aControlContext = WeakReference< XAccessibleContext >( xNativeControlContext );
240 :
241 : // .................................................................
242 : // add as listener to the context - we want to multiplex some states
243 0 : if ( isAliveMode( m_xUnoControl ) && xNativeControlContext.is() )
244 : { // (but only in alive mode)
245 0 : startStateMultiplexing( );
246 : }
247 :
248 : // now that we have all information about our control, do some adjustments
249 0 : adjustAccessibleRole();
250 0 : initializeComposedState();
251 :
252 : // some initialization for our child manager, which is used in alive mode only
253 0 : if ( isAliveMode( m_xUnoControl ) )
254 : {
255 0 : Reference< XAccessibleStateSet > xStates( getAccessibleStateSet( ) );
256 : OSL_ENSURE( xStates.is(), "AccessibleControlShape::AccessibleControlShape: no inner state set!" );
257 0 : m_pChildManager->setTransientChildren( !xStates.is() || xStates->contains( AccessibleStateType::MANAGES_DESCENDANTS ) );
258 : }
259 :
260 : // .................................................................
261 : // finally, aggregate a proxy for the control context
262 : // first a factory for the proxy
263 0 : Reference< XProxyFactory > xFactory = ProxyFactory::create( comphelper::getComponentContext(getProcessServiceFactory()) );
264 : // then the proxy itself
265 0 : if ( xNativeControlContext.is() )
266 : {
267 0 : m_xControlContextProxy = xFactory->createProxy( xNativeControlContext );
268 0 : OSL_VERIFY( xNativeControlContext->queryInterface( ::getCppuType( &m_xControlContextTypeAccess ) ) >>= m_xControlContextTypeAccess );
269 0 : OSL_VERIFY( xNativeControlContext->queryInterface( ::getCppuType( &m_xControlContextComponent ) ) >>= m_xControlContextComponent );
270 :
271 : // aggregate the proxy
272 0 : osl_atomic_increment( &m_refCount );
273 0 : if ( m_xControlContextProxy.is() )
274 : {
275 : // At this point in time, the proxy has a ref count of exactly one - in m_xControlContextProxy.
276 : // Remember to _not_ reset this member unles the delegator of the proxy has been reset, too!
277 0 : m_xControlContextProxy->setDelegator( *this );
278 : }
279 0 : osl_atomic_decrement( &m_refCount );
280 :
281 0 : m_bDisposeNativeContext = sal_True;
282 :
283 : // Finally, we need to add ourself as mode listener to the control. In case the mode switches,
284 : // we need to dispose ourself.
285 0 : xControlModes->addModeChangeListener( this );
286 0 : }
287 : }
288 : }
289 : }
290 0 : catch( const Exception& )
291 : {
292 : OSL_FAIL( "AccessibleControlShape::Init: could not \"aggregate\" the controls XAccessibleContext!" );
293 : }
294 0 : }
295 :
296 : //-----------------------------------------------------------------------------
297 0 : Reference< XAccessibleContext > SAL_CALL AccessibleControlShape::getAccessibleContext(void) throw (RuntimeException)
298 : {
299 0 : return AccessibleShape::getAccessibleContext ();
300 : }
301 :
302 :
303 : //-----------------------------------------------------------------------------
304 0 : void SAL_CALL AccessibleControlShape::grabFocus(void) throw (RuntimeException)
305 : {
306 0 : if ( !m_xUnoControl.is() || !isAliveMode( m_xUnoControl ) )
307 : {
308 : // in design mode, we simply forward the request to the base class
309 0 : AccessibleShape::grabFocus();
310 : }
311 : else
312 : {
313 0 : Reference< XWindow > xWindow( m_xUnoControl, UNO_QUERY );
314 : OSL_ENSURE( xWindow.is(), "AccessibleControlShape::grabFocus: invalid control!" );
315 0 : if ( xWindow.is() )
316 0 : xWindow->setFocus();
317 : }
318 0 : }
319 :
320 : //-----------------------------------------------------------------------------
321 0 : ::rtl::OUString SAL_CALL AccessibleControlShape::getImplementationName(void) throw (RuntimeException)
322 : {
323 0 : return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.accessibility.AccessibleControlShape" ) );
324 : }
325 :
326 : //-----------------------------------------------------------------------------
327 0 : ::rtl::OUString AccessibleControlShape::CreateAccessibleBaseName(void) throw (RuntimeException)
328 : {
329 0 : ::rtl::OUString sName;
330 :
331 0 : ShapeTypeId nShapeType = ShapeTypeHandler::Instance().GetTypeId (mxShape);
332 0 : switch (nShapeType)
333 : {
334 : case DRAWING_CONTROL:
335 0 : sName = ::rtl::OUString (RTL_CONSTASCII_USTRINGPARAM("ControlShape"));
336 : break;
337 : default:
338 0 : sName = ::rtl::OUString (RTL_CONSTASCII_USTRINGPARAM("UnknownAccessibleControlShape"));
339 0 : Reference< XShapeDescriptor > xDescriptor (mxShape, UNO_QUERY);
340 0 : if (xDescriptor.is())
341 : sName += ::rtl::OUString (RTL_CONSTASCII_USTRINGPARAM(": "))
342 0 : + xDescriptor->getShapeType();
343 : }
344 :
345 0 : return sName;
346 : }
347 :
348 :
349 :
350 :
351 : //--------------------------------------------------------------------
352 : ::rtl::OUString
353 0 : AccessibleControlShape::CreateAccessibleDescription (void)
354 : throw (RuntimeException)
355 : {
356 0 : DescriptionGenerator aDG (mxShape);
357 0 : ShapeTypeId nShapeType = ShapeTypeHandler::Instance().GetTypeId (mxShape);
358 0 : switch (nShapeType)
359 : {
360 : case DRAWING_CONTROL:
361 : {
362 : // check if we can obtain the "Desc" property from the model
363 0 : ::rtl::OUString sDesc( getControlModelStringProperty( lcl_getDescPropertyName() ) );
364 0 : if ( sDesc.isEmpty() )
365 : { // no -> use the default
366 0 : aDG.Initialize (STR_ObjNameSingulUno);
367 : aDG.AddProperty (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlBackground")),
368 : DescriptionGenerator::COLOR,
369 0 : ::rtl::OUString());
370 : aDG.AddProperty (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlBorder")),
371 : DescriptionGenerator::INTEGER,
372 0 : ::rtl::OUString());
373 : }
374 : // ensure that we are listening to the Name property
375 0 : m_bListeningForDesc = ensureListeningState( m_bListeningForDesc, sal_True, lcl_getDescPropertyName() );
376 : }
377 : break;
378 :
379 : default:
380 : aDG.Initialize (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
381 0 : "Unknown accessible control shape")) );
382 0 : Reference< XShapeDescriptor > xDescriptor (mxShape, UNO_QUERY);
383 0 : if (xDescriptor.is())
384 : {
385 0 : aDG.AppendString (::rtl::OUString (RTL_CONSTASCII_USTRINGPARAM("service name=")));
386 0 : aDG.AppendString (xDescriptor->getShapeType());
387 0 : }
388 : }
389 :
390 0 : return aDG();
391 : }
392 :
393 : //--------------------------------------------------------------------
394 0 : IMPLEMENT_FORWARD_REFCOUNT( AccessibleControlShape, AccessibleShape )
395 0 : IMPLEMENT_GET_IMPLEMENTATION_ID( AccessibleControlShape )
396 :
397 : //--------------------------------------------------------------------
398 0 : void SAL_CALL AccessibleControlShape::propertyChange( const PropertyChangeEvent& _rEvent ) throw (RuntimeException)
399 : {
400 0 : ::osl::MutexGuard aGuard( maMutex );
401 :
402 : // check if it is the name or the description
403 0 : if ( _rEvent.PropertyName.equals( lcl_getNamePropertyName() )
404 0 : || _rEvent.PropertyName.equals( lcl_getLabelPropertyName( ) )
405 : )
406 : {
407 : SetAccessibleName(
408 0 : CreateAccessibleName(),
409 0 : AccessibleContextBase::AutomaticallyCreated);
410 : }
411 0 : else if ( _rEvent.PropertyName.equals( lcl_getDescPropertyName() ) )
412 : {
413 : SetAccessibleDescription(
414 0 : CreateAccessibleDescription(),
415 0 : AccessibleContextBase::AutomaticallyCreated);
416 0 : }
417 : #if OSL_DEBUG_LEVEL > 0
418 : else
419 : {
420 : OSL_FAIL( "AccessibleControlShape::propertyChange: where did this come from?" );
421 : }
422 : #endif
423 0 : }
424 :
425 : //--------------------------------------------------------------------
426 0 : Any SAL_CALL AccessibleControlShape::queryInterface( const Type& _rType ) throw (RuntimeException)
427 : {
428 0 : Any aReturn = AccessibleShape::queryInterface( _rType );
429 0 : if ( !aReturn.hasValue() )
430 : {
431 0 : aReturn = AccessibleControlShape_Base::queryInterface( _rType );
432 0 : if ( !aReturn.hasValue() && m_xControlContextProxy.is() )
433 0 : aReturn = m_xControlContextProxy->queryAggregation( _rType );
434 : }
435 0 : return aReturn;
436 : }
437 :
438 : //--------------------------------------------------------------------
439 0 : Sequence< Type > SAL_CALL AccessibleControlShape::getTypes() throw (RuntimeException)
440 : {
441 0 : Sequence< Type > aShapeTypes = AccessibleShape::getTypes();
442 0 : Sequence< Type > aOwnTypes = AccessibleControlShape_Base::getTypes();
443 :
444 0 : Sequence< Type > aAggregateTypes;
445 0 : if ( m_xControlContextTypeAccess.is() )
446 0 : aAggregateTypes = m_xControlContextTypeAccess->getTypes();
447 :
448 0 : Sequence< Type > aAllTypes = concatSequences( aShapeTypes, aOwnTypes, aAggregateTypes );
449 :
450 : // remove duplicates
451 0 : Type* pBegin = aAllTypes.getArray();
452 0 : Type* pEnd = pBegin + aAllTypes.getLength();
453 0 : while ( pBegin != pEnd )
454 : {
455 0 : Type aThisRoundType = *pBegin;
456 0 : if ( ++pBegin != pEnd )
457 : {
458 0 : pEnd = ::std::remove( pBegin, pEnd, aThisRoundType );
459 : // now all types between begin and (the old) end which equal aThisRoundType
460 : // are moved behind the new end
461 : }
462 0 : }
463 0 : aAllTypes.realloc( pEnd - aAllTypes.getArray() );
464 :
465 0 : return aAllTypes;
466 : }
467 :
468 : //--------------------------------------------------------------------
469 0 : void SAL_CALL AccessibleControlShape::notifyEvent( const AccessibleEventObject& _rEvent ) throw (RuntimeException)
470 : {
471 0 : if ( AccessibleEventId::STATE_CHANGED == _rEvent.EventId )
472 : {
473 : // multiplex this change
474 0 : sal_Int16 nLostState( 0 ), nGainedState( 0 );
475 0 : _rEvent.OldValue >>= nLostState;
476 0 : _rEvent.NewValue >>= nGainedState;
477 :
478 : // don't multiplex states which the inner context is not resposible for
479 0 : if ( isComposedState( nLostState ) )
480 0 : AccessibleShape::ResetState( nLostState );
481 :
482 0 : if ( isComposedState( nGainedState ) )
483 0 : AccessibleShape::SetState( nGainedState );
484 : }
485 : else
486 : {
487 0 : AccessibleEventObject aTranslatedEvent( _rEvent );
488 :
489 : {
490 0 : ::osl::MutexGuard aGuard( maMutex );
491 :
492 : // let the child manager translate the event
493 0 : aTranslatedEvent.Source = *this;
494 0 : m_pChildManager->translateAccessibleEvent( _rEvent, aTranslatedEvent );
495 :
496 : // see if any of these notifications affect our child manager
497 0 : m_pChildManager->handleChildNotification( _rEvent );
498 : }
499 :
500 0 : FireEvent( aTranslatedEvent );
501 : }
502 0 : }
503 :
504 : //--------------------------------------------------------------------
505 0 : void SAL_CALL AccessibleControlShape::modeChanged( const ModeChangeEvent& _rSource ) throw (RuntimeException)
506 : {
507 : // did it come from our inner context (the real one, not it's proxy!)?
508 : OSL_TRACE ("AccessibleControlShape::modeChanged");
509 0 : Reference< XControl > xSource( _rSource.Source, UNO_QUERY ); // for faster compare
510 0 : if ( xSource.get() == m_xUnoControl.get() )
511 : {
512 : // If our "pseudo-aggregated" inner context does not live anymore,
513 : // we don't want to live, too. This is accomplished by asking our
514 : // parent to replace this object with a new one. Disposing this
515 : // object and sending notifications about the replacement are in
516 : // the responsibility of our parent.
517 0 : OSL_VERIFY( mpParent->ReplaceChild ( this, mxShape, mnIndex, maShapeTreeInfo ) );
518 0 : }
519 : #if OSL_DEBUG_LEVEL > 0
520 : else
521 : OSL_FAIL( "AccessibleControlShape::modeChanged: where did this come from?" );
522 : #endif
523 0 : }
524 :
525 : //--------------------------------------------------------------------
526 0 : void SAL_CALL AccessibleControlShape::disposing (const EventObject& _rSource) throw (RuntimeException)
527 : {
528 0 : AccessibleShape::disposing( _rSource );
529 0 : }
530 :
531 : //--------------------------------------------------------------------
532 0 : sal_Bool AccessibleControlShape::ensureListeningState(
533 : const sal_Bool _bCurrentlyListening, const sal_Bool _bNeedNewListening,
534 : const ::rtl::OUString& _rPropertyName )
535 : {
536 0 : if ( ( _bCurrentlyListening == _bNeedNewListening ) || !ensureControlModelAccess() )
537 : // nothing to do
538 0 : return _bCurrentlyListening;
539 :
540 : try
541 : {
542 0 : if ( !m_xModelPropsMeta.is() || m_xModelPropsMeta->hasPropertyByName( _rPropertyName ) )
543 : {
544 : // add or revoke as listener
545 0 : if ( _bNeedNewListening )
546 0 : m_xControlModel->addPropertyChangeListener( _rPropertyName, static_cast< XPropertyChangeListener* >( this ) );
547 : else
548 0 : m_xControlModel->removePropertyChangeListener( _rPropertyName, static_cast< XPropertyChangeListener* >( this ) );
549 : }
550 : else
551 : OSL_FAIL( "AccessibleControlShape::ensureListeningState: this property does not exist at this model!" );
552 : }
553 0 : catch( const Exception& e )
554 : {
555 : (void)e; // make compiler happy
556 : OSL_FAIL( "AccessibleControlShape::ensureListeningState: could not change the listening state!" );
557 : }
558 :
559 0 : return _bNeedNewListening;
560 : }
561 :
562 : //--------------------------------------------------------------------
563 0 : sal_Int32 SAL_CALL AccessibleControlShape::getAccessibleChildCount( ) throw(RuntimeException)
564 : {
565 0 : if ( !m_xUnoControl.is() )
566 0 : return 0;
567 0 : else if ( !isAliveMode( m_xUnoControl ) )
568 : // no special action required when in design mode
569 0 : return AccessibleShape::getAccessibleChildCount( );
570 : else
571 : {
572 : // in alive mode, we have the full control over our children - they are determined by the children
573 : // of the context of our UNO control
574 0 : Reference< XAccessibleContext > xControlContext( m_aControlContext );
575 : OSL_ENSURE( xControlContext.is(), "AccessibleControlShape::getAccessibleChildCount: control context already dead! How this!" );
576 0 : return xControlContext.is() ? xControlContext->getAccessibleChildCount() : 0;
577 : }
578 : }
579 :
580 : //--------------------------------------------------------------------
581 0 : Reference< XAccessible > SAL_CALL AccessibleControlShape::getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException, RuntimeException)
582 : {
583 0 : Reference< XAccessible > xChild;
584 0 : if ( !m_xUnoControl.is() )
585 : {
586 0 : throw IndexOutOfBoundsException();
587 : }
588 0 : if ( !isAliveMode( m_xUnoControl ) )
589 : {
590 : // no special action required when in design mode - let the base class handle this
591 0 : xChild = AccessibleShape::getAccessibleChild( i );
592 : }
593 : else
594 : {
595 : // in alive mode, we have the full control over our children - they are determined by the children
596 : // of the context of our UNO control
597 :
598 0 : Reference< XAccessibleContext > xControlContext( m_aControlContext );
599 : OSL_ENSURE( xControlContext.is(), "AccessibleControlShape::getAccessibleChildCount: control context already dead! How this!" );
600 0 : if ( xControlContext.is() )
601 : {
602 0 : Reference< XAccessible > xInnerChild( xControlContext->getAccessibleChild( i ) );
603 : OSL_ENSURE( xInnerChild.is(), "AccessibleControlShape::getAccessibleChild: control context returned nonsense!" );
604 0 : if ( xInnerChild.is() )
605 : {
606 : // we need to wrap this inner child into an own implementation
607 0 : xChild = m_pChildManager->getAccessibleWrapperFor( xInnerChild );
608 0 : }
609 0 : }
610 : }
611 :
612 : #if OSL_DEBUG_LEVEL > 0
613 : sal_Int32 nChildIndex = -1;
614 : Reference< XAccessibleContext > xContext;
615 : if ( xChild.is() )
616 : xContext = xChild->getAccessibleContext( );
617 : if ( xContext.is() )
618 : nChildIndex = xContext->getAccessibleIndexInParent( );
619 : OSL_ENSURE( nChildIndex == i, "AccessibleControlShape::getAccessibleChild: index mismatch!" );
620 : #endif
621 0 : return xChild;
622 : }
623 :
624 : //--------------------------------------------------------------------
625 0 : Reference< XAccessibleRelationSet > SAL_CALL AccessibleControlShape::getAccessibleRelationSet( ) throw (RuntimeException)
626 : {
627 : // TODO
628 0 : return AccessibleShape::getAccessibleRelationSet( );
629 : }
630 :
631 : //--------------------------------------------------------------------
632 0 : ::rtl::OUString AccessibleControlShape::CreateAccessibleName (void) throw (RuntimeException)
633 : {
634 0 : ensureControlModelAccess();
635 :
636 : // check if we can obtain the "Name" resp. "Label" property from the model
637 0 : const ::rtl::OUString& rAccNameProperty = lcl_getPreferredAccNameProperty( m_xModelPropsMeta );
638 :
639 0 : ::rtl::OUString sName( getControlModelStringProperty( rAccNameProperty ) );
640 0 : if ( sName.isEmpty() )
641 : { // no -> use the default
642 0 : sName = AccessibleShape::CreateAccessibleName();
643 : }
644 :
645 : // now that somebody first asked us for our name, ensure that we are listening to name changes on the model
646 0 : m_bListeningForName = ensureListeningState( m_bListeningForName, sal_True, lcl_getPreferredAccNameProperty( m_xModelPropsMeta ) );
647 :
648 0 : return sName;
649 : }
650 :
651 : //--------------------------------------------------------------------
652 0 : void SAL_CALL AccessibleControlShape::disposing (void)
653 : {
654 : // ensure we're not listening
655 0 : m_bListeningForName = ensureListeningState( m_bListeningForName, sal_False, lcl_getPreferredAccNameProperty( m_xModelPropsMeta ) );
656 0 : m_bListeningForDesc = ensureListeningState( m_bListeningForDesc, sal_False, lcl_getDescPropertyName() );
657 :
658 0 : if ( m_bMultiplexingStates )
659 0 : stopStateMultiplexing( );
660 :
661 : // dispose the child cache/map
662 0 : m_pChildManager->dispose();
663 :
664 : // release the model
665 0 : m_xControlModel.clear();
666 0 : m_xModelPropsMeta.clear();
667 0 : m_aControlContext = WeakReference< XAccessibleContext >();
668 :
669 : // stop listening at the control container (should never be necessary here, but who knows ....)
670 0 : if ( m_bWaitingForControl )
671 : {
672 : OSL_FAIL( "AccessibleControlShape::disposing: this should never happen!" );
673 0 : Reference< XContainer > xContainer = lcl_getControlContainer( maShapeTreeInfo.GetWindow(), maShapeTreeInfo.GetSdrView() );
674 0 : if ( xContainer.is() )
675 : {
676 0 : m_bWaitingForControl = sal_False;
677 0 : xContainer->removeContainerListener( this );
678 0 : }
679 : }
680 :
681 : // forward the disposel to our inner context
682 0 : if ( m_bDisposeNativeContext )
683 : {
684 : // don't listen for mode changes anymore
685 0 : Reference< XModeChangeBroadcaster > xControlModes( m_xUnoControl, UNO_QUERY );
686 : OSL_ENSURE( xControlModes.is(), "AccessibleControlShape::disposing: don't have an mode broadcaster anymore!" );
687 0 : if ( xControlModes.is() )
688 0 : xControlModes->removeModeChangeListener( this );
689 :
690 0 : if ( m_xControlContextComponent.is() )
691 0 : m_xControlContextComponent->dispose();
692 : // do _not_ clear m_xControlContextProxy! This has to be done in the dtor for correct ref-count handling
693 :
694 : // no need to dispose the proxy/inner context anymore
695 0 : m_bDisposeNativeContext = sal_False;
696 : }
697 :
698 0 : m_xUnoControl.clear();
699 :
700 : // let the base do it's stuff
701 0 : AccessibleShape::disposing();
702 0 : }
703 :
704 : //--------------------------------------------------------------------
705 0 : sal_Bool AccessibleControlShape::ensureControlModelAccess() SAL_THROW(())
706 : {
707 0 : if ( m_xControlModel.is() )
708 0 : return sal_True;
709 :
710 : try
711 : {
712 0 : Reference< XControlShape > xShape( mxShape, UNO_QUERY );
713 0 : if ( xShape.is() )
714 0 : m_xControlModel = m_xControlModel.query( xShape->getControl() );
715 :
716 0 : if ( m_xControlModel.is() )
717 0 : m_xModelPropsMeta = m_xControlModel->getPropertySetInfo();
718 : }
719 0 : catch( const Exception& e )
720 : {
721 : (void)e; // make compiler happy
722 : OSL_FAIL( "AccessibleControlShape::ensureControlModelAccess: caught an exception!" );
723 : }
724 :
725 0 : return m_xControlModel.is();
726 : }
727 :
728 : //--------------------------------------------------------------------
729 0 : void AccessibleControlShape::startStateMultiplexing()
730 : {
731 : OSL_PRECOND( !m_bMultiplexingStates, "AccessibleControlShape::startStateMultiplexing: already multiplexing!" );
732 :
733 : #if OSL_DEBUG_LEVEL > 0
734 : // we should have a control, and it should be in alive mode
735 : OSL_PRECOND( isAliveMode( m_xUnoControl ),
736 : "AccessibleControlShape::startStateMultiplexing: should be done in alive mode only!" );
737 : #endif
738 : // we should have the native context of the control
739 0 : Reference< XAccessibleEventBroadcaster > xBroadcaster( m_aControlContext.get(), UNO_QUERY );
740 : OSL_ENSURE( xBroadcaster.is(), "AccessibleControlShape::startStateMultiplexing: no AccessibleEventBroadcaster on the native context!" );
741 :
742 0 : if ( xBroadcaster.is() )
743 : {
744 0 : xBroadcaster->addAccessibleEventListener( this );
745 0 : m_bMultiplexingStates = sal_True;
746 0 : }
747 0 : }
748 :
749 : //--------------------------------------------------------------------
750 0 : void AccessibleControlShape::stopStateMultiplexing()
751 : {
752 : OSL_PRECOND( m_bMultiplexingStates, "AccessibleControlShape::stopStateMultiplexing: not multiplexing!" );
753 :
754 : // we should have the native context of the control
755 0 : Reference< XAccessibleEventBroadcaster > xBroadcaster( m_aControlContext.get(), UNO_QUERY );
756 : OSL_ENSURE( xBroadcaster.is(), "AccessibleControlShape::stopStateMultiplexing: no AccessibleEventBroadcaster on the native context!" );
757 :
758 0 : if ( xBroadcaster.is() )
759 : {
760 0 : xBroadcaster->removeAccessibleEventListener( this );
761 0 : m_bMultiplexingStates = sal_False;
762 0 : }
763 0 : }
764 :
765 : //--------------------------------------------------------------------
766 0 : ::rtl::OUString AccessibleControlShape::getControlModelStringProperty( const ::rtl::OUString& _rPropertyName ) const SAL_THROW(())
767 : {
768 0 : ::rtl::OUString sReturn;
769 : try
770 : {
771 0 : if ( const_cast< AccessibleControlShape* >( this )->ensureControlModelAccess() )
772 : {
773 0 : if ( !m_xModelPropsMeta.is() || m_xModelPropsMeta->hasPropertyByName( _rPropertyName ) )
774 : // ask only if a) the control does not have a PropertySetInfo object or b) it has, and the
775 : // property in question is available
776 0 : m_xControlModel->getPropertyValue( _rPropertyName ) >>= sReturn;
777 : }
778 : }
779 0 : catch( const Exception& )
780 : {
781 : OSL_FAIL( "OAccessibleControlContext::getModelStringProperty: caught an exception!" );
782 : }
783 0 : return sReturn;
784 : }
785 :
786 : //--------------------------------------------------------------------
787 0 : void AccessibleControlShape::adjustAccessibleRole( )
788 : {
789 : // if we're in design mode, we are a simple SHAPE, in alive mode, we use the role of our inner context
790 0 : if ( !isAliveMode( m_xUnoControl ) )
791 0 : return;
792 :
793 : // we're in alive mode -> determine the role of the inner context
794 0 : Reference< XAccessibleContext > xNativeContext( m_aControlContext );
795 : OSL_PRECOND( xNativeContext.is(), "AccessibleControlShape::adjustAccessibleRole: no inner context!" );
796 0 : if ( xNativeContext.is() )
797 0 : SetAccessibleRole( xNativeContext->getAccessibleRole( ) );
798 : }
799 :
800 : #ifdef DBG_UTIL
801 : //--------------------------------------------------------------------
802 : sal_Bool AccessibleControlShape::SetState( sal_Int16 _nState )
803 : {
804 : OSL_ENSURE( !isAliveMode( m_xUnoControl ) || !isComposedState( _nState ),
805 : "AccessibleControlShape::SetState: a state which should be determined by the control context is set from outside!" );
806 : return AccessibleShape::SetState( _nState );
807 : }
808 : #endif // DBG_UTIL
809 :
810 : //--------------------------------------------------------------------
811 0 : void AccessibleControlShape::initializeComposedState()
812 : {
813 0 : if ( !isAliveMode( m_xUnoControl ) )
814 : // no action necessary for design mode
815 0 : return;
816 :
817 : // get our own state set implementation
818 : ::utl::AccessibleStateSetHelper* pComposedStates =
819 0 : static_cast< ::utl::AccessibleStateSetHelper* >( mxStateSet.get() );
820 : OSL_PRECOND( pComposedStates,
821 : "AccessibleControlShape::initializeComposedState: no composed set!" );
822 :
823 : // we need to reset some states of the composed set, because they either do not apply
824 : // for controls in alive mode, or are in the responsibility of the UNO-control, anyway
825 0 : pComposedStates->RemoveState( AccessibleStateType::ENABLED ); // this is controlled by the UNO-control
826 0 : pComposedStates->RemoveState( AccessibleStateType::SENSITIVE ); // this is controlled by the UNO-control
827 0 : pComposedStates->RemoveState( AccessibleStateType::FOCUSABLE ); // this is controlled by the UNO-control
828 0 : pComposedStates->RemoveState( AccessibleStateType::SELECTABLE ); // this does not hold for an alive UNO-control
829 : #if OSL_DEBUG_LEVEL > 0
830 : // now, only states which are not in the responsibility of the UNO control should be part of this state set
831 : {
832 : Sequence< sal_Int16 > aInitStates = pComposedStates->getStates();
833 : for ( sal_Int32 i=0; i<aInitStates.getLength(); ++i )
834 : OSL_ENSURE( !isComposedState( aInitStates.getConstArray()[i] ),
835 : "AccessibleControlShape::initializeComposedState: invalid initial composed state (should be controlled by the UNO-control)!" );
836 : }
837 : #endif
838 :
839 : // get my inner context
840 0 : Reference< XAccessibleContext > xInnerContext( m_aControlContext );
841 : OSL_PRECOND( xInnerContext.is(), "AccessibleControlShape::initializeComposedState: no inner context!" );
842 0 : if ( xInnerContext.is() )
843 : {
844 : // get all states of the inner context
845 0 : Reference< XAccessibleStateSet > xInnerStates( xInnerContext->getAccessibleStateSet() );
846 : OSL_ENSURE( xInnerStates.is(), "AccessibleControlShape::initializeComposedState: no inner states!" );
847 0 : Sequence< sal_Int16 > aInnerStates;
848 0 : if ( xInnerStates.is() )
849 0 : aInnerStates = xInnerStates->getStates();
850 :
851 : // look which one are to be propagated to the composed context
852 0 : const sal_Int16* pStates = aInnerStates.getConstArray();
853 0 : const sal_Int16* pStatesEnd = pStates + aInnerStates.getLength();
854 0 : for ( ; pStates != pStatesEnd; ++pStates )
855 : {
856 0 : if ( isComposedState( *pStates ) && !pComposedStates->contains( *pStates ) )
857 : {
858 0 : pComposedStates->AddState( *pStates );
859 : }
860 0 : }
861 0 : }
862 : }
863 :
864 0 : void SAL_CALL AccessibleControlShape::elementInserted( const ::com::sun::star::container::ContainerEvent& _rEvent ) throw (::com::sun::star::uno::RuntimeException)
865 : {
866 0 : Reference< XContainer > xContainer( _rEvent.Source, UNO_QUERY );
867 0 : Reference< XControl > xControl( _rEvent.Element, UNO_QUERY );
868 :
869 : OSL_ENSURE( xContainer.is() && xControl.is(),
870 : "AccessibleControlShape::elementInserted: invalid event description!" );
871 :
872 0 : if ( !xControl.is() )
873 0 : return;
874 :
875 0 : ensureControlModelAccess();
876 :
877 0 : Reference< XInterface > xNewNormalized( xControl->getModel(), UNO_QUERY );
878 0 : Reference< XInterface > xMyModelNormalized( m_xControlModel, UNO_QUERY );
879 0 : if ( xNewNormalized.get() && xMyModelNormalized.get() )
880 : {
881 : // now finally the control for the model we're responsible for has been inserted into the container
882 0 : Reference< XInterface > xKeepAlive( *this );
883 :
884 : // first, we're not interested in any more container events
885 0 : if ( xContainer.is() )
886 : {
887 0 : xContainer->removeContainerListener( this );
888 0 : m_bWaitingForControl = sal_False;
889 : }
890 :
891 : // second, we need to replace ourself with a new version, which now can be based on the
892 : // control
893 0 : OSL_VERIFY( mpParent->ReplaceChild ( this, mxShape, mnIndex, maShapeTreeInfo ) );
894 0 : }
895 : }
896 :
897 0 : void SAL_CALL AccessibleControlShape::elementRemoved( const ::com::sun::star::container::ContainerEvent& ) throw (::com::sun::star::uno::RuntimeException)
898 : {
899 : // not interested in
900 0 : }
901 :
902 0 : void SAL_CALL AccessibleControlShape::elementReplaced( const ::com::sun::star::container::ContainerEvent& ) throw (::com::sun::star::uno::RuntimeException)
903 : {
904 : // not interested in
905 0 : }
906 :
907 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
