sc/source/filter/xml/xmlcvali.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "xmlcvali.hxx"
  21 #include "xmlimprt.hxx"
  22 #include "xmlconti.hxx"
  23 #include <document.hxx>
  24 #include "XMLConverter.hxx"
  25
  26 #include <xmloff/xmltoken.hxx>
  27 #include <xmloff/xmlnamespace.hxx>
  28 #include <xmloff/XMLEventsImportContext.hxx>
  29 #include <com/sun/star/sheet/TableValidationVisibility.hpp>
  30
  31 using namespace com::sun::star;
  32 using namespace xmloff::token;
  33 using namespace ::formula;
  34
  35 namespace {
  36
  37 class ScXMLContentValidationContext : public ScXMLImportContext
  38 {
  39     OUString      sName;
  40     OUString      sHelpTitle;
  41     OUString      sHelpMessage;
  42     OUString      sErrorTitle;
  43     OUString      sErrorMessage;
  44     OUString      sErrorMessageType;
  45     OUString      sBaseCellAddress;
  46     OUString      sCondition;
  47     sal_Int16          nShowList;
  48     bool           bAllowEmptyCell;
  49     bool           bIsCaseSensitive;
  50     bool           bDisplayHelp;
  51     bool           bDisplayError;
  52
  53     rtl::Reference<XMLEventsImportContext> xEventContext;
  54
  55     css::sheet::ValidationAlertStyle GetAlertStyle() const;
  56     void SetFormula( OUString& rFormula, OUString& rFormulaNmsp, FormulaGrammar::Grammar& reGrammar,
  57         const OUString& rCondition, const OUString& rGlobNmsp, FormulaGrammar::Grammar eGlobGrammar, bool bHasNmsp ) const;
  58     void GetCondition( ScMyImportValidation& rValidation ) const;
  59
  60 public:
  61
  62     ScXMLContentValidationContext( ScXMLImport& rImport,
  63                         const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList );
  64
  65     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
  66         sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
  67
  68     virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
  69
  70     void SetHelpMessage(const OUString& sTitle, const OUString& sMessage, const bool bDisplay);
  71     void SetErrorMessage(const OUString& sTitle, const OUString& sMessage, const OUString& sMessageType, const bool bDisplay);
  72     void SetErrorMacro(const bool bExecute);
  73 };
  74
  75 class ScXMLHelpMessageContext : public ScXMLImportContext
  76 {
  77     OUString   sTitle;
  78     OUStringBuffer sMessage;
  79     sal_Int32       nParagraphCount;
  80     bool        bDisplay;
  81
  82     ScXMLContentValidationContext* pValidationContext;
  83
  84 public:
  85
  86     ScXMLHelpMessageContext( ScXMLImport& rImport,
  87                         const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
  88                         ScXMLContentValidationContext* pValidationContext);
  89
  90     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
  91         sal_Int32 nElement,
  92         const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
  93
  94     virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
  95 };
  96
  97 class ScXMLErrorMessageContext : public ScXMLImportContext
  98 {
  99     OUString   sTitle;
 100     OUStringBuffer sMessage;
 101     OUString   sMessageType;
 102     sal_Int32       nParagraphCount;
 103     bool        bDisplay;
 104
 105     ScXMLContentValidationContext* pValidationContext;
 106
 107 public:
 108
 109     ScXMLErrorMessageContext( ScXMLImport& rImport,
 110                         const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 111                         ScXMLContentValidationContext* pValidationContext);
 112
 113     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
 114         sal_Int32 nElement,
 115         const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
 116
 117     virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
 118 };
 119
 120 class ScXMLErrorMacroContext : public ScXMLImportContext
 121 {
 122     bool        bExecute;
 123     ScXMLContentValidationContext*  pValidationContext;
 124
 125 public:
 126
 127     ScXMLErrorMacroContext( ScXMLImport& rImport,
 128                         const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 129                         ScXMLContentValidationContext* pValidationContext);
 130
 131     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
 132         sal_Int32 nElement,
 133         const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
 134     virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
 135 };
 136
 137 }
 138
 139 ScXMLContentValidationsContext::ScXMLContentValidationsContext( ScXMLImport& rImport ) :
 140     ScXMLImportContext( rImport )
 141 {
 142     // here are no attributes
 143 }
 144
 145 ScXMLContentValidationsContext::~ScXMLContentValidationsContext()
 146 {
 147 }
 148
 149 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLContentValidationsContext::createFastChildContext(
 150     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 151 {
 152     SvXMLImportContext *pContext = nullptr;
 153     sax_fastparser::FastAttributeList *pAttribList =
 154         &sax_fastparser::castToFastAttributeList( xAttrList );
 155
 156     switch (nElement)
 157     {
 158         case XML_ELEMENT( TABLE, XML_CONTENT_VALIDATION ):
 159             pContext = new ScXMLContentValidationContext( GetScImport(), pAttribList );
 160         break;
 161     }
 162
 163     return pContext;
 164 }
 165
 166 ScXMLContentValidationContext::ScXMLContentValidationContext( ScXMLImport& rImport,
 167                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList ) :
 168     ScXMLImportContext( rImport ),
 169     nShowList(sheet::TableValidationVisibility::UNSORTED),
 170     bAllowEmptyCell(true),
 171     bIsCaseSensitive(false),
 172     bDisplayHelp(false),
 173     bDisplayError(false)
 174 {
 175     if ( !rAttrList.is() )
 176         return;
 177
 178     for (auto &aIter : *rAttrList)
 179     {
 180         switch (aIter.getToken())
 181         {
 182         case XML_ELEMENT( TABLE, XML_NAME ):
 183             sName = aIter.toString();
 184             break;
 185         case XML_ELEMENT( TABLE, XML_CONDITION ):
 186             sCondition = aIter.toString();
 187             break;
 188         case XML_ELEMENT( TABLE, XML_BASE_CELL_ADDRESS ):
 189             sBaseCellAddress = aIter.toString();
 190             break;
 191         case XML_ELEMENT( TABLE, XML_ALLOW_EMPTY_CELL ):
 192             if (IsXMLToken(aIter, XML_FALSE))
 193                 bAllowEmptyCell = false;
 194             break;
 195         case XML_ELEMENT( TABLE, XML_CASE_SENSITIVE ):
 196             if (IsXMLToken(aIter, XML_TRUE))
 197                 bIsCaseSensitive = true;
 198             break;
 199         case XML_ELEMENT( TABLE, XML_DISPLAY_LIST ):
 200             if (IsXMLToken(aIter, XML_NO))
 201             {
 202                 nShowList = sheet::TableValidationVisibility::INVISIBLE;
 203             }
 204             else if (IsXMLToken(aIter, XML_UNSORTED))
 205             {
 206                 nShowList = sheet::TableValidationVisibility::UNSORTED;
 207             }
 208             else if (IsXMLToken(aIter, XML_SORT_ASCENDING))
 209             {
 210                 nShowList = sheet::TableValidationVisibility::SORTEDASCENDING;
 211             }
 212             else if (IsXMLToken(aIter, XML_SORTED_ASCENDING))
 213             {
 214                 // Read old wrong value, fdo#72548
 215                 nShowList = sheet::TableValidationVisibility::SORTEDASCENDING;
 216             }
 217             break;
 218         }
 219     }
 220 }
 221
 222 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLContentValidationContext::createFastChildContext(
 223     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 224 {
 225     SvXMLImportContext *pContext = nullptr;
 226     sax_fastparser::FastAttributeList *pAttribList =
 227         &sax_fastparser::castToFastAttributeList( xAttrList );
 228
 229     switch (nElement)
 230     {
 231     case XML_ELEMENT( TABLE, XML_HELP_MESSAGE ):
 232         pContext = new ScXMLHelpMessageContext( GetScImport(), pAttribList, this);
 233         break;
 234     case XML_ELEMENT( TABLE, XML_ERROR_MESSAGE ):
 235         pContext = new ScXMLErrorMessageContext( GetScImport(), pAttribList, this);
 236         break;
 237     case XML_ELEMENT( TABLE, XML_ERROR_MACRO ):
 238         pContext = new ScXMLErrorMacroContext( GetScImport(), pAttribList, this);
 239         break;
 240     case XML_ELEMENT(OFFICE, XML_EVENT_LISTENERS):
 241         xEventContext = new XMLEventsImportContext( GetImport() );
 242         pContext = xEventContext.get();
 243     }
 244
 245     return pContext;
 246 }
 247
 248 sheet::ValidationAlertStyle ScXMLContentValidationContext::GetAlertStyle() const
 249 {
 250     if (IsXMLToken(sErrorMessageType, XML_MACRO))
 251         return sheet::ValidationAlertStyle_MACRO;
 252     if (IsXMLToken(sErrorMessageType, XML_STOP))
 253         return sheet::ValidationAlertStyle_STOP;
 254     if (IsXMLToken(sErrorMessageType, XML_WARNING))
 255         return sheet::ValidationAlertStyle_WARNING;
 256     if (IsXMLToken(sErrorMessageType, XML_INFORMATION))
 257         return sheet::ValidationAlertStyle_INFO;
 258     // default for unknown
 259     return sheet::ValidationAlertStyle_STOP;
 260 }
 261
 262 void ScXMLContentValidationContext::SetFormula( OUString& rFormula, OUString& rFormulaNmsp, FormulaGrammar::Grammar& reGrammar,
 263     const OUString& rCondition, const OUString& rGlobNmsp, FormulaGrammar::Grammar eGlobGrammar, bool bHasNmsp ) const
 264 {
 265     reGrammar = FormulaGrammar::GRAM_UNSPECIFIED;
 266     if( bHasNmsp )
 267     {
 268         // the entire attribute contains a namespace: internal namespace not allowed
 269         rFormula = rCondition;
 270         rFormulaNmsp = rGlobNmsp;
 271         reGrammar = eGlobGrammar;
 272     }
 273     else
 274     {
 275         // the attribute does not contain a namespace: try to find a namespace of an external grammar
 276         GetScImport().ExtractFormulaNamespaceGrammar( rFormula, rFormulaNmsp, reGrammar, rCondition, true );
 277         if( reGrammar != FormulaGrammar::GRAM_EXTERNAL )
 278             reGrammar = eGlobGrammar;
 279     }
 280 }
 281
 282 void ScXMLContentValidationContext::GetCondition( ScMyImportValidation& rValidation ) const
 283 {
 284     rValidation.aValidationType = sheet::ValidationType_ANY;    // default if no condition is given
 285     rValidation.aOperator = sheet::ConditionOperator_NONE;
 286
 287     if( sCondition.isEmpty() )
 288         return;
 289
 290     // extract leading namespace from condition string
 291     OUString aCondition, aConditionNmsp;
 292     FormulaGrammar::Grammar eGrammar = FormulaGrammar::GRAM_UNSPECIFIED;
 293     GetScImport().ExtractFormulaNamespaceGrammar( aCondition, aConditionNmsp, eGrammar, sCondition );
 294     bool bHasNmsp = aCondition.getLength() < sCondition.getLength();
 295
 296     // parse a condition from the attribute string
 297     ScXMLConditionParseResult aParseResult;
 298     ScXMLConditionHelper::parseCondition( aParseResult, aCondition, 0 );
 299
 300     /*  Check the result. A valid value in aParseResult.meToken implies
 301         that the other members of aParseResult are filled with valid data
 302         for that token. */
 303     bool bSecondaryPart = false;
 304     switch( aParseResult.meToken )
 305     {
 306         case XML_COND_TEXTLENGTH:               // condition is 'cell-content-text-length()<operator><expression>'
 307         case XML_COND_TEXTLENGTH_ISBETWEEN:     // condition is 'cell-content-text-length-is-between(<expression1>,<expression2>)'
 308         case XML_COND_TEXTLENGTH_ISNOTBETWEEN:  // condition is 'cell-content-text-length-is-not-between(<expression1>,<expression2>)'
 309         case XML_COND_ISINLIST:                 // condition is 'cell-content-is-in-list(<expression>)'
 310         case XML_COND_ISTRUEFORMULA:            // condition is 'is-true-formula(<expression>)'
 311             rValidation.aValidationType = aParseResult.meValidation;
 312             rValidation.aOperator = aParseResult.meOperator;
 313         break;
 314
 315         case XML_COND_ISWHOLENUMBER:            // condition is 'cell-content-is-whole-number() and <condition>'
 316         case XML_COND_ISDECIMALNUMBER:          // condition is 'cell-content-is-decimal-number() and <condition>'
 317         case XML_COND_ISDATE:                   // condition is 'cell-content-is-date() and <condition>'
 318         case XML_COND_ISTIME:                   // condition is 'cell-content-is-time() and <condition>'
 319             rValidation.aValidationType = aParseResult.meValidation;
 320             bSecondaryPart = true;
 321         break;
 322
 323         default:;   // unacceptable or unknown condition
 324     }
 325
 326     /*  Parse the following 'and <condition>' part of some conditions. This
 327         updates the members of aParseResult that will contain the operands
 328         and comparison operator then. */
 329     if( bSecondaryPart )
 330     {
 331         ScXMLConditionHelper::parseCondition( aParseResult, aCondition, aParseResult.mnEndIndex );
 332         if( aParseResult.meToken == XML_COND_AND )
 333         {
 334             ScXMLConditionHelper::parseCondition( aParseResult, aCondition, aParseResult.mnEndIndex );
 335             switch( aParseResult.meToken )
 336             {
 337                 case XML_COND_CELLCONTENT:  // condition is 'and cell-content()<operator><expression>'
 338                 case XML_COND_ISBETWEEN:    // condition is 'and cell-content-is-between(<expression1>,<expression2>)'
 339                 case XML_COND_ISNOTBETWEEN: // condition is 'and cell-content-is-not-between(<expression1>,<expression2>)'
 340                     rValidation.aOperator = aParseResult.meOperator;
 341                 break;
 342                 default:;   // unacceptable or unknown condition
 343             }
 344         }
 345     }
 346
 347     // a validation type (date, integer) without a condition isn't possible
 348     if( rValidation.aOperator == sheet::ConditionOperator_NONE )
 349         rValidation.aValidationType = sheet::ValidationType_ANY;
 350
 351     // parse the formulas
 352     if( rValidation.aValidationType != sheet::ValidationType_ANY )
 353     {
 354         SetFormula( rValidation.sFormula1, rValidation.sFormulaNmsp1, rValidation.eGrammar1,
 355             aParseResult.maOperand1, aConditionNmsp, eGrammar, bHasNmsp );
 356         SetFormula( rValidation.sFormula2, rValidation.sFormulaNmsp2, rValidation.eGrammar2,
 357             aParseResult.maOperand2, aConditionNmsp, eGrammar, bHasNmsp );
 358     }
 359 }
 360
 361 void SAL_CALL ScXMLContentValidationContext::endFastElement( sal_Int32 /*nElement*/ )
 362 {
 363     // #i36650# event-listeners element moved up one level
 364     if (xEventContext.is())
 365     {
 366         uno::Sequence<beans::PropertyValue> aValues;
 367         xEventContext->GetEventSequence( u"OnError"_ustr, aValues );
 368
 369         auto pValue = std::find_if(std::cbegin(aValues), std::cend(aValues),
 370             [](const beans::PropertyValue& rValue) {
 371                 return rValue.Name == "MacroName" || rValue.Name == "Script"; });
 372         if (pValue != std::cend(aValues))
 373             pValue->Value >>= sErrorTitle;
 374     }
 375
 376     ScMyImportValidation aValidation;
 377     if (ScDocument* pDoc = GetScImport().GetDocument())
 378         aValidation.eGrammar1 = aValidation.eGrammar2 = pDoc->GetStorageGrammar();
 379     aValidation.sName = sName;
 380     aValidation.sBaseCellAddress = sBaseCellAddress;
 381     aValidation.sInputTitle = sHelpTitle;
 382     aValidation.sInputMessage = sHelpMessage;
 383     aValidation.sErrorTitle = sErrorTitle;
 384     aValidation.sErrorMessage = sErrorMessage;
 385     GetCondition( aValidation );
 386     aValidation.aAlertStyle = GetAlertStyle();
 387     aValidation.bShowErrorMessage = bDisplayError;
 388     aValidation.bShowInputMessage = bDisplayHelp;
 389     aValidation.bIgnoreBlanks = bAllowEmptyCell;
 390     aValidation.bCaseSensitive = bIsCaseSensitive;
 391     aValidation.nShowList = nShowList;
 392     GetScImport().AddValidation(aValidation);
 393 }
 394
 395 void ScXMLContentValidationContext::SetHelpMessage(const OUString& sTitle, const OUString& sMessage, const bool bDisplay)
 396 {
 397     sHelpTitle = sTitle;
 398     sHelpMessage = sMessage;
 399     bDisplayHelp = bDisplay;
 400 }
 401
 402 void ScXMLContentValidationContext::SetErrorMessage(const OUString& sTitle, const OUString& sMessage,
 403     const OUString& sMessageType, const bool bDisplay)
 404 {
 405     sErrorTitle = sTitle;
 406     sErrorMessage = sMessage;
 407     sErrorMessageType = sMessageType;
 408     bDisplayError = bDisplay;
 409 }
 410
 411 void ScXMLContentValidationContext::SetErrorMacro(const bool bExecute)
 412 {
 413     sErrorMessageType = "macro";
 414     bDisplayError = bExecute;
 415 }
 416
 417 ScXMLHelpMessageContext::ScXMLHelpMessageContext( ScXMLImport& rImport,
 418                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 419                                       ScXMLContentValidationContext* pTempValidationContext) :
 420     ScXMLImportContext( rImport ),
 421     nParagraphCount(0),
 422     bDisplay(false)
 423 {
 424     pValidationContext = pTempValidationContext;
 425     if ( !rAttrList.is() )
 426         return;
 427
 428     for (auto &aIter : *rAttrList)
 429     {
 430         switch (aIter.getToken())
 431         {
 432         case XML_ELEMENT( TABLE, XML_TITLE ):
 433             sTitle = aIter.toString();
 434             break;
 435         case XML_ELEMENT( TABLE, XML_DISPLAY ):
 436             bDisplay = IsXMLToken(aIter, XML_TRUE);
 437             break;
 438         }
 439     }
 440 }
 441
 442 css::uno::Reference< css::xml::sax::XFastContextHandler > ScXMLHelpMessageContext::createFastChildContext(
 443         sal_Int32 nElement,
 444         const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/ )
 445 {
 446     SvXMLImportContext *pContext = nullptr;
 447
 448     switch( nElement )
 449     {
 450         case XML_ELEMENT(TEXT, XML_P):
 451         {
 452             if(nParagraphCount)
 453                 sMessage.append('\n');
 454             ++nParagraphCount;
 455             pContext = new ScXMLContentContext( GetScImport(), sMessage );
 456         }
 457         break;
 458     }
 459
 460     return pContext;
 461 }
 462
 463 void SAL_CALL ScXMLHelpMessageContext::endFastElement( sal_Int32 /*nElement*/ )
 464 {
 465     pValidationContext->SetHelpMessage(sTitle, sMessage.makeStringAndClear(), bDisplay);
 466 }
 467
 468 ScXMLErrorMessageContext::ScXMLErrorMessageContext( ScXMLImport& rImport,
 469                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 470                                       ScXMLContentValidationContext* pTempValidationContext) :
 471     ScXMLImportContext( rImport ),
 472     nParagraphCount(0),
 473     bDisplay(false)
 474 {
 475     pValidationContext = pTempValidationContext;
 476     if ( !rAttrList.is() )
 477         return;
 478
 479     for (auto &aIter : *rAttrList)
 480     {
 481         switch (aIter.getToken())
 482         {
 483         case XML_ELEMENT( TABLE, XML_TITLE ):
 484             sTitle = aIter.toString();
 485             break;
 486         case XML_ELEMENT( TABLE, XML_MESSAGE_TYPE ):
 487             sMessageType = aIter.toString();
 488             break;
 489         case XML_ELEMENT( TABLE, XML_DISPLAY ):
 490             bDisplay = IsXMLToken(aIter, XML_TRUE);
 491             break;
 492         }
 493     }
 494 }
 495
 496 css::uno::Reference< css::xml::sax::XFastContextHandler > ScXMLErrorMessageContext::createFastChildContext(
 497         sal_Int32 nElement,
 498         const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/ )
 499 {
 500     SvXMLImportContext *pContext = nullptr;
 501
 502     switch( nElement )
 503     {
 504         case XML_ELEMENT(TEXT, XML_P):
 505         {
 506             if(nParagraphCount)
 507                 sMessage.append('\n');
 508             ++nParagraphCount;
 509             pContext = new ScXMLContentContext( GetScImport(), sMessage);
 510         }
 511         break;
 512     }
 513
 514     return pContext;
 515 }
 516
 517 void SAL_CALL ScXMLErrorMessageContext::endFastElement( sal_Int32 /*nElement*/ )
 518 {
 519     pValidationContext->SetErrorMessage(sTitle, sMessage.makeStringAndClear(), sMessageType, bDisplay);
 520 }
 521
 522 ScXMLErrorMacroContext::ScXMLErrorMacroContext( ScXMLImport& rImport,
 523                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 524                                       ScXMLContentValidationContext* pTempValidationContext) :
 525     ScXMLImportContext( rImport ),
 526     bExecute(false)
 527 {
 528     pValidationContext = pTempValidationContext;
 529     if ( !rAttrList.is() )
 530         return;
 531
 532     for (auto &aIter : *rAttrList)
 533     {
 534         switch (aIter.getToken())
 535         {
 536         case XML_ELEMENT( TABLE, XML_NAME ):
 537             break;
 538         case XML_ELEMENT( TABLE, XML_EXECUTE ):
 539             bExecute = IsXMLToken(aIter, XML_TRUE);
 540             break;
 541         }
 542     }
 543 }
 544
 545 css::uno::Reference< css::xml::sax::XFastContextHandler >  ScXMLErrorMacroContext::createFastChildContext(
 546     sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/ )
 547 {
 548     SvXMLImportContext *pContext = nullptr;
 549
 550     if (nElement == XML_ELEMENT(SCRIPT, XML_EVENTS))
 551     {
 552         pContext = new XMLEventsImportContext(GetImport());
 553     }
 554
 555     return pContext;
 556 }
 557
 558 void SAL_CALL ScXMLErrorMacroContext::endFastElement( sal_Int32 /*nElement*/ )
 559 {
 560     pValidationContext->SetErrorMacro( bExecute );
 561 }
 562
 563 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */