/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <AccessibleDocument.hxx>

#include <AccessibleSpreadsheet.hxx>

#include <tabvwsh.hxx>

#include <AccessibilityHints.hxx>

#include <document.hxx>

#include <drwlayer.hxx>

#include <DrawModelBroadcaster.hxx>

#include <drawview.hxx>

#include <gridwin.hxx>

#include <AccessibleEditObject.hxx>

#include <userdat.hxx>

#include <scresid.hxx>

#include <strings.hrc>

#include <strings.hxx>

#include <markdata.hxx>

#include <com/sun/star/accessibility/AccessibleEventId.hpp>

#include <com/sun/star/accessibility/AccessibleStateType.hpp>

#include <com/sun/star/accessibility/AccessibleRelationType.hpp>

#include <com/sun/star/accessibility/AccessibleRole.hpp>

#include <com/sun/star/view/XSelectionSupplier.hpp>

#include <com/sun/star/drawing/ShapeCollection.hpp>

#include <com/sun/star/drawing/XShape.hpp>

#include <com/sun/star/drawing/XShapes.hpp>

#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>

#include <o3tl/safeint.hxx>

#include <tools/gen.hxx>

#include <svx/svdpage.hxx>

#include <svx/svdobj.hxx>

#include <svx/ShapeTypeHandler.hxx>

#include <svx/AccessibleShape.hxx>

#include <svx/AccessibleShapeTreeInfo.hxx>

#include <svx/AccessibleShapeInfo.hxx>

#include <svx/IAccessibleParent.hxx>

#include <comphelper/sequence.hxx>

#include <sfx2/viewfrm.hxx>

#include <sfx2/docfile.hxx>

#include <toolkit/helper/vclunohelper.hxx>

#include <unotools/accessiblerelationsethelper.hxx>

#include <utility>

#include <vcl/svapp.hxx>

#include <vcl/unohelp.hxx>

#include <vcl/vclevent.hxx>

#include <svx/AccessibleControlShape.hxx>

#include <svx/SvxShapeTypes.hxx>

#include <sfx2/objsh.hxx>

#include <editeng/editview.hxx>

#include <editeng/editeng.hxx>

#include <comphelper/processfactory.hxx>

#include <algorithm>

#include <scmod.hxx>

#ifdef indices

#undef indices

#endif

#ifdef extents

#undef extents

#endif

using namespace ::com::sun::star;

using namespace ::com::sun::star::accessibility;

namespace {

struct ScAccessibleShapeData

{

    ScAccessibleShapeData(css::uno::Reference< css::drawing::XShape > xShape_);

    ~ScAccessibleShapeData();

    mutable rtl::Reference< ::accessibility::AccessibleShape > pAccShape;

    std::optional<ScAddress> xRelationCell; // if it is NULL this shape is anchored on the table

    css::uno::Reference< css::drawing::XShape > xShape;

    bool                    bSelected;

    bool                    bSelectable;

    // cache these to make the sorting cheaper

    std::optional<sal_Int16> mxLayerID;

    std::optional<sal_Int32> mxZOrder;

};

}

ScAccessibleShapeData::ScAccessibleShapeData(css::uno::Reference< css::drawing::XShape > xShape_)

    : xShape(std::move(xShape_)),

    bSelected(false), bSelectable(true)

{

    static constexpr OUStringLiteral gsLayerId = u"LayerID";

    static constexpr OUStringLiteral gsZOrder = u"ZOrder";

    uno::Reference< beans::XPropertySet> xProps(xShape, uno::UNO_QUERY);

    if (xProps.is())

    {

        uno::Any aAny = xProps->getPropertyValue(gsLayerId);

        sal_Int16 nLayerID;

        if (aAny >>= nLayerID)

            mxLayerID = nLayerID;

        sal_Int32 nZOrder;

        aAny = xProps->getPropertyValue(gsZOrder);

        if (aAny >>= nZOrder)

            mxZOrder = nZOrder;

    }

}

ScAccessibleShapeData::~ScAccessibleShapeData()

{

    if (pAccShape.is())

    {

        pAccShape->dispose();

    }

}

namespace {

struct ScShapeDataLess

{

    static void ConvertLayerId(sal_Int16& rLayerID) // changes the number of the LayerId so it the accessibility order

    {

        // note: MSVC 2017 ICE's if this is written as "switch" so use "if"

        if (SC_LAYER_FRONT.get() == rLayerID)

        {

            rLayerID = 1;

        }

        else if (SC_LAYER_BACK.get() == rLayerID)

        {

            rLayerID = 0;

        }

        else if (SC_LAYER_INTERN.get() == rLayerID)

        {

            rLayerID = 2;

        }

        else if (SC_LAYER_CONTROLS.get() == rLayerID)

        {

            rLayerID = 3;

        }

    }

    static bool LessThanSheet(const ScAccessibleShapeData* pData)

    {

        bool bResult(false);

        if (pData->mxLayerID)

        {

            if (SdrLayerID(*pData->mxLayerID) == SC_LAYER_BACK)

                bResult = true;

        }

        return bResult;

    }

    bool operator()(const ScAccessibleShapeData* pData1, const ScAccessibleShapeData* pData2) const

    {

        bool bResult(false);

        if (pData1 && pData2)

        {

            if( pData1->mxLayerID && pData2->mxLayerID )

            {

                sal_Int16 nLayerID1 = *pData1->mxLayerID;

                sal_Int16 nLayerID2 = *pData2->mxLayerID;

                if (nLayerID1 == nLayerID2)

                {

                    if ( pData1->mxZOrder && pData2->mxZOrder )

                        bResult = (*pData1->mxZOrder < *pData2->mxZOrder);

                }

                else

                {

                    ConvertLayerId(nLayerID1);

                    ConvertLayerId(nLayerID2);

                    bResult = (nLayerID1 < nLayerID2);

                }

            }

        }

        else if (pData1 && !pData2)

            bResult = LessThanSheet(pData1);

        else if (!pData1 && pData2)

            bResult = !LessThanSheet(pData2);

        else

            bResult = false;

        return bResult;

    }

};

}

class ScChildrenShapes : public SfxListener,

    public ::accessibility::IAccessibleParent

{

public:

    ScChildrenShapes(ScAccessibleDocument* pAccessibleDocument, ScTabViewShell* pViewShell, ScSplitPos eSplitPos);

    virtual ~ScChildrenShapes() override;

    ///=====  SfxListener  =====================================================

    virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;

    ///=====  IAccessibleParent  ===============================================

    virtual bool ReplaceChild (

        ::accessibility::AccessibleShape* pCurrentChild,

        const css::uno::Reference< css::drawing::XShape >& _rxShape,

        const tools::Long _nIndex,

        const ::accessibility::AccessibleShapeTreeInfo& _rShapeTreeInfo

    ) override;

    virtual ::accessibility::AccessibleControlShape* GetAccControlShapeFromModel

        (css::beans::XPropertySet* pSet) override;

    virtual ::accessibility::AccessibleShape*

        GetAccessibleCaption (const css::uno::Reference<css::drawing::XShape>& xShape) override;

    ///=====  Internal  ========================================================

    void SetDrawBroadcaster();

    sal_Int32 GetCount() const;

    rtl::Reference<::accessibility::AccessibleShape> Get(const ScAccessibleShapeData* pData) const;

    rtl::Reference<::accessibility::AccessibleShape> Get(sal_Int32 nIndex) const;

    uno::Reference< XAccessible > GetAt(const awt::Point& rPoint) const;

    // gets the index of the shape starting on 0 (without the index of the table)

    // returns the selected shape

    bool IsSelected(sal_Int32 nIndex,

        css::uno::Reference<css::drawing::XShape>& rShape) const;

    bool SelectionChanged();

    void Select(sal_Int32 nIndex);

    void DeselectAll(); // deselect also the table

    void SelectAll();

    sal_Int32 GetSelectedCount() const;

    rtl::Reference<::accessibility::AccessibleShape> GetSelected(sal_Int32 nSelectedChildIndex,

                                                                 bool bTabSelected) const;

    void Deselect(sal_Int32 nChildIndex);

    SdrPage* GetDrawPage() const;

    rtl::Reference<utl::AccessibleRelationSetHelper> GetRelationSet(const ScAddress* pAddress) const;

    void VisAreaChanged() const;

private:

    typedef std::vector<ScAccessibleShapeData*> SortedShapes;

    typedef std::unordered_map<css::uno::Reference< css::drawing::XShape >, ScAccessibleShapeData*> ShapesMap;

    mutable SortedShapes maZOrderedShapes; // a null pointer represents the sheet in the correct order

    mutable ShapesMap maShapesMap;

    mutable bool mbShapesNeedSorting; // set if maZOrderedShapes needs sorting

    mutable ::accessibility::AccessibleShapeTreeInfo maShapeTreeInfo;

    mutable css::uno::Reference<css::view::XSelectionSupplier> xSelectionSupplier;

    mutable sal_uInt32 mnShapesSelected;

    ScTabViewShell* mpViewShell;

    ScAccessibleDocument* mpAccessibleDocument;

    ScSplitPos meSplitPos;

    void FillShapes(std::vector < uno::Reference < drawing::XShape > >& rShapes) const;

    bool FindSelectedShapesChanges(const css::uno::Reference<css::drawing::XShapes>& xShapes) const;

    std::optional<ScAddress> GetAnchor(const uno::Reference<drawing::XShape>& xShape) const;

    rtl::Reference<utl::AccessibleRelationSetHelper> GetRelationSet(const ScAccessibleShapeData* pData) const;

    void SetAnchor(const uno::Reference<drawing::XShape>& xShape, ScAccessibleShapeData* pData) const;

    void AddShape(const uno::Reference<drawing::XShape>& xShape, bool bCommitChange) const;

    void RemoveShape(const uno::Reference<drawing::XShape>& xShape) const;

    bool FindShape(const uno::Reference<drawing::XShape>& xShape, SortedShapes::iterator& rItr) const;

    static sal_Int8 Compare(const ScAccessibleShapeData* pData1,

        const ScAccessibleShapeData* pData2);

};

ScChildrenShapes::ScChildrenShapes(ScAccessibleDocument* pAccessibleDocument, ScTabViewShell* pViewShell, ScSplitPos eSplitPos)

    :

    mbShapesNeedSorting(false),

    mnShapesSelected(0),

    mpViewShell(pViewShell),

    mpAccessibleDocument(pAccessibleDocument),

    meSplitPos(eSplitPos)

{

    if (mpViewShell)

    {

        SfxViewFrame& rViewFrame = mpViewShell->GetViewFrame();

        xSelectionSupplier = uno::Reference<view::XSelectionSupplier>(rViewFrame.GetFrame().GetController(), uno::UNO_QUERY);

        if (xSelectionSupplier.is())

        {

            xSelectionSupplier->addSelectionChangeListener(mpAccessibleDocument);

            uno::Reference<drawing::XShapes> xShapes(mpViewShell->getSelectedXShapes());

            if (xShapes.is())

                mnShapesSelected = xShapes->getCount();

        }

    }

    maZOrderedShapes.push_back(nullptr); // add an element which represents the table

    GetCount(); // fill list with filtered shapes (no internal shapes)

    if (mnShapesSelected)

    {

        //set flag on every selected shape

        if (!xSelectionSupplier.is())

            throw uno::RuntimeException(u"Could not get selected shapes. Null reference to xSelectionSupplier in ScChildrenShapes::ScChildrenShapes."_ustr);

        uno::Reference<drawing::XShapes> xShapes(mpViewShell->getSelectedXShapes());

        if (xShapes.is())

            FindSelectedShapesChanges(xShapes);

    }

    if (!pViewShell)

        return;

    ScViewData& rViewData = pViewShell->GetViewData();

    SfxBroadcaster* pDrawBC = rViewData.GetDocument().GetDrawBroadcaster();

    if (pDrawBC)

    {

        StartListening(*pDrawBC);

        maShapeTreeInfo.SetModelBroadcaster( new ScDrawModelBroadcaster(rViewData.GetDocument().GetDrawLayer()) );

        maShapeTreeInfo.SetSdrView(rViewData.GetScDrawView());

        maShapeTreeInfo.SetController(nullptr);

        maShapeTreeInfo.SetWindow(pViewShell->GetWindowByPos(meSplitPos));

        maShapeTreeInfo.SetViewForwarder(mpAccessibleDocument);

    }

}

ScChildrenShapes::~ScChildrenShapes()

{

    for (ScAccessibleShapeData* pShapeData : maZOrderedShapes)

        delete pShapeData;

    if (mpViewShell)

    {

        SfxBroadcaster* pDrawBC = mpViewShell->GetViewData().GetDocument().GetDrawBroadcaster();

        if (pDrawBC)

            EndListening(*pDrawBC);

    }

    if (mpAccessibleDocument && xSelectionSupplier.is())

        xSelectionSupplier->removeSelectionChangeListener(mpAccessibleDocument);

}

void ScChildrenShapes::SetDrawBroadcaster()

{

    if (!mpViewShell)

        return;

    ScViewData& rViewData = mpViewShell->GetViewData();

    SfxBroadcaster* pDrawBC = rViewData.GetDocument().GetDrawBroadcaster();

    if (pDrawBC)

    {

        StartListening(*pDrawBC, DuplicateHandling::Prevent);

        maShapeTreeInfo.SetModelBroadcaster( new ScDrawModelBroadcaster(rViewData.GetDocument().GetDrawLayer()) );

        maShapeTreeInfo.SetSdrView(rViewData.GetScDrawView());

        maShapeTreeInfo.SetController(nullptr);

        maShapeTreeInfo.SetWindow(mpViewShell->GetWindowByPos(meSplitPos));

        maShapeTreeInfo.SetViewForwarder(mpAccessibleDocument);

    }

}

void ScChildrenShapes::Notify(SfxBroadcaster&, const SfxHint& rHint)

{

    if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)

        return;

    const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);

    SdrObject* pObj = const_cast<SdrObject*>(pSdrHint->GetObject());

    if (!(pObj && /*(pObj->GetLayer() != SC_LAYER_INTERN) && */(pObj->getSdrPageFromSdrObject() == GetDrawPage()) &&

        (pObj->getSdrPageFromSdrObject() == pObj->getParentSdrObjListFromSdrObject())) ) //only do something if the object lies direct on the page

        return;

    switch (pSdrHint->GetKind())

    {

        case SdrHintKind::ObjectChange :         // object changed

        {

            uno::Reference<drawing::XShape> xShape (pObj->getUnoShape(), uno::UNO_QUERY);

            if (xShape.is())

            {

                mbShapesNeedSorting = true; // sort, because the z index or layer could be changed

                auto it = maShapesMap.find(xShape);

                if (it != maShapesMap.end())

                    SetAnchor(xShape, it->second);

            }

        }

        break;

        case SdrHintKind::ObjectInserted :    // new drawing object inserted

        {

            uno::Reference<drawing::XShape> xShape (pObj->getUnoShape(), uno::UNO_QUERY);

            if (xShape.is())

                AddShape(xShape, true);

        }

        break;

        case SdrHintKind::ObjectRemoved :     // Removed drawing object from list

        {

            uno::Reference<drawing::XShape> xShape (pObj->getUnoShape(), uno::UNO_QUERY);

            if (xShape.is())

                RemoveShape(xShape);

        }

        break;

        default :

        {

            // other events are not interesting

        }

        break;

    }

}

bool ScChildrenShapes::ReplaceChild (::accessibility::AccessibleShape* pCurrentChild,

        const css::uno::Reference< css::drawing::XShape >& _rxShape,

        const tools::Long /*_nIndex*/, const ::accessibility::AccessibleShapeTreeInfo& _rShapeTreeInfo)

{

    // create the new child

    rtl::Reference< ::accessibility::AccessibleShape > pReplacement(::accessibility::ShapeTypeHandler::Instance().CreateAccessibleObject (

        ::accessibility::AccessibleShapeInfo ( _rxShape, pCurrentChild->getAccessibleParent(), this ),

        _rShapeTreeInfo

    ));

    bool bResult(false);

    if (pReplacement.is())

    {

        OSL_ENSURE(pCurrentChild->GetXShape().get() == pReplacement->GetXShape().get(), "XShape changes and should be inserted sorted");

        auto it = maShapesMap.find(pCurrentChild->GetXShape());

        if (it != maShapesMap.end() && it->second->pAccShape.is())

        {

            OSL_ENSURE(it->second->pAccShape == pCurrentChild, "wrong child found");

            // child is gone - event

            mpAccessibleDocument->CommitChange(AccessibleEventId::CHILD,

                                               uno::Any(uno::Reference<XAccessible>(pCurrentChild)),

                                               uno::Any());

            pCurrentChild->dispose();

        }

        // Init after above possible pCurrentChild->dispose so we don't trigger the assert

        // ScDrawModelBroadcaster::addShapeEventListener of duplicate listeners

        pReplacement->Init();

        if (it != maShapesMap.end())

        {

            it->second->pAccShape = pReplacement;

            // child is new - event

            mpAccessibleDocument->CommitChange(AccessibleEventId::CHILD, uno::Any(),

                                               uno::Any(uno::Reference<XAccessible>(pReplacement)));

            bResult = true;

        }

    }

    return bResult;

}

::accessibility::AccessibleControlShape * ScChildrenShapes::GetAccControlShapeFromModel(css::beans::XPropertySet* pSet)

{

    GetCount(); // populate

    for (ScAccessibleShapeData* pShape : maZOrderedShapes)

    {

        if (pShape)

        {

            rtl::Reference< ::accessibility::AccessibleShape > pAccShape(pShape->pAccShape);

            if (pAccShape.is() && ::accessibility::ShapeTypeHandler::Instance().GetTypeId (pAccShape->GetXShape()) == ::accessibility::DRAWING_CONTROL)

            {

                ::accessibility::AccessibleControlShape *pCtlAccShape = static_cast < ::accessibility::AccessibleControlShape* >(pAccShape.get());

                if (pCtlAccShape && pCtlAccShape->GetControlModel() == pSet)

                    return pCtlAccShape;

            }

        }

    }

    return nullptr;

}

::accessibility::AccessibleShape*

ScChildrenShapes::GetAccessibleCaption (const css::uno::Reference < css::drawing::XShape>& xShape)

{

    GetCount(); // populate

    auto it = maShapesMap.find(xShape);

    if (it == maShapesMap.end())

        return nullptr;

    ScAccessibleShapeData* pShape = it->second;

    return pShape->pAccShape.get();

}

sal_Int32 ScChildrenShapes::GetCount() const

{

    SdrPage* pDrawPage = GetDrawPage();

    if (pDrawPage && (maZOrderedShapes.size() == 1)) // the table is always in

    {

        size_t nSdrObjCount = pDrawPage->GetObjCount();

        maZOrderedShapes.reserve(nSdrObjCount + 1); // the table is always in

        for (const rtl::Reference<SdrObject>& pObj : *pDrawPage)

        {

            uno::Reference< drawing::XShape > xShape (pObj->getUnoShape(), uno::UNO_QUERY);

            AddShape(xShape, false); //inserts in the correct order

        }

    }

    return maZOrderedShapes.size();

}

rtl::Reference<::accessibility::AccessibleShape>

ScChildrenShapes::Get(const ScAccessibleShapeData* pData) const

{

    if (!pData)

        return nullptr;

    if (!pData->pAccShape.is())

    {

        ::accessibility::ShapeTypeHandler& rShapeHandler = ::accessibility::ShapeTypeHandler::Instance();

        ::accessibility::AccessibleShapeInfo aShapeInfo(pData->xShape, mpAccessibleDocument, const_cast<ScChildrenShapes*>(this));

        pData->pAccShape = rShapeHandler.CreateAccessibleObject(

            aShapeInfo, maShapeTreeInfo);

        if (pData->pAccShape.is())

        {

            pData->pAccShape->Init();

            if (pData->bSelected)

                pData->pAccShape->SetState(AccessibleStateType::SELECTED);

            if (!pData->bSelectable)

                pData->pAccShape->ResetState(AccessibleStateType::SELECTABLE);

            pData->pAccShape->SetRelationSet(GetRelationSet(pData));

        }

    }

    return pData->pAccShape;

 }

rtl::Reference<::accessibility::AccessibleShape> ScChildrenShapes::Get(sal_Int32 nIndex) const

{

    if (maZOrderedShapes.size() <= 1)

        GetCount(); // fill list with filtered shapes (no internal shapes)

    if (mbShapesNeedSorting)

    {

        std::sort(maZOrderedShapes.begin(), maZOrderedShapes.end(), ScShapeDataLess());

        mbShapesNeedSorting = false;

    }

    if (o3tl::make_unsigned(nIndex) >= maZOrderedShapes.size())

        return nullptr;

    return Get(maZOrderedShapes[nIndex]);

}

