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 : #include <vcl/idle.hxx>
32 :
33 : #include <svtools/stdctrl.hxx>
34 : #include <svtools/svmedit.hxx>
35 : #include <svtools/treelistbox.hxx>
36 : #include <svl/stritem.hxx>
37 : #include <svl/zforlist.hxx>
38 : #include <svl/eitem.hxx>
39 :
40 : #include <unotools/charclass.hxx>
41 : #include <tools/diagnose_ex.h>
42 :
43 : #include "formdlgs.hrc"
44 : #include "funcpage.hxx"
45 : #include "formula/formula.hxx"
46 : #include "formula/IFunctionDescription.hxx"
47 : #include "formula/FormulaCompiler.hxx"
48 : #include "formula/token.hxx"
49 : #include "formula/tokenarray.hxx"
50 : #include "formula/formdata.hxx"
51 : #include "formula/formulahelper.hxx"
52 : #include "structpg.hxx"
53 : #include "parawin.hxx"
54 : #include "ModuleHelper.hxx"
55 : #include "ForResId.hrc"
56 : #include <com/sun/star/sheet/FormulaToken.hpp>
57 : #include <com/sun/star/sheet/FormulaLanguage.hpp>
58 : #include <com/sun/star/sheet/FormulaMapGroup.hpp>
59 : #include <com/sun/star/sheet/FormulaMapGroupSpecialOffset.hpp>
60 : #include <com/sun/star/beans/XPropertySet.hpp>
61 : #include <boost/ref.hpp>
62 : #include <boost/shared_ptr.hpp>
63 : #include <comphelper/processfactory.hxx>
64 : #include <comphelper/string.hxx>
65 : #include <map>
66 :
67 : #define TOKEN_OPEN 0
68 : #define TOKEN_CLOSE 1
69 : #define TOKEN_SEP 2
70 : namespace formula
71 : {
72 : using namespace ::com::sun::star;
73 :
74 : class FormulaDlg_Impl
75 : {
76 : public:
77 : ::std::pair<RefButton*,RefEdit*>
78 : RefInputStartBefore( RefEdit* pEdit, RefButton* pButton );
79 : void RefInputStartAfter( RefEdit* pEdit, RefButton* pButton );
80 : void RefInputDoneAfter( bool bForced );
81 : bool CalcValue( const OUString& rStrExp, OUString& rStrResult );
82 : bool CalcStruct( const OUString& rStrExp);
83 : void UpdateValues();
84 : void DeleteArgs();
85 : sal_Int32 GetFunctionPos(sal_Int32 nPos);
86 : void ClearAllParas();
87 :
88 : void MakeTree(IStructHelper* _pTree,SvTreeListEntry* pParent,FormulaToken* _pToken,long Count);
89 : void fillTree(IStructHelper* _pTree);
90 : void UpdateTokenArray( const OUString& rStrExp);
91 : OUString RepairFormula(const OUString& aFormula);
92 : void FillDialog(bool nFlag=true);
93 : void EditNextFunc( bool bForward, sal_Int32 nFStart=NOT_FOUND );
94 : void EditThisFunc(sal_Int32 nFStart);
95 :
96 : void StoreFormEditData(FormEditData* pEditData);
97 :
98 : void Update();
99 : void Update(const OUString& _sExp);
100 :
101 : void SaveArg( sal_uInt16 nEd );
102 : void UpdateSelection();
103 : void DoEnter( bool bOk );
104 : void FillListboxes();
105 : void FillControls(bool &rbNext, bool &rbPrev);
106 :
107 : FormulaDlgMode SetMeText(const OUString& _sText, sal_Int32 PrivStart, sal_Int32 PrivEnd, bool bMatrix, bool _bSelect, bool _bUpdate);
108 : void SetMeText(const OUString& _sText);
109 : bool CheckMatrix(OUString& aFormula /*IN/OUT*/);
110 :
111 : void SetEdSelection();
112 :
113 : bool UpdateParaWin(Selection& _rSelection);
114 : void UpdateParaWin(const Selection& _rSelection,const OUString& _sRefStr);
115 :
116 : void SetData(sal_Int32 nFStart, sal_Int32 nNextFStart, sal_Int32 nNextFEnd, sal_Int32& PrivStart, sal_Int32& PrivEnd);
117 : void PreNotify( NotifyEvent& rNEvt );
118 :
119 : RefEdit* GetCurrRefEdit();
120 :
121 0 : const FormulaHelper& GetFormulaHelper() const { return m_aFormulaHelper;}
122 : uno::Reference< sheet::XFormulaOpCodeMapper > GetFormulaOpCodeMapper() const;
123 :
124 : DECL_LINK( ModifyHdl, ParaWin* );
125 : DECL_LINK( FxHdl, ParaWin* );
126 :
127 : DECL_LINK(MatrixHdl, void *);
128 : DECL_LINK(FormulaHdl, void *);
129 : DECL_LINK(FormulaCursorHdl, void *);
130 : DECL_LINK( BtnHdl, PushButton* );
131 : DECL_LINK(DblClkHdl, void *);
132 : DECL_LINK(FuncSelHdl, void *);
133 : DECL_LINK(StructSelHdl, void *);
134 : public:
135 : mutable uno::Reference< sheet::XFormulaOpCodeMapper> m_xOpCodeMapper;
136 : uno::Sequence< sheet::FormulaToken > m_aTokenList;
137 : ::std::unique_ptr<FormulaTokenArray> m_pTokenArray;
138 : mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aSpecialOpCodes;
139 : mutable const sheet::FormulaOpCodeMapEntry* m_pSpecialOpCodesEnd;
140 : mutable uno::Sequence< sheet::FormulaToken > m_aSeparatorsOpCodes;
141 : mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aFunctionOpCodes;
142 : mutable const sheet::FormulaOpCodeMapEntry* m_pFunctionOpCodesEnd;
143 : mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aUnaryOpCodes;
144 : mutable const sheet::FormulaOpCodeMapEntry* m_pUnaryOpCodesEnd;
145 : mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aBinaryOpCodes;
146 : mutable const sheet::FormulaOpCodeMapEntry* m_pBinaryOpCodesEnd;
147 : ::std::map<FormulaToken*,sheet::FormulaToken> m_aTokenMap;
148 : IFormulaEditorHelper* m_pHelper;
149 : VclPtr<Dialog> m_pParent;
150 : IControlReferenceHandler* m_pDlg;
151 : VclPtr<TabControl> m_pTabCtrl;
152 : VclPtr<VclVBox> m_pParaWinBox;
153 : VclPtr<ParaWin> pParaWin;
154 : VclPtr<FixedText> m_pFtHeadLine;
155 : VclPtr<FixedText> m_pFtFuncName;
156 : VclPtr<FixedText> m_pFtFuncDesc;
157 :
158 : VclPtr<FixedText> m_pFtEditName;
159 :
160 : VclPtr<FixedText> m_pFtResult;
161 : VclPtr<Edit> m_pWndResult;
162 :
163 : VclPtr<FixedText> m_pFtFormula;
164 : VclPtr<EditBox> m_pMEFormula;
165 :
166 : VclPtr<CheckBox> m_pBtnMatrix;
167 : VclPtr<CancelButton> m_pBtnCancel;
168 :
169 : VclPtr<PushButton> m_pBtnBackward;
170 : VclPtr<PushButton> m_pBtnForward;
171 : VclPtr<OKButton> m_pBtnEnd;
172 :
173 : VclPtr<RefEdit> m_pEdRef;
174 : VclPtr<RefButton> m_pRefBtn;
175 :
176 : VclPtr<FixedText> m_pFtFormResult;
177 : VclPtr<Edit> m_pWndFormResult;
178 :
179 : VclPtr<RefEdit> pTheRefEdit;
180 : VclPtr<RefButton> pTheRefButton;
181 : VclPtr<FuncPage> pFuncPage;
182 : VclPtr<StructPage> pStructPage;
183 : OUString aOldFormula;
184 : bool bStructUpdate;
185 : VclPtr<MultiLineEdit> pMEdit;
186 : bool bUserMatrixFlag;
187 : Idle aIdle;
188 :
189 : const OUString aTitle1;
190 : const OUString aTitle2;
191 : const OUString aTxtEnd;
192 : OUString aTxtOk; // behind aBtnEnd
193 : FormulaHelper m_aFormulaHelper;
194 :
195 : OString m_aEditHelpId;
196 :
197 : OString aOldHelp;
198 : OString aOldUnique;
199 : OString aActivWinId;
200 : bool bIsShutDown;
201 :
202 : vcl::Font aFntBold;
203 : vcl::Font aFntLight;
204 : sal_uInt16 nEdFocus;
205 : bool bEditFlag;
206 : const IFunctionDescription* pFuncDesc;
207 : sal_Int32 nArgs;
208 : ::std::vector< OUString > m_aArguments;
209 : Selection aFuncSel;
210 :
211 : FormulaDlg_Impl(Dialog* pParent
212 : , bool _bSupportFunctionResult
213 : , bool _bSupportResult
214 : , bool _bSupportMatrix
215 : ,IFormulaEditorHelper* _pHelper
216 : ,const IFunctionManager* _pFunctionMgr
217 : ,IControlReferenceHandler* _pDlg);
218 : ~FormulaDlg_Impl();
219 :
220 : };
221 :
222 0 : FormulaDlg_Impl::FormulaDlg_Impl(Dialog* pParent
223 : , bool _bSupportFunctionResult
224 : , bool _bSupportResult
225 : , bool _bSupportMatrix
226 : ,IFormulaEditorHelper* _pHelper
227 : ,const IFunctionManager* _pFunctionMgr
228 : ,IControlReferenceHandler* _pDlg)
229 : :
230 : m_pSpecialOpCodesEnd(NULL),
231 : m_pFunctionOpCodesEnd(NULL),
232 : m_pUnaryOpCodesEnd(NULL),
233 : m_pBinaryOpCodesEnd(NULL),
234 : m_pHelper (_pHelper),
235 : m_pParent (pParent),
236 : m_pDlg (_pDlg),
237 : pTheRefEdit (NULL),
238 : pTheRefButton (NULL),
239 : pMEdit (NULL),
240 : bUserMatrixFlag (false),
241 : aTitle1 ( ModuleRes( STR_TITLE1 ) ),
242 : aTitle2 ( ModuleRes( STR_TITLE2 ) ),
243 : aTxtEnd ( ModuleRes( STR_END ) ),
244 : m_aFormulaHelper(_pFunctionMgr),
245 : bIsShutDown (false),
246 : nEdFocus (0),
247 : pFuncDesc (NULL),
248 0 : nArgs (0)
249 : {
250 0 : pParent->get(m_pParaWinBox, "BOX");
251 0 : pParent->get(m_pTabCtrl, "tabs");
252 0 : pParent->get(m_pFtHeadLine, "headline");
253 0 : pParent->get(m_pFtFuncName, "funcname");
254 0 : pParent->get(m_pFtFuncDesc, "funcdesc");
255 0 : pParent->get(m_pFtEditName, "editname");
256 0 : pParent->get(m_pFtResult, "label2");
257 0 : pParent->get(m_pWndResult, "result");
258 0 : pParent->get(m_pFtFormula, "formula");
259 :
260 : //Space for two lines of text
261 0 : m_pFtHeadLine->SetText("X\nX\n");
262 0 : long nHeight = m_pFtHeadLine->GetOptimalSize().Height();
263 0 : m_pFtHeadLine->set_height_request(nHeight);
264 0 : m_pFtHeadLine->SetText("");
265 :
266 0 : m_pFtFuncName->SetText("X\nX\n");
267 0 : nHeight = m_pFtFuncName->GetOptimalSize().Height();
268 0 : m_pFtFuncName->set_height_request(nHeight);
269 0 : m_pFtFuncDesc->set_height_request(nHeight);
270 0 : m_pFtFuncName->SetText("");
271 :
272 0 : pParent->get(m_pMEFormula, "ed_formula");
273 0 : Size aSize(pParent->LogicToPixel(Size(203, 43), MAP_APPFONT));
274 0 : m_pMEFormula->set_height_request(aSize.Height());
275 0 : m_pMEFormula->set_width_request(aSize.Width());
276 0 : pParent->get(m_pBtnMatrix, "array");
277 0 : pParent->get(m_pBtnCancel, "cancel");
278 0 : pParent->get(m_pBtnBackward, "back");
279 0 : pParent->get(m_pBtnForward, "next");
280 0 : pParent->get(m_pBtnEnd, "ok");
281 0 : aTxtOk = m_pBtnEnd->GetText();
282 0 : pParent->get(m_pFtFormResult, "label1");
283 0 : pParent->get(m_pWndFormResult, "formula_result");
284 0 : pParent->get(m_pEdRef, "ED_REF");
285 0 : m_pEdRef->SetReferences(_pDlg, m_pFtEditName);
286 0 : pParent->get(m_pRefBtn, "RB_REF");
287 0 : m_pRefBtn->SetReferences(_pDlg, m_pEdRef);
288 :
289 0 : pParaWin = VclPtr<ParaWin>::Create(m_pParaWinBox, _pDlg);
290 0 : pParaWin->Show();
291 0 : m_pParaWinBox->Hide();
292 0 : m_pFtEditName->Hide();
293 0 : m_pEdRef->Hide();
294 0 : m_pRefBtn->Hide();
295 :
296 0 : pMEdit = m_pMEFormula->GetEdit();
297 :
298 0 : m_pMEFormula->SetAccessibleName(m_pFtFormula->GetText());
299 0 : pMEdit->SetAccessibleName(m_pFtFormula->GetText());
300 :
301 0 : m_aEditHelpId = pMEdit->GetHelpId();
302 0 : pMEdit->SetUniqueId( m_aEditHelpId );
303 :
304 0 : bEditFlag=false;
305 0 : bStructUpdate=true;
306 0 : pParaWin->SetArgModifiedHdl(LINK( this, FormulaDlg_Impl, ModifyHdl ) );
307 0 : pParaWin->SetFxHdl(LINK( this, FormulaDlg_Impl, FxHdl ) );
308 :
309 0 : pFuncPage= VclPtr<FuncPage>::Create( m_pTabCtrl,_pFunctionMgr);
310 0 : pStructPage= VclPtr<StructPage>::Create( m_pTabCtrl);
311 0 : pFuncPage->Hide();
312 0 : pStructPage->Hide();
313 0 : m_pTabCtrl->SetTabPage( TP_FUNCTION, pFuncPage);
314 0 : m_pTabCtrl->SetTabPage( TP_STRUCT, pStructPage);
315 :
316 0 : aOldHelp = pParent->GetHelpId(); // HelpId from resource always for "Page 1"
317 0 : aOldUnique = pParent->GetUniqueId();
318 :
319 0 : m_pFtResult->Show( _bSupportResult );
320 0 : m_pWndResult->Show( _bSupportResult );
321 :
322 0 : m_pFtFormResult->Show( _bSupportFunctionResult );
323 0 : m_pWndFormResult->Show( _bSupportFunctionResult );
324 :
325 0 : if ( _bSupportMatrix )
326 0 : m_pBtnMatrix->SetClickHdl(LINK( this, FormulaDlg_Impl, MatrixHdl ) );
327 : else
328 0 : m_pBtnMatrix->Hide();
329 :
330 0 : m_pBtnCancel ->SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
331 0 : m_pBtnEnd ->SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
332 0 : m_pBtnForward ->SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
333 0 : m_pBtnBackward->SetClickHdl( LINK( this, FormulaDlg_Impl, BtnHdl ) );
334 :
335 0 : pFuncPage->SetDoubleClickHdl( LINK( this, FormulaDlg_Impl, DblClkHdl ) );
336 0 : pFuncPage->SetSelectHdl( LINK( this, FormulaDlg_Impl, FuncSelHdl) );
337 0 : pStructPage->SetSelectionHdl( LINK( this, FormulaDlg_Impl, StructSelHdl ) );
338 0 : pMEdit->SetModifyHdl( LINK( this, FormulaDlg_Impl, FormulaHdl ) );
339 0 : m_pMEFormula->SetSelChangedHdl( LINK( this, FormulaDlg_Impl, FormulaCursorHdl ) );
340 :
341 0 : aFntLight = m_pFtFormula->GetFont();
342 0 : aFntLight.SetTransparent( true );
343 0 : aFntBold = aFntLight;
344 0 : aFntBold.SetWeight( WEIGHT_BOLD );
345 :
346 0 : pParaWin->SetArgumentFonts(aFntBold,aFntLight);
347 :
348 : // function description for choosing a function is no longer in a different color
349 :
350 0 : m_pFtHeadLine->SetFont(aFntBold);
351 0 : m_pFtFuncName->SetFont(aFntLight);
352 0 : m_pFtFuncDesc->SetFont(aFntLight);
353 0 : }
354 :
355 0 : FormulaDlg_Impl::~FormulaDlg_Impl()
356 : {
357 0 : if(aIdle.IsActive())
358 : {
359 0 : aIdle.SetIdleHdl(Link<Idle *, void>());
360 0 : aIdle.Stop();
361 : }// if(aIdle.IsActive())
362 0 : bIsShutDown=true;// Set it in order to PreNotify not to save GetFocus.
363 :
364 0 : m_pTabCtrl->RemovePage(TP_FUNCTION);
365 0 : m_pTabCtrl->RemovePage(TP_STRUCT);
366 :
367 0 : pStructPage.disposeAndClear();
368 0 : pFuncPage.disposeAndClear();
369 0 : pParaWin.disposeAndClear();
370 0 : DeleteArgs();
371 0 : }
372 :
373 0 : void FormulaDlg_Impl::StoreFormEditData(FormEditData* pData)
374 : {
375 0 : if (pData) // it won't be destroyed via Close
376 : {
377 0 : pData->SetFStart(pMEdit->GetSelection().Min());
378 0 : pData->SetSelection(pMEdit->GetSelection());
379 :
380 0 : if(m_pTabCtrl->GetCurPageId()==TP_FUNCTION)
381 0 : pData->SetMode( (sal_uInt16) FORMULA_FORMDLG_FORMULA );
382 : else
383 0 : pData->SetMode( (sal_uInt16) FORMULA_FORMDLG_EDIT );
384 0 : pData->SetUndoStr(pMEdit->GetText());
385 0 : pData->SetMatrixFlag(m_pBtnMatrix->IsChecked());
386 : }
387 0 : }
388 :
389 :
390 0 : void FormulaDlg_Impl::PreNotify( NotifyEvent& rNEvt )
391 : {
392 0 : MouseNotifyEvent nSwitch=rNEvt.GetType();
393 0 : if(nSwitch==MouseNotifyEvent::GETFOCUS && !bIsShutDown)
394 : {
395 0 : vcl::Window* pWin=rNEvt.GetWindow();
396 0 : if(pWin!=NULL)
397 : {
398 0 : aActivWinId = pWin->GetUniqueId();
399 0 : if(aActivWinId.isEmpty())
400 : {
401 0 : vcl::Window* pParent=pWin->GetParent();
402 0 : while(pParent!=NULL)
403 : {
404 0 : aActivWinId=pParent->GetUniqueId();
405 :
406 0 : if(!aActivWinId.isEmpty()) break;
407 :
408 0 : pParent=pParent->GetParent();
409 : }
410 : }
411 0 : if(!aActivWinId.isEmpty())
412 : {
413 :
414 0 : FormEditData* pData = m_pHelper->getFormEditData();
415 :
416 0 : if (pData && !aIdle.IsActive()) // won't be destroyed via Close
417 : {
418 0 : pData->SetUniqueId(aActivWinId);
419 : }
420 : }
421 : }
422 : }
423 0 : }
424 0 : uno::Reference< sheet::XFormulaOpCodeMapper > FormulaDlg_Impl::GetFormulaOpCodeMapper() const
425 : {
426 0 : if ( !m_xOpCodeMapper.is() )
427 : {
428 0 : m_xOpCodeMapper = m_pHelper->getFormulaOpCodeMapper();
429 0 : m_aFunctionOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::FUNCTIONS);
430 0 : m_pFunctionOpCodesEnd = m_aFunctionOpCodes.getConstArray() + m_aFunctionOpCodes.getLength();
431 :
432 0 : m_aUnaryOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::UNARY_OPERATORS);
433 0 : m_pUnaryOpCodesEnd = m_aUnaryOpCodes.getConstArray() + m_aUnaryOpCodes.getLength();
434 :
435 0 : m_aBinaryOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::BINARY_OPERATORS);
436 0 : m_pBinaryOpCodesEnd = m_aBinaryOpCodes.getConstArray() + m_aBinaryOpCodes.getLength();
437 :
438 0 : uno::Sequence< OUString > aArgs(3);
439 0 : aArgs[TOKEN_OPEN] = "(";
440 0 : aArgs[TOKEN_CLOSE] = ")";
441 0 : aArgs[TOKEN_SEP] = ";";
442 0 : m_aSeparatorsOpCodes = m_xOpCodeMapper->getMappings(aArgs,sheet::FormulaLanguage::ODFF);
443 :
444 0 : m_aSpecialOpCodes = m_xOpCodeMapper->getAvailableMappings(sheet::FormulaLanguage::ODFF,sheet::FormulaMapGroup::SPECIAL);
445 0 : m_pSpecialOpCodesEnd = m_aSpecialOpCodes.getConstArray() + m_aSpecialOpCodes.getLength();
446 : } // if ( !m_xOpCodeMapper.is() )
447 0 : return m_xOpCodeMapper;
448 : }
449 :
450 0 : void FormulaDlg_Impl::DeleteArgs()
451 : {
452 0 : ::std::vector< OUString>().swap(m_aArguments);
453 0 : nArgs = 0;
454 0 : }
455 : namespace
456 : {
457 : // comparing two property instances
458 : struct OpCodeCompare : public ::std::binary_function< sheet::FormulaOpCodeMapEntry, sal_Int32 , bool >
459 : {
460 0 : bool operator() (const sheet::FormulaOpCodeMapEntry& x, sal_Int32 y) const
461 : {
462 0 : return x.Token.OpCode == y;
463 : }
464 : };
465 : }
466 :
467 0 : sal_Int32 FormulaDlg_Impl::GetFunctionPos(sal_Int32 nPos)
468 : {
469 0 : if ( !m_aTokenList.hasElements() )
470 0 : return SAL_MAX_INT32;
471 :
472 0 : const sal_Unicode sep = m_pHelper->getFunctionManager()->getSingleToken(IFunctionManager::eSep);
473 :
474 0 : sal_Int32 nFuncPos = SAL_MAX_INT32;
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 : bool bFlag = false;
485 0 : sal_Int32 nTokPos = 1;
486 0 : sal_Int32 nOldTokPos = 1;
487 0 : sal_Int32 nPrevFuncPos = 1;
488 0 : short nBracketCount = 0;
489 0 : while ( pIter != pEnd )
490 : {
491 0 : const sal_Int32 eOp = pIter->OpCode;
492 0 : uno::Sequence<sheet::FormulaToken> aArgs(1);
493 0 : aArgs[0] = *pIter;
494 0 : const OUString aString = xParser->printFormula(aArgs, aRefPos);
495 0 : const sheet::FormulaToken* pNextToken = pIter + 1;
496 :
497 0 : if( !bUserMatrixFlag && FormulaCompiler::IsMatrixFunction((OpCode)eOp) )
498 : {
499 0 : m_pBtnMatrix->Check();
500 : }
501 :
502 0 : if( eOp == m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::PUSH].Token.OpCode ||
503 0 : eOp == m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::SPACES].Token.OpCode )
504 : {
505 0 : const sal_Int32 n1 = nTokPos < 0 ? -1 : aFormString.indexOf(sep, nTokPos);
506 0 : const sal_Int32 n2 = nTokPos < 0 ? -1 : aFormString.indexOf(')',nTokPos);
507 0 : sal_Int32 nXXX = nTokPos;
508 0 : if( n1 < n2 && n1 != -1 )
509 : {
510 0 : nTokPos=n1;
511 : }
512 : else
513 : {
514 0 : nTokPos=n2;
515 : }
516 0 : if( pNextToken != pEnd )
517 : {
518 0 : aArgs[0] = *pNextToken;
519 0 : const OUString a2String = xParser->printFormula(aArgs, aRefPos);
520 0 : const sal_Int32 n3 = nXXX < 0 ? -1 : aFormString.indexOf(a2String, nXXX);
521 0 : if (n3 < nTokPos && n3 != -1)
522 0 : nTokPos = n3;
523 : }
524 : }
525 : else
526 : {
527 0 : nTokPos = nTokPos + aString.getLength();
528 : }
529 :
530 0 : if( eOp == m_aSeparatorsOpCodes[TOKEN_OPEN].OpCode )
531 : {
532 0 : nBracketCount++;
533 0 : bFlag = true;
534 : }
535 0 : else if( eOp == m_aSeparatorsOpCodes[TOKEN_CLOSE].OpCode )
536 : {
537 0 : nBracketCount--;
538 0 : bFlag = false;
539 0 : nFuncPos = nPrevFuncPos;
540 : }
541 0 : bool bIsFunction = ::std::find_if(m_aFunctionOpCodes.getConstArray(),m_pFunctionOpCodesEnd,::std::bind2nd(OpCodeCompare(),boost::cref(eOp))) != m_pFunctionOpCodesEnd;
542 :
543 0 : if( bIsFunction && m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::SPACES].Token.OpCode != eOp )
544 : {
545 0 : nPrevFuncPos = nFuncPos;
546 0 : nFuncPos = nOldTokPos;
547 : }
548 :
549 0 : if( nOldTokPos <= nPos && nPos < nTokPos )
550 : {
551 0 : if( !bIsFunction )
552 : {
553 0 : if( nBracketCount < 1 )
554 : {
555 0 : nFuncPos = pMEdit->GetText().getLength();
556 : }
557 0 : else if( !bFlag )
558 : {
559 0 : nFuncPos = nPrevFuncPos;
560 : }
561 : }
562 0 : break;
563 : }
564 :
565 0 : pIter = pNextToken;
566 0 : nOldTokPos = nTokPos;
567 0 : } // while ( pIter != pEnd )
568 : }
569 0 : catch ( const uno::Exception& e )
570 : {
571 : (void)e;
572 : SAL_WARN("formula.ui", "FormulaDlg_Impl::GetFunctionPos exception! " << e.Message);
573 : }
574 :
575 0 : return nFuncPos;
576 : }
577 :
578 0 : bool FormulaDlg_Impl::CalcValue( const OUString& rStrExp, OUString& rStrResult )
579 : {
580 0 : bool bResult = true;
581 :
582 0 : if ( !rStrExp.isEmpty() )
583 : {
584 : // Only calculate the value when there isn't any more keyboard input:
585 :
586 0 : if ( !Application::AnyInput( VclInputFlags::KEYBOARD ) )
587 : {
588 0 : bResult = m_pHelper->calculateValue(rStrExp,rStrResult);
589 : }
590 : else
591 0 : bResult = false;
592 : }
593 :
594 0 : return bResult;
595 : }
596 :
597 0 : void FormulaDlg_Impl::UpdateValues()
598 : {
599 0 : OUString aStrResult;
600 :
601 0 : if ( CalcValue( pFuncDesc->getFormula( m_aArguments ), aStrResult ) )
602 0 : m_pWndResult->SetText( aStrResult );
603 :
604 0 : aStrResult.clear();
605 0 : if ( CalcValue(m_pHelper->getCurrentFormula(), aStrResult ) )
606 0 : m_pWndFormResult->SetText( aStrResult );
607 : else
608 : {
609 0 : aStrResult.clear();
610 0 : m_pWndFormResult->SetText( aStrResult );
611 : }
612 0 : CalcStruct(pMEdit->GetText());
613 0 : }
614 :
615 0 : bool FormulaDlg_Impl::CalcStruct( const OUString& rStrExp)
616 : {
617 0 : bool bResult = true;
618 0 : sal_Int32 nLength = rStrExp.getLength();
619 :
620 0 : if ( !rStrExp.isEmpty() && aOldFormula!=rStrExp && bStructUpdate)
621 : {
622 : // Only calculate the value when there isn't any more keyboard input:
623 :
624 0 : if ( !Application::AnyInput( VclInputFlags::KEYBOARD ) )
625 : {
626 0 : pStructPage->ClearStruct();
627 :
628 0 : OUString aString=rStrExp;
629 0 : if(rStrExp[nLength-1] == '(')
630 : {
631 0 : aString = aString.copy(0, nLength-1);
632 : }
633 :
634 0 : aString = comphelper::string::remove(aString, '\n');
635 0 : OUString aStrResult;
636 :
637 0 : if ( CalcValue(aString, aStrResult ) )
638 0 : m_pWndFormResult->SetText( aStrResult );
639 :
640 0 : UpdateTokenArray(aString);
641 0 : fillTree(pStructPage);
642 :
643 0 : aOldFormula = rStrExp;
644 0 : if(rStrExp[nLength-1] == '(')
645 0 : UpdateTokenArray(rStrExp);
646 : }
647 : else
648 0 : bResult = false;
649 : }
650 0 : return bResult;
651 : }
652 :
653 :
654 0 : void FormulaDlg_Impl::MakeTree(IStructHelper* _pTree,SvTreeListEntry* pParent,FormulaToken* _pToken,long Count)
655 : {
656 0 : if( _pToken != NULL && Count > 0 )
657 : {
658 0 : long nParas = _pToken->GetParamCount();
659 0 : OpCode eOp = _pToken->GetOpCode();
660 :
661 : // #i101512# for output, the original token is needed
662 0 : FormulaToken* pOrigToken = (_pToken->GetType() == svFAP) ? _pToken->GetFAPOrigToken() : _pToken;
663 0 : uno::Sequence<sheet::FormulaToken> aArgs(1);
664 0 : ::std::map<FormulaToken*,sheet::FormulaToken>::const_iterator itr = m_aTokenMap.find(pOrigToken);
665 0 : if (itr == m_aTokenMap.end())
666 0 : return;
667 :
668 0 : aArgs[0] = itr->second;
669 : try
670 : {
671 0 : const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
672 0 : const OUString aResult = m_pHelper->getFormulaParser()->printFormula(aArgs, aRefPos);
673 :
674 0 : if ( nParas > 0 )
675 : {
676 : SvTreeListEntry* pEntry;
677 :
678 0 : OUString aTest=_pTree->GetEntryText(pParent);
679 :
680 0 : if(aTest==aResult &&
681 0 : (eOp==ocAdd || eOp==ocMul ||
682 : eOp==ocAmpersand))
683 : {
684 0 : pEntry=pParent;
685 : }
686 : else
687 : {
688 0 : if(eOp==ocBad)
689 : {
690 0 : pEntry=_pTree->InsertEntry(aResult,pParent,STRUCT_ERROR,0,_pToken);
691 : }
692 : else
693 : {
694 0 : pEntry=_pTree->InsertEntry(aResult,pParent,STRUCT_FOLDER,0,_pToken);
695 : }
696 : }
697 :
698 0 : MakeTree(_pTree,pEntry,m_pTokenArray->PrevRPN(),nParas);
699 0 : --Count;
700 0 : m_pTokenArray->NextRPN();
701 0 : MakeTree(_pTree,pParent,m_pTokenArray->PrevRPN(),Count);
702 : }
703 : else
704 : {
705 0 : if(eOp==ocBad)
706 : {
707 0 : _pTree->InsertEntry(aResult,pParent,STRUCT_ERROR,0,_pToken);
708 : }
709 : else
710 : {
711 0 : _pTree->InsertEntry(aResult,pParent,STRUCT_END,0,_pToken);
712 : }
713 0 : --Count;
714 0 : MakeTree(_pTree,pParent,m_pTokenArray->PrevRPN(),Count);
715 0 : }
716 : }
717 0 : catch(const uno::Exception&)
718 : {
719 : DBG_UNHANDLED_EXCEPTION();
720 0 : }
721 : }
722 : }
723 :
724 0 : void FormulaDlg_Impl::fillTree(IStructHelper* _pTree)
725 : {
726 0 : GetFormulaOpCodeMapper();
727 0 : FormulaToken* pToken = m_pTokenArray->LastRPN();
728 :
729 0 : if( pToken != NULL)
730 : {
731 0 : MakeTree(_pTree,NULL,pToken,1);
732 : }
733 0 : }
734 0 : void FormulaDlg_Impl::UpdateTokenArray( const OUString& rStrExp)
735 : {
736 0 : m_aTokenMap.clear();
737 0 : m_aTokenList.realloc(0);
738 : try
739 : {
740 0 : const table::CellAddress aRefPos(m_pHelper->getReferencePosition());
741 0 : m_aTokenList = m_pHelper->getFormulaParser()->parseFormula(rStrExp, aRefPos);
742 : }
743 0 : catch(const uno::Exception&)
744 : {
745 : DBG_UNHANDLED_EXCEPTION();
746 : }
747 0 : GetFormulaOpCodeMapper(); // just to get it initialized
748 0 : m_pTokenArray = m_pHelper->convertToTokenArray(m_aTokenList);
749 0 : const sal_Int32 nLen = static_cast<sal_Int32>(m_pTokenArray->GetLen());
750 0 : FormulaToken** pTokens = m_pTokenArray->GetArray();
751 0 : if ( pTokens && nLen == m_aTokenList.getLength() )
752 : {
753 0 : for (sal_Int32 nPos=0; nPos<nLen; nPos++)
754 : {
755 0 : m_aTokenMap.insert(::std::map<FormulaToken*,sheet::FormulaToken>::value_type(pTokens[nPos],m_aTokenList[nPos]));
756 : }
757 : } // if ( pTokens && nLen == m_aTokenList.getLength() )
758 :
759 0 : FormulaCompiler aCompiler(*m_pTokenArray.get());
760 : // #i101512# Disable special handling of jump commands.
761 0 : aCompiler.EnableJumpCommandReorder(false);
762 0 : aCompiler.EnableStopOnError(false);
763 0 : aCompiler.CompileTokenArray();
764 0 : }
765 :
766 0 : void FormulaDlg_Impl::FillDialog(bool nFlag)
767 : {
768 0 : bool bNext=true, bPrev=true;
769 0 : if(nFlag)
770 0 : FillControls(bNext, bPrev);
771 0 : FillListboxes();
772 0 : if(nFlag)
773 : {
774 0 : m_pBtnBackward->Enable(bPrev);
775 0 : m_pBtnForward->Enable(bNext);
776 : }
777 :
778 0 : OUString aStrResult;
779 :
780 0 : if ( CalcValue(m_pHelper->getCurrentFormula(), aStrResult ) )
781 0 : m_pWndFormResult->SetText( aStrResult );
782 : else
783 : {
784 0 : aStrResult.clear();
785 0 : m_pWndFormResult->SetText( aStrResult );
786 0 : }
787 0 : }
788 :
789 :
790 0 : void FormulaDlg_Impl::FillListboxes()
791 : {
792 : // Switch between the "Pages"
793 0 : FormEditData* pData = m_pHelper->getFormEditData();
794 0 : OUString aNewTitle;
795 : // 1. Page: select function
796 0 : if ( pFuncDesc && pFuncDesc->getCategory() )
797 : {
798 : // We'll never have more than int32 max categories so this is safe ...
799 0 : if( pFuncPage->GetCategory() != static_cast<sal_Int32>(pFuncDesc->getCategory()->getNumber() + 1) )
800 0 : pFuncPage->SetCategory(pFuncDesc->getCategory()->getNumber() + 1);
801 :
802 0 : sal_Int32 nPos=pFuncPage->GetFuncPos(pFuncDesc);
803 :
804 0 : pFuncPage->SetFunction(nPos);
805 : }
806 0 : else if ( pData )
807 : {
808 0 : pFuncPage->SetCategory( pData->GetCatSel() );
809 0 : pFuncPage->SetFunction( pData->GetFuncSel() );
810 : }
811 0 : FuncSelHdl(NULL);
812 :
813 0 : m_pHelper->setDispatcherLock( true );// Activate Modal-Mode
814 :
815 0 : aNewTitle = aTitle1;
816 :
817 : // HelpId for 1. page is the one from the resource
818 0 : m_pParent->SetHelpId( aOldHelp );
819 0 : m_pParent->SetUniqueId( aOldUnique );
820 0 : }
821 :
822 0 : void FormulaDlg_Impl::FillControls(bool &rbNext, bool &rbPrev)
823 : {
824 : // Switch between the "Pages"
825 0 : FormEditData* pData = m_pHelper->getFormEditData();
826 0 : if (!pData )
827 0 : return;
828 :
829 : // 2. Page or Edit: show selected function
830 :
831 0 : sal_Int32 nFStart = pData->GetFStart();
832 0 : OUString aFormula = m_pHelper->getCurrentFormula() + " )";
833 0 : sal_Int32 nNextFStart = nFStart;
834 0 : sal_Int32 nNextFEnd = 0;
835 :
836 0 : DeleteArgs();
837 0 : const IFunctionDescription* pOldFuncDesc = pFuncDesc;
838 :
839 0 : if ( m_aFormulaHelper.GetNextFunc( aFormula, false,
840 0 : nNextFStart, &nNextFEnd, &pFuncDesc, &m_aArguments ) )
841 : {
842 0 : const bool 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_Int32 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_Int32 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_Int32 i=nClearPos; i<nArgs; i++)
1192 : {
1193 0 : m_aArguments[i].clear();
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.clear();
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.get() : 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.get() : 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.clear();
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==nullptr)
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 == nullptr;
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 : _bSupportResult, _bSupportMatrix,
1655 0 : this, _pFunctionMgr, _pDlg))
1656 : {
1657 0 : SetText(m_pImpl->aTitle1);
1658 0 : }
1659 :
1660 0 : FormulaModalDialog::~FormulaModalDialog() { disposeOnce(); }
1661 :
1662 0 : void FormulaModalDialog::dispose()
1663 : {
1664 0 : m_pImpl.reset();
1665 0 : ModalDialog::dispose();
1666 0 : }
1667 :
1668 0 : void FormulaModalDialog::Update(const OUString& _sExp)
1669 : {
1670 0 : m_pImpl->Update(_sExp);
1671 0 : }
1672 :
1673 0 : void FormulaModalDialog::SetMeText(const OUString& _sText)
1674 : {
1675 0 : m_pImpl->SetMeText(_sText);
1676 0 : }
1677 :
1678 0 : bool FormulaModalDialog::CheckMatrix(OUString& aFormula)
1679 : {
1680 0 : return m_pImpl->CheckMatrix(aFormula);
1681 : }
1682 :
1683 0 : void FormulaModalDialog::Update()
1684 : {
1685 0 : m_pImpl->Update();
1686 0 : }
1687 :
1688 0 : ::std::pair<RefButton*,RefEdit*> FormulaModalDialog::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton )
1689 : {
1690 0 : return m_pImpl->RefInputStartBefore( pEdit, pButton );
1691 : }
1692 :
1693 0 : void FormulaModalDialog::RefInputStartAfter( RefEdit* pEdit, RefButton* pButton )
1694 : {
1695 0 : m_pImpl->RefInputStartAfter( pEdit, pButton );
1696 0 : }
1697 0 : void FormulaModalDialog::RefInputDoneAfter( bool bForced )
1698 : {
1699 0 : m_pImpl->RefInputDoneAfter( bForced );
1700 0 : }
1701 :
1702 0 : void FormulaModalDialog::SetFocusWin(vcl::Window *pWin,const OString& nUniqueId)
1703 : {
1704 0 : if(pWin->GetUniqueId()==nUniqueId)
1705 : {
1706 0 : pWin->GrabFocus();
1707 : }
1708 : else
1709 : {
1710 0 : sal_uInt16 nCount=pWin->GetChildCount();
1711 :
1712 0 : for(sal_uInt16 i=0;i<nCount;i++)
1713 : {
1714 0 : vcl::Window* pChild=pWin->GetChild(i);
1715 0 : SetFocusWin(pChild,nUniqueId);
1716 : }
1717 : }
1718 0 : }
1719 :
1720 0 : bool FormulaModalDialog::PreNotify( NotifyEvent& rNEvt )
1721 : {
1722 0 : m_pImpl->PreNotify( rNEvt );
1723 :
1724 0 : return ModalDialog::PreNotify(rNEvt);
1725 : }
1726 :
1727 0 : void FormulaModalDialog::StoreFormEditData(FormEditData* pData)
1728 : {
1729 0 : m_pImpl->StoreFormEditData(pData);
1730 0 : }
1731 :
1732 :
1733 : // Initialisation / General functions for Dialog
1734 :
1735 0 : FormulaDlg::FormulaDlg( SfxBindings* pB, SfxChildWindow* pCW,
1736 : vcl::Window* pParent
1737 : , bool _bSupportFunctionResult
1738 : , bool _bSupportResult
1739 : , bool _bSupportMatrix
1740 : , IFunctionManager* _pFunctionMgr, IControlReferenceHandler* _pDlg ) :
1741 : SfxModelessDialog( pB, pCW, pParent, "FormulaDialog", "formula/ui/formuladialog.ui" ),
1742 : m_pImpl( new FormulaDlg_Impl(this, _bSupportFunctionResult
1743 : , _bSupportResult
1744 : , _bSupportMatrix
1745 0 : , this, _pFunctionMgr, _pDlg))
1746 : {
1747 : //undo SfxModelessDialog HelpId clear hack
1748 0 : reverseUniqueHelpIdHack(*this);
1749 0 : SetText(m_pImpl->aTitle1);
1750 0 : }
1751 :
1752 0 : FormulaDlg::~FormulaDlg() {disposeOnce();}
1753 :
1754 0 : void FormulaDlg::dispose()
1755 : {
1756 0 : m_pImpl.reset();
1757 0 : SfxModelessDialog::dispose();
1758 0 : }
1759 :
1760 0 : void FormulaDlg::Update(const OUString& _sExp)
1761 : {
1762 0 : m_pImpl->Update(_sExp);
1763 0 : }
1764 :
1765 :
1766 0 : void FormulaDlg::SetMeText(const OUString& _sText)
1767 : {
1768 0 : m_pImpl->SetMeText(_sText);
1769 0 : }
1770 :
1771 0 : FormulaDlgMode FormulaDlg::SetMeText(const OUString& _sText, sal_Int32 PrivStart, sal_Int32 PrivEnd, bool bMatrix, bool _bSelect, bool _bUpdate)
1772 : {
1773 0 : return m_pImpl->SetMeText(_sText,PrivStart, PrivEnd,bMatrix,_bSelect,_bUpdate);
1774 : }
1775 :
1776 0 : bool FormulaDlg::CheckMatrix(OUString& aFormula)
1777 : {
1778 0 : return m_pImpl->CheckMatrix(aFormula);
1779 : }
1780 :
1781 0 : OUString FormulaDlg::GetMeText() const
1782 : {
1783 0 : return m_pImpl->pMEdit->GetText();
1784 : }
1785 :
1786 0 : void FormulaDlg::Update()
1787 : {
1788 0 : m_pImpl->Update();
1789 0 : m_pImpl->aIdle.SetPriority(SchedulerPriority::LOWER);
1790 0 : m_pImpl->aIdle.SetIdleHdl(LINK( this, FormulaDlg, UpdateFocusHdl));
1791 0 : m_pImpl->aIdle.Start();
1792 0 : }
1793 :
1794 0 : void FormulaDlg::DoEnter(bool _bOk)
1795 : {
1796 0 : m_pImpl->DoEnter(_bOk);
1797 0 : }
1798 0 : ::std::pair<RefButton*,RefEdit*> FormulaDlg::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton )
1799 : {
1800 0 : return m_pImpl->RefInputStartBefore( pEdit, pButton );
1801 : }
1802 0 : void FormulaDlg::RefInputStartAfter( RefEdit* pEdit, RefButton* pButton )
1803 : {
1804 0 : m_pImpl->RefInputStartAfter( pEdit, pButton );
1805 0 : }
1806 0 : void FormulaDlg::RefInputDoneAfter( bool bForced )
1807 : {
1808 0 : m_pImpl->RefInputDoneAfter( bForced );
1809 0 : }
1810 :
1811 0 : void FormulaDlg::SetFocusWin(vcl::Window *pWin,const OString& nUniqueId)
1812 : {
1813 0 : if(pWin->GetUniqueId()==nUniqueId)
1814 : {
1815 0 : pWin->GrabFocus();
1816 : }
1817 : else
1818 : {
1819 0 : sal_uInt16 nCount=pWin->GetChildCount();
1820 :
1821 0 : for(sal_uInt16 i=0;i<nCount;i++)
1822 : {
1823 0 : vcl::Window* pChild=pWin->GetChild(i);
1824 0 : SetFocusWin(pChild,nUniqueId);
1825 : }
1826 : }
1827 0 : }
1828 :
1829 :
1830 0 : bool FormulaDlg::PreNotify( NotifyEvent& rNEvt )
1831 : {
1832 0 : if (m_pImpl)
1833 0 : m_pImpl->PreNotify( rNEvt );
1834 0 : return SfxModelessDialog::PreNotify(rNEvt);
1835 : }
1836 :
1837 0 : void FormulaDlg::disableOk()
1838 : {
1839 0 : m_pImpl->m_pBtnEnd->Disable();
1840 0 : }
1841 :
1842 0 : void FormulaDlg::StoreFormEditData(FormEditData* pData)
1843 : {
1844 0 : m_pImpl->StoreFormEditData(pData);
1845 0 : }
1846 :
1847 :
1848 0 : const IFunctionDescription* FormulaDlg::getCurrentFunctionDescription() const
1849 : {
1850 : SAL_WARN_IF( (m_pImpl->pFuncDesc && m_pImpl->pFuncDesc->getSuppressedArgumentCount() != m_pImpl->nArgs),
1851 : "formula.ui", "FormulaDlg::getCurrentFunctionDescription: getSuppressedArgumentCount " <<
1852 : m_pImpl->pFuncDesc->getSuppressedArgumentCount() << " != nArgs " << m_pImpl->nArgs << " for " <<
1853 : m_pImpl->pFuncDesc->getFunctionName());
1854 0 : return m_pImpl->pFuncDesc;
1855 : }
1856 :
1857 0 : void FormulaDlg::UpdateParaWin(const Selection& _rSelection,const OUString& _sRefStr)
1858 : {
1859 0 : m_pImpl->UpdateParaWin(_rSelection,_sRefStr);
1860 0 : }
1861 0 : bool FormulaDlg::UpdateParaWin(Selection& _rSelection)
1862 : {
1863 0 : return m_pImpl->UpdateParaWin(_rSelection);
1864 : }
1865 :
1866 0 : RefEdit* FormulaDlg::GetActiveEdit()
1867 : {
1868 0 : return m_pImpl->pParaWin->GetActiveEdit();
1869 : }
1870 :
1871 0 : const FormulaHelper& FormulaDlg::GetFormulaHelper() const
1872 : {
1873 0 : return m_pImpl->GetFormulaHelper();
1874 : }
1875 :
1876 0 : void FormulaDlg::SetEdSelection()
1877 : {
1878 0 : m_pImpl->SetEdSelection();
1879 0 : }
1880 0 : IMPL_LINK_NOARG_TYPED(FormulaDlg, UpdateFocusHdl, Idle *, void)
1881 : {
1882 0 : FormEditData* pData = m_pImpl->m_pHelper->getFormEditData();
1883 :
1884 0 : if (pData) // won't be destroyed via Close
1885 : {
1886 0 : m_pImpl->m_pHelper->setReferenceInput(pData);
1887 0 : OString nUniqueId(pData->GetUniqueId());
1888 0 : SetFocusWin(this,nUniqueId);
1889 : }
1890 0 : }
1891 :
1892 :
1893 0 : void FormEditData::SaveValues()
1894 : {
1895 0 : FormEditData* pTemp = new FormEditData(*this);
1896 :
1897 0 : Reset();
1898 0 : pParent = pTemp;
1899 0 : }
1900 :
1901 0 : void FormEditData::Reset()
1902 : {
1903 0 : pParent = NULL;
1904 0 : nMode = 0;
1905 0 : nFStart = 0;
1906 0 : nCatSel = 1; //! oder 0 (zuletzt benutzte)
1907 0 : nFuncSel = 0;
1908 0 : nOffset = 0;
1909 0 : nEdFocus = 0;
1910 0 : bMatrix = false;
1911 0 : aUniqueId=OString();
1912 0 : aSelection.Min()=0;
1913 0 : aSelection.Max()=0;
1914 0 : aUndoStr.clear();
1915 0 : }
1916 :
1917 0 : const FormEditData& FormEditData::operator=( const FormEditData& r )
1918 : {
1919 0 : pParent = r.pParent;
1920 0 : nMode = r.nMode;
1921 0 : nFStart = r.nFStart;
1922 0 : nCatSel = r.nCatSel;
1923 0 : nFuncSel = r.nFuncSel;
1924 0 : nOffset = r.nOffset;
1925 0 : nEdFocus = r.nEdFocus;
1926 0 : aUndoStr = r.aUndoStr;
1927 0 : bMatrix = r.bMatrix ;
1928 0 : aUniqueId = r.aUniqueId;
1929 0 : aSelection = r.aSelection;
1930 0 : return *this;
1931 : }
1932 :
1933 0 : FormEditData::FormEditData()
1934 : {
1935 0 : Reset();
1936 0 : }
1937 :
1938 0 : FormEditData::~FormEditData()
1939 : {
1940 0 : delete pParent;
1941 0 : }
1942 :
1943 0 : FormEditData::FormEditData( const FormEditData& r )
1944 : {
1945 0 : *this = r;
1946 0 : }
1947 :
1948 :
1949 183 : } // formula
1950 :
1951 :
1952 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
