Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <accessibility/standard/vclxaccessibletoolboxitem.hxx>
21 : #include <toolkit/helper/convert.hxx>
22 : #include <accessibility/helper/accresmgr.hxx>
23 : #include <accessibility/helper/accessiblestrings.hrc>
24 : #include <com/sun/star/awt/Point.hpp>
25 : #include <com/sun/star/awt/Rectangle.hpp>
26 : #include <com/sun/star/awt/Size.hpp>
27 :
28 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
29 : #include <com/sun/star/accessibility/AccessibleRole.hpp>
30 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
31 : #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
32 : #include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp>
33 : #include <cppuhelper/supportsservice.hxx>
34 : #include <vcl/svapp.hxx>
35 : #include <vcl/toolbox.hxx>
36 : #include <vcl/unohelp2.hxx>
37 : #include <vcl/help.hxx>
38 : #include <vcl/settings.hxx>
39 : #include <toolkit/awt/vclxwindow.hxx>
40 : #include <toolkit/helper/externallock.hxx>
41 : #include <unotools/accessiblestatesethelper.hxx>
42 : #include <unotools/accessiblerelationsethelper.hxx>
43 : #include <cppuhelper/typeprovider.hxx>
44 : #include <comphelper/sequence.hxx>
45 :
46 : #include <com/sun/star/accessibility/XAccessibleSelection.hpp>
47 :
48 : // class VCLXAccessibleToolBoxItem ------------------------------------------
49 :
50 : using namespace ::com::sun::star::accessibility;
51 : using namespace ::com::sun::star::uno;
52 : using namespace ::com::sun::star::beans;
53 : using namespace ::com::sun::star::lang;
54 : using namespace ::com::sun::star;
55 : using namespace ::comphelper;
56 :
57 :
58 : // Ctor() and Dtor()
59 :
60 796 : VCLXAccessibleToolBoxItem::VCLXAccessibleToolBoxItem( ToolBox* _pToolBox, sal_Int32 _nPos ) :
61 :
62 : AccessibleTextHelper_BASE( new VCLExternalSolarLock() ),
63 :
64 : m_pToolBox ( _pToolBox ),
65 : m_nIndexInParent( _nPos ),
66 : m_nRole ( AccessibleRole::PUSH_BUTTON ),
67 : m_nItemId ( 0 ),
68 : m_bHasFocus ( false ),
69 : m_bIsChecked ( false ),
70 796 : m_bIndeterminate( false )
71 :
72 : {
73 796 : m_pExternalLock = static_cast< VCLExternalSolarLock* >( getExternalLock( ) );
74 :
75 : OSL_ENSURE( m_pToolBox, "invalid toolbox" );
76 796 : m_nItemId = m_pToolBox->GetItemId( (sal_uInt16)m_nIndexInParent );
77 796 : m_sOldName = GetText( true );
78 796 : m_bIsChecked = m_pToolBox->IsItemChecked( m_nItemId );
79 796 : m_bIndeterminate = ( m_pToolBox->GetItemState( m_nItemId ) == TRISTATE_INDET );
80 796 : ToolBoxItemType eType = m_pToolBox->GetItemType( (sal_uInt16)m_nIndexInParent );
81 796 : switch ( eType )
82 : {
83 : case ToolBoxItemType::BUTTON :
84 : {
85 704 : ToolBoxItemBits nBits = m_pToolBox->GetItemBits( m_nItemId );
86 1408 : if (
87 3258 : (( nBits & ToolBoxItemBits::DROPDOWN ) == ToolBoxItemBits::DROPDOWN) ||
88 1850 : (( nBits & ToolBoxItemBits::DROPDOWNONLY ) == ToolBoxItemBits::DROPDOWNONLY)
89 : )
90 131 : m_nRole = AccessibleRole::BUTTON_DROPDOWN;
91 1146 : else if (
92 3112 : ( ( nBits & ToolBoxItemBits::CHECKABLE ) == ToolBoxItemBits::CHECKABLE ) ||
93 3522 : ( ( nBits & ToolBoxItemBits::RADIOCHECK ) == ToolBoxItemBits::RADIOCHECK ) ||
94 1393 : ( ( nBits & ToolBoxItemBits::AUTOCHECK ) == ToolBoxItemBits::AUTOCHECK )
95 : )
96 163 : m_nRole = AccessibleRole::TOGGLE_BUTTON;
97 410 : else if ( m_pToolBox->GetItemWindow( m_nItemId ) )
98 12 : m_nRole = AccessibleRole::PANEL;
99 704 : break;
100 : }
101 :
102 : case ToolBoxItemType::SPACE :
103 0 : m_nRole = AccessibleRole::FILLER;
104 0 : break;
105 :
106 : case ToolBoxItemType::SEPARATOR :
107 : case ToolBoxItemType::BREAK :
108 92 : m_nRole = AccessibleRole::SEPARATOR;
109 92 : break;
110 :
111 : default:
112 : {
113 : SAL_WARN( "accessibility", "unsupported toolbox itemtype" );
114 : }
115 : }
116 796 : }
117 :
118 2352 : VCLXAccessibleToolBoxItem::~VCLXAccessibleToolBoxItem()
119 : {
120 784 : delete m_pExternalLock;
121 784 : m_pExternalLock = NULL;
122 1568 : }
123 :
124 858 : OUString VCLXAccessibleToolBoxItem::GetText( bool _bAsName )
125 : {
126 858 : OUString sRet;
127 : // no text for separators and spaces
128 858 : if ( m_pToolBox && m_nItemId > 0 && ( _bAsName || m_pToolBox->GetButtonType() != ButtonType::SYMBOLONLY ) )
129 : {
130 766 : sRet = m_pToolBox->GetItemText( m_nItemId );
131 766 : if (sRet.isEmpty())
132 : {
133 5 : sRet = m_pToolBox->GetQuickHelpText( m_nItemId );
134 5 : if (sRet.isEmpty())
135 : {
136 5 : vcl::Window* pItemWindow = m_pToolBox->GetItemWindow( m_nItemId );
137 10 : if ( m_nRole == AccessibleRole::PANEL && pItemWindow && pItemWindow->GetAccessible().is() &&
138 5 : pItemWindow->GetAccessible()->getAccessibleContext().is() )
139 : {
140 0 : OUString sWinText = pItemWindow->GetAccessible()->getAccessibleContext()->getAccessibleName();
141 0 : if (!sWinText.isEmpty())
142 0 : sRet = sWinText;
143 : }
144 : }
145 : }
146 :
147 : }
148 858 : return sRet;
149 : }
150 :
151 8 : void VCLXAccessibleToolBoxItem::SetFocus( bool _bFocus )
152 : {
153 8 : if ( m_bHasFocus != _bFocus )
154 : {
155 4 : Any aOldValue;
156 8 : Any aNewValue;
157 4 : if ( m_bHasFocus )
158 0 : aOldValue <<= AccessibleStateType::FOCUSED;
159 : else
160 4 : aNewValue <<= AccessibleStateType::FOCUSED;
161 4 : m_bHasFocus = _bFocus;
162 8 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
163 : }
164 8 : }
165 :
166 67 : void VCLXAccessibleToolBoxItem::SetChecked( bool _bCheck )
167 : {
168 67 : if( m_nRole == AccessibleRole::PANEL)
169 70 : return;
170 64 : if ( m_bIsChecked != _bCheck )
171 : {
172 0 : Any aOldValue;
173 0 : Any aNewValue;
174 0 : if ( m_bIsChecked )
175 0 : aOldValue <<= AccessibleStateType::CHECKED;
176 : else
177 0 : aNewValue <<= AccessibleStateType::CHECKED;
178 0 : m_bIsChecked = _bCheck;
179 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
180 : }
181 : }
182 :
183 4 : void VCLXAccessibleToolBoxItem::SetIndeterminate( bool _bIndeterminate )
184 : {
185 4 : if ( m_bIndeterminate != _bIndeterminate )
186 : {
187 0 : Any aOldValue, aNewValue;
188 0 : if ( m_bIndeterminate )
189 0 : aOldValue <<= AccessibleStateType::INDETERMINATE;
190 : else
191 0 : aNewValue <<= AccessibleStateType::INDETERMINATE;
192 0 : m_bIndeterminate = _bIndeterminate;
193 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
194 : }
195 4 : }
196 :
197 0 : void VCLXAccessibleToolBoxItem::NameChanged()
198 : {
199 0 : OUString sNewName = implGetText();
200 0 : if ( sNewName != m_sOldName )
201 : {
202 0 : Any aOldValue, aNewValue;
203 0 : aOldValue <<= m_sOldName;
204 : // save new name as old name for next change
205 0 : m_sOldName = sNewName;
206 0 : aNewValue <<= m_sOldName;
207 0 : NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldValue, aNewValue );
208 0 : }
209 0 : }
210 :
211 12 : void VCLXAccessibleToolBoxItem::SetChild( const Reference< XAccessible >& _xChild )
212 : {
213 12 : m_xChild = _xChild;
214 12 : }
215 :
216 0 : void VCLXAccessibleToolBoxItem::NotifyChildEvent( const Reference< XAccessible >& _xChild, bool _bShow )
217 : {
218 0 : Any aOld = _bShow ? Any() : makeAny( _xChild );
219 0 : Any aNew = _bShow ? makeAny( _xChild ) : Any();
220 0 : NotifyAccessibleEvent( AccessibleEventId::CHILD, aOld, aNew );
221 0 : }
222 :
223 3 : void VCLXAccessibleToolBoxItem::ToggleEnableState()
224 : {
225 12 : Any aOldValue[2], aNewValue[2];
226 3 : if ( m_pToolBox->IsItemEnabled( m_nItemId ) )
227 : {
228 0 : aNewValue[0] <<= AccessibleStateType::SENSITIVE;
229 0 : aNewValue[1] <<= AccessibleStateType::ENABLED;
230 : }
231 : else
232 : {
233 3 : aOldValue[0] <<= AccessibleStateType::ENABLED;
234 3 : aOldValue[1] <<= AccessibleStateType::SENSITIVE;
235 : }
236 :
237 3 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[0], aNewValue[0] );
238 12 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[1], aNewValue[1] );
239 3 : }
240 :
241 0 : awt::Rectangle VCLXAccessibleToolBoxItem::implGetBounds( ) throw (RuntimeException)
242 : {
243 0 : awt::Rectangle aRect;
244 0 : if ( m_pToolBox )
245 0 : aRect = AWTRectangle( m_pToolBox->GetItemPosRect( (sal_uInt16)m_nIndexInParent ) );
246 :
247 0 : return aRect;
248 : }
249 :
250 0 : OUString VCLXAccessibleToolBoxItem::implGetText()
251 : {
252 0 : return GetText (true);
253 : }
254 :
255 0 : Locale VCLXAccessibleToolBoxItem::implGetLocale()
256 : {
257 0 : return Application::GetSettings().GetUILanguageTag().getLocale();
258 : }
259 :
260 0 : void VCLXAccessibleToolBoxItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
261 : {
262 0 : nStartIndex = 0;
263 0 : nEndIndex = 0;
264 0 : }
265 :
266 : // XInterface
267 :
268 24122 : IMPLEMENT_FORWARD_REFCOUNT( VCLXAccessibleToolBoxItem, AccessibleTextHelper_BASE )
269 2384 : Any SAL_CALL VCLXAccessibleToolBoxItem::queryInterface( const Type& _rType ) throw (RuntimeException, std::exception)
270 : {
271 : // #i33611# - toolbox buttons without text don't support XAccessibleText
272 4768 : if ( _rType == cppu::UnoType<XAccessibleText>::get()
273 2384 : && ( !m_pToolBox || m_pToolBox->GetButtonType() == ButtonType::SYMBOLONLY ) )
274 0 : return Any();
275 :
276 2384 : ::com::sun::star::uno::Any aReturn = AccessibleTextHelper_BASE::queryInterface( _rType );
277 2384 : if ( !aReturn.hasValue() )
278 798 : aReturn = VCLXAccessibleToolBoxItem_BASE::queryInterface( _rType );
279 2384 : return aReturn;
280 : }
281 :
282 : // XTypeProvider
283 :
284 0 : IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleToolBoxItem, AccessibleTextHelper_BASE, VCLXAccessibleToolBoxItem_BASE )
285 :
286 : // XComponent
287 :
288 796 : void SAL_CALL VCLXAccessibleToolBoxItem::disposing()
289 : {
290 796 : AccessibleTextHelper_BASE::disposing();
291 796 : m_pToolBox = NULL;
292 796 : }
293 :
294 : // XServiceInfo
295 :
296 1 : OUString VCLXAccessibleToolBoxItem::getImplementationName() throw (RuntimeException, std::exception)
297 : {
298 1 : return OUString( "com.sun.star.comp.toolkit.AccessibleToolBoxItem" );
299 : }
300 :
301 0 : sal_Bool VCLXAccessibleToolBoxItem::supportsService( const OUString& rServiceName ) throw (RuntimeException, std::exception)
302 : {
303 0 : return cppu::supportsService(this, rServiceName);
304 : }
305 :
306 0 : Sequence< OUString > VCLXAccessibleToolBoxItem::getSupportedServiceNames() throw (RuntimeException, std::exception)
307 : {
308 0 : Sequence< OUString > aNames(4);
309 0 : aNames[0] = "com.sun.star.accessibility.AccessibleContext";
310 0 : aNames[1] = "com.sun.star.accessibility.AccessibleComponent";
311 0 : aNames[2] = "com.sun.star.accessibility.AccessibleExtendedComponent";
312 0 : aNames[3] = "com.sun.star.accessibility.AccessibleToolBoxItem";
313 0 : return aNames;
314 : }
315 :
316 : // XAccessible
317 :
318 401 : Reference< XAccessibleContext > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleContext( ) throw (RuntimeException, std::exception)
319 : {
320 401 : return this;
321 : }
322 :
323 : // XAccessibleContext
324 :
325 798 : sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleChildCount( ) throw (RuntimeException, std::exception)
326 : {
327 798 : OContextEntryGuard aGuard( this );
328 :
329 798 : return m_xChild.is() ? 1 : 0;
330 : }
331 :
332 9 : Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleChild( sal_Int32 i ) throw (RuntimeException, com::sun::star::lang::IndexOutOfBoundsException, std::exception)
333 : {
334 9 : OContextEntryGuard aGuard( this );
335 :
336 : // no child -> so index is out of bounds
337 9 : if ( !m_xChild.is() || i != 0 )
338 0 : throw IndexOutOfBoundsException();
339 :
340 9 : return m_xChild;
341 : }
342 :
343 6 : Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleParent( ) throw (RuntimeException, std::exception)
344 : {
345 6 : OContextEntryGuard aGuard( this );
346 :
347 6 : return m_pToolBox->GetAccessible();
348 : }
349 :
350 0 : sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleIndexInParent( ) throw (RuntimeException, std::exception)
351 : {
352 0 : OContextEntryGuard aGuard( this );
353 :
354 0 : return m_nIndexInParent;
355 : }
356 :
357 400 : sal_Int16 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleRole( ) throw (RuntimeException, std::exception)
358 : {
359 400 : OContextEntryGuard aGuard( this );
360 :
361 400 : return m_nRole;
362 : }
363 :
364 6 : OUString SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleDescription( ) throw (RuntimeException, std::exception)
365 : {
366 6 : OExternalLockGuard aGuard( this );
367 :
368 6 : if (m_nRole == AccessibleRole::PANEL && getAccessibleChildCount() > 0)
369 : {
370 6 : return TK_RES_STRING( RID_STR_ACC_PANEL_DESCRIPTION );
371 : }
372 : else
373 : {
374 0 : OUString sDescription;
375 0 : if ( m_pToolBox )
376 0 : sDescription = m_pToolBox->GetHelpText( m_nItemId );
377 0 : return sDescription;
378 6 : }
379 : }
380 :
381 62 : OUString SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleName( ) throw (RuntimeException, std::exception)
382 : {
383 62 : OExternalLockGuard aGuard( this );
384 :
385 : // entry text == accessible name
386 62 : return GetText( true );
387 : }
388 :
389 0 : Reference< XAccessibleRelationSet > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleRelationSet( ) throw (RuntimeException, std::exception)
390 : {
391 0 : OContextEntryGuard aGuard( this );
392 :
393 0 : utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
394 0 : Reference< XAccessibleRelationSet > xSet = pRelationSetHelper;
395 0 : return xSet;
396 : }
397 :
398 394 : Reference< XAccessibleStateSet > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleStateSet( ) throw (RuntimeException, std::exception)
399 : {
400 394 : OExternalLockGuard aGuard( this );
401 :
402 394 : utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
403 394 : Reference< XAccessibleStateSet > xStateSet = pStateSetHelper;
404 :
405 394 : if ( m_pToolBox && !rBHelper.bDisposed && !rBHelper.bInDispose )
406 : {
407 394 : pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE );
408 394 : if ( m_bIsChecked && m_nRole != AccessibleRole::PANEL )
409 13 : pStateSetHelper->AddState( AccessibleStateType::CHECKED );
410 394 : if ( m_bIndeterminate )
411 0 : pStateSetHelper->AddState( AccessibleStateType::INDETERMINATE );
412 394 : if ( m_pToolBox->IsEnabled() && m_pToolBox->IsItemEnabled( m_nItemId ) )
413 : {
414 212 : pStateSetHelper->AddState( AccessibleStateType::ENABLED );
415 212 : pStateSetHelper->AddState( AccessibleStateType::SENSITIVE );
416 : }
417 394 : if ( m_pToolBox->IsItemVisible( m_nItemId ) )
418 290 : pStateSetHelper->AddState( AccessibleStateType::VISIBLE );
419 394 : if ( m_pToolBox->IsItemReallyVisible( m_nItemId ) )
420 260 : pStateSetHelper->AddState( AccessibleStateType::SHOWING );
421 394 : if ( m_bHasFocus )
422 0 : pStateSetHelper->AddState( AccessibleStateType::FOCUSED );
423 : }
424 : else
425 0 : pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
426 :
427 394 : return xStateSet;
428 : }
429 :
430 : // XAccessibleText
431 :
432 0 : sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getCaretPosition() throw (RuntimeException, std::exception)
433 : {
434 0 : return -1;
435 : }
436 :
437 0 : sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::setCaretPosition( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
438 : {
439 0 : OExternalLockGuard aGuard( this );
440 :
441 0 : if ( !implIsValidRange( nIndex, nIndex, implGetText().getLength() ) )
442 0 : throw IndexOutOfBoundsException();
443 :
444 0 : return false;
445 : }
446 :
447 0 : Sequence< PropertyValue > SAL_CALL VCLXAccessibleToolBoxItem::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
448 : {
449 0 : OExternalLockGuard aGuard( this );
450 :
451 0 : OUString sText( implGetText() );
452 :
453 0 : if ( !implIsValidIndex( nIndex, sText.getLength() ) )
454 0 : throw IndexOutOfBoundsException();
455 :
456 0 : return Sequence< PropertyValue >();
457 : }
458 :
459 0 : awt::Rectangle SAL_CALL VCLXAccessibleToolBoxItem::getCharacterBounds( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
460 : {
461 0 : OExternalLockGuard aGuard( this );
462 :
463 0 : OUString sText( implGetText() );
464 :
465 0 : if ( !implIsValidIndex( nIndex, sText.getLength() ) )
466 0 : throw IndexOutOfBoundsException();
467 :
468 0 : awt::Rectangle aBounds( 0, 0, 0, 0 );
469 0 : if ( m_pToolBox && m_pToolBox->GetButtonType() != ButtonType::SYMBOLONLY ) // symbol buttons have no character bounds
470 : {
471 0 : Rectangle aCharRect = m_pToolBox->GetCharacterBounds( m_nItemId, nIndex );
472 0 : Rectangle aItemRect = m_pToolBox->GetItemRect( m_nItemId );
473 0 : aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() );
474 0 : aBounds = AWTRectangle( aCharRect );
475 : }
476 :
477 0 : return aBounds;
478 : }
479 :
480 0 : sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getIndexAtPoint( const awt::Point& aPoint ) throw (RuntimeException, std::exception)
481 : {
482 0 : OExternalLockGuard aGuard( this );
483 :
484 0 : sal_Int32 nIndex = -1;
485 0 : if ( m_pToolBox && m_pToolBox->GetButtonType() != ButtonType::SYMBOLONLY ) // symbol buttons have no character bounds
486 : {
487 0 : sal_uInt16 nItemId = 0;
488 0 : Rectangle aItemRect = m_pToolBox->GetItemRect( m_nItemId );
489 0 : Point aPnt( VCLPoint( aPoint ) );
490 0 : aPnt += aItemRect.TopLeft();
491 0 : sal_Int32 nIdx = m_pToolBox->GetIndexForPoint( aPnt, nItemId );
492 0 : if ( nIdx != -1 && nItemId == m_nItemId )
493 0 : nIndex = nIdx;
494 : }
495 :
496 0 : return nIndex;
497 : }
498 :
499 0 : sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
500 : {
501 0 : OExternalLockGuard aGuard( this );
502 :
503 0 : if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
504 0 : throw IndexOutOfBoundsException();
505 :
506 0 : return false;
507 : }
508 :
509 0 : sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
510 : {
511 0 : OExternalLockGuard aGuard( this );
512 :
513 0 : if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
514 0 : throw IndexOutOfBoundsException();
515 :
516 0 : bool bReturn = false;
517 :
518 0 : if ( m_pToolBox )
519 : {
520 0 : Reference< datatransfer::clipboard::XClipboard > xClipboard = m_pToolBox->GetClipboard();
521 0 : if ( xClipboard.is() )
522 : {
523 0 : OUString sText( getTextRange( nStartIndex, nEndIndex ) );
524 :
525 0 : vcl::unohelper::TextDataObject* pDataObj = new vcl::unohelper::TextDataObject( sText );
526 :
527 0 : SolarMutexReleaser aReleaser;
528 0 : xClipboard->setContents( pDataObj, NULL );
529 :
530 0 : Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY );
531 0 : if( xFlushableClipboard.is() )
532 0 : xFlushableClipboard->flushClipboard();
533 :
534 0 : bReturn = true;
535 0 : }
536 : }
537 :
538 0 : return bReturn;
539 : }
540 :
541 : // XAccessibleComponent
542 :
543 0 : Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleAtPoint( const awt::Point& ) throw (RuntimeException, std::exception)
544 : {
545 0 : return Reference< XAccessible >();
546 : }
547 :
548 0 : void SAL_CALL VCLXAccessibleToolBoxItem::grabFocus( ) throw (RuntimeException, std::exception)
549 : {
550 0 : Reference< XAccessible > xParent(getAccessibleParent());
551 :
552 0 : if( xParent.is() )
553 : {
554 0 : Reference< XAccessibleSelection > rxAccessibleSelection(xParent->getAccessibleContext(), UNO_QUERY);
555 :
556 0 : if ( rxAccessibleSelection.is() )
557 : {
558 0 : rxAccessibleSelection -> selectAccessibleChild ( getAccessibleIndexInParent() );
559 0 : }
560 0 : }
561 0 : }
562 :
563 0 : sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getForeground( ) throw (RuntimeException, std::exception)
564 : {
565 0 : OExternalLockGuard aGuard( this );
566 :
567 0 : sal_Int32 nColor = 0;
568 0 : if ( m_pToolBox )
569 0 : nColor = m_pToolBox->GetControlForeground().GetColor();
570 :
571 0 : return nColor;
572 : }
573 :
574 0 : sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getBackground( ) throw (RuntimeException, std::exception)
575 : {
576 0 : OExternalLockGuard aGuard( this );
577 :
578 0 : sal_Int32 nColor = 0;
579 0 : if ( m_pToolBox )
580 0 : nColor = m_pToolBox->GetControlBackground().GetColor();
581 :
582 0 : return nColor;
583 : }
584 :
585 : // XAccessibleExtendedComponent
586 0 : Reference< awt::XFont > SAL_CALL VCLXAccessibleToolBoxItem::getFont( ) throw (RuntimeException, std::exception)
587 : {
588 0 : return uno::Reference< awt::XFont >();
589 : }
590 :
591 0 : OUString SAL_CALL VCLXAccessibleToolBoxItem::getTitledBorderText( ) throw (RuntimeException, std::exception)
592 : {
593 0 : OExternalLockGuard aGuard( this );
594 :
595 0 : OUString sRet;
596 0 : if ( m_pToolBox )
597 0 : sRet = m_pToolBox->GetItemText( m_nItemId );
598 :
599 0 : return sRet;
600 : }
601 :
602 0 : OUString SAL_CALL VCLXAccessibleToolBoxItem::getToolTipText( ) throw (RuntimeException, std::exception)
603 : {
604 0 : OExternalLockGuard aGuard( this );
605 :
606 0 : OUString sRet;
607 0 : if ( m_pToolBox )
608 : {
609 0 : if ( Help::IsExtHelpEnabled() )
610 0 : sRet = m_pToolBox->GetHelpText( m_nItemId );
611 : else
612 0 : sRet = m_pToolBox->GetQuickHelpText( m_nItemId );
613 0 : if ( sRet.isEmpty() )
614 : // no help text set, so use item text
615 0 : sRet = m_pToolBox->GetItemText( m_nItemId );
616 : }
617 0 : return sRet;
618 : }
619 :
620 : // XAccessibleAction
621 :
622 2 : sal_Int32 VCLXAccessibleToolBoxItem::getAccessibleActionCount( ) throw (RuntimeException, std::exception)
623 : {
624 : // only one action -> "Click"
625 2 : return 1;
626 : }
627 :
628 2 : sal_Bool VCLXAccessibleToolBoxItem::doAccessibleAction ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
629 : {
630 2 : OExternalLockGuard aGuard( this );
631 :
632 2 : if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
633 0 : throw IndexOutOfBoundsException();
634 :
635 2 : if ( m_pToolBox )
636 2 : m_pToolBox->TriggerItem( m_nItemId );
637 :
638 2 : return true;
639 : }
640 :
641 0 : OUString VCLXAccessibleToolBoxItem::getAccessibleActionDescription ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
642 : {
643 0 : OExternalLockGuard aGuard( this );
644 :
645 0 : if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
646 0 : throw IndexOutOfBoundsException();
647 :
648 0 : return OUString( TK_RES_STRING( RID_STR_ACC_ACTION_CLICK ) );
649 : }
650 :
651 0 : Reference< XAccessibleKeyBinding > VCLXAccessibleToolBoxItem::getAccessibleActionKeyBinding( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
652 : {
653 0 : OContextEntryGuard aGuard( this );
654 :
655 0 : if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
656 0 : throw IndexOutOfBoundsException();
657 :
658 0 : return Reference< XAccessibleKeyBinding >();
659 : }
660 :
661 : // XAccessibleValue
662 :
663 0 : Any VCLXAccessibleToolBoxItem::getCurrentValue( ) throw (RuntimeException, std::exception)
664 : {
665 0 : OExternalLockGuard aGuard( this );
666 :
667 0 : Any aValue;
668 0 : if ( m_pToolBox )
669 0 : aValue <<= (sal_Int32)m_pToolBox->IsItemChecked( m_nItemId );
670 :
671 0 : if( m_nRole == AccessibleRole::PANEL )
672 0 : aValue <<= (sal_Int32)0;
673 0 : return aValue;
674 : }
675 :
676 0 : sal_Bool VCLXAccessibleToolBoxItem::setCurrentValue( const Any& aNumber ) throw (RuntimeException, std::exception)
677 : {
678 0 : OExternalLockGuard aGuard( this );
679 :
680 0 : bool bReturn = false;
681 :
682 0 : if ( m_pToolBox )
683 : {
684 0 : sal_Int32 nValue = 0;
685 0 : OSL_VERIFY( aNumber >>= nValue );
686 :
687 0 : if ( nValue < 0 )
688 0 : nValue = 0;
689 0 : else if ( nValue > 1 )
690 0 : nValue = 1;
691 :
692 0 : m_pToolBox->CheckItem( m_nItemId, nValue == 1 );
693 0 : bReturn = true;
694 : }
695 :
696 0 : return bReturn;
697 : }
698 :
699 0 : Any VCLXAccessibleToolBoxItem::getMaximumValue( ) throw (RuntimeException, std::exception)
700 : {
701 0 : return makeAny((sal_Int32)1);
702 : }
703 :
704 0 : Any VCLXAccessibleToolBoxItem::getMinimumValue( ) throw (RuntimeException, std::exception)
705 : {
706 0 : return makeAny((sal_Int32)0);
707 : }
708 :
709 :
710 :
711 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