uno::Reference< XAccessible > ScChildrenShapes::GetAt(const awt::Point& rPoint) const

{

    uno::Reference<XAccessible> xAccessible;

    if(mpViewShell)

    {

        if (mbShapesNeedSorting)

        {

            std::sort(maZOrderedShapes.begin(), maZOrderedShapes.end(), ScShapeDataLess());

            mbShapesNeedSorting = false;

        }

        sal_Int32 i(maZOrderedShapes.size() - 1);

        bool bFound(false);

        while (!bFound && i >= 0)

        {

            ScAccessibleShapeData* pShape = maZOrderedShapes[i];

            if (pShape)

            {

                if (!pShape->pAccShape.is())

                    Get(pShape);

                if (pShape->pAccShape.is())

                {

                    Point aPoint(vcl::unohelper::ConvertToVCLPoint(rPoint));

                    aPoint

                        -= vcl::unohelper::ConvertToVCLRect(pShape->pAccShape->getBounds()).TopLeft();

                    if (pShape->pAccShape->containsPoint(vcl::unohelper::ConvertToAWTPoint(aPoint)))

                    {

                        xAccessible = pShape->pAccShape.get();

                        bFound = true;

                    }

                }

                else

                {

                    OSL_FAIL("I should have an accessible shape now!");

                }

            }

            else

                bFound = true; // this is the sheet and it lies before the rest of the shapes which are background shapes

            --i;

        }

    }

    return xAccessible;

}

bool ScChildrenShapes::IsSelected(sal_Int32 nIndex,

                        uno::Reference<drawing::XShape>& rShape) const

{

    bool bResult (false);

    if (maZOrderedShapes.size() <= 1)

        GetCount(); // fill list with filtered shapes (no internal shapes)

    if (!xSelectionSupplier.is())

        throw uno::RuntimeException(u"Could not get selected shapes. Null reference to xSelectionSupplier in ScChildrenShapes::IsSelected."_ustr);

    if (mbShapesNeedSorting)

    {

        std::sort(maZOrderedShapes.begin(), maZOrderedShapes.end(), ScShapeDataLess());

        mbShapesNeedSorting = false;

    }

    if (!maZOrderedShapes[nIndex])

        return false;

    bResult = maZOrderedShapes[nIndex]->bSelected;

    rShape = maZOrderedShapes[nIndex]->xShape;

#if OSL_DEBUG_LEVEL > 0 // test whether it is truly selected by a slower method

    uno::Reference< drawing::XShape > xReturnShape;

    bool bDebugResult(false);

    uno::Reference<drawing::XShapes> xShapes(mpViewShell->getSelectedXShapes());

    if (xShapes.is())

    {

        sal_Int32 nCount(xShapes->getCount());

        if (nCount)

        {

            uno::Reference< drawing::XShape > xShape;

            uno::Reference< drawing::XShape > xIndexShape = maZOrderedShapes[nIndex]->xShape;

            sal_Int32 i(0);

            while (!bDebugResult && (i < nCount))

            {

                xShapes->getByIndex(i) >>= xShape;

                if (xShape.is() && (xIndexShape.get() == xShape.get()))

                {

                    bDebugResult = true;

                    xReturnShape = xShape;

                }

                else

                    ++i;

            }

        }

    }

    OSL_ENSURE((bResult == bDebugResult) && ((bResult && (rShape.get() == xReturnShape.get())) || !bResult), "found the wrong shape or result");

#endif

    return bResult;

}

bool ScChildrenShapes::SelectionChanged()

{

    bool bResult(false);

    if (!xSelectionSupplier.is())

        throw uno::RuntimeException(u"Could not get selected shapes. Null reference to xSelectionSupplier in ScChildrenShapes::SelectionChanged."_ustr);

    uno::Reference<drawing::XShapes> xShapes(mpViewShell->getSelectedXShapes());

    bResult = FindSelectedShapesChanges(xShapes);

    return bResult;

}

void ScChildrenShapes::Select(sal_Int32 nIndex)

