sc/source/filter/oox/extlstcontext.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 <memory>
  11 #include <extlstcontext.hxx>
  12 #include <worksheethelper.hxx>
  13 #include <oox/core/contexthandler.hxx>
  14 #include <oox/helper/attributelist.hxx>
  15 #include <oox/token/namespaces.hxx>
  16 #include <oox/token/tokens.hxx>
  17 #include <colorscale.hxx>
  18 #include <condformatbuffer.hxx>
  19 #include <condformatcontext.hxx>
  20 #include <document.hxx>
  21 #include <worksheetfragment.hxx>
  22 #include <workbookfragment.hxx>
  23 #include <stylesbuffer.hxx>
  24 #include <stylesfragment.hxx>
  25 #include <SparklineFragment.hxx>
  26
  27 #include <rangeutl.hxx>
  28 #include <sal/log.hxx>
  29
  30 using ::oox::core::ContextHandlerRef;
  31 using ::oox::xls::CondFormatBuffer;
  32
  33 sal_Int32 gnStyleIdx = 0; // Holds index of the <extlst> <cfRule> style (Will be reset by finalize import)
  34
  35 namespace oox::xls {
  36
  37 ExtCfRuleContext::ExtCfRuleContext( WorksheetContextBase& rFragment, ScDataBarFormatData* pTarget ):
  38     WorksheetContextBase( rFragment ),
  39     mpTarget( pTarget ),
  40     mbFirstEntry(true)
  41 {
  42 }
  43
  44 ContextHandlerRef ExtCfRuleContext::onCreateContext( sal_Int32 , const AttributeList& )
  45 {
  46     return this;
  47 }
  48
  49 void ExtCfRuleContext::onStartElement( const AttributeList& rAttribs )
  50 {
  51     switch( getCurrentElement() )
  52     {
  53         case XLS14_TOKEN( dataBar ):
  54         {
  55             ExtCfDataBarRuleRef xRule = getCondFormats().createExtCfDataBarRule(mpTarget);
  56             xRule->importDataBar( rAttribs );
  57             break;
  58         }
  59         case XLS14_TOKEN( fillColor ):
  60         {
  61             ExtCfDataBarRuleRef xRule = getCondFormats().createExtCfDataBarRule(mpTarget);
  62             xRule->importPositiveFillColor( rAttribs );
  63             break;
  64         }
  65         case XLS14_TOKEN( negativeFillColor ):
  66         {
  67             ExtCfDataBarRuleRef xRule = getCondFormats().createExtCfDataBarRule(mpTarget);
  68             xRule->importNegativeFillColor( rAttribs );
  69             break;
  70         }
  71         case XLS14_TOKEN( axisColor ):
  72         {
  73             ExtCfDataBarRuleRef xRule = getCondFormats().createExtCfDataBarRule(mpTarget);
  74             xRule->importAxisColor( rAttribs );
  75             break;
  76         }
  77         case XLS14_TOKEN( cfvo ):
  78         {
  79             ExtCfDataBarRuleRef xRule = getCondFormats().createExtCfDataBarRule(mpTarget);
  80             xRule->importCfvo( rAttribs );
  81             xRule->getModel().mbIsLower = mbFirstEntry;
  82             mbFirstEntry = false;
  83             mpRule = std::move(xRule);
  84             break;
  85         }
  86         default:
  87             break;
  88     }
  89 }
  90
  91 void ExtCfRuleContext::onCharacters( const OUString& rChars )
  92 {
  93     switch( getCurrentElement() )
  94     {
  95         case XM_TOKEN( f ):
  96         {
  97             if (mpRule)
  98             {
  99                 mpRule->getModel().msScaleTypeValue = rChars;
 100             }
 101         }
 102         break;
 103     }
 104 }
 105
 106 void ExtCfRuleContext::onEndElement()
 107 {
 108     switch( getCurrentElement() )
 109     {
 110         case XLS14_TOKEN( cfvo ):
 111         {
 112             mpRule.reset();
 113             break;
 114         }
 115     }
 116 }
 117
 118 namespace {
 119     bool IsSpecificTextCondMode(ScConditionMode eMode)
 120     {
 121         switch (eMode)
 122         {
 123         case ScConditionMode::BeginsWith:
 124         case ScConditionMode::EndsWith:
 125         case ScConditionMode::ContainsText:
 126         case ScConditionMode::NotContainsText:
 127             return true;
 128         default:
 129             break;
 130         }
 131         return false;
 132     }
 133 }
 134
 135 ExtConditionalFormattingContext::ExtConditionalFormattingContext(WorksheetContextBase& rFragment)
 136     : WorksheetContextBase(rFragment)
 137     , nFormulaCount(0)
 138     , nPriority(-1)
 139     , eOperator(ScConditionMode::NONE)
 140     , isPreviousElementF(false)
 141 {
 142 }
 143
 144 ContextHandlerRef ExtConditionalFormattingContext::onCreateContext(sal_Int32 nElement, const AttributeList& rAttribs)
 145 {
 146     if (mpCurrentRule)
 147     {
 148         ScFormatEntry& rFormat = **maEntries.rbegin();
 149         assert(rFormat.GetType() == ScFormatEntry::Type::Iconset);
 150         ScIconSetFormat& rIconSet = static_cast<ScIconSetFormat&>(rFormat);
 151         ScDocument& rDoc = getScDocument();
 152         SCTAB nTab = getSheetIndex();
 153         ScAddress aPos(0, 0, nTab);
 154         mpCurrentRule->SetData(&rIconSet, &rDoc, aPos);
 155         mpCurrentRule.reset();
 156     }
 157     if (nElement == XLS14_TOKEN(cfRule))
 158     {
 159         OUString aType = rAttribs.getString(XML_type, OUString());
 160         OUString aId = rAttribs.getString(XML_id, OUString());
 161         nPriority = rAttribs.getInteger( XML_priority, -1 );
 162         maPriorities.push_back(nPriority);
 163         maModel.nPriority = nPriority;
 164
 165         if (aType == "dataBar")
 166         {
 167             // an ext entry does not need to have an existing corresponding entry
 168             ScDataBarFormatData* pInfo;
 169             ExtLst::const_iterator aExt = getExtLst().find( aId );
 170             if (aExt == getExtLst().end())
 171             {
 172                 pInfo = new ScDataBarFormatData();
 173                 auto pFormat = std::make_unique<ScDataBarFormat>(&getScDocument());
 174                 pFormat->SetDataBarData(pInfo);
 175                 getCondFormats().importExtFormatEntries().push_back(std::move(pFormat));
 176             }
 177             else
 178             {
 179                 pInfo = aExt->second;
 180             }
 181
 182             if (!pInfo)
 183             {
 184                 return nullptr;
 185             }
 186             return new ExtCfRuleContext( *this, pInfo );
 187         }
 188         else if (aType == "iconSet")
 189         {
 190             ScDocument& rDoc = getScDocument();
 191             mpCurrentRule.reset(new IconSetRule(*this));
 192             maEntries.push_back(std::make_unique<ScIconSetFormat>(&rDoc));
 193             return new IconSetContext(*this, mpCurrentRule.get());
 194         }
 195         else if (aType == "cellIs")
 196         {
 197             sal_Int32 aToken = rAttribs.getToken( XML_operator, XML_TOKEN_INVALID );
 198             eOperator =  CondFormatBuffer::convertToInternalOperator(aToken);
 199             maModel.eOperator = eOperator;
 200             return this;
 201         }
 202         else if (aType == "containsText")
 203         {
 204             eOperator = ScConditionMode::ContainsText;
 205             maModel.eOperator = eOperator;
 206             return this;
 207         }
 208         else if (aType == "notContainsText")
 209         {
 210             eOperator = ScConditionMode::NotContainsText;
 211             maModel.eOperator = eOperator;
 212             return this;
 213         }
 214         else if (aType == "beginsWith")
 215         {
 216             eOperator = ScConditionMode::BeginsWith;
 217             maModel.eOperator = eOperator;
 218             return this;
 219         }
 220         else if (aType == "endsWith")
 221         {
 222             eOperator = ScConditionMode::EndsWith;
 223             maModel.eOperator = eOperator;
 224             return this;
 225         }
 226         else if (aType == "expression")
 227         {
 228             eOperator = ScConditionMode::Direct;
 229             maModel.eOperator = eOperator;
 230             return this;
 231         }
 232         else
 233         {
 234             SAL_WARN("sc", "unhandled XLS14_TOKEN(cfRule) with type: " << aType);
 235         }
 236     }
 237     else if (nElement == XLS14_TOKEN( dxf ))
 238     {
 239         return new DxfContext( *this, getStyles().createExtDxf() );
 240     }
 241     else if (nElement == XM_TOKEN( sqref ) || nElement == XM_TOKEN( f ))
 242     {
 243         if(nElement == XM_TOKEN( f ))
 244            nFormulaCount++;
 245         return this;
 246     }
 247
 248     return nullptr;
 249 }
 250
 251 void ExtConditionalFormattingContext::onStartElement(const AttributeList& /*Attribs*/)
 252 {
 253 }
 254
 255 void ExtConditionalFormattingContext::onCharacters(const OUString& rCharacters)
 256 {
 257     switch (getCurrentElement())
 258     {
 259         case XM_TOKEN(f):
 260         {
 261             aChars = rCharacters;
 262             isPreviousElementF = true;
 263         }
 264         break;
 265         case XM_TOKEN(sqref):
 266         {
 267             aChars = rCharacters;
 268         }
 269         break;
 270     }
 271
 272 }
 273
 274 void ExtConditionalFormattingContext::onEndElement()
 275 {
 276     switch (getCurrentElement())
 277     {
 278         case XM_TOKEN(f):
 279         {
 280             if(!IsSpecificTextCondMode(eOperator) || nFormulaCount == 2)
 281                maModel.aFormula = aChars;
 282         }
 283         break;
 284         case XLS14_TOKEN( cfRule ):
 285         {
 286             if (IsSpecificTextCondMode(maModel.eOperator) && nFormulaCount == 1)
 287             {
 288                 maModel.aFormula = aChars;
 289                 maModel.eOperator = ScConditionMode::Direct;
 290             }
 291
 292             if (Dxf* pDxf = getStyles().getExtDxfs().get(gnStyleIdx).get())
 293                 pDxf->finalizeImport();
 294             maModel.aStyle = getStyles().createExtDxfStyle(gnStyleIdx);
 295             gnStyleIdx++;
 296             nFormulaCount = 0;
 297             maModels.push_back(maModel);
 298         }
 299         break;
 300         case XM_TOKEN(sqref):
 301         {
 302             ScRangeList aRange;
 303             ScDocument& rDoc = getScDocument();
 304             bool bSuccess = ScRangeStringConverter::GetRangeListFromString(aRange, aChars, rDoc, formula::FormulaGrammar::CONV_XL_OOX);
 305             if (!bSuccess || aRange.empty())
 306                 break;
 307
 308             SCTAB nTab = getSheetIndex();
 309             for (size_t i = 0; i < aRange.size(); ++i)
 310             {
 311                 aRange[i].aStart.SetTab(nTab);
 312                 aRange[i].aEnd.SetTab(nTab);
 313             }
 314
 315             if (maModels.size() > 1)
 316             {
 317                 std::sort(maModels.begin(), maModels.end(),
 318                           [](const ExtCondFormatRuleModel& lhs, const ExtCondFormatRuleModel& rhs) {
 319                               return lhs.nPriority < rhs.nPriority;
 320                           });
 321             }
 322
 323             if (isPreviousElementF) // sqref can be alone in some cases.
 324             {
 325                 for (size_t i = 0; i < maModels.size(); ++i)
 326                 {
 327                     ScAddress rPos = aRange.GetTopLeftCorner();
 328                     ScCondFormatEntry* pEntry = new ScCondFormatEntry(maModels[i].eOperator, maModels[i].aFormula, u""_ustr, rDoc,
 329                                                                       rPos, maModels[i].aStyle, u""_ustr, u""_ustr,
 330                                                                       formula::FormulaGrammar::GRAM_OOXML ,
 331                                                                       formula::FormulaGrammar::GRAM_OOXML,
 332                                                                       ScFormatEntry::Type::ExtCondition );
 333                     maEntries.push_back(std::unique_ptr<ScFormatEntry>(pEntry));
 334                 }
 335
 336                 assert(maPriorities.size() >= maModels.size());
 337                 maModels.clear();
 338             }
 339
 340             std::vector< std::unique_ptr<ExtCfCondFormat> >& rExtFormats =  getCondFormats().importExtCondFormat();
 341             rExtFormats.push_back(std::make_unique<ExtCfCondFormat>(aRange, maEntries, &maPriorities));
 342
 343             maPriorities.clear();
 344             isPreviousElementF = false;
 345         }
 346         break;
 347         default:
 348         break;
 349     }
 350 }
 351
 352 ExtLstLocalContext::ExtLstLocalContext( WorksheetContextBase& rFragment, ScDataBarFormatData* pTarget ):
 353     WorksheetContextBase(rFragment),
 354     mpTarget(pTarget)
 355 {
 356 }
 357
 358 ContextHandlerRef ExtLstLocalContext::onCreateContext( sal_Int32 nElement, const AttributeList& )
 359 {
 360     switch( getCurrentElement() )
 361     {
 362         case XLS_TOKEN( extLst ):
 363             if(nElement == XLS_TOKEN( ext ))
 364                 return this;
 365             else
 366                 return nullptr;
 367         case XLS_TOKEN( ext ):
 368             if (nElement == XLS14_TOKEN( id ))
 369                 return this;
 370             else
 371                 return nullptr;
 372     }
 373     return nullptr;
 374 }
 375
 376 void ExtLstLocalContext::onStartElement( const AttributeList& )
 377 {
 378     switch( getCurrentElement() )
 379     {
 380         case XLS14_TOKEN( id ):
 381         break;
 382     }
 383 }
 384
 385 void ExtLstLocalContext::onCharacters( const OUString& rChars )
 386 {
 387     if (getCurrentElement() == XLS14_TOKEN( id ))
 388     {
 389         getExtLst().insert( std::pair< OUString, ScDataBarFormatData*>(rChars, mpTarget) );
 390     }
 391 }
 392
 393 ExtGlobalContext::ExtGlobalContext( WorksheetContextBase& rFragment ):
 394     WorksheetContextBase(rFragment)
 395 {
 396 }
 397
 398 ContextHandlerRef ExtGlobalContext::onCreateContext( sal_Int32 nElement, const AttributeList& /*rAttribs*/ )
 399 {
 400     switch (nElement)
 401     {
 402         case XLS14_TOKEN(conditionalFormatting): return new ExtConditionalFormattingContext(*this);
 403         case XLS14_TOKEN(dataValidations):       return new ExtDataValidationsContext(*this);
 404         case XLS14_TOKEN(sparklineGroups): return new SparklineGroupsContext(*this);
 405     }
 406     return this;
 407 }
 408
 409 void ExtGlobalContext::onStartElement( const AttributeList& /*rAttribs*/ )
 410 {
 411 }
 412
 413 ExtLstGlobalContext::ExtLstGlobalContext( WorksheetFragment& rFragment ):
 414     WorksheetContextBase(rFragment)
 415 {
 416 }
 417
 418 ContextHandlerRef ExtLstGlobalContext::onCreateContext( sal_Int32 nElement, const AttributeList& )
 419 {
 420     if (nElement == XLS_TOKEN( ext ))
 421         return new ExtGlobalContext( *this );
 422
 423     return this;
 424 }
 425
 426 ExtGlobalWorkbookContext::ExtGlobalWorkbookContext( WorkbookContextBase& rFragment ):
 427     WorkbookContextBase(rFragment)
 428 {
 429 }
 430
 431 ContextHandlerRef ExtGlobalWorkbookContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
 432 {
 433     if (nElement == LOEXT_TOKEN(extCalcPr))
 434     {
 435         ScDocument& rDoc = getScDocument();
 436         sal_Int32 nToken = rAttribs.getToken( XML_stringRefSyntax, XML_CalcA1 );
 437         ScCalcConfig aCalcConfig = rDoc.GetCalcConfig();
 438
 439         switch( nToken )
 440         {
 441              case XML_CalcA1:
 442                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_OOO );
 443                 break;
 444              case XML_ExcelA1:
 445                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_XL_A1 );
 446                 break;
 447              case XML_ExcelR1C1:
 448                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_XL_R1C1 );
 449                 break;
 450              case XML_CalcA1ExcelA1:
 451                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_A1_XL_A1 );
 452                 break;
 453              default:
 454                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_UNSPECIFIED );
 455                break;
 456         }
 457         rDoc.SetCalcConfig(aCalcConfig);
 458     }
 459
 460     return this;
 461 }
 462
 463 void ExtGlobalWorkbookContext::onStartElement( const AttributeList& /*rAttribs*/ )
 464 {
 465 }
 466
 467 ExtLstGlobalWorkbookContext::ExtLstGlobalWorkbookContext( WorkbookFragment& rFragment ):
 468     WorkbookContextBase(rFragment)
 469 {
 470 }
 471
 472 ContextHandlerRef ExtLstGlobalWorkbookContext::onCreateContext( sal_Int32 nElement, const AttributeList& )
 473 {
 474     if (nElement == XLS_TOKEN( ext ))
 475         return new ExtGlobalWorkbookContext( *this );
 476
 477     return this;
 478 }
 479
 480 } //namespace oox::xls
 481
 482 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */