Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : #include <editeng/eeitem.hxx>
30 : :
31 : : #include "xmlexprt.hxx"
32 : : #include "XMLConverter.hxx"
33 : : #include "xmlstyle.hxx"
34 : : #include "unonames.hxx"
35 : : #include "document.hxx"
36 : : #include "olinetab.hxx"
37 : : #include "cellsuno.hxx"
38 : : #include "cell.hxx"
39 : : #include "rangenam.hxx"
40 : : #include "XMLTableMasterPageExport.hxx"
41 : : #include "drwlayer.hxx"
42 : : #include "XMLExportDataPilot.hxx"
43 : : #include "XMLExportDatabaseRanges.hxx"
44 : : #include "XMLExportDDELinks.hxx"
45 : : #include "XMLExportIterator.hxx"
46 : : #include "XMLColumnRowGroupExport.hxx"
47 : : #include "XMLStylesExportHelper.hxx"
48 : : #include "XMLChangeTrackingExportHelper.hxx"
49 : : #include "sheetdata.hxx"
50 : : #include "docoptio.hxx"
51 : : #include "XMLExportSharedData.hxx"
52 : : #include "chgviset.hxx"
53 : : #include "docuno.hxx"
54 : : #include "textuno.hxx"
55 : : #include "chartlis.hxx"
56 : : #include "scitems.hxx"
57 : : #include "docpool.hxx"
58 : : #include "userdat.hxx"
59 : : #include "dociter.hxx"
60 : : #include "chgtrack.hxx"
61 : : #include "rangeutl.hxx"
62 : : #include "convuno.hxx"
63 : : #include "postit.hxx"
64 : : #include "externalrefmgr.hxx"
65 : : #include "editutil.hxx"
66 : : #include "tabprotection.hxx"
67 : : #include "cachedattraccess.hxx"
68 : : #include "colorscale.hxx"
69 : : #include "conditio.hxx"
70 : :
71 : : #include <xmloff/xmltoken.hxx>
72 : : #include <xmloff/xmlnmspe.hxx>
73 : : #include <xmloff/xmluconv.hxx>
74 : : #include <xmloff/nmspmap.hxx>
75 : : #include <xmloff/families.hxx>
76 : : #include <xmloff/numehelp.hxx>
77 : : #include <xmloff/txtparae.hxx>
78 : : #include <xmloff/xmlcnitm.hxx>
79 : : #include <xmloff/xmlerror.hxx>
80 : : #include <xmloff/XMLEventExport.hxx>
81 : :
82 : : #include <sax/tools/converter.hxx>
83 : :
84 : : #include <rtl/ustring.hxx>
85 : :
86 : : #include "tools/color.hxx"
87 : : #include <rtl/math.hxx>
88 : : #include <svl/zforlist.hxx>
89 : : #include <svx/unoshape.hxx>
90 : : #include <comphelper/extract.hxx>
91 : : #include <toolkit/helper/convert.hxx>
92 : : #include <svx/svdobj.hxx>
93 : : #include <svx/svdocapt.hxx>
94 : : #include <editeng/outlobj.hxx>
95 : : #include <svx/svditer.hxx>
96 : : #include <svx/svdpage.hxx>
97 : :
98 : : #include <comphelper/processfactory.hxx>
99 : : #include <com/sun/star/sheet/XUsedAreaCursor.hpp>
100 : : #include <com/sun/star/sheet/XCellRangeAddressable.hpp>
101 : : #include <com/sun/star/sheet/XAreaLinks.hpp>
102 : : #include <com/sun/star/sheet/XAreaLink.hpp>
103 : : #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
104 : : #include <com/sun/star/table/XColumnRowRange.hpp>
105 : : #include <com/sun/star/sheet/XPrintAreas.hpp>
106 : : #include <com/sun/star/container/XNamed.hpp>
107 : : #include <com/sun/star/util/XProtectable.hpp>
108 : : #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
109 : : #include <com/sun/star/sheet/XUniqueCellFormatRangesSupplier.hpp>
110 : : #include <com/sun/star/sheet/XCellRangesQuery.hpp>
111 : : #include <com/sun/star/sheet/CellFlags.hpp>
112 : : #include <com/sun/star/util/XMergeable.hpp>
113 : : #include <com/sun/star/sheet/XArrayFormulaRange.hpp>
114 : : #include <com/sun/star/text/XText.hpp>
115 : : #include <com/sun/star/sheet/XLabelRanges.hpp>
116 : : #include <com/sun/star/sheet/XLabelRange.hpp>
117 : : #include <com/sun/star/sheet/XNamedRanges.hpp>
118 : : #include <com/sun/star/sheet/XNamedRange.hpp>
119 : : #include <com/sun/star/sheet/XCellRangeReferrer.hpp>
120 : : #include <com/sun/star/sheet/NamedRangeFlag.hpp>
121 : : #include <com/sun/star/sheet/XSheetLinkable.hpp>
122 : : #include <com/sun/star/form/XFormsSupplier2.hpp>
123 : : #include <com/sun/star/io/XActiveDataSource.hpp>
124 : : #include <com/sun/star/io/XSeekable.hpp>
125 : : #include <com/sun/star/beans/XPropertySet.hpp>
126 : :
127 : : #include <com/sun/star/chart2/XChartDocument.hpp>
128 : : #include <com/sun/star/chart2/data/XRangeXMLConversion.hpp>
129 : : #include <com/sun/star/chart2/data/XDataReceiver.hpp>
130 : :
131 : : #include <com/sun/star/document/XDocumentProperties.hpp>
132 : : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
133 : :
134 : : #include "XMLCodeNameProvider.hxx"
135 : :
136 : : #include <sfx2/objsh.hxx>
137 : :
138 : : #include <vector>
139 : : #include <vbahelper/vbaaccesshelper.hxx>
140 : :
141 : : //! not found in unonames.hxx
142 : : #define SC_LAYERID "LayerID"
143 : :
144 : : #define SC_VIEWCHANGES_COUNT 13
145 : : #define SC_SHOW_CHANGES 0
146 : : #define SC_SHOW_ACCEPTED_CHANGES 1
147 : : #define SC_SHOW_REJECTED_CHANGES 2
148 : : #define SC_SHOW_CHANGES_BY_DATETIME 3
149 : : #define SC_SHOW_CHANGES_BY_DATETIME_MODE 4
150 : : #define SC_SHOW_CHANGES_BY_DATETIME_FIRST_DATETIME 5
151 : : #define SC_SHOW_CHANGES_BY_DATETIME_SECOND_DATETIME 6
152 : : #define SC_SHOW_CHANGES_BY_AUTHOR 7
153 : : #define SC_SHOW_CHANGES_BY_AUTHOR_NAME 8
154 : : #define SC_SHOW_CHANGES_BY_COMMENT 9
155 : : #define SC_SHOW_CHANGES_BY_COMMENT_TEXT 10
156 : : #define SC_SHOW_CHANGES_BY_RANGES 11
157 : : #define SC_SHOW_CHANGES_BY_RANGES_LIST 12
158 : :
159 : : using namespace formula;
160 : : using namespace com::sun::star;
161 : : using namespace xmloff::token;
162 : : using ::std::vector;
163 : : using ::rtl::OUString;
164 : : using ::rtl::OUStringBuffer;
165 : : using ::com::sun::star::uno::Reference;
166 : : using ::com::sun::star::uno::UNO_QUERY;
167 : :
168 : : //----------------------------------------------------------------------------
169 : :
170 : : namespace
171 : : {
172 : 0 : OUString lcl_RangeSequenceToString(
173 : : const uno::Sequence< OUString > & rRanges,
174 : : const uno::Reference< chart2::data::XRangeXMLConversion > & xFormatConverter )
175 : : {
176 : 0 : OUStringBuffer aResult;
177 : 0 : const sal_Int32 nMaxIndex( rRanges.getLength() - 1 );
178 : 0 : const sal_Unicode cSep( sal_Char(' '));
179 [ # # ]: 0 : for( sal_Int32 i=0; i<=nMaxIndex; ++i )
180 : : {
181 : 0 : OUString aRange( rRanges[i] );
182 [ # # ]: 0 : if( xFormatConverter.is())
183 [ # # ][ # # ]: 0 : aRange = xFormatConverter->convertRangeToXML( aRange );
184 [ # # ]: 0 : aResult.append( aRange );
185 [ # # ]: 0 : if( i < nMaxIndex )
186 [ # # ]: 0 : aResult.append( cSep );
187 : 0 : }
188 [ # # ]: 0 : return aResult.makeStringAndClear();
189 : : }
190 : :
191 : 0 : OUString lcl_GetRawString( ScDocument* pDoc, const ScAddress& rPos )
192 : : {
193 : : // return text/edit cell string content, with line feeds in edit cells
194 : :
195 [ # # ]: 0 : String aVal; // document uses tools-strings
196 [ # # ]: 0 : if (pDoc)
197 : : {
198 [ # # ]: 0 : ScBaseCell* pCell = pDoc->GetCell( rPos );
199 [ # # ]: 0 : if (pCell)
200 : : {
201 : 0 : CellType eType = pCell->GetCellType();
202 [ # # ]: 0 : if ( eType == CELLTYPE_STRING )
203 [ # # ]: 0 : aVal = static_cast<ScStringCell*>(pCell)->GetString(); // string cell: content
204 [ # # ]: 0 : else if ( eType == CELLTYPE_EDIT )
205 : : {
206 : : // edit cell: text with line breaks
207 : 0 : const EditTextObject* pData = static_cast<ScEditCell*>(pCell)->GetData();
208 [ # # ]: 0 : if (pData)
209 : : {
210 [ # # ]: 0 : EditEngine& rEngine = pDoc->GetEditEngine();
211 [ # # ]: 0 : rEngine.SetText( *pData );
212 [ # # ][ # # ]: 0 : aVal = rEngine.GetText( LINEEND_LF );
[ # # ]
213 : : }
214 : : }
215 : : }
216 : : }
217 [ # # ][ # # ]: 0 : return aVal;
218 : : }
219 : : } // anonymous namespace
220 : :
221 : : //----------------------------------------------------------------------------
222 : :
223 : 183 : OUString SAL_CALL ScXMLOOoExport_getImplementationName() throw()
224 : : {
225 : 183 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLExporter" ) );
226 : : }
227 : :
228 : 1 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_getSupportedServiceNames() throw()
229 : : {
230 : 1 : const rtl::OUString aServiceName( ScXMLOOoExport_getImplementationName() );
231 [ + - ]: 1 : return uno::Sequence< rtl::OUString >( &aServiceName, 1 );
232 : : }
233 : :
234 : 2 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_createInstance(
235 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
236 : : {
237 [ + - ][ + - ]: 2 : return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_ALL );
238 : : }
239 : :
240 : 185 : OUString SAL_CALL ScXMLOOoExport_Meta_getImplementationName() throw()
241 : : {
242 : 185 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLMetaExporter" ) );
243 : : }
244 : :
245 : 2 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_Meta_getSupportedServiceNames() throw()
246 : : {
247 : 2 : const rtl::OUString aServiceName( ScXMLOOoExport_Meta_getImplementationName() );
248 [ + - ]: 2 : return uno::Sequence< rtl::OUString > ( &aServiceName, 1 );
249 : : }
250 : :
251 : 2 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_Meta_createInstance(
252 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
253 : : {
254 [ + - ][ + - ]: 2 : return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_META );
255 : : }
256 : :
257 : 187 : OUString SAL_CALL ScXMLOOoExport_Styles_getImplementationName() throw()
258 : : {
259 : 187 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLStylesExporter" ) );
260 : : }
261 : :
262 : 3 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_Styles_getSupportedServiceNames() throw()
263 : : {
264 : 3 : const rtl::OUString aServiceName( ScXMLOOoExport_Styles_getImplementationName() );
265 [ + - ]: 3 : return uno::Sequence< rtl::OUString > ( &aServiceName, 1 );
266 : : }
267 : :
268 : 4 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_Styles_createInstance(
269 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
270 : : {
271 [ + - ][ + - ]: 4 : return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS);
272 : : }
273 : :
274 : 185 : OUString SAL_CALL ScXMLOOoExport_Content_getImplementationName() throw()
275 : : {
276 : 185 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLContentExporter" ) );
277 : : }
278 : :
279 : 2 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_Content_getSupportedServiceNames() throw()
280 : : {
281 : 2 : const rtl::OUString aServiceName( ScXMLOOoExport_Content_getImplementationName() );
282 [ + - ]: 2 : return uno::Sequence< rtl::OUString > ( &aServiceName, 1 );
283 : : }
284 : :
285 : 2 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_Content_createInstance(
286 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
287 : : {
288 [ + - ][ + - ]: 2 : return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS);
289 : : }
290 : :
291 : 187 : OUString SAL_CALL ScXMLOOoExport_Settings_getImplementationName() throw()
292 : : {
293 : 187 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLSettingsExporter" ) );
294 : : }
295 : :
296 : 3 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_Settings_getSupportedServiceNames() throw()
297 : : {
298 : 3 : const rtl::OUString aServiceName( ScXMLOOoExport_Settings_getImplementationName() );
299 [ + - ]: 3 : return uno::Sequence< rtl::OUString > ( &aServiceName, 1 );
300 : : }
301 : :
302 : 4 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_Settings_createInstance(
303 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
304 : : {
305 [ + - ][ + - ]: 4 : return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_SETTINGS );
306 : : }
307 : :
308 : : // Oasis Filter
309 : :
310 : 181 : OUString SAL_CALL ScXMLOasisExport_getImplementationName() throw()
311 : : {
312 : 181 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisExporter" ) );
313 : : }
314 : :
315 : 0 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_getSupportedServiceNames() throw()
316 : : {
317 : 0 : const rtl::OUString aServiceName( ScXMLOasisExport_getImplementationName() );
318 [ # # ]: 0 : const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
319 : 0 : return aSeq;
320 : : }
321 : :
322 : 0 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_createInstance(
323 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
324 : : {
325 [ # # ][ # # ]: 0 : return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_ALL|EXPORT_OASIS);
326 : : }
327 : :
328 : 185 : OUString SAL_CALL ScXMLOasisExport_Meta_getImplementationName() throw()
329 : : {
330 : 185 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisMetaExporter" ) );
331 : : }
332 : :
333 : 2 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_Meta_getSupportedServiceNames() throw()
334 : : {
335 : 2 : const rtl::OUString aServiceName( ScXMLOasisExport_Meta_getImplementationName() );
336 [ + - ]: 2 : const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
337 : 2 : return aSeq;
338 : : }
339 : :
340 : 2 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_Meta_createInstance(
341 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
342 : : {
343 [ + - ][ + - ]: 2 : return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_META|EXPORT_OASIS);
344 : : }
345 : :
346 : 185 : OUString SAL_CALL ScXMLOasisExport_Styles_getImplementationName() throw()
347 : : {
348 : 185 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisStylesExporter" ) );
349 : : }
350 : :
351 : 2 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_Styles_getSupportedServiceNames() throw()
352 : : {
353 : 2 : const rtl::OUString aServiceName( ScXMLOasisExport_Styles_getImplementationName() );
354 [ + - ]: 2 : const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
355 : 2 : return aSeq;
356 : : }
357 : :
358 : 2 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_Styles_createInstance(
359 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
360 : : {
361 [ + - ][ + - ]: 2 : return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS|EXPORT_OASIS);
362 : : }
363 : :
364 : 185 : OUString SAL_CALL ScXMLOasisExport_Content_getImplementationName() throw()
365 : : {
366 : 185 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisContentExporter" ) );
367 : : }
368 : :
369 : 2 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_Content_getSupportedServiceNames() throw()
370 : : {
371 : 2 : const rtl::OUString aServiceName( ScXMLOasisExport_Content_getImplementationName() );
372 [ + - ]: 2 : const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
373 : 2 : return aSeq;
374 : : }
375 : :
376 : 2 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_Content_createInstance(
377 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
378 : : {
379 [ + - ][ + - ]: 2 : return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS|EXPORT_OASIS);
380 : : }
381 : :
382 : 185 : OUString SAL_CALL ScXMLOasisExport_Settings_getImplementationName() throw()
383 : : {
384 : 185 : return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisSettingsExporter" ) );
385 : : }
386 : :
387 : 2 : uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_Settings_getSupportedServiceNames() throw()
388 : : {
389 : 2 : const rtl::OUString aServiceName( ScXMLOasisExport_Settings_getImplementationName() );
390 [ + - ]: 2 : const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
391 : 2 : return aSeq;
392 : : }
393 : :
394 : 2 : uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_Settings_createInstance(
395 : : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
396 : : {
397 [ + - ][ + - ]: 2 : return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_SETTINGS|EXPORT_OASIS);
398 : : }
399 : : //----------------------------------------------------------------------------
400 : :
401 : : class ScXMLShapeExport : public XMLShapeExport
402 : : {
403 : : public:
404 : 8 : ScXMLShapeExport(SvXMLExport& rExp) : XMLShapeExport(rExp) {}
405 : : ~ScXMLShapeExport();
406 : :
407 : : /** is called before a shape element for the given XShape is exported */
408 : : virtual void onExport( const uno::Reference < drawing::XShape >& xShape );
409 : : };
410 : :
411 : 8 : ScXMLShapeExport::~ScXMLShapeExport()
412 : : {
413 [ - + ]: 16 : }
414 : :
415 : 0 : void ScXMLShapeExport::onExport( const uno::Reference < drawing::XShape >& xShape )
416 : : {
417 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xShapeProp( xShape, uno::UNO_QUERY );
418 [ # # ]: 0 : if( xShapeProp.is() )
419 : : {
420 : 0 : sal_Int16 nLayerID = 0;
421 [ # # ][ # # ]: 0 : if( (xShapeProp->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( SC_LAYERID ))) >>= nLayerID) && (nLayerID == SC_LAYER_BACK) )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # #
# # # # ]
422 [ # # ]: 0 : GetExport().AddAttribute(XML_NAMESPACE_TABLE, XML_TABLE_BACKGROUND, XML_TRUE);
423 : 0 : }
424 : 0 : }
425 : :
426 : : //----------------------------------------------------------------------------
427 : :
428 : 22 : sal_Int16 ScXMLExport::GetFieldUnit()
429 : : {
430 : : com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> xProperties(
431 [ + - ][ + - ]: 44 : comphelper::getProcessServiceFactory()->createInstance(
432 : 22 : rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sheet.GlobalSheetSettings" )) ),
433 [ + - ][ + - ]: 22 : com::sun::star::uno::UNO_QUERY);
[ + - ]
434 [ + - ]: 22 : if (xProperties.is())
435 : : {
436 : 22 : sal_Int16 nFieldUnit = 0;
437 [ + - ][ + - ]: 22 : if (xProperties->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Metric"))) >>= nFieldUnit)
[ + - ][ + - ]
438 : 22 : return nFieldUnit;
439 : : }
440 : 22 : return 0;
441 : : }
442 : :
443 : :
444 : : // #110680#
445 : 22 : ScXMLExport::ScXMLExport(
446 : : const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceFactory,
447 : : const sal_uInt16 nExportFlag)
448 : 22 : : SvXMLExport( SvXMLUnitConverter::GetMeasureUnit(GetFieldUnit()),
449 : : xServiceFactory, XML_SPREADSHEET, nExportFlag ),
450 : : pDoc(NULL),
451 : : nSourceStreamPos(0),
452 : : pNumberFormatAttributesExportHelper(NULL),
453 : : pSharedData(NULL),
454 : : pColumnStyles(NULL),
455 : : pRowStyles(NULL),
456 : : pCellStyles(NULL),
457 : : pRowFormatRanges(NULL),
458 : : aTableStyles(),
459 : : pGroupColumns (NULL),
460 : : pGroupRows (NULL),
461 : : pDefaults(NULL),
462 : : pChartListener(NULL),
463 : : pCurrentCell(NULL),
464 : : pMergedRangesContainer(NULL),
465 : : pValidationsContainer(NULL),
466 : : pCellsItr(NULL),
467 : : pChangeTrackingExportHelper(NULL),
468 : : sLayerID(RTL_CONSTASCII_USTRINGPARAM( SC_LAYERID )),
469 : : sCaptionShape(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.CaptionShape")),
470 : : nOpenRow(-1),
471 : : nProgressCount(0),
472 : : nCurrentTable(0),
473 : : bHasRowHeader(false),
474 : : bRowHeaderOpen(false),
475 [ + - ][ + - ]: 22 : mbShowProgress( false )
[ + - ][ + - ]
476 : : {
477 [ + + ]: 22 : if (getExportFlags() & EXPORT_CONTENT)
478 : : {
479 [ + - ][ + - ]: 6 : pGroupColumns = new ScMyOpenCloseColumnRowGroup(*this, XML_TABLE_COLUMN_GROUP);
480 [ + - ][ + - ]: 6 : pGroupRows = new ScMyOpenCloseColumnRowGroup(*this, XML_TABLE_ROW_GROUP);
481 [ + - ][ + - ]: 6 : pColumnStyles = new ScColumnStyles();
482 [ + - ][ + - ]: 6 : pRowStyles = new ScRowStyles();
483 [ + - ][ + - ]: 6 : pRowFormatRanges = new ScRowFormatRanges();
484 [ + - ][ + - ]: 6 : pMergedRangesContainer = new ScMyMergedRangesContainer();
485 [ + - ][ + - ]: 6 : pValidationsContainer = new ScMyValidationsContainer();
486 [ + - ][ + - ]: 6 : pCellsItr = new ScMyNotEmptyCellsIterator(*this);
487 [ + - ]: 6 : pDefaults = new ScMyDefaultStyles();
488 : : }
489 [ + - ][ + - ]: 22 : pCellStyles = new ScFormatRangeStyles();
490 : :
491 : : // document is not set here - create ScChangeTrackingExportHelper later
492 : :
493 [ + - ][ + - ]: 22 : xScPropHdlFactory = new XMLScPropHdlFactory;
[ + - ]
494 [ + - ][ + - ]: 22 : xCellStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScCellStylesProperties, xScPropHdlFactory);
[ + - ]
495 [ + - ][ + - ]: 22 : xColumnStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScColumnStylesProperties, xScPropHdlFactory);
[ + - ]
496 [ + - ][ + - ]: 22 : xRowStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScRowStylesProperties, xScPropHdlFactory);
[ + - ]
497 [ + - ][ + - ]: 22 : xTableStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScTableStylesProperties, xScPropHdlFactory);
[ + - ]
498 [ + - ][ + - ]: 22 : xCellStylesExportPropertySetMapper = new ScXMLCellExportPropertyMapper(xCellStylesPropertySetMapper);
[ + - ]
499 [ + - ][ + - ]: 22 : xCellStylesExportPropertySetMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaExtPropMapper(*this));
[ + - ][ + - ]
[ + - ]
500 [ + - ][ + - ]: 22 : xColumnStylesExportPropertySetMapper = new ScXMLColumnExportPropertyMapper(xColumnStylesPropertySetMapper);
[ + - ]
501 [ + - ][ + - ]: 22 : xRowStylesExportPropertySetMapper = new ScXMLRowExportPropertyMapper(xRowStylesPropertySetMapper);
[ + - ]
502 [ + - ][ + - ]: 22 : xTableStylesExportPropertySetMapper = new ScXMLTableExportPropertyMapper(xTableStylesPropertySetMapper);
[ + - ]
503 : :
504 : : GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_CELL, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)),
505 [ + - ][ + - ]: 22 : xCellStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_PREFIX)));
[ + - ][ + - ]
[ + - ][ + - ]
506 : : GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_COLUMN, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_NAME)),
507 [ + - ][ + - ]: 22 : xColumnStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_PREFIX)));
[ + - ][ + - ]
[ + - ][ + - ]
508 : : GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_ROW, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_NAME)),
509 [ + - ][ + - ]: 22 : xRowStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_PREFIX)));
[ + - ][ + - ]
[ + - ][ + - ]
510 : : GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_TABLE, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_TABLE_STYLES_NAME)),
511 [ + - ][ + - ]: 22 : xTableStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_TABLE_STYLES_PREFIX)));
[ + - ][ + - ]
[ + - ][ + - ]
512 : :
513 [ + + ]: 22 : if( (getExportFlags() & (EXPORT_STYLES|EXPORT_AUTOSTYLES|EXPORT_MASTERSTYLES|EXPORT_CONTENT) ) != 0 )
514 : : {
515 : : // This name is reserved for the external ref cache tables. This
516 : : // should not conflict with user-defined styles since this name is
517 : : // used for a table style which is not available in the UI.
518 [ + - ]: 12 : sExternalRefTabStyleName = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ta_extref"));
519 [ + - ][ + - ]: 12 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_TABLE, sExternalRefTabStyleName);
[ + - ][ + - ]
520 : :
521 [ + - ][ + - ]: 12 : sAttrName = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_NAME));
522 [ + - ][ + - ]: 12 : sAttrStyleName = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_STYLE_NAME));
523 [ + - ][ + - ]: 12 : sAttrColumnsRepeated = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_NUMBER_COLUMNS_REPEATED));
524 [ + - ][ + - ]: 12 : sAttrFormula = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_FORMULA));
525 [ + - ][ + - ]: 12 : sAttrStringValue = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_STRING_VALUE));
526 [ + - ][ + - ]: 12 : sAttrValueType = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE_TYPE));
527 [ + - ][ + - ]: 12 : sElemCell = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE_CELL));
528 [ + - ][ + - ]: 12 : sElemCoveredCell = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_COVERED_TABLE_CELL));
529 [ + - ][ + - ]: 12 : sElemCol = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE_COLUMN));
530 [ + - ][ + - ]: 12 : sElemRow = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE_ROW));
531 [ + - ][ + - ]: 12 : sElemTab = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE));
532 [ + - ][ + - ]: 12 : sElemP = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TEXT, GetXMLToken(XML_P));
533 : : }
534 : 22 : }
535 : :
536 : :
537 [ + - ][ + - ]: 22 : ScXMLExport::~ScXMLExport()
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
538 : : {
539 [ + + ][ + - ]: 22 : delete pGroupColumns;
540 [ + + ][ + - ]: 22 : delete pGroupRows;
541 [ + + ][ + - ]: 22 : delete pColumnStyles;
542 [ + + ][ + - ]: 22 : delete pRowStyles;
543 [ + - ][ + - ]: 22 : delete pCellStyles;
544 [ + + ][ + - ]: 22 : delete pRowFormatRanges;
545 [ + + ][ + - ]: 22 : delete pMergedRangesContainer;
546 [ + + ][ + - ]: 22 : delete pValidationsContainer;
547 [ + - ][ + - ]: 22 : delete pChangeTrackingExportHelper;
548 [ - + ][ # # ]: 22 : delete pChartListener;
549 [ + + ][ + - ]: 22 : delete pCellsItr;
550 [ + + ][ + - ]: 22 : delete pDefaults;
551 [ - + ][ # # ]: 22 : delete pNumberFormatAttributesExportHelper;
552 [ - + ]: 44 : }
553 : :
554 : 0 : void ScXMLExport::SetSourceStream( const uno::Reference<io::XInputStream>& xNewStream )
555 : : {
556 : 0 : xSourceStream = xNewStream;
557 : :
558 [ # # ]: 0 : if ( xSourceStream.is() )
559 : : {
560 : : // make sure it's a plain UTF-8 stream as written by OOo itself
561 : :
562 : 0 : const sal_Char pXmlHeader[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
563 : 0 : sal_Int32 nLen = strlen(pXmlHeader);
564 : :
565 [ # # ]: 0 : uno::Sequence<sal_Int8> aFileStart(nLen);
566 [ # # ][ # # ]: 0 : sal_Int32 nRead = xSourceStream->readBytes( aFileStart, nLen );
567 : :
568 [ # # ][ # # ]: 0 : if ( nRead != nLen || memcmp( aFileStart.getConstArray(), pXmlHeader, nLen ) != 0 )
[ # # ]
569 : : {
570 : : // invalid - ignore stream, save normally
571 : 0 : xSourceStream.clear();
572 : : }
573 : : else
574 : : {
575 : : // keep track of the bytes already read
576 : 0 : nSourceStreamPos = nRead;
577 : :
578 [ # # ][ # # ]: 0 : const ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetModel())->GetSheetSaveData();
579 [ # # ]: 0 : if (pSheetData)
580 : : {
581 : : // add the loaded namespaces to the name space map
582 : :
583 [ # # ][ # # ]: 0 : if ( !pSheetData->AddLoadedNamespaces( _GetNamespaceMap() ) )
584 : : {
585 : : // conflicts in the namespaces - ignore the stream, save normally
586 : 0 : xSourceStream.clear();
587 : : }
588 : : }
589 [ # # ]: 0 : }
590 : : }
591 : 0 : }
592 : :
593 : 0 : sal_Int32 ScXMLExport::GetNumberFormatStyleIndex(sal_Int32 nNumFmt) const
594 : : {
595 [ # # ]: 0 : NumberFormatIndexMap::const_iterator itr = aNumFmtIndexMap.find(nNumFmt);
596 [ # # ][ # # ]: 0 : if (itr == aNumFmtIndexMap.end())
597 : 0 : return -1;
598 : :
599 [ # # ]: 0 : return itr->second;
600 : : }
601 : :
602 : : namespace {
603 : :
604 : : /**
605 : : * Update the progress bar state when an instance of this class goes out of
606 : : * scope.
607 : : */
608 : : class ProgressBarUpdater
609 : : {
610 : : ProgressBarHelper& mrHelper;
611 : : const sal_Int32& mrTableCount;
612 : : const sal_Int32& mrShapesCount;
613 : : const sal_Int32 mnCellCount;
614 : : public:
615 : : ProgressBarUpdater(ProgressBarHelper& rHelper,
616 : : const sal_Int32& rTableCount, const sal_Int32& rShapesCount,
617 : : const sal_Int32 nCellCount) :
618 : : mrHelper(rHelper),
619 : : mrTableCount(rTableCount),
620 : : mrShapesCount(rShapesCount),
621 : : mnCellCount(nCellCount) {}
622 : :
623 : : ~ProgressBarUpdater()
624 : : {
625 : : sal_Int32 nRef = mnCellCount + (2 * mrTableCount) + (2 * mrShapesCount);
626 : : mrHelper.SetReference(nRef);
627 : : mrHelper.SetValue(0);
628 : : }
629 : : };
630 : :
631 : : }
632 : :
633 : 4 : void ScXMLExport::CollectSharedData(sal_Int32& nTableCount, sal_Int32& nShapesCount)
634 : : {
635 [ + - ]: 4 : if (!GetModel().is())
636 : : return;
637 : :
638 [ + - ]: 4 : uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc(GetModel(), uno::UNO_QUERY);
639 [ - + ]: 4 : if (!xSpreadDoc.is())
640 : : return;
641 : :
642 [ + - ][ + - ]: 4 : uno::Reference<container::XIndexAccess> xIndex(xSpreadDoc->getSheets(), uno::UNO_QUERY);
[ + - ]
643 [ - + ]: 4 : if (!xIndex.is())
644 : : return;
645 : :
646 [ + - ][ + - ]: 4 : nTableCount = xIndex->getCount();
647 [ + - ]: 4 : if (!pSharedData)
648 [ + - ]: 4 : CreateSharedData(nTableCount);
649 : :
650 [ + - ]: 4 : pCellStyles->AddNewTable(nTableCount - 1);
651 : :
652 [ + + ]: 8 : for (SCTAB nTable = 0; nTable < nTableCount; ++nTable)
653 : : {
654 [ + - ][ + - ]: 4 : pDoc->GetNotes(nTable)->CreateAllNoteCaptions(nTable);
655 : 4 : nCurrentTable = sal::static_int_cast<sal_uInt16>(nTable);
656 [ + - ][ + - ]: 4 : uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xIndex->getByIndex(nTable), uno::UNO_QUERY);
[ + - ]
657 [ - + ]: 4 : if (!xDrawPageSupplier.is())
658 : 0 : continue;
659 : :
660 [ + - ][ + - ]: 4 : uno::Reference<drawing::XDrawPage> xDrawPage(xDrawPageSupplier->getDrawPage());
661 [ + - ]: 4 : ScMyDrawPage aDrawPage;
662 : 4 : aDrawPage.bHasForms = false;
663 [ + - ]: 4 : aDrawPage.xDrawPage.set(xDrawPage);
664 [ + - ]: 4 : pSharedData->AddDrawPage(aDrawPage, nTable);
665 [ + - ]: 4 : uno::Reference<container::XIndexAccess> xShapesIndex(xDrawPage, uno::UNO_QUERY);
666 [ - + ]: 4 : if (!xShapesIndex.is())
667 : 0 : continue;
668 : :
669 [ + - ][ + - ]: 4 : sal_Int32 nShapes = xShapesIndex->getCount();
670 [ - + ]: 4 : for (sal_Int32 nShape = 0; nShape < nShapes; ++nShape)
671 : : {
672 [ # # ][ # # ]: 0 : uno::Reference<drawing::XShape> xShape(xShapesIndex->getByIndex(nShape), uno::UNO_QUERY);
[ # # ]
673 [ # # ]: 0 : if (!xShape.is())
674 : 0 : continue;
675 : :
676 [ # # ]: 0 : uno::Reference<beans::XPropertySet> xShapeProp(xShape, uno::UNO_QUERY);
677 [ # # ]: 0 : if (!xShapeProp.is())
678 : 0 : continue;
679 : :
680 : 0 : sal_Int16 nLayerID = 0;
681 [ # # ][ # # ]: 0 : bool bExtracted = xShapeProp->getPropertyValue(sLayerID) >>= nLayerID;
682 [ # # ]: 0 : if (!bExtracted)
683 : 0 : continue;
684 : :
685 [ # # ][ # # ]: 0 : if ((nLayerID == SC_LAYER_INTERN) || (nLayerID == SC_LAYER_HIDDEN))
686 : : {
687 [ # # ]: 0 : CollectInternalShape(xShape);
688 : 0 : continue;
689 : : }
690 : :
691 : 0 : ++nShapesCount;
692 : :
693 [ # # ]: 0 : SvxShape* pShapeImp = SvxShape::getImplementation(xShape);
694 [ # # ]: 0 : if (!pShapeImp)
695 : 0 : continue;
696 : :
697 [ # # ]: 0 : SdrObject* pSdrObj = pShapeImp->GetSdrObject();
698 [ # # ]: 0 : if (!pSdrObj)
699 : 0 : continue;
700 : :
701 [ # # ][ # # ]: 0 : if (ScDrawObjData *pAnchor = ScDrawLayer::GetObjData(pSdrObj))
702 : : {
703 [ # # ]: 0 : ScMyShape aMyShape;
704 : 0 : aMyShape.aAddress = pAnchor->maStart;
705 : 0 : aMyShape.aEndAddress = pAnchor->maEnd;
706 : 0 : aMyShape.nEndX = pAnchor->maEndOffset.X();
707 : 0 : aMyShape.nEndY = pAnchor->maEndOffset.Y();
708 [ # # ]: 0 : aMyShape.xShape = xShape;
709 [ # # ]: 0 : pSharedData->AddNewShape(aMyShape);
710 [ # # ]: 0 : pSharedData->SetLastColumn(nTable, pAnchor->maStart.Col());
711 [ # # ][ # # ]: 0 : pSharedData->SetLastRow(nTable, pAnchor->maStart.Row());
712 : : }
713 : : else
714 [ # # ]: 0 : pSharedData->AddTableShape(nTable, xShape);
715 [ # # ][ # # ]: 0 : }
716 [ - + ][ + - ]: 8 : }
[ - + ][ - + ]
[ + - ][ - + ]
[ + - ]
717 : : }
718 : :
719 : 4 : void ScXMLExport::CollectShapesAutoStyles(const sal_Int32 nTableCount)
720 : : {
721 : : // #i84077# To avoid compiler warnings about uninitialized aShapeItr,
722 : : // it's initialized using this dummy list. The iterator contains shapes
723 : : // from all sheets, so it can't be declared inside the nTable loop where
724 : : // it is used.
725 [ + - ]: 4 : ScMyShapeList aDummyInitList;
726 : :
727 [ + - ]: 4 : pSharedData->SortShapesContainer();
728 [ + - ]: 4 : pSharedData->SortNoteShapes();
729 : 4 : const ScMyShapeList* pShapeList(NULL);
730 : 4 : ScMyShapeList::const_iterator aShapeItr = aDummyInitList.end();
731 [ - + ]: 4 : if (pSharedData->GetShapesContainer())
732 : : {
733 : 0 : pShapeList = pSharedData->GetShapesContainer()->GetShapes();
734 : 0 : aShapeItr = pShapeList->begin();
735 : : }
736 [ + - ]: 4 : if (pSharedData->HasDrawPage())
737 : : {
738 [ + + ]: 8 : for (SCTAB nTable = 0; nTable < nTableCount; ++nTable)
739 : : {
740 [ + - ]: 4 : uno::Reference<drawing::XDrawPage> xDrawPage(pSharedData->GetDrawPage(nTable));
741 [ + - ]: 4 : uno::Reference<drawing::XShapes> xShapes (xDrawPage, uno::UNO_QUERY);
742 : :
743 [ + - ]: 4 : if (xShapes.is())
744 : : {
745 [ + - ][ + - ]: 4 : GetShapeExport()->seekShapes(xShapes);
[ + - ]
746 [ + - ]: 4 : uno::Reference< form::XFormsSupplier2 > xFormsSupplier( xDrawPage, uno::UNO_QUERY );
747 [ + - ][ + - ]: 4 : if( xFormsSupplier.is() && xFormsSupplier->hasForms() )
[ + - ][ - + ]
[ - + ]
748 : : {
749 [ # # ][ # # ]: 0 : GetFormExport()->examineForms(xDrawPage);
[ # # ][ # # ]
750 [ # # ]: 0 : pSharedData->SetDrawPageHasForms(nTable, true);
751 : : }
752 : 4 : ScMyTableShapes* pTableShapes(pSharedData->GetTableShapes());
753 [ - + ]: 4 : if (pTableShapes)
754 : : {
755 : 0 : ScMyTableXShapes::iterator aItr((*pTableShapes)[nTable].begin());
756 : 0 : ScMyTableXShapes::iterator aEndItr((*pTableShapes)[nTable].end());
757 [ # # ]: 0 : while (aItr != aEndItr)
758 : : {
759 [ # # ][ # # ]: 0 : GetShapeExport()->collectShapeAutoStyles(*aItr);
[ # # ][ # # ]
760 [ # # ]: 0 : IncrementProgressBar(false);
761 : 0 : ++aItr;
762 : : }
763 : : }
764 [ - + ]: 4 : if (pShapeList)
765 : : {
766 : 0 : ScMyShapeList::const_iterator aEndItr(pShapeList->end());
767 [ # # ][ # # ]: 0 : while (aShapeItr != aEndItr && (static_cast<sal_Int32>(aShapeItr->aAddress.Tab()) == nTable))
[ # # ]
768 : : {
769 [ # # ][ # # ]: 0 : GetShapeExport()->collectShapeAutoStyles(aShapeItr->xShape);
[ # # ][ # # ]
770 [ # # ]: 0 : IncrementProgressBar(false);
771 : 0 : ++aShapeItr;
772 : : }
773 : : }
774 : 4 : const ScMyNoteShapeList* pNoteShapes = NULL;
775 : 4 : ScMyNoteShapeList::const_iterator aNoteShapeItr;
776 : 4 : ScMyNoteShapeList::const_iterator aNoteShapeEndItr;
777 [ - + ]: 4 : if (pSharedData->GetNoteShapes())
778 : : {
779 : 0 : pNoteShapes = pSharedData->GetNoteShapes()->GetNotes();
780 [ # # ]: 0 : if (pNoteShapes)
781 : : {
782 : 0 : aNoteShapeItr = pNoteShapes->begin();
783 : 0 : aNoteShapeEndItr = pNoteShapes->end();
784 : : }
785 : : }
786 [ - + ]: 4 : if (pNoteShapes)
787 : : {
788 [ # # ]: 0 : while (aNoteShapeItr != aNoteShapeEndItr)
789 : : {
790 [ # # ]: 0 : if (static_cast<sal_Int32>(aNoteShapeItr->aPos.Tab()) == nTable)
791 [ # # ][ # # ]: 0 : GetShapeExport()->collectShapeAutoStyles(aNoteShapeItr->xShape);
[ # # ][ # # ]
792 : 0 : ++aNoteShapeItr;
793 : : }
794 : 4 : }
795 : : }
796 : 4 : }
797 : : }
798 [ + - ]: 4 : pSharedData->SortNoteShapes(); // sort twice, because some more shapes are added
799 : 4 : }
800 : :
801 : 4 : void ScXMLExport::_ExportMeta()
802 : : {
803 [ + - ][ + - ]: 4 : sal_Int32 nCellCount(pDoc ? pDoc->GetCellCount() : 0);
804 : 4 : sal_Int32 nTableCount(0);
805 : 4 : sal_Int32 nShapesCount(0);
806 [ + - ][ + - ]: 4 : GetAutoStylePool()->ClearEntries();
[ + - ][ + - ]
807 [ + - ]: 4 : CollectSharedData(nTableCount, nShapesCount);
808 : :
809 [ + - ]: 4 : uno::Sequence<beans::NamedValue> stats(3);
810 [ + - ]: 4 : stats[0] = beans::NamedValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TableCount")),
811 [ + - ][ + - ]: 8 : uno::makeAny(nTableCount));
812 [ + - ]: 4 : stats[1] = beans::NamedValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CellCount")),
813 [ + - ][ + - ]: 8 : uno::makeAny(nCellCount));
814 [ + - ]: 4 : stats[2] = beans::NamedValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ObjectCount")),
815 [ + - ][ + - ]: 8 : uno::makeAny(nShapesCount));
816 : :
817 : : // update document statistics at the model
818 : 4 : uno::Reference<document::XDocumentPropertiesSupplier> xPropSup(GetModel(),
819 [ + - ]: 4 : uno::UNO_QUERY_THROW);
820 : : uno::Reference<document::XDocumentProperties> xDocProps(
821 [ + - ][ + - ]: 4 : xPropSup->getDocumentProperties());
822 [ + - ]: 4 : if (xDocProps.is()) {
823 [ + - ][ + - ]: 4 : xDocProps->setDocumentStatistics(stats);
824 : : }
825 : :
826 : : // export document properties
827 [ + - ][ + - ]: 4 : SvXMLExport::_ExportMeta();
828 : 4 : }
829 : :
830 : 8 : void ScXMLExport::_ExportFontDecls()
831 : : {
832 : 8 : GetFontAutoStylePool(); // make sure the pool is created
833 : 8 : SvXMLExport::_ExportFontDecls();
834 : 8 : }
835 : :
836 : 8 : table::CellRangeAddress ScXMLExport::GetEndAddress(const uno::Reference<sheet::XSpreadsheet>& xTable, const sal_Int32 /* nTable */)
837 : : {
838 : 8 : table::CellRangeAddress aCellAddress;
839 [ + - ][ + - ]: 8 : uno::Reference<sheet::XSheetCellCursor> xCursor(xTable->createCursor());
840 [ + - ]: 8 : uno::Reference<sheet::XUsedAreaCursor> xUsedArea (xCursor, uno::UNO_QUERY);
841 [ + - ]: 8 : uno::Reference<sheet::XCellRangeAddressable> xCellAddress (xCursor, uno::UNO_QUERY);
842 [ + - ][ + - ]: 8 : if (xUsedArea.is() && xCellAddress.is())
[ + - ]
843 : : {
844 [ + - ][ + - ]: 8 : xUsedArea->gotoEndOfUsedArea(true);
845 [ + - ][ + - ]: 8 : aCellAddress = xCellAddress->getRangeAddress();
846 : : }
847 : 8 : return aCellAddress;
848 : : }
849 : :
850 : 4 : void ScXMLExport::GetAreaLinks( uno::Reference< sheet::XSpreadsheetDocument>& xSpreadDoc,
851 : : ScMyAreaLinksContainer& rAreaLinks )
852 : : {
853 [ + - ]: 4 : uno::Reference< beans::XPropertySet > xPropSet( xSpreadDoc, uno::UNO_QUERY );
854 [ - + ]: 8 : if( !xPropSet.is() ) return;
855 : :
856 [ + - ][ + - ]: 4 : uno::Reference< container::XIndexAccess > xLinksIAccess( xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNO_AREALINKS ) ) ), uno::UNO_QUERY);
[ + - ][ + - ]
857 [ + - ]: 4 : if( xLinksIAccess.is() )
858 : : {
859 [ + - ]: 4 : const OUString sFilter( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_FILTER ) );
860 [ + - ]: 4 : const OUString sFilterOpt( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_FILTOPT ) );
861 [ + - ]: 4 : const OUString sURL( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_LINKURL ) );
862 [ + - ]: 4 : const OUString sRefresh( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_REFDELAY ) );
863 : :
864 [ + - ][ + - ]: 4 : sal_Int32 nCount(xLinksIAccess->getCount());
865 [ - + ]: 4 : for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
866 : : {
867 [ # # ][ # # ]: 0 : uno::Reference< sheet::XAreaLink > xAreaLink(xLinksIAccess->getByIndex( nIndex ), uno::UNO_QUERY);
[ # # ]
868 [ # # ]: 0 : if( xAreaLink.is() )
869 : : {
870 : 0 : ScMyAreaLink aAreaLink;
871 [ # # ][ # # ]: 0 : aAreaLink.aDestRange = xAreaLink->getDestArea();
872 [ # # ][ # # ]: 0 : aAreaLink.sSourceStr = xAreaLink->getSourceArea();
873 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xLinkProp( xAreaLink, uno::UNO_QUERY );
874 [ # # ]: 0 : if( xLinkProp.is() )
875 : : {
876 [ # # ][ # # ]: 0 : xLinkProp->getPropertyValue( sFilter ) >>= aAreaLink.sFilter;
877 [ # # ][ # # ]: 0 : xLinkProp->getPropertyValue( sFilterOpt ) >>= aAreaLink.sFilterOptions;
878 [ # # ][ # # ]: 0 : xLinkProp->getPropertyValue( sURL ) >>= aAreaLink.sURL;
879 [ # # ][ # # ]: 0 : xLinkProp->getPropertyValue( sRefresh ) >>= aAreaLink.nRefresh;
880 : : }
881 [ # # ]: 0 : rAreaLinks.AddNewAreaLink( aAreaLink );
882 : : }
883 : 4 : }
884 : : }
885 [ + - ][ + - ]: 4 : rAreaLinks.Sort();
886 : : }
887 : :
888 : : // core implementation
889 : 4 : void ScXMLExport::GetDetectiveOpList( ScMyDetectiveOpContainer& rDetOp )
890 : : {
891 [ + - ]: 4 : if (pDoc)
892 : : {
893 : 4 : ScDetOpList* pOpList(pDoc->GetDetOpList());
894 [ - + ]: 4 : if( pOpList )
895 : : {
896 : 0 : size_t nCount = pOpList->Count();
897 [ # # ]: 0 : for (size_t nIndex = 0; nIndex < nCount; ++nIndex )
898 : : {
899 : 0 : const ScDetOpData* pDetData = pOpList->GetObject( nIndex);
900 [ # # ]: 0 : if( pDetData )
901 : : {
902 : 0 : const ScAddress& rDetPos = pDetData->GetPos();
903 : 0 : SCTAB nTab = rDetPos.Tab();
904 [ # # ]: 0 : if ( nTab < pDoc->GetTableCount() )
905 : : {
906 : 0 : rDetOp.AddOperation( pDetData->GetOperation(), rDetPos, static_cast<sal_uInt32>( nIndex) );
907 : :
908 : : // cells with detective operations are written even if empty
909 : 0 : pSharedData->SetLastColumn( nTab, rDetPos.Col() );
910 : 0 : pSharedData->SetLastRow( nTab, rDetPos.Row() );
911 : : }
912 : : }
913 : : }
914 : 0 : rDetOp.Sort();
915 : : }
916 : : }
917 : 4 : }
918 : :
919 : 4 : void ScXMLExport::WriteSingleColumn(const sal_Int32 nRepeatColumns, const sal_Int32 nStyleIndex,
920 : : const sal_Int32 nIndex, const bool bIsAutoStyle, const bool bIsVisible)
921 : : {
922 : 4 : CheckAttrList();
923 [ + - ][ + - ]: 4 : AddAttribute(sAttrStyleName, *pColumnStyles->GetStyleNameByIndex(nStyleIndex));
924 [ - + ]: 4 : if (!bIsVisible)
925 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_COLLAPSE);
926 [ - + ]: 4 : if (nRepeatColumns > 1)
927 : : {
928 : 0 : OUString sOUEndCol(OUString::valueOf(static_cast <sal_Int32> (nRepeatColumns)));
929 [ # # ]: 0 : AddAttribute(sAttrColumnsRepeated, sOUEndCol);
930 : : }
931 [ + - ]: 4 : if (nIndex != -1)
932 [ + - ][ + - ]: 4 : AddAttribute(XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME, *pCellStyles->GetStyleNameByIndex(nIndex, bIsAutoStyle));
933 [ + - ][ + - ]: 4 : SvXMLElementExport aElemC(*this, sElemCol, true, true);
934 : 4 : }
935 : :
936 : 4 : void ScXMLExport::WriteColumn(const sal_Int32 nColumn, const sal_Int32 nRepeatColumns,
937 : : const sal_Int32 nStyleIndex, const bool bIsVisible)
938 : : {
939 : 4 : sal_Int32 nRepeat(1);
940 : 4 : sal_Int32 nPrevIndex((*pDefaults->GetColDefaults())[nColumn].nIndex);
941 : 4 : bool bPrevAutoStyle((*pDefaults->GetColDefaults())[nColumn].bIsAutoStyle);
942 [ - + ]: 4 : for (sal_Int32 i = nColumn + 1; i < nColumn + nRepeatColumns; ++i)
943 : : {
944 [ # # # # ]: 0 : if (((*pDefaults->GetColDefaults())[i].nIndex != nPrevIndex) ||
[ # # ]
945 : 0 : ((*pDefaults->GetColDefaults())[i].bIsAutoStyle != bPrevAutoStyle))
946 : : {
947 : 0 : WriteSingleColumn(nRepeat, nStyleIndex, nPrevIndex, bPrevAutoStyle, bIsVisible);
948 : 0 : nPrevIndex = (*pDefaults->GetColDefaults())[i].nIndex;
949 : 0 : bPrevAutoStyle = (*pDefaults->GetColDefaults())[i].bIsAutoStyle;
950 : 0 : nRepeat = 1;
951 : : }
952 : : else
953 : 0 : ++nRepeat;
954 : : }
955 : 4 : WriteSingleColumn(nRepeat, nStyleIndex, nPrevIndex, bPrevAutoStyle, bIsVisible);
956 : 4 : }
957 : :
958 : 0 : void ScXMLExport::OpenHeaderColumn()
959 : : {
960 : 0 : StartElement( XML_NAMESPACE_TABLE, XML_TABLE_HEADER_COLUMNS, true );
961 : 0 : }
962 : :
963 : 0 : void ScXMLExport::CloseHeaderColumn()
964 : : {
965 : 0 : EndElement(XML_NAMESPACE_TABLE, XML_TABLE_HEADER_COLUMNS, true);
966 : 0 : }
967 : :
968 : 4 : void ScXMLExport::ExportColumns(const sal_Int32 nTable, const table::CellRangeAddress& aColumnHeaderRange, const bool bHasColumnHeader)
969 : : {
970 : 4 : sal_Int32 nColsRepeated (1);
971 : 4 : rtl::OUString sParent;
972 : : sal_Int32 nIndex;
973 : 4 : sal_Int32 nPrevColumn(0);
974 : 4 : bool bPrevIsVisible (true);
975 : 4 : bool bWasHeader (false);
976 : 4 : bool bIsHeader (false);
977 : 4 : bool bIsClosed (true);
978 : 4 : sal_Int32 nPrevIndex (-1);
979 : : sal_Int32 nColumn;
980 [ + - ][ + + ]: 8 : for (nColumn = 0; nColumn <= pSharedData->GetLastColumn(nTable); ++nColumn)
981 : : {
982 : 4 : CheckAttrList();
983 : 4 : bool bIsVisible(true);
984 [ + - ]: 4 : nIndex = pColumnStyles->GetStyleNameIndex(nTable, nColumn, bIsVisible);
985 : :
986 [ - + ][ # # ]: 4 : bIsHeader = bHasColumnHeader && (aColumnHeaderRange.StartColumn <= nColumn) && (nColumn <= aColumnHeaderRange.EndColumn);
[ # # ]
987 [ - + ]: 4 : if (bIsHeader != bWasHeader)
988 : : {
989 [ # # ]: 0 : if (bIsHeader)
990 : : {
991 [ # # ]: 0 : if (nColumn > 0)
992 : : {
993 [ # # ]: 0 : WriteColumn(nPrevColumn, nColsRepeated, nPrevIndex, bPrevIsVisible);
994 [ # # ][ # # ]: 0 : if (pGroupColumns->IsGroupEnd(nColumn - 1))
995 [ # # ]: 0 : pGroupColumns->CloseGroups(nColumn - 1);
996 : : }
997 : 0 : bPrevIsVisible = bIsVisible;
998 : 0 : nPrevIndex = nIndex;
999 : 0 : nPrevColumn = nColumn;
1000 : 0 : nColsRepeated = 1;
1001 [ # # ][ # # ]: 0 : if(pGroupColumns->IsGroupStart(nColumn))
1002 [ # # ]: 0 : pGroupColumns->OpenGroups(nColumn);
1003 [ # # ]: 0 : OpenHeaderColumn();
1004 : 0 : bWasHeader = true;
1005 : 0 : bIsClosed = false;
1006 : : }
1007 : : else
1008 : : {
1009 [ # # ]: 0 : WriteColumn(nPrevColumn, nColsRepeated, nPrevIndex, bPrevIsVisible);
1010 [ # # ]: 0 : CloseHeaderColumn();
1011 [ # # ][ # # ]: 0 : if (pGroupColumns->IsGroupEnd(nColumn - 1))
1012 [ # # ]: 0 : pGroupColumns->CloseGroups(nColumn - 1);
1013 [ # # ][ # # ]: 0 : if(pGroupColumns->IsGroupStart(nColumn))
1014 [ # # ]: 0 : pGroupColumns->OpenGroups(nColumn);
1015 : 0 : bPrevIsVisible = bIsVisible;
1016 : 0 : nPrevIndex = nIndex;
1017 : 0 : nPrevColumn = nColumn;
1018 : 0 : nColsRepeated = 1;
1019 : 0 : bWasHeader = false;
1020 : 0 : bIsClosed = true;
1021 : : }
1022 : : }
1023 [ + - ]: 4 : else if (nColumn == 0)
1024 : : {
1025 [ + - ][ - + ]: 4 : if (pGroupColumns->IsGroupStart(nColumn))
1026 [ # # ]: 0 : pGroupColumns->OpenGroups(nColumn);
1027 : 4 : bPrevIsVisible = bIsVisible;
1028 : 4 : nPrevIndex = nIndex;
1029 : : }
1030 [ # # ][ # # ]: 0 : else if ((bIsVisible == bPrevIsVisible) && (nIndex == nPrevIndex) &&
[ # # ][ # # ]
[ # # ]
1031 [ # # ][ # # ]: 0 : !pGroupColumns->IsGroupStart(nColumn) && !pGroupColumns->IsGroupEnd(nColumn - 1))
1032 : 0 : ++nColsRepeated;
1033 : : else
1034 : : {
1035 [ # # ]: 0 : WriteColumn(nPrevColumn, nColsRepeated, nPrevIndex, bPrevIsVisible);
1036 [ # # ][ # # ]: 0 : if (pGroupColumns->IsGroupEnd(nColumn - 1))
1037 : : {
1038 [ # # ]: 0 : if (bIsHeader)
1039 [ # # ]: 0 : CloseHeaderColumn();
1040 [ # # ]: 0 : pGroupColumns->CloseGroups(nColumn - 1);
1041 [ # # ]: 0 : if (bIsHeader)
1042 [ # # ]: 0 : OpenHeaderColumn();
1043 : : }
1044 [ # # ][ # # ]: 0 : if (pGroupColumns->IsGroupStart(nColumn))
1045 : : {
1046 [ # # ]: 0 : if (bIsHeader)
1047 [ # # ]: 0 : CloseHeaderColumn();
1048 [ # # ]: 0 : pGroupColumns->OpenGroups(nColumn);
1049 [ # # ]: 0 : if (bIsHeader)
1050 [ # # ]: 0 : OpenHeaderColumn();
1051 : : }
1052 : 0 : bPrevIsVisible = bIsVisible;
1053 : 0 : nPrevIndex = nIndex;
1054 : 0 : nPrevColumn = nColumn;
1055 : 0 : nColsRepeated = 1;
1056 : : }
1057 : : }
1058 [ + - ]: 4 : WriteColumn(nPrevColumn, nColsRepeated, nPrevIndex, bPrevIsVisible);
1059 [ - + ]: 4 : if (!bIsClosed)
1060 [ # # ]: 0 : CloseHeaderColumn();
1061 [ + - ][ - + ]: 4 : if (pGroupColumns->IsGroupEnd(nColumn - 1))
1062 [ # # ]: 4 : pGroupColumns->CloseGroups(nColumn - 1);
1063 : 4 : }
1064 : :
1065 : 4 : void ScXMLExport::ExportExternalRefCacheStyles()
1066 : : {
1067 : : sal_Int32 nEntryIndex = GetCellStylesPropertySetMapper()->FindEntryIndex(
1068 [ + - ][ + - ]: 4 : "NumberFormat", XML_NAMESPACE_STYLE, OUString(RTL_CONSTASCII_USTRINGPARAM("data-style-name")));
[ + - ][ + - ]
[ + - ]
1069 : :
1070 [ + - ]: 4 : if (nEntryIndex < 0)
1071 : : // No entry index for the number format is found.
1072 : : return;
1073 : :
1074 [ + - ]: 4 : ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
1075 [ + - ][ - + ]: 4 : if (!pRefMgr->hasExternalData())
1076 : : // No external reference data cached.
1077 : : return;
1078 : :
1079 : : // Export each unique number format used in the external ref cache.
1080 [ # # ]: 0 : vector<sal_uInt32> aNumFmts;
1081 [ # # ]: 0 : pRefMgr->getAllCachedNumberFormats(aNumFmts);
1082 [ # # ][ # # ]: 0 : const OUString aDefaultStyle = OUString(RTL_CONSTASCII_USTRINGPARAM("Default")).intern();
1083 [ # # ][ # # ]: 0 : for (vector<sal_uInt32>::const_iterator itr = aNumFmts.begin(), itrEnd = aNumFmts.end();
[ # # ][ # # ]
[ # # ]
1084 : : itr != itrEnd; ++itr)
1085 : : {
1086 [ # # ]: 0 : sal_Int32 nNumFmt = static_cast<sal_Int32>(*itr);
1087 : :
1088 [ # # ]: 0 : addDataStyle(nNumFmt);
1089 : :
1090 : 0 : uno::Any aVal;
1091 [ # # ]: 0 : aVal <<= nNumFmt;
1092 [ # # ]: 0 : vector<XMLPropertyState> aProps;
1093 [ # # ]: 0 : aProps.push_back(XMLPropertyState(nEntryIndex, aVal));
1094 [ # # ]: 0 : aVal <<= aDefaultStyle;
1095 [ # # ]: 0 : aProps.push_back(XMLPropertyState(nEntryIndex, aVal));
1096 : :
1097 : 0 : OUString aName;
1098 : : sal_Int32 nIndex;
1099 [ # # ][ # # ]: 0 : if (GetAutoStylePool()->Add(aName, XML_STYLE_FAMILY_TABLE_CELL, aDefaultStyle, aProps))
[ # # ][ # # ]
[ # # ]
1100 : : {
1101 [ # # ]: 0 : OUString* pTemp(new OUString(aName));
1102 [ # # ][ # # ]: 0 : if (!pCellStyles->AddStyleName(pTemp, nIndex, true))
1103 [ # # ]: 0 : delete pTemp;
1104 : : }
1105 : : else
1106 : : {
1107 : : bool bIsAuto;
1108 : : nIndex = pCellStyles->GetIndexOfStyleName(
1109 [ # # ][ # # ]: 0 : aName, OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_PREFIX)), bIsAuto);
1110 : : }
1111 : :
1112 : : // store the number format to index mapping for later use.
1113 [ # # ][ # # ]: 0 : aNumFmtIndexMap.insert(NumberFormatIndexMap::value_type(nNumFmt, nIndex));
1114 : 4 : }
1115 : : }
1116 : :
1117 : 4 : void ScXMLExport::WriteRowContent()
1118 : : {
1119 [ + - ]: 4 : ScMyRowFormatRange aRange;
1120 : 4 : sal_Int32 nIndex(-1);
1121 : : #if OSL_DEBUG_LEVEL > 0
1122 : : sal_Int32 nPrevCol(0);
1123 : : #endif
1124 : 4 : sal_Int32 nCols(0);
1125 : 4 : sal_Int32 nPrevValidationIndex(-1);
1126 : 4 : bool bIsAutoStyle(true);
1127 : 4 : bool bIsFirst(true);
1128 [ + - ][ + + ]: 8 : while (pRowFormatRanges->GetNext(aRange))
1129 : : {
1130 : : #if OSL_DEBUG_LEVEL > 0
1131 : : OSL_ENSURE(bIsFirst || (!bIsFirst && (nPrevCol + nCols == aRange.nStartColumn)), "here are some columns missing");
1132 : : #endif
1133 [ + - ]: 4 : if (bIsFirst)
1134 : : {
1135 : 4 : nIndex = aRange.nIndex;
1136 : 4 : nPrevValidationIndex = aRange.nValidationIndex;
1137 : 4 : bIsAutoStyle = aRange.bIsAutoStyle;
1138 : 4 : nCols = aRange.nRepeatColumns;
1139 : 4 : bIsFirst = false;
1140 : : #if OSL_DEBUG_LEVEL > 0
1141 : : nPrevCol = aRange.nStartColumn;
1142 : : #endif
1143 : : }
1144 : : else
1145 : : {
1146 [ # # ][ # # ]: 0 : if (((aRange.nIndex == nIndex && aRange.bIsAutoStyle == bIsAutoStyle) ||
[ # # ][ # # ]
[ # # ]
1147 : : (aRange.nIndex == nIndex && nIndex == -1)) &&
1148 : : nPrevValidationIndex == aRange.nValidationIndex)
1149 : 0 : nCols += aRange.nRepeatColumns;
1150 : : else
1151 : : {
1152 [ # # ]: 0 : if (nIndex != -1)
1153 [ # # ][ # # ]: 0 : AddAttribute(sAttrStyleName, *pCellStyles->GetStyleNameByIndex(nIndex, bIsAutoStyle));
1154 [ # # ]: 0 : if (nPrevValidationIndex > -1)
1155 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION_NAME, pValidationsContainer->GetValidationName(nPrevValidationIndex));
1156 [ # # ]: 0 : if (nCols > 1)
1157 : : {
1158 : 0 : rtl::OUStringBuffer aBuf;
1159 [ # # ]: 0 : ::sax::Converter::convertNumber(aBuf, nCols);
1160 [ # # ][ # # ]: 0 : AddAttribute(sAttrColumnsRepeated, aBuf.makeStringAndClear());
1161 : : }
1162 [ # # ]: 0 : SvXMLElementExport aElemC(*this, sElemCell, true, true);
1163 : 0 : nIndex = aRange.nIndex;
1164 : 0 : bIsAutoStyle = aRange.bIsAutoStyle;
1165 : 0 : nCols = aRange.nRepeatColumns;
1166 [ # # ]: 0 : nPrevValidationIndex = aRange.nValidationIndex;
1167 : : #if OSL_DEBUG_LEVEL > 0
1168 : : nPrevCol = aRange.nStartColumn;
1169 : : #endif
1170 : : }
1171 : : }
1172 : : }
1173 [ + - ]: 4 : if (!bIsFirst)
1174 : : {
1175 : 4 : table::CellAddress aCellAddress;
1176 [ - + ]: 4 : if (nIndex != -1)
1177 [ # # ][ # # ]: 0 : AddAttribute(sAttrStyleName, *pCellStyles->GetStyleNameByIndex(nIndex, bIsAutoStyle));
1178 [ - + ]: 4 : if (nPrevValidationIndex > -1)
1179 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION_NAME, pValidationsContainer->GetValidationName(nPrevValidationIndex));
1180 [ - + ]: 4 : if (nCols > 1)
1181 : : {
1182 : 0 : rtl::OUStringBuffer aBuf;
1183 [ # # ]: 0 : ::sax::Converter::convertNumber(aBuf, nCols);
1184 [ # # ][ # # ]: 0 : AddAttribute(sAttrColumnsRepeated, aBuf.makeStringAndClear());
1185 : : }
1186 [ + - ][ + - ]: 4 : SvXMLElementExport aElemC(*this, sElemCell, true, true);
1187 : : }
1188 : 4 : }
1189 : :
1190 : 4 : void ScXMLExport::WriteRowStartTag(
1191 : : sal_Int32 nRow, const sal_Int32 nIndex, const sal_Int32 nEqualRows,
1192 : : bool bHidden, bool bFiltered)
1193 : : {
1194 : 4 : AddAttribute(sAttrStyleName, *pRowStyles->GetStyleNameByIndex(nIndex));
1195 [ - + ]: 4 : if (bHidden)
1196 : : {
1197 [ # # ]: 0 : if (bFiltered)
1198 : 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_FILTER);
1199 : : else
1200 : 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_COLLAPSE);
1201 : : }
1202 [ - + ]: 4 : if (nEqualRows > 1)
1203 : : {
1204 : 0 : rtl::OUStringBuffer aBuf;
1205 [ # # ]: 0 : ::sax::Converter::convertNumber(aBuf, nEqualRows);
1206 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_REPEATED, aBuf.makeStringAndClear());
1207 : : }
1208 : :
1209 : 4 : const ScMyDefaultStyleList& rRowDefaults = *pDefaults->GetRowDefaults();
1210 [ - + ]: 4 : if ( nRow >= sal::static_int_cast<sal_Int32>( rRowDefaults.size() ) )
1211 : : {
1212 : : // used to happen with detective operations - if there are more cases, use the last row's style
1213 : : OSL_FAIL("WriteRowStartTag: not enough defaults");
1214 : 0 : nRow = rRowDefaults.size() - 1;
1215 : : }
1216 : 4 : sal_Int32 nCellStyleIndex(rRowDefaults[nRow].nIndex);
1217 [ - + ]: 4 : if (nCellStyleIndex != -1)
1218 : : AddAttribute(XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME,
1219 : : *pCellStyles->GetStyleNameByIndex(nCellStyleIndex,
1220 : 0 : (*pDefaults->GetRowDefaults())[nRow].bIsAutoStyle));
1221 : 4 : StartElement( sElemRow, true);
1222 : 4 : }
1223 : :
1224 : 0 : void ScXMLExport::OpenHeaderRows()
1225 : : {
1226 : 0 : StartElement( XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, true);
1227 : 0 : bRowHeaderOpen = true;
1228 : 0 : }
1229 : :
1230 : 0 : void ScXMLExport::CloseHeaderRows()
1231 : : {
1232 : 0 : EndElement(XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, true);
1233 : 0 : }
1234 : :
1235 : 4 : void ScXMLExport::OpenNewRow(
1236 : : const sal_Int32 nIndex, const sal_Int32 nStartRow, const sal_Int32 nEqualRows,
1237 : : bool bHidden, bool bFiltered)
1238 : : {
1239 : 4 : nOpenRow = nStartRow;
1240 [ - + ]: 4 : if (pGroupRows->IsGroupStart(nStartRow))
1241 : : {
1242 [ # # ][ # # ]: 0 : if (bHasRowHeader && bRowHeaderOpen)
1243 : 0 : CloseHeaderRows();
1244 : 0 : pGroupRows->OpenGroups(nStartRow);
1245 [ # # ][ # # ]: 0 : if (bHasRowHeader && bRowHeaderOpen)
1246 : 0 : OpenHeaderRows();
1247 : : }
1248 [ - + ][ # # ]: 4 : if (bHasRowHeader && !bRowHeaderOpen && nStartRow >= aRowHeaderRange.StartRow && nStartRow <= aRowHeaderRange.EndRow)
[ # # ][ # # ]
1249 : : {
1250 [ # # ]: 0 : if (nStartRow == aRowHeaderRange.StartRow)
1251 : 0 : OpenHeaderRows();
1252 : : sal_Int32 nEquals;
1253 [ # # ]: 0 : if (aRowHeaderRange.EndRow < nStartRow + nEqualRows - 1)
1254 : 0 : nEquals = aRowHeaderRange.EndRow - nStartRow + 1;
1255 : : else
1256 : 0 : nEquals = nEqualRows;
1257 : 0 : WriteRowStartTag(nStartRow, nIndex, nEquals, bHidden, bFiltered);
1258 : 0 : nOpenRow = nStartRow + nEquals - 1;
1259 [ # # ]: 0 : if (nEquals < nEqualRows)
1260 : : {
1261 : 0 : CloseRow(nStartRow + nEquals - 1);
1262 : 0 : WriteRowStartTag(nStartRow, nIndex, nEqualRows - nEquals, bHidden, bFiltered);
1263 : 0 : nOpenRow = nStartRow + nEqualRows - 1;
1264 : 0 : }
1265 : : }
1266 : : else
1267 : 4 : WriteRowStartTag(nStartRow, nIndex, nEqualRows, bHidden, bFiltered);
1268 : 4 : }
1269 : :
1270 : 0 : void ScXMLExport::OpenAndCloseRow(
1271 : : const sal_Int32 nIndex, const sal_Int32 nStartRow, const sal_Int32 nEqualRows,
1272 : : bool bHidden, bool bFiltered)
1273 : : {
1274 : 0 : OpenNewRow(nIndex, nStartRow, nEqualRows, bHidden, bFiltered);
1275 : 0 : WriteRowContent();
1276 : 0 : CloseRow(nStartRow + nEqualRows - 1);
1277 : 0 : pRowFormatRanges->Clear();
1278 : 0 : }
1279 : :
1280 : 4 : void ScXMLExport::OpenRow(const sal_Int32 nTable, const sal_Int32 nStartRow, const sal_Int32 nRepeatRow, ScXMLCachedRowAttrAccess& rRowAttr)
1281 : : {
1282 [ - + ]: 4 : if (nRepeatRow > 1)
1283 : : {
1284 : 0 : sal_Int32 nPrevIndex(0), nIndex;
1285 : 0 : bool bPrevHidden = false;
1286 : 0 : bool bPrevFiltered = false;
1287 : 0 : bool bHidden = false;
1288 : 0 : bool bFiltered = false;
1289 : 0 : sal_Int32 nEqualRows(1);
1290 : 0 : sal_Int32 nEndRow(nStartRow + nRepeatRow);
1291 : : sal_Int32 nRow;
1292 [ # # ]: 0 : for (nRow = nStartRow; nRow < nEndRow; ++nRow)
1293 : : {
1294 [ # # ]: 0 : if (nRow == nStartRow)
1295 : : {
1296 : 0 : nPrevIndex = pRowStyles->GetStyleNameIndex(nTable, nRow);
1297 [ # # ]: 0 : if (pDoc)
1298 : : {
1299 : 0 : bPrevHidden = rRowAttr.rowHidden(nTable, nRow);
1300 : 0 : bPrevFiltered = rRowAttr.rowFiltered(nTable, nRow);
1301 : : }
1302 : : }
1303 : : else
1304 : : {
1305 : 0 : nIndex = pRowStyles->GetStyleNameIndex(nTable, nRow);
1306 [ # # ]: 0 : if (pDoc)
1307 : : {
1308 : 0 : bHidden = rRowAttr.rowHidden(nTable, nRow);
1309 : 0 : bFiltered = rRowAttr.rowFiltered(nTable, nRow);
1310 : : }
1311 [ # # ][ # # ]: 0 : if (nIndex == nPrevIndex && bHidden == bPrevHidden && bFiltered == bPrevFiltered &&
[ # # ][ # #
# # # # ]
[ # # ]
1312 [ # # ][ # # ]: 0 : !(bHasRowHeader && ((nRow == aRowHeaderRange.StartRow) || (nRow - 1 == aRowHeaderRange.EndRow))) &&
1313 : 0 : !(pGroupRows->IsGroupStart(nRow)) &&
1314 : 0 : !(pGroupRows->IsGroupEnd(nRow - 1)))
1315 : 0 : ++nEqualRows;
1316 : : else
1317 : : {
1318 [ # # ]: 0 : if (nRow < nEndRow)
1319 : : {
1320 [ # # ]: 0 : ScRowFormatRanges* pTempRowFormatRanges = new ScRowFormatRanges(pRowFormatRanges);
1321 : 0 : OpenAndCloseRow(nPrevIndex, nRow - nEqualRows, nEqualRows, bPrevHidden, bPrevFiltered);
1322 [ # # ]: 0 : delete pRowFormatRanges;
1323 : 0 : pRowFormatRanges = pTempRowFormatRanges;
1324 : : }
1325 : : else
1326 : 0 : OpenAndCloseRow(nPrevIndex, nRow - nEqualRows, nEqualRows, bPrevHidden, bPrevFiltered);
1327 : 0 : nEqualRows = 1;
1328 : 0 : nPrevIndex = nIndex;
1329 : 0 : bPrevHidden = bHidden;
1330 : 0 : bPrevFiltered = bFiltered;
1331 : : }
1332 : : }
1333 : : }
1334 : 0 : OpenNewRow(nPrevIndex, nRow - nEqualRows, nEqualRows, bPrevHidden, bPrevFiltered);
1335 : : }
1336 : : else
1337 : : {
1338 : 4 : sal_Int32 nIndex = pRowStyles->GetStyleNameIndex(nTable, nStartRow);
1339 : 4 : bool bHidden = false;
1340 : 4 : bool bFiltered = false;
1341 [ + - ]: 4 : if (pDoc)
1342 : : {
1343 : 4 : bHidden = rRowAttr.rowHidden(nTable, nStartRow);
1344 : 4 : bFiltered = rRowAttr.rowFiltered(nTable, nStartRow);
1345 : : }
1346 : 4 : OpenNewRow(nIndex, nStartRow, 1, bHidden, bFiltered);
1347 : : }
1348 : 4 : nOpenRow = nStartRow + nRepeatRow - 1;
1349 : 4 : }
1350 : :
1351 : 4 : void ScXMLExport::CloseRow(const sal_Int32 nRow)
1352 : : {
1353 [ + - ]: 4 : if (nOpenRow > -1)
1354 : : {
1355 : 4 : EndElement(sElemRow, true);
1356 [ # # ][ - + ]: 4 : if (bHasRowHeader && nRow == aRowHeaderRange.EndRow)
1357 : : {
1358 : 0 : CloseHeaderRows();
1359 : 0 : bRowHeaderOpen = false;
1360 : : }
1361 [ - + ]: 4 : if (pGroupRows->IsGroupEnd(nRow))
1362 : : {
1363 [ # # ][ # # ]: 0 : if (bHasRowHeader && bRowHeaderOpen)
1364 : 0 : CloseHeaderRows();
1365 : 0 : pGroupRows->CloseGroups(nRow);
1366 [ # # ][ # # ]: 0 : if (bHasRowHeader && bRowHeaderOpen)
1367 : 0 : OpenHeaderRows();
1368 : : }
1369 : : }
1370 : 4 : nOpenRow = -1;
1371 : 4 : }
1372 : :
1373 : 4 : void ScXMLExport::ExportFormatRanges(const sal_Int32 nStartCol, const sal_Int32 nStartRow,
1374 : : const sal_Int32 nEndCol, const sal_Int32 nEndRow, const sal_Int32 nSheet)
1375 : : {
1376 [ + - ]: 4 : pRowFormatRanges->Clear();
1377 [ + - ]: 4 : ScXMLCachedRowAttrAccess aRowAttr(pDoc);
1378 [ + - ]: 4 : if (nStartRow == nEndRow)
1379 : : {
1380 [ + - ]: 4 : pCellStyles->GetFormatRanges(nStartCol, nEndCol, nStartRow, nSheet, pRowFormatRanges);
1381 [ + - ]: 4 : if (nOpenRow == - 1)
1382 [ + - ]: 4 : OpenRow(nSheet, nStartRow, 1, aRowAttr);
1383 [ + - ]: 4 : WriteRowContent();
1384 [ + - ]: 4 : pRowFormatRanges->Clear();
1385 : : }
1386 : : else
1387 : : {
1388 [ # # ]: 0 : if (nOpenRow > -1)
1389 : : {
1390 [ # # ][ # # ]: 0 : pCellStyles->GetFormatRanges(nStartCol, pSharedData->GetLastColumn(nSheet), nStartRow, nSheet, pRowFormatRanges);
1391 [ # # ]: 0 : WriteRowContent();
1392 [ # # ]: 0 : CloseRow(nStartRow);
1393 : 0 : sal_Int32 nRows(1);
1394 : 0 : sal_Int32 nTotalRows(nEndRow - nStartRow + 1 - 1);
1395 [ # # ]: 0 : while (nRows < nTotalRows)
1396 : : {
1397 [ # # ]: 0 : pRowFormatRanges->Clear();
1398 [ # # ][ # # ]: 0 : pCellStyles->GetFormatRanges(0, pSharedData->GetLastColumn(nSheet), nStartRow + nRows, nSheet, pRowFormatRanges);
1399 [ # # ]: 0 : sal_Int32 nMaxRows = pRowFormatRanges->GetMaxRows();
1400 : : OSL_ENSURE(nMaxRows, "something wents wrong");
1401 [ # # ]: 0 : if (nMaxRows >= nTotalRows - nRows)
1402 : : {
1403 [ # # ]: 0 : OpenRow(nSheet, nStartRow + nRows, nTotalRows - nRows, aRowAttr);
1404 : 0 : nRows += nTotalRows - nRows;
1405 : : }
1406 : : else
1407 : : {
1408 [ # # ]: 0 : OpenRow(nSheet, nStartRow + nRows, nMaxRows, aRowAttr);
1409 : 0 : nRows += nMaxRows;
1410 : : }
1411 [ # # ][ # # ]: 0 : if (!pRowFormatRanges->GetSize())
1412 [ # # ][ # # ]: 0 : pCellStyles->GetFormatRanges(0, pSharedData->GetLastColumn(nSheet), nStartRow + nRows, nSheet, pRowFormatRanges);
1413 [ # # ]: 0 : WriteRowContent();
1414 [ # # ]: 0 : CloseRow(nStartRow + nRows - 1);
1415 : : }
1416 [ # # ]: 0 : if (nTotalRows == 1)
1417 [ # # ]: 0 : CloseRow(nStartRow);
1418 [ # # ]: 0 : OpenRow(nSheet, nEndRow, 1, aRowAttr);
1419 [ # # ]: 0 : pRowFormatRanges->Clear();
1420 [ # # ]: 0 : pCellStyles->GetFormatRanges(0, nEndCol, nEndRow, nSheet, pRowFormatRanges);
1421 [ # # ]: 0 : WriteRowContent();
1422 : : }
1423 : : else
1424 : : {
1425 : 0 : sal_Int32 nRows(0);
1426 : 0 : sal_Int32 nTotalRows(nEndRow - nStartRow + 1 - 1);
1427 [ # # ]: 0 : while (nRows < nTotalRows)
1428 : : {
1429 [ # # ][ # # ]: 0 : pCellStyles->GetFormatRanges(0, pSharedData->GetLastColumn(nSheet), nStartRow + nRows, nSheet, pRowFormatRanges);
1430 [ # # ]: 0 : sal_Int32 nMaxRows = pRowFormatRanges->GetMaxRows();
1431 [ # # ]: 0 : if (nMaxRows >= nTotalRows - nRows)
1432 : : {
1433 [ # # ]: 0 : OpenRow(nSheet, nStartRow + nRows, nTotalRows - nRows, aRowAttr);
1434 : 0 : nRows += nTotalRows - nRows;
1435 : : }
1436 : : else
1437 : : {
1438 [ # # ]: 0 : OpenRow(nSheet, nStartRow + nRows, nMaxRows, aRowAttr);
1439 : 0 : nRows += nMaxRows;
1440 : : }
1441 [ # # ][ # # ]: 0 : if (!pRowFormatRanges->GetSize())
1442 [ # # ][ # # ]: 0 : pCellStyles->GetFormatRanges(0, pSharedData->GetLastColumn(nSheet), nStartRow + nRows, nSheet, pRowFormatRanges);
1443 [ # # ]: 0 : WriteRowContent();
1444 [ # # ]: 0 : CloseRow(nStartRow + nRows - 1);
1445 : : }
1446 [ # # ]: 0 : OpenRow(nSheet, nEndRow, 1, aRowAttr);
1447 [ # # ]: 0 : pRowFormatRanges->Clear();
1448 [ # # ]: 0 : pCellStyles->GetFormatRanges(0, nEndCol, nEndRow, nSheet, pRowFormatRanges);
1449 [ # # ]: 0 : WriteRowContent();
1450 : : }
1451 : : }
1452 : 4 : }
1453 : :
1454 : 4 : void ScXMLExport::GetColumnRowHeader(bool& rHasColumnHeader, table::CellRangeAddress& rColumnHeaderRange,
1455 : : bool& rHasRowHeader, table::CellRangeAddress& rRowHeaderRange,
1456 : : rtl::OUString& rPrintRanges) const
1457 : : {
1458 [ + - ]: 4 : uno::Reference <sheet::XPrintAreas> xPrintAreas (xCurrentTable, uno::UNO_QUERY);
1459 [ + - ]: 4 : if (xPrintAreas.is())
1460 : : {
1461 [ + - ][ + - ]: 4 : rHasRowHeader = xPrintAreas->getPrintTitleRows();
1462 [ + - ][ + - ]: 4 : rHasColumnHeader = xPrintAreas->getPrintTitleColumns();
1463 [ + - ][ + - ]: 4 : rRowHeaderRange = xPrintAreas->getTitleRows();
1464 [ + - ][ + - ]: 4 : rColumnHeaderRange = xPrintAreas->getTitleColumns();
1465 [ + - ][ + - ]: 4 : uno::Sequence< table::CellRangeAddress > aRangeList( xPrintAreas->getPrintAreas() );
1466 [ + - ][ + - ]: 4 : ScRangeStringConverter::GetStringFromRangeList( rPrintRanges, aRangeList, pDoc, FormulaGrammar::CONV_OOO );
1467 : 4 : }
1468 : 4 : }
1469 : :
1470 : 0 : void ScXMLExport::FillFieldGroup(ScOutlineArray* pFields, ScMyOpenCloseColumnRowGroup* pGroups)
1471 : : {
1472 : 0 : size_t nDepth = pFields->GetDepth();
1473 [ # # ]: 0 : for (size_t i = 0; i < nDepth; ++i)
1474 : : {
1475 : 0 : size_t nFields = pFields->GetCount(i);
1476 [ # # ]: 0 : for (size_t j = 0; j < nFields; ++j)
1477 : : {
1478 [ # # ]: 0 : ScMyColumnRowGroup aGroup;
1479 [ # # ]: 0 : const ScOutlineEntry* pEntry = pFields->GetEntry(i, j);
1480 [ # # ]: 0 : aGroup.nField = pEntry->GetStart();
1481 : 0 : aGroup.nLevel = static_cast<sal_Int16>(i);
1482 [ # # ]: 0 : aGroup.bDisplay = !(pEntry->IsHidden());
1483 [ # # ][ # # ]: 0 : pGroups->AddGroup(aGroup, pEntry->GetEnd());
1484 : : }
1485 : : }
1486 [ # # ]: 0 : if (nDepth)
1487 : 0 : pGroups->Sort();
1488 : 0 : }
1489 : :
1490 : 4 : void ScXMLExport::FillColumnRowGroups()
1491 : : {
1492 [ + - ]: 4 : if (pDoc)
1493 : : {
1494 : 4 : ScOutlineTable* pOutlineTable = pDoc->GetOutlineTable( static_cast<SCTAB>(nCurrentTable), false );
1495 [ - + ]: 4 : if(pOutlineTable)
1496 : : {
1497 : 0 : ScOutlineArray* pCols(pOutlineTable->GetColArray());
1498 : 0 : ScOutlineArray* pRows(pOutlineTable->GetRowArray());
1499 [ # # ]: 0 : if (pCols)
1500 : 0 : FillFieldGroup(pCols, pGroupColumns);
1501 [ # # ]: 0 : if (pRows)
1502 : 0 : FillFieldGroup(pRows, pGroupRows);
1503 : 0 : pSharedData->SetLastColumn(nCurrentTable, pGroupColumns->GetLast());
1504 : 0 : pSharedData->SetLastRow(nCurrentTable, pGroupRows->GetLast());
1505 : : }
1506 : : }
1507 : 4 : }
1508 : :
1509 : 4 : void ScXMLExport::SetBodyAttributes()
1510 : : {
1511 [ + - ][ - + ]: 4 : if (pDoc && pDoc->IsDocProtected())
[ - + ]
1512 : : {
1513 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_STRUCTURE_PROTECTED, XML_TRUE);
1514 : 0 : rtl::OUStringBuffer aBuffer;
1515 [ # # ]: 0 : uno::Sequence<sal_Int8> aPassHash;
1516 : 0 : ScPasswordHash eHashUsed = PASSHASH_UNSPECIFIED;
1517 [ # # ]: 0 : const ScDocProtection* p = pDoc->GetDocProtection();
1518 [ # # ]: 0 : if (p)
1519 : : {
1520 [ # # ][ # # ]: 0 : if (p->hasPasswordHash(PASSHASH_SHA1))
1521 : : {
1522 [ # # ][ # # ]: 0 : aPassHash = p->getPasswordHash(PASSHASH_SHA1);
[ # # ]
1523 : 0 : eHashUsed = PASSHASH_SHA1;
1524 : : }
1525 [ # # ][ # # ]: 0 : else if (p->hasPasswordHash(PASSHASH_XL, PASSHASH_SHA1))
1526 : : {
1527 [ # # ][ # # ]: 0 : aPassHash = p->getPasswordHash(PASSHASH_XL, PASSHASH_SHA1);
[ # # ]
1528 : 0 : eHashUsed = PASSHASH_XL;
1529 : : }
1530 : : }
1531 [ # # ]: 0 : ::sax::Converter::encodeBase64(aBuffer, aPassHash);
1532 [ # # ]: 0 : if (aBuffer.getLength())
1533 : : {
1534 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY, aBuffer.makeStringAndClear());
1535 [ # # ][ # # ]: 0 : if ( getDefaultVersion() >= SvtSaveOptions::ODFVER_012 )
1536 : : {
1537 [ # # ]: 0 : if (eHashUsed == PASSHASH_XL)
1538 : : {
1539 : : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY_DIGEST_ALGORITHM,
1540 [ # # ][ # # ]: 0 : ScPassHashHelper::getHashURI(PASSHASH_XL));
1541 : : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY_DIGEST_ALGORITHM_2,
1542 [ # # ][ # # ]: 0 : ScPassHashHelper::getHashURI(PASSHASH_SHA1));
1543 : : }
1544 [ # # ]: 0 : else if (eHashUsed == PASSHASH_SHA1)
1545 : : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY_DIGEST_ALGORITHM,
1546 [ # # ][ # # ]: 0 : ScPassHashHelper::getHashURI(PASSHASH_SHA1));
1547 : : }
1548 [ # # ]: 0 : }
1549 : : }
1550 : 4 : }
1551 : :
1552 : 0 : static bool lcl_CopyStreamElement( const uno::Reference< io::XInputStream >& xInput,
1553 : : const uno::Reference< io::XOutputStream >& xOutput,
1554 : : sal_Int32 nCount )
1555 : : {
1556 : 0 : const sal_Int32 nBufSize = 16*1024;
1557 [ # # ]: 0 : uno::Sequence<sal_Int8> aSequence(nBufSize);
1558 : :
1559 : 0 : sal_Int32 nRemaining = nCount;
1560 : 0 : bool bFirst = true;
1561 : :
1562 [ # # ]: 0 : while ( nRemaining > 0 )
1563 : : {
1564 [ # # ][ # # ]: 0 : sal_Int32 nRead = xInput->readBytes( aSequence, std::min( nRemaining, nBufSize ) );
[ # # ]
1565 [ # # ]: 0 : if (bFirst)
1566 : : {
1567 : : // safety check: Make sure the copied part actually points to the start of an element
1568 [ # # ][ # # ]: 0 : if ( nRead < 1 || aSequence[0] != static_cast<sal_Int8>('<') )
[ # # ][ # # ]
1569 : : {
1570 : 0 : return false; // abort and set an error
1571 : : }
1572 : 0 : bFirst = false;
1573 : : }
1574 [ # # ]: 0 : if (nRead == nRemaining)
1575 : : {
1576 : : // safety check: Make sure the copied part also ends at the end of an element
1577 [ # # ][ # # ]: 0 : if ( aSequence[nRead-1] != static_cast<sal_Int8>('>') )
1578 : : {
1579 : 0 : return false; // abort and set an error
1580 : : }
1581 : : }
1582 : :
1583 [ # # ]: 0 : if ( nRead == nBufSize )
1584 : : {
1585 [ # # ][ # # ]: 0 : xOutput->writeBytes( aSequence );
1586 : 0 : nRemaining -= nRead;
1587 : : }
1588 : : else
1589 : : {
1590 [ # # ]: 0 : if ( nRead > 0 )
1591 : : {
1592 [ # # ]: 0 : uno::Sequence<sal_Int8> aTempBuf( aSequence.getConstArray(), nRead );
1593 [ # # ][ # # ]: 0 : xOutput->writeBytes( aTempBuf );
[ # # ]
1594 : : }
1595 : 0 : nRemaining = 0;
1596 : : }
1597 : : }
1598 [ # # ]: 0 : return true; // successful
1599 : : }
1600 : :
1601 : 0 : static void lcl_SkipBytesInBlocks( const uno::Reference< io::XInputStream >& xInput, sal_Int32 nBytesToSkip )
1602 : : {
1603 : : // skipBytes in zip stream is implemented as reading.
1604 : : // For now, split into several calls to avoid allocating a large buffer.
1605 : : // Later, skipBytes should be changed.
1606 : :
1607 : 0 : const sal_Int32 nMaxSize = 32*1024;
1608 : :
1609 [ # # ]: 0 : if ( nBytesToSkip > 0 )
1610 : : {
1611 : 0 : sal_Int32 nRemaining = nBytesToSkip;
1612 [ # # ]: 0 : while ( nRemaining > 0 )
1613 : : {
1614 [ # # ]: 0 : sal_Int32 nSkip = std::min( nRemaining, nMaxSize );
1615 [ # # ][ # # ]: 0 : xInput->skipBytes( nSkip );
1616 : 0 : nRemaining -= nSkip;
1617 : : }
1618 : : }
1619 : 0 : }
1620 : :
1621 : 0 : void ScXMLExport::CopySourceStream( sal_Int32 nStartOffset, sal_Int32 nEndOffset, sal_Int32& rNewStart, sal_Int32& rNewEnd )
1622 : : {
1623 : 0 : uno::Reference<xml::sax::XDocumentHandler> xHandler = GetDocHandler();
1624 [ # # ]: 0 : uno::Reference<io::XActiveDataSource> xDestSource( xHandler, uno::UNO_QUERY );
1625 [ # # ]: 0 : if ( xDestSource.is() )
1626 : : {
1627 [ # # ][ # # ]: 0 : uno::Reference<io::XOutputStream> xDestStream = xDestSource->getOutputStream();
1628 [ # # ]: 0 : uno::Reference<io::XSeekable> xDestSeek( xDestStream, uno::UNO_QUERY );
1629 [ # # ]: 0 : if ( xDestSeek.is() )
1630 : : {
1631 : : // temporary: set same stream again to clear buffer
1632 [ # # ][ # # ]: 0 : xDestSource->setOutputStream( xDestStream );
1633 : :
1634 [ # # ]: 0 : if ( getExportFlags() & EXPORT_PRETTY )
1635 : : {
1636 : 0 : const rtl::OString aOutStr("\n ");
1637 [ # # ]: 0 : uno::Sequence<sal_Int8> aOutSeq( (sal_Int8*)aOutStr.getStr(), aOutStr.getLength() );
1638 [ # # ][ # # ]: 0 : xDestStream->writeBytes( aOutSeq );
[ # # ]
1639 : : }
1640 : :
1641 [ # # ][ # # ]: 0 : rNewStart = (sal_Int32)xDestSeek->getPosition();
1642 : :
1643 [ # # ]: 0 : if ( nStartOffset > nSourceStreamPos )
1644 [ # # ]: 0 : lcl_SkipBytesInBlocks( xSourceStream, nStartOffset - nSourceStreamPos );
1645 : :
1646 [ # # ][ # # ]: 0 : if ( !lcl_CopyStreamElement( xSourceStream, xDestStream, nEndOffset - nStartOffset ) )
1647 : : {
1648 : : // If copying went wrong, set an error.
1649 : : // ScXMLImportWrapper then resets all stream flags, so the next save attempt will use normal saving.
1650 : :
1651 [ # # ]: 0 : uno::Sequence<OUString> aEmptySeq;
1652 [ # # ][ # # ]: 0 : SetError(XMLERROR_CANCEL|XMLERROR_FLAG_SEVERE, aEmptySeq);
1653 : : }
1654 : 0 : nSourceStreamPos = nEndOffset;
1655 : :
1656 [ # # ][ # # ]: 0 : rNewEnd = (sal_Int32)xDestSeek->getPosition();
1657 : 0 : }
1658 : 0 : }
1659 : 0 : }
1660 : :
1661 : 4 : void ScXMLExport::_ExportContent()
1662 : : {
1663 : 4 : nCurrentTable = 0;
1664 [ - + ]: 4 : if (!pSharedData)
1665 : : {
1666 : 0 : sal_Int32 nTableCount(0);
1667 : 0 : sal_Int32 nShapesCount(0);
1668 [ # # ]: 0 : CollectSharedData(nTableCount, nShapesCount);
1669 : : OSL_FAIL("no shared data setted");
1670 : : }
1671 [ + - ]: 4 : ScXMLExportDatabaseRanges aExportDatabaseRanges(*this);
1672 [ - + ]: 4 : if (!GetModel().is())
1673 : : return;
1674 : :
1675 [ + - ]: 4 : uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( GetModel(), uno::UNO_QUERY );
1676 [ - + ]: 4 : if ( !xSpreadDoc.is() )
1677 : : return;
1678 : :
1679 [ + - ][ + - ]: 4 : ScSheetSaveData* pSheetData = ScModelObj::getImplementation(xSpreadDoc)->GetSheetSaveData();
1680 [ + - ]: 4 : if (pSheetData)
1681 [ + - ]: 4 : pSheetData->ResetSaveEntries();
1682 : :
1683 [ + - ][ + - ]: 4 : uno::Reference<container::XIndexAccess> xIndex( xSpreadDoc->getSheets(), uno::UNO_QUERY );
[ + - ]
1684 [ + - ]: 4 : if ( xIndex.is() )
1685 : : {
1686 : : //_GetNamespaceMap().ClearQNamesCache();
1687 [ + - ]: 4 : pChangeTrackingExportHelper->CollectAndWriteChanges();
1688 [ + - ]: 4 : WriteCalculationSettings(xSpreadDoc);
1689 [ + - ][ + - ]: 4 : sal_Int32 nTableCount(xIndex->getCount());
1690 [ + - ]: 4 : ScMyAreaLinksContainer aAreaLinks;
1691 [ + - ]: 4 : GetAreaLinks( xSpreadDoc, aAreaLinks );
1692 [ + - ]: 4 : ScMyEmptyDatabaseRangesContainer aEmptyRanges(aExportDatabaseRanges.GetEmptyDatabaseRanges());
1693 [ + - ]: 4 : ScMyDetectiveOpContainer aDetectiveOpContainer;
1694 [ + - ]: 4 : GetDetectiveOpList( aDetectiveOpContainer );
1695 : :
1696 [ + - ]: 4 : pCellStyles->Sort();
1697 [ + - ]: 4 : pMergedRangesContainer->Sort();
1698 [ + - ]: 4 : pSharedData->GetDetectiveObjContainer()->Sort();
1699 : :
1700 [ + - ]: 4 : pCellsItr->Clear();
1701 : 4 : pCellsItr->SetShapes( pSharedData->GetShapesContainer() );
1702 : 4 : pCellsItr->SetNoteShapes( pSharedData->GetNoteShapes() );
1703 : 4 : pCellsItr->SetMergedRanges( pMergedRangesContainer );
1704 : 4 : pCellsItr->SetAreaLinks( &aAreaLinks );
1705 : 4 : pCellsItr->SetEmptyDatabaseRanges( &aEmptyRanges );
1706 : 4 : pCellsItr->SetDetectiveObj( pSharedData->GetDetectiveObjContainer() );
1707 : 4 : pCellsItr->SetDetectiveOp( &aDetectiveOpContainer );
1708 : :
1709 [ + - ]: 4 : if (nTableCount > 0)
1710 [ + - ]: 4 : pValidationsContainer->WriteValidations(*this);
1711 [ + - ]: 4 : WriteTheLabelRanges( xSpreadDoc );
1712 [ + + ]: 8 : for (sal_Int32 nTable = 0; nTable < nTableCount; ++nTable)
1713 : : {
1714 : 4 : sal_Int32 nStartOffset = -1;
1715 : 4 : sal_Int32 nEndOffset = -1;
1716 [ + - ][ + - ]: 4 : if (pSheetData && pDoc && pDoc->IsStreamValid((SCTAB)nTable) && !pDoc->GetChangeTrack())
[ + - ][ - + ]
[ # # ][ - + ]
1717 [ # # ]: 0 : pSheetData->GetStreamPos( nTable, nStartOffset, nEndOffset );
1718 : :
1719 [ - + ][ # # ]: 4 : if ( nStartOffset >= 0 && nEndOffset >= 0 && xSourceStream.is() )
[ # # ][ - + ]
1720 : : {
1721 : 0 : sal_Int32 nNewStart = -1;
1722 : 0 : sal_Int32 nNewEnd = -1;
1723 [ # # ]: 0 : CopySourceStream( nStartOffset, nEndOffset, nNewStart, nNewEnd );
1724 : :
1725 : : // store position of copied sheet in output
1726 [ # # ]: 0 : pSheetData->AddSavePos( nTable, nNewStart, nNewEnd );
1727 : :
1728 : : // skip iterator entries for this sheet
1729 [ # # ]: 0 : pCellsItr->SkipTable(static_cast<SCTAB>(nTable));
1730 : : }
1731 : : else
1732 : : {
1733 [ + - ][ + - ]: 4 : uno::Reference<sheet::XSpreadsheet> xTable(xIndex->getByIndex(nTable), uno::UNO_QUERY);
[ + - ]
1734 [ + - ]: 4 : WriteTable(nTable, xTable);
1735 : : }
1736 [ + - ]: 4 : IncrementProgressBar(false);
1737 [ + - ][ + - ]: 4 : }
[ + - ]
1738 : : }
1739 [ + - ]: 4 : WriteExternalRefCaches();
1740 [ + - ]: 4 : WriteNamedExpressions();
1741 [ + - ]: 4 : aExportDatabaseRanges.WriteDatabaseRanges();
1742 [ + - ]: 4 : ScXMLExportDataPilot aExportDataPilot(*this);
1743 [ + - ]: 4 : aExportDataPilot.WriteDataPilots(xSpreadDoc);
1744 [ + - ]: 4 : WriteConsolidation();
1745 [ + - ]: 4 : ScXMLExportDDELinks aExportDDELinks(*this);
1746 [ + - ]: 4 : aExportDDELinks.WriteDDELinks(xSpreadDoc);
1747 [ + - ]: 4 : IncrementProgressBar(true, 0);
1748 [ + - ][ + - ]: 4 : GetProgressBarHelper()->SetValue(GetProgressBarHelper()->GetReference());
[ + - ][ + - ]
[ + - ][ - + ]
[ + - ][ + - ]
1749 : : }
1750 : :
1751 : 4 : void ScXMLExport::_ExportStyles( sal_Bool bUsed )
1752 : : {
1753 [ - + ]: 4 : if (!pSharedData)
1754 : : {
1755 : 0 : sal_Int32 nTableCount(0);
1756 : 0 : sal_Int32 nShapesCount(0);
1757 [ # # ]: 0 : CollectSharedData(nTableCount, nShapesCount);
1758 : : }
1759 [ + - ][ + - ]: 4 : ScXMLStyleExport aStylesExp(*this, rtl::OUString(), GetAutoStylePool().get());
[ + - ]
1760 [ + - ]: 4 : if (GetModel().is())
1761 : : {
1762 [ + - ]: 4 : uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
1763 [ + - ]: 4 : if (xMultiServiceFactory.is())
1764 : : {
1765 [ + - ][ + - ]: 4 : uno::Reference <beans::XPropertySet> xProperties(xMultiServiceFactory->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.Defaults"))), uno::UNO_QUERY);
[ + - ][ + - ]
1766 [ + - ]: 4 : if (xProperties.is())
1767 [ + - ][ + - ]: 4 : aStylesExp.exportDefaultStyle(xProperties, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)), xCellStylesExportPropertySetMapper);
1768 [ + - ][ - + ]: 4 : if (pSharedData->HasShapes())
1769 : : {
1770 [ # # ][ # # ]: 0 : GetShapeExport()->ExportGraphicDefaults();
[ # # ][ # # ]
1771 : 4 : }
1772 : : }
1773 [ + - ]: 4 : uno::Reference <style::XStyleFamiliesSupplier> xStyleFamiliesSupplier (GetModel(), uno::UNO_QUERY);
1774 [ + - ]: 4 : if (xStyleFamiliesSupplier.is())
1775 : : {
1776 [ + - ][ + - ]: 4 : uno::Reference <container::XNameAccess> xStylesFamilies(xStyleFamiliesSupplier->getStyleFamilies());
1777 [ + - ]: 4 : if (xStylesFamilies.is())
1778 : : {
1779 [ + - ][ + - ]: 4 : uno::Reference <container::XIndexAccess> xCellStyles(xStylesFamilies->getByName(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CellStyles"))), uno::UNO_QUERY);
[ + - ][ + - ]
1780 [ + - ]: 4 : if (xCellStyles.is())
1781 : : {
1782 [ + - ][ + - ]: 4 : sal_Int32 nCount(xCellStyles->getCount());
1783 [ + - ]: 4 : rtl::OUString sNumberFormat(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_NUMFMT));
1784 [ + + ]: 24 : for (sal_Int32 i = 0; i < nCount; ++i)
1785 : : {
1786 [ + - ][ + - ]: 20 : uno::Reference <beans::XPropertySet> xCellProperties(xCellStyles->getByIndex(i), uno::UNO_QUERY);
[ + - ]
1787 [ + - ]: 20 : if (xCellProperties.is())
1788 : : {
1789 : 20 : sal_Int32 nNumberFormat = 0;
1790 [ + - ][ + - ]: 20 : if (xCellProperties->getPropertyValue(sNumberFormat) >>= nNumberFormat)
[ + - ]
1791 [ + - ]: 20 : addDataStyle(nNumberFormat);
1792 : : }
1793 : 24 : }
1794 : 4 : }
1795 : 4 : }
1796 : 4 : }
1797 : : }
1798 [ + - ]: 4 : exportDataStyles();
1799 : :
1800 : : aStylesExp.exportStyleFamily(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CellStyles")),
1801 [ + - ][ + - ]: 4 : rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)), xCellStylesExportPropertySetMapper, false, XML_STYLE_FAMILY_TABLE_CELL);
[ + - ]
1802 : :
1803 [ + - ][ + - ]: 4 : SvXMLExport::_ExportStyles(bUsed);
1804 : 4 : }
1805 : :
1806 : 4 : void ScXMLExport::AddStyleFromCells(const uno::Reference<beans::XPropertySet>& xProperties,
1807 : : const uno::Reference<sheet::XSpreadsheet>& xTable,
1808 : : sal_Int32 nTable, const rtl::OUString* pOldName)
1809 : : {
1810 : : //! pass xCellRanges instead
1811 [ + - ]: 4 : uno::Reference<sheet::XSheetCellRanges> xCellRanges( xProperties, uno::UNO_QUERY );
1812 : :
1813 [ + - ]: 4 : rtl::OUString SC_SCELLPREFIX(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_PREFIX));
1814 [ + - ]: 4 : rtl::OUString SC_NUMBERFORMAT(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_NUMFMT));
1815 : :
1816 : 4 : rtl::OUString sStyleName;
1817 : 4 : sal_Int32 nNumberFormat(-1);
1818 : 4 : sal_Int32 nValidationIndex(-1);
1819 [ + - ][ + - ]: 4 : std::vector< XMLPropertyState > xPropStates(xCellStylesExportPropertySetMapper->Filter( xProperties ));
1820 : 4 : std::vector< XMLPropertyState >::iterator aItr(xPropStates.begin());
1821 : 4 : std::vector< XMLPropertyState >::iterator aEndItr(xPropStates.end());
1822 : 4 : sal_Int32 nCount(0);
1823 [ + - ][ + + ]: 8 : while (aItr != aEndItr)
1824 : : {
1825 [ + - ]: 4 : if (aItr->mnIndex != -1)
1826 : : {
1827 [ + - ][ + - ]: 4 : switch (xCellStylesPropertySetMapper->GetEntryContextId(aItr->mnIndex))
[ - + - - ]
1828 : : {
1829 : : case CTF_SC_VALIDATION :
1830 : : {
1831 [ # # ]: 0 : pValidationsContainer->AddValidation(aItr->maValue, nValidationIndex);
1832 : : // this is not very slow, because it is most the last property or
1833 : : // if it is not the last property it is the property before the last property,
1834 : : // so in the worst case only one property has to be copied, but in the best case no
1835 : : // property has to be copied
1836 [ # # ]: 0 : aItr = xPropStates.erase(aItr);
1837 : 0 : aEndItr = xPropStates.end(); // old aEndItr is invalidated!
1838 : : }
1839 : 0 : break;
1840 : : case CTF_SC_CELLSTYLE :
1841 : : {
1842 : 4 : aItr->maValue >>= sStyleName;
1843 : 4 : aItr->mnIndex = -1;
1844 : 4 : ++aItr;
1845 : 4 : ++nCount;
1846 : : }
1847 : 4 : break;
1848 : : case CTF_SC_NUMBERFORMAT :
1849 : : {
1850 [ # # ]: 0 : if (aItr->maValue >>= nNumberFormat)
1851 [ # # ]: 0 : addDataStyle(nNumberFormat);
1852 : 0 : ++aItr;
1853 : 0 : ++nCount;
1854 : : }
1855 : 0 : break;
1856 : : default:
1857 : : {
1858 : 0 : ++aItr;
1859 : 0 : ++nCount;
1860 : : }
1861 : 4 : break;
1862 : : }
1863 : : }
1864 : : else
1865 : : {
1866 : 0 : ++aItr;
1867 : 0 : ++nCount;
1868 : : }
1869 : : }
1870 [ + - ]: 4 : if (nCount == 1) // this is the CellStyle and should be removed if alone
1871 : 4 : xPropStates.clear();
1872 [ + - ]: 4 : if (nNumberFormat == -1)
1873 [ + - ][ + - ]: 4 : xProperties->getPropertyValue(SC_NUMBERFORMAT) >>= nNumberFormat;
1874 [ + - ]: 4 : if (!sStyleName.isEmpty())
1875 : : {
1876 [ - + ]: 4 : if (!xPropStates.empty())
1877 : : {
1878 : : sal_Int32 nIndex;
1879 [ # # ]: 0 : if (pOldName)
1880 : : {
1881 [ # # ][ # # ]: 0 : if (GetAutoStylePool()->AddNamed(*pOldName, XML_STYLE_FAMILY_TABLE_CELL, sStyleName, xPropStates))
[ # # ][ # # ]
[ # # ]
1882 : : {
1883 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_CELL, *pOldName);
[ # # ][ # # ]
1884 : : // add to pCellStyles, so the name is found for normal sheets
1885 [ # # ]: 0 : rtl::OUString* pTemp(new rtl::OUString(*pOldName));
1886 [ # # ][ # # ]: 0 : if (!pCellStyles->AddStyleName(pTemp, nIndex))
1887 [ # # ]: 0 : delete pTemp;
1888 : : }
1889 : : }
1890 : : else
1891 : : {
1892 : 0 : rtl::OUString sName;
1893 : 0 : bool bIsAutoStyle(true);
1894 [ # # ][ # # ]: 0 : if (GetAutoStylePool()->Add(sName, XML_STYLE_FAMILY_TABLE_CELL, sStyleName, xPropStates))
[ # # ][ # # ]
[ # # ]
1895 : : {
1896 [ # # ]: 0 : rtl::OUString* pTemp(new rtl::OUString(sName));
1897 [ # # ][ # # ]: 0 : if (!pCellStyles->AddStyleName(pTemp, nIndex))
1898 [ # # ]: 0 : delete pTemp;
1899 : : }
1900 : : else
1901 [ # # ]: 0 : nIndex = pCellStyles->GetIndexOfStyleName(sName, SC_SCELLPREFIX, bIsAutoStyle);
1902 : :
1903 [ # # ][ # # ]: 0 : uno::Sequence<table::CellRangeAddress> aAddresses(xCellRanges->getRangeAddresses());
1904 [ # # ]: 0 : table::CellRangeAddress* pAddresses(aAddresses.getArray());
1905 : 0 : bool bGetMerge(true);
1906 [ # # ]: 0 : for (sal_Int32 i = 0; i < aAddresses.getLength(); ++i, ++pAddresses)
1907 : : {
1908 [ # # ]: 0 : pSharedData->SetLastColumn(nTable, pAddresses->EndColumn);
1909 [ # # ]: 0 : pSharedData->SetLastRow(nTable, pAddresses->EndRow);
1910 [ # # ]: 0 : pCellStyles->AddRangeStyleName(*pAddresses, nIndex, bIsAutoStyle, nValidationIndex, nNumberFormat);
1911 [ # # ]: 0 : if (bGetMerge)
1912 [ # # ]: 0 : bGetMerge = GetMerged(pAddresses, xTable);
1913 [ # # ]: 0 : }
1914 : : }
1915 : : }
1916 : : else
1917 : : {
1918 [ + - ][ + - ]: 4 : rtl::OUString* pTemp(new rtl::OUString(EncodeStyleName(sStyleName)));
1919 : 4 : sal_Int32 nIndex(0);
1920 [ + - ][ - + ]: 4 : if (!pCellStyles->AddStyleName(pTemp, nIndex, false))
1921 : : {
1922 [ # # ]: 0 : delete pTemp;
1923 : 0 : pTemp = NULL;
1924 : : }
1925 [ + - ]: 4 : if ( !pOldName )
1926 : : {
1927 [ + - ][ + - ]: 4 : uno::Sequence<table::CellRangeAddress> aAddresses(xCellRanges->getRangeAddresses());
1928 [ + - ]: 4 : table::CellRangeAddress* pAddresses(aAddresses.getArray());
1929 : 4 : bool bGetMerge(true);
1930 [ + + ]: 8 : for (sal_Int32 i = 0; i < aAddresses.getLength(); ++i, ++pAddresses)
1931 : : {
1932 [ + - ]: 4 : if (bGetMerge)
1933 [ + - ]: 4 : bGetMerge = GetMerged(pAddresses, xTable);
1934 [ + - ]: 4 : pCellStyles->AddRangeStyleName(*pAddresses, nIndex, false, nValidationIndex, nNumberFormat);
1935 [ + - ][ - + ]: 4 : if (!sStyleName.equalsAsciiL("Default", 7) || nValidationIndex != -1)
[ - + ]
1936 : : {
1937 [ # # ]: 0 : pSharedData->SetLastColumn(nTable, pAddresses->EndColumn);
1938 [ # # ]: 0 : pSharedData->SetLastRow(nTable, pAddresses->EndRow);
1939 : : }
1940 [ + - ]: 4 : }
1941 : : }
1942 : : }
1943 : 4 : }
1944 : 4 : }
1945 : :
1946 : 4 : void ScXMLExport::AddStyleFromColumn(const uno::Reference<beans::XPropertySet>& xColumnProperties,
1947 : : const rtl::OUString* pOldName, sal_Int32& rIndex, bool& rIsVisible)
1948 : : {
1949 [ + - ]: 4 : rtl::OUString SC_SCOLUMNPREFIX(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_PREFIX));
1950 : :
1951 [ + - ][ + - ]: 4 : std::vector<XMLPropertyState> xPropStates(xColumnStylesExportPropertySetMapper->Filter(xColumnProperties));
1952 [ + - ]: 4 : if(!xPropStates.empty())
1953 : : {
1954 : 4 : std::vector< XMLPropertyState >::iterator aItr(xPropStates.begin());
1955 : 4 : std::vector< XMLPropertyState >::iterator aEndItr(xPropStates.end());
1956 [ + - ][ + - ]: 8 : while (aItr != aEndItr)
1957 : : {
1958 [ + - ][ + - ]: 8 : if (xColumnStylesPropertySetMapper->GetEntryContextId(aItr->mnIndex) == CTF_SC_ISVISIBLE)
[ + + ]
1959 : : {
1960 : 4 : aItr->maValue >>= rIsVisible;
1961 : 4 : break;
1962 : : }
1963 : 4 : ++aItr;
1964 : : }
1965 : :
1966 : 4 : rtl::OUString sParent;
1967 [ - + ]: 4 : if (pOldName)
1968 : : {
1969 [ # # ][ # # ]: 0 : if (GetAutoStylePool()->AddNamed(*pOldName, XML_STYLE_FAMILY_TABLE_COLUMN, sParent, xPropStates))
[ # # ][ # # ]
[ # # ]
1970 : : {
1971 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_COLUMN, *pOldName);
[ # # ][ # # ]
1972 : : // add to pColumnStyles, so the name is found for normal sheets
1973 [ # # ]: 0 : rtl::OUString* pTemp(new rtl::OUString(*pOldName));
1974 [ # # ]: 0 : rIndex = pColumnStyles->AddStyleName(pTemp);
1975 : : }
1976 : : }
1977 : : else
1978 : : {
1979 : 4 : rtl::OUString sName;
1980 [ + - ][ + - ]: 4 : if (GetAutoStylePool()->Add(sName, XML_STYLE_FAMILY_TABLE_COLUMN, sParent, xPropStates))
[ + - ][ + - ]
[ + - ]
1981 : : {
1982 [ + - ]: 4 : rtl::OUString* pTemp(new rtl::OUString(sName));
1983 [ + - ]: 4 : rIndex = pColumnStyles->AddStyleName(pTemp);
1984 : : }
1985 : : else
1986 [ # # ]: 4 : rIndex = pColumnStyles->GetIndexOfStyleName(sName, SC_SCOLUMNPREFIX);
1987 : 4 : }
1988 : 4 : }
1989 : 4 : }
1990 : :
1991 : 4 : void ScXMLExport::AddStyleFromRow(const uno::Reference<beans::XPropertySet>& xRowProperties,
1992 : : const rtl::OUString* pOldName, sal_Int32& rIndex)
1993 : : {
1994 [ + - ]: 4 : rtl::OUString SC_SROWPREFIX(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_PREFIX));
1995 : :
1996 [ + - ][ + - ]: 4 : std::vector<XMLPropertyState> xPropStates(xRowStylesExportPropertySetMapper->Filter(xRowProperties));
1997 [ + - ]: 4 : if(!xPropStates.empty())
1998 : : {
1999 : 4 : rtl::OUString sParent;
2000 [ - + ]: 4 : if (pOldName)
2001 : : {
2002 [ # # ][ # # ]: 0 : if (GetAutoStylePool()->AddNamed(*pOldName, XML_STYLE_FAMILY_TABLE_ROW, sParent, xPropStates))
[ # # ][ # # ]
[ # # ]
2003 : : {
2004 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_ROW, *pOldName);
[ # # ][ # # ]
2005 : : // add to pRowStyles, so the name is found for normal sheets
2006 [ # # ]: 0 : rtl::OUString* pTemp(new rtl::OUString(*pOldName));
2007 [ # # ]: 0 : rIndex = pRowStyles->AddStyleName(pTemp);
2008 : : }
2009 : : }
2010 : : else
2011 : : {
2012 : 4 : rtl::OUString sName;
2013 [ + - ][ + - ]: 4 : if (GetAutoStylePool()->Add(sName, XML_STYLE_FAMILY_TABLE_ROW, sParent, xPropStates))
[ + - ][ + - ]
[ + - ]
2014 : : {
2015 [ + - ]: 4 : rtl::OUString* pTemp(new rtl::OUString(sName));
2016 [ + - ]: 4 : rIndex = pRowStyles->AddStyleName(pTemp);
2017 : : }
2018 : : else
2019 [ # # ]: 4 : rIndex = pRowStyles->GetIndexOfStyleName(sName, SC_SROWPREFIX);
2020 : 4 : }
2021 : 4 : }
2022 : 4 : }
2023 : :
2024 : 0 : uno::Any lcl_GetEnumerated( uno::Reference<container::XEnumerationAccess> xEnumAccess, sal_Int32 nIndex )
2025 : : {
2026 : 0 : uno::Any aRet;
2027 [ # # ][ # # ]: 0 : uno::Reference<container::XEnumeration> xEnum( xEnumAccess->createEnumeration() );
2028 : : try
2029 : : {
2030 : 0 : sal_Int32 nSkip = nIndex;
2031 [ # # ]: 0 : while ( nSkip > 0 )
2032 : : {
2033 [ # # ][ # # ]: 0 : (void) xEnum->nextElement();
2034 : 0 : --nSkip;
2035 : : }
2036 [ # # ][ # # ]: 0 : aRet = xEnum->nextElement();
2037 : : }
2038 [ # # ]: 0 : catch (container::NoSuchElementException&)
2039 : : {
2040 : : // leave aRet empty
2041 : : }
2042 [ # # ]: 0 : return aRet;
2043 : : }
2044 : :
2045 : 8 : void ScXMLExport::_ExportAutoStyles()
2046 : : {
2047 [ + - ]: 8 : if (!GetModel().is())
2048 : : return;
2049 : :
2050 [ + - ]: 8 : Reference <sheet::XSpreadsheetDocument> xSpreadDoc( GetModel(), uno::UNO_QUERY );
2051 [ - + ]: 8 : if (!xSpreadDoc.is())
2052 : : return;
2053 : :
2054 [ + - ][ + - ]: 8 : Reference<container::XIndexAccess> xIndex( xSpreadDoc->getSheets(), uno::UNO_QUERY );
[ + - ]
2055 [ - + ]: 8 : if (!xIndex.is())
2056 : : return;
2057 : :
2058 [ + + ]: 8 : if (getExportFlags() & EXPORT_CONTENT)
2059 : : {
2060 : : // re-create automatic styles with old names from stored data
2061 [ + - ][ + - ]: 4 : ScSheetSaveData* pSheetData = ScModelObj::getImplementation(xSpreadDoc)->GetSheetSaveData();
2062 [ + - ][ + - ]: 4 : if (pSheetData && pDoc)
2063 : : {
2064 : : // formulas have to be calculated now, to detect changed results
2065 : : // (during normal save, they will be calculated anyway)
2066 [ + - ]: 4 : SCTAB nTabCount = pDoc->GetTableCount();
2067 [ + + ]: 8 : for (SCTAB nTab=0; nTab<nTabCount; ++nTab)
2068 [ + - ][ - + ]: 4 : if (pDoc->IsStreamValid(nTab))
2069 : : {
2070 [ # # ]: 0 : ScCellIterator aIter( pDoc, 0,0,nTab, MAXCOL,MAXROW,nTab );
2071 [ # # ]: 0 : ScBaseCell* pCell = aIter.GetFirst();
2072 [ # # ]: 0 : while (pCell)
2073 : : {
2074 [ # # ]: 0 : if (pCell->GetCellType() == CELLTYPE_FORMULA)
2075 [ # # ][ # # ]: 0 : static_cast<ScFormulaCell*>(pCell)->IsValue(); // interpret if dirty
2076 [ # # ]: 0 : pCell = aIter.GetNext();
2077 : : }
2078 : : }
2079 : :
2080 : : // stored cell styles
2081 : 4 : const std::vector<ScCellStyleEntry>& rCellEntries = pSheetData->GetCellStyles();
2082 : 4 : std::vector<ScCellStyleEntry>::const_iterator aCellIter = rCellEntries.begin();
2083 : 4 : std::vector<ScCellStyleEntry>::const_iterator aCellEnd = rCellEntries.end();
2084 [ + - ][ - + ]: 4 : while (aCellIter != aCellEnd)
2085 : : {
2086 : 0 : ScAddress aPos = aCellIter->maCellPos;
2087 : 0 : sal_Int32 nTable = aPos.Tab();
2088 [ # # ]: 0 : bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
2089 [ # # ]: 0 : if (bCopySheet)
2090 : : {
2091 [ # # ][ # # ]: 0 : Reference <sheet::XSpreadsheet> xTable(xIndex->getByIndex(nTable), uno::UNO_QUERY);
[ # # ]
2092 : : Reference <beans::XPropertySet> xProperties(
2093 [ # # ][ # # ]: 0 : xTable->getCellByPosition( aPos.Col(), aPos.Row() ), uno::UNO_QUERY );
[ # # ]
2094 : :
2095 [ # # ]: 0 : AddStyleFromCells(xProperties, xTable, nTable, &aCellIter->maName);
2096 : : }
2097 : 0 : ++aCellIter;
2098 : : }
2099 : :
2100 : : // stored column styles
2101 : 4 : const std::vector<ScCellStyleEntry>& rColumnEntries = pSheetData->GetColumnStyles();
2102 : 4 : std::vector<ScCellStyleEntry>::const_iterator aColumnIter = rColumnEntries.begin();
2103 : 4 : std::vector<ScCellStyleEntry>::const_iterator aColumnEnd = rColumnEntries.end();
2104 [ + - ][ - + ]: 4 : while (aColumnIter != aColumnEnd)
2105 : : {
2106 : 0 : ScAddress aPos = aColumnIter->maCellPos;
2107 : 0 : sal_Int32 nTable = aPos.Tab();
2108 [ # # ]: 0 : bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
2109 [ # # ]: 0 : if (bCopySheet)
2110 : : {
2111 [ # # ][ # # ]: 0 : Reference<table::XColumnRowRange> xColumnRowRange(xIndex->getByIndex(nTable), uno::UNO_QUERY);
[ # # ]
2112 [ # # ][ # # ]: 0 : Reference<table::XTableColumns> xTableColumns(xColumnRowRange->getColumns());
2113 [ # # ][ # # ]: 0 : Reference<beans::XPropertySet> xColumnProperties(xTableColumns->getByIndex( aPos.Col() ), uno::UNO_QUERY);
[ # # ]
2114 : :
2115 : 0 : sal_Int32 nIndex(-1);
2116 : 0 : bool bIsVisible(true);
2117 [ # # ]: 0 : AddStyleFromColumn( xColumnProperties, &aColumnIter->maName, nIndex, bIsVisible );
2118 : : }
2119 : 0 : ++aColumnIter;
2120 : : }
2121 : :
2122 : : // stored row styles
2123 : 4 : const std::vector<ScCellStyleEntry>& rRowEntries = pSheetData->GetRowStyles();
2124 : 4 : std::vector<ScCellStyleEntry>::const_iterator aRowIter = rRowEntries.begin();
2125 : 4 : std::vector<ScCellStyleEntry>::const_iterator aRowEnd = rRowEntries.end();
2126 [ + - ][ - + ]: 4 : while (aRowIter != aRowEnd)
2127 : : {
2128 : 0 : ScAddress aPos = aRowIter->maCellPos;
2129 : 0 : sal_Int32 nTable = aPos.Tab();
2130 [ # # ]: 0 : bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
2131 [ # # ]: 0 : if (bCopySheet)
2132 : : {
2133 [ # # ][ # # ]: 0 : Reference<table::XColumnRowRange> xColumnRowRange(xIndex->getByIndex(nTable), uno::UNO_QUERY);
[ # # ]
2134 [ # # ][ # # ]: 0 : Reference<table::XTableRows> xTableRows(xColumnRowRange->getRows());
2135 [ # # ][ # # ]: 0 : Reference<beans::XPropertySet> xRowProperties(xTableRows->getByIndex( aPos.Row() ), uno::UNO_QUERY);
[ # # ]
2136 : :
2137 : 0 : sal_Int32 nIndex(-1);
2138 [ # # ]: 0 : AddStyleFromRow( xRowProperties, &aRowIter->maName, nIndex );
2139 : : }
2140 : 0 : ++aRowIter;
2141 : : }
2142 : :
2143 : : // stored table styles
2144 : 4 : const std::vector<ScCellStyleEntry>& rTableEntries = pSheetData->GetTableStyles();
2145 : 4 : std::vector<ScCellStyleEntry>::const_iterator aTableIter = rTableEntries.begin();
2146 : 4 : std::vector<ScCellStyleEntry>::const_iterator aTableEnd = rTableEntries.end();
2147 [ + - ][ - + ]: 4 : while (aTableIter != aTableEnd)
2148 : : {
2149 : 0 : ScAddress aPos = aTableIter->maCellPos;
2150 : 0 : sal_Int32 nTable = aPos.Tab();
2151 [ # # ]: 0 : bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
2152 [ # # ]: 0 : if (bCopySheet)
2153 : : {
2154 : : //! separate method AddStyleFromTable needed?
2155 [ # # ][ # # ]: 0 : Reference<beans::XPropertySet> xTableProperties(xIndex->getByIndex(nTable), uno::UNO_QUERY);
[ # # ]
2156 [ # # ]: 0 : if (xTableProperties.is())
2157 : : {
2158 [ # # ][ # # ]: 0 : std::vector<XMLPropertyState> xPropStates(xTableStylesExportPropertySetMapper->Filter(xTableProperties));
2159 : 0 : rtl::OUString sParent;
2160 : 0 : rtl::OUString sName( aTableIter->maName );
2161 [ # # ][ # # ]: 0 : GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TABLE_TABLE, sParent, xPropStates);
[ # # ][ # # ]
2162 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_TABLE, sName);
[ # # ][ # # ]
2163 : 0 : }
2164 : : }
2165 : 0 : ++aTableIter;
2166 : : }
2167 : :
2168 : : // stored styles for notes
2169 : :
2170 [ + - ][ + - ]: 4 : UniReference<SvXMLExportPropertyMapper> xShapeMapper = XMLShapeExport::CreateShapePropMapper( *this );
2171 [ + - ][ + - ]: 4 : GetShapeExport(); // make sure the graphics styles family is added
2172 : :
2173 : 4 : const std::vector<ScNoteStyleEntry>& rNoteEntries = pSheetData->GetNoteStyles();
2174 : 4 : std::vector<ScNoteStyleEntry>::const_iterator aNoteIter = rNoteEntries.begin();
2175 : 4 : std::vector<ScNoteStyleEntry>::const_iterator aNoteEnd = rNoteEntries.end();
2176 [ + - ][ - + ]: 4 : while (aNoteIter != aNoteEnd)
2177 : : {
2178 : 0 : ScAddress aPos = aNoteIter->maCellPos;
2179 : 0 : SCTAB nTable = aPos.Tab();
2180 [ # # ]: 0 : bool bCopySheet = pDoc->IsStreamValid( nTable );
2181 [ # # ]: 0 : if (bCopySheet)
2182 : : {
2183 : : //! separate method AddStyleFromNote needed?
2184 : :
2185 [ # # ][ # # ]: 0 : ScPostIt* pNote = pDoc->GetNotes( nTable )->findByAddress(aPos);
2186 : : OSL_ENSURE( pNote, "note not found" );
2187 [ # # ]: 0 : if (pNote)
2188 : : {
2189 [ # # ]: 0 : SdrCaptionObj* pDrawObj = pNote->GetOrCreateCaption( aPos );
2190 : : // all uno shapes are created anyway in CollectSharedData
2191 [ # # ][ # # ]: 0 : Reference<beans::XPropertySet> xShapeProperties( pDrawObj->getUnoShape(), uno::UNO_QUERY );
2192 [ # # ]: 0 : if (xShapeProperties.is())
2193 : : {
2194 [ # # ]: 0 : if ( !aNoteIter->maStyleName.isEmpty() )
2195 : : {
2196 [ # # ][ # # ]: 0 : std::vector<XMLPropertyState> xPropStates(xShapeMapper->Filter(xShapeProperties));
2197 : 0 : rtl::OUString sParent;
2198 : 0 : rtl::OUString sName( aNoteIter->maStyleName );
2199 [ # # ][ # # ]: 0 : GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_SD_GRAPHICS_ID, sParent, xPropStates);
[ # # ][ # # ]
2200 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_SD_GRAPHICS_ID, sName);
[ # # ][ # # ]
2201 : : }
2202 [ # # ]: 0 : if ( !aNoteIter->maTextStyle.isEmpty() )
2203 : : {
2204 : : std::vector<XMLPropertyState> xPropStates(
2205 [ # # ][ # # ]: 0 : GetTextParagraphExport()->GetParagraphPropertyMapper()->Filter(xShapeProperties));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2206 : 0 : rtl::OUString sParent;
2207 : 0 : rtl::OUString sName( aNoteIter->maTextStyle );
2208 [ # # ][ # # ]: 0 : GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TEXT_PARAGRAPH, sParent, xPropStates);
[ # # ][ # # ]
2209 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TEXT_PARAGRAPH, sName);
[ # # ][ # # ]
2210 : : }
2211 : 0 : }
2212 : : }
2213 : : }
2214 : 0 : ++aNoteIter;
2215 : : }
2216 : :
2217 : : // note paragraph styles
2218 : :
2219 [ + - ][ + - ]: 4 : UniReference<SvXMLExportPropertyMapper> xParaPropMapper = GetTextParagraphExport()->GetParagraphPropertyMapper();
[ + - ][ + - ]
2220 : :
2221 : 4 : const std::vector<ScTextStyleEntry>& rNoteParaEntries = pSheetData->GetNoteParaStyles();
2222 : 4 : std::vector<ScTextStyleEntry>::const_iterator aNoteParaIter = rNoteParaEntries.begin();
2223 : 4 : std::vector<ScTextStyleEntry>::const_iterator aNoteParaEnd = rNoteParaEntries.end();
2224 [ + - ][ - + ]: 4 : while (aNoteParaIter != aNoteParaEnd)
2225 : : {
2226 : 0 : ScAddress aPos = aNoteParaIter->maCellPos;
2227 : 0 : SCTAB nTable = aPos.Tab();
2228 [ # # ]: 0 : bool bCopySheet = pDoc->IsStreamValid( nTable );
2229 [ # # ]: 0 : if (bCopySheet)
2230 : : {
2231 [ # # ][ # # ]: 0 : ScPostIt* pNote = pDoc->GetNotes(nTable)->findByAddress( aPos );
2232 : : OSL_ENSURE( pNote, "note not found" );
2233 [ # # ]: 0 : if (pNote)
2234 : : {
2235 [ # # ]: 0 : SdrCaptionObj* pDrawObj = pNote->GetOrCreateCaption( aPos );
2236 [ # # ][ # # ]: 0 : Reference<container::XEnumerationAccess> xCellText(pDrawObj->getUnoShape(), uno::UNO_QUERY);
2237 : : Reference<beans::XPropertySet> xParaProp(
2238 [ # # ][ # # ]: 0 : lcl_GetEnumerated( xCellText, aNoteParaIter->maSelection.nStartPara ), uno::UNO_QUERY );
2239 [ # # ]: 0 : if ( xParaProp.is() )
2240 : : {
2241 [ # # ][ # # ]: 0 : std::vector<XMLPropertyState> xPropStates(xParaPropMapper->Filter(xParaProp));
2242 : 0 : rtl::OUString sParent;
2243 : 0 : rtl::OUString sName( aNoteParaIter->maName );
2244 [ # # ][ # # ]: 0 : GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TEXT_PARAGRAPH, sParent, xPropStates);
[ # # ][ # # ]
2245 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TEXT_PARAGRAPH, sName);
[ # # ][ # # ]
2246 : 0 : }
2247 : : }
2248 : : }
2249 : 0 : ++aNoteParaIter;
2250 : : }
2251 : :
2252 : : // note text styles
2253 : :
2254 [ + - ][ + - ]: 4 : UniReference<SvXMLExportPropertyMapper> xTextPropMapper = XMLTextParagraphExport::CreateCharExtPropMapper( *this );
2255 : :
2256 : 4 : const std::vector<ScTextStyleEntry>& rNoteTextEntries = pSheetData->GetNoteTextStyles();
2257 : 4 : std::vector<ScTextStyleEntry>::const_iterator aNoteTextIter = rNoteTextEntries.begin();
2258 : 4 : std::vector<ScTextStyleEntry>::const_iterator aNoteTextEnd = rNoteTextEntries.end();
2259 [ + - ][ - + ]: 4 : while (aNoteTextIter != aNoteTextEnd)
2260 : : {
2261 : 0 : ScAddress aPos = aNoteTextIter->maCellPos;
2262 : 0 : SCTAB nTable = aPos.Tab();
2263 [ # # ]: 0 : bool bCopySheet = pDoc->IsStreamValid( nTable );
2264 [ # # ]: 0 : if (bCopySheet)
2265 : : {
2266 [ # # ][ # # ]: 0 : ScPostIt* pNote = pDoc->GetNotes(nTable)->findByAddress( aPos );
2267 : : OSL_ENSURE( pNote, "note not found" );
2268 [ # # ]: 0 : if (pNote)
2269 : : {
2270 [ # # ]: 0 : SdrCaptionObj* pDrawObj = pNote->GetOrCreateCaption( aPos );
2271 [ # # ][ # # ]: 0 : Reference<text::XSimpleText> xCellText(pDrawObj->getUnoShape(), uno::UNO_QUERY);
2272 [ # # ][ # # ]: 0 : Reference<beans::XPropertySet> xCursorProp(xCellText->createTextCursor(), uno::UNO_QUERY);
[ # # ]
2273 [ # # ]: 0 : ScDrawTextCursor* pCursor = ScDrawTextCursor::getImplementation( xCursorProp );
2274 [ # # ]: 0 : if (pCursor)
2275 : : {
2276 : 0 : pCursor->SetSelection( aNoteTextIter->maSelection );
2277 : :
2278 [ # # ][ # # ]: 0 : std::vector<XMLPropertyState> xPropStates(xTextPropMapper->Filter(xCursorProp));
2279 : 0 : rtl::OUString sParent;
2280 : 0 : rtl::OUString sName( aNoteTextIter->maName );
2281 [ # # ][ # # ]: 0 : GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TEXT_TEXT, sParent, xPropStates);
[ # # ][ # # ]
2282 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TEXT_TEXT, sName);
[ # # ][ # # ]
2283 : 0 : }
2284 : : }
2285 : : }
2286 : 0 : ++aNoteTextIter;
2287 : : }
2288 : :
2289 : : // stored text styles
2290 : :
2291 : 4 : const std::vector<ScTextStyleEntry>& rTextEntries = pSheetData->GetTextStyles();
2292 : 4 : std::vector<ScTextStyleEntry>::const_iterator aTextIter = rTextEntries.begin();
2293 : 4 : std::vector<ScTextStyleEntry>::const_iterator aTextEnd = rTextEntries.end();
2294 [ + - ][ - + ]: 4 : while (aTextIter != aTextEnd)
2295 : : {
2296 : 0 : ScAddress aPos = aTextIter->maCellPos;
2297 : 0 : sal_Int32 nTable = aPos.Tab();
2298 [ # # ]: 0 : bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
2299 [ # # ]: 0 : if (bCopySheet)
2300 : : {
2301 : : //! separate method AddStyleFromText needed?
2302 : : //! cache sheet object
2303 : :
2304 [ # # ][ # # ]: 0 : Reference<table::XCellRange> xCellRange(xIndex->getByIndex(nTable), uno::UNO_QUERY);
[ # # ]
2305 [ # # ][ # # ]: 0 : Reference<text::XSimpleText> xCellText(xCellRange->getCellByPosition(aPos.Col(), aPos.Row()), uno::UNO_QUERY);
[ # # ]
2306 [ # # ][ # # ]: 0 : Reference<beans::XPropertySet> xCursorProp(xCellText->createTextCursor(), uno::UNO_QUERY);
[ # # ]
2307 [ # # ]: 0 : ScCellTextCursor* pCursor = ScCellTextCursor::getImplementation( xCursorProp );
2308 [ # # ]: 0 : if (pCursor)
2309 : : {
2310 : 0 : pCursor->SetSelection( aTextIter->maSelection );
2311 : :
2312 [ # # ][ # # ]: 0 : std::vector<XMLPropertyState> xPropStates(xTextPropMapper->Filter(xCursorProp));
2313 : 0 : rtl::OUString sParent;
2314 : 0 : rtl::OUString sName( aTextIter->maName );
2315 [ # # ][ # # ]: 0 : GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TEXT_TEXT, sParent, xPropStates);
[ # # ][ # # ]
2316 [ # # ][ # # ]: 0 : GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TEXT_TEXT, sName);
[ # # ][ # # ]
2317 : 0 : }
2318 : : }
2319 : 0 : ++aTextIter;
2320 [ + - ][ + - ]: 4 : }
[ + - ]
2321 : : }
2322 : :
2323 [ + - ]: 4 : ExportExternalRefCacheStyles();
2324 : :
2325 [ - + ]: 4 : if (!pSharedData)
2326 : : {
2327 : 0 : sal_Int32 nTableCount(0);
2328 : 0 : sal_Int32 nShapesCount(0);
2329 [ # # ]: 0 : CollectSharedData(nTableCount, nShapesCount);
2330 : : }
2331 [ + - ][ + - ]: 4 : sal_Int32 nTableCount(xIndex->getCount());
2332 [ + - ]: 4 : pCellStyles->AddNewTable(nTableCount - 1);
2333 [ + - ]: 4 : CollectShapesAutoStyles(nTableCount);
2334 [ + - ][ + + ]: 8 : for (sal_Int32 nTable = 0; nTable < nTableCount; ++nTable, IncrementProgressBar(false))
2335 : : {
2336 [ + - ]: 4 : bool bUseStream = pSheetData && pDoc && pDoc->IsStreamValid((SCTAB)nTable) &&
2337 [ # # ]: 0 : pSheetData->HasStreamPos(nTable) && xSourceStream.is() &&
2338 [ + - ][ + - ]: 8 : !pDoc->GetChangeTrack();
[ - + ]
[ # # # # ]
[ # # ]
2339 : :
2340 [ + - ][ + - ]: 4 : Reference <sheet::XSpreadsheet> xTable(xIndex->getByIndex(nTable), uno::UNO_QUERY);
[ + - ]
2341 [ - + ]: 4 : if (!xTable.is())
2342 : 0 : continue;
2343 : :
2344 : : // table styles array must be complete, including copied tables - Add should find the stored style
2345 [ + - ]: 4 : Reference<beans::XPropertySet> xTableProperties(xTable, uno::UNO_QUERY);
2346 [ + - ]: 4 : if (xTableProperties.is())
2347 : : {
2348 [ + - ][ + - ]: 4 : std::vector<XMLPropertyState> xPropStates(xTableStylesExportPropertySetMapper->Filter(xTableProperties));
2349 [ + - ]: 4 : if(!xPropStates.empty())
2350 : : {
2351 : 4 : rtl::OUString sParent;
2352 : 4 : rtl::OUString sName;
2353 [ + - ][ + - ]: 4 : GetAutoStylePool()->Add(sName, XML_STYLE_FAMILY_TABLE_TABLE, sParent, xPropStates);
[ + - ][ + - ]
2354 [ + - ]: 4 : aTableStyles.push_back(sName);
2355 : 4 : }
2356 : : }
2357 : :
2358 [ - + ]: 4 : if (bUseStream)
2359 : 0 : continue;
2360 : :
2361 : : // collect other auto-styles only for non-copied sheets
2362 [ + - ]: 4 : Reference<sheet::XUniqueCellFormatRangesSupplier> xCellFormatRanges ( xTable, uno::UNO_QUERY );
2363 [ + - ]: 4 : if ( xCellFormatRanges.is() )
2364 : : {
2365 [ + - ][ + - ]: 4 : Reference<container::XIndexAccess> xFormatRangesIndex(xCellFormatRanges->getUniqueCellFormatRanges());
2366 [ + - ]: 4 : if (xFormatRangesIndex.is())
2367 : : {
2368 [ + - ][ + - ]: 4 : sal_Int32 nFormatRangesCount(xFormatRangesIndex->getCount());
2369 [ + - ][ + - ]: 4 : GetProgressBarHelper()->ChangeReference(GetProgressBarHelper()->GetReference() + nFormatRangesCount);
[ + - ]
2370 [ + + ]: 8 : for (sal_Int32 nFormatRange = 0; nFormatRange < nFormatRangesCount; ++nFormatRange)
2371 : : {
2372 [ + - ][ + - ]: 4 : Reference< sheet::XSheetCellRanges> xCellRanges(xFormatRangesIndex->getByIndex(nFormatRange), uno::UNO_QUERY);
[ + - ]
2373 [ + - ]: 4 : if (xCellRanges.is())
2374 : : {
2375 [ + - ]: 4 : Reference <beans::XPropertySet> xProperties (xCellRanges, uno::UNO_QUERY);
2376 [ + - ]: 4 : if (xProperties.is())
2377 : : {
2378 [ + - ]: 4 : AddStyleFromCells(xProperties, xTable, nTable, NULL);
2379 [ + - ]: 4 : IncrementProgressBar(false);
2380 : 4 : }
2381 : : }
2382 : 4 : }
2383 : 4 : }
2384 : : }
2385 [ + - ]: 4 : Reference<table::XColumnRowRange> xColumnRowRange (xTable, uno::UNO_QUERY);
2386 [ + - ]: 4 : if (xColumnRowRange.is())
2387 : : {
2388 [ + - ]: 4 : if (pDoc)
2389 : : {
2390 [ + - ]: 4 : pDoc->SyncColRowFlags();
2391 [ + - ][ + - ]: 4 : Reference<table::XTableColumns> xTableColumns(xColumnRowRange->getColumns());
2392 [ + - ]: 4 : if (xTableColumns.is())
2393 : : {
2394 [ + - ]: 4 : sal_Int32 nColumns(pDoc->GetLastChangedCol(sal::static_int_cast<SCTAB>(nTable)));
2395 [ + - ]: 4 : pSharedData->SetLastColumn(nTable, nColumns);
2396 [ + - ]: 4 : table::CellRangeAddress aCellAddress(GetEndAddress(xTable, nTable));
2397 [ - + ]: 4 : if (aCellAddress.EndColumn > nColumns)
2398 : : {
2399 : 0 : ++nColumns;
2400 [ # # ]: 0 : pColumnStyles->AddNewTable(nTable, aCellAddress.EndColumn);
2401 : : }
2402 : : else
2403 [ + - ]: 4 : pColumnStyles->AddNewTable(nTable, nColumns);
2404 : 4 : sal_Int32 nColumn = 0;
2405 [ + + ]: 8 : while (nColumn <= MAXCOL)
2406 : : {
2407 : 4 : sal_Int32 nIndex(-1);
2408 : 4 : bool bIsVisible(true);
2409 [ + - ][ + - ]: 4 : Reference <beans::XPropertySet> xColumnProperties(xTableColumns->getByIndex(nColumn), uno::UNO_QUERY);
[ + - ]
2410 [ + - ]: 4 : if (xColumnProperties.is())
2411 : : {
2412 [ + - ]: 4 : AddStyleFromColumn( xColumnProperties, NULL, nIndex, bIsVisible );
2413 [ + - ]: 4 : pColumnStyles->AddFieldStyleName(nTable, nColumn, nIndex, bIsVisible);
2414 : : }
2415 : 4 : sal_Int32 nOld(nColumn);
2416 [ + - ]: 4 : nColumn = pDoc->GetNextDifferentChangedCol(sal::static_int_cast<SCTAB>(nTable), static_cast<SCCOL>(nColumn));
2417 [ + + ]: 4096 : for (sal_Int32 i = nOld + 1; i < nColumn; ++i)
2418 [ + - ]: 4092 : pColumnStyles->AddFieldStyleName(nTable, i, nIndex, bIsVisible);
2419 : 4 : }
2420 [ - + ]: 4 : if (aCellAddress.EndColumn > nColumns)
2421 : : {
2422 : 0 : bool bIsVisible(true);
2423 [ # # ]: 0 : sal_Int32 nIndex(pColumnStyles->GetStyleNameIndex(nTable, nColumns, bIsVisible));
2424 [ # # ]: 4 : for (sal_Int32 i = nColumns + 1; i <= aCellAddress.EndColumn; ++i)
2425 [ # # ]: 0 : pColumnStyles->AddFieldStyleName(nTable, i, nIndex, bIsVisible);
2426 : : }
2427 : : }
2428 [ + - ][ + - ]: 4 : Reference<table::XTableRows> xTableRows(xColumnRowRange->getRows());
2429 [ + - ]: 4 : if (xTableRows.is())
2430 : : {
2431 [ + - ]: 4 : sal_Int32 nRows(pDoc->GetLastChangedRow(sal::static_int_cast<SCTAB>(nTable)));
2432 [ + - ]: 4 : pSharedData->SetLastRow(nTable, nRows);
2433 : :
2434 [ + - ]: 4 : pRowStyles->AddNewTable(nTable, MAXROW);
2435 : 4 : sal_Int32 nRow = 0;
2436 [ + + ]: 8 : while (nRow <= MAXROW)
2437 : : {
2438 : 4 : sal_Int32 nIndex = 0;
2439 [ + - ][ + - ]: 4 : Reference <beans::XPropertySet> xRowProperties(xTableRows->getByIndex(nRow), uno::UNO_QUERY);
[ + - ]
2440 [ + - ]: 4 : if(xRowProperties.is())
2441 : : {
2442 [ + - ]: 4 : AddStyleFromRow( xRowProperties, NULL, nIndex );
2443 [ + - ]: 4 : pRowStyles->AddFieldStyleName(nTable, nRow, nIndex);
2444 : : }
2445 : 4 : sal_Int32 nOld(nRow);
2446 [ + - ]: 4 : nRow = pDoc->GetNextDifferentChangedRow(sal::static_int_cast<SCTAB>(nTable), static_cast<SCROW>(nRow), false);
2447 [ + - ]: 4 : if (nRow > nOld + 1)
2448 [ + - ]: 4 : pRowStyles->AddFieldStyleName(nTable, nOld + 1, nIndex, nRow - 1);
2449 : 4 : }
2450 : 4 : }
2451 : : }
2452 : : }
2453 [ + - ]: 4 : Reference<sheet::XCellRangesQuery> xCellRangesQuery (xTable, uno::UNO_QUERY);
2454 [ + - ]: 4 : if (xCellRangesQuery.is())
2455 : : {
2456 [ + - ][ + - ]: 4 : Reference<sheet::XSheetCellRanges> xSheetCellRanges(xCellRangesQuery->queryContentCells(sheet::CellFlags::FORMATTED));
2457 [ + - ]: 4 : Reference<sheet::XSheetOperation> xSheetOperation(xSheetCellRanges, uno::UNO_QUERY);
2458 [ + - ][ + - ]: 4 : if (xSheetCellRanges.is() && xSheetOperation.is())
[ + - ]
2459 : : {
2460 [ + - ][ + - ]: 4 : sal_uInt32 nCount(sal_uInt32(xSheetOperation->computeFunction(sheet::GeneralFunction_COUNT)));
2461 [ + - ][ + - ]: 4 : Reference<container::XEnumerationAccess> xCellsAccess(xSheetCellRanges->getCells());
2462 [ + - ]: 4 : if (xCellsAccess.is())
2463 : : {
2464 [ + - ][ + - ]: 4 : GetProgressBarHelper()->ChangeReference(GetProgressBarHelper()->GetReference() + nCount);
[ + - ]
2465 [ + - ][ + - ]: 4 : Reference<container::XEnumeration> xCells(xCellsAccess->createEnumeration());
2466 [ + - ]: 4 : if (xCells.is())
2467 : : {
2468 : 4 : sal_uInt32 nCount2(0);
2469 [ + - ][ + - ]: 4 : while (xCells->hasMoreElements())
[ - + ]
2470 : : {
2471 [ # # ][ # # ]: 0 : Reference<text::XText> xText(xCells->nextElement(), uno::UNO_QUERY);
[ # # ]
2472 [ # # ]: 0 : if (xText.is())
2473 [ # # ][ # # ]: 0 : GetTextParagraphExport()->collectTextAutoStyles(xText, false, false);
[ # # ][ # # ]
2474 : 0 : ++nCount2;
2475 [ # # ]: 0 : IncrementProgressBar(false);
2476 : 0 : }
2477 [ - + ]: 4 : if(nCount2 > nCount)
2478 [ # # ][ # # ]: 0 : GetProgressBarHelper()->SetReference(GetProgressBarHelper()->GetReference() + nCount2 - nCount);
2479 : 4 : }
2480 : 4 : }
2481 : 4 : }
2482 : : }
2483 [ - + ][ + - ]: 4 : }
2484 [ + - ]: 4 : pChangeTrackingExportHelper->CollectAutoStyles();
2485 : :
2486 : : GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_COLUMN,
2487 [ + - ][ + - ]: 4 : GetDocHandler(), GetMM100UnitConverter(), GetNamespaceMap());
[ + - ][ + - ]
2488 : : GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_ROW,
2489 [ + - ][ + - ]: 4 : GetDocHandler(), GetMM100UnitConverter(), GetNamespaceMap());
[ + - ][ + - ]
2490 : : GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_TABLE,
2491 [ + - ][ + - ]: 4 : GetDocHandler(), GetMM100UnitConverter(), GetNamespaceMap());
[ + - ][ + - ]
2492 [ + - ]: 4 : exportAutoDataStyles();
2493 : : GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_CELL,
2494 [ + - ][ + - ]: 4 : GetDocHandler(), GetMM100UnitConverter(), GetNamespaceMap());
[ + - ][ + - ]
2495 : :
2496 [ + - ][ + - ]: 4 : GetShapeExport()->exportAutoStyles();
[ + - ][ + - ]
2497 [ + - ][ + - ]: 4 : GetFormExport()->exportAutoStyles( );
[ + - ][ + - ]
2498 : :
2499 [ + - ]: 4 : if (pDoc)
2500 : : {
2501 [ + - ]: 4 : ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
2502 : : // #i100879# write the table style for cached tables only if there are cached tables
2503 : : // (same logic as in ExportExternalRefCacheStyles)
2504 [ + - ][ - + ]: 4 : if (pRefMgr->hasExternalData())
2505 : : {
2506 : : // Special table style for the external ref cache tables.
2507 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_STYLE, XML_NAME, sExternalRefTabStyleName);
2508 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_STYLE, XML_FAMILY, XML_TABLE);
2509 [ # # ]: 0 : SvXMLElementExport aElemStyle(*this, XML_NAMESPACE_STYLE, XML_STYLE, true, true);
2510 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY, XML_FALSE);
2511 [ # # ][ # # ]: 0 : SvXMLElementExport aElemStyleTabProps(*this, XML_NAMESPACE_STYLE, XML_TABLE_PROPERTIES, true, true);
[ # # ]
2512 : : }
2513 : : }
2514 : : }
2515 : :
2516 [ + + ]: 8 : if (getExportFlags() & EXPORT_MASTERSTYLES)
2517 : : {
2518 [ + - ][ + - ]: 4 : GetPageExport()->collectAutoStyles(true);
[ + - ][ + - ]
2519 [ + - ][ + - ]: 4 : GetPageExport()->exportAutoStyles();
[ + - ][ + - ]
2520 : : }
2521 : :
2522 : : // #i30251#; only write Text Styles once
2523 : :
2524 [ + + ][ + - ]: 8 : if ((getExportFlags() & EXPORT_CONTENT) || (getExportFlags() & EXPORT_MASTERSTYLES))
[ + - ]
2525 [ + - ][ + - ]: 8 : GetTextParagraphExport()->exportTextAutoStyles();
[ + - ][ + - ]
[ - + ][ + - ]
2526 : : }
2527 : :
2528 : 4 : void ScXMLExport::_ExportMasterStyles()
2529 : : {
2530 [ + - ][ + - ]: 4 : GetPageExport()->exportMasterStyles( true );
2531 : 4 : }
2532 : :
2533 : 0 : void ScXMLExport::CollectInternalShape( uno::Reference< drawing::XShape > xShape )
2534 : : {
2535 : : // detective objects and notes
2536 [ # # ]: 0 : if( SvxShape* pShapeImp = SvxShape::getImplementation( xShape ) )
2537 : : {
2538 [ # # ]: 0 : if( SdrObject* pObject = pShapeImp->GetSdrObject() )
2539 : : {
2540 : : // collect note caption objects from all layers (internal or hidden)
2541 [ # # ]: 0 : if( ScDrawObjData* pCaptData = ScDrawLayer::GetNoteCaptionData( pObject, static_cast< SCTAB >( nCurrentTable ) ) )
2542 : : {
2543 : 0 : pSharedData->AddNoteObj( xShape, pCaptData->maStart );
2544 : :
2545 : : // #i60851# When the file is saved while editing a new note,
2546 : : // the cell is still empty -> last column/row must be updated
2547 : : OSL_ENSURE( pCaptData->maStart.Tab() == nCurrentTable, "invalid table in object data" );
2548 : 0 : pSharedData->SetLastColumn( nCurrentTable, pCaptData->maStart.Col() );
2549 : 0 : pSharedData->SetLastRow( nCurrentTable, pCaptData->maStart.Row() );
2550 : : }
2551 : : // other objects from internal layer only (detective)
2552 [ # # ]: 0 : else if( pObject->GetLayer() == SC_LAYER_INTERN )
2553 : : {
2554 : 0 : ScDetectiveFunc aDetFunc( pDoc, static_cast<SCTAB>(nCurrentTable) );
2555 : 0 : ScAddress aPosition;
2556 : 0 : ScRange aSourceRange;
2557 : : bool bRedLine;
2558 : : ScDetectiveObjType eObjType = aDetFunc.GetDetectiveObjectType(
2559 [ # # ]: 0 : pObject, nCurrentTable, aPosition, aSourceRange, bRedLine );
2560 [ # # ]: 0 : pSharedData->GetDetectiveObjContainer()->AddObject( eObjType, static_cast<SCTAB>(nCurrentTable), aPosition, aSourceRange, bRedLine );
2561 : : }
2562 : : }
2563 : : }
2564 : 0 : }
2565 : :
2566 : 4 : bool ScXMLExport::GetMerged (const table::CellRangeAddress* pCellAddress,
2567 : : const uno::Reference <sheet::XSpreadsheet>& xTable)
2568 : : {
2569 : 4 : bool bReady(false);
2570 : 4 : sal_Int32 nRow(pCellAddress->StartRow);
2571 : 4 : sal_Int32 nCol(pCellAddress->StartColumn);
2572 : 4 : sal_Int32 nEndRow(pCellAddress->EndRow);
2573 : 4 : sal_Int32 nEndCol(pCellAddress->EndColumn);
2574 : 4 : bool bRowInc(nEndRow > nRow);
2575 [ + + ][ + - ]: 8 : while(!bReady && nRow <= nEndRow && nCol <= nEndCol)
[ + - ][ + + ]
2576 : : {
2577 [ + - ][ + - ]: 4 : uno::Reference<sheet::XSheetCellRange> xSheetCellRange(xTable->getCellRangeByPosition(nCol, nRow, nCol, nRow), uno::UNO_QUERY);
[ + - ]
2578 [ + - ]: 4 : if (xSheetCellRange.is())
2579 : : {
2580 [ + - ][ + - ]: 4 : uno::Reference<sheet::XSheetCellCursor> xCursor(xTable->createCursorByRange(xSheetCellRange));
2581 [ + - ]: 4 : if(xCursor.is())
2582 : : {
2583 [ + - ]: 4 : uno::Reference<sheet::XCellRangeAddressable> xCellAddress (xCursor, uno::UNO_QUERY);
2584 [ + - ][ + - ]: 4 : xCursor->collapseToMergedArea();
2585 [ + - ][ + - ]: 4 : table::CellRangeAddress aCellAddress2(xCellAddress->getRangeAddress());
2586 [ + - ][ - + ]: 4 : if ((aCellAddress2.EndRow > nRow ||
[ # # ][ # # ]
2587 : : aCellAddress2.EndColumn > nCol) &&
2588 : : aCellAddress2.StartRow == nRow &&
2589 : : aCellAddress2.StartColumn == nCol)
2590 : : {
2591 [ # # ]: 0 : pMergedRangesContainer->AddRange(aCellAddress2);
2592 [ # # ]: 0 : pSharedData->SetLastColumn(aCellAddress2.Sheet, aCellAddress2.EndColumn);
2593 [ # # ]: 0 : pSharedData->SetLastRow(aCellAddress2.Sheet, aCellAddress2.EndRow);
2594 : : }
2595 : : else
2596 : 4 : bReady = true;
2597 : 4 : }
2598 : : }
2599 [ - + ]: 4 : if (!bReady)
2600 : : {
2601 [ # # ]: 0 : if (bRowInc)
2602 : 0 : ++nRow;
2603 : : else
2604 : 0 : ++nCol;
2605 : : }
2606 : 4 : }
2607 : : OSL_ENSURE(!(!bReady && nEndRow > nRow && nEndCol > nCol), "should not be possible");
2608 : 4 : return !bReady;
2609 : : }
2610 : :
2611 : 0 : bool ScXMLExport::IsMatrix (const ScAddress& aCell,
2612 : : table::CellRangeAddress& aCellAddress, bool& bIsFirst) const
2613 : : {
2614 : 0 : bIsFirst = false;
2615 : :
2616 : 0 : ScRange aMatrixRange;
2617 : :
2618 [ # # ][ # # ]: 0 : if (pDoc && pDoc->GetMatrixFormulaRange(aCell, aMatrixRange))
[ # # ][ # # ]
2619 : : {
2620 : 0 : ScUnoConversion::FillApiRange( aCellAddress, aMatrixRange );
2621 [ # # # # : 0 : if ((aCellAddress.StartColumn == aCell.Col() && aCellAddress.StartRow == aCell.Row()) &&
# # ][ # # ]
[ # # ]
2622 : 0 : (aCellAddress.EndColumn > aCell.Col() || aCellAddress.EndRow > aCell.Row()))
2623 : : {
2624 : 0 : bIsFirst = true;
2625 : 0 : return true;
2626 : : }
2627 [ # # ][ # # : 0 : else if (aCellAddress.StartColumn != aCell.Col() || aCellAddress.StartRow != aCell.Row() ||
# # # # ]
[ # # ]
2628 : 0 : aCellAddress.EndColumn != aCell.Col() || aCellAddress.EndRow != aCell.Row())
2629 : 0 : return true;
2630 : : else
2631 : : {
2632 : 0 : bIsFirst = true;
2633 : 0 : return true;
2634 : : }
2635 : : }
2636 : :
2637 : 0 : return false;
2638 : : }
2639 : :
2640 : 0 : bool ScXMLExport::GetCellText (ScMyCell& rMyCell, const ScAddress& aPos) const
2641 : : {
2642 [ # # ]: 0 : if (rMyCell.bHasStringValue)
2643 : 0 : return true;
2644 : : else
2645 : : {
2646 [ # # ]: 0 : rMyCell.sStringValue = ScCellObj::GetOutputString_Impl(pDoc, aPos);
2647 : 0 : rMyCell.bHasStringValue = true;
2648 : 0 : return true;
2649 : : }
2650 : : }
2651 : :
2652 : 4 : void ScXMLExport::WriteTable(sal_Int32 nTable, const Reference<sheet::XSpreadsheet>& xTable)
2653 : : {
2654 [ + - ]: 4 : if (!xTable.is())
2655 : : return;
2656 : :
2657 [ + - ]: 4 : xCurrentTable.set(xTable);
2658 [ + - ]: 4 : xCurrentTableCellRange.set(xTable, uno::UNO_QUERY);
2659 [ + - ]: 4 : uno::Reference<container::XNamed> xName (xTable, uno::UNO_QUERY );
2660 [ - + ]: 4 : if (!xName.is())
2661 : : return;
2662 : :
2663 : 4 : nCurrentTable = sal::static_int_cast<sal_uInt16>( nTable );
2664 [ + - ][ + - ]: 4 : rtl::OUString sOUTableName(xName->getName());
2665 [ + - ]: 4 : AddAttribute(sAttrName, sOUTableName);
2666 [ + - ]: 4 : AddAttribute(sAttrStyleName, aTableStyles[nTable]);
2667 : :
2668 [ + - ]: 4 : uno::Reference<util::XProtectable> xProtectable (xTable, uno::UNO_QUERY);
2669 : 4 : ScTableProtection* pProtect = NULL;
2670 [ + - ][ + - ]: 4 : if (xProtectable.is() && xProtectable->isProtected())
[ + - ][ - + ]
[ - + ]
2671 : : {
2672 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTED, XML_TRUE);
2673 [ # # ]: 0 : if (pDoc)
2674 : : {
2675 [ # # ]: 0 : pProtect = pDoc->GetTabProtection(nTable);
2676 [ # # ]: 0 : if (pProtect)
2677 : : {
2678 : 0 : rtl::OUStringBuffer aBuffer;
2679 : 0 : ScPasswordHash eHashUsed = PASSHASH_UNSPECIFIED;
2680 [ # # ][ # # ]: 0 : if (pProtect->hasPasswordHash(PASSHASH_SHA1))
2681 : : {
2682 : : ::sax::Converter::encodeBase64(aBuffer,
2683 [ # # ][ # # ]: 0 : pProtect->getPasswordHash(PASSHASH_SHA1));
[ # # ]
2684 : 0 : eHashUsed = PASSHASH_SHA1;
2685 : : }
2686 [ # # ][ # # ]: 0 : else if (pProtect->hasPasswordHash(PASSHASH_XL, PASSHASH_SHA1))
2687 : : {
2688 : : // Double-hash this by SHA1 on top of the legacy xls hash.
2689 [ # # ]: 0 : uno::Sequence<sal_Int8> aHash = pProtect->getPasswordHash(PASSHASH_XL, PASSHASH_SHA1);
2690 [ # # ]: 0 : ::sax::Converter::encodeBase64(aBuffer, aHash);
2691 [ # # ]: 0 : eHashUsed = PASSHASH_XL;
2692 : : }
2693 [ # # ]: 0 : if (aBuffer.getLength())
2694 : : {
2695 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY, aBuffer.makeStringAndClear());
2696 [ # # ][ # # ]: 0 : if ( getDefaultVersion() >= SvtSaveOptions::ODFVER_012 )
2697 : : {
2698 [ # # ]: 0 : if (eHashUsed == PASSHASH_XL)
2699 : : {
2700 : : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY_DIGEST_ALGORITHM,
2701 [ # # ][ # # ]: 0 : ScPassHashHelper::getHashURI(PASSHASH_XL));
2702 : : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY_DIGEST_ALGORITHM_2,
2703 [ # # ][ # # ]: 0 : ScPassHashHelper::getHashURI(PASSHASH_SHA1));
2704 : : }
2705 [ # # ]: 0 : else if (eHashUsed == PASSHASH_SHA1)
2706 : : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY_DIGEST_ALGORITHM,
2707 [ # # ][ # # ]: 0 : ScPassHashHelper::getHashURI(PASSHASH_SHA1));
2708 : : }
2709 : 0 : }
2710 : : }
2711 : : }
2712 : : }
2713 : 4 : rtl::OUString sPrintRanges;
2714 : 4 : table::CellRangeAddress aColumnHeaderRange;
2715 : : bool bHasColumnHeader;
2716 [ + - ]: 4 : GetColumnRowHeader(bHasColumnHeader, aColumnHeaderRange, bHasRowHeader, aRowHeaderRange, sPrintRanges);
2717 [ - + ]: 4 : if( !sPrintRanges.isEmpty() )
2718 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_PRINT_RANGES, sPrintRanges );
2719 [ + - ][ - + ]: 4 : else if (!pDoc->IsPrintEntireSheet(static_cast<SCTAB>(nTable)))
2720 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_PRINT, XML_FALSE);
2721 [ + - ]: 4 : SvXMLElementExport aElemT(*this, sElemTab, true, true);
2722 : :
2723 [ - + ][ # # ]: 4 : if (pProtect && pProtect->isProtected())
[ # # ][ - + ]
2724 : : {
2725 [ # # ][ # # ]: 0 : if (pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS))
2726 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_SELECT_PROTECTED_CELLS, XML_TRUE);
2727 [ # # ][ # # ]: 0 : if (pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS))
2728 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_SELECT_UNPROTECTED_CELLS, XML_TRUE);
2729 : :
2730 : 0 : rtl::OUString aElemName = GetNamespaceMap().GetQNameByKey(
2731 [ # # # # ]: 0 : XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE_PROTECTION));
2732 : :
2733 [ # # ][ # # ]: 0 : SvXMLElementExport aElemProtected(*this, aElemName, true, true);
2734 : : }
2735 : :
2736 : 4 : CheckAttrList();
2737 : :
2738 [ + - ][ - + ]: 4 : if ( pDoc && pDoc->GetSheetEvents( static_cast<SCTAB>(nTable) ) &&
[ # # ][ - + ]
[ + - ]
2739 [ # # ]: 0 : getDefaultVersion() >= SvtSaveOptions::ODFVER_012 )
2740 : : {
2741 : : // store sheet events
2742 [ # # ]: 0 : uno::Reference<document::XEventsSupplier> xSupplier(xTable, uno::UNO_QUERY);
2743 [ # # ][ # # ]: 0 : uno::Reference<container::XNameAccess> xEvents(xSupplier->getEvents(), uno::UNO_QUERY);
[ # # ]
2744 [ # # ][ # # ]: 0 : GetEventExport().ExportExt( xEvents );
2745 : : }
2746 : :
2747 [ + - ]: 4 : WriteTableSource();
2748 [ + - ]: 4 : WriteScenario();
2749 : 4 : uno::Reference<drawing::XDrawPage> xDrawPage;
2750 [ - + ][ # # ]: 4 : if (pSharedData->HasForm(nTable, xDrawPage) && xDrawPage.is())
[ - + ][ + - ]
2751 : : {
2752 [ # # ]: 0 : ::xmloff::OOfficeFormsExport aForms(*this);
2753 [ # # ][ # # ]: 0 : GetFormExport()->exportForms( xDrawPage );
[ # # ][ # # ]
2754 [ # # ][ # # ]: 0 : bool bRet(GetFormExport()->seekPage( xDrawPage ));
[ # # ][ # # ]
2755 : : OSL_ENSURE( bRet, "OFormLayerXMLExport::seekPage failed!" );
2756 [ # # ]: 0 : (void)bRet; // avoid warning in product version
2757 : : }
2758 [ + - ]: 4 : if (pSharedData->HasDrawPage())
2759 : : {
2760 [ + - ][ + - ]: 4 : GetShapeExport()->seekShapes(uno::Reference<drawing::XShapes>(pSharedData->GetDrawPage(nTable), uno::UNO_QUERY));
[ + - ][ + - ]
[ + - ]
2761 [ + - ]: 4 : WriteTableShapes();
2762 : : }
2763 [ + - ]: 4 : table::CellRangeAddress aRange(GetEndAddress(xTable, nTable));
2764 [ + - ]: 4 : pSharedData->SetLastColumn(nTable, aRange.EndColumn);
2765 [ + - ]: 4 : pSharedData->SetLastRow(nTable, aRange.EndRow);
2766 [ + - ]: 4 : pCellsItr->SetCurrentTable(static_cast<SCTAB>(nTable), xCurrentTable);
2767 [ + - ]: 4 : pGroupColumns->NewTable();
2768 [ + - ]: 4 : pGroupRows->NewTable();
2769 [ + - ]: 4 : FillColumnRowGroups();
2770 [ - + ]: 4 : if (bHasColumnHeader)
2771 [ # # ]: 0 : pSharedData->SetLastColumn(nTable, aColumnHeaderRange.EndColumn);
2772 : 4 : bRowHeaderOpen = sal_False;
2773 [ - + ]: 4 : if (bHasRowHeader)
2774 [ # # ]: 0 : pSharedData->SetLastRow(nTable, aRowHeaderRange.EndRow);
2775 : : pDefaults->FillDefaultStyles(nTable, pSharedData->GetLastRow(nTable),
2776 [ + - ][ + - ]: 4 : pSharedData->GetLastColumn(nTable), pCellStyles, pDoc);
[ + - ]
2777 : 4 : pRowFormatRanges->SetRowDefaults(pDefaults->GetRowDefaults());
2778 : 4 : pRowFormatRanges->SetColDefaults(pDefaults->GetColDefaults());
2779 : 4 : pCellStyles->SetRowDefaults(pDefaults->GetRowDefaults());
2780 : 4 : pCellStyles->SetColDefaults(pDefaults->GetColDefaults());
2781 [ + - ]: 4 : ExportColumns(nTable, aColumnHeaderRange, bHasColumnHeader);
2782 : 4 : bool bIsFirst(true);
2783 : 4 : sal_Int32 nEqualCells(0);
2784 [ + - ]: 4 : ScMyCell aCell;
2785 [ + - ]: 4 : ScMyCell aPrevCell;
2786 [ + - ][ - + ]: 4 : while(pCellsItr->GetNext(aCell, pCellStyles))
2787 : : {
2788 [ # # ]: 0 : if (bIsFirst)
2789 : : {
2790 [ # # ]: 0 : ExportFormatRanges(0, 0, aCell.aCellAddress.Column - 1, aCell.aCellAddress.Row, nTable);
2791 [ # # ]: 0 : aPrevCell = aCell;
2792 : 0 : bIsFirst = sal_False;
2793 : : }
2794 : : else
2795 : : {
2796 [ # # ][ # # ]: 0 : if ((aPrevCell.aCellAddress.Row == aCell.aCellAddress.Row) &&
2797 : : (aPrevCell.aCellAddress.Column + nEqualCells + 1 == aCell.aCellAddress.Column))
2798 : : {
2799 [ # # ][ # # ]: 0 : if(IsCellEqual(aPrevCell, aCell))
2800 : 0 : ++nEqualCells;
2801 : : else
2802 : : {
2803 [ # # ]: 0 : WriteCell(aPrevCell, nEqualCells);
2804 : 0 : nEqualCells = 0;
2805 [ # # ]: 0 : aPrevCell = aCell;
2806 : : }
2807 : : }
2808 : : else
2809 : : {
2810 [ # # ]: 0 : WriteCell(aPrevCell, nEqualCells);
2811 : : ExportFormatRanges(aPrevCell.aCellAddress.Column + nEqualCells + 1, aPrevCell.aCellAddress.Row,
2812 [ # # ]: 0 : aCell.aCellAddress.Column - 1, aCell.aCellAddress.Row, nTable);
2813 : 0 : nEqualCells = 0;
2814 [ # # ]: 0 : aPrevCell = aCell;
2815 : : }
2816 : : }
2817 : : }
2818 [ - + ]: 4 : if (!bIsFirst)
2819 : : {
2820 [ # # ]: 0 : WriteCell(aPrevCell, nEqualCells);
2821 : : ExportFormatRanges(aPrevCell.aCellAddress.Column + nEqualCells + 1, aPrevCell.aCellAddress.Row,
2822 [ # # ][ # # ]: 0 : pSharedData->GetLastColumn(nTable), pSharedData->GetLastRow(nTable), nTable);
[ # # ]
2823 : : }
2824 : : else
2825 [ + - ][ + - ]: 4 : ExportFormatRanges(0, 0, pSharedData->GetLastColumn(nTable), pSharedData->GetLastRow(nTable), nTable);
[ + - ]
2826 : :
2827 [ + - ][ + - ]: 4 : CloseRow(pSharedData->GetLastRow(nTable));
2828 : 4 : nEqualCells = 0;
2829 : :
2830 [ + - ]: 4 : if (pDoc)
2831 : : {
2832 : : // Export sheet-local named ranges.
2833 [ + - ]: 4 : ScRangeName* pRangeName = pDoc->GetRangeName(nTable);
2834 [ + - ][ + - ]: 4 : if (pRangeName && !pRangeName->empty())
[ - + ][ - + ]
2835 : : {
2836 [ # # ]: 0 : WriteNamedRange(pRangeName);
2837 : : }
2838 : :
2839 [ + - ][ + - ]: 4 : if(getDefaultVersion() > SvtSaveOptions::ODFVER_012)
2840 : : {
2841 : : //export new conditional format information
2842 [ + - ]: 4 : ExportConditionalFormat(nTable);
2843 : : }
2844 : :
2845 [ + - ][ + - ]: 4 : }
[ + - ][ + - ]
2846 : : }
2847 : :
2848 : 0 : void ScXMLExport::WriteCell(ScMyCell& aCell, sal_Int32 nEqualCellCount)
2849 : : {
2850 : : // nEqualCellCount is the number of additional cells
2851 [ # # ]: 0 : SetRepeatAttribute(nEqualCellCount, (aCell.nType != table::CellContentType_EMPTY));
2852 : :
2853 : 0 : ScAddress aCellPos;
2854 : 0 : ScUnoConversion::FillScAddress( aCellPos, aCell.aCellAddress );
2855 [ # # ]: 0 : if (aCell.nStyleIndex != -1)
2856 [ # # ][ # # ]: 0 : AddAttribute(sAttrStyleName, *pCellStyles->GetStyleNameByIndex(aCell.nStyleIndex, aCell.bIsAutoStyle));
2857 [ # # ]: 0 : if (aCell.nValidationIndex > -1)
2858 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION_NAME, pValidationsContainer->GetValidationName(aCell.nValidationIndex));
2859 [ # # ][ # # ]: 0 : bool bIsMatrix(aCell.bIsMatrixBase || aCell.bIsMatrixCovered);
2860 : 0 : bool bIsFirstMatrixCell(aCell.bIsMatrixBase);
2861 [ # # ]: 0 : if (bIsFirstMatrixCell)
2862 : : {
2863 : 0 : sal_Int32 nColumns(aCell.aMatrixRange.EndColumn - aCell.aMatrixRange.StartColumn + 1);
2864 : 0 : sal_Int32 nRows(aCell.aMatrixRange.EndRow - aCell.aMatrixRange.StartRow + 1);
2865 : 0 : rtl::OUStringBuffer sColumns;
2866 : 0 : rtl::OUStringBuffer sRows;
2867 [ # # ]: 0 : ::sax::Converter::convertNumber(sColumns, nColumns);
2868 [ # # ]: 0 : ::sax::Converter::convertNumber(sRows, nRows);
2869 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_MATRIX_COLUMNS_SPANNED, sColumns.makeStringAndClear());
2870 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_MATRIX_ROWS_SPANNED, sRows.makeStringAndClear());
2871 : : }
2872 : 0 : bool bIsEmpty(false);
2873 [ # # # # : 0 : switch (aCell.nType)
# ]
2874 : : {
2875 : : case table::CellContentType_EMPTY :
2876 : : {
2877 : 0 : bIsEmpty = true;
2878 : : }
2879 : 0 : break;
2880 : : case table::CellContentType_VALUE :
2881 : : {
2882 [ # # ]: 0 : if (!aCell.bHasDoubleValue)
2883 : : {
2884 [ # # ]: 0 : aCell.fValue = pDoc->GetValue( aCellPos );
2885 : 0 : aCell.bHasDoubleValue = true;
2886 : : }
2887 : : GetNumberFormatAttributesExportHelper()->SetNumberFormatAttributes(
2888 [ # # ][ # # ]: 0 : aCell.nNumberFormat, aCell.fValue);
2889 : : }
2890 : 0 : break;
2891 : : case table::CellContentType_TEXT :
2892 : : {
2893 [ # # ][ # # ]: 0 : if (GetCellText(aCell, aCellPos))
2894 : : {
2895 [ # # ]: 0 : rtl::OUString sFormula(lcl_GetRawString(pDoc, aCellPos));
2896 : : GetNumberFormatAttributesExportHelper()->SetNumberFormatAttributes(
2897 [ # # ][ # # ]: 0 : sFormula, aCell.sStringValue, true, true);
2898 : : }
2899 : : }
2900 : 0 : break;
2901 : : case table::CellContentType_FORMULA :
2902 : : {
2903 [ # # ][ # # ]: 0 : ScBaseCell* pBaseCell = pDoc ? pDoc->GetCell(aCellPos) : NULL;
2904 [ # # ][ # # ]: 0 : if (pBaseCell && pBaseCell->GetCellType() == CELLTYPE_FORMULA)
[ # # ]
2905 : : {
2906 : 0 : rtl::OUStringBuffer sFormula;
2907 [ # # ]: 0 : ScFormulaCell* pFormulaCell((ScFormulaCell*) pBaseCell);
2908 [ # # ][ # # ]: 0 : if (!bIsMatrix || (bIsMatrix && bIsFirstMatrixCell))
[ # # ]
2909 : : {
2910 : 0 : const formula::FormulaGrammar::Grammar eGrammar = pDoc->GetStorageGrammar();
2911 [ # # ]: 0 : sal_uInt16 nNamespacePrefix = (eGrammar == formula::FormulaGrammar::GRAM_ODFF ? XML_NAMESPACE_OF : XML_NAMESPACE_OOOC);
2912 [ # # ]: 0 : pFormulaCell->GetFormula(sFormula, eGrammar);
2913 [ # # ]: 0 : rtl::OUString sOUFormula(sFormula.makeStringAndClear());
2914 [ # # ]: 0 : if (!bIsMatrix)
2915 : : {
2916 [ # # ][ # # ]: 0 : AddAttribute(sAttrFormula, GetNamespaceMap().GetQNameByKey( nNamespacePrefix, sOUFormula, false ));
2917 : : }
2918 : : else
2919 : : {
2920 [ # # ][ # # ]: 0 : AddAttribute(sAttrFormula, GetNamespaceMap().GetQNameByKey( nNamespacePrefix, sOUFormula.copy(1, sOUFormula.getLength() - 2), false ));
2921 : 0 : }
2922 : : }
2923 [ # # ][ # # ]: 0 : if (pFormulaCell->IsValue())
2924 : : {
2925 : : bool bIsStandard;
2926 : 0 : rtl::OUString sCurrency;
2927 [ # # ][ # # ]: 0 : GetNumberFormatAttributesExportHelper()->GetCellType(aCell.nNumberFormat, sCurrency, bIsStandard);
2928 [ # # ]: 0 : if (bIsStandard)
2929 : : {
2930 [ # # ]: 0 : if (pDoc)
2931 : : GetNumberFormatAttributesExportHelper()->SetNumberFormatAttributes(
2932 [ # # ][ # # ]: 0 : pFormulaCell->GetStandardFormat(*pDoc->GetFormatTable(), 0),
2933 [ # # ][ # # ]: 0 : pDoc->GetValue( aCellPos ));
[ # # ]
2934 : : }
2935 : : else
2936 : : {
2937 [ # # ]: 0 : if (pDoc)
2938 : : GetNumberFormatAttributesExportHelper()->SetNumberFormatAttributes(
2939 [ # # ][ # # ]: 0 : aCell.nNumberFormat, pDoc->GetValue( aCellPos ));
[ # # ]
2940 : 0 : }
2941 : : }
2942 : : else
2943 : : {
2944 [ # # ][ # # ]: 0 : if (GetCellText(aCell, aCellPos))
2945 [ # # ]: 0 : if (!aCell.sStringValue.isEmpty())
2946 : : {
2947 [ # # ]: 0 : AddAttribute(sAttrValueType, XML_STRING);
2948 [ # # ]: 0 : AddAttribute(sAttrStringValue, aCell.sStringValue);
2949 : : }
2950 : 0 : }
2951 : : }
2952 : : }
2953 : 0 : break;
2954 : : default:
2955 : : {
2956 : : // added to avoid warnings
2957 : : }
2958 : : }
2959 : 0 : rtl::OUString* pCellString(&sElemCell);
2960 [ # # ]: 0 : if (aCell.bIsCovered)
2961 : : {
2962 : 0 : pCellString = &sElemCoveredCell;
2963 : : }
2964 : : else
2965 : : {
2966 [ # # ]: 0 : if (aCell.bIsMergedBase)
2967 : : {
2968 : 0 : sal_Int32 nColumns(aCell.aMergeRange.EndColumn - aCell.aMergeRange.StartColumn + 1);
2969 : 0 : sal_Int32 nRows(aCell.aMergeRange.EndRow - aCell.aMergeRange.StartRow + 1);
2970 : 0 : rtl::OUStringBuffer sColumns;
2971 : 0 : rtl::OUStringBuffer sRows;
2972 [ # # ]: 0 : ::sax::Converter::convertNumber(sColumns, nColumns);
2973 [ # # ]: 0 : ::sax::Converter::convertNumber(sRows, nRows);
2974 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_SPANNED, sColumns.makeStringAndClear());
2975 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_SPANNED, sRows.makeStringAndClear());
2976 : : }
2977 : : }
2978 [ # # ]: 0 : SvXMLElementExport aElemC(*this, *pCellString, true, true);
2979 : 0 : CheckAttrList();
2980 [ # # ]: 0 : WriteAreaLink(aCell);
2981 [ # # ]: 0 : WriteAnnotation(aCell);
2982 [ # # ]: 0 : WriteDetective(aCell);
2983 : :
2984 : 0 : bool bEditCell = false;
2985 : :
2986 [ # # ]: 0 : if (!bIsEmpty)
2987 : : {
2988 [ # # ][ # # ]: 0 : if ((aCell.nType == table::CellContentType_TEXT && IsEditCell(aCell)) ||
[ # # ][ # # ]
[ # # ][ # # ]
2989 [ # # ]: 0 : (aCell.nType == table::CellContentType_FORMULA && IsMultiLineFormulaCell(aCell)))
2990 : : {
2991 : 0 : bEditCell = true;
2992 [ # # ][ # # ]: 0 : uno::Reference<text::XText> xText(xCurrentTableCellRange->getCellByPosition(aCell.aCellAddress.Column, aCell.aCellAddress.Row), uno::UNO_QUERY);
[ # # ]
2993 [ # # ]: 0 : if ( xText.is())
2994 [ # # ][ # # ]: 0 : GetTextParagraphExport()->exportText(xText, false, false);
[ # # ][ # # ]
2995 : : }
2996 : : else
2997 : : {
2998 [ # # ]: 0 : SvXMLElementExport aElemP(*this, sElemP, true, false);
2999 : 0 : bool bPrevCharWasSpace(true);
3000 [ # # ][ # # ]: 0 : if (GetCellText(aCell, aCellPos))
3001 [ # # ][ # # ]: 0 : GetTextParagraphExport()->exportText(aCell.sStringValue, bPrevCharWasSpace);
[ # # ][ # # ]
[ # # ]
3002 : : }
3003 : : }
3004 [ # # ]: 0 : WriteShapes(aCell);
3005 [ # # ]: 0 : if (!bIsEmpty)
3006 [ # # ][ # # ]: 0 : IncrementProgressBar(bEditCell);
3007 : 0 : }
3008 : :
3009 : 0 : void ScXMLExport::ExportShape(const uno::Reference < drawing::XShape >& xShape, awt::Point* pPoint)
3010 : : {
3011 [ # # ]: 0 : uno::Reference < beans::XPropertySet > xShapeProps ( xShape, uno::UNO_QUERY );
3012 : 0 : bool bIsChart( false );
3013 [ # # ]: 0 : rtl::OUString sPropCLSID (RTL_CONSTASCII_USTRINGPARAM("CLSID"));
3014 [ # # ]: 0 : rtl::OUString sPropModel (RTL_CONSTASCII_USTRINGPARAM("Model"));
3015 [ # # ]: 0 : rtl::OUString sPersistName (RTL_CONSTASCII_USTRINGPARAM("PersistName"));
3016 [ # # ]: 0 : if (xShapeProps.is())
3017 : : {
3018 : 0 : sal_Int32 nZOrder = 0;
3019 [ # # ][ # # ]: 0 : if (xShapeProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ZOrder"))) >>= nZOrder)
[ # # ][ # # ]
3020 : : {
3021 : 0 : rtl::OUStringBuffer sBuffer;
3022 [ # # ]: 0 : ::sax::Converter::convertNumber(sBuffer, nZOrder);
3023 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_DRAW, XML_ZINDEX, sBuffer.makeStringAndClear());
3024 : : }
3025 [ # # ][ # # ]: 0 : uno::Reference< beans::XPropertySetInfo > xPropSetInfo = xShapeProps->getPropertySetInfo();
3026 [ # # ][ # # ]: 0 : if( xPropSetInfo->hasPropertyByName( sPropCLSID ) )
[ # # ]
3027 : : {
3028 : 0 : rtl::OUString sCLSID;
3029 [ # # ][ # # ]: 0 : if (xShapeProps->getPropertyValue( sPropCLSID ) >>= sCLSID)
[ # # ]
3030 : : {
3031 [ # # ][ # # ]: 0 : if ( sCLSID.equalsIgnoreAsciiCase(GetChartExport()->getChartCLSID()) )
[ # # ][ # # ]
[ # # ]
3032 : : {
3033 : : // we have a chart
3034 : 0 : ::rtl::OUString sRanges;
3035 [ # # ]: 0 : if ( pDoc )
3036 : : {
3037 : 0 : ::rtl::OUString aChartName;
3038 [ # # ][ # # ]: 0 : xShapeProps->getPropertyValue( sPersistName ) >>= aChartName;
3039 [ # # ]: 0 : ScChartListenerCollection* pCollection = pDoc->GetChartListenerCollection();
3040 [ # # ]: 0 : if (pCollection)
3041 : : {
3042 [ # # ]: 0 : ScChartListener* pListener = pCollection->findByName(aChartName);
3043 [ # # ]: 0 : if (pListener)
3044 : : {
3045 [ # # ]: 0 : const ScRangeListRef& rRangeList = pListener->GetRangeList();
3046 [ # # ]: 0 : if ( rRangeList.Is() )
3047 : : {
3048 [ # # ]: 0 : ScRangeStringConverter::GetStringFromRangeList( sRanges, rRangeList, pDoc, FormulaGrammar::CONV_OOO );
3049 [ # # ]: 0 : if ( !sRanges.isEmpty() )
3050 : : {
3051 : 0 : bIsChart = true;
3052 [ # # ]: 0 : SvXMLAttributeList* pAttrList = new SvXMLAttributeList();
3053 [ # # ]: 0 : if ( pAttrList )
3054 : : {
3055 : : pAttrList->AddAttribute(
3056 [ # # ][ # # ]: 0 : GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_DRAW, GetXMLToken( XML_NOTIFY_ON_UPDATE_OF_RANGES ) ), sRanges );
[ # # ]
3057 : : }
3058 [ # # ][ # # ]: 0 : GetShapeExport()->exportShape( xShape, SEF_EXPORT_NO_CHART_DATA | SEF_DEFAULT, pPoint, pAttrList );
[ # # ][ # # ]
3059 : : }
3060 [ # # ]: 0 : }
3061 : : }
3062 : 0 : }
3063 : : }
3064 : :
3065 [ # # ]: 0 : if ( sRanges.isEmpty() )
3066 : : {
3067 : 0 : uno::Reference< frame::XModel > xChartModel;
3068 [ # # ][ # # ]: 0 : if( ( xShapeProps->getPropertyValue( sPropModel ) >>= xChartModel ) &&
[ # # # # ]
[ # # ]
[ # # # # ]
[ # # ]
3069 : 0 : xChartModel.is())
3070 : : {
3071 [ # # ]: 0 : uno::Reference< chart2::XChartDocument > xChartDoc( xChartModel, uno::UNO_QUERY );
3072 [ # # ]: 0 : uno::Reference< chart2::data::XDataReceiver > xReceiver( xChartModel, uno::UNO_QUERY );
3073 [ # # ][ # # ]: 0 : if( xChartDoc.is() && xReceiver.is() &&
[ # # ][ # # ]
3074 [ # # ][ # # ]: 0 : ! xChartDoc->hasInternalDataProvider())
3075 : : {
3076 : : // we have a chart that gets its data from Calc
3077 : 0 : bIsChart = true;
3078 : : uno::Sequence< ::rtl::OUString > aRepresentations(
3079 [ # # ][ # # ]: 0 : xReceiver->getUsedRangeRepresentations());
3080 : 0 : SvXMLAttributeList* pAttrList = 0;
3081 [ # # ]: 0 : if(aRepresentations.getLength())
3082 : : {
3083 : : // add the ranges used by the chart to the shape
3084 : : // element to be able to start listening after
3085 : : // load (when the chart is not yet loaded)
3086 [ # # ][ # # ]: 0 : uno::Reference< chart2::data::XRangeXMLConversion > xRangeConverter( xChartDoc->getDataProvider(), uno::UNO_QUERY );
[ # # ]
3087 [ # # ]: 0 : sRanges = lcl_RangeSequenceToString( aRepresentations, xRangeConverter );
3088 [ # # ]: 0 : pAttrList = new SvXMLAttributeList();
3089 : : pAttrList->AddAttribute(
3090 [ # # ][ # # ]: 0 : GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_DRAW, GetXMLToken(XML_NOTIFY_ON_UPDATE_OF_RANGES) ), sRanges );
[ # # ]
3091 : : }
3092 [ # # ][ # # ]: 0 : GetShapeExport()->exportShape(xShape, SEF_EXPORT_NO_CHART_DATA | SEF_DEFAULT, pPoint, pAttrList);
[ # # ][ # # ]
[ # # ]
3093 : 0 : }
3094 : 0 : }
3095 : 0 : }
3096 : : }
3097 : 0 : }
3098 : 0 : }
3099 : : }
3100 [ # # ]: 0 : if (!bIsChart)
3101 : : {
3102 : : // #i66550 HLINK_FOR_SHAPES
3103 : 0 : rtl::OUString sHlink;
3104 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
3105 [ # # ]: 0 : if ( xProps.is() )
3106 [ # # ][ # # ]: 0 : xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_HYPERLINK ) ) ) >>= sHlink;
[ # # ]
3107 : :
3108 : 0 : std::auto_ptr< SvXMLElementExport > pDrawA;
3109 : : // enlose shapes with <draw:a> element only if sHlink contains something
3110 [ # # ]: 0 : if ( !sHlink.isEmpty() )
3111 : : {
3112 : : // need to get delete the attributes that are pre-loaded
3113 : : // for the shape export ( otherwise they will become
3114 : : // attributes of the draw:a element ) This *shouldn't*
3115 : : // affect performance adversely as there are only a
3116 : : // couple of attributes involved
3117 [ # # ][ # # ]: 0 : uno::Reference< xml::sax::XAttributeList > xSaveAttribs( new SvXMLAttributeList( GetAttrList() ) );
[ # # ]
3118 [ # # ]: 0 : ClearAttrList();
3119 : : // Add Hlink
3120 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
3121 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sHlink);
3122 [ # # ][ # # ]: 0 : pDrawA.reset( new SvXMLElementExport( *this, XML_NAMESPACE_DRAW, XML_A, false, false ) );
3123 : : // Attribute list has been cleared by previous operation
3124 : : // re-add pre-loaded attributes
3125 [ # # ]: 0 : AddAttributeList( xSaveAttribs );
3126 : : }
3127 [ # # ][ # # ]: 0 : GetShapeExport()->exportShape(xShape, SEF_DEFAULT, pPoint);
[ # # ][ # # ]
[ # # ]
3128 : : }
3129 [ # # ]: 0 : IncrementProgressBar(false);
3130 : 0 : }
3131 : :
3132 : 0 : void ScXMLExport::WriteShapes(const ScMyCell& rMyCell)
3133 : : {
3134 [ # # ][ # # ]: 0 : if( rMyCell.bHasShape && !rMyCell.aShapeList.empty() && pDoc )
[ # # ][ # # ]
3135 : : {
3136 : 0 : awt::Point aPoint;
3137 : : Rectangle aRec = pDoc->GetMMRect(static_cast<SCCOL>(rMyCell.aCellAddress.Column), static_cast<SCROW>(rMyCell.aCellAddress.Row),
3138 [ # # ]: 0 : static_cast<SCCOL>(rMyCell.aCellAddress.Column), static_cast<SCROW>(rMyCell.aCellAddress.Row), static_cast<SCTAB>(rMyCell.aCellAddress.Sheet));
3139 [ # # ]: 0 : bool bNegativePage(pDoc->IsNegativePage(rMyCell.aCellAddress.Sheet));
3140 [ # # ]: 0 : if (bNegativePage)
3141 : 0 : aPoint.X = aRec.Right();
3142 : : else
3143 : 0 : aPoint.X = aRec.Left();
3144 : 0 : aPoint.Y = aRec.Top();
3145 : 0 : ScMyShapeList::const_iterator aItr = rMyCell.aShapeList.begin();
3146 : 0 : ScMyShapeList::const_iterator aEndItr(rMyCell.aShapeList.end());
3147 [ # # ]: 0 : while (aItr != aEndItr)
3148 : : {
3149 [ # # ]: 0 : if (aItr->xShape.is())
3150 : : {
3151 [ # # ]: 0 : if (bNegativePage)
3152 [ # # ][ # # ]: 0 : aPoint.X = 2 * aItr->xShape->getPosition().X + aItr->xShape->getSize().Width - aPoint.X;
[ # # ][ # # ]
3153 [ # # ][ # # ]: 0 : if ( !aItr->xShape->getShapeType().equals(sCaptionShape) )
[ # # ]
3154 : : {
3155 : 0 : rtl::OUString sEndAddress;
3156 [ # # ]: 0 : ScRangeStringConverter::GetStringFromAddress(sEndAddress, aItr->aEndAddress, pDoc, FormulaGrammar::CONV_OOO);
3157 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_END_CELL_ADDRESS, sEndAddress);
3158 : 0 : rtl::OUStringBuffer sBuffer;
3159 : 0 : GetMM100UnitConverter().convertMeasureToXML(
3160 [ # # ]: 0 : sBuffer, aItr->nEndX);
3161 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_END_X, sBuffer.makeStringAndClear());
3162 : 0 : GetMM100UnitConverter().convertMeasureToXML(
3163 [ # # ]: 0 : sBuffer, aItr->nEndY);
3164 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_END_Y, sBuffer.makeStringAndClear());
3165 : : }
3166 [ # # ]: 0 : ExportShape(aItr->xShape, &aPoint);
3167 : : }
3168 : 0 : ++aItr;
3169 : : }
3170 : : }
3171 : 0 : }
3172 : :
3173 : 4 : void ScXMLExport::WriteTableShapes()
3174 : : {
3175 : 4 : ScMyTableShapes* pTableShapes(pSharedData->GetTableShapes());
3176 [ # # ][ - + ]: 4 : if (pTableShapes && !(*pTableShapes)[nCurrentTable].empty())
[ - + ]
3177 : : {
3178 : : OSL_ENSURE(pTableShapes->size() > static_cast<size_t>(nCurrentTable), "wrong Table");
3179 [ # # ]: 0 : SvXMLElementExport aShapesElem(*this, XML_NAMESPACE_TABLE, XML_SHAPES, true, false);
3180 : 0 : ScMyTableXShapes::iterator aItr((*pTableShapes)[nCurrentTable].begin());
3181 : 0 : ScMyTableXShapes::iterator aEndItr((*pTableShapes)[nCurrentTable].end());
3182 [ # # ]: 0 : while (aItr != aEndItr)
3183 : : {
3184 [ # # ]: 0 : if (aItr->is())
3185 : : {
3186 [ # # ][ # # ]: 0 : if (pDoc->IsNegativePage(static_cast<SCTAB>(nCurrentTable)))
3187 : : {
3188 [ # # ][ # # ]: 0 : awt::Point aPoint((*aItr)->getPosition());
3189 [ # # ][ # # ]: 0 : awt::Size aSize((*aItr)->getSize());
3190 : 0 : aPoint.X += aPoint.X + aSize.Width;
3191 : 0 : aPoint.Y = 0;
3192 [ # # ]: 0 : ExportShape(*aItr, &aPoint);
3193 : : }
3194 : : else
3195 [ # # ]: 0 : ExportShape(*aItr, NULL);
3196 : : }
3197 [ # # ]: 0 : aItr = (*pTableShapes)[nCurrentTable].erase(aItr);
3198 [ # # ]: 0 : }
3199 : : }
3200 : 4 : }
3201 : :
3202 : 0 : void ScXMLExport::WriteAreaLink( const ScMyCell& rMyCell )
3203 : : {
3204 [ # # ]: 0 : if( rMyCell.bHasAreaLink )
3205 : : {
3206 : 0 : const ScMyAreaLink& rAreaLink = rMyCell.aAreaLink;
3207 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_NAME, rAreaLink.sSourceStr );
3208 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
3209 [ # # ][ # # ]: 0 : AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, GetRelativeReference(rAreaLink.sURL) );
3210 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_FILTER_NAME, rAreaLink.sFilter );
3211 [ # # ]: 0 : if( !rAreaLink.sFilterOptions.isEmpty() )
3212 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_FILTER_OPTIONS, rAreaLink.sFilterOptions );
3213 : 0 : OUStringBuffer sValue;
3214 [ # # ]: 0 : ::sax::Converter::convertNumber( sValue, rAreaLink.GetColCount() );
3215 [ # # ][ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_LAST_COLUMN_SPANNED, sValue.makeStringAndClear() );
3216 [ # # ]: 0 : ::sax::Converter::convertNumber( sValue, rAreaLink.GetRowCount() );
3217 [ # # ][ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_LAST_ROW_SPANNED, sValue.makeStringAndClear() );
3218 [ # # ]: 0 : if( rAreaLink.nRefresh )
3219 : : {
3220 : : ::sax::Converter::convertDuration( sValue,
3221 [ # # ]: 0 : (double)rAreaLink.nRefresh / 86400 );
3222 [ # # ][ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_REFRESH_DELAY, sValue.makeStringAndClear() );
3223 : : }
3224 [ # # ][ # # ]: 0 : SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_CELL_RANGE_SOURCE, true, true );
3225 : : }
3226 : 0 : }
3227 : :
3228 : 0 : void ScXMLExport::exportAnnotationMeta( const uno::Reference < drawing::XShape >& xShape)
3229 : : {
3230 [ # # ][ # # ]: 0 : if (pCurrentCell && pCurrentCell->xNoteShape.is() && pCurrentCell->xNoteShape.get() == xShape.get() && pCurrentCell->xAnnotation.is())
[ # # ][ # # ]
[ # # ]
3231 : : {
3232 [ # # ][ # # ]: 0 : rtl::OUString sAuthor(pCurrentCell->xAnnotation->getAuthor());
3233 [ # # ]: 0 : if (!sAuthor.isEmpty())
3234 : : {
3235 : : SvXMLElementExport aCreatorElem( *this, XML_NAMESPACE_DC,
3236 : : XML_CREATOR, true,
3237 [ # # ]: 0 : false );
3238 [ # # ][ # # ]: 0 : Characters(sAuthor);
3239 : : }
3240 : :
3241 [ # # ][ # # ]: 0 : String aDate(pCurrentCell->xAnnotation->getDate());
[ # # ]
3242 [ # # ]: 0 : if (pDoc)
3243 : : {
3244 [ # # ]: 0 : SvNumberFormatter* pNumForm = pDoc->GetFormatTable();
3245 : : double fDate;
3246 [ # # ]: 0 : sal_uInt32 nfIndex = pNumForm->GetFormatIndex(NF_DATE_SYS_DDMMYYYY, LANGUAGE_SYSTEM);
3247 [ # # ][ # # ]: 0 : if (pNumForm->IsNumberFormat(aDate, nfIndex, fDate))
3248 : : {
3249 : 0 : rtl::OUStringBuffer sBuf;
3250 [ # # ]: 0 : GetMM100UnitConverter().convertDateTime(sBuf, fDate,true);
3251 : : SvXMLElementExport aDateElem( *this, XML_NAMESPACE_DC,
3252 : : XML_DATE, true,
3253 [ # # ]: 0 : false );
3254 [ # # ][ # # ]: 0 : Characters(sBuf.makeStringAndClear());
[ # # ]
3255 : : }
3256 : : else
3257 : : {
3258 : : SvXMLElementExport aDateElem( *this, XML_NAMESPACE_META,
3259 : : XML_DATE_STRING, true,
3260 [ # # ]: 0 : false );
3261 [ # # ][ # # ]: 0 : Characters(rtl::OUString(aDate));
[ # # ]
3262 : : }
3263 : : }
3264 : : else
3265 : : {
3266 : : SvXMLElementExport aDateElem( *this, XML_NAMESPACE_META,
3267 : : XML_DATE_STRING, true,
3268 [ # # ]: 0 : false );
3269 [ # # ][ # # ]: 0 : Characters(rtl::OUString(aDate));
[ # # ]
3270 [ # # ]: 0 : }
3271 : : }
3272 : 0 : }
3273 : :
3274 : 0 : void ScXMLExport::WriteAnnotation(ScMyCell& rMyCell)
3275 : : {
3276 [ # # ][ # # ]: 0 : if( rMyCell.bHasAnnotation && rMyCell.xAnnotation.is())
[ # # ]
3277 : : {
3278 : :
3279 [ # # ]: 0 : if (rMyCell.xAnnotation->getIsVisible())
3280 : 0 : AddAttribute(XML_NAMESPACE_OFFICE, XML_DISPLAY, XML_TRUE);
3281 : :
3282 : 0 : pCurrentCell = &rMyCell;
3283 : :
3284 [ # # ]: 0 : if(rMyCell.xNoteShape.is())
3285 [ # # ][ # # ]: 0 : GetShapeExport()->exportShape(rMyCell.xNoteShape, SEF_DEFAULT|SEF_EXPORT_ANNOTATION, NULL);
3286 : :
3287 : 0 : pCurrentCell = NULL;
3288 : :
3289 : 0 : rMyCell.xNoteShape.clear();
3290 : : }
3291 : 0 : }
3292 : :
3293 : 0 : void ScXMLExport::WriteDetective( const ScMyCell& rMyCell )
3294 : : {
3295 [ # # ][ # # ]: 0 : if( rMyCell.bHasDetectiveObj || rMyCell.bHasDetectiveOp )
3296 : : {
3297 : 0 : const ScMyDetectiveObjVec& rObjVec = rMyCell.aDetectiveObjVec;
3298 : 0 : const ScMyDetectiveOpVec& rOpVec = rMyCell.aDetectiveOpVec;
3299 : 0 : sal_Int32 nObjCount(rObjVec.size());
3300 : 0 : sal_Int32 nOpCount(rOpVec.size());
3301 [ # # ][ # # ]: 0 : if( nObjCount || nOpCount )
3302 : : {
3303 [ # # ]: 0 : SvXMLElementExport aDetElem( *this, XML_NAMESPACE_TABLE, XML_DETECTIVE, true, true );
3304 : 0 : OUString sString;
3305 : 0 : ScMyDetectiveObjVec::const_iterator aObjItr(rObjVec.begin());
3306 : 0 : ScMyDetectiveObjVec::const_iterator aEndObjItr(rObjVec.end());
3307 [ # # ][ # # ]: 0 : while(aObjItr != aEndObjItr)
3308 : : {
3309 [ # # ]: 0 : if (aObjItr->eObjType != SC_DETOBJ_CIRCLE)
3310 : : {
3311 [ # # ][ # # ]: 0 : if( (aObjItr->eObjType == SC_DETOBJ_ARROW) || (aObjItr->eObjType == SC_DETOBJ_TOOTHERTAB))
[ # # ]
3312 : : {
3313 [ # # ]: 0 : ScRangeStringConverter::GetStringFromRange( sString, aObjItr->aSourceRange, pDoc, FormulaGrammar::CONV_OOO );
3314 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, sString );
3315 : : }
3316 [ # # ]: 0 : ScXMLConverter::GetStringFromDetObjType( sString, aObjItr->eObjType );
3317 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_DIRECTION, sString );
3318 [ # # ]: 0 : if( aObjItr->bHasError )
3319 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_CONTAINS_ERROR, XML_TRUE );
3320 : : }
3321 : : else
3322 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_MARKED_INVALID, XML_TRUE );
3323 [ # # ]: 0 : SvXMLElementExport aRangeElem( *this, XML_NAMESPACE_TABLE, XML_HIGHLIGHTED_RANGE, true, true );
3324 : 0 : ++aObjItr;
3325 [ # # ]: 0 : }
3326 : 0 : OUStringBuffer aBuffer;
3327 : 0 : ScMyDetectiveOpVec::const_iterator aOpItr(rOpVec.begin());
3328 : 0 : ScMyDetectiveOpVec::const_iterator aEndOpItr(rOpVec.end());
3329 [ # # ][ # # ]: 0 : while(aOpItr != aEndOpItr)
3330 : : {
3331 : 0 : OUString sOpString;
3332 [ # # ]: 0 : ScXMLConverter::GetStringFromDetOpType( sOpString, aOpItr->eOpType );
3333 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_NAME, sOpString );
3334 [ # # ]: 0 : ::sax::Converter::convertNumber( aBuffer, aOpItr->nIndex );
3335 [ # # ][ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_INDEX, aBuffer.makeStringAndClear() );
3336 [ # # ]: 0 : SvXMLElementExport aRangeElem( *this, XML_NAMESPACE_TABLE, XML_OPERATION, true, true );
3337 : 0 : ++aOpItr;
3338 [ # # ][ # # ]: 0 : }
3339 : : }
3340 : : }
3341 : 0 : }
3342 : :
3343 : 0 : void ScXMLExport::SetRepeatAttribute(sal_Int32 nEqualCellCount, bool bIncProgress)
3344 : : {
3345 : : // nEqualCellCount is additional cells, so the attribute value is nEqualCellCount+1
3346 [ # # ]: 0 : if (nEqualCellCount > 0)
3347 : : {
3348 : 0 : sal_Int32 nTemp(nEqualCellCount + 1);
3349 : 0 : OUString sOUEqualCellCount(OUString::valueOf(nTemp));
3350 [ # # ]: 0 : AddAttribute(sAttrColumnsRepeated, sOUEqualCellCount);
3351 [ # # ]: 0 : if (bIncProgress)
3352 [ # # ]: 0 : IncrementProgressBar(sal_False, nEqualCellCount);
3353 : : }
3354 : 0 : }
3355 : :
3356 : 0 : bool ScXMLExport::IsCellTypeEqual (const ScMyCell& aCell1, const ScMyCell& aCell2) const
3357 : : {
3358 : 0 : return (aCell1.nType == aCell2.nType);
3359 : : }
3360 : :
3361 : 0 : bool ScXMLExport::IsEditCell(const com::sun::star::table::CellAddress& aAddress, ScMyCell* pMyCell) const
3362 : : {
3363 : : ScAddress aCoreAddress(static_cast<SCCOL>(aAddress.Column),
3364 : : static_cast<SCROW>(aAddress.Row),
3365 : 0 : static_cast<SCTAB>(aAddress.Sheet));
3366 [ # # ][ # # ]: 0 : ScBaseCell* pBaseCell = GetDocument() ? GetDocument()->GetCell(aCoreAddress) : NULL;
3367 [ # # ]: 0 : if (pMyCell)
3368 : 0 : pMyCell->pBaseCell = pBaseCell;
3369 : :
3370 [ # # ]: 0 : if (pBaseCell)
3371 : 0 : return (pBaseCell->GetCellType() == CELLTYPE_EDIT);
3372 : 0 : return false;
3373 : : }
3374 : :
3375 : 0 : bool ScXMLExport::IsEditCell(ScMyCell& rCell) const
3376 : : {
3377 [ # # ]: 0 : if (rCell.bKnowWhetherIsEditCell)
3378 : 0 : return rCell.bIsEditCell;
3379 : : else
3380 : : {
3381 : 0 : rCell.bIsEditCell = IsEditCell(rCell.aCellAddress, &rCell);
3382 : 0 : rCell.bKnowWhetherIsEditCell = true;
3383 : 0 : return rCell.bIsEditCell;
3384 : : }
3385 : : }
3386 : :
3387 : 0 : bool ScXMLExport::IsMultiLineFormulaCell(ScMyCell& rCell) const
3388 : : {
3389 [ # # ]: 0 : if (rCell.pBaseCell)
3390 : : {
3391 [ # # ]: 0 : if (rCell.pBaseCell->GetCellType() != CELLTYPE_FORMULA)
3392 : 0 : return false;
3393 : :
3394 [ # # ][ # # ]: 0 : return static_cast<ScFormulaCell*>(rCell.pBaseCell)->IsMultilineResult();
3395 : : }
3396 : :
3397 : : ScAddress aAddr(static_cast<SCCOL>(rCell.aCellAddress.Column),
3398 : : static_cast<SCROW>(rCell.aCellAddress.Row),
3399 : 0 : static_cast<SCTAB>(rCell.aCellAddress.Sheet));
3400 [ # # ][ # # ]: 0 : ScBaseCell* pBaseCell = pDoc ? pDoc->GetCell(aAddr) : NULL;
3401 [ # # ]: 0 : if (!pBaseCell)
3402 : 0 : return false;
3403 : :
3404 : 0 : rCell.pBaseCell = pBaseCell;
3405 [ # # ]: 0 : if (rCell.pBaseCell->GetCellType() != CELLTYPE_FORMULA)
3406 : 0 : return false;
3407 : :
3408 [ # # ][ # # ]: 0 : return static_cast<ScFormulaCell*>(rCell.pBaseCell)->IsMultilineResult();
3409 : : }
3410 : :
3411 : 0 : bool ScXMLExport::IsCellEqual (ScMyCell& aCell1, ScMyCell& aCell2)
3412 : : {
3413 : 0 : ScAddress aCellPos1;
3414 : 0 : ScUnoConversion::FillScAddress( aCellPos1, aCell1.aCellAddress );
3415 : 0 : ScAddress aCellPos2;
3416 : 0 : ScUnoConversion::FillScAddress( aCellPos2, aCell2.aCellAddress );
3417 : 0 : bool bIsEqual = false;
3418 [ # # ][ # # ]: 0 : if( !aCell1.bIsMergedBase && !aCell2.bIsMergedBase &&
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3419 : : aCell1.bIsCovered == aCell2.bIsCovered &&
3420 : 0 : !aCell1.bIsMatrixBase && !aCell2.bIsMatrixBase &&
3421 : : aCell1.bIsMatrixCovered == aCell2.bIsMatrixCovered &&
3422 : : aCell1.bHasAnnotation == aCell2.bHasAnnotation &&
3423 : 0 : !aCell1.bHasShape && !aCell2.bHasShape &&
3424 : : aCell1.bHasAreaLink == aCell2.bHasAreaLink &&
3425 : 0 : !aCell1.bHasDetectiveObj && !aCell2.bHasDetectiveObj)
3426 : : {
3427 [ # # # # : 0 : if( (aCell1.bHasAreaLink &&
# # ][ # # ]
[ # # ][ # # ]
3428 : 0 : (aCell1.aAreaLink.GetColCount() == 1) &&
3429 : 0 : (aCell2.aAreaLink.GetColCount() == 1) &&
3430 [ # # ]: 0 : aCell1.aAreaLink.Compare( aCell2.aAreaLink ) ) ||
3431 : 0 : !aCell1.bHasAreaLink )
3432 : : {
3433 [ # # ]: 0 : if (!aCell1.bHasAnnotation || (aCell1.bHasAnnotation && false/*IsAnnotationEqual(aCell1.xCell, aCell2.xCell)*/)) // no longer compareable
3434 : : {
3435 [ # # ][ # # ]: 0 : if ((((aCell1.nStyleIndex == aCell2.nStyleIndex) && (aCell1.bIsAutoStyle == aCell2.bIsAutoStyle)) ||
[ # # ][ # # ]
[ # # # # ]
[ # # ]
3436 : : ((aCell1.nStyleIndex == aCell2.nStyleIndex) && (aCell1.nStyleIndex == -1))) &&
3437 : : (aCell1.nValidationIndex == aCell2.nValidationIndex) &&
3438 : 0 : IsCellTypeEqual(aCell1, aCell2))
3439 : : {
3440 [ # # # # : 0 : switch ( aCell1.nType )
# ]
3441 : : {
3442 : : case table::CellContentType_EMPTY :
3443 : : {
3444 : 0 : bIsEqual = true;
3445 : : }
3446 : 0 : break;
3447 : : case table::CellContentType_VALUE :
3448 : : {
3449 [ # # ]: 0 : if(!aCell1.bHasDoubleValue)
3450 : : {
3451 [ # # ]: 0 : aCell1.fValue = pDoc->GetValue( aCellPos1 );
3452 : 0 : aCell1.bHasDoubleValue = true;
3453 : : }
3454 [ # # ]: 0 : if (!aCell2.bHasDoubleValue)
3455 : : {
3456 [ # # ]: 0 : aCell2.fValue = pDoc->GetValue( aCellPos2 );
3457 : 0 : aCell2.bHasDoubleValue = true;
3458 : : }
3459 : : // #i29101# number format may be different from column default styles,
3460 : : // but can lead to different value types, so it must also be compared
3461 : : bIsEqual = (aCell1.nNumberFormat == aCell2.nNumberFormat) &&
3462 [ # # ][ # # ]: 0 : (aCell1.fValue == aCell2.fValue);
3463 : : }
3464 : 0 : break;
3465 : : case table::CellContentType_TEXT :
3466 : : {
3467 [ # # ][ # # ]: 0 : if (IsEditCell(aCell1) || IsEditCell(aCell2))
[ # # ][ # # ]
[ # # ]
3468 : 0 : bIsEqual = false;
3469 : : else
3470 : : {
3471 [ # # ][ # # ]: 0 : if (GetCellText(aCell1, aCellPos1) && GetCellText(aCell2, aCellPos2))
[ # # ][ # # ]
[ # # ]
3472 : : {
3473 : 0 : bIsEqual = (aCell1.sStringValue == aCell2.sStringValue) &&
3474 [ # # ][ # # ]: 0 : (lcl_GetRawString(pDoc, aCellPos1) == lcl_GetRawString(pDoc, aCellPos2));
[ # # ][ # # ]
[ # # ]
[ # # # # ]
[ # # ]
3475 : : }
3476 : : else
3477 : 0 : bIsEqual = false;
3478 : : }
3479 : : }
3480 : 0 : break;
3481 : : case table::CellContentType_FORMULA :
3482 : : {
3483 : 0 : bIsEqual = false;
3484 : : }
3485 : 0 : break;
3486 : : default :
3487 : : {
3488 : 0 : bIsEqual = false;
3489 : : }
3490 : 0 : break;
3491 : : }
3492 : : }
3493 : : }
3494 : : }
3495 : : }
3496 : 0 : return bIsEqual;
3497 : : }
3498 : :
3499 : 4 : void ScXMLExport::WriteCalculationSettings(const uno::Reference <sheet::XSpreadsheetDocument>& xSpreadDoc)
3500 : : {
3501 [ + - ]: 4 : uno::Reference<beans::XPropertySet> xPropertySet(xSpreadDoc, uno::UNO_QUERY);
3502 [ + - ]: 4 : if (xPropertySet.is())
3503 : : {
3504 [ + - ][ + - ]: 4 : bool bCalcAsShown (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_CALCASSHOWN))) ));
[ + - ][ + - ]
3505 [ + - ][ + - ]: 4 : bool bIgnoreCase (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_IGNORECASE))) ));
[ + - ][ + - ]
3506 [ + - ][ + - ]: 4 : bool bLookUpLabels (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_LOOKUPLABELS))) ));
[ + - ][ + - ]
3507 [ + - ][ + - ]: 4 : bool bMatchWholeCell (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_MATCHWHOLE))) ));
[ + - ][ + - ]
3508 [ + - ][ + - ]: 4 : bool bUseRegularExpressions (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_REGEXENABLED))) ));
[ + - ][ + - ]
3509 [ + - ][ + - ]: 4 : bool bIsIterationEnabled (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_ITERENABLED))) ));
[ + - ][ + - ]
3510 [ + - ][ + - ]: 4 : sal_uInt16 nYear2000 (pDoc ? pDoc->GetDocOptions().GetYear2000() : 0);
3511 : 4 : sal_Int32 nIterationCount(100);
3512 [ + - ][ + - ]: 4 : xPropertySet->getPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_ITERCOUNT))) >>= nIterationCount;
[ + - ]
3513 : 4 : double fIterationEpsilon = 0;
3514 [ + - ][ + - ]: 4 : xPropertySet->getPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_ITEREPSILON))) >>= fIterationEpsilon;
[ + - ]
3515 : 4 : util::Date aNullDate;
3516 [ + - ][ + - ]: 4 : xPropertySet->getPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_NULLDATE))) >>= aNullDate;
[ + - ][ + - ]
3517 [ + - ][ + - ]: 8 : if (bCalcAsShown || bIgnoreCase || !bLookUpLabels || !bMatchWholeCell || !bUseRegularExpressions ||
[ + - ][ + - ]
[ + - ]
[ + - + - ]
[ + - ][ + - ]
[ + - ][ - + ]
[ - + ][ + - ]
3518 : 4 : bIsIterationEnabled || nIterationCount != 100 || !::rtl::math::approxEqual(fIterationEpsilon, 0.001) ||
3519 : : aNullDate.Day != 30 || aNullDate.Month != 12 || aNullDate.Year != 1899 || nYear2000 != 1930)
3520 : : {
3521 [ # # ]: 0 : if (bIgnoreCase)
3522 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_FALSE);
3523 [ # # ]: 0 : if (bCalcAsShown)
3524 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_PRECISION_AS_SHOWN, XML_TRUE);
3525 [ # # ]: 0 : if (!bMatchWholeCell)
3526 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_SEARCH_CRITERIA_MUST_APPLY_TO_WHOLE_CELL, XML_FALSE);
3527 [ # # ]: 0 : if (!bLookUpLabels)
3528 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_AUTOMATIC_FIND_LABELS, XML_FALSE);
3529 [ # # ]: 0 : if (!bUseRegularExpressions)
3530 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_USE_REGULAR_EXPRESSIONS, XML_FALSE);
3531 [ # # ]: 0 : if (nYear2000 != 1930)
3532 : : {
3533 : 0 : rtl::OUStringBuffer sBuffer;
3534 [ # # ]: 0 : ::sax::Converter::convertNumber(sBuffer, nYear2000);
3535 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NULL_YEAR, sBuffer.makeStringAndClear());
3536 : : }
3537 [ # # ]: 0 : SvXMLElementExport aCalcSettings(*this, XML_NAMESPACE_TABLE, XML_CALCULATION_SETTINGS, true, true);
3538 : : {
3539 [ # # ][ # # ]: 0 : if (aNullDate.Day != 30 || aNullDate.Month != 12 || aNullDate.Year != 1899)
[ # # ]
3540 : : {
3541 : 0 : rtl::OUStringBuffer sDate;
3542 [ # # ]: 0 : GetMM100UnitConverter().convertDateTime(sDate, 0.0, aNullDate);
3543 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_DATE_VALUE, sDate.makeStringAndClear());
3544 [ # # ][ # # ]: 0 : SvXMLElementExport aElemNullDate(*this, XML_NAMESPACE_TABLE, XML_NULL_DATE, true, true);
3545 : : }
3546 [ # # ][ # # ]: 0 : if (bIsIterationEnabled || nIterationCount != 100 || !::rtl::math::approxEqual(fIterationEpsilon, 0.001))
[ # # ][ # # ]
3547 : : {
3548 : 0 : rtl::OUStringBuffer sBuffer;
3549 [ # # ]: 0 : if (bIsIterationEnabled)
3550 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_STATUS, XML_ENABLE);
3551 [ # # ]: 0 : if (nIterationCount != 100)
3552 : : {
3553 : : ::sax::Converter::convertNumber(sBuffer,
3554 [ # # ]: 0 : nIterationCount);
3555 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_STEPS, sBuffer.makeStringAndClear());
3556 : : }
3557 [ # # ]: 0 : if (!::rtl::math::approxEqual(fIterationEpsilon, 0.001))
3558 : : {
3559 : : ::sax::Converter::convertDouble(sBuffer,
3560 [ # # ]: 0 : fIterationEpsilon);
3561 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_MAXIMUM_DIFFERENCE, sBuffer.makeStringAndClear());
3562 : : }
3563 [ # # ][ # # ]: 0 : SvXMLElementExport aElemIteration(*this, XML_NAMESPACE_TABLE, XML_ITERATION, true, true);
3564 : : }
3565 [ # # ]: 4 : }
3566 : : }
3567 : 4 : }
3568 : 4 : }
3569 : :
3570 : 4 : void ScXMLExport::WriteTableSource()
3571 : : {
3572 [ + - ]: 4 : uno::Reference <sheet::XSheetLinkable> xLinkable (xCurrentTable, uno::UNO_QUERY);
3573 [ + - ][ + - ]: 4 : if (xLinkable.is() && GetModel().is())
[ + - ]
3574 : : {
3575 [ + - ][ + - ]: 4 : sheet::SheetLinkMode nMode (xLinkable->getLinkMode());
3576 [ - + ]: 4 : if (nMode != sheet::SheetLinkMode_NONE)
3577 : : {
3578 [ # # ][ # # ]: 0 : rtl::OUString sLink (xLinkable->getLinkUrl());
3579 [ # # ]: 0 : uno::Reference <beans::XPropertySet> xProps (GetModel(), uno::UNO_QUERY);
3580 [ # # ]: 0 : if (xProps.is())
3581 : : {
3582 [ # # ][ # # ]: 0 : uno::Reference <container::XIndexAccess> xIndex(xProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_SHEETLINKS))), uno::UNO_QUERY);
[ # # ][ # # ]
3583 [ # # ]: 0 : if (xIndex.is())
3584 : : {
3585 [ # # ][ # # ]: 0 : sal_Int32 nCount(xIndex->getCount());
3586 [ # # ]: 0 : if (nCount)
3587 : : {
3588 : 0 : bool bFound(false);
3589 : 0 : uno::Reference <beans::XPropertySet> xLinkProps;
3590 [ # # ][ # # ]: 0 : for (sal_Int32 i = 0; (i < nCount) && !bFound; ++i)
[ # # ]
3591 : : {
3592 [ # # ][ # # ]: 0 : xLinkProps.set(xIndex->getByIndex(i), uno::UNO_QUERY);
[ # # ]
3593 [ # # ]: 0 : if (xLinkProps.is())
3594 : : {
3595 : 0 : rtl::OUString sNewLink;
3596 [ # # ][ # # ]: 0 : if (xLinkProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_LINKURL))) >>= sNewLink)
[ # # ][ # # ]
3597 : 0 : bFound = sLink.equals(sNewLink);
3598 : : }
3599 : : }
3600 [ # # ][ # # ]: 0 : if (bFound && xLinkProps.is())
[ # # ]
3601 : : {
3602 : 0 : rtl::OUString sFilter;
3603 : 0 : rtl::OUString sFilterOptions;
3604 [ # # ][ # # ]: 0 : rtl::OUString sTableName (xLinkable->getLinkSheetName());
3605 : 0 : sal_Int32 nRefresh(0);
3606 [ # # ][ # # ]: 0 : xLinkProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_FILTER))) >>= sFilter;
[ # # ]
3607 [ # # ][ # # ]: 0 : xLinkProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_FILTOPT))) >>= sFilterOptions;
[ # # ]
3608 [ # # ][ # # ]: 0 : xLinkProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_REFDELAY))) >>= nRefresh;
[ # # ]
3609 [ # # ]: 0 : if (!sLink.isEmpty())
3610 : : {
3611 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE);
3612 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetRelativeReference(sLink));
3613 [ # # ]: 0 : if (!sTableName.isEmpty())
3614 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_TABLE_NAME, sTableName);
3615 [ # # ]: 0 : if (!sFilter.isEmpty())
3616 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_FILTER_NAME, sFilter);
3617 [ # # ]: 0 : if (!sFilterOptions.isEmpty())
3618 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_FILTER_OPTIONS, sFilterOptions);
3619 [ # # ]: 0 : if (nMode != sheet::SheetLinkMode_NORMAL)
3620 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_MODE, XML_COPY_RESULTS_ONLY);
3621 [ # # ]: 0 : if( nRefresh )
3622 : : {
3623 : 0 : rtl::OUStringBuffer sBuffer;
3624 : : ::sax::Converter::convertDuration( sBuffer,
3625 [ # # ]: 0 : (double)nRefresh / 86400 );
3626 [ # # ][ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_REFRESH_DELAY, sBuffer.makeStringAndClear() );
3627 : : }
3628 [ # # ][ # # ]: 0 : SvXMLElementExport aSourceElem(*this, XML_NAMESPACE_TABLE, XML_TABLE_SOURCE, true, true);
3629 : 0 : }
3630 : 0 : }
3631 : : }
3632 : 0 : }
3633 : 0 : }
3634 : : }
3635 : 4 : }
3636 : 4 : }
3637 : :
3638 : : // core implementation
3639 : 4 : void ScXMLExport::WriteScenario()
3640 : : {
3641 [ + - ][ - + ]: 4 : if (pDoc && pDoc->IsScenario(static_cast<SCTAB>(nCurrentTable)))
[ - + ]
3642 : : {
3643 : 0 : rtl::OUString sComment;
3644 : 0 : Color aColor;
3645 : : sal_uInt16 nFlags;
3646 [ # # ]: 0 : pDoc->GetScenarioData(static_cast<SCTAB>(nCurrentTable), sComment, aColor, nFlags);
3647 [ # # ]: 0 : if (!(nFlags & SC_SCENARIO_SHOWFRAME))
3648 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY_BORDER, XML_FALSE);
3649 : 0 : rtl::OUStringBuffer aBuffer;
3650 [ # # ]: 0 : ::sax::Converter::convertColor(aBuffer, aColor.GetColor());
3651 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_BORDER_COLOR, aBuffer.makeStringAndClear());
3652 [ # # ]: 0 : if (!(nFlags & SC_SCENARIO_TWOWAY))
3653 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_COPY_BACK, XML_FALSE);
3654 [ # # ]: 0 : if (!(nFlags & SC_SCENARIO_ATTRIB))
3655 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_COPY_STYLES, XML_FALSE);
3656 [ # # ]: 0 : if (nFlags & SC_SCENARIO_VALUE)
3657 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_COPY_FORMULAS, XML_FALSE);
3658 [ # # ]: 0 : if (nFlags & SC_SCENARIO_PROTECT)
3659 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTED, XML_TRUE);
3660 : : ::sax::Converter::convertBool(aBuffer,
3661 [ # # ][ # # ]: 0 : pDoc->IsActiveScenario(static_cast<SCTAB>(nCurrentTable)));
3662 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_IS_ACTIVE, aBuffer.makeStringAndClear());
3663 [ # # ]: 0 : const ScRangeList* pRangeList = pDoc->GetScenarioRanges(static_cast<SCTAB>(nCurrentTable));
3664 : 0 : rtl::OUString sRangeListStr;
3665 [ # # ]: 0 : ScRangeStringConverter::GetStringFromRangeList( sRangeListStr, pRangeList, pDoc, FormulaGrammar::CONV_OOO );
3666 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_SCENARIO_RANGES, sRangeListStr);
3667 [ # # ]: 0 : if (!sComment.isEmpty())
3668 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_COMMENT, sComment);
3669 [ # # ][ # # ]: 0 : SvXMLElementExport aElem(*this, XML_NAMESPACE_TABLE, XML_SCENARIO, sal_True, sal_True);
3670 : : }
3671 : 4 : }
3672 : :
3673 : 4 : void ScXMLExport::WriteTheLabelRanges( const uno::Reference< sheet::XSpreadsheetDocument >& xSpreadDoc )
3674 : : {
3675 [ + - ]: 4 : uno::Reference< beans::XPropertySet > xDocProp( xSpreadDoc, uno::UNO_QUERY );
3676 [ - + ]: 8 : if( !xDocProp.is() ) return;
3677 : :
3678 : 4 : sal_Int32 nCount(0);
3679 [ + - ][ + - ]: 4 : uno::Reference< container::XIndexAccess > xColRangesIAccess(xDocProp->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNO_COLLABELRNG ) ) ), uno::UNO_QUERY);
[ + - ][ + - ]
3680 [ + - ]: 4 : if( xColRangesIAccess.is() )
3681 [ + - ][ + - ]: 4 : nCount += xColRangesIAccess->getCount();
3682 : :
3683 [ + - ][ + - ]: 4 : uno::Reference< container::XIndexAccess > xRowRangesIAccess(xDocProp->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNO_ROWLABELRNG ) ) ), uno::UNO_QUERY);
[ + - ][ + - ]
3684 [ + - ]: 4 : if( xRowRangesIAccess.is() )
3685 [ + - ][ + - ]: 4 : nCount += xRowRangesIAccess->getCount();
3686 : :
3687 [ - + ]: 4 : if( nCount )
3688 : : {
3689 [ # # ]: 0 : SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_LABEL_RANGES, true, true );
3690 [ # # ]: 0 : WriteLabelRanges( xColRangesIAccess, true );
3691 [ # # ][ # # ]: 0 : WriteLabelRanges( xRowRangesIAccess, false );
3692 [ + - ]: 4 : }
3693 : : }
3694 : :
3695 : 0 : void ScXMLExport::WriteLabelRanges( const uno::Reference< container::XIndexAccess >& xRangesIAccess, bool bColumn )
3696 : : {
3697 [ # # ]: 0 : if( !xRangesIAccess.is() ) return;
3698 : :
3699 : 0 : sal_Int32 nCount(xRangesIAccess->getCount());
3700 [ # # ]: 0 : for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
3701 : : {
3702 [ # # ][ # # ]: 0 : uno::Reference< sheet::XLabelRange > xRange(xRangesIAccess->getByIndex( nIndex ), uno::UNO_QUERY);
[ # # ]
3703 [ # # ]: 0 : if( xRange.is() )
3704 : : {
3705 : 0 : OUString sRangeStr;
3706 [ # # ][ # # ]: 0 : table::CellRangeAddress aCellRange( xRange->getLabelArea() );
3707 [ # # ]: 0 : ScRangeStringConverter::GetStringFromRange( sRangeStr, aCellRange, pDoc, FormulaGrammar::CONV_OOO );
3708 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_LABEL_CELL_RANGE_ADDRESS, sRangeStr );
3709 [ # # ][ # # ]: 0 : aCellRange = xRange->getDataArea();
3710 [ # # ]: 0 : ScRangeStringConverter::GetStringFromRange( sRangeStr, aCellRange, pDoc, FormulaGrammar::CONV_OOO );
3711 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_DATA_CELL_RANGE_ADDRESS, sRangeStr );
3712 [ # # ][ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_ORIENTATION, bColumn ? XML_COLUMN : XML_ROW );
3713 [ # # ][ # # ]: 0 : SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_LABEL_RANGE, true, true );
3714 : : }
3715 : 0 : }
3716 : : }
3717 : :
3718 : 4 : void ScXMLExport::WriteNamedExpressions()
3719 : : {
3720 [ - + ]: 4 : if (!pDoc)
3721 : 4 : return;
3722 : 4 : ScRangeName* pNamedRanges = pDoc->GetRangeName();
3723 : 4 : WriteNamedRange(pNamedRanges);
3724 : : }
3725 : :
3726 : 4 : void ScXMLExport::WriteNamedRange(ScRangeName* pRangeName)
3727 : : {
3728 : : //write a global or local ScRangeName
3729 [ + - ]: 4 : SvXMLElementExport aElemNEs(*this, XML_NAMESPACE_TABLE, XML_NAMED_EXPRESSIONS, true, true);
3730 [ + - ][ # # ]: 4 : for (ScRangeName::iterator it = pRangeName->begin(); it != pRangeName->end(); ++it)
[ + - ][ + - ]
[ - + ]
3731 : : {
3732 [ # # ][ # # ]: 0 : AddAttribute(sAttrName, it->second->GetName());
3733 : :
3734 : 0 : rtl::OUString sBaseCellAddress;
3735 [ # # ]: 0 : ScRangeStringConverter::GetStringFromAddress( sBaseCellAddress, it->second->GetPos(), pDoc,
3736 [ # # ]: 0 : FormulaGrammar::CONV_OOO, ' ', false, SCA_ABS_3D);
3737 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_BASE_CELL_ADDRESS, sBaseCellAddress);
3738 : :
3739 [ # # ]: 0 : String sSymbol;
3740 [ # # ][ # # ]: 0 : it->second->GetSymbol(sSymbol, pDoc->GetStorageGrammar());
3741 [ # # ]: 0 : rtl::OUString sTempSymbol(sSymbol);
3742 : 0 : ScRange aRange;
3743 [ # # ][ # # ]: 0 : if (it->second->IsReference(aRange))
[ # # ]
3744 : : {
3745 : :
3746 : 0 : rtl::OUString sContent(sTempSymbol.copy(1, sTempSymbol.getLength() -2 ));
3747 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, sContent);
3748 : :
3749 [ # # ][ # # ]: 0 : sal_Int32 nRangeType = it->second->GetUnoType();
3750 : 0 : rtl::OUStringBuffer sBufferRangeType;
3751 [ # # ]: 0 : if ((nRangeType & sheet::NamedRangeFlag::COLUMN_HEADER) == sheet::NamedRangeFlag::COLUMN_HEADER)
3752 [ # # ][ # # ]: 0 : sBufferRangeType.append(GetXMLToken(XML_REPEAT_COLUMN));
3753 [ # # ]: 0 : if ((nRangeType & sheet::NamedRangeFlag::ROW_HEADER) == sheet::NamedRangeFlag::ROW_HEADER)
3754 : : {
3755 [ # # ]: 0 : if (sBufferRangeType.getLength() > 0)
3756 [ # # ]: 0 : sBufferRangeType.appendAscii(" ");
3757 [ # # ][ # # ]: 0 : sBufferRangeType.append(GetXMLToken(XML_REPEAT_ROW));
3758 : : }
3759 [ # # ]: 0 : if ((nRangeType & sheet::NamedRangeFlag::FILTER_CRITERIA) == sheet::NamedRangeFlag::FILTER_CRITERIA)
3760 : : {
3761 [ # # ]: 0 : if (sBufferRangeType.getLength() > 0)
3762 [ # # ]: 0 : sBufferRangeType.appendAscii(" ");
3763 [ # # ][ # # ]: 0 : sBufferRangeType.append(GetXMLToken(XML_FILTER));
3764 : : }
3765 [ # # ]: 0 : if ((nRangeType & sheet::NamedRangeFlag::PRINT_AREA) == sheet::NamedRangeFlag::PRINT_AREA)
3766 : : {
3767 [ # # ]: 0 : if (sBufferRangeType.getLength() > 0)
3768 [ # # ]: 0 : sBufferRangeType.appendAscii(" ");
3769 [ # # ][ # # ]: 0 : sBufferRangeType.append(GetXMLToken(XML_PRINT_RANGE));
3770 : : }
3771 [ # # ]: 0 : rtl::OUString sRangeType = sBufferRangeType.makeStringAndClear();
3772 [ # # ]: 0 : if (!sRangeType.isEmpty())
3773 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_RANGE_USABLE_AS, sRangeType);
3774 [ # # ][ # # ]: 0 : SvXMLElementExport aElemNR(*this, XML_NAMESPACE_TABLE, XML_NAMED_RANGE, true, true);
3775 : :
3776 : : }
3777 : : else
3778 : : {
3779 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_EXPRESSION, sTempSymbol);
3780 [ # # ][ # # ]: 0 : SvXMLElementExport aElemNE(*this, XML_NAMESPACE_TABLE, XML_NAMED_EXPRESSION, true, true);
3781 : : }
3782 [ # # ][ + - ]: 4 : }
3783 : 4 : }
3784 : :
3785 : : namespace {
3786 : :
3787 : 0 : rtl::OUString getCondFormatEntryType(const ScColorScaleEntry& rEntry)
3788 : : {
3789 [ # # # # : 0 : switch(rEntry.GetType())
# # # #
# ]
3790 : : {
3791 : : case COLORSCALE_MIN:
3792 : 0 : return rtl::OUString("minimum");
3793 : : case COLORSCALE_MAX:
3794 : 0 : return rtl::OUString("maximum");
3795 : : case COLORSCALE_PERCENT:
3796 : 0 : return rtl::OUString("percent");
3797 : : case COLORSCALE_PERCENTILE:
3798 : 0 : return rtl::OUString("percentile");
3799 : : case COLORSCALE_FORMULA:
3800 : 0 : return rtl::OUString("formula");
3801 : : case COLORSCALE_VALUE:
3802 : 0 : return rtl::OUString("number");
3803 : : case COLORSCALE_AUTOMIN:
3804 : 0 : return rtl::OUString("auto-minimum");
3805 : : case COLORSCALE_AUTOMAX:
3806 : 0 : return rtl::OUString("auto-maximum");
3807 : : }
3808 : 0 : return rtl::OUString();
3809 : : }
3810 : :
3811 : : }
3812 : :
3813 : 4 : void ScXMLExport::ExportConditionalFormat(SCTAB nTab)
3814 : : {
3815 : 4 : ScConditionalFormatList* pCondFormatList = pDoc->GetCondFormList(nTab);
3816 [ + - ]: 4 : if(pCondFormatList)
3817 : : {
3818 [ + - ][ + - ]: 4 : if(pCondFormatList && !pCondFormatList->size())
[ + - ][ - + ]
3819 : 4 : return;
3820 : :
3821 [ # # ]: 0 : SvXMLElementExport aElementCondFormats(*this, XML_NAMESPACE_CALC_EXT, XML_CONDITIONAL_FORMATS, true, true);
3822 : :
3823 [ # # ]: 0 : if(pCondFormatList)
3824 : : {
3825 [ # # ][ # # ]: 0 : for(ScConditionalFormatList::const_iterator itr = pCondFormatList->begin();
[ # # ][ # # ]
[ # # ]
3826 [ # # ]: 0 : itr != pCondFormatList->end(); ++itr)
3827 : : {
3828 : 0 : rtl::OUString sRanges;
3829 [ # # ]: 0 : const ScRangeList& rRangeList = itr->GetRange();
3830 [ # # ]: 0 : ScRangeStringConverter::GetStringFromRangeList( sRanges, &rRangeList, pDoc, formula::FormulaGrammar::CONV_ODF );
3831 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_TARGET_RANGE_ADDRESS, sRanges);
3832 [ # # ]: 0 : SvXMLElementExport aElementCondFormat(*this, XML_NAMESPACE_CALC_EXT, XML_CONDITIONAL_FORMAT, true, true);
3833 [ # # ][ # # ]: 0 : size_t nEntries = itr->size();
3834 [ # # ]: 0 : for(size_t i = 0; i < nEntries; ++i)
3835 : : {
3836 [ # # ][ # # ]: 0 : const ScFormatEntry* pFormatEntry = itr->GetEntry(i);
3837 [ # # ][ # # ]: 0 : if(pFormatEntry->GetType()==condformat::CONDITION)
3838 : : {
3839 : 0 : const ScCondFormatEntry* pEntry = static_cast<const ScCondFormatEntry*>(pFormatEntry);
3840 : 0 : rtl::OUStringBuffer aCond;
3841 : 0 : ScAddress aPos = pEntry->GetSrcPos();
3842 [ # # # # : 0 : switch(pEntry->GetOperation())
# # # # #
# # # # ]
3843 : : {
3844 : : case SC_COND_EQUAL:
3845 [ # # ]: 0 : aCond.append('=');
3846 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3847 : 0 : break;
3848 : : case SC_COND_LESS:
3849 [ # # ]: 0 : aCond.append('<');
3850 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3851 : 0 : break;
3852 : : case SC_COND_GREATER:
3853 [ # # ]: 0 : aCond.append('>');
3854 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3855 : 0 : break;
3856 : : case SC_COND_EQLESS:
3857 [ # # ]: 0 : aCond.append("<=");
3858 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3859 : 0 : break;
3860 : : case SC_COND_EQGREATER:
3861 [ # # ]: 0 : aCond.append(">=");
3862 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3863 : 0 : break;
3864 : : case SC_COND_NOTEQUAL:
3865 [ # # ]: 0 : aCond.append("!=");
3866 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3867 : 0 : break;
3868 : : case SC_COND_BETWEEN:
3869 [ # # ]: 0 : aCond.append(rtl::OUString("between("));
3870 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3871 [ # # ]: 0 : aCond.append(',');
3872 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 1, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3873 [ # # ]: 0 : aCond.append(')');
3874 : 0 : break;
3875 : : case SC_COND_NOTBETWEEN:
3876 [ # # ]: 0 : aCond.append(rtl::OUString("not-between("));
3877 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3878 [ # # ]: 0 : aCond.append(',');
3879 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 1, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3880 [ # # ]: 0 : aCond.append(')');
3881 : 0 : break;
3882 : : case SC_COND_DUPLICATE:
3883 [ # # ]: 0 : aCond.append("duplicate");
3884 : 0 : break;
3885 : : case SC_COND_NOTDUPLICATE:
3886 [ # # ]: 0 : aCond.append("unique");
3887 : 0 : break;
3888 : : case SC_COND_DIRECT:
3889 [ # # ]: 0 : aCond.append("formula-is(");
3890 [ # # ][ # # ]: 0 : aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
[ # # ][ # # ]
3891 [ # # ]: 0 : aCond.append(')');
3892 : 0 : break;
3893 : : case SC_COND_NONE:
3894 : 0 : continue;
3895 : : }
3896 [ # # ]: 0 : rtl::OUString sStyle = pEntry->GetStyle();
3897 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_APPLY_STYLE_NAME, sStyle);
3898 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_VALUE, aCond.makeStringAndClear());
3899 : :
3900 : 0 : rtl::OUString sBaseAddress;
3901 [ # # ]: 0 : ScRangeStringConverter::GetStringFromAddress( sBaseAddress, aPos, pDoc,formula::FormulaGrammar::CONV_ODF );
3902 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_BASE_CELL_ADDRESS, sBaseAddress);
3903 [ # # ][ # # ]: 0 : SvXMLElementExport aElementCondEntry(*this, XML_NAMESPACE_CALC_EXT, XML_CONDITION, true, true);
[ # # ]
3904 : : }
3905 [ # # ][ # # ]: 0 : else if(pFormatEntry->GetType() == condformat::COLORSCALE)
3906 : : {
3907 [ # # ]: 0 : SvXMLElementExport aElementColorScale(*this, XML_NAMESPACE_CALC_EXT, XML_COLOR_SCALE, true, true);
3908 : 0 : const ScColorScaleFormat& mrColorScale = static_cast<const ScColorScaleFormat&>(*pFormatEntry);
3909 [ # # ][ # # ]: 0 : for(ScColorScaleFormat::const_iterator it = mrColorScale.begin();
[ # # ][ # # ]
3910 [ # # ]: 0 : it != mrColorScale.end(); ++it)
3911 : : {
3912 [ # # ][ # # ]: 0 : if(it->GetType() == COLORSCALE_FORMULA)
[ # # ]
3913 : : {
3914 [ # # ][ # # ]: 0 : rtl::OUString sFormula = it->GetFormula(formula::FormulaGrammar::GRAM_ODFF);
3915 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_VALUE, sFormula);
3916 : : }
3917 : : else
3918 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_VALUE, rtl::OUString::valueOf(it->GetValue()));
[ # # ]
3919 : :
3920 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_TYPE, getCondFormatEntryType(*it));
[ # # ]
3921 : 0 : rtl::OUStringBuffer aBuffer;
3922 [ # # ][ # # ]: 0 : ::sax::Converter::convertColor(aBuffer, it->GetColor().GetColor());
[ # # ]
3923 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_COLOR, aBuffer.makeStringAndClear());
3924 [ # # ]: 0 : SvXMLElementExport aElementColorScaleEntry(*this, XML_NAMESPACE_CALC_EXT, XML_COLOR_SCALE_ENTRY, true, true);
3925 [ # # ][ # # ]: 0 : }
3926 : : }
3927 [ # # ][ # # ]: 0 : else if(pFormatEntry->GetType() == condformat::DATABAR)
3928 : : {
3929 [ # # ]: 0 : const ScDataBarFormatData* pFormatData = static_cast<const ScDataBarFormat&>(*pFormatEntry).GetDataBarData();
3930 [ # # ]: 0 : if(!pFormatData->mbGradient)
3931 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_GRADIENT, XML_FALSE);
3932 [ # # ]: 0 : if(pFormatData->mbOnlyBar)
3933 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_SHOW_VALUE, XML_FALSE);
3934 : :
3935 [ # # ]: 0 : if(pFormatData->mbNeg)
3936 : : {
3937 [ # # ]: 0 : if(pFormatData->mpNegativeColor)
3938 : : {
3939 : 0 : rtl::OUStringBuffer aBuffer;
3940 [ # # ]: 0 : ::sax::Converter::convertColor(aBuffer, pFormatData->mpNegativeColor->GetColor());
3941 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_NEGATIVE_COLOR, aBuffer.makeStringAndClear());
3942 : : }
3943 : : else
3944 : : {
3945 : 0 : rtl::OUStringBuffer aBuffer;
3946 [ # # ]: 0 : ::sax::Converter::convertColor(aBuffer, Color(COL_LIGHTRED).GetColor());
3947 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_NEGATIVE_COLOR, aBuffer.makeStringAndClear());
3948 : : }
3949 : : }
3950 : :
3951 [ # # ]: 0 : if(pFormatData->meAxisPosition != databar::AUTOMATIC)
3952 : : {
3953 [ # # ]: 0 : if(pFormatData->meAxisPosition == databar::NONE)
3954 : : {
3955 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_AXIS_POSITION, rtl::OUString("none"));
3956 : : }
3957 : : else
3958 : : {
3959 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_AXIS_POSITION, rtl::OUString("middle"));
3960 : : }
3961 : : }
3962 : :
3963 : 0 : rtl::OUStringBuffer aBuffer;
3964 [ # # ]: 0 : ::sax::Converter::convertColor(aBuffer, pFormatData->maPositiveColor.GetColor());
3965 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_POSITIVE_COLOR, aBuffer.makeStringAndClear());
3966 : :
3967 [ # # ]: 0 : aBuffer = rtl::OUStringBuffer();
3968 [ # # ]: 0 : ::sax::Converter::convertColor(aBuffer, pFormatData->maAxisColor.GetColor());
3969 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_AXIS_COLOR, aBuffer.makeStringAndClear());
3970 [ # # ]: 0 : SvXMLElementExport aElementDataBar(*this, XML_NAMESPACE_CALC_EXT, XML_DATA_BAR, true, true);
3971 : :
3972 : : {
3973 [ # # ][ # # ]: 0 : if(pFormatData->mpLowerLimit->GetType() == COLORSCALE_FORMULA)
3974 : : {
3975 [ # # ]: 0 : rtl::OUString sFormula = pFormatData->mpLowerLimit->GetFormula(formula::FormulaGrammar::GRAM_ODFF);
3976 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_VALUE, sFormula);
3977 : : }
3978 : : else
3979 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_VALUE, rtl::OUString::valueOf(pFormatData->mpLowerLimit->GetValue()));
3980 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_TYPE, getCondFormatEntryType(*pFormatData->mpLowerLimit));
3981 [ # # ][ # # ]: 0 : SvXMLElementExport aElementDataBarEntryLower(*this, XML_NAMESPACE_CALC_EXT, XML_DATA_BAR_ENTRY, true, true);
3982 : : }
3983 : :
3984 : : {
3985 [ # # ][ # # ]: 0 : if(pFormatData->mpUpperLimit->GetType() == COLORSCALE_FORMULA)
3986 : : {
3987 [ # # ]: 0 : rtl::OUString sFormula = pFormatData->mpUpperLimit->GetFormula(formula::FormulaGrammar::GRAM_ODFF);
3988 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_VALUE, sFormula);
3989 : : }
3990 : : else
3991 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_VALUE, rtl::OUString::valueOf(pFormatData->mpUpperLimit->GetValue()));
3992 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_CALC_EXT, XML_TYPE, getCondFormatEntryType(*pFormatData->mpUpperLimit));
3993 [ # # ][ # # ]: 0 : SvXMLElementExport aElementDataBarEntryUpper(*this, XML_NAMESPACE_CALC_EXT, XML_DATA_BAR_ENTRY, true, true);
3994 [ # # ]: 0 : }
3995 : : }
3996 : : }
3997 [ # # ]: 0 : }
3998 [ # # ]: 4 : }
3999 : : }
4000 : : }
4001 : :
4002 : 4 : void ScXMLExport::WriteExternalRefCaches()
4003 : : {
4004 [ - + ]: 4 : if (!pDoc)
4005 : 4 : return;
4006 : :
4007 : 4 : ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
4008 : 4 : pRefMgr->resetSrcFileData(GetOrigFileName());
4009 : 4 : sal_uInt16 nCount = pRefMgr->getExternalFileCount();
4010 [ - + ]: 4 : for (sal_uInt16 nFileId = 0; nFileId < nCount; ++nFileId)
4011 : : {
4012 [ # # ]: 0 : const OUString* pUrl = pRefMgr->getExternalFileName(nFileId);
4013 [ # # ]: 0 : if (!pUrl)
4014 : 0 : continue;
4015 : :
4016 [ # # ]: 0 : vector<OUString> aTabNames;
4017 [ # # ]: 0 : pRefMgr->getAllCachedTableNames(nFileId, aTabNames);
4018 [ # # ]: 0 : if (aTabNames.empty())
4019 : 0 : continue;
4020 : :
4021 [ # # ][ # # ]: 0 : for (vector<OUString>::const_iterator itr = aTabNames.begin(), itrEnd = aTabNames.end();
[ # # ][ # # ]
4022 : : itr != itrEnd; ++itr)
4023 : : {
4024 [ # # ]: 0 : ScExternalRefCache::TableTypeRef pTable = pRefMgr->getCacheTable(nFileId, *itr, false);
4025 [ # # ][ # # ]: 0 : if (!pTable.get() || !pTable->isReferenced())
[ # # ][ # # ]
4026 : 0 : continue;
4027 : :
4028 : 0 : OUStringBuffer aBuf;
4029 [ # # ]: 0 : aBuf.append(sal_Unicode('\''));
4030 [ # # ]: 0 : aBuf.append(*pUrl);
4031 [ # # ]: 0 : aBuf.append(sal_Unicode('\''));
4032 [ # # ]: 0 : aBuf.append(sal_Unicode('#'));
4033 [ # # ]: 0 : aBuf.append(*itr);
4034 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NAME, aBuf.makeStringAndClear());
4035 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_PRINT, GetXMLToken(XML_FALSE));
4036 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, sExternalRefTabStyleName);
4037 [ # # ]: 0 : SvXMLElementExport aElemTable(*this, XML_NAMESPACE_TABLE, XML_TABLE, true, true);
4038 : : {
4039 [ # # ]: 0 : const ScExternalRefManager::SrcFileData* pExtFileData = pRefMgr->getExternalFileData(nFileId);
4040 [ # # ]: 0 : if (pExtFileData)
4041 : : {
4042 : 0 : OUString aRelUrl;
4043 [ # # ]: 0 : if (!pExtFileData->maRelativeName.isEmpty())
4044 : 0 : aRelUrl = pExtFileData->maRelativeName;
4045 : : else
4046 [ # # ]: 0 : aRelUrl = GetRelativeReference(pExtFileData->maRelativeName);
4047 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE);
4048 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aRelUrl);
4049 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_TABLE_NAME, *itr);
4050 [ # # ]: 0 : if (!pExtFileData->maFilterName.isEmpty())
4051 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_FILTER_NAME, pExtFileData->maFilterName);
4052 [ # # ]: 0 : if (!pExtFileData->maFilterOptions.isEmpty())
4053 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_FILTER_OPTIONS, pExtFileData->maFilterOptions);
4054 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_MODE, XML_COPY_RESULTS_ONLY);
4055 : : }
4056 [ # # ][ # # ]: 0 : SvXMLElementExport aElemTableSource(*this, XML_NAMESPACE_TABLE, XML_TABLE_SOURCE, true, true);
4057 : : }
4058 : :
4059 : : // Determine maximum column count of used area, for repeated cells.
4060 : 0 : SCCOL nMaxColsUsed = 1; // assume that there is at least one cell somewhere..
4061 [ # # ]: 0 : vector<SCROW> aRows;
4062 [ # # ]: 0 : pTable->getAllRows(aRows);
4063 [ # # ][ # # ]: 0 : for (vector<SCROW>::const_iterator itrRow = aRows.begin(), itrRowEnd = aRows.end();
[ # # ][ # # ]
[ # # ]
4064 : : itrRow != itrRowEnd; ++itrRow)
4065 : : {
4066 [ # # ]: 0 : SCROW nRow = *itrRow;
4067 [ # # ]: 0 : vector<SCCOL> aCols;
4068 [ # # ]: 0 : pTable->getAllCols(nRow, aCols);
4069 [ # # ]: 0 : if (!aCols.empty())
4070 : : {
4071 [ # # ]: 0 : SCCOL nCol = aCols.back();
4072 [ # # ]: 0 : if (nMaxColsUsed <= nCol)
4073 : 0 : nMaxColsUsed = nCol + 1;
4074 : : }
4075 : 0 : }
4076 : :
4077 : : // Column definitions have to be present to make a valid file
4078 : : {
4079 [ # # ]: 0 : if (nMaxColsUsed > 1)
4080 : : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED,
4081 [ # # ]: 0 : OUString::valueOf(static_cast<sal_Int32>(nMaxColsUsed)));
4082 [ # # ][ # # ]: 0 : SvXMLElementExport aElemColumn(*this, XML_NAMESPACE_TABLE, XML_TABLE_COLUMN, true, true);
4083 : : }
4084 : :
4085 : : // Write cache content for this table.
4086 : 0 : SCROW nLastRow = 0;
4087 : 0 : bool bFirstRow = true;
4088 [ # # ][ # # ]: 0 : for (vector<SCROW>::const_iterator itrRow = aRows.begin(), itrRowEnd = aRows.end();
[ # # ][ # # ]
[ # # ]
4089 : : itrRow != itrRowEnd; ++itrRow)
4090 : : {
4091 [ # # ]: 0 : SCROW nRow = *itrRow;
4092 [ # # ]: 0 : if (bFirstRow)
4093 : : {
4094 [ # # ]: 0 : if (nRow > 0)
4095 : : {
4096 [ # # ]: 0 : if (nRow > 1)
4097 : : {
4098 : 0 : OUStringBuffer aVal;
4099 [ # # ]: 0 : aVal.append(nRow);
4100 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_REPEATED, aVal.makeStringAndClear());
4101 : : }
4102 [ # # ]: 0 : SvXMLElementExport aElemRow(*this, XML_NAMESPACE_TABLE, XML_TABLE_ROW, true, true);
4103 : 0 : OUStringBuffer aVal;
4104 [ # # ]: 0 : aVal.append(static_cast<sal_Int32>(nMaxColsUsed));
4105 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, aVal.makeStringAndClear());
4106 [ # # ][ # # ]: 0 : SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, true, true);
[ # # ]
4107 : : }
4108 : : }
4109 : : else
4110 : : {
4111 : 0 : SCROW nRowGap = nRow - nLastRow;
4112 [ # # ]: 0 : if (nRowGap > 1)
4113 : : {
4114 [ # # ]: 0 : if (nRowGap > 2)
4115 : : {
4116 : 0 : OUStringBuffer aVal;
4117 [ # # ]: 0 : aVal.append(static_cast<sal_Int32>(nRowGap-1));
4118 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_REPEATED, aVal.makeStringAndClear());
4119 : : }
4120 [ # # ]: 0 : SvXMLElementExport aElemRow(*this, XML_NAMESPACE_TABLE, XML_TABLE_ROW, true, true);
4121 : 0 : OUStringBuffer aVal;
4122 [ # # ]: 0 : aVal.append(static_cast<sal_Int32>(nMaxColsUsed));
4123 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, aVal.makeStringAndClear());
4124 [ # # ][ # # ]: 0 : SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, true, true);
[ # # ]
4125 : : }
4126 : : }
4127 [ # # ]: 0 : SvXMLElementExport aElemRow(*this, XML_NAMESPACE_TABLE, XML_TABLE_ROW, true, true);
4128 : :
4129 [ # # ]: 0 : vector<SCCOL> aCols;
4130 [ # # ]: 0 : pTable->getAllCols(nRow, aCols);
4131 : 0 : SCCOL nLastCol = 0;
4132 : 0 : bool bFirstCol = true;
4133 [ # # ][ # # ]: 0 : for (vector<SCCOL>::const_iterator itrCol = aCols.begin(), itrColEnd = aCols.end();
[ # # ][ # # ]
[ # # ]
4134 : : itrCol != itrColEnd; ++itrCol)
4135 : : {
4136 [ # # ]: 0 : SCCOL nCol = *itrCol;
4137 [ # # ]: 0 : if (bFirstCol)
4138 : : {
4139 [ # # ]: 0 : if (nCol > 0)
4140 : : {
4141 [ # # ]: 0 : if (nCol > 1)
4142 : : {
4143 : 0 : OUStringBuffer aVal;
4144 [ # # ]: 0 : aVal.append(static_cast<sal_Int32>(nCol));
4145 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, aVal.makeStringAndClear());
4146 : : }
4147 [ # # ][ # # ]: 0 : SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, true, true);
4148 : : }
4149 : : }
4150 : : else
4151 : : {
4152 : 0 : SCCOL nColGap = nCol - nLastCol;
4153 [ # # ]: 0 : if (nColGap > 1)
4154 : : {
4155 [ # # ]: 0 : if (nColGap > 2)
4156 : : {
4157 : 0 : OUStringBuffer aVal;
4158 [ # # ]: 0 : aVal.append(static_cast<sal_Int32>(nColGap-1));
4159 [ # # ][ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, aVal.makeStringAndClear());
4160 : : }
4161 [ # # ][ # # ]: 0 : SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, true, true);
4162 : : }
4163 : : }
4164 : :
4165 : : // Write out this cell.
4166 : 0 : sal_uInt32 nNumFmt = 0;
4167 [ # # ]: 0 : ScExternalRefCache::TokenRef pToken = pTable->getCell(nCol, nRow, &nNumFmt);
4168 : 0 : OUString aStrVal;
4169 [ # # ]: 0 : if (pToken.get())
4170 : : {
4171 [ # # ]: 0 : sal_Int32 nIndex = GetNumberFormatStyleIndex(nNumFmt);
4172 [ # # ]: 0 : if (nIndex >= 0)
4173 : : {
4174 [ # # ]: 0 : const OUString aStyleName = *pCellStyles->GetStyleNameByIndex(nIndex, true);
4175 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, aStyleName);
4176 : : }
4177 : :
4178 [ # # # ]: 0 : switch(pToken->GetType())
4179 : : {
4180 : : case svDouble:
4181 : : {
4182 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
4183 : 0 : OUStringBuffer aVal;
4184 [ # # ][ # # ]: 0 : aVal.append(pToken->GetDouble());
4185 [ # # ]: 0 : aStrVal = aVal.makeStringAndClear();
4186 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, aStrVal);
4187 : : }
4188 : 0 : break;
4189 : : case svString:
4190 : : {
4191 [ # # ]: 0 : AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_STRING);
4192 [ # # ][ # # ]: 0 : aStrVal = pToken->GetString();
4193 : : }
4194 : 0 : break;
4195 : : default:
4196 : : ;
4197 : : }
4198 : : }
4199 [ # # ]: 0 : SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, true, true);
4200 [ # # ]: 0 : SvXMLElementExport aElemText(*this, XML_NAMESPACE_TEXT, XML_P, true, false);
4201 [ # # ]: 0 : Characters(aStrVal);
4202 : :
4203 : 0 : nLastCol = nCol;
4204 : 0 : bFirstCol = false;
4205 [ # # ][ # # ]: 0 : }
[ # # ]
4206 : 0 : nLastRow = nRow;
4207 : 0 : bFirstRow = false;
4208 [ # # ]: 0 : }
4209 [ # # ][ # # ]: 0 : }
[ # # ]
4210 [ # # ]: 0 : }
4211 : : }
4212 : :
4213 : : // core implementation
4214 : 4 : void ScXMLExport::WriteConsolidation()
4215 : : {
4216 [ + - ]: 4 : if (pDoc)
4217 : : {
4218 : 4 : const ScConsolidateParam* pCons(pDoc->GetConsolidateDlgData());
4219 [ - + ]: 4 : if( pCons )
4220 : : {
4221 : 0 : OUString sStrData;
4222 : :
4223 [ # # ]: 0 : ScXMLConverter::GetStringFromFunction( sStrData, pCons->eFunction );
4224 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_FUNCTION, sStrData );
4225 : :
4226 : 0 : sStrData = OUString();
4227 [ # # ]: 0 : for( sal_Int32 nIndex = 0; nIndex < pCons->nDataAreaCount; ++nIndex )
4228 [ # # ]: 0 : ScRangeStringConverter::GetStringFromArea( sStrData, *pCons->ppDataAreas[ nIndex ], pDoc, FormulaGrammar::CONV_OOO, true );
4229 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_SOURCE_CELL_RANGE_ADDRESSES, sStrData );
4230 : :
4231 [ # # ]: 0 : ScRangeStringConverter::GetStringFromAddress( sStrData, ScAddress( pCons->nCol, pCons->nRow, pCons->nTab ), pDoc, FormulaGrammar::CONV_OOO );
4232 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_TARGET_CELL_ADDRESS, sStrData );
4233 : :
4234 [ # # ][ # # ]: 0 : if( pCons->bByCol && !pCons->bByRow )
4235 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_USE_LABEL, XML_COLUMN );
4236 [ # # ][ # # ]: 0 : else if( !pCons->bByCol && pCons->bByRow )
4237 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_USE_LABEL, XML_ROW );
4238 [ # # ][ # # ]: 0 : else if( pCons->bByCol && pCons->bByRow )
4239 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_USE_LABEL, XML_BOTH );
4240 : :
4241 [ # # ]: 0 : if( pCons->bReferenceData )
4242 [ # # ]: 0 : AddAttribute( XML_NAMESPACE_TABLE, XML_LINK_TO_SOURCE_DATA, XML_TRUE );
4243 : :
4244 [ # # ][ # # ]: 0 : SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_CONSOLIDATION, true, true );
4245 : : }
4246 : : }
4247 : 4 : }
4248 : :
4249 : 22 : SvXMLAutoStylePoolP* ScXMLExport::CreateAutoStylePool()
4250 : : {
4251 [ + - ]: 22 : return new ScXMLAutoStylePoolP(*this);
4252 : : }
4253 : :
4254 : 4 : XMLPageExport* ScXMLExport::CreatePageExport()
4255 : : {
4256 [ + - ]: 4 : return new XMLTableMasterPageExport( *this );
4257 : : }
4258 : :
4259 : 4 : void ScXMLExport::GetChangeTrackViewSettings(uno::Sequence<beans::PropertyValue>& rProps)
4260 : : {
4261 [ + - ]: 4 : ScChangeViewSettings* pViewSettings(GetDocument() ? GetDocument()->GetChangeViewSettings() : NULL);
4262 [ - + ]: 4 : if (pViewSettings)
4263 : : {
4264 : 0 : sal_Int32 nChangePos(rProps.getLength());
4265 : 0 : rProps.realloc(nChangePos + 1);
4266 : 0 : beans::PropertyValue* pProps(rProps.getArray());
4267 [ # # ]: 0 : if (pProps)
4268 : : {
4269 [ # # ]: 0 : uno::Sequence<beans::PropertyValue> aChangeProps(SC_VIEWCHANGES_COUNT);
4270 [ # # ]: 0 : beans::PropertyValue* pChangeProps(aChangeProps.getArray());
4271 [ # # ]: 0 : if (pChangeProps)
4272 : : {
4273 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChanges"));
4274 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES].Value <<= pViewSettings->ShowChanges();
4275 [ # # ]: 0 : pChangeProps[SC_SHOW_ACCEPTED_CHANGES].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowAcceptedChanges"));
4276 [ # # ]: 0 : pChangeProps[SC_SHOW_ACCEPTED_CHANGES].Value <<= pViewSettings->IsShowAccepted();
4277 [ # # ]: 0 : pChangeProps[SC_SHOW_REJECTED_CHANGES].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowRejectedChanges"));
4278 [ # # ]: 0 : pChangeProps[SC_SHOW_REJECTED_CHANGES].Value <<= pViewSettings->IsShowRejected();
4279 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_DATETIME].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByDatetime"));
4280 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_DATETIME].Value <<= pViewSettings->HasDate();
4281 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_MODE].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByDatetimeMode"));
4282 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_MODE].Value <<= static_cast<sal_Int16>(pViewSettings->GetTheDateMode());
4283 : 0 : util::DateTime aDateTime;
4284 [ # # ]: 0 : ScXMLConverter::ConvertCoreToAPIDateTime(pViewSettings->GetTheFirstDateTime(), aDateTime);
4285 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_FIRST_DATETIME].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByDatetimeFirstDatetime"));
4286 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_FIRST_DATETIME].Value <<= aDateTime;
4287 [ # # ]: 0 : ScXMLConverter::ConvertCoreToAPIDateTime(pViewSettings->GetTheLastDateTime(), aDateTime);
4288 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_SECOND_DATETIME].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByDatetimeSecondDatetime"));
4289 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_SECOND_DATETIME].Value <<= aDateTime;
4290 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_AUTHOR].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByAuthor"));
4291 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_AUTHOR].Value <<= pViewSettings->HasAuthor();
4292 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_AUTHOR_NAME].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByAuthorName"));
4293 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_AUTHOR_NAME].Value <<= rtl::OUString (pViewSettings->GetTheAuthorToShow());
4294 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_COMMENT].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByComment"));
4295 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_COMMENT].Value <<= pViewSettings->HasComment();
4296 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_COMMENT_TEXT].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByCommentText"));
4297 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_COMMENT_TEXT].Value <<= rtl::OUString (pViewSettings->GetTheComment());
4298 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_RANGES].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByRanges"));
4299 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_RANGES].Value <<= pViewSettings->HasRange();
4300 : 0 : rtl::OUString sRangeList;
4301 [ # # ]: 0 : ScRangeStringConverter::GetStringFromRangeList(sRangeList, &(pViewSettings->GetTheRangeList()), GetDocument(), FormulaGrammar::CONV_OOO);
4302 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_RANGES_LIST].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByRangesList"));
4303 [ # # ]: 0 : pChangeProps[SC_SHOW_CHANGES_BY_RANGES_LIST].Value <<= sRangeList;
4304 : :
4305 [ # # ]: 0 : pProps[nChangePos].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TrackedChangesViewSettings"));
4306 [ # # ]: 0 : pProps[nChangePos].Value <<= aChangeProps;
4307 [ # # ]: 0 : }
4308 : : }
4309 : : }
4310 : 4 : }
4311 : :
4312 : 4 : void ScXMLExport::GetViewSettings(uno::Sequence<beans::PropertyValue>& rProps)
4313 : : {
4314 : 4 : rProps.realloc(4);
4315 : 4 : beans::PropertyValue* pProps(rProps.getArray());
4316 [ + - ]: 4 : if(pProps)
4317 : : {
4318 [ + - ]: 4 : if (GetModel().is())
4319 : : {
4320 [ + - ]: 4 : ScModelObj* pDocObj(ScModelObj::getImplementation( GetModel() ));
4321 [ + - ]: 4 : if (pDocObj)
4322 : : {
4323 : 4 : SfxObjectShell* pEmbeddedObj = pDocObj->GetEmbeddedObject();
4324 [ + - ]: 4 : if (pEmbeddedObj)
4325 : : {
4326 [ + - ]: 4 : Rectangle aRect(pEmbeddedObj->GetVisArea());
4327 : 4 : sal_uInt16 i(0);
4328 [ + - ]: 4 : pProps[i].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VisibleAreaTop"));
4329 [ + - ]: 4 : pProps[i].Value <<= static_cast<sal_Int32>(aRect.getY());
4330 [ + - ]: 4 : pProps[++i].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VisibleAreaLeft"));
4331 [ + - ]: 4 : pProps[i].Value <<= static_cast<sal_Int32>(aRect.getX());
4332 [ + - ]: 4 : pProps[++i].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VisibleAreaWidth"));
4333 [ + - ]: 4 : pProps[i].Value <<= static_cast<sal_Int32>(aRect.getWidth());
4334 [ + - ]: 4 : pProps[++i].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VisibleAreaHeight"));
4335 [ + - ]: 4 : pProps[i].Value <<= static_cast<sal_Int32>(aRect.getHeight());
4336 : : }
4337 : : }
4338 : : }
4339 : : }
4340 : 4 : GetChangeTrackViewSettings(rProps);
4341 : 4 : }
4342 : :
4343 : :
4344 : :
4345 : :
4346 : 4 : void ScXMLExport::GetConfigurationSettings(uno::Sequence<beans::PropertyValue>& rProps)
4347 : : {
4348 [ + - ]: 4 : if (GetModel().is())
4349 : : {
4350 [ + - ]: 4 : uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
4351 [ + - ]: 4 : if (xMultiServiceFactory.is())
4352 : : {
4353 [ + - ][ + - ]: 4 : uno::Reference <beans::XPropertySet> xProperties(xMultiServiceFactory->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.SpreadsheetSettings"))), uno::UNO_QUERY);
[ + - ][ + - ]
4354 [ + - ]: 4 : if (xProperties.is())
4355 [ + - ]: 4 : SvXMLUnitConverter::convertPropertySet(rProps, xProperties);
4356 : :
4357 : 4 : sal_Int32 nPropsToAdd = 0;
4358 : 4 : rtl::OUStringBuffer aTrackedChangesKey;
4359 [ - + ][ # # ]: 4 : if (GetDocument() && GetDocument()->GetChangeTrack() && GetDocument()->GetChangeTrack()->IsProtected())
[ # # ][ - + ]
[ + - ]
4360 : : {
4361 : : ::sax::Converter::encodeBase64(aTrackedChangesKey,
4362 [ # # ][ # # ]: 0 : GetDocument()->GetChangeTrack()->GetProtection());
[ # # ]
4363 [ # # ]: 0 : if (aTrackedChangesKey.getLength())
4364 : 0 : ++nPropsToAdd;
4365 : : }
4366 : :
4367 : 4 : bool bVBACompat = false;
4368 : 4 : uno::Reference <container::XNameAccess> xCodeNameAccess;
4369 : : OSL_ENSURE( pDoc, "ScXMLExport::GetConfigurationSettings - no ScDocument!" );
4370 [ + - ][ - + ]: 4 : if( pDoc && pDoc->IsInVBAMode() )
[ - + ][ + - ]
4371 : : {
4372 : : // VBA compatibility mode
4373 : 0 : bVBACompat = true;
4374 : 0 : ++nPropsToAdd;
4375 : : // code names
4376 [ # # ][ # # ]: 0 : xCodeNameAccess = new XMLCodeNameProvider( pDoc );
[ # # ]
4377 [ # # ][ # # ]: 0 : if( xCodeNameAccess->hasElements() )
[ # # ]
4378 : 0 : ++nPropsToAdd;
4379 : : else
4380 : 0 : xCodeNameAccess.clear();
4381 : : }
4382 : :
4383 [ - + ]: 4 : if( nPropsToAdd > 0 )
4384 : : {
4385 : 0 : sal_Int32 nCount(rProps.getLength());
4386 [ # # ]: 0 : rProps.realloc(nCount + nPropsToAdd);
4387 [ # # ]: 0 : if (aTrackedChangesKey.getLength())
4388 : : {
4389 [ # # ][ # # ]: 0 : rProps[nCount].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TrackedChangesProtectionKey"));
4390 [ # # ][ # # ]: 0 : rProps[nCount].Value <<= aTrackedChangesKey.makeStringAndClear();
[ # # ]
4391 : 0 : ++nCount;
4392 : : }
4393 [ # # ]: 0 : if( bVBACompat )
4394 : : {
4395 [ # # ][ # # ]: 0 : rProps[nCount].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VBACompatibilityMode"));
4396 [ # # ][ # # ]: 0 : rProps[nCount].Value <<= bVBACompat;
4397 : 0 : ++nCount;
4398 : : }
4399 [ # # ]: 0 : if( xCodeNameAccess.is() )
4400 : : {
4401 [ # # ][ # # ]: 0 : rProps[nCount].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ScriptConfiguration"));
4402 [ # # ][ # # ]: 0 : rProps[nCount].Value <<= xCodeNameAccess;
4403 : 0 : ++nCount;
4404 : : }
4405 : 4 : }
4406 : 4 : }
4407 : : }
4408 : 4 : }
4409 : :
4410 : 8 : XMLShapeExport* ScXMLExport::CreateShapeExport()
4411 : : {
4412 [ + - ]: 8 : return new ScXMLShapeExport(*this);
4413 : : }
4414 : :
4415 : 4 : void ScXMLExport::CreateSharedData(const sal_Int32 nTableCount)
4416 : : {
4417 [ + - ]: 4 : pSharedData = new ScMySharedData(nTableCount);
4418 : 4 : }
4419 : :
4420 : 0 : XMLNumberFormatAttributesExportHelper* ScXMLExport::GetNumberFormatAttributesExportHelper()
4421 : : {
4422 [ # # ]: 0 : if (!pNumberFormatAttributesExportHelper)
4423 [ # # ]: 0 : pNumberFormatAttributesExportHelper = new XMLNumberFormatAttributesExportHelper(GetNumberFormatsSupplier(), *this );
4424 : 0 : return pNumberFormatAttributesExportHelper;
4425 : : }
4426 : :
4427 : 48 : void ScXMLExport::CollectUserDefinedNamespaces(const SfxItemPool* pPool, sal_uInt16 nAttrib)
4428 : : {
4429 : : const SfxPoolItem* pItem;
4430 : 48 : sal_uInt32 nItems(pPool->GetItemCount2( nAttrib ));
4431 [ - + ]: 48 : for( sal_uInt32 i = 0; i < nItems; ++i )
4432 : : {
4433 [ # # ]: 0 : if( 0 != (pItem = pPool->GetItem2( nAttrib, i ) ) )
4434 : : {
4435 : 0 : const SvXMLAttrContainerItem *pUnknown((const SvXMLAttrContainerItem *)pItem);
4436 [ # # ]: 0 : if( (pUnknown->GetAttrCount() > 0) )
4437 : : {
4438 : 0 : sal_uInt16 nIdx(pUnknown->GetFirstNamespaceIndex());
4439 [ # # ]: 0 : while( USHRT_MAX != nIdx )
4440 : : {
4441 [ # # ]: 0 : if( (XML_NAMESPACE_UNKNOWN_FLAG & nIdx) != 0 )
4442 : : {
4443 : 0 : const OUString& rPrefix = pUnknown->GetPrefix( nIdx );
4444 : : // Add namespace declaration for unknown attributes if
4445 : : // there aren't existing ones for the prefix used by the
4446 : : // attibutes
4447 : 0 : _GetNamespaceMap().Add( rPrefix,
4448 : 0 : pUnknown->GetNamespace( nIdx ),
4449 : 0 : XML_NAMESPACE_UNKNOWN );
4450 : : }
4451 : 0 : nIdx = pUnknown->GetNextNamespaceIndex( nIdx );
4452 : : }
4453 : : }
4454 : : }
4455 : : }
4456 : :
4457 : : // #i66550# needed for 'presentation:event-listener' element for URLs in shapes
4458 : 48 : _GetNamespaceMap().Add(
4459 : 48 : GetXMLToken( XML_NP_PRESENTATION ),
4460 : 48 : GetXMLToken( XML_N_PRESENTATION ),
4461 : 48 : XML_NAMESPACE_PRESENTATION );
4462 : 48 : }
4463 : :
4464 : 16 : void ScXMLExport::IncrementProgressBar(bool bEditCell, sal_Int32 nInc)
4465 : : {
4466 : 16 : nProgressCount += nInc;
4467 [ + + ][ - + ]: 16 : if (bEditCell || nProgressCount > 100)
4468 : : {
4469 : 4 : GetProgressBarHelper()->Increment(nProgressCount);
4470 : 4 : nProgressCount = 0;
4471 : : }
4472 : 16 : }
4473 : :
4474 : 16 : sal_uInt32 ScXMLExport::exportDoc( enum XMLTokenEnum eClass )
4475 : : {
4476 [ + + ]: 16 : if( (getExportFlags() & (EXPORT_FONTDECLS|EXPORT_STYLES|
4477 : : EXPORT_MASTERSTYLES|EXPORT_CONTENT)) != 0 )
4478 : : {
4479 [ + - ]: 8 : if (GetDocument())
4480 : : {
4481 : : // if source doc was Excel then
4482 : 8 : uno::Reference< frame::XModel > xModel = GetModel();
4483 [ + - ]: 8 : if ( xModel.is() )
4484 : : {
4485 [ + - ]: 8 : uno::Reference< lang::XUnoTunnel > xObjShellTunnel( xModel, uno::UNO_QUERY );
4486 [ + - ][ + - ]: 8 : SfxObjectShell* pFoundShell = reinterpret_cast<SfxObjectShell*>( xObjShellTunnel.is() ? xObjShellTunnel->getSomething(SfxObjectShell::getUnoTunnelId()) : 0 );
[ + - ][ + - ]
4487 [ + - ][ + - ]: 8 : if ( pFoundShell && ooo::vba::isAlienExcelDoc( *pFoundShell ) )
[ - + ][ - + ]
4488 : : {
4489 [ # # ][ # # ]: 0 : xRowStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScFromXLSRowStylesProperties, xScPropHdlFactory);
[ # # ]
4490 [ # # ][ # # ]: 0 : xRowStylesExportPropertySetMapper = new ScXMLRowExportPropertyMapper(xRowStylesPropertySetMapper);
[ # # ]
4491 : : GetAutoStylePool()->SetFamilyPropSetMapper( XML_STYLE_FAMILY_TABLE_ROW,
4492 [ # # ][ # # ]: 0 : xRowStylesExportPropertySetMapper );
[ # # ][ # # ]
4493 : 8 : }
4494 : : }
4495 [ + - ][ + - ]: 8 : CollectUserDefinedNamespaces(GetDocument()->GetPool(), ATTR_USERDEF);
4496 [ + - ][ + - ]: 8 : CollectUserDefinedNamespaces(GetDocument()->GetEditPool(), EE_PARA_XMLATTRIBS);
4497 [ + - ][ + - ]: 8 : CollectUserDefinedNamespaces(GetDocument()->GetEditPool(), EE_CHAR_XMLATTRIBS);
4498 [ + - ]: 8 : ScDrawLayer* pDrawLayer = GetDocument()->GetDrawLayer();
4499 [ + - ]: 8 : if (pDrawLayer)
4500 : : {
4501 [ + - ]: 8 : CollectUserDefinedNamespaces(&pDrawLayer->GetItemPool(), EE_PARA_XMLATTRIBS);
4502 [ + - ]: 8 : CollectUserDefinedNamespaces(&pDrawLayer->GetItemPool(), EE_CHAR_XMLATTRIBS);
4503 [ + - ]: 8 : CollectUserDefinedNamespaces(&pDrawLayer->GetItemPool(), SDRATTR_XMLATTRIBUTES);
4504 : : }
4505 : :
4506 : : // sheet events use officeooo namespace
4507 [ + + ][ + - ]: 12 : if( (getExportFlags() & EXPORT_CONTENT) != 0 &&
[ + + ]
4508 [ + - ]: 4 : getDefaultVersion() >= SvtSaveOptions::ODFVER_012 )
4509 : : {
4510 : 4 : bool bAnySheetEvents = false;
4511 [ + - ]: 4 : SCTAB nTabCount = pDoc->GetTableCount();
4512 [ + + ]: 8 : for (SCTAB nTab=0; nTab<nTabCount; ++nTab)
4513 [ + - ][ - + ]: 4 : if (pDoc->GetSheetEvents(nTab))
4514 : 0 : bAnySheetEvents = true;
4515 [ - + ]: 4 : if (bAnySheetEvents)
4516 : 0 : _GetNamespaceMap().Add(
4517 [ # # ]: 0 : GetXMLToken( XML_NP_OFFICE_EXT ),
4518 [ # # ]: 0 : GetXMLToken( XML_N_OFFICE_EXT ),
4519 [ # # ]: 0 : XML_NAMESPACE_OFFICE_EXT );
4520 : 8 : }
4521 : : }
4522 : : }
4523 : 16 : return SvXMLExport::exportDoc( eClass );
4524 : : }
4525 : :
4526 : : // XExporter
4527 : 25 : void SAL_CALL ScXMLExport::setSourceDocument( const uno::Reference<lang::XComponent>& xComponent )
4528 : : throw(lang::IllegalArgumentException, uno::RuntimeException)
4529 : : {
4530 [ + - ]: 25 : SolarMutexGuard aGuard;
4531 [ + - ]: 25 : SvXMLExport::setSourceDocument( xComponent );
4532 : :
4533 [ + - ]: 25 : pDoc = ScXMLConverter::GetScDocument( GetModel() );
4534 : : OSL_ENSURE( pDoc, "ScXMLExport::setSourceDocument - no ScDocument!" );
4535 [ - + ]: 25 : if (!pDoc)
4536 [ # # ]: 0 : throw lang::IllegalArgumentException();
4537 : :
4538 : : // create ScChangeTrackingExportHelper after document is known
4539 [ + - ][ + - ]: 25 : pChangeTrackingExportHelper = new ScChangeTrackingExportHelper(*this);
4540 : :
4541 : : // Set the document's storage grammar corresponding to the ODF version that
4542 : : // is to be written.
4543 [ + - ]: 25 : SvtSaveOptions::ODFDefaultVersion meODFDefaultVersion = getDefaultVersion();
4544 [ - + ]: 25 : switch (meODFDefaultVersion)
4545 : : {
4546 : : // ODF 1.0 and 1.1 use GRAM_PODF, everything later or unspecified GRAM_ODFF
4547 : : case SvtSaveOptions::ODFVER_010:
4548 : : case SvtSaveOptions::ODFVER_011:
4549 [ # # ]: 0 : pDoc->SetStorageGrammar( formula::FormulaGrammar::GRAM_PODF);
4550 : 0 : break;
4551 : : default:
4552 [ + - ]: 25 : pDoc->SetStorageGrammar( formula::FormulaGrammar::GRAM_ODFF);
4553 [ + - ]: 25 : }
4554 : 25 : }
4555 : :
4556 : : // XFilter
4557 : 16 : sal_Bool SAL_CALL ScXMLExport::filter( const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& aDescriptor )
4558 : : throw(::com::sun::star::uno::RuntimeException)
4559 : : {
4560 [ + - ]: 16 : SolarMutexGuard aGuard;
4561 [ + - ]: 16 : if (pDoc)
4562 : 16 : pDoc->DisableIdle(true);
4563 [ + - ]: 16 : bool bReturn(SvXMLExport::filter(aDescriptor));
4564 [ + - ]: 16 : if (pDoc)
4565 : 16 : pDoc->DisableIdle(false);
4566 [ + - ]: 16 : return bReturn;
4567 : : }
4568 : :
4569 : 0 : void SAL_CALL ScXMLExport::cancel()
4570 : : throw(::com::sun::star::uno::RuntimeException)
4571 : : {
4572 [ # # ]: 0 : SolarMutexGuard aGuard;
4573 [ # # ]: 0 : if (pDoc)
4574 : 0 : pDoc->DisableIdle(false);
4575 [ # # ][ # # ]: 0 : SvXMLExport::cancel();
4576 : 0 : }
4577 : :
4578 : : // XInitialization
4579 : 25 : void SAL_CALL ScXMLExport::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments )
4580 : : throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
4581 : : {
4582 [ + - ]: 25 : SolarMutexGuard aGuard;
4583 [ + - ][ + - ]: 25 : SvXMLExport::initialize(aArguments);
4584 : 25 : }
4585 : :
4586 : : // XServiceInfo
4587 : 0 : ::rtl::OUString SAL_CALL ScXMLExport::getImplementationName( )
4588 : : throw(::com::sun::star::uno::RuntimeException)
4589 : : {
4590 [ # # ]: 0 : SolarMutexGuard aGuard;
4591 : :
4592 : 0 : sal_uInt16 nFlags = getExportFlags();
4593 [ # # ]: 0 : if (nFlags & EXPORT_OASIS)
4594 : : {
4595 : 0 : nFlags |= EXPORT_OASIS;
4596 [ # # # # : 0 : switch( nFlags )
# # ]
4597 : : {
4598 : : case EXPORT_ALL:
4599 : 0 : return ScXMLOasisExport_getImplementationName();
4600 : : case (EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS):
4601 : 0 : return ScXMLOasisExport_Styles_getImplementationName();
4602 : : case (EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS):
4603 : 0 : return ScXMLOasisExport_Content_getImplementationName();
4604 : : case EXPORT_META:
4605 : 0 : return ScXMLOasisExport_Meta_getImplementationName();
4606 : : case EXPORT_SETTINGS:
4607 : 0 : return ScXMLOasisExport_Settings_getImplementationName();
4608 : : default:
4609 : : // generic name for 'unknown' cases
4610 : 0 : return ScXMLOasisExport_getImplementationName();
4611 : : }
4612 : : }
4613 : : else
4614 : : {
4615 [ # # # # : 0 : switch( nFlags )
# # ]
4616 : : {
4617 : : case EXPORT_ALL:
4618 : 0 : return ScXMLOOoExport_getImplementationName();
4619 : : case (EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS):
4620 : 0 : return ScXMLOOoExport_Styles_getImplementationName();
4621 : : case (EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS):
4622 : 0 : return ScXMLOOoExport_Content_getImplementationName();
4623 : : case EXPORT_META:
4624 : 0 : return ScXMLOOoExport_Meta_getImplementationName();
4625 : : case EXPORT_SETTINGS:
4626 : 0 : return ScXMLOOoExport_Settings_getImplementationName();
4627 : : default:
4628 : : // generic name for 'unknown' cases
4629 : 0 : return ScXMLOOoExport_getImplementationName();
4630 : : }
4631 [ # # ]: 0 : }
4632 : : }
4633 : :
4634 : 0 : sal_Bool SAL_CALL ScXMLExport::supportsService( const ::rtl::OUString& ServiceName )
4635 : : throw(::com::sun::star::uno::RuntimeException)
4636 : : {
4637 [ # # ]: 0 : SolarMutexGuard aGuard;
4638 [ # # ][ # # ]: 0 : return SvXMLExport::supportsService( ServiceName );
4639 : : }
4640 : :
4641 : 0 : ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL ScXMLExport::getSupportedServiceNames( )
4642 : : throw(::com::sun::star::uno::RuntimeException)
4643 : : {
4644 [ # # ]: 0 : SolarMutexGuard aGuard;
4645 [ # # ][ # # ]: 0 : return SvXMLExport::getSupportedServiceNames();
4646 : : }
4647 : :
4648 : : // XUnoTunnel
4649 : 16 : sal_Int64 SAL_CALL ScXMLExport::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& aIdentifier )
4650 : : throw(::com::sun::star::uno::RuntimeException)
4651 : : {
4652 [ + - ]: 16 : SolarMutexGuard aGuard;
4653 [ + - ][ + - ]: 16 : return SvXMLExport::getSomething(aIdentifier);
4654 : : }
4655 : :
4656 : 6 : void ScXMLExport::DisposingModel()
4657 : : {
4658 : 6 : SvXMLExport::DisposingModel();
4659 : 6 : pDoc = NULL;
4660 : 6 : xCurrentTable = 0;
4661 [ + - ][ + - ]: 159 : }
4662 : :
4663 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