{

    if (maZOrderedShapes.size() <= 1)

        GetCount(); // fill list with filtered shapes (no internal shapes)

    if (!xSelectionSupplier.is())

        throw uno::RuntimeException(u"Could not get selected shapes. Null reference to xSelectionSupplier in ScChildrenShapes::Select."_ustr);

    if (mbShapesNeedSorting)

    {

        std::sort(maZOrderedShapes.begin(), maZOrderedShapes.end(), ScShapeDataLess());

        mbShapesNeedSorting = false;

    }

    if (!maZOrderedShapes[nIndex])

        return;

    uno::Reference<drawing::XShape> xShape;

    if (IsSelected(nIndex, xShape) || !maZOrderedShapes[nIndex]->bSelectable)

        return;

    uno::Reference<drawing::XShapes> xShapes(mpViewShell->getSelectedXShapes());

    if (!xShapes.is())

        xShapes = drawing::ShapeCollection::create(

                comphelper::getProcessComponentContext());

    xShapes->add(maZOrderedShapes[nIndex]->xShape);

    try

    {

        xSelectionSupplier->select(uno::Any(xShapes));

        maZOrderedShapes[nIndex]->bSelected = true;

        if (maZOrderedShapes[nIndex]->pAccShape.is())

            maZOrderedShapes[nIndex]->pAccShape->SetState(AccessibleStateType::SELECTED);

    }

    catch (lang::IllegalArgumentException&)

    {

    }

}

void ScChildrenShapes::DeselectAll()

{

    if (!xSelectionSupplier.is())

        throw uno::RuntimeException(u"Could not get selected shapes. Null reference to xSelectionSupplier in ScChildrenShapes::DeselectAll."_ustr);

    bool bSomethingSelected(true);

    try

    {

        xSelectionSupplier->select(uno::Any()); //deselects all

    }

    catch (lang::IllegalArgumentException&)

    {

        OSL_FAIL("nothing selected before");

        bSomethingSelected = false;

    }

    if (bSomethingSelected)

        for (ScAccessibleShapeData* pAccShapeData : maZOrderedShapes)

            if (pAccShapeData)

            {

                pAccShapeData->bSelected = false;

                if (pAccShapeData->pAccShape.is())

                    pAccShapeData->pAccShape->ResetState(AccessibleStateType::SELECTED);

            }

};

void ScChildrenShapes::SelectAll()

{

    if (!xSelectionSupplier.is())

        throw uno::RuntimeException(u"Could not get selected shapes. Null reference to xSelectionSupplier in ScChildrenShapes::SelectAll."_ustr);

    if (maZOrderedShapes.size() <= 1)

        GetCount(); // fill list with filtered shapes (no internal shapes)

    if (maZOrderedShapes.size() <= 1)

        return;

    uno::Reference<drawing::XShapes> xShapes = drawing::ShapeCollection::create(

            comphelper::getProcessComponentContext());

    try

    {

        for (ScAccessibleShapeData* pAccShapeData : maZOrderedShapes)

        {

            if (pAccShapeData && pAccShapeData->bSelectable)

            {

                pAccShapeData->bSelected = true;

                if (pAccShapeData->pAccShape.is())

                    pAccShapeData->pAccShape->SetState(AccessibleStateType::SELECTED);

                if (xShapes.is())

                    xShapes->add(pAccShapeData->xShape);

            }

        }

        xSelectionSupplier->select(uno::Any(xShapes));

    }

    catch (lang::IllegalArgumentException&)

    {

        SelectionChanged(); // find all selected shapes and set the flags

    }

}

void ScChildrenShapes::FillShapes(std::vector < uno::Reference < drawing::XShape > >& rShapes) const

{

    uno::Reference<drawing::XShapes> xShapes(mpViewShell->getSelectedXShapes());

    if (xShapes.is())

    {

        sal_uInt32 nCount(xShapes->getCount());

        for (sal_uInt32 i = 0; i < nCount; ++i)

        {

            uno::Reference<drawing::XShape> xShape;

            xShapes->getByIndex(i) >>= xShape;

            if (xShape.is())

                rShapes.push_back(xShape);

        }

    }

}

sal_Int32 ScChildrenShapes::GetSelectedCount() const

{

    if (!xSelectionSupplier.is())

        throw uno::RuntimeException(u"Could not get selected shapes. Null reference to xSelectionSupplier in ScChildrenShapes::GetSelectedCount."_ustr);

    std::vector < uno::Reference < drawing::XShape > > aShapes;

    FillShapes(aShapes);

    return aShapes.size();

}

rtl::Reference<::accessibility::AccessibleShape>

ScChildrenShapes::GetSelected(sal_Int32 nSelectedChildIndex, bool bTabSelected) const

{

    rtl::Reference<::accessibility::AccessibleShape> xAccessible;

    if (maZOrderedShapes.size() <= 1)

        GetCount(); // fill list with shapes

    if (!bTabSelected)

    {

        std::vector < uno::Reference < drawing::XShape > > aShapes;

        FillShapes(aShapes);

        if (nSelectedChildIndex < 0 || o3tl::make_unsigned(nSelectedChildIndex) >= aShapes.size())

            return xAccessible;

        SortedShapes::iterator aItr;

        if (FindShape(aShapes[nSelectedChildIndex], aItr))

            xAccessible = Get(*aItr);

    }

    else

    {

        if (mbShapesNeedSorting)

        {

            std::sort(maZOrderedShapes.begin(), maZOrderedShapes.end(), ScShapeDataLess());

            mbShapesNeedSorting = false;

        }

        for(const auto& rpShape : maZOrderedShapes)

        {

            if (!rpShape || rpShape->bSelected)

            {

                if (nSelectedChildIndex == 0)

                {

                    if (rpShape)

                        xAccessible = rpShape->pAccShape.get();

                    break;

                }

                else

                    --nSelectedChildIndex;

            }

        }

    }

    return xAccessible;

}

void ScChildrenShapes::Deselect(sal_Int32 nChildIndex)

{

    uno::Reference<drawing::XShape> xShape;

    if (!IsSelected(nChildIndex, xShape)) // returns false if it is the sheet

        return;

    if (!xShape.is())

        return;

    uno::Reference<drawing::XShapes> xShapes(mpViewShell->getSelectedXShapes());

    if (xShapes.is())

        xShapes->remove(xShape);

    try

    {

        xSelectionSupplier->select(uno::Any(xShapes));

    }

    catch (lang::IllegalArgumentException&)

    {

        OSL_FAIL("something not selectable");

    }

    maZOrderedShapes[nChildIndex]->bSelected = false;

    if (maZOrderedShapes[nChildIndex]->pAccShape.is())

        maZOrderedShapes[nChildIndex]->pAccShape->ResetState(AccessibleStateType::SELECTED);

}

SdrPage* ScChildrenShapes::GetDrawPage() const

{

    SCTAB nTab(mpAccessibleDocument->getVisibleTable());

    SdrPage* pDrawPage = nullptr;

    if (mpViewShell)

    {

        ScDocument& rDoc = mpViewShell->GetViewData().GetDocument();

        if (ScDrawLayer* pDrawLayer = rDoc.GetDrawLayer())

        {

            if (pDrawLayer->HasObjects() && (pDrawLayer->GetPageCount() > nTab))

                pDrawPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(static_cast<sal_Int16>(nTab)));

        }

    }

    return pDrawPage;

}

rtl::Reference<utl::AccessibleRelationSetHelper> ScChildrenShapes::GetRelationSet(const ScAddress* pAddress) const

{

    rtl::Reference<utl::AccessibleRelationSetHelper> pRelationSet;

    for (const ScAccessibleShapeData* pAccShapeData : maZOrderedShapes)

    {

        if (pAccShapeData &&

            ((!pAccShapeData->xRelationCell && !pAddress) ||

            (pAccShapeData->xRelationCell && pAddress && (*(pAccShapeData->xRelationCell) == *pAddress))))

        {

            if (!pRelationSet)

                pRelationSet = new utl::AccessibleRelationSetHelper();

            AccessibleRelation aRelation;

            aRelation.TargetSet = { Get(pAccShapeData) };

            aRelation.RelationType = AccessibleRelationType_CONTROLLER_FOR;

            pRelationSet->AddRelation(aRelation);

        }

    }

    return pRelationSet;

}

bool ScChildrenShapes::FindSelectedShapesChanges(const uno::Reference<drawing::XShapes>& xShapes) const

{

    bool bResult(false);

    SortedShapes aShapesList;

    if (xShapes.is())

    {

        mnShapesSelected = xShapes->getCount();

        for (sal_uInt32 i = 0; i < mnShapesSelected; ++i)