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 "AccessibleBase.hxx"
21 : #include "AccessibleChartShape.hxx"
22 : #include "ObjectHierarchy.hxx"
23 : #include "ObjectIdentifier.hxx"
24 : #include "chartview/ExplicitValueProvider.hxx"
25 : #include "macros.hxx"
26 :
27 : #include <com/sun/star/awt/XDevice.hpp>
28 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
29 : #include <com/sun/star/accessibility/AccessibleEventObject.hpp>
30 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
31 : #include <com/sun/star/accessibility/AccessibleRole.hpp>
32 : #include <com/sun/star/drawing/LineStyle.hpp>
33 : #include <com/sun/star/drawing/FillStyle.hpp>
34 : #include <rtl/ustrbuf.hxx>
35 : // for SolarMutex
36 : #include <vcl/svapp.hxx>
37 : #include <rtl/uuid.h>
38 : #include <cppuhelper/queryinterface.hxx>
39 : #include <cppuhelper/supportsservice.hxx>
40 : #include <svl/itemset.hxx>
41 : #include <editeng/unofdesc.hxx>
42 : #include <editeng/outliner.hxx>
43 : #include <svx/svdoutl.hxx>
44 : #include <svx/svdetc.hxx>
45 : #include <svx/unoshape.hxx>
46 : #include <svx/unoprov.hxx>
47 : #include <vcl/unohelp.hxx>
48 : #include <toolkit/helper/vclunohelper.hxx>
49 : #include <vcl/window.hxx>
50 : #include <vcl/graph.hxx>
51 : #include <vcl/settings.hxx>
52 :
53 : #include <algorithm>
54 : #include <o3tl/compat_functional.hxx>
55 :
56 : #include "ChartElementFactory.hxx"
57 :
58 : using namespace ::com::sun::star;
59 : using namespace ::com::sun::star::accessibility;
60 :
61 : using ::com::sun::star::uno::UNO_QUERY;
62 : using ::com::sun::star::uno::Reference;
63 : using ::osl::MutexGuard;
64 : using ::osl::ClearableMutexGuard;
65 : using ::osl::ResettableMutexGuard;
66 : using ::com::sun::star::uno::RuntimeException;
67 : using ::com::sun::star::uno::Any;
68 :
69 : namespace chart
70 : {
71 :
72 : /** @param bMayHaveChildren is false per default
73 : */
74 0 : AccessibleBase::AccessibleBase(
75 : const AccessibleElementInfo & rAccInfo,
76 : bool bMayHaveChildren,
77 : bool bAlwaysTransparent /* default: false */ ) :
78 : impl::AccessibleBase_Base( m_aMutex ),
79 : m_bIsDisposed( false ),
80 : m_bMayHaveChildren( bMayHaveChildren ),
81 : m_bChildrenInitialized( false ),
82 : m_nEventNotifierId(0),
83 0 : m_pStateSetHelper( new ::utl::AccessibleStateSetHelper() ),
84 : m_aStateSet( m_pStateSetHelper ),
85 : m_aAccInfo( rAccInfo ),
86 : m_bAlwaysTransparent( bAlwaysTransparent ),
87 0 : m_bStateSetInitialized( false )
88 : {
89 : // initialize some states
90 : OSL_ASSERT( m_pStateSetHelper );
91 0 : m_pStateSetHelper->AddState( AccessibleStateType::ENABLED );
92 0 : m_pStateSetHelper->AddState( AccessibleStateType::SHOWING );
93 0 : m_pStateSetHelper->AddState( AccessibleStateType::VISIBLE );
94 0 : m_pStateSetHelper->AddState( AccessibleStateType::SELECTABLE );
95 0 : m_pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE );
96 0 : }
97 :
98 0 : AccessibleBase::~AccessibleBase()
99 : {
100 : OSL_ASSERT( m_bIsDisposed );
101 0 : }
102 :
103 0 : bool AccessibleBase::CheckDisposeState( bool bThrowException /* default: true */ ) const
104 : throw (lang::DisposedException)
105 : {
106 0 : if( bThrowException &&
107 : m_bIsDisposed )
108 : {
109 : throw lang::DisposedException("component has state DEFUNC",
110 0 : static_cast< uno::XWeak * >( const_cast< AccessibleBase * >( this )));
111 : }
112 0 : return m_bIsDisposed;
113 : }
114 :
115 0 : bool AccessibleBase::NotifyEvent( EventType eEventType, const AccessibleUniqueId & rId )
116 : {
117 0 : if( GetId() == rId )
118 : {
119 : // event is addressed to this object
120 :
121 0 : ::com::sun::star::uno::Any aEmpty;
122 0 : ::com::sun::star::uno::Any aSelected;
123 0 : aSelected <<= AccessibleStateType::SELECTED;
124 0 : switch( eEventType )
125 : {
126 : case OBJECT_CHANGE:
127 : {
128 0 : BroadcastAccEvent( AccessibleEventId::VISIBLE_DATA_CHANGED, aEmpty, aEmpty );
129 : #if OSL_DEBUG_LEVEL > 1
130 : OSL_TRACE(
131 : OUStringToOString(
132 : OUString( "Visible data event sent by: " ) +
133 : getAccessibleName(),
134 : RTL_TEXTENCODING_ASCII_US ).getStr() );
135 : #endif
136 : }
137 0 : break;
138 :
139 : case GOT_SELECTION:
140 : {
141 0 : AddState( AccessibleStateType::SELECTED );
142 0 : BroadcastAccEvent( AccessibleEventId::STATE_CHANGED, aSelected, aEmpty );
143 :
144 0 : AddState( AccessibleStateType::FOCUSED );
145 0 : aSelected <<= AccessibleStateType::FOCUSED;
146 0 : BroadcastAccEvent( AccessibleEventId::STATE_CHANGED, aSelected, aEmpty, true );
147 : #if OSL_DEBUG_LEVEL > 1
148 : OSL_TRACE(
149 : OUStringToOString(
150 : OUString( "Selection acquired by: " ) +
151 : getAccessibleName(),
152 : RTL_TEXTENCODING_ASCII_US ).getStr() );
153 : #endif
154 : }
155 0 : break;
156 :
157 : case LOST_SELECTION:
158 : {
159 0 : RemoveState( AccessibleStateType::SELECTED );
160 0 : BroadcastAccEvent( AccessibleEventId::STATE_CHANGED, aEmpty, aSelected );
161 :
162 0 : AddState( AccessibleStateType::FOCUSED );
163 0 : aSelected <<= AccessibleStateType::FOCUSED;
164 0 : BroadcastAccEvent( AccessibleEventId::STATE_CHANGED, aEmpty, aSelected, true );
165 : #if OSL_DEBUG_LEVEL > 1
166 : OSL_TRACE(
167 : OUStringToOString(
168 : OUString( "Selection lost by: " ) +
169 : getAccessibleName(),
170 : RTL_TEXTENCODING_ASCII_US ).getStr() );
171 : #endif
172 : }
173 0 : break;
174 :
175 : case PROPERTY_CHANGE:
176 : {
177 : //not implemented --> rebuild all
178 : }
179 0 : break;
180 : }
181 0 : return true;
182 : }
183 0 : else if( m_bMayHaveChildren )
184 : {
185 0 : bool bStop = false;
186 :
187 0 : ClearableMutexGuard aGuard( GetMutex() );
188 : // make local copy for notification
189 0 : ChildListVectorType aLocalChildList( m_aChildList );
190 0 : aGuard.clear();
191 :
192 0 : ChildListVectorType::iterator aEndIter = aLocalChildList.end();
193 0 : for( ChildListVectorType::iterator aIter = aLocalChildList.begin() ;
194 0 : ( aIter != aEndIter ) && ( ! bStop ) ;
195 : ++aIter )
196 : {
197 : // Note: at this place we must be sure to have an AccessibleBase
198 : // object in the UNO reference to XAccessible !
199 : bStop = (*static_cast< AccessibleBase * >
200 0 : ( (*aIter).get() )).NotifyEvent( eEventType, rId );
201 : }
202 0 : return bStop;
203 : }
204 :
205 0 : return false;
206 : }
207 :
208 0 : void AccessibleBase::AddState( sal_Int16 aState )
209 : throw (RuntimeException)
210 : {
211 0 : CheckDisposeState();
212 : OSL_ASSERT( m_pStateSetHelper );
213 0 : m_pStateSetHelper->AddState( aState );
214 0 : }
215 :
216 0 : void AccessibleBase::RemoveState( sal_Int16 aState )
217 : throw (RuntimeException)
218 : {
219 0 : CheckDisposeState();
220 : OSL_ASSERT( m_pStateSetHelper );
221 0 : m_pStateSetHelper->RemoveState( aState );
222 0 : }
223 :
224 0 : bool AccessibleBase::UpdateChildren()
225 : {
226 0 : bool bMustUpdateChildren = false;
227 : {
228 0 : MutexGuard aGuard( GetMutex() );
229 0 : if( ! m_bMayHaveChildren ||
230 : m_bIsDisposed )
231 0 : return false;
232 :
233 0 : bMustUpdateChildren = ( m_bMayHaveChildren &&
234 0 : ! m_bChildrenInitialized );
235 : }
236 :
237 : // update unguarded
238 0 : if( bMustUpdateChildren )
239 0 : m_bChildrenInitialized = ImplUpdateChildren();
240 :
241 0 : return m_bChildrenInitialized;
242 : }
243 :
244 0 : bool AccessibleBase::ImplUpdateChildren()
245 : {
246 0 : bool bResult = false;
247 :
248 0 : if( m_aAccInfo.m_spObjectHierarchy )
249 : {
250 : ObjectHierarchy::tChildContainer aModelChildren(
251 0 : m_aAccInfo.m_spObjectHierarchy->getChildren( GetId() ));
252 0 : ::std::vector< ChildOIDMap::key_type > aAccChildren;
253 0 : aAccChildren.reserve( aModelChildren.size());
254 : ::std::transform( m_aChildOIDMap.begin(), m_aChildOIDMap.end(),
255 : ::std::back_inserter( aAccChildren ),
256 0 : ::o3tl::select1st< ChildOIDMap::value_type >());
257 :
258 0 : ::std::sort( aModelChildren.begin(), aModelChildren.end());
259 :
260 0 : ::std::vector< ObjectHierarchy::tOID > aChildrenToRemove, aChildrenToAdd;
261 : ::std::set_difference( aModelChildren.begin(), aModelChildren.end(),
262 : aAccChildren.begin(), aAccChildren.end(),
263 0 : ::std::back_inserter( aChildrenToAdd ));
264 : ::std::set_difference( aAccChildren.begin(), aAccChildren.end(),
265 : aModelChildren.begin(), aModelChildren.end(),
266 0 : ::std::back_inserter( aChildrenToRemove ));
267 :
268 0 : ::std::vector< ObjectHierarchy::tOID >::const_iterator aIt( aChildrenToRemove.begin());
269 0 : for( ; aIt != aChildrenToRemove.end(); ++aIt )
270 : {
271 0 : RemoveChildByOId( *aIt );
272 : }
273 :
274 0 : AccessibleElementInfo aAccInfo( GetInfo());
275 0 : aAccInfo.m_pParent = this;
276 :
277 0 : for( aIt = aChildrenToAdd.begin(); aIt != aChildrenToAdd.end(); ++aIt )
278 : {
279 0 : aAccInfo.m_aOID = *aIt;
280 0 : if ( aIt->isAutoGeneratedObject() )
281 : {
282 0 : AddChild( ChartElementFactory::CreateChartElement( aAccInfo ) );
283 : }
284 0 : else if ( aIt->isAdditionalShape() )
285 : {
286 0 : AddChild( new AccessibleChartShape( aAccInfo, true, false ) );
287 : }
288 : }
289 0 : bResult = true;
290 : }
291 :
292 0 : return bResult;
293 : }
294 :
295 0 : void AccessibleBase::AddChild( AccessibleBase * pChild )
296 : {
297 : OSL_ENSURE( pChild != NULL, "Invalid Child" );
298 0 : if( pChild )
299 : {
300 0 : ClearableMutexGuard aGuard( GetMutex() );
301 :
302 0 : Reference< XAccessible > xChild( pChild );
303 0 : m_aChildList.push_back( xChild );
304 :
305 0 : m_aChildOIDMap[ pChild->GetId() ] = xChild;
306 :
307 : // inform listeners of new child
308 0 : if( m_bChildrenInitialized )
309 : {
310 0 : Any aEmpty, aNew;
311 0 : aNew <<= xChild;
312 :
313 0 : aGuard.clear();
314 0 : BroadcastAccEvent( AccessibleEventId::CHILD, aNew, aEmpty );
315 0 : }
316 : }
317 0 : }
318 :
319 : /** in this method we imply that the Reference< XAccessible > elements in the
320 : vector are AccessibleBase objects !
321 : */
322 0 : void AccessibleBase::RemoveChildByOId( const ObjectIdentifier& rOId )
323 : {
324 0 : ClearableMutexGuard aGuard( GetMutex() );
325 :
326 0 : ChildOIDMap::iterator aIt( m_aChildOIDMap.find( rOId ));
327 0 : if( aIt != m_aChildOIDMap.end())
328 : {
329 0 : Reference< XAccessible > xChild( aIt->second );
330 :
331 : // remove from map
332 0 : m_aChildOIDMap.erase( aIt );
333 :
334 : // search child in vector
335 : ChildListVectorType::iterator aVecIter =
336 0 : ::std::find( m_aChildList.begin(), m_aChildList.end(), xChild );
337 :
338 : OSL_ENSURE( aVecIter != m_aChildList.end(),
339 : "Inconsistent ChildMap" );
340 :
341 : // remove child from vector
342 0 : m_aChildList.erase( aVecIter );
343 0 : bool bInitialized = m_bChildrenInitialized;
344 :
345 : // call listeners unguarded
346 0 : aGuard.clear();
347 :
348 : // inform listeners of removed child
349 0 : if( bInitialized )
350 : {
351 0 : Any aEmpty, aOld;
352 0 : aOld <<= xChild;
353 :
354 0 : BroadcastAccEvent( AccessibleEventId::CHILD, aEmpty, aOld );
355 : }
356 :
357 : // dispose the child
358 0 : Reference< lang::XComponent > xComp( xChild, UNO_QUERY );
359 0 : if( xComp.is())
360 0 : xComp->dispose();
361 0 : }
362 0 : }
363 :
364 0 : awt::Point AccessibleBase::GetUpperLeftOnScreen() const
365 : {
366 0 : awt::Point aResult;
367 0 : if( m_aAccInfo.m_pParent )
368 : {
369 0 : ClearableMutexGuard aGuard( GetMutex() );
370 0 : AccessibleBase * pParent = m_aAccInfo.m_pParent;
371 0 : aGuard.clear();
372 :
373 0 : if( pParent )
374 : {
375 0 : aResult = pParent->GetUpperLeftOnScreen();
376 : }
377 : else
378 0 : OSL_FAIL( "Default position used is probably incorrect." );
379 : }
380 :
381 0 : return aResult;
382 : }
383 :
384 0 : void AccessibleBase::BroadcastAccEvent(
385 : sal_Int16 nId,
386 : const Any & rNew,
387 : const Any & rOld,
388 : bool bSendGlobally ) const
389 : {
390 0 : ClearableMutexGuard aGuard( GetMutex() );
391 :
392 0 : if ( !m_nEventNotifierId && !bSendGlobally )
393 0 : return;
394 : // if we don't have a client id for the notifier, then we don't have listeners, then
395 : // we don't need to notify anything
396 : //except SendGlobally for focus handling?
397 :
398 : // the const cast is needed, because UNO parameters are never const
399 : const AccessibleEventObject aEvent(
400 : const_cast< uno::XWeak * >( static_cast< const uno::XWeak * >( this )),
401 0 : nId, rNew, rOld );
402 :
403 0 : if ( m_nEventNotifierId ) // let the notifier handle this event
404 0 : ::comphelper::AccessibleEventNotifier::addEvent( m_nEventNotifierId, aEvent );
405 :
406 0 : aGuard.clear();
407 :
408 : // send event to global message queue
409 0 : if( bSendGlobally )
410 : {
411 0 : ::vcl::unohelper::NotifyAccessibleStateEventGlobally( aEvent );
412 0 : }
413 : }
414 :
415 0 : void AccessibleBase::KillAllChildren()
416 : {
417 0 : ClearableMutexGuard aGuard( GetMutex() );
418 :
419 : // make local copy for notification
420 0 : ChildListVectorType aLocalChildList( m_aChildList );
421 :
422 : // remove all children
423 0 : m_aChildList.clear();
424 0 : m_aChildOIDMap.clear();
425 :
426 0 : aGuard.clear();
427 :
428 : // call dispose for all children
429 : // and notify listeners
430 0 : Reference< lang::XComponent > xComp;
431 0 : Any aEmpty, aOld;
432 0 : ChildListVectorType::const_iterator aEndIter = aLocalChildList.end();
433 0 : for( ChildListVectorType::const_iterator aIter = aLocalChildList.begin();
434 : aIter != aEndIter; ++aIter )
435 : {
436 0 : aOld <<= (*aIter);
437 0 : BroadcastAccEvent( AccessibleEventId::CHILD, aEmpty, aOld );
438 :
439 0 : xComp.set( *aIter, UNO_QUERY );
440 0 : if( xComp.is())
441 0 : xComp->dispose();
442 : }
443 0 : m_bChildrenInitialized = false;
444 0 : }
445 :
446 0 : AccessibleElementInfo AccessibleBase::GetInfo() const
447 : {
448 0 : return m_aAccInfo;
449 : }
450 :
451 0 : void AccessibleBase::SetInfo( const AccessibleElementInfo & rNewInfo )
452 : {
453 0 : m_aAccInfo = rNewInfo;
454 0 : if( m_bMayHaveChildren )
455 : {
456 0 : KillAllChildren();
457 : }
458 : BroadcastAccEvent( AccessibleEventId::INVALIDATE_ALL_CHILDREN, uno::Any(), uno::Any(),
459 0 : true /* global notification */ );
460 0 : }
461 :
462 0 : AccessibleUniqueId AccessibleBase::GetId() const
463 : {
464 0 : return m_aAccInfo.m_aOID;
465 : }
466 :
467 : // ________ (XComponent::dispose) ________
468 0 : void SAL_CALL AccessibleBase::disposing()
469 : {
470 0 : ClearableMutexGuard aGuard( GetMutex() );
471 : OSL_ENSURE( ! m_bIsDisposed, "dispose() called twice" );
472 :
473 : // notify disposing to all AccessibleEvent listeners asynchron
474 0 : if ( m_nEventNotifierId )
475 : {
476 0 : ::comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( m_nEventNotifierId, *this );
477 0 : m_nEventNotifierId = 0;
478 : }
479 :
480 : // reset pointers
481 0 : m_aAccInfo.m_pParent = NULL;
482 :
483 : // invalidate implementation for helper, but keep UNO reference to still
484 : // allow a tool to query the DEFUNC state.
485 : // Note: The object will be deleted when the last reference is released
486 0 : m_pStateSetHelper = NULL;
487 :
488 : // attach new empty state set helper to member reference
489 0 : ::utl::AccessibleStateSetHelper * pHelper = new ::utl::AccessibleStateSetHelper();
490 0 : pHelper->AddState( AccessibleStateType::DEFUNC );
491 : // release old helper and attach new one
492 0 : m_aStateSet.set( pHelper );
493 :
494 0 : m_bIsDisposed = true;
495 :
496 : // call listeners unguarded
497 0 : aGuard.clear();
498 :
499 0 : if( m_bMayHaveChildren )
500 : {
501 0 : KillAllChildren();
502 : }
503 : else
504 0 : OSL_ENSURE( m_aChildList.empty(), "Child list should be empty" );
505 0 : }
506 :
507 : // ________ XAccessible ________
508 0 : Reference< XAccessibleContext > SAL_CALL AccessibleBase::getAccessibleContext()
509 : throw (RuntimeException, std::exception)
510 : {
511 0 : return this;
512 : }
513 :
514 : // ________ AccessibleBase::XAccessibleContext ________
515 0 : sal_Int32 SAL_CALL AccessibleBase::getAccessibleChildCount()
516 : throw (RuntimeException, std::exception)
517 : {
518 0 : ClearableMutexGuard aGuard( GetMutex() );
519 0 : if( ! m_bMayHaveChildren ||
520 : m_bIsDisposed )
521 0 : return 0;
522 :
523 0 : bool bMustUpdateChildren = ( m_bMayHaveChildren &&
524 0 : ! m_bChildrenInitialized );
525 :
526 0 : aGuard.clear();
527 :
528 : // update unguarded
529 0 : if( bMustUpdateChildren )
530 0 : UpdateChildren();
531 :
532 0 : return ImplGetAccessibleChildCount();
533 : }
534 :
535 0 : sal_Int32 AccessibleBase::ImplGetAccessibleChildCount() const
536 : throw (RuntimeException)
537 : {
538 0 : return m_aChildList.size();
539 : }
540 :
541 0 : Reference< XAccessible > SAL_CALL AccessibleBase::getAccessibleChild( sal_Int32 i )
542 : throw (lang::IndexOutOfBoundsException, RuntimeException, std::exception)
543 : {
544 0 : CheckDisposeState();
545 0 : Reference< XAccessible > xResult;
546 :
547 0 : ResettableMutexGuard aGuard( GetMutex() );
548 0 : bool bMustUpdateChildren = ( m_bMayHaveChildren &&
549 0 : ! m_bChildrenInitialized );
550 :
551 0 : aGuard.clear();
552 :
553 0 : if( bMustUpdateChildren )
554 0 : UpdateChildren();
555 :
556 0 : xResult.set( ImplGetAccessibleChildById( i ));
557 :
558 0 : return xResult;
559 : }
560 :
561 0 : Reference< XAccessible > AccessibleBase::ImplGetAccessibleChildById( sal_Int32 i ) const
562 : throw (lang::IndexOutOfBoundsException, RuntimeException)
563 : {
564 0 : Reference< XAccessible > xResult;
565 :
566 0 : MutexGuard aGuard( GetMutex());
567 0 : if( ! m_bMayHaveChildren ||
568 0 : i < 0 ||
569 0 : static_cast< ChildListVectorType::size_type >( i ) >= m_aChildList.size() )
570 : {
571 0 : OUString aBuf = "Index " + OUString::number( i ) + " is invalid for range [ 0, " +
572 0 : OUString::number( m_aChildList.size() - 1 ) +
573 0 : " ]";
574 : lang::IndexOutOfBoundsException aEx( aBuf,
575 : const_cast< ::cppu::OWeakObject * >(
576 0 : static_cast< const ::cppu::OWeakObject * >( this )));
577 0 : throw aEx;
578 : }
579 : else
580 0 : xResult.set( m_aChildList[ i ] );
581 :
582 0 : return xResult;
583 : }
584 :
585 0 : Reference< XAccessible > SAL_CALL AccessibleBase::getAccessibleParent()
586 : throw (RuntimeException, std::exception)
587 : {
588 0 : CheckDisposeState();
589 0 : Reference< XAccessible > aResult;
590 0 : if( m_aAccInfo.m_pParent )
591 0 : aResult.set( m_aAccInfo.m_pParent );
592 :
593 0 : return aResult;
594 : }
595 :
596 0 : sal_Int32 SAL_CALL AccessibleBase::getAccessibleIndexInParent()
597 : throw (RuntimeException, std::exception)
598 : {
599 0 : CheckDisposeState();
600 :
601 0 : if( m_aAccInfo.m_spObjectHierarchy )
602 0 : return m_aAccInfo.m_spObjectHierarchy->getIndexInParent( GetId() );
603 0 : return -1;
604 : }
605 :
606 0 : sal_Int16 SAL_CALL AccessibleBase::getAccessibleRole()
607 : throw (RuntimeException, std::exception)
608 : {
609 0 : return AccessibleRole::SHAPE;
610 : }
611 :
612 0 : Reference< XAccessibleRelationSet > SAL_CALL AccessibleBase::getAccessibleRelationSet()
613 : throw (RuntimeException, std::exception)
614 : {
615 0 : Reference< XAccessibleRelationSet > aResult;
616 0 : return aResult;
617 : }
618 :
619 0 : Reference< XAccessibleStateSet > SAL_CALL AccessibleBase::getAccessibleStateSet()
620 : throw (RuntimeException, std::exception)
621 : {
622 0 : if( ! m_bStateSetInitialized )
623 : {
624 0 : Reference< view::XSelectionSupplier > xSelSupp( GetInfo().m_xSelectionSupplier );
625 0 : if ( xSelSupp.is() )
626 : {
627 0 : ObjectIdentifier aOID( xSelSupp->getSelection() );
628 0 : if ( aOID.isValid() && GetId() == aOID )
629 : {
630 0 : AddState( AccessibleStateType::SELECTED );
631 0 : AddState( AccessibleStateType::FOCUSED );
632 0 : }
633 : }
634 0 : m_bStateSetInitialized = true;
635 : }
636 :
637 0 : return m_aStateSet;
638 : }
639 :
640 0 : lang::Locale SAL_CALL AccessibleBase::getLocale()
641 : throw (IllegalAccessibleComponentStateException, RuntimeException, std::exception)
642 : {
643 0 : CheckDisposeState();
644 :
645 0 : return Application::GetSettings().GetLanguageTag().getLocale();
646 : }
647 :
648 : // ________ AccessibleBase::XAccessibleComponent ________
649 0 : sal_Bool SAL_CALL AccessibleBase::containsPoint( const awt::Point& aPoint )
650 : throw (RuntimeException, std::exception)
651 : {
652 0 : awt::Rectangle aRect( getBounds() );
653 :
654 : // contains() works with relative coordinates
655 0 : aRect.X = 0;
656 0 : aRect.Y = 0;
657 :
658 0 : return ( aPoint.X >= aRect.X &&
659 0 : aPoint.Y >= aRect.Y &&
660 0 : aPoint.X < (aRect.X + aRect.Width) &&
661 0 : aPoint.Y < (aRect.Y + aRect.Height) );
662 : }
663 :
664 0 : Reference< XAccessible > SAL_CALL AccessibleBase::getAccessibleAtPoint( const awt::Point& aPoint )
665 : throw (RuntimeException, std::exception)
666 : {
667 0 : CheckDisposeState();
668 0 : Reference< XAccessible > aResult;
669 0 : awt::Rectangle aRect( getBounds());
670 :
671 : // children are positioned relative to this object, so translate bound rect
672 0 : aRect.X = 0;
673 0 : aRect.Y = 0;
674 :
675 : // children must be inside the own bound rect
676 0 : if( ( aRect.X <= aPoint.X && aPoint.X <= (aRect.X + aRect.Width) ) &&
677 0 : ( aRect.Y <= aPoint.Y && aPoint.Y <= (aRect.Y + aRect.Height)))
678 : {
679 0 : ClearableMutexGuard aGuard( GetMutex() );
680 0 : ChildListVectorType aLocalChildList( m_aChildList );
681 0 : aGuard.clear();
682 :
683 0 : Reference< XAccessibleComponent > aComp;
684 0 : for( ChildListVectorType::const_iterator aIter = aLocalChildList.begin();
685 0 : aIter != aLocalChildList.end(); ++aIter )
686 : {
687 0 : aComp.set( *aIter, UNO_QUERY );
688 0 : if( aComp.is())
689 : {
690 0 : aRect = aComp->getBounds();
691 0 : if( ( aRect.X <= aPoint.X && aPoint.X <= (aRect.X + aRect.Width) ) &&
692 0 : ( aRect.Y <= aPoint.Y && aPoint.Y <= (aRect.Y + aRect.Height)))
693 : {
694 0 : aResult = (*aIter);
695 0 : break;
696 : }
697 : }
698 0 : }
699 : }
700 :
701 0 : return aResult;
702 : }
703 :
704 0 : awt::Rectangle SAL_CALL AccessibleBase::getBounds()
705 : throw (RuntimeException, std::exception)
706 : {
707 : ExplicitValueProvider *pExplicitValueProvider(
708 0 : ExplicitValueProvider::getExplicitValueProvider( m_aAccInfo.m_xView ));
709 0 : if( pExplicitValueProvider )
710 : {
711 0 : Window* pWindow( VCLUnoHelper::GetWindow( m_aAccInfo.m_xWindow ));
712 0 : awt::Rectangle aLogicRect( pExplicitValueProvider->getRectangleOfObject( m_aAccInfo.m_aOID.getObjectCID() ));
713 0 : if( pWindow )
714 : {
715 : Rectangle aRect( aLogicRect.X, aLogicRect.Y,
716 : aLogicRect.X + aLogicRect.Width,
717 0 : aLogicRect.Y + aLogicRect.Height );
718 0 : SolarMutexGuard aSolarGuard;
719 0 : aRect = pWindow->LogicToPixel( aRect );
720 :
721 : // aLogicRect is relative to the page, but we need a value relative
722 : // to the parent object
723 0 : awt::Point aParentLocOnScreen;
724 0 : uno::Reference< XAccessibleComponent > xParent( getAccessibleParent(), uno::UNO_QUERY );
725 0 : if( xParent.is() )
726 0 : aParentLocOnScreen = xParent->getLocationOnScreen();
727 :
728 0 : awt::Point aULOnScreen = GetUpperLeftOnScreen();
729 0 : awt::Point aOffset( aParentLocOnScreen.X - aULOnScreen.X,
730 0 : aParentLocOnScreen.Y - aULOnScreen.Y );
731 :
732 0 : return awt::Rectangle( aRect.getX() - aOffset.X, aRect.getY() - aOffset.Y,
733 0 : aRect.getWidth(), aRect.getHeight());
734 : }
735 : }
736 :
737 0 : return awt::Rectangle();
738 : }
739 :
740 0 : awt::Point SAL_CALL AccessibleBase::getLocation()
741 : throw (RuntimeException, std::exception)
742 : {
743 0 : CheckDisposeState();
744 0 : awt::Rectangle aBBox( getBounds() );
745 0 : return awt::Point( aBBox.X, aBBox.Y );
746 : }
747 :
748 0 : awt::Point SAL_CALL AccessibleBase::getLocationOnScreen()
749 : throw (RuntimeException, std::exception)
750 : {
751 0 : CheckDisposeState();
752 :
753 0 : if( m_aAccInfo.m_pParent != NULL )
754 : {
755 0 : AccessibleBase * pParent = m_aAccInfo.m_pParent;
756 0 : awt::Point aLocThisRel( getLocation());
757 0 : awt::Point aUpperLeft;
758 :
759 0 : if( pParent != NULL )
760 0 : aUpperLeft = pParent->getLocationOnScreen();
761 :
762 0 : return awt::Point( aUpperLeft.X + aLocThisRel.X,
763 0 : aUpperLeft.Y + aLocThisRel.Y );
764 : }
765 : else
766 0 : return getLocation();
767 : }
768 :
769 0 : awt::Size SAL_CALL AccessibleBase::getSize()
770 : throw (RuntimeException, std::exception)
771 : {
772 0 : CheckDisposeState();
773 0 : awt::Rectangle aBBox( getBounds() );
774 0 : return awt::Size( aBBox.Width, aBBox.Height );
775 : }
776 :
777 0 : void SAL_CALL AccessibleBase::grabFocus()
778 : throw (RuntimeException, std::exception)
779 : {
780 0 : CheckDisposeState();
781 :
782 0 : Reference< view::XSelectionSupplier > xSelSupp( GetInfo().m_xSelectionSupplier );
783 0 : if ( xSelSupp.is() )
784 : {
785 0 : xSelSupp->select( GetId().getAny() );
786 0 : }
787 0 : }
788 :
789 0 : sal_Int32 SAL_CALL AccessibleBase::getForeground()
790 : throw (RuntimeException, std::exception)
791 : {
792 0 : return getColor( ACC_BASE_FOREGROUND );
793 : }
794 :
795 0 : sal_Int32 SAL_CALL AccessibleBase::getBackground()
796 : throw (RuntimeException, std::exception)
797 : {
798 0 : return getColor( ACC_BASE_BACKGROUND );
799 : }
800 :
801 0 : sal_Int32 AccessibleBase::getColor( eColorType eColType )
802 : {
803 0 : sal_Int32 nResult = static_cast< sal_Int32 >( Color( COL_TRANSPARENT ).GetColor());
804 0 : if( m_bAlwaysTransparent )
805 0 : return nResult;
806 :
807 0 : ObjectIdentifier aOID( m_aAccInfo.m_aOID );
808 0 : ObjectType eType( aOID.getObjectType() );
809 0 : Reference< beans::XPropertySet > xObjProp;
810 0 : OUString aObjectCID = aOID.getObjectCID();
811 0 : if( eType == OBJECTTYPE_LEGEND_ENTRY )
812 : {
813 : // for colors get the data series/point properties
814 0 : OUString aParentParticle( ObjectIdentifier::getFullParentParticle( aObjectCID ));
815 0 : aObjectCID = ObjectIdentifier::createClassifiedIdentifierForParticle( aParentParticle );
816 : }
817 :
818 : xObjProp.set(
819 : ObjectIdentifier::getObjectPropertySet(
820 0 : aObjectCID, Reference< chart2::XChartDocument >( m_aAccInfo.m_xChartDocument )), uno::UNO_QUERY );
821 0 : if( xObjProp.is())
822 : {
823 : try
824 : {
825 0 : OUString aPropName;
826 0 : OUString aStylePropName;
827 :
828 0 : switch( eType )
829 : {
830 : case OBJECTTYPE_LEGEND_ENTRY:
831 : case OBJECTTYPE_DATA_SERIES:
832 : case OBJECTTYPE_DATA_POINT:
833 0 : if( eColType == ACC_BASE_FOREGROUND )
834 : {
835 0 : aPropName = "BorderColor";
836 0 : aStylePropName = "BorderTransparency";
837 : }
838 : else
839 : {
840 0 : aPropName = "Color";
841 0 : aStylePropName = "Transparency";
842 : }
843 0 : break;
844 : default:
845 0 : if( eColType == ACC_BASE_FOREGROUND )
846 : {
847 0 : aPropName = "LineColor";
848 0 : aStylePropName = "LineTransparence";
849 : }
850 : else
851 : {
852 0 : aPropName = "FillColor";
853 0 : aStylePropName = "FillTransparence";
854 : }
855 0 : break;
856 : }
857 :
858 0 : bool bTransparent = m_bAlwaysTransparent;
859 0 : Reference< beans::XPropertySetInfo > xInfo( xObjProp->getPropertySetInfo(), uno::UNO_QUERY );
860 0 : if( xInfo.is() &&
861 0 : xInfo->hasPropertyByName( aStylePropName ))
862 : {
863 0 : if( eColType == ACC_BASE_FOREGROUND )
864 : {
865 : drawing::LineStyle aLStyle;
866 0 : if( xObjProp->getPropertyValue( aStylePropName ) >>= aLStyle )
867 0 : bTransparent = (aLStyle == drawing::LineStyle_NONE);
868 : }
869 : else
870 : {
871 : drawing::FillStyle aFStyle;
872 0 : if( xObjProp->getPropertyValue( aStylePropName ) >>= aFStyle )
873 0 : bTransparent = (aFStyle == drawing::FillStyle_NONE);
874 : }
875 : }
876 :
877 0 : if( !bTransparent &&
878 0 : xInfo.is() &&
879 0 : xInfo->hasPropertyByName( aPropName ))
880 : {
881 0 : xObjProp->getPropertyValue( aPropName ) >>= nResult;
882 0 : }
883 : }
884 0 : catch( const uno::Exception & ex )
885 : {
886 : ASSERT_EXCEPTION( ex );
887 : }
888 : }
889 :
890 0 : return nResult;
891 : }
892 :
893 : // ________ AccessibleBase::XServiceInfo ________
894 0 : OUString SAL_CALL AccessibleBase::getImplementationName()
895 : throw (RuntimeException, std::exception)
896 : {
897 0 : return OUString( "AccessibleBase" );
898 : }
899 :
900 0 : sal_Bool SAL_CALL AccessibleBase::supportsService( const OUString& ServiceName )
901 : throw (RuntimeException, std::exception)
902 : {
903 0 : return cppu::supportsService( this, ServiceName );
904 : }
905 :
906 0 : uno::Sequence< OUString > SAL_CALL AccessibleBase::getSupportedServiceNames()
907 : throw (RuntimeException, std::exception)
908 : {
909 0 : uno::Sequence< OUString > aSeq( 2 );
910 0 : OUString* pStr = aSeq.getArray();
911 0 : pStr[ 0 ] = "com.sun.star.accessibility.Accessible";
912 0 : pStr[ 1 ] = "com.sun.star.accessibility.AccessibleContext";
913 :
914 0 : return aSeq;
915 : }
916 :
917 : // ________ AccessibleBase::XEventListener ________
918 0 : void SAL_CALL AccessibleBase::disposing( const lang::EventObject& /*Source*/ )
919 : throw (RuntimeException, std::exception)
920 : {
921 0 : }
922 :
923 : // ________ XAccessibleEventBroadcasters ________
924 0 : void SAL_CALL AccessibleBase::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
925 : throw (RuntimeException, std::exception)
926 : {
927 0 : MutexGuard aGuard( GetMutex() );
928 :
929 0 : if ( xListener.is() )
930 : {
931 0 : if ( !m_nEventNotifierId )
932 0 : m_nEventNotifierId = ::comphelper::AccessibleEventNotifier::registerClient();
933 :
934 0 : ::comphelper::AccessibleEventNotifier::addEventListener( m_nEventNotifierId, xListener );
935 0 : }
936 0 : }
937 :
938 0 : void SAL_CALL AccessibleBase::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
939 : throw (RuntimeException, std::exception)
940 : {
941 0 : MutexGuard aGuard( GetMutex() );
942 :
943 0 : if ( xListener.is() )
944 : {
945 0 : sal_Int32 nListenerCount = ::comphelper::AccessibleEventNotifier::removeEventListener( m_nEventNotifierId, xListener );
946 0 : if ( !nListenerCount )
947 : {
948 : // no listeners anymore
949 0 : ::comphelper::AccessibleEventNotifier::revokeClient( m_nEventNotifierId );
950 0 : m_nEventNotifierId = 0;
951 : }
952 0 : }
953 0 : }
954 :
955 : } // namespace chart
956 :
957 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
