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