Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : */
9 :
10 : #include <com/sun/star/uno/Any.hxx>
11 : #include <com/sun/star/uno/Sequence.hxx>
12 : #include <com/sun/star/lang/Locale.hpp>
13 : #include <com/sun/star/i18n/LocaleDataItem.hpp>
14 :
15 : #include "formulaopt.hxx"
16 : #include "miscuno.hxx"
17 : #include "global.hxx"
18 : #include "formulagroup.hxx"
19 :
20 : using namespace utl;
21 : using namespace com::sun::star::uno;
22 : namespace lang = ::com::sun::star::lang;
23 : using ::com::sun::star::i18n::LocaleDataItem;
24 :
25 0 : TYPEINIT1(ScTpFormulaItem, SfxPoolItem);
26 :
27 80 : ScFormulaOptions::ScFormulaOptions()
28 : {
29 80 : SetDefaults();
30 80 : }
31 :
32 952 : ScFormulaOptions::ScFormulaOptions( const ScFormulaOptions& rCpy ) :
33 : bUseEnglishFuncName ( rCpy.bUseEnglishFuncName ),
34 : eFormulaGrammar ( rCpy.eFormulaGrammar ),
35 : aCalcConfig(rCpy.aCalcConfig),
36 : aFormulaSepArg ( rCpy.aFormulaSepArg ),
37 : aFormulaSepArrayRow ( rCpy.aFormulaSepArrayRow ),
38 : aFormulaSepArrayCol ( rCpy.aFormulaSepArrayCol ),
39 : meOOXMLRecalc ( rCpy.meOOXMLRecalc ),
40 952 : meODFRecalc ( rCpy.meODFRecalc )
41 : {
42 952 : }
43 :
44 982 : ScFormulaOptions::~ScFormulaOptions()
45 : {
46 982 : }
47 :
48 80 : void ScFormulaOptions::SetDefaults()
49 : {
50 80 : bUseEnglishFuncName = false;
51 80 : eFormulaGrammar = ::formula::FormulaGrammar::GRAM_NATIVE;
52 80 : meOOXMLRecalc = RECALC_ASK;
53 80 : meODFRecalc = RECALC_ASK;
54 :
55 : // unspecified means use the current formula syntax.
56 80 : aCalcConfig.reset();
57 :
58 80 : ResetFormulaSeparators();
59 80 : }
60 :
61 80 : void ScFormulaOptions::ResetFormulaSeparators()
62 : {
63 80 : GetDefaultFormulaSeparators(aFormulaSepArg, aFormulaSepArrayCol, aFormulaSepArrayRow);
64 80 : }
65 :
66 80 : void ScFormulaOptions::GetDefaultFormulaSeparators(
67 : OUString& rSepArg, OUString& rSepArrayCol, OUString& rSepArrayRow)
68 : {
69 : // Defaults to the old separator values.
70 80 : rSepArg = ";";
71 80 : rSepArrayCol = ";";
72 80 : rSepArrayRow = "|";
73 :
74 80 : const lang::Locale& rLocale = *ScGlobal::GetLocale();
75 80 : const OUString& rLang = rLocale.Language;
76 80 : if (rLang == "ru")
77 : // Don't do automatic guess for these languages, and fall back to
78 : // the old separator set.
79 0 : return;
80 :
81 80 : const LocaleDataWrapper& rLocaleData = GetLocaleDataWrapper();
82 80 : const OUString& rDecSep = rLocaleData.getNumDecimalSep();
83 80 : const OUString& rListSep = rLocaleData.getListSep();
84 :
85 80 : if (rDecSep.isEmpty() || rListSep.isEmpty())
86 : // Something is wrong. Stick with the default separators.
87 0 : return;
88 :
89 80 : sal_Unicode cDecSep = rDecSep[0];
90 80 : sal_Unicode cListSep = rListSep[0];
91 :
92 : // Excel by default uses system's list separator as the parameter
93 : // separator, which in English locales is a comma. However, OOo's list
94 : // separator value is set to ';' for all English locales. Because of this
95 : // discrepancy, we will hardcode the separator value here, for now.
96 80 : if (cDecSep == '.')
97 80 : cListSep = ',';
98 :
99 : // Special case for de_CH locale.
100 80 : if (rLocale.Language == "de" && rLocale.Country == "CH")
101 0 : cListSep = ';';
102 :
103 : // by default, the parameter separator equals the locale-specific
104 : // list separator.
105 80 : rSepArg = OUString(cListSep);
106 :
107 80 : if (cDecSep == cListSep && cDecSep != ';')
108 : // if the decimal and list separators are equal, set the
109 : // parameter separator to be ';', unless they are both
110 : // semicolon in which case don't change the decimal separator.
111 0 : rSepArg = ";";
112 :
113 80 : rSepArrayCol = ",";
114 80 : if (cDecSep == ',')
115 0 : rSepArrayCol = ".";
116 80 : rSepArrayRow = ";";
117 : }
118 :
119 80 : const LocaleDataWrapper& ScFormulaOptions::GetLocaleDataWrapper()
120 : {
121 80 : return *ScGlobal::pLocaleData;
122 : }
123 :
124 0 : ScFormulaOptions& ScFormulaOptions::operator=( const ScFormulaOptions& rCpy )
125 : {
126 0 : bUseEnglishFuncName = rCpy.bUseEnglishFuncName;
127 0 : eFormulaGrammar = rCpy.eFormulaGrammar;
128 0 : aCalcConfig = rCpy.aCalcConfig;
129 0 : aFormulaSepArg = rCpy.aFormulaSepArg;
130 0 : aFormulaSepArrayRow = rCpy.aFormulaSepArrayRow;
131 0 : aFormulaSepArrayCol = rCpy.aFormulaSepArrayCol;
132 0 : meOOXMLRecalc = rCpy.meOOXMLRecalc;
133 0 : meODFRecalc = rCpy.meODFRecalc;
134 0 : return *this;
135 : }
136 :
137 0 : bool ScFormulaOptions::operator==( const ScFormulaOptions& rOpt ) const
138 : {
139 0 : return bUseEnglishFuncName == rOpt.bUseEnglishFuncName
140 0 : && eFormulaGrammar == rOpt.eFormulaGrammar
141 0 : && aCalcConfig == rOpt.aCalcConfig
142 0 : && aFormulaSepArg == rOpt.aFormulaSepArg
143 0 : && aFormulaSepArrayRow == rOpt.aFormulaSepArrayRow
144 0 : && aFormulaSepArrayCol == rOpt.aFormulaSepArrayCol
145 0 : && meOOXMLRecalc == rOpt.meOOXMLRecalc
146 0 : && meODFRecalc == rOpt.meODFRecalc;
147 : }
148 :
149 0 : bool ScFormulaOptions::operator!=( const ScFormulaOptions& rOpt ) const
150 : {
151 0 : return !(operator==(rOpt));
152 : }
153 :
154 0 : ScTpFormulaItem::ScTpFormulaItem( sal_uInt16 nWhichP, const ScFormulaOptions& rOpt ) :
155 : SfxPoolItem ( nWhichP ),
156 0 : theOptions ( rOpt )
157 : {
158 0 : }
159 :
160 0 : ScTpFormulaItem::ScTpFormulaItem( const ScTpFormulaItem& rItem ) :
161 : SfxPoolItem ( rItem ),
162 0 : theOptions ( rItem.theOptions )
163 : {
164 0 : }
165 :
166 0 : ScTpFormulaItem::~ScTpFormulaItem()
167 : {
168 0 : }
169 :
170 0 : OUString ScTpFormulaItem::GetValueText() const
171 : {
172 0 : return OUString("ScTpFormulaItem");
173 : }
174 :
175 0 : bool ScTpFormulaItem::operator==( const SfxPoolItem& rItem ) const
176 : {
177 : assert(SfxPoolItem::operator==(rItem));
178 :
179 0 : const ScTpFormulaItem& rPItem = static_cast<const ScTpFormulaItem&>(rItem);
180 0 : return ( theOptions == rPItem.theOptions );
181 : }
182 :
183 0 : SfxPoolItem* ScTpFormulaItem::Clone( SfxItemPool * ) const
184 : {
185 0 : return new ScTpFormulaItem( *this );
186 : }
187 :
188 : #define CFGPATH_FORMULA "Office.Calc/Formula"
189 :
190 : #define SCFORMULAOPT_GRAMMAR 0
191 : #define SCFORMULAOPT_ENGLISH_FUNCNAME 1
192 : #define SCFORMULAOPT_SEP_ARG 2
193 : #define SCFORMULAOPT_SEP_ARRAY_ROW 3
194 : #define SCFORMULAOPT_SEP_ARRAY_COL 4
195 : #define SCFORMULAOPT_STRING_REF_SYNTAX 5
196 : #define SCFORMULAOPT_STRING_CONVERSION 6
197 : #define SCFORMULAOPT_EMPTY_OUSTRING_AS_ZERO 7
198 : #define SCFORMULAOPT_OOXML_RECALC 8
199 : #define SCFORMULAOPT_ODF_RECALC 9
200 : #define SCFORMULAOPT_OPENCL_ENABLED 10
201 : #define SCFORMULAOPT_OPENCL_AUTOSELECT 11
202 : #define SCFORMULAOPT_OPENCL_DEVICE 12
203 : #define SCFORMULAOPT_COUNT 13
204 :
205 140 : Sequence<OUString> ScFormulaCfg::GetPropertyNames()
206 : {
207 : static const char* aPropNames[] =
208 : {
209 : "Syntax/Grammar", // SCFORMULAOPT_GRAMMAR
210 : "Syntax/EnglishFunctionName", // SCFORMULAOPT_ENGLISH_FUNCNAME
211 : "Syntax/SeparatorArg", // SCFORMULAOPT_SEP_ARG
212 : "Syntax/SeparatorArrayRow", // SCFORMULAOPT_SEP_ARRAY_ROW
213 : "Syntax/SeparatorArrayCol", // SCFORMULAOPT_SEP_ARRAY_COL
214 : "Syntax/StringRefAddressSyntax", // SCFORMULAOPT_STRING_REF_SYNTAX
215 : "Syntax/StringConversion", // SCFORMULAOPT_STRING_CONVERSION
216 : "Syntax/EmptyStringAsZero", // SCFORMULAOPT_EMPTY_OUSTRING_AS_ZERO
217 : "Load/OOXMLRecalcMode", // SCFORMULAOPT_OOXML_RECALC
218 : "Load/ODFRecalcMode", // SCFORMULAOPT_ODF_RECALC
219 : "Calculation/OpenCL", // SCFORMULAOPT_OPENCL_ENABLED
220 : "Calculation/OpenCLAutoSelect", // SCFORMULAOPT_OPENCL_AUTOSELECT
221 : "Calculation/OpenCLDevice" // SCFORMULAOPT_OPENCL_DEVICE
222 : };
223 140 : Sequence<OUString> aNames(SCFORMULAOPT_COUNT);
224 140 : OUString* pNames = aNames.getArray();
225 1960 : for (int i = 0; i < SCFORMULAOPT_COUNT; ++i)
226 1820 : pNames[i] = OUString::createFromAscii(aPropNames[i]);
227 :
228 140 : return aNames;
229 : }
230 :
231 70 : ScFormulaCfg::PropsToIds ScFormulaCfg::GetPropNamesToId()
232 : {
233 70 : Sequence<OUString> aPropNames = GetPropertyNames();
234 : static sal_uInt16 aVals[] = { SCFORMULAOPT_GRAMMAR, SCFORMULAOPT_ENGLISH_FUNCNAME, SCFORMULAOPT_SEP_ARG, SCFORMULAOPT_SEP_ARRAY_ROW, SCFORMULAOPT_SEP_ARRAY_COL, SCFORMULAOPT_STRING_REF_SYNTAX, SCFORMULAOPT_STRING_CONVERSION, SCFORMULAOPT_EMPTY_OUSTRING_AS_ZERO, SCFORMULAOPT_OOXML_RECALC, SCFORMULAOPT_ODF_RECALC, SCFORMULAOPT_OPENCL_ENABLED, SCFORMULAOPT_OPENCL_AUTOSELECT, SCFORMULAOPT_OPENCL_DEVICE };
235 : OSL_ENSURE( SAL_N_ELEMENTS(aVals) == aPropNames.getLength(), "Properties and ids are out of Sync");
236 70 : PropsToIds aPropIdMap;
237 980 : for ( sal_uInt16 i=0; i<aPropNames.getLength(); ++i )
238 910 : aPropIdMap[aPropNames[i]] = aVals[ i ];
239 70 : return aPropIdMap;
240 : }
241 :
242 70 : ScFormulaCfg::ScFormulaCfg() :
243 70 : ConfigItem( OUString( CFGPATH_FORMULA ) )
244 : {
245 70 : Sequence<OUString> aNames = GetPropertyNames();
246 70 : UpdateFromProperties( aNames );
247 70 : EnableNotification( aNames );
248 70 : }
249 :
250 70 : void ScFormulaCfg::UpdateFromProperties( const Sequence<OUString>& aNames )
251 : {
252 70 : Sequence<Any> aValues = GetProperties(aNames);
253 70 : const Any* pValues = aValues.getConstArray();
254 : OSL_ENSURE(aValues.getLength() == aNames.getLength(), "GetProperties failed");
255 140 : PropsToIds aPropMap = GetPropNamesToId();
256 70 : if(aValues.getLength() == aNames.getLength())
257 : {
258 70 : sal_Int32 nIntVal = 0;
259 980 : for(int nProp = 0; nProp < aNames.getLength(); nProp++)
260 : {
261 910 : PropsToIds::iterator it_end = aPropMap.end();
262 910 : PropsToIds::iterator it = aPropMap.find( aNames[nProp] );
263 910 : if(pValues[nProp].hasValue() && it != it_end )
264 : {
265 700 : switch(it->second)
266 : {
267 : case SCFORMULAOPT_GRAMMAR:
268 : {
269 : // Get default value in case this option is not set.
270 0 : ::formula::FormulaGrammar::Grammar eGram = GetFormulaSyntax();
271 :
272 : do
273 : {
274 0 : if (!(pValues[nProp] >>= nIntVal))
275 : // extractino failed.
276 0 : break;
277 :
278 0 : switch (nIntVal)
279 : {
280 : case 0: // Calc A1
281 0 : eGram = ::formula::FormulaGrammar::GRAM_NATIVE;
282 0 : break;
283 : case 1: // Excel A1
284 0 : eGram = ::formula::FormulaGrammar::GRAM_NATIVE_XL_A1;
285 0 : break;
286 : case 2: // Excel R1C1
287 0 : eGram = ::formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1;
288 0 : break;
289 : default:
290 : ;
291 : }
292 : }
293 : while (false);
294 0 : SetFormulaSyntax(eGram);
295 : }
296 0 : break;
297 : case SCFORMULAOPT_ENGLISH_FUNCNAME:
298 : {
299 70 : bool bEnglish = false;
300 70 : if (pValues[nProp] >>= bEnglish)
301 70 : SetUseEnglishFuncName(bEnglish);
302 : }
303 70 : break;
304 : case SCFORMULAOPT_SEP_ARG:
305 : {
306 70 : OUString aSep;
307 70 : if ((pValues[nProp] >>= aSep) && !aSep.isEmpty())
308 0 : SetFormulaSepArg(aSep);
309 : }
310 70 : break;
311 : case SCFORMULAOPT_SEP_ARRAY_ROW:
312 : {
313 70 : OUString aSep;
314 70 : if ((pValues[nProp] >>= aSep) && !aSep.isEmpty())
315 0 : SetFormulaSepArrayRow(aSep);
316 : }
317 70 : break;
318 : case SCFORMULAOPT_SEP_ARRAY_COL:
319 : {
320 70 : OUString aSep;
321 70 : if ((pValues[nProp] >>= aSep) && !aSep.isEmpty())
322 0 : SetFormulaSepArrayCol(aSep);
323 : }
324 70 : break;
325 : case SCFORMULAOPT_STRING_REF_SYNTAX:
326 : {
327 : // Get default value in case this option is not set.
328 0 : ::formula::FormulaGrammar::AddressConvention eConv = GetCalcConfig().meStringRefAddressSyntax;
329 :
330 : do
331 : {
332 0 : if (!(pValues[nProp] >>= nIntVal))
333 : // extraction failed.
334 0 : break;
335 :
336 0 : switch (nIntVal)
337 : {
338 : case -1: // Same as the formula grammar.
339 0 : eConv = formula::FormulaGrammar::CONV_UNSPECIFIED;
340 0 : break;
341 : case 0: // Calc A1
342 0 : eConv = formula::FormulaGrammar::CONV_OOO;
343 0 : break;
344 : case 1: // Excel A1
345 0 : eConv = formula::FormulaGrammar::CONV_XL_A1;
346 0 : break;
347 : case 2: // Excel R1C1
348 0 : eConv = formula::FormulaGrammar::CONV_XL_R1C1;
349 0 : break;
350 : default:
351 : ;
352 : }
353 : }
354 : while (false);
355 0 : GetCalcConfig().meStringRefAddressSyntax = eConv;
356 : }
357 0 : break;
358 : case SCFORMULAOPT_STRING_CONVERSION:
359 : {
360 : // Get default value in case this option is not set.
361 0 : ScCalcConfig::StringConversion eConv = GetCalcConfig().meStringConversion;
362 :
363 : do
364 : {
365 0 : if (!(pValues[nProp] >>= nIntVal))
366 : // extraction failed.
367 0 : break;
368 :
369 0 : switch (nIntVal)
370 : {
371 : case 0:
372 0 : eConv = ScCalcConfig::STRING_CONVERSION_AS_ERROR;
373 0 : break;
374 : case 1:
375 0 : eConv = ScCalcConfig::STRING_CONVERSION_AS_ZERO;
376 0 : break;
377 : case 2:
378 0 : eConv = ScCalcConfig::STRING_CONVERSION_UNAMBIGUOUS;
379 0 : break;
380 : case 3:
381 0 : eConv = ScCalcConfig::STRING_CONVERSION_LOCALE_DEPENDENT;
382 0 : break;
383 : default:
384 : SAL_WARN("sc", "unknown string conversion option!");
385 : }
386 : }
387 : while (false);
388 0 : GetCalcConfig().meStringConversion = eConv;
389 : }
390 0 : break;
391 : case SCFORMULAOPT_EMPTY_OUSTRING_AS_ZERO:
392 : {
393 70 : bool bVal = GetCalcConfig().mbEmptyStringAsZero;
394 70 : pValues[nProp] >>= bVal;
395 70 : GetCalcConfig().mbEmptyStringAsZero = bVal;
396 : }
397 70 : break;
398 : case SCFORMULAOPT_OOXML_RECALC:
399 : {
400 70 : ScRecalcOptions eOpt = RECALC_ASK;
401 70 : if (pValues[nProp] >>= nIntVal)
402 : {
403 70 : switch (nIntVal)
404 : {
405 : case 0:
406 0 : eOpt = RECALC_ALWAYS;
407 0 : break;
408 : case 1:
409 70 : eOpt = RECALC_NEVER;
410 70 : break;
411 : case 2:
412 0 : eOpt = RECALC_ASK;
413 0 : break;
414 : default:
415 : SAL_WARN("sc", "unknown ooxml recalc option!");
416 : }
417 : }
418 :
419 70 : SetOOXMLRecalcOptions(eOpt);
420 : }
421 70 : break;
422 : case SCFORMULAOPT_ODF_RECALC:
423 : {
424 70 : ScRecalcOptions eOpt = RECALC_ASK;
425 70 : if (pValues[nProp] >>= nIntVal)
426 : {
427 70 : switch (nIntVal)
428 : {
429 : case 0:
430 0 : eOpt = RECALC_ALWAYS;
431 0 : break;
432 : case 1:
433 70 : eOpt = RECALC_NEVER;
434 70 : break;
435 : case 2:
436 0 : eOpt = RECALC_ASK;
437 0 : break;
438 : default:
439 : SAL_WARN("sc", "unknown odf recalc option!");
440 : }
441 : }
442 :
443 70 : SetODFRecalcOptions(eOpt);
444 : }
445 70 : break;
446 : case SCFORMULAOPT_OPENCL_ENABLED:
447 : {
448 70 : bool bVal = GetCalcConfig().mbOpenCLEnabled;
449 70 : pValues[nProp] >>= bVal;
450 : #if 0 // Don't remove please.
451 : // The intent here is that tml when running CppunitTest_sc_opencl_test turns this on.
452 : bVal = sal_True;
453 : #endif
454 70 : GetCalcConfig().mbOpenCLEnabled = bVal;
455 : }
456 70 : break;
457 : case SCFORMULAOPT_OPENCL_AUTOSELECT:
458 : {
459 70 : bool bVal = GetCalcConfig().mbOpenCLAutoSelect;
460 70 : pValues[nProp] >>= bVal;
461 70 : GetCalcConfig().mbOpenCLAutoSelect = bVal;
462 : }
463 70 : break;
464 : case SCFORMULAOPT_OPENCL_DEVICE:
465 : {
466 70 : OUString aOpenCLDevice = GetCalcConfig().maOpenCLDevice;
467 70 : pValues[nProp] >>= aOpenCLDevice;
468 70 : GetCalcConfig().maOpenCLDevice = aOpenCLDevice;
469 : }
470 70 : break;
471 : default:
472 : ;
473 : }
474 : }
475 : }
476 70 : }
477 70 : }
478 :
479 0 : void ScFormulaCfg::Commit()
480 : {
481 0 : Sequence<OUString> aNames = GetPropertyNames();
482 0 : Sequence<Any> aValues(aNames.getLength());
483 0 : Any* pValues = aValues.getArray();
484 0 : bool bSetOpenCL = false;
485 :
486 0 : for (int nProp = 0; nProp < aNames.getLength(); ++nProp)
487 : {
488 0 : switch (nProp)
489 : {
490 : case SCFORMULAOPT_GRAMMAR :
491 : {
492 0 : sal_Int32 nVal = 0;
493 0 : switch (GetFormulaSyntax())
494 : {
495 0 : case ::formula::FormulaGrammar::GRAM_NATIVE_XL_A1: nVal = 1; break;
496 0 : case ::formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1: nVal = 2; break;
497 0 : default: break;
498 : }
499 0 : pValues[nProp] <<= nVal;
500 : }
501 0 : break;
502 : case SCFORMULAOPT_ENGLISH_FUNCNAME:
503 : {
504 0 : bool b = GetUseEnglishFuncName();
505 0 : pValues[nProp] <<= b;
506 : }
507 0 : break;
508 : case SCFORMULAOPT_SEP_ARG:
509 0 : pValues[nProp] <<= GetFormulaSepArg();
510 0 : break;
511 : case SCFORMULAOPT_SEP_ARRAY_ROW:
512 0 : pValues[nProp] <<= GetFormulaSepArrayRow();
513 0 : break;
514 : case SCFORMULAOPT_SEP_ARRAY_COL:
515 0 : pValues[nProp] <<= GetFormulaSepArrayCol();
516 0 : break;
517 : case SCFORMULAOPT_STRING_REF_SYNTAX:
518 : {
519 0 : sal_Int32 nVal = -1;
520 0 : switch (GetCalcConfig().meStringRefAddressSyntax)
521 : {
522 0 : case ::formula::FormulaGrammar::CONV_OOO: nVal = 0; break;
523 0 : case ::formula::FormulaGrammar::CONV_XL_A1: nVal = 1; break;
524 0 : case ::formula::FormulaGrammar::CONV_XL_R1C1: nVal = 2; break;
525 0 : default: break;
526 : }
527 0 : pValues[nProp] <<= nVal;
528 : }
529 0 : break;
530 : case SCFORMULAOPT_STRING_CONVERSION:
531 : {
532 0 : sal_Int32 nVal = 3;
533 0 : switch (GetCalcConfig().meStringConversion)
534 : {
535 0 : case ScCalcConfig::STRING_CONVERSION_AS_ERROR: nVal = 0; break;
536 0 : case ScCalcConfig::STRING_CONVERSION_AS_ZERO: nVal = 1; break;
537 0 : case ScCalcConfig::STRING_CONVERSION_UNAMBIGUOUS: nVal = 2; break;
538 0 : case ScCalcConfig::STRING_CONVERSION_LOCALE_DEPENDENT: nVal = 3; break;
539 : }
540 0 : pValues[nProp] <<= nVal;
541 : }
542 0 : break;
543 : case SCFORMULAOPT_EMPTY_OUSTRING_AS_ZERO:
544 : {
545 0 : bool bVal = GetCalcConfig().mbEmptyStringAsZero;
546 0 : pValues[nProp] <<= bVal;
547 : }
548 0 : break;
549 : case SCFORMULAOPT_OOXML_RECALC:
550 : {
551 0 : sal_Int32 nVal = 2;
552 0 : switch (GetOOXMLRecalcOptions())
553 : {
554 : case RECALC_ALWAYS:
555 0 : nVal = 0;
556 0 : break;
557 : case RECALC_NEVER:
558 0 : nVal = 1;
559 0 : break;
560 : case RECALC_ASK:
561 0 : nVal = 2;
562 0 : break;
563 : }
564 :
565 0 : pValues[nProp] <<= nVal;
566 : }
567 0 : break;
568 : case SCFORMULAOPT_ODF_RECALC:
569 : {
570 0 : sal_Int32 nVal = 2;
571 0 : switch (GetODFRecalcOptions())
572 : {
573 : case RECALC_ALWAYS:
574 0 : nVal = 0;
575 0 : break;
576 : case RECALC_NEVER:
577 0 : nVal = 1;
578 0 : break;
579 : case RECALC_ASK:
580 0 : nVal = 2;
581 0 : break;
582 : }
583 :
584 0 : pValues[nProp] <<= nVal;
585 : }
586 0 : break;
587 : case SCFORMULAOPT_OPENCL_ENABLED:
588 : {
589 0 : bool bVal = GetCalcConfig().mbOpenCLEnabled;
590 0 : pValues[nProp] <<= bVal;
591 0 : bSetOpenCL = bVal;
592 : }
593 0 : break;
594 : case SCFORMULAOPT_OPENCL_AUTOSELECT:
595 : {
596 0 : bool bVal = GetCalcConfig().mbOpenCLAutoSelect;
597 0 : pValues[nProp] <<= bVal;
598 0 : bSetOpenCL = true;
599 : }
600 0 : break;
601 : case SCFORMULAOPT_OPENCL_DEVICE:
602 : {
603 0 : OUString aOpenCLDevice = GetCalcConfig().maOpenCLDevice;
604 0 : pValues[nProp] <<= aOpenCLDevice;
605 0 : bSetOpenCL = true;
606 : }
607 0 : break;
608 : default:
609 : ;
610 : }
611 : }
612 0 : if(bSetOpenCL)
613 : sc::FormulaGroupInterpreter::switchOpenCLDevice(
614 0 : GetCalcConfig().maOpenCLDevice, GetCalcConfig().mbOpenCLAutoSelect);
615 :
616 0 : PutProperties(aNames, aValues);
617 0 : }
618 :
619 0 : void ScFormulaCfg::SetOptions( const ScFormulaOptions& rNew )
620 : {
621 0 : *(ScFormulaOptions*)this = rNew;
622 0 : SetModified();
623 0 : }
624 :
625 0 : void ScFormulaCfg::Notify( const ::com::sun::star::uno::Sequence< OUString >& rNames)
626 : {
627 0 : UpdateFromProperties( rNames );
628 228 : }
629 :
630 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
