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