/* -*- 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 <com/sun/star/awt/MouseButton.hpp>

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

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

#include <com/sun/star/script/vba/XVBAEventProcessor.hpp>

#include <com/sun/star/util/VetoException.hpp>

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

#include <editeng/outliner.hxx>

#include <svx/svditer.hxx>

#include <svx/svdmark.hxx>

#include <svx/svdpage.hxx>

#include <svx/svdpagv.hxx>

#include <svx/svdview.hxx>

#include <svx/unoshape.hxx>

#include <svx/fmshell.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/request.hxx>

#include <sfx2/viewfrm.hxx>

#include <comphelper/profilezone.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/sequence.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <cppuhelper/queryinterface.hxx>

#include <toolkit/helper/vclunohelper.hxx>

#include <vcl/svapp.hxx>

#include <vcl/unohelp.hxx>

#include <tools/multisel.hxx>

#include <drawsh.hxx>

#include <drtxtob.hxx>

#include <transobj.hxx>

#include <editsh.hxx>

#include <viewuno.hxx>

#include <cellsuno.hxx>

#include <miscuno.hxx>

#include <tabvwsh.hxx>

#include <prevwsh.hxx>

#include <docsh.hxx>

#include <drwlayer.hxx>

#include <attrib.hxx>

#include <drawview.hxx>

#include <fupoor.hxx>

#include <sc.hrc>

#include <unonames.hxx>

#include <scmod.hxx>

#include <appoptio.hxx>

#include <gridwin.hxx>

#include <sheetevents.hxx>

#include <markdata.hxx>

#include <scextopt.hxx>

#include <preview.hxx>

#include <inputhdl.hxx>

#include <inputwin.hxx>

#include <svx/sdrhittesthelper.hxx>

#include <formatsh.hxx>

#include <sfx2/app.hxx>

#include <scitems.hxx>

using namespace com::sun::star;

//! Clipping Marks

//  no Which-ID here, Map only for PropertySetInfo

static std::span<const SfxItemPropertyMapEntry> lcl_GetViewOptPropertyMap()

{

    static const SfxItemPropertyMapEntry aViewOptPropertyMap_Impl[] =

    {

        { OLD_UNO_COLROWHDR,   0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_GRIDCOLOR,    0,  cppu::UnoType<sal_Int32>::get(),    0, 0},

        { SC_UNO_COLROWHDR,    0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_HORSCROLL,    0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHEETTABS,    0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_VERTSCROLL,   0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_HIDESPELL,    0,  cppu::UnoType<bool>::get(),          0, 0},  /* deprecated #i91949 */

        { OLD_UNO_HORSCROLL,   0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_OUTLSYMB,     0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_VALUEHIGH,    0,  cppu::UnoType<bool>::get(),          0, 0},

        { OLD_UNO_OUTLSYMB,    0,  cppu::UnoType<bool>::get(),          0, 0},

        { OLD_UNO_SHEETTABS,   0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWANCHOR,   0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWCHARTS,   0,  cppu::UnoType<sal_Int16>::get(),    0, 0},

        { SC_UNO_SHOWDRAW,     0,  cppu::UnoType<sal_Int16>::get(),    0, 0},

        { SC_UNO_SHOWFORM,     0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWGRID,     0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWHELP,     0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWNOTES,    0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWNOTEAUTHOR,    0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWFORMULASMARKS,    0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWOBJ,      0,  cppu::UnoType<sal_Int16>::get(),    0, 0},

        { SC_UNO_SHOWPAGEBR,   0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_SHOWZERO,     0,  cppu::UnoType<bool>::get(),          0, 0},

        { OLD_UNO_VALUEHIGH,   0,  cppu::UnoType<bool>::get(),          0, 0},

        { OLD_UNO_VERTSCROLL,  0,  cppu::UnoType<bool>::get(),          0, 0},

        { SC_UNO_VISAREA,      0,  cppu::UnoType<awt::Rectangle>::get(), 0, 0},

        { SC_UNO_ZOOMTYPE,     0,  cppu::UnoType<sal_Int16>::get(),    0, 0},

        { SC_UNO_ZOOMVALUE,    0,  cppu::UnoType<sal_Int16>::get(),    0, 0},

        { SC_UNO_VISAREASCREEN,0,  cppu::UnoType<awt::Rectangle>::get(), 0, 0},

        { SC_UNO_FORMULABARHEIGHT,0,cppu::UnoType<sal_Int16>::get(),     0, 0},

    };

    return aViewOptPropertyMap_Impl;

}

