sc/source/ui/Accessibility/AccessibleDocument.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 /* Somehow, under same circumstances, MSVC creates object code for 2
  21  * inlined functions. Nobody here uses them, so simply define them away
  22  * so that there be no dupplicate symbols anymore.
  23
  24  * The symbols "extents" and "indices" come from boost::multi_array.
  25  */
  26
  27 #ifdef indices
  28 #undef indices
  29 #endif
  30 #define indices dummy1_indices
  31
  32 #ifdef extents
  33 #undef extents
  34 #endif
  35 #define extents dummy1_extents
  36
  37 #include "AccessibleDocument.hxx"
  38 #include "AccessibleSpreadsheet.hxx"
  39 #include "tabvwsh.hxx"
  40 #include "AccessibilityHints.hxx"
  41 #include "document.hxx"
  42 #include "drwlayer.hxx"
  43 #include "shapeuno.hxx"
  44 #include "DrawModelBroadcaster.hxx"
  45 #include "drawview.hxx"
  46 #include "gridwin.hxx"
  47 #include "AccessibleEditObject.hxx"
  48 #include "userdat.hxx"
  49 #include "scresid.hxx"
  50 #include "sc.hrc"
  51 #include "markdata.hxx"
  52
  53 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  54 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  55 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  56 #include <com/sun/star/view/XSelectionSupplier.hpp>
  57 #include <com/sun/star/drawing/XShape.hpp>
  58 #include <com/sun/star/drawing/XShapes.hpp>
  59
  60 #include <unotools/accessiblestatesethelper.hxx>
  61 #include <tools/gen.hxx>
  62 #include <svx/svdpage.hxx>
  63 #include <svx/svdobj.hxx>
  64 #include <svx/ShapeTypeHandler.hxx>
  65 #include <svx/AccessibleShape.hxx>
  66 #include <svx/AccessibleShapeTreeInfo.hxx>
  67 #include <svx/AccessibleShapeInfo.hxx>
  68 #include <comphelper/sequence.hxx>
  69 #include <comphelper/servicehelper.hxx>
  70 #include <sfx2/viewfrm.hxx>
  71 #include <svx/unoshcol.hxx>
  72 #include <svx/unoshape.hxx>
  73 #include <unotools/accessiblerelationsethelper.hxx>
  74 #include <toolkit/helper/convert.hxx>
  75 #include <vcl/svapp.hxx>
  76
  77 #include <list>
  78 #include <algorithm>
  79
  80 #ifdef indices
  81 #undef indices
  82 #endif
  83
  84 #ifdef extents
  85 #undef extents
  86 #endif
  87
  88 using namespace ::com::sun::star;
  89 using namespace ::com::sun::star::accessibility;
  90 using ::std::for_each;
  91
  92     //=====  internal  ========================================================
  93
  94 struct ScAccessibleShapeData
  95 {
  96     ScAccessibleShapeData() : pAccShape(NULL), pRelationCell(NULL), bSelected(false), bSelectable(sal_True) {}
  97     ~ScAccessibleShapeData();
  98     mutable ::accessibility::AccessibleShape* pAccShape;
  99     mutable ScAddress*          pRelationCell; // if it is NULL this shape is anchored on the table
 100     com::sun::star::uno::Reference< com::sun::star::drawing::XShape > xShape;
 101     mutable sal_Bool            bSelected;
 102     sal_Bool                    bSelectable;
 103 };
 104
 105 ScAccessibleShapeData::~ScAccessibleShapeData()
 106 {
 107     if (pAccShape)
 108     {
 109         pAccShape->dispose();
 110         pAccShape->release();
 111     }
 112 }
 113
 114 struct ScShapeDataLess
 115 {
 116     OUString msLayerId;
 117     OUString msZOrder;
 118     ScShapeDataLess()
 119         : msLayerId( "LayerID" ),
 120         msZOrder( "ZOrder" )
 121     {
 122     }
 123     void ConvertLayerId(sal_Int16& rLayerID) const // changes the number of the LayerId so it the accessibility order
 124     {
 125         switch (rLayerID)
 126         {
 127         case SC_LAYER_FRONT:
 128             rLayerID = 1;
 129             break;
 130         case SC_LAYER_BACK:
 131             rLayerID = 0;
 132             break;
 133         case SC_LAYER_INTERN:
 134             rLayerID = 2;
 135             break;
 136         case SC_LAYER_CONTROLS:
 137             rLayerID = 3;
 138             break;
 139         }
 140     }
 141     sal_Bool LessThanSheet(const ScAccessibleShapeData* pData) const
 142     {
 143         sal_Bool bResult(false);
 144         uno::Reference< beans::XPropertySet> xProps(pData->xShape, uno::UNO_QUERY);
 145         if (xProps.is())
 146         {
 147             uno::Any aPropAny = xProps->getPropertyValue(msLayerId);
 148             sal_Int16 nLayerID = 0;
 149             if( (aPropAny >>= nLayerID) )
 150             {
 151                 if (nLayerID == SC_LAYER_BACK)
 152                     bResult = sal_True;
 153             }
 154         }
 155         return bResult;
 156     }
 157     sal_Bool operator()(const ScAccessibleShapeData* pData1, const ScAccessibleShapeData* pData2) const
 158     {
 159         sal_Bool bResult(false);
 160         if (pData1 && pData2)
 161         {
 162             uno::Reference< beans::XPropertySet> xProps1(pData1->xShape, uno::UNO_QUERY);
 163             uno::Reference< beans::XPropertySet> xProps2(pData2->xShape, uno::UNO_QUERY);
 164             if (xProps1.is() && xProps2.is())
 165             {
 166                 uno::Any aPropAny1 = xProps1->getPropertyValue(msLayerId);
 167                 uno::Any aPropAny2 = xProps2->getPropertyValue(msLayerId);
 168                 sal_Int16 nLayerID1(0);
 169                 sal_Int16 nLayerID2(0);
 170                 if( (aPropAny1 >>= nLayerID1) && (aPropAny2 >>= nLayerID2) )
 171                 {
 172                     if (nLayerID1 == nLayerID2)
 173                     {
 174                         uno::Any aAny1 = xProps1->getPropertyValue(msZOrder);
 175                         sal_Int32 nZOrder1 = 0;
 176                         uno::Any aAny2 = xProps2->getPropertyValue(msZOrder);
 177                         sal_Int32 nZOrder2 = 0;
 178                         if ( (aAny1 >>= nZOrder1) && (aAny2 >>= nZOrder2) )
 179                             bResult = (nZOrder1 < nZOrder2);
 180                     }
 181                     else
 182                     {
 183                         ConvertLayerId(nLayerID1);
 184                         ConvertLayerId(nLayerID2);
 185                         bResult = (nLayerID1 < nLayerID2);
 186                     }
 187                 }
 188             }
 189         }
 190         else if (pData1 && !pData2)
 191             bResult = LessThanSheet(pData1);
 192         else if (!pData1 && pData2)
 193             bResult = !LessThanSheet(pData2);
 194         else
 195             bResult = false;
 196         return bResult;
 197     }
 198 };
 199
 200 struct DeselectShape
 201 {
 202     void operator() (const ScAccessibleShapeData* pAccShapeData) const
 203     {
 204         if (pAccShapeData)
 205         {
 206             pAccShapeData->bSelected = false;
 207             if (pAccShapeData->pAccShape)
 208                 pAccShapeData->pAccShape->ResetState(AccessibleStateType::SELECTED);
 209         }
 210     }
 211 };
 212
 213 struct SelectShape
 214 {
 215     uno::Reference < drawing::XShapes > xShapes;
 216     SelectShape(uno::Reference<drawing::XShapes>& xTemp) : xShapes(xTemp) {}
 217     void operator() (const ScAccessibleShapeData* pAccShapeData) const
 218     {
 219         if (pAccShapeData && pAccShapeData->bSelectable)
 220         {
 221             pAccShapeData->bSelected = sal_True;
 222             if (pAccShapeData->pAccShape)
 223                 pAccShapeData->pAccShape->SetState(AccessibleStateType::SELECTED);
 224             if (xShapes.is())
 225                 xShapes->add(pAccShapeData->xShape);
 226         }
 227     }
 228 };
 229
 230 struct Destroy
 231 {
 232     void operator() (ScAccessibleShapeData* pData)
 233     {
 234         if (pData)
 235             DELETEZ(pData);
 236     }
 237 };
 238
 239 class ScChildrenShapes : public SfxListener,
 240     public ::accessibility::IAccessibleParent
 241 {
 242 public:
 243     ScChildrenShapes(ScAccessibleDocument* pAccessibleDocument, ScTabViewShell* pViewShell, ScSplitPos eSplitPos);
 244     ~ScChildrenShapes();
 245
 246     ///=====  SfxListener  =====================================================
 247
 248     virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint );
 249
 250     ///=====  IAccessibleParent  ===============================================
 251
 252     virtual sal_Bool ReplaceChild (
 253         ::accessibility::AccessibleShape* pCurrentChild,
 254         const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& _rxShape,
 255         const long _nIndex,
 256         const ::accessibility::AccessibleShapeTreeInfo& _rShapeTreeInfo
 257     )   throw (::com::sun::star::uno::RuntimeException);
 258
 259     ///=====  Internal  ========================================================
 260     void SetDrawBroadcaster();
 261
 262     sal_Int32 GetCount() const;
 263     uno::Reference< XAccessible > Get(const ScAccessibleShapeData* pData) const;
 264     uno::Reference< XAccessible > Get(sal_Int32 nIndex) const;
 265     uno::Reference< XAccessible > GetAt(const awt::Point& rPoint) const;
 266
 267     // gets the index of the shape starting on 0 (without the index of the table)
 268     // returns the selected shape
 269     sal_Bool IsSelected(sal_Int32 nIndex,
 270         com::sun::star::uno::Reference<com::sun::star::drawing::XShape>& rShape) const;
 271
 272     sal_Bool SelectionChanged();
 273
 274     void Select(sal_Int32 nIndex);
 275     void DeselectAll(); // deselect also the table
 276     void SelectAll();
 277     sal_Int32 GetSelectedCount() const;
 278     uno::Reference< XAccessible > GetSelected(sal_Int32 nSelectedChildIndex, sal_Bool bTabSelected) const;
 279     void Deselect(sal_Int32 nChildIndex);
 280
 281     SdrPage* GetDrawPage() const;
 282
 283     utl::AccessibleRelationSetHelper* GetRelationSet(const ScAddress* pAddress) const;
 284
 285     void VisAreaChanged() const;
 286 private:
 287     typedef std::vector<ScAccessibleShapeData*> SortedShapes;
 288
 289     mutable SortedShapes maZOrderedShapes; // a null pointer represents the sheet in the correct order
 290
 291     mutable ::accessibility::AccessibleShapeTreeInfo maShapeTreeInfo;
 292     mutable com::sun::star::uno::Reference<com::sun::star::view::XSelectionSupplier> xSelectionSupplier;
 293     mutable sal_uInt32 mnSdrObjCount;
 294     mutable sal_uInt32 mnShapesSelected;
 295     ScTabViewShell* mpViewShell;
 296     ScAccessibleDocument* mpAccessibleDocument;
 297     ScSplitPos meSplitPos;
 298
 299     void FillShapes(std::vector < uno::Reference < drawing::XShape > >& rShapes) const;
 300     sal_Bool FindSelectedShapesChanges(const com::sun::star::uno::Reference<com::sun::star::drawing::XShapes>& xShapes, sal_Bool bCommitChange) const;
 301     void FillSelectionSupplier() const;
 302
 303     ScAddress* GetAnchor(const uno::Reference<drawing::XShape>& xShape) const;
 304     uno::Reference<XAccessibleRelationSet> GetRelationSet(const ScAccessibleShapeData* pData) const;
 305     void CheckWhetherAnchorChanged(const uno::Reference<drawing::XShape>& xShape) const;
 306     void SetAnchor(const uno::Reference<drawing::XShape>& xShape, ScAccessibleShapeData* pData) const;
 307     void AddShape(const uno::Reference<drawing::XShape>& xShape, sal_Bool bCommitChange) const;
 308     void RemoveShape(const uno::Reference<drawing::XShape>& xShape) const;
 309
 310     sal_Bool FindShape(const uno::Reference<drawing::XShape>& xShape, SortedShapes::iterator& rItr) const;
 311
 312     sal_Int8 Compare(const ScAccessibleShapeData* pData1,
 313         const ScAccessibleShapeData* pData2) const;
 314 };
 315
 316 ScChildrenShapes::ScChildrenShapes(ScAccessibleDocument* pAccessibleDocument, ScTabViewShell* pViewShell, ScSplitPos eSplitPos)
 317     :
 318     mnShapesSelected(0),
 319     mpViewShell(pViewShell),
 320     mpAccessibleDocument(pAccessibleDocument),
 321     meSplitPos(eSplitPos)
 322 {
 323     FillSelectionSupplier();
 324     maZOrderedShapes.push_back(NULL); // add an element which represents the table
 325
 326     GetCount(); // fill list with filtered shapes (no internal shapes)
 327
 328     if (mnShapesSelected)
 329     {
 330         //set flag on every selected shape
 331         if (!xSelectionSupplier.is())
 332             throw uno::RuntimeException();
 333
 334         uno::Reference<drawing::XShapes> xShapes(xSelectionSupplier->getSelection(), uno::UNO_QUERY);
 335         if (xShapes.is())
 336             FindSelectedShapesChanges(xShapes, false);
 337     }
 338     if (pViewShell)
 339     {
 340         ScViewData *pViewData = pViewShell->GetViewData();
 341         SfxBroadcaster* pDrawBC = pViewData ? pViewData->GetDocument()->GetDrawBroadcaster() : NULL;
 342         if (pDrawBC)
 343         {
 344             StartListening(*pDrawBC);
 345
 346             maShapeTreeInfo.SetModelBroadcaster( new ScDrawModelBroadcaster(pViewData->GetDocument()->GetDrawLayer()) );
 347             maShapeTreeInfo.SetSdrView(pViewData->GetScDrawView());
 348             maShapeTreeInfo.SetController(NULL);
 349             maShapeTreeInfo.SetWindow(pViewShell->GetWindowByPos(meSplitPos));
 350             maShapeTreeInfo.SetViewForwarder(mpAccessibleDocument);
 351         }
 352     }
 353 }
 354
 355 ScChildrenShapes::~ScChildrenShapes()
 356 {
 357     std::for_each(maZOrderedShapes.begin(), maZOrderedShapes.end(), Destroy());
 358     if (mpViewShell)
 359     {
 360         ScViewData *pViewData = mpViewShell->GetViewData();
 361         SfxBroadcaster* pDrawBC = pViewData ? pViewData->GetDocument()->GetDrawBroadcaster() : NULL;
 362         if (pDrawBC)
 363             EndListening(*pDrawBC);
 364     }
 365 }
 366
 367 void ScChildrenShapes::SetDrawBroadcaster()
 368 {
 369     if (mpViewShell)
 370     {
 371         ScViewData *pViewData = mpViewShell->GetViewData();
 372         SfxBroadcaster* pDrawBC = pViewData ? pViewData->GetDocument()->GetDrawBroadcaster() : NULL;
 373         if (pDrawBC)
 374         {
 375             StartListening(*pDrawBC, sal_True);
 376
 377             maShapeTreeInfo.SetModelBroadcaster( new ScDrawModelBroadcaster(pViewData->GetDocument()->GetDrawLayer()) );
 378             maShapeTreeInfo.SetSdrView(pViewData->GetScDrawView());
 379             maShapeTreeInfo.SetController(NULL);
 380             maShapeTreeInfo.SetWindow(mpViewShell->GetWindowByPos(meSplitPos));
 381             maShapeTreeInfo.SetViewForwarder(mpAccessibleDocument);
 382         }
 383     }
 384 }
 385
 386 void ScChildrenShapes::Notify(SfxBroadcaster&, const SfxHint& rHint)
 387 {
 388     if ( rHint.ISA( SdrHint ) )
 389     {
 390         const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
 391         if (pSdrHint)
 392         {
 393             SdrObject* pObj = const_cast<SdrObject*>(pSdrHint->GetObject());
 394             if (pObj && /*(pObj->GetLayer() != SC_LAYER_INTERN) && */(pObj->GetPage() == GetDrawPage()) &&
 395                 (pObj->GetPage() == pObj->GetObjList()) ) //only do something if the object lies direct on the page
 396             {
 397                 switch (pSdrHint->GetKind())
 398                 {
 399                     case HINT_OBJCHG :         // Objekt geaendert
 400                     {
 401                         uno::Reference<drawing::XShape> xShape (pObj->getUnoShape(), uno::UNO_QUERY);
 402                         if (xShape.is())
 403                         {
 404                             ScShapeDataLess aLess;
 405                             std::sort(maZOrderedShapes.begin(), maZOrderedShapes.end(), aLess); // sort, because the z index or layer could be changed
 406                             CheckWhetherAnchorChanged(xShape);
 407                         }
 408                     }
 409                     break;
 410                     case HINT_OBJINSERTED :    // Neues Zeichenobjekt eingefuegt
 411                     {
 412                         uno::Reference<drawing::XShape> xShape (pObj->getUnoShape(), uno::UNO_QUERY);
 413                         if (xShape.is())
 414                             AddShape(xShape, sal_True);
 415                     }
 416                     break;
 417                     case HINT_OBJREMOVED :     // Zeichenobjekt aus Liste entfernt
 418                     {
 419                         uno::Reference<drawing::XShape> xShape (pObj->getUnoShape(), uno::UNO_QUERY);
 420                         if (xShape.is())
 421                             RemoveShape(xShape);
 422                     }
 423                     break;
 424                     default :
 425                     {
 426                         // other events are not interesting
 427                     }
 428                     break;
 429                 }
 430             }
 431         }
 432     }
 433 }
 434
 435 sal_Bool ScChildrenShapes::ReplaceChild (::accessibility::AccessibleShape* pCurrentChild,
 436         const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& _rxShape,
 437         const long _nIndex, const ::accessibility::AccessibleShapeTreeInfo& _rShapeTreeInfo)
 438     throw (uno::RuntimeException)
 439 {
 440     // create the new child
 441     ::accessibility::AccessibleShape* pReplacement = ::accessibility::ShapeTypeHandler::Instance().CreateAccessibleObject (
 442         ::accessibility::AccessibleShapeInfo ( _rxShape, pCurrentChild->getAccessibleParent(), this, _nIndex ),
 443         _rShapeTreeInfo
 444     );
 445     ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xNewChild( pReplacement ); // keep this alive (do this before calling Init!)
 446     if ( pReplacement )
 447         pReplacement->Init();
 448
 449     sal_Bool bResult(false);
 450     if (pCurrentChild && pReplacement)
 451     {
 452         OSL_ENSURE(pCurrentChild->GetXShape().get() == pReplacement->GetXShape().get(), "XShape changes and should be inserted sorted");
 453         SortedShapes::iterator aItr;
 454         FindShape(pCurrentChild->GetXShape(), aItr);
 455         if (aItr != maZOrderedShapes.end() && (*aItr))
 456         {
 457             if ((*aItr)->pAccShape)
 458             {
 459                 OSL_ENSURE((*aItr)->pAccShape == pCurrentChild, "wrong child found");
 460                 AccessibleEventObject aEvent;
 461                 aEvent.EventId = AccessibleEventId::CHILD;
 462                 aEvent.Source = uno::Reference< XAccessibleContext >(mpAccessibleDocument);
 463                 aEvent.OldValue <<= uno::makeAny(uno::Reference<XAccessible>(pCurrentChild));
 464
 465                 mpAccessibleDocument->CommitChange(aEvent); // child is gone - event
 466
 467                 pCurrentChild->dispose();
 468             }
 469             (*aItr)->pAccShape = pReplacement;
 470             AccessibleEventObject aEvent;
 471             aEvent.EventId = AccessibleEventId::CHILD;
 472             aEvent.Source = uno::Reference< XAccessibleContext >(mpAccessibleDocument);
 473             aEvent.NewValue <<= uno::makeAny(uno::Reference<XAccessible>(pReplacement));
 474
 475             mpAccessibleDocument->CommitChange(aEvent); // child is new - event
 476             bResult = sal_True;
 477         }
 478     }
 479     return bResult;
 480 }
 481
 482 sal_Int32 ScChildrenShapes::GetCount() const
 483 {
 484     SdrPage* pDrawPage = GetDrawPage();
 485     if (pDrawPage && (maZOrderedShapes.size() == 1)) // the table is always in
 486     {
 487         mnSdrObjCount = pDrawPage->GetObjCount();
 488         maZOrderedShapes.reserve(mnSdrObjCount + 1); // the table is always in
 489         for (sal_uInt32 i = 0; i < mnSdrObjCount; ++i)
 490         {
 491             SdrObject* pObj = pDrawPage->GetObj(i);
 492             if (pObj/* && (pObj->GetLayer() != SC_LAYER_INTERN)*/)
 493             {
 494                 uno::Reference< drawing::XShape > xShape (pObj->getUnoShape(), uno::UNO_QUERY);
 495                 AddShape(xShape, false); //inserts in the correct order
 496             }
 497         }
 498     }
 499     return maZOrderedShapes.size();
 500 }
 501
 502 uno::Reference< XAccessible > ScChildrenShapes::Get(const ScAccessibleShapeData* pData) const
 503 {
 504     if (!pData)
 505         return NULL;
 506
 507     if (!pData->pAccShape)
 508     {
 509         ::accessibility::ShapeTypeHandler& rShapeHandler = ::accessibility::ShapeTypeHandler::Instance();
 510         ::accessibility::AccessibleShapeInfo aShapeInfo(pData->xShape, mpAccessibleDocument, const_cast<ScChildrenShapes*>(this));
 511         pData->pAccShape = rShapeHandler.CreateAccessibleObject(
 512             aShapeInfo, maShapeTreeInfo);
 513         if (pData->pAccShape)
 514         {
 515             pData->pAccShape->acquire();
 516             pData->pAccShape->Init();
 517             if (pData->bSelected)
 518                 pData->pAccShape->SetState(AccessibleStateType::SELECTED);
 519             if (!pData->bSelectable)
 520                 pData->pAccShape->ResetState(AccessibleStateType::SELECTABLE);
 521             pData->pAccShape->SetRelationSet(GetRelationSet(pData));
 522         }
 523     }
 524     return pData->pAccShape;
 525  }
 526
 527 uno::Reference< XAccessible > ScChildrenShapes::Get(sal_Int32 nIndex) const
 528 {
 529     if (maZOrderedShapes.size() <= 1)
 530         GetCount(); // fill list with filtered shapes (no internal shapes)
 531
 532     if (static_cast<sal_uInt32>(nIndex) >= maZOrderedShapes.size())
 533         return NULL;
 534
 535     return Get(maZOrderedShapes[nIndex]);
 536 }
 537
 538 uno::Reference< XAccessible > ScChildrenShapes::GetAt(const awt::Point& rPoint) const
 539 {
 540     uno::Reference<XAccessible> xAccessible;
 541     if(mpViewShell)
 542     {
 543         sal_Int32 i(maZOrderedShapes.size() - 1);
 544         sal_Bool bFound(false);
 545         while (!bFound && i >= 0)
 546         {
 547             ScAccessibleShapeData* pShape = maZOrderedShapes[i];
 548             if (pShape)
 549             {
 550                 if (!pShape->pAccShape)
 551                     Get(pShape);
 552
 553                 if (pShape->pAccShape)
 554                 {
 555                     Point aPoint(VCLPoint(rPoint));
 556                     aPoint -= VCLRectangle(pShape->pAccShape->getBounds()).TopLeft();
 557                     if (pShape->pAccShape->containsPoint(AWTPoint(aPoint)))
 558                     {
 559                         xAccessible = pShape->pAccShape;
 560                         bFound = sal_True;
 561                     }
 562                 }
 563                 else
 564                 {
 565                     OSL_FAIL("I should have an accessible shape now!");
 566                 }
 567             }
 568             else
 569                 bFound = sal_True; // this is the sheet and it lies before the rest of the shapes which are background shapes
 570
 571             --i;
 572         }
 573     }
 574     return xAccessible;
 575 }
 576
 577 sal_Bool ScChildrenShapes::IsSelected(sal_Int32 nIndex,
 578                         uno::Reference<drawing::XShape>& rShape) const
 579 {
 580     sal_Bool bResult (false);
 581     if (maZOrderedShapes.size() <= 1)
 582         GetCount(); // fill list with filtered shapes (no internal shapes)
 583
 584     if (!xSelectionSupplier.is())
 585         throw uno::RuntimeException();
 586
 587     if (!maZOrderedShapes[nIndex])
 588         return false;
 589
 590     bResult = maZOrderedShapes[nIndex]->bSelected;
 591     rShape = maZOrderedShapes[nIndex]->xShape;
 592
 593 #if OSL_DEBUG_LEVEL > 0 // test whether it is truly selected by a slower method
 594     uno::Reference< drawing::XShape > xReturnShape;
 595     sal_Bool bDebugResult(false);
 596     uno::Reference<container::XIndexAccess> xIndexAccess;
 597     xSelectionSupplier->getSelection() >>= xIndexAccess;
 598
 599     if (xIndexAccess.is())
 600     {
 601         sal_Int32 nCount(xIndexAccess->getCount());
 602         if (nCount)
 603         {
 604             uno::Reference< drawing::XShape > xShape;
 605             uno::Reference< drawing::XShape > xIndexShape = maZOrderedShapes[nIndex]->xShape;
 606             sal_Int32 i(0);
 607             while (!bDebugResult && (i < nCount))
 608             {
 609                 xIndexAccess->getByIndex(i) >>= xShape;
 610                 if (xShape.is() && (xIndexShape.get() == xShape.get()))
 611                 {
 612                     bDebugResult = sal_True;
 613                     xReturnShape = xShape;
 614                 }
 615                 else
 616                     ++i;
 617             }
 618         }
 619     }
 620     OSL_ENSURE((bResult == bDebugResult) && ((bResult && (rShape.get() == xReturnShape.get())) || !bResult), "found the wrong shape or result");
 621 #endif
 622
 623     return bResult;
 624 }
 625
 626 sal_Bool ScChildrenShapes::SelectionChanged()
 627 {
 628     sal_Bool bResult(false);
 629     if (!xSelectionSupplier.is())
 630         throw uno::RuntimeException();
 631
 632     uno::Reference<drawing::XShapes> xShapes(xSelectionSupplier->getSelection(), uno::UNO_QUERY);
 633
 634     bResult = FindSelectedShapesChanges(xShapes, sal_True);
 635
 636     return bResult;
 637 }
 638
 639 void ScChildrenShapes::Select(sal_Int32 nIndex)
 640 {
 641     if (maZOrderedShapes.size() <= 1)
 642         GetCount(); // fill list with filtered shapes (no internal shapes)
 643
 644     if (!xSelectionSupplier.is())
 645         throw uno::RuntimeException();
 646
 647     if (!maZOrderedShapes[nIndex])
 648         return;
 649
 650     uno::Reference<drawing::XShape> xShape;
 651     if (!IsSelected(nIndex, xShape) && maZOrderedShapes[nIndex]->bSelectable)
 652     {
 653         uno::Reference<drawing::XShapes> xShapes;
 654         xSelectionSupplier->getSelection() >>= xShapes;
 655
 656         if (!xShapes.is())
 657             xShapes = new SvxShapeCollection();
 658
 659         xShapes->add(maZOrderedShapes[nIndex]->xShape);
 660
 661         try
 662         {
 663             xSelectionSupplier->select(uno::makeAny(xShapes));
 664             maZOrderedShapes[nIndex]->bSelected = sal_True;
 665             if (maZOrderedShapes[nIndex]->pAccShape)
 666                 maZOrderedShapes[nIndex]->pAccShape->SetState(AccessibleStateType::SELECTED);
 667         }
 668         catch (lang::IllegalArgumentException&)
 669         {
 670         }
 671     }
 672 }
 673
 674 void ScChildrenShapes::DeselectAll()
 675 {
 676     if (!xSelectionSupplier.is())
 677         throw uno::RuntimeException();
 678
 679     sal_Bool bSomethingSelected(sal_True);
 680     try
 681     {
 682         xSelectionSupplier->select(uno::Any()); //deselects all
 683     }
 684     catch (lang::IllegalArgumentException&)
 685     {
 686         OSL_FAIL("nothing selected before");
 687         bSomethingSelected = false;
 688     }
 689
 690     if (bSomethingSelected)
 691         std::for_each(maZOrderedShapes.begin(), maZOrderedShapes.end(), DeselectShape());
 692 }
 693
 694 void ScChildrenShapes::SelectAll()
 695 {
 696     if (!xSelectionSupplier.is())
 697         throw uno::RuntimeException();
 698
 699     if (maZOrderedShapes.size() <= 1)
 700         GetCount(); // fill list with filtered shapes (no internal shapes)
 701
 702     if (maZOrderedShapes.size() > 1)
 703     {
 704         uno::Reference<drawing::XShapes> xShapes;
 705         xShapes = new SvxShapeCollection();
 706
 707         try
 708         {
 709             std::for_each(maZOrderedShapes.begin(), maZOrderedShapes.end(), SelectShape(xShapes));
 710             xSelectionSupplier->select(uno::makeAny(xShapes));
 711         }
 712         catch (lang::IllegalArgumentException&)
 713         {
 714             SelectionChanged(); // find all selected shapes and set the flags
 715         }
 716     }
 717 }
 718
 719 void ScChildrenShapes::FillShapes(std::vector < uno::Reference < drawing::XShape > >& rShapes) const
 720 {
 721     uno::Reference<container::XIndexAccess> xIndexAccess;
 722     xSelectionSupplier->getSelection() >>= xIndexAccess;
 723
 724     if (xIndexAccess.is())
 725     {
 726         sal_uInt32 nCount(xIndexAccess->getCount());
 727         for (sal_uInt32 i = 0; i < nCount; ++i)
 728         {
 729             uno::Reference<drawing::XShape> xShape;
 730             xIndexAccess->getByIndex(i) >>= xShape;
 731             if (xShape.is())
 732                 rShapes.push_back(xShape);
 733         }
 734     }
 735 }
 736
 737 sal_Int32 ScChildrenShapes::GetSelectedCount() const
 738 {
 739     if (!xSelectionSupplier.is())
 740         throw uno::RuntimeException();
 741
 742     std::vector < uno::Reference < drawing::XShape > > aShapes;
 743     FillShapes(aShapes);
 744
 745     return aShapes.size();
 746 }
 747
 748 uno::Reference< XAccessible > ScChildrenShapes::GetSelected(sal_Int32 nSelectedChildIndex, sal_Bool bTabSelected) const
 749 {
 750     uno::Reference< XAccessible > xAccessible;
 751
 752     if (maZOrderedShapes.size() <= 1)
 753         GetCount(); // fill list with shapes
 754
 755     if (!bTabSelected)
 756     {
 757         std::vector < uno::Reference < drawing::XShape > > aShapes;
 758         FillShapes(aShapes);
 759
 760         SortedShapes::iterator aItr;
 761         if (FindShape(aShapes[nSelectedChildIndex], aItr))
 762             xAccessible = Get(aItr - maZOrderedShapes.begin());
 763     }
 764     else
 765     {
 766         SortedShapes::iterator aItr = maZOrderedShapes.begin();
 767         SortedShapes::iterator aEndItr = maZOrderedShapes.end();
 768         sal_Bool bFound(false);
 769         while(!bFound && aItr != aEndItr)
 770         {
 771             if (*aItr)
 772             {
 773                 if ((*aItr)->bSelected)
 774                 {
 775                     if (nSelectedChildIndex == 0)
 776                         bFound = sal_True;
 777                     else
 778                         --nSelectedChildIndex;
 779                 }
 780             }
 781             else
 782             {
 783                 if (nSelectedChildIndex == 0)
 784                     bFound = sal_True;
 785                 else
 786                     --nSelectedChildIndex;
 787             }
 788             if (!bFound)
 789                 ++aItr;
 790         }
 791         if (bFound && *aItr)
 792             xAccessible = (*aItr)->pAccShape;
 793     }
 794
 795     return xAccessible;
 796 }
 797
 798 void ScChildrenShapes::Deselect(sal_Int32 nChildIndex)
 799 {
 800     uno::Reference<drawing::XShape> xShape;
 801     if (IsSelected(nChildIndex, xShape)) // returns false if it is the sheet
 802     {
 803         if (xShape.is())
 804         {
 805             uno::Reference<drawing::XShapes> xShapes;
 806             xSelectionSupplier->getSelection() >>= xShapes;
 807             if (xShapes.is())
 808                 xShapes->remove(xShape);
 809
 810             try
 811             {
 812                 xSelectionSupplier->select(uno::makeAny(xShapes));
 813             }
 814             catch (lang::IllegalArgumentException&)
 815             {
 816                 OSL_FAIL("something not selectable");
 817             }
 818
 819             maZOrderedShapes[nChildIndex]->bSelected = false;
 820             if (maZOrderedShapes[nChildIndex]->pAccShape)
 821                 maZOrderedShapes[nChildIndex]->pAccShape->ResetState(AccessibleStateType::SELECTED);
 822         }
 823     }
 824 }
 825
 826
 827 SdrPage* ScChildrenShapes::GetDrawPage() const
 828 {
 829     SCTAB nTab(mpAccessibleDocument->getVisibleTable());
 830     SdrPage* pDrawPage = NULL;
 831     if (mpViewShell)
 832     {
 833         ScViewData *pViewData = mpViewShell->GetViewData();
 834         ScDocument* pDoc = pViewData ? pViewData->GetDocument() : NULL;
 835         if (pDoc && pDoc->GetDrawLayer())
 836         {
 837             ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
 838             if (pDrawLayer->HasObjects() && (pDrawLayer->GetPageCount() > nTab))
 839                 pDrawPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(static_cast<sal_Int16>(nTab)));
 840         }
 841     }
 842     return pDrawPage;
 843 }
 844
 845 struct SetRelation
 846 {
 847     const ScChildrenShapes* mpChildrenShapes;
 848     mutable utl::AccessibleRelationSetHelper* mpRelationSet;
 849     const ScAddress* mpAddress;
 850     SetRelation(const ScChildrenShapes* pChildrenShapes, const ScAddress* pAddress)
 851         :
 852         mpChildrenShapes(pChildrenShapes),
 853         mpRelationSet(NULL),
 854         mpAddress(pAddress)
 855     {
 856     }
 857     void operator() (const ScAccessibleShapeData* pAccShapeData) const
 858     {
 859         if (pAccShapeData &&
 860             ((!pAccShapeData->pRelationCell && !mpAddress) ||
 861             (pAccShapeData->pRelationCell && mpAddress && (*(pAccShapeData->pRelationCell) == *mpAddress))))
 862         {
 863             if (!mpRelationSet)
 864                 mpRelationSet = new utl::AccessibleRelationSetHelper();
 865
 866             AccessibleRelation aRelation;
 867             aRelation.TargetSet.realloc(1);
 868             aRelation.TargetSet[0] = mpChildrenShapes->Get(pAccShapeData);
 869             aRelation.RelationType = AccessibleRelationType::CONTROLLER_FOR;
 870
 871             mpRelationSet->AddRelation(aRelation);
 872         }
 873     }
 874 };
 875
 876 utl::AccessibleRelationSetHelper* ScChildrenShapes::GetRelationSet(const ScAddress* pAddress) const
 877 {
 878     SetRelation aSetRelation(this, pAddress);
 879     ::std::for_each(maZOrderedShapes.begin(), maZOrderedShapes.end(), aSetRelation);
 880     return aSetRelation.mpRelationSet;
 881 }
 882
 883 sal_Bool ScChildrenShapes::FindSelectedShapesChanges(const uno::Reference<drawing::XShapes>& xShapes, sal_Bool /* bCommitChange */) const
 884 {
 885     sal_Bool bResult(false);
 886     SortedShapes aShapesList;
 887     uno::Reference<container::XIndexAccess> xIndexAcc(xShapes, uno::UNO_QUERY);
 888     if (xIndexAcc.is())
 889     {
 890         mnShapesSelected = xIndexAcc->getCount();
 891         for (sal_uInt32 i = 0; i < mnShapesSelected; ++i)
 892         {
 893             uno::Reference< drawing::XShape > xShape;
 894             xIndexAcc->getByIndex(i) >>= xShape;
 895             if (xShape.is())
 896             {
 897                 ScAccessibleShapeData* pShapeData = new ScAccessibleShapeData();
 898                 pShapeData->xShape = xShape;
 899                 aShapesList.push_back(pShapeData);
 900             }
 901         }
 902     }
 903     else
 904         mnShapesSelected = 0;
 905     ScShapeDataLess aLess;
 906     std::sort(aShapesList.begin(), aShapesList.end(), aLess);
 907
 908     SortedShapes::iterator aXShapesItr(aShapesList.begin());
 909     SortedShapes::const_iterator aXShapesEndItr(aShapesList.end());
 910     SortedShapes::iterator aDataItr(maZOrderedShapes.begin());
 911     SortedShapes::const_iterator aDataEndItr(maZOrderedShapes.end());
 912     SortedShapes::const_iterator aFocusedItr = aDataEndItr;
 913     while((aDataItr != aDataEndItr))
 914     {
 915         if (*aDataItr) // is it realy a shape or only the sheet
 916         {
 917             sal_Int8 nComp(0);
 918             if (aXShapesItr == aXShapesEndItr)
 919                 nComp = -1; // simulate that the Shape is lower, so the selction state will be removed
 920             else
 921                 nComp = Compare(*aDataItr, *aXShapesItr);
 922             if (nComp == 0)
 923             {
 924                 if (!(*aDataItr)->bSelected)
 925                 {
 926                     (*aDataItr)->bSelected = sal_True;
 927                     if ((*aDataItr)->pAccShape)
 928                     {
 929                         (*aDataItr)->pAccShape->SetState(AccessibleStateType::SELECTED);
 930                         (*aDataItr)->pAccShape->ResetState(AccessibleStateType::FOCUSED);
 931                         bResult = sal_True;
 932                     }
 933                     aFocusedItr = aDataItr;
 934                 }
 935                 ++aDataItr;
 936                 ++aXShapesItr;
 937             }
 938             else if (nComp < 0)
 939             {
 940                 if ((*aDataItr)->bSelected)
 941                 {
 942                     (*aDataItr)->bSelected = false;
 943                     if ((*aDataItr)->pAccShape)
 944                     {
 945                         (*aDataItr)->pAccShape->ResetState(AccessibleStateType::SELECTED);
 946                         (*aDataItr)->pAccShape->ResetState(AccessibleStateType::FOCUSED);
 947                         bResult = sal_True;
 948                     }
 949                 }
 950                 ++aDataItr;
 951             }
 952             else
 953             {
 954                 OSL_FAIL("here is a selected shape which is not in the childlist");
 955                 ++aXShapesItr;
 956                 --mnShapesSelected;
 957             }
 958         }
 959         else
 960             ++aDataItr;
 961     }
 962     if ((aFocusedItr != aDataEndItr) && (*aFocusedItr)->pAccShape && (mnShapesSelected == 1))
 963         (*aFocusedItr)->pAccShape->SetState(AccessibleStateType::FOCUSED);
 964
 965     std::for_each(aShapesList.begin(), aShapesList.end(), Destroy());
 966
 967     return bResult;
 968 }
 969
 970 void ScChildrenShapes::FillSelectionSupplier() const
 971 {
 972     if (!xSelectionSupplier.is() && mpViewShell)
 973     {
 974         SfxViewFrame* pViewFrame = mpViewShell->GetViewFrame();
 975         if (pViewFrame)
 976         {
 977             xSelectionSupplier = uno::Reference<view::XSelectionSupplier>(pViewFrame->GetFrame().GetController(), uno::UNO_QUERY);
 978             if (xSelectionSupplier.is())
 979             {
 980                 if (mpAccessibleDocument)
 981                     xSelectionSupplier->addSelectionChangeListener(mpAccessibleDocument);
 982                 uno::Reference<drawing::XShapes> xShapes (xSelectionSupplier->getSelection(), uno::UNO_QUERY);
 983                 if (xShapes.is())
 984                     mnShapesSelected = xShapes->getCount();
 985             }
 986         }
 987     }
 988 }
 989
 990 ScAddress* ScChildrenShapes::GetAnchor(const uno::Reference<drawing::XShape>& xShape) const
 991 {
 992     ScAddress* pAddress = NULL;
 993     if (mpViewShell)
 994     {
 995         SvxShape* pShapeImp = SvxShape::getImplementation(xShape);
 996         uno::Reference<beans::XPropertySet> xShapeProp(xShape, uno::UNO_QUERY);
 997         if (pShapeImp && xShapeProp.is())
 998         {
 999             if (SdrObject *pSdrObj = pShapeImp->GetSdrObject())
1000             {
1001                 if (ScDrawObjData *pAnchor = ScDrawLayer::GetObjData(pSdrObj))
1002                     return new ScAddress(pAnchor->maStart);
1003             }
1004         }
1005     }
1006
1007     return pAddress;
1008 }
1009
1010 uno::Reference<XAccessibleRelationSet> ScChildrenShapes::GetRelationSet(const ScAccessibleShapeData* pData) const
1011 {
1012     utl::AccessibleRelationSetHelper* pRelationSet = new utl::AccessibleRelationSetHelper();
1013
1014     if(pData && pRelationSet && mpAccessibleDocument)
1015     {
1016         uno::Reference<XAccessible> xAccessible = mpAccessibleDocument->GetAccessibleSpreadsheet(); // should be the current table
1017         if (pData->pRelationCell && xAccessible.is())
1018         {
1019             uno::Reference<XAccessibleTable> xAccTable (xAccessible->getAccessibleContext(), uno::UNO_QUERY);
1020             if (xAccTable.is())
1021                 xAccessible = xAccTable->getAccessibleCellAt(pData->pRelationCell->Row(), pData->pRelationCell->Col());
1022         }
1023         AccessibleRelation aRelation;
1024         aRelation.TargetSet.realloc(1);
1025         aRelation.TargetSet[0] = xAccessible;
1026         aRelation.RelationType = AccessibleRelationType::CONTROLLED_BY;
1027         pRelationSet->AddRelation(aRelation);
1028     }
1029
1030     return pRelationSet;
1031 }
1032
1033 void ScChildrenShapes::CheckWhetherAnchorChanged(const uno::Reference<drawing::XShape>& xShape) const
1034 {
1035     SortedShapes::iterator aItr;
1036     if (FindShape(xShape, aItr))
1037         SetAnchor(xShape, *aItr);
1038 }
1039
1040 void ScChildrenShapes::SetAnchor(const uno::Reference<drawing::XShape>& xShape, ScAccessibleShapeData* pData) const
1041 {
1042     if (pData)
1043     {
1044         ScAddress* pAddress = GetAnchor(xShape);
1045         if ((pAddress && pData->pRelationCell && (*pAddress != *(pData->pRelationCell))) ||
1046             (!pAddress && pData->pRelationCell) || (pAddress && !pData->pRelationCell))
1047         {
1048             if (pData->pRelationCell)
1049                 delete pData->pRelationCell;
1050             pData->pRelationCell = pAddress;
1051             if (pData->pAccShape)
1052                 pData->pAccShape->SetRelationSet(GetRelationSet(pData));
1053         }
1054         else
1055             delete pAddress;
1056     }
1057 }
1058
1059 void ScChildrenShapes::AddShape(const uno::Reference<drawing::XShape>& xShape, sal_Bool bCommitChange) const
1060 {
1061     SortedShapes::iterator aFindItr;
1062     if (!FindShape(xShape, aFindItr))
1063     {
1064         ScAccessibleShapeData* pShape = new ScAccessibleShapeData();
1065         pShape->xShape = xShape;
1066         SortedShapes::iterator aNewItr = maZOrderedShapes.insert(aFindItr, pShape);
1067         SetAnchor(xShape, pShape);
1068
1069         uno::Reference< beans::XPropertySet > xShapeProp(xShape, uno::UNO_QUERY);
1070         if (xShapeProp.is())
1071         {
1072             uno::Any aPropAny = xShapeProp->getPropertyValue(OUString(  "LayerID" ));
1073             sal_Int16 nLayerID = 0;
1074             if( aPropAny >>= nLayerID )
1075             {
1076                 if( (nLayerID == SC_LAYER_INTERN) || (nLayerID == SC_LAYER_HIDDEN) )
1077                     pShape->bSelectable = false;
1078                 else
1079                     pShape->bSelectable = sal_True;
1080             }
1081         }
1082
1083
1084         if (!xSelectionSupplier.is())
1085             throw uno::RuntimeException();
1086
1087         uno::Reference<container::XEnumerationAccess> xEnumAcc(xSelectionSupplier->getSelection(), uno::UNO_QUERY);
1088         if (xEnumAcc.is())
1089         {
1090             uno::Reference<container::XEnumeration> xEnum = xEnumAcc->createEnumeration();
1091             if (xEnum.is())
1092             {
1093                 uno::Reference<drawing::XShape> xSelectedShape;
1094                 sal_Bool bFound(false);
1095                 while (!bFound && xEnum->hasMoreElements())
1096                 {
1097                     xEnum->nextElement() >>= xSelectedShape;
1098                     if (xShape.is() && (xShape.get() == xSelectedShape.get()))
1099                     {
1100                         pShape->bSelected = sal_True;
1101                         bFound = sal_True;
1102                     }
1103                 }
1104             }
1105         }
1106         if (mpAccessibleDocument && bCommitChange)
1107         {
1108             AccessibleEventObject aEvent;
1109             aEvent.EventId = AccessibleEventId::CHILD;
1110             aEvent.Source = uno::Reference< XAccessibleContext >(mpAccessibleDocument);
1111             aEvent.NewValue <<= Get(aNewItr - maZOrderedShapes.begin());
1112
1113             mpAccessibleDocument->CommitChange(aEvent); // new child - event
1114         }
1115     }
1116     else
1117     {
1118         OSL_FAIL("shape is always in the list");
1119     }
1120 }
1121
1122 void ScChildrenShapes::RemoveShape(const uno::Reference<drawing::XShape>& xShape) const
1123 {
1124     SortedShapes::iterator aItr;
1125     if (FindShape(xShape, aItr))
1126     {
1127         if (mpAccessibleDocument)
1128         {
1129             uno::Reference<XAccessible> xOldAccessible (Get(aItr - maZOrderedShapes.begin()));
1130
1131             delete *aItr;
1132             maZOrderedShapes.erase(aItr);
1133
1134             AccessibleEventObject aEvent;
1135             aEvent.EventId = AccessibleEventId::CHILD;
1136             aEvent.Source = uno::Reference< XAccessibleContext >(mpAccessibleDocument);
1137             aEvent.OldValue <<= uno::makeAny(xOldAccessible);
1138
1139             mpAccessibleDocument->CommitChange(aEvent); // child is gone - event
1140         }
1141         else
1142         {
1143             delete *aItr;
1144             maZOrderedShapes.erase(aItr);
1145         }
1146     }
1147     else
1148     {
1149         OSL_FAIL("shape was not in internal list");
1150     }
1151 }
1152
1153 sal_Bool ScChildrenShapes::FindShape(const uno::Reference<drawing::XShape>& xShape, ScChildrenShapes::SortedShapes::iterator& rItr) const
1154 {
1155     sal_Bool bResult(false);
1156     ScAccessibleShapeData aShape;
1157     aShape.xShape = xShape;
1158     ScShapeDataLess aLess;
1159     rItr = std::lower_bound(maZOrderedShapes.begin(), maZOrderedShapes.end(), &aShape, aLess);
1160     if ((rItr != maZOrderedShapes.end()) && (*rItr != NULL) && ((*rItr)->xShape.get() == xShape.get()))
1161         bResult = sal_True; // if the shape is found
1162
1163 #if OSL_DEBUG_LEVEL > 0 // test whether it finds truly the correct shape (perhaps it is not really sorted)
1164     SortedShapes::iterator aDebugItr = maZOrderedShapes.begin();
1165     SortedShapes::iterator aEndItr = maZOrderedShapes.end();
1166     sal_Bool bFound(false);
1167     while (!bFound && aDebugItr != aEndItr)
1168     {
1169         if (*aDebugItr && ((*aDebugItr)->xShape.get() == xShape.get()))
1170             bFound = sal_True;
1171         else
1172             ++aDebugItr;
1173     }
1174     sal_Bool bResult2 = (aDebugItr != maZOrderedShapes.end());
1175     OSL_ENSURE((bResult == bResult2) && ((bResult && (rItr == aDebugItr)) || !bResult), "wrong Shape found");
1176 #endif
1177     return bResult;
1178 }
1179
1180 sal_Int8 ScChildrenShapes::Compare(const ScAccessibleShapeData* pData1,
1181         const ScAccessibleShapeData* pData2) const
1182 {
1183     ScShapeDataLess aLess;
1184
1185     sal_Bool bResult1(aLess(pData1, pData2));
1186     sal_Bool bResult2(aLess(pData2, pData1));
1187
1188     sal_Int8 nResult(0);
1189     if (!bResult1 && bResult2)
1190         nResult = 1;
1191     else if (bResult1 && !bResult2)
1192         nResult = -1;
1193
1194     return nResult;
1195 }
1196
1197 struct ScVisAreaChanged
1198 {
1199     ScAccessibleDocument* mpAccDoc;
1200     ScVisAreaChanged(ScAccessibleDocument* pAccDoc) : mpAccDoc(pAccDoc) {}
1201     void operator() (const ScAccessibleShapeData* pAccShapeData) const
1202     {
1203         if (pAccShapeData && pAccShapeData->pAccShape)
1204         {
1205             pAccShapeData->pAccShape->ViewForwarderChanged(::accessibility::IAccessibleViewForwarderListener::VISIBLE_AREA, mpAccDoc);
1206         }
1207     }
1208 };
1209
1210 void ScChildrenShapes::VisAreaChanged() const
1211 {
1212     ScVisAreaChanged aVisAreaChanged(mpAccessibleDocument);
1213     std::for_each(maZOrderedShapes.begin(), maZOrderedShapes.end(), aVisAreaChanged);
1214 }
1215
1216 // ============================================================================
1217
1218 ScAccessibleDocument::ScAccessibleDocument(
1219         const uno::Reference<XAccessible>& rxParent,
1220         ScTabViewShell* pViewShell,
1221         ScSplitPos eSplitPos)
1222     : ScAccessibleDocumentBase(rxParent),
1223     mpViewShell(pViewShell),
1224     meSplitPos(eSplitPos),
1225     mpAccessibleSpreadsheet(NULL),
1226     mpChildrenShapes(NULL),
1227     mpTempAccEdit(NULL),
1228     mbCompleteSheetSelected(false)
1229 {
1230     if (pViewShell)
1231     {
1232         pViewShell->AddAccessibilityObject(*this);
1233         Window *pWin = pViewShell->GetWindowByPos(eSplitPos);
1234         if( pWin )
1235         {
1236             pWin->AddChildEventListener( LINK( this, ScAccessibleDocument, WindowChildEventListener ));
1237             sal_uInt16 nCount =   pWin->GetChildCount();
1238             for( sal_uInt16 i=0; i < nCount; ++i )
1239             {
1240                 Window *pChildWin = pWin->GetChild( i );
1241                 if( pChildWin &&
1242                     AccessibleRole::EMBEDDED_OBJECT == pChildWin->GetAccessibleRole() )
1243                     AddChild( pChildWin->GetAccessible(), false );
1244             }
1245         }
1246         ScViewData *pViewData = pViewShell->GetViewData();
1247         if (pViewData && pViewData->HasEditView(eSplitPos))
1248         {
1249             uno::Reference<XAccessible> xAcc = new ScAccessibleEditObject(this, pViewData->GetEditView(eSplitPos),
1250                 pViewShell->GetWindowByPos(eSplitPos), GetCurrentCellName(), GetCurrentCellDescription(),
1251                 ScAccessibleEditObject::CellInEditMode);
1252             AddChild(xAcc, false);
1253         }
1254     }
1255     maVisArea = GetVisibleArea_Impl();
1256 }
1257
1258 void ScAccessibleDocument::Init()
1259 {
1260     if(!mpChildrenShapes)
1261         mpChildrenShapes = new ScChildrenShapes(this, mpViewShell, meSplitPos);
1262 }
1263
1264 ScAccessibleDocument::~ScAccessibleDocument(void)
1265 {
1266     if (!ScAccessibleContextBase::IsDefunc() && !rBHelper.bInDispose)
1267     {
1268         // increment refcount to prevent double call off dtor
1269         osl_atomic_increment( &m_refCount );
1270         dispose();
1271     }
1272 }
1273
1274 void SAL_CALL ScAccessibleDocument::disposing()
1275 {
1276     SolarMutexGuard aGuard;
1277     FreeAccessibleSpreadsheet();
1278     if (mpViewShell)
1279     {
1280         Window *pWin = mpViewShell->GetWindowByPos(meSplitPos);
1281         if( pWin )
1282             pWin->RemoveChildEventListener( LINK( this, ScAccessibleDocument, WindowChildEventListener ));
1283
1284         mpViewShell->RemoveAccessibilityObject(*this);
1285         mpViewShell = NULL;
1286     }
1287     if (mpChildrenShapes)
1288         DELETEZ(mpChildrenShapes);
1289
1290     ScAccessibleDocumentBase::disposing();
1291 }
1292
1293 void SAL_CALL ScAccessibleDocument::disposing( const lang::EventObject& /* Source */ )
1294         throw (uno::RuntimeException)
1295 {
1296     disposing();
1297 }
1298
1299     //=====  SfxListener  =====================================================
1300
1301 IMPL_LINK( ScAccessibleDocument, WindowChildEventListener, VclSimpleEvent*, pEvent )
1302 {
1303     OSL_ENSURE( pEvent && pEvent->ISA( VclWindowEvent ), "Unknown WindowEvent!" );
1304     if ( pEvent && pEvent->ISA( VclWindowEvent ) )
1305     {
1306         VclWindowEvent *pVclEvent = static_cast< VclWindowEvent * >( pEvent );
1307         OSL_ENSURE( pVclEvent->GetWindow(), "Window???" );
1308         switch ( pVclEvent->GetId() )
1309         {
1310         case VCLEVENT_WINDOW_SHOW:  // send create on show for direct accessible children
1311             {
1312                 Window* pChildWin = static_cast < Window * >( pVclEvent->GetData() );
1313                 if( pChildWin && AccessibleRole::EMBEDDED_OBJECT == pChildWin->GetAccessibleRole() )
1314                 {
1315                     AddChild( pChildWin->GetAccessible(), sal_True );
1316                 }
1317             }
1318             break;
1319         case VCLEVENT_WINDOW_HIDE:  // send destroy on hide for direct accessible children
1320             {
1321                 Window* pChildWin = static_cast < Window * >( pVclEvent->GetData() );
1322                 if( pChildWin && AccessibleRole::EMBEDDED_OBJECT == pChildWin->GetAccessibleRole() )
1323                 {
1324                     RemoveChild( pChildWin->GetAccessible(), sal_True );
1325                 }
1326             }
1327             break;
1328         }
1329     }
1330     return 0;
1331 }
1332
1333 void ScAccessibleDocument::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
1334 {
1335     if (rHint.ISA( ScAccGridWinFocusLostHint ) )
1336     {
1337         const ScAccGridWinFocusLostHint& rRef = (const ScAccGridWinFocusLostHint&)rHint;
1338         if (rRef.GetOldGridWin() == meSplitPos)
1339         {
1340             if (mxTempAcc.is() && mpTempAccEdit)
1341                 mpTempAccEdit->LostFocus();
1342             else if (mpAccessibleSpreadsheet)
1343                 mpAccessibleSpreadsheet->LostFocus();
1344             else
1345                 CommitFocusLost();
1346         }
1347     }
1348     else if (rHint.ISA( ScAccGridWinFocusGotHint ) )
1349     {
1350         const ScAccGridWinFocusGotHint& rRef = (const ScAccGridWinFocusGotHint&)rHint;
1351         if (rRef.GetNewGridWin() == meSplitPos)
1352         {
1353             if (mxTempAcc.is() && mpTempAccEdit)
1354                 mpTempAccEdit->GotFocus();
1355             else if (mpAccessibleSpreadsheet)
1356                 mpAccessibleSpreadsheet->GotFocus();
1357             else
1358                 CommitFocusGained();
1359         }
1360     }
1361     else if (rHint.ISA( SfxSimpleHint ))
1362     {
1363         const SfxSimpleHint& rRef = (const SfxSimpleHint&)rHint;
1364         // only notify if child exist, otherwise it is not necessary
1365         if ((rRef.GetId() == SC_HINT_ACC_TABLECHANGED) &&
1366             mpAccessibleSpreadsheet)
1367         {
1368             FreeAccessibleSpreadsheet();
1369             if (mpChildrenShapes)
1370                 DELETEZ(mpChildrenShapes);
1371
1372             // Accessibility: Shapes / form controls after reload not accessible
1373             if ( !mpChildrenShapes )
1374             {
1375                 mpChildrenShapes = new ScChildrenShapes( this, mpViewShell, meSplitPos );
1376             }
1377
1378             AccessibleEventObject aEvent;
1379             aEvent.EventId = AccessibleEventId::INVALIDATE_ALL_CHILDREN;
1380             aEvent.Source = uno::Reference< XAccessibleContext >(this);
1381             CommitChange(aEvent); // all children changed
1382         }
1383         else if (rRef.GetId() == SC_HINT_ACC_MAKEDRAWLAYER)
1384         {
1385             if (mpChildrenShapes)
1386                 mpChildrenShapes->SetDrawBroadcaster();
1387         }
1388         else if ((rRef.GetId() == SC_HINT_ACC_ENTEREDITMODE)) // this event comes only on creating edit field of a cell
1389         {
1390             ScViewData *pViewData = mpViewShell ? mpViewShell->GetViewData() : NULL;
1391             if (pViewData && pViewData->HasEditView(meSplitPos))
1392             {
1393                 mpTempAccEdit = new ScAccessibleEditObject(this, pViewData->GetEditView(meSplitPos),
1394                     mpViewShell->GetWindowByPos(meSplitPos), GetCurrentCellName(),
1395                     OUString(String(ScResId(STR_ACC_EDITLINE_DESCR))), ScAccessibleEditObject::CellInEditMode);
1396                 uno::Reference<XAccessible> xAcc = mpTempAccEdit;
1397
1398                 AddChild(xAcc, sal_True);
1399
1400                 if (mpAccessibleSpreadsheet)
1401                     mpAccessibleSpreadsheet->LostFocus();
1402                 else
1403                     CommitFocusLost();
1404
1405                 mpTempAccEdit->GotFocus();
1406             }
1407         }
1408         else if (rRef.GetId() == SC_HINT_ACC_LEAVEEDITMODE)
1409         {
1410             if (mxTempAcc.is())
1411             {
1412                 if (mpTempAccEdit)
1413                     mpTempAccEdit->LostFocus();
1414
1415                 mpTempAccEdit = NULL;
1416                 RemoveChild(mxTempAcc, sal_True);
1417
1418                 if (mpAccessibleSpreadsheet)
1419                     mpAccessibleSpreadsheet->GotFocus();
1420                 else
1421                     CommitFocusGained();
1422             }
1423         }
1424         else if ((rRef.GetId() == SC_HINT_ACC_VISAREACHANGED) || (rRef.GetId() == SC_HINT_ACC_WINDOWRESIZED))
1425         {
1426             Rectangle aOldVisArea(maVisArea);
1427             maVisArea = GetVisibleArea_Impl();
1428
1429             if (maVisArea != aOldVisArea)
1430             {
1431                 if (maVisArea.GetSize() != aOldVisArea.GetSize())
1432                 {
1433                     AccessibleEventObject aEvent;
1434                     aEvent.EventId = AccessibleEventId::BOUNDRECT_CHANGED;
1435                     aEvent.Source = uno::Reference< XAccessibleContext >(this);
1436
1437                     CommitChange(aEvent);
1438
1439                     if (mpAccessibleSpreadsheet)
1440                         mpAccessibleSpreadsheet->BoundingBoxChanged();
1441                 }
1442                 else if (mpAccessibleSpreadsheet)
1443                 {
1444                     mpAccessibleSpreadsheet->VisAreaChanged();
1445                 }
1446                 if (mpChildrenShapes)
1447                     mpChildrenShapes->VisAreaChanged();
1448             }
1449         }
1450     }
1451
1452     ScAccessibleDocumentBase::Notify(rBC, rHint);
1453 }
1454
1455 void SAL_CALL ScAccessibleDocument::selectionChanged( const lang::EventObject& /* aEvent */ )
1456         throw (uno::RuntimeException)
1457 {
1458     sal_Bool bSelectionChanged(false);
1459     if (mpAccessibleSpreadsheet)
1460     {
1461         sal_Bool bOldSelected(mbCompleteSheetSelected);
1462         mbCompleteSheetSelected = IsTableSelected();
1463         if (bOldSelected != mbCompleteSheetSelected)
1464         {
1465             mpAccessibleSpreadsheet->CompleteSelectionChanged(mbCompleteSheetSelected);
1466             bSelectionChanged = sal_True;
1467         }
1468     }
1469
1470     if (mpChildrenShapes && mpChildrenShapes->SelectionChanged())
1471         bSelectionChanged = sal_True;
1472
1473     if (bSelectionChanged)
1474     {
1475         AccessibleEventObject aEvent;
1476         aEvent.EventId = AccessibleEventId::SELECTION_CHANGED;
1477         aEvent.Source = uno::Reference< XAccessibleContext >(this);
1478
1479         CommitChange(aEvent);
1480     }
1481 }
1482
1483     //=====  XInterface  =====================================================
1484
1485 uno::Any SAL_CALL ScAccessibleDocument::queryInterface( uno::Type const & rType )
1486     throw (uno::RuntimeException)
1487 {
1488     uno::Any aAny (ScAccessibleDocumentImpl::queryInterface(rType));
1489     return aAny.hasValue() ? aAny : ScAccessibleContextBase::queryInterface(rType);
1490 }
1491
1492 void SAL_CALL ScAccessibleDocument::acquire()
1493     throw ()
1494 {
1495     ScAccessibleContextBase::acquire();
1496 }
1497
1498 void SAL_CALL ScAccessibleDocument::release()
1499     throw ()
1500 {
1501     ScAccessibleContextBase::release();
1502 }
1503
1504     //=====  XAccessibleComponent  ============================================
1505
1506 uno::Reference< XAccessible > SAL_CALL ScAccessibleDocument::getAccessibleAtPoint(
1507         const awt::Point& rPoint )
1508         throw (uno::RuntimeException)
1509 {
1510     uno::Reference<XAccessible> xAccessible = NULL;
1511     if (containsPoint(rPoint))
1512     {
1513         SolarMutexGuard aGuard;
1514         IsObjectValid();
1515         if (mpChildrenShapes)
1516             xAccessible = mpChildrenShapes->GetAt(rPoint);
1517         if(!xAccessible.is())
1518         {
1519             if (mxTempAcc.is())
1520             {
1521                 uno::Reference< XAccessibleContext > xCont(mxTempAcc->getAccessibleContext());
1522                 uno::Reference< XAccessibleComponent > xComp(xCont, uno::UNO_QUERY);
1523                 if (xComp.is())
1524                 {
1525                     Rectangle aBound(VCLRectangle(xComp->getBounds()));
1526                     if (aBound.IsInside(VCLPoint(rPoint)))
1527                         xAccessible = mxTempAcc;
1528                 }
1529             }
1530             if (!xAccessible.is())
1531                 xAccessible = GetAccessibleSpreadsheet();
1532         }
1533     }
1534     return xAccessible;
1535 }
1536
1537 void SAL_CALL ScAccessibleDocument::grabFocus(  )
1538         throw (uno::RuntimeException)
1539 {
1540     SolarMutexGuard aGuard;
1541     IsObjectValid();
1542     if (getAccessibleParent().is())
1543     {
1544         uno::Reference<XAccessibleComponent> xAccessibleComponent(getAccessibleParent()->getAccessibleContext(), uno::UNO_QUERY);
1545         if (xAccessibleComponent.is())
1546         {
1547             xAccessibleComponent->grabFocus();
1548             // grab only focus if it does not have the focus and it is not hidden
1549             if (mpViewShell && mpViewShell->GetViewData() &&
1550                 (mpViewShell->GetViewData()->GetActivePart() != meSplitPos) &&
1551                 mpViewShell->GetWindowByPos(meSplitPos)->IsVisible())
1552             {
1553                 mpViewShell->ActivatePart(meSplitPos);
1554             }
1555         }
1556     }
1557 }
1558
1559     //=====  XAccessibleContext  ==============================================
1560
1561     /// Return the number of currently visible children.
1562 sal_Int32 SAL_CALL
1563     ScAccessibleDocument::getAccessibleChildCount(void)
1564     throw (uno::RuntimeException)
1565 {
1566     SolarMutexGuard aGuard;
1567     IsObjectValid();
1568     sal_Int32 nCount(1);
1569     if (mpChildrenShapes)
1570         nCount = mpChildrenShapes->GetCount(); // returns the count of the shapes inclusive the table
1571
1572     if (mxTempAcc.is())
1573         ++nCount;
1574
1575     return nCount;
1576 }
1577
1578     /// Return the specified child or NULL if index is invalid.
1579 uno::Reference<XAccessible> SAL_CALL
1580     ScAccessibleDocument::getAccessibleChild(sal_Int32 nIndex)
1581     throw (uno::RuntimeException,
1582         lang::IndexOutOfBoundsException)
1583 {
1584     SolarMutexGuard aGuard;
1585     IsObjectValid();
1586     uno::Reference<XAccessible> xAccessible;
1587     if (nIndex >= 0)
1588     {
1589         sal_Int32 nCount(1);
1590         if (mpChildrenShapes)
1591         {
1592             xAccessible = mpChildrenShapes->Get(nIndex); // returns NULL if it is the table or out of range
1593             nCount = mpChildrenShapes->GetCount(); //there is always a table
1594         }
1595         if (!xAccessible.is())
1596         {
1597             if (nIndex < nCount)
1598                 xAccessible = GetAccessibleSpreadsheet();
1599             else if (nIndex == nCount && mxTempAcc.is())
1600                 xAccessible = mxTempAcc;
1601         }
1602     }
1603
1604     if (!xAccessible.is())
1605         throw lang::IndexOutOfBoundsException();
1606
1607     return xAccessible;
1608 }
1609
1610     /// Return the set of current states.
1611 uno::Reference<XAccessibleStateSet> SAL_CALL
1612     ScAccessibleDocument::getAccessibleStateSet(void)
1613     throw (uno::RuntimeException)
1614 {
1615     SolarMutexGuard aGuard;
1616     uno::Reference<XAccessibleStateSet> xParentStates;
1617     if (getAccessibleParent().is())
1618     {
1619         uno::Reference<XAccessibleContext> xParentContext = getAccessibleParent()->getAccessibleContext();
1620         xParentStates = xParentContext->getAccessibleStateSet();
1621     }
1622     utl::AccessibleStateSetHelper* pStateSet = new utl::AccessibleStateSetHelper();
1623     if (IsDefunc(xParentStates))
1624         pStateSet->AddState(AccessibleStateType::DEFUNC);
1625     else
1626     {
1627         if (IsEditable(xParentStates))
1628             pStateSet->AddState(AccessibleStateType::EDITABLE);
1629         pStateSet->AddState(AccessibleStateType::ENABLED);
1630         pStateSet->AddState(AccessibleStateType::OPAQUE);
1631         if (isShowing())
1632             pStateSet->AddState(AccessibleStateType::SHOWING);
1633         if (isVisible())
1634             pStateSet->AddState(AccessibleStateType::VISIBLE);
1635     }
1636     return pStateSet;
1637 }
1638
1639     ///=====  XAccessibleSelection  ===========================================
1640
1641 void SAL_CALL
1642     ScAccessibleDocument::selectAccessibleChild( sal_Int32 nChildIndex )
1643         throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1644 {
1645     SolarMutexGuard aGuard;
1646     IsObjectValid();
1647
1648     if (mpChildrenShapes && mpViewShell)
1649     {
1650         sal_Int32 nCount(mpChildrenShapes->GetCount()); //all shapes and the table
1651         if (mxTempAcc.is())
1652             ++nCount;
1653         if (nChildIndex < 0 || nChildIndex >= nCount)
1654             throw lang::IndexOutOfBoundsException();
1655
1656         uno::Reference < XAccessible > xAccessible = mpChildrenShapes->Get(nChildIndex);
1657         if (xAccessible.is())
1658         {
1659             sal_Bool bWasTableSelected(IsTableSelected());
1660
1661             if (mpChildrenShapes)
1662                 mpChildrenShapes->Select(nChildIndex); // throws no lang::IndexOutOfBoundsException if Index is to high
1663
1664             if (bWasTableSelected)
1665                 mpViewShell->SelectAll();
1666         }
1667         else
1668         {
1669             if (mpViewShell)
1670                 mpViewShell->SelectAll();
1671         }
1672     }
1673 }
1674
1675 sal_Bool SAL_CALL
1676     ScAccessibleDocument::isAccessibleChildSelected( sal_Int32 nChildIndex )
1677         throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1678 {
1679     SolarMutexGuard aGuard;
1680     IsObjectValid();
1681     sal_Bool bResult(false);
1682
1683     if (mpChildrenShapes)
1684     {
1685         sal_Int32 nCount(mpChildrenShapes->GetCount()); //all shapes and the table
1686         if (mxTempAcc.is())
1687             ++nCount;
1688         if (nChildIndex < 0 || nChildIndex >= nCount)
1689             throw lang::IndexOutOfBoundsException();
1690
1691         uno::Reference < XAccessible > xAccessible = mpChildrenShapes->Get(nChildIndex);
1692         if (xAccessible.is())
1693         {
1694             uno::Reference<drawing::XShape> xShape;
1695             bResult = mpChildrenShapes->IsSelected(nChildIndex, xShape); // throws no lang::IndexOutOfBoundsException if Index is to high
1696         }
1697         else
1698         {
1699             if (mxTempAcc.is() && nChildIndex == nCount)
1700                 bResult = sal_True;
1701             else
1702                 bResult = IsTableSelected();
1703         }
1704     }
1705     return bResult;
1706 }
1707
1708 void SAL_CALL
1709     ScAccessibleDocument::clearAccessibleSelection(  )
1710         throw (uno::RuntimeException)
1711 {
1712     SolarMutexGuard aGuard;
1713     IsObjectValid();
1714
1715     if (mpChildrenShapes)
1716         mpChildrenShapes->DeselectAll(); //deselects all (also the table)
1717 }
1718
1719 void SAL_CALL
1720     ScAccessibleDocument::selectAllAccessibleChildren(  )
1721         throw (uno::RuntimeException)
1722 {
1723     SolarMutexGuard aGuard;
1724     IsObjectValid();
1725
1726     if (mpChildrenShapes)
1727         mpChildrenShapes->SelectAll();
1728
1729     // select table after shapes, because while selecting shapes the table will be deselected
1730     if (mpViewShell)
1731     {
1732         mpViewShell->SelectAll();
1733     }
1734 }
1735
1736 sal_Int32 SAL_CALL
1737     ScAccessibleDocument::getSelectedAccessibleChildCount(  )
1738         throw (uno::RuntimeException)
1739 {
1740     SolarMutexGuard aGuard;
1741     IsObjectValid();
1742     sal_Int32 nCount(0);
1743
1744     if (mpChildrenShapes)
1745         nCount = mpChildrenShapes->GetSelectedCount();
1746
1747     if (IsTableSelected())
1748         ++nCount;
1749
1750     if (mxTempAcc.is())
1751         ++nCount;
1752
1753     return nCount;
1754 }
1755
1756 uno::Reference<XAccessible > SAL_CALL
1757     ScAccessibleDocument::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
1758         throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1759 {
1760     SolarMutexGuard aGuard;
1761     IsObjectValid();
1762     uno::Reference<XAccessible> xAccessible;
1763     if (mpChildrenShapes)
1764     {
1765         sal_Int32 nCount(getSelectedAccessibleChildCount()); //all shapes and the table
1766         if (nSelectedChildIndex < 0 || nSelectedChildIndex >= nCount)
1767             throw lang::IndexOutOfBoundsException();
1768
1769         sal_Bool bTabMarked(IsTableSelected());
1770
1771         if (mpChildrenShapes)
1772             xAccessible = mpChildrenShapes->GetSelected(nSelectedChildIndex, bTabMarked); // throws no lang::IndexOutOfBoundsException if Index is to high
1773         if (mxTempAcc.is() && nSelectedChildIndex == nCount - 1)
1774             xAccessible = mxTempAcc;
1775         else if (bTabMarked)
1776             xAccessible = GetAccessibleSpreadsheet();
1777     }
1778
1779     OSL_ENSURE(xAccessible.is(), "here should always be an accessible object or a exception throwed");
1780
1781     return xAccessible;
1782 }
1783
1784 void SAL_CALL
1785     ScAccessibleDocument::deselectAccessibleChild( sal_Int32 nChildIndex )
1786         throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1787 {
1788     SolarMutexGuard aGuard;
1789     IsObjectValid();
1790
1791     if (mpChildrenShapes && mpViewShell)
1792     {
1793         sal_Int32 nCount(mpChildrenShapes->GetCount()); //all shapes and the table
1794         if (mxTempAcc.is())
1795             ++nCount;
1796         if (nChildIndex < 0 || nChildIndex >= nCount)
1797             throw lang::IndexOutOfBoundsException();
1798
1799         sal_Bool bTabMarked(IsTableSelected());
1800
1801         uno::Reference < XAccessible > xAccessible = mpChildrenShapes->Get(nChildIndex);
1802         if (xAccessible.is())
1803         {
1804             if (mpChildrenShapes)
1805                 mpChildrenShapes->Deselect(nChildIndex); // throws no lang::IndexOutOfBoundsException if Index is to high
1806
1807             if (bTabMarked)
1808                 mpViewShell->SelectAll(); // select the table again
1809         }
1810         else if (bTabMarked)
1811             mpViewShell->Unmark();
1812     }
1813 }
1814
1815     //=====  XServiceInfo  ====================================================
1816
1817 OUString SAL_CALL
1818     ScAccessibleDocument::getImplementationName(void)
1819     throw (uno::RuntimeException)
1820 {
1821     return OUString("ScAccessibleDocument");
1822 }
1823
1824 uno::Sequence< OUString> SAL_CALL
1825     ScAccessibleDocument::getSupportedServiceNames(void)
1826         throw (uno::RuntimeException)
1827 {
1828     uno::Sequence< OUString > aSequence = ScAccessibleContextBase::getSupportedServiceNames();
1829     sal_Int32 nOldSize(aSequence.getLength());
1830     aSequence.realloc(nOldSize + 1);
1831     OUString* pNames = aSequence.getArray();
1832
1833     pNames[nOldSize] = OUString("com.sun.star.AccessibleSpreadsheetDocumentView");
1834
1835     return aSequence;
1836 }
1837
1838 //=====  XTypeProvider  =======================================================
1839
1840 uno::Sequence< uno::Type > SAL_CALL ScAccessibleDocument::getTypes()
1841         throw (uno::RuntimeException)
1842 {
1843     return comphelper::concatSequences(ScAccessibleDocumentImpl::getTypes(), ScAccessibleContextBase::getTypes());
1844 }
1845
1846 namespace
1847 {
1848     class theScAccessibleDocumentImplementationId : public rtl::Static< UnoTunnelIdInit, theScAccessibleDocumentImplementationId > {};
1849 }
1850
1851 uno::Sequence<sal_Int8> SAL_CALL
1852     ScAccessibleDocument::getImplementationId(void)
1853     throw (uno::RuntimeException)
1854 {
1855     return theScAccessibleDocumentImplementationId::get().getSeq();
1856 }
1857
1858 ///=====  IAccessibleViewForwarder  ========================================
1859
1860 sal_Bool ScAccessibleDocument::IsValid (void) const
1861 {
1862     SolarMutexGuard aGuard;
1863     IsObjectValid();
1864     return (!ScAccessibleContextBase::IsDefunc() && !rBHelper.bInDispose);
1865 }
1866
1867 Rectangle ScAccessibleDocument::GetVisibleArea_Impl() const
1868 {
1869     Rectangle aVisRect(GetBoundingBox());
1870
1871     if (mpViewShell)
1872     {
1873         ScViewData *pViewData = mpViewShell->GetViewData();
1874         if (pViewData)
1875         {
1876             Point aPoint(pViewData->GetPixPos(meSplitPos)); // returns a negative Point
1877             aPoint.setX(-aPoint.getX());
1878             aPoint.setY(-aPoint.getY());
1879             aVisRect.SetPos(aPoint);
1880         }
1881
1882         ScGridWindow* pWin = static_cast<ScGridWindow*>(mpViewShell->GetWindowByPos(meSplitPos));
1883         if (pWin)
1884             aVisRect = pWin->PixelToLogic(aVisRect, pWin->GetDrawMapMode());
1885     }
1886
1887     return aVisRect;
1888 }
1889
1890 Rectangle ScAccessibleDocument::GetVisibleArea() const
1891 {
1892     SolarMutexGuard aGuard;
1893     IsObjectValid();
1894     return maVisArea;
1895 }
1896
1897 Point ScAccessibleDocument::LogicToPixel (const Point& rPoint) const
1898 {
1899     SolarMutexGuard aGuard;
1900     IsObjectValid();
1901     Point aPoint;
1902     ScGridWindow* pWin = static_cast<ScGridWindow*>(mpViewShell->GetWindowByPos(meSplitPos));
1903     if (pWin)
1904     {
1905         aPoint = pWin->LogicToPixel(rPoint, pWin->GetDrawMapMode());
1906         aPoint += pWin->GetWindowExtentsRelative(NULL).TopLeft();
1907     }
1908     return aPoint;
1909 }
1910
1911 Size ScAccessibleDocument::LogicToPixel (const Size& rSize) const
1912 {
1913     SolarMutexGuard aGuard;
1914     IsObjectValid();
1915     Size aSize;
1916     ScGridWindow* pWin = static_cast<ScGridWindow*>(mpViewShell->GetWindowByPos(meSplitPos));
1917     if (pWin)
1918         aSize = pWin->LogicToPixel(rSize, pWin->GetDrawMapMode());
1919     return aSize;
1920 }
1921
1922 Point ScAccessibleDocument::PixelToLogic (const Point& rPoint) const
1923 {
1924     SolarMutexGuard aGuard;
1925     IsObjectValid();
1926     Point aPoint;
1927     ScGridWindow* pWin = static_cast<ScGridWindow*>(mpViewShell->GetWindowByPos(meSplitPos));
1928     if (pWin)
1929     {
1930         aPoint -= pWin->GetWindowExtentsRelative(NULL).TopLeft();
1931         aPoint = pWin->PixelToLogic(rPoint, pWin->GetDrawMapMode());
1932     }
1933     return aPoint;
1934 }
1935
1936 Size ScAccessibleDocument::PixelToLogic (const Size& rSize) const
1937 {
1938     SolarMutexGuard aGuard;
1939     IsObjectValid();
1940     Size aSize;
1941     ScGridWindow* pWin = static_cast<ScGridWindow*>(mpViewShell->GetWindowByPos(meSplitPos));
1942     if (pWin)
1943         aSize = pWin->PixelToLogic(rSize, pWin->GetDrawMapMode());
1944     return aSize;
1945 }
1946
1947     //=====  internal  ========================================================
1948
1949 utl::AccessibleRelationSetHelper* ScAccessibleDocument::GetRelationSet(const ScAddress* pAddress) const
1950 {
1951     utl::AccessibleRelationSetHelper* pRelationSet = NULL;
1952     if (mpChildrenShapes)
1953         pRelationSet = mpChildrenShapes->GetRelationSet(pAddress);
1954     return pRelationSet;
1955 }
1956
1957 OUString SAL_CALL
1958     ScAccessibleDocument::createAccessibleDescription(void)
1959     throw (uno::RuntimeException)
1960 {
1961     OUString sDescription = String(ScResId(STR_ACC_DOC_DESCR));
1962     return sDescription;
1963 }
1964
1965 OUString SAL_CALL
1966     ScAccessibleDocument::createAccessibleName(void)
1967     throw (uno::RuntimeException)
1968 {
1969     SolarMutexGuard aGuard;
1970     IsObjectValid();
1971     OUString sName = String(ScResId(STR_ACC_DOC_NAME));
1972     sal_Int32 nNumber(sal_Int32(meSplitPos) + 1);
1973     sName += OUString::valueOf(nNumber);
1974     return sName;
1975 }
1976
1977 Rectangle ScAccessibleDocument::GetBoundingBoxOnScreen() const
1978     throw (uno::RuntimeException)
1979 {
1980     Rectangle aRect;
1981     if (mpViewShell)
1982     {
1983         Window* pWindow = mpViewShell->GetWindowByPos(meSplitPos);
1984         if (pWindow)
1985             aRect = pWindow->GetWindowExtentsRelative(NULL);
1986     }
1987     return aRect;
1988 }
1989
1990 Rectangle ScAccessibleDocument::GetBoundingBox() const
1991     throw (uno::RuntimeException)
1992 {
1993     Rectangle aRect;
1994     if (mpViewShell)
1995     {
1996         Window* pWindow = mpViewShell->GetWindowByPos(meSplitPos);
1997         if (pWindow)
1998             aRect = pWindow->GetWindowExtentsRelative(pWindow->GetAccessibleParentWindow());
1999     }
2000     return aRect;
2001 }
2002
2003 SCTAB ScAccessibleDocument::getVisibleTable() const
2004 {
2005     SCTAB nVisibleTable(0);
2006     ScViewData *pViewData = mpViewShell ? mpViewShell->GetViewData() : NULL;
2007     if (pViewData)
2008         nVisibleTable = pViewData->GetTabNo();
2009     return nVisibleTable;
2010 }
2011
2012 uno::Reference < XAccessible >
2013     ScAccessibleDocument::GetAccessibleSpreadsheet()
2014 {
2015     if (!mpAccessibleSpreadsheet && mpViewShell)
2016     {
2017         mpAccessibleSpreadsheet = new ScAccessibleSpreadsheet(this, mpViewShell, getVisibleTable(), meSplitPos);
2018         mpAccessibleSpreadsheet->acquire();
2019         mpAccessibleSpreadsheet->Init();
2020         mbCompleteSheetSelected = IsTableSelected();
2021     }
2022     return mpAccessibleSpreadsheet;
2023 }
2024
2025 void ScAccessibleDocument::FreeAccessibleSpreadsheet()
2026 {
2027     if (mpAccessibleSpreadsheet)
2028     {
2029         mpAccessibleSpreadsheet->dispose();
2030         mpAccessibleSpreadsheet->release();
2031         mpAccessibleSpreadsheet = NULL;
2032     }
2033 }
2034
2035 sal_Bool ScAccessibleDocument::IsTableSelected() const
2036 {
2037     sal_Bool bResult (false);
2038     ScViewData *pViewData = mpViewShell ? mpViewShell->GetViewData() : NULL;
2039     if(pViewData)
2040     {
2041         SCTAB nTab(getVisibleTable());
2042         //#103800#; use a copy of MarkData
2043         ScMarkData aMarkData(pViewData->GetMarkData());
2044         aMarkData.MarkToMulti();
2045         if (aMarkData.IsAllMarked(ScRange(ScAddress(0, 0, nTab),ScAddress(MAXCOL, MAXROW, nTab))))
2046             bResult = sal_True;
2047     }
2048     return bResult;
2049 }
2050
2051 sal_Bool ScAccessibleDocument::IsDefunc(
2052     const uno::Reference<XAccessibleStateSet>& rxParentStates)
2053 {
2054     return ScAccessibleContextBase::IsDefunc() || (mpViewShell == NULL) || !getAccessibleParent().is() ||
2055         (rxParentStates.is() && rxParentStates->contains(AccessibleStateType::DEFUNC));
2056 }
2057
2058 sal_Bool ScAccessibleDocument::IsEditable(
2059     const uno::Reference<XAccessibleStateSet>& /* rxParentStates */)
2060 {
2061     // what is with document protection or readonly documents?
2062     return sal_True;
2063 }
2064
2065 void ScAccessibleDocument::AddChild(const uno::Reference<XAccessible>& xAcc, sal_Bool bFireEvent)
2066 {
2067     OSL_ENSURE(!mxTempAcc.is(), "this object should be removed before");
2068     if (xAcc.is())
2069     {
2070         mxTempAcc = xAcc;
2071         if( bFireEvent )
2072         {
2073             AccessibleEventObject aEvent;
2074                         aEvent.Source = uno::Reference<XAccessibleContext>(this);
2075             aEvent.EventId = AccessibleEventId::CHILD;
2076             aEvent.NewValue <<= mxTempAcc;
2077             CommitChange( aEvent );
2078         }
2079     }
2080 }
2081
2082 void ScAccessibleDocument::RemoveChild(const uno::Reference<XAccessible>& xAcc, sal_Bool bFireEvent)
2083 {
2084     OSL_ENSURE(mxTempAcc.is(), "this object should be added before");
2085     if (xAcc.is())
2086     {
2087         OSL_ENSURE(xAcc.get() == mxTempAcc.get(), "only the same object should be removed");
2088         if( bFireEvent )
2089         {
2090             AccessibleEventObject aEvent;
2091                         aEvent.Source = uno::Reference<XAccessibleContext>(this);
2092             aEvent.EventId = AccessibleEventId::CHILD;
2093             aEvent.OldValue <<= mxTempAcc;
2094             CommitChange( aEvent );
2095         }
2096         mxTempAcc = NULL;
2097     }
2098 }
2099
2100 OUString ScAccessibleDocument::GetCurrentCellName() const
2101 {
2102     String sName( ScResId(STR_ACC_CELL_NAME) );
2103     ScViewData *pViewData = mpViewShell ? mpViewShell->GetViewData() : NULL;
2104     if (pViewData)
2105     {
2106         String sAddress;
2107         // Document not needed, because only the cell address, but not the tablename is needed
2108         pViewData->GetCurPos().Format( sAddress, SCA_VALID, NULL );
2109         sName.SearchAndReplaceAscii("%1", sAddress);
2110     }
2111     return OUString(sName);
2112 }
2113
2114 OUString ScAccessibleDocument::GetCurrentCellDescription() const
2115 {
2116     return OUString();
2117 }
2118
2119 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */