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
  59 using namespace formula;
  60 using namespace com::sun::star;
  61
  62 ScDocument* ScFormulaDlg::pDoc = NULL;
  63 ScAddress ScFormulaDlg::aCursorPos;
  64
  65
  66 //      Initialisierung / gemeinsame Funktionen  fuer Dialog
  67
  68
  69 ScFormulaDlg::ScFormulaDlg( SfxBindings* pB, SfxChildWindow* pCW,
  70                                     Window* pParent, ScViewData* pViewData,formula::IFunctionManager* _pFunctionMgr )
  71     : formula::FormulaDlg( pB, pCW, pParent, true,true,true, _pFunctionMgr,this)
  72     , m_aHelper(this,pB)
  73 {
  74     m_aHelper.SetWindow(this);
  75     ScModule* pScMod = SC_MOD();
  76     pScMod->InputEnterHandler();
  77     ScTabViewShell* pScViewShell = NULL;
  78
  79     // title has to be from the view that opened the dialog,
  80     // even if it's not the current view
  81
  82     if ( pB )
  83     {
  84         SfxDispatcher* pMyDisp = pB->GetDispatcher();
  85         if (pMyDisp)
  86         {
  87             SfxViewFrame* pMyViewFrm = pMyDisp->GetFrame();
  88             if (pMyViewFrm)
  89             {
  90                 pScViewShell = PTR_CAST( ScTabViewShell, pMyViewFrm->GetViewShell() );
  91                 if( pScViewShell )
  92                     pScViewShell->UpdateInputHandler(true);
  93             }
  94         }
  95     }
  96
  97     if ( pDoc == NULL )
  98         pDoc = pViewData->GetDocument();
  99     m_xParser.set(ScServiceProvider::MakeInstance(SC_SERVICE_FORMULAPARS,(ScDocShell*)pDoc->GetDocumentShell()),uno::UNO_QUERY);
 100     uno::Reference< beans::XPropertySet> xSet(m_xParser,uno::UNO_QUERY);
 101     xSet->setPropertyValue(OUString(SC_UNO_COMPILEFAP),uno::makeAny(sal_True));
 102
 103     m_xOpCodeMapper.set(ScServiceProvider::MakeInstance(SC_SERVICE_OPCODEMAPPER,(ScDocShell*)pDoc->GetDocumentShell()),uno::UNO_QUERY);
 104
 105     ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl(pScViewShell);
 106
 107     OSL_ENSURE( pInputHdl, "Missing input handler :-/" );
 108
 109     if ( pInputHdl )
 110         pInputHdl->NotifyChange( NULL );
 111
 112     m_aHelper.enableInput( false );
 113     m_aHelper.EnableSpreadsheets();
 114     m_aHelper.Init();
 115     m_aHelper.SetDispatcherLock( true );
 116
 117     notifyChange();
 118     fill();
 119
 120     ScFormEditData* pData = pScMod->GetFormEditData();
 121     if (!pData)
 122     {
 123         //Nun wird es Zeit den Inputhandler festzulegen
 124         pScMod->SetRefInputHdl(pScMod->GetInputHdl());
 125
 126         pDoc = pViewData->GetDocument();
 127         SCCOL nCol = pViewData->GetCurX();
 128         SCROW nRow = pViewData->GetCurY();
 129         SCTAB nTab = pViewData->GetTabNo();
 130         aCursorPos = ScAddress( nCol, nRow, nTab );
 131
 132         pScMod->InitFormEditData();                             // neu anlegen
 133         pData = pScMod->GetFormEditData();
 134         pData->SetInputHandler(pScMod->GetInputHdl());
 135         pData->SetDocShell(pViewData->GetDocShell());
 136
 137         OSL_ENSURE(pData,"FormEditData ist nicht da");
 138
 139         formula::FormulaDlgMode eMode = FORMULA_FORMDLG_FORMULA;            // Default...
 140
 141         //  Formel vorhanden? Dann editieren
 142
 143         OUString aFormula;
 144         pDoc->GetFormula( nCol, nRow, nTab, aFormula );
 145         bool bEdit   = ( aFormula.getLength() > 1 );
 146         bool bMatrix = false;
 147         if ( bEdit )
 148         {
 149             bMatrix = CheckMatrix(aFormula);
 150
 151             sal_Int32 nFStart = 0;
 152             sal_Int32 nFEnd   = 0;
 153             if ( GetFormulaHelper().GetNextFunc( aFormula, false, nFStart, &nFEnd) )
 154             {
 155                 pScMod->InputReplaceSelection( aFormula );
 156                 pScMod->InputSetSelection( nFStart, nFEnd );
 157                 sal_Int32 PrivStart, PrivEnd;
 158                 pScMod->InputGetSelection( PrivStart, PrivEnd);
 159
 160                 eMode = SetMeText(pScMod->InputGetFormulaStr(),PrivStart, PrivEnd, bMatrix, true, true);
 161                 pData->SetFStart( nFStart );
 162             }
 163             else
 164                 bEdit = false;
 165         }
 166
 167         if ( !bEdit )
 168         {
 169             OUString aNewFormula('=');
 170             if ( aFormula.startsWith("=") )
 171                 aNewFormula = aFormula;
 172
 173             pScMod->InputReplaceSelection( aNewFormula );
 174             pScMod->InputSetSelection( 1, aNewFormula.getLength()+1 );
 175             sal_Int32 PrivStart, PrivEnd;
 176             pScMod->InputGetSelection( PrivStart, PrivEnd);
 177             SetMeText(pScMod->InputGetFormulaStr(),PrivStart, PrivEnd,bMatrix,false,false);
 178
 179             pData->SetFStart( 1 );      // hinter dem "="
 180         }
 181
 182         pData->SetMode( (sal_uInt16) eMode );
 183         OUString rStrExp = GetMeText();
 184
 185         Update(rStrExp);
 186     }
 187
 188 }
 189
 190 void ScFormulaDlg::notifyChange()
 191 {
 192     ScModule* pScMod = SC_MOD();
 193
 194     ScInputHandler* pInputHdl = pScMod->GetInputHdl();
 195     if ( pInputHdl )
 196         pInputHdl->NotifyChange( NULL );
 197 }
 198
 199 void ScFormulaDlg::fill()
 200 {
 201     ScModule* pScMod = SC_MOD();
 202     ScFormEditData* pData = pScMod->GetFormEditData();
 203     notifyChange();
 204     OUString rStrExp;
 205     if (pData)
 206     {
 207         //  Daten schon vorhanden -> Zustand wiederherstellen (nach Umschalten)
 208         //  pDoc und aCursorPos nicht neu initialisieren
 209         //pDoc = pViewData->GetDocument();
 210         if(IsInputHdl(pData->GetInputHandler()))
 211         {
 212             pScMod->SetRefInputHdl(pData->GetInputHandler());
 213         }
 214         else
 215         {
 216             PtrTabViewShell pTabViewShell;
 217             ScInputHandler* pInputHdl = GetNextInputHandler(pData->GetDocShell(),&pTabViewShell);
 218
 219             if ( pInputHdl == NULL ) //DocShell hat keinen InputHandler mehr,
 220             {                   //hat der Anwender halt Pech gehabt.
 221                 disableOk();
 222                 pInputHdl = pScMod->GetInputHdl();
 223             }
 224             else
 225             {
 226                 pInputHdl->SetRefViewShell(pTabViewShell);
 227             }
 228             pScMod->SetRefInputHdl(pInputHdl);
 229             pData->SetInputHandler(pInputHdl);
 230         }
 231
 232         OUString aOldFormulaTmp(pScMod->InputGetFormulaStr());
 233         pScMod->InputSetSelection( 0, aOldFormulaTmp.getLength());
 234
 235         rStrExp=pData->GetUndoStr();
 236         pScMod->InputReplaceSelection(rStrExp);
 237
 238         SetMeText(rStrExp);
 239
 240         Update();
 241         // Jetzt nochmals zurueckschalten, da evtl. neues Doc geoeffnet wurde!
 242         pScMod->SetRefInputHdl(NULL);
 243     }
 244 }
 245
 246 ScFormulaDlg::~ScFormulaDlg()
 247 {
 248     ScModule* pScMod = SC_MOD();
 249     ScFormEditData* pData = pScMod->GetFormEditData();
 250
 251     if (pData) // wird nicht ueber Close zerstoert;
 252     {
 253         //Referenz Inputhandler zuruecksetzen
 254         pScMod->SetRefInputHdl(NULL);
 255         StoreFormEditData(pData);
 256     } // if (pData) // wird nicht ueber Close zerstoert;
 257 }
 258
 259 bool ScFormulaDlg::IsInputHdl(ScInputHandler* pHdl)
 260 {
 261     bool bAlive = false;
 262
 263     //  gehoert der InputHandler zu irgendeiner ViewShell ?
 264
 265     TypeId aScType = TYPE(ScTabViewShell);
 266     SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType );
 267     while ( pSh && !bAlive )
 268     {
 269         if (((ScTabViewShell*)pSh)->GetInputHandler() == pHdl)
 270             bAlive = true;
 271         pSh = SfxViewShell::GetNext( *pSh, &aScType );
 272     }
 273
 274     return bAlive;
 275
 276 }
 277
 278 ScInputHandler* ScFormulaDlg::GetNextInputHandler(ScDocShell* pDocShell,PtrTabViewShell* ppViewSh)
 279 {
 280     ScInputHandler* pHdl=NULL;
 281
 282     SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
 283     while( pFrame && pHdl==NULL)
 284     {
 285         SfxViewShell* p = pFrame->GetViewShell();
 286         ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,p);
 287         if(pViewSh!=NULL)
 288         {
 289             pHdl=pViewSh->GetInputHandler();
 290             if(ppViewSh!=NULL) *ppViewSh=pViewSh;
 291         }
 292         pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 293     }
 294
 295
 296     return pHdl;
 297 }
 298
 299
 300 bool ScFormulaDlg::Close()
 301 {
 302     DoEnter(false);
 303     return true;
 304 }
 305
 306
 307 //                          Funktionen fuer rechte Seite
 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! um bei ColRowNames kein #REF! zu bekommen,
 314     // wenn ein Name eigentlich als Bereich in die Gesamt-Formel
 315     // eingefuegt wird, bei der Einzeldarstellung aber als
 316     // single-Zellbezug interpretiert wird
 317     bool bColRowName = pFCell->HasColRowName();
 318     if ( bColRowName )
 319     {
 320         // ColRowName im RPN-Code?
 321         if ( pFCell->GetCode()->GetCodeLen() <= 1 )
 322         {   // ==1: einzelner ist als Parameter immer Bereich
 323             // ==0: es waere vielleicht einer, wenn..
 324             OUStringBuffer aBraced;
 325             aBraced.append('(');
 326             aBraced.append(rStrExp);
 327             aBraced.append(')');
 328             pFCell.reset( new ScSimpleFormulaCalculator( pDoc, aCursorPos, aBraced.makeStringAndClear() ) );
 329         }
 330         else
 331             bColRowName = false;
 332     }
 333
 334     sal_uInt16 nErrCode = pFCell->GetErrCode();
 335     if ( nErrCode == 0 )
 336     {
 337         SvNumberFormatter& aFormatter = *(pDoc->GetFormatTable());
 338         Color* pColor;
 339         if ( pFCell->IsValue() )
 340         {
 341             double n = pFCell->GetValue();
 342             sal_uLong nFormat = aFormatter.GetStandardFormat( n, 0,
 343                             pFCell->GetFormatType(), ScGlobal::eLnge );
 344             aFormatter.GetOutputString( n, nFormat,
 345                                         rStrResult, &pColor );
 346         }
 347         else
 348         {
 349             sal_uLong nFormat = aFormatter.GetStandardFormat(
 350                             pFCell->GetFormatType(), ScGlobal::eLnge);
 351             aFormatter.GetOutputString( pFCell->GetString().getString(), nFormat,
 352                                         rStrResult, &pColor );
 353         }
 354
 355         ScRange aTestRange;
 356         if ( bColRowName || (aTestRange.Parse(rStrExp) & SCA_VALID) )
 357             rStrResult += " ...";
 358             // Bereich
 359     }
 360     else
 361         rStrResult += ScGlobal::GetErrorString(nErrCode);
 362
 363     return true;
 364 }
 365
 366 //  virtuelle Methoden von ScAnyRefDlg:
 367 void ScFormulaDlg::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
 368 {
 369     pEdit->SetSelection(Selection(0, SELECTION_MAX));
 370     ::std::pair<formula::RefButton*,formula::RefEdit*> aPair = RefInputStartBefore( pEdit, pButton );
 371     m_aHelper.RefInputStart( aPair.second, aPair.first);
 372     RefInputStartAfter( aPair.second, aPair.first );
 373 }
 374
 375 void ScFormulaDlg::RefInputDone( bool bForced )
 376 {
 377     m_aHelper.RefInputDone( bForced );
 378     RefInputDoneAfter( bForced );
 379 }
 380
 381 void ScFormulaDlg::SetReference( const ScRange& rRef, ScDocument* pRefDoc )
 382 {
 383     const IFunctionDescription* pFunc = getCurrentFunctionDescription();
 384     if ( pFunc && pFunc->getSuppressedArgumentCount() > 0 )
 385     {
 386         Selection theSel;
 387         bool bRefNull = UpdateParaWin(theSel);
 388
 389         if ( rRef.aStart != rRef.aEnd && bRefNull )
 390         {
 391             RefInputStart(GetActiveEdit());
 392         }
 393
 394         OUString      aRefStr;
 395         bool bOtherDoc = ( pRefDoc != pDoc && pRefDoc->GetDocumentShell()->HasName() );
 396         if ( bOtherDoc )
 397         {
 398             //  Referenz auf anderes Dokument - wie inputhdl.cxx
 399
 400             OSL_ENSURE(rRef.aStart.Tab()==rRef.aEnd.Tab(), "nStartTab!=nEndTab");
 401
 402             OUString aTmp(rRef.Format(SCA_VALID|SCA_TAB_3D, pRefDoc));     // immer 3d
 403
 404             SfxObjectShell* pObjSh = pRefDoc->GetDocumentShell();
 405
 406             // #i75893# convert escaped URL of the document to something user friendly
 407 //           OUString aFileName = pObjSh->GetMedium()->GetName();
 408             OUString aFileName = pObjSh->GetMedium()->GetURLObject().GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
 409
 410             aRefStr = "'";
 411             aRefStr += aFileName;
 412             aRefStr += "'#";
 413             aRefStr += aTmp;
 414         }
 415         else
 416         {
 417             // We can't use ScRange::Format here because in R1C1 mode we need
 418             // to display the reference position relative to the cursor
 419             // position.
 420             ScTokenArray aArray;
 421             ScComplexRefData aRefData;
 422             aRefData.InitRangeRel(rRef, aCursorPos);
 423             bool bSingle = aRefData.Ref1 == aRefData.Ref2;
 424             if (aCursorPos.Tab() != rRef.aStart.Tab())
 425                 aRefData.Ref1.SetFlag3D(true);
 426             if (bSingle)
 427                 aArray.AddSingleReference(aRefData.Ref1);
 428             else
 429                 aArray.AddDoubleReference(aRefData);
 430             ScCompiler aComp(pDoc, aCursorPos, aArray);
 431             aComp.SetGrammar(pDoc->GetGrammar());
 432             OUStringBuffer aBuf;
 433             aComp.CreateStringFromTokenArray(aBuf);
 434             aRefStr = aBuf.makeStringAndClear();
 435         }
 436
 437         UpdateParaWin(theSel,aRefStr);
 438     }
 439 }
 440
 441 bool ScFormulaDlg::IsRefInputMode() const
 442 {
 443     const IFunctionDescription* pDesc = getCurrentFunctionDescription();
 444     bool bRef = (pDesc && (pDesc->getSuppressedArgumentCount() > 0)) && (pDoc!=NULL);
 445     return bRef;
 446 }
 447
 448 bool ScFormulaDlg::IsDocAllowed(SfxObjectShell* pDocSh) const
 449 {
 450     //  not allowed: different from this doc, and no name
 451     //  pDocSh is always a ScDocShell
 452     if ( pDocSh && ((ScDocShell*)pDocSh)->GetDocument() != pDoc && !pDocSh->HasName() )
 453         return false;
 454
 455     return true;        // everything else is allowed
 456 }
 457
 458 void ScFormulaDlg::SetActive()
 459 {
 460     const IFunctionDescription* pFunc = getCurrentFunctionDescription();
 461     if ( pFunc && pFunc->getSuppressedArgumentCount() > 0 )
 462     {
 463         RefInputDone();
 464         SetEdSelection();
 465     }
 466 }
 467
 468 void ScFormulaDlg::SaveLRUEntry(const ScFuncDesc* pFuncDescP)
 469 {
 470     if (pFuncDescP && pFuncDescP->nFIndex!=0)
 471     {
 472         ScModule* pScMod = SC_MOD();
 473         pScMod->InsertEntryToLRUList(pFuncDescP->nFIndex);
 474     }
 475 }
 476
 477 void ScFormulaDlg::doClose(bool /*_bOk*/)
 478 {
 479     m_aHelper.DoClose( ScFormulaDlgWrapper::GetChildWindowId() );
 480 }
 481 void ScFormulaDlg::insertEntryToLRUList(const formula::IFunctionDescription*    _pDesc)
 482 {
 483     const ScFuncDesc* pDesc = dynamic_cast<const ScFuncDesc*>(_pDesc);
 484     SaveLRUEntry(pDesc);
 485 }
 486 void ScFormulaDlg::showReference(const OUString& _sFormula)
 487 {
 488     ShowReference(_sFormula);
 489 }
 490 void ScFormulaDlg::ShowReference(const OUString& _sFormula)
 491 {
 492     m_aHelper.ShowReference(_sFormula);
 493 }
 494 void ScFormulaDlg::HideReference( bool bDoneRefMode )
 495 {
 496     m_aHelper.HideReference(bDoneRefMode);
 497 }
 498 void ScFormulaDlg::ViewShellChanged()
 499 {
 500     m_aHelper.ViewShellChanged();
 501 }
 502 void ScFormulaDlg::AddRefEntry( )
 503 {
 504
 505 }
 506 bool ScFormulaDlg::IsTableLocked( ) const
 507 {
 508     // per Default kann bei Referenzeingabe auch die Tabelle umgeschaltet werden
 509     return false;
 510 }
 511 void ScFormulaDlg::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton)
 512 {
 513     m_aHelper.ToggleCollapsed(pEdit,pButton);
 514 }
 515 void ScFormulaDlg::ReleaseFocus( formula::RefEdit* pEdit, formula::RefButton* pButton)
 516 {
 517     m_aHelper.ReleaseFocus(pEdit,pButton);
 518 }
 519 void ScFormulaDlg::dispatch(bool _bOK, bool _bMatrixChecked)
 520 {
 521     SfxBoolItem   aRetItem( SID_DLG_RETOK, _bOK );
 522     SfxBoolItem   aMatItem( SID_DLG_MATRIX, _bMatrixChecked );
 523     SfxStringItem aStrItem( SCITEM_STRING, getCurrentFormula() );
 524
 525     // Wenn durch Dokument-Umschalterei die Eingabezeile weg war/ist,
 526     // ist der String leer. Dann nicht die alte Formel loeschen.
 527     if ( aStrItem.GetValue().isEmpty() )
 528         aRetItem.SetValue( false );     // sal_False = Cancel
 529
 530     m_aHelper.SetDispatcherLock( false ); // Modal-Modus ausschalten
 531
 532     clear();
 533
 534     GetBindings().GetDispatcher()->Execute( SID_INS_FUNCTION,
 535                               SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
 536                               &aRetItem, &aStrItem, &aMatItem, 0L );
 537 }
 538 void ScFormulaDlg::setDispatcherLock( bool bLock )
 539 {
 540     m_aHelper.SetDispatcherLock( bLock );
 541 }
 542 void ScFormulaDlg::setReferenceInput(const formula::FormEditData* _pData)
 543 {
 544     ScModule* pScMod = SC_MOD();
 545     ScFormEditData* pData = const_cast<ScFormEditData*>(dynamic_cast<const ScFormEditData*>(_pData));
 546     pScMod->SetRefInputHdl(pData->GetInputHandler());
 547 }
 548 void ScFormulaDlg::deleteFormData()
 549 {
 550     ScModule* pScMod = SC_MOD();
 551     pScMod->ClearFormEditData();        // pData wird ungueltig!
 552 }
 553 void ScFormulaDlg::clear()
 554 {
 555     pDoc = NULL;
 556
 557     //Referenz Inputhandler zuruecksetzen
 558     ScModule* pScMod = SC_MOD();
 559     pScMod->SetRefInputHdl(NULL);
 560
 561     // Enable() der Eingabezeile erzwingen:
 562     ScTabViewShell* pScViewShell = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
 563     if ( pScViewShell )
 564         pScViewShell->UpdateInputHandler();
 565 }
 566 void ScFormulaDlg::switchBack()
 567 {
 568     ScModule* pScMod = SC_MOD();
 569     // auf das Dokument zurueckschalten
 570     // (noetig, weil ein fremdes oben sein kann - #34222#)
 571     ScInputHandler* pHdl = pScMod->GetInputHdl();
 572     if ( pHdl )
 573     {
 574         pHdl->ViewShellGone(NULL);  // -> aktive View neu holen
 575         pHdl->ShowRefFrame();
 576     }
 577
 578     // aktuelle Tabelle ggF. restaurieren (wg. Maus-RefInput)
 579     ScTabViewShell* pScViewShell = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
 580     if ( pScViewShell )
 581     {
 582         ScViewData* pVD=pScViewShell->GetViewData();
 583         SCTAB nExecTab = aCursorPos.Tab();
 584         if ( nExecTab != pVD->GetTabNo() )
 585             pScViewShell->SetTabNo( nExecTab );
 586
 587         SCROW nRow=aCursorPos.Row();
 588         SCCOL nCol=aCursorPos.Col();
 589
 590         if(pVD->GetCurX()!=nCol || pVD->GetCurY()!=nRow)
 591             pScViewShell->SetCursor(nCol,nRow);
 592     }
 593 }
 594 formula::FormEditData* ScFormulaDlg::getFormEditData() const
 595 {
 596     ScModule* pScMod = SC_MOD();
 597     return pScMod->GetFormEditData();
 598 }
 599 void ScFormulaDlg::setCurrentFormula(const OUString& _sReplacement)
 600 {
 601     ScModule* pScMod = SC_MOD();
 602     {
 603         //fdo#69971 We need the EditEngine Modification handler of the inputbar that we
 604         //are feeding to be disabled while this dialog is open. Otherwise we end up in
 605         //a situation where...
 606         //a) this ScFormulaDlg changes the editengine
 607         //b) the modify callback gets called
 608         //c) which also modifies the editengine
 609         //d) on return from that modify handler the editengine attempts to use
 610         //   old node pointers which were replaced and removed by c
 611         //
 612         //We turn it off in the ctor and back on in the dtor, but if calc has
 613         //to repaint, e.g. when switching to another window and back, then in
 614         //ScMultiTextWnd::Paint a new editengine will have been created via
 615         //GetEditView with its default Modification handler enabled. So ensure
 616         //its off when we will access it via InputReplaceSelection
 617         pScMod->InputTurnOffWinEngine();
 618     }
 619     pScMod->InputReplaceSelection(_sReplacement);
 620 }
 621 void ScFormulaDlg::setSelection(sal_Int32 _nStart, sal_Int32 _nEnd)
 622 {
 623     ScModule* pScMod = SC_MOD();
 624     pScMod->InputSetSelection( _nStart, _nEnd );
 625 }
 626 void ScFormulaDlg::getSelection(sal_Int32& _nStart, sal_Int32& _nEnd) const
 627 {
 628     ScModule* pScMod = SC_MOD();
 629     pScMod->InputGetSelection( _nStart, _nEnd );
 630 }
 631 OUString ScFormulaDlg::getCurrentFormula() const
 632 {
 633     ScModule* pScMod = SC_MOD();
 634     return pScMod->InputGetFormulaStr();
 635 }
 636 formula::IFunctionManager* ScFormulaDlg::getFunctionManager()
 637 {
 638     return ScGlobal::GetStarCalcFunctionMgr();
 639 }
 640 uno::Reference< sheet::XFormulaParser> ScFormulaDlg::getFormulaParser() const
 641 {
 642     return m_xParser;
 643 }
 644 uno::Reference< sheet::XFormulaOpCodeMapper> ScFormulaDlg::getFormulaOpCodeMapper() const
 645 {
 646     return m_xOpCodeMapper;
 647 }
 648
 649 table::CellAddress ScFormulaDlg::getReferencePosition() const
 650 {
 651     return table::CellAddress(aCursorPos.Tab(),aCursorPos.Col(),aCursorPos.Row());
 652 }
 653
 654 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 655 ::std::auto_ptr<formula::FormulaTokenArray> ScFormulaDlg::convertToTokenArray(const uno::Sequence< sheet::FormulaToken >& _aTokenList)
 656 {
 657     ::std::auto_ptr<formula::FormulaTokenArray> pArray(new ScTokenArray());
 658     pArray->Fill(_aTokenList, pDoc->GetSharedStringPool(), pDoc->GetExternalRefManager());
 659     return pArray;
 660 }
 661 // for mysterious reasons Apple llvm-g++ 4.2.1 needs these explicit
 662 // template instantiations; otherwise linking fails with unresolved symbols
 663 template class ::std::auto_ptr<formula::FormulaTokenArray>;
 664 template std::auto_ptr<formula::FormulaTokenArray>::operator std::auto_ptr_ref<formula::FormulaTokenArray>();
 665 SAL_WNODEPRECATED_DECLARATIONS_POP
 666
 667 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */