sc/source/ui/formdlg/formula.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 "scitems.hxx"
  21 #include <sfx2/dispatch.hxx>
  22 #include <sfx2/docfile.hxx>
  23 #include <sfx2/objsh.hxx>
  24 #include <svl/zforlist.hxx>
  25 #include <svl/stritem.hxx>
  26 #include <svtools/treelistbox.hxx>
  27 #include <sfx2/viewfrm.hxx>
  28 #include <vcl/svapp.hxx>
  29 #include <vcl/mnemonic.hxx>
  30 #include <unotools/charclass.hxx>
  31 #include <tools/urlobj.hxx>
  32 #include <formula/formulahelper.hxx>
  33 #include <formula/IFunctionDescription.hxx>
  34
  35 #include "tokenuno.hxx"
  36 #include "formula.hxx"
  37 #include "formdata.hxx"
  38 #include "globstr.hrc"
  39 #include "scresid.hxx"
  40 #include "reffact.hxx"
  41 #include "document.hxx"
  42 #include "simpleformulacalc.hxx"
  43 #include "scmod.hxx"
  44 #include "inputhdl.hxx"
  45 #include "tabvwsh.hxx"
  46 #include "appoptio.hxx"
  47 #include "docsh.hxx"
  48 #include "funcdesc.hxx"
  49 #include <formula/token.hxx>
  50 #include "tokenarray.hxx"
  51 #include "sc.hrc"
  52 #include "servuno.hxx"
  53 #include "unonames.hxx"
  54 #include "externalrefmgr.hxx"
  55
  56 #include <com/sun/star/table/CellAddress.hpp>
  57
  58 using namespace formula;
  59 using namespace com::sun::star;
  60
  61 ScDocument* ScFormulaDlg::pDoc = NULL;
  62 ScAddress ScFormulaDlg::aCursorPos;
  63
  64 //      init/ shared functions for dialog
  65
  66 ScFormulaDlg::ScFormulaDlg( SfxBindings* pB, SfxChildWindow* pCW,
  67                                     vcl::Window* pParent, ScViewData* pViewData,formula::IFunctionManager* _pFunctionMgr )
  68     : formula::FormulaDlg( pB, pCW, pParent, true,true,true, _pFunctionMgr,this)
  69     , m_aHelper(this,pB)
  70 {
  71     m_aHelper.SetWindow(this);
  72     ScModule* pScMod = SC_MOD();
  73     pScMod->InputEnterHandler();
  74     ScTabViewShell* pScViewShell = NULL;
  75
  76     // title has to be from the view that opened the dialog,
  77     // even if it's not the current view
  78
  79     if ( pB )
  80     {
  81         SfxDispatcher* pMyDisp = pB->GetDispatcher();
  82         if (pMyDisp)
  83         {
  84             SfxViewFrame* pMyViewFrm = pMyDisp->GetFrame();
  85             if (pMyViewFrm)
  86             {
  87                 pScViewShell = PTR_CAST( ScTabViewShell, pMyViewFrm->GetViewShell() );
  88                 if( pScViewShell )
  89                     pScViewShell->UpdateInputHandler(true);
  90             }
  91         }
  92     }
  93
  94     if ( pDoc == NULL )
  95         pDoc = pViewData->GetDocument();
  96     m_xParser.set(ScServiceProvider::MakeInstance(SC_SERVICE_FORMULAPARS, static_cast<ScDocShell*>(pDoc->GetDocumentShell())),uno::UNO_QUERY);
  97     uno::Reference< beans::XPropertySet> xSet(m_xParser,uno::UNO_QUERY);
  98     xSet->setPropertyValue(OUString(SC_UNO_COMPILEFAP),uno::makeAny(sal_True));
  99
 100     m_xOpCodeMapper.set(ScServiceProvider::MakeInstance(SC_SERVICE_OPCODEMAPPER, static_cast<ScDocShell*>(pDoc->GetDocumentShell())),uno::UNO_QUERY);
 101
 102     ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl(pScViewShell);
 103
 104     OSL_ENSURE( pInputHdl, "Missing input handler :-/" );
 105
 106     if ( pInputHdl )
 107         pInputHdl->NotifyChange( NULL );
 108
 109     ScFormulaReferenceHelper::enableInput( false );
 110     ScFormulaReferenceHelper::EnableSpreadsheets();
 111     m_aHelper.Init();
 112     ScFormulaReferenceHelper::SetDispatcherLock( true );
 113
 114     notifyChange();
 115     fill();
 116
 117     ScFormEditData* pData = pScMod->GetFormEditData();
 118     if (!pData)
 119     {
 120         pScMod->SetRefInputHdl(pScMod->GetInputHdl());
 121
 122         pDoc = pViewData->GetDocument();
 123         SCCOL nCol = pViewData->GetCurX();
 124         SCROW nRow = pViewData->GetCurY();
 125         SCTAB nTab = pViewData->GetTabNo();
 126         aCursorPos = ScAddress( nCol, nRow, nTab );
 127
 128         pScMod->InitFormEditData();                             // create new
 129         pData = pScMod->GetFormEditData();
 130         pData->SetInputHandler(pScMod->GetInputHdl());
 131         pData->SetDocShell(pViewData->GetDocShell());
 132
 133         OSL_ENSURE(pData,"FormEditData ist nicht da");
 134
 135         formula::FormulaDlgMode eMode = FORMULA_FORMDLG_FORMULA;            // default...
 136
 137         // edit if formula exists
 138
 139         OUString aFormula;
 140         pDoc->GetFormula( nCol, nRow, nTab, aFormula );
 141         bool bEdit   = ( aFormula.getLength() > 1 );
 142         bool bMatrix = false;
 143         if ( bEdit )
 144         {
 145             bMatrix = CheckMatrix(aFormula);
 146
 147             sal_Int32 nFStart = 0;
 148             sal_Int32 nFEnd   = 0;
 149             if ( GetFormulaHelper().GetNextFunc( aFormula, false, nFStart, &nFEnd) )
 150             {
 151                 pScMod->InputReplaceSelection( aFormula );
 152                 pScMod->InputSetSelection( nFStart, nFEnd );
 153                 sal_Int32 PrivStart, PrivEnd;
 154                 pScMod->InputGetSelection( PrivStart, PrivEnd);
 155
 156                 eMode = SetMeText(pScMod->InputGetFormulaStr(),PrivStart, PrivEnd, bMatrix, true, true);
 157                 pData->SetFStart( nFStart );
 158             }
 159             else
 160                 bEdit = false;
 161         }
 162
 163         if ( !bEdit )
 164         {
 165             OUString aNewFormula('=');
 166             if ( aFormula.startsWith("=") )
 167                 aNewFormula = aFormula;
 168
 169             pScMod->InputReplaceSelection( aNewFormula );
 170             pScMod->InputSetSelection( 1, aNewFormula.getLength()+1 );
 171             sal_Int32 PrivStart, PrivEnd;
 172             pScMod->InputGetSelection( PrivStart, PrivEnd);
 173             SetMeText(pScMod->InputGetFormulaStr(),PrivStart, PrivEnd,bMatrix,false,false);
 174
 175             pData->SetFStart( 1 );      // after "="
 176         }
 177
 178         pData->SetMode( (sal_uInt16) eMode );
 179         OUString rStrExp = GetMeText();
 180
 181         Update(rStrExp);
 182     }
 183
 184 }
 185
 186 void ScFormulaDlg::notifyChange()
 187 {
 188     ScModule* pScMod = SC_MOD();
 189
 190     ScInputHandler* pInputHdl = pScMod->GetInputHdl();
 191     if ( pInputHdl )
 192         pInputHdl->NotifyChange( NULL );
 193 }
 194
 195 void ScFormulaDlg::fill()
 196 {
 197     ScModule* pScMod = SC_MOD();
 198     ScFormEditData* pData = pScMod->GetFormEditData();
 199     notifyChange();
 200     OUString rStrExp;
 201     if (pData)
 202     {
 203         //  data exists -> restore state (after switch)
 204         //  don't reinitialise pDoc and aCursorPos
 205         //pDoc = pViewData->GetDocument();
 206         if(IsInputHdl(pData->GetInputHandler()))
 207         {
 208             pScMod->SetRefInputHdl(pData->GetInputHandler());
 209         }
 210         else
 211         {
 212             PtrTabViewShell pTabViewShell;
 213             ScInputHandler* pInputHdl = GetNextInputHandler(pData->GetDocShell(),&pTabViewShell);
 214
 215             if ( pInputHdl == NULL ) //no more InputHandler for DocShell
 216             {
 217                 disableOk();
 218                 pInputHdl = pScMod->GetInputHdl();
 219             }
 220             else
 221             {
 222                 pInputHdl->SetRefViewShell(pTabViewShell);
 223             }
 224             pScMod->SetRefInputHdl(pInputHdl);
 225             pData->SetInputHandler(pInputHdl);
 226         }
 227
 228         OUString aOldFormulaTmp(pScMod->InputGetFormulaStr());
 229         pScMod->InputSetSelection( 0, aOldFormulaTmp.getLength());
 230
 231         rStrExp=pData->GetUndoStr();
 232         pScMod->InputReplaceSelection(rStrExp);
 233
 234         SetMeText(rStrExp);
 235
 236         Update();
 237         // switch back, maybe new Doc has been opened
 238         pScMod->SetRefInputHdl(NULL);
 239     }
 240 }
 241
 242 ScFormulaDlg::~ScFormulaDlg()
 243 {
 244     disposeOnce();
 245 }
 246
 247 void ScFormulaDlg::dispose()
 248 {
 249     ScModule* pScMod = SC_MOD();
 250     ScFormEditData* pData = pScMod->GetFormEditData();
 251     m_aHelper.dispose();
 252
 253     if (pData) // close dosen't destroy;
 254     {
 255         //set back reference input handler
 256         pScMod->SetRefInputHdl(NULL);
 257         StoreFormEditData(pData);
 258     }
 259     formula::FormulaDlg::dispose();
 260 }
 261
 262 bool ScFormulaDlg::IsInputHdl(ScInputHandler* pHdl)
 263 {
 264     bool bAlive = false;
 265
 266     //  belongs InputHandler to a ViewShell?
 267
 268     TypeId aScType = TYPE(ScTabViewShell);
 269     SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType );
 270     while ( pSh && !bAlive )
 271     {
 272         if (static_cast<ScTabViewShell*>(pSh)->GetInputHandler() == pHdl)
 273             bAlive = true;
 274         pSh = SfxViewShell::GetNext( *pSh, &aScType );
 275     }
 276
 277     return bAlive;
 278
 279 }
 280
 281 ScInputHandler* ScFormulaDlg::GetNextInputHandler(ScDocShell* pDocShell,PtrTabViewShell* ppViewSh)
 282 {
 283     ScInputHandler* pHdl=NULL;
 284
 285     SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
 286     while( pFrame && pHdl==NULL)
 287     {
 288         SfxViewShell* p = pFrame->GetViewShell();
 289         ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,p);
 290         if(pViewSh!=NULL)
 291         {
 292             pHdl=pViewSh->GetInputHandler();
 293             if(ppViewSh!=NULL) *ppViewSh=pViewSh;
 294         }
 295         pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 296     }
 297
 298     return pHdl;
 299 }
 300
 301 bool ScFormulaDlg::Close()
 302 {
 303     DoEnter(false);
 304     return true;
 305 }
 306
 307 //                          functions for right side
 308
 309 bool ScFormulaDlg::calculateValue( const OUString& rStrExp, OUString& rStrResult )
 310 {
 311     boost::scoped_ptr<ScSimpleFormulaCalculator> pFCell( new ScSimpleFormulaCalculator( pDoc, aCursorPos, rStrExp ) );
 312
 313     // HACK! to avoid neither #REF! from ColRowNames
 314     // if a name is added as actually range in the overall formula,
 315     // but is interpreted at the individual representation as single-cell reference
 316     bool bColRowName = pFCell->HasColRowName();
 317     if ( bColRowName )
 318     {
 319         // ColRowName from RPN-Code?
 320         if ( pFCell->GetCode()->GetCodeLen() <= 1 )
 321         {   // ==1: area
 322             // ==0: would be an area if...
 323             OUStringBuffer aBraced;
 324             aBraced.append('(');
 325             aBraced.append(rStrExp);
 326             aBraced.append(')');
 327             pFCell.reset( new ScSimpleFormulaCalculator( pDoc, aCursorPos, aBraced.makeStringAndClear() ) );
 328         }
 329         else
 330             bColRowName = false;
 331     }
 332
 333     sal_uInt16 nErrCode = pFCell->GetErrCode();
 334     if ( nErrCode == 0 )
 335     {
 336         SvNumberFormatter& aFormatter = *(pDoc->GetFormatTable());
 337         Color* pColor;
 338         if ( pFCell->IsValue() )
 339         {
 340             double n = pFCell->GetValue();
 341             sal_uLong nFormat = aFormatter.GetStandardFormat( n, 0,
 342                             pFCell->GetFormatType(), ScGlobal::eLnge );
 343             aFormatter.GetOutputString( n, nFormat,
 344                                         rStrResult, &pColor );
 345         }
 346         else
 347         {
 348             sal_uLong nFormat = aFormatter.GetStandardFormat(
 349                             pFCell->GetFormatType(), ScGlobal::eLnge);
 350             aFormatter.GetOutputString( pFCell->GetString().getString(), nFormat,
 351                                         rStrResult, &pColor );
 352         }
 353
 354         ScRange aTestRange;
 355         if ( bColRowName || (aTestRange.Parse(rStrExp) & SCA_VALID) )
 356             rStrResult += " ...";
 357             // area
 358     }
 359     else
 360         rStrResult += ScGlobal::GetErrorString(nErrCode);
 361
 362     return true;
 363 }
 364
 365 //  virtual methods of ScAnyRefDlg:
 366 void ScFormulaDlg::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
 367 {
 368     pEdit->SetSelection(Selection(0, SELECTION_MAX));
 369     ::std::pair<formula::RefButton*,formula::RefEdit*> aPair = RefInputStartBefore( pEdit, pButton );
 370     m_aHelper.RefInputStart( aPair.second, aPair.first);
 371     RefInputStartAfter( aPair.second, aPair.first );
 372 }
 373
 374 void ScFormulaDlg::RefInputDone( bool bForced )
 375 {
 376     m_aHelper.RefInputDone( bForced );
 377     RefInputDoneAfter( bForced );
 378 }
 379
 380 void ScFormulaDlg::SetReference( const ScRange& rRef, ScDocument* pRefDoc )
 381 {
 382     const IFunctionDescription* pFunc = getCurrentFunctionDescription();
 383     if ( pFunc && pFunc->getSuppressedArgumentCount() > 0 )
 384     {
 385         Selection theSel;
 386         bool bRefNull = UpdateParaWin(theSel);
 387
 388         if ( rRef.aStart != rRef.aEnd && bRefNull )
 389         {
 390             RefInputStart(GetActiveEdit());
 391         }
 392
 393         OUString      aRefStr;
 394         bool bOtherDoc = ( pRefDoc != pDoc && pRefDoc->GetDocumentShell()->HasName() );
 395         if ( bOtherDoc )
 396         {
 397             //  reference to other document - wie inputhdl.cxx
 398
 399             OSL_ENSURE(rRef.aStart.Tab()==rRef.aEnd.Tab(), "nStartTab!=nEndTab");
 400
 401             OUString aTmp(rRef.Format(SCA_VALID|SCA_TAB_3D, pRefDoc));     // immer 3d
 402
 403             SfxObjectShell* pObjSh = pRefDoc->GetDocumentShell();
 404
 405             // #i75893# convert escaped URL of the document to something user friendly
 406 //           OUString aFileName = pObjSh->GetMedium()->GetName();
 407             OUString aFileName = pObjSh->GetMedium()->GetURLObject().GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
 408
 409             aRefStr = "'";
 410             aRefStr += aFileName;
 411             aRefStr += "'#";
 412             aRefStr += aTmp;
 413         }
 414         else
 415         {
 416             // We can't use ScRange::Format here because in R1C1 mode we need
 417             // to display the reference position relative to the cursor
 418             // position.
 419             ScTokenArray aArray;
 420             ScComplexRefData aRefData;
 421             aRefData.InitRangeRel(rRef, aCursorPos);
 422             bool bSingle = aRefData.Ref1 == aRefData.Ref2;
 423             if (aCursorPos.Tab() != rRef.aStart.Tab())
 424                 aRefData.Ref1.SetFlag3D(true);
 425             if (bSingle)
 426                 aArray.AddSingleReference(aRefData.Ref1);
 427             else
 428                 aArray.AddDoubleReference(aRefData);
 429             ScCompiler aComp(pDoc, aCursorPos, aArray);
 430             aComp.SetGrammar(pDoc->GetGrammar());
 431             OUStringBuffer aBuf;
 432             aComp.CreateStringFromTokenArray(aBuf);
 433             aRefStr = aBuf.makeStringAndClear();
 434         }
 435
 436         UpdateParaWin(theSel,aRefStr);
 437     }
 438 }
 439
 440 bool ScFormulaDlg::IsRefInputMode() const
 441 {
 442     const IFunctionDescription* pDesc = getCurrentFunctionDescription();
 443     bool bRef = (pDesc && (pDesc->getSuppressedArgumentCount() > 0)) && (pDoc!=NULL);
 444     return bRef;
 445 }
 446
 447 bool ScFormulaDlg::IsDocAllowed(SfxObjectShell* pDocSh) const
 448 {
 449     //  not allowed: different from this doc, and no name
 450     //  pDocSh is always a ScDocShell
 451     if ( pDocSh && &static_cast<ScDocShell*>(pDocSh)->GetDocument() != pDoc && !pDocSh->HasName() )
 452         return false;
 453
 454     return true;        // everything else is allowed
 455 }
 456
 457 void ScFormulaDlg::SetActive()
 458 {
 459     const IFunctionDescription* pFunc = getCurrentFunctionDescription();
 460     if ( pFunc && pFunc->getSuppressedArgumentCount() > 0 )
 461     {
 462         RefInputDone();
 463         SetEdSelection();
 464     }
 465 }
 466
 467 void ScFormulaDlg::SaveLRUEntry(const ScFuncDesc* pFuncDescP)
 468 {
 469     if (pFuncDescP && pFuncDescP->nFIndex!=0)
 470     {
 471         ScModule* pScMod = SC_MOD();
 472         pScMod->InsertEntryToLRUList(pFuncDescP->nFIndex);
 473     }
 474 }
 475
 476 void ScFormulaDlg::doClose(bool /*_bOk*/)
 477 {
 478     m_aHelper.DoClose( ScFormulaDlgWrapper::GetChildWindowId() );
 479 }
 480 void ScFormulaDlg::insertEntryToLRUList(const formula::IFunctionDescription*    _pDesc)
 481 {
 482     const ScFuncDesc* pDesc = dynamic_cast<const ScFuncDesc*>(_pDesc);
 483     SaveLRUEntry(pDesc);
 484 }
 485 void ScFormulaDlg::showReference(const OUString& _sFormula)
 486 {
 487     ShowReference(_sFormula);
 488 }
 489 void ScFormulaDlg::ShowReference(const OUString& _sFormula)
 490 {
 491     m_aHelper.ShowReference(_sFormula);
 492 }
 493 void ScFormulaDlg::HideReference( bool bDoneRefMode )
 494 {
 495     m_aHelper.HideReference(bDoneRefMode);
 496 }
 497 void ScFormulaDlg::ViewShellChanged()
 498 {
 499     ScFormulaReferenceHelper::ViewShellChanged();
 500 }
 501 void ScFormulaDlg::AddRefEntry( )
 502 {
 503
 504 }
 505 bool ScFormulaDlg::IsTableLocked( ) const
 506 {
 507     // default: reference input can also be used to switch the table
 508     return false;
 509 }
 510 void ScFormulaDlg::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton)
 511 {
 512     m_aHelper.ToggleCollapsed(pEdit,pButton);
 513 }
 514 void ScFormulaDlg::ReleaseFocus( formula::RefEdit* pEdit, formula::RefButton* pButton)
 515 {
 516     m_aHelper.ReleaseFocus(pEdit,pButton);
 517 }
 518 void ScFormulaDlg::dispatch(bool _bOK, bool _bMatrixChecked)
 519 {
 520     SfxBoolItem   aRetItem( SID_DLG_RETOK, _bOK );
 521     SfxBoolItem   aMatItem( SID_DLG_MATRIX, _bMatrixChecked );
 522     SfxStringItem aStrItem( SCITEM_STRING, getCurrentFormula() );
 523
 524     // if edit line is empty (caused by document switching) -> string is empty
 525     // -> don't delete old formula
 526     if ( aStrItem.GetValue().isEmpty() )
 527         aRetItem.SetValue( false );     // sal_False = Cancel
 528
 529     ScFormulaReferenceHelper::SetDispatcherLock( false ); // turn off modal-mode
 530
 531     clear();
 532
 533     GetBindings().GetDispatcher()->Execute( SID_INS_FUNCTION,
 534                               SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
 535                               &aRetItem, &aStrItem, &aMatItem, 0L );
 536 }
 537 void ScFormulaDlg::setDispatcherLock( bool bLock )
 538 {
 539     ScFormulaReferenceHelper::SetDispatcherLock( bLock );
 540 }
 541 void ScFormulaDlg::setReferenceInput(const formula::FormEditData* _pData)
 542 {
 543     ScModule* pScMod = SC_MOD();
 544     ScFormEditData& rData = const_cast<ScFormEditData&>(dynamic_cast<const ScFormEditData&>(*_pData));
 545     pScMod->SetRefInputHdl(rData.GetInputHandler());
 546 }
 547 void ScFormulaDlg::deleteFormData()
 548 {
 549     ScModule* pScMod = SC_MOD();
 550     pScMod->ClearFormEditData();        // pData is invalid!
 551 }
 552 void ScFormulaDlg::clear()
 553 {
 554     pDoc = NULL;
 555
 556     //restore reference inputhandler
 557     ScModule* pScMod = SC_MOD();
 558     pScMod->SetRefInputHdl(NULL);
 559
 560     // force Enable() of edit line
 561     ScTabViewShell* pScViewShell = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
 562     if ( pScViewShell )
 563         pScViewShell->UpdateInputHandler();
 564 }
 565 void ScFormulaDlg::switchBack()
 566 {
 567     ScModule* pScMod = SC_MOD();
 568     // back to the document
 569     // (foreign doc could be above - #34222#)
 570     ScInputHandler* pHdl = pScMod->GetInputHdl();
 571     if ( pHdl )
 572     {
 573         pHdl->ViewShellGone(NULL);  // -> get active view
 574         pHdl->ShowRefFrame();
 575     }
 576
 577     // restore current chart (cause mouse-RefInput)
 578     ScTabViewShell* pScViewShell = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
 579     if ( pScViewShell )
 580     {
 581         ScViewData& rVD=pScViewShell->GetViewData();
 582         SCTAB nExecTab = aCursorPos.Tab();
 583         if ( nExecTab != rVD.GetTabNo() )
 584             pScViewShell->SetTabNo( nExecTab );
 585
 586         SCROW nRow=aCursorPos.Row();
 587         SCCOL nCol=aCursorPos.Col();
 588
 589         if(rVD.GetCurX()!=nCol || rVD.GetCurY()!=nRow)
 590             pScViewShell->SetCursor(nCol,nRow);
 591     }
 592 }
 593 formula::FormEditData* ScFormulaDlg::getFormEditData() const
 594 {
 595     ScModule* pScMod = SC_MOD();
 596     return pScMod->GetFormEditData();
 597 }
 598 void ScFormulaDlg::setCurrentFormula(const OUString& _sReplacement)
 599 {
 600     ScModule* pScMod = SC_MOD();
 601     {
 602         //fdo#69971 We need the EditEngine Modification handler of the inputbar that we
 603         //are feeding to be disabled while this dialog is open. Otherwise we end up in
 604         //a situation where...
 605         //a) this ScFormulaDlg changes the editengine
 606         //b) the modify callback gets called
 607         //c) which also modifies the editengine
 608         //d) on return from that modify handler the editengine attempts to use
 609         //   old node pointers which were replaced and removed by c
 610         //
 611         //We turn it off in the ctor and back on in the dtor, but if calc has
 612         //to repaint, e.g. when switching to another window and back, then in
 613         //ScMultiTextWnd::Paint a new editengine will have been created via
 614         //GetEditView with its default Modification handler enabled. So ensure
 615         //its off when we will access it via InputReplaceSelection
 616         pScMod->InputTurnOffWinEngine();
 617     }
 618     pScMod->InputReplaceSelection(_sReplacement);
 619 }
 620 void ScFormulaDlg::setSelection(sal_Int32 _nStart, sal_Int32 _nEnd)
 621 {
 622     ScModule* pScMod = SC_MOD();
 623     pScMod->InputSetSelection( _nStart, _nEnd );
 624 }
 625 void ScFormulaDlg::getSelection(sal_Int32& _nStart, sal_Int32& _nEnd) const
 626 {
 627     ScModule* pScMod = SC_MOD();
 628     pScMod->InputGetSelection( _nStart, _nEnd );
 629 }
 630 OUString ScFormulaDlg::getCurrentFormula() const
 631 {
 632     ScModule* pScMod = SC_MOD();
 633     return pScMod->InputGetFormulaStr();
 634 }
 635 formula::IFunctionManager* ScFormulaDlg::getFunctionManager()
 636 {
 637     return ScGlobal::GetStarCalcFunctionMgr();
 638 }
 639 uno::Reference< sheet::XFormulaParser> ScFormulaDlg::getFormulaParser() const
 640 {
 641     return m_xParser;
 642 }
 643 uno::Reference< sheet::XFormulaOpCodeMapper> ScFormulaDlg::getFormulaOpCodeMapper() const
 644 {
 645     return m_xOpCodeMapper;
 646 }
 647
 648 table::CellAddress ScFormulaDlg::getReferencePosition() const
 649 {
 650     return table::CellAddress(aCursorPos.Tab(),aCursorPos.Col(),aCursorPos.Row());
 651 }
 652
 653 ::std::unique_ptr<formula::FormulaTokenArray> ScFormulaDlg::convertToTokenArray(const uno::Sequence< sheet::FormulaToken >& _aTokenList)
 654 {
 655     ::std::unique_ptr<formula::FormulaTokenArray> pArray(new ScTokenArray());
 656     pArray->Fill(_aTokenList, pDoc->GetSharedStringPool(), pDoc->GetExternalRefManager());
 657     return pArray;
 658 }
 659
 660 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */