LibreOffice Module svx (master)  1
xmlxtexp.cxx
Go to the documentation of this file.
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>
50 #include <unotools/streamwrap.hxx>
51 #include <svx/xmlgrhlp.hxx>
52 
53 #include <xmlxtexp.hxx>
54 
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 
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 
157  SetGraphicStorageHandler(xGraphicStorageHandler);
158 }
159 
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 
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 
313 {
314  bool bRet = false;
315 
316  try
317  {
318  GetDocHandler()->startDocument();
319 
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  }
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:
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: */
Type
virtual void ExportMasterStyles_() override
Definition: xmlxtexp.cxx:402
FieldUnit
constexpr sal_uInt16 XML_NAMESPACE_OFFICE
static void createStorageStream(uno::Reference< io::XOutputStream > *xOut, rtl::Reference< SvXMLGraphicHelper > &rxGraphicHelper, const uno::Reference< embed::XStorage > &xSubStorage)
Definition: xmlxtexp.cxx:185
static void initializeStreamMetadata(const uno::Reference< uno::XInterface > &xOut)
Definition: xmlxtexp.cxx:164
static bool save(const OUString &rURL, const css::uno::Reference< css::container::XNameContainer > &xTable, const css::uno::Reference< css::embed::XStorage > &xStorage, OUString *pOptName)
Definition: xmlxtexp.cxx:197
void addChaffWhenEncryptedStorage()
SvXMLExportFlags
sal_uInt16 GetFirstKey() const
constexpr sal_uInt16 XML_NAMESPACE_XLINK
constexpr sal_uInt16 XML_NAMESPACE_OOO
XML_N_OOO
const css::uno::Reference< css::xml::sax::XDocumentHandler > & GetDocHandler() const
NONE
SvXMLAttributeList & GetAttrList()
Reference< XInputStream > xStream
XML_NP_XLINK
XML_NP_OFFICE
constexpr sal_uInt16 XML_NAMESPACE_DRAW
XML_N_OFFICE
constexpr sal_uInt16 XML_NAMESPACE_SVG
#define TOOLS_WARN_EXCEPTION(area, stream)
XML_N_DRAW
XML_NP_DRAW
SvxXMLXTableExportComponent(const css::uno::Reference< css::uno::XComponentContext > &xContext, const css::uno::Reference< css::xml::sax::XDocumentHandler > &xHandler, const css::uno::Reference< css::container::XNameContainer > &xTable, css::uno::Reference< css::document::XGraphicStorageHandler > const &xGraphicStorageHandler)
Definition: xmlxtexp.cxx:143
static css::uno::Reference< css::embed::XStorage > GetStorageFromURL(const OUString &aURL, sal_Int32 nStorageMode, const css::uno::Reference< css::uno::XComponentContext > &rxContext=css::uno::Reference< css::uno::XComponentContext >())
virtual ~SvxXMLXTableExportComponent() override
Definition: xmlxtexp.cxx:160
css::uno::Type const & get()
XML_N_SVG
sal_uInt16 GetNextKey(sal_uInt16 nOldKey) const
const SvXMLNamespaceMap & GetNamespaceMap() const
void SetGraphicStorageHandler(css::uno::Reference< css::document::XGraphicStorageHandler > const &rxGraphicStorageHandler)
virtual void ExportContent_() override
Definition: xmlxtexp.cxx:403
SvXMLNamespaceMap & GetNamespaceMap_()
const OUString & GetXMLToken(enum XMLTokenEnum eToken)
static bool convertColor(sal_Int32 &rColor, const OUString &rValue)
XML_NP_SVG
const o3tl::enumarray< SvxAdjust, unsigned short > aSvxToUnoAdjust USHRT_MAX
XML_N_XLINK
INetProtocol GetProtocol() const
sal_uInt16 Add(const OUString &rPrefix, const OUString &rName, sal_uInt16 nKey=XML_NAMESPACE_UNKNOWN)
Reference< XComponentContext > getProcessComponentContext()
void AddAttribute(const OUString &sName, const OUString &sValue)
static rtl::Reference< SvXMLGraphicHelper > Create(const css::uno::Reference< css::embed::XStorage > &rXMLStorage, SvXMLGraphicHelperMode eCreateMode)
XML_NP_OOO
const css::uno::Reference< css::container::XNameContainer > & mxTable
Definition: xmlxtexp.hxx:58
sal_uInt16 nPos
virtual void ExportAutoStyles_() override
Definition: xmlxtexp.cxx:401