LibreOffice Module sc (master)  1
formulaopt.cxx
Go to the documentation of this file.
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 
10 #include <com/sun/star/uno/Sequence.hxx>
11 #include <com/sun/star/lang/Locale.hpp>
12 #include <osl/diagnose.h>
13 #include <sal/log.hxx>
15 #include <formulaopt.hxx>
16 #include <miscuno.hxx>
17 #include <global.hxx>
18 #include <formulagroup.hxx>
19 #include <sc.hrc>
20 
21 using namespace utl;
22 using namespace com::sun::star::uno;
23 namespace lang = ::com::sun::star::lang;
24 
25 
27 {
28  SetDefaults();
29 }
30 
32 {
33  bUseEnglishFuncName = false;
35  mbWriteCalcConfig = true;
36  meOOXMLRecalc = RECALC_ASK;
37  meODFRecalc = RECALC_ASK;
38 
39  // unspecified means use the current formula syntax.
40  aCalcConfig.reset();
41 
42  ResetFormulaSeparators();
43 }
44 
46 {
47  GetDefaultFormulaSeparators(aFormulaSepArg, aFormulaSepArrayCol, aFormulaSepArrayRow);
48 }
49 
51  OUString& rSepArg, OUString& rSepArrayCol, OUString& rSepArrayRow)
52 {
53  // Defaults to the old separator values.
54  rSepArg = ";";
55  rSepArrayCol = ";";
56  rSepArrayRow = "|";
57 
58  const lang::Locale& rLocale = *ScGlobal::GetLocale();
59  const OUString& rLang = rLocale.Language;
60  if (rLang == "ru")
61  // Don't do automatic guess for these languages, and fall back to
62  // the old separator set.
63  return;
64 
65  const LocaleDataWrapper& rLocaleData = *ScGlobal::getLocaleDataPtr();
66  const OUString& rDecSep = rLocaleData.getNumDecimalSep();
67  const OUString& rListSep = rLocaleData.getListSep();
68 
69  if (rDecSep.isEmpty() || rListSep.isEmpty())
70  // Something is wrong. Stick with the default separators.
71  return;
72 
73  sal_Unicode cDecSep = rDecSep[0];
74  sal_Unicode cListSep = rListSep[0];
75  sal_Unicode cDecSepAlt = rLocaleData.getNumDecimalSepAlt().toChar(); // usually 0 (empty)
76 
77  // Excel by default uses system's list separator as the parameter
78  // separator, which in English locales is a comma. However, OOo's list
79  // separator value is set to ';' for all English locales. Because of this
80  // discrepancy, we will hardcode the separator value here, for now.
81  // Similar for decimal separator alternative.
82  // However, if the decimal separator alternative is '.' and the decimal
83  // separator is ',' this makes no sense, fall back to ';' in that case.
84  if (cDecSep == '.' || (cDecSepAlt == '.' && cDecSep != ','))
85  cListSep = ',';
86  else if (cDecSep == ',' && cDecSepAlt == '.')
87  cListSep = ';';
88 
89  // Special case for de_CH locale.
90  if (rLocale.Language == "de" && rLocale.Country == "CH")
91  cListSep = ';';
92 
93  // by default, the parameter separator equals the locale-specific
94  // list separator.
95  rSepArg = OUString(cListSep);
96 
97  if (cDecSep == cListSep && cDecSep != ';')
98  // if the decimal and list separators are equal, set the
99  // parameter separator to be ';', unless they are both
100  // semicolon in which case don't change the decimal separator.
101  rSepArg = ";";
102 
103  rSepArrayCol = ",";
104  if (cDecSep == ',')
105  rSepArrayCol = ".";
106  rSepArrayRow = ";";
107 }
108 
110 {
111  return bUseEnglishFuncName == rOpt.bUseEnglishFuncName
112  && eFormulaGrammar == rOpt.eFormulaGrammar
113  && aCalcConfig == rOpt.aCalcConfig
114  && mbWriteCalcConfig == rOpt.mbWriteCalcConfig
115  && aFormulaSepArg == rOpt.aFormulaSepArg
116  && aFormulaSepArrayRow == rOpt.aFormulaSepArrayRow
117  && aFormulaSepArrayCol == rOpt.aFormulaSepArrayCol
118  && meOOXMLRecalc == rOpt.meOOXMLRecalc
119  && meODFRecalc == rOpt.meODFRecalc;
120 }
121 
123 {
124  return !(operator==(rOpt));
125 }
126 
128  SfxPoolItem ( SID_SCFORMULAOPTIONS ),
129  theOptions ( rOpt )
130 {
131 }
132 
134 {
135 }
136 
137 bool ScTpFormulaItem::operator==( const SfxPoolItem& rItem ) const
138 {
139  assert(SfxPoolItem::operator==(rItem));
140 
141  const ScTpFormulaItem& rPItem = static_cast<const ScTpFormulaItem&>(rItem);
142  return ( theOptions == rPItem.theOptions );
143 }
144 
146 {
147  return new ScTpFormulaItem( *this );
148 }
149 
150 #define CFGPATH_FORMULA "Office.Calc/Formula"
151 
152 #define SCFORMULAOPT_GRAMMAR 0
153 #define SCFORMULAOPT_ENGLISH_FUNCNAME 1
154 #define SCFORMULAOPT_SEP_ARG 2
155 #define SCFORMULAOPT_SEP_ARRAY_ROW 3
156 #define SCFORMULAOPT_SEP_ARRAY_COL 4
157 #define SCFORMULAOPT_STRING_REF_SYNTAX 5
158 #define SCFORMULAOPT_STRING_CONVERSION 6
159 #define SCFORMULAOPT_EMPTY_OUSTRING_AS_ZERO 7
160 #define SCFORMULAOPT_OOXML_RECALC 8
161 #define SCFORMULAOPT_ODF_RECALC 9
162 #define SCFORMULAOPT_OPENCL_AUTOSELECT 10
163 #define SCFORMULAOPT_OPENCL_DEVICE 11
164 #define SCFORMULAOPT_OPENCL_SUBSET_ONLY 12
165 #define SCFORMULAOPT_OPENCL_MIN_SIZE 13
166 #define SCFORMULAOPT_OPENCL_SUBSET_OPS 14
167 
169 {
170  return {"Syntax/Grammar", // SCFORMULAOPT_GRAMMAR
171  "Syntax/EnglishFunctionName", // SCFORMULAOPT_ENGLISH_FUNCNAME
172  "Syntax/SeparatorArg", // SCFORMULAOPT_SEP_ARG
173  "Syntax/SeparatorArrayRow", // SCFORMULAOPT_SEP_ARRAY_ROW
174  "Syntax/SeparatorArrayCol", // SCFORMULAOPT_SEP_ARRAY_COL
175  "Syntax/StringRefAddressSyntax", // SCFORMULAOPT_STRING_REF_SYNTAX
176  "Syntax/StringConversion", // SCFORMULAOPT_STRING_CONVERSION
177  "Syntax/EmptyStringAsZero", // SCFORMULAOPT_EMPTY_OUSTRING_AS_ZERO
178  "Load/OOXMLRecalcMode", // SCFORMULAOPT_OOXML_RECALC
179  "Load/ODFRecalcMode", // SCFORMULAOPT_ODF_RECALC
180  "Calculation/OpenCLAutoSelect", // SCFORMULAOPT_OPENCL_AUTOSELECT
181  "Calculation/OpenCLDevice", // SCFORMULAOPT_OPENCL_DEVICE
182  "Calculation/OpenCLSubsetOnly", // SCFORMULAOPT_OPENCL_SUBSET_ONLY
183  "Calculation/OpenCLMinimumDataSize", // SCFORMULAOPT_OPENCL_MIN_SIZE
184  "Calculation/OpenCLSubsetOpCodes"}; // SCFORMULAOPT_OPENCL_SUBSET_OPS
185 }
186 
188 {
190  static sal_uInt16 aVals[] = {
206  };
207  OSL_ENSURE( SAL_N_ELEMENTS(aVals) == aPropNames.getLength(), "Properties and ids are out of Sync");
208  PropsToIds aPropIdMap;
209  for ( sal_Int32 i=0; i<aPropNames.getLength(); ++i )
210  aPropIdMap[aPropNames[i]] = aVals[ i ];
211  return aPropIdMap;
212 }
213 
216 {
218  UpdateFromProperties( aNames );
219  EnableNotification( aNames );
220 }
221 
223 {
224  Sequence<Any> aValues = GetProperties(aNames);
225  const Any* pValues = aValues.getConstArray();
226  OSL_ENSURE(aValues.getLength() == aNames.getLength(), "GetProperties failed");
227  PropsToIds aPropMap = GetPropNamesToId();
228  if(aValues.getLength() != aNames.getLength())
229  return;
230 
231  sal_Int32 nIntVal = 0;
232  for(int nProp = 0; nProp < aNames.getLength(); nProp++)
233  {
234  PropsToIds::iterator it_end = aPropMap.end();
235  PropsToIds::iterator it = aPropMap.find( aNames[nProp] );
236  if(pValues[nProp].hasValue() && it != it_end )
237  {
238  switch(it->second)
239  {
241  {
242  // Get default value in case this option is not set.
244 
245  do
246  {
247  if (!(pValues[nProp] >>= nIntVal))
248  // extracting failed.
249  break;
250 
251  switch (nIntVal)
252  {
253  case 0: // Calc A1
255  break;
256  case 1: // Excel A1
258  break;
259  case 2: // Excel R1C1
261  break;
262  default:
263  ;
264  }
265  }
266  while (false);
267  SetFormulaSyntax(eGram);
268  }
269  break;
271  {
272  bool bEnglish = false;
273  if (pValues[nProp] >>= bEnglish)
274  SetUseEnglishFuncName(bEnglish);
275  }
276  break;
278  {
279  OUString aSep;
280  if ((pValues[nProp] >>= aSep) && !aSep.isEmpty())
281  SetFormulaSepArg(aSep);
282  }
283  break;
285  {
286  OUString aSep;
287  if ((pValues[nProp] >>= aSep) && !aSep.isEmpty())
288  SetFormulaSepArrayRow(aSep);
289  }
290  break;
292  {
293  OUString aSep;
294  if ((pValues[nProp] >>= aSep) && !aSep.isEmpty())
295  SetFormulaSepArrayCol(aSep);
296  }
297  break;
299  {
300  // Get default value in case this option is not set.
302 
303  do
304  {
305  if (!(pValues[nProp] >>= nIntVal))
306  // extraction failed.
307  break;
308 
309  switch (nIntVal)
310  {
311  case -1: // Same as the formula grammar.
313  break;
314  case 0: // Calc A1
316  break;
317  case 1: // Excel A1
319  break;
320  case 2: // Excel R1C1
322  break;
323  case 3: // Calc A1 | Excel A1
325  break;
326  default:
327  ;
328  }
329  }
330  while (false);
332  }
333  break;
335  {
336  // Get default value in case this option is not set.
338 
339  do
340  {
341  if (!(pValues[nProp] >>= nIntVal))
342  // extraction failed.
343  break;
344 
345  switch (nIntVal)
346  {
347  case 0:
349  break;
350  case 1:
352  break;
353  case 2:
355  break;
356  case 3:
358  break;
359  default:
360  SAL_WARN("sc", "unknown string conversion option!");
361  }
362  }
363  while (false);
365  }
366  break;
368  {
369  bool bVal = GetCalcConfig().mbEmptyStringAsZero;
370  pValues[nProp] >>= bVal;
372  }
373  break;
375  {
377  if (pValues[nProp] >>= nIntVal)
378  {
379  switch (nIntVal)
380  {
381  case 0:
382  eOpt = RECALC_ALWAYS;
383  break;
384  case 1:
385  eOpt = RECALC_NEVER;
386  break;
387  case 2:
388  eOpt = RECALC_ASK;
389  break;
390  default:
391  SAL_WARN("sc", "unknown ooxml recalc option!");
392  }
393  }
394 
395  SetOOXMLRecalcOptions(eOpt);
396  }
397  break;
399  {
401  if (pValues[nProp] >>= nIntVal)
402  {
403  switch (nIntVal)
404  {
405  case 0:
406  eOpt = RECALC_ALWAYS;
407  break;
408  case 1:
409  eOpt = RECALC_NEVER;
410  break;
411  case 2:
412  eOpt = RECALC_ASK;
413  break;
414  default:
415  SAL_WARN("sc", "unknown odf recalc option!");
416  }
417  }
418 
419  SetODFRecalcOptions(eOpt);
420  }
421  break;
423  {
424  bool bVal = GetCalcConfig().mbOpenCLAutoSelect;
425  pValues[nProp] >>= bVal;
427  }
428  break;
430  {
431  OUString aOpenCLDevice = GetCalcConfig().maOpenCLDevice;
432  pValues[nProp] >>= aOpenCLDevice;
433  GetCalcConfig().maOpenCLDevice = aOpenCLDevice;
434  }
435  break;
437  {
438  bool bVal = GetCalcConfig().mbOpenCLSubsetOnly;
439  pValues[nProp] >>= bVal;
441  }
442  break;
444  {
446  pValues[nProp] >>= nVal;
448  }
449  break;
451  {
452  OUString sVal = ScOpCodeSetToSymbolicString(GetCalcConfig().mpOpenCLSubsetOpCodes);
453  pValues[nProp] >>= sVal;
455  }
456  break;
457  }
458  }
459  }
460 }
461 
463 {
465  Sequence<Any> aValues(aNames.getLength());
466  Any* pValues = aValues.getArray();
467 
468  Sequence<Any> aOldValues = GetProperties(aNames);
469  Any* pOldValues = aOldValues.getArray();
470 
471  bool bSetOpenCL = false;
472 
473  for (int nProp = 0; nProp < aNames.getLength(); ++nProp)
474  {
475  switch (nProp)
476  {
477  case SCFORMULAOPT_GRAMMAR :
478  {
479  sal_Int32 nVal = 0;
480  switch (GetFormulaSyntax())
481  {
482  case ::formula::FormulaGrammar::GRAM_NATIVE_XL_A1: nVal = 1; break;
483  case ::formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1: nVal = 2; break;
484  default: break;
485  }
486  pValues[nProp] <<= nVal;
487  }
488  break;
490  {
491  bool b = GetUseEnglishFuncName();
492  pValues[nProp] <<= b;
493  }
494  break;
496  pValues[nProp] <<= GetFormulaSepArg();
497  break;
499  pValues[nProp] <<= GetFormulaSepArrayRow();
500  break;
502  pValues[nProp] <<= GetFormulaSepArrayCol();
503  break;
505  {
506  sal_Int32 nVal = -1;
507 
508  if (GetWriteCalcConfig())
509  {
510  switch (GetCalcConfig().meStringRefAddressSyntax)
511  {
512  case ::formula::FormulaGrammar::CONV_OOO: nVal = 0; break;
513  case ::formula::FormulaGrammar::CONV_XL_A1: nVal = 1; break;
514  case ::formula::FormulaGrammar::CONV_XL_R1C1: nVal = 2; break;
515  case ::formula::FormulaGrammar::CONV_A1_XL_A1: nVal = 3; break;
516  default: break;
517  }
518  pValues[nProp] <<= nVal;
519  }
520  else
521  {
522  pValues[nProp] = pOldValues[nProp];
523  }
524  }
525  break;
527  {
528  if (GetWriteCalcConfig())
529  {
530  sal_Int32 nVal = 3;
531 
532  switch (GetCalcConfig().meStringConversion)
533  {
534  case ScCalcConfig::StringConversion::ILLEGAL: nVal = 0; break;
535  case ScCalcConfig::StringConversion::ZERO: nVal = 1; break;
536  case ScCalcConfig::StringConversion::UNAMBIGUOUS: nVal = 2; break;
537  case ScCalcConfig::StringConversion::LOCALE: nVal = 3; break;
538  }
539  pValues[nProp] <<= nVal;
540  }
541  else
542  {
543  pValues[nProp] = pOldValues[nProp];
544  }
545  }
546  break;
548  {
549  if (GetWriteCalcConfig())
550  {
551  bool bVal = GetCalcConfig().mbEmptyStringAsZero;
552  pValues[nProp] <<= bVal;
553  }
554  else
555  {
556  pValues[nProp] = pOldValues[nProp];
557  }
558  }
559  break;
561  {
562  sal_Int32 nVal = 2;
563  switch (GetOOXMLRecalcOptions())
564  {
565  case RECALC_ALWAYS:
566  nVal = 0;
567  break;
568  case RECALC_NEVER:
569  nVal = 1;
570  break;
571  case RECALC_ASK:
572  nVal = 2;
573  break;
574  }
575 
576  pValues[nProp] <<= nVal;
577  }
578  break;
580  {
581  sal_Int32 nVal = 2;
582  switch (GetODFRecalcOptions())
583  {
584  case RECALC_ALWAYS:
585  nVal = 0;
586  break;
587  case RECALC_NEVER:
588  nVal = 1;
589  break;
590  case RECALC_ASK:
591  nVal = 2;
592  break;
593  }
594 
595  pValues[nProp] <<= nVal;
596  }
597  break;
599  {
600  bool bVal = GetCalcConfig().mbOpenCLAutoSelect;
601  pValues[nProp] <<= bVal;
602  bSetOpenCL = true;
603  }
604  break;
606  {
607  OUString aOpenCLDevice = GetCalcConfig().maOpenCLDevice;
608  pValues[nProp] <<= aOpenCLDevice;
609  bSetOpenCL = true;
610  }
611  break;
613  {
614  bool bVal = GetCalcConfig().mbOpenCLSubsetOnly;
615  pValues[nProp] <<= bVal;
616  }
617  break;
619  {
621  pValues[nProp] <<= nVal;
622  }
623  break;
625  {
626  OUString sVal = ScOpCodeSetToSymbolicString(GetCalcConfig().mpOpenCLSubsetOpCodes);
627  pValues[nProp] <<= sVal;
628  }
629  break;
630  }
631  }
632 #if !HAVE_FEATURE_OPENCL
633  (void) bSetOpenCL;
634 #else
635  if(bSetOpenCL)
636  sc::FormulaGroupInterpreter::switchOpenCLDevice(
637  GetCalcConfig().maOpenCLDevice, GetCalcConfig().mbOpenCLAutoSelect);
638 #endif
639  PutProperties(aNames, aValues);
640 }
641 
643 {
644  *static_cast<ScFormulaOptions*>(this) = rNew;
645  SetModified();
646 }
647 
648 void ScFormulaCfg::Notify( const css::uno::Sequence< OUString >& rNames)
649 {
650  UpdateFromProperties( rNames );
651 }
652 
653 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
virtual void Notify(const css::uno::Sequence< OUString > &aPropertyNames) override
Definition: formulaopt.cxx:648
bool operator!=(const ScFormulaOptions &rOpt) const
Definition: formulaopt.cxx:122
static void GetDefaultFormulaSeparators(OUString &rSepArg, OUString &rSepArrayCol, OUString &rSepArrayRow)
Definition: formulaopt.cxx:50
#define SCFORMULAOPT_OPENCL_DEVICE
Definition: formulaopt.cxx:163
ScRecalcOptions GetODFRecalcOptions() const
Definition: formulaopt.hxx:66
=1+"1" gives 2, but =1+"1.000" or =1+"x" give VALUE!
const OUString & getListSep() const
virtual ~ScTpFormulaItem() override
Definition: formulaopt.cxx:133
OUString maOpenCLDevice
Definition: calcconfig.hxx:64
OUString aFormulaSepArg
Definition: formulaopt.hxx:28
void SetOOXMLRecalcOptions(ScRecalcOptions eOpt)
Definition: formulaopt.hxx:62
bool GetUseEnglishFuncName() const
Definition: formulaopt.hxx:48
#define SCFORMULAOPT_STRING_CONVERSION
Definition: formulaopt.cxx:158
OUString ScOpCodeSetToSymbolicString(const ScCalcConfig::OpCodeSet &rOpCodes)
Definition: calcconfig.cxx:194
const OUString & GetFormulaSepArrayRow() const
Definition: formulaopt.hxx:57
#define SCFORMULAOPT_OPENCL_SUBSET_ONLY
Definition: formulaopt.cxx:164
sal_uInt16 sal_Unicode
#define SCFORMULAOPT_OPENCL_AUTOSELECT
Definition: formulaopt.cxx:162
void SetFormulaSyntax(::formula::FormulaGrammar::Grammar eGram)
Definition: formulaopt.hxx:40
static css::uno::Sequence< OUString > GetPropertyNames()
Definition: formulaopt.cxx:168
=1+"1" or =1+"x" give 1
static css::lang::Locale * GetLocale()
Definition: global.cxx:1049
ScTpFormulaItem(const ScFormulaOptions &rOpt)
Definition: formulaopt.cxx:127
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
ScCalcConfig::OpCodeSet ScStringToOpCodeSet(const OUString &rOpCodes)
Definition: calcconfig.cxx:210
#define SCFORMULAOPT_SEP_ARRAY_ROW
Definition: formulaopt.cxx:155
bool bUseEnglishFuncName
Definition: formulaopt.hxx:23
ScRecalcOptions meOOXMLRecalc
Definition: formulaopt.hxx:32
bool EnableNotification(const css::uno::Sequence< OUString > &rNames, bool bEnableInternalNotification=false)
bool mbOpenCLSubsetOnly
Definition: calcconfig.hxx:62
StringConversion meStringConversion
Definition: calcconfig.hxx:54
std::map< OUString, sal_uInt16 > PropsToIds
Definition: formulaopt.hxx:102
#define SAL_N_ELEMENTS(arr)
ScRecalcOptions meODFRecalc
Definition: formulaopt.hxx:33
ScCalcConfig aCalcConfig
Definition: formulaopt.hxx:25
const OUString & getNumDecimalSep() const
ScCalcConfig & GetCalcConfig()
Definition: formulaopt.hxx:43
int i
bool PutProperties(const css::uno::Sequence< OUString > &rNames, const css::uno::Sequence< css::uno::Any > &rValues)
virtual bool operator==(const SfxPoolItem &) const override
Definition: formulaopt.cxx:137
OpCodeSet mpOpenCLSubsetOpCodes
Definition: calcconfig.hxx:69
#define SCFORMULAOPT_OPENCL_MIN_SIZE
Definition: formulaopt.cxx:165
=1+"1.000" may be 2 or 1001 ... =1+"x" gives VALUE!
void SetFormulaSepArg(const OUString &rSep)
Definition: formulaopt.hxx:53
css::uno::Sequence< css::uno::Any > GetProperties(const css::uno::Sequence< OUString > &rNames)
const PropertyStruct aPropNames[]
static ScFormulaCfg::PropsToIds GetPropNamesToId()
Definition: formulaopt.cxx:187
void SetFormulaSepArrayCol(const OUString &rSep)
Definition: formulaopt.hxx:59
formula::FormulaGrammar::AddressConvention meStringRefAddressSyntax
Definition: calcconfig.hxx:53
virtual ScTpFormulaItem * Clone(SfxItemPool *pPool=nullptr) const override
Definition: formulaopt.cxx:145
void SetFormulaSepArrayRow(const OUString &rSep)
Definition: formulaopt.hxx:56
void SetUseEnglishFuncName(bool bVal)
Definition: formulaopt.hxx:47
bool mbOpenCLAutoSelect
Definition: calcconfig.hxx:63
#define SCFORMULAOPT_OPENCL_SUBSET_OPS
Definition: formulaopt.cxx:166
const OUString & GetFormulaSepArg() const
Definition: formulaopt.hxx:54
const OUString & GetFormulaSepArrayCol() const
Definition: formulaopt.hxx:60
const OUString & getNumDecimalSepAlt() const
static SC_DLLPUBLIC const LocaleDataWrapper * getLocaleDataPtr()
Definition: global.cxx:1001
sal_Int32 mnOpenCLMinimumFormulaGroupSize
Definition: calcconfig.hxx:65
const PropertyValue * pValues
#define SCFORMULAOPT_SEP_ARG
Definition: formulaopt.cxx:154
ScRecalcOptions GetOOXMLRecalcOptions() const
Definition: formulaopt.hxx:63
#define SCFORMULAOPT_STRING_REF_SYNTAX
Definition: formulaopt.cxx:157
#define SCFORMULAOPT_ENGLISH_FUNCNAME
Definition: formulaopt.cxx:153
#define SCFORMULAOPT_GRAMMAR
Definition: formulaopt.cxx:152
#define SCFORMULAOPT_SEP_ARRAY_COL
Definition: formulaopt.cxx:156
bool operator==(const ScFormulaOptions &rOpt) const
Definition: formulaopt.cxx:109
#define SCFORMULAOPT_ODF_RECALC
Definition: formulaopt.cxx:161
ScRecalcOptions
Definition: calcconfig.hxx:23
::formula::FormulaGrammar::Grammar GetFormulaSyntax() const
Definition: formulaopt.hxx:41
ScFormulaOptions theOptions
Definition: formulaopt.hxx:95
virtual void ImplCommit() override
Definition: formulaopt.cxx:462
void UpdateFromProperties(const css::uno::Sequence< OUString > &rNames)
Definition: formulaopt.cxx:222
OUString aFormulaSepArrayCol
Definition: formulaopt.hxx:30
=1+"1" or =1+"x" give VALUE!
#define SAL_WARN(area, stream)
bool GetWriteCalcConfig() const
Definition: formulaopt.hxx:51
OUString aFormulaSepArrayRow
Definition: formulaopt.hxx:29
void ResetFormulaSeparators()
Definition: formulaopt.cxx:45
bool mbEmptyStringAsZero
Definition: calcconfig.hxx:55
formula::FormulaGrammar::Grammar eFormulaGrammar
Definition: formulaopt.hxx:24
#define SCFORMULAOPT_EMPTY_OUSTRING_AS_ZERO
Definition: formulaopt.cxx:159
void SetOptions(const ScFormulaOptions &rNew)
Definition: formulaopt.cxx:642
void SetODFRecalcOptions(ScRecalcOptions eOpt)
Definition: formulaopt.hxx:65
#define SCFORMULAOPT_OOXML_RECALC
Definition: formulaopt.cxx:160
#define CFGPATH_FORMULA
Definition: formulaopt.cxx:150
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo
bool operator==(const SharedUNOComponent< INTERFACE, COMPONENT > &_rLHS, const css::uno::Reference< INTERFACE > &_rRHS)