Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 760 insertions, 0 deletions

diff --git a/sc/source/ui/miscdlgs/anyrefdg.cxx b/sc/source/ui/miscdlgs/anyrefdg.cxx
new file mode 100644
index 000000000..e9663dc3f
--- /dev/null
+++ b/sc/source/ui/miscdlgs/anyrefdg.cxx
@@ -0,0 +1,760 @@
+/* -*- 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 <rangelst.hxx>
+#include <comphelper/string.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/viewfrm.hxx>
+
+#include <anyrefdg.hxx>
+#include <sc.hrc>
+#include <inputhdl.hxx>
+#include <scmod.hxx>
+#include <inputwin.hxx>
+#include <tabvwsh.hxx>
+#include <docsh.hxx>
+#include <rfindlst.hxx>
+#include <compiler.hxx>
+#include <inputopt.hxx>
+#include <rangeutl.hxx>
+#include <tokenarray.hxx>
+#include <comphelper/lok.hxx>
+#include <output.hxx>
+
+#include <memory>
+
+ScFormulaReferenceHelper::ScFormulaReferenceHelper(IAnyRefDialog* _pDlg,SfxBindings* _pBindings)
+ : m_pDlg(_pDlg)
+ , m_pRefEdit (nullptr)
+ , m_pRefBtn (nullptr)
+ , m_pDialog(nullptr)
+ , m_pBindings(_pBindings)
+ , m_nRefTab(0)
+ , m_bHighlightRef(false)
+{
+    ScInputOptions aInputOption=SC_MOD()->GetInputOptions();
+    m_bEnableColorRef=aInputOption.GetRangeFinder();
+}
+
+ScFormulaReferenceHelper::~ScFormulaReferenceHelper() COVERITY_NOEXCEPT_FALSE
+{
+    dispose();
+}
+
+void ScFormulaReferenceHelper::dispose()
+{
+    // common cleanup for ScAnyRefDlg and ScFormulaDlg is done here
+    HideReference();
+    enableInput( true );
+
+    ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl();
+    if ( pInputHdl )
+        pInputHdl->ResetDelayTimer();   // stop the timer for disabling the input line
+
+    m_pDialog = nullptr;
+}
+
+void ScFormulaReferenceHelper::enableInput( bool bEnable )
+{
+    ScDocShell* pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>));
+    while( pDocShell )
+    {
+        SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
+        while( pFrame )
+        {
+            //  enable everything except InPlace, including bean frames
+            if ( !pFrame->GetFrame().IsInPlace() )
+            {
+                SfxViewShell* p = pFrame->GetViewShell();
+                ScTabViewShell* pViewSh = dynamic_cast< ScTabViewShell *>( p );
+                if(pViewSh!=nullptr)
+                {
+                    vcl::Window *pWin=pViewSh->GetWindow();
+                    if(pWin)
+                    {
+                        vcl::Window *pParent=pWin->GetParent();
+                        if(pParent)
+                        {
+                            pParent->EnableInput(bEnable);
+                            pViewSh->EnableRefInput(bEnable);
+                        }
+                    }
+                }
+            }
+            pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
+        }
+
+        pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pDocShell, checkSfxObjectShell<ScDocShell>));
+    }
+}
+
+void ScFormulaReferenceHelper::ShowSimpleReference(const OUString& rStr)
+{
+    if (m_bEnableColorRef)
+    {
+        m_bHighlightRef = true;
+        ScViewData* pViewData=ScDocShell::GetViewData();
+        if ( pViewData )
+        {
+            ScDocument* pDoc=pViewData->GetDocument();
+            ScTabViewShell* pTabViewShell=pViewData->GetViewShell();
+
+            ScRangeList aRangeList;
+
+            pTabViewShell->DoneRefMode();
+            pTabViewShell->ClearHighlightRanges();
+
+            if( ParseWithNames( aRangeList, rStr, *pDoc ) )
+            {
+                for ( size_t i = 0, nRanges = aRangeList.size(); i < nRanges; ++i )
+                {
+                    ScRange const & rRangeEntry = aRangeList[ i ];
+                    Color aColName = ScRangeFindList::GetColorName( i );
+                    pTabViewShell->AddHighlightRange( rRangeEntry, aColName );
+               }
+            }
+        }
+    }
+}
+
+bool ScFormulaReferenceHelper::ParseWithNames( ScRangeList& rRanges, const OUString& rStr, const ScDocument& rDoc )
+{
+    rRanges.RemoveAll();
+
+    if (rStr.isEmpty())
+        return true;
+
+    ScAddress::Details aDetails(rDoc.GetAddressConvention(), 0, 0);
+
+    bool bError = false;
+    sal_Int32 nIdx {0};
+    do
+    {
+        ScRange aRange;
+        OUString aRangeStr( rStr.getToken( 0, ';', nIdx ) );
+
+        ScRefFlags nFlags = aRange.ParseAny( aRangeStr, &rDoc, aDetails );
+        if ( nFlags & ScRefFlags::VALID )
+        {
+            if ( (nFlags & ScRefFlags::TAB_3D) == ScRefFlags::ZERO )
+                aRange.aStart.SetTab( m_nRefTab );
+            if ( (nFlags & ScRefFlags::TAB2_3D) == ScRefFlags::ZERO )
+                aRange.aEnd.SetTab( aRange.aStart.Tab() );
+            rRanges.push_back( aRange );
+        }
+        else if ( ScRangeUtil::MakeRangeFromName( aRangeStr, &rDoc, m_nRefTab, aRange, RUTL_NAMES, aDetails ) )
+            rRanges.push_back( aRange );
+        else
+            bError = true;
+    }
+    while (nIdx>0);
+
+    return !bError;
+}
+
+void ScFormulaReferenceHelper::ShowFormulaReference(const OUString& rStr)
+{
+    if( m_bEnableColorRef)
+    {
+        m_bHighlightRef=true;
+        ScViewData* pViewData=ScDocShell::GetViewData();
+        if ( pViewData && m_pRefComp )
+        {
+            ScTabViewShell* pTabViewShell=pViewData->GetViewShell();
+            SCCOL nCol = pViewData->GetCurX();
+            SCROW nRow = pViewData->GetCurY();
+            SCTAB nTab = pViewData->GetTabNo();
+            ScAddress aPos( nCol, nRow, nTab );
+
+            std::unique_ptr<ScTokenArray> pScTokA(m_pRefComp->CompileString(rStr));
+
+            if (pTabViewShell && pScTokA)
+            {
+                const ScViewData& rViewData = pTabViewShell->GetViewData();
+                ScDocument* pDoc = rViewData.GetDocument();
+                pTabViewShell->DoneRefMode();
+                pTabViewShell->ClearHighlightRanges();
+
+                formula::FormulaTokenArrayPlainIterator aIter(*pScTokA);
+                const formula::FormulaToken* pToken = aIter.GetNextReference();
+
+                sal_uInt16 nIndex=0;
+
+                while(pToken!=nullptr)
+                {
+                    bool bDoubleRef=(pToken->GetType()==formula::svDoubleRef);
+
+                    if(pToken->GetType()==formula::svSingleRef || bDoubleRef)
+                    {
+                        ScRange aRange;
+                        if(bDoubleRef)
+                        {
+                            ScComplexRefData aRef( *pToken->GetDoubleRef() );
+                            aRange = aRef.toAbs(pDoc, aPos);
+                        }
+                        else
+                        {
+                            ScSingleRefData aRef( *pToken->GetSingleRef() );
+                            aRange.aStart = aRef.toAbs(pDoc, aPos);
+                            aRange.aEnd = aRange.aStart;
+                        }
+                        Color aColName=ScRangeFindList::GetColorName(nIndex++);
+                        pTabViewShell->AddHighlightRange(aRange, aColName);
+                    }
+
+                    pToken = aIter.GetNextReference();
+                }
+            }
+        }
+    }
+}
+
+void ScFormulaReferenceHelper::HideReference( bool bDoneRefMode )
+{
+    ScViewData* pViewData=ScDocShell::GetViewData();
+
+    if( pViewData && m_bHighlightRef && m_bEnableColorRef)
+    {
+        ScTabViewShell* pTabViewShell=pViewData->GetViewShell();
+
+        if(pTabViewShell!=nullptr)
+        {
+            //  bDoneRefMode is sal_False when called from before SetReference.
+            //  In that case, RefMode was just started and must not be ended now.
+
+            if ( bDoneRefMode )
+                pTabViewShell->DoneRefMode();
+            pTabViewShell->ClearHighlightRanges();
+
+            if( comphelper::LibreOfficeKit::isActive() )
+            {
+                // Clear
+                std::vector<ReferenceMark> aReferenceMarks;
+                ScInputHandler::SendReferenceMarks( pTabViewShell, aReferenceMarks );
+            }
+        }
+        m_bHighlightRef=false;
+    }
+}
+
+void ScFormulaReferenceHelper::ShowReference(const OUString& rStr)
+{
+    if( m_bEnableColorRef )
+    {
+        if( rStr.indexOf('(') != -1 ||
+            rStr.indexOf('+') != -1 ||
+            rStr.indexOf('*') != -1 ||
+            rStr.indexOf('-') != -1 ||
+            rStr.indexOf('/') != -1 ||
+            rStr.indexOf('&') != -1 ||
+            rStr.indexOf('<') != -1 ||
+            rStr.indexOf('>') != -1 ||
+            rStr.indexOf('=') != -1 ||
+            rStr.indexOf('^') != -1 )
+        {
+            ShowFormulaReference(rStr);
+        }
+        else
+        {
+            ShowSimpleReference(rStr);
+        }
+    }
+}
+
+void ScFormulaReferenceHelper::ReleaseFocus( formula::RefEdit* pEdit )
+{
+    if( !m_pRefEdit && pEdit )
+    {
+        m_pDlg->RefInputStart( pEdit );
+    }
+
+    ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
+    if( pViewShell )
+    {
+        pViewShell->ActiveGrabFocus();
+        if( m_pRefEdit )
+        {
+            const ScViewData& rViewData = pViewShell->GetViewData();
+            ScDocument* pDoc = rViewData.GetDocument();
+            ScRangeList aRangeList;
+            if( ParseWithNames( aRangeList, m_pRefEdit->GetText(), *pDoc ) )
+            {
+                if ( !aRangeList.empty() )
+                {
+                    const ScRange & rRange = aRangeList.front();
+                    pViewShell->SetTabNo( rRange.aStart.Tab() );
+                    pViewShell->MoveCursorAbs(  rRange.aStart.Col(),
+                        rRange.aStart.Row(), SC_FOLLOW_JUMP, false, false );
+                    pViewShell->MoveCursorAbs( rRange.aEnd.Col(),
+                        rRange.aEnd.Row(), SC_FOLLOW_JUMP, true, false );
+                    m_pDlg->SetReference( rRange, *pDoc );
+                }
+            }
+        }
+    }
+}
+
+void ScFormulaReferenceHelper::Init()
+{
+    ScViewData* pViewData=ScDocShell::GetViewData();    //! use pScViewShell?
+    if ( pViewData )
+    {
+        ScDocument* pDoc = pViewData->GetDocument();
+        SCCOL nCol = pViewData->GetCurX();
+        SCROW nRow = pViewData->GetCurY();
+        SCTAB nTab = pViewData->GetTabNo();
+        ScAddress aCursorPos( nCol, nRow, nTab );
+
+        m_pRefComp.reset( new ScCompiler( pDoc, aCursorPos, pDoc->GetGrammar()) );
+        m_pRefComp->EnableJumpCommandReorder(false);
+        m_pRefComp->EnableStopOnError(false);
+
+        m_nRefTab = nTab;
+    }
+}
+
+IMPL_LINK_NOARG(ScFormulaReferenceHelper, ActivateHdl, weld::Widget&, bool)
+{
+    if (m_pRefEdit)
+        m_pRefEdit->GrabFocus();
+    m_pDlg->RefInputDone(true);
+    return true;
+}
+
+void ScFormulaReferenceHelper::RefInputDone( bool bForced )
+{
+    if ( CanInputDone( bForced ) )
+    {
+        if (m_pDialog)
+        {
+            // Adjust window title
+            m_pDialog->set_title(m_sOldDialogText);
+
+            if (m_pRefEdit)
+                m_pRefEdit->SetActivateHdl(Link<weld::Widget&, bool>());
+
+            // set button image
+            if (m_pRefBtn)
+            {
+                m_pRefBtn->SetActivateHdl(Link<weld::Widget&, bool>());
+                m_pRefBtn->SetStartImage();
+            }
+
+            m_pDialog->undo_collapse();
+
+            m_pRefEdit = nullptr;
+            m_pRefBtn = nullptr;
+        }
+    }
+}
+
+void ScFormulaReferenceHelper::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
+{
+    if (!m_pRefEdit)
+    {
+        m_pRefEdit = pEdit;
+        m_pRefBtn  = pButton;
+
+        // Save and adjust window title
+        m_sOldDialogText = m_pDialog->get_title();
+        if (weld::Label *pLabel = m_pRefEdit->GetLabelWidgetForShrinkMode())
+        {
+            const OUString sLabel = pLabel->get_label();
+            if (!sLabel.isEmpty())
+            {
+                const OUString sNewDialogText = m_sOldDialogText + ": " + comphelper::string::stripEnd(sLabel, ':');
+                m_pDialog->set_title(pLabel->strip_mnemonic(sNewDialogText));
+            }
+        }
+
+        m_pDialog->collapse(pEdit->GetWidget(), pButton ? pButton->GetWidget() : nullptr);
+
+        // set button image
+        if (pButton)
+            pButton->SetEndImage();
+
+        m_pRefEdit->SetActivateHdl(LINK(this, ScFormulaReferenceHelper, ActivateHdl));
+        if (m_pRefBtn)
+            m_pRefBtn->SetActivateHdl(LINK(this, ScFormulaReferenceHelper, ActivateHdl));
+    }
+}
+
+void ScFormulaReferenceHelper::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton )
+{
+    if( pEdit )
+    {
+        if( m_pRefEdit == pEdit )                 // is this the active ref edit field?
+        {
+            m_pRefEdit->GrabFocus();              // before RefInputDone()
+            m_pDlg->RefInputDone( true );               // finish ref input
+        }
+        else
+        {
+            m_pDlg->RefInputDone( true );               // another active ref edit?
+            m_pDlg->RefInputStart( pEdit, pButton );    // start ref input
+            // pRefEdit might differ from pEdit after RefInputStart() (i.e. ScFormulaDlg)
+            if( m_pRefEdit )
+                m_pRefEdit->GrabFocus();
+        }
+    }
+}
+
+void ScFormulaReferenceHelper::DoClose( sal_uInt16 nId )
+{
+    SfxApplication* pSfxApp = SfxGetpApp();
+
+    SetDispatcherLock( false );         //! here and in dtor ?
+
+    SfxViewFrame* pViewFrm = SfxViewFrame::Current();
+    if ( pViewFrm && pViewFrm->HasChildWindow(FID_INPUTLINE_STATUS) )
+    {
+        //  The input row is disabled with ToolBox::Disable disabled, thus it must be
+        //  reenabled with ToolBox::Enable (before the AppWindow is enabled)
+        //  for the buttons to be drawn as enabled.
+        SfxChildWindow* pChild = pViewFrm->GetChildWindow(FID_INPUTLINE_STATUS);
+        if (pChild)
+        {
+            ScInputWindow* pWin = static_cast<ScInputWindow*>(pChild->GetWindow());
+            pWin->Enable();
+        }
+    }
+
+    // find parent view frame to close dialog
+    SfxViewFrame* pMyViewFrm = nullptr;
+    if ( m_pBindings )
+    {
+        SfxDispatcher* pMyDisp = m_pBindings->GetDispatcher();
+        if (pMyDisp)
+            pMyViewFrm = pMyDisp->GetFrame();
+    }
+    SC_MOD()->SetRefDialog( nId, false, pMyViewFrm );
+
+    pSfxApp->Broadcast( SfxHint( SfxHintId::ScKillEditView ) );
+
+    ScTabViewShell* pScViewShell = ScTabViewShell::GetActiveViewShell();
+    if ( pScViewShell )
+        pScViewShell->UpdateInputHandler(true);
+}
+
+void ScFormulaReferenceHelper::SetDispatcherLock( bool bLock )
+{
+    //  lock / unlock only the dispatcher of Calc document
+    SfxDispatcher* pDisp = nullptr;
+    if ( m_pBindings )
+    {
+        pDisp = m_pBindings->GetDispatcher();
+    }
+    else if(SfxViewFrame* pViewFrame = SfxViewFrame::Current())
+    {
+        if (dynamic_cast< ScTabViewShell* >(pViewFrame->GetViewShell()))
+            pDisp = pViewFrame->GetDispatcher();
+    }
+
+    if (pDisp)
+        pDisp->Lock(bLock);
+}
+
+void ScFormulaReferenceHelper::ViewShellChanged()
+{
+    enableInput( false );
+
+    EnableSpreadsheets();
+}
+void ScFormulaReferenceHelper::EnableSpreadsheets(bool bFlag)
+{
+    ScDocShell* pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>));
+    while( pDocShell )
+    {
+        SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
+        while( pFrame )
+        {
+            //  enable everything except InPlace, including bean frames
+            if ( !pFrame->GetFrame().IsInPlace() )
+            {
+                SfxViewShell* p = pFrame->GetViewShell();
+                ScTabViewShell* pViewSh = dynamic_cast< ScTabViewShell *>( p );
+                if(pViewSh!=nullptr)
+                {
+                    vcl::Window *pWin=pViewSh->GetWindow();
+                    if(pWin)
+                    {
+                        vcl::Window *pParent=pWin->GetParent();
+                        if(pParent)
+                        {
+                            pParent->EnableInput(bFlag,false);
+                            pViewSh->EnableRefInput(bFlag);
+                        }
+                    }
+                }
+            }
+            pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
+        }
+
+        pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pDocShell, checkSfxObjectShell<ScDocShell>));
+    }
+}
+
+static void lcl_InvalidateWindows()
+{
+    ScDocShell* pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>));
+    while( pDocShell )
+    {
+        SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
+        while( pFrame )
+        {
+            //  enable everything except InPlace, including bean frames
+            if ( !pFrame->GetFrame().IsInPlace() )
+            {
+                SfxViewShell* p = pFrame->GetViewShell();
+                ScTabViewShell* pViewSh = dynamic_cast< ScTabViewShell *>( p );
+                if(pViewSh!=nullptr)
+                {
+                    vcl::Window *pWin=pViewSh->GetWindow();
+                    if(pWin)
+                    {
+                        vcl::Window *pParent=pWin->GetParent();
+                        if(pParent)
+                            pParent->Invalidate();
+                    }
+                }
+            }
+            pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
+        }
+
+        pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pDocShell, checkSfxObjectShell<ScDocShell>));
+    }
+}
+
+static void lcl_HideAllReferences()
+{
+    SfxViewShell* pSh = SfxViewShell::GetFirst( true, checkSfxViewShell<ScTabViewShell> );
+    while ( pSh )
+    {
+        static_cast<ScTabViewShell*>(pSh)->ClearHighlightRanges();
+        pSh = SfxViewShell::GetNext( *pSh, true, checkSfxViewShell<ScTabViewShell> );
+    }
+}
+
+ScRefHandler::ScRefHandler(SfxDialogController& rController, SfxBindings* pB, bool bBindRef)
+    : m_pController(&rController)
+    , m_bInRefMode(false)
+    , m_aHelper(this, pB)
+    , m_pMyBindings(pB)
+{
+    m_aHelper.SetDialog(rController.getDialog());
+
+    if( bBindRef ) EnterRefMode();
+}
+
+bool ScRefHandler::EnterRefMode()
+{
+    if( m_bInRefMode ) return false;
+
+    SC_MOD()->InputEnterHandler();
+
+    ScTabViewShell* pScViewShell = nullptr;
+
+    // title has to be from the view that opened the dialog,
+    // even if it's not the current view
+
+    SfxObjectShell* pParentDoc = nullptr;
+    if ( m_pMyBindings )
+    {
+        SfxDispatcher* pMyDisp = m_pMyBindings->GetDispatcher();
+        if (pMyDisp)
+        {
+            SfxViewFrame* pMyViewFrm = pMyDisp->GetFrame();
+            if (pMyViewFrm)
+            {
+                pScViewShell = dynamic_cast<ScTabViewShell*>( pMyViewFrm->GetViewShell()  );
+                if( pScViewShell )
+                    pScViewShell->UpdateInputHandler(true);
+                pParentDoc = pMyViewFrm->GetObjectShell();
+            }
+        }
+    }
+    if ( !pParentDoc && pScViewShell )                  // use current only if above fails
+        pParentDoc = pScViewShell->GetObjectShell();
+    if ( pParentDoc )
+        m_aDocName = pParentDoc->GetTitle();
+
+    ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl(pScViewShell);
+
+    OSL_ENSURE( pInputHdl, "Missing input handler :-/" );
+
+    if ( pInputHdl )
+        pInputHdl->NotifyChange( nullptr );
+
+    ScFormulaReferenceHelper::enableInput( false );
+
+    ScFormulaReferenceHelper::EnableSpreadsheets();
+
+    m_aHelper.Init();
+
+    m_aHelper.SetDispatcherLock( true );
+
+    m_bInRefMode = true;
+    return m_bInRefMode;
+}
+
+ScRefHandler::~ScRefHandler() COVERITY_NOEXCEPT_FALSE
+{
+    disposeRefHandler();
+}
+
+void ScRefHandler::disposeRefHandler()
+{
+    m_pController = nullptr;
+    LeaveRefMode();
+    m_aHelper.dispose();
+}
+
+bool ScRefHandler::LeaveRefMode()
+{
+    if( !m_bInRefMode ) return false;
+
+    lcl_HideAllReferences();
+
+    SetDispatcherLock( false );         //! here and in DoClose ?
+
+    ScTabViewShell* pScViewShell = ScTabViewShell::GetActiveViewShell();
+    if( pScViewShell )
+        pScViewShell->UpdateInputHandler(true);
+
+    lcl_InvalidateWindows();
+
+    m_bInRefMode = false;
+    return true;
+}
+
+void ScRefHandler::SwitchToDocument()
+{
+    ScTabViewShell* pCurrent = ScTabViewShell::GetActiveViewShell();
+    if (pCurrent)
+    {
+        SfxObjectShell* pObjSh = pCurrent->GetObjectShell();
+        if ( pObjSh && pObjSh->GetTitle() == m_aDocName )
+        {
+            //  right document already visible -> nothing to do
+            return;
+        }
+    }
+
+    SfxViewShell* pSh = SfxViewShell::GetFirst( true, checkSfxViewShell<ScTabViewShell> );
+    while ( pSh )
+    {
+        SfxObjectShell* pObjSh = pSh->GetObjectShell();
+        if ( pObjSh && pObjSh->GetTitle() == m_aDocName )
+        {
+            //  switch to first TabViewShell for document
+            static_cast<ScTabViewShell*>(pSh)->SetActive();
+            return;
+        }
+        pSh = SfxViewShell::GetNext( *pSh, true, checkSfxViewShell<ScTabViewShell> );
+    }
+}
+
+bool ScRefHandler::IsDocAllowed(SfxObjectShell* pDocSh) const   // pDocSh may be 0
+{
+    //  if aDocName isn't initialized, allow
+    if ( m_aDocName.isEmpty() )
+        return true;
+
+    if ( !pDocSh )
+        return false;
+
+    //  default: allow only same document (overridden in function dialog)
+    return m_aDocName==pDocSh->GetTitle();
+}
+
+bool ScRefHandler::IsRefInputMode() const
+{
+    return m_pController->getDialog()->get_visible();
+}
+
+bool ScRefHandler::DoClose( sal_uInt16 nId )
+{
+    m_aHelper.DoClose(nId);
+    return true;
+}
+
+void ScRefHandler::SetDispatcherLock( bool bLock )
+{
+    m_aHelper.SetDispatcherLock( bLock );
+}
+
+void ScRefHandler::ViewShellChanged()
+{
+    ScFormulaReferenceHelper::ViewShellChanged();
+}
+
+void ScRefHandler::AddRefEntry()
+{
+    // override this for multi-references
+}
+
+bool ScRefHandler::IsTableLocked() const
+{
+    // the default is that the sheet can be switched during while the reference is edited
+
+    return false;
+}
+
+//  RefInputStart/Done: Zoom-In (AutoHide) on single field
+//  (using button or movement)
+
+void ScRefHandler::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
+{
+    m_aHelper.RefInputStart( pEdit, pButton );
+}
+
+void ScRefHandler::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton )
+{
+    m_aHelper.ToggleCollapsed( pEdit, pButton );
+}
+
+bool ScRefHandler::ParseWithNames( ScRangeList& rRanges, const OUString& rStr, const ScDocument& rDoc )
+{
+    return m_aHelper.ParseWithNames( rRanges, rStr, rDoc );
+}
+
+void ScRefHandler::HideReference( bool bDoneRefMode )
+{
+    m_aHelper.HideReference( bDoneRefMode );
+}
+
+void ScRefHandler::ShowReference(const OUString& rStr)
+{
+    m_aHelper.ShowReference(rStr);
+}
+
+void ScRefHandler::ReleaseFocus( formula::RefEdit* pEdit )
+{
+    m_aHelper.ReleaseFocus( pEdit );
+}
+
+void ScRefHandler::RefInputDone( bool bForced )
+{
+    m_aHelper.RefInputDone( bForced );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */