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