constexpr OUString SCTABVIEWOBJ_SERVICE = u"com.sun.star.sheet.SpreadsheetView"_ustr;

constexpr OUString SCVIEWSETTINGS_SERVICE = u"com.sun.star.sheet.SpreadsheetViewSettings"_ustr;

SC_SIMPLE_SERVICE_INFO( ScViewPaneBase, u"ScViewPaneObj"_ustr, u"com.sun.star.sheet.SpreadsheetViewPane"_ustr )

ScViewPaneBase::ScViewPaneBase(ScTabViewShell* pViewSh, sal_uInt16 nP) :

    pViewShell( pViewSh ),

    nPane( nP )

{

    if (pViewShell)

        StartListening(*pViewShell);

}

ScViewPaneBase::~ScViewPaneBase()

{

    SolarMutexGuard g;

    if (pViewShell)

        EndListening(*pViewShell);

}

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

{

    if ( rHint.GetId() == SfxHintId::Dying )

        pViewShell = nullptr;

}

uno::Any SAL_CALL ScViewPaneBase::queryInterface( const uno::Type& rType )

{

    uno::Any aReturn = ::cppu::queryInterface(rType,

                    static_cast<sheet::XViewPane*>(this),

                    static_cast<sheet::XCellRangeReferrer*>(this),

                    static_cast<view::XFormLayerAccess*>(this),

                    static_cast<view::XControlAccess*>(this),

                    static_cast<lang::XServiceInfo*>(this),

                    static_cast<lang::XTypeProvider*>(this));

    if ( aReturn.hasValue() )

        return aReturn;

    return uno::Any();          // OWeakObject is in derived objects

}

uno::Sequence<uno::Type> SAL_CALL ScViewPaneBase::getTypes()

{

    static const uno::Sequence<uno::Type> aTypes

    {

        cppu::UnoType<sheet::XViewPane>::get(),

        cppu::UnoType<sheet::XCellRangeReferrer>::get(),

        cppu::UnoType<view::XFormLayerAccess>::get(),

        cppu::UnoType<lang::XServiceInfo>::get(),

        cppu::UnoType<lang::XTypeProvider>::get(),

    };

    return aTypes;

}

uno::Sequence<sal_Int8> SAL_CALL ScViewPaneBase::getImplementationId()

{

    return css::uno::Sequence<sal_Int8>();

}

// XViewPane

sal_Int32 SAL_CALL ScViewPaneBase::getFirstVisibleColumn()

{

    SolarMutexGuard aGuard;

    if (pViewShell)

    {

        ScViewData& rViewData = pViewShell->GetViewData();

        ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?

                                rViewData.GetActivePart() :

                                static_cast<ScSplitPos>(nPane);

        ScHSplitPos eWhichH = WhichH( eWhich );

        return rViewData.GetPosX( eWhichH );

    }

    OSL_FAIL("no View ?!?"); //! Exception?

    return 0;

}

void SAL_CALL ScViewPaneBase::setFirstVisibleColumn(sal_Int32 nFirstVisibleColumn)

{

    SolarMutexGuard aGuard;

    if (pViewShell)

    {

        ScViewData& rViewData = pViewShell->GetViewData();

        ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?

                                rViewData.GetActivePart() :

                                static_cast<ScSplitPos>(nPane);

        ScHSplitPos eWhichH = WhichH( eWhich );

        tools::Long nDeltaX = static_cast<tools::Long>(nFirstVisibleColumn) - rViewData.GetPosX( eWhichH );

        pViewShell->ScrollX( nDeltaX, eWhichH );

    }

}

sal_Int32 SAL_CALL ScViewPaneBase::getFirstVisibleRow()

{

    SolarMutexGuard aGuard;

    if (pViewShell)

    {

        ScViewData& rViewData = pViewShell->GetViewData();

        ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?

                                rViewData.GetActivePart() :

                                static_cast<ScSplitPos>(nPane);

        ScVSplitPos eWhichV = WhichV( eWhich );

        return rViewData.GetPosY( eWhichV );

    }

    OSL_FAIL("no View ?!?"); //! Exception?

    return 0;

}

void SAL_CALL ScViewPaneBase::setFirstVisibleRow( sal_Int32 nFirstVisibleRow )

{

    SolarMutexGuard aGuard;

    if (pViewShell)

    {

        ScViewData& rViewData = pViewShell->GetViewData();

        ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?

                                rViewData.GetActivePart() :

                                static_cast<ScSplitPos>(nPane);

        ScVSplitPos eWhichV = WhichV( eWhich );

        tools::Long nDeltaY = static_cast<tools::Long>(nFirstVisibleRow) - rViewData.GetPosY( eWhichV );

        pViewShell->ScrollY( nDeltaY, eWhichV );

    }

}

table::CellRangeAddress SAL_CALL ScViewPaneBase::getVisibleRange()

{

    SolarMutexGuard aGuard;

    table::CellRangeAddress aAdr;

    if (pViewShell)

    {

        ScViewData& rViewData = pViewShell->GetViewData();

        ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?

                                rViewData.GetActivePart() :

                                static_cast<ScSplitPos>(nPane);

        ScHSplitPos eWhichH = WhichH( eWhich );

        ScVSplitPos eWhichV = WhichV( eWhich );

        //  VisibleCellsX returns only completely visible cells

        //  VisibleRange in Excel also partially visible ones

        //! do the same ???

        SCCOL nVisX = rViewData.VisibleCellsX( eWhichH );

        SCROW nVisY = rViewData.VisibleCellsY( eWhichV );

        if (!nVisX) nVisX = 1;  // there has to be something in the range

        if (!nVisY) nVisY = 1;

        aAdr.Sheet       = rViewData.CurrentTabForData();

        aAdr.StartColumn = rViewData.GetPosX( eWhichH );

        aAdr.StartRow    = rViewData.GetPosY( eWhichV );

        aAdr.EndColumn   = aAdr.StartColumn + nVisX - 1;

        aAdr.EndRow      = aAdr.StartRow    + nVisY - 1;

    }

    return aAdr;

}

// XCellRangeSource

uno::Reference<table::XCellRange> SAL_CALL ScViewPaneBase::getReferredCells()

{

    SolarMutexGuard aGuard;

    if (pViewShell)

    {

        ScDocShell* pDocSh = pViewShell->GetViewData().GetDocShell();

        table::CellRangeAddress aAdr(getVisibleRange());        //! helper function with ScRange?

        ScRange aRange( static_cast<SCCOL>(aAdr.StartColumn), static_cast<SCROW>(aAdr.StartRow), aAdr.Sheet,

                        static_cast<SCCOL>(aAdr.EndColumn), static_cast<SCROW>(aAdr.EndRow), aAdr.Sheet );

        if ( aRange.aStart == aRange.aEnd )

            return new ScCellObj( pDocSh, aRange.aStart );

        else

            return new ScCellRangeObj( pDocSh, aRange );

    }

    return nullptr;

}

namespace

{

    bool lcl_prepareFormShellCall( ScTabViewShell* _pViewShell, sal_uInt16 _nPane, FmFormShell*& _rpFormShell, vcl::Window*& _rpWindow, SdrView*& _rpSdrView )

    {

        if ( !_pViewShell )

            return false;

        ScViewData& rViewData = _pViewShell->GetViewData();

        ScSplitPos eWhich = ( _nPane == SC_VIEWPANE_ACTIVE ) ?

                                rViewData.GetActivePart() :

                                static_cast<ScSplitPos>(_nPane);

        _rpWindow = _pViewShell->GetWindowByPos( eWhich );

        _rpSdrView = _pViewShell->GetScDrawView();

        _rpFormShell = _pViewShell->GetFormShell();

        return ( _rpFormShell != nullptr ) && ( _rpSdrView != nullptr )&& ( _rpWindow != nullptr );

    }

}

// XFormLayerAccess

uno::Reference< form::runtime::XFormController > SAL_CALL ScViewPaneBase::getFormController( const uno::Reference< form::XForm >& Form )

{

    SolarMutexGuard aGuard;

    uno::Reference< form::runtime::XFormController > xController;

    vcl::Window* pWindow( nullptr );

    SdrView* pSdrView( nullptr );

    FmFormShell* pFormShell( nullptr );

    if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow, pSdrView ) )

        xController = FmFormShell::GetFormController( Form, *pSdrView, *pWindow->GetOutDev() );

    return xController;

}

sal_Bool SAL_CALL ScViewPaneBase::isFormDesignMode(  )

{

    SolarMutexGuard aGuard;

    bool bIsFormDesignMode( true );

    FmFormShell* pFormShell( pViewShell ? pViewShell->GetFormShell() : nullptr );

    if ( pFormShell )

        bIsFormDesignMode = pFormShell->IsDesignMode();

    return bIsFormDesignMode;

}

void SAL_CALL ScViewPaneBase::setFormDesignMode( sal_Bool DesignMode )

{

    SolarMutexGuard aGuard;

    vcl::Window* pWindow( nullptr );

    SdrView* pSdrView( nullptr );

    FmFormShell* pFormShell( nullptr );

    if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow, pSdrView ) )

        pFormShell->SetDesignMode( DesignMode );

}

// XControlAccess

uno::Reference<awt::XControl> SAL_CALL ScViewPaneBase::getControl(

                            const uno::Reference<awt::XControlModel>& xModel )

{

    SolarMutexGuard aGuard;

    uno::Reference<awt::XControl> xRet;

    vcl::Window* pWindow( nullptr );

    SdrView* pSdrView( nullptr );

    FmFormShell* pFormShell( nullptr );

    if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow, pSdrView ) )

        pFormShell->GetFormControl( xModel, *pSdrView, *pWindow->GetOutDev(), xRet );

    if ( !xRet.is() )

        throw container::NoSuchElementException();      // no control found

    return xRet;

}

awt::Rectangle ScViewPaneBase::GetVisArea() const

{

    awt::Rectangle aVisArea;

    if (pViewShell)

    {

        ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?

                                pViewShell->GetViewData().GetActivePart() :

                                static_cast<ScSplitPos>(nPane);

        ScGridWindow* pWindow = static_cast<ScGridWindow*>(pViewShell->GetWindowByPos(eWhich));

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

        if (pWindow)

        {

            ScHSplitPos eWhichH = ((eWhich == SC_SPLIT_TOPLEFT) || (eWhich == SC_SPLIT_BOTTOMLEFT)) ?

                                    SC_SPLIT_LEFT : SC_SPLIT_RIGHT;

            ScVSplitPos eWhichV = ((eWhich == SC_SPLIT_TOPLEFT) || (eWhich == SC_SPLIT_TOPRIGHT)) ?

                                    SC_SPLIT_TOP : SC_SPLIT_BOTTOM;

            ScAddress aCell(pViewShell->GetViewData().GetPosX(eWhichH),

                pViewShell->GetViewData().GetPosY(eWhichV),

                pViewShell->GetViewData().CurrentTabForData());

            tools::Rectangle aCellRect( rDoc.GetMMRect( aCell.Col(), aCell.Row(), aCell.Col(), aCell.Row(), aCell.Tab() ) );

            Size aVisSize( pWindow->PixelToLogic( pWindow->GetSizePixel(), pWindow->GetDrawMapMode( true ) ) );

            Point aVisPos( aCellRect.TopLeft() );

            if ( rDoc.IsLayoutRTL( aCell.Tab() ) )

            {

                aVisPos = aCellRect.TopRight();

                aVisPos.AdjustX( -(aVisSize.Width()) );

            }

            tools::Rectangle aVisRect( aVisPos, aVisSize );

            aVisArea = vcl::unohelper::ConvertToAWTRect(aVisRect);

        }

    }

    return aVisArea;

}

ScViewPaneObj::ScViewPaneObj(ScTabViewShell* pViewSh, sal_uInt16 nP) :

    ScViewPaneBase( pViewSh, nP )

{

}

ScViewPaneObj::~ScViewPaneObj()

{

}

uno::Any SAL_CALL ScViewPaneObj::queryInterface( const uno::Type& rType )

{

    //  ScViewPaneBase has everything except OWeakObject

    uno::Any aRet(ScViewPaneBase::queryInterface( rType ));

    if (!aRet.hasValue())

        aRet = OWeakObject::queryInterface( rType );

    return aRet;

}

void SAL_CALL ScViewPaneObj::acquire() noexcept

{

    OWeakObject::acquire();

}

void SAL_CALL ScViewPaneObj::release() noexcept

{

    OWeakObject::release();

}

//  We need default ctor for SMART_REFLECTION_IMPLEMENTATION

ScTabViewObj::ScTabViewObj( ScTabViewShell* pViewSh ) :

    ScViewPaneBase( pViewSh, SC_VIEWPANE_ACTIVE ),

    SfxBaseController( pViewSh ),

    aPropSet( lcl_GetViewOptPropertyMap() ),

    aMouseClickHandlers( 0 ),

    aActivationListeners( 0 ),

    nPreviousTab( 0 ),

    bDrawSelModeSet(false),

    bFilteredRangeSelection(false),

    mbLeftMousePressed(false)

{

    if (pViewSh)

        nPreviousTab = pViewSh->GetViewData().CurrentTabForData();

}

ScTabViewObj::~ScTabViewObj()

{

    //! Listening or something along that line

    if (!aMouseClickHandlers.empty())

    {

        acquire();

        EndMouseListening();

    }

    if (!aActivationListeners.empty())

    {

        acquire();

        EndActivationListening();

    }

}

uno::Any SAL_CALL ScTabViewObj::queryInterface( const uno::Type& rType )

{

    uno::Any aReturn = ::cppu::queryInterface(rType,

                    static_cast<sheet::XSpreadsheetView*>(this),

                    static_cast<sheet::XEnhancedMouseClickBroadcaster*>(this),

                    static_cast<sheet::XActivationBroadcaster*>(this),

                    static_cast<container::XEnumerationAccess*>(this),

                    static_cast<container::XIndexAccess*>(this),

                    static_cast<container::XElementAccess*>(static_cast<container::XIndexAccess*>(this)),

                    static_cast<view::XSelectionSupplier*>(this),

                    static_cast<beans::XPropertySet*>(this),

                    static_cast<sheet::XViewSplitable*>(this),

                    static_cast<sheet::XViewFreezable*>(this),

                    static_cast<sheet::XRangeSelection*>(this),

                    static_cast<sheet::XSheetRange*>(this),

                    static_cast<sheet::XSelectedSheetsSupplier*>(this),

                    static_cast<datatransfer::XTransferableSupplier*>(this));

    if ( aReturn.hasValue() )

        return aReturn;

    uno::Any aRet(ScViewPaneBase::queryInterface( rType ));

    if (!aRet.hasValue())

        aRet = SfxBaseController::queryInterface( rType );

    return aRet;

}

void SAL_CALL ScTabViewObj::acquire() noexcept

{

    SfxBaseController::acquire();

}

void SAL_CALL ScTabViewObj::release() noexcept

{

    SfxBaseController::release();

}

static void lcl_CallActivate( ScDocShell* pDocSh, SCTAB nTab, ScSheetEventId nEvent )

{

    ScDocument& rDoc = pDocSh->GetDocument();

    // when deleting a sheet, nPreviousTab can be invalid

    // (could be handled with reference updates)

    if (!rDoc.HasTable(nTab))

        return;

    const ScSheetEvents* pEvents = rDoc.GetSheetEvents(nTab);

    if (pEvents)

    {

        const OUString* pScript = pEvents->GetScript(nEvent);

        if (pScript)

        {

            uno::Any aRet;

            uno::Sequence<uno::Any> aParams;

            uno::Sequence<sal_Int16> aOutArgsIndex;

            uno::Sequence<uno::Any> aOutArgs;

            /*ErrCode eRet =*/ pDocSh->CallXScript( *pScript, aParams, aRet, aOutArgsIndex, aOutArgs );

        }

    }

    // execute VBA event handlers

    try

    {

        uno::Reference< script::vba::XVBAEventProcessor > xVbaEvents( rDoc.GetVbaEventProcessor(), uno::UNO_SET_THROW );

        // the parameter is the clicked object, as in the mousePressed call above

        uno::Sequence< uno::Any > aArgs{ uno::Any(nTab) };

        xVbaEvents->processVbaEvent( ScSheetEvents::GetVbaSheetEventId( nEvent ), aArgs );

    }

    catch( uno::Exception& )

    {

    }

}

void ScTabViewObj::SheetChanged( bool bSameTabButMoved )

{

    if ( !GetViewShell() )

        return;

    ScViewData& rViewData = GetViewShell()->GetViewData();

    ScDocShell* pDocSh = rViewData.GetDocShell();

    if (!aActivationListeners.empty())

    {

        sheet::ActivationEvent aEvent;

        uno::Reference< sheet::XSpreadsheetView > xView(this);

        aEvent.Source.set(xView, uno::UNO_QUERY);

        aEvent.ActiveSheet = new ScTableSheetObj(pDocSh, rViewData.CurrentTabForData());

        // Listener's handler may remove it from the listeners list

        for (size_t i = aActivationListeners.size(); i > 0; --i)

        {

            try

            {

                aActivationListeners[i - 1]->activeSpreadsheetChanged( aEvent );

            }

            catch( uno::Exception& )

            {

                aActivationListeners.erase(aActivationListeners.begin() + (i - 1));

            }

        }

    }

    /*  Handle sheet events, but do not trigger event handlers, if the old

        active sheet gets re-activated after inserting/deleting/moving a sheet. */

    SCTAB nNewTab = rViewData.CurrentTabForData();

    if ( !bSameTabButMoved && (nNewTab != nPreviousTab) )

    {

        lcl_CallActivate( pDocSh, nPreviousTab, ScSheetEventId::UNFOCUS );

        lcl_CallActivate( pDocSh, nNewTab, ScSheetEventId::FOCUS );

    }

    nPreviousTab = nNewTab;

}

uno::Sequence<uno::Type> SAL_CALL ScTabViewObj::getTypes()

{

    return comphelper::concatSequences(

        ScViewPaneBase::getTypes(),

        SfxBaseController::getTypes(),

        uno::Sequence<uno::Type>

        {

            cppu::UnoType<sheet::XSpreadsheetView>::get(),

            cppu::UnoType<container::XEnumerationAccess>::get(),

            cppu::UnoType<container::XIndexAccess>::get(),

            cppu::UnoType<view::XSelectionSupplier>::get(),

            cppu::UnoType<beans::XPropertySet>::get(),

            cppu::UnoType<sheet::XViewSplitable>::get(),

            cppu::UnoType<sheet::XViewFreezable>::get(),

            cppu::UnoType<sheet::XRangeSelection>::get(),

            cppu::UnoType<sheet::XSheetRange>::get(),

            cppu::UnoType<lang::XUnoTunnel>::get(),

            cppu::UnoType<sheet::XEnhancedMouseClickBroadcaster>::get(),

            cppu::UnoType<sheet::XActivationBroadcaster>::get(),

            cppu::UnoType<datatransfer::XTransferableSupplier>::get()

        } );

}

uno::Sequence<sal_Int8> SAL_CALL ScTabViewObj::getImplementationId()

{

    return css::uno::Sequence<sal_Int8>();

}

// XDocumentView

static bool lcl_TabInRanges( SCTAB nTab, const ScRangeList& rRanges )

{

    for (size_t i = 0, nCount = rRanges.size(); i < nCount; ++i)

    {

        const ScRange & rRange = rRanges[ i ];

        if ( nTab >= rRange.aStart.Tab() && nTab <= rRange.aEnd.Tab() )

            return true;

    }

    return false;

}

static void lcl_ShowObject( ScTabViewShell& rViewSh, const ScDrawView& rDrawView, const SdrObject* pSelObj )

{

    bool bFound = false;

    SCTAB nObjectTab = 0;

    SdrModel& rModel = rDrawView.GetModel();

    sal_uInt16 nPageCount = rModel.GetPageCount();

    for (sal_uInt16 i=0; i<nPageCount && !bFound; i++)

    {

        SdrPage* pPage = rModel.GetPage(i);

        if (pPage)

        {

            SdrObjListIter aIter( pPage, SdrIterMode::DeepWithGroups );

            SdrObject* pObject = aIter.Next();

            while (pObject && !bFound)

            {

                if ( pObject == pSelObj )

                {

                    bFound = true;

                    nObjectTab = static_cast<SCTAB>(i);

                }

                pObject = aIter.Next();

            }

        }

    }

    if (bFound)

    {

        rViewSh.SetTabNo( nObjectTab );

        rViewSh.ScrollToObject( pSelObj );

    }

}

sal_Bool SAL_CALL ScTabViewObj::select( const uno::Any& aSelection )

{

    SolarMutexGuard aGuard;

    ScTabViewShell* pViewSh = GetViewShell();

    if ( !pViewSh )

        return false;

    //! Type of aSelection can be some specific interface instead of XInterface

    bool bRet = false;

    uno::Reference<uno::XInterface> xInterface(aSelection, uno::UNO_QUERY);

    if ( !xInterface.is() )  //clear all selections

    {

        ScDrawView* pDrawView = pViewSh->GetScDrawView();

        if (pDrawView)

        {

            pDrawView->ScEndTextEdit();

            pDrawView->UnmarkAll();

        }

        else //#102232#; if there is  no DrawView remove range selection

            pViewSh->Unmark();

        bRet = true;

    }

    if (bDrawSelModeSet) // remove DrawSelMode if set by API; if necessary it will be set again later

    {

        pViewSh->SetDrawSelMode(false);

        pViewSh->UpdateLayerLocks();

        bDrawSelModeSet = false;

    }

    if (bRet)

        return bRet;

    ScCellRangesBase* pRangesImp = dynamic_cast<ScCellRangesBase*>( xInterface.get() );

    uno::Reference<drawing::XShapes> xShapeColl( xInterface, uno::UNO_QUERY );

    uno::Reference<drawing::XShape> xShapeSel( xInterface, uno::UNO_QUERY );

    SvxShape* pShapeImp = comphelper::getFromUnoTunnel<SvxShape>( xShapeSel );

    if (pRangesImp)                                     // Cell ranges

    {

        ScViewData& rViewData = pViewSh->GetViewData();

        if ( rViewData.GetDocShell() == pRangesImp->GetDocShell() )

        {

            //  perhaps remove drawing selection first

            //  (MarkListHasChanged removes sheet selection)

            ScDrawView* pDrawView = pViewSh->GetScDrawView();

            if (pDrawView)

            {

                pDrawView->ScEndTextEdit();

                pDrawView->UnmarkAll();

            }

            FuPoor* pFunc = pViewSh->GetDrawFuncPtr();

            if ( pFunc && pFunc->GetSlotID() != SID_OBJECT_SELECT )

            {

                //  execute the slot of drawing function again -> switch off

                SfxDispatcher* pDisp = pViewSh->GetDispatcher();

                if (pDisp)

                    pDisp->Execute( pFunc->GetSlotID(), SfxCallMode::SYNCHRON );

            }

            pViewSh->SetDrawShell(false);

            pViewSh->SetDrawSelMode(false); // after Dispatcher-Execute

            //  select ranges

            const ScRangeList& rRanges = pRangesImp->GetRangeList();

            size_t nRangeCount = rRanges.size();

            // for empty range list, remove selection (cursor remains where it was)

            if ( nRangeCount == 0 )

                pViewSh->Unmark();

            else if ( nRangeCount == 1 )

                pViewSh->MarkRange( rRanges[ 0 ] );

            else

            {

                // multiselection

                const ScRange & rFirst = rRanges[ 0 ];

                if ( !lcl_TabInRanges( rViewData.CurrentTabForData(), rRanges ) )

                    pViewSh->SetTabNo( rFirst.aStart.Tab() );

                pViewSh->DoneBlockMode();

                pViewSh->InitOwnBlockMode( rFirst );    /* TODO: or even the overall range? */

                rViewData.GetMarkData().MarkFromRangeList( rRanges, true );

                pViewSh->MarkDataChanged();

                rViewData.GetDocShell()->PostPaintGridAll();   // Marks (old&new)

                pViewSh->AlignToCursor( rFirst.aStart.Col(), rFirst.aStart.Row(),

                                            SC_FOLLOW_JUMP );

                pViewSh->SetCursor( rFirst.aStart.Col(), rFirst.aStart.Row() );

                //! method of the view to select RangeList

            }

            bRet = true;

        }

    }

    else if ( pShapeImp || xShapeColl.is() )            // Drawing-Layer

    {

        ScDrawView* pDrawView = pViewSh->GetScDrawView();

        if (pDrawView)

        {

            pDrawView->ScEndTextEdit();

            pDrawView->UnmarkAll();

            if (pShapeImp)      // single shape

            {

                SdrObject *pObj = pShapeImp->GetSdrObject();

                if (pObj)

                {

                    lcl_ShowObject( *pViewSh, *pDrawView, pObj );

                    SdrPageView* pPV = pDrawView->GetSdrPageView();

                    if ( pPV && pObj->getSdrPageFromSdrObject() == pPV->GetPage() )

                    {

                        pDrawView->MarkObj( pObj, pPV );

                        bRet = true;

                    }

                }

            }

            else                // Shape-Collection (xShapeColl is not 0)

            {

                //  We'll switch to the sheet where the first object is

                //  and select all objects on that sheet

                //!?throw exception when objects are on different sheets?

                tools::Long nCount = xShapeColl->getCount();

                if (nCount)

                {

                    SdrPageView* pPV = nullptr;

                    bool bAllMarked(true);

                    for ( tools::Long i = 0; i < nCount; i++ )

                    {

                        uno::Reference<drawing::XShape> xShapeInt(xShapeColl->getByIndex(i), uno::UNO_QUERY);

                        if (xShapeInt.is())

                        {

                            SdrObject* pObj = SdrObject::getSdrObjectFromXShape( xShapeInt );

                            if (pObj)

                            {

                                if (!bDrawSelModeSet && (pObj->GetLayer() == SC_LAYER_BACK))

                                {

                                    pViewSh->SetDrawSelMode(true);

                                    pViewSh->UpdateLayerLocks();

                                    bDrawSelModeSet = true;

                                }

                                if (!pPV)               // first object

                                {

                                    lcl_ShowObject( *pViewSh, *pDrawView, pObj );

                                    pPV = pDrawView->GetSdrPageView();

                                }

                                if ( pPV && pObj->getSdrPageFromSdrObject() == pPV->GetPage() )

                                {

                                    if (pDrawView->IsObjMarkable( pObj, pPV ))

                                        pDrawView->MarkObj( pObj, pPV );

                                    else

                                        bAllMarked = false;

                                }

                            }

                        }

                    }

                    if (bAllMarked)

                        bRet = true;

                }

                else

                    bRet = true; // empty XShapes (all shapes are deselected)

            }

            if (bRet)

                pViewSh->SetDrawShell(true);

        }

    }

    if (!bRet)

        throw lang::IllegalArgumentException();

    return bRet;

}

uno::Reference<drawing::XShapes> ScTabViewShell::getSelectedXShapes()

{

    uno::Reference<drawing::XShapes> xShapes;

    SdrView* pSdrView = GetScDrawView();

    if (pSdrView)

    {

        const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();

        const size_t nMarkCount = rMarkList.GetMarkCount();

        if (nMarkCount)

        {

            //  generate ShapeCollection (like in SdXImpressView::getSelection in Draw)

            //  XInterfaceRef will be returned and it has to be UsrObject-XInterface

            xShapes = drawing::ShapeCollection::create(comphelper::getProcessComponentContext());

            for (size_t i = 0; i < nMarkCount; ++i)

            {

                SdrObject* pDrawObj = rMarkList.GetMark(i)->GetMarkedSdrObj();

                if (pDrawObj)

                {

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

                    if (xShape.is())

                        xShapes->add(xShape);

                }

            }

        }

    }

    return xShapes;

}

uno::Any SAL_CALL ScTabViewObj::getSelection()

{

    SolarMutexGuard aGuard;

    ScTabViewShell* pViewSh = GetViewShell();

    rtl::Reference<ScCellRangesBase> pObj;

    if (pViewSh)

    {

        //  is something selected in drawing layer?

        uno::Reference<uno::XInterface> xRet(pViewSh->getSelectedXShapes());

        if (xRet.is())

            return uno::Any(xRet);

        //  otherwise sheet (cell) selection

        ScViewData& rViewData = pViewSh->GetViewData();

        ScDocShell* pDocSh = rViewData.GetDocShell();

        const ScMarkData& rMark = rViewData.GetMarkData();

        SCTAB nTabs = rMark.GetSelectCount();

        ScRange aRange;

        ScMarkType eMarkType = rViewData.GetSimpleArea(aRange);

        if ( nTabs == 1 && (eMarkType == SC_MARK_SIMPLE) )

        {

            // tdf#154803 - check if range is entirely merged

            ScDocument& rDoc = pDocSh->GetDocument();

            const ScMergeAttr& rMergeAttr = rDoc.GetAttr(aRange.aStart, ATTR_MERGE);

            SCCOL nColSpan = 1;

            SCROW nRowSpan = 1;