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