1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_formula.hxx"
26
27 //----------------------------------------------------------------------------
28 #include <sfx2/dispatch.hxx>
29 #include <sfx2/docfile.hxx>
30 #include <sfx2/viewfrm.hxx>
31 #include <vcl/svapp.hxx>
32 #include <vcl/mnemonic.hxx>
33 #include <vcl/tabpage.hxx>
34 #include <vcl/tabctrl.hxx>
35 #include <vcl/lstbox.hxx>
36 #include <vcl/group.hxx>
37 #include <vcl/wall.hxx>
38
39 #include <svtools/stdctrl.hxx>
40 #include <svtools/svmedit.hxx>
41 #include <svtools/svtreebx.hxx>
42 #include <svl/stritem.hxx>
43 #include <svl/zforlist.hxx>
44 #include <svl/eitem.hxx>
45
46 #include <unotools/charclass.hxx>
47 #include <tools/urlobj.hxx>
48 #include <tools/diagnose_ex.h>
49
50 #include "formdlgs.hrc"
51 #include "funcpage.hxx"
52 #include "formula/formula.hxx"
53 #include "formula/IFunctionDescription.hxx"
54 #include "formula/FormulaCompiler.hxx"
55 #include "formula/token.hxx"
56 #include "formula/tokenarray.hxx"
57 #include "formula/formdata.hxx"
58 #include "formula/formulahelper.hxx"
59 #include "structpg.hxx"
60 #include "parawin.hxx"
61 #include "ModuleHelper.hxx"
62 #include "ForResId.hrc"
63 #include <com/sun/star/sheet/FormulaToken.hpp>
64 #include <com/sun/star/sheet/FormulaLanguage.hpp>
65 #include <com/sun/star/sheet/FormulaMapGroup.hpp>
66 #include <com/sun/star/sheet/FormulaMapGroupSpecialOffset.hpp>
67 #include <com/sun/star/beans/XPropertySet.hpp>
68 #include <boost/bind.hpp>
69 #include <comphelper/processfactory.hxx>
70 #include <map>
71
72 #define TOKEN_OPEN 0
73 #define TOKEN_CLOSE 1
74 #define TOKEN_SEP 2
75 namespace formula
76 {
77 using namespace ::com::sun::star;
78
79 class OFormulaToken : public IFormulaToken
80 {
81 sal_Int32 m_nParaCount;
82 bool m_bIsFunction;
83
84 public:
OFormulaToken(bool _bFunction,sal_Int32 _nParaCount)85 OFormulaToken(bool _bFunction,sal_Int32 _nParaCount) : m_nParaCount(_nParaCount),m_bIsFunction(_bFunction){}
86
isFunction() const87 virtual bool isFunction() const { return m_bIsFunction; }
getArgumentCount() const88 virtual sal_uInt32 getArgumentCount() const { return m_nParaCount; }
89 };
90
91
92 class FormulaDlg_Impl
93 {
94 public:
95 ::std::pair<RefButton*,RefEdit*>
96 RefInputStartBefore( RefEdit* pEdit, RefButton* pButton );
97 void RefInputStartAfter( RefEdit* pEdit, RefButton* pButton );
98 void RefInputDoneAfter( sal_Bool bForced );
99 sal_Bool CalcValue( const String& rStrExp, String& rStrResult );
100 sal_Bool CalcStruct( const String& rStrExp);
101 void UpdateValues();
102 void DeleteArgs();
103 xub_StrLen GetFunctionPos(xub_StrLen nPos);
104 void ClearAllParas();
105
106 void MakeTree(IStructHelper* _pTree,SvLBoxEntry* pParent,FormulaToken* _pToken,long Count);
107 void fillTree(IStructHelper* _pTree);
108 void UpdateTokenArray( const String& rStrExp);
109 String RepairFormula(const String& aFormula);
110 void FillDialog(sal_Bool nFlag=sal_True);
111 void EditNextFunc( sal_Bool bForward, xub_StrLen nFStart=NOT_FOUND );
112 void EditThisFunc(xub_StrLen nFStart);
113 void EditFuncParas(xub_StrLen nEditPos);
114
115
116 void UpdateArgInput( sal_uInt16 nOffset, sal_uInt16 nInput );
117 void Update();
118 void Update(const String& _sExp);
119
120
121 void SaveArg( sal_uInt16 nEd );
122 void UpdateSelection();
123 void DoEnter( sal_Bool bOk );
124 void UpdateFunctionDesc();
125 void ResizeArgArr( const IFunctionDescription* pNewFunc );
126 void FillListboxes();
127 void FillControls(sal_Bool &rbNext, sal_Bool &rbPrev);
128
129 FormulaDlgMode SetMeText(const String& _sText,xub_StrLen PrivStart, xub_StrLen PrivEnd,sal_Bool bMatrix,sal_Bool _bSelect,sal_Bool _bUpdate);
130 void SetMeText(const String& _sText);
131 sal_Bool CheckMatrix(String& aFormula /*IN/OUT*/);
132
133 void SetEdSelection();
134
135 sal_Bool UpdateParaWin(Selection& _rSelection);
136 void UpdateParaWin(const Selection& _rSelection,const String& _sRefStr);
137
138 void SetData(xub_StrLen nFStart,xub_StrLen nNextFStart,xub_StrLen nNextFEnd,xub_StrLen& PrivStart,xub_StrLen& PrivEnd);
139 void PreNotify( NotifyEvent& rNEvt );
140
141 RefEdit* GetCurrRefEdit();
142 rtl::OString FindFocusWin(Window *pWin);
143
144 const FormulaHelper& GetFormulaHelper() const;
145 uno::Reference< sheet::XFormulaOpCodeMapper > GetFormulaOpCodeMapper() const;
146
147 DECL_LINK( ModifyHdl, ParaWin* );
148 DECL_LINK( FxHdl, ParaWin* );
149
150 DECL_LINK( MatrixHdl, CheckBox *);
151 DECL_LINK( FormulaHdl, MultiLineEdit* );
152 DECL_LINK( FormulaCursorHdl, EditBox*);
153 DECL_LINK( BtnHdl, PushButton* );
154 DECL_LINK( GetEdFocusHdl, ArgInput* );
155 DECL_LINK( GetFxFocusHdl, ArgInput* );
156 DECL_LINK( DblClkHdl, FuncPage* );
157 DECL_LINK( FuncSelHdl, FuncPage*);
158 DECL_LINK( StructSelHdl, StructPage * );
159 public:
160 OModuleClient m_aModuleClient;
161 mutable uno::Reference< sheet::XFormulaOpCodeMapper> m_xOpCodeMapper;
162 uno::Sequence< sheet::FormulaToken > m_aTokenList;
163 ::std::auto_ptr<FormulaTokenArray> m_pTokenArray;
164 mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aSpecialOpCodes;
165 mutable const sheet::FormulaOpCodeMapEntry* m_pSpecialOpCodesEnd;
166 mutable uno::Sequence< sheet::FormulaToken > m_aSeparatorsOpCodes;
167 mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aFunctionOpCodes;
168 mutable const sheet::FormulaOpCodeMapEntry* m_pFunctionOpCodesEnd;
169 mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aUnaryOpCodes;
170 mutable const sheet::FormulaOpCodeMapEntry* m_pUnaryOpCodesEnd;
171 mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aBinaryOpCodes;
172 mutable const sheet::FormulaOpCodeMapEntry* m_pBinaryOpCodesEnd;
173 ::std::vector< ::boost::shared_ptr<OFormulaToken> > m_aTokens;
174 ::std::map<FormulaToken*,sheet::FormulaToken> m_aTokenMap;
175 IFormulaEditorHelper* m_pHelper;
176 Dialog* m_pParent;
177 IControlReferenceHandler* m_pDlg;
178 TabControl aTabCtrl;
179 GroupBox aGEdit; //! MUST be placed before pParaWin for initializing
180 ParaWin* pParaWin;
181 FixedText aFtHeadLine;
182 FixedInfo aFtFuncName;
183 FixedInfo aFtFuncDesc;
184
185 FixedText aFtEditName;
186 //FixedInfo aFtEditDesc;
187
188 FixedText aFtResult;
189 ValWnd aWndResult;
190
191 FixedText aFtFormula;
192 EditBox aMEFormula;
193
194 CheckBox aBtnMatrix;
195 HelpButton aBtnHelp;
196 CancelButton aBtnCancel;
197
198 PushButton aBtnBackward;
199 PushButton aBtnForward;
200 OKButton aBtnEnd;
201
202 RefEdit aEdRef;
203 RefButton aRefBtn;
204
205 FixedText aFtFormResult;
206 ValWnd aWndFormResult;
207
208 RefEdit* pTheRefEdit;
209 RefButton* pTheRefButton;
210 FuncPage* pFuncPage;
211 StructPage* pStructPage;
212 String aOldFormula;
213 sal_Bool bStructUpdate;
214 MultiLineEdit* pMEdit;
215 sal_Bool bUserMatrixFlag;
216 Timer aTimer;
217
218 const String aTitle1;
219 const String aTitle2;
220 const String aTxtEnd;
221 const String aTxtOk; // hinter aBtnEnd
222 FormulaHelper
223 m_aFormulaHelper;
224
225 rtl::OString m_aEditHelpId;
226
227 rtl::OString aOldHelp;
228 rtl::OString aOldUnique;
229 rtl::OString aActivWinId;
230 sal_Bool bIsShutDown;
231
232
233
234 Font aFntBold;
235 Font aFntLight;
236 sal_uInt16 nEdFocus;
237 // Selection theCurSel;
238 sal_Bool bEditFlag;
239 const IFunctionDescription* pFuncDesc;
240 xub_StrLen nArgs;
241 ::std::vector< ::rtl::OUString > m_aArguments;
242 Selection aFuncSel;
243
244 FormulaDlg_Impl(Dialog* pParent
245 , bool _bSupportFunctionResult
246 , bool _bSupportResult
247 , bool _bSupportMatrix
248 ,IFormulaEditorHelper* _pHelper
249 ,const IFunctionManager* _pFunctionMgr
250 ,IControlReferenceHandler* _pDlg);
251 ~FormulaDlg_Impl();
252
253 };
FormulaDlg_Impl(Dialog * pParent,bool _bSupportFunctionResult,bool _bSupportResult,bool _bSupportMatrix,IFormulaEditorHelper * _pHelper,const IFunctionManager * _pFunctionMgr,IControlReferenceHandler * _pDlg)254 FormulaDlg_Impl::FormulaDlg_Impl(Dialog* pParent
255 , bool _bSupportFunctionResult
256 , bool _bSupportResult
257 , bool _bSupportMatrix
258 ,IFormulaEditorHelper* _pHelper
259 ,const IFunctionManager* _pFunctionMgr
260 ,IControlReferenceHandler* _pDlg)
261 :
262 m_pHelper (_pHelper),
263 m_pParent (pParent),
264 m_pDlg (_pDlg),
265 aTabCtrl ( pParent, ModuleRes( TC_FUNCTION ) ),
266 aGEdit ( pParent, ModuleRes( GB_EDIT ) ),
267 aFtHeadLine ( pParent, ModuleRes( FT_HEADLINE ) ),
268 aFtFuncName ( pParent, ModuleRes( FT_FUNCNAME ) ),
269 aFtFuncDesc ( pParent, ModuleRes( FT_FUNCDESC ) ),
270 //
271 aFtEditName ( pParent, ModuleRes( FT_EDITNAME ) ),
272 aFtResult ( pParent, ModuleRes( FT_RESULT ) ),
273 aWndResult ( pParent, ModuleRes( WND_RESULT ) ),
274
275 aFtFormula ( pParent, ModuleRes( FT_FORMULA ) ),
276 aMEFormula ( pParent, ModuleRes( ED_FORMULA ) ),
277 //
278 aBtnMatrix ( pParent, ModuleRes( BTN_MATRIX ) ),
279 aBtnHelp ( pParent, ModuleRes( BTN_HELP ) ),
280 aBtnCancel ( pParent, ModuleRes( BTN_CANCEL ) ),
281 aBtnBackward ( pParent, ModuleRes( BTN_BACKWARD ) ),
282 aBtnForward ( pParent, ModuleRes( BTN_FORWARD ) ),
283 aBtnEnd ( pParent, ModuleRes( BTN_END ) ),
284 aEdRef ( pParent, _pDlg, ModuleRes( ED_REF) ),
285 aRefBtn ( pParent, ModuleRes( RB_REF),&aEdRef,_pDlg ),
286 aFtFormResult ( pParent, ModuleRes( FT_FORMULA_RESULT)),
287 aWndFormResult ( pParent, ModuleRes( WND_FORMULA_RESULT)),
288 //
289 pTheRefEdit (NULL),
290 pMEdit (NULL),
291 bUserMatrixFlag (sal_False),
292 //
293 aTitle1 ( ModuleRes( STR_TITLE1 ) ), // lokale Resource
294 aTitle2 ( ModuleRes( STR_TITLE2 ) ), // lokale Resource
295 aTxtEnd ( ModuleRes( STR_END ) ), // lokale Resource
296 aTxtOk ( aBtnEnd.GetText() ),
297 m_aFormulaHelper(_pFunctionMgr),
298 //
299 bIsShutDown (sal_False),
300 nEdFocus (0),
301 pFuncDesc (NULL),
302 nArgs (0)
303 {
304 pParaWin = new ParaWin( pParent,_pDlg, aGEdit.GetPosPixel());
305 aGEdit.Hide();
306 pParaWin->Hide();
307 aFtEditName.Hide();
308 aEdRef.Hide();
309 aRefBtn.Hide();
310
311 pMEdit = aMEFormula.GetEdit();
312 aMEFormula.SetAccessibleName(aFtFormula.GetText());
313 if (pMEdit)
314 pMEdit->SetAccessibleName(aFtFormula.GetText());
315 m_aEditHelpId = pMEdit->GetHelpId();
316 pMEdit->SetUniqueId( m_aEditHelpId );
317
318 bEditFlag=sal_False;
319 bStructUpdate=sal_True;
320 Point aPos=aGEdit.GetPosPixel();
321 pParaWin->SetPosPixel(aPos);
322 pParaWin->SetArgModifiedHdl(LINK( this, FormulaDlg_Impl, ModifyHdl ) );
323 pParaWin->SetFxHdl(LINK( this, FormulaDlg_Impl, FxHdl ) );
324
325 pFuncPage= new FuncPage( &aTabCtrl,_pFunctionMgr);
326 pStructPage= new StructPage( &aTabCtrl);
327 pFuncPage->Hide();
328 pStructPage->Hide();
329 aTabCtrl.SetTabPage( TP_FUNCTION, pFuncPage);
330 aTabCtrl.SetTabPage( TP_STRUCT, pStructPage);
331
332 aOldHelp = pParent->GetHelpId(); // HelpId aus Resource immer fuer "Seite 1"
333 aOldUnique = pParent->GetUniqueId();
334
335 aFtResult.Show( _bSupportResult );
336 aWndResult.Show( _bSupportResult );
337
338 aFtFormResult.Show( _bSupportFunctionResult );
339 aWndFormResult.Show( _bSupportFunctionResult );
340
341 if ( _bSupportMatrix )
342 aBtnMatrix.SetClickHdl(LINK( this, FormulaDlg_Impl, MatrixHdl ) );
343 else
344 aBtnMatrix.Hide();
345
346 aBtnCancel .SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
347 aBtnEnd .SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
348 aBtnForward .SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
349 aBtnBackward.SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
350
351 pFuncPage->SetDoubleClickHdl( LINK( this, FormulaDlg_Impl, DblClkHdl ) );
352 pFuncPage->SetSelectHdl( LINK( this, FormulaDlg_Impl, FuncSelHdl) );
353 pStructPage->SetSelectionHdl( LINK( this, FormulaDlg_Impl, StructSelHdl ) );
354 pMEdit->SetModifyHdl( LINK( this, FormulaDlg_Impl, FormulaHdl ) );
355 aMEFormula.SetSelChangedHdl( LINK( this, FormulaDlg_Impl, FormulaCursorHdl ) );
356
357 aFntLight = aFtFormula.GetFont();
358 aFntLight.SetTransparent( sal_True );
359 aFntBold = aFntLight;
360 aFntBold.SetWeight( WEIGHT_BOLD );
361
362 pParaWin->SetArgumentFonts(aFntBold,aFntLight);
363
364 // function description for choosing a function is no longer in a different color
365
366 aFtHeadLine.SetFont(aFntBold);
367 aFtFuncName.SetFont(aFntLight);
368 aFtFuncDesc.SetFont(aFntLight);
369 }
~FormulaDlg_Impl()370 FormulaDlg_Impl::~FormulaDlg_Impl()
371 {
372 if(aTimer.IsActive())
373 {
374 aTimer.SetTimeoutHdl(Link());
375 aTimer.Stop();
376 } // if(aTimer.IsActive())
377 bIsShutDown=sal_True;// Setzen, damit PreNotify keinen GetFocus speichert.
378 FormEditData* pData = m_pHelper->getFormEditData();
379 if (pData) // wird nicht ueber Close zerstoert;
380 {
381 pData->SetFStart((xub_StrLen)pMEdit->GetSelection().Min());
382 pData->SetSelection(pMEdit->GetSelection());
383
384 if(aTabCtrl.GetCurPageId()==TP_FUNCTION)
385 pData->SetMode( (sal_uInt16) FORMULA_FORMDLG_FORMULA );
386 else
387 pData->SetMode( (sal_uInt16) FORMULA_FORMDLG_EDIT );
388 pData->SetUndoStr(pMEdit->GetText());
389 pData->SetMatrixFlag(aBtnMatrix.IsChecked());
390 }
391
392 aTabCtrl.RemovePage(TP_FUNCTION);
393 aTabCtrl.RemovePage(TP_STRUCT);
394
395 delete pStructPage;
396 delete pFuncPage;
397 delete pParaWin;
398 DeleteArgs();
399 }
400 // -----------------------------------------------------------------------------
PreNotify(NotifyEvent & rNEvt)401 void FormulaDlg_Impl::PreNotify( NotifyEvent& rNEvt )
402 {
403 sal_uInt16 nSwitch=rNEvt.GetType();
404 if(nSwitch==EVENT_GETFOCUS && !bIsShutDown)
405 {
406 Window* pWin=rNEvt.GetWindow();
407 if(pWin!=NULL)
408 {
409 aActivWinId = pWin->GetUniqueId();
410 if(aActivWinId.getLength()==0)
411 {
412 Window* pParent=pWin->GetParent();
413 while(pParent!=NULL)
414 {
415 aActivWinId=pParent->GetUniqueId();
416
417 if(aActivWinId.getLength()!=0) break;
418
419 pParent=pParent->GetParent();
420 }
421 }
422 if(aActivWinId.getLength())
423 {
424
425 FormEditData* pData = m_pHelper->getFormEditData();
426
427 if (pData && !aTimer.IsActive()) // wird nicht ueber Close zerstoert;
428 {
429 pData->SetUniqueId(aActivWinId);
430 }
431 }
432 }
433 }
434 }
GetFormulaOpCodeMapper() const435 uno::Reference< sheet::XFormulaOpCodeMapper > FormulaDlg_Impl::GetFormulaOpCodeMapper() const
436 {
437 if ( !m_xOpCodeMapper.is() )
438 {
439 m_xOpCodeMapper = m_pHelper->getFormulaOpCodeMapper();
440 m_aFunctionOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::FUNCTIONS);
441 m_pFunctionOpCodesEnd = m_aFunctionOpCodes.getConstArray() + m_aFunctionOpCodes.getLength();
442
443 m_aUnaryOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::UNARY_OPERATORS);
444 m_pUnaryOpCodesEnd = m_aUnaryOpCodes.getConstArray() + m_aUnaryOpCodes.getLength();
445
446 m_aBinaryOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::BINARY_OPERATORS);
447 m_pBinaryOpCodesEnd = m_aBinaryOpCodes.getConstArray() + m_aBinaryOpCodes.getLength();
448
449 uno::Sequence< ::rtl::OUString > aArgs(3);
450 aArgs[TOKEN_OPEN] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("("));
451 aArgs[TOKEN_CLOSE] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")"));
452 aArgs[TOKEN_SEP] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(";"));
453 m_aSeparatorsOpCodes = m_xOpCodeMapper->getMappings(aArgs,sheet::FormulaLanguage::ODFF);
454
455 m_aSpecialOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::SPECIAL);
456 m_pSpecialOpCodesEnd = m_aSpecialOpCodes.getConstArray() + m_aSpecialOpCodes.getLength();
457 } // if ( !m_xOpCodeMapper.is() )
458 return m_xOpCodeMapper;
459 }
460
DeleteArgs()461 void FormulaDlg_Impl::DeleteArgs()
462 {
463 ::std::vector< ::rtl::OUString>().swap(m_aArguments);
464 nArgs = 0;
465 }
466 namespace
467 {
468 // comparing two property instances
469 struct OpCodeCompare : public ::std::binary_function< sheet::FormulaOpCodeMapEntry, sal_Int32 , bool >
470 {
operator ()formula::__anon37c2110d0111::OpCodeCompare471 bool operator() (const sheet::FormulaOpCodeMapEntry& x, sal_Int32 y) const
472 {
473 return x.Token.OpCode == y;
474 }
475 };
476 }
477 // -----------------------------------------------------------------------------
GetFunctionPos(xub_StrLen nPos)478 xub_StrLen FormulaDlg_Impl::GetFunctionPos(xub_StrLen nPos)
479 {
480 const sal_Unicode sep = m_pHelper->getFunctionManager()->getSingleToken(IFunctionManager::eSep);
481
482 xub_StrLen nTokPos=1;
483 xub_StrLen nOldTokPos=1;
484 xub_StrLen nFuncPos=STRING_NOTFOUND; //@ Testweise
485 xub_StrLen nPrevFuncPos=1;
486 short nBracketCount=0;
487 sal_Bool bFlag=sal_False;
488 String aFormString = pMEdit->GetText();
489 m_aFormulaHelper.GetCharClass()->toUpper( aFormString );
490
491 if ( m_aTokenList.getLength() )
492 {
493 const uno::Reference< sheet::XFormulaParser > xParser(m_pHelper->getFormulaParser());
494 const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
495
496 const sheet::FormulaToken* pIter = m_aTokenList.getConstArray();
497 const sheet::FormulaToken* pEnd = pIter + m_aTokenList.getLength();
498 //if ( pIter != pEnd && aFormString.GetChar(0) == '=' )
499 // ++pIter;
500 try
501 {
502 while ( pIter != pEnd )
503 {
504 const sal_Int32 eOp = pIter->OpCode;
505 uno::Sequence<sheet::FormulaToken> aArgs(1);
506 aArgs[0] = *pIter;
507 const String aString = xParser->printFormula(aArgs, aRefPos);
508 const sheet::FormulaToken* pNextToken = pIter + 1;
509
510 if(!bUserMatrixFlag && FormulaCompiler::IsMatrixFunction((OpCode)eOp) )
511 {
512 aBtnMatrix.Check();
513 }
514
515 if ( eOp == m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::PUSH].Token.OpCode || eOp == m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::SPACES].Token.OpCode )
516 {
517 const xub_StrLen n1=aFormString.Search(sep, nTokPos);
518 const xub_StrLen n2=aFormString.Search(')',nTokPos);
519 xub_StrLen nXXX=nTokPos;
520 if(n1<n2)
521 {
522 nTokPos=n1;
523 }
524 else
525 {
526 nTokPos=n2;
527 }
528 if ( pNextToken != pEnd )
529 {
530 aArgs[0] = *pNextToken;
531 const String a2String = xParser->printFormula(aArgs, aRefPos);
532 const xub_StrLen n3 = aFormString.Search(a2String,nXXX);
533 if ( n3 < nTokPos )
534 nTokPos = n3;
535 }
536 }
537 else
538 {
539 nTokPos = sal::static_int_cast<xub_StrLen>( nTokPos + aString.Len() );
540 }
541
542 if ( eOp == m_aSeparatorsOpCodes[TOKEN_OPEN].OpCode )
543 {
544 nBracketCount++;
545 bFlag=sal_True;
546 }
547 else if ( eOp == m_aSeparatorsOpCodes[TOKEN_CLOSE].OpCode )
548 {
549 nBracketCount--;
550 bFlag=sal_False;
551 nFuncPos=nPrevFuncPos;
552 }
553 bool bIsFunction = ::std::find_if(m_aFunctionOpCodes.getConstArray(),m_pFunctionOpCodesEnd,::std::bind2nd(OpCodeCompare(),boost::cref(eOp))) != m_pFunctionOpCodesEnd;
554
555 if ( bIsFunction && m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::SPACES].Token.OpCode != eOp )
556 {
557 nPrevFuncPos = nFuncPos;
558 nFuncPos = nOldTokPos;
559 }
560
561 if ( nOldTokPos <= nPos && nPos < nTokPos )
562 {
563 if ( !bIsFunction )
564 {
565 if ( nBracketCount < 1 )
566 {
567 nFuncPos= pMEdit->GetText().Len();
568 }
569 else if ( !bFlag )
570 {
571 nFuncPos=nPrevFuncPos;
572 }
573 }
574 break;
575 }
576
577 pIter = pNextToken;
578 nOldTokPos = nTokPos;
579 } // while ( pIter != pEnd )
580 }
581 catch(const uno::Exception& )
582 {
583 DBG_ERROR("Exception caught!");
584 }
585 }
586
587 return nFuncPos;
588 }
589 // -----------------------------------------------------------------------------
CalcValue(const String & rStrExp,String & rStrResult)590 sal_Bool FormulaDlg_Impl::CalcValue( const String& rStrExp, String& rStrResult )
591 {
592 sal_Bool bResult = sal_True;
593
594 if ( rStrExp.Len() > 0 )
595 {
596 // nur, wenn keine Tastatureingabe mehr anliegt, den Wert berechnen:
597
598 if ( !Application::AnyInput( INPUT_KEYBOARD ) )
599 {
600 bResult = m_pHelper->calculateValue(rStrExp,rStrResult);
601 }
602 else
603 bResult = sal_False;
604 }
605
606 return bResult;
607 }
608
UpdateValues()609 void FormulaDlg_Impl::UpdateValues()
610 {
611 String aStrResult;
612
613 if ( CalcValue( pFuncDesc->getFormula( m_aArguments ), aStrResult ) )
614 aWndResult.SetValue( aStrResult );
615
616 aStrResult.Erase();
617 if ( CalcValue(m_pHelper->getCurrentFormula(), aStrResult ) )
618 aWndFormResult.SetValue( aStrResult );
619 else
620 {
621 aStrResult.Erase();
622 aWndFormResult.SetValue( aStrResult );
623 }
624 CalcStruct(pMEdit->GetText());
625 }
626
CalcStruct(const String & rStrExp)627 sal_Bool FormulaDlg_Impl::CalcStruct( const String& rStrExp)
628 {
629 sal_Bool bResult = sal_True;
630 xub_StrLen nLength=rStrExp.Len();
631
632 if ( rStrExp.Len() > 0 && aOldFormula!=rStrExp && bStructUpdate)
633 {
634 // nur, wenn keine Tastatureingabe mehr anliegt, den Wert berechnen:
635
636 if ( !Application::AnyInput( INPUT_KEYBOARD ) )
637 {
638 pStructPage->ClearStruct();
639
640 String aString=rStrExp;
641 if(rStrExp.GetChar(nLength-1)=='(')
642 {
643 aString.Erase((xub_StrLen)(nLength-1));
644 }
645
646 aString.EraseAllChars('\n');
647 String aStrResult;
648
649 if ( CalcValue(aString, aStrResult ) )
650 aWndFormResult.SetValue( aStrResult );
651
652 UpdateTokenArray(aString);
653 fillTree(pStructPage);
654
655 aOldFormula=rStrExp;
656 if(rStrExp.GetChar(nLength-1)=='(')
657 UpdateTokenArray(rStrExp);
658 }
659 else
660 bResult = sal_False;
661 }
662 return bResult;
663 }
664
665 // -----------------------------------------------------------------------------
MakeTree(IStructHelper * _pTree,SvLBoxEntry * pParent,FormulaToken * _pToken,long Count)666 void FormulaDlg_Impl::MakeTree(IStructHelper* _pTree,SvLBoxEntry* pParent,FormulaToken* _pToken,long Count)
667 {
668 if( _pToken != NULL && Count > 0 )
669 {
670 long nParas = _pToken->GetParamCount();
671 OpCode eOp = _pToken->GetOpCode();
672
673 // #i101512# for output, the original token is needed
674 FormulaToken* pOrigToken = (_pToken->GetType() == svFAP) ? _pToken->GetFAPOrigToken() : _pToken;
675 uno::Sequence<sheet::FormulaToken> aArgs(1);
676 aArgs[0] = m_aTokenMap.find(pOrigToken)->second;
677 try
678 {
679 const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
680 const String aResult = m_pHelper->getFormulaParser()->printFormula(aArgs, aRefPos);
681
682 if ( nParas > 0 )
683 {
684 SvLBoxEntry* pEntry;
685
686 String aTest=_pTree->GetEntryText(pParent);
687
688 if(aTest==aResult &&
689 (eOp==ocAdd || eOp==ocMul ||
690 eOp==ocAmpersand))
691 {
692 pEntry=pParent;
693 }
694 else
695 {
696 if(eOp==ocBad)
697 {
698 pEntry=_pTree->InsertEntry(aResult,pParent,STRUCT_ERROR,0,_pToken);
699 }
700 else
701 {
702 pEntry=_pTree->InsertEntry(aResult,pParent,STRUCT_FOLDER,0,_pToken);
703 }
704 }
705
706 MakeTree(_pTree,pEntry,m_pTokenArray->PrevRPN(),nParas);
707 --Count;
708 m_pTokenArray->NextRPN();
709 MakeTree(_pTree,pParent,m_pTokenArray->PrevRPN(),Count);
710 }
711 else
712 {
713 if(eOp==ocBad)
714 {
715 _pTree->InsertEntry(aResult,pParent,STRUCT_ERROR,0,_pToken);
716 }
717 else
718 {
719 _pTree->InsertEntry(aResult,pParent,STRUCT_END,0,_pToken);
720 }
721 --Count;
722 MakeTree(_pTree,pParent,m_pTokenArray->PrevRPN(),Count);
723 }
724 }
725 catch(uno::Exception&)
726 {
727 DBG_UNHANDLED_EXCEPTION();
728 }
729 }
730 }
731
fillTree(IStructHelper * _pTree)732 void FormulaDlg_Impl::fillTree(IStructHelper* _pTree)
733 {
734 GetFormulaOpCodeMapper();
735 FormulaToken* pToken = m_pTokenArray->LastRPN();
736
737 if( pToken != NULL)
738 {
739 MakeTree(_pTree,NULL,pToken,1);
740 }
741 }
UpdateTokenArray(const String & rStrExp)742 void FormulaDlg_Impl::UpdateTokenArray( const String& rStrExp)
743 {
744 m_aTokenMap.clear();
745 m_aTokenList.realloc(0);
746 try
747 {
748 const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
749 m_aTokenList = m_pHelper->getFormulaParser()->parseFormula(rStrExp, aRefPos);
750 }
751 catch(const uno::Exception&)
752 {
753 DBG_UNHANDLED_EXCEPTION();
754 }
755 GetFormulaOpCodeMapper(); // just to get it initialized
756 m_pTokenArray = m_pHelper->convertToTokenArray(m_aTokenList);
757 const sal_Int32 nLen = static_cast<sal_Int32>(m_pTokenArray->GetLen());
758 FormulaToken** pTokens = m_pTokenArray->GetArray();
759 if ( pTokens && nLen == m_aTokenList.getLength() )
760 {
761 for (sal_Int32 nPos=0; nPos<nLen; nPos++)
762 {
763 m_aTokenMap.insert(::std::map<FormulaToken*,sheet::FormulaToken>::value_type(pTokens[nPos],m_aTokenList[nPos]));
764 }
765 } // if ( pTokens && nLen == m_aTokenList.getLength() )
766
767 FormulaCompiler aCompiler(*m_pTokenArray.get());
768 aCompiler.SetCompileForFAP(sal_True); // #i101512# special handling is needed
769 aCompiler.CompileTokenArray();
770 }
771
FillDialog(sal_Bool nFlag)772 void FormulaDlg_Impl::FillDialog(sal_Bool nFlag)
773 {
774 sal_Bool bNext=sal_True, bPrev=sal_True;
775 if(nFlag)
776 FillControls(bNext, bPrev);
777 FillListboxes();
778 if(nFlag)
779 {
780 aBtnBackward.Enable(bPrev);
781 aBtnForward.Enable(bNext);
782 }
783
784 String aStrResult;
785
786 if ( CalcValue(m_pHelper->getCurrentFormula(), aStrResult ) )
787 aWndFormResult.SetValue( aStrResult );
788 else
789 {
790 aStrResult.Erase();
791 aWndFormResult.SetValue( aStrResult );
792 }
793 }
794
795 // -----------------------------------------------------------------------------
FillListboxes()796 void FormulaDlg_Impl::FillListboxes()
797 {
798 // Umschalten zwischen den "Seiten"
799 FormEditData* pData = m_pHelper->getFormEditData();
800 String aNewTitle;
801 // 1. Seite: Funktion auswaehlen
802 if ( pFuncDesc && pFuncDesc->getCategory() )
803 {
804 if( pFuncPage->GetCategory() != pFuncDesc->getCategory()->getNumber() + 1 )
805 pFuncPage->SetCategory(static_cast<sal_uInt16>(pFuncDesc->getCategory()->getNumber() + 1));
806
807 sal_uInt16 nPos=pFuncPage->GetFuncPos(pFuncDesc);
808
809 pFuncPage->SetFunction(nPos);
810 }
811 else if ( pData )
812 {
813 pFuncPage->SetCategory( pData->GetCatSel() );
814 pFuncPage->SetFunction( pData->GetFuncSel() );
815 }
816 FuncSelHdl(NULL);
817
818 // ResizeArgArr jetzt schon in UpdateFunctionDesc
819
820
821 m_pHelper->setDispatcherLock( sal_True);// Modal-Modus einschalten
822
823 aNewTitle = aTitle1;
824
825 // HelpId fuer 1. Seite ist die aus der Resource
826 m_pParent->SetHelpId( aOldHelp );
827 m_pParent->SetUniqueId( aOldUnique );
828 }
829 // -----------------------------------------------------------------------------
FillControls(sal_Bool & rbNext,sal_Bool & rbPrev)830 void FormulaDlg_Impl::FillControls(sal_Bool &rbNext, sal_Bool &rbPrev)
831 {
832 // Umschalten zwischen den "Seiten"
833 FormEditData* pData = m_pHelper->getFormEditData();
834 if (!pData )
835 return;
836
837 String aNewTitle;
838 // 2. Seite oder Editieren: ausgewaehlte Funktion anzeigen
839
840 xub_StrLen nFStart = pData->GetFStart();
841 String aFormula = m_pHelper->getCurrentFormula();
842 xub_StrLen nNextFStart = nFStart;
843 xub_StrLen nNextFEnd = 0;
844
845 aFormula.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " )" ));
846 DeleteArgs();
847 const IFunctionDescription* pOldFuncDesc = pFuncDesc;
848 sal_Bool bTestFlag = sal_False;
849
850 if ( m_aFormulaHelper.GetNextFunc( aFormula, sal_False,
851 nNextFStart, &nNextFEnd, &pFuncDesc, &m_aArguments ) )
852 {
853 bTestFlag = (pOldFuncDesc != pFuncDesc);
854 if(bTestFlag)
855 {
856 aFtHeadLine.Hide();
857 aFtFuncName.Hide();
858 aFtFuncDesc.Hide();
859 pParaWin->SetFunctionDesc(pFuncDesc);
860 aFtEditName.SetText( pFuncDesc->getFunctionName() );
861 aFtEditName.Show();
862 pParaWin->Show();
863 const rtl::OString aHelpId = pFuncDesc->getHelpId();
864 if ( aHelpId.getLength() )
865 pMEdit->SetHelpId(aHelpId);
866 }
867
868 xub_StrLen nOldStart, nOldEnd;
869 m_pHelper->getSelection( nOldStart, nOldEnd );
870 if ( nOldStart != nNextFStart || nOldEnd != nNextFEnd )
871 {
872 m_pHelper->setSelection( nNextFStart, nNextFEnd );
873 }
874 aFuncSel.Min() = nNextFStart;
875 aFuncSel.Max() = nNextFEnd;
876
877 if(!bEditFlag)
878 pMEdit->SetText(m_pHelper->getCurrentFormula());
879 xub_StrLen PrivStart, PrivEnd;
880 m_pHelper->getSelection( PrivStart, PrivEnd);
881 if(!bEditFlag)
882 pMEdit->SetSelection( Selection(PrivStart, PrivEnd));
883
884 nArgs = pFuncDesc->getSuppressedArgumentCount();
885 sal_uInt16 nOffset = pData->GetOffset();
886 nEdFocus = pData->GetEdFocus();
887
888 // Verkettung der Edit's fuer Focus-Kontrolle
889
890 if(bTestFlag)
891 pParaWin->SetArgumentOffset(nOffset);
892 sal_uInt16 nActiv=0;
893 xub_StrLen nArgPos= m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 );
894 xub_StrLen nEditPos=(xub_StrLen) pMEdit->GetSelection().Min();
895 sal_Bool bFlag=sal_False;
896
897 for(sal_uInt16 i=0;i<nArgs;i++)
898 {
899 sal_Int32 nLength = m_aArguments[i].getLength()+1;
900 pParaWin->SetArgument(i,m_aArguments[i]);
901 if(nArgPos<=nEditPos && nEditPos<nArgPos+nLength)
902 {
903 nActiv=i;
904 bFlag=sal_True;
905 }
906 nArgPos = sal::static_int_cast<xub_StrLen>( nArgPos + nLength );
907 }
908 pParaWin->UpdateParas();
909
910 if(bFlag)
911 {
912 pParaWin->SetActiveLine(nActiv);
913 }
914
915 //pParaWin->SetEdFocus( nEdFocus );
916 UpdateValues();
917 }
918 else
919 {
920 aFtEditName.SetText(String());
921 pMEdit->SetHelpId( m_aEditHelpId );
922 }
923 // Test, ob vorne/hinten noch mehr Funktionen sind
924
925 xub_StrLen nTempStart = m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 );
926 rbNext = m_aFormulaHelper.GetNextFunc( aFormula, sal_False, nTempStart );
927 nTempStart=(xub_StrLen)pMEdit->GetSelection().Min();
928 pData->SetFStart(nTempStart);
929 rbPrev = m_aFormulaHelper.GetNextFunc( aFormula, sal_True, nTempStart );
930 }
931 // -----------------------------------------------------------------------------
932
ClearAllParas()933 void FormulaDlg_Impl::ClearAllParas()
934 {
935 DeleteArgs();
936 pFuncDesc = NULL;
937 pParaWin->ClearAll();
938 aWndResult.SetValue(String());
939 aFtFuncName.SetText(String());
940 FuncSelHdl(NULL);
941
942 if(pFuncPage->IsVisible())
943 {
944 aFtEditName.Hide();
945 pParaWin->Hide();
946
947 aBtnForward.Enable(sal_True); //@new
948 aFtHeadLine.Show();
949 aFtFuncName.Show();
950 aFtFuncDesc.Show();
951 }
952 }
RepairFormula(const String & aFormula)953 String FormulaDlg_Impl::RepairFormula(const String& aFormula)
954 {
955 String aResult('=');
956 try
957 {
958 UpdateTokenArray(aFormula);
959
960 if ( m_aTokenList.getLength() )
961 {
962 const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
963 const String sFormula(m_pHelper->getFormulaParser()->printFormula(m_aTokenList, aRefPos));
964 if ( !sFormula.Len() || sFormula.GetChar(0) != '=' )
965 aResult += sFormula;
966 else
967 aResult = sFormula;
968
969 }
970 }
971 catch(const uno::Exception& )
972 {
973 DBG_ERROR("Exception caught!");
974 }
975 return aResult;
976 }
977
DoEnter(sal_Bool bOk)978 void FormulaDlg_Impl::DoEnter(sal_Bool bOk)
979 {
980 // Eingabe ins Dokument uebernehmen oder abbrechen
981 if ( bOk)
982 {
983 // ggf. Dummy-Argumente entfernen
984 String aInputFormula = m_pHelper->getCurrentFormula();
985 String aString = RepairFormula(pMEdit->GetText());
986 m_pHelper->setSelection(0, aInputFormula.Len());
987 m_pHelper->setCurrentFormula(aString);
988 }
989
990 m_pHelper->switchBack();
991
992 m_pHelper->dispatch(bOk,aBtnMatrix.IsChecked());
993 // Daten loeschen
994 m_pHelper->deleteFormData();
995
996 // Dialog schliessen
997 m_pHelper->doClose(bOk);
998 }
999 // -----------------------------------------------------------------------------
1000
IMPL_LINK(FormulaDlg_Impl,BtnHdl,PushButton *,pBtn)1001 IMPL_LINK( FormulaDlg_Impl, BtnHdl, PushButton*, pBtn )
1002 {
1003 if ( pBtn == &aBtnCancel )
1004 {
1005 DoEnter(sal_False); // schliesst den Dialog
1006 }
1007 else if ( pBtn == &aBtnEnd )
1008 {
1009 DoEnter(sal_True); // schliesst den Dialog
1010 }
1011 else if ( pBtn == &aBtnForward )
1012 {
1013 //@pMEdit->GrabFocus(); // Damit die Selektion auch angezeigt wird.
1014 const IFunctionDescription* pDesc =pFuncPage->GetFuncDesc( pFuncPage->GetFunction() );
1015
1016 if(pDesc==pFuncDesc || !pFuncPage->IsVisible())
1017 EditNextFunc( sal_True );
1018 else
1019 {
1020 DblClkHdl(pFuncPage); //new
1021 aBtnForward.Enable(sal_False); //new
1022 }
1023 //@EditNextFunc( sal_True );
1024 }
1025 else if ( pBtn == &aBtnBackward )
1026 {
1027 bEditFlag=sal_False;
1028 aBtnForward.Enable(sal_True);
1029 EditNextFunc( sal_False );
1030 aMEFormula.Invalidate();
1031 aMEFormula.Update();
1032 }
1033 //...
1034
1035 return 0;
1036 }
1037 // -----------------------------------------------------------------------------
1038
1039
1040 // --------------------------------------------------------------------------
1041 // Funktionen fuer 1. Seite
1042 // --------------------------------------------------------------------------
1043
ResizeArgArr(const IFunctionDescription * pNewFunc)1044 void FormulaDlg_Impl::ResizeArgArr( const IFunctionDescription* pNewFunc )
1045 {
1046 if ( pFuncDesc != pNewFunc )
1047 {
1048 DeleteArgs();
1049
1050 if ( pNewFunc )
1051 nArgs = pNewFunc->getSuppressedArgumentCount();
1052
1053 pFuncDesc = pNewFunc;
1054 }
1055 }
1056 // -----------------------------------------------------------------------------
1057
UpdateFunctionDesc()1058 void FormulaDlg_Impl::UpdateFunctionDesc()
1059 {
1060 FormEditData* pData = m_pHelper->getFormEditData();
1061 if (!pData)
1062 return;
1063 sal_uInt16 nCat = pFuncPage->GetCategory();
1064 if ( nCat == LISTBOX_ENTRY_NOTFOUND )
1065 nCat = 0;
1066 pData->SetCatSel( nCat );
1067 sal_uInt16 nFunc = pFuncPage->GetFunction();
1068 if ( nFunc == LISTBOX_ENTRY_NOTFOUND )
1069 nFunc = 0;
1070 pData->SetFuncSel( nFunc );
1071
1072 if ( (pFuncPage->GetFunctionEntryCount() > 0)
1073 && (pFuncPage->GetFunction() != LISTBOX_ENTRY_NOTFOUND) )
1074 {
1075 const IFunctionDescription* pDesc = pFuncPage->GetFuncDesc(pFuncPage->GetFunction() );
1076 if (pDesc)
1077 {
1078 pDesc->initArgumentInfo(); // full argument info is needed
1079
1080 String aSig = pDesc->getSignature();
1081
1082 aFtFuncName.SetText( aSig );
1083 aFtFuncDesc.SetText( pDesc->getDescription() );
1084 ResizeArgArr( pDesc );
1085
1086 if ( !m_aArguments.empty() ) // noch Argumente da?
1087 aSig = pDesc->getFormula( m_aArguments ); // fuer Eingabezeile
1088 //@ m_pHelper->setCurrentFormula( aSig );
1089 }
1090 }
1091 else
1092 {
1093 aFtFuncName.SetText( String() );
1094 aFtFuncDesc.SetText( String() );
1095
1096 //ResizeArgArr( NULL );
1097 m_pHelper->setCurrentFormula( String() );
1098 }
1099 }
1100 // -----------------------------------------------------------------------------
1101
1102 // Handler fuer Listboxen
1103
IMPL_LINK(FormulaDlg_Impl,DblClkHdl,FuncPage *,EMPTYARG)1104 IMPL_LINK( FormulaDlg_Impl, DblClkHdl, FuncPage*, EMPTYARG )
1105 {
1106 sal_uInt16 nFunc = pFuncPage->GetFunction();
1107
1108 // ex-UpdateLRUList
1109 const IFunctionDescription* pDesc = pFuncPage->GetFuncDesc(nFunc);
1110 m_pHelper->insertEntryToLRUList(pDesc);
1111
1112 String aFuncName = pFuncPage->GetSelFunctionName();
1113 aFuncName.AppendAscii(RTL_CONSTASCII_STRINGPARAM( "()" ));
1114 m_pHelper->setCurrentFormula(aFuncName);
1115 pMEdit->ReplaceSelected(aFuncName);
1116
1117 Selection aSel=pMEdit->GetSelection();
1118 aSel.Max()=aSel.Max()-1;
1119 pMEdit->SetSelection(aSel);
1120
1121 FormulaHdl(pMEdit);
1122
1123 aSel.Min()=aSel.Max();
1124 pMEdit->SetSelection(aSel);
1125
1126 if(nArgs==0)
1127 {
1128 BtnHdl(&aBtnBackward);
1129 }
1130
1131 pParaWin->SetEdFocus(0);
1132 aBtnForward.Enable(sal_False); //@New
1133
1134 return 0;
1135 }
1136 // -----------------------------------------------------------------------------
1137
1138 // --------------------------------------------------------------------------
1139 // Funktionen fuer rechte Seite
1140 // --------------------------------------------------------------------------
SetData(xub_StrLen nFStart,xub_StrLen nNextFStart,xub_StrLen nNextFEnd,xub_StrLen & PrivStart,xub_StrLen & PrivEnd)1141 void FormulaDlg_Impl::SetData(xub_StrLen nFStart,xub_StrLen nNextFStart,xub_StrLen nNextFEnd,xub_StrLen& PrivStart,xub_StrLen& PrivEnd)
1142 {
1143 xub_StrLen nFEnd;
1144
1145 // Selektion merken und neue setzen
1146 m_pHelper->getSelection( nFStart, nFEnd );
1147 m_pHelper->setSelection( nNextFStart, nNextFEnd );
1148 if(!bEditFlag)
1149 pMEdit->SetText(m_pHelper->getCurrentFormula());
1150
1151
1152 m_pHelper->getSelection( PrivStart, PrivEnd);
1153 if(!bEditFlag)
1154 {
1155 pMEdit->SetSelection( Selection(PrivStart, PrivEnd));
1156 aMEFormula.UpdateOldSel();
1157 }
1158
1159 FormEditData* pData = m_pHelper->getFormEditData();
1160 pData->SetFStart( nNextFStart );
1161 pData->SetOffset( 0 );
1162 pData->SetEdFocus( 0 );
1163
1164 FillDialog();
1165 }
1166 // -----------------------------------------------------------------------------
EditThisFunc(xub_StrLen nFStart)1167 void FormulaDlg_Impl::EditThisFunc(xub_StrLen nFStart)
1168 {
1169 FormEditData* pData = m_pHelper->getFormEditData();
1170 if (!pData) return;
1171
1172 String aFormula = m_pHelper->getCurrentFormula();
1173
1174 if(nFStart==NOT_FOUND)
1175 {
1176 nFStart = pData->GetFStart();
1177 }
1178 else
1179 {
1180 pData->SetFStart(nFStart);
1181 }
1182
1183 xub_StrLen nNextFStart = nFStart;
1184 xub_StrLen nNextFEnd = 0;
1185
1186 sal_Bool bFound;
1187
1188 //@bFound = m_pHelper->getNextFunction( aFormula, sal_False, nNextFStart, &nNextFEnd, &pFuncDesc );
1189
1190 bFound = m_aFormulaHelper.GetNextFunc( aFormula, sal_False, nNextFStart, &nNextFEnd);
1191 if ( bFound )
1192 {
1193 xub_StrLen PrivStart, PrivEnd;
1194 SetData(nFStart,nNextFStart,nNextFEnd,PrivStart, PrivEnd);
1195 m_pHelper->showReference(aFormula.Copy(PrivStart, PrivEnd-PrivStart));
1196 }
1197 else
1198 {
1199 ClearAllParas();
1200 }
1201 }
1202
EditNextFunc(sal_Bool bForward,xub_StrLen nFStart)1203 void FormulaDlg_Impl::EditNextFunc( sal_Bool bForward, xub_StrLen nFStart )
1204 {
1205 FormEditData* pData = m_pHelper->getFormEditData();
1206 if (!pData)
1207 return;
1208
1209 String aFormula = m_pHelper->getCurrentFormula();
1210
1211 if(nFStart==NOT_FOUND)
1212 {
1213 nFStart = pData->GetFStart();
1214 }
1215 else
1216 {
1217 pData->SetFStart(nFStart);
1218 }
1219
1220 xub_StrLen nNextFStart = 0;
1221 xub_StrLen nNextFEnd = 0;
1222
1223 sal_Bool bFound;
1224 if ( bForward )
1225 {
1226 nNextFStart = m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 );
1227 //@bFound = m_pHelper->getNextFunction( aFormula, sal_False, nNextFStart, &nNextFEnd, &pFuncDesc );
1228 bFound = m_aFormulaHelper.GetNextFunc( aFormula, sal_False, nNextFStart, &nNextFEnd);
1229 }
1230 else
1231 {
1232 nNextFStart = nFStart;
1233 //@bFound = m_pHelper->getNextFunction( aFormula, sal_True, nNextFStart, &nNextFEnd, &pFuncDesc );
1234 bFound = m_aFormulaHelper.GetNextFunc( aFormula, sal_True, nNextFStart, &nNextFEnd);
1235 }
1236
1237 if ( bFound )
1238 {
1239 xub_StrLen PrivStart, PrivEnd;
1240 SetData(nFStart,nNextFStart,nNextFEnd,PrivStart, PrivEnd);
1241 }
1242 }
1243
EditFuncParas(xub_StrLen nEditPos)1244 void FormulaDlg_Impl::EditFuncParas(xub_StrLen nEditPos)
1245 {
1246 if(pFuncDesc!=NULL)
1247 {
1248 FormEditData* pData = m_pHelper->getFormEditData();
1249 if (!pData) return;
1250
1251 String aFormula = m_pHelper->getCurrentFormula();
1252 aFormula +=')';
1253 xub_StrLen nFStart = pData->GetFStart();
1254
1255 DeleteArgs();
1256
1257 nArgs = pFuncDesc->getSuppressedArgumentCount();
1258
1259 sal_Int32 nArgPos=m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 );
1260 m_aFormulaHelper.GetArgStrings(m_aArguments,aFormula, nFStart, nArgs );
1261 // m_aArguments = ScFormulaUtil::GetArgStrings( aFormula, nFStart, nArgs );
1262
1263 sal_uInt16 nActiv=pParaWin->GetSliderPos();
1264 sal_Bool bFlag=sal_False;
1265 ::std::vector< ::rtl::OUString >::iterator aIter = m_aArguments.begin();
1266 ::std::vector< ::rtl::OUString >::iterator aEnd = m_aArguments.end();
1267 for(sal_uInt16 i=0;aIter != aEnd;i++,++aIter)
1268 {
1269 sal_Int32 nLength=(*aIter).getLength();
1270 pParaWin->SetArgument(i,(*aIter));
1271 if(nArgPos<=nEditPos && nEditPos<nArgPos+nLength)
1272 {
1273 nActiv=i;
1274 bFlag=sal_True;
1275 }
1276 nArgPos+=nLength+1;
1277 }
1278
1279 if(bFlag)
1280 {
1281 pParaWin->SetSliderPos(nActiv);
1282 }
1283
1284 pParaWin->UpdateParas();
1285 UpdateValues();
1286 }
1287
1288 }
1289
SaveArg(sal_uInt16 nEd)1290 void FormulaDlg_Impl::SaveArg( sal_uInt16 nEd )
1291 {
1292 if (nEd<nArgs)
1293 {
1294 sal_uInt16 i;
1295 for(i=0;i<=nEd;i++)
1296 {
1297 if ( m_aArguments[i].getLength() == 0 )
1298 m_aArguments[i] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" "));
1299 }
1300 if(pParaWin->GetArgument(nEd).Len()!=0)
1301 m_aArguments[nEd] = pParaWin->GetArgument(nEd);
1302
1303 sal_uInt16 nClearPos=nEd+1;
1304 for(i=nEd+1;i<nArgs;i++)
1305 {
1306 if(pParaWin->GetArgument(i).Len()!=0)
1307 {
1308 nClearPos=i+1;
1309 }
1310 }
1311
1312 for(i=nClearPos;i<nArgs;i++)
1313 {
1314 m_aArguments[i] = ::rtl::OUString();
1315 }
1316 }
1317 }
1318
IMPL_LINK(FormulaDlg_Impl,FxHdl,ParaWin *,pPtr)1319 IMPL_LINK( FormulaDlg_Impl, FxHdl, ParaWin*, pPtr )
1320 {
1321 if(pPtr==pParaWin)
1322 {
1323 aBtnForward.Enable(sal_True); //@ Damit eine neue Fkt eingegeben werden kann.
1324 aTabCtrl.SetCurPageId(TP_FUNCTION);
1325
1326 String aUndoStr = m_pHelper->getCurrentFormula(); // bevor unten ein ";" eingefuegt wird
1327 FormEditData* pData = m_pHelper->getFormEditData();
1328 if (!pData) return 0;
1329
1330 sal_uInt16 nArgNo = pParaWin->GetActiveLine();
1331 nEdFocus=nArgNo;
1332
1333 SaveArg(nArgNo);
1334 UpdateSelection();
1335
1336 xub_StrLen nFormulaStrPos = pData->GetFStart();
1337
1338 String aFormula = m_pHelper->getCurrentFormula();
1339 xub_StrLen n1 = m_aFormulaHelper.GetArgStart( aFormula, nFormulaStrPos, nEdFocus+pData->GetOffset() );
1340
1341 pData->SetEdFocus( nEdFocus );
1342 pData->SaveValues();
1343 pData->SetMode( (sal_uInt16) FORMULA_FORMDLG_FORMULA );
1344 pData->SetFStart( n1 );
1345 pData->SetUndoStr( aUndoStr );
1346 ClearAllParas();
1347
1348 FillDialog(sal_False);
1349 pFuncPage->SetFocus(); //Da Parawin nicht mehr sichtbar
1350 }
1351 return 0;
1352 }
1353
IMPL_LINK(FormulaDlg_Impl,ModifyHdl,ParaWin *,pPtr)1354 IMPL_LINK( FormulaDlg_Impl, ModifyHdl, ParaWin*, pPtr )
1355 {
1356 if(pPtr==pParaWin)
1357 {
1358 SaveArg(pParaWin->GetActiveLine());
1359 UpdateValues();
1360
1361 UpdateSelection();
1362 CalcStruct(pMEdit->GetText());
1363 }
1364 return 0;
1365 }
1366
IMPL_LINK(FormulaDlg_Impl,FormulaHdl,MultiLineEdit *,EMPTYARG)1367 IMPL_LINK( FormulaDlg_Impl, FormulaHdl, MultiLineEdit*, EMPTYARG )
1368 {
1369
1370 FormEditData* pData = m_pHelper->getFormEditData();
1371 if (!pData) return 0;
1372
1373 bEditFlag=sal_True;
1374 String aInputFormula=m_pHelper->getCurrentFormula();
1375 String aString=pMEdit->GetText();
1376
1377 Selection aSel =pMEdit->GetSelection();
1378 xub_StrLen nTest=0;
1379
1380 if(aString.Len()==0) //falls alles geloescht wurde
1381 {
1382 aString +='=';
1383 pMEdit->SetText(aString);
1384 aSel .Min()=1;
1385 aSel .Max()=1;
1386 pMEdit->SetSelection(aSel);
1387 }
1388 else if(aString.GetChar(nTest)!='=') //falls ersetzt wurde;
1389 {
1390 aString.Insert( (sal_Unicode)'=', 0 );
1391 pMEdit->SetText(aString);
1392 aSel .Min()+=1;
1393 aSel .Max()+=1;
1394 pMEdit->SetSelection(aSel);
1395 }
1396
1397
1398 m_pHelper->setSelection(0, aInputFormula.Len());
1399 m_pHelper->setCurrentFormula(aString);
1400 m_pHelper->setSelection((xub_StrLen)aSel.Min(),(xub_StrLen)aSel.Max());
1401
1402 xub_StrLen nPos=(xub_StrLen)aSel.Min()-1;
1403
1404 String aStrResult;
1405
1406 if ( CalcValue(m_pHelper->getCurrentFormula(), aStrResult ) )
1407 aWndFormResult.SetValue( aStrResult );
1408 else
1409 {
1410 aStrResult.Erase();
1411 aWndFormResult.SetValue( aStrResult );
1412 }
1413 CalcStruct(aString);
1414
1415 nPos=GetFunctionPos(nPos);
1416
1417 if(nPos<aSel.Min()-1)
1418 {
1419 xub_StrLen nPos1=aString.Search('(',nPos);
1420 EditNextFunc( sal_False, nPos1);
1421 }
1422 else
1423 {
1424 ClearAllParas();
1425 }
1426
1427 m_pHelper->setSelection((xub_StrLen)aSel.Min(),(xub_StrLen)aSel.Max());
1428 bEditFlag=sal_False;
1429 return 0;
1430 }
1431
IMPL_LINK(FormulaDlg_Impl,FormulaCursorHdl,EditBox *,EMPTYARG)1432 IMPL_LINK( FormulaDlg_Impl, FormulaCursorHdl, EditBox*, EMPTYARG )
1433 {
1434 FormEditData* pData = m_pHelper->getFormEditData();
1435 if (!pData) return 0;
1436 xub_StrLen nFStart = pData->GetFStart();
1437
1438 bEditFlag=sal_True;
1439
1440 String aInputFormula=m_pHelper->getCurrentFormula();
1441 String aString=pMEdit->GetText();
1442
1443 Selection aSel =pMEdit->GetSelection();
1444 m_pHelper->setSelection((xub_StrLen)aSel.Min(),(xub_StrLen)aSel.Max());
1445
1446 if(aSel.Min()==0)
1447 {
1448 aSel.Min()=1;
1449 pMEdit->SetSelection(aSel);
1450 }
1451
1452 if(aSel.Min()!=aString.Len())
1453 {
1454 xub_StrLen nPos=(xub_StrLen)aSel.Min();
1455
1456 nFStart=GetFunctionPos(nPos - 1);
1457
1458 if(nFStart<nPos)
1459 {
1460 xub_StrLen nPos1=m_aFormulaHelper.GetFunctionEnd(aString,nFStart);
1461
1462 if(nPos1>nPos || nPos1==STRING_NOTFOUND)
1463 {
1464 EditThisFunc(nFStart);
1465 }
1466 else
1467 {
1468 xub_StrLen n=nPos;
1469 short nCount=1;
1470 while(n>0)
1471 {
1472 if(aString.GetChar(n)==')')
1473 nCount++;
1474 else if(aString.GetChar(n)=='(')
1475 nCount--;
1476 if(nCount==0) break;
1477 n--;
1478 }
1479 if(nCount==0)
1480 {
1481 nFStart=m_aFormulaHelper.GetFunctionStart(aString,n,sal_True);
1482 EditThisFunc(nFStart);
1483 }
1484 else
1485 {
1486 ClearAllParas();
1487 }
1488 }
1489 }
1490 else
1491 {
1492 ClearAllParas();
1493 }
1494 }
1495 m_pHelper->setSelection((xub_StrLen)aSel.Min(),(xub_StrLen)aSel.Max());
1496
1497 bEditFlag=sal_False;
1498 return 0;
1499 }
1500
UpdateSelection()1501 void FormulaDlg_Impl::UpdateSelection()
1502 {
1503 m_pHelper->setSelection((xub_StrLen)aFuncSel.Min(),(xub_StrLen)aFuncSel.Max());
1504 m_pHelper->setCurrentFormula( pFuncDesc->getFormula( m_aArguments ) );
1505 pMEdit->SetText(m_pHelper->getCurrentFormula());
1506 xub_StrLen PrivStart, PrivEnd;
1507 m_pHelper->getSelection( PrivStart, PrivEnd);
1508 aFuncSel.Min()=PrivStart;
1509 aFuncSel.Max()=PrivEnd;
1510
1511 nArgs = pFuncDesc->getSuppressedArgumentCount();
1512
1513 String aFormula=pMEdit->GetText();
1514 sal_Int32 nArgPos=m_aFormulaHelper.GetArgStart( aFormula,PrivStart,0);
1515
1516 sal_uInt16 nPos=pParaWin->GetActiveLine();
1517
1518 for(sal_uInt16 i=0;i<nPos;i++)
1519 {
1520 nArgPos += (m_aArguments[i].getLength() + 1);
1521 }
1522 sal_Int32 nLength= m_aArguments[nPos].getLength();
1523
1524 Selection aSel(nArgPos,nArgPos+nLength);
1525 m_pHelper->setSelection((sal_uInt16)nArgPos,(sal_uInt16)(nArgPos+nLength));
1526 pMEdit->SetSelection(aSel);
1527 aMEFormula.UpdateOldSel();
1528 }
RefInputStartBefore(RefEdit * pEdit,RefButton * pButton)1529 ::std::pair<RefButton*,RefEdit*> FormulaDlg_Impl::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton )
1530 {
1531 aEdRef.Show();
1532 pTheRefEdit = pEdit;
1533 pTheRefButton = pButton;
1534
1535 if( pTheRefEdit )
1536 {
1537 aEdRef.SetRefString( pTheRefEdit->GetText() );
1538 aEdRef.SetSelection( pTheRefEdit->GetSelection() );
1539 aEdRef.SetHelpId( pTheRefEdit->GetHelpId() );
1540 aEdRef.SetUniqueId( pTheRefEdit->GetUniqueId() );
1541 }
1542
1543 aRefBtn.Show( pButton != NULL );
1544
1545 //m_pHelper->RefInputStart( &aEdRef, pButton ? &aRefBtn : NULL );
1546 ::std::pair<RefButton*,RefEdit*> aPair;
1547 aPair.first = pButton ? &aRefBtn : NULL;
1548 aPair.second = &aEdRef;
1549 return aPair;
1550 }
RefInputStartAfter(RefEdit *,RefButton *)1551 void FormulaDlg_Impl::RefInputStartAfter( RefEdit* /*pEdit*/, RefButton* /*pButton*/ )
1552 {
1553 aRefBtn.SetEndImage();
1554
1555 if( pTheRefEdit )
1556 {
1557 String aStr = aTitle2;
1558 aStr += ' ';
1559 aStr += aFtEditName.GetText();
1560 aStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "( " ) );
1561 if( pParaWin->GetActiveLine() > 0 )
1562 aStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "...; " ) );
1563 aStr += pParaWin->GetActiveArgName();
1564 if( pParaWin->GetActiveLine() + 1 < nArgs )
1565 aStr.AppendAscii(RTL_CONSTASCII_STRINGPARAM( "; ..." ));
1566 aStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " )" ) );
1567
1568 m_pParent->SetText( MnemonicGenerator::EraseAllMnemonicChars( aStr ) );
1569 }
1570 }
RefInputDoneAfter(sal_Bool bForced)1571 void FormulaDlg_Impl::RefInputDoneAfter( sal_Bool bForced )
1572 {
1573 aRefBtn.SetStartImage();
1574 if( bForced || !aRefBtn.IsVisible() )
1575 {
1576 aEdRef.Hide();
1577 aRefBtn.Hide();
1578 if( pTheRefEdit )
1579 {
1580 pTheRefEdit->SetRefString( aEdRef.GetText() );
1581 pTheRefEdit->GrabFocus();
1582
1583 if( pTheRefButton )
1584 pTheRefButton->SetStartImage();
1585
1586 sal_uInt16 nPrivActiv = pParaWin->GetActiveLine();
1587 pParaWin->SetArgument( nPrivActiv, aEdRef.GetText() );
1588 ModifyHdl( pParaWin );
1589 pTheRefEdit = NULL;
1590 }
1591 m_pParent->SetText( aTitle1 );
1592 }
1593 }
GetCurrRefEdit()1594 RefEdit* FormulaDlg_Impl::GetCurrRefEdit()
1595 {
1596 return aEdRef.IsVisible() ? &aEdRef : pParaWin->GetActiveEdit();
1597 }
Update()1598 void FormulaDlg_Impl::Update()
1599 {
1600 FormEditData* pData = m_pHelper->getFormEditData();
1601 const String sExpression = pMEdit->GetText();
1602 aOldFormula = String();
1603 UpdateTokenArray(sExpression);
1604 FormulaCursorHdl(&aMEFormula);
1605 CalcStruct(sExpression);
1606 if(pData->GetMode() == FORMULA_FORMDLG_FORMULA)
1607 aTabCtrl.SetCurPageId(TP_FUNCTION);
1608 else
1609 aTabCtrl.SetCurPageId(TP_STRUCT);
1610 aBtnMatrix.Check(pData->GetMatrixFlag());
1611 /*aTimer.SetTimeout(200);
1612 aTimer.SetTimeoutHdl(LINK( this, FormulaDlg_Impl, UpdateFocusHdl));
1613 aTimer.Start();*/
1614 }
Update(const String & _sExp)1615 void FormulaDlg_Impl::Update(const String& _sExp)
1616 {
1617 CalcStruct(_sExp);
1618 FillDialog();
1619 //aBtnForward.Enable(sal_True); //@New
1620 FuncSelHdl(NULL);
1621 }
SetMeText(const String & _sText)1622 void FormulaDlg_Impl::SetMeText(const String& _sText)
1623 {
1624 FormEditData* pData = m_pHelper->getFormEditData();
1625 pMEdit->SetText(_sText);
1626 pMEdit->SetSelection( pData->GetSelection());
1627 aMEFormula.UpdateOldSel();
1628 }
SetMeText(const String & _sText,xub_StrLen PrivStart,xub_StrLen PrivEnd,sal_Bool bMatrix,sal_Bool _bSelect,sal_Bool _bUpdate)1629 FormulaDlgMode FormulaDlg_Impl::SetMeText(const String& _sText,xub_StrLen PrivStart, xub_StrLen PrivEnd,sal_Bool bMatrix,sal_Bool _bSelect,sal_Bool _bUpdate)
1630 {
1631 FormulaDlgMode eMode = FORMULA_FORMDLG_FORMULA;
1632 if(!bEditFlag)
1633 pMEdit->SetText(_sText);
1634
1635 if ( _bSelect || !bEditFlag )
1636 pMEdit->SetSelection( Selection(PrivStart, PrivEnd));
1637 if ( _bUpdate )
1638 {
1639 aMEFormula.UpdateOldSel();
1640 pMEdit->Invalidate();
1641 m_pHelper->showReference(pMEdit->GetSelected());
1642 eMode = FORMULA_FORMDLG_EDIT;
1643
1644 aBtnMatrix.Check( bMatrix );
1645 } // if ( _bUpdate )
1646 return eMode;
1647 }
CheckMatrix(String & aFormula)1648 sal_Bool FormulaDlg_Impl::CheckMatrix(String& aFormula)
1649 {
1650 pMEdit->GrabFocus();
1651 xub_StrLen nLen = aFormula.Len();
1652 sal_Bool bMatrix = nLen > 3 // Matrix-Formel ?
1653 && aFormula.GetChar(0) == '{'
1654 && aFormula.GetChar(1) == '='
1655 && aFormula.GetChar(nLen-1) == '}';
1656 if ( bMatrix )
1657 {
1658 aFormula.Erase( 0, 1 );
1659 aFormula.Erase( aFormula.Len()-1, 1);
1660 aBtnMatrix.Check( bMatrix );
1661 aBtnMatrix.Disable();
1662 } // if ( bMatrix )
1663
1664 aTabCtrl.SetCurPageId(TP_STRUCT);
1665 return bMatrix;
1666 }
IMPL_LINK(FormulaDlg_Impl,StructSelHdl,StructPage *,pStruP)1667 IMPL_LINK( FormulaDlg_Impl, StructSelHdl, StructPage*, pStruP )
1668 {
1669 bStructUpdate=sal_False;
1670 if(pStructPage->IsVisible()) aBtnForward.Enable(sal_False); //@New
1671
1672 if(pStructPage==pStruP)
1673 {
1674 /// TODO
1675 //ScToken* pSelToken = pStructPage->GetSelectedToken();
1676 // ScToken* pOrigToken = ((pSelToken && pSelToken->GetType() == svFAP) ?
1677 // pSelToken->GetFAPOrigToken() : pSelToken);
1678 //xub_StrLen nTokPos=1;
1679
1680 //if(pScTokA!=NULL)
1681 //{
1682 // ScToken* pToken = pScTokA->First();
1683
1684 // while(pToken!=NULL)
1685 // {
1686 // String aString;
1687 // if ( pToken == pOrigToken )
1688 // break;
1689 // pComp->CreateStringFromToken( aString,pToken);
1690 // nTokPos = sal::static_int_cast<xub_StrLen>( nTokPos + aString.Len() );
1691 // pToken=pScTokA->Next();
1692 // }
1693 // EditThisFunc(nTokPos);
1694 //}
1695
1696 //if( pOrigToken )
1697 //{
1698 // String aStr;
1699 // pComp->CreateStringFromToken( aStr, pOrigToken );
1700 // String aEntryTxt=pStructPage->GetSelectedEntryText();
1701
1702 // if(aEntryTxt!=aStr)
1703 // ShowReference(aEntryTxt);
1704 //}
1705
1706 }
1707 bStructUpdate=sal_True;
1708 return 0;
1709 }
IMPL_LINK(FormulaDlg_Impl,MatrixHdl,CheckBox *,EMPTYARG)1710 IMPL_LINK( FormulaDlg_Impl, MatrixHdl, CheckBox *, EMPTYARG )
1711 {
1712 bUserMatrixFlag=sal_True;
1713 return 0;
1714 }
1715
IMPL_LINK(FormulaDlg_Impl,FuncSelHdl,FuncPage *,EMPTYARG)1716 IMPL_LINK( FormulaDlg_Impl, FuncSelHdl, FuncPage*, EMPTYARG )
1717 {
1718 sal_uInt16 nCat = pFuncPage->GetCategory();
1719 if ( nCat == LISTBOX_ENTRY_NOTFOUND ) nCat = 0;
1720 sal_uInt16 nFunc = pFuncPage->GetFunction();
1721 if ( nFunc == LISTBOX_ENTRY_NOTFOUND ) nFunc = 0;
1722
1723 if ( (pFuncPage->GetFunctionEntryCount() > 0)
1724 && (pFuncPage->GetFunction() != LISTBOX_ENTRY_NOTFOUND) )
1725 {
1726 const IFunctionDescription* pDesc =pFuncPage->GetFuncDesc( pFuncPage->GetFunction() );
1727
1728 if(pDesc!=pFuncDesc) aBtnForward.Enable(sal_True); //new
1729
1730 if (pDesc)
1731 {
1732 pDesc->initArgumentInfo(); // full argument info is needed
1733
1734 String aSig = pDesc->getSignature();
1735 aFtHeadLine.SetText( pDesc->getFunctionName() );
1736 aFtFuncName.SetText( aSig );
1737 aFtFuncDesc.SetText( pDesc->getDescription() );
1738 }
1739 }
1740 else
1741 {
1742 aFtHeadLine.SetText( String() );
1743 aFtFuncName.SetText( String() );
1744 aFtFuncDesc.SetText( String() );
1745 }
1746 return 0;
1747 }
1748
UpdateParaWin(const Selection & _rSelection,const String & _sRefStr)1749 void FormulaDlg_Impl::UpdateParaWin(const Selection& _rSelection,const String& _sRefStr)
1750 {
1751 Selection theSel = _rSelection;
1752 aEdRef.ReplaceSelected( _sRefStr );
1753 theSel.Max() = theSel.Min() + _sRefStr.Len();
1754 aEdRef.SetSelection( theSel );
1755
1756 //-------------------------------------
1757 // Manuelles Update der Ergebnisfelder:
1758 //-------------------------------------
1759 sal_uInt16 nPrivActiv = pParaWin->GetActiveLine();
1760 pParaWin->SetArgument(nPrivActiv,aEdRef.GetText());
1761 pParaWin->UpdateParas();
1762
1763 Edit* pEd = GetCurrRefEdit();
1764 if( pEd != NULL )
1765 pEd->SetSelection( theSel );
1766
1767 pParaWin->SetRefMode(sal_False);
1768 }
UpdateParaWin(Selection & _rSelection)1769 sal_Bool FormulaDlg_Impl::UpdateParaWin(Selection& _rSelection)
1770 {
1771 pParaWin->SetRefMode(sal_True);
1772
1773 String aStrEd;
1774 Edit* pEd = GetCurrRefEdit();
1775 if(pEd!=NULL && pTheRefEdit==NULL)
1776 {
1777 _rSelection=pEd->GetSelection();
1778 _rSelection.Justify();
1779 aStrEd=pEd->GetText();
1780 aEdRef.SetRefString(aStrEd);
1781 aEdRef.SetSelection( _rSelection );
1782 }
1783 else
1784 {
1785 _rSelection=aEdRef.GetSelection();
1786 _rSelection.Justify();
1787 aStrEd= aEdRef.GetText();
1788 }
1789 return pTheRefEdit == NULL;
1790 }
FindFocusWin(Window * pWin)1791 rtl::OString FormulaDlg_Impl::FindFocusWin(Window *pWin)
1792 {
1793 rtl::OString aUniqueId;
1794 if(pWin->HasFocus())
1795 {
1796 aUniqueId=pWin->GetUniqueId();
1797 if(aUniqueId.getLength()==0)
1798 {
1799 Window* pParent=pWin->GetParent();
1800 while(pParent!=NULL)
1801 {
1802 aUniqueId=pParent->GetUniqueId();
1803
1804 if(aUniqueId.getLength()!=0) break;
1805
1806 pParent=pParent->GetParent();
1807 }
1808 }
1809 }
1810 else
1811 {
1812 sal_uInt16 nCount=pWin->GetChildCount();
1813
1814 for(sal_uInt16 i=0;i<nCount;i++)
1815 {
1816 Window* pChild=pWin->GetChild(i);
1817 aUniqueId=FindFocusWin(pChild);
1818 if(aUniqueId.getLength()>0) break;
1819 }
1820 }
1821 return aUniqueId;
1822 }
1823
SetEdSelection()1824 void FormulaDlg_Impl::SetEdSelection()
1825 {
1826 Edit* pEd = GetCurrRefEdit()/*aScParaWin.GetActiveEdit()*/;
1827 if( pEd )
1828 {
1829 Selection theSel = aEdRef.GetSelection();
1830 // Edit may have the focus -> call ModifyHdl in addition
1831 // to what's happening in GetFocus
1832 pEd->GetModifyHdl().Call(pEd);
1833 pEd->GrabFocus();
1834 pEd->SetSelection(theSel);
1835 } // if( pEd )
1836 }
1837 // -----------------------------------------------------------------------------
GetFormulaHelper() const1838 const FormulaHelper& FormulaDlg_Impl::GetFormulaHelper() const
1839 {
1840 return m_aFormulaHelper;
1841 }
1842 //============================================================================
FormulaModalDialog(Window * pParent,bool _bSupportFunctionResult,bool _bSupportResult,bool _bSupportMatrix,IFormulaEditorHelper * _pHelper,IFunctionManager * _pFunctionMgr,IControlReferenceHandler * _pDlg)1843 FormulaModalDialog::FormulaModalDialog( Window* pParent
1844 , bool _bSupportFunctionResult
1845 , bool _bSupportResult
1846 , bool _bSupportMatrix
1847 , IFormulaEditorHelper* _pHelper
1848 , IFunctionManager* _pFunctionMgr
1849 , IControlReferenceHandler* _pDlg ) :
1850 ModalDialog( pParent, ModuleRes(RID_FORMULADLG_FORMULA_MODAL) ),
1851 m_pImpl( new FormulaDlg_Impl(this,_bSupportFunctionResult
1852 , _bSupportResult
1853 , _bSupportMatrix
1854 ,_pHelper,_pFunctionMgr,_pDlg))
1855 {
1856 FreeResource();
1857 SetText(m_pImpl->aTitle1);
1858 }
~FormulaModalDialog()1859 FormulaModalDialog::~FormulaModalDialog()
1860 {
1861 }
1862 // -----------------------------------------------------------------------------
Update(const String & _sExp)1863 void FormulaModalDialog::Update(const String& _sExp)
1864 {
1865 m_pImpl->Update(_sExp);
1866 }
1867
1868 // -----------------------------------------------------------------------------
SetMeText(const String & _sText)1869 void FormulaModalDialog::SetMeText(const String& _sText)
1870 {
1871 m_pImpl->SetMeText(_sText);
1872 }
1873
1874 // -----------------------------------------------------------------------------
SetMeText(const String & _sText,xub_StrLen PrivStart,xub_StrLen PrivEnd,sal_Bool bMatrix,sal_Bool _bSelect,sal_Bool _bUpdate)1875 FormulaDlgMode FormulaModalDialog::SetMeText(const String& _sText,xub_StrLen PrivStart, xub_StrLen PrivEnd,sal_Bool bMatrix,sal_Bool _bSelect,sal_Bool _bUpdate)
1876 {
1877 return m_pImpl->SetMeText(_sText,PrivStart, PrivEnd,bMatrix,_bSelect,_bUpdate);
1878 }
1879 // -----------------------------------------------------------------------------
CheckMatrix()1880 void FormulaModalDialog::CheckMatrix()
1881 {
1882 m_pImpl->aBtnMatrix.Check();
1883 }
1884 // -----------------------------------------------------------------------------
CheckMatrix(String & aFormula)1885 sal_Bool FormulaModalDialog::CheckMatrix(String& aFormula)
1886 {
1887 return m_pImpl->CheckMatrix(aFormula);
1888 }
1889 // -----------------------------------------------------------------------------
GetMeText() const1890 String FormulaModalDialog::GetMeText() const
1891 {
1892 return m_pImpl->pMEdit->GetText();
1893 }
1894 // -----------------------------------------------------------------------------
Update()1895 void FormulaModalDialog::Update()
1896 {
1897 m_pImpl->Update();
1898 }
1899 // -----------------------------------------------------------------------------
GetFormulaHelper() const1900 const FormulaHelper& FormulaModalDialog::GetFormulaHelper() const
1901 {
1902 return m_pImpl->GetFormulaHelper();
1903 }
1904 // -----------------------------------------------------------------------------
isUserMatrix() const1905 sal_Bool FormulaModalDialog::isUserMatrix() const
1906 {
1907 return m_pImpl->bUserMatrixFlag;
1908 }
DoEnter(sal_Bool _bOk)1909 void FormulaModalDialog::DoEnter(sal_Bool _bOk)
1910 {
1911 m_pImpl->DoEnter(_bOk);
1912 }
RefInputStartBefore(RefEdit * pEdit,RefButton * pButton)1913 ::std::pair<RefButton*,RefEdit*> FormulaModalDialog::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton )
1914 {
1915 return m_pImpl->RefInputStartBefore( pEdit, pButton );
1916 }
RefInputStartAfter(RefEdit * pEdit,RefButton * pButton)1917 void FormulaModalDialog::RefInputStartAfter( RefEdit* pEdit, RefButton* pButton )
1918 {
1919 m_pImpl->RefInputStartAfter( pEdit, pButton );
1920 }
RefInputDoneAfter(sal_Bool bForced)1921 void FormulaModalDialog::RefInputDoneAfter( sal_Bool bForced )
1922 {
1923 m_pImpl->RefInputDoneAfter( bForced );
1924 }
1925
FindFocusWin(Window * pWin)1926 rtl::OString FormulaModalDialog::FindFocusWin(Window *pWin)
1927 {
1928 return m_pImpl->FindFocusWin( pWin );
1929 }
1930
SetFocusWin(Window * pWin,const rtl::OString & nUniqueId)1931 void FormulaModalDialog::SetFocusWin(Window *pWin,const rtl::OString& nUniqueId)
1932 {
1933 if(pWin->GetUniqueId()==nUniqueId)
1934 {
1935 pWin->GrabFocus();
1936 }
1937 else
1938 {
1939 sal_uInt16 nCount=pWin->GetChildCount();
1940
1941 for(sal_uInt16 i=0;i<nCount;i++)
1942 {
1943 Window* pChild=pWin->GetChild(i);
1944 SetFocusWin(pChild,nUniqueId);
1945 }
1946 }
1947 }
1948
1949
PreNotify(NotifyEvent & rNEvt)1950 long FormulaModalDialog::PreNotify( NotifyEvent& rNEvt )
1951 {
1952 m_pImpl->PreNotify( rNEvt );
1953
1954 return ModalDialog::PreNotify(rNEvt);
1955 }
1956
HighlightFunctionParas(const String & aFormula)1957 void FormulaModalDialog::HighlightFunctionParas(const String& aFormula)
1958 {
1959 m_pImpl->m_pHelper->showReference(aFormula);
1960 }
1961
disableOk()1962 void FormulaModalDialog::disableOk()
1963 {
1964 m_pImpl->aBtnEnd.Disable();
1965 }
1966 // -----------------------------------------------------------------------------
getCurrentFunctionDescription() const1967 const IFunctionDescription* FormulaModalDialog::getCurrentFunctionDescription() const
1968 {
1969 OSL_VERIFY(!m_pImpl->pFuncDesc || m_pImpl->pFuncDesc->getSuppressedArgumentCount() == m_pImpl->nArgs);
1970 return m_pImpl->pFuncDesc;
1971 }
1972 // -----------------------------------------------------------------------------
UpdateParaWin(const Selection & _rSelection,const String & _sRefStr)1973 void FormulaModalDialog::UpdateParaWin(const Selection& _rSelection,const String& _sRefStr)
1974 {
1975 m_pImpl->UpdateParaWin(_rSelection,_sRefStr);
1976 }
UpdateParaWin(Selection & _rSelection)1977 sal_Bool FormulaModalDialog::UpdateParaWin(Selection& _rSelection)
1978 {
1979 return m_pImpl->UpdateParaWin(_rSelection);
1980 }
1981 // -----------------------------------------------------------------------------
GetActiveEdit()1982 RefEdit* FormulaModalDialog::GetActiveEdit()
1983 {
1984 return m_pImpl->pParaWin->GetActiveEdit();
1985 }
1986 // -----------------------------------------------------------------------------
SetEdSelection()1987 void FormulaModalDialog::SetEdSelection()
1988 {
1989 m_pImpl->SetEdSelection();
1990 }
1991
1992 // --------------------------------------------------------------------------
1993 // Initialisierung / gemeinsaME Funktionen fuer Dialog
1994 // --------------------------------------------------------------------------
FormulaDlg(SfxBindings * pB,SfxChildWindow * pCW,Window * pParent,bool _bSupportFunctionResult,bool _bSupportResult,bool _bSupportMatrix,IFormulaEditorHelper * _pHelper,IFunctionManager * _pFunctionMgr,IControlReferenceHandler * _pDlg)1995 FormulaDlg::FormulaDlg( SfxBindings* pB, SfxChildWindow* pCW,
1996 Window* pParent
1997 , bool _bSupportFunctionResult
1998 , bool _bSupportResult
1999 , bool _bSupportMatrix
2000 , IFormulaEditorHelper* _pHelper,IFunctionManager* _pFunctionMgr,IControlReferenceHandler* _pDlg ) :
2001 SfxModelessDialog( pB, pCW, pParent, ModuleRes(RID_FORMULADLG_FORMULA) ),
2002 m_pImpl( new FormulaDlg_Impl(this, _bSupportFunctionResult
2003 , _bSupportResult
2004 , _bSupportMatrix
2005 ,_pHelper,_pFunctionMgr,_pDlg))
2006 {
2007 FreeResource();
2008 if(!GetHelpId().getLength()) //Hack, da im SfxModelessDialog die HelpId
2009 SetHelpId(GetUniqueId()); //fuer einen ModelessDialog entfernt und
2010 //in eine UniqueId gewandelt wird, machen
2011 //wir das an dieser Stelle rueckgaengig.
2012 SetText(m_pImpl->aTitle1);
2013 }
2014
~FormulaDlg()2015 FormulaDlg::~FormulaDlg()
2016 {
2017 }
2018 // -----------------------------------------------------------------------------
Update(const String & _sExp)2019 void FormulaDlg::Update(const String& _sExp)
2020 {
2021 m_pImpl->Update(_sExp);
2022 }
2023
2024 // -----------------------------------------------------------------------------
SetMeText(const String & _sText)2025 void FormulaDlg::SetMeText(const String& _sText)
2026 {
2027 m_pImpl->SetMeText(_sText);
2028 }
2029
2030 // -----------------------------------------------------------------------------
SetMeText(const String & _sText,xub_StrLen PrivStart,xub_StrLen PrivEnd,sal_Bool bMatrix,sal_Bool _bSelect,sal_Bool _bUpdate)2031 FormulaDlgMode FormulaDlg::SetMeText(const String& _sText,xub_StrLen PrivStart, xub_StrLen PrivEnd,sal_Bool bMatrix,sal_Bool _bSelect,sal_Bool _bUpdate)
2032 {
2033 return m_pImpl->SetMeText(_sText,PrivStart, PrivEnd,bMatrix,_bSelect,_bUpdate);
2034 }
2035 // -----------------------------------------------------------------------------
CheckMatrix()2036 void FormulaDlg::CheckMatrix()
2037 {
2038 m_pImpl->aBtnMatrix.Check();
2039 }
2040 // -----------------------------------------------------------------------------
CheckMatrix(String & aFormula)2041 sal_Bool FormulaDlg::CheckMatrix(String& aFormula)
2042 {
2043 return m_pImpl->CheckMatrix(aFormula);
2044 }
2045 // -----------------------------------------------------------------------------
GetMeText() const2046 String FormulaDlg::GetMeText() const
2047 {
2048 return m_pImpl->pMEdit->GetText();
2049 }
2050 // -----------------------------------------------------------------------------
Update()2051 void FormulaDlg::Update()
2052 {
2053 m_pImpl->Update();
2054 m_pImpl->aTimer.SetTimeout(200);
2055 m_pImpl->aTimer.SetTimeoutHdl(LINK( this, FormulaDlg, UpdateFocusHdl));
2056 m_pImpl->aTimer.Start();
2057 }
2058
2059 // -----------------------------------------------------------------------------
isUserMatrix() const2060 sal_Bool FormulaDlg::isUserMatrix() const
2061 {
2062 return m_pImpl->bUserMatrixFlag;
2063 }
DoEnter(sal_Bool _bOk)2064 void FormulaDlg::DoEnter(sal_Bool _bOk)
2065 {
2066 m_pImpl->DoEnter(_bOk);
2067 }
RefInputStartBefore(RefEdit * pEdit,RefButton * pButton)2068 ::std::pair<RefButton*,RefEdit*> FormulaDlg::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton )
2069 {
2070 return m_pImpl->RefInputStartBefore( pEdit, pButton );
2071 }
RefInputStartAfter(RefEdit * pEdit,RefButton * pButton)2072 void FormulaDlg::RefInputStartAfter( RefEdit* pEdit, RefButton* pButton )
2073 {
2074 m_pImpl->RefInputStartAfter( pEdit, pButton );
2075 }
RefInputDoneAfter(sal_Bool bForced)2076 void FormulaDlg::RefInputDoneAfter( sal_Bool bForced )
2077 {
2078 m_pImpl->RefInputDoneAfter( bForced );
2079 }
2080
FindFocusWin(Window * pWin)2081 rtl::OString FormulaDlg::FindFocusWin(Window *pWin)
2082 {
2083 return m_pImpl->FindFocusWin( pWin );
2084 }
2085
SetFocusWin(Window * pWin,const rtl::OString & nUniqueId)2086 void FormulaDlg::SetFocusWin(Window *pWin,const rtl::OString& nUniqueId)
2087 {
2088 if(pWin->GetUniqueId()==nUniqueId)
2089 {
2090 pWin->GrabFocus();
2091 }
2092 else
2093 {
2094 sal_uInt16 nCount=pWin->GetChildCount();
2095
2096 for(sal_uInt16 i=0;i<nCount;i++)
2097 {
2098 Window* pChild=pWin->GetChild(i);
2099 SetFocusWin(pChild,nUniqueId);
2100 }
2101 }
2102 }
2103
2104
PreNotify(NotifyEvent & rNEvt)2105 long FormulaDlg::PreNotify( NotifyEvent& rNEvt )
2106 {
2107 m_pImpl->PreNotify( rNEvt );
2108 return SfxModelessDialog::PreNotify(rNEvt);
2109 }
2110
HighlightFunctionParas(const String & aFormula)2111 void FormulaDlg::HighlightFunctionParas(const String& aFormula)
2112 {
2113 m_pImpl->m_pHelper->showReference(aFormula);
2114 }
2115
disableOk()2116 void FormulaDlg::disableOk()
2117 {
2118 m_pImpl->aBtnEnd.Disable();
2119 }
2120 // -----------------------------------------------------------------------------
getCurrentFunctionDescription() const2121 const IFunctionDescription* FormulaDlg::getCurrentFunctionDescription() const
2122 {
2123 OSL_VERIFY(!m_pImpl->pFuncDesc || m_pImpl->pFuncDesc->getSuppressedArgumentCount() == m_pImpl->nArgs);
2124 return m_pImpl->pFuncDesc;
2125 }
2126 // -----------------------------------------------------------------------------
UpdateParaWin(const Selection & _rSelection,const String & _sRefStr)2127 void FormulaDlg::UpdateParaWin(const Selection& _rSelection,const String& _sRefStr)
2128 {
2129 m_pImpl->UpdateParaWin(_rSelection,_sRefStr);
2130 }
UpdateParaWin(Selection & _rSelection)2131 sal_Bool FormulaDlg::UpdateParaWin(Selection& _rSelection)
2132 {
2133 return m_pImpl->UpdateParaWin(_rSelection);
2134 }
2135 // -----------------------------------------------------------------------------
GetActiveEdit()2136 RefEdit* FormulaDlg::GetActiveEdit()
2137 {
2138 return m_pImpl->pParaWin->GetActiveEdit();
2139 }
2140 // -----------------------------------------------------------------------------
GetFormulaHelper() const2141 const FormulaHelper& FormulaDlg::GetFormulaHelper() const
2142 {
2143 return m_pImpl->GetFormulaHelper();
2144 }
2145 // -----------------------------------------------------------------------------
SetEdSelection()2146 void FormulaDlg::SetEdSelection()
2147 {
2148 m_pImpl->SetEdSelection();
2149 }
IMPL_LINK(FormulaDlg,UpdateFocusHdl,Timer *,EMPTYARG)2150 IMPL_LINK( FormulaDlg, UpdateFocusHdl, Timer*, EMPTYARG )
2151 {
2152 FormEditData* pData = m_pImpl->m_pHelper->getFormEditData();
2153
2154 if (pData) // wird nicht ueber Close zerstoert;
2155 {
2156 m_pImpl->m_pHelper->setReferenceInput(pData);
2157 rtl::OString nUniqueId(pData->GetUniqueId());
2158 SetFocusWin(this,nUniqueId);
2159 }
2160 return 0;
2161 }
2162
2163 // -----------------------------------------------------------------------------
2164 // -----------------------------------------------------------------------------
SaveValues()2165 void FormEditData::SaveValues()
2166 {
2167 FormEditData* pTemp = new FormEditData(*this);
2168
2169 Reset();
2170 pParent = pTemp;
2171 }
2172 // -----------------------------------------------------------------------------
Reset()2173 void FormEditData::Reset()
2174 {
2175 pParent = NULL;
2176 nMode = 0;
2177 nFStart = 0;
2178 nCatSel = 1; //! oder 0 (zuletzt benutzte)
2179 nFuncSel = 0;
2180 nOffset = 0;
2181 nEdFocus = 0;
2182 bMatrix =sal_False;
2183 aUniqueId=rtl::OString();
2184 aSelection.Min()=0;
2185 aSelection.Max()=0;
2186 aUndoStr.Erase();
2187 }
2188 // -----------------------------------------------------------------------------
RestoreValues()2189 void FormEditData::RestoreValues()
2190 {
2191 FormEditData* pTemp = pParent;
2192 DBG_ASSERT(pTemp,"RestoreValues ohne Parent");
2193 if (pTemp)
2194 {
2195 *this = *pTemp;
2196 pTemp->pParent = NULL; // sonst wird der auch geloescht!
2197 delete pTemp;
2198 }
2199 }
2200 // -----------------------------------------------------------------------------
operator =(const FormEditData & r)2201 const FormEditData& FormEditData::operator=( const FormEditData& r )
2202 {
2203 pParent = r.pParent;
2204 nMode = r.nMode;
2205 nFStart = r.nFStart;
2206 nCatSel = r.nCatSel;
2207 nFuncSel = r.nFuncSel;
2208 nOffset = r.nOffset;
2209 nEdFocus = r.nEdFocus;
2210 aUndoStr = r.aUndoStr;
2211 bMatrix = r.bMatrix ;
2212 aUniqueId = r.aUniqueId;
2213 aSelection = r.aSelection;
2214 return *this;
2215 }
2216 // -----------------------------------------------------------------------------
FormEditData()2217 FormEditData::FormEditData()
2218 {
2219 Reset();
2220 }
2221
~FormEditData()2222 FormEditData::~FormEditData()
2223 {
2224 delete pParent;
2225 }
2226
FormEditData(const FormEditData & r)2227 FormEditData::FormEditData( const FormEditData& r )
2228 {
2229 *this = r;
2230 }
2231
2232 // -----------------------------------------------------------------------------
2233 } // formula
2234 // -----------------------------------------------------------------------------
2235