sc/source/ui/Accessibility/AccessibleCell.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 "AccessibleCell.hxx"
  21 #include "scitems.hxx"
  22 #include <editeng/eeitem.hxx>
  23
  24
  25 #include "AccessibleText.hxx"
  26 #include "AccessibleDocument.hxx"
  27 #include "tabvwsh.hxx"
  28 #include "document.hxx"
  29 #include "attrib.hxx"
  30 #include "miscuno.hxx"
  31 #include "editsrc.hxx"
  32 #include "dociter.hxx"
  33 #include "markdata.hxx"
  34 #include "cellvalue.hxx"
  35 #include "formulaiter.hxx"
  36 #include "validat.hxx"
  37
  38 #include <unotools/accessiblestatesethelper.hxx>
  39 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  40 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  41 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  42 #include <com/sun/star/accessibility/XAccessibleTable.hpp>
  43 #include <editeng/brushitem.hxx>
  44 #include <comphelper/sequence.hxx>
  45 #include <float.h>
  46 #include <vcl/svapp.hxx>
  47
  48 #include "AccessibleSpreadsheet.hxx"
  49
  50 using namespace ::com::sun::star;
  51 using namespace ::com::sun::star::accessibility;
  52
  53 rtl::Reference<ScAccessibleCell> ScAccessibleCell::create(
  54         const uno::Reference<XAccessible>& rxParent,
  55         ScTabViewShell* pViewShell,
  56         ScAddress& rCellAddress,
  57         sal_Int32 nIndex,
  58         ScSplitPos eSplitPos,
  59         ScAccessibleDocument* pAccDoc)
  60 {
  61     rtl::Reference<ScAccessibleCell> x(new ScAccessibleCell(
  62         rxParent, pViewShell, rCellAddress, nIndex, eSplitPos, pAccDoc));
  63     x->Init();
  64     return x;
  65 }
  66
  67 ScAccessibleCell::ScAccessibleCell(
  68         const uno::Reference<XAccessible>& rxParent,
  69         ScTabViewShell* pViewShell,
  70         ScAddress& rCellAddress,
  71         sal_Int32 nIndex,
  72         ScSplitPos eSplitPos,
  73         ScAccessibleDocument* pAccDoc)
  74     :
  75     ScAccessibleCellBase(rxParent, GetDocument(pViewShell), rCellAddress, nIndex),
  76         ::accessibility::AccessibleStaticTextBase(CreateEditSource(pViewShell, rCellAddress, eSplitPos)),
  77     mpViewShell(pViewShell),
  78     mpAccDoc(pAccDoc),
  79     meSplitPos(eSplitPos)
  80 {
  81     if (pViewShell)
  82         pViewShell->AddAccessibilityObject(*this);
  83 }
  84
  85 ScAccessibleCell::~ScAccessibleCell()
  86 {
  87     if (!ScAccessibleContextBase::IsDefunc() && !rBHelper.bInDispose)
  88     {
  89         // increment refcount to prevent double call off dtor
  90         osl_atomic_increment( &m_refCount );
  91         // call dispose to inform object which have a weak reference to this object
  92         dispose();
  93     }
  94 }
  95
  96 void ScAccessibleCell::Init()
  97 {
  98     ScAccessibleCellBase::Init();
  99
 100     SetEventSource(this);
 101 }
 102
 103 void SAL_CALL ScAccessibleCell::disposing()
 104 {
 105     SolarMutexGuard aGuard;
 106     // dispose in AccessibleStaticTextBase
 107     Dispose();
 108
 109     if (mpViewShell)
 110     {
 111         mpViewShell->RemoveAccessibilityObject(*this);
 112         mpViewShell = NULL;
 113     }
 114     mpAccDoc = NULL;
 115
 116     ScAccessibleCellBase::disposing();
 117 }
 118
 119     //=====  XInterface  =====================================================
 120
 121 IMPLEMENT_FORWARD_XINTERFACE3( ScAccessibleCell, ScAccessibleCellBase, AccessibleStaticTextBase, ScAccessibleCellAttributeImpl )
 122
 123     //=====  XTypeProvider  ===================================================
 124
 125 IMPLEMENT_FORWARD_XTYPEPROVIDER3( ScAccessibleCell, ScAccessibleCellBase, AccessibleStaticTextBase, ScAccessibleCellAttributeImpl )
 126
 127     //=====  XAccessibleComponent  ============================================
 128
 129 uno::Reference< XAccessible > SAL_CALL ScAccessibleCell::getAccessibleAtPoint(
 130         const awt::Point& rPoint )
 131         throw (uno::RuntimeException, std::exception)
 132 {
 133     return AccessibleStaticTextBase::getAccessibleAtPoint(rPoint);
 134 }
 135
 136 void SAL_CALL ScAccessibleCell::grabFocus(  )
 137         throw (uno::RuntimeException, std::exception)
 138 {
 139      SolarMutexGuard aGuard;
 140     IsObjectValid();
 141     if (getAccessibleParent().is() && mpViewShell)
 142     {
 143         uno::Reference<XAccessibleComponent> xAccessibleComponent(getAccessibleParent()->getAccessibleContext(), uno::UNO_QUERY);
 144         if (xAccessibleComponent.is())
 145         {
 146             xAccessibleComponent->grabFocus();
 147             mpViewShell->SetCursor(maCellAddress.Col(), maCellAddress.Row());
 148         }
 149     }
 150 }
 151
 152 Rectangle ScAccessibleCell::GetBoundingBoxOnScreen(void) const
 153         throw (uno::RuntimeException, std::exception)
 154 {
 155     Rectangle aCellRect(GetBoundingBox());
 156     if (mpViewShell)
 157     {
 158         Window* pWindow = mpViewShell->GetWindowByPos(meSplitPos);
 159         if (pWindow)
 160         {
 161             Rectangle aRect = pWindow->GetWindowExtentsRelative(NULL);
 162             aCellRect.setX(aCellRect.getX() + aRect.getX());
 163             aCellRect.setY(aCellRect.getY() + aRect.getY());
 164         }
 165     }
 166     return aCellRect;
 167 }
 168
 169 Rectangle ScAccessibleCell::GetBoundingBox() const
 170         throw (uno::RuntimeException, std::exception)
 171 {
 172     Rectangle aCellRect;
 173     if (mpViewShell)
 174     {
 175         long nSizeX, nSizeY;
 176         mpViewShell->GetViewData()->GetMergeSizePixel(
 177             maCellAddress.Col(), maCellAddress.Row(), nSizeX, nSizeY);
 178         aCellRect.SetSize(Size(nSizeX, nSizeY));
 179         aCellRect.SetPos(mpViewShell->GetViewData()->GetScrPos(maCellAddress.Col(), maCellAddress.Row(), meSplitPos, true));
 180
 181         Window* pWindow = mpViewShell->GetWindowByPos(meSplitPos);
 182         if (pWindow)
 183         {
 184             Rectangle aRect(pWindow->GetWindowExtentsRelative(pWindow->GetAccessibleParentWindow()));
 185             aRect.Move(-aRect.Left(), -aRect.Top());
 186             aCellRect = aRect.Intersection(aCellRect);
 187         }
 188
 189         /*  #i19430# Gnopernicus reads text partly if it sticks out of the cell
 190             boundaries. This leads to wrong results in cases where the cell
 191             text is rotated, because rotation is not taken into account when
 192             calculating the visible part of the text. In these cases we will
 193             simply expand the cell size to the width of the unrotated text. */
 194         if (mpDoc)
 195         {
 196             const SfxInt32Item* pItem = static_cast< const SfxInt32Item* >(
 197                 mpDoc->GetAttr( maCellAddress.Col(), maCellAddress.Row(), maCellAddress.Tab(), ATTR_ROTATE_VALUE ) );
 198             if( pItem && (pItem->GetValue() != 0) )
 199             {
 200                 Rectangle aParaRect = GetParagraphBoundingBox();
 201                 if( !aParaRect.IsEmpty() && (aCellRect.GetWidth() < aParaRect.GetWidth()) )
 202                     aCellRect.SetSize( Size( aParaRect.GetWidth(), aCellRect.GetHeight() ) );
 203             }
 204         }
 205     }
 206     if (aCellRect.IsEmpty())
 207         aCellRect.SetPos(Point(-1, -1));
 208     return aCellRect;
 209 }
 210
 211     //=====  XAccessibleContext  ==============================================
 212
 213 sal_Int32 SAL_CALL
 214     ScAccessibleCell::getAccessibleChildCount(void)
 215                     throw (uno::RuntimeException, std::exception)
 216 {
 217     return AccessibleStaticTextBase::getAccessibleChildCount();
 218 }
 219
 220 uno::Reference< XAccessible > SAL_CALL
 221     ScAccessibleCell::getAccessibleChild(sal_Int32 nIndex)
 222         throw (uno::RuntimeException,
 223         lang::IndexOutOfBoundsException, std::exception)
 224 {
 225     return AccessibleStaticTextBase::getAccessibleChild(nIndex);
 226 }
 227
 228 uno::Reference<XAccessibleStateSet> SAL_CALL
 229     ScAccessibleCell::getAccessibleStateSet(void)
 230     throw (uno::RuntimeException, std::exception)
 231 {
 232     SolarMutexGuard aGuard;
 233     uno::Reference<XAccessibleStateSet> xParentStates;
 234     if (getAccessibleParent().is())
 235     {
 236         uno::Reference<XAccessibleContext> xParentContext = getAccessibleParent()->getAccessibleContext();
 237         xParentStates = xParentContext->getAccessibleStateSet();
 238     }
 239     utl::AccessibleStateSetHelper* pStateSet = new utl::AccessibleStateSetHelper();
 240     if (IsDefunc(xParentStates))
 241         pStateSet->AddState(AccessibleStateType::DEFUNC);
 242     else
 243     {
 244         if (IsFormulaMode())
 245         {
 246             pStateSet->AddState(AccessibleStateType::ENABLED);
 247             pStateSet->AddState(AccessibleStateType::MULTI_LINE);
 248             pStateSet->AddState(AccessibleStateType::MULTI_SELECTABLE);
 249             if (IsOpaque(xParentStates))
 250                 pStateSet->AddState(AccessibleStateType::OPAQUE);
 251             pStateSet->AddState(AccessibleStateType::SELECTABLE);
 252             if (IsSelected())
 253                 pStateSet->AddState(AccessibleStateType::SELECTED);
 254             if (isShowing())
 255                 pStateSet->AddState(AccessibleStateType::SHOWING);
 256             pStateSet->AddState(AccessibleStateType::TRANSIENT);
 257             if (isVisible())
 258                 pStateSet->AddState(AccessibleStateType::VISIBLE);
 259             return pStateSet;
 260         }
 261         if (IsEditable(xParentStates))
 262         {
 263             pStateSet->AddState(AccessibleStateType::EDITABLE);
 264             pStateSet->AddState(AccessibleStateType::RESIZABLE);
 265         }
 266         pStateSet->AddState(AccessibleStateType::ENABLED);
 267         pStateSet->AddState(AccessibleStateType::MULTI_LINE);
 268         pStateSet->AddState(AccessibleStateType::MULTI_SELECTABLE);
 269         pStateSet->AddState(AccessibleStateType::FOCUSABLE);
 270         if (IsOpaque(xParentStates))
 271             pStateSet->AddState(AccessibleStateType::OPAQUE);
 272         pStateSet->AddState(AccessibleStateType::SELECTABLE);
 273         if (IsSelected())
 274             pStateSet->AddState(AccessibleStateType::SELECTED);
 275         if (isShowing())
 276             pStateSet->AddState(AccessibleStateType::SHOWING);
 277         pStateSet->AddState(AccessibleStateType::TRANSIENT);
 278         if (isVisible())
 279             pStateSet->AddState(AccessibleStateType::VISIBLE);
 280     }
 281     return pStateSet;
 282 }
 283
 284 uno::Reference<XAccessibleRelationSet> SAL_CALL
 285        ScAccessibleCell::getAccessibleRelationSet()
 286     throw (uno::RuntimeException, std::exception)
 287 {
 288     SolarMutexGuard aGuard;
 289     IsObjectValid();
 290     utl::AccessibleRelationSetHelper* pRelationSet = NULL;
 291     if (mpAccDoc)
 292         pRelationSet = mpAccDoc->GetRelationSet(&maCellAddress);
 293     if (!pRelationSet)
 294         pRelationSet = new utl::AccessibleRelationSetHelper();
 295     FillDependends(pRelationSet);
 296     FillPrecedents(pRelationSet);
 297     return pRelationSet;
 298 }
 299
 300     //=====  XServiceInfo  ====================================================
 301
 302 OUString SAL_CALL ScAccessibleCell::getImplementationName(void)
 303         throw (uno::RuntimeException, std::exception)
 304 {
 305     return OUString("ScAccessibleCell");
 306 }
 307
 308 uno::Sequence< OUString> SAL_CALL
 309     ScAccessibleCell::getSupportedServiceNames(void)
 310         throw (uno::RuntimeException, std::exception)
 311 {
 312     uno::Sequence< OUString > aSequence = ScAccessibleContextBase::getSupportedServiceNames();
 313     sal_Int32 nOldSize(aSequence.getLength());
 314     aSequence.realloc(nOldSize + 1);
 315
 316     aSequence[nOldSize] = "com.sun.star.sheet.AccessibleCell";
 317
 318     return aSequence;
 319 }
 320
 321     //====  internal  =========================================================
 322
 323 bool ScAccessibleCell::IsDefunc(
 324     const uno::Reference<XAccessibleStateSet>& rxParentStates)
 325 {
 326     return ScAccessibleContextBase::IsDefunc() || (mpDoc == NULL) || (mpViewShell == NULL) || !getAccessibleParent().is() ||
 327          (rxParentStates.is() && rxParentStates->contains(AccessibleStateType::DEFUNC));
 328 }
 329
 330 bool ScAccessibleCell::IsEditable(
 331     const uno::Reference<XAccessibleStateSet>& rxParentStates)
 332 {
 333     bool bEditable(true);
 334     if (rxParentStates.is() && !rxParentStates->contains(AccessibleStateType::EDITABLE) &&
 335         mpDoc)
 336     {
 337         // here I have to test whether the protection of the table should influence this cell.
 338         const ScProtectionAttr* pItem = (const ScProtectionAttr*)mpDoc->GetAttr(
 339             maCellAddress.Col(), maCellAddress.Row(),
 340             maCellAddress.Tab(), ATTR_PROTECTION);
 341         if (pItem)
 342             bEditable = !pItem->GetProtection();
 343     }
 344     return bEditable;
 345 }
 346
 347 bool ScAccessibleCell::IsOpaque(
 348     const uno::Reference<XAccessibleStateSet>& /* rxParentStates */)
 349 {
 350     // test whether there is a background color
 351     bool bOpaque(true);
 352     if (mpDoc)
 353     {
 354         const SvxBrushItem* pItem = (const SvxBrushItem*)mpDoc->GetAttr(
 355             maCellAddress.Col(), maCellAddress.Row(),
 356             maCellAddress.Tab(), ATTR_BACKGROUND);
 357         if (pItem)
 358             bOpaque = pItem->GetColor() != COL_TRANSPARENT;
 359     }
 360     return bOpaque;
 361 }
 362
 363 bool ScAccessibleCell::IsSelected()
 364 {
 365     if (IsFormulaMode())
 366     {
 367         const ScAccessibleSpreadsheet *pSheet =static_cast<const ScAccessibleSpreadsheet*>(mxParent.get());
 368         if (pSheet)
 369         {
 370             return pSheet->IsScAddrFormulaSel(maCellAddress);
 371         }
 372         return false;
 373     }
 374
 375     bool bResult(false);
 376     if (mpViewShell && mpViewShell->GetViewData())
 377     {
 378         const ScMarkData& rMarkdata = mpViewShell->GetViewData()->GetMarkData();
 379         bResult = rMarkdata.IsCellMarked(maCellAddress.Col(), maCellAddress.Row());
 380     }
 381     return bResult;
 382 }
 383
 384 ScDocument* ScAccessibleCell::GetDocument(ScTabViewShell* pViewShell)
 385 {
 386     ScDocument* pDoc = NULL;
 387     if (pViewShell && pViewShell->GetViewData())
 388         pDoc = pViewShell->GetViewData()->GetDocument();
 389     return pDoc;
 390 }
 391
 392 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 393 ::std::auto_ptr< SvxEditSource > ScAccessibleCell::CreateEditSource(ScTabViewShell* pViewShell, ScAddress aCell, ScSplitPos eSplitPos)
 394 {
 395     if (IsFormulaMode())
 396     {
 397         return ::std::auto_ptr< SvxEditSource >();
 398     }
 399     ::std::auto_ptr < ScAccessibleTextData > pAccessibleCellTextData
 400         ( new ScAccessibleCellTextData( pViewShell, aCell, eSplitPos, this ) );
 401     ::std::auto_ptr< SvxEditSource > pEditSource (new ScAccessibilityEditSource(pAccessibleCellTextData));
 402
 403     return pEditSource;
 404 }
 405 SAL_WNODEPRECATED_DECLARATIONS_POP
 406
 407 void ScAccessibleCell::FillDependends(utl::AccessibleRelationSetHelper* pRelationSet)
 408 {
 409     if (mpDoc)
 410     {
 411         ScRange aRange(0, 0, maCellAddress.Tab(), MAXCOL, MAXROW, maCellAddress.Tab());
 412         ScCellIterator aCellIter(mpDoc, aRange);
 413
 414         for (bool bHasCell = aCellIter.first(); bHasCell; bHasCell = aCellIter.next())
 415         {
 416             if (aCellIter.getType() == CELLTYPE_FORMULA)
 417             {
 418                 bool bFound = false;
 419                 ScDetectiveRefIter aIter(aCellIter.getFormulaCell());
 420                 ScRange aRef;
 421                 while ( !bFound && aIter.GetNextRef( aRef ) )
 422                 {
 423                     if (aRef.In(maCellAddress))
 424                         bFound = true;
 425                 }
 426                 if (bFound)
 427                     AddRelation(aCellIter.GetPos(), AccessibleRelationType::CONTROLLER_FOR, pRelationSet);
 428             }
 429         }
 430     }
 431 }
 432
 433 void ScAccessibleCell::FillPrecedents(utl::AccessibleRelationSetHelper* pRelationSet)
 434 {
 435     if (mpDoc && mpDoc->GetCellType(maCellAddress) == CELLTYPE_FORMULA)
 436     {
 437         ScFormulaCell* pCell = mpDoc->GetFormulaCell(maCellAddress);
 438         if (!pCell)
 439             return;
 440         ScDetectiveRefIter aIter(pCell);
 441         ScRange aRef;
 442         while ( aIter.GetNextRef( aRef ) )
 443         {
 444             AddRelation( aRef, AccessibleRelationType::CONTROLLED_BY, pRelationSet);
 445         }
 446     }
 447 }
 448
 449 void ScAccessibleCell::AddRelation(const ScAddress& rCell,
 450     const sal_uInt16 aRelationType,
 451     utl::AccessibleRelationSetHelper* pRelationSet)
 452 {
 453     AddRelation(ScRange(rCell, rCell), aRelationType, pRelationSet);
 454 }
 455
 456 void ScAccessibleCell::AddRelation(const ScRange& rRange,
 457     const sal_uInt16 aRelationType,
 458     utl::AccessibleRelationSetHelper* pRelationSet)
 459 {
 460     uno::Reference < XAccessibleTable > xTable ( getAccessibleParent()->getAccessibleContext(), uno::UNO_QUERY );
 461     if (xTable.is())
 462     {
 463         sal_uInt32 nCount(static_cast<sal_uInt32>(rRange.aEnd.Col() -
 464                     rRange.aStart.Col() + 1) * (rRange.aEnd.Row() -
 465                     rRange.aStart.Row() + 1));
 466         uno::Sequence < uno::Reference < uno::XInterface > > aTargetSet( nCount );
 467         uno::Reference < uno::XInterface >* pTargetSet = aTargetSet.getArray();
 468         if (pTargetSet)
 469         {
 470             sal_uInt32 nPos(0);
 471             for (sal_uInt32 nRow = rRange.aStart.Row(); nRow <= sal::static_int_cast<sal_uInt32>(rRange.aEnd.Row()); ++nRow)
 472             {
 473                 for (sal_uInt32 nCol = rRange.aStart.Col(); nCol <= sal::static_int_cast<sal_uInt32>(rRange.aEnd.Col()); ++nCol)
 474                 {
 475                     pTargetSet[nPos] = xTable->getAccessibleCellAt(nRow, nCol);
 476                     ++nPos;
 477                 }
 478             }
 479             OSL_ENSURE(nCount == nPos, "something wents wrong");
 480         }
 481         AccessibleRelation aRelation;
 482         aRelation.RelationType = aRelationType;
 483         aRelation.TargetSet = aTargetSet;
 484         pRelationSet->AddRelation(aRelation);
 485     }
 486 }
 487
 488 static OUString ReplaceOneChar(const OUString& oldOUString, const OUString& replacedChar, const OUString& replaceStr)
 489 {
 490     int iReplace = oldOUString.lastIndexOf(replacedChar);
 491     OUString aRet = oldOUString;
 492     while(iReplace > -1)
 493     {
 494         aRet = aRet.replaceAt(iReplace, 1, replaceStr);
 495         iReplace = aRet.lastIndexOf(replacedChar, iReplace);
 496     }
 497     return aRet;
 498 }
 499
 500 static OUString ReplaceFourChar(const OUString& oldOUString)
 501 {
 502     OUString aRet = ReplaceOneChar(oldOUString, "\\", "\\\\");
 503     aRet = ReplaceOneChar(aRet, ";", "\\;");
 504     aRet = ReplaceOneChar(aRet, "=", "\\=");
 505     aRet = ReplaceOneChar(aRet, ",", "\\,");
 506     aRet = ReplaceOneChar(aRet, ":", "\\:");
 507     return aRet;
 508 }
 509
 510 uno::Any SAL_CALL ScAccessibleCell::getExtendedAttributes()
 511     throw (::com::sun::star::lang::IndexOutOfBoundsException,
 512            ::com::sun::star::uno::RuntimeException,
 513            std::exception)
 514 {
 515     SolarMutexGuard aGuard;
 516
 517     uno::Any strRet;
 518     if (mpViewShell)
 519     {
 520         OUString strFor = mpViewShell->GetFormula(maCellAddress) ;
 521         strFor = strFor.replaceAt(0,1,"");
 522         strFor = ReplaceFourChar(strFor);
 523         strFor = "Formula:" + strFor;
 524         strFor += ";Note:";
 525         strFor += ReplaceFourChar(GetAllDisplayNote());
 526         strFor += ";";
 527         strFor += getShadowAttrs();//the string returned contains the spliter ";"
 528         strFor += getBorderAttrs();//the string returned contains the spliter ";"
 529         //end of cell attributes
 530         if( mpDoc )
 531         {
 532             strFor += "isdropdown:";
 533             if( IsDropdown() )
 534                 strFor += "true";
 535             else
 536                 strFor += "false";
 537             strFor += ";";
 538         }
 539         strRet <<= strFor ;
 540     }
 541     return strRet;
 542 }
 543
 544 // cell has its own ParaIndent property, so when calling character attributes on cell, the ParaIndent should replace the ParaLeftMargin if its value is not zero.
 545 uno::Sequence< beans::PropertyValue > SAL_CALL ScAccessibleCell::getCharacterAttributes( sal_Int32 nIndex, const ::com::sun::star::uno::Sequence< OUString >& aRequestedAttributes ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 546 {
 547     SolarMutexGuard aGuard;
 548
 549     uno::Sequence< beans::PropertyValue > aAttribs = AccessibleStaticTextBase::getCharacterAttributes( nIndex, aRequestedAttributes );
 550     beans::PropertyValue *pAttribs = aAttribs.getArray();
 551
 552     sal_uInt16 nParaIndent = static_cast< const SfxUInt16Item* >( mpDoc->GetAttr( maCellAddress.Col(), maCellAddress.Row(), maCellAddress.Tab(), ATTR_INDENT ) )->GetValue();
 553     if (nParaIndent > 0)
 554     {
 555         OUString sLeftMarginName ("ParaLeftMargin");
 556         for (int i = 0; i < aAttribs.getLength(); ++i)
 557         {
 558             if (sLeftMarginName == pAttribs[i].Name)
 559             {
 560                 pAttribs[i].Value = uno::makeAny( nParaIndent );
 561                 break;
 562             }
 563         }
 564     }
 565     return aAttribs;
 566 }
 567
 568 bool ScAccessibleCell::IsFormulaMode()
 569 {
 570     ScAccessibleSpreadsheet* pSheet = static_cast<ScAccessibleSpreadsheet*>(mxParent.get());
 571     if (pSheet)
 572     {
 573         return pSheet->IsFormulaMode();
 574     }
 575     return false;
 576 }
 577
 578 bool ScAccessibleCell::IsDropdown()
 579 {
 580     sal_uInt16 nPosX = maCellAddress.Col();
 581     sal_uInt16 nPosY = sal_uInt16(maCellAddress.Row());
 582     sal_uInt16 nTab = maCellAddress.Tab();
 583     sal_uInt32 nValidation = static_cast< const SfxUInt32Item* >( mpDoc->GetAttr( nPosX, nPosY, nTab, ATTR_VALIDDATA ) )->GetValue();
 584     if( nValidation )
 585     {
 586         const ScValidationData* pData = mpDoc->GetValidationEntry( nValidation );
 587         if( pData && pData->HasSelectionList() )
 588             return true;
 589     }
 590     ScMergeFlagAttr* pAttr;
 591     pAttr = (ScMergeFlagAttr*)mpDoc->GetAttr( nPosX, nPosY, nTab, ATTR_MERGE_FLAG );
 592     if( pAttr->HasAutoFilter() )
 593     {
 594         return true;
 595     }
 596     else
 597     {
 598         sal_uInt16 nTabCount = mpDoc->GetTableCount();
 599         if ( nTab+1<nTabCount && mpDoc->IsScenario(nTab+1) && !mpDoc->IsScenario(nTab) )
 600         {
 601             SCTAB i;
 602             ScMarkData aMarks;
 603             for (i=nTab+1; i<nTabCount && mpDoc->IsScenario(i); i++)
 604                 mpDoc->MarkScenario( i, nTab, aMarks, false, SC_SCENARIO_SHOWFRAME );
 605             ScRangeList aRanges;
 606             aMarks.FillRangeListWithMarks( &aRanges, false );
 607             bool bHasScenario;
 608             SCTAB nRangeCount = aRanges.size();
 609             for (i=0; i<nRangeCount; i++)
 610             {
 611                 ScRange aRange = *aRanges[i];
 612                 mpDoc->ExtendTotalMerge( aRange );
 613                 bool bTextBelow = ( aRange.aStart.Row() == 0 );
 614                 // MT IA2: Not used: sal_Bool bIsInScen = sal_False;
 615                 if ( bTextBelow )
 616                 {
 617                     bHasScenario = (aRange.aStart.Col() == nPosX && aRange.aEnd.Row() == nPosY-1);
 618                 }
 619                 else
 620                 {
 621                     bHasScenario = (aRange.aStart.Col() == nPosX && aRange.aStart.Row() == nPosY+1);
 622                 }
 623                 if( bHasScenario ) return true;
 624             }
 625         }
 626     }
 627     return false;
 628 }
 629
 630 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */