sc/source/core/tool/formulaopt.cxx

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