writerfilter/source/ooxml/OOXMLDocumentImpl.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 <comphelper/sequenceashashmap.hxx>
  21
  22 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  23 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
  24 #include <com/sun/star/xml/sax/SAXException.hpp>
  25 #include <com/sun/star/xml/dom/DocumentBuilder.hpp>
  26 #include <com/sun/star/graphic/GraphicMapper.hpp>
  27 #include <ooxml/resourceids.hxx>
  28 #include <oox/drawingml/theme.hxx>
  29 #include <oox/shape/ShapeFilterBase.hxx>
  30 #include "OOXMLStreamImpl.hxx"
  31 #include "OOXMLDocumentImpl.hxx"
  32 #include "OOXMLBinaryObjectReference.hxx"
  33 #include "OOXMLFastDocumentHandler.hxx"
  34 #include "OOXMLPropertySet.hxx"
  35
  36 #include <sal/log.hxx>
  37 #include <comphelper/diagnose_ex.hxx>
  38 #include <svx/dialmgr.hxx>
  39 #include <svx/strings.hrc>
  40 #include <comphelper/sequence.hxx>
  41 #include <comphelper/namedvaluecollection.hxx>
  42 #include <cppuhelper/exc_hlp.hxx>
  43 #include <unotools/mediadescriptor.hxx>
  44
  45 #include <iostream>
  46 #include <sfx2/objsh.hxx>
  47 #include <utility>
  48
  49 // this extern variable is declared in OOXMLStreamImpl.hxx
  50 OUString customTarget;
  51 OUString embeddingsTarget;
  52 using namespace ::com::sun::star;
  53 namespace writerfilter::ooxml
  54 {
  55
  56 OOXMLDocumentImpl::OOXMLDocumentImpl(OOXMLStream::Pointer_t pStream, uno::Reference<task::XStatusIndicator> xStatusIndicator, bool bSkipImages, const uno::Sequence<beans::PropertyValue>& rDescriptor)
  57     : mpStream(std::move(pStream))
  58     , mxStatusIndicator(std::move(xStatusIndicator))
  59     , mnXNoteId(0)
  60     , mbIsSubstream(false)
  61     , mbSkipImages(bSkipImages)
  62     , mnPercentSize(0)
  63     , mnProgressLastPos(0)
  64     , mnProgressCurrentPos(0)
  65     , mnProgressEndPos(0)
  66     , m_rBaseURL(utl::MediaDescriptor(rDescriptor).getUnpackedValueOrDefault("DocumentBaseURL", OUString()))
  67     , maMediaDescriptor(rDescriptor)
  68     , mxGraphicMapper(graphic::GraphicMapper::create(mpStream->getContext()))
  69 {
  70     pushShapeContext();
  71 }
  72
  73 OOXMLDocumentImpl::~OOXMLDocumentImpl()
  74 {
  75 }
  76
  77 void OOXMLDocumentImpl::resolveFastSubStream(Stream & rStreamHandler,
  78                                              OOXMLStream::StreamType_t nType)
  79 {
  80     OOXMLStream::Pointer_t pStream;
  81     try
  82     {
  83         pStream = OOXMLDocumentFactory::createStream(mpStream, nType);
  84     }
  85     catch (uno::Exception const&)
  86     {
  87         TOOLS_INFO_EXCEPTION("writerfilter.ooxml", "resolveFastSubStream: exception while "
  88                 "resolving stream " << nType);
  89         return;
  90     }
  91     OOXMLStream::Pointer_t savedStream = mpStream;
  92     mpStream = pStream;
  93
  94     uno::Reference<xml::sax::XFastParser> xParser(mpStream->getFastParser());
  95
  96     if (xParser.is())
  97     {
  98         uno::Reference<uno::XComponentContext> xContext(mpStream->getContext());
  99         rtl::Reference<OOXMLFastDocumentHandler> pDocHandler =
 100                         new OOXMLFastDocumentHandler(xContext, &rStreamHandler, this, mnXNoteId);
 101
 102         uno::Reference<xml::sax::XFastTokenHandler> xTokenHandler(mpStream->getFastTokenHandler());
 103
 104         xParser->setFastDocumentHandler(pDocHandler);
 105         xParser->setTokenHandler(xTokenHandler);
 106
 107         uno::Reference<io::XInputStream> xInputStream = mpStream->getDocumentStream();
 108
 109         if (xInputStream.is())
 110         {
 111             struct xml::sax::InputSource oInputSource;
 112             oInputSource.aInputStream = xInputStream;
 113             xParser->parseStream(oInputSource);
 114
 115             xInputStream->closeInput();
 116         }
 117     }
 118
 119     mpStream = savedStream;
 120 }
 121
 122 void OOXMLDocumentImpl::resolveFastSubStreamWithId(Stream & rStream,
 123                                     const writerfilter::Reference<Stream>::Pointer_t& pStream,
 124                                     sal_uInt32 nId)
 125 {
 126     rStream.substream(nId, pStream);
 127 }
 128
 129 uno::Reference<xml::dom::XDocument> OOXMLDocumentImpl::importSubStream(OOXMLStream::StreamType_t nType)
 130 {
 131     uno::Reference<xml::dom::XDocument> xRet;
 132
 133     OOXMLStream::Pointer_t pStream;
 134     try
 135     {
 136         pStream = OOXMLDocumentFactory::createStream(mpStream, nType);
 137     }
 138     catch (uno::Exception const&)
 139     {
 140         TOOLS_INFO_EXCEPTION("writerfilter.ooxml", "importSubStream: exception while "
 141                 "importing stream " << nType);
 142         return xRet;
 143     }
 144
 145     uno::Reference<io::XInputStream> xInputStream = pStream->getDocumentStream();
 146     if (xInputStream.is())
 147     {
 148         try
 149         {
 150             uno::Reference<uno::XComponentContext> xContext(mpStream->getContext());
 151             uno::Reference<xml::dom::XDocumentBuilder> xDomBuilder(xml::dom::DocumentBuilder::create(xContext));
 152             xRet = xDomBuilder->parse(xInputStream);
 153         }
 154         catch (uno::Exception const&)
 155         {
 156             TOOLS_INFO_EXCEPTION("writerfilter.ooxml", "importSubStream: exception while "
 157                      "parsing stream " << nType);
 158             return xRet;
 159         }
 160     }
 161
 162     if (OOXMLStream::CUSTOMXML == nType)
 163     {
 164         importSubStreamRelations(pStream, OOXMLStream::CUSTOMXMLPROPS);
 165     }
 166     else if (OOXMLStream::CHARTS == nType)
 167     {
 168         importSubStreamRelations(pStream, OOXMLStream::EMBEDDINGS);
 169     }
 170
 171     return xRet;
 172 }
 173
 174
 175 void OOXMLDocumentImpl::importSubStreamRelations(const OOXMLStream::Pointer_t& pStream, OOXMLStream::StreamType_t nType)
 176 {
 177     uno::Reference<xml::dom::XDocument> xRelation;
 178     OOXMLStream::Pointer_t cStream;
 179     try
 180     {
 181         cStream = OOXMLDocumentFactory::createStream(pStream, nType);
 182     }
 183     catch (uno::Exception const&)
 184     {
 185         TOOLS_WARN_EXCEPTION("writerfilter.ooxml", "importSubStreamRelations: exception while "
 186             "importing stream " << nType);
 187         return;
 188     }
 189
 190     uno::Reference<io::XInputStream> xcpInputStream = cStream->getDocumentStream();
 191
 192     if (!xcpInputStream.is())
 193         return;
 194
 195     // importing itemprops files for item.xml from customXml.
 196     if (OOXMLStream::CUSTOMXMLPROPS == nType)
 197     {
 198         try
 199         {
 200              uno::Reference<uno::XComponentContext> xcpContext(pStream->getContext());
 201              uno::Reference<xml::dom::XDocumentBuilder> xDomBuilder(xml::dom::DocumentBuilder::create(xcpContext));
 202              xRelation = xDomBuilder->parse(xcpInputStream);
 203         }
 204         catch (uno::Exception const&)
 205         {
 206             TOOLS_WARN_EXCEPTION("writerfilter.ooxml", "importSubStream: exception while "
 207                      "parsing stream " << nType);
 208             mxCustomXmlProsDom = xRelation;
 209         }
 210
 211         if(xRelation.is())
 212         {
 213             mxCustomXmlProsDom = xRelation;
 214         }
 215     }
 216     else if(OOXMLStream::EMBEDDINGS == nType)
 217     {
 218         mxEmbeddings = xcpInputStream;
 219     }
 220     else if(OOXMLStream::CHARTS == nType)
 221     {
 222         importSubStreamRelations(cStream, OOXMLStream::EMBEDDINGS);
 223     }
 224
 225
 226 }
 227
 228 void OOXMLDocumentImpl::setXNoteId(const sal_Int32 nId)
 229 {
 230     mnXNoteId = nId;
 231 }
 232
 233 sal_Int32 OOXMLDocumentImpl::getXNoteId() const
 234 {
 235     return mnXNoteId;
 236 }
 237
 238 const OUString & OOXMLDocumentImpl::getTarget() const
 239 {
 240     return mpStream->getTarget();
 241 }
 242
 243 writerfilter::Reference<Stream>::Pointer_t
 244 OOXMLDocumentImpl::getSubStream(const OUString & rId)
 245 {
 246     OOXMLStream::Pointer_t pStream
 247         (OOXMLDocumentFactory::createStream(mpStream, rId));
 248
 249     OOXMLDocumentImpl * pTemp;
 250     // Do not pass status indicator to sub-streams: they are typically marginal in size, so we just track the main document for now.
 251     writerfilter::Reference<Stream>::Pointer_t pRet( pTemp = new OOXMLDocumentImpl(pStream, uno::Reference<task::XStatusIndicator>(), mbSkipImages, maMediaDescriptor));
 252     pTemp->setModel(mxModel);
 253     pTemp->setDrawPage(mxDrawPage);
 254     pTemp->mbIsSubstream = true;
 255     return pRet;
 256 }
 257
 258 writerfilter::Reference<Stream>::Pointer_t
 259 OOXMLDocumentImpl::getXNoteStream(OOXMLStream::StreamType_t nType, const sal_Int32 nId)
 260 {
 261     OOXMLStream::Pointer_t pStream =
 262         OOXMLDocumentFactory::createStream(mpStream, nType);
 263     // See above, no status indicator for the note stream, either.
 264     OOXMLDocumentImpl * pDocument = new OOXMLDocumentImpl(pStream, uno::Reference<task::XStatusIndicator>(), mbSkipImages, maMediaDescriptor);
 265     pDocument->setXNoteId(nId);
 266     pDocument->setModel(getModel());
 267     pDocument->setDrawPage(getDrawPage());
 268
 269     return writerfilter::Reference<Stream>::Pointer_t(pDocument);
 270 }
 271
 272 void OOXMLDocumentImpl::resolveFootnote(Stream & rStream,
 273                                         Id aType,
 274                                         const sal_Int32 nNoteId)
 275 {
 276     if (!mpXFootnoteStream)
 277         mpXFootnoteStream = getXNoteStream(OOXMLStream::FOOTNOTES, nNoteId);
 278
 279     Id nId;
 280     switch (aType)
 281     {
 282     case NS_ooxml::LN_Value_doc_ST_FtnEdn_separator:
 283     case NS_ooxml::LN_Value_doc_ST_FtnEdn_continuationSeparator:
 284         nId = aType;
 285         break;
 286     default:
 287         nId = NS_ooxml::LN_footnote;
 288         break;
 289     }
 290
 291     resolveFastSubStreamWithId(rStream, mpXFootnoteStream, nId);
 292 }
 293
 294 void OOXMLDocumentImpl::resolveEndnote(Stream & rStream,
 295                                        Id aType,
 296                                        const sal_Int32 nNoteId)
 297 {
 298     if (!mpXEndnoteStream)
 299        mpXEndnoteStream = getXNoteStream(OOXMLStream::ENDNOTES, nNoteId);
 300
 301     Id nId;
 302     switch (aType)
 303     {
 304     case NS_ooxml::LN_Value_doc_ST_FtnEdn_separator:
 305     case NS_ooxml::LN_Value_doc_ST_FtnEdn_continuationSeparator:
 306         nId = aType;
 307         break;
 308     default:
 309         nId = NS_ooxml::LN_endnote;
 310         break;
 311     }
 312
 313     resolveFastSubStreamWithId(rStream, mpXEndnoteStream, nId);
 314 }
 315
 316 void OOXMLDocumentImpl::resolveCommentsExtendedStream(Stream& rStream)
 317 {
 318     resolveFastSubStream(rStream, OOXMLStream::COMMENTS_EXTENDED);
 319 }
 320
 321 void OOXMLDocumentImpl::resolveComment(Stream & rStream,
 322                                        const sal_Int32 nId)
 323 {
 324     if (!mbCommentsExtendedResolved)
 325     {
 326         resolveCommentsExtendedStream(rStream);
 327         mbCommentsExtendedResolved = true;
 328     }
 329
 330     writerfilter::Reference<Stream>::Pointer_t pStream =
 331         getXNoteStream(OOXMLStream::COMMENTS, nId);
 332
 333     resolveFastSubStreamWithId(rStream, pStream, NS_ooxml::LN_annotation);
 334 }
 335
 336 OOXMLPropertySet * OOXMLDocumentImpl::getPicturePropSet
 337 (const OUString & rId)
 338 {
 339     OOXMLStream::Pointer_t pStream
 340         (OOXMLDocumentFactory::createStream(mpStream, rId));
 341
 342     writerfilter::Reference<BinaryObj>::Pointer_t pPicture
 343         (new OOXMLBinaryObjectReference(pStream));
 344
 345     OOXMLValue::Pointer_t pPayloadValue(new OOXMLBinaryValue(pPicture));
 346
 347     OOXMLPropertySet::Pointer_t pBlipSet(new OOXMLPropertySet);
 348
 349     pBlipSet->add(NS_ooxml::LN_payload, pPayloadValue, OOXMLProperty::ATTRIBUTE);
 350
 351     OOXMLValue::Pointer_t pBlipValue(new OOXMLPropertySetValue(pBlipSet));
 352
 353     OOXMLPropertySet * pProps = new OOXMLPropertySet;
 354
 355     pProps->add(NS_ooxml::LN_blip, pBlipValue, OOXMLProperty::ATTRIBUTE);
 356
 357     return pProps;
 358 }
 359
 360 void OOXMLDocumentImpl::resolvePicture(Stream & rStream,
 361                                        const OUString & rId)
 362 {
 363     OOXMLPropertySet::Pointer_t pProps(getPicturePropSet(rId));
 364
 365     rStream.props(pProps.get());
 366 }
 367
 368 OUString OOXMLDocumentImpl::getTargetForId(const OUString & rId)
 369 {
 370     return mpStream->getTargetForId(rId);
 371 }
 372
 373 void OOXMLDocumentImpl::resolveHeader(Stream & rStream,
 374                                       const sal_Int32 type,
 375                                       const OUString & rId)
 376 {
 377      writerfilter::Reference<Stream>::Pointer_t pStream =
 378          getSubStream(rId);
 379      switch (type)
 380      {
 381      case NS_ooxml::LN_Value_ST_HdrFtr_even:
 382          resolveFastSubStreamWithId(rStream, pStream, NS_ooxml::LN_headerl);
 383         break;
 384      case NS_ooxml::LN_Value_ST_HdrFtr_default: // here we assume that default is right, but not necessarily true :-(
 385          resolveFastSubStreamWithId(rStream, pStream, NS_ooxml::LN_headerr);
 386          break;
 387      case NS_ooxml::LN_Value_ST_HdrFtr_first:
 388          resolveFastSubStreamWithId(rStream, pStream, NS_ooxml::LN_headerf);
 389          break;
 390      default:
 391          break;
 392      }
 393 }
 394
 395 void OOXMLDocumentImpl::resolveFooter(Stream & rStream,
 396                                       const sal_Int32 type,
 397                                       const OUString & rId)
 398 {
 399      writerfilter::Reference<Stream>::Pointer_t pStream =
 400          getSubStream(rId);
 401
 402      switch (type)
 403      {
 404      case NS_ooxml::LN_Value_ST_HdrFtr_even:
 405          resolveFastSubStreamWithId(rStream, pStream, NS_ooxml::LN_footerl);
 406          break;
 407      case NS_ooxml::LN_Value_ST_HdrFtr_default: // here we assume that default is right, but not necessarily true :-(
 408          resolveFastSubStreamWithId(rStream, pStream, NS_ooxml::LN_footerr);
 409          break;
 410      case NS_ooxml::LN_Value_ST_HdrFtr_first:
 411          resolveFastSubStreamWithId(rStream, pStream, NS_ooxml::LN_footerf);
 412          break;
 413      default:
 414          break;
 415      }
 416 }
 417
 418 namespace {
 419 // Ensures that the indicator is reset after exiting OOXMLDocumentImpl::resolve
 420 class StatusIndicatorGuard{
 421 public:
 422     explicit StatusIndicatorGuard(css::uno::Reference<css::task::XStatusIndicator> xStatusIndicator)
 423         :mxStatusIndicator(std::move(xStatusIndicator))
 424     {
 425     }
 426
 427     ~StatusIndicatorGuard()
 428     {
 429         if (mxStatusIndicator.is())
 430                 mxStatusIndicator->end();
 431     }
 432
 433 private:
 434     css::uno::Reference<css::task::XStatusIndicator> mxStatusIndicator;
 435 };
 436 }
 437
 438 void OOXMLDocumentImpl::resolve(Stream & rStream)
 439 {
 440     StatusIndicatorGuard aStatusIndicatorGuard(mxStatusIndicator);
 441
 442     if (utl::MediaDescriptor(maMediaDescriptor).getUnpackedValueOrDefault("ReadGlossaries", false))
 443     {
 444         resolveFastSubStream(rStream, OOXMLStream::GLOSSARY);
 445         return;
 446     }
 447
 448     uno::Reference<xml::sax::XFastParser> xParser(mpStream->getFastParser());
 449
 450     if (mxModel.is())
 451     {
 452         uno::Reference<document::XDocumentPropertiesSupplier> xDocumentPropertiesSupplier(mxModel, uno::UNO_QUERY);
 453         uno::Reference<document::XDocumentProperties> xDocumentProperties = xDocumentPropertiesSupplier->getDocumentProperties();
 454         comphelper::SequenceAsHashMap aMap(xDocumentProperties->getDocumentStatistics());
 455         if (aMap.find("ParagraphCount") != aMap.end())
 456         {
 457             sal_Int32 nValue;
 458             if (aMap["ParagraphCount"] >>= nValue)
 459             {
 460                 if (mxStatusIndicator.is())
 461                 {
 462                     // We want to care about the progress if we know the estimated paragraph count and we have given a status indicator as well.
 463                     // Set the end position only here, so later it's enough to check if that is non-zero in incrementProgress().
 464                     mnProgressEndPos = nValue;
 465                     OUString aDocLoad(SvxResId(RID_SVXSTR_DOC_LOAD));
 466                     mxStatusIndicator->start(aDocLoad, mnProgressEndPos);
 467                     mnPercentSize = mnProgressEndPos / 100;
 468                 }
 469             }
 470         }
 471     }
 472
 473     if (!xParser.is())
 474         return;
 475
 476     uno::Reference<uno::XComponentContext> xContext(mpStream->getContext());
 477
 478     rStream.setDocumentReference(this);
 479
 480     rtl::Reference<OOXMLFastDocumentHandler> pDocHandler =
 481                 new OOXMLFastDocumentHandler(xContext, &rStream, this, mnXNoteId);
 482     pDocHandler->setIsSubstream( mbIsSubstream );
 483     uno::Reference < xml::sax::XFastTokenHandler > xTokenHandler(mpStream->getFastTokenHandler());
 484
 485     resolveFastSubStream(rStream, OOXMLStream::SETTINGS);
 486     mxThemeDom = importSubStream(OOXMLStream::THEME);
 487     resolveFastSubStream(rStream, OOXMLStream::THEME);
 488     // Convert the oox::Theme to the draw page
 489     {
 490         auto pThemePtr = getTheme();
 491         if (pThemePtr)
 492             pThemePtr->addTheme(getDrawPage());
 493     }
 494     mxGlossaryDocDom = importSubStream(OOXMLStream::GLOSSARY);
 495     if (mxGlossaryDocDom.is())
 496         resolveGlossaryStream(rStream);
 497
 498     resolveEmbeddingsStream(mpStream);
 499
 500     // Custom xml's are handled as part of grab bag.
 501     resolveCustomXmlStream(rStream);
 502
 503     resolveFastSubStream(rStream, OOXMLStream::FONTTABLE);
 504     resolveFastSubStream(rStream, OOXMLStream::STYLES);
 505     resolveFastSubStream(rStream, OOXMLStream::NUMBERING);
 506
 507     xParser->setFastDocumentHandler( pDocHandler );
 508     xParser->setTokenHandler( xTokenHandler );
 509
 510     xml::sax::InputSource aParserInput;
 511     aParserInput.sSystemId = mpStream->getTarget();
 512     aParserInput.aInputStream = mpStream->getDocumentStream();
 513     try
 514     {
 515         xParser->parseStream(aParserInput);
 516     }
 517     catch (xml::sax::SAXException const& rErr)
 518     {
 519         // don't silently swallow these - handlers may not have been executed,
 520         // and the domain mapper is likely in an inconsistent state
 521         // In case user chooses to try to continue loading, don't ask again for this file
 522         SfxObjectShell* rShell = SfxObjectShell::GetShellFromComponent(mxModel);
 523         if (!rShell
 524             || !rShell->IsContinueImportOnFilterExceptions(
 525                 Concat2View("SAXException: " + rErr.Message)))
 526             throw;
 527     }
 528     catch (uno::RuntimeException const&)
 529     {
 530         throw;
 531     }
 532     // note: cannot throw anything other than SAXException out of here?
 533     catch (uno::Exception const&)
 534     {
 535         css::uno::Any anyEx = cppu::getCaughtException();
 536         SAL_WARN("writerfilter.ooxml", "OOXMLDocumentImpl::resolve(): " << exceptionToString(anyEx));
 537         throw lang::WrappedTargetRuntimeException("", nullptr, anyEx);
 538     }
 539     catch (...)
 540     {
 541         SAL_WARN("writerfilter.ooxml",
 542             "OOXMLDocumentImpl::resolve(): non-UNO exception");
 543     }
 544 }
 545
 546 void OOXMLDocumentImpl::incrementProgress()
 547 {
 548     mnProgressCurrentPos++;
 549     // 1) If we know the end
 550     // 2) We progressed enough that updating makes sense
 551     // 3) We did not reach the end yet (possible in case the doc stat is misleading)
 552     if (mnProgressEndPos && mnProgressCurrentPos > (mnProgressLastPos + mnPercentSize) && mnProgressLastPos < mnProgressEndPos)
 553     {
 554         mnProgressLastPos = mnProgressCurrentPos;
 555         if (mxStatusIndicator.is())
 556             mxStatusIndicator->setValue(mnProgressLastPos);
 557     }
 558 }
 559
 560 void OOXMLDocumentImpl::resolveCustomXmlStream(Stream & rStream)
 561 {
 562     // Resolving all item[n].xml files from CustomXml folder.
 563     uno::Reference<embed::XRelationshipAccess> xRelationshipAccess;
 564     xRelationshipAccess.set(dynamic_cast<OOXMLStreamImpl&>(*mpStream).accessDocumentStream(), uno::UNO_QUERY);
 565     if (!xRelationshipAccess.is())
 566         return;
 567
 568     static const char sCustomType[] = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml";
 569     static const char sCustomTypeStrict[] = "http://purl.oclc.org/ooxml/officeDocument/relationships/customXml";
 570     bool bFound = false;
 571     const uno::Sequence<uno::Sequence< beans::StringPair>> aSeqs = xRelationshipAccess->getAllRelationships();
 572     std::vector<uno::Reference<xml::dom::XDocument>> aCustomXmlDomList;
 573     std::vector<uno::Reference<xml::dom::XDocument>> aCustomXmlDomPropsList;
 574     for (const uno::Sequence<beans::StringPair>& aSeq : aSeqs)
 575     {
 576         for (const beans::StringPair& aPair : aSeq)
 577         {
 578             // Need to resolve only customxml files from document relationships.
 579             // Skipping other files.
 580             if (aPair.Second == sCustomType ||
 581                 aPair.Second == sCustomTypeStrict)
 582                 bFound = true;
 583             else if (aPair.First == "Target" && bFound)
 584             {
 585                 // Adding value to extern variable customTarget. It will be used in ooxmlstreamimpl
 586                 // to ensure customxml target is visited in lcl_getTarget.
 587                 customTarget = aPair.Second;
 588             }
 589         }
 590
 591         if (bFound)
 592         {
 593             uno::Reference<xml::dom::XDocument> customXmlTemp = importSubStream(OOXMLStream::CUSTOMXML);
 594             // This will add all item[n].xml with its relationship file i.e itemprops.xml to
 595             // grabbag list.
 596             if (mxCustomXmlProsDom.is() && customXmlTemp.is())
 597             {
 598                 aCustomXmlDomList.push_back(customXmlTemp);
 599                 aCustomXmlDomPropsList.push_back(mxCustomXmlProsDom);
 600                 resolveFastSubStream(rStream, OOXMLStream::CUSTOMXML);
 601             }
 602
 603             bFound = false;
 604         }
 605     }
 606
 607     mxCustomXmlDomList = comphelper::containerToSequence(aCustomXmlDomList);
 608     mxCustomXmlDomPropsList = comphelper::containerToSequence(aCustomXmlDomPropsList);
 609 }
 610
 611 namespace
 612 {
 613 const char sSettingsType[] = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings";
 614 const char sStylesType[] = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles";
 615 const char sFonttableType[] = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable";
 616 const char sWebSettings[] = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings";
 617 const char sSettingsTypeStrict[] = "http://purl.oclc.org/ooxml/officeDocument/relationships/settings";
 618 const char sStylesTypeStrict[] = "http://purl.oclc.org/ooxml/officeDocument/relationships/styles";
 619 const char sFonttableTypeStrict[] = "http://purl.oclc.org/ooxml/officeDocument/relationships/fontTable";
 620 const char sWebSettingsStrict[] = "http://purl.oclc.org/ooxml/officeDocument/relationships/webSettings";
 621
 622 constexpr OUStringLiteral sId = u"Id";
 623 constexpr OUStringLiteral sType = u"Type";
 624 constexpr OUStringLiteral sTarget = u"Target";
 625 constexpr OUStringLiteral sTargetMode = u"TargetMode";
 626 constexpr OUStringLiteral sContentType = u"_contentType";
 627 constexpr OUStringLiteral sRelDom = u"_relDom";
 628 constexpr OUStringLiteral sSettingsContentType = u"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml";
 629 constexpr OUStringLiteral sStylesContentType = u"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml";
 630 constexpr OUStringLiteral sWebsettingsContentType = u"application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml";
 631 constexpr OUStringLiteral sFonttableContentType = u"application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml";
 632 }
 633
 634 // See DocxExport::WriteGlossary
 635 void OOXMLDocumentImpl::resolveGlossaryStream(Stream & /*rStream*/)
 636 {
 637     OOXMLStream::Pointer_t pStream;
 638     try
 639     {
 640         pStream = OOXMLDocumentFactory::createStream(mpStream, OOXMLStream::GLOSSARY);
 641     }
 642     catch (uno::Exception const&)
 643     {
 644         TOOLS_INFO_EXCEPTION("writerfilter.ooxml", "resolveGlossaryStream: exception while "
 645                  "createStream for glossary" << OOXMLStream::GLOSSARY);
 646         return;
 647     }
 648     uno::Reference<embed::XRelationshipAccess> xRelationshipAccess;
 649     xRelationshipAccess.set(dynamic_cast<OOXMLStreamImpl&>(*pStream).accessDocumentStream(), uno::UNO_QUERY);
 650     if (!xRelationshipAccess.is())
 651         return;
 652
 653
 654     const uno::Sequence< uno::Sequence< beans::StringPair > >aSeqs = xRelationshipAccess->getAllRelationships();
 655     std::vector< uno::Sequence<beans::NamedValue> > aGlossaryDomList;
 656     for (const uno::Sequence< beans::StringPair >& aSeq : aSeqs)
 657     {
 658         comphelper::NamedValueCollection aRelDefinition;
 659         for (const auto& [name, value] : aSeq)
 660             aRelDefinition.put(name, value);
 661
 662         const OUString gType = aRelDefinition.getOrDefault(sType, OUString{});
 663         OOXMLStream::StreamType_t nType(OOXMLStream::UNKNOWN);
 664         if (gType == sSettingsType || gType == sSettingsTypeStrict)
 665         {
 666             nType = OOXMLStream::SETTINGS;
 667             aRelDefinition.put(sContentType, sSettingsContentType);
 668         }
 669         else if (gType == sStylesType || gType == sStylesTypeStrict)
 670         {
 671             nType = OOXMLStream::STYLES;
 672             aRelDefinition.put(sContentType, sStylesContentType);
 673         }
 674         else if (gType == sWebSettings || gType == sWebSettingsStrict)
 675         {
 676             nType = OOXMLStream::WEBSETTINGS;
 677             aRelDefinition.put(sContentType, sWebsettingsContentType);
 678         }
 679         else if (gType == sFonttableType || gType == sFonttableTypeStrict)
 680         {
 681             nType = OOXMLStream::FONTTABLE;
 682             aRelDefinition.put(sContentType, sFonttableContentType);
 683         }
 684         else if (aRelDefinition.getOrDefault(sTargetMode, OUString{}) != "External")
 685         {
 686             // Some internal relation, but we don't create a DOM for it here yet?
 687             SAL_WARN("writerfilter.ooxml", "Unknown type of glossary internal relation: "
 688                 "Id=\"" + aRelDefinition.getOrDefault<OUString>(sId, {}) + "\" "
 689                 "Type=\"" + gType + "\" "
 690                 "Target=\"" + aRelDefinition.getOrDefault<OUString>(sTarget, {}) + "\"");
 691             continue;
 692         }
 693
 694         if (nType != OOXMLStream::UNKNOWN)
 695         {
 696             try
 697             {
 698                 auto gStream = OOXMLDocumentFactory::createStream(pStream, nType);
 699                 uno::Reference xInputStream = gStream->getDocumentStream();
 700                 uno::Reference xContext(pStream->getContext());
 701                 uno::Reference xDomBuilder(xml::dom::DocumentBuilder::create(xContext));
 702                 uno::Reference xDom = xDomBuilder->parse(xInputStream);
 703                 aRelDefinition.put(sRelDom, xDom);
 704             }
 705             catch (uno::Exception const&)
 706             {
 707                 TOOLS_INFO_EXCEPTION("writerfilter.ooxml", "importSubStream: exception while "
 708                     "parsing stream of Type" << nType);
 709             }
 710         }
 711         aGlossaryDomList.push_back(aRelDefinition.getNamedValues());
 712     }
 713     mxGlossaryDomList = comphelper::containerToSequence(aGlossaryDomList);
 714 }
 715
 716 void OOXMLDocumentImpl::resolveEmbeddingsStream(const OOXMLStream::Pointer_t& pStream)
 717 {
 718     uno::Reference<embed::XRelationshipAccess> xRelationshipAccess;
 719     xRelationshipAccess.set(dynamic_cast<OOXMLStreamImpl&>(*pStream).accessDocumentStream(), uno::UNO_QUERY);
 720     if (xRelationshipAccess.is())
 721     {
 722         OUString const sChartType("http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart");
 723         OUString const sChartTypeStrict("http://purl.oclc.org/ooxml/officeDocument/relationships/chart");
 724         OUString const sFootersType("http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer");
 725         OUString const sFootersTypeStrict("http://purl.oclc.org/ooxml/officeDocument/relationships/footer");
 726         OUString const sHeaderType("http://schemas.openxmlformats.org/officeDocument/2006/relationships/header");
 727         OUString const sHeaderTypeStrict("http://purl.oclc.org/ooxml/officeDocument/relationships/header");
 728
 729         bool bFound = false;
 730         bool bHeaderFooterFound = false;
 731         OOXMLStream::StreamType_t streamType = OOXMLStream::UNKNOWN;
 732         const uno::Sequence< uno::Sequence< beans::StringPair > >aSeqs = xRelationshipAccess->getAllRelationships();
 733         for (const uno::Sequence< beans::StringPair >& aSeq : aSeqs)
 734         {
 735             for (const beans::StringPair& aPair : aSeq)
 736             {
 737                 if (aPair.Second == sChartType ||
 738                         aPair.Second == sChartTypeStrict)
 739                 {
 740                     bFound = true;
 741                 }
 742                 else if(aPair.Second == sFootersType ||
 743                         aPair.Second == sFootersTypeStrict)
 744                 {
 745                     bHeaderFooterFound = true;
 746                     streamType = OOXMLStream::FOOTER;
 747                 }
 748                 else if(aPair.Second == sHeaderType ||
 749                         aPair.Second == sHeaderTypeStrict)
 750                 {
 751                     bHeaderFooterFound = true;
 752                     streamType = OOXMLStream::HEADER;
 753                 }
 754                 else if(aPair.First == "Target" && ( bFound || bHeaderFooterFound ))
 755                 {
 756                     // Adding value to extern variable customTarget. It will be used in ooxmlstreamimpl
 757                     // to ensure chart.xml target is visited in lcl_getTarget.
 758                     customTarget = aPair.Second;
 759                 }
 760             }
 761             if( bFound || bHeaderFooterFound)
 762             {
 763                 if(bFound)
 764                 {
 765                     importSubStreamRelations(pStream, OOXMLStream::CHARTS);
 766                 }
 767                 if(bHeaderFooterFound)
 768                 {
 769                     try
 770                     {
 771                         OOXMLStream::Pointer_t Stream = OOXMLDocumentFactory::createStream(pStream, streamType);
 772                         if (Stream)
 773                             resolveEmbeddingsStream(Stream);
 774                     }
 775                     catch (uno::Exception const&)
 776                     {
 777                         TOOLS_INFO_EXCEPTION("writerfilter.ooxml", "resolveEmbeddingsStream: can't find header/footer whilst "
 778                                "resolving stream " << streamType);
 779                         return;
 780                     }
 781                 }
 782
 783                 beans::PropertyValue embeddingsTemp;
 784                 // This will add all .xlsx and .bin to grabbag list.
 785                 if(bFound && mxEmbeddings.is())
 786                 {
 787                     embeddingsTemp.Name = embeddingsTarget;
 788                     embeddingsTemp.Value <<= mxEmbeddings;
 789                     m_aEmbeddings.push_back(embeddingsTemp);
 790                     mxEmbeddings.clear();
 791                 }
 792                 bFound = false;
 793                 bHeaderFooterFound = false;
 794             }
 795         }
 796     }
 797     if (!m_aEmbeddings.empty())
 798         mxEmbeddingsList = comphelper::containerToSequence(m_aEmbeddings);
 799 }
 800
 801 uno::Reference<xml::dom::XDocument> OOXMLDocumentImpl::getGlossaryDocDom( )
 802 {
 803     return mxGlossaryDocDom;
 804 }
 805
 806 uno::Sequence<uno::Sequence< beans::NamedValue> > OOXMLDocumentImpl::getGlossaryDomList()
 807 {
 808     return mxGlossaryDomList;
 809 }
 810
 811 uno::Reference<io::XInputStream> OOXMLDocumentImpl::getInputStreamForId(const OUString & rId)
 812 {
 813     OOXMLStream::Pointer_t pStream(OOXMLDocumentFactory::createStream(mpStream, rId));
 814
 815     return pStream->getDocumentStream();
 816 }
 817
 818 void OOXMLDocumentImpl::setModel(uno::Reference<frame::XModel> xModel)
 819 {
 820     mxModel.set(xModel);
 821 }
 822
 823 uno::Reference<frame::XModel> OOXMLDocumentImpl::getModel()
 824 {
 825     return mxModel;
 826 }
 827
 828 void OOXMLDocumentImpl::setDrawPage(uno::Reference<drawing::XDrawPage> xDrawPage)
 829 {
 830     mxDrawPage.set(xDrawPage);
 831 }
 832
 833 uno::Reference<drawing::XDrawPage> OOXMLDocumentImpl::getDrawPage()
 834 {
 835     return mxDrawPage;
 836 }
 837
 838 const uno::Sequence<beans::PropertyValue>& OOXMLDocumentImpl::getMediaDescriptor() const
 839 {
 840     return maMediaDescriptor;
 841 }
 842
 843 void OOXMLDocumentImpl::setShapeContext( rtl::Reference<oox::shape::ShapeContextHandler> xContext )
 844 {
 845     if (!maShapeContexts.empty())
 846         maShapeContexts.top() = xContext;
 847 }
 848
 849 rtl::Reference<oox::shape::ShapeContextHandler> OOXMLDocumentImpl::getShapeContext( )
 850 {
 851     if (!maShapeContexts.empty())
 852         return maShapeContexts.top();
 853     else
 854         return {};
 855 }
 856
 857 void OOXMLDocumentImpl::pushShapeContext()
 858 {
 859     maShapeContexts.push({});
 860 }
 861
 862 void OOXMLDocumentImpl::popShapeContext()
 863 {
 864     if (!maShapeContexts.empty())
 865         maShapeContexts.pop();
 866 }
 867
 868 uno::Reference<xml::dom::XDocument> OOXMLDocumentImpl::getThemeDom( )
 869 {
 870     return mxThemeDom;
 871 }
 872
 873 uno::Sequence<uno::Reference<xml::dom::XDocument> > OOXMLDocumentImpl::getCustomXmlDomList( )
 874 {
 875     return mxCustomXmlDomList;
 876 }
 877
 878 uno::Sequence<uno::Reference<xml::dom::XDocument> > OOXMLDocumentImpl::getCustomXmlDomPropsList( )
 879 {
 880     return mxCustomXmlDomPropsList;
 881 }
 882
 883 uno::Sequence<beans::PropertyValue > OOXMLDocumentImpl::getEmbeddingsList( )
 884 {
 885     return mxEmbeddingsList;
 886 }
 887
 888 const rtl::Reference<oox::shape::ShapeFilterBase>& OOXMLDocumentImpl::getShapeFilterBase()
 889 {
 890     if (!mxShapeFilterBase)
 891         mxShapeFilterBase = new oox::shape::ShapeFilterBase(mpStream->getContext());
 892     return mxShapeFilterBase;
 893 }
 894
 895 const rtl::Reference<oox::drawingml::ThemeFilterBase>& OOXMLDocumentImpl::getThemeFilterBase()
 896 {
 897     if (!mxThemeFilterBase)
 898         mxThemeFilterBase = new oox::drawingml::ThemeFilterBase(mpStream->getContext());
 899     return mxThemeFilterBase;
 900 }
 901
 902 OOXMLDocument *
 903 OOXMLDocumentFactory::createDocument
 904 (const OOXMLStream::Pointer_t& pStream,
 905  const uno::Reference<task::XStatusIndicator>& xStatusIndicator,
 906  bool mbSkipImages, const uno::Sequence<beans::PropertyValue>& rDescriptor)
 907 {
 908     return new OOXMLDocumentImpl(pStream, xStatusIndicator, mbSkipImages, rDescriptor);
 909 }
 910
 911 }
 912
 913 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */