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
  26 #include <rangeutl.hxx>
  27 #include <sal/log.hxx>
  28
  29 using ::oox::core::ContextHandlerRef;
  30 using ::oox::xls::CondFormatBuffer;
  31
  32 sal_Int32 rStyleIdx = 0;
  33
  34 namespace oox {
  35 namespace 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( negativeFillColor ):
  60         {
  61             ExtCfDataBarRuleRef xRule = getCondFormats().createExtCfDataBarRule(mpTarget);
  62             xRule->importNegativeFillColor( rAttribs );
  63             break;
  64         }
  65         case XLS14_TOKEN( axisColor ):
  66         {
  67             ExtCfDataBarRuleRef xRule = getCondFormats().createExtCfDataBarRule(mpTarget);
  68             xRule->importAxisColor( rAttribs );
  69             break;
  70         }
  71         case XLS14_TOKEN( cfvo ):
  72         {
  73             ExtCfDataBarRuleRef xRule = getCondFormats().createExtCfDataBarRule(mpTarget);
  74             xRule->importCfvo( rAttribs );
  75             xRule->getModel().mbIsLower = mbFirstEntry;
  76             mbFirstEntry = false;
  77             break;
  78         }
  79         default:
  80             break;
  81     }
  82 }
  83
  84 ExtConditionalFormattingContext::ExtConditionalFormattingContext(WorksheetContextBase& rFragment)
  85     : WorksheetContextBase(rFragment)
  86     , nPriority(-1)
  87     , eOperator(ScConditionMode::NONE)
  88     , isPreviousElementF(false)
  89 {
  90 }
  91
  92 ContextHandlerRef ExtConditionalFormattingContext::onCreateContext(sal_Int32 nElement, const AttributeList& rAttribs)
  93 {
  94     if (mpCurrentRule)
  95     {
  96         ScFormatEntry& rFormat = **maEntries.rbegin();
  97         assert(rFormat.GetType() == ScFormatEntry::Type::Iconset);
  98         ScIconSetFormat& rIconSet = static_cast<ScIconSetFormat&>(rFormat);
  99         ScDocument* pDoc = &getScDocument();
 100         SCTAB nTab = getSheetIndex();
 101         ScAddress aPos(0, 0, nTab);
 102         mpCurrentRule->SetData(&rIconSet, pDoc, aPos);
 103         mpCurrentRule.reset();
 104     }
 105     if (nElement == XLS14_TOKEN(cfRule))
 106     {
 107         OUString aType = rAttribs.getString(XML_type, OUString());
 108         OUString aId = rAttribs.getString(XML_id, OUString());
 109         nPriority = rAttribs.getInteger( XML_priority, -1 );
 110         maPriorities.push_back(nPriority);
 111
 112         if (aType == "dataBar")
 113         {
 114             // an ext entry does not need to have an existing corresponding entry
 115             ExtLst::const_iterator aExt = getExtLst().find( aId );
 116             if(aExt == getExtLst().end())
 117                 return nullptr;
 118
 119             ScDataBarFormatData* pInfo = aExt->second;
 120             if (!pInfo)
 121             {
 122                 return nullptr;
 123             }
 124             return new ExtCfRuleContext( *this, pInfo );
 125         }
 126         else if (aType == "iconSet")
 127         {
 128             ScDocument* pDoc = &getScDocument();
 129             mpCurrentRule.reset(new IconSetRule(*this));
 130             maEntries.push_back(std::make_unique<ScIconSetFormat>(pDoc));
 131             return new IconSetContext(*this, mpCurrentRule.get());
 132         }
 133         else if (aType == "cellIs")
 134         {
 135             sal_Int32 aToken = rAttribs.getToken( XML_operator, XML_TOKEN_INVALID );
 136             eOperator =  CondFormatBuffer::convertToInternalOperator(aToken);
 137             return this;
 138         }
 139         else
 140         {
 141             SAL_WARN("sc", "unhandled XLS14_TOKEN(cfRule) with type: " << aType);
 142         }
 143     }
 144     else if (nElement == XLS14_TOKEN( dxf ))
 145     {
 146         return new DxfContext( *this, getStyles().createExtDxf() );
 147     }
 148     else if (nElement == XM_TOKEN( sqref ) || nElement == XM_TOKEN( f ))
 149     {
 150         return this;
 151     }
 152
 153     return nullptr;
 154 }
 155
 156 void ExtConditionalFormattingContext::onStartElement(const AttributeList& /*Attribs*/)
 157 {
 158 }
 159
 160 void ExtConditionalFormattingContext::onCharacters(const OUString& rCharacters)
 161 {
 162     switch (getCurrentElement())
 163     {
 164         case XM_TOKEN(f):
 165         {
 166             aChars = rCharacters;
 167             isPreviousElementF = true;
 168         }
 169         break;
 170         case XM_TOKEN(sqref):
 171         {
 172             aChars = rCharacters;
 173         }
 174         break;
 175     }
 176
 177 }
 178
 179 void ExtConditionalFormattingContext::onEndElement()
 180 {
 181     switch (getCurrentElement())
 182     {
 183         case XM_TOKEN(f):
 184         {
 185             rFormulas.push_back(aChars);
 186         }
 187         break;
 188         case XLS14_TOKEN( cfRule ):
 189         {
 190             getStyles().getExtDxfs().forEachMem( &Dxf::finalizeImport );
 191         }
 192         break;
 193         case XM_TOKEN(sqref):
 194         {
 195             ScRangeList aRange;
 196             ScDocument* pDoc = &getScDocument();
 197             bool bSuccess = ScRangeStringConverter::GetRangeListFromString(aRange, aChars, pDoc, formula::FormulaGrammar::CONV_XL_OOX);
 198             if (!bSuccess || aRange.empty())
 199                 break;
 200
 201             SCTAB nTab = getSheetIndex();
 202             for (size_t i = 0; i < aRange.size(); ++i)
 203             {
 204                 aRange[i].aStart.SetTab(nTab);
 205                 aRange[i].aEnd.SetTab(nTab);
 206             }
 207
 208             if (isPreviousElementF) // sqref can be alone in some cases.
 209             {
 210                 for (const OUString& rFormula : rFormulas)
 211                 {
 212                     ScAddress rPos = aRange.GetTopLeftCorner();
 213                     rStyle = getStyles().createExtDxfStyle(rStyleIdx);
 214                     ScCondFormatEntry* pEntry = new ScCondFormatEntry(eOperator, rFormula, "", pDoc,
 215                                                                       rPos, rStyle, "", "",
 216                                                                       formula::FormulaGrammar::GRAM_OOXML ,
 217                                                                       formula::FormulaGrammar::GRAM_OOXML,
 218                                                                       ScFormatEntry::Type::ExtCondition );
 219                     maEntries.push_back(std::unique_ptr<ScFormatEntry>(pEntry));
 220                     rStyleIdx++;
 221                 }
 222
 223                 assert(rFormulas.size() == maPriorities.size());
 224                 rFormulas.clear();
 225             }
 226
 227             std::vector< std::unique_ptr<ExtCfCondFormat> >& rExtFormats =  getCondFormats().importExtCondFormat();
 228             rExtFormats.push_back(std::make_unique<ExtCfCondFormat>(aRange, maEntries, &maPriorities));
 229
 230             maPriorities.clear();
 231             isPreviousElementF = false;
 232         }
 233         break;
 234         default:
 235         break;
 236     }
 237 }
 238
 239 ExtLstLocalContext::ExtLstLocalContext( WorksheetContextBase& rFragment, ScDataBarFormatData* pTarget ):
 240     WorksheetContextBase(rFragment),
 241     mpTarget(pTarget)
 242 {
 243 }
 244
 245 ContextHandlerRef ExtLstLocalContext::onCreateContext( sal_Int32 nElement, const AttributeList& )
 246 {
 247     switch( getCurrentElement() )
 248     {
 249         case XLS_TOKEN( extLst ):
 250             if(nElement == XLS_TOKEN( ext ))
 251                 return this;
 252             else
 253                 return nullptr;
 254             break;
 255         case XLS_TOKEN( ext ):
 256             if (nElement == XLS14_TOKEN( id ))
 257                 return this;
 258             else
 259                 return nullptr;
 260     }
 261     return nullptr;
 262 }
 263
 264 void ExtLstLocalContext::onStartElement( const AttributeList& )
 265 {
 266     switch( getCurrentElement() )
 267     {
 268         case XLS14_TOKEN( id ):
 269         break;
 270     }
 271 }
 272
 273 void ExtLstLocalContext::onCharacters( const OUString& rChars )
 274 {
 275     if (getCurrentElement() == XLS14_TOKEN( id ))
 276     {
 277         getExtLst().insert( std::pair< OUString, ScDataBarFormatData*>(rChars, mpTarget) );
 278     }
 279 }
 280
 281 ExtGlobalContext::ExtGlobalContext( WorksheetContextBase& rFragment ):
 282     WorksheetContextBase(rFragment)
 283 {
 284 }
 285
 286 ContextHandlerRef ExtGlobalContext::onCreateContext( sal_Int32 nElement, const AttributeList& /*rAttribs*/ )
 287 {
 288     switch (nElement)
 289     {
 290         case XLS14_TOKEN(conditionalFormatting): return new ExtConditionalFormattingContext(*this);
 291         case XLS14_TOKEN(dataValidations):       return new ExtDataValidationsContext(*this);
 292     }
 293     return this;
 294 }
 295
 296 void ExtGlobalContext::onStartElement( const AttributeList& /*rAttribs*/ )
 297 {
 298 }
 299
 300 ExtLstGlobalContext::ExtLstGlobalContext( WorksheetFragment& rFragment ):
 301     WorksheetContextBase(rFragment)
 302 {
 303 }
 304
 305 ContextHandlerRef ExtLstGlobalContext::onCreateContext( sal_Int32 nElement, const AttributeList& )
 306 {
 307     if (nElement == XLS_TOKEN( ext ))
 308         return new ExtGlobalContext( *this );
 309
 310     return this;
 311 }
 312
 313 ExtGlobalWorkbookContext::ExtGlobalWorkbookContext( WorkbookContextBase& rFragment ):
 314     WorkbookContextBase(rFragment)
 315 {
 316 }
 317
 318 ContextHandlerRef ExtGlobalWorkbookContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
 319 {
 320     if (nElement == LOEXT_TOKEN(extCalcPr))
 321     {
 322         ScDocument* pDoc = &getScDocument();
 323         sal_Int32 nToken = rAttribs.getToken( XML_stringRefSyntax, XML_CalcA1 );
 324         ScCalcConfig aCalcConfig = pDoc->GetCalcConfig();
 325
 326         switch( nToken )
 327         {
 328              case XML_CalcA1:
 329                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_OOO );
 330                 break;
 331              case XML_ExcelA1:
 332                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_XL_A1 );
 333                 break;
 334              case XML_ExcelR1C1:
 335                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_XL_R1C1 );
 336                 break;
 337              case XML_CalcA1ExcelA1:
 338                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_A1_XL_A1 );
 339                 break;
 340              default:
 341                 aCalcConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_UNSPECIFIED );
 342                break;
 343         }
 344         pDoc->SetCalcConfig(aCalcConfig);
 345     }
 346
 347     return this;
 348 }
 349
 350 void ExtGlobalWorkbookContext::onStartElement( const AttributeList& /*rAttribs*/ )
 351 {
 352 }
 353
 354 ExtLstGlobalWorkbookContext::ExtLstGlobalWorkbookContext( WorkbookFragment& rFragment ):
 355     WorkbookContextBase(rFragment)
 356 {
 357 }
 358
 359 ContextHandlerRef ExtLstGlobalWorkbookContext::onCreateContext( sal_Int32 nElement, const AttributeList& )
 360 {
 361     if (nElement == XLS_TOKEN( ext ))
 362         return new ExtGlobalWorkbookContext( *this );
 363
 364     return this;
 365 }
 366
 367 } //namespace oox
 368 } //namespace xls
 369
 370 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */