sc/source/ui/Accessibility/AccessibleDocument.cxx

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