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 "AccessibleCsvControl.hxx"
21 : #include <com/sun/star/accessibility/AccessibleRole.hpp>
22 : #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
23 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
24 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
25 : #include <com/sun/star/accessibility/AccessibleTextType.hpp>
26 : #include <com/sun/star/accessibility/AccessibleTableModelChange.hpp>
27 : #include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp>
28 : #include <tools/debug.hxx>
29 : #include <toolkit/helper/convert.hxx>
30 : #include <unotools/accessiblerelationsethelper.hxx>
31 : #include <unotools/accessiblestatesethelper.hxx>
32 : #include <comphelper/sequence.hxx>
33 : #include <comphelper/servicehelper.hxx>
34 : #include "scitems.hxx"
35 : #include <editeng/fontitem.hxx>
36 : #include <editeng/fhgtitem.hxx>
37 : #include <editeng/langitem.hxx>
38 : #include "csvcontrol.hxx"
39 : #include "csvruler.hxx"
40 : #include "csvgrid.hxx"
41 : #include "AccessibleText.hxx"
42 : #include "editsrc.hxx"
43 : #include "scresid.hxx"
44 : #include "sc.hrc"
45 : #include "scmod.hxx"
46 : #include <svtools/colorcfg.hxx>
47 : #include <vcl/svapp.hxx>
48 : // ause
49 : #include "editutil.hxx"
50 :
51 : using ::rtl::OUString;
52 : using ::rtl::OUStringBuffer;
53 : using ::utl::AccessibleRelationSetHelper;
54 : using ::utl::AccessibleStateSetHelper;
55 : using ::accessibility::AccessibleStaticTextBase;
56 : using ::com::sun::star::uno::Any;
57 : using ::com::sun::star::uno::Reference;
58 : using ::com::sun::star::uno::Sequence;
59 : using ::com::sun::star::uno::RuntimeException;
60 : using ::com::sun::star::uno::XInterface;
61 : using ::com::sun::star::lang::DisposedException;
62 : using ::com::sun::star::lang::IndexOutOfBoundsException;
63 : using ::com::sun::star::lang::IllegalArgumentException;
64 : using ::com::sun::star::beans::PropertyValue;
65 : using namespace ::com::sun::star::accessibility;
66 :
67 :
68 : // ----------------------------------------------------------------------------
69 :
70 : const sal_uInt16 nRulerRole = AccessibleRole::TEXT;
71 : const sal_uInt16 nGridRole = AccessibleRole::TABLE;
72 : const sal_uInt16 nCellRole = AccessibleRole::TEXT;
73 :
74 : #define RULER_IMPL_NAME "ScAccessibleCsvRuler"
75 : #define GRID_IMPL_NAME "ScAccessibleCsvGrid"
76 : #define CELL_IMPL_NAME "ScAccessibleCsvCell"
77 :
78 : const sal_Unicode cRulerDot = '.';
79 : const sal_Unicode cRulerLine = '|';
80 :
81 : const sal_Int32 CSV_LINE_HEADER = CSV_POS_INVALID;
82 : const sal_uInt32 CSV_COLUMN_HEADER = CSV_COLUMN_INVALID;
83 :
84 :
85 : // CSV base control ===========================================================
86 :
87 : DBG_NAME( ScAccessibleCsvControl )
88 :
89 0 : ScAccessibleCsvControl::ScAccessibleCsvControl(
90 : const Reference< XAccessible >& rxParent,
91 : ScCsvControl& rControl,
92 : sal_uInt16 nRole ) :
93 : ScAccessibleContextBase( rxParent, nRole ),
94 0 : mpControl( &rControl )
95 : {
96 : DBG_CTOR( ScAccessibleCsvControl, NULL );
97 0 : }
98 :
99 0 : ScAccessibleCsvControl::~ScAccessibleCsvControl()
100 : {
101 : DBG_DTOR( ScAccessibleCsvControl, NULL );
102 0 : implDispose();
103 0 : }
104 :
105 0 : void SAL_CALL ScAccessibleCsvControl::disposing()
106 : {
107 0 : SolarMutexGuard aGuard;
108 0 : mpControl = NULL;
109 0 : ScAccessibleContextBase::disposing();
110 0 : }
111 :
112 :
113 : // XAccessibleComponent -------------------------------------------------------
114 :
115 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvControl::getAccessibleAtPoint( const AwtPoint& /* rPoint */ )
116 : throw( RuntimeException )
117 : {
118 0 : ensureAlive();
119 0 : return NULL;
120 : }
121 :
122 0 : sal_Bool SAL_CALL ScAccessibleCsvControl::isVisible() throw( RuntimeException )
123 : {
124 0 : SolarMutexGuard aGuard;
125 0 : ensureAlive();
126 0 : return implGetControl().IsVisible();
127 : }
128 :
129 0 : void SAL_CALL ScAccessibleCsvControl::grabFocus() throw( RuntimeException )
130 : {
131 0 : SolarMutexGuard aGuard;
132 0 : ensureAlive();
133 0 : implGetControl().GrabFocus();
134 0 : }
135 :
136 :
137 : // events ---------------------------------------------------------------------
138 :
139 0 : void ScAccessibleCsvControl::SendFocusEvent( bool bFocused )
140 : {
141 0 : if( bFocused )
142 0 : CommitFocusGained();
143 : else
144 0 : CommitFocusLost();
145 0 : }
146 :
147 0 : void ScAccessibleCsvControl::SendCaretEvent()
148 : {
149 : OSL_FAIL( "ScAccessibleCsvControl::SendCaretEvent - Illegal call" );
150 0 : }
151 :
152 0 : void ScAccessibleCsvControl::SendVisibleEvent()
153 : {
154 0 : AccessibleEventObject aEvent;
155 0 : aEvent.EventId = AccessibleEventId::VISIBLE_DATA_CHANGED;
156 0 : aEvent.Source = Reference< XAccessible >( this );
157 0 : CommitChange( aEvent );
158 0 : }
159 :
160 0 : void ScAccessibleCsvControl::SendSelectionEvent()
161 : {
162 0 : AccessibleEventObject aEvent;
163 0 : aEvent.EventId = AccessibleEventId::SELECTION_CHANGED;
164 0 : aEvent.Source = Reference< XAccessible >( this );
165 0 : CommitChange( aEvent );
166 0 : }
167 :
168 0 : void ScAccessibleCsvControl::SendTableUpdateEvent( sal_uInt32 /* nFirstColumn */, sal_uInt32 /* nLastColumn */, bool /* bAllRows */ )
169 : {
170 : OSL_FAIL( "ScAccessibleCsvControl::SendTableUpdateEvent - Illegal call" );
171 0 : }
172 :
173 0 : void ScAccessibleCsvControl::SendInsertColumnEvent( sal_uInt32 /* nFirstColumn */, sal_uInt32 /* nLastColumn */ )
174 : {
175 : OSL_FAIL( "ScAccessibleCsvControl::SendInsertColumnEvent - Illegal call" );
176 0 : }
177 :
178 0 : void ScAccessibleCsvControl::SendRemoveColumnEvent( sal_uInt32 /* nFirstColumn */, sal_uInt32 /* nLastColumn */ )
179 : {
180 : OSL_FAIL( "ScAccessibleCsvControl::SendRemoveColumnEvent - Illegal call" );
181 0 : }
182 :
183 :
184 : // helpers --------------------------------------------------------------------
185 :
186 0 : Rectangle ScAccessibleCsvControl::GetBoundingBoxOnScreen() const throw( RuntimeException )
187 : {
188 0 : SolarMutexGuard aGuard;
189 0 : ensureAlive();
190 0 : return implGetControl().GetWindowExtentsRelative( NULL );
191 : }
192 :
193 0 : Rectangle ScAccessibleCsvControl::GetBoundingBox() const throw( RuntimeException )
194 : {
195 0 : SolarMutexGuard aGuard;
196 0 : ensureAlive();
197 0 : return implGetControl().GetWindowExtentsRelative( implGetControl().GetAccessibleParentWindow() );
198 : }
199 :
200 0 : void ScAccessibleCsvControl::ensureAlive() const throw( DisposedException )
201 : {
202 0 : if( !implIsAlive() )
203 0 : throw DisposedException();
204 0 : }
205 :
206 0 : ScCsvControl& ScAccessibleCsvControl::implGetControl() const
207 : {
208 : OSL_ENSURE( mpControl, "ScAccessibleCsvControl::implGetControl - missing control" );
209 0 : return *mpControl;
210 : }
211 :
212 0 : Reference< XAccessible > ScAccessibleCsvControl::implGetChildByRole(
213 : const Reference< XAccessible >& rxParentObj, sal_uInt16 nRole ) throw( RuntimeException )
214 : {
215 0 : Reference< XAccessible > xAccObj;
216 0 : if( rxParentObj.is() )
217 : {
218 0 : Reference< XAccessibleContext > xParentCtxt = rxParentObj->getAccessibleContext();
219 0 : if( xParentCtxt.is() )
220 : {
221 0 : sal_Int32 nCount = xParentCtxt->getAccessibleChildCount();
222 0 : sal_Int32 nIndex = 0;
223 0 : while( !xAccObj.is() && (nIndex < nCount) )
224 : {
225 0 : Reference< XAccessible > xCurrObj = xParentCtxt->getAccessibleChild( nIndex );
226 0 : if( xCurrObj.is() )
227 : {
228 0 : Reference< XAccessibleContext > xCurrCtxt = xCurrObj->getAccessibleContext();
229 0 : if( xCurrCtxt.is() && (xCurrCtxt->getAccessibleRole() == nRole) )
230 0 : xAccObj = xCurrObj;
231 : }
232 0 : ++nIndex;
233 0 : }
234 0 : }
235 : }
236 0 : return xAccObj;
237 : }
238 :
239 0 : AccessibleStateSetHelper* ScAccessibleCsvControl::implCreateStateSet()
240 : {
241 0 : SolarMutexGuard aGuard;
242 0 : AccessibleStateSetHelper* pStateSet = new AccessibleStateSetHelper();
243 0 : if( implIsAlive() )
244 : {
245 0 : const ScCsvControl& rCtrl = implGetControl();
246 0 : pStateSet->AddState( AccessibleStateType::OPAQUE );
247 0 : if( rCtrl.IsEnabled() )
248 0 : pStateSet->AddState( AccessibleStateType::ENABLED );
249 0 : if( isShowing() )
250 0 : pStateSet->AddState( AccessibleStateType::SHOWING );
251 0 : if( isVisible() )
252 0 : pStateSet->AddState( AccessibleStateType::VISIBLE );
253 : }
254 : else
255 0 : pStateSet->AddState( AccessibleStateType::DEFUNC );
256 0 : return pStateSet;
257 : }
258 :
259 0 : void ScAccessibleCsvControl::implDispose()
260 : {
261 0 : if( implIsAlive() )
262 : {
263 : // prevent multiple call of dtor
264 0 : osl_atomic_increment( &m_refCount );
265 0 : dispose();
266 : }
267 0 : }
268 :
269 0 : Point ScAccessibleCsvControl::implGetAbsPos( const Point& rPos ) const
270 : {
271 0 : return rPos + implGetControl().GetWindowExtentsRelative( NULL ).TopLeft();
272 : }
273 :
274 :
275 : // Ruler ======================================================================
276 :
277 : /** Converts a ruler cursor position to API text index. */
278 0 : static sal_Int32 lcl_GetApiPos( sal_Int32 nRulerPos )
279 : {
280 0 : sal_Int32 nApiPos = nRulerPos;
281 0 : sal_Int32 nStart = (nRulerPos - 1) / 10;
282 0 : sal_Int32 nExp = 1;
283 0 : while( nStart >= nExp )
284 : {
285 0 : nApiPos += nStart - nExp + 1;
286 0 : nExp *= 10;
287 : }
288 0 : return ::std::max( nApiPos, static_cast<sal_Int32>(0) );
289 : }
290 :
291 : /** Converts an API text index to a ruler cursor position. */
292 0 : static sal_Int32 lcl_GetRulerPos( sal_Int32 nApiPos )
293 : {
294 0 : sal_Int32 nDiv = 10;
295 0 : sal_Int32 nExp = 10;
296 0 : sal_Int32 nRulerPos = 0;
297 0 : sal_Int32 nApiBase = 0;
298 0 : sal_Int32 nApiLimit = 10;
299 0 : while( nApiPos >= nApiLimit )
300 : {
301 0 : ++nDiv;
302 0 : nRulerPos = nExp;
303 0 : nExp *= 10;
304 0 : nApiBase = nApiLimit;
305 0 : nApiLimit = lcl_GetApiPos( nExp );
306 : }
307 0 : sal_Int32 nRelPos = nApiPos - nApiBase;
308 0 : return nRulerPos + nRelPos / nDiv * 10 + ::std::max( nRelPos % nDiv - nDiv + 10L, 0L );
309 : }
310 :
311 : /** Expands the sequence's size and returns the base index of the new inserted elements. */
312 0 : static inline sal_Int32 lcl_ExpandSequence( Sequence< PropertyValue >& rSeq, sal_Int32 nExp )
313 : {
314 : OSL_ENSURE( nExp > 0, "lcl_ExpandSequence - invalid value" );
315 0 : rSeq.realloc( rSeq.getLength() + nExp );
316 0 : return rSeq.getLength() - nExp;
317 : }
318 :
319 : /** Fills the property value rVal with the specified name and value from the item. */
320 0 : static inline void lcl_FillProperty( PropertyValue& rVal, const OUString& rPropName, const SfxPoolItem& rItem, sal_uInt8 nMID )
321 : {
322 0 : rVal.Name = rPropName;
323 0 : rItem.QueryValue( rVal.Value, nMID );
324 0 : }
325 :
326 : /** Fills the sequence with all font attributes of rFont. */
327 0 : static void lcl_FillFontAttributes( Sequence< PropertyValue >& rSeq, const Font& rFont )
328 : {
329 0 : SvxFontItem aFontItem( rFont.GetFamily(), rFont.GetName(), rFont.GetStyleName(), rFont.GetPitch(), rFont.GetCharSet(), ATTR_FONT );
330 0 : SvxFontHeightItem aHeightItem( rFont.GetSize().Height(), 100, ATTR_FONT_HEIGHT );
331 0 : SvxLanguageItem aLangItem( rFont.GetLanguage(), ATTR_FONT_LANGUAGE );
332 :
333 0 : sal_Int32 nIndex = lcl_ExpandSequence( rSeq, 7 );
334 0 : lcl_FillProperty( rSeq[ nIndex++ ], "CharFontName", aFontItem, MID_FONT_FAMILY_NAME );
335 0 : lcl_FillProperty( rSeq[ nIndex++ ], "CharFontFamily", aFontItem, MID_FONT_FAMILY );
336 0 : lcl_FillProperty( rSeq[ nIndex++ ], "CharFontStyleName", aFontItem, MID_FONT_STYLE_NAME );
337 0 : lcl_FillProperty( rSeq[ nIndex++ ], "CharFontCharSet", aFontItem, MID_FONT_PITCH );
338 0 : lcl_FillProperty( rSeq[ nIndex++ ], "CharFontPitch", aFontItem, MID_FONT_CHAR_SET );
339 0 : lcl_FillProperty( rSeq[ nIndex++ ], "CharHeight", aHeightItem, MID_FONTHEIGHT );
340 0 : lcl_FillProperty( rSeq[ nIndex++ ], "CharLocale", aLangItem, MID_LANG_LOCALE );
341 0 : }
342 :
343 :
344 :
345 : // ----------------------------------------------------------------------------
346 :
347 : DBG_NAME( ScAccessibleCsvRuler )
348 :
349 0 : ScAccessibleCsvRuler::ScAccessibleCsvRuler( ScCsvRuler& rRuler ) :
350 0 : ScAccessibleCsvControl( rRuler.GetAccessibleParentWindow()->GetAccessible(), rRuler, nRulerRole )
351 : {
352 : DBG_CTOR( ScAccessibleCsvRuler, NULL );
353 0 : constructStringBuffer();
354 0 : }
355 :
356 0 : ScAccessibleCsvRuler::~ScAccessibleCsvRuler()
357 : {
358 : DBG_DTOR( ScAccessibleCsvRuler, NULL );
359 0 : implDispose();
360 0 : }
361 :
362 : // XAccessibleComponent -----------------------------------------------------
363 :
364 0 : sal_Int32 SAL_CALL ScAccessibleCsvRuler::getForeground( )
365 : throw (RuntimeException)
366 : {
367 0 : SolarMutexGuard aGuard;
368 0 : ensureAlive();
369 0 : return implGetRuler().GetSettings().GetStyleSettings().GetLabelTextColor().GetColor();
370 : }
371 :
372 0 : sal_Int32 SAL_CALL ScAccessibleCsvRuler::getBackground( )
373 : throw (RuntimeException)
374 : {
375 0 : SolarMutexGuard aGuard;
376 0 : ensureAlive();
377 0 : return implGetRuler().GetSettings().GetStyleSettings().GetFaceColor().GetColor();
378 : }
379 :
380 : // XAccessibleContext ---------------------------------------------------------
381 :
382 0 : sal_Int32 SAL_CALL ScAccessibleCsvRuler::getAccessibleChildCount() throw( RuntimeException )
383 : {
384 0 : ensureAlive();
385 0 : return 0;
386 : }
387 :
388 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvRuler::getAccessibleChild( sal_Int32 /* nIndex */ )
389 : throw( IndexOutOfBoundsException, RuntimeException )
390 : {
391 0 : ensureAlive();
392 0 : throw IndexOutOfBoundsException();
393 : }
394 :
395 0 : Reference< XAccessibleRelationSet > SAL_CALL ScAccessibleCsvRuler::getAccessibleRelationSet()
396 : throw( RuntimeException )
397 : {
398 0 : SolarMutexGuard aGuard;
399 0 : ensureAlive();
400 0 : AccessibleRelationSetHelper* pRelationSet = new AccessibleRelationSetHelper();
401 0 : Reference< XAccessible > xAccObj = implGetChildByRole( getAccessibleParent(), nGridRole );
402 0 : if( xAccObj.is() )
403 : {
404 0 : Sequence< Reference< XInterface > > aSeq( 1 );
405 0 : aSeq[ 0 ] = xAccObj;
406 0 : pRelationSet->AddRelation( AccessibleRelation( AccessibleRelationType::CONTROLLER_FOR, aSeq ) );
407 : }
408 0 : return pRelationSet;
409 : }
410 :
411 0 : Reference< XAccessibleStateSet > SAL_CALL ScAccessibleCsvRuler::getAccessibleStateSet()
412 : throw( RuntimeException )
413 : {
414 0 : SolarMutexGuard aGuard;
415 0 : AccessibleStateSetHelper* pStateSet = implCreateStateSet();
416 0 : if( implIsAlive() )
417 : {
418 0 : pStateSet->AddState( AccessibleStateType::FOCUSABLE );
419 0 : pStateSet->AddState( AccessibleStateType::SINGLE_LINE );
420 0 : if( implGetRuler().HasFocus() )
421 0 : pStateSet->AddState( AccessibleStateType::FOCUSED );
422 : }
423 0 : return pStateSet;
424 : }
425 :
426 :
427 : // XAccessibleText ------------------------------------------------------------
428 :
429 0 : sal_Int32 SAL_CALL ScAccessibleCsvRuler::getCaretPosition() throw( RuntimeException )
430 : {
431 0 : SolarMutexGuard aGuard;
432 0 : ensureAlive();
433 0 : return lcl_GetApiPos( implGetRuler().GetRulerCursorPos() );
434 : }
435 :
436 0 : sal_Bool SAL_CALL ScAccessibleCsvRuler::setCaretPosition( sal_Int32 nIndex )
437 : throw( IndexOutOfBoundsException, RuntimeException )
438 : {
439 0 : SolarMutexGuard aGuard;
440 0 : ensureAlive();
441 0 : ensureValidIndex( nIndex );
442 0 : ScCsvRuler& rRuler = implGetRuler();
443 0 : sal_Int32 nOldCursor = rRuler.GetRulerCursorPos();
444 0 : rRuler.Execute( CSVCMD_MOVERULERCURSOR, lcl_GetRulerPos( nIndex ) );
445 0 : return rRuler.GetRulerCursorPos() != nOldCursor;
446 : }
447 :
448 0 : sal_Unicode SAL_CALL ScAccessibleCsvRuler::getCharacter( sal_Int32 nIndex )
449 : throw( IndexOutOfBoundsException, RuntimeException )
450 : {
451 0 : SolarMutexGuard aGuard;
452 0 : ensureAlive();
453 0 : ensureValidIndex( nIndex );
454 0 : return maBuffer[nIndex];
455 : }
456 :
457 0 : Sequence< PropertyValue > SAL_CALL ScAccessibleCsvRuler::getCharacterAttributes( sal_Int32 nIndex,
458 : const ::com::sun::star::uno::Sequence< ::rtl::OUString >& /* aRequestedAttributes */ )
459 : throw( IndexOutOfBoundsException, RuntimeException )
460 : {
461 0 : SolarMutexGuard aGuard;
462 0 : ensureAlive();
463 0 : ensureValidIndexWithEnd( nIndex );
464 0 : Sequence< PropertyValue > aSeq;
465 0 : lcl_FillFontAttributes( aSeq, implGetRuler().GetFont() );
466 0 : return aSeq;
467 : }
468 :
469 0 : ScAccessibleCsvRuler::AwtRectangle SAL_CALL ScAccessibleCsvRuler::getCharacterBounds( sal_Int32 nIndex )
470 : throw( IndexOutOfBoundsException, RuntimeException )
471 : {
472 0 : SolarMutexGuard aGuard;
473 0 : ensureAlive();
474 0 : ensureValidIndexWithEnd( nIndex );
475 0 : ScCsvRuler& rRuler = implGetRuler();
476 0 : Point aPos( rRuler.GetX( lcl_GetRulerPos( nIndex ) ) - rRuler.GetCharWidth() / 2, 0 );
477 0 : AwtRectangle aRect( aPos.X(), aPos.Y(), rRuler.GetCharWidth(), rRuler.GetSizePixel().Height() );
478 : // do not return rectangle out of window
479 0 : sal_Int32 nWidth = rRuler.GetOutputSizePixel().Width();
480 0 : if( aRect.X >= nWidth )
481 0 : throw IndexOutOfBoundsException();
482 0 : if( aRect.X + aRect.Width > nWidth )
483 0 : aRect.Width = nWidth - aRect.X;
484 0 : return aRect;
485 : }
486 :
487 0 : sal_Int32 SAL_CALL ScAccessibleCsvRuler::getCharacterCount() throw( RuntimeException )
488 : {
489 0 : SolarMutexGuard aGuard;
490 0 : ensureAlive();
491 0 : return implGetTextLength();
492 : }
493 :
494 0 : sal_Int32 SAL_CALL ScAccessibleCsvRuler::getIndexAtPoint( const AwtPoint& rPoint )
495 : throw( RuntimeException )
496 : {
497 0 : SolarMutexGuard aGuard;
498 0 : ensureAlive();
499 0 : ScCsvRuler& rRuler = implGetRuler();
500 : // use object's coordinate system, convert to API position
501 0 : return lcl_GetApiPos( ::std::min( ::std::max( rRuler.GetPosFromX( rPoint.X ), static_cast<sal_Int32>(0) ), rRuler.GetPosCount() ) );
502 : }
503 :
504 0 : OUString SAL_CALL ScAccessibleCsvRuler::getSelectedText() throw( RuntimeException )
505 : {
506 0 : ensureAlive();
507 0 : return OUString();
508 : }
509 :
510 0 : sal_Int32 SAL_CALL ScAccessibleCsvRuler::getSelectionStart() throw( RuntimeException )
511 : {
512 0 : ensureAlive();
513 0 : return -1;
514 : }
515 :
516 0 : sal_Int32 SAL_CALL ScAccessibleCsvRuler::getSelectionEnd() throw( RuntimeException )
517 : {
518 0 : ensureAlive();
519 0 : return -1;
520 : }
521 :
522 0 : sal_Bool SAL_CALL ScAccessibleCsvRuler::setSelection( sal_Int32 /* nStartIndex */, sal_Int32 /* nEndIndex */ )
523 : throw( IndexOutOfBoundsException, RuntimeException )
524 : {
525 0 : ensureAlive();
526 0 : return false;
527 : }
528 :
529 0 : OUString SAL_CALL ScAccessibleCsvRuler::getText() throw( RuntimeException )
530 : {
531 0 : SolarMutexGuard aGuard;
532 0 : ensureAlive();
533 0 : return OUString( maBuffer.getStr(), implGetTextLength() );
534 : }
535 :
536 0 : OUString SAL_CALL ScAccessibleCsvRuler::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
537 : throw( IndexOutOfBoundsException, RuntimeException )
538 : {
539 0 : SolarMutexGuard aGuard;
540 0 : ensureAlive();
541 0 : ensureValidRange( nStartIndex, nEndIndex );
542 0 : return OUString( maBuffer.getStr() + nStartIndex, nEndIndex - nStartIndex );
543 : }
544 :
545 0 : TextSegment SAL_CALL ScAccessibleCsvRuler::getTextAtIndex( sal_Int32 nIndex, sal_Int16 nTextType )
546 : throw( IndexOutOfBoundsException, IllegalArgumentException, RuntimeException )
547 : {
548 0 : SolarMutexGuard aGuard;
549 0 : ensureAlive();
550 :
551 0 : TextSegment aResult;
552 0 : aResult.SegmentStart = -1;
553 0 : aResult.SegmentEnd = -1;
554 :
555 0 : if( (nIndex == implGetTextLength()) && (nTextType != AccessibleTextType::LINE) )
556 : return aResult;
557 :
558 0 : ensureValidIndex( nIndex );
559 :
560 0 : OUStringBuffer aResultText; // will be assigned to aResult.SegmentText below
561 0 : sal_Int32 nRulerPos = lcl_GetRulerPos( nIndex );
562 :
563 0 : switch( nTextType )
564 : {
565 : // single character
566 : case AccessibleTextType::CHARACTER:
567 : {
568 0 : aResult.SegmentStart = nIndex;
569 0 : aResultText.append(maBuffer[nIndex]);
570 : }
571 0 : break;
572 :
573 : // entire number or single dot/line
574 : case AccessibleTextType::WORD:
575 : case AccessibleTextType::GLYPH:
576 0 : aResult.SegmentStart = nIndex;
577 0 : if( nRulerPos % 10 )
578 0 : aResultText.append(maBuffer[nIndex]);
579 : else
580 0 : aResultText.append( nRulerPos ); // string representation of sal_Int32!!!
581 0 : break;
582 :
583 : // entire text
584 : case AccessibleTextType::SENTENCE:
585 : case AccessibleTextType::PARAGRAPH:
586 : case AccessibleTextType::LINE:
587 0 : aResult.SegmentStart = 0;
588 0 : aResultText.append( maBuffer.getStr(), implGetTextLength() );
589 0 : break;
590 :
591 : // equal-formatted text
592 : case AccessibleTextType::ATTRIBUTE_RUN:
593 : {
594 0 : sal_Int32 nFirstIndex = implGetFirstEqualFormatted( nIndex );
595 0 : sal_Int32 nLastIndex = implGetLastEqualFormatted( nIndex );
596 0 : aResult.SegmentStart = nFirstIndex;
597 0 : aResultText.append( maBuffer.getStr() + nFirstIndex, nLastIndex - nFirstIndex + 1 );
598 : }
599 0 : break;
600 :
601 : default:
602 0 : throw RuntimeException();
603 : }
604 :
605 0 : aResult.SegmentText = aResultText.makeStringAndClear();
606 0 : aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
607 0 : return aResult;
608 : }
609 :
610 0 : TextSegment SAL_CALL ScAccessibleCsvRuler::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 nTextType )
611 : throw( IndexOutOfBoundsException, IllegalArgumentException, RuntimeException )
612 : {
613 0 : SolarMutexGuard aGuard;
614 0 : ensureAlive();
615 0 : ensureValidIndexWithEnd( nIndex );
616 :
617 0 : TextSegment aResult;
618 0 : aResult.SegmentStart = -1;
619 0 : aResult.SegmentEnd = -1;
620 :
621 0 : sal_Int32 nRulerPos = lcl_GetRulerPos( nIndex );
622 :
623 0 : switch( nTextType )
624 : {
625 : // single character
626 : case AccessibleTextType::CHARACTER:
627 0 : if( nIndex > 0 )
628 0 : aResult = getTextAtIndex( nIndex - 1, nTextType );
629 : // else empty
630 0 : break;
631 :
632 : // entire number or single dot/line
633 : case AccessibleTextType::WORD:
634 : case AccessibleTextType::GLYPH:
635 0 : if( nRulerPos > 0 )
636 0 : aResult = getTextAtIndex( lcl_GetApiPos( nRulerPos - 1 ), nTextType );
637 : // else empty
638 0 : break;
639 :
640 : // entire text
641 : case AccessibleTextType::SENTENCE:
642 : case AccessibleTextType::PARAGRAPH:
643 : case AccessibleTextType::LINE:
644 : // empty
645 0 : break;
646 :
647 : // equal-formatted text
648 : case AccessibleTextType::ATTRIBUTE_RUN:
649 : {
650 0 : sal_Int32 nFirstIndex = implGetFirstEqualFormatted( nIndex );
651 0 : if( nFirstIndex > 0 )
652 0 : aResult = getTextAtIndex( nFirstIndex - 1, nTextType );
653 : // else empty
654 : }
655 0 : break;
656 :
657 : default:
658 0 : throw RuntimeException();
659 : }
660 0 : return aResult;
661 : }
662 :
663 0 : TextSegment SAL_CALL ScAccessibleCsvRuler::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 nTextType )
664 : throw( IndexOutOfBoundsException, IllegalArgumentException, RuntimeException )
665 : {
666 0 : SolarMutexGuard aGuard;
667 0 : ensureAlive();
668 0 : ensureValidIndexWithEnd( nIndex );
669 :
670 0 : TextSegment aResult;
671 0 : aResult.SegmentStart = -1;
672 0 : aResult.SegmentEnd = -1;
673 :
674 0 : sal_Int32 nRulerPos = lcl_GetRulerPos( nIndex );
675 0 : sal_Int32 nLastValid = implGetTextLength();
676 :
677 0 : switch( nTextType )
678 : {
679 : // single character
680 : case AccessibleTextType::CHARACTER:
681 0 : if( nIndex < nLastValid )
682 0 : aResult = getTextAtIndex( nIndex + 1, nTextType );
683 : // else empty
684 0 : break;
685 :
686 : // entire number or single dot/line
687 : case AccessibleTextType::WORD:
688 : case AccessibleTextType::GLYPH:
689 0 : if( nRulerPos < implGetRuler().GetPosCount() )
690 0 : aResult = getTextAtIndex( lcl_GetApiPos( nRulerPos + 1 ), nTextType );
691 : // else empty
692 0 : break;
693 :
694 : // entire text
695 : case AccessibleTextType::SENTENCE:
696 : case AccessibleTextType::PARAGRAPH:
697 : case AccessibleTextType::LINE:
698 : // empty
699 0 : break;
700 :
701 : // equal-formatted text
702 : case AccessibleTextType::ATTRIBUTE_RUN:
703 : {
704 0 : sal_Int32 nLastIndex = implGetLastEqualFormatted( nIndex );
705 0 : if( nLastIndex < nLastValid )
706 0 : aResult = getTextAtIndex( nLastIndex + 1, nTextType );
707 : // else empty
708 : }
709 0 : break;
710 :
711 : default:
712 0 : throw RuntimeException();
713 : }
714 0 : return aResult;
715 : }
716 :
717 0 : sal_Bool SAL_CALL ScAccessibleCsvRuler::copyText( sal_Int32 /* nStartIndex */, sal_Int32 /* nEndIndex */ )
718 : throw( IndexOutOfBoundsException, RuntimeException )
719 : {
720 0 : ensureAlive();
721 0 : return false;
722 : }
723 :
724 :
725 : // XInterface -----------------------------------------------------------------
726 :
727 0 : Any SAL_CALL ScAccessibleCsvRuler::queryInterface( const ::com::sun::star::uno::Type& rType )
728 : throw( RuntimeException )
729 : {
730 0 : Any aAny( ScAccessibleCsvRulerImpl::queryInterface( rType ) );
731 0 : return aAny.hasValue() ? aAny : ScAccessibleCsvControl::queryInterface( rType );
732 : }
733 :
734 0 : void SAL_CALL ScAccessibleCsvRuler::acquire() throw ()
735 : {
736 0 : ScAccessibleCsvControl::acquire();
737 0 : }
738 :
739 0 : void SAL_CALL ScAccessibleCsvRuler::release() throw ()
740 : {
741 0 : ScAccessibleCsvControl::release();
742 0 : }
743 :
744 :
745 : // XServiceInfo ---------------------------------------------------------------
746 :
747 0 : OUString SAL_CALL ScAccessibleCsvRuler::getImplementationName() throw( RuntimeException )
748 : {
749 0 : return OUString( RULER_IMPL_NAME );
750 : }
751 :
752 :
753 : // XTypeProvider --------------------------------------------------------------
754 :
755 0 : Sequence< ::com::sun::star::uno::Type > SAL_CALL ScAccessibleCsvRuler::getTypes() throw( RuntimeException )
756 : {
757 0 : Sequence< ::com::sun::star::uno::Type > aSeq( 1 );
758 0 : aSeq[ 0 ] = getCppuType( static_cast< const Reference< XAccessibleText >* >( NULL ) );
759 0 : return ::comphelper::concatSequences( ScAccessibleCsvControl::getTypes(), aSeq );
760 : }
761 :
762 : namespace
763 : {
764 : class theScAccessibleCsvRulerImplementationId : public rtl::Static< UnoTunnelIdInit, theScAccessibleCsvRulerImplementationId > {};
765 : }
766 :
767 0 : Sequence< sal_Int8 > SAL_CALL ScAccessibleCsvRuler::getImplementationId() throw( RuntimeException )
768 : {
769 0 : return theScAccessibleCsvRulerImplementationId::get().getSeq();
770 : }
771 :
772 :
773 : // events ---------------------------------------------------------------------
774 :
775 0 : void ScAccessibleCsvRuler::SendCaretEvent()
776 : {
777 0 : sal_Int32 nPos = implGetRuler().GetRulerCursorPos();
778 0 : if( nPos != CSV_POS_INVALID )
779 : {
780 0 : AccessibleEventObject aEvent;
781 0 : aEvent.EventId = AccessibleEventId::CARET_CHANGED;
782 0 : aEvent.Source = Reference< XAccessible >( this );
783 0 : aEvent.NewValue <<= nPos;
784 0 : CommitChange( aEvent );
785 : }
786 0 : }
787 :
788 :
789 : // helpers --------------------------------------------------------------------
790 :
791 0 : OUString SAL_CALL ScAccessibleCsvRuler::createAccessibleName() throw( RuntimeException )
792 : {
793 0 : return String( ScResId( STR_ACC_CSVRULER_NAME ) );
794 : }
795 :
796 0 : OUString SAL_CALL ScAccessibleCsvRuler::createAccessibleDescription() throw( RuntimeException )
797 : {
798 0 : return String( ScResId( STR_ACC_CSVRULER_DESCR ) );
799 : }
800 :
801 0 : void ScAccessibleCsvRuler::ensureValidIndex( sal_Int32 nIndex ) const
802 : throw( IndexOutOfBoundsException )
803 : {
804 0 : if( (nIndex < 0) || (nIndex >= implGetTextLength()) )
805 0 : throw IndexOutOfBoundsException();
806 0 : }
807 :
808 0 : void ScAccessibleCsvRuler::ensureValidIndexWithEnd( sal_Int32 nIndex ) const
809 : throw( IndexOutOfBoundsException )
810 : {
811 0 : if( (nIndex < 0) || (nIndex > implGetTextLength()) )
812 0 : throw IndexOutOfBoundsException();
813 0 : }
814 :
815 0 : void ScAccessibleCsvRuler::ensureValidRange( sal_Int32& rnStartIndex, sal_Int32& rnEndIndex ) const
816 : throw( IndexOutOfBoundsException )
817 : {
818 0 : if( rnStartIndex > rnEndIndex )
819 0 : ::std::swap( rnStartIndex, rnEndIndex );
820 0 : if( (rnStartIndex < 0) || (rnEndIndex > implGetTextLength()) )
821 0 : throw IndexOutOfBoundsException();
822 0 : }
823 :
824 0 : ScCsvRuler& ScAccessibleCsvRuler::implGetRuler() const
825 : {
826 0 : return static_cast< ScCsvRuler& >( implGetControl() );
827 : }
828 :
829 0 : void ScAccessibleCsvRuler::constructStringBuffer() throw( RuntimeException )
830 : {
831 0 : SolarMutexGuard aGuard;
832 0 : ensureAlive();
833 : // extend existing string buffer to new ruler size
834 0 : sal_Int32 nRulerCount = implGetRuler().GetPosCount();
835 0 : sal_Int32 nRulerPos = lcl_GetRulerPos( maBuffer.getLength() );
836 0 : for( ; nRulerPos <= nRulerCount; ++nRulerPos ) // include last position
837 : {
838 0 : switch( nRulerPos % 10 )
839 : {
840 0 : case 0: maBuffer.append( nRulerPos ); break;
841 0 : case 5: maBuffer.append( cRulerLine ); break;
842 0 : default: maBuffer.append( cRulerDot );
843 : }
844 0 : }
845 0 : }
846 :
847 0 : sal_Int32 ScAccessibleCsvRuler::implGetTextLength() const
848 : {
849 0 : return lcl_GetApiPos( implGetRuler().GetPosCount() + 1 );
850 : }
851 :
852 0 : bool ScAccessibleCsvRuler::implHasSplit( sal_Int32 nApiPos )
853 : {
854 0 : sal_Int32 nRulerPos = lcl_GetRulerPos( nApiPos );
855 0 : return implGetRuler().HasSplit( nRulerPos ) && (nApiPos == lcl_GetApiPos( nRulerPos ));
856 : }
857 :
858 0 : sal_Int32 ScAccessibleCsvRuler::implGetFirstEqualFormatted( sal_Int32 nApiPos )
859 : {
860 0 : bool bSplit = implHasSplit( nApiPos );
861 0 : while( (nApiPos > 0) && (implHasSplit( nApiPos - 1 ) == bSplit) )
862 0 : --nApiPos;
863 0 : return nApiPos;
864 : }
865 :
866 0 : sal_Int32 ScAccessibleCsvRuler::implGetLastEqualFormatted( sal_Int32 nApiPos )
867 : {
868 0 : bool bSplit = implHasSplit( nApiPos );
869 0 : sal_Int32 nLength = implGetTextLength();
870 0 : while( (nApiPos < nLength - 1) && (implHasSplit( nApiPos + 1 ) == bSplit) )
871 0 : ++nApiPos;
872 0 : return nApiPos;
873 : }
874 :
875 :
876 : // Grid =======================================================================
877 :
878 : /** Converts a grid columnm index to an API column index. */
879 0 : static inline sal_Int32 lcl_GetApiColumn( sal_uInt32 nGridColumn )
880 : {
881 0 : return (nGridColumn != CSV_COLUMN_HEADER) ? static_cast< sal_Int32 >( nGridColumn + 1 ) : 0;
882 : }
883 :
884 : /** Converts an API columnm index to a ScCsvGrid column index. */
885 0 : static inline sal_uInt32 lcl_GetGridColumn( sal_Int32 nApiColumn )
886 : {
887 0 : return (nApiColumn > 0) ? static_cast< sal_uInt32 >( nApiColumn - 1 ) : CSV_COLUMN_HEADER;
888 : }
889 :
890 :
891 : // ----------------------------------------------------------------------------
892 :
893 : DBG_NAME( ScAccessibleCsvGrid )
894 :
895 0 : ScAccessibleCsvGrid::ScAccessibleCsvGrid( ScCsvGrid& rGrid ) :
896 0 : ScAccessibleCsvControl( rGrid.GetAccessibleParentWindow()->GetAccessible(), rGrid, nGridRole )
897 : {
898 : DBG_CTOR( ScAccessibleCsvGrid, NULL );
899 0 : }
900 :
901 0 : ScAccessibleCsvGrid::~ScAccessibleCsvGrid()
902 : {
903 : DBG_DTOR( ScAccessibleCsvGrid, NULL );
904 0 : implDispose();
905 0 : }
906 :
907 :
908 : // XAccessibleComponent -------------------------------------------------------
909 :
910 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvGrid::getAccessibleAtPoint( const AwtPoint& rPoint )
911 : throw( RuntimeException )
912 : {
913 0 : Reference< XAccessible > xRet;
914 0 : if( containsPoint( rPoint ) )
915 : {
916 0 : SolarMutexGuard aGuard;
917 0 : ensureAlive();
918 :
919 0 : const ScCsvGrid& rGrid = implGetGrid();
920 : // #102679#; use <= instead of <, because the offset is the size and not the point
921 0 : sal_Int32 nColumn = ((rGrid.GetFirstX() <= rPoint.X) && (rPoint.X <= rGrid.GetLastX())) ?
922 0 : lcl_GetApiColumn( rGrid.GetColumnFromX( rPoint.X ) ) : 0;
923 0 : sal_Int32 nRow = (rPoint.Y >= rGrid.GetHdrHeight()) ?
924 0 : (rGrid.GetLineFromY( rPoint.Y ) - rGrid.GetFirstVisLine() + 1) : 0;
925 0 : xRet = implCreateCellObj( nRow, nColumn );
926 : }
927 0 : return xRet;
928 : }
929 :
930 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getForeground( )
931 : throw (RuntimeException)
932 : {
933 0 : SolarMutexGuard aGuard;
934 0 : ensureAlive();
935 0 : return implGetGrid().GetSettings().GetStyleSettings().GetButtonTextColor().GetColor();
936 : }
937 :
938 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getBackground( )
939 : throw (RuntimeException)
940 : {
941 0 : SolarMutexGuard aGuard;
942 0 : ensureAlive();
943 0 : return SC_MOD()->GetColorConfig().GetColorValue( ::svtools::DOCCOLOR ).nColor;
944 : }
945 :
946 : // XAccessibleContext ---------------------------------------------------------
947 :
948 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getAccessibleChildCount() throw( RuntimeException )
949 : {
950 0 : SolarMutexGuard aGuard;
951 0 : ensureAlive();
952 0 : return implGetCellCount();
953 : }
954 :
955 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvGrid::getAccessibleChild( sal_Int32 nIndex )
956 : throw( IndexOutOfBoundsException, RuntimeException )
957 : {
958 0 : SolarMutexGuard aGuard;
959 0 : ensureAlive();
960 0 : ensureValidIndex( nIndex );
961 0 : return implCreateCellObj( implGetRow( nIndex ), implGetColumn( nIndex ) );
962 : }
963 :
964 0 : Reference< XAccessibleRelationSet > SAL_CALL ScAccessibleCsvGrid::getAccessibleRelationSet()
965 : throw( RuntimeException )
966 : {
967 0 : SolarMutexGuard aGuard;
968 0 : ensureAlive();
969 0 : AccessibleRelationSetHelper* pRelationSet = new AccessibleRelationSetHelper();
970 0 : Reference< XAccessible > xAccObj = implGetChildByRole( getAccessibleParent(), nRulerRole );
971 0 : if( xAccObj.is() )
972 : {
973 0 : Sequence< Reference< XInterface > > aSeq( 1 );
974 0 : aSeq[ 0 ] = xAccObj;
975 0 : pRelationSet->AddRelation( AccessibleRelation( AccessibleRelationType::CONTROLLED_BY, aSeq ) );
976 : }
977 0 : return pRelationSet;
978 : }
979 :
980 0 : Reference< XAccessibleStateSet > SAL_CALL ScAccessibleCsvGrid::getAccessibleStateSet()
981 : throw( RuntimeException )
982 : {
983 0 : SolarMutexGuard aGuard;
984 0 : AccessibleStateSetHelper* pStateSet = implCreateStateSet();
985 0 : if( implIsAlive() )
986 : {
987 0 : pStateSet->AddState( AccessibleStateType::FOCUSABLE );
988 0 : pStateSet->AddState( AccessibleStateType::MULTI_SELECTABLE );
989 0 : pStateSet->AddState( AccessibleStateType::MANAGES_DESCENDANTS );
990 0 : if( implGetGrid().HasFocus() )
991 0 : pStateSet->AddState( AccessibleStateType::FOCUSED );
992 : }
993 : else
994 0 : pStateSet->AddState( AccessibleStateType::DEFUNC );
995 0 : return pStateSet;
996 : }
997 :
998 :
999 : // XAccessibleTable -----------------------------------------------------------
1000 :
1001 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getAccessibleRowCount() throw( RuntimeException )
1002 : {
1003 0 : SolarMutexGuard aGuard;
1004 0 : ensureAlive();
1005 0 : return implGetRowCount();
1006 : }
1007 :
1008 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getAccessibleColumnCount() throw( RuntimeException )
1009 : {
1010 0 : SolarMutexGuard aGuard;
1011 0 : ensureAlive();
1012 0 : return implGetColumnCount();
1013 : }
1014 :
1015 0 : OUString SAL_CALL ScAccessibleCsvGrid::getAccessibleRowDescription( sal_Int32 nRow )
1016 : throw( IndexOutOfBoundsException, RuntimeException )
1017 : {
1018 0 : SolarMutexGuard aGuard;
1019 0 : ensureAlive();
1020 0 : ensureValidPosition( nRow, 0 );
1021 0 : return implGetCellText( nRow, 0 );
1022 : }
1023 :
1024 0 : OUString SAL_CALL ScAccessibleCsvGrid::getAccessibleColumnDescription( sal_Int32 nColumn )
1025 : throw( IndexOutOfBoundsException, RuntimeException )
1026 : {
1027 0 : SolarMutexGuard aGuard;
1028 0 : ensureAlive();
1029 0 : ensureValidPosition( 0, nColumn );
1030 0 : return implGetCellText( 0, nColumn );
1031 : }
1032 :
1033 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn )
1034 : throw( IndexOutOfBoundsException, RuntimeException )
1035 : {
1036 0 : ensureAlive();
1037 0 : ensureValidPosition( nRow, nColumn );
1038 0 : return 1;
1039 : }
1040 :
1041 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn )
1042 : throw( IndexOutOfBoundsException, RuntimeException )
1043 : {
1044 0 : ensureAlive();
1045 0 : ensureValidPosition( nRow, nColumn );
1046 0 : return 1;
1047 : }
1048 :
1049 0 : Reference< XAccessibleTable > SAL_CALL ScAccessibleCsvGrid::getAccessibleRowHeaders()
1050 : throw( RuntimeException )
1051 : {
1052 0 : ensureAlive();
1053 0 : return NULL;
1054 : }
1055 :
1056 0 : Reference< XAccessibleTable > SAL_CALL ScAccessibleCsvGrid::getAccessibleColumnHeaders()
1057 : throw( RuntimeException )
1058 : {
1059 0 : ensureAlive();
1060 0 : return NULL;
1061 : }
1062 :
1063 0 : Sequence< sal_Int32 > SAL_CALL ScAccessibleCsvGrid::getSelectedAccessibleRows()
1064 : throw( RuntimeException )
1065 : {
1066 0 : ensureAlive();
1067 0 : return Sequence< sal_Int32 >();
1068 : }
1069 :
1070 0 : Sequence< sal_Int32 > SAL_CALL ScAccessibleCsvGrid::getSelectedAccessibleColumns()
1071 : throw( RuntimeException )
1072 : {
1073 0 : SolarMutexGuard aGuard;
1074 0 : ensureAlive();
1075 :
1076 0 : ScCsvGrid& rGrid = implGetGrid();
1077 0 : Sequence< sal_Int32 > aSeq( implGetColumnCount() );
1078 :
1079 0 : sal_Int32 nSeqIx = 0;
1080 0 : sal_uInt32 nColIx = rGrid.GetFirstSelected();
1081 0 : for( ; nColIx != CSV_COLUMN_INVALID; ++nSeqIx, nColIx = rGrid.GetNextSelected( nColIx ) )
1082 0 : aSeq[ nSeqIx ] = lcl_GetApiColumn( nColIx );
1083 :
1084 0 : aSeq.realloc( nSeqIx );
1085 0 : return aSeq;
1086 : }
1087 :
1088 0 : sal_Bool SAL_CALL ScAccessibleCsvGrid::isAccessibleRowSelected( sal_Int32 /* nRow */ )
1089 : throw( IndexOutOfBoundsException, RuntimeException )
1090 : {
1091 0 : ensureAlive();
1092 0 : return false;
1093 : }
1094 :
1095 0 : sal_Bool SAL_CALL ScAccessibleCsvGrid::isAccessibleColumnSelected( sal_Int32 nColumn )
1096 : throw( IndexOutOfBoundsException, RuntimeException )
1097 : {
1098 0 : SolarMutexGuard aGuard;
1099 0 : ensureAlive();
1100 0 : ensureValidIndex( nColumn );
1101 0 : return implIsColumnSelected( nColumn );
1102 : }
1103 :
1104 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvGrid::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn )
1105 : throw( IndexOutOfBoundsException, RuntimeException )
1106 : {
1107 0 : SolarMutexGuard aGuard;
1108 0 : ensureAlive();
1109 0 : ensureValidPosition( nRow, nColumn );
1110 0 : return implCreateCellObj( nRow, nColumn );
1111 : }
1112 :
1113 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvGrid::getAccessibleCaption()
1114 : throw( RuntimeException )
1115 : {
1116 0 : ensureAlive();
1117 0 : return NULL;
1118 : }
1119 :
1120 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvGrid::getAccessibleSummary()
1121 : throw( RuntimeException )
1122 : {
1123 0 : ensureAlive();
1124 0 : return NULL;
1125 : }
1126 :
1127 0 : sal_Bool SAL_CALL ScAccessibleCsvGrid::isAccessibleSelected( sal_Int32 /* nRow */, sal_Int32 nColumn )
1128 : throw( IndexOutOfBoundsException, RuntimeException )
1129 : {
1130 0 : return isAccessibleColumnSelected( nColumn );
1131 : }
1132 :
1133 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn )
1134 : throw( IndexOutOfBoundsException, RuntimeException )
1135 : {
1136 0 : SolarMutexGuard aGuard;
1137 0 : ensureAlive();
1138 0 : ensureValidPosition( nRow, nColumn );
1139 0 : return implGetIndex( nRow, nColumn );
1140 : }
1141 :
1142 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getAccessibleRow( sal_Int32 nChildIndex )
1143 : throw( IndexOutOfBoundsException, RuntimeException )
1144 : {
1145 0 : SolarMutexGuard aGuard;
1146 0 : ensureAlive();
1147 0 : ensureValidIndex( nChildIndex );
1148 0 : return implGetRow( nChildIndex );
1149 : }
1150 :
1151 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getAccessibleColumn( sal_Int32 nChildIndex )
1152 : throw( IndexOutOfBoundsException, RuntimeException )
1153 : {
1154 0 : SolarMutexGuard aGuard;
1155 0 : ensureAlive();
1156 0 : ensureValidIndex( nChildIndex );
1157 0 : return implGetColumn( nChildIndex );
1158 : }
1159 :
1160 :
1161 : // XAccessibleSelection -------------------------------------------------------
1162 :
1163 0 : void SAL_CALL ScAccessibleCsvGrid::selectAccessibleChild( sal_Int32 nChildIndex )
1164 : throw( IndexOutOfBoundsException, RuntimeException )
1165 : {
1166 0 : SolarMutexGuard aGuard;
1167 0 : ensureAlive();
1168 0 : ensureValidIndex( nChildIndex );
1169 0 : sal_Int32 nColumn = implGetColumn( nChildIndex );
1170 0 : if( nChildIndex == 0 )
1171 0 : implGetGrid().SelectAll();
1172 : else
1173 0 : implSelectColumn( nColumn, true );
1174 0 : }
1175 :
1176 0 : sal_Bool SAL_CALL ScAccessibleCsvGrid::isAccessibleChildSelected( sal_Int32 nChildIndex )
1177 : throw( IndexOutOfBoundsException, RuntimeException )
1178 : {
1179 0 : SolarMutexGuard aGuard;
1180 0 : ensureAlive();
1181 0 : ensureValidIndex( nChildIndex );
1182 0 : sal_Int32 nColumn = implGetColumn( nChildIndex );
1183 0 : return implIsColumnSelected( nColumn );
1184 : }
1185 :
1186 0 : void SAL_CALL ScAccessibleCsvGrid::clearAccessibleSelection() throw( RuntimeException )
1187 : {
1188 0 : SolarMutexGuard aGuard;
1189 0 : ensureAlive();
1190 0 : implGetGrid().SelectAll( false );
1191 0 : }
1192 :
1193 0 : void SAL_CALL ScAccessibleCsvGrid::selectAllAccessibleChildren() throw( RuntimeException )
1194 : {
1195 0 : selectAccessibleChild( 0 );
1196 0 : }
1197 :
1198 0 : sal_Int32 SAL_CALL ScAccessibleCsvGrid::getSelectedAccessibleChildCount() throw( RuntimeException )
1199 : {
1200 0 : SolarMutexGuard aGuard;
1201 0 : ensureAlive();
1202 0 : return implGetRowCount() * implGetSelColumnCount();
1203 : }
1204 :
1205 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvGrid::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
1206 : throw( IndexOutOfBoundsException, RuntimeException )
1207 : {
1208 0 : SolarMutexGuard aGuard;
1209 0 : ensureAlive();
1210 0 : sal_Int32 nColumns = implGetSelColumnCount();
1211 0 : if( nColumns == 0 )
1212 0 : throw IndexOutOfBoundsException();
1213 :
1214 0 : sal_Int32 nRow = nSelectedChildIndex / nColumns;
1215 0 : sal_Int32 nColumn = implGetSelColumn( nSelectedChildIndex % nColumns );
1216 0 : return getAccessibleCellAt( nRow, nColumn );
1217 : }
1218 :
1219 0 : void SAL_CALL ScAccessibleCsvGrid::deselectAccessibleChild( sal_Int32 nSelectedChildIndex )
1220 : throw( IndexOutOfBoundsException, RuntimeException )
1221 : {
1222 0 : SolarMutexGuard aGuard;
1223 0 : ensureAlive();
1224 0 : sal_Int32 nColumns = implGetSelColumnCount();
1225 0 : if( nColumns == 0 )
1226 0 : throw IndexOutOfBoundsException();
1227 :
1228 0 : sal_Int32 nColumn = implGetSelColumn( nSelectedChildIndex % nColumns );
1229 0 : ensureValidPosition( nSelectedChildIndex / nColumns, nColumn );
1230 0 : if( nColumn > 0 )
1231 0 : implSelectColumn( nColumn, false );
1232 0 : }
1233 :
1234 :
1235 : // XInterface -----------------------------------------------------------------
1236 :
1237 0 : Any SAL_CALL ScAccessibleCsvGrid::queryInterface( const ::com::sun::star::uno::Type& rType )
1238 : throw( RuntimeException )
1239 : {
1240 0 : Any aAny( ScAccessibleCsvGridImpl::queryInterface( rType ) );
1241 0 : return aAny.hasValue() ? aAny : ScAccessibleCsvControl::queryInterface( rType );
1242 : }
1243 :
1244 0 : void SAL_CALL ScAccessibleCsvGrid::acquire() throw ()
1245 : {
1246 0 : ScAccessibleCsvControl::acquire();
1247 0 : }
1248 :
1249 0 : void SAL_CALL ScAccessibleCsvGrid::release() throw ()
1250 : {
1251 0 : ScAccessibleCsvControl::release();
1252 0 : }
1253 :
1254 :
1255 : // XServiceInfo ---------------------------------------------------------------
1256 :
1257 0 : OUString SAL_CALL ScAccessibleCsvGrid::getImplementationName() throw( RuntimeException )
1258 : {
1259 0 : return OUString( GRID_IMPL_NAME );
1260 : }
1261 :
1262 :
1263 : // XTypeProvider --------------------------------------------------------------
1264 :
1265 0 : Sequence< ::com::sun::star::uno::Type > SAL_CALL ScAccessibleCsvGrid::getTypes() throw( RuntimeException )
1266 : {
1267 0 : Sequence< ::com::sun::star::uno::Type > aSeq( 2 );
1268 0 : aSeq[ 0 ] = getCppuType( static_cast< const Reference< XAccessibleTable >* >( NULL ) );
1269 0 : aSeq[ 1 ] = getCppuType( static_cast< const Reference< XAccessibleSelection >* >( NULL ) );
1270 0 : return ::comphelper::concatSequences( ScAccessibleCsvControl::getTypes(), aSeq );
1271 : }
1272 :
1273 : namespace
1274 : {
1275 : class theScAccessibleCsvGridImplementationId : public rtl::Static< UnoTunnelIdInit, theScAccessibleCsvGridImplementationId > {};
1276 : }
1277 :
1278 0 : Sequence< sal_Int8 > SAL_CALL ScAccessibleCsvGrid::getImplementationId() throw( RuntimeException )
1279 : {
1280 0 : return theScAccessibleCsvGridImplementationId::get().getSeq();
1281 : }
1282 :
1283 :
1284 : // events ---------------------------------------------------------------------
1285 :
1286 0 : void ScAccessibleCsvGrid::SendFocusEvent( bool bFocused )
1287 : {
1288 0 : ScAccessibleCsvControl::SendFocusEvent( bFocused );
1289 :
1290 0 : AccessibleEventObject aEvent;
1291 0 : aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED;
1292 0 : aEvent.Source = Reference< XAccessible >( this );
1293 : (bFocused ? aEvent.NewValue : aEvent.OldValue) <<=
1294 0 : getAccessibleCellAt( 0, lcl_GetApiColumn( implGetGrid().GetFocusColumn() ) );
1295 0 : CommitChange( aEvent );
1296 0 : }
1297 :
1298 0 : void ScAccessibleCsvGrid::SendTableUpdateEvent( sal_uInt32 nFirstColumn, sal_uInt32 nLastColumn, bool bAllRows )
1299 : {
1300 0 : if( nFirstColumn <= nLastColumn )
1301 : {
1302 : AccessibleTableModelChange aModelChange(
1303 0 : AccessibleTableModelChangeType::UPDATE, 0, bAllRows ? implGetRowCount() - 1 : 0,
1304 0 : lcl_GetApiColumn( nFirstColumn ), lcl_GetApiColumn( nLastColumn ) );
1305 0 : AccessibleEventObject aEvent;
1306 0 : aEvent.EventId = AccessibleEventId::TABLE_MODEL_CHANGED;
1307 0 : aEvent.Source = Reference< XAccessible >( this );
1308 0 : aEvent.NewValue <<= aModelChange;
1309 0 : CommitChange( aEvent );
1310 : }
1311 0 : }
1312 :
1313 0 : void ScAccessibleCsvGrid::SendInsertColumnEvent( sal_uInt32 nFirstColumn, sal_uInt32 nLastColumn )
1314 : {
1315 0 : if( nFirstColumn <= nLastColumn )
1316 : {
1317 : AccessibleTableModelChange aModelChange(
1318 0 : AccessibleTableModelChangeType::INSERT, 0, implGetRowCount() - 1,
1319 0 : lcl_GetApiColumn( nFirstColumn ), lcl_GetApiColumn( nLastColumn ) );
1320 0 : AccessibleEventObject aEvent;
1321 0 : aEvent.EventId = AccessibleEventId::TABLE_MODEL_CHANGED;
1322 0 : aEvent.Source = Reference< XAccessible >( this );
1323 0 : aEvent.NewValue <<= aModelChange;
1324 0 : CommitChange( aEvent );
1325 : }
1326 0 : }
1327 :
1328 0 : void ScAccessibleCsvGrid::SendRemoveColumnEvent( sal_uInt32 nFirstColumn, sal_uInt32 nLastColumn )
1329 : {
1330 0 : if( nFirstColumn <= nLastColumn )
1331 : {
1332 : AccessibleTableModelChange aModelChange(
1333 0 : AccessibleTableModelChangeType::DELETE, 0, implGetRowCount() - 1,
1334 0 : lcl_GetApiColumn( nFirstColumn ), lcl_GetApiColumn( nLastColumn ) );
1335 0 : AccessibleEventObject aEvent;
1336 0 : aEvent.EventId = AccessibleEventId::TABLE_MODEL_CHANGED;
1337 0 : aEvent.Source = Reference< XAccessible >( this );
1338 0 : aEvent.NewValue <<= aModelChange;
1339 0 : CommitChange( aEvent );
1340 : }
1341 0 : }
1342 :
1343 :
1344 : // helpers --------------------------------------------------------------------
1345 :
1346 0 : OUString SAL_CALL ScAccessibleCsvGrid::createAccessibleName() throw( RuntimeException )
1347 : {
1348 0 : return String( ScResId( STR_ACC_CSVGRID_NAME ) );
1349 : }
1350 :
1351 0 : OUString SAL_CALL ScAccessibleCsvGrid::createAccessibleDescription() throw( RuntimeException )
1352 : {
1353 0 : return String( ScResId( STR_ACC_CSVGRID_DESCR ) );
1354 : }
1355 :
1356 0 : void ScAccessibleCsvGrid::ensureValidIndex( sal_Int32 nIndex ) const
1357 : throw( IndexOutOfBoundsException )
1358 : {
1359 0 : if( (nIndex < 0) || (nIndex >= implGetCellCount()) )
1360 0 : throw IndexOutOfBoundsException();
1361 0 : }
1362 :
1363 0 : void ScAccessibleCsvGrid::ensureValidPosition( sal_Int32 nRow, sal_Int32 nColumn ) const
1364 : throw( IndexOutOfBoundsException )
1365 : {
1366 0 : if( (nRow < 0) || (nRow >= implGetRowCount()) || (nColumn < 0) || (nColumn >= implGetColumnCount()) )
1367 0 : throw IndexOutOfBoundsException();
1368 0 : }
1369 :
1370 0 : ScCsvGrid& ScAccessibleCsvGrid::implGetGrid() const
1371 : {
1372 0 : return static_cast< ScCsvGrid& >( implGetControl() );
1373 : }
1374 :
1375 0 : bool ScAccessibleCsvGrid::implIsColumnSelected( sal_Int32 nColumn ) const
1376 : {
1377 0 : return (nColumn > 0) && implGetGrid().IsSelected( lcl_GetGridColumn( nColumn ) );
1378 : }
1379 :
1380 0 : void ScAccessibleCsvGrid::implSelectColumn( sal_Int32 nColumn, bool bSelect )
1381 : {
1382 0 : if( nColumn > 0 )
1383 0 : implGetGrid().Select( lcl_GetGridColumn( nColumn ), bSelect );
1384 0 : }
1385 :
1386 0 : sal_Int32 ScAccessibleCsvGrid::implGetRowCount() const
1387 : {
1388 0 : return static_cast< sal_Int32 >( implGetGrid().GetLastVisLine() - implGetGrid().GetFirstVisLine() + 2 );
1389 : }
1390 :
1391 0 : sal_Int32 ScAccessibleCsvGrid::implGetColumnCount() const
1392 : {
1393 0 : return static_cast< sal_Int32 >( implGetGrid().GetColumnCount() + 1 );
1394 : }
1395 :
1396 0 : sal_Int32 ScAccessibleCsvGrid::implGetSelColumnCount() const
1397 : {
1398 0 : ScCsvGrid& rGrid = implGetGrid();
1399 0 : sal_Int32 nCount = 0;
1400 0 : for( sal_uInt32 nColIx = rGrid.GetFirstSelected(); nColIx != CSV_COLUMN_INVALID; nColIx = rGrid.GetNextSelected( nColIx ) )
1401 0 : ++nCount;
1402 0 : return nCount;
1403 : }
1404 :
1405 0 : sal_Int32 ScAccessibleCsvGrid::implGetSelColumn( sal_Int32 nSelColumn ) const
1406 : {
1407 0 : ScCsvGrid& rGrid = implGetGrid();
1408 0 : sal_Int32 nColumn = 0;
1409 0 : for( sal_uInt32 nColIx = rGrid.GetFirstSelected(); nColIx != CSV_COLUMN_INVALID; nColIx = rGrid.GetNextSelected( nColIx ) )
1410 : {
1411 0 : if( nColumn == nSelColumn )
1412 0 : return static_cast< sal_Int32 >( nColIx + 1 );
1413 0 : ++nColumn;
1414 : }
1415 0 : return 0;
1416 : }
1417 :
1418 0 : String ScAccessibleCsvGrid::implGetCellText( sal_Int32 nRow, sal_Int32 nColumn ) const
1419 : {
1420 0 : ScCsvGrid& rGrid = implGetGrid();
1421 0 : sal_Int32 nLine = nRow + rGrid.GetFirstVisLine() - 1;
1422 0 : String aCellStr;
1423 0 : if( (nColumn > 0) && (nRow > 0) )
1424 0 : aCellStr = rGrid.GetCellText( lcl_GetGridColumn( nColumn ), nLine );
1425 0 : else if( nRow > 0 )
1426 0 : aCellStr = String::CreateFromInt32( nLine + 1L );
1427 0 : else if( nColumn > 0 )
1428 0 : aCellStr = rGrid.GetColumnTypeName( lcl_GetGridColumn( nColumn ) );
1429 0 : return aCellStr;
1430 : }
1431 :
1432 :
1433 0 : ScAccessibleCsvControl* ScAccessibleCsvGrid::implCreateCellObj( sal_Int32 nRow, sal_Int32 nColumn ) const
1434 : {
1435 0 : return new ScAccessibleCsvCell( implGetGrid(), implGetCellText( nRow, nColumn ), nRow, nColumn );
1436 : }
1437 :
1438 :
1439 : // ============================================================================
1440 :
1441 : DBG_NAME( ScAccessibleCsvCell )
1442 :
1443 0 : ScAccessibleCsvCell::ScAccessibleCsvCell(
1444 : ScCsvGrid& rGrid,
1445 : const String& rCellText,
1446 : sal_Int32 nRow, sal_Int32 nColumn ) :
1447 : ScAccessibleCsvControl( rGrid.GetAccessible(), rGrid, nCellRole ),
1448 : AccessibleStaticTextBase( SvxEditSourcePtr( NULL ) ),
1449 : maCellText( rCellText ),
1450 0 : mnLine( nRow ? (nRow + rGrid.GetFirstVisLine() - 1) : CSV_LINE_HEADER ),
1451 0 : mnColumn( lcl_GetGridColumn( nColumn ) ),
1452 0 : mnIndex( nRow * (rGrid.GetColumnCount() + 1) + nColumn )
1453 : {
1454 : DBG_CTOR( ScAccessibleCsvCell, NULL );
1455 0 : SetEditSource( implCreateEditSource() );
1456 0 : }
1457 :
1458 0 : ScAccessibleCsvCell::~ScAccessibleCsvCell()
1459 : {
1460 : DBG_DTOR( ScAccessibleCsvCell, NULL );
1461 0 : }
1462 :
1463 0 : void SAL_CALL ScAccessibleCsvCell::disposing()
1464 : {
1465 0 : SolarMutexGuard aGuard;
1466 0 : SetEditSource( SvxEditSourcePtr( NULL ) );
1467 0 : ScAccessibleCsvControl::disposing();
1468 0 : }
1469 :
1470 :
1471 : // XAccessibleComponent -------------------------------------------------------
1472 :
1473 0 : void SAL_CALL ScAccessibleCsvCell::grabFocus() throw( RuntimeException )
1474 : {
1475 0 : SolarMutexGuard aGuard;
1476 0 : ensureAlive();
1477 0 : ScCsvGrid& rGrid = implGetGrid();
1478 0 : rGrid.Execute( CSVCMD_MOVEGRIDCURSOR, rGrid.GetColumnPos( mnColumn ) );
1479 0 : }
1480 :
1481 0 : sal_Int32 SAL_CALL ScAccessibleCsvCell::getForeground( )
1482 : throw (RuntimeException)
1483 : {
1484 0 : SolarMutexGuard aGuard;
1485 0 : ensureAlive();
1486 0 : return implGetGrid().GetSettings().GetStyleSettings().GetButtonTextColor().GetColor();
1487 : }
1488 :
1489 0 : sal_Int32 SAL_CALL ScAccessibleCsvCell::getBackground( )
1490 : throw (RuntimeException)
1491 : {
1492 0 : SolarMutexGuard aGuard;
1493 0 : ensureAlive();
1494 0 : return SC_MOD()->GetColorConfig().GetColorValue( ::svtools::DOCCOLOR ).nColor;
1495 : }
1496 :
1497 : // XAccessibleContext -----------------------------------------------------
1498 :
1499 0 : sal_Int32 SAL_CALL ScAccessibleCsvCell::getAccessibleChildCount() throw( RuntimeException )
1500 : {
1501 0 : return AccessibleStaticTextBase::getAccessibleChildCount();
1502 : }
1503 :
1504 0 : Reference< XAccessible > SAL_CALL ScAccessibleCsvCell::getAccessibleChild( sal_Int32 nIndex )
1505 : throw( IndexOutOfBoundsException, RuntimeException )
1506 : {
1507 0 : return AccessibleStaticTextBase::getAccessibleChild( nIndex );
1508 : }
1509 :
1510 0 : sal_Int32 SAL_CALL ScAccessibleCsvCell::getAccessibleIndexInParent() throw( RuntimeException )
1511 : {
1512 0 : SolarMutexGuard aGuard;
1513 0 : ensureAlive();
1514 0 : return mnIndex;
1515 : }
1516 :
1517 0 : Reference< XAccessibleRelationSet > SAL_CALL ScAccessibleCsvCell::getAccessibleRelationSet()
1518 : throw( RuntimeException )
1519 : {
1520 0 : SolarMutexGuard aGuard;
1521 0 : ensureAlive();
1522 0 : return new AccessibleRelationSetHelper();
1523 : }
1524 :
1525 0 : Reference< XAccessibleStateSet > SAL_CALL ScAccessibleCsvCell::getAccessibleStateSet()
1526 : throw( RuntimeException )
1527 : {
1528 0 : SolarMutexGuard aGuard;
1529 0 : AccessibleStateSetHelper* pStateSet = implCreateStateSet();
1530 0 : if( implIsAlive() )
1531 : {
1532 0 : const ScCsvGrid& rGrid = implGetGrid();
1533 0 : pStateSet->AddState( AccessibleStateType::SINGLE_LINE );
1534 0 : if( mnColumn != CSV_COLUMN_HEADER )
1535 0 : pStateSet->AddState( AccessibleStateType::SELECTABLE );
1536 0 : if( rGrid.HasFocus() && (rGrid.GetFocusColumn() == mnColumn) && (mnLine == CSV_LINE_HEADER) )
1537 0 : pStateSet->AddState( AccessibleStateType::ACTIVE );
1538 0 : if( rGrid.IsSelected( mnColumn ) )
1539 0 : pStateSet->AddState( AccessibleStateType::SELECTED );
1540 : }
1541 0 : return pStateSet;
1542 : }
1543 :
1544 : // XInterface -----------------------------------------------------------------
1545 :
1546 0 : IMPLEMENT_FORWARD_XINTERFACE2( ScAccessibleCsvCell, ScAccessibleCsvControl, AccessibleStaticTextBase )
1547 :
1548 : // XTypeProvider --------------------------------------------------------------
1549 :
1550 0 : IMPLEMENT_FORWARD_XTYPEPROVIDER2( ScAccessibleCsvCell, ScAccessibleCsvControl, AccessibleStaticTextBase )
1551 :
1552 : // XServiceInfo ---------------------------------------------------------------
1553 :
1554 0 : OUString SAL_CALL ScAccessibleCsvCell::getImplementationName() throw( RuntimeException )
1555 : {
1556 0 : return OUString( CELL_IMPL_NAME );
1557 : }
1558 :
1559 : // helpers --------------------------------------------------------------------
1560 :
1561 0 : Rectangle ScAccessibleCsvCell::GetBoundingBoxOnScreen() const throw( RuntimeException )
1562 : {
1563 0 : SolarMutexGuard aGuard;
1564 0 : ensureAlive();
1565 0 : Rectangle aRect( implGetBoundingBox() );
1566 0 : aRect.SetPos( implGetAbsPos( aRect.TopLeft() ) );
1567 0 : return aRect;
1568 : }
1569 :
1570 0 : Rectangle ScAccessibleCsvCell::GetBoundingBox() const throw( RuntimeException )
1571 : {
1572 0 : SolarMutexGuard aGuard;
1573 0 : ensureAlive();
1574 0 : return implGetBoundingBox();
1575 : }
1576 :
1577 0 : OUString SAL_CALL ScAccessibleCsvCell::createAccessibleName() throw( RuntimeException )
1578 : {
1579 0 : return maCellText;
1580 : }
1581 :
1582 0 : OUString SAL_CALL ScAccessibleCsvCell::createAccessibleDescription() throw( RuntimeException )
1583 : {
1584 0 : return OUString();
1585 : }
1586 :
1587 0 : ScCsvGrid& ScAccessibleCsvCell::implGetGrid() const
1588 : {
1589 0 : return static_cast< ScCsvGrid& >( implGetControl() );
1590 : }
1591 :
1592 0 : Point ScAccessibleCsvCell::implGetRealPos() const
1593 : {
1594 0 : ScCsvGrid& rGrid = implGetGrid();
1595 : return Point(
1596 0 : (mnColumn == CSV_COLUMN_HEADER) ? rGrid.GetHdrX() : rGrid.GetColumnX( mnColumn ),
1597 0 : (mnLine == CSV_LINE_HEADER) ? 0 : rGrid.GetY( mnLine ) );
1598 : }
1599 :
1600 0 : sal_uInt32 ScAccessibleCsvCell::implCalcPixelWidth(sal_uInt32 nChars) const
1601 : {
1602 0 : ScCsvGrid& rGrid = implGetGrid();
1603 0 : return rGrid.GetCharWidth() * nChars;
1604 : }
1605 :
1606 0 : Size ScAccessibleCsvCell::implGetRealSize() const
1607 : {
1608 0 : ScCsvGrid& rGrid = implGetGrid();
1609 : return Size(
1610 0 : (mnColumn == CSV_COLUMN_HEADER) ? rGrid.GetHdrWidth() : implCalcPixelWidth( rGrid.GetColumnWidth( mnColumn ) ),
1611 0 : (mnLine == CSV_LINE_HEADER) ? rGrid.GetHdrHeight() : rGrid.GetLineHeight() );
1612 : }
1613 :
1614 0 : Rectangle ScAccessibleCsvCell::implGetBoundingBox() const
1615 : {
1616 0 : ScCsvGrid& rGrid = implGetGrid();
1617 0 : Rectangle aClipRect( Point( 0, 0 ), rGrid.GetSizePixel() );
1618 0 : if( mnColumn != CSV_COLUMN_HEADER )
1619 : {
1620 0 : aClipRect.Left() = rGrid.GetFirstX();
1621 0 : aClipRect.Right() = rGrid.GetLastX();
1622 : }
1623 0 : if( mnLine != CSV_LINE_HEADER )
1624 0 : aClipRect.Top() = rGrid.GetHdrHeight();
1625 :
1626 0 : Rectangle aRect( implGetRealPos(), implGetRealSize() );
1627 0 : aRect.Intersection( aClipRect );
1628 0 : if( (aRect.GetWidth() <= 0) || (aRect.GetHeight() <= 0) )
1629 0 : aRect.SetSize( Size( -1, -1 ) );
1630 0 : return aRect;
1631 : }
1632 :
1633 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1634 0 : ::std::auto_ptr< SvxEditSource > ScAccessibleCsvCell::implCreateEditSource()
1635 : {
1636 0 : ScCsvGrid& rGrid = implGetGrid();
1637 0 : Rectangle aBoundRect( implGetBoundingBox() );
1638 0 : aBoundRect -= implGetRealPos();
1639 :
1640 : ::std::auto_ptr< ScAccessibleTextData > pCsvTextData( new ScAccessibleCsvTextData(
1641 0 : &rGrid, rGrid.GetEditEngine(), maCellText, aBoundRect, implGetRealSize() ) );
1642 :
1643 0 : ::std::auto_ptr< SvxEditSource > pEditSource( new ScAccessibilityEditSource( pCsvTextData ) );
1644 0 : return pEditSource;
1645 : }
1646 15 : SAL_WNODEPRECATED_DECLARATIONS_POP
1647 :
1648 : // ============================================================================
1649 :
1650 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
