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