LCOV - code coverage report
Current view: top level - sc/source/core/tool - formulaopt.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 117 294 39.8 %
Date: 2014-11-03 Functions: 13 31 41.9 %
Legend: Lines: hit not hit

          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: */

Generated by: LCOV version 1.10