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