xref: /trunk/main/sc/source/ui/formdlg/formula.cxx (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_sc.hxx"
30 
31 
32 
33 //----------------------------------------------------------------------------
34 
35 #include "scitems.hxx"
36 #include <sfx2/dispatch.hxx>
37 #include <sfx2/docfile.hxx>
38 #include <sfx2/objsh.hxx>
39 #include <svl/zforlist.hxx>
40 #include <svl/stritem.hxx>
41 #include <svtools/svtreebx.hxx>
42 #include <sfx2/viewfrm.hxx>
43 #include <vcl/svapp.hxx>
44 #include <vcl/mnemonic.hxx>
45 #include <unotools/charclass.hxx>
46 #include <tools/urlobj.hxx>
47 #include <formula/formulahelper.hxx>
48 #include <formula/IFunctionDescription.hxx>
49 
50 #include "tokenuno.hxx"
51 #include "formula.hxx"
52 #include "formdata.hxx"
53 #include "globstr.hrc"
54 #include "scresid.hxx"
55 #include "reffact.hxx"
56 #include "document.hxx"
57 #include "cell.hxx"
58 #include "scmod.hxx"
59 #include "inputhdl.hxx"
60 #include "tabvwsh.hxx"
61 #include "appoptio.hxx"
62 #include "docsh.hxx"
63 #include "funcdesc.hxx"
64 #include "formula/token.hxx"
65 #include "tokenarray.hxx"
66 #include "sc.hrc"
67 #include "servuno.hxx"
68 #include "unonames.hxx"
69 #include "externalrefmgr.hxx"
70 
71 #include <com/sun/star/table/CellAddress.hpp>
72 
73 //============================================================================
74 using namespace formula;
75 using namespace com::sun::star;
76 
77 ScDocument* ScFormulaDlg::pDoc = NULL;
78 ScAddress ScFormulaDlg::aCursorPos;
79 
80 
81 
82 //  --------------------------------------------------------------------------
83 //      Initialisierung / gemeinsame Funktionen  fuer Dialog
84 //  --------------------------------------------------------------------------
85 
86 ScFormulaDlg::ScFormulaDlg( SfxBindings* pB, SfxChildWindow* pCW,
87                                     Window* pParent, ScViewData* pViewData,formula::IFunctionManager* _pFunctionMgr )
88     : formula::FormulaDlg( pB, pCW, pParent, true,true,true,this, _pFunctionMgr,this)
89     , m_aHelper(this,pB)
90 {
91     m_aHelper.SetWindow(this);
92     ScModule* pScMod = SC_MOD();
93     pScMod->InputEnterHandler();
94     ScTabViewShell* pScViewShell = NULL;
95 
96     // title has to be from the view that opened the dialog,
97     // even if it's not the current view
98 
99     SfxObjectShell* pParentDoc = NULL;
100     if ( pB )
101     {
102         SfxDispatcher* pMyDisp = pB->GetDispatcher();
103         if (pMyDisp)
104         {
105             SfxViewFrame* pMyViewFrm = pMyDisp->GetFrame();
106             if (pMyViewFrm)
107             {
108                 pScViewShell = PTR_CAST( ScTabViewShell, pMyViewFrm->GetViewShell() );
109                 if( pScViewShell )
110                     pScViewShell->UpdateInputHandler(sal_True);
111                 pParentDoc = pMyViewFrm->GetObjectShell();
112             }
113         }
114     }
115     //if ( !pParentDoc && pScViewShell )                    // use current only if above fails
116     //  pParentDoc = pScViewShell->GetObjectShell();
117     //if ( pParentDoc )
118     //  aDocName = pParentDoc->GetTitle();
119 
120     if ( pDoc == NULL )
121         pDoc = pViewData->GetDocument();
122     m_xParser.set(ScServiceProvider::MakeInstance(SC_SERVICE_FORMULAPARS,(ScDocShell*)pDoc->GetDocumentShell()),uno::UNO_QUERY);
123     uno::Reference< beans::XPropertySet> xSet(m_xParser,uno::UNO_QUERY);
124     xSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_COMPILEFAP)),uno::makeAny(sal_True));
125 
126     m_xOpCodeMapper.set(ScServiceProvider::MakeInstance(SC_SERVICE_OPCODEMAPPER,(ScDocShell*)pDoc->GetDocumentShell()),uno::UNO_QUERY);
127 
128     ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl(pScViewShell);
129 
130     DBG_ASSERT( pInputHdl, "Missing input handler :-/" );
131 
132     if ( pInputHdl )
133         pInputHdl->NotifyChange( NULL );
134 
135     m_aHelper.enableInput( sal_False );
136     m_aHelper.EnableSpreadsheets();
137     m_aHelper.Init();
138     m_aHelper.SetDispatcherLock( sal_True );
139 
140     notifyChange();
141     fill();
142 
143     ScFormEditData* pData = pScMod->GetFormEditData();
144     if (!pData)
145     {
146         //Nun wird es Zeit den Inputhandler festzulegen
147         pScMod->SetRefInputHdl(pScMod->GetInputHdl());
148 
149         pDoc = pViewData->GetDocument();
150         SCCOL nCol = pViewData->GetCurX();
151         SCROW nRow = pViewData->GetCurY();
152         SCTAB nTab = pViewData->GetTabNo();
153         aCursorPos = ScAddress( nCol, nRow, nTab );
154 
155         pScMod->InitFormEditData();                             // neu anlegen
156         pData = pScMod->GetFormEditData();
157         pData->SetInputHandler(pScMod->GetInputHdl());
158         pData->SetDocShell(pViewData->GetDocShell());
159 
160         DBG_ASSERT(pData,"FormEditData ist nicht da");
161 
162         formula::FormulaDlgMode eMode = FORMULA_FORMDLG_FORMULA;            // Default...
163 
164         //  Formel vorhanden? Dann editieren
165 
166         String aFormula;
167         pDoc->GetFormula( nCol, nRow, nTab, aFormula );
168         sal_Bool bEdit   = ( aFormula.Len() > 1 );
169         sal_Bool bMatrix = sal_False;
170         if ( bEdit )
171         {
172             bMatrix = CheckMatrix(aFormula);
173 
174             xub_StrLen nFStart = 0;
175             xub_StrLen nFEnd   = 0;
176             if ( GetFormulaHelper().GetNextFunc( aFormula, sal_False, nFStart, &nFEnd) )
177             {
178                 pScMod->InputReplaceSelection( aFormula );
179                 pScMod->InputSetSelection( nFStart, nFEnd );
180                 xub_StrLen PrivStart, PrivEnd;
181                 pScMod->InputGetSelection( PrivStart, PrivEnd);
182 
183                 eMode = SetMeText(pScMod->InputGetFormulaStr(),PrivStart, PrivEnd,bMatrix,sal_True,sal_True);
184                 pData->SetFStart( nFStart );
185             }
186             else
187                 bEdit = sal_False;
188         }
189 
190         if ( !bEdit )
191         {
192             String aNewFormula = '=';
193             if ( aFormula.Len() > 0 && aFormula.GetChar(0) == '=' )
194                 aNewFormula=aFormula;
195 
196             pScMod->InputReplaceSelection( aNewFormula );
197             pScMod->InputSetSelection( 1, aNewFormula.Len()+1 );
198             xub_StrLen PrivStart, PrivEnd;
199             pScMod->InputGetSelection( PrivStart, PrivEnd);
200             SetMeText(pScMod->InputGetFormulaStr(),PrivStart, PrivEnd,bMatrix,sal_False,sal_False);
201 
202             pData->SetFStart( 1 );      // hinter dem "="
203         }
204 
205         pData->SetMode( (sal_uInt16) eMode );
206         String rStrExp = GetMeText();
207 
208         pCell = new ScFormulaCell( pDoc, aCursorPos, rStrExp );
209 
210         Update(rStrExp);
211     } // if (!pData)
212 
213 }
214 
215 void ScFormulaDlg::notifyChange()
216 {
217     ScModule* pScMod = SC_MOD();
218 
219     ScInputHandler* pInputHdl = pScMod->GetInputHdl();
220     if ( pInputHdl )
221         pInputHdl->NotifyChange( NULL );
222 }
223 // -----------------------------------------------------------------------------
224 void ScFormulaDlg::fill()
225 {
226     ScModule* pScMod = SC_MOD();
227     ScFormEditData* pData = pScMod->GetFormEditData();
228     notifyChange();
229     String rStrExp;
230     if (pData)
231     {
232         //  Daten schon vorhanden -> Zustand wiederherstellen (nach Umschalten)
233         //  pDoc und aCursorPos nicht neu initialisieren
234         //pDoc = pViewData->GetDocument();
235         if(IsInputHdl(pData->GetInputHandler()))
236         {
237             pScMod->SetRefInputHdl(pData->GetInputHandler());
238         }
239         else
240         {
241             PtrTabViewShell pTabViewShell;
242             ScInputHandler* pInputHdl = GetNextInputHandler(pData->GetDocShell(),&pTabViewShell);
243 
244             if ( pInputHdl == NULL ) //DocShell hat keinen InputHandler mehr,
245             {                   //hat der Anwender halt Pech gehabt.
246                 disableOk();
247                 pInputHdl = pScMod->GetInputHdl();
248             }
249             else
250             {
251                 pInputHdl->SetRefViewShell(pTabViewShell);
252             }
253             pScMod->SetRefInputHdl(pInputHdl);
254             pData->SetInputHandler(pInputHdl);
255         }
256 
257         String aOldFormulaTmp(pScMod->InputGetFormulaStr());
258         pScMod->InputSetSelection( 0, aOldFormulaTmp.Len());
259 
260         rStrExp=pData->GetUndoStr();
261         pScMod->InputReplaceSelection(rStrExp);
262 
263         SetMeText(rStrExp);
264 
265         pCell = new ScFormulaCell( pDoc, aCursorPos, rStrExp );
266 
267         Update();
268         // Jetzt nochmals zurueckschalten, da evtl. neues Doc geoeffnet wurde!
269         pScMod->SetRefInputHdl(NULL);
270     }
271 }
272 
273 __EXPORT ScFormulaDlg::~ScFormulaDlg()
274 {
275     ScModule* pScMod = SC_MOD();
276     ScFormEditData* pData = pScMod->GetFormEditData();
277 
278     if (pData) // wird nicht ueber Close zerstoert;
279     {
280         //Referenz Inputhandler zuruecksetzen
281         pScMod->SetRefInputHdl(NULL);
282     } // if (pData) // wird nicht ueber Close zerstoert;
283 
284     delete pCell;
285 }
286 
287 sal_Bool ScFormulaDlg::IsInputHdl(ScInputHandler* pHdl)
288 {
289     sal_Bool bAlive = sal_False;
290 
291     //  gehoert der InputHandler zu irgendeiner ViewShell ?
292 
293     TypeId aScType = TYPE(ScTabViewShell);
294     SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType );
295     while ( pSh && !bAlive )
296     {
297         if (((ScTabViewShell*)pSh)->GetInputHandler() == pHdl)
298             bAlive = sal_True;
299         pSh = SfxViewShell::GetNext( *pSh, &aScType );
300     }
301 
302     return bAlive;
303 
304 }
305 
306 ScInputHandler* ScFormulaDlg::GetNextInputHandler(ScDocShell* pDocShell,PtrTabViewShell* ppViewSh)
307 {
308     ScInputHandler* pHdl=NULL;
309 
310     SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
311     while( pFrame && pHdl==NULL)
312     {
313         SfxViewShell* p = pFrame->GetViewShell();
314         ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,p);
315         if(pViewSh!=NULL)
316         {
317             pHdl=pViewSh->GetInputHandler();
318             if(ppViewSh!=NULL) *ppViewSh=pViewSh;
319         }
320         pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
321     }
322 
323 
324     return pHdl;
325 }
326 
327 
328 sal_Bool __EXPORT ScFormulaDlg::Close()
329 {
330     DoEnter(sal_False);
331     return sal_True;
332 }
333 
334 //  --------------------------------------------------------------------------
335 //                          Funktionen fuer rechte Seite
336 //  --------------------------------------------------------------------------
337 bool ScFormulaDlg::calculateValue( const String& rStrExp, String& rStrResult )
338 {
339     sal_Bool bResult = sal_True;
340 
341     ::std::auto_ptr<ScFormulaCell> pFCell( new ScFormulaCell( pDoc, aCursorPos, rStrExp ) );
342 
343     // #35521# HACK! um bei ColRowNames kein #REF! zu bekommen,
344     // wenn ein Name eigentlich als Bereich in die Gesamt-Formel
345     // eingefuegt wird, bei der Einzeldarstellung aber als
346     // single-Zellbezug interpretiert wird
347     sal_Bool bColRowName = pCell->HasColRowName();
348     if ( bColRowName )
349     {
350         // ColRowName im RPN-Code?
351         if ( pCell->GetCode()->GetCodeLen() <= 1 )
352         {   // ==1: einzelner ist als Parameter immer Bereich
353             // ==0: es waere vielleicht einer, wenn..
354             String aBraced( '(' );
355             aBraced += rStrExp;
356             aBraced += ')';
357             pFCell.reset( new ScFormulaCell( pDoc, aCursorPos, aBraced ) );
358         }
359         else
360             bColRowName = sal_False;
361     }
362 
363     sal_uInt16 nErrCode = pFCell->GetErrCode();
364     if ( nErrCode == 0 )
365     {
366         SvNumberFormatter& aFormatter = *(pDoc->GetFormatTable());
367         Color* pColor;
368         if ( pFCell->IsValue() )
369         {
370             double n = pFCell->GetValue();
371             sal_uLong nFormat = aFormatter.GetStandardFormat( n, 0,
372                             pFCell->GetFormatType(), ScGlobal::eLnge );
373             aFormatter.GetOutputString( n, nFormat,
374                                         rStrResult, &pColor );
375         }
376         else
377         {
378             String aStr;
379 
380             pFCell->GetString( aStr );
381             sal_uLong nFormat = aFormatter.GetStandardFormat(
382                             pFCell->GetFormatType(), ScGlobal::eLnge);
383             aFormatter.GetOutputString( aStr, nFormat,
384                                         rStrResult, &pColor );
385         }
386 
387         ScRange aTestRange;
388         if ( bColRowName || (aTestRange.Parse(rStrExp) & SCA_VALID) )
389             rStrResult.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " ..." ));
390             // Bereich
391     }
392     else
393         rStrResult += ScGlobal::GetErrorString(nErrCode);
394 
395     if(!isUserMatrix() && pFCell->GetMatrixFlag())
396     {
397         CheckMatrix();
398     }
399 
400     return bResult;
401 }
402 
403 
404 
405 //  virtuelle Methoden von ScAnyRefDlg:
406 void ScFormulaDlg::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
407 {
408     ::std::pair<formula::RefButton*,formula::RefEdit*> aPair = RefInputStartBefore( pEdit, pButton );
409     m_aHelper.RefInputStart( aPair.second, aPair.first);
410     RefInputStartAfter( aPair.second, aPair.first );
411 }
412 void ScFormulaDlg::RefInputDone( sal_Bool bForced )
413 {
414     m_aHelper.RefInputDone( bForced );
415     RefInputDoneAfter( bForced );
416 }
417 
418 void ScFormulaDlg::SetReference( const ScRange& rRef, ScDocument* pRefDoc )
419 {
420     const IFunctionDescription* pFunc = getCurrentFunctionDescription();
421     if ( pFunc && pFunc->getSuppressedArgumentCount() > 0 )
422     {
423         Selection theSel;
424         sal_Bool bRefNull = UpdateParaWin(theSel);
425 
426         if ( rRef.aStart != rRef.aEnd && bRefNull )
427         {
428             RefInputStart(GetActiveEdit());
429         }
430 
431         String      aRefStr;
432         sal_Bool bOtherDoc = ( pRefDoc != pDoc && pRefDoc->GetDocumentShell()->HasName() );
433         if ( bOtherDoc )
434         {
435             //  Referenz auf anderes Dokument - wie inputhdl.cxx
436 
437             DBG_ASSERT(rRef.aStart.Tab()==rRef.aEnd.Tab(), "nStartTab!=nEndTab");
438 
439             String aTmp;
440             rRef.Format( aTmp, SCA_VALID|SCA_TAB_3D, pRefDoc );     // immer 3d
441 
442             SfxObjectShell* pObjSh = pRefDoc->GetDocumentShell();
443 
444             // #i75893# convert escaped URL of the document to something user friendly
445 //           String aFileName = pObjSh->GetMedium()->GetName();
446             String aFileName = pObjSh->GetMedium()->GetURLObject().GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
447 
448             aRefStr = '\'';
449             aRefStr += aFileName;
450             aRefStr.AppendAscii(RTL_CONSTASCII_STRINGPARAM( "'#" ));
451             aRefStr += aTmp;
452         }
453         else
454         {
455             sal_uInt16 nFmt = ( rRef.aStart.Tab() == aCursorPos.Tab() )
456                                 ? SCA_VALID
457                                 : SCA_VALID | SCA_TAB_3D;
458             rRef.Format( aRefStr, nFmt, pRefDoc, pRefDoc->GetAddressConvention() );
459         }
460 
461         UpdateParaWin(theSel,aRefStr);
462     }
463 }
464 
465 sal_Bool ScFormulaDlg::IsRefInputMode() const
466 {
467     const IFunctionDescription* pDesc = getCurrentFunctionDescription();
468     sal_Bool bRef = (pDesc && (pDesc->getSuppressedArgumentCount() > 0)) && (pDoc!=NULL);
469     return bRef;
470 }
471 
472 sal_Bool ScFormulaDlg::IsDocAllowed(SfxObjectShell* pDocSh) const
473 {
474     //  not allowed: different from this doc, and no name
475     //  pDocSh is always a ScDocShell
476     if ( pDocSh && ((ScDocShell*)pDocSh)->GetDocument() != pDoc && !pDocSh->HasName() )
477         return sal_False;
478 
479     return sal_True;        // everything else is allowed
480 }
481 
482 void ScFormulaDlg::SetActive()
483 {
484     const IFunctionDescription* pFunc = getCurrentFunctionDescription();
485     if ( pFunc && pFunc->getSuppressedArgumentCount() > 0 )
486     {
487         RefInputDone();
488         SetEdSelection();
489     }
490 }
491 
492 void ScFormulaDlg::SaveLRUEntry(const ScFuncDesc* pFuncDescP)
493 {
494     if (pFuncDescP && pFuncDescP->nFIndex!=0)
495     {
496         ScModule* pScMod = SC_MOD();
497         pScMod->InsertEntryToLRUList(pFuncDescP->nFIndex);
498     }
499 }
500 
501 void ScFormulaDlg::doClose(sal_Bool /*_bOk*/)
502 {
503     m_aHelper.DoClose( ScFormulaDlgWrapper::GetChildWindowId() );
504 }
505 void ScFormulaDlg::insertEntryToLRUList(const formula::IFunctionDescription*    _pDesc)
506 {
507     const ScFuncDesc* pDesc = dynamic_cast<const ScFuncDesc*>(_pDesc);
508     SaveLRUEntry(pDesc);
509 }
510 void ScFormulaDlg::showReference(const String& _sFormula)
511 {
512     ShowReference(_sFormula);
513 }
514 void ScFormulaDlg::ShowReference(const String& _sFormula)
515 {
516     m_aHelper.ShowReference(_sFormula);
517 }
518 void ScFormulaDlg::HideReference( sal_Bool bDoneRefMode )
519 {
520     m_aHelper.HideReference(bDoneRefMode);
521 }
522 void ScFormulaDlg::ViewShellChanged( ScTabViewShell* pScViewShell )
523 {
524     m_aHelper.ViewShellChanged( pScViewShell );
525 }
526 void ScFormulaDlg::AddRefEntry( )
527 {
528 
529 }
530 sal_Bool ScFormulaDlg::IsTableLocked( ) const
531 {
532     // per Default kann bei Referenzeingabe auch die Tabelle umgeschaltet werden
533     return sal_False;
534 }
535 void ScFormulaDlg::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton)
536 {
537     m_aHelper.ToggleCollapsed(pEdit,pButton);
538 }
539 void ScFormulaDlg::ReleaseFocus( formula::RefEdit* pEdit, formula::RefButton* pButton)
540 {
541     m_aHelper.ReleaseFocus(pEdit,pButton);
542 }
543 void ScFormulaDlg::dispatch(sal_Bool _bOK,sal_Bool _bMartixChecked)
544 {
545     SfxBoolItem   aRetItem( SID_DLG_RETOK, _bOK );
546     SfxBoolItem   aMatItem( SID_DLG_MATRIX, _bMartixChecked );
547     SfxStringItem aStrItem( SCITEM_STRING, getCurrentFormula() );
548 
549     // Wenn durch Dokument-Umschalterei die Eingabezeile weg war/ist,
550     // ist der String leer. Dann nicht die alte Formel loeschen.
551     if ( !aStrItem.GetValue().Len() )
552         aRetItem.SetValue( sal_False );     // sal_False = Cancel
553 
554     m_aHelper.SetDispatcherLock( sal_False ); // Modal-Modus ausschalten
555 
556     clear();
557 
558     GetBindings().GetDispatcher()->Execute( SID_INS_FUNCTION,
559                               SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
560                               &aRetItem, &aStrItem, &aMatItem, 0L );
561 }
562 void ScFormulaDlg::setDispatcherLock( sal_Bool bLock )
563 {
564     m_aHelper.SetDispatcherLock( bLock );
565 }
566 void ScFormulaDlg::setReferenceInput(const formula::FormEditData* _pData)
567 {
568     ScModule* pScMod = SC_MOD();
569     ScFormEditData* pData = const_cast<ScFormEditData*>(dynamic_cast<const ScFormEditData*>(_pData));
570     pScMod->SetRefInputHdl(pData->GetInputHandler());
571 }
572 void ScFormulaDlg::deleteFormData()
573 {
574     ScModule* pScMod = SC_MOD();
575     pScMod->ClearFormEditData();        // pData wird ungueltig!
576 }
577 void ScFormulaDlg::clear()
578 {
579     pDoc = NULL;
580 
581     //Referenz Inputhandler zuruecksetzen
582     ScModule* pScMod = SC_MOD();
583     pScMod->SetRefInputHdl(NULL);
584 
585     // Enable() der Eingabezeile erzwingen:
586     ScTabViewShell* pScViewShell = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
587     if ( pScViewShell )
588         pScViewShell->UpdateInputHandler();
589 }
590 void ScFormulaDlg::switchBack()
591 {
592     ScModule* pScMod = SC_MOD();
593     // auf das Dokument zurueckschalten
594     // (noetig, weil ein fremdes oben sein kann - #34222#)
595     ScInputHandler* pHdl = pScMod->GetInputHdl();
596     if ( pHdl )
597     {
598         pHdl->ViewShellGone(NULL);  // -> aktive View neu holen
599         pHdl->ShowRefFrame();
600     }
601 
602     // aktuelle Tabelle ggF. restaurieren (wg. Maus-RefInput)
603     ScTabViewShell* pScViewShell = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
604     if ( pScViewShell )
605     {
606         ScViewData* pVD=pScViewShell->GetViewData();
607         SCTAB nExecTab = aCursorPos.Tab();
608         if ( nExecTab != pVD->GetTabNo() )
609             pScViewShell->SetTabNo( nExecTab );
610 
611         SCROW nRow=aCursorPos.Row();
612         SCCOL nCol=aCursorPos.Col();
613 
614         if(pVD->GetCurX()!=nCol || pVD->GetCurY()!=nRow)
615             pScViewShell->SetCursor(nCol,nRow);
616     }
617 }
618 formula::FormEditData* ScFormulaDlg::getFormEditData() const
619 {
620     ScModule* pScMod = SC_MOD();
621     return pScMod->GetFormEditData();
622 }
623 void ScFormulaDlg::setCurrentFormula(const String& _sReplacement)
624 {
625     ScModule* pScMod = SC_MOD();
626     pScMod->InputReplaceSelection(_sReplacement);
627 }
628 void ScFormulaDlg::setSelection(xub_StrLen _nStart,xub_StrLen _nEnd)
629 {
630     ScModule* pScMod = SC_MOD();
631     pScMod->InputSetSelection( _nStart, _nEnd );
632 }
633 void ScFormulaDlg::getSelection(xub_StrLen& _nStart,xub_StrLen& _nEnd) const
634 {
635     ScModule* pScMod = SC_MOD();
636     pScMod->InputGetSelection( _nStart, _nEnd );
637 }
638 String ScFormulaDlg::getCurrentFormula() const
639 {
640     ScModule* pScMod = SC_MOD();
641     return pScMod->InputGetFormulaStr();
642 }
643 formula::IFunctionManager* ScFormulaDlg::getFunctionManager()
644 {
645     return ScGlobal::GetStarCalcFunctionMgr();
646 }
647 uno::Reference< sheet::XFormulaParser> ScFormulaDlg::getFormulaParser() const
648 {
649     return m_xParser;
650 }
651 uno::Reference< sheet::XFormulaOpCodeMapper> ScFormulaDlg::getFormulaOpCodeMapper() const
652 {
653     return m_xOpCodeMapper;
654 }
655 
656 table::CellAddress ScFormulaDlg::getReferencePosition() const
657 {
658     return table::CellAddress(aCursorPos.Tab(),aCursorPos.Col(),aCursorPos.Row());
659 }
660 
661 ::std::auto_ptr<formula::FormulaTokenArray> ScFormulaDlg::convertToTokenArray(const uno::Sequence< sheet::FormulaToken >& _aTokenList)
662 {
663     ::std::auto_ptr<formula::FormulaTokenArray> pArray(new ScTokenArray());
664     pArray->Fill( _aTokenList, pDoc->GetExternalRefManager());
665     return pArray;
666 }
667 
668