| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| |
| //---------------------------------------------------------------------------- |
| |
| #include "scitems.hxx" |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <sfx2/objsh.hxx> |
| #include <svl/zforlist.hxx> |
| #include <svl/stritem.hxx> |
| #include <svtools/svtreebx.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/mnemonic.hxx> |
| #include <unotools/charclass.hxx> |
| #include <tools/urlobj.hxx> |
| #include <formula/formulahelper.hxx> |
| #include <formula/IFunctionDescription.hxx> |
| |
| #include "tokenuno.hxx" |
| #include "formula.hxx" |
| #include "formdata.hxx" |
| #include "globstr.hrc" |
| #include "scresid.hxx" |
| #include "reffact.hxx" |
| #include "document.hxx" |
| #include "cell.hxx" |
| #include "scmod.hxx" |
| #include "inputhdl.hxx" |
| #include "tabvwsh.hxx" |
| #include "appoptio.hxx" |
| #include "docsh.hxx" |
| #include "funcdesc.hxx" |
| #include "formula/token.hxx" |
| #include "tokenarray.hxx" |
| #include "sc.hrc" |
| #include "servuno.hxx" |
| #include "unonames.hxx" |
| #include "externalrefmgr.hxx" |
| |
| #include <com/sun/star/table/CellAddress.hpp> |
| |
| //============================================================================ |
| using namespace formula; |
| using namespace com::sun::star; |
| |
| ScDocument* ScFormulaDlg::pDoc = NULL; |
| ScAddress ScFormulaDlg::aCursorPos; |
| |
| |
| |
| // -------------------------------------------------------------------------- |
| // Initialisierung / gemeinsame Funktionen fuer Dialog |
| // -------------------------------------------------------------------------- |
| |
| ScFormulaDlg::ScFormulaDlg( SfxBindings* pB, SfxChildWindow* pCW, |
| Window* pParent, ScViewData* pViewData,formula::IFunctionManager* _pFunctionMgr ) |
| : formula::FormulaDlg( pB, pCW, pParent, true,true,true,this, _pFunctionMgr,this) |
| , m_aHelper(this,pB) |
| { |
| m_aHelper.SetWindow(this); |
| ScModule* pScMod = SC_MOD(); |
| pScMod->InputEnterHandler(); |
| ScTabViewShell* pScViewShell = NULL; |
| |
| // title has to be from the view that opened the dialog, |
| // even if it's not the current view |
| |
| SfxObjectShell* pParentDoc = NULL; |
| if ( pB ) |
| { |
| SfxDispatcher* pMyDisp = pB->GetDispatcher(); |
| if (pMyDisp) |
| { |
| SfxViewFrame* pMyViewFrm = pMyDisp->GetFrame(); |
| if (pMyViewFrm) |
| { |
| pScViewShell = PTR_CAST( ScTabViewShell, pMyViewFrm->GetViewShell() ); |
| if( pScViewShell ) |
| pScViewShell->UpdateInputHandler(sal_True); |
| pParentDoc = pMyViewFrm->GetObjectShell(); |
| } |
| } |
| } |
| //if ( !pParentDoc && pScViewShell ) // use current only if above fails |
| // pParentDoc = pScViewShell->GetObjectShell(); |
| //if ( pParentDoc ) |
| // aDocName = pParentDoc->GetTitle(); |
| |
| if ( pDoc == NULL ) |
| pDoc = pViewData->GetDocument(); |
| m_xParser.set(ScServiceProvider::MakeInstance(SC_SERVICE_FORMULAPARS,(ScDocShell*)pDoc->GetDocumentShell()),uno::UNO_QUERY); |
| uno::Reference< beans::XPropertySet> xSet(m_xParser,uno::UNO_QUERY); |
| xSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_COMPILEFAP)),uno::makeAny(sal_True)); |
| |
| m_xOpCodeMapper.set(ScServiceProvider::MakeInstance(SC_SERVICE_OPCODEMAPPER,(ScDocShell*)pDoc->GetDocumentShell()),uno::UNO_QUERY); |
| |
| ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl(pScViewShell); |
| |
| DBG_ASSERT( pInputHdl, "Missing input handler :-/" ); |
| |
| if ( pInputHdl ) |
| pInputHdl->NotifyChange( NULL ); |
| |
| m_aHelper.enableInput( sal_False ); |
| m_aHelper.EnableSpreadsheets(); |
| m_aHelper.Init(); |
| m_aHelper.SetDispatcherLock( sal_True ); |
| |
| notifyChange(); |
| fill(); |
| |
| ScFormEditData* pData = pScMod->GetFormEditData(); |
| if (!pData) |
| { |
| //Nun wird es Zeit den Inputhandler festzulegen |
| pScMod->SetRefInputHdl(pScMod->GetInputHdl()); |
| |
| pDoc = pViewData->GetDocument(); |
| SCCOL nCol = pViewData->GetCurX(); |
| SCROW nRow = pViewData->GetCurY(); |
| SCTAB nTab = pViewData->GetTabNo(); |
| aCursorPos = ScAddress( nCol, nRow, nTab ); |
| |
| pScMod->InitFormEditData(); // neu anlegen |
| pData = pScMod->GetFormEditData(); |
| pData->SetInputHandler(pScMod->GetInputHdl()); |
| pData->SetDocShell(pViewData->GetDocShell()); |
| |
| DBG_ASSERT(pData,"FormEditData ist nicht da"); |
| |
| formula::FormulaDlgMode eMode = FORMULA_FORMDLG_FORMULA; // Default... |
| |
| // Formel vorhanden? Dann editieren |
| |
| String aFormula; |
| pDoc->GetFormula( nCol, nRow, nTab, aFormula ); |
| sal_Bool bEdit = ( aFormula.Len() > 1 ); |
| sal_Bool bMatrix = sal_False; |
| if ( bEdit ) |
| { |
| bMatrix = CheckMatrix(aFormula); |
| |
| xub_StrLen nFStart = 0; |
| xub_StrLen nFEnd = 0; |
| if ( GetFormulaHelper().GetNextFunc( aFormula, sal_False, nFStart, &nFEnd) ) |
| { |
| pScMod->InputReplaceSelection( aFormula ); |
| pScMod->InputSetSelection( nFStart, nFEnd ); |
| xub_StrLen PrivStart, PrivEnd; |
| pScMod->InputGetSelection( PrivStart, PrivEnd); |
| |
| eMode = SetMeText(pScMod->InputGetFormulaStr(),PrivStart, PrivEnd,bMatrix,sal_True,sal_True); |
| pData->SetFStart( nFStart ); |
| } |
| else |
| bEdit = sal_False; |
| } |
| |
| if ( !bEdit ) |
| { |
| String aNewFormula = '='; |
| if ( aFormula.Len() > 0 && aFormula.GetChar(0) == '=' ) |
| aNewFormula=aFormula; |
| |
| pScMod->InputReplaceSelection( aNewFormula ); |
| pScMod->InputSetSelection( 1, aNewFormula.Len()+1 ); |
| xub_StrLen PrivStart, PrivEnd; |
| pScMod->InputGetSelection( PrivStart, PrivEnd); |
| SetMeText(pScMod->InputGetFormulaStr(),PrivStart, PrivEnd,bMatrix,sal_False,sal_False); |
| |
| pData->SetFStart( 1 ); // hinter dem "=" |
| } |
| |
| pData->SetMode( (sal_uInt16) eMode ); |
| String rStrExp = GetMeText(); |
| |
| pCell = new ScFormulaCell( pDoc, aCursorPos, rStrExp ); |
| |
| Update(rStrExp); |
| } // if (!pData) |
| |
| } |
| |
| void ScFormulaDlg::notifyChange() |
| { |
| ScModule* pScMod = SC_MOD(); |
| |
| ScInputHandler* pInputHdl = pScMod->GetInputHdl(); |
| if ( pInputHdl ) |
| pInputHdl->NotifyChange( NULL ); |
| } |
| // ----------------------------------------------------------------------------- |
| void ScFormulaDlg::fill() |
| { |
| ScModule* pScMod = SC_MOD(); |
| ScFormEditData* pData = pScMod->GetFormEditData(); |
| notifyChange(); |
| String rStrExp; |
| if (pData) |
| { |
| // Daten schon vorhanden -> Zustand wiederherstellen (nach Umschalten) |
| // pDoc und aCursorPos nicht neu initialisieren |
| //pDoc = pViewData->GetDocument(); |
| if(IsInputHdl(pData->GetInputHandler())) |
| { |
| pScMod->SetRefInputHdl(pData->GetInputHandler()); |
| } |
| else |
| { |
| PtrTabViewShell pTabViewShell; |
| ScInputHandler* pInputHdl = GetNextInputHandler(pData->GetDocShell(),&pTabViewShell); |
| |
| if ( pInputHdl == NULL ) //DocShell hat keinen InputHandler mehr, |
| { //hat der Anwender halt Pech gehabt. |
| disableOk(); |
| pInputHdl = pScMod->GetInputHdl(); |
| } |
| else |
| { |
| pInputHdl->SetRefViewShell(pTabViewShell); |
| } |
| pScMod->SetRefInputHdl(pInputHdl); |
| pData->SetInputHandler(pInputHdl); |
| } |
| |
| String aOldFormulaTmp(pScMod->InputGetFormulaStr()); |
| pScMod->InputSetSelection( 0, aOldFormulaTmp.Len()); |
| |
| rStrExp=pData->GetUndoStr(); |
| pScMod->InputReplaceSelection(rStrExp); |
| |
| SetMeText(rStrExp); |
| |
| pCell = new ScFormulaCell( pDoc, aCursorPos, rStrExp ); |
| |
| Update(); |
| // Jetzt nochmals zurueckschalten, da evtl. neues Doc geoeffnet wurde! |
| pScMod->SetRefInputHdl(NULL); |
| } |
| } |
| |
| __EXPORT ScFormulaDlg::~ScFormulaDlg() |
| { |
| ScModule* pScMod = SC_MOD(); |
| ScFormEditData* pData = pScMod->GetFormEditData(); |
| |
| if (pData) // wird nicht ueber Close zerstoert; |
| { |
| //Referenz Inputhandler zuruecksetzen |
| pScMod->SetRefInputHdl(NULL); |
| } // if (pData) // wird nicht ueber Close zerstoert; |
| |
| delete pCell; |
| } |
| |
| sal_Bool ScFormulaDlg::IsInputHdl(ScInputHandler* pHdl) |
| { |
| sal_Bool bAlive = sal_False; |
| |
| // gehoert der InputHandler zu irgendeiner ViewShell ? |
| |
| TypeId aScType = TYPE(ScTabViewShell); |
| SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType ); |
| while ( pSh && !bAlive ) |
| { |
| if (((ScTabViewShell*)pSh)->GetInputHandler() == pHdl) |
| bAlive = sal_True; |
| pSh = SfxViewShell::GetNext( *pSh, &aScType ); |
| } |
| |
| return bAlive; |
| |
| } |
| |
| ScInputHandler* ScFormulaDlg::GetNextInputHandler(ScDocShell* pDocShell,PtrTabViewShell* ppViewSh) |
| { |
| ScInputHandler* pHdl=NULL; |
| |
| SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell ); |
| while( pFrame && pHdl==NULL) |
| { |
| SfxViewShell* p = pFrame->GetViewShell(); |
| ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,p); |
| if(pViewSh!=NULL) |
| { |
| pHdl=pViewSh->GetInputHandler(); |
| if(ppViewSh!=NULL) *ppViewSh=pViewSh; |
| } |
| pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell ); |
| } |
| |
| |
| return pHdl; |
| } |
| |
| |
| sal_Bool __EXPORT ScFormulaDlg::Close() |
| { |
| DoEnter(sal_False); |
| return sal_True; |
| } |
| |
| // -------------------------------------------------------------------------- |
| // Funktionen fuer rechte Seite |
| // -------------------------------------------------------------------------- |
| bool ScFormulaDlg::calculateValue( const String& rStrExp, String& rStrResult ) |
| { |
| sal_Bool bResult = sal_True; |
| |
| ::std::auto_ptr<ScFormulaCell> pFCell( new ScFormulaCell( pDoc, aCursorPos, rStrExp ) ); |
| |
| // #35521# HACK! um bei ColRowNames kein #REF! zu bekommen, |
| // wenn ein Name eigentlich als Bereich in die Gesamt-Formel |
| // eingefuegt wird, bei der Einzeldarstellung aber als |
| // single-Zellbezug interpretiert wird |
| sal_Bool bColRowName = pCell->HasColRowName(); |
| if ( bColRowName ) |
| { |
| // ColRowName im RPN-Code? |
| if ( pCell->GetCode()->GetCodeLen() <= 1 ) |
| { // ==1: einzelner ist als Parameter immer Bereich |
| // ==0: es waere vielleicht einer, wenn.. |
| String aBraced( '(' ); |
| aBraced += rStrExp; |
| aBraced += ')'; |
| pFCell.reset( new ScFormulaCell( pDoc, aCursorPos, aBraced ) ); |
| } |
| else |
| bColRowName = sal_False; |
| } |
| |
| sal_uInt16 nErrCode = pFCell->GetErrCode(); |
| if ( nErrCode == 0 ) |
| { |
| SvNumberFormatter& aFormatter = *(pDoc->GetFormatTable()); |
| Color* pColor; |
| if ( pFCell->IsValue() ) |
| { |
| double n = pFCell->GetValue(); |
| sal_uLong nFormat = aFormatter.GetStandardFormat( n, 0, |
| pFCell->GetFormatType(), ScGlobal::eLnge ); |
| aFormatter.GetOutputString( n, nFormat, |
| rStrResult, &pColor ); |
| } |
| else |
| { |
| String aStr; |
| |
| pFCell->GetString( aStr ); |
| sal_uLong nFormat = aFormatter.GetStandardFormat( |
| pFCell->GetFormatType(), ScGlobal::eLnge); |
| aFormatter.GetOutputString( aStr, nFormat, |
| rStrResult, &pColor ); |
| } |
| |
| ScRange aTestRange; |
| if ( bColRowName || (aTestRange.Parse(rStrExp) & SCA_VALID) ) |
| rStrResult.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " ..." )); |
| // Bereich |
| } |
| else |
| rStrResult += ScGlobal::GetErrorString(nErrCode); |
| |
| if(!isUserMatrix() && pFCell->GetMatrixFlag()) |
| { |
| CheckMatrix(); |
| } |
| |
| return bResult; |
| } |
| |
| |
| |
| // virtuelle Methoden von ScAnyRefDlg: |
| void ScFormulaDlg::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton ) |
| { |
| ::std::pair<formula::RefButton*,formula::RefEdit*> aPair = RefInputStartBefore( pEdit, pButton ); |
| m_aHelper.RefInputStart( aPair.second, aPair.first); |
| RefInputStartAfter( aPair.second, aPair.first ); |
| } |
| void ScFormulaDlg::RefInputDone( sal_Bool bForced ) |
| { |
| m_aHelper.RefInputDone( bForced ); |
| RefInputDoneAfter( bForced ); |
| } |
| |
| void ScFormulaDlg::SetReference( const ScRange& rRef, ScDocument* pRefDoc ) |
| { |
| const IFunctionDescription* pFunc = getCurrentFunctionDescription(); |
| if ( pFunc && pFunc->getSuppressedArgumentCount() > 0 ) |
| { |
| Selection theSel; |
| sal_Bool bRefNull = UpdateParaWin(theSel); |
| |
| if ( rRef.aStart != rRef.aEnd && bRefNull ) |
| { |
| RefInputStart(GetActiveEdit()); |
| } |
| |
| String aRefStr; |
| sal_Bool bOtherDoc = ( pRefDoc != pDoc && pRefDoc->GetDocumentShell()->HasName() ); |
| if ( bOtherDoc ) |
| { |
| // Referenz auf anderes Dokument - wie inputhdl.cxx |
| |
| DBG_ASSERT(rRef.aStart.Tab()==rRef.aEnd.Tab(), "nStartTab!=nEndTab"); |
| |
| String aTmp; |
| rRef.Format( aTmp, SCA_VALID|SCA_TAB_3D, pRefDoc ); // immer 3d |
| |
| SfxObjectShell* pObjSh = pRefDoc->GetDocumentShell(); |
| |
| // #i75893# convert escaped URL of the document to something user friendly |
| // String aFileName = pObjSh->GetMedium()->GetName(); |
| String aFileName = pObjSh->GetMedium()->GetURLObject().GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ); |
| |
| aRefStr = '\''; |
| aRefStr += aFileName; |
| aRefStr.AppendAscii(RTL_CONSTASCII_STRINGPARAM( "'#" )); |
| aRefStr += aTmp; |
| } |
| else |
| { |
| sal_uInt16 nFmt = ( rRef.aStart.Tab() == aCursorPos.Tab() ) |
| ? SCA_VALID |
| : SCA_VALID | SCA_TAB_3D; |
| rRef.Format( aRefStr, nFmt, pRefDoc, pRefDoc->GetAddressConvention() ); |
| } |
| |
| UpdateParaWin(theSel,aRefStr); |
| } |
| } |
| |
| sal_Bool ScFormulaDlg::IsRefInputMode() const |
| { |
| const IFunctionDescription* pDesc = getCurrentFunctionDescription(); |
| sal_Bool bRef = (pDesc && (pDesc->getSuppressedArgumentCount() > 0)) && (pDoc!=NULL); |
| return bRef; |
| } |
| |
| sal_Bool ScFormulaDlg::IsDocAllowed(SfxObjectShell* pDocSh) const |
| { |
| // not allowed: different from this doc, and no name |
| // pDocSh is always a ScDocShell |
| if ( pDocSh && ((ScDocShell*)pDocSh)->GetDocument() != pDoc && !pDocSh->HasName() ) |
| return sal_False; |
| |
| return sal_True; // everything else is allowed |
| } |
| |
| void ScFormulaDlg::SetActive() |
| { |
| const IFunctionDescription* pFunc = getCurrentFunctionDescription(); |
| if ( pFunc && pFunc->getSuppressedArgumentCount() > 0 ) |
| { |
| RefInputDone(); |
| SetEdSelection(); |
| } |
| } |
| |
| void ScFormulaDlg::SaveLRUEntry(const ScFuncDesc* pFuncDescP) |
| { |
| if (pFuncDescP && pFuncDescP->nFIndex!=0) |
| { |
| ScModule* pScMod = SC_MOD(); |
| pScMod->InsertEntryToLRUList(pFuncDescP->nFIndex); |
| } |
| } |
| |
| void ScFormulaDlg::doClose(sal_Bool /*_bOk*/) |
| { |
| m_aHelper.DoClose( ScFormulaDlgWrapper::GetChildWindowId() ); |
| } |
| void ScFormulaDlg::insertEntryToLRUList(const formula::IFunctionDescription* _pDesc) |
| { |
| const ScFuncDesc* pDesc = dynamic_cast<const ScFuncDesc*>(_pDesc); |
| SaveLRUEntry(pDesc); |
| } |
| void ScFormulaDlg::showReference(const String& _sFormula) |
| { |
| ShowReference(_sFormula); |
| } |
| void ScFormulaDlg::ShowReference(const String& _sFormula) |
| { |
| m_aHelper.ShowReference(_sFormula); |
| } |
| void ScFormulaDlg::HideReference( sal_Bool bDoneRefMode ) |
| { |
| m_aHelper.HideReference(bDoneRefMode); |
| } |
| void ScFormulaDlg::ViewShellChanged( ScTabViewShell* pScViewShell ) |
| { |
| m_aHelper.ViewShellChanged( pScViewShell ); |
| } |
| void ScFormulaDlg::AddRefEntry( ) |
| { |
| |
| } |
| sal_Bool ScFormulaDlg::IsTableLocked( ) const |
| { |
| // per Default kann bei Referenzeingabe auch die Tabelle umgeschaltet werden |
| return sal_False; |
| } |
| void ScFormulaDlg::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton) |
| { |
| m_aHelper.ToggleCollapsed(pEdit,pButton); |
| } |
| void ScFormulaDlg::ReleaseFocus( formula::RefEdit* pEdit, formula::RefButton* pButton) |
| { |
| m_aHelper.ReleaseFocus(pEdit,pButton); |
| } |
| void ScFormulaDlg::dispatch(sal_Bool _bOK,sal_Bool _bMartixChecked) |
| { |
| SfxBoolItem aRetItem( SID_DLG_RETOK, _bOK ); |
| SfxBoolItem aMatItem( SID_DLG_MATRIX, _bMartixChecked ); |
| SfxStringItem aStrItem( SCITEM_STRING, getCurrentFormula() ); |
| |
| // Wenn durch Dokument-Umschalterei die Eingabezeile weg war/ist, |
| // ist der String leer. Dann nicht die alte Formel loeschen. |
| if ( !aStrItem.GetValue().Len() ) |
| aRetItem.SetValue( sal_False ); // sal_False = Cancel |
| |
| m_aHelper.SetDispatcherLock( sal_False ); // Modal-Modus ausschalten |
| |
| clear(); |
| |
| GetBindings().GetDispatcher()->Execute( SID_INS_FUNCTION, |
| SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, |
| &aRetItem, &aStrItem, &aMatItem, 0L ); |
| } |
| void ScFormulaDlg::setDispatcherLock( sal_Bool bLock ) |
| { |
| m_aHelper.SetDispatcherLock( bLock ); |
| } |
| void ScFormulaDlg::setReferenceInput(const formula::FormEditData* _pData) |
| { |
| ScModule* pScMod = SC_MOD(); |
| ScFormEditData* pData = const_cast<ScFormEditData*>(dynamic_cast<const ScFormEditData*>(_pData)); |
| pScMod->SetRefInputHdl(pData->GetInputHandler()); |
| } |
| void ScFormulaDlg::deleteFormData() |
| { |
| ScModule* pScMod = SC_MOD(); |
| pScMod->ClearFormEditData(); // pData wird ungueltig! |
| } |
| void ScFormulaDlg::clear() |
| { |
| pDoc = NULL; |
| |
| //Referenz Inputhandler zuruecksetzen |
| ScModule* pScMod = SC_MOD(); |
| pScMod->SetRefInputHdl(NULL); |
| |
| // Enable() der Eingabezeile erzwingen: |
| ScTabViewShell* pScViewShell = PTR_CAST(ScTabViewShell, SfxViewShell::Current()); |
| if ( pScViewShell ) |
| pScViewShell->UpdateInputHandler(); |
| } |
| void ScFormulaDlg::switchBack() |
| { |
| ScModule* pScMod = SC_MOD(); |
| // auf das Dokument zurueckschalten |
| // (noetig, weil ein fremdes oben sein kann - #34222#) |
| ScInputHandler* pHdl = pScMod->GetInputHdl(); |
| if ( pHdl ) |
| { |
| pHdl->ViewShellGone(NULL); // -> aktive View neu holen |
| pHdl->ShowRefFrame(); |
| } |
| |
| // aktuelle Tabelle ggF. restaurieren (wg. Maus-RefInput) |
| ScTabViewShell* pScViewShell = PTR_CAST(ScTabViewShell, SfxViewShell::Current()); |
| if ( pScViewShell ) |
| { |
| ScViewData* pVD=pScViewShell->GetViewData(); |
| SCTAB nExecTab = aCursorPos.Tab(); |
| if ( nExecTab != pVD->GetTabNo() ) |
| pScViewShell->SetTabNo( nExecTab ); |
| |
| SCROW nRow=aCursorPos.Row(); |
| SCCOL nCol=aCursorPos.Col(); |
| |
| if(pVD->GetCurX()!=nCol || pVD->GetCurY()!=nRow) |
| pScViewShell->SetCursor(nCol,nRow); |
| } |
| } |
| formula::FormEditData* ScFormulaDlg::getFormEditData() const |
| { |
| ScModule* pScMod = SC_MOD(); |
| return pScMod->GetFormEditData(); |
| } |
| void ScFormulaDlg::setCurrentFormula(const String& _sReplacement) |
| { |
| ScModule* pScMod = SC_MOD(); |
| pScMod->InputReplaceSelection(_sReplacement); |
| } |
| void ScFormulaDlg::setSelection(xub_StrLen _nStart,xub_StrLen _nEnd) |
| { |
| ScModule* pScMod = SC_MOD(); |
| pScMod->InputSetSelection( _nStart, _nEnd ); |
| } |
| void ScFormulaDlg::getSelection(xub_StrLen& _nStart,xub_StrLen& _nEnd) const |
| { |
| ScModule* pScMod = SC_MOD(); |
| pScMod->InputGetSelection( _nStart, _nEnd ); |
| } |
| String ScFormulaDlg::getCurrentFormula() const |
| { |
| ScModule* pScMod = SC_MOD(); |
| return pScMod->InputGetFormulaStr(); |
| } |
| formula::IFunctionManager* ScFormulaDlg::getFunctionManager() |
| { |
| return ScGlobal::GetStarCalcFunctionMgr(); |
| } |
| uno::Reference< sheet::XFormulaParser> ScFormulaDlg::getFormulaParser() const |
| { |
| return m_xParser; |
| } |
| uno::Reference< sheet::XFormulaOpCodeMapper> ScFormulaDlg::getFormulaOpCodeMapper() const |
| { |
| return m_xOpCodeMapper; |
| } |
| |
| table::CellAddress ScFormulaDlg::getReferencePosition() const |
| { |
| return table::CellAddress(aCursorPos.Tab(),aCursorPos.Col(),aCursorPos.Row()); |
| } |
| |
| ::std::auto_ptr<formula::FormulaTokenArray> ScFormulaDlg::convertToTokenArray(const uno::Sequence< sheet::FormulaToken >& _aTokenList) |
| { |
| ::std::auto_ptr<formula::FormulaTokenArray> pArray(new ScTokenArray()); |
| pArray->Fill( _aTokenList, pDoc->GetExternalRefManager()); |
| return pArray; |
| } |
| |