writerfilter/source/ooxml/OOXMLFastContextHandler.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 <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  21 #include <com/sun/star/xml/sax/FastShapeContextHandler.hpp>
  22 #include <com/sun/star/xml/sax/SAXException.hpp>
  23 #include <ooxml/resourceids.hxx>
  24 #include <oox/token/namespaces.hxx>
  25 #include <sal/log.hxx>
  26 #include <comphelper/embeddedobjectcontainer.hxx>
  27 #include <cppuhelper/exc_hlp.hxx>
  28 #include <tools/globname.hxx>
  29 #include <comphelper/classids.hxx>
  30 #include <sfx2/sfxbasemodel.hxx>
  31 #include "OOXMLFastContextHandler.hxx"
  32 #include "OOXMLFactory.hxx"
  33 #include "Handler.hxx"
  34
  35 static const sal_Unicode uCR = 0xd;
  36 static const sal_Unicode uFtnEdnSep = 0x3;
  37 static const sal_Unicode uTab = 0x9;
  38 static const sal_Unicode uPgNum = 0x0;
  39 static const sal_Unicode uNoBreakHyphen = 0x2011;
  40 static const sal_Unicode uSoftHyphen = 0xAD;
  41
  42 static const sal_uInt8 cFtnEdnCont = 0x4;
  43 static const sal_uInt8 cFieldLock = 0x8;
  44
  45 namespace writerfilter {
  46 namespace ooxml
  47 {
  48 using namespace ::com::sun::star;
  49 using namespace oox;
  50 using namespace ::std;
  51
  52 /*
  53   class OOXMLFastContextHandler
  54  */
  55
  56 OOXMLFastContextHandler::OOXMLFastContextHandler
  57 (uno::Reference< uno::XComponentContext > const & context)
  58 : mpParent(nullptr),
  59   mId(0),
  60   mnDefine(0),
  61   mnToken(oox::XML_TOKEN_COUNT),
  62   mpStream(nullptr),
  63   mnTableDepth(0),
  64   inPositionV(false),
  65   m_xContext(context),
  66   m_bDiscardChildren(false),
  67   m_bTookChoice(false)
  68 {
  69     if (mpParserState.get() == nullptr)
  70         mpParserState = new OOXMLParserState();
  71
  72     mpParserState->incContextCount();
  73 }
  74
  75 OOXMLFastContextHandler::OOXMLFastContextHandler(OOXMLFastContextHandler * pContext)
  76 : cppu::WeakImplHelper<xml::sax::XFastContextHandler>(),
  77   mpParent(pContext),
  78   mId(0),
  79   mnDefine(0),
  80   mnToken(oox::XML_TOKEN_COUNT),
  81   mpStream(pContext->mpStream),
  82   mpParserState(pContext->mpParserState),
  83   mnTableDepth(pContext->mnTableDepth),
  84   inPositionV(pContext->inPositionV),
  85   m_xContext(pContext->m_xContext),
  86   m_bDiscardChildren(pContext->m_bDiscardChildren),
  87   m_bTookChoice(pContext->m_bTookChoice)
  88 {
  89     if (mpParserState.get() == nullptr)
  90         mpParserState = new OOXMLParserState();
  91
  92     mpParserState->incContextCount();
  93 }
  94
  95 OOXMLFastContextHandler::~OOXMLFastContextHandler()
  96 {
  97 }
  98
  99 bool OOXMLFastContextHandler::prepareMceContext(Token_t nElement, const uno::Reference<xml::sax::XFastAttributeList>& rAttribs)
 100 {
 101     switch (oox::getBaseToken(nElement))
 102     {
 103         case XML_AlternateContent:
 104             {
 105                 SavedAlternateState aState;
 106                 aState.m_bDiscardChildren = m_bDiscardChildren;
 107                 m_bDiscardChildren = false;
 108                 aState.m_bTookChoice = m_bTookChoice;
 109                 m_bTookChoice = false;
 110                 mpParserState->getSavedAlternateStates().push_back(aState);
 111             }
 112             break;
 113         case XML_Choice:
 114         {
 115             OUString aRequires = rAttribs->getOptionalValue(XML_Requires);
 116             static const char* aFeatures[] = {
 117                 "wps",
 118                 "wpg",
 119             };
 120             for (const char *p : aFeatures)
 121             {
 122                 if (aRequires.equalsAscii(p))
 123                 {
 124                     m_bTookChoice = true;
 125                     return false;
 126                 }
 127             }
 128             return true;
 129         }
 130             break;
 131         case XML_Fallback:
 132             // If Choice is already taken, then let's ignore the Fallback.
 133             return m_bTookChoice;
 134             break;
 135         default:
 136             SAL_WARN("writerfilter", "OOXMLFastContextHandler::prepareMceContext: unhandled element:" << oox::getBaseToken(nElement));
 137             break;
 138     }
 139     return false;
 140 }
 141
 142 // xml::sax::XFastContextHandler:
 143 void SAL_CALL OOXMLFastContextHandler::startFastElement
 144 (Token_t Element,
 145  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
 146 {
 147     // Set xml:space value early, to allow child contexts use it when dealing with strings.
 148     if (Attribs && Attribs->hasAttribute(oox::NMSP_xml | oox::XML_space))
 149     {
 150         mbPreserveSpace = Attribs->getValue(oox::NMSP_xml | oox::XML_space) == "preserve";
 151         mbPreserveSpaceSet = true;
 152     }
 153
 154     if (oox::getNamespace(Element) == NMSP_mce)
 155         m_bDiscardChildren = prepareMceContext(Element, Attribs);
 156
 157     else if (!m_bDiscardChildren)
 158     {
 159         attributes(Attribs);
 160         lcl_startFastElement(Element, Attribs);
 161     }
 162 }
 163
 164 void SAL_CALL OOXMLFastContextHandler::startUnknownElement
 165 (const OUString & /*Namespace*/, const OUString & /*Name*/,
 166  const uno::Reference< xml::sax::XFastAttributeList > & /*Attribs*/)
 167 {
 168 }
 169
 170 void SAL_CALL OOXMLFastContextHandler::endFastElement(Token_t Element)
 171 {
 172     if (Element == (NMSP_mce | XML_Choice) || Element == (NMSP_mce | XML_Fallback))
 173         m_bDiscardChildren = false;
 174     else if (Element == (NMSP_mce | XML_AlternateContent))
 175     {
 176         SavedAlternateState aState(mpParserState->getSavedAlternateStates().back());
 177         mpParserState->getSavedAlternateStates().pop_back();
 178         m_bDiscardChildren = aState.m_bDiscardChildren;
 179         m_bTookChoice = aState.m_bTookChoice;
 180     }
 181     else if (!m_bDiscardChildren)
 182         lcl_endFastElement(Element);
 183 }
 184
 185 void OOXMLFastContextHandler::lcl_startFastElement
 186 (Token_t Element,
 187  const uno::Reference< xml::sax::XFastAttributeList > & /*Attribs*/)
 188 {
 189     OOXMLFactory::startAction(this);
 190     if( Element == (NMSP_dmlWordDr|XML_positionV) )
 191         inPositionV = true;
 192     else if( Element == (NMSP_dmlWordDr|XML_positionH) )
 193         inPositionV = false;
 194
 195 }
 196
 197 void OOXMLFastContextHandler::lcl_endFastElement
 198 (Token_t /*Element*/)
 199 {
 200     OOXMLFactory::endAction(this);
 201 }
 202
 203 void SAL_CALL OOXMLFastContextHandler::endUnknownElement
 204 (const OUString & , const OUString & )
 205 {
 206 }
 207
 208 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
 209  OOXMLFastContextHandler::createFastChildContext
 210 (Token_t Element,
 211  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
 212 {
 213     uno::Reference< xml::sax::XFastContextHandler > xResult;
 214     if (oox::getNamespace(Element) != NMSP_mce && !m_bDiscardChildren)
 215         xResult.set(lcl_createFastChildContext(Element, Attribs));
 216     else if (oox::getNamespace(Element) == NMSP_mce)
 217         xResult = this;
 218
 219     return xResult;
 220 }
 221
 222 uno::Reference< xml::sax::XFastContextHandler >
 223  OOXMLFastContextHandler::lcl_createFastChildContext
 224 (Token_t Element,
 225  const uno::Reference< xml::sax::XFastAttributeList > & /*Attribs*/)
 226 {
 227     return OOXMLFactory::createFastChildContext(this, Element);
 228 }
 229
 230 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
 231 OOXMLFastContextHandler::createUnknownChildContext
 232 (const OUString &,
 233  const OUString &,
 234  const uno::Reference< xml::sax::XFastAttributeList > & /*Attribs*/)
 235 {
 236     return uno::Reference< xml::sax::XFastContextHandler >
 237         (new OOXMLFastContextHandler(*const_cast<const OOXMLFastContextHandler *>(this)));
 238 }
 239
 240 void SAL_CALL OOXMLFastContextHandler::characters
 241 (const OUString & aChars)
 242 {
 243     lcl_characters(aChars);
 244 }
 245
 246 void OOXMLFastContextHandler::lcl_characters
 247 (const OUString & rString)
 248 {
 249     if (!m_bDiscardChildren)
 250         OOXMLFactory::characters(this, rString);
 251 }
 252
 253 void OOXMLFastContextHandler::setStream(Stream * pStream)
 254 {
 255     mpStream = pStream;
 256 }
 257
 258 OOXMLValue::Pointer_t OOXMLFastContextHandler::getValue() const
 259 {
 260     return OOXMLValue::Pointer_t();
 261 }
 262
 263 void OOXMLFastContextHandler::attributes
 264 (const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
 265 {
 266     OOXMLFactory::attributes(this, Attribs);
 267 }
 268
 269 void OOXMLFastContextHandler::startAction()
 270 {
 271     OOXMLFactory::startAction(this);
 272 }
 273
 274 void OOXMLFastContextHandler::endAction()
 275 {
 276     OOXMLFactory::endAction(this);
 277 }
 278
 279 void OOXMLFastContextHandler::setId(Id rId)
 280 {
 281     mId = rId;
 282 }
 283
 284 Id OOXMLFastContextHandler::getId() const
 285 {
 286     return mId;
 287 }
 288
 289 void OOXMLFastContextHandler::setDefine(Id nDefine)
 290 {
 291     mnDefine = nDefine;
 292 }
 293
 294
 295 void OOXMLFastContextHandler::setToken(Token_t nToken)
 296 {
 297     mnToken = nToken;
 298 }
 299
 300 Token_t OOXMLFastContextHandler::getToken() const
 301 {
 302     return mnToken;
 303 }
 304
 305 void OOXMLFastContextHandler::sendTableDepth() const
 306 {
 307     if (mnTableDepth > 0)
 308     {
 309         OOXMLPropertySet::Pointer_t pProps(new OOXMLPropertySet);
 310         {
 311             OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(mnTableDepth);
 312             pProps->add(NS_ooxml::LN_tblDepth, pVal, OOXMLProperty::SPRM);
 313         }
 314         {
 315             OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(1);
 316             pProps->add(NS_ooxml::LN_inTbl, pVal, OOXMLProperty::SPRM);
 317         }
 318
 319         mpStream->props(pProps.get());
 320     }
 321 }
 322
 323 void OOXMLFastContextHandler::setHandle()
 324 {
 325     mpParserState->setHandle();
 326     mpStream->info(mpParserState->getHandle());
 327 }
 328
 329 void OOXMLFastContextHandler::startCharacterGroup()
 330 {
 331     if (isForwardEvents())
 332     {
 333         if (mpParserState->isInCharacterGroup())
 334             endCharacterGroup();
 335
 336         if (! mpParserState->isInParagraphGroup())
 337             startParagraphGroup();
 338
 339         if (! mpParserState->isInCharacterGroup())
 340         {
 341             mpStream->startCharacterGroup();
 342             mpParserState->setInCharacterGroup(true);
 343             mpParserState->resolveCharacterProperties(*mpStream);
 344         }
 345
 346         // tdf#108714 : if we have a postponed break information,
 347         // then apply it now, before any other paragraph content.
 348         mpParserState->resolvePostponedBreak(*mpStream);
 349     }
 350 }
 351
 352 void OOXMLFastContextHandler::endCharacterGroup()
 353 {
 354     if (isForwardEvents() && mpParserState->isInCharacterGroup())
 355     {
 356         mpStream->endCharacterGroup();
 357         mpParserState->setInCharacterGroup(false);
 358     }
 359 }
 360
 361 void OOXMLFastContextHandler::pushBiDiEmbedLevel() {}
 362
 363 void OOXMLFastContextHandler::popBiDiEmbedLevel() {}
 364
 365 void OOXMLFastContextHandler::startParagraphGroup()
 366 {
 367     if (isForwardEvents())
 368     {
 369         if (mpParserState->isInParagraphGroup())
 370             endParagraphGroup();
 371
 372         if (! mpParserState->isInSectionGroup())
 373             startSectionGroup();
 374
 375         if (! mpParserState->isInParagraphGroup())
 376         {
 377             mpStream->startParagraphGroup();
 378             mpParserState->setInParagraphGroup(true);
 379         }
 380     }
 381 }
 382
 383 void OOXMLFastContextHandler::endParagraphGroup()
 384 {
 385     if (isForwardEvents())
 386     {
 387         if (mpParserState->isInCharacterGroup())
 388             endCharacterGroup();
 389
 390         if (mpParserState->isInParagraphGroup())
 391         {
 392             mpStream->endParagraphGroup();
 393             mpParserState->setInParagraphGroup(false);
 394         }
 395     }
 396 }
 397
 398 void OOXMLFastContextHandler::startSdt()
 399 {
 400     OOXMLPropertySet::Pointer_t pProps(new OOXMLPropertySet);
 401     OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(1);
 402     pProps->add(NS_ooxml::LN_CT_SdtBlock_sdtContent, pVal, OOXMLProperty::ATTRIBUTE);
 403     mpStream->props(pProps.get());
 404 }
 405
 406 void OOXMLFastContextHandler::endSdt()
 407 {
 408     OOXMLPropertySet::Pointer_t pProps(new OOXMLPropertySet);
 409     OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(1);
 410     pProps->add(NS_ooxml::LN_CT_SdtBlock_sdtEndContent, pVal, OOXMLProperty::ATTRIBUTE);
 411     mpStream->props(pProps.get());
 412 }
 413
 414 void OOXMLFastContextHandler::startSectionGroup()
 415 {
 416     if (isForwardEvents())
 417     {
 418         if (mpParserState->isInSectionGroup())
 419             endSectionGroup();
 420
 421         if (! mpParserState->isInSectionGroup())
 422         {
 423             mpStream->info(mpParserState->getHandle());
 424             mpStream->startSectionGroup();
 425             mpParserState->setInSectionGroup(true);
 426         }
 427     }
 428 }
 429
 430 void OOXMLFastContextHandler::endSectionGroup()
 431 {
 432     if (isForwardEvents())
 433     {
 434         if (mpParserState->isInParagraphGroup())
 435             endParagraphGroup();
 436
 437         if (mpParserState->isInSectionGroup())
 438         {
 439             mpStream->endSectionGroup();
 440             mpParserState->setInSectionGroup(false);
 441         }
 442     }
 443 }
 444
 445 void OOXMLFastContextHandler::setLastParagraphInSection()
 446 {
 447     mpParserState->setLastParagraphInSection(true);
 448     mpStream->markLastParagraphInSection( );
 449 }
 450
 451 void OOXMLFastContextHandler::setLastSectionGroup()
 452 {
 453     mpStream->markLastSectionGroup( );
 454 }
 455
 456 void OOXMLFastContextHandler::newProperty
 457 (Id /*nId*/, const OOXMLValue::Pointer_t& /*pVal*/)
 458 {
 459 }
 460
 461 void OOXMLFastContextHandler::setPropertySet
 462 (const OOXMLPropertySet::Pointer_t& /* pPropertySet */)
 463 {
 464 }
 465
 466 OOXMLPropertySet::Pointer_t OOXMLFastContextHandler::getPropertySet() const
 467 {
 468     return OOXMLPropertySet::Pointer_t();
 469 }
 470
 471 void OOXMLFastContextHandler::startField()
 472 {
 473     startCharacterGroup();
 474     if (isForwardEvents())
 475         mpStream->text(&cFieldStart, 1);
 476     endCharacterGroup();
 477 }
 478
 479 void OOXMLFastContextHandler::fieldSeparator()
 480 {
 481     startCharacterGroup();
 482     if (isForwardEvents())
 483         mpStream->text(&cFieldSep, 1);
 484     endCharacterGroup();
 485 }
 486
 487 void OOXMLFastContextHandler::endField()
 488 {
 489     startCharacterGroup();
 490     if (isForwardEvents())
 491         mpStream->text(&cFieldEnd, 1);
 492     endCharacterGroup();
 493 }
 494
 495 void OOXMLFastContextHandler::lockField()
 496 {
 497     startCharacterGroup();
 498     if (isForwardEvents())
 499         mpStream->text(&cFieldLock, 1);
 500     endCharacterGroup();
 501 }
 502
 503 void OOXMLFastContextHandler::ftnednref()
 504 {
 505 }
 506
 507 void OOXMLFastContextHandler::ftnednsep()
 508 {
 509     if (isForwardEvents())
 510         mpStream->utext(reinterpret_cast<const sal_uInt8*>(&uFtnEdnSep), 1);
 511 }
 512
 513 void OOXMLFastContextHandler::ftnedncont()
 514 {
 515     if (isForwardEvents())
 516         mpStream->text(&cFtnEdnCont, 1);
 517 }
 518
 519 void OOXMLFastContextHandler::pgNum()
 520 {
 521     if (isForwardEvents())
 522         mpStream->utext(reinterpret_cast<const sal_uInt8*>(&uPgNum), 1);
 523 }
 524
 525 void OOXMLFastContextHandler::tab()
 526 {
 527     if (isForwardEvents())
 528         mpStream->utext(reinterpret_cast<const sal_uInt8*>(&uTab), 1);
 529 }
 530
 531 void OOXMLFastContextHandler::symbol()
 532 {
 533     if (isForwardEvents())
 534         sendPropertiesWithId(NS_ooxml::LN_EG_RunInnerContent_sym);
 535 }
 536
 537 void OOXMLFastContextHandler::cr()
 538 {
 539     if (isForwardEvents())
 540         mpStream->utext(reinterpret_cast<const sal_uInt8*>(&uCR), 1);
 541 }
 542
 543 void OOXMLFastContextHandler::noBreakHyphen()
 544 {
 545     if (isForwardEvents())
 546         mpStream->utext(reinterpret_cast<const sal_uInt8*>(&uNoBreakHyphen), 1);
 547 }
 548
 549 void OOXMLFastContextHandler::softHyphen()
 550 {
 551     if (isForwardEvents())
 552         mpStream->utext(reinterpret_cast<const sal_uInt8*>(&uSoftHyphen), 1);
 553 }
 554
 555 void OOXMLFastContextHandler::handleLastParagraphInSection()
 556 {
 557     if (mpParserState->isLastParagraphInSection())
 558     {
 559         mpParserState->setLastParagraphInSection(false);
 560         startSectionGroup();
 561     }
 562 }
 563
 564 void OOXMLFastContextHandler::endOfParagraph()
 565 {
 566     if (! mpParserState->isInCharacterGroup())
 567         startCharacterGroup();
 568     if (isForwardEvents())
 569         mpStream->utext(reinterpret_cast<const sal_uInt8*>(&uCR), 1);
 570
 571     mpParserState->getDocument()->incrementProgress();
 572 }
 573
 574 void OOXMLFastContextHandler::startTxbxContent()
 575 {
 576 /*
 577     This usually means there are recursive <w:p> elements, and the ones
 578     inside and outside of w:txbxContent should not interfere (e.g.
 579     the lastParagraphInSection setting). So save the whole state
 580     and possibly start new groups for the nested content (not section
 581     group though, as that'd cause the txbxContent to be moved onto
 582     another page, I'm not sure how that should work exactly).
 583 */
 584     mpParserState->startTxbxContent();
 585     startParagraphGroup();
 586 }
 587
 588 void OOXMLFastContextHandler::endTxbxContent()
 589 {
 590     endParagraphGroup();
 591     mpParserState->endTxbxContent();
 592 }
 593
 594 namespace {
 595 // XML schema defines white space as one of four characters:
 596 // #x9 (tab), #xA (line feed), #xD (carriage return), and #x20 (space)
 597 bool IsXMLWhitespace(sal_Unicode cChar)
 598 {
 599     return cChar == 0x9 || cChar == 0xA || cChar == 0xD || cChar == 0x20;
 600 }
 601
 602 OUString TrimXMLWhitespace(const OUString & sText)
 603 {
 604     sal_Int32 nTrimmedStart = 0;
 605     const sal_Int32 nLen = sText.getLength();
 606     sal_Int32 nTrimmedEnd = nLen - 1;
 607     while (nTrimmedStart < nLen && IsXMLWhitespace(sText[nTrimmedStart]))
 608         ++nTrimmedStart;
 609     while (nTrimmedStart <= nTrimmedEnd && IsXMLWhitespace(sText[nTrimmedEnd]))
 610         --nTrimmedEnd;
 611     if ((nTrimmedStart == 0) && (nTrimmedEnd == nLen - 1))
 612         return sText;
 613     else if (nTrimmedStart > nTrimmedEnd)
 614         return OUString();
 615     else
 616         return sText.copy(nTrimmedStart, nTrimmedEnd-nTrimmedStart+1);
 617 }
 618 }
 619
 620 void OOXMLFastContextHandler::text(const OUString & sText)
 621 {
 622     if (isForwardEvents())
 623     {
 624         // tdf#108806: CRLFs in XML were converted to \n before this point.
 625         // These must be converted to spaces before further processing.
 626         OUString sNormalizedText = sText.replaceAll("\n", " ");
 627         // tdf#108995: by default, leading and trailing white space is ignored;
 628         // tabs are converted to spaces
 629         if (!IsPreserveSpace())
 630         {
 631             sNormalizedText = TrimXMLWhitespace(sNormalizedText).replaceAll("\t", " ");
 632         }
 633         mpStream->utext(reinterpret_cast < const sal_uInt8 * >
 634                         (sNormalizedText.getStr()),
 635                         sNormalizedText.getLength());
 636     }
 637 }
 638
 639 void OOXMLFastContextHandler::positionOffset(const OUString& rText)
 640 {
 641     if (isForwardEvents())
 642         mpStream->positionOffset(rText, inPositionV);
 643 }
 644
 645 void OOXMLFastContextHandler::ignore()
 646 {
 647 }
 648
 649 void OOXMLFastContextHandler::alignH(const OUString& rText)
 650 {
 651     if (isForwardEvents())
 652         mpStream->align(rText, /*bVertical=*/false);
 653 }
 654
 655 void OOXMLFastContextHandler::alignV(const OUString& rText)
 656 {
 657     if (isForwardEvents())
 658         mpStream->align(rText, /*bVertical=*/true);
 659 }
 660
 661 void OOXMLFastContextHandler::positivePercentage(const OUString& rText)
 662 {
 663     if (isForwardEvents())
 664         mpStream->positivePercentage(rText);
 665 }
 666
 667 void OOXMLFastContextHandler::startGlossaryEntry()
 668 {
 669     if (isForwardEvents())
 670         mpStream->startGlossaryEntry();
 671 }
 672
 673 void OOXMLFastContextHandler::endGlossaryEntry()
 674 {
 675     if (isForwardEvents())
 676         mpStream->endGlossaryEntry();
 677 }
 678
 679 void OOXMLFastContextHandler::propagateCharacterProperties()
 680 {
 681     mpParserState->setCharacterProperties(getPropertySet());
 682 }
 683
 684 void OOXMLFastContextHandler::propagateCharacterPropertiesAsSet(Id nId)
 685 {
 686     OOXMLValue::Pointer_t pValue(new OOXMLPropertySetValue(getPropertySet()));
 687     OOXMLPropertySet::Pointer_t pPropertySet(new OOXMLPropertySet);
 688
 689     pPropertySet->add(nId, pValue, OOXMLProperty::SPRM);
 690     mpParserState->setCharacterProperties(pPropertySet);
 691 }
 692
 693 void OOXMLFastContextHandler::propagateCellProperties()
 694 {
 695     mpParserState->setCellProperties(getPropertySet());
 696 }
 697
 698 void OOXMLFastContextHandler::propagateRowProperties()
 699 {
 700     mpParserState->setRowProperties(getPropertySet());
 701 }
 702
 703 void OOXMLFastContextHandler::propagateTableProperties()
 704 {
 705     OOXMLPropertySet::Pointer_t pProps = getPropertySet();
 706
 707     mpParserState->setTableProperties(pProps);
 708 }
 709
 710 void OOXMLFastContextHandler::sendCellProperties()
 711 {
 712     mpParserState->resolveCellProperties(*mpStream);
 713 }
 714
 715 void OOXMLFastContextHandler::sendRowProperties()
 716 {
 717     mpParserState->resolveRowProperties(*mpStream);
 718 }
 719
 720 void OOXMLFastContextHandler::sendTableProperties()
 721 {
 722     mpParserState->resolveTableProperties(*mpStream);
 723 }
 724
 725 void OOXMLFastContextHandler::clearTableProps()
 726 {
 727     mpParserState->setTableProperties(new OOXMLPropertySet());
 728 }
 729
 730 void OOXMLFastContextHandler::sendPropertiesWithId(Id nId)
 731 {
 732     OOXMLValue::Pointer_t pValue(new OOXMLPropertySetValue(getPropertySet()));
 733     OOXMLPropertySet::Pointer_t pPropertySet(new OOXMLPropertySet);
 734
 735     pPropertySet->add(nId, pValue, OOXMLProperty::SPRM);
 736     mpStream->props(pPropertySet.get());
 737 }
 738
 739 void OOXMLFastContextHandler::clearProps()
 740 {
 741     setPropertySet(new OOXMLPropertySet());
 742 }
 743
 744 void OOXMLFastContextHandler::setDefaultBooleanValue()
 745 {
 746 }
 747
 748 void OOXMLFastContextHandler::setDefaultIntegerValue()
 749 {
 750 }
 751
 752 void OOXMLFastContextHandler::setDefaultHexValue()
 753 {
 754 }
 755
 756 void OOXMLFastContextHandler::setDefaultStringValue()
 757 {
 758 }
 759
 760 void OOXMLFastContextHandler::setDocument(OOXMLDocumentImpl* pDocument)
 761 {
 762     mpParserState->setDocument(pDocument);
 763 }
 764
 765 OOXMLDocumentImpl* OOXMLFastContextHandler::getDocument()
 766 {
 767     return mpParserState->getDocument();
 768 }
 769
 770 void OOXMLFastContextHandler::setForwardEvents(bool bForwardEvents)
 771 {
 772     mpParserState->setForwardEvents(bForwardEvents);
 773 }
 774
 775 bool OOXMLFastContextHandler::isForwardEvents() const
 776 {
 777     return mpParserState->isForwardEvents();
 778 }
 779
 780 void OOXMLFastContextHandler::setXNoteId(const sal_Int32 nId)
 781 {
 782     mpParserState->setXNoteId(nId);
 783 }
 784
 785 void OOXMLFastContextHandler::setXNoteId(const OOXMLValue::Pointer_t& pValue)
 786 {
 787     mpParserState->setXNoteId(sal_Int32(pValue->getInt()));
 788 }
 789
 790 sal_Int32 OOXMLFastContextHandler::getXNoteId() const
 791 {
 792     return mpParserState->getXNoteId();
 793 }
 794
 795 void OOXMLFastContextHandler::resolveFootnote
 796 (const sal_Int32 nId)
 797 {
 798     mpParserState->getDocument()->resolveFootnote
 799         (*mpStream, 0, nId);
 800 }
 801
 802 void OOXMLFastContextHandler::resolveEndnote(const sal_Int32 nId)
 803 {
 804     mpParserState->getDocument()->resolveEndnote
 805         (*mpStream, 0, nId);
 806 }
 807
 808 void OOXMLFastContextHandler::resolveComment(const sal_Int32 nId)
 809 {
 810     mpParserState->getDocument()->resolveComment(*mpStream, nId);
 811 }
 812
 813 void OOXMLFastContextHandler::resolvePicture(const OUString & rId)
 814 {
 815     mpParserState->getDocument()->resolvePicture(*mpStream, rId);
 816 }
 817
 818 void OOXMLFastContextHandler::resolveHeader
 819 (const sal_Int32 type, const OUString & rId)
 820 {
 821     mpParserState->getDocument()->resolveHeader(*mpStream, type, rId);
 822 }
 823
 824 void OOXMLFastContextHandler::resolveFooter
 825 (const sal_Int32 type, const OUString & rId)
 826 {
 827     mpParserState->getDocument()->resolveFooter(*mpStream, type, rId);
 828 }
 829
 830 // Add the data pointed to by the reference as another property.
 831 void OOXMLFastContextHandler::resolveData(const OUString & rId)
 832 {
 833     OOXMLDocument * objDocument = getDocument();
 834     SAL_WARN_IF(!objDocument, "writerfilter", "no document to resolveData");
 835     if (!objDocument)
 836         return;
 837
 838     uno::Reference<io::XInputStream> xInputStream
 839         (objDocument->getInputStreamForId(rId));
 840
 841     OOXMLValue::Pointer_t aValue(new OOXMLInputStreamValue(xInputStream));
 842
 843     newProperty(NS_ooxml::LN_inputstream, aValue);
 844 }
 845
 846 OUString OOXMLFastContextHandler::getTargetForId
 847 (const OUString & rId)
 848 {
 849     return mpParserState->getDocument()->getTargetForId(rId);
 850 }
 851
 852 void OOXMLFastContextHandler::sendPropertyToParent()
 853 {
 854     if (mpParent != nullptr)
 855     {
 856         OOXMLPropertySet::Pointer_t pProps(mpParent->getPropertySet());
 857
 858         if (pProps.get() != nullptr)
 859         {
 860             pProps->add(mId, getValue(), OOXMLProperty::SPRM);
 861         }
 862     }
 863 }
 864
 865 void OOXMLFastContextHandler::sendPropertiesToParent()
 866 {
 867     if (mpParent != nullptr)
 868     {
 869         OOXMLPropertySet::Pointer_t pParentProps(mpParent->getPropertySet());
 870
 871         if (pParentProps.get() != nullptr)
 872         {
 873             OOXMLPropertySet::Pointer_t pProps(getPropertySet());
 874
 875             if (pProps.get() != nullptr)
 876             {
 877                 OOXMLValue::Pointer_t pValue
 878                     (new OOXMLPropertySetValue(getPropertySet()));
 879
 880                 pParentProps->add(getId(), pValue, OOXMLProperty::SPRM);
 881
 882             }
 883         }
 884     }
 885 }
 886
 887 bool OOXMLFastContextHandler::IsPreserveSpace() const
 888 {
 889     // xml:space attribute applies to all elements within the content of the element where it is specified,
 890     // unless overridden with another instance of the xml:space attribute
 891     if (mbPreserveSpaceSet)
 892         return mbPreserveSpace;
 893     if (mpParent)
 894         return mpParent->IsPreserveSpace();
 895     return false; // default value
 896 }
 897
 898 /*
 899   class OOXMLFastContextHandlerStream
 900  */
 901
 902 OOXMLFastContextHandlerStream::OOXMLFastContextHandlerStream
 903 (OOXMLFastContextHandler * pContext)
 904 : OOXMLFastContextHandler(pContext),
 905   mpPropertySetAttrs(new OOXMLPropertySet)
 906 {
 907 }
 908
 909 OOXMLFastContextHandlerStream::~OOXMLFastContextHandlerStream()
 910 {
 911 }
 912
 913 void OOXMLFastContextHandlerStream::newProperty(Id nId,
 914                                                 const OOXMLValue::Pointer_t& pVal)
 915 {
 916     if (nId != 0x0)
 917     {
 918         mpPropertySetAttrs->add(nId, pVal, OOXMLProperty::ATTRIBUTE);
 919     }
 920 }
 921
 922 void OOXMLFastContextHandlerStream::sendProperty(Id nId)
 923 {
 924     OOXMLPropertySetEntryToString aHandler(nId);
 925     getPropertySetAttrs()->resolve(aHandler);
 926     const OUString & sText = aHandler.getString();
 927     mpStream->utext(reinterpret_cast < const sal_uInt8 * >
 928                     (sText.getStr()),
 929                     sText.getLength());
 930 }
 931
 932
 933 OOXMLPropertySet::Pointer_t OOXMLFastContextHandlerStream::getPropertySet()
 934     const
 935 {
 936     return getPropertySetAttrs();
 937 }
 938
 939 void OOXMLFastContextHandlerStream::handleHyperlink()
 940 {
 941     OOXMLHyperlinkHandler aHyperlinkHandler(this);
 942     getPropertySetAttrs()->resolve(aHyperlinkHandler);
 943     aHyperlinkHandler.writetext();
 944 }
 945
 946 /*
 947   class OOXMLFastContextHandlerProperties
 948  */
 949 OOXMLFastContextHandlerProperties::OOXMLFastContextHandlerProperties
 950 (OOXMLFastContextHandler * pContext)
 951 : OOXMLFastContextHandler(pContext), mpPropertySet(new OOXMLPropertySet),
 952   mbResolve(false)
 953 {
 954     if (pContext->getResource() == STREAM)
 955         mbResolve = true;
 956 }
 957
 958 OOXMLFastContextHandlerProperties::~OOXMLFastContextHandlerProperties()
 959 {
 960 }
 961
 962 void OOXMLFastContextHandlerProperties::lcl_endFastElement
 963 (Token_t /*Element*/)
 964 {
 965     try
 966     {
 967         endAction();
 968
 969         if (mbResolve)
 970         {
 971             if (isForwardEvents())
 972             {
 973                 mpStream->props(mpPropertySet.get());
 974             }
 975         }
 976         else
 977         {
 978             sendPropertiesToParent();
 979         }
 980     }
 981     catch (const uno::RuntimeException&)
 982     {
 983         throw;
 984     }
 985     catch (const xml::sax::SAXException&)
 986     {
 987         throw;
 988     }
 989     catch (const uno::Exception& e)
 990     {
 991         auto a = cppu::getCaughtException();
 992         throw lang::WrappedTargetRuntimeException(e.Message, e.Context, a);
 993     }
 994 }
 995
 996 OOXMLValue::Pointer_t OOXMLFastContextHandlerProperties::getValue() const
 997 {
 998     return OOXMLValue::Pointer_t(new OOXMLPropertySetValue(mpPropertySet));
 999 }
1000
1001 void OOXMLFastContextHandlerProperties::newProperty
1002 (Id nId, const OOXMLValue::Pointer_t& pVal)
1003 {
1004     if (nId != 0x0)
1005     {
1006         mpPropertySet->add(nId, pVal, OOXMLProperty::ATTRIBUTE);
1007     }
1008 }
1009
1010 void OOXMLFastContextHandlerProperties::handleXNotes()
1011 {
1012     switch (mnToken)
1013     {
1014     case W_TOKEN(footnoteReference):
1015         {
1016             OOXMLFootnoteHandler aFootnoteHandler(this);
1017             mpPropertySet->resolve(aFootnoteHandler);
1018         }
1019         break;
1020     case W_TOKEN(endnoteReference):
1021         {
1022             OOXMLEndnoteHandler aEndnoteHandler(this);
1023             mpPropertySet->resolve(aEndnoteHandler);
1024         }
1025         break;
1026     default:
1027         break;
1028     }
1029 }
1030
1031 void OOXMLFastContextHandlerProperties::handleHdrFtr()
1032 {
1033     switch (mnToken)
1034     {
1035     case W_TOKEN(footerReference):
1036         {
1037             OOXMLFooterHandler aFooterHandler(this);
1038             mpPropertySet->resolve(aFooterHandler);
1039             aFooterHandler.finalize();
1040         }
1041         break;
1042     case W_TOKEN(headerReference):
1043         {
1044             OOXMLHeaderHandler aHeaderHandler(this);
1045             mpPropertySet->resolve(aHeaderHandler);
1046             aHeaderHandler.finalize();
1047         }
1048         break;
1049     default:
1050         break;
1051     }
1052 }
1053
1054 void OOXMLFastContextHandlerProperties::handleComment()
1055 {
1056     OOXMLCommentHandler aCommentHandler(this);
1057     getPropertySet()->resolve(aCommentHandler);
1058 }
1059
1060 void OOXMLFastContextHandlerProperties::handlePicture()
1061 {
1062     OOXMLPictureHandler aPictureHandler(this);
1063     getPropertySet()->resolve(aPictureHandler);
1064 }
1065
1066 void OOXMLFastContextHandlerProperties::handleBreak()
1067 {
1068     if(isForwardEvents())
1069     {
1070         OOXMLBreakHandler aBreakHandler(*mpStream);
1071         getPropertySet()->resolve(aBreakHandler);
1072     }
1073 }
1074
1075 // tdf#108714 : allow <w:br> at block level (despite this is illegal according to ECMA-376-1:2016)
1076 void OOXMLFastContextHandlerProperties::handleOutOfOrderBreak()
1077 {
1078     if(isForwardEvents())
1079     {
1080         mpParserState->setPostponedBreak(getPropertySet());
1081     }
1082 }
1083
1084 void OOXMLFastContextHandlerProperties::handleOLE()
1085 {
1086     OOXMLOLEHandler aOLEHandler(this);
1087     getPropertySet()->resolve(aOLEHandler);
1088 }
1089
1090 void OOXMLFastContextHandlerProperties::handleFontRel()
1091 {
1092     OOXMLEmbeddedFontHandler handler(this);
1093     getPropertySet()->resolve(handler);
1094 }
1095
1096 void OOXMLFastContextHandlerProperties::handleHyperlinkURL() {
1097     OOXMLHyperlinkURLHandler aHyperlinkURLHandler(this);
1098     getPropertySet()->resolve(aHyperlinkURLHandler);
1099 }
1100
1101 void OOXMLFastContextHandlerProperties::setPropertySet
1102 (const OOXMLPropertySet::Pointer_t& pPropertySet)
1103 {
1104     if (pPropertySet.get() != nullptr)
1105         mpPropertySet = pPropertySet;
1106 }
1107
1108 OOXMLPropertySet::Pointer_t
1109 OOXMLFastContextHandlerProperties::getPropertySet() const
1110 {
1111     return mpPropertySet;
1112 }
1113
1114 /*
1115  * class OOXMLFasContextHandlerPropertyTable
1116  */
1117
1118 OOXMLFastContextHandlerPropertyTable::OOXMLFastContextHandlerPropertyTable
1119 (OOXMLFastContextHandler * pContext)
1120 : OOXMLFastContextHandlerProperties(pContext)
1121 {
1122 }
1123
1124 OOXMLFastContextHandlerPropertyTable::~OOXMLFastContextHandlerPropertyTable()
1125 {
1126 }
1127
1128 void OOXMLFastContextHandlerPropertyTable::lcl_endFastElement
1129 (Token_t /*Element*/)
1130 {
1131     OOXMLPropertySet::Pointer_t pPropSet(mpPropertySet->clone());
1132     OOXMLTable::ValuePointer_t pTmpVal
1133         (new OOXMLPropertySetValue(pPropSet));
1134
1135     mTable.add(pTmpVal);
1136
1137     writerfilter::Reference<Table>::Pointer_t pTable(mTable.clone());
1138
1139     mpStream->table(mId, pTable);
1140
1141     endAction();
1142 }
1143
1144 /*
1145  class OOXMLFastContextHandlerValue
1146 */
1147
1148 OOXMLFastContextHandlerValue::OOXMLFastContextHandlerValue
1149 (OOXMLFastContextHandler * pContext)
1150 : OOXMLFastContextHandler(pContext)
1151 {
1152 }
1153
1154 OOXMLFastContextHandlerValue::~OOXMLFastContextHandlerValue()
1155 {
1156 }
1157
1158 void OOXMLFastContextHandlerValue::setValue(const OOXMLValue::Pointer_t& pValue)
1159 {
1160     mpValue = pValue;
1161 }
1162
1163 OOXMLValue::Pointer_t OOXMLFastContextHandlerValue::getValue() const
1164 {
1165     return mpValue;
1166 }
1167
1168 void OOXMLFastContextHandlerValue::lcl_endFastElement
1169 (Token_t /*Element*/)
1170 {
1171     sendPropertyToParent();
1172
1173     endAction();
1174 }
1175
1176 void OOXMLFastContextHandlerValue::setDefaultBooleanValue()
1177 {
1178     if (mpValue.get() == nullptr)
1179     {
1180         OOXMLValue::Pointer_t pValue = OOXMLBooleanValue::Create(true);
1181         setValue(pValue);
1182     }
1183 }
1184
1185 void OOXMLFastContextHandlerValue::setDefaultIntegerValue()
1186 {
1187     if (mpValue.get() == nullptr)
1188     {
1189         OOXMLValue::Pointer_t pValue = OOXMLIntegerValue::Create(0);
1190         setValue(pValue);
1191     }
1192 }
1193
1194 void OOXMLFastContextHandlerValue::setDefaultHexValue()
1195 {
1196     if (mpValue.get() == nullptr)
1197     {
1198         OOXMLValue::Pointer_t pValue(new OOXMLHexValue(sal_uInt32(0)));
1199         setValue(pValue);
1200     }
1201 }
1202
1203 void OOXMLFastContextHandlerValue::setDefaultStringValue()
1204 {
1205     if (mpValue.get() == nullptr)
1206     {
1207         OOXMLValue::Pointer_t pValue(new OOXMLStringValue(OUString()));
1208         setValue(pValue);
1209     }
1210 }
1211
1212 // ECMA-376-1:2016 17.3.2.8; https://www.unicode.org/reports/tr9/#Explicit_Directional_Embeddings
1213 void OOXMLFastContextHandlerValue::pushBiDiEmbedLevel()
1214 {
1215     const bool bRtl
1216         = mpValue.get() && mpValue.get()->getInt() == NS_ooxml::LN_Value_ST_Direction_rtl;
1217     OOXMLFactory::characters(this, bRtl ? u"\u202B" : u"\u202A"); // RLE / LRE
1218 }
1219
1220 void OOXMLFastContextHandlerValue::popBiDiEmbedLevel()
1221 {
1222     OOXMLFactory::characters(this, u"\u202C"); // PDF (POP DIRECTIONAL FORMATTING)
1223 }
1224
1225 /*
1226   class OOXMLFastContextHandlerTable
1227 */
1228
1229 OOXMLFastContextHandlerTable::OOXMLFastContextHandlerTable
1230 (OOXMLFastContextHandler * pContext)
1231 : OOXMLFastContextHandler(pContext)
1232 {
1233 }
1234
1235 OOXMLFastContextHandlerTable::~OOXMLFastContextHandlerTable()
1236 {
1237 }
1238
1239 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
1240 OOXMLFastContextHandlerTable::createFastChildContext
1241 (Token_t Element,
1242  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1243 {
1244     addCurrentChild();
1245
1246     mCurrentChild.set(OOXMLFastContextHandler::createFastChildContext(Element, Attribs));
1247
1248     return mCurrentChild;
1249 }
1250
1251 void OOXMLFastContextHandlerTable::lcl_endFastElement
1252 (Token_t /*Element*/)
1253 {
1254     addCurrentChild();
1255
1256     writerfilter::Reference<Table>::Pointer_t pTable(mTable.clone());
1257     if (isForwardEvents() && mId != 0x0)
1258     {
1259         mpStream->table(mId, pTable);
1260     }
1261 }
1262
1263 void OOXMLFastContextHandlerTable::addCurrentChild()
1264 {
1265     OOXMLFastContextHandler * pHandler = dynamic_cast<OOXMLFastContextHandler*>(mCurrentChild.get());
1266     if (pHandler != nullptr)
1267     {
1268         OOXMLValue::Pointer_t pValue(pHandler->getValue());
1269
1270         if (pValue.get() != nullptr)
1271         {
1272             OOXMLTable::ValuePointer_t pTmpVal(pValue->clone());
1273             mTable.add(pTmpVal);
1274         }
1275     }
1276 }
1277
1278 /*
1279   class OOXMLFastContextHandlerXNote
1280  */
1281
1282 OOXMLFastContextHandlerXNote::OOXMLFastContextHandlerXNote
1283     (OOXMLFastContextHandler * pContext)
1284     : OOXMLFastContextHandlerProperties(pContext)
1285     , mbForwardEventsSaved(false)
1286     , mnMyXNoteId(0)
1287     , mnMyXNoteType(0)
1288 {
1289 }
1290
1291 OOXMLFastContextHandlerXNote::~OOXMLFastContextHandlerXNote()
1292 {
1293 }
1294
1295 void OOXMLFastContextHandlerXNote::lcl_startFastElement
1296 (Token_t /*Element*/,
1297  const uno::Reference< xml::sax::XFastAttributeList > & /*Attribs*/)
1298 {
1299     mbForwardEventsSaved = isForwardEvents();
1300
1301     // If this is the note we're looking for or this is the footnote separator one.
1302     if (mnMyXNoteId == getXNoteId() || static_cast<sal_uInt32>(mnMyXNoteType) == NS_ooxml::LN_Value_doc_ST_FtnEdn_separator)
1303         setForwardEvents(true);
1304     else
1305         setForwardEvents(false);
1306
1307     startAction();
1308 }
1309
1310 void OOXMLFastContextHandlerXNote::lcl_endFastElement
1311 (Token_t Element)
1312 {
1313     endAction();
1314
1315     OOXMLFastContextHandlerProperties::lcl_endFastElement(Element);
1316
1317     setForwardEvents(mbForwardEventsSaved);
1318 }
1319
1320 void OOXMLFastContextHandlerXNote::checkId(const OOXMLValue::Pointer_t& pValue)
1321 {
1322     mnMyXNoteId = sal_Int32(pValue->getInt());
1323 }
1324
1325 void OOXMLFastContextHandlerXNote::checkType(const OOXMLValue::Pointer_t& pValue)
1326 {
1327     mnMyXNoteType = pValue->getInt();
1328 }
1329
1330 /*
1331   class OOXMLFastContextHandlerTextTableCell
1332  */
1333
1334 OOXMLFastContextHandlerTextTableCell::OOXMLFastContextHandlerTextTableCell
1335 (OOXMLFastContextHandler * pContext)
1336 : OOXMLFastContextHandler(pContext)
1337 {
1338 }
1339
1340 OOXMLFastContextHandlerTextTableCell::~OOXMLFastContextHandlerTextTableCell()
1341 {
1342 }
1343
1344 void OOXMLFastContextHandlerTextTableCell::startCell()
1345 {
1346     if (isForwardEvents())
1347     {
1348         OOXMLPropertySet::Pointer_t pProps(new OOXMLPropertySet);
1349         {
1350             OOXMLValue::Pointer_t pVal = OOXMLBooleanValue::Create(mnTableDepth > 0);
1351             pProps->add(NS_ooxml::LN_tcStart, pVal, OOXMLProperty::SPRM);
1352         }
1353
1354         mpStream->props(pProps.get());
1355     }
1356 }
1357
1358 void OOXMLFastContextHandlerTextTableCell::endCell()
1359 {
1360     if (isForwardEvents())
1361     {
1362         OOXMLPropertySet::Pointer_t pProps(new OOXMLPropertySet);
1363         {
1364             OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(mnTableDepth);
1365             pProps->add(NS_ooxml::LN_tblDepth, pVal, OOXMLProperty::SPRM);
1366         }
1367         {
1368             OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(1);
1369             pProps->add(NS_ooxml::LN_inTbl, pVal, OOXMLProperty::SPRM);
1370         }
1371         {
1372             OOXMLValue::Pointer_t pVal = OOXMLBooleanValue::Create(mnTableDepth > 0);
1373             pProps->add(NS_ooxml::LN_tblCell, pVal, OOXMLProperty::SPRM);
1374         }
1375         {
1376             OOXMLValue::Pointer_t pVal = OOXMLBooleanValue::Create(mnTableDepth > 0);
1377             pProps->add(NS_ooxml::LN_tcEnd, pVal, OOXMLProperty::SPRM);
1378         }
1379
1380         mpStream->props(pProps.get());
1381     }
1382 }
1383
1384 /*
1385   class OOXMLFastContextHandlerTextTableRow
1386  */
1387
1388 OOXMLFastContextHandlerTextTableRow::OOXMLFastContextHandlerTextTableRow
1389 (OOXMLFastContextHandler * pContext)
1390 : OOXMLFastContextHandler(pContext)
1391 {
1392 }
1393
1394 OOXMLFastContextHandlerTextTableRow::~OOXMLFastContextHandlerTextTableRow()
1395 {
1396 }
1397
1398 void OOXMLFastContextHandlerTextTableRow::startRow()
1399 {
1400 }
1401
1402 void OOXMLFastContextHandlerTextTableRow::endRow()
1403 {
1404     if (mpGridAfter)
1405     {
1406         // Grid after is the same as grid before, the empty cells are just
1407         // inserted after the real ones, not before.
1408         handleGridBefore(mpGridAfter);
1409         mpGridAfter = nullptr;
1410     }
1411
1412     startParagraphGroup();
1413
1414     if (isForwardEvents())
1415     {
1416         OOXMLPropertySet::Pointer_t pProps(new OOXMLPropertySet);
1417         {
1418             OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(mnTableDepth);
1419             pProps->add(NS_ooxml::LN_tblDepth, pVal, OOXMLProperty::SPRM);
1420         }
1421         {
1422             OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(1);
1423             pProps->add(NS_ooxml::LN_inTbl, pVal, OOXMLProperty::SPRM);
1424         }
1425         {
1426             OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(1);
1427             pProps->add(NS_ooxml::LN_tblRow, pVal, OOXMLProperty::SPRM);
1428         }
1429
1430         mpStream->props(pProps.get());
1431     }
1432
1433     startCharacterGroup();
1434
1435     if (isForwardEvents())
1436         mpStream->utext(reinterpret_cast<const sal_uInt8*>(&uCR), 1);
1437
1438     endCharacterGroup();
1439     endParagraphGroup();
1440 }
1441
1442 void OOXMLFastContextHandlerTextTableRow::handleGridAfter(const OOXMLValue::Pointer_t& rValue)
1443 {
1444     if (OOXMLFastContextHandler* pTableRowProperties = getParent())
1445     {
1446         if (OOXMLFastContextHandler* pTableRow = pTableRowProperties->getParent())
1447             // Save the value into the table row context, so it can be handled
1448             // right before the end of the row.
1449             pTableRow->setGridAfter(rValue);
1450     }
1451 }
1452
1453 namespace {
1454 OOXMLValue::Pointer_t fakeNoBorder()
1455 {
1456     OOXMLPropertySet::Pointer_t pProps( new OOXMLPropertySet );
1457     OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(0);
1458     pProps->add(NS_ooxml::LN_CT_Border_val, pVal, OOXMLProperty::ATTRIBUTE);
1459     OOXMLValue::Pointer_t pValue( new OOXMLPropertySetValue( pProps ));
1460     return pValue;
1461 }
1462 }
1463
1464 // Handle w:gridBefore here by faking necessary input that'll fake cells. I'm apparently
1465 // not insane enough to find out how to add cells in dmapper.
1466 void OOXMLFastContextHandlerTextTableRow::handleGridBefore( const OOXMLValue::Pointer_t& val )
1467 {
1468     int count = val->getInt();
1469     for( int i = 0;
1470          i < count;
1471          ++i )
1472     {
1473         endOfParagraph();
1474
1475         if (isForwardEvents())
1476         {
1477             // This whole part is OOXMLFastContextHandlerTextTableCell::endCell() .
1478             OOXMLPropertySet::Pointer_t pProps(new OOXMLPropertySet);
1479             {
1480                 OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(mnTableDepth);
1481                 pProps->add(NS_ooxml::LN_tblDepth, pVal, OOXMLProperty::SPRM);
1482             }
1483             {
1484                 OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(1);
1485                 pProps->add(NS_ooxml::LN_inTbl, pVal, OOXMLProperty::SPRM);
1486             }
1487             {
1488                 OOXMLValue::Pointer_t pVal = OOXMLBooleanValue::Create(mnTableDepth > 0);
1489                 pProps->add(NS_ooxml::LN_tblCell, pVal, OOXMLProperty::SPRM);
1490             }
1491
1492             mpStream->props(pProps.get());
1493
1494             // fake <w:tcBorders> with no border
1495             OOXMLPropertySet::Pointer_t pCellProps( new OOXMLPropertySet );
1496             {
1497                 OOXMLPropertySet::Pointer_t pBorderProps( new OOXMLPropertySet );
1498                 static Id borders[] = { NS_ooxml::LN_CT_TcBorders_top, NS_ooxml::LN_CT_TcBorders_bottom,
1499                     NS_ooxml::LN_CT_TcBorders_start, NS_ooxml::LN_CT_TcBorders_end };
1500                 for(sal_uInt32 border : borders)
1501                     pBorderProps->add(border, fakeNoBorder(), OOXMLProperty::SPRM);
1502                 OOXMLValue::Pointer_t pValue( new OOXMLPropertySetValue( pBorderProps ));
1503                 pCellProps->add(NS_ooxml::LN_CT_TcPrBase_tcBorders, pValue, OOXMLProperty::SPRM);
1504                 mpParserState->setCellProperties(pCellProps);
1505             }
1506         }
1507
1508         sendCellProperties();
1509         endParagraphGroup();
1510     }
1511 }
1512
1513 /*
1514   class OOXMLFastContextHandlerTextTable
1515  */
1516
1517 OOXMLFastContextHandlerTextTable::OOXMLFastContextHandlerTextTable
1518 (OOXMLFastContextHandler * pContext)
1519 : OOXMLFastContextHandler(pContext)
1520 {
1521 }
1522
1523 OOXMLFastContextHandlerTextTable::~OOXMLFastContextHandlerTextTable()
1524 {
1525     clearTableProps();
1526 }
1527
1528 void OOXMLFastContextHandlerTextTable::lcl_startFastElement
1529 (Token_t /*Element*/,
1530  const uno::Reference< xml::sax::XFastAttributeList > & /*Attribs*/)
1531 {
1532     mpParserState->startTable();
1533     mnTableDepth++;
1534
1535     OOXMLPropertySet::Pointer_t pProps( new OOXMLPropertySet );
1536     {
1537         OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(mnTableDepth);
1538         pProps->add(NS_ooxml::LN_tblStart, pVal, OOXMLProperty::SPRM);
1539     }
1540     mpParserState->setCharacterProperties(pProps);
1541
1542     startAction();
1543 }
1544
1545 void OOXMLFastContextHandlerTextTable::lcl_endFastElement
1546 (Token_t /*Element*/)
1547 {
1548     endAction();
1549
1550     OOXMLPropertySet::Pointer_t pProps( new OOXMLPropertySet );
1551     {
1552         OOXMLValue::Pointer_t pVal = OOXMLIntegerValue::Create(mnTableDepth);
1553         pProps->add(NS_ooxml::LN_tblEnd, pVal, OOXMLProperty::SPRM);
1554     }
1555     mpParserState->setCharacterProperties(pProps);
1556
1557     mnTableDepth--;
1558     mpParserState->endTable();
1559 }
1560
1561 // tdf#111550
1562 void OOXMLFastContextHandlerTextTable::start_P_Tbl()
1563 {
1564     // Normally, when one paragraph ends, and another begins,
1565     // in OOXMLFactory_wml::endAction handler for <w:p>,
1566     // pHandler->endOfParagraph() is called, which (among other things)
1567     // calls TableManager::setHandle() to update current cell's starting point.
1568     // Then, in OOXMLFactory_wml::startAction for next <w:p>,
1569     // pHandler->startParagraphGroup() is called, which ends previous group,
1570     // and there, it pushes cells to row in TableManager::endParagraphGroup()
1571     // (cells have correct bounds defined by mCurHandle).
1572     // When a table is child of a <w:p>, that paragraph doesn't end before nested
1573     // paragraph begins. So, pHandler->endOfParagraph() was not (and should not be)
1574     // called. But as next paragraph starts, is the previous group is closed, then
1575     // cells will have wrong boundings. Here, we know that we *are* in paragraph
1576     // group, but it should not be finished.
1577     mpParserState->setInParagraphGroup(false);
1578 }
1579
1580 /*
1581   class OOXMLFastContextHandlerShape
1582  */
1583
1584 OOXMLFastContextHandlerShape::OOXMLFastContextHandlerShape
1585 (OOXMLFastContextHandler * pContext)
1586 : OOXMLFastContextHandlerProperties(pContext), m_bShapeSent( false ),
1587     m_bShapeStarted(false), m_bShapeContextPushed(false)
1588 {
1589 }
1590
1591 OOXMLFastContextHandlerShape::~OOXMLFastContextHandlerShape()
1592 {
1593     if (m_bShapeContextPushed)
1594         getDocument()->popShapeContext();
1595 }
1596
1597 void OOXMLFastContextHandlerShape::lcl_startFastElement
1598 (Token_t Element,
1599  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1600 {
1601     startAction();
1602
1603     if (mrShapeContext.is())
1604     {
1605         mrShapeContext->startFastElement(Element, Attribs);
1606     }
1607 }
1608
1609 void SAL_CALL OOXMLFastContextHandlerShape::startUnknownElement
1610 (const OUString & Namespace,
1611  const OUString & Name,
1612  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1613 {
1614     if (mrShapeContext.is())
1615         mrShapeContext->startUnknownElement(Namespace, Name, Attribs);
1616 }
1617
1618 void OOXMLFastContextHandlerShape::setToken(Token_t nToken)
1619 {
1620     if (nToken == Token_t(NMSP_wps | XML_wsp) || nToken == Token_t(NMSP_dmlPicture | XML_pic))
1621     {
1622         // drawingML shapes are independent, <wps:bodyPr> is not parsed after
1623         // shape contents without pushing/popping the stack.
1624         m_bShapeContextPushed = true;
1625         getDocument()->pushShapeContext();
1626     }
1627
1628     mrShapeContext.set(getDocument()->getShapeContext());
1629     if (!mrShapeContext.is())
1630     {
1631         // Define the shape context for the whole document
1632         mrShapeContext = css::xml::sax::FastShapeContextHandler::create(getComponentContext());
1633         getDocument()->setShapeContext(mrShapeContext);
1634     }
1635
1636     mrShapeContext->setModel(getDocument()->getModel());
1637     uno::Reference<document::XDocumentPropertiesSupplier> xDocSupplier(getDocument()->getModel(), uno::UNO_QUERY_THROW);
1638     mrShapeContext->setDocumentProperties(xDocSupplier->getDocumentProperties());
1639     mrShapeContext->setDrawPage(getDocument()->getDrawPage());
1640     mrShapeContext->setMediaDescriptor(getDocument()->getMediaDescriptor());
1641
1642     mrShapeContext->setRelationFragmentPath(mpParserState->getTarget());
1643
1644     OOXMLFastContextHandler::setToken(nToken);
1645
1646     if (mrShapeContext.is())
1647         mrShapeContext->setStartToken(nToken);
1648 }
1649
1650 void OOXMLFastContextHandlerShape::sendShape( Token_t Element )
1651 {
1652     if ( mrShapeContext.is() && !m_bShapeSent )
1653     {
1654         awt::Point aPosition = mpStream->getPositionOffset();
1655         mrShapeContext->setPosition(aPosition);
1656         uno::Reference<drawing::XShape> xShape(mrShapeContext->getShape());
1657         m_bShapeSent = true;
1658         if (xShape.is())
1659         {
1660             OOXMLValue::Pointer_t
1661                 pValue(new OOXMLShapeValue(xShape));
1662             newProperty(NS_ooxml::LN_shape, pValue);
1663
1664             bool bIsPicture = Element == ( NMSP_dmlPicture | XML_pic );
1665
1666             // Notify the dmapper that the shape is ready to use
1667             if ( !bIsPicture )
1668             {
1669                 mpStream->startShape( xShape );
1670                 m_bShapeStarted = true;
1671             }
1672         }
1673     }
1674 }
1675
1676 void OOXMLFastContextHandlerShape::lcl_endFastElement
1677 (Token_t Element)
1678 {
1679     if (mrShapeContext.is())
1680     {
1681         mrShapeContext->endFastElement(Element);
1682         sendShape( Element );
1683     }
1684
1685     OOXMLFastContextHandlerProperties::lcl_endFastElement(Element);
1686
1687     // Ending the shape should be the last thing to do
1688     bool bIsPicture = Element == ( NMSP_dmlPicture | XML_pic );
1689     if ( !bIsPicture && m_bShapeStarted)
1690         mpStream->endShape( );
1691 }
1692
1693 void SAL_CALL OOXMLFastContextHandlerShape::endUnknownElement
1694 (const OUString & Namespace,
1695  const OUString & Name)
1696 {
1697     if (mrShapeContext.is())
1698         mrShapeContext->endUnknownElement(Namespace, Name);
1699 }
1700
1701 uno::Reference< xml::sax::XFastContextHandler >
1702 OOXMLFastContextHandlerShape::lcl_createFastChildContext
1703 (Token_t Element,
1704  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1705 {
1706     uno::Reference< xml::sax::XFastContextHandler > xContextHandler;
1707
1708     bool bGroupShape = Element == Token_t(NMSP_vml | XML_group);
1709     // drawingML version also counts as a group shape.
1710     bGroupShape |= mrShapeContext->getStartToken() == Token_t(NMSP_wpg | XML_wgp);
1711
1712     switch (oox::getNamespace(Element))
1713     {
1714         case NMSP_doc:
1715         case NMSP_vmlWord:
1716         case NMSP_vmlOffice:
1717             if (!bGroupShape)
1718                 xContextHandler.set(OOXMLFactory::createFastChildContextFromStart(this, Element));
1719             SAL_FALLTHROUGH;
1720         default:
1721             if (!xContextHandler.is())
1722             {
1723                 if (mrShapeContext.is())
1724                 {
1725                     uno::Reference<XFastContextHandler> pChildContext =
1726                         mrShapeContext->createFastChildContext(Element, Attribs);
1727
1728                     OOXMLFastContextHandlerWrapper * pWrapper =
1729                         new OOXMLFastContextHandlerWrapper(this, pChildContext);
1730
1731                     if (!bGroupShape)
1732                     {
1733                         pWrapper->addNamespace(NMSP_doc);
1734                         pWrapper->addNamespace(NMSP_vmlWord);
1735                         pWrapper->addNamespace(NMSP_vmlOffice);
1736                         pWrapper->addToken( NMSP_vml|XML_textbox );
1737                     }
1738
1739                     xContextHandler.set(pWrapper);
1740                 }
1741                 else
1742                     xContextHandler.set(this);
1743             }
1744             break;
1745     }
1746
1747     // VML import of shape text is already handled by
1748     // OOXMLFastContextHandlerWrapper::lcl_createFastChildContext(), here we
1749     // handle the WPS import of shape text, as there the parent context is a
1750     // Shape one, so a different situation.
1751     if (Element == static_cast<sal_Int32>(NMSP_wps | XML_txbx) ||
1752         Element == static_cast<sal_Int32>(NMSP_wps | XML_linkedTxbx) )
1753         sendShape(Element);
1754
1755     return xContextHandler;
1756 }
1757
1758 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
1759 OOXMLFastContextHandlerShape::createUnknownChildContext
1760 (const OUString & Namespace,
1761  const OUString & Name,
1762  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1763 {
1764     uno::Reference< xml::sax::XFastContextHandler > xResult;
1765
1766     if (mrShapeContext.is())
1767         xResult.set(mrShapeContext->createUnknownChildContext
1768             (Namespace, Name, Attribs));
1769
1770     return xResult;
1771 }
1772
1773 void OOXMLFastContextHandlerShape::lcl_characters
1774 (const OUString & aChars)
1775 {
1776     if (mrShapeContext.is())
1777         mrShapeContext->characters(aChars);
1778 }
1779
1780 /*
1781   class OOXMLFastContextHandlerWrapper
1782 */
1783
1784 OOXMLFastContextHandlerWrapper::OOXMLFastContextHandlerWrapper
1785 (OOXMLFastContextHandler * pParent,
1786  uno::Reference<XFastContextHandler> const & xContext)
1787 : OOXMLFastContextHandler(pParent), mxContext(xContext)
1788 {
1789     setId(pParent->getId());
1790     setToken(pParent->getToken());
1791     setPropertySet(pParent->getPropertySet());
1792 }
1793
1794 OOXMLFastContextHandlerWrapper::~OOXMLFastContextHandlerWrapper()
1795 {
1796 }
1797
1798 void SAL_CALL OOXMLFastContextHandlerWrapper::startUnknownElement
1799 (const OUString & Namespace,
1800  const OUString & Name,
1801  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1802 {
1803     if (mxContext.is())
1804         mxContext->startUnknownElement(Namespace, Name, Attribs);
1805 }
1806
1807 void SAL_CALL OOXMLFastContextHandlerWrapper::endUnknownElement
1808 (const OUString & Namespace,
1809  const OUString & Name)
1810 {
1811     if (mxContext.is())
1812         mxContext->endUnknownElement(Namespace, Name);
1813 }
1814
1815 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
1816 OOXMLFastContextHandlerWrapper::createUnknownChildContext
1817 (const OUString & Namespace,
1818  const OUString & Name,
1819  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1820 {
1821     uno::Reference< xml::sax::XFastContextHandler > xResult;
1822
1823     if (mxContext.is())
1824         xResult = mxContext->createUnknownChildContext
1825             (Namespace, Name, Attribs);
1826     else
1827         xResult.set(this);
1828
1829     return xResult;
1830 }
1831
1832 void OOXMLFastContextHandlerWrapper::attributes
1833 (const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1834 {
1835     if (mxContext.is())
1836     {
1837         OOXMLFastContextHandler * pHandler = getFastContextHandler();
1838         if (pHandler != nullptr)
1839             pHandler->attributes(Attribs);
1840     }
1841 }
1842
1843 OOXMLFastContextHandler::ResourceEnum_t
1844 OOXMLFastContextHandlerWrapper::getResource() const
1845 {
1846     return UNKNOWN;
1847 }
1848
1849 void OOXMLFastContextHandlerWrapper::addNamespace(Id nId)
1850 {
1851     mMyNamespaces.insert(nId);
1852 }
1853
1854 void OOXMLFastContextHandlerWrapper::addToken( Token_t Token )
1855 {
1856     mMyTokens.insert( Token );
1857 }
1858
1859 void OOXMLFastContextHandlerWrapper::lcl_startFastElement
1860 (Token_t Element,
1861  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1862 {
1863     if (mxContext.is())
1864         mxContext->startFastElement(Element, Attribs);
1865 }
1866
1867 void OOXMLFastContextHandlerWrapper::lcl_endFastElement
1868 (Token_t Element)
1869 {
1870     if (mxContext.is())
1871         mxContext->endFastElement(Element);
1872 }
1873
1874 uno::Reference< xml::sax::XFastContextHandler >
1875 OOXMLFastContextHandlerWrapper::lcl_createFastChildContext
1876 (Token_t Element,
1877  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
1878 {
1879     uno::Reference< xml::sax::XFastContextHandler > xResult;
1880
1881     bool bInNamespaces = mMyNamespaces.find(oox::getNamespace(Element)) != mMyNamespaces.end();
1882     bool bInTokens = mMyTokens.find( Element ) != mMyTokens.end( );
1883
1884     // We have methods to _add_ individual tokens or whole namespaces to be
1885     // processed by writerfilter (instead of oox), but we have no method to
1886     // filter out a single token. Just hardwire the 'wrap' and 'signatureline' tokens
1887     // here until we need a more generic solution.
1888     bool bIsWrap = Element == static_cast<sal_Int32>(NMSP_vmlWord | XML_wrap);
1889     bool bIsSignatureLine = Element == static_cast<sal_Int32>(NMSP_vmlOffice | XML_signatureline);
1890     bool bSkipImages = getDocument()->IsSkipImages() && oox::getNamespace(Element) == NMSP_dml &&
1891         !((oox::getBaseToken(Element) == XML_linkedTxbx) || (oox::getBaseToken(Element) == XML_txbx));
1892
1893     if ( bInNamespaces && ((!bIsWrap && !bIsSignatureLine) || dynamic_cast<OOXMLFastContextHandlerShape&>(*mpParent).isShapeSent()) )
1894         xResult.set(OOXMLFactory::createFastChildContextFromStart(this, Element));
1895     else if (mxContext.is()  && !bSkipImages)
1896     {
1897         OOXMLFastContextHandlerWrapper * pWrapper =
1898             new OOXMLFastContextHandlerWrapper
1899             (this, mxContext->createFastChildContext(Element, Attribs));
1900         pWrapper->mMyNamespaces = mMyNamespaces;
1901         pWrapper->setPropertySet(getPropertySet());
1902         xResult.set(pWrapper);
1903     }
1904     else
1905         xResult.set(this);
1906
1907     if ( bInTokens )
1908         static_cast<OOXMLFastContextHandlerShape*>(mpParent)->sendShape( Element );
1909
1910     return xResult;
1911 }
1912
1913 void OOXMLFastContextHandlerWrapper::lcl_characters
1914 (const OUString & aChars)
1915 {
1916     if (mxContext.is())
1917         mxContext->characters(aChars);
1918 }
1919
1920 OOXMLFastContextHandler *
1921 OOXMLFastContextHandlerWrapper::getFastContextHandler() const
1922 {
1923     if (mxContext.is())
1924         return dynamic_cast<OOXMLFastContextHandler *>(mxContext.get());
1925
1926     return nullptr;
1927 }
1928
1929 void OOXMLFastContextHandlerWrapper::newProperty
1930 (Id nId, const OOXMLValue::Pointer_t& pVal)
1931 {
1932     if (mxContext.is())
1933     {
1934         OOXMLFastContextHandler * pHandler = getFastContextHandler();
1935         if (pHandler != nullptr)
1936             pHandler->newProperty(nId, pVal);
1937     }
1938 }
1939
1940 void OOXMLFastContextHandlerWrapper::setPropertySet
1941 (const OOXMLPropertySet::Pointer_t& pPropertySet)
1942 {
1943     if (mxContext.is())
1944     {
1945         OOXMLFastContextHandler * pHandler = getFastContextHandler();
1946         if (pHandler != nullptr)
1947             pHandler->setPropertySet(pPropertySet);
1948     }
1949
1950     mpPropertySet = pPropertySet;
1951 }
1952
1953 OOXMLPropertySet::Pointer_t OOXMLFastContextHandlerWrapper::getPropertySet()
1954     const
1955 {
1956     OOXMLPropertySet::Pointer_t pResult(mpPropertySet);
1957
1958     if (mxContext.is())
1959     {
1960         OOXMLFastContextHandler * pHandler = getFastContextHandler();
1961         if (pHandler != nullptr)
1962             pResult = pHandler->getPropertySet();
1963     }
1964
1965     return pResult;
1966 }
1967
1968 string OOXMLFastContextHandlerWrapper::getType() const
1969 {
1970     string sResult = "Wrapper(";
1971
1972     if (mxContext.is())
1973     {
1974         OOXMLFastContextHandler * pHandler = getFastContextHandler();
1975         if (pHandler != nullptr)
1976             sResult += pHandler->getType();
1977     }
1978
1979     sResult += ")";
1980
1981     return sResult;
1982 }
1983
1984 void OOXMLFastContextHandlerWrapper::setId(Id rId)
1985 {
1986     OOXMLFastContextHandler::setId(rId);
1987
1988     if (mxContext.is())
1989     {
1990         OOXMLFastContextHandler * pHandler = getFastContextHandler();
1991         if (pHandler != nullptr)
1992             pHandler->setId(rId);
1993     }
1994 }
1995
1996 Id OOXMLFastContextHandlerWrapper::getId() const
1997 {
1998     Id nResult = OOXMLFastContextHandler::getId();
1999
2000     if (mxContext.is())
2001     {
2002         OOXMLFastContextHandler * pHandler = getFastContextHandler();
2003         if (pHandler != nullptr && pHandler->getId() != 0)
2004             nResult = pHandler->getId();
2005     }
2006
2007     return nResult;
2008 }
2009
2010 void OOXMLFastContextHandlerWrapper::setToken(Token_t nToken)
2011 {
2012     OOXMLFastContextHandler::setToken(nToken);
2013
2014     if (mxContext.is())
2015     {
2016         OOXMLFastContextHandler * pHandler = getFastContextHandler();
2017         if (pHandler != nullptr)
2018             pHandler->setToken(nToken);
2019     }
2020 }
2021
2022 Token_t OOXMLFastContextHandlerWrapper::getToken() const
2023 {
2024     Token_t nResult = OOXMLFastContextHandler::getToken();
2025
2026     if (mxContext.is())
2027     {
2028         OOXMLFastContextHandler * pHandler = getFastContextHandler();
2029         if (pHandler != nullptr)
2030             nResult = pHandler->getToken();
2031     }
2032
2033     return nResult;
2034 }
2035
2036
2037 /*
2038   class OOXMLFastContextHandlerLinear
2039  */
2040
2041 OOXMLFastContextHandlerLinear::OOXMLFastContextHandlerLinear(OOXMLFastContextHandler* pContext)
2042     : OOXMLFastContextHandlerProperties(pContext)
2043     , depthCount( 0 )
2044 {
2045 }
2046
2047 void OOXMLFastContextHandlerLinear::lcl_startFastElement(Token_t Element,
2048     const uno::Reference< xml::sax::XFastAttributeList >& Attribs)
2049 {
2050     buffer.appendOpeningTag( Element, Attribs );
2051     ++depthCount;
2052 }
2053
2054 void OOXMLFastContextHandlerLinear::lcl_endFastElement(Token_t Element)
2055 {
2056     buffer.appendClosingTag( Element );
2057     if( --depthCount == 0 )
2058         process();
2059 }
2060
2061 uno::Reference< xml::sax::XFastContextHandler >
2062 OOXMLFastContextHandlerLinear::lcl_createFastChildContext(Token_t,
2063     const uno::Reference< xml::sax::XFastAttributeList >&)
2064 {
2065     uno::Reference< xml::sax::XFastContextHandler > xContextHandler;
2066     xContextHandler.set( this );
2067     return xContextHandler;
2068 }
2069
2070 void OOXMLFastContextHandlerLinear::lcl_characters(const OUString& aChars)
2071 {
2072     buffer.appendCharacters( aChars );
2073 }
2074
2075 /*
2076   class OOXMLFastContextHandlerLinear
2077  */
2078
2079 OOXMLFastContextHandlerMath::OOXMLFastContextHandlerMath(OOXMLFastContextHandler* pContext)
2080     : OOXMLFastContextHandlerLinear(pContext)
2081 {
2082 }
2083
2084 void OOXMLFastContextHandlerMath::process()
2085 {
2086     SvGlobalName name( SO3_SM_CLASSID );
2087     comphelper::EmbeddedObjectContainer container;
2088     OUString aName;
2089     uno::Sequence<beans::PropertyValue> objArgs(1);
2090     objArgs[0].Name = "DefaultParentBaseURL";
2091     objArgs[0].Value <<= getDocument()->GetDocumentBaseURL();
2092     uno::Reference<embed::XEmbeddedObject> ref =
2093         container.CreateEmbeddedObject(name.GetByteSequence(), objArgs, aName);
2094     assert(ref.is());
2095     if (!ref.is())
2096         return;
2097     uno::Reference< uno::XInterface > component(ref->getComponent(), uno::UNO_QUERY_THROW);
2098 // gcc4.4 (and 4.3 and possibly older) have a problem with dynamic_cast directly to the target class,
2099 // so help it with an intermediate cast. I'm not sure what exactly the problem is, seems to be unrelated
2100 // to RTLD_GLOBAL, so most probably a gcc bug.
2101     oox::FormulaImportBase& import = dynamic_cast<oox::FormulaImportBase&>(dynamic_cast<SfxBaseModel&>(*component.get()));
2102     import.readFormulaOoxml(buffer);
2103     if (isForwardEvents())
2104     {
2105         OOXMLPropertySet::Pointer_t pProps(new OOXMLPropertySet);
2106         OOXMLValue::Pointer_t pVal( new OOXMLStarMathValue( ref ));
2107         pProps->add(NS_ooxml::LN_starmath, pVal, OOXMLProperty::ATTRIBUTE);
2108         mpStream->props( pProps.get() );
2109     }
2110 }
2111
2112 }}
2113
2114 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */