sc/source/ui/miscdlgs/anyrefdg.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <rangelst.hxx>
  21 #include <comphelper/string.hxx>
  22 #include <sfx2/app.hxx>
  23 #include <sfx2/viewsh.hxx>
  24 #include <sfx2/bindings.hxx>
  25 #include <sfx2/dispatch.hxx>
  26 #include <sfx2/viewfrm.hxx>
  27 #include <osl/diagnose.h>
  28 #include <o3tl/string_view.hxx>
  29
  30 #include <anyrefdg.hxx>
  31 #include <sc.hrc>
  32 #include <inputhdl.hxx>
  33 #include <scmod.hxx>
  34 #include <inputwin.hxx>
  35 #include <tabvwsh.hxx>
  36 #include <docsh.hxx>
  37 #include <rfindlst.hxx>
  38 #include <compiler.hxx>
  39 #include <inputopt.hxx>
  40 #include <rangeutl.hxx>
  41 #include <tokenarray.hxx>
  42 #include <comphelper/lok.hxx>
  43 #include <output.hxx>
  44
  45 #include <memory>
  46
  47 ScFormulaReferenceHelper::ScFormulaReferenceHelper(IAnyRefDialog* _pDlg,SfxBindings* _pBindings)
  48  : m_pDlg(_pDlg)
  49  , m_pRefEdit (nullptr)
  50  , m_pRefBtn (nullptr)
  51  , m_pDialog(nullptr)
  52  , m_pBindings(_pBindings)
  53  , m_nRefTab(0)
  54  , m_bHighlightRef(false)
  55 {
  56     ScInputOptions aInputOption = ScModule::get()->GetInputOptions();
  57     m_bEnableColorRef=aInputOption.GetRangeFinder();
  58 }
  59
  60 ScFormulaReferenceHelper::~ScFormulaReferenceHelper() COVERITY_NOEXCEPT_FALSE
  61 {
  62     dispose();
  63 }
  64
  65 void ScFormulaReferenceHelper::dispose()
  66 {
  67     // common cleanup for ScAnyRefDlg and ScFormulaDlg is done here
  68     HideReference();
  69     enableInput( true );
  70
  71     ScInputHandler* pInputHdl = ScModule::get()->GetInputHdl();
  72     if ( pInputHdl )
  73         pInputHdl->ResetDelayTimer();   // stop the timer for disabling the input line
  74
  75     m_pDialog = nullptr;
  76 }
  77
  78 void ScFormulaReferenceHelper::enableInput( bool bEnable )
  79 {
  80     ScDocShell* pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>));
  81     while( pDocShell )
  82     {
  83         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
  84         while( pFrame )
  85         {
  86             //  enable everything except InPlace, including bean frames
  87             if ( !pFrame->GetFrame().IsInPlace() )
  88             {
  89                 SfxViewShell* p = pFrame->GetViewShell();
  90                 ScTabViewShell* pViewSh = dynamic_cast< ScTabViewShell *>( p );
  91                 if(pViewSh!=nullptr)
  92                 {
  93                     vcl::Window *pWin=pViewSh->GetWindow();
  94                     if(pWin)
  95                     {
  96                         vcl::Window *pParent=pWin->GetParent();
  97                         if(pParent)
  98                         {
  99                             pParent->EnableInput(bEnable);
 100                             pViewSh->EnableRefInput(bEnable);
 101                         }
 102                     }
 103                 }
 104             }
 105             pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 106         }
 107
 108         pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pDocShell, checkSfxObjectShell<ScDocShell>));
 109     }
 110 }
 111
 112 void ScFormulaReferenceHelper::ShowSimpleReference(std::u16string_view rStr)
 113 {
 114     if (!m_bEnableColorRef)
 115         return;
 116
 117     m_bHighlightRef = true;
 118     ScViewData* pViewData=ScDocShell::GetViewData();
 119     if ( !pViewData )
 120         return;
 121
 122     ScDocument& rDoc = pViewData->GetDocument();
 123     ScTabViewShell* pTabViewShell=pViewData->GetViewShell();
 124
 125     ScRangeList aRangeList;
 126
 127     pTabViewShell->DoneRefMode();
 128     pTabViewShell->ClearHighlightRanges();
 129
 130     if( ParseWithNames( aRangeList, rStr, rDoc ) )
 131     {
 132         for ( size_t i = 0, nRanges = aRangeList.size(); i < nRanges; ++i )
 133         {
 134             ScRange const & rRangeEntry = aRangeList[ i ];
 135             Color aColName = ScRangeFindList::GetColorName( i );
 136             pTabViewShell->AddHighlightRange( rRangeEntry, aColName );
 137         }
 138     }
 139 }
 140
 141 bool ScFormulaReferenceHelper::ParseWithNames( ScRangeList& rRanges, std::u16string_view rStr, const ScDocument& rDoc )
 142 {
 143     rRanges.RemoveAll();
 144
 145     if (rStr.empty())
 146         return true;
 147
 148     ScAddress::Details aDetails(rDoc.GetAddressConvention(), 0, 0);
 149
 150     bool bError = false;
 151     sal_Int32 nIdx {0};
 152     do
 153     {
 154         ScRange aRange;
 155         OUString aRangeStr( o3tl::getToken(rStr, 0, ';', nIdx ) );
 156
 157         ScRefFlags nFlags = aRange.ParseAny( aRangeStr, rDoc, aDetails );
 158         if ( nFlags & ScRefFlags::VALID )
 159         {
 160             if ( (nFlags & ScRefFlags::TAB_3D) == ScRefFlags::ZERO )
 161                 aRange.aStart.SetTab( m_nRefTab );
 162             if ( (nFlags & ScRefFlags::TAB2_3D) == ScRefFlags::ZERO )
 163                 aRange.aEnd.SetTab( aRange.aStart.Tab() );
 164             rRanges.push_back( aRange );
 165         }
 166         else if ( ScRangeUtil::MakeRangeFromName( aRangeStr, rDoc, m_nRefTab, aRange, RUTL_NAMES, aDetails ) )
 167             rRanges.push_back( aRange );
 168         else
 169             bError = true;
 170     }
 171     while (nIdx>0);
 172
 173     return !bError;
 174 }
 175
 176 void ScFormulaReferenceHelper::ShowFormulaReference(const OUString& rStr)
 177 {
 178     if( !m_bEnableColorRef)
 179         return;
 180
 181     m_bHighlightRef=true;
 182     ScViewData* pViewData=ScDocShell::GetViewData();
 183     if ( !(pViewData && m_pRefComp) )
 184         return;
 185
 186     ScTabViewShell* pTabViewShell=pViewData->GetViewShell();
 187     SCCOL nCol = pViewData->GetCurX();
 188     SCROW nRow = pViewData->GetCurY();
 189     SCTAB nTab = pViewData->GetTabNo();
 190     ScAddress aPos( nCol, nRow, nTab );
 191
 192     std::unique_ptr<ScTokenArray> pScTokA(m_pRefComp->CompileString(rStr));
 193
 194     if (!(pTabViewShell && pScTokA))
 195         return;
 196
 197     const ScViewData& rViewData = pTabViewShell->GetViewData();
 198     ScDocument& rDoc = rViewData.GetDocument();
 199     pTabViewShell->DoneRefMode();
 200     pTabViewShell->ClearHighlightRanges();
 201
 202     formula::FormulaTokenArrayPlainIterator aIter(*pScTokA);
 203     const formula::FormulaToken* pToken = aIter.GetNextReference();
 204
 205     sal_uInt16 nIndex=0;
 206
 207     while(pToken!=nullptr)
 208     {
 209         bool bDoubleRef=(pToken->GetType()==formula::svDoubleRef);
 210
 211         if(pToken->GetType()==formula::svSingleRef || bDoubleRef)
 212         {
 213             ScRange aRange;
 214             if(bDoubleRef)
 215             {
 216                 ScComplexRefData aRef( *pToken->GetDoubleRef() );
 217                 aRange = aRef.toAbs(rDoc, aPos);
 218             }
 219             else
 220             {
 221                 ScSingleRefData aRef( *pToken->GetSingleRef() );
 222                 aRange.aStart = aRef.toAbs(rDoc, aPos);
 223                 aRange.aEnd = aRange.aStart;
 224             }
 225             Color aColName=ScRangeFindList::GetColorName(nIndex++);
 226             pTabViewShell->AddHighlightRange(aRange, aColName);
 227         }
 228
 229         pToken = aIter.GetNextReference();
 230     }
 231 }
 232
 233 void ScFormulaReferenceHelper::HideReference( bool bDoneRefMode )
 234 {
 235     ScViewData* pViewData=ScDocShell::GetViewData();
 236
 237     if( !(pViewData && m_bHighlightRef && m_bEnableColorRef))
 238         return;
 239
 240     ScTabViewShell* pTabViewShell=pViewData->GetViewShell();
 241
 242     if(pTabViewShell!=nullptr)
 243     {
 244         //  bDoneRefMode is sal_False when called from before SetReference.
 245         //  In that case, RefMode was just started and must not be ended now.
 246
 247         if ( bDoneRefMode )
 248             pTabViewShell->DoneRefMode();
 249         pTabViewShell->ClearHighlightRanges();
 250
 251         if( comphelper::LibreOfficeKit::isActive() )
 252         {
 253             // Clear
 254             std::vector<ReferenceMark> aReferenceMarks;
 255             ScInputHandler::SendReferenceMarks( pTabViewShell, aReferenceMarks );
 256         }
 257     }
 258     m_bHighlightRef=false;
 259 }
 260
 261 void ScFormulaReferenceHelper::ShowReference(const OUString& rStr)
 262 {
 263     if( !m_bEnableColorRef )
 264         return;
 265
 266     // Exclude ';' semicolon as it is the separator for ParseWithNames() used
 267     // in ShowSimpleReference(). Also sheet separator '.' dot is part of simple
 268     // reference (could be array col/row separator as well but then in '{' '}'
 269     // braces). Prefer '!' exclamation mark to be intersection operator rather
 270     // than Excel sheet separator.
 271     if (comphelper::string::indexOfAny( rStr, u"()+-*/^%&=<>~! #[]{},|\\@", 0) != -1)
 272     {
 273         ShowFormulaReference(rStr);
 274     }
 275     else
 276     {
 277         ShowSimpleReference(rStr);
 278     }
 279 }
 280
 281 void ScFormulaReferenceHelper::ReleaseFocus( formula::RefEdit* pEdit )
 282 {
 283     if( !m_pRefEdit && pEdit )
 284     {
 285         m_pDlg->RefInputStart( pEdit );
 286     }
 287
 288     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 289     if( !pViewShell )
 290         return;
 291
 292     pViewShell->ActiveGrabFocus();
 293     if( !m_pRefEdit )
 294         return;
 295
 296     const ScViewData& rViewData = pViewShell->GetViewData();
 297     ScDocument& rDoc = rViewData.GetDocument();
 298     ScRangeList aRangeList;
 299     if( !ParseWithNames( aRangeList, m_pRefEdit->GetText(), rDoc ) )
 300         return;
 301
 302     if ( !aRangeList.empty() )
 303     {
 304         const ScRange & rRange = aRangeList.front();
 305         pViewShell->SetTabNo( rRange.aStart.Tab() );
 306         pViewShell->MoveCursorAbs(  rRange.aStart.Col(),
 307             rRange.aStart.Row(), SC_FOLLOW_JUMP, false, false );
 308         pViewShell->MoveCursorAbs( rRange.aEnd.Col(),
 309             rRange.aEnd.Row(), SC_FOLLOW_JUMP, true, false );
 310         m_pDlg->SetReference( rRange, rDoc );
 311     }
 312 }
 313
 314 void ScFormulaReferenceHelper::Init()
 315 {
 316     ScViewData* pViewData=ScDocShell::GetViewData();    //! use pScViewShell?
 317     if ( !pViewData )
 318         return;
 319
 320     ScDocument& rDoc = pViewData->GetDocument();
 321     SCCOL nCol = pViewData->GetCurX();
 322     SCROW nRow = pViewData->GetCurY();
 323     SCTAB nTab = pViewData->GetTabNo();
 324     ScAddress aCursorPos( nCol, nRow, nTab );
 325
 326     m_pRefComp.reset( new ScCompiler( rDoc, aCursorPos, rDoc.GetGrammar()) );
 327     m_pRefComp->EnableJumpCommandReorder(false);
 328     m_pRefComp->EnableStopOnError(false);
 329
 330     m_nRefTab = nTab;
 331 }
 332
 333 IMPL_LINK_NOARG(ScFormulaReferenceHelper, ActivateHdl, weld::Widget&, bool)
 334 {
 335     if (m_pRefEdit)
 336         m_pRefEdit->GrabFocus();
 337     m_pDlg->RefInputDone(true);
 338     return true;
 339 }
 340
 341 void ScFormulaReferenceHelper::RefInputDone( bool bForced )
 342 {
 343     if ( !CanInputDone( bForced ) )
 344         return;
 345
 346     if (!m_pDialog)
 347         return;
 348
 349     // Adjust window title
 350     m_pDialog->set_title(m_sOldDialogText);
 351
 352     if (m_pRefEdit)
 353         m_pRefEdit->SetActivateHdl(Link<weld::Widget&, bool>());
 354
 355     // set button image
 356     if (m_pRefBtn)
 357     {
 358         m_pRefBtn->SetActivateHdl(Link<weld::Widget&, bool>());
 359         m_pRefBtn->SetStartImage();
 360     }
 361
 362     m_pDialog->undo_collapse();
 363
 364     m_pRefEdit = nullptr;
 365     m_pRefBtn = nullptr;
 366 }
 367
 368 void ScFormulaReferenceHelper::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
 369 {
 370     if (m_pRefEdit)
 371         return;
 372
 373     m_pRefEdit = pEdit;
 374     m_pRefBtn  = pButton;
 375
 376     // Save and adjust window title
 377     m_sOldDialogText = m_pDialog->get_title();
 378     if (weld::Label *pLabel = m_pRefEdit->GetLabelWidgetForShrinkMode())
 379     {
 380         const OUString sLabel = pLabel->get_label();
 381         if (!sLabel.isEmpty())
 382         {
 383             const OUString sNewDialogText = m_sOldDialogText + ": " + comphelper::string::stripEnd(sLabel, ':');
 384             m_pDialog->set_title(pLabel->strip_mnemonic(sNewDialogText));
 385         }
 386     }
 387
 388     m_pDialog->collapse(pEdit->GetWidget(), pButton ? pButton->GetWidget() : nullptr);
 389
 390     // set button image
 391     if (pButton)
 392         pButton->SetEndImage();
 393
 394     m_pRefEdit->SetActivateHdl(LINK(this, ScFormulaReferenceHelper, ActivateHdl));
 395     if (m_pRefBtn)
 396         m_pRefBtn->SetActivateHdl(LINK(this, ScFormulaReferenceHelper, ActivateHdl));
 397 }
 398
 399 void ScFormulaReferenceHelper::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton )
 400 {
 401     if( !pEdit )
 402         return;
 403
 404     if( m_pRefEdit == pEdit )                 // is this the active ref edit field?
 405     {
 406         m_pRefEdit->GrabFocus();              // before RefInputDone()
 407         m_pDlg->RefInputDone( true );               // finish ref input
 408     }
 409     else
 410     {
 411         m_pDlg->RefInputDone( true );               // another active ref edit?
 412         m_pDlg->RefInputStart( pEdit, pButton );    // start ref input
 413         // pRefEdit might differ from pEdit after RefInputStart() (i.e. ScFormulaDlg)
 414         if( m_pRefEdit )
 415             m_pRefEdit->GrabFocus();
 416     }
 417 }
 418
 419 void ScFormulaReferenceHelper::DoClose( sal_uInt16 nId )
 420 {
 421     SfxApplication* pSfxApp = SfxGetpApp();
 422
 423     SetDispatcherLock( false );         //! here and in dtor ?
 424
 425     SfxViewFrame* pViewFrm = SfxViewFrame::Current();
 426     if ( pViewFrm && pViewFrm->HasChildWindow(FID_INPUTLINE_STATUS) )
 427     {
 428         //  The input row is disabled with ToolBox::Disable disabled, thus it must be
 429         //  reenabled with ToolBox::Enable (before the AppWindow is enabled)
 430         //  for the buttons to be drawn as enabled.
 431         SfxChildWindow* pChild = pViewFrm->GetChildWindow(FID_INPUTLINE_STATUS);
 432         if (pChild)
 433         {
 434             ScInputWindow* pWin = static_cast<ScInputWindow*>(pChild->GetWindow());
 435             pWin->Enable();
 436         }
 437     }
 438
 439     // find parent view frame to close dialog
 440     SfxViewFrame* pMyViewFrm = nullptr;
 441     if ( m_pBindings )
 442     {
 443         SfxDispatcher* pMyDisp = m_pBindings->GetDispatcher();
 444         if (pMyDisp)
 445             pMyViewFrm = pMyDisp->GetFrame();
 446     }
 447     ScModule::get()->SetRefDialog(nId, false, pMyViewFrm);
 448
 449     pSfxApp->Broadcast( SfxHint( SfxHintId::ScKillEditView ) );
 450
 451     ScTabViewShell* pScViewShell = ScTabViewShell::GetActiveViewShell();
 452     if ( pScViewShell )
 453         pScViewShell->UpdateInputHandler(true);
 454 }
 455
 456 void ScFormulaReferenceHelper::SetDispatcherLock( bool bLock )
 457 {
 458     if (!comphelper::LibreOfficeKit::isActive())
 459     {
 460         // lock / unlock only the dispatchers of Calc documents
 461         ScDocShell* pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>));
 462         while (pDocShell)
 463         {
 464             SfxViewFrame* pFrame = SfxViewFrame::GetFirst(pDocShell);
 465             while (pFrame)
 466             {
 467                 SfxDispatcher* pDisp = pFrame->GetDispatcher();
 468                 if (pDisp)
 469                     pDisp->Lock(bLock);
 470                 pFrame = SfxViewFrame::GetNext(*pFrame, pDocShell);
 471             }
 472             pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pDocShell, checkSfxObjectShell<ScDocShell>));
 473         }
 474         return;
 475         // if a new view is created while the dialog is open,
 476         // that view's dispatcher is locked when trying to create the dialog
 477         // for that view (ScTabViewShell::CreateRefDialog)
 478     }
 479
 480     //  lock / unlock only the dispatcher of Calc document
 481     SfxDispatcher* pDisp = nullptr;
 482     if ( m_pBindings )
 483     {
 484         pDisp = m_pBindings->GetDispatcher();
 485     }
 486     else if(SfxViewFrame* pViewFrame = SfxViewFrame::Current())
 487     {
 488         if (dynamic_cast< ScTabViewShell* >(pViewFrame->GetViewShell()))
 489             pDisp = pViewFrame->GetDispatcher();
 490     }
 491
 492     if (pDisp)
 493         pDisp->Lock(bLock);
 494 }
 495
 496 void ScFormulaReferenceHelper::ViewShellChanged()
 497 {
 498     enableInput( false );
 499
 500     EnableSpreadsheets();
 501 }
 502 void ScFormulaReferenceHelper::EnableSpreadsheets(bool bFlag)
 503 {
 504     ScDocShell* pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>));
 505     while( pDocShell )
 506     {
 507         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
 508         while( pFrame )
 509         {
 510             //  enable everything except InPlace, including bean frames
 511             if ( !pFrame->GetFrame().IsInPlace() )
 512             {
 513                 SfxViewShell* p = pFrame->GetViewShell();
 514                 ScTabViewShell* pViewSh = dynamic_cast< ScTabViewShell *>( p );
 515                 if(pViewSh!=nullptr)
 516                 {
 517                     vcl::Window *pWin=pViewSh->GetWindow();
 518                     if(pWin)
 519                     {
 520                         vcl::Window *pParent=pWin->GetParent();
 521                         if(pParent)
 522                         {
 523                             pParent->EnableInput(bFlag,false);
 524                             pViewSh->EnableRefInput(bFlag);
 525                         }
 526                     }
 527                 }
 528             }
 529             pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 530         }
 531
 532         pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pDocShell, checkSfxObjectShell<ScDocShell>));
 533     }
 534 }
 535
 536 static void lcl_InvalidateWindows()
 537 {
 538     ScDocShell* pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>));
 539     while( pDocShell )
 540     {
 541         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
 542         while( pFrame )
 543         {
 544             //  enable everything except InPlace, including bean frames
 545             if ( !pFrame->GetFrame().IsInPlace() )
 546             {
 547                 SfxViewShell* p = pFrame->GetViewShell();
 548                 ScTabViewShell* pViewSh = dynamic_cast< ScTabViewShell *>( p );
 549                 if(pViewSh!=nullptr)
 550                 {
 551                     vcl::Window *pWin=pViewSh->GetWindow();
 552                     if(pWin)
 553                     {
 554                         vcl::Window *pParent=pWin->GetParent();
 555                         if(pParent)
 556                             pParent->Invalidate();
 557                     }
 558                 }
 559             }
 560             pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 561         }
 562
 563         pDocShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pDocShell, checkSfxObjectShell<ScDocShell>));
 564     }
 565 }
 566
 567 static void lcl_HideAllReferences()
 568 {
 569     SfxViewShell* pSh = SfxViewShell::GetFirst( true, checkSfxViewShell<ScTabViewShell> );
 570     while ( pSh )
 571     {
 572         static_cast<ScTabViewShell*>(pSh)->ClearHighlightRanges();
 573         pSh = SfxViewShell::GetNext( *pSh, true, checkSfxViewShell<ScTabViewShell> );
 574     }
 575 }
 576
 577 ScRefHandler::ScRefHandler(SfxDialogController& rController, SfxBindings* pB, bool bBindRef)
 578     : m_pController(&rController)
 579     , m_bInRefMode(false)
 580     , m_aHelper(this, pB)
 581     , m_pMyBindings(pB)
 582 {
 583     m_aHelper.SetDialog(rController.getDialog());
 584
 585     if( bBindRef ) EnterRefMode();
 586 }
 587
 588 bool ScRefHandler::EnterRefMode()
 589 {
 590     if( m_bInRefMode ) return false;
 591
 592     ScModule* mod = ScModule::get();
 593     mod->InputEnterHandler();
 594
 595     ScTabViewShell* pScViewShell = nullptr;
 596
 597     // title has to be from the view that opened the dialog,
 598     // even if it's not the current view
 599
 600     SfxObjectShell* pParentDoc = nullptr;
 601     if ( m_pMyBindings )
 602     {
 603         SfxDispatcher* pMyDisp = m_pMyBindings->GetDispatcher();
 604         if (pMyDisp)
 605         {
 606             SfxViewFrame* pMyViewFrm = pMyDisp->GetFrame();
 607             if (pMyViewFrm)
 608             {
 609                 pScViewShell = dynamic_cast<ScTabViewShell*>( pMyViewFrm->GetViewShell()  );
 610                 if( pScViewShell )
 611                     pScViewShell->UpdateInputHandler(true);
 612                 pParentDoc = pMyViewFrm->GetObjectShell();
 613             }
 614         }
 615     }
 616     if ( !pParentDoc && pScViewShell )                  // use current only if above fails
 617         pParentDoc = pScViewShell->GetObjectShell();
 618     if ( pParentDoc )
 619         m_aDocName = pParentDoc->GetTitle();
 620
 621     ScInputHandler* pInputHdl = mod->GetInputHdl(pScViewShell);
 622
 623     OSL_ENSURE( pInputHdl, "Missing input handler :-/" );
 624
 625     if ( pInputHdl )
 626         pInputHdl->NotifyChange( nullptr );
 627
 628     ScFormulaReferenceHelper::enableInput( false );
 629
 630     ScFormulaReferenceHelper::EnableSpreadsheets();
 631
 632     m_aHelper.Init();
 633
 634     m_aHelper.SetDispatcherLock( true );
 635
 636     m_bInRefMode = true;
 637     return m_bInRefMode;
 638 }
 639
 640 ScRefHandler::~ScRefHandler() COVERITY_NOEXCEPT_FALSE
 641 {
 642     disposeRefHandler();
 643 }
 644
 645 void ScRefHandler::disposeRefHandler()
 646 {
 647     m_pController = nullptr;
 648     LeaveRefMode();
 649     m_aHelper.dispose();
 650 }
 651
 652 bool ScRefHandler::LeaveRefMode()
 653 {
 654     if( !m_bInRefMode ) return false;
 655
 656     lcl_HideAllReferences();
 657
 658     SetDispatcherLock( false );         //! here and in DoClose ?
 659
 660     ScTabViewShell* pScViewShell = ScTabViewShell::GetActiveViewShell();
 661     if( pScViewShell )
 662         pScViewShell->UpdateInputHandler(true);
 663
 664     lcl_InvalidateWindows();
 665
 666     m_bInRefMode = false;
 667     return true;
 668 }
 669
 670 void ScRefHandler::SwitchToDocument()
 671 {
 672     ScTabViewShell* pCurrent = ScTabViewShell::GetActiveViewShell();
 673     if (pCurrent)
 674     {
 675         SfxObjectShell* pObjSh = pCurrent->GetObjectShell();
 676         if ( pObjSh && pObjSh->GetTitle() == m_aDocName )
 677         {
 678             //  right document already visible -> nothing to do
 679             return;
 680         }
 681     }
 682
 683     SfxViewShell* pSh = SfxViewShell::GetFirst( true, checkSfxViewShell<ScTabViewShell> );
 684     while ( pSh )
 685     {
 686         SfxObjectShell* pObjSh = pSh->GetObjectShell();
 687         if ( pObjSh && pObjSh->GetTitle() == m_aDocName )
 688         {
 689             //  switch to first TabViewShell for document
 690             static_cast<ScTabViewShell*>(pSh)->SetActive();
 691             return;
 692         }
 693         pSh = SfxViewShell::GetNext( *pSh, true, checkSfxViewShell<ScTabViewShell> );
 694     }
 695 }
 696
 697 bool ScRefHandler::IsDocAllowed(SfxObjectShell* pDocSh) const   // pDocSh may be 0
 698 {
 699     //  if aDocName isn't initialized, allow
 700     if ( m_aDocName.isEmpty() )
 701         return true;
 702
 703     if ( !pDocSh )
 704         return false;
 705
 706     //  default: allow only same document (overridden in function dialog)
 707     return m_aDocName==pDocSh->GetTitle();
 708 }
 709
 710 bool ScRefHandler::IsRefInputMode() const
 711 {
 712     return m_pController->getDialog()->get_visible();
 713 }
 714
 715 bool ScRefHandler::DoClose( sal_uInt16 nId )
 716 {
 717     m_aHelper.DoClose(nId);
 718     return true;
 719 }
 720
 721 void ScRefHandler::SetDispatcherLock( bool bLock )
 722 {
 723     m_aHelper.SetDispatcherLock( bLock );
 724 }
 725
 726 void ScRefHandler::ViewShellChanged()
 727 {
 728     ScFormulaReferenceHelper::ViewShellChanged();
 729 }
 730
 731 void ScRefHandler::AddRefEntry()
 732 {
 733     // override this for multi-references
 734 }
 735
 736 bool ScRefHandler::IsTableLocked() const
 737 {
 738     // the default is that the sheet can be switched during while the reference is edited
 739
 740     return false;
 741 }
 742
 743 //  RefInputStart/Done: Zoom-In (AutoHide) on single field
 744 //  (using button or movement)
 745
 746 void ScRefHandler::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
 747 {
 748     m_aHelper.RefInputStart( pEdit, pButton );
 749 }
 750
 751 void ScRefHandler::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton )
 752 {
 753     m_aHelper.ToggleCollapsed( pEdit, pButton );
 754 }
 755
 756 bool ScRefHandler::ParseWithNames( ScRangeList& rRanges, std::u16string_view rStr, const ScDocument& rDoc )
 757 {
 758     return m_aHelper.ParseWithNames( rRanges, rStr, rDoc );
 759 }
 760
 761 void ScRefHandler::HideReference( bool bDoneRefMode )
 762 {
 763     m_aHelper.HideReference( bDoneRefMode );
 764 }
 765
 766 void ScRefHandler::ShowReference(const OUString& rStr)
 767 {
 768     m_aHelper.ShowReference(rStr);
 769 }
 770
 771 void ScRefHandler::ReleaseFocus( formula::RefEdit* pEdit )
 772 {
 773     m_aHelper.ReleaseFocus( pEdit );
 774 }
 775
 776 void ScRefHandler::RefInputDone( bool bForced )
 777 {
 778     m_aHelper.RefInputDone( bForced );
 779 }
 780
 781 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */