sc/source/ui/Accessibility/AccessibleCsvControl.cxx

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