Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <sfx2/dispatch.hxx>
21 : #include <sfx2/docfile.hxx>
22 : #include <sfx2/viewfrm.hxx>
23 : #include <vcl/svapp.hxx>
24 : #include <vcl/mnemonic.hxx>
25 : #include <vcl/tabpage.hxx>
26 : #include <vcl/tabctrl.hxx>
27 : #include <vcl/lstbox.hxx>
28 : #include <vcl/group.hxx>
29 : #include <vcl/wall.hxx>
30 : #include <vcl/layout.hxx>
31 :
32 : #include <svtools/stdctrl.hxx>
33 : #include <svtools/svmedit.hxx>
34 : #include <svtools/treelistbox.hxx>
35 : #include <svl/stritem.hxx>
36 : #include <svl/zforlist.hxx>
37 : #include <svl/eitem.hxx>
38 :
39 : #include <unotools/charclass.hxx>
40 : #include <tools/diagnose_ex.h>
41 :
42 : #include "formdlgs.hrc"
43 : #include "funcpage.hxx"
44 : #include "formula/formula.hxx"
45 : #include "formula/IFunctionDescription.hxx"
46 : #include "formula/FormulaCompiler.hxx"
47 : #include "formula/token.hxx"
48 : #include "formula/tokenarray.hxx"
49 : #include "formula/formdata.hxx"
50 : #include "formula/formulahelper.hxx"
51 : #include "structpg.hxx"
52 : #include "parawin.hxx"
53 : #include "ModuleHelper.hxx"
54 : #include "ForResId.hrc"
55 : #include <com/sun/star/sheet/FormulaToken.hpp>
56 : #include <com/sun/star/sheet/FormulaLanguage.hpp>
57 : #include <com/sun/star/sheet/FormulaMapGroup.hpp>
58 : #include <com/sun/star/sheet/FormulaMapGroupSpecialOffset.hpp>
59 : #include <com/sun/star/beans/XPropertySet.hpp>
60 : #include <boost/ref.hpp>
61 : #include <boost/shared_ptr.hpp>
62 : #include <comphelper/processfactory.hxx>
63 : #include <comphelper/string.hxx>
64 : #include <map>
65 :
66 : #define TOKEN_OPEN 0
67 : #define TOKEN_CLOSE 1
68 : #define TOKEN_SEP 2
69 : namespace formula
70 : {
71 : using namespace ::com::sun::star;
72 :
73 : class FormulaDlg_Impl
74 : {
75 : public:
76 : ::std::pair<RefButton*,RefEdit*>
77 : RefInputStartBefore( RefEdit* pEdit, RefButton* pButton );
78 : void RefInputStartAfter( RefEdit* pEdit, RefButton* pButton );
79 : void RefInputDoneAfter( bool bForced );
80 : bool CalcValue( const OUString& rStrExp, OUString& rStrResult );
81 : bool CalcStruct( const OUString& rStrExp);
82 : void UpdateValues();
83 : void DeleteArgs();
84 : sal_Int32 GetFunctionPos(sal_Int32 nPos);
85 : void ClearAllParas();
86 :
87 : void MakeTree(IStructHelper* _pTree,SvTreeListEntry* pParent,FormulaToken* _pToken,long Count);
88 : void fillTree(IStructHelper* _pTree);
89 : void UpdateTokenArray( const OUString& rStrExp);
90 : OUString RepairFormula(const OUString& aFormula);
91 : void FillDialog(bool nFlag=true);
92 : void EditNextFunc( bool bForward, sal_Int32 nFStart=NOT_FOUND );
93 : void EditThisFunc(sal_Int32 nFStart);
94 :
95 : void StoreFormEditData(FormEditData* pEditData);
96 :
97 : void Update();
98 : void Update(const OUString& _sExp);
99 :
100 : void SaveArg( sal_uInt16 nEd );
101 : void UpdateSelection();
102 : void DoEnter( bool bOk );
103 : void FillListboxes();
104 : void FillControls(bool &rbNext, bool &rbPrev);
105 :
106 : FormulaDlgMode SetMeText(const OUString& _sText, sal_Int32 PrivStart, sal_Int32 PrivEnd, bool bMatrix, bool _bSelect, bool _bUpdate);
107 : void SetMeText(const OUString& _sText);
108 : bool CheckMatrix(OUString& aFormula /*IN/OUT*/);
109 :
110 : void SetEdSelection();
111 :
112 : bool UpdateParaWin(Selection& _rSelection);
113 : void UpdateParaWin(const Selection& _rSelection,const OUString& _sRefStr);
114 :
115 : void SetData(sal_Int32 nFStart, sal_Int32 nNextFStart, sal_Int32 nNextFEnd, sal_Int32& PrivStart, sal_Int32& PrivEnd);
116 : void PreNotify( NotifyEvent& rNEvt );
117 :
118 : RefEdit* GetCurrRefEdit();
119 :
120 0 : const FormulaHelper& GetFormulaHelper() const { return m_aFormulaHelper;}
121 : uno::Reference< sheet::XFormulaOpCodeMapper > GetFormulaOpCodeMapper() const;
122 :
123 : DECL_LINK( ModifyHdl, ParaWin* );
124 : DECL_LINK( FxHdl, ParaWin* );
125 :
126 : DECL_LINK(MatrixHdl, void *);
127 : DECL_LINK(FormulaHdl, void *);
128 : DECL_LINK(FormulaCursorHdl, void *);
129 : DECL_LINK( BtnHdl, PushButton* );
130 : DECL_LINK(DblClkHdl, void *);
131 : DECL_LINK(FuncSelHdl, void *);
132 : DECL_LINK(StructSelHdl, void *);
133 : public:
134 : mutable uno::Reference< sheet::XFormulaOpCodeMapper> m_xOpCodeMapper;
135 : uno::Sequence< sheet::FormulaToken > m_aTokenList;
136 : ::std::unique_ptr<FormulaTokenArray> m_pTokenArray;
137 : mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aSpecialOpCodes;
138 : mutable const sheet::FormulaOpCodeMapEntry* m_pSpecialOpCodesEnd;
139 : mutable uno::Sequence< sheet::FormulaToken > m_aSeparatorsOpCodes;
140 : mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aFunctionOpCodes;
141 : mutable const sheet::FormulaOpCodeMapEntry* m_pFunctionOpCodesEnd;
142 : mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aUnaryOpCodes;
143 : mutable const sheet::FormulaOpCodeMapEntry* m_pUnaryOpCodesEnd;
144 : mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aBinaryOpCodes;
145 : mutable const sheet::FormulaOpCodeMapEntry* m_pBinaryOpCodesEnd;
146 : ::std::map<FormulaToken*,sheet::FormulaToken> m_aTokenMap;
147 : IFormulaEditorHelper* m_pHelper;
148 : Dialog* m_pParent;
149 : IControlReferenceHandler* m_pDlg;
150 : TabControl *m_pTabCtrl;
151 : VclVBox *m_pParaWinBox;
152 : ParaWin* pParaWin;
153 : FixedText *m_pFtHeadLine;
154 : FixedText *m_pFtFuncName;
155 : FixedText *m_pFtFuncDesc;
156 :
157 : FixedText *m_pFtEditName;
158 :
159 : FixedText *m_pFtResult;
160 : Edit *m_pWndResult;
161 :
162 : FixedText *m_pFtFormula;
163 : EditBox *m_pMEFormula;
164 :
165 : CheckBox *m_pBtnMatrix;
166 : CancelButton *m_pBtnCancel;
167 :
168 : PushButton *m_pBtnBackward;
169 : PushButton *m_pBtnForward;
170 : OKButton *m_pBtnEnd;
171 :
172 : RefEdit *m_pEdRef;
173 : RefButton *m_pRefBtn;
174 :
175 : FixedText *m_pFtFormResult;
176 : Edit *m_pWndFormResult;
177 :
178 : RefEdit* pTheRefEdit;
179 : RefButton* pTheRefButton;
180 : FuncPage* pFuncPage;
181 : StructPage* pStructPage;
182 : OUString aOldFormula;
183 : bool bStructUpdate;
184 : MultiLineEdit* pMEdit;
185 : bool bUserMatrixFlag;
186 : Timer aTimer;
187 :
188 : const OUString aTitle1;
189 : const OUString aTitle2;
190 : const OUString aTxtEnd;
191 : OUString aTxtOk; // behind aBtnEnd
192 : FormulaHelper m_aFormulaHelper;
193 :
194 : OString m_aEditHelpId;
195 :
196 : OString aOldHelp;
197 : OString aOldUnique;
198 : OString aActivWinId;
199 : bool bIsShutDown;
200 :
201 : vcl::Font aFntBold;
202 : vcl::Font aFntLight;
203 : sal_uInt16 nEdFocus;
204 : bool bEditFlag;
205 : const IFunctionDescription* pFuncDesc;
206 : sal_Int32 nArgs;
207 : ::std::vector< OUString > m_aArguments;
208 : Selection aFuncSel;
209 :
210 : FormulaDlg_Impl(Dialog* pParent
211 : , bool _bSupportFunctionResult
212 : , bool _bSupportResult
213 : , bool _bSupportMatrix
214 : ,IFormulaEditorHelper* _pHelper
215 : ,const IFunctionManager* _pFunctionMgr
216 : ,IControlReferenceHandler* _pDlg);
217 : ~FormulaDlg_Impl();
218 :
219 : };
220 :
221 0 : FormulaDlg_Impl::FormulaDlg_Impl(Dialog* pParent
222 : , bool _bSupportFunctionResult
223 : , bool _bSupportResult
224 : , bool _bSupportMatrix
225 : ,IFormulaEditorHelper* _pHelper
226 : ,const IFunctionManager* _pFunctionMgr
227 : ,IControlReferenceHandler* _pDlg)
228 : :
229 : m_pSpecialOpCodesEnd(NULL),
230 : m_pFunctionOpCodesEnd(NULL),
231 : m_pUnaryOpCodesEnd(NULL),
232 : m_pBinaryOpCodesEnd(NULL),
233 : m_pHelper (_pHelper),
234 : m_pParent (pParent),
235 : m_pDlg (_pDlg),
236 : pTheRefEdit (NULL),
237 : pTheRefButton (NULL),
238 : pMEdit (NULL),
239 : bUserMatrixFlag (false),
240 : aTitle1 ( ModuleRes( STR_TITLE1 ) ),
241 : aTitle2 ( ModuleRes( STR_TITLE2 ) ),
242 : aTxtEnd ( ModuleRes( STR_END ) ),
243 : m_aFormulaHelper(_pFunctionMgr),
244 : bIsShutDown (false),
245 : nEdFocus (0),
246 : pFuncDesc (NULL),
247 0 : nArgs (0)
248 : {
249 0 : pParent->get(m_pParaWinBox, "BOX");
250 0 : pParent->get(m_pTabCtrl, "tabs");
251 0 : pParent->get(m_pFtHeadLine, "headline");
252 0 : pParent->get(m_pFtFuncName, "funcname");
253 0 : pParent->get(m_pFtFuncDesc, "funcdesc");
254 0 : pParent->get(m_pFtEditName, "editname");
255 0 : pParent->get(m_pFtResult, "label2");
256 0 : pParent->get(m_pWndResult, "result");
257 0 : pParent->get(m_pFtFormula, "formula");
258 :
259 : //Space for two lines of text
260 0 : m_pFtHeadLine->SetText("X\nX\n");
261 0 : long nHeight = m_pFtHeadLine->GetOptimalSize().Height();
262 0 : m_pFtHeadLine->set_height_request(nHeight);
263 0 : m_pFtHeadLine->SetText("");
264 :
265 0 : m_pFtFuncName->SetText("X\nX\n");
266 0 : nHeight = m_pFtFuncName->GetOptimalSize().Height();
267 0 : m_pFtFuncName->set_height_request(nHeight);
268 0 : m_pFtFuncDesc->set_height_request(nHeight);
269 0 : m_pFtFuncName->SetText("");
270 :
271 0 : pParent->get(m_pMEFormula, "ed_formula");
272 0 : Size aSize(pParent->LogicToPixel(Size(203, 43), MAP_APPFONT));
273 0 : m_pMEFormula->set_height_request(aSize.Height());
274 0 : m_pMEFormula->set_width_request(aSize.Width());
275 0 : pParent->get(m_pBtnMatrix, "array");
276 0 : pParent->get(m_pBtnCancel, "cancel");
277 0 : pParent->get(m_pBtnBackward, "back");
278 0 : pParent->get(m_pBtnForward, "next");
279 0 : pParent->get(m_pBtnEnd, "ok");
280 0 : aTxtOk = m_pBtnEnd->GetText();
281 0 : pParent->get(m_pFtFormResult, "label1");
282 0 : pParent->get(m_pWndFormResult, "formula_result");
283 0 : pParent->get(m_pEdRef, "ED_REF");
284 0 : m_pEdRef->SetReferences(_pDlg, m_pFtEditName);
285 0 : pParent->get(m_pRefBtn, "RB_REF");
286 0 : m_pRefBtn->SetReferences(_pDlg, m_pEdRef);
287 :
288 0 : pParaWin = new ParaWin(m_pParaWinBox, _pDlg);
289 0 : pParaWin->Show();
290 0 : m_pParaWinBox->Hide();
291 0 : m_pFtEditName->Hide();
292 0 : m_pEdRef->Hide();
293 0 : m_pRefBtn->Hide();
294 :
295 0 : pMEdit = m_pMEFormula->GetEdit();
296 :
297 0 : m_pMEFormula->SetAccessibleName(m_pFtFormula->GetText());
298 0 : pMEdit->SetAccessibleName(m_pFtFormula->GetText());
299 :
300 0 : m_aEditHelpId = pMEdit->GetHelpId();
301 0 : pMEdit->SetUniqueId( m_aEditHelpId );
302 :
303 0 : bEditFlag=false;
304 0 : bStructUpdate=true;
305 0 : pParaWin->SetArgModifiedHdl(LINK( this, FormulaDlg_Impl, ModifyHdl ) );
306 0 : pParaWin->SetFxHdl(LINK( this, FormulaDlg_Impl, FxHdl ) );
307 :
308 0 : pFuncPage= new FuncPage( m_pTabCtrl,_pFunctionMgr);
309 0 : pStructPage= new StructPage( m_pTabCtrl);
310 0 : pFuncPage->Hide();
311 0 : pStructPage->Hide();
312 0 : m_pTabCtrl->SetTabPage( TP_FUNCTION, pFuncPage);
313 0 : m_pTabCtrl->SetTabPage( TP_STRUCT, pStructPage);
314 :
315 0 : aOldHelp = pParent->GetHelpId(); // HelpId from resource always for "Page 1"
316 0 : aOldUnique = pParent->GetUniqueId();
317 :
318 0 : m_pFtResult->Show( _bSupportResult );
319 0 : m_pWndResult->Show( _bSupportResult );
320 :
321 0 : m_pFtFormResult->Show( _bSupportFunctionResult );
322 0 : m_pWndFormResult->Show( _bSupportFunctionResult );
323 :
324 0 : if ( _bSupportMatrix )
325 0 : m_pBtnMatrix->SetClickHdl(LINK( this, FormulaDlg_Impl, MatrixHdl ) );
326 : else
327 0 : m_pBtnMatrix->Hide();
328 :
329 0 : m_pBtnCancel ->SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
330 0 : m_pBtnEnd ->SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
331 0 : m_pBtnForward ->SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
332 0 : m_pBtnBackward->SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
333 :
334 0 : pFuncPage->SetDoubleClickHdl( LINK( this, FormulaDlg_Impl, DblClkHdl ) );
335 0 : pFuncPage->SetSelectHdl( LINK( this, FormulaDlg_Impl, FuncSelHdl) );
336 0 : pStructPage->SetSelectionHdl( LINK( this, FormulaDlg_Impl, StructSelHdl ) );
337 0 : pMEdit->SetModifyHdl( LINK( this, FormulaDlg_Impl, FormulaHdl ) );
338 0 : m_pMEFormula->SetSelChangedHdl( LINK( this, FormulaDlg_Impl, FormulaCursorHdl ) );
339 :
340 0 : aFntLight = m_pFtFormula->GetFont();
341 0 : aFntLight.SetTransparent( true );
342 0 : aFntBold = aFntLight;
343 0 : aFntBold.SetWeight( WEIGHT_BOLD );
344 :
345 0 : pParaWin->SetArgumentFonts(aFntBold,aFntLight);
346 :
347 : // function description for choosing a function is no longer in a different color
348 :
349 0 : m_pFtHeadLine->SetFont(aFntBold);
350 0 : m_pFtFuncName->SetFont(aFntLight);
351 0 : m_pFtFuncDesc->SetFont(aFntLight);
352 0 : }
353 :
354 0 : FormulaDlg_Impl::~FormulaDlg_Impl()
355 : {
356 0 : if(aTimer.IsActive())
357 : {
358 0 : aTimer.SetTimeoutHdl(Link());
359 0 : aTimer.Stop();
360 : }// if(aTimer.IsActive())
361 0 : bIsShutDown=true;// Set it in order to PreNotify not to save GetFocus.
362 :
363 0 : m_pTabCtrl->RemovePage(TP_FUNCTION);
364 0 : m_pTabCtrl->RemovePage(TP_STRUCT);
365 :
366 0 : delete pStructPage;
367 0 : delete pFuncPage;
368 0 : delete pParaWin;
369 0 : DeleteArgs();
370 0 : }
371 :
372 0 : void FormulaDlg_Impl::StoreFormEditData(FormEditData* pData)
373 : {
374 0 : if (pData) // it won't be destroyed via Close
375 : {
376 0 : pData->SetFStart(pMEdit->GetSelection().Min());
377 0 : pData->SetSelection(pMEdit->GetSelection());
378 :
379 0 : if(m_pTabCtrl->GetCurPageId()==TP_FUNCTION)
380 0 : pData->SetMode( (sal_uInt16) FORMULA_FORMDLG_FORMULA );
381 : else
382 0 : pData->SetMode( (sal_uInt16) FORMULA_FORMDLG_EDIT );
383 0 : pData->SetUndoStr(pMEdit->GetText());
384 0 : pData->SetMatrixFlag(m_pBtnMatrix->IsChecked());
385 : }
386 0 : }
387 :
388 :
389 0 : void FormulaDlg_Impl::PreNotify( NotifyEvent& rNEvt )
390 : {
391 0 : sal_uInt16 nSwitch=rNEvt.GetType();
392 0 : if(nSwitch==EVENT_GETFOCUS && !bIsShutDown)
393 : {
394 0 : vcl::Window* pWin=rNEvt.GetWindow();
395 0 : if(pWin!=NULL)
396 : {
397 0 : aActivWinId = pWin->GetUniqueId();
398 0 : if(aActivWinId.isEmpty())
399 : {
400 0 : vcl::Window* pParent=pWin->GetParent();
401 0 : while(pParent!=NULL)
402 : {
403 0 : aActivWinId=pParent->GetUniqueId();
404 :
405 0 : if(!aActivWinId.isEmpty()) break;
406 :
407 0 : pParent=pParent->GetParent();
408 : }
409 : }
410 0 : if(!aActivWinId.isEmpty())
411 : {
412 :
413 0 : FormEditData* pData = m_pHelper->getFormEditData();
414 :
415 0 : if (pData && !aTimer.IsActive()) // won't be destroyed via Close
416 : {
417 0 : pData->SetUniqueId(aActivWinId);
418 : }
419 : }
420 : }
421 : }
422 0 : }
423 0 : uno::Reference< sheet::XFormulaOpCodeMapper > FormulaDlg_Impl::GetFormulaOpCodeMapper() const
424 : {
425 0 : if ( !m_xOpCodeMapper.is() )
426 : {
427 0 : m_xOpCodeMapper = m_pHelper->getFormulaOpCodeMapper();
428 0 : m_aFunctionOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::FUNCTIONS);
429 0 : m_pFunctionOpCodesEnd = m_aFunctionOpCodes.getConstArray() + m_aFunctionOpCodes.getLength();
430 :
431 0 : m_aUnaryOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::UNARY_OPERATORS);
432 0 : m_pUnaryOpCodesEnd = m_aUnaryOpCodes.getConstArray() + m_aUnaryOpCodes.getLength();
433 :
434 0 : m_aBinaryOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::BINARY_OPERATORS);
435 0 : m_pBinaryOpCodesEnd = m_aBinaryOpCodes.getConstArray() + m_aBinaryOpCodes.getLength();
436 :
437 0 : uno::Sequence< OUString > aArgs(3);
438 0 : aArgs[TOKEN_OPEN] = "(";
439 0 : aArgs[TOKEN_CLOSE] = ")";
440 0 : aArgs[TOKEN_SEP] = ";";
441 0 : m_aSeparatorsOpCodes = m_xOpCodeMapper->getMappings(aArgs,sheet::FormulaLanguage::ODFF);
442 :
443 0 : m_aSpecialOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::SPECIAL);
444 0 : m_pSpecialOpCodesEnd = m_aSpecialOpCodes.getConstArray() + m_aSpecialOpCodes.getLength();
445 : } // if ( !m_xOpCodeMapper.is() )
446 0 : return m_xOpCodeMapper;
447 : }
448 :
449 0 : void FormulaDlg_Impl::DeleteArgs()
450 : {
451 0 : ::std::vector< OUString>().swap(m_aArguments);
452 0 : nArgs = 0;
453 0 : }
454 : namespace
455 : {
456 : // comparing two property instances
457 : struct OpCodeCompare : public ::std::binary_function< sheet::FormulaOpCodeMapEntry, sal_Int32 , bool >
458 : {
459 0 : bool operator() (const sheet::FormulaOpCodeMapEntry& x, sal_Int32 y) const
460 : {
461 0 : return x.Token.OpCode == y;
462 : }
463 : };
464 : }
465 :
466 0 : sal_Int32 FormulaDlg_Impl::GetFunctionPos(sal_Int32 nPos)
467 : {
468 0 : if ( !m_aTokenList.hasElements() )
469 0 : return SAL_MAX_INT32;
470 :
471 0 : const sal_Unicode sep = m_pHelper->getFunctionManager()->getSingleToken(IFunctionManager::eSep);
472 :
473 0 : sal_Int32 nFuncPos = SAL_MAX_INT32;
474 0 : bool bFlag = false;
475 0 : OUString aFormString = m_aFormulaHelper.GetCharClass()->uppercase(pMEdit->GetText());
476 :
477 0 : const uno::Reference< sheet::XFormulaParser > xParser(m_pHelper->getFormulaParser());
478 0 : const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
479 :
480 0 : const sheet::FormulaToken* pIter = m_aTokenList.getConstArray();
481 0 : const sheet::FormulaToken* pEnd = pIter + m_aTokenList.getLength();
482 : try
483 : {
484 0 : sal_Int32 nTokPos = 1;
485 0 : sal_Int32 nOldTokPos = 1;
486 0 : sal_Int32 nPrevFuncPos = 1;
487 0 : short nBracketCount = 0;
488 0 : while ( pIter != pEnd )
489 : {
490 0 : const sal_Int32 eOp = pIter->OpCode;
491 0 : uno::Sequence<sheet::FormulaToken> aArgs(1);
492 0 : aArgs[0] = *pIter;
493 0 : const OUString aString = xParser->printFormula(aArgs, aRefPos);
494 0 : const sheet::FormulaToken* pNextToken = pIter + 1;
495 :
496 0 : if( !bUserMatrixFlag && FormulaCompiler::IsMatrixFunction((OpCode)eOp) )
497 : {
498 0 : m_pBtnMatrix->Check();
499 : }
500 :
501 0 : if( eOp == m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::PUSH].Token.OpCode ||
502 0 : eOp == m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::SPACES].Token.OpCode )
503 : {
504 0 : const sal_Int32 n1 = nTokPos < 0 ? -1 : aFormString.indexOf(sep, nTokPos);
505 0 : const sal_Int32 n2 = nTokPos < 0 ? -1 : aFormString.indexOf(')',nTokPos);
506 0 : sal_Int32 nXXX = nTokPos;
507 0 : if( n1 < n2 && n1 != -1 )
508 : {
509 0 : nTokPos=n1;
510 : }
511 : else
512 : {
513 0 : nTokPos=n2;
514 : }
515 0 : if( pNextToken != pEnd )
516 : {
517 0 : aArgs[0] = *pNextToken;
518 0 : const OUString a2String = xParser->printFormula(aArgs, aRefPos);
519 0 : const sal_Int32 n3 = nXXX < 0 ? -1 : aFormString.indexOf(a2String, nXXX);
520 0 : if (n3 < nTokPos && n3 != -1)
521 0 : nTokPos = n3;
522 : }
523 : }
524 : else
525 : {
526 0 : nTokPos = nTokPos + aString.getLength();
527 : }
528 :
529 0 : if( eOp == m_aSeparatorsOpCodes[TOKEN_OPEN].OpCode )
530 : {
531 0 : nBracketCount++;
532 0 : bFlag = true;
533 : }
534 0 : else if( eOp == m_aSeparatorsOpCodes[TOKEN_CLOSE].OpCode )
535 : {
536 0 : nBracketCount--;
537 0 : bFlag = false;
538 0 : nFuncPos = nPrevFuncPos;
539 : }
540 0 : bool bIsFunction = ::std::find_if(m_aFunctionOpCodes.getConstArray(),m_pFunctionOpCodesEnd,::std::bind2nd(OpCodeCompare(),boost::cref(eOp))) != m_pFunctionOpCodesEnd;
541 :
542 0 : if( bIsFunction && m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::SPACES].Token.OpCode != eOp )
543 : {
544 0 : nPrevFuncPos = nFuncPos;
545 0 : nFuncPos = nOldTokPos;
546 : }
547 :
548 0 : if( nOldTokPos <= nPos && nPos < nTokPos )
549 : {
550 0 : if( !bIsFunction )
551 : {
552 0 : if( nBracketCount < 1 )
553 : {
554 0 : nFuncPos = pMEdit->GetText().getLength();
555 : }
556 0 : else if( !bFlag )
557 : {
558 0 : nFuncPos = nPrevFuncPos;
559 : }
560 : }
561 0 : break;
562 : }
563 :
564 0 : pIter = pNextToken;
565 0 : nOldTokPos = nTokPos;
566 0 : } // while ( pIter != pEnd )
567 : }
568 0 : catch ( const uno::Exception& e )
569 : {
570 : (void)e;
571 : SAL_WARN("formula.ui", "FormulaDlg_Impl::GetFunctionPos exception! " << e.Message);
572 : }
573 :
574 0 : return nFuncPos;
575 : }
576 :
577 0 : bool FormulaDlg_Impl::CalcValue( const OUString& rStrExp, OUString& rStrResult )
578 : {
579 0 : bool bResult = true;
580 :
581 0 : if ( !rStrExp.isEmpty() )
582 : {
583 : // Only calculate the value when there isn't any more keyboard input:
584 :
585 0 : if ( !Application::AnyInput( VCL_INPUT_KEYBOARD ) )
586 : {
587 0 : bResult = m_pHelper->calculateValue(rStrExp,rStrResult);
588 : }
589 : else
590 0 : bResult = false;
591 : }
592 :
593 0 : return bResult;
594 : }
595 :
596 0 : void FormulaDlg_Impl::UpdateValues()
597 : {
598 0 : OUString aStrResult;
599 :
600 0 : if ( CalcValue( pFuncDesc->getFormula( m_aArguments ), aStrResult ) )
601 0 : m_pWndResult->SetText( aStrResult );
602 :
603 0 : aStrResult = "";
604 0 : if ( CalcValue(m_pHelper->getCurrentFormula(), aStrResult ) )
605 0 : m_pWndFormResult->SetText( aStrResult );
606 : else
607 : {
608 0 : aStrResult = "";
609 0 : m_pWndFormResult->SetText( aStrResult );
610 : }
611 0 : CalcStruct(pMEdit->GetText());
612 0 : }
613 :
614 0 : bool FormulaDlg_Impl::CalcStruct( const OUString& rStrExp)
615 : {
616 0 : bool bResult = true;
617 0 : sal_Int32 nLength = rStrExp.getLength();
618 :
619 0 : if ( !rStrExp.isEmpty() && aOldFormula!=rStrExp && bStructUpdate)
620 : {
621 : // Only calculate the value when there isn't any more keyboard input:
622 :
623 0 : if ( !Application::AnyInput( VCL_INPUT_KEYBOARD ) )
624 : {
625 0 : pStructPage->ClearStruct();
626 :
627 0 : OUString aString=rStrExp;
628 0 : if(rStrExp[nLength-1] == '(')
629 : {
630 0 : aString = aString.copy(0, nLength-1);
631 : }
632 :
633 0 : aString = comphelper::string::remove(aString, '\n');
634 0 : OUString aStrResult;
635 :
636 0 : if ( CalcValue(aString, aStrResult ) )
637 0 : m_pWndFormResult->SetText( aStrResult );
638 :
639 0 : UpdateTokenArray(aString);
640 0 : fillTree(pStructPage);
641 :
642 0 : aOldFormula = rStrExp;
643 0 : if(rStrExp[nLength-1] == '(')
644 0 : UpdateTokenArray(rStrExp);
645 : }
646 : else
647 0 : bResult = false;
648 : }
649 0 : return bResult;
650 : }
651 :
652 :
653 0 : void FormulaDlg_Impl::MakeTree(IStructHelper* _pTree,SvTreeListEntry* pParent,FormulaToken* _pToken,long Count)
654 : {
655 0 : if( _pToken != NULL && Count > 0 )
656 : {
657 0 : long nParas = _pToken->GetParamCount();
658 0 : OpCode eOp = _pToken->GetOpCode();
659 :
660 : // #i101512# for output, the original token is needed
661 0 : FormulaToken* pOrigToken = (_pToken->GetType() == svFAP) ? _pToken->GetFAPOrigToken() : _pToken;
662 0 : uno::Sequence<sheet::FormulaToken> aArgs(1);
663 0 : ::std::map<FormulaToken*,sheet::FormulaToken>::const_iterator itr = m_aTokenMap.find(pOrigToken);
664 0 : if (itr == m_aTokenMap.end())
665 0 : return;
666 :
667 0 : aArgs[0] = itr->second;
668 : try
669 : {
670 0 : const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
671 0 : const OUString aResult = m_pHelper->getFormulaParser()->printFormula(aArgs, aRefPos);
672 :
673 0 : if ( nParas > 0 )
674 : {
675 : SvTreeListEntry* pEntry;
676 :
677 0 : OUString aTest=_pTree->GetEntryText(pParent);
678 :
679 0 : if(aTest==aResult &&
680 0 : (eOp==ocAdd || eOp==ocMul ||
681 : eOp==ocAmpersand))
682 : {
683 0 : pEntry=pParent;
684 : }
685 : else
686 : {
687 0 : if(eOp==ocBad)
688 : {
689 0 : pEntry=_pTree->InsertEntry(aResult,pParent,STRUCT_ERROR,0,_pToken);
690 : }
691 : else
692 : {
693 0 : pEntry=_pTree->InsertEntry(aResult,pParent,STRUCT_FOLDER,0,_pToken);
694 : }
695 : }
696 :
697 0 : MakeTree(_pTree,pEntry,m_pTokenArray->PrevRPN(),nParas);
698 0 : --Count;
699 0 : m_pTokenArray->NextRPN();
700 0 : MakeTree(_pTree,pParent,m_pTokenArray->PrevRPN(),Count);
701 : }
702 : else
703 : {
704 0 : if(eOp==ocBad)
705 : {
706 0 : _pTree->InsertEntry(aResult,pParent,STRUCT_ERROR,0,_pToken);
707 : }
708 : else
709 : {
710 0 : _pTree->InsertEntry(aResult,pParent,STRUCT_END,0,_pToken);
711 : }
712 0 : --Count;
713 0 : MakeTree(_pTree,pParent,m_pTokenArray->PrevRPN(),Count);
714 0 : }
715 : }
716 0 : catch(const uno::Exception&)
717 : {
718 : DBG_UNHANDLED_EXCEPTION();
719 0 : }
720 : }
721 : }
722 :
723 0 : void FormulaDlg_Impl::fillTree(IStructHelper* _pTree)
724 : {
725 0 : GetFormulaOpCodeMapper();
726 0 : FormulaToken* pToken = m_pTokenArray->LastRPN();
727 :
728 0 : if( pToken != NULL)
729 : {
730 0 : MakeTree(_pTree,NULL,pToken,1);
731 : }
732 0 : }
733 0 : void FormulaDlg_Impl::UpdateTokenArray( const OUString& rStrExp)
734 : {
735 0 : m_aTokenMap.clear();
736 0 : m_aTokenList.realloc(0);
737 : try
738 : {
739 0 : const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
740 0 : m_aTokenList = m_pHelper->getFormulaParser()->parseFormula(rStrExp, aRefPos);
741 : }
742 0 : catch(const uno::Exception&)
743 : {
744 : DBG_UNHANDLED_EXCEPTION();
745 : }
746 0 : GetFormulaOpCodeMapper(); // just to get it initialized
747 0 : m_pTokenArray = m_pHelper->convertToTokenArray(m_aTokenList);
748 0 : const sal_Int32 nLen = static_cast<sal_Int32>(m_pTokenArray->GetLen());
749 0 : FormulaToken** pTokens = m_pTokenArray->GetArray();
750 0 : if ( pTokens && nLen == m_aTokenList.getLength() )
751 : {
752 0 : for (sal_Int32 nPos=0; nPos<nLen; nPos++)
753 : {
754 0 : m_aTokenMap.insert(::std::map<FormulaToken*,sheet::FormulaToken>::value_type(pTokens[nPos],m_aTokenList[nPos]));
755 : }
756 : } // if ( pTokens && nLen == m_aTokenList.getLength() )
757 :
758 0 : FormulaCompiler aCompiler(*m_pTokenArray.get());
759 : // #i101512# Disable special handling of jump commands.
760 0 : aCompiler.EnableJumpCommandReorder(false);
761 0 : aCompiler.EnableStopOnError(false);
762 0 : aCompiler.CompileTokenArray();
763 0 : }
764 :
765 0 : void FormulaDlg_Impl::FillDialog(bool nFlag)
766 : {
767 0 : bool bNext=true, bPrev=true;
768 0 : if(nFlag)
769 0 : FillControls(bNext, bPrev);
770 0 : FillListboxes();
771 0 : if(nFlag)
772 : {
773 0 : m_pBtnBackward->Enable(bPrev);
774 0 : m_pBtnForward->Enable(bNext);
775 : }
776 :
777 0 : OUString aStrResult;
778 :
779 0 : if ( CalcValue(m_pHelper->getCurrentFormula(), aStrResult ) )
780 0 : m_pWndFormResult->SetText( aStrResult );
781 : else
782 : {
783 0 : aStrResult = "";
784 0 : m_pWndFormResult->SetText( aStrResult );
785 0 : }
786 0 : }
787 :
788 :
789 0 : void FormulaDlg_Impl::FillListboxes()
790 : {
791 : // Switch between the "Pages"
792 0 : FormEditData* pData = m_pHelper->getFormEditData();
793 0 : OUString aNewTitle;
794 : // 1. Page: select function
795 0 : if ( pFuncDesc && pFuncDesc->getCategory() )
796 : {
797 : // We'll never have more than int32 max categories so this is safe ...
798 0 : if( pFuncPage->GetCategory() != static_cast<sal_Int32>(pFuncDesc->getCategory()->getNumber() + 1) )
799 0 : pFuncPage->SetCategory(pFuncDesc->getCategory()->getNumber() + 1);
800 :
801 0 : sal_Int32 nPos=pFuncPage->GetFuncPos(pFuncDesc);
802 :
803 0 : pFuncPage->SetFunction(nPos);
804 : }
805 0 : else if ( pData )
806 : {
807 0 : pFuncPage->SetCategory( pData->GetCatSel() );
808 0 : pFuncPage->SetFunction( pData->GetFuncSel() );
809 : }
810 0 : FuncSelHdl(NULL);
811 :
812 0 : m_pHelper->setDispatcherLock( true );// Activate Modal-Mode
813 :
814 0 : aNewTitle = aTitle1;
815 :
816 : // HelpId for 1. page is the one from the resource
817 0 : m_pParent->SetHelpId( aOldHelp );
818 0 : m_pParent->SetUniqueId( aOldUnique );
819 0 : }
820 :
821 0 : void FormulaDlg_Impl::FillControls(bool &rbNext, bool &rbPrev)
822 : {
823 : // Switch between the "Pages"
824 0 : FormEditData* pData = m_pHelper->getFormEditData();
825 0 : if (!pData )
826 0 : return;
827 :
828 : // 2. Page or Edit: show selected function
829 :
830 0 : sal_Int32 nFStart = pData->GetFStart();
831 0 : OUString aFormula = m_pHelper->getCurrentFormula() + " )";
832 0 : sal_Int32 nNextFStart = nFStart;
833 0 : sal_Int32 nNextFEnd = 0;
834 :
835 0 : DeleteArgs();
836 0 : const IFunctionDescription* pOldFuncDesc = pFuncDesc;
837 0 : bool bTestFlag = false;
838 :
839 0 : if ( m_aFormulaHelper.GetNextFunc( aFormula, false,
840 0 : nNextFStart, &nNextFEnd, &pFuncDesc, &m_aArguments ) )
841 : {
842 0 : bTestFlag = (pOldFuncDesc != pFuncDesc);
843 0 : if(bTestFlag)
844 : {
845 0 : m_pFtHeadLine->Hide();
846 0 : m_pFtFuncName->Hide();
847 0 : m_pFtFuncDesc->Hide();
848 0 : pParaWin->SetFunctionDesc(pFuncDesc);
849 0 : m_pFtEditName->SetText( pFuncDesc->getFunctionName() );
850 0 : m_pFtEditName->Show();
851 0 : m_pParaWinBox->Show();
852 0 : const OString aHelpId = pFuncDesc->getHelpId();
853 0 : if ( !aHelpId.isEmpty() )
854 0 : pMEdit->SetHelpId(aHelpId);
855 : }
856 :
857 : sal_Int32 nOldStart, nOldEnd;
858 0 : m_pHelper->getSelection( nOldStart, nOldEnd );
859 0 : if ( nOldStart != nNextFStart || nOldEnd != nNextFEnd )
860 : {
861 0 : m_pHelper->setSelection( nNextFStart, nNextFEnd );
862 : }
863 0 : aFuncSel.Min() = nNextFStart;
864 0 : aFuncSel.Max() = nNextFEnd;
865 :
866 0 : if(!bEditFlag)
867 0 : pMEdit->SetText(m_pHelper->getCurrentFormula());
868 : sal_Int32 PrivStart, PrivEnd;
869 0 : m_pHelper->getSelection( PrivStart, PrivEnd);
870 0 : if(!bEditFlag)
871 0 : pMEdit->SetSelection( Selection(PrivStart, PrivEnd));
872 :
873 0 : nArgs = pFuncDesc->getSuppressedArgumentCount();
874 0 : sal_uInt16 nOffset = pData->GetOffset();
875 0 : nEdFocus = pData->GetEdFocus();
876 :
877 : // Concatenate the Edit's for Focus-Control
878 :
879 0 : if(bTestFlag)
880 0 : pParaWin->SetArgumentOffset(nOffset);
881 0 : sal_uInt16 nActiv=0;
882 0 : sal_Int32 nArgPos = m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 );
883 0 : sal_Int32 nEditPos = pMEdit->GetSelection().Min();
884 0 : bool bFlag = false;
885 :
886 0 : for(sal_uInt16 i=0;i<nArgs;i++)
887 : {
888 0 : sal_Int32 nLength = m_aArguments[i].getLength()+1;
889 0 : pParaWin->SetArgument(i,m_aArguments[i]);
890 0 : if(nArgPos<=nEditPos && nEditPos<nArgPos+nLength)
891 : {
892 0 : nActiv=i;
893 0 : bFlag=true;
894 : }
895 0 : nArgPos = nArgPos + nLength;
896 : }
897 0 : pParaWin->UpdateParas();
898 :
899 0 : if(bFlag)
900 : {
901 0 : pParaWin->SetActiveLine(nActiv);
902 : }
903 :
904 0 : UpdateValues();
905 : }
906 : else
907 : {
908 0 : m_pFtEditName->SetText("");
909 0 : pMEdit->SetHelpId( m_aEditHelpId );
910 : }
911 : // Test, ob vorne/hinten noch mehr Funktionen sind
912 :
913 0 : sal_Int32 nTempStart = m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 );
914 0 : rbNext = m_aFormulaHelper.GetNextFunc( aFormula, false, nTempStart );
915 0 : nTempStart = pMEdit->GetSelection().Min();
916 0 : pData->SetFStart(nTempStart);
917 0 : rbPrev = m_aFormulaHelper.GetNextFunc( aFormula, true, nTempStart );
918 : }
919 :
920 :
921 0 : void FormulaDlg_Impl::ClearAllParas()
922 : {
923 0 : DeleteArgs();
924 0 : pFuncDesc = NULL;
925 0 : pParaWin->ClearAll();
926 0 : m_pWndResult->SetText(OUString());
927 0 : m_pFtFuncName->SetText(OUString());
928 0 : FuncSelHdl(NULL);
929 :
930 0 : if (pFuncPage->IsVisible())
931 : {
932 0 : m_pFtEditName->Hide();
933 0 : m_pParaWinBox->Hide();
934 :
935 0 : m_pBtnForward->Enable(true); //@new
936 0 : m_pFtHeadLine->Show();
937 0 : m_pFtFuncName->Show();
938 0 : m_pFtFuncDesc->Show();
939 : }
940 0 : }
941 0 : OUString FormulaDlg_Impl::RepairFormula(const OUString& aFormula)
942 : {
943 0 : OUString aResult('=');
944 : try
945 : {
946 0 : UpdateTokenArray(aFormula);
947 :
948 0 : if ( m_aTokenList.getLength() )
949 : {
950 0 : const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
951 0 : const OUString sFormula(m_pHelper->getFormulaParser()->printFormula(m_aTokenList, aRefPos));
952 0 : if ( sFormula.isEmpty() || sFormula[0] != '=' )
953 0 : aResult += sFormula;
954 : else
955 0 : aResult = sFormula;
956 :
957 : }
958 : }
959 0 : catch ( const uno::Exception& e )
960 : {
961 : (void)e;
962 : SAL_WARN("formula.ui", "FormulaDlg_Impl::RepairFormula exception! " << e.Message);
963 : }
964 0 : return aResult;
965 : }
966 :
967 0 : void FormulaDlg_Impl::DoEnter(bool bOk)
968 : {
969 : // Accept input to the document or cancel
970 0 : if ( bOk)
971 : {
972 : // remove dummy arguments
973 0 : OUString aInputFormula = m_pHelper->getCurrentFormula();
974 0 : OUString aString = RepairFormula(pMEdit->GetText());
975 0 : m_pHelper->setSelection(0, aInputFormula.getLength());
976 0 : m_pHelper->setCurrentFormula(aString);
977 : }
978 :
979 0 : m_pHelper->switchBack();
980 :
981 0 : m_pHelper->dispatch(bOk,m_pBtnMatrix->IsChecked());
982 : // Clear data
983 0 : m_pHelper->deleteFormData();
984 :
985 : // Close dialog
986 0 : m_pHelper->doClose(bOk);
987 0 : }
988 :
989 :
990 0 : IMPL_LINK( FormulaDlg_Impl, BtnHdl, PushButton*, pBtn )
991 : {
992 0 : if ( pBtn == m_pBtnCancel )
993 : {
994 0 : DoEnter(false); // closes the Dialog
995 : }
996 0 : else if ( pBtn == m_pBtnEnd )
997 : {
998 0 : DoEnter(true); // closes the Dialog
999 : }
1000 0 : else if ( pBtn == m_pBtnForward )
1001 : {
1002 0 : const IFunctionDescription* pDesc =pFuncPage->GetFuncDesc( pFuncPage->GetFunction() );
1003 :
1004 0 : if(pDesc==pFuncDesc || !pFuncPage->IsVisible())
1005 0 : EditNextFunc( true );
1006 : else
1007 : {
1008 0 : DblClkHdl(pFuncPage); //new
1009 0 : m_pBtnForward->Enable(false); //new
1010 : }
1011 : }
1012 0 : else if ( pBtn == m_pBtnBackward )
1013 : {
1014 0 : bEditFlag=false;
1015 0 : m_pBtnForward->Enable(true);
1016 0 : EditNextFunc( false );
1017 0 : m_pMEFormula->Invalidate();
1018 0 : m_pMEFormula->Update();
1019 : }
1020 :
1021 :
1022 0 : return 0;
1023 : }
1024 :
1025 :
1026 :
1027 :
1028 : // Functions for 1. Page
1029 :
1030 :
1031 :
1032 :
1033 : // Handler for Listboxes
1034 :
1035 0 : IMPL_LINK_NOARG(FormulaDlg_Impl, DblClkHdl)
1036 : {
1037 0 : sal_Int32 nFunc = pFuncPage->GetFunction();
1038 :
1039 : // ex-UpdateLRUList
1040 0 : const IFunctionDescription* pDesc = pFuncPage->GetFuncDesc(nFunc);
1041 0 : m_pHelper->insertEntryToLRUList(pDesc);
1042 :
1043 0 : OUString aFuncName = pFuncPage->GetSelFunctionName() + "()";
1044 0 : m_pHelper->setCurrentFormula(aFuncName);
1045 0 : pMEdit->ReplaceSelected(aFuncName);
1046 :
1047 0 : Selection aSel=pMEdit->GetSelection();
1048 0 : aSel.Max()=aSel.Max()-1;
1049 0 : pMEdit->SetSelection(aSel);
1050 :
1051 0 : FormulaHdl(pMEdit);
1052 :
1053 0 : aSel.Min()=aSel.Max();
1054 0 : pMEdit->SetSelection(aSel);
1055 :
1056 0 : if(nArgs==0)
1057 : {
1058 0 : BtnHdl(m_pBtnBackward);
1059 : }
1060 :
1061 0 : pParaWin->SetEdFocus(0);
1062 0 : m_pBtnForward->Enable(false); //@New
1063 :
1064 0 : return 0;
1065 : }
1066 :
1067 :
1068 :
1069 : // Functions for right Page
1070 :
1071 0 : void FormulaDlg_Impl::SetData(sal_Int32 nFStart, sal_Int32 nNextFStart, sal_Int32 nNextFEnd, sal_Int32& PrivStart, sal_Int32& PrivEnd)
1072 : {
1073 : sal_Int32 nFEnd;
1074 :
1075 : // Notice and set new selection
1076 0 : m_pHelper->getSelection( nFStart, nFEnd );
1077 0 : m_pHelper->setSelection( nNextFStart, nNextFEnd );
1078 0 : if(!bEditFlag)
1079 0 : pMEdit->SetText(m_pHelper->getCurrentFormula());
1080 :
1081 :
1082 0 : m_pHelper->getSelection( PrivStart, PrivEnd);
1083 0 : if(!bEditFlag)
1084 : {
1085 0 : pMEdit->SetSelection( Selection(PrivStart, PrivEnd));
1086 0 : m_pMEFormula->UpdateOldSel();
1087 : }
1088 :
1089 0 : FormEditData* pData = m_pHelper->getFormEditData();
1090 0 : pData->SetFStart( nNextFStart );
1091 0 : pData->SetOffset( 0 );
1092 0 : pData->SetEdFocus( 0 );
1093 :
1094 0 : FillDialog();
1095 0 : }
1096 :
1097 0 : void FormulaDlg_Impl::EditThisFunc(sal_Int32 nFStart)
1098 : {
1099 0 : FormEditData* pData = m_pHelper->getFormEditData();
1100 0 : if (!pData) return;
1101 :
1102 0 : OUString aFormula = m_pHelper->getCurrentFormula();
1103 :
1104 0 : if(nFStart==NOT_FOUND)
1105 : {
1106 0 : nFStart = pData->GetFStart();
1107 : }
1108 : else
1109 : {
1110 0 : pData->SetFStart(nFStart);
1111 : }
1112 :
1113 0 : sal_Int32 nNextFStart = nFStart;
1114 0 : sal_Int32 nNextFEnd = 0;
1115 :
1116 : bool bFound;
1117 :
1118 0 : bFound = m_aFormulaHelper.GetNextFunc( aFormula, false, nNextFStart, &nNextFEnd);
1119 0 : if ( bFound )
1120 : {
1121 : sal_Int32 PrivStart, PrivEnd;
1122 0 : SetData(nFStart, nNextFStart, nNextFEnd, PrivStart, PrivEnd);
1123 0 : m_pHelper->showReference(aFormula.copy(PrivStart, PrivEnd-PrivStart));
1124 : }
1125 : else
1126 : {
1127 0 : ClearAllParas();
1128 0 : }
1129 : }
1130 :
1131 0 : void FormulaDlg_Impl::EditNextFunc( bool bForward, sal_Int32 nFStart )
1132 : {
1133 0 : FormEditData* pData = m_pHelper->getFormEditData();
1134 0 : if (!pData)
1135 0 : return;
1136 :
1137 0 : OUString aFormula = m_pHelper->getCurrentFormula();
1138 :
1139 0 : if(nFStart==NOT_FOUND)
1140 : {
1141 0 : nFStart = pData->GetFStart();
1142 : }
1143 : else
1144 : {
1145 0 : pData->SetFStart(nFStart);
1146 : }
1147 :
1148 0 : sal_Int32 nNextFStart = 0;
1149 0 : sal_Int32 nNextFEnd = 0;
1150 :
1151 : bool bFound;
1152 0 : if ( bForward )
1153 : {
1154 0 : nNextFStart = m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 );
1155 0 : bFound = m_aFormulaHelper.GetNextFunc( aFormula, false, nNextFStart, &nNextFEnd);
1156 : }
1157 : else
1158 : {
1159 0 : nNextFStart = nFStart;
1160 0 : bFound = m_aFormulaHelper.GetNextFunc( aFormula, true, nNextFStart, &nNextFEnd);
1161 : }
1162 :
1163 0 : if ( bFound )
1164 : {
1165 : sal_Int32 PrivStart, PrivEnd;
1166 0 : SetData(nFStart, nNextFStart, nNextFEnd, PrivStart, PrivEnd);
1167 0 : }
1168 : }
1169 :
1170 0 : void FormulaDlg_Impl::SaveArg( sal_uInt16 nEd )
1171 : {
1172 0 : if (nEd<nArgs)
1173 : {
1174 0 : for(sal_uInt16 i=0; i<=nEd; i++)
1175 : {
1176 0 : if ( m_aArguments[i].isEmpty() )
1177 0 : m_aArguments[i] = " ";
1178 : }
1179 0 : if(!pParaWin->GetArgument(nEd).isEmpty())
1180 0 : m_aArguments[nEd] = pParaWin->GetArgument(nEd);
1181 :
1182 0 : sal_uInt16 nClearPos=nEd+1;
1183 0 : for(sal_uInt16 i=nEd+1; i<nArgs; i++)
1184 : {
1185 0 : if( !pParaWin->GetArgument(i).isEmpty() )
1186 : {
1187 0 : nClearPos=i+1;
1188 : }
1189 : }
1190 :
1191 0 : for(sal_uInt16 i=nClearPos; i<nArgs; i++)
1192 : {
1193 0 : m_aArguments[i] = "";
1194 : }
1195 : }
1196 0 : }
1197 :
1198 0 : IMPL_LINK( FormulaDlg_Impl, FxHdl, ParaWin*, pPtr )
1199 : {
1200 0 : if(pPtr==pParaWin)
1201 : {
1202 0 : m_pBtnForward->Enable(true); //@ In order to be able to input another function.
1203 0 : m_pTabCtrl->SetCurPageId(TP_FUNCTION);
1204 :
1205 0 : OUString aUndoStr = m_pHelper->getCurrentFormula(); // it will be added before a ";"
1206 0 : FormEditData* pData = m_pHelper->getFormEditData();
1207 0 : if (!pData) return 0;
1208 :
1209 0 : sal_uInt16 nArgNo = pParaWin->GetActiveLine();
1210 0 : nEdFocus=nArgNo;
1211 :
1212 0 : SaveArg(nArgNo);
1213 0 : UpdateSelection();
1214 :
1215 0 : sal_Int32 nFormulaStrPos = pData->GetFStart();
1216 :
1217 0 : OUString aFormula = m_pHelper->getCurrentFormula();
1218 0 : sal_Int32 n1 = m_aFormulaHelper.GetArgStart( aFormula, nFormulaStrPos, nEdFocus+pData->GetOffset() );
1219 :
1220 0 : pData->SetEdFocus( nEdFocus );
1221 0 : pData->SaveValues();
1222 0 : pData->SetMode( (sal_uInt16) FORMULA_FORMDLG_FORMULA );
1223 0 : pData->SetFStart( n1 );
1224 0 : pData->SetUndoStr( aUndoStr );
1225 0 : ClearAllParas();
1226 :
1227 0 : FillDialog(false);
1228 0 : pFuncPage->SetFocus(); //There Parawin is not visible anymore
1229 : }
1230 0 : return 0;
1231 : }
1232 :
1233 0 : IMPL_LINK( FormulaDlg_Impl, ModifyHdl, ParaWin*, pPtr )
1234 : {
1235 0 : if(pPtr==pParaWin)
1236 : {
1237 0 : SaveArg(pParaWin->GetActiveLine());
1238 0 : UpdateValues();
1239 :
1240 0 : UpdateSelection();
1241 0 : CalcStruct(pMEdit->GetText());
1242 : }
1243 0 : return 0;
1244 : }
1245 :
1246 0 : IMPL_LINK_NOARG(FormulaDlg_Impl, FormulaHdl)
1247 : {
1248 :
1249 0 : FormEditData* pData = m_pHelper->getFormEditData();
1250 0 : if (!pData) return 0;
1251 :
1252 0 : bEditFlag=true;
1253 0 : OUString aInputFormula=m_pHelper->getCurrentFormula();
1254 0 : OUString aString=pMEdit->GetText();
1255 :
1256 0 : Selection aSel = pMEdit->GetSelection();
1257 0 : sal_Int32 nTest = 0;
1258 :
1259 0 : if(aString.isEmpty()) //in case everything was cleared
1260 : {
1261 0 : aString += "=";
1262 0 : pMEdit->SetText(aString);
1263 0 : aSel .Min() = 1;
1264 0 : aSel .Max() = 1;
1265 0 : pMEdit->SetSelection(aSel);
1266 : }
1267 0 : else if(aString[nTest]!='=') //in case it's replaced;
1268 : {
1269 0 : aString = "=" + aString;
1270 0 : pMEdit->SetText(aString);
1271 0 : aSel .Min() += 1;
1272 0 : aSel .Max() += 1;
1273 0 : pMEdit->SetSelection(aSel);
1274 : }
1275 :
1276 :
1277 0 : m_pHelper->setSelection(0, aInputFormula.getLength());
1278 0 : m_pHelper->setCurrentFormula(aString);
1279 0 : m_pHelper->setSelection(aSel.Min(), aSel.Max());
1280 :
1281 0 : sal_Int32 nPos = aSel.Min()-1;
1282 :
1283 0 : OUString aStrResult;
1284 :
1285 0 : if ( CalcValue(m_pHelper->getCurrentFormula(), aStrResult ) )
1286 0 : m_pWndFormResult->SetText( aStrResult );
1287 : else
1288 : {
1289 0 : aStrResult = "";
1290 0 : m_pWndFormResult->SetText( aStrResult );
1291 : }
1292 0 : CalcStruct(aString);
1293 :
1294 0 : nPos=GetFunctionPos(nPos);
1295 :
1296 0 : if(nPos<aSel.Min()-1)
1297 : {
1298 0 : sal_Int32 nPos1 = aString.indexOf('(',nPos);
1299 0 : EditNextFunc( false, nPos1);
1300 : }
1301 : else
1302 : {
1303 0 : ClearAllParas();
1304 : }
1305 :
1306 0 : m_pHelper->setSelection(aSel.Min(), aSel.Max());
1307 0 : bEditFlag=false;
1308 0 : return 0;
1309 : }
1310 :
1311 0 : IMPL_LINK_NOARG(FormulaDlg_Impl, FormulaCursorHdl)
1312 : {
1313 0 : FormEditData* pData = m_pHelper->getFormEditData();
1314 0 : if (!pData) return 0;
1315 0 : sal_Int32 nFStart = pData->GetFStart();
1316 :
1317 0 : bEditFlag=true;
1318 :
1319 0 : OUString aString=pMEdit->GetText();
1320 :
1321 0 : Selection aSel =pMEdit->GetSelection();
1322 0 : m_pHelper->setSelection(aSel.Min(), aSel.Max());
1323 :
1324 0 : if(aSel.Min()==0)
1325 : {
1326 0 : aSel.Min()=1;
1327 0 : pMEdit->SetSelection(aSel);
1328 : }
1329 :
1330 0 : if(aSel.Min() != aString.getLength())
1331 : {
1332 0 : sal_Int32 nPos = aSel.Min();
1333 :
1334 0 : nFStart=GetFunctionPos(nPos - 1);
1335 :
1336 0 : if(nFStart<nPos)
1337 : {
1338 0 : sal_Int32 nPos1 = m_aFormulaHelper.GetFunctionEnd(aString,nFStart);
1339 :
1340 0 : if(nPos1>nPos)
1341 : {
1342 0 : EditThisFunc(nFStart);
1343 : }
1344 : else
1345 : {
1346 0 : sal_Int32 n = nPos;
1347 0 : short nCount=1;
1348 0 : while(n>0)
1349 : {
1350 0 : if(aString[n]==')')
1351 0 : nCount++;
1352 0 : else if(aString[n]=='(')
1353 0 : nCount--;
1354 0 : if(nCount==0) break;
1355 0 : n--;
1356 : }
1357 0 : if(nCount==0)
1358 : {
1359 0 : nFStart=m_aFormulaHelper.GetFunctionStart(aString, n, true);
1360 0 : EditThisFunc(nFStart);
1361 : }
1362 : else
1363 : {
1364 0 : ClearAllParas();
1365 : }
1366 : }
1367 : }
1368 : else
1369 : {
1370 0 : ClearAllParas();
1371 : }
1372 : }
1373 0 : m_pHelper->setSelection(aSel.Min(), aSel.Max());
1374 :
1375 0 : bEditFlag=false;
1376 0 : return 0;
1377 : }
1378 :
1379 0 : void FormulaDlg_Impl::UpdateSelection()
1380 : {
1381 0 : m_pHelper->setSelection(aFuncSel.Min(), aFuncSel.Max());
1382 0 : m_pHelper->setCurrentFormula( pFuncDesc->getFormula( m_aArguments ) );
1383 0 : pMEdit->SetText(m_pHelper->getCurrentFormula());
1384 : sal_Int32 PrivStart, PrivEnd;
1385 0 : m_pHelper->getSelection( PrivStart, PrivEnd);
1386 0 : aFuncSel.Min() = PrivStart;
1387 0 : aFuncSel.Max() = PrivEnd;
1388 :
1389 0 : nArgs = pFuncDesc->getSuppressedArgumentCount();
1390 :
1391 0 : OUString aFormula=pMEdit->GetText();
1392 0 : sal_Int32 nArgPos=m_aFormulaHelper.GetArgStart( aFormula,PrivStart,0);
1393 :
1394 0 : sal_uInt16 nPos=pParaWin->GetActiveLine();
1395 :
1396 0 : for(sal_uInt16 i=0;i<nPos;i++)
1397 : {
1398 0 : nArgPos += (m_aArguments[i].getLength() + 1);
1399 : }
1400 0 : sal_Int32 nLength= m_aArguments[nPos].getLength();
1401 :
1402 0 : Selection aSel(nArgPos,nArgPos+nLength);
1403 0 : m_pHelper->setSelection((sal_uInt16)nArgPos,(sal_uInt16)(nArgPos+nLength));
1404 0 : pMEdit->SetSelection(aSel);
1405 0 : m_pMEFormula->UpdateOldSel();
1406 0 : }
1407 :
1408 0 : ::std::pair<RefButton*,RefEdit*> FormulaDlg_Impl::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton )
1409 : {
1410 : //because its initially hidden, give it its optimal
1411 : //size so clicking the refbutton has an initial
1412 : //size to work work when retro-fitting this to .ui
1413 0 : m_pEdRef->SetSizePixel(m_pEdRef->GetOptimalSize());
1414 0 : m_pEdRef->Show();
1415 0 : pTheRefEdit = pEdit;
1416 0 : pTheRefButton = pButton;
1417 :
1418 0 : if( pTheRefEdit )
1419 : {
1420 0 : m_pEdRef->SetRefString( pTheRefEdit->GetText() );
1421 0 : m_pEdRef->SetSelection( pTheRefEdit->GetSelection() );
1422 0 : m_pEdRef->SetHelpId( pTheRefEdit->GetHelpId() );
1423 0 : m_pEdRef->SetUniqueId( pTheRefEdit->GetUniqueId() );
1424 : }
1425 :
1426 0 : m_pRefBtn->Show( pButton != NULL );
1427 :
1428 0 : ::std::pair<RefButton*,RefEdit*> aPair;
1429 0 : aPair.first = pButton ? m_pRefBtn : NULL;
1430 0 : aPair.second = m_pEdRef;
1431 0 : return aPair;
1432 : }
1433 0 : void FormulaDlg_Impl::RefInputStartAfter( RefEdit* /*pEdit*/, RefButton* /*pButton*/ )
1434 : {
1435 0 : m_pRefBtn->SetEndImage();
1436 :
1437 0 : if( pTheRefEdit )
1438 : {
1439 0 : OUString aStr = aTitle2 + " " + m_pFtEditName->GetText() + "( ";
1440 :
1441 0 : if( pParaWin->GetActiveLine() > 0 )
1442 0 : aStr += "...; ";
1443 0 : aStr += pParaWin->GetActiveArgName();
1444 0 : if( pParaWin->GetActiveLine() + 1 < nArgs )
1445 0 : aStr += "; ...";
1446 0 : aStr += " )";
1447 :
1448 0 : m_pParent->SetText( MnemonicGenerator::EraseAllMnemonicChars( aStr ) );
1449 : }
1450 0 : }
1451 0 : void FormulaDlg_Impl::RefInputDoneAfter( bool bForced )
1452 : {
1453 0 : m_pRefBtn->SetStartImage();
1454 0 : if( bForced || !m_pRefBtn->IsVisible() )
1455 : {
1456 0 : m_pEdRef->Hide();
1457 0 : m_pRefBtn->Hide();
1458 0 : if( pTheRefEdit )
1459 : {
1460 0 : pTheRefEdit->SetRefString( m_pEdRef->GetText() );
1461 0 : pTheRefEdit->GrabFocus();
1462 :
1463 0 : if( pTheRefButton )
1464 0 : pTheRefButton->SetStartImage();
1465 :
1466 0 : sal_uInt16 nPrivActiv = pParaWin->GetActiveLine();
1467 0 : pParaWin->SetArgument( nPrivActiv, m_pEdRef->GetText() );
1468 0 : ModifyHdl( pParaWin );
1469 0 : pTheRefEdit = NULL;
1470 : }
1471 0 : m_pParent->SetText( aTitle1 );
1472 : }
1473 0 : }
1474 0 : RefEdit* FormulaDlg_Impl::GetCurrRefEdit()
1475 : {
1476 0 : return m_pEdRef->IsVisible() ? m_pEdRef : pParaWin->GetActiveEdit();
1477 : }
1478 0 : void FormulaDlg_Impl::Update()
1479 : {
1480 0 : FormEditData* pData = m_pHelper->getFormEditData();
1481 0 : const OUString sExpression = pMEdit->GetText();
1482 0 : aOldFormula = "";
1483 0 : UpdateTokenArray(sExpression);
1484 0 : FormulaCursorHdl(m_pMEFormula);
1485 0 : CalcStruct(sExpression);
1486 0 : if(pData->GetMode() == FORMULA_FORMDLG_FORMULA)
1487 0 : m_pTabCtrl->SetCurPageId(TP_FUNCTION);
1488 : else
1489 0 : m_pTabCtrl->SetCurPageId(TP_STRUCT);
1490 0 : m_pBtnMatrix->Check(pData->GetMatrixFlag());
1491 0 : }
1492 0 : void FormulaDlg_Impl::Update(const OUString& _sExp)
1493 : {
1494 0 : CalcStruct(_sExp);
1495 0 : FillDialog();
1496 0 : FuncSelHdl(NULL);
1497 0 : }
1498 0 : void FormulaDlg_Impl::SetMeText(const OUString& _sText)
1499 : {
1500 0 : FormEditData* pData = m_pHelper->getFormEditData();
1501 0 : pMEdit->SetText(_sText);
1502 0 : pMEdit->SetSelection( pData->GetSelection());
1503 0 : m_pMEFormula->UpdateOldSel();
1504 0 : }
1505 0 : FormulaDlgMode FormulaDlg_Impl::SetMeText(const OUString& _sText, sal_Int32 PrivStart, sal_Int32 PrivEnd, bool bMatrix, bool _bSelect, bool _bUpdate)
1506 : {
1507 0 : FormulaDlgMode eMode = FORMULA_FORMDLG_FORMULA;
1508 0 : if(!bEditFlag)
1509 0 : pMEdit->SetText(_sText);
1510 :
1511 0 : if ( _bSelect || !bEditFlag )
1512 0 : pMEdit->SetSelection( Selection(PrivStart, PrivEnd));
1513 0 : if ( _bUpdate )
1514 : {
1515 0 : m_pMEFormula->UpdateOldSel();
1516 0 : pMEdit->Invalidate();
1517 0 : m_pHelper->showReference(pMEdit->GetSelected());
1518 0 : eMode = FORMULA_FORMDLG_EDIT;
1519 :
1520 0 : m_pBtnMatrix->Check( bMatrix );
1521 : } // if ( _bUpdate )
1522 0 : return eMode;
1523 : }
1524 0 : bool FormulaDlg_Impl::CheckMatrix(OUString& aFormula)
1525 : {
1526 0 : pMEdit->GrabFocus();
1527 0 : sal_Int32 nLen = aFormula.getLength();
1528 : bool bMatrix = nLen > 3 // Matrix-Formula
1529 0 : && aFormula[0] == '{'
1530 0 : && aFormula[1] == '='
1531 0 : && aFormula[nLen-1] == '}';
1532 0 : if ( bMatrix )
1533 : {
1534 0 : aFormula = aFormula.copy( 1, aFormula.getLength()-2 );
1535 0 : m_pBtnMatrix->Check( bMatrix );
1536 0 : m_pBtnMatrix->Disable();
1537 : } // if ( bMatrix )
1538 :
1539 0 : m_pTabCtrl->SetCurPageId(TP_STRUCT);
1540 0 : return bMatrix;
1541 : }
1542 0 : IMPL_LINK_NOARG(FormulaDlg_Impl, StructSelHdl)
1543 : {
1544 0 : bStructUpdate=false;
1545 0 : if(pStructPage->IsVisible()) m_pBtnForward->Enable(false); //@New
1546 :
1547 0 : bStructUpdate=true;
1548 0 : return 0;
1549 : }
1550 0 : IMPL_LINK_NOARG(FormulaDlg_Impl, MatrixHdl)
1551 : {
1552 0 : bUserMatrixFlag=true;
1553 0 : return 0;
1554 : }
1555 :
1556 0 : IMPL_LINK_NOARG(FormulaDlg_Impl, FuncSelHdl)
1557 : {
1558 0 : sal_Int32 nCat = pFuncPage->GetCategory();
1559 0 : if ( nCat == LISTBOX_ENTRY_NOTFOUND ) nCat = 0;
1560 0 : sal_Int32 nFunc = pFuncPage->GetFunction();
1561 0 : if ( nFunc == LISTBOX_ENTRY_NOTFOUND ) nFunc = 0;
1562 :
1563 0 : if ( (pFuncPage->GetFunctionEntryCount() > 0)
1564 0 : && (pFuncPage->GetFunction() != LISTBOX_ENTRY_NOTFOUND) )
1565 : {
1566 0 : const IFunctionDescription* pDesc =pFuncPage->GetFuncDesc( pFuncPage->GetFunction() );
1567 :
1568 0 : if(pDesc!=pFuncDesc) m_pBtnForward->Enable(true); //new
1569 :
1570 0 : if (pDesc)
1571 : {
1572 0 : pDesc->initArgumentInfo(); // full argument info is needed
1573 :
1574 0 : OUString aSig = pDesc->getSignature();
1575 0 : m_pFtHeadLine->SetText( pDesc->getFunctionName() );
1576 0 : m_pFtFuncName->SetText( aSig );
1577 0 : m_pFtFuncDesc->SetText( pDesc->getDescription() );
1578 : }
1579 : }
1580 : else
1581 : {
1582 0 : m_pFtHeadLine->SetText( OUString() );
1583 0 : m_pFtFuncName->SetText( OUString() );
1584 0 : m_pFtFuncDesc->SetText( OUString() );
1585 : }
1586 0 : return 0;
1587 : }
1588 :
1589 0 : void FormulaDlg_Impl::UpdateParaWin(const Selection& _rSelection, const OUString& _sRefStr)
1590 : {
1591 0 : Selection theSel = _rSelection;
1592 0 : m_pEdRef->ReplaceSelected( _sRefStr );
1593 0 : theSel.Max() = theSel.Min() + _sRefStr.getLength();
1594 0 : m_pEdRef->SetSelection( theSel );
1595 :
1596 :
1597 : // Manual Update of the results' fields:
1598 :
1599 0 : sal_uInt16 nPrivActiv = pParaWin->GetActiveLine();
1600 0 : pParaWin->SetArgument(nPrivActiv,m_pEdRef->GetText());
1601 0 : pParaWin->UpdateParas();
1602 :
1603 0 : Edit* pEd = GetCurrRefEdit();
1604 0 : if( pEd != NULL )
1605 0 : pEd->SetSelection( theSel );
1606 :
1607 0 : pParaWin->SetRefMode(false);
1608 0 : }
1609 0 : bool FormulaDlg_Impl::UpdateParaWin(Selection& _rSelection)
1610 : {
1611 0 : pParaWin->SetRefMode(true);
1612 :
1613 0 : OUString aStrEd;
1614 0 : Edit* pEd = GetCurrRefEdit();
1615 0 : if(pEd!=NULL && pTheRefEdit==NULL)
1616 : {
1617 0 : _rSelection=pEd->GetSelection();
1618 0 : _rSelection.Justify();
1619 0 : aStrEd=pEd->GetText();
1620 0 : m_pEdRef->SetRefString(aStrEd);
1621 0 : m_pEdRef->SetSelection( _rSelection );
1622 : }
1623 : else
1624 : {
1625 0 : _rSelection=m_pEdRef->GetSelection();
1626 0 : _rSelection.Justify();
1627 0 : aStrEd= m_pEdRef->GetText();
1628 : }
1629 0 : return pTheRefEdit == NULL;
1630 : }
1631 :
1632 0 : void FormulaDlg_Impl::SetEdSelection()
1633 : {
1634 0 : Edit* pEd = GetCurrRefEdit()/*aScParaWin.GetActiveEdit()*/;
1635 0 : if( pEd )
1636 : {
1637 0 : Selection theSel = m_pEdRef->GetSelection();
1638 : // Edit may have the focus -> call ModifyHdl in addition
1639 : // to what's happening in GetFocus
1640 0 : pEd->GetModifyHdl().Call(pEd);
1641 0 : pEd->GrabFocus();
1642 0 : pEd->SetSelection(theSel);
1643 : } // if( pEd )
1644 0 : }
1645 :
1646 0 : FormulaModalDialog::FormulaModalDialog( vcl::Window* pParent
1647 : , bool _bSupportFunctionResult
1648 : , bool _bSupportResult
1649 : , bool _bSupportMatrix
1650 : , IFunctionManager* _pFunctionMgr
1651 : , IControlReferenceHandler* _pDlg )
1652 : : ModalDialog(pParent, "FormulaDialog", "formula/ui/formuladialog.ui")
1653 : , m_pImpl(new FormulaDlg_Impl(this,_bSupportFunctionResult,
1654 0 : _bSupportResult, _bSupportMatrix, this, _pFunctionMgr, _pDlg))
1655 : {
1656 0 : SetText(m_pImpl->aTitle1);
1657 0 : }
1658 :
1659 0 : FormulaModalDialog::~FormulaModalDialog() {}
1660 :
1661 0 : void FormulaModalDialog::Update(const OUString& _sExp)
1662 : {
1663 0 : m_pImpl->Update(_sExp);
1664 0 : }
1665 :
1666 0 : void FormulaModalDialog::SetMeText(const OUString& _sText)
1667 : {
1668 0 : m_pImpl->SetMeText(_sText);
1669 0 : }
1670 :
1671 0 : bool FormulaModalDialog::CheckMatrix(OUString& aFormula)
1672 : {
1673 0 : return m_pImpl->CheckMatrix(aFormula);
1674 : }
1675 :
1676 0 : void FormulaModalDialog::Update()
1677 : {
1678 0 : m_pImpl->Update();
1679 0 : }
1680 :
1681 0 : ::std::pair<RefButton*,RefEdit*> FormulaModalDialog::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton )
1682 : {
1683 0 : return m_pImpl->RefInputStartBefore( pEdit, pButton );
1684 : }
1685 :
1686 0 : void FormulaModalDialog::RefInputStartAfter( RefEdit* pEdit, RefButton* pButton )
1687 : {
1688 0 : m_pImpl->RefInputStartAfter( pEdit, pButton );
1689 0 : }
1690 0 : void FormulaModalDialog::RefInputDoneAfter( bool bForced )
1691 : {
1692 0 : m_pImpl->RefInputDoneAfter( bForced );
1693 0 : }
1694 :
1695 0 : void FormulaModalDialog::SetFocusWin(vcl::Window *pWin,const OString& nUniqueId)
1696 : {
1697 0 : if(pWin->GetUniqueId()==nUniqueId)
1698 : {
1699 0 : pWin->GrabFocus();
1700 : }
1701 : else
1702 : {
1703 0 : sal_uInt16 nCount=pWin->GetChildCount();
1704 :
1705 0 : for(sal_uInt16 i=0;i<nCount;i++)
1706 : {
1707 0 : vcl::Window* pChild=pWin->GetChild(i);
1708 0 : SetFocusWin(pChild,nUniqueId);
1709 : }
1710 : }
1711 0 : }
1712 :
1713 0 : bool FormulaModalDialog::PreNotify( NotifyEvent& rNEvt )
1714 : {
1715 0 : m_pImpl->PreNotify( rNEvt );
1716 :
1717 0 : return ModalDialog::PreNotify(rNEvt);
1718 : }
1719 :
1720 0 : void FormulaModalDialog::StoreFormEditData(FormEditData* pData)
1721 : {
1722 0 : m_pImpl->StoreFormEditData(pData);
1723 0 : }
1724 :
1725 :
1726 : // Initialisation / General functions for Dialog
1727 :
1728 0 : FormulaDlg::FormulaDlg( SfxBindings* pB, SfxChildWindow* pCW,
1729 : vcl::Window* pParent
1730 : , bool _bSupportFunctionResult
1731 : , bool _bSupportResult
1732 : , bool _bSupportMatrix
1733 : , IFunctionManager* _pFunctionMgr, IControlReferenceHandler* _pDlg ) :
1734 : SfxModelessDialog( pB, pCW, pParent, "FormulaDialog", "formula/ui/formuladialog.ui" ),
1735 : m_pImpl( new FormulaDlg_Impl(this, _bSupportFunctionResult
1736 : , _bSupportResult
1737 : , _bSupportMatrix
1738 0 : , this, _pFunctionMgr, _pDlg))
1739 : {
1740 : //undo SfxModelessDialog HelpId clear hack
1741 0 : reverseUniqueHelpIdHack(*this);
1742 0 : SetText(m_pImpl->aTitle1);
1743 0 : }
1744 :
1745 0 : FormulaDlg::~FormulaDlg() {}
1746 :
1747 0 : void FormulaDlg::Update(const OUString& _sExp)
1748 : {
1749 0 : m_pImpl->Update(_sExp);
1750 0 : }
1751 :
1752 :
1753 0 : void FormulaDlg::SetMeText(const OUString& _sText)
1754 : {
1755 0 : m_pImpl->SetMeText(_sText);
1756 0 : }
1757 :
1758 0 : FormulaDlgMode FormulaDlg::SetMeText(const OUString& _sText, sal_Int32 PrivStart, sal_Int32 PrivEnd, bool bMatrix, bool _bSelect, bool _bUpdate)
1759 : {
1760 0 : return m_pImpl->SetMeText(_sText,PrivStart, PrivEnd,bMatrix,_bSelect,_bUpdate);
1761 : }
1762 :
1763 0 : bool FormulaDlg::CheckMatrix(OUString& aFormula)
1764 : {
1765 0 : return m_pImpl->CheckMatrix(aFormula);
1766 : }
1767 :
1768 0 : OUString FormulaDlg::GetMeText() const
1769 : {
1770 0 : return m_pImpl->pMEdit->GetText();
1771 : }
1772 :
1773 0 : void FormulaDlg::Update()
1774 : {
1775 0 : m_pImpl->Update();
1776 0 : m_pImpl->aTimer.SetTimeout(200);
1777 0 : m_pImpl->aTimer.SetTimeoutHdl(LINK( this, FormulaDlg, UpdateFocusHdl));
1778 0 : m_pImpl->aTimer.Start();
1779 0 : }
1780 :
1781 0 : void FormulaDlg::DoEnter(bool _bOk)
1782 : {
1783 0 : m_pImpl->DoEnter(_bOk);
1784 0 : }
1785 0 : ::std::pair<RefButton*,RefEdit*> FormulaDlg::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton )
1786 : {
1787 0 : return m_pImpl->RefInputStartBefore( pEdit, pButton );
1788 : }
1789 0 : void FormulaDlg::RefInputStartAfter( RefEdit* pEdit, RefButton* pButton )
1790 : {
1791 0 : m_pImpl->RefInputStartAfter( pEdit, pButton );
1792 0 : }
1793 0 : void FormulaDlg::RefInputDoneAfter( bool bForced )
1794 : {
1795 0 : m_pImpl->RefInputDoneAfter( bForced );
1796 0 : }
1797 :
1798 0 : void FormulaDlg::SetFocusWin(vcl::Window *pWin,const OString& nUniqueId)
1799 : {
1800 0 : if(pWin->GetUniqueId()==nUniqueId)
1801 : {
1802 0 : pWin->GrabFocus();
1803 : }
1804 : else
1805 : {
1806 0 : sal_uInt16 nCount=pWin->GetChildCount();
1807 :
1808 0 : for(sal_uInt16 i=0;i<nCount;i++)
1809 : {
1810 0 : vcl::Window* pChild=pWin->GetChild(i);
1811 0 : SetFocusWin(pChild,nUniqueId);
1812 : }
1813 : }
1814 0 : }
1815 :
1816 :
1817 0 : bool FormulaDlg::PreNotify( NotifyEvent& rNEvt )
1818 : {
1819 0 : m_pImpl->PreNotify( rNEvt );
1820 0 : return SfxModelessDialog::PreNotify(rNEvt);
1821 : }
1822 :
1823 0 : void FormulaDlg::disableOk()
1824 : {
1825 0 : m_pImpl->m_pBtnEnd->Disable();
1826 0 : }
1827 :
1828 0 : void FormulaDlg::StoreFormEditData(FormEditData* pData)
1829 : {
1830 0 : m_pImpl->StoreFormEditData(pData);
1831 0 : }
1832 :
1833 :
1834 0 : const IFunctionDescription* FormulaDlg::getCurrentFunctionDescription() const
1835 : {
1836 : SAL_WARN_IF( (m_pImpl->pFuncDesc && m_pImpl->pFuncDesc->getSuppressedArgumentCount() != m_pImpl->nArgs),
1837 : "formula.ui", "FormulaDlg::getCurrentFunctionDescription: getSuppressedArgumentCount " <<
1838 : m_pImpl->pFuncDesc->getSuppressedArgumentCount() << " != nArgs " << m_pImpl->nArgs << " for " <<
1839 : m_pImpl->pFuncDesc->getFunctionName());
1840 0 : return m_pImpl->pFuncDesc;
1841 : }
1842 :
1843 0 : void FormulaDlg::UpdateParaWin(const Selection& _rSelection,const OUString& _sRefStr)
1844 : {
1845 0 : m_pImpl->UpdateParaWin(_rSelection,_sRefStr);
1846 0 : }
1847 0 : bool FormulaDlg::UpdateParaWin(Selection& _rSelection)
1848 : {
1849 0 : return m_pImpl->UpdateParaWin(_rSelection);
1850 : }
1851 :
1852 0 : RefEdit* FormulaDlg::GetActiveEdit()
1853 : {
1854 0 : return m_pImpl->pParaWin->GetActiveEdit();
1855 : }
1856 :
1857 0 : const FormulaHelper& FormulaDlg::GetFormulaHelper() const
1858 : {
1859 0 : return m_pImpl->GetFormulaHelper();
1860 : }
1861 :
1862 0 : void FormulaDlg::SetEdSelection()
1863 : {
1864 0 : m_pImpl->SetEdSelection();
1865 0 : }
1866 0 : IMPL_LINK_NOARG(FormulaDlg, UpdateFocusHdl)
1867 : {
1868 0 : FormEditData* pData = m_pImpl->m_pHelper->getFormEditData();
1869 :
1870 0 : if (pData) // won't be destroyed via Close
1871 : {
1872 0 : m_pImpl->m_pHelper->setReferenceInput(pData);
1873 0 : OString nUniqueId(pData->GetUniqueId());
1874 0 : SetFocusWin(this,nUniqueId);
1875 : }
1876 0 : return 0;
1877 : }
1878 :
1879 :
1880 0 : void FormEditData::SaveValues()
1881 : {
1882 0 : FormEditData* pTemp = new FormEditData(*this);
1883 :
1884 0 : Reset();
1885 0 : pParent = pTemp;
1886 0 : }
1887 :
1888 0 : void FormEditData::Reset()
1889 : {
1890 0 : pParent = NULL;
1891 0 : nMode = 0;
1892 0 : nFStart = 0;
1893 0 : nCatSel = 1; //! oder 0 (zuletzt benutzte)
1894 0 : nFuncSel = 0;
1895 0 : nOffset = 0;
1896 0 : nEdFocus = 0;
1897 0 : bMatrix = false;
1898 0 : aUniqueId=OString();
1899 0 : aSelection.Min()=0;
1900 0 : aSelection.Max()=0;
1901 0 : aUndoStr = "";
1902 0 : }
1903 :
1904 0 : const FormEditData& FormEditData::operator=( const FormEditData& r )
1905 : {
1906 0 : pParent = r.pParent;
1907 0 : nMode = r.nMode;
1908 0 : nFStart = r.nFStart;
1909 0 : nCatSel = r.nCatSel;
1910 0 : nFuncSel = r.nFuncSel;
1911 0 : nOffset = r.nOffset;
1912 0 : nEdFocus = r.nEdFocus;
1913 0 : aUndoStr = r.aUndoStr;
1914 0 : bMatrix = r.bMatrix ;
1915 0 : aUniqueId = r.aUniqueId;
1916 0 : aSelection = r.aSelection;
1917 0 : return *this;
1918 : }
1919 :
1920 0 : FormEditData::FormEditData()
1921 : {
1922 0 : Reset();
1923 0 : }
1924 :
1925 0 : FormEditData::~FormEditData()
1926 : {
1927 0 : delete pParent;
1928 0 : }
1929 :
1930 0 : FormEditData::FormEditData( const FormEditData& r )
1931 : {
1932 0 : *this = r;
1933 0 : }
1934 :
1935 :
1936 276 : } // formula
1937 :
1938 :
1939 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
