svx/source/xml/xmlxtexp.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 <sal/config.h>
  21
  22 #include <tools/diagnose_ex.h>
  23 #include <tools/urlobj.hxx>
  24 #include <com/sun/star/beans/XPropertySet.hpp>
  25 #include <com/sun/star/container/XNameContainer.hpp>
  26 #include <com/sun/star/xml/sax/Writer.hpp>
  27 #include <com/sun/star/uno/Sequence.hxx>
  28 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
  29 #include <com/sun/star/drawing/LineDash.hpp>
  30 #include <com/sun/star/awt/Gradient.hpp>
  31 #include <com/sun/star/awt/XBitmap.hpp>
  32 #include <com/sun/star/drawing/Hatch.hpp>
  33 #include <com/sun/star/embed/ElementModes.hpp>
  34
  35 #include <sax/tools/converter.hxx>
  36 #include <sfx2/docfile.hxx>
  37 #include <rtl/ustrbuf.hxx>
  38 #include <xmloff/xmlnamespace.hxx>
  39 #include <xmloff/namespacemap.hxx>
  40
  41 #include <xmloff/xmltoken.hxx>
  42 #include <xmloff/xmlmetae.hxx>
  43 #include <xmloff/DashStyle.hxx>
  44 #include <xmloff/GradientStyle.hxx>
  45 #include <xmloff/HatchStyle.hxx>
  46 #include <xmloff/ImageStyle.hxx>
  47 #include <xmloff/MarkerStyle.hxx>
  48 #include <com/sun/star/embed/XTransactedObject.hpp>
  49 #include <comphelper/processfactory.hxx>
  50 #include <unotools/streamwrap.hxx>
  51 #include <svx/xmlgrhlp.hxx>
  52
  53 #include <xmlxtexp.hxx>
  54
  55 #include <comphelper/storagehelper.hxx>
  56 #include <memory>
  57
  58 using namespace com::sun::star;
  59 using namespace com::sun::star::container;
  60 using namespace com::sun::star::document;
  61 using namespace com::sun::star::uno;
  62 using namespace com::sun::star::awt;
  63 using namespace com::sun::star::lang;
  64 using namespace com::sun::star::xml::sax;
  65 using namespace ::xmloff::token;
  66 using namespace cppu;
  67
  68 using com::sun::star::embed::XTransactedObject;
  69
  70 namespace {
  71
  72 class SvxXMLTableEntryExporter
  73 {
  74 public:
  75     explicit SvxXMLTableEntryExporter( SvXMLExport& rExport ) : mrExport( rExport ) {}
  76     virtual ~SvxXMLTableEntryExporter();
  77
  78     virtual void exportEntry( const OUString& rStrName, const Any& rValue ) = 0;
  79
  80 protected:
  81     SvXMLExport& mrExport;
  82 };
  83
  84 class SvxXMLColorEntryExporter : public SvxXMLTableEntryExporter
  85 {
  86 public:
  87     explicit SvxXMLColorEntryExporter( SvXMLExport& rExport );
  88
  89     virtual void exportEntry( const OUString& rStrName, const Any& rValue ) override;
  90 };
  91
  92 class SvxXMLLineEndEntryExporter : public SvxXMLTableEntryExporter
  93 {
  94 public:
  95     explicit SvxXMLLineEndEntryExporter( SvXMLExport& rExport );
  96
  97     virtual void exportEntry( const OUString& rStrName, const Any& rValue ) override;
  98 private:
  99     XMLMarkerStyleExport maMarkerStyle;
 100 };
 101
 102 class SvxXMLDashEntryExporter : public SvxXMLTableEntryExporter
 103 {
 104 public:
 105     explicit SvxXMLDashEntryExporter( SvXMLExport& rExport );
 106
 107     virtual void exportEntry( const OUString& rStrName, const Any& rValue ) override;
 108
 109 private:
 110     XMLDashStyleExport maDashStyle;
 111 };
 112
 113 class SvxXMLHatchEntryExporter : public SvxXMLTableEntryExporter
 114 {
 115 public:
 116     explicit SvxXMLHatchEntryExporter( SvXMLExport& rExport );
 117
 118     virtual void exportEntry( const OUString& rStrName, const Any& rValue ) override;
 119 private:
 120     XMLHatchStyleExport maHatchStyle;
 121 };
 122
 123 class SvxXMLGradientEntryExporter : public SvxXMLTableEntryExporter
 124 {
 125 public:
 126     explicit SvxXMLGradientEntryExporter( SvXMLExport& rExport );
 127
 128     virtual void exportEntry( const OUString& rStrName, const Any& rValue ) override;
 129 private:
 130     XMLGradientStyleExport maGradientStyle;
 131 };
 132
 133 class SvxXMLBitmapEntryExporter : public SvxXMLTableEntryExporter
 134 {
 135 public:
 136     explicit SvxXMLBitmapEntryExporter( SvXMLExport& rExport );
 137
 138     virtual void exportEntry( const OUString& rStrName, const Any& rValue ) override;
 139 };
 140
 141 }
 142
 143 SvxXMLXTableExportComponent::SvxXMLXTableExportComponent(
 144     const css::uno::Reference< css::uno::XComponentContext >& rContext,
 145     const uno::Reference<xml::sax::XDocumentHandler> & rHandler,
 146     const uno::Reference<container::XNameContainer >& xTable,
 147     uno::Reference<document::XGraphicStorageHandler> const & xGraphicStorageHandler)
 148 :   SvXMLExport(rContext, "", /*rFileName*/"", rHandler, nullptr, FieldUnit::MM_100TH, SvXMLExportFlags::NONE),
 149     mxTable( xTable )
 150 {
 151
 152     GetNamespaceMap_().Add( GetXMLToken(XML_NP_OOO), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO );
 153     GetNamespaceMap_().Add( GetXMLToken(XML_NP_OFFICE), GetXMLToken(XML_N_OFFICE), XML_NAMESPACE_OFFICE );
 154     GetNamespaceMap_().Add( GetXMLToken(XML_NP_DRAW), GetXMLToken(XML_N_DRAW), XML_NAMESPACE_DRAW );
 155     GetNamespaceMap_().Add( GetXMLToken(XML_NP_XLINK), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK );
 156     GetNamespaceMap_().Add( GetXMLToken(XML_NP_SVG), GetXMLToken(XML_N_SVG),  XML_NAMESPACE_SVG );
 157     SetGraphicStorageHandler(xGraphicStorageHandler);
 158 }
 159
 160 SvxXMLXTableExportComponent::~SvxXMLXTableExportComponent()
 161 {
 162 }
 163
 164 static void initializeStreamMetadata( const uno::Reference< uno::XInterface > &xOut )
 165 {
 166     uno::Reference< beans::XPropertySet > xProps( xOut, uno::UNO_QUERY );
 167     if( !xProps.is() )
 168     {
 169         OSL_FAIL( "Missing stream metadata interface" );
 170         return;
 171     }
 172
 173     try
 174     {
 175         xProps->setPropertyValue("MediaType",  uno::makeAny( OUString( "text/xml" ) ) );
 176
 177         // use stock encryption
 178         xProps->setPropertyValue("UseCommonStoragePasswordEncryption", uno::makeAny( true ) );
 179     } catch ( const uno::Exception & )
 180     {
 181         TOOLS_WARN_EXCEPTION("svx", "exception setting stream metadata");
 182     }
 183 }
 184
 185 static void createStorageStream( uno::Reference < io::XOutputStream > *xOut,
 186                                  rtl::Reference<SvXMLGraphicHelper>&   rxGraphicHelper,
 187                                  const uno::Reference < embed::XStorage >& xSubStorage )
 188 {
 189     uno::Reference < io::XStream > xStream = xSubStorage->openStreamElement(
 190                         "Content.xml",
 191                         embed::ElementModes::WRITE );
 192     rxGraphicHelper = SvXMLGraphicHelper::Create( xSubStorage, SvXMLGraphicHelperMode::Write );
 193     initializeStreamMetadata( xStream );
 194     *xOut = xStream->getOutputStream();
 195 }
 196
 197 bool SvxXMLXTableExportComponent::save(
 198         const OUString& rURL,
 199         const uno::Reference<container::XNameContainer >& xTable,
 200         const uno::Reference<embed::XStorage >& xStorage,
 201         OUString *pOptName )
 202 {
 203     bool bRet = false;
 204     std::unique_ptr<SfxMedium> pMedium;
 205     rtl::Reference<SvXMLGraphicHelper> xGraphicHelper;
 206
 207     INetURLObject aURLObj( rURL );
 208     bool bToStorage = aURLObj.GetProtocol() == INetProtocol::NotValid; // a relative path
 209     bool bSaveAsStorage = xTable->getElementType() == cppu::UnoType<awt::XBitmap>::get();
 210
 211     if( pOptName )
 212         *pOptName = rURL;
 213
 214     try
 215     {
 216         uno::Reference< uno::XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
 217
 218         uno::Reference< xml::sax::XWriter > xWriter = xml::sax::Writer::create( xContext );
 219
 220         uno::Reference < io::XStream > xStream;
 221         uno::Reference < io::XOutputStream > xOut;
 222         uno::Reference<embed::XStorage > xSubStorage;
 223         uno::Reference<XGraphicStorageHandler> xGraphicStorageHandler;
 224         const sal_Int32 eCreate = embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE;
 225
 226         if( !bToStorage || !xStorage.is() )
 227         { // local URL -> SfxMedium route
 228             if( bSaveAsStorage )
 229                 xSubStorage = ::comphelper::OStorageHelper::GetStorageFromURL( rURL, eCreate );
 230             else
 231             {
 232                 pMedium.reset(new SfxMedium( rURL, StreamMode::WRITE | StreamMode::TRUNC ));
 233
 234                 SvStream* pStream = pMedium->GetOutStream();
 235                 if( !pStream )
 236                 {
 237                     OSL_FAIL( "no output stream!" );
 238                     return false;
 239                 }
 240
 241                 xOut = new utl::OOutputStreamWrapper( *pStream );
 242             }
 243         }
 244         else // save into the xSubStorage
 245         {
 246             OUString aPath = rURL;
 247
 248             if( bSaveAsStorage )
 249             {
 250                 try {
 251                     xSubStorage = xStorage->openStorageElement( aPath, eCreate );
 252                 } catch (uno::Exception &) {
 253                     OSL_FAIL( "no output storage!" );
 254                     return false;
 255                 }
 256             }
 257             else
 258             {
 259                 aPath += ".xml";
 260                 try {
 261                     xStream = xStorage->openStreamElement( aPath, eCreate );
 262                     if( !xStream.is() )
 263                         return false;
 264                     initializeStreamMetadata( xStream );
 265                     xOut = xStream->getOutputStream();
 266                 } catch (uno::Exception &) {
 267                     OSL_FAIL( "no output stream!" );
 268                     return false;
 269                 }
 270                 if( pOptName )
 271                     *pOptName = aPath;
 272             }
 273         }
 274
 275         if( !xOut.is() && xSubStorage.is() )
 276             createStorageStream( &xOut, xGraphicHelper, xSubStorage );
 277         if( !xOut.is() )
 278             return false;
 279
 280         xWriter->setOutputStream( xOut );
 281         if( xGraphicHelper.is() )
 282             xGraphicStorageHandler = xGraphicHelper.get();
 283
 284         // Finally do the export
 285         rtl::Reference< SvxXMLXTableExportComponent > xExporter( new SvxXMLXTableExportComponent( xContext, xWriter, xTable, xGraphicStorageHandler ) );
 286         bRet = xExporter->exportTable();
 287
 288         if( xGraphicHelper )
 289             xGraphicHelper->dispose();
 290         xGraphicHelper.clear();
 291
 292         if( xSubStorage.is() )
 293         {
 294             uno::Reference< XTransactedObject > xTrans( xSubStorage, UNO_QUERY );
 295             if( xTrans.is() )
 296                 xTrans->commit();
 297
 298             xSubStorage->dispose();
 299         }
 300     }
 301     catch( uno::Exception& )
 302     {
 303         bRet = false;
 304     }
 305
 306     if( pMedium )
 307         pMedium->Commit();
 308
 309     return bRet;
 310 }
 311
 312 bool SvxXMLXTableExportComponent::exportTable() noexcept
 313 {
 314     bool bRet = false;
 315
 316     try
 317     {
 318         GetDocHandler()->startDocument();
 319
 320         addChaffWhenEncryptedStorage();
 321
 322         // export namespaces
 323         sal_uInt16 nPos = GetNamespaceMap().GetFirstKey();
 324         while( USHRT_MAX != nPos )
 325         {
 326             GetAttrList().AddAttribute( GetNamespaceMap().GetAttrNameByKey( nPos ), GetNamespaceMap().GetNameByKey( nPos ) );
 327             nPos = GetNamespaceMap().GetNextKey( nPos );
 328         }
 329
 330         do
 331         {
 332             if( !mxTable.is() )
 333                 break;
 334
 335             char const* pEleName;
 336             Type aExportType = mxTable->getElementType();
 337             std::unique_ptr<SvxXMLTableEntryExporter> pExporter;
 338
 339             if( aExportType == cppu::UnoType<sal_Int32>::get() )
 340             {
 341                 pExporter.reset(new SvxXMLColorEntryExporter(*this));
 342                 pEleName = "color-table";
 343             }
 344             else if( aExportType == cppu::UnoType< drawing::PolyPolygonBezierCoords >::get() )
 345             {
 346                 pExporter.reset(new SvxXMLLineEndEntryExporter(*this));
 347                 pEleName = "marker-table";
 348             }
 349             else if( aExportType == cppu::UnoType< drawing::LineDash >::get() )
 350             {
 351                 pExporter.reset(new SvxXMLDashEntryExporter(*this));
 352                 pEleName = "dash-table";
 353             }
 354             else if( aExportType == cppu::UnoType< drawing::Hatch >::get() )
 355             {
 356                 pExporter.reset(new SvxXMLHatchEntryExporter(*this));
 357                 pEleName = "hatch-table";
 358             }
 359             else if( aExportType == cppu::UnoType< awt::Gradient >::get() )
 360             {
 361                 pExporter.reset(new SvxXMLGradientEntryExporter(*this));
 362                 pEleName = "gradient-table";
 363             }
 364             else if( aExportType == cppu::UnoType<awt::XBitmap>::get())
 365             {
 366                 pExporter.reset(new SvxXMLBitmapEntryExporter(*this));
 367                 pEleName = "bitmap-table";
 368             }
 369             else
 370             {
 371                 OSL_FAIL( "unknown type for export");
 372                 break;
 373             }
 374
 375             SvXMLElementExport aElem( *this, XML_NAMESPACE_OOO, pEleName, true, true );
 376
 377             const Sequence< OUString > aNames = mxTable->getElementNames();
 378             Any aAny;
 379
 380             for( const OUString& rName : aNames )
 381             {
 382                 aAny = mxTable->getByName( rName );
 383                 pExporter->exportEntry( rName, aAny );
 384             }
 385
 386             bRet = true;
 387         }
 388         while(false);
 389
 390         GetDocHandler()->endDocument();
 391     }
 392     catch( Exception const& )
 393     {
 394         bRet = false;
 395     }
 396
 397     return bRet;
 398 }
 399
 400 // methods without content:
 401 void SvxXMLXTableExportComponent::ExportAutoStyles_() {}
 402 void SvxXMLXTableExportComponent::ExportMasterStyles_() {}
 403 void SvxXMLXTableExportComponent::ExportContent_() {}
 404
 405
 406 SvxXMLTableEntryExporter::~SvxXMLTableEntryExporter()
 407 {
 408 }
 409
 410
 411 SvxXMLColorEntryExporter::SvxXMLColorEntryExporter( SvXMLExport& rExport )
 412 : SvxXMLTableEntryExporter( rExport )
 413 {
 414 }
 415
 416 void SvxXMLColorEntryExporter::exportEntry( const OUString& rStrName, const Any& rValue )
 417 {
 418     mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, rStrName );
 419
 420     sal_Int32 nColor = 0;
 421     rValue >>= nColor;
 422
 423     OUStringBuffer aOut;
 424     ::sax::Converter::convertColor( aOut, nColor );
 425     mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_COLOR, aOut.makeStringAndClear() );
 426
 427     SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_COLOR, true, true );
 428 }
 429
 430
 431 SvxXMLLineEndEntryExporter::SvxXMLLineEndEntryExporter( SvXMLExport& rExport )
 432 : SvxXMLTableEntryExporter( rExport ), maMarkerStyle( rExport )
 433 {
 434 }
 435
 436 void SvxXMLLineEndEntryExporter::exportEntry( const OUString& rStrName, const Any& rValue )
 437 {
 438     maMarkerStyle.exportXML( rStrName, rValue );
 439 }
 440
 441
 442 SvxXMLDashEntryExporter::SvxXMLDashEntryExporter( SvXMLExport& rExport )
 443 : SvxXMLTableEntryExporter( rExport ), maDashStyle( rExport )
 444 {
 445 }
 446
 447 void SvxXMLDashEntryExporter::exportEntry( const OUString& rStrName, const Any& rValue )
 448 {
 449     maDashStyle.exportXML( rStrName, rValue );
 450 }
 451
 452
 453 SvxXMLHatchEntryExporter::SvxXMLHatchEntryExporter( SvXMLExport& rExport )
 454 : SvxXMLTableEntryExporter( rExport ), maHatchStyle( rExport )
 455 {
 456 }
 457
 458 void SvxXMLHatchEntryExporter::exportEntry( const OUString& rStrName, const Any& rValue )
 459 {
 460     maHatchStyle.exportXML( rStrName, rValue );
 461 }
 462
 463
 464 SvxXMLGradientEntryExporter::SvxXMLGradientEntryExporter( SvXMLExport& rExport )
 465 : SvxXMLTableEntryExporter( rExport ), maGradientStyle( rExport )
 466 {
 467 }
 468
 469 void SvxXMLGradientEntryExporter::exportEntry( const OUString& rStrName, const Any& rValue )
 470 {
 471     maGradientStyle.exportXML( rStrName, rValue );
 472 }
 473
 474
 475 SvxXMLBitmapEntryExporter::SvxXMLBitmapEntryExporter( SvXMLExport& rExport )
 476 : SvxXMLTableEntryExporter( rExport )
 477 {
 478 }
 479
 480 void SvxXMLBitmapEntryExporter::exportEntry( const OUString& rStrName, const Any& rValue )
 481 {
 482     XMLImageStyle::exportXML(rStrName, rValue, mrExport);
 483 }
 484
 485 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */