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