Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <sal/config.h>
21 :
22 : #include <o3tl/ptr_container.hxx>
23 : #include <svl/zforlist.hxx>
24 : #include <sal/macros.h>
25 :
26 : #include <xmloff/nmspmap.hxx>
27 : #include <xmloff/xmlnmspe.hxx>
28 : #include <xmloff/i18nmap.hxx>
29 : #include <xmloff/xmltkmap.hxx>
30 : #include <xmloff/xmlictxt.hxx>
31 : #include <xmloff/xmlmetai.hxx>
32 : #include <sfx2/objsh.hxx>
33 : #include <xmloff/xmlnumfi.hxx>
34 : #include <xmloff/xmlscripti.hxx>
35 : #include <xmloff/XMLFontStylesContext.hxx>
36 : #include <xmloff/DocumentSettingsContext.hxx>
37 : #include <xmloff/xmluconv.hxx>
38 : #include <xmloff/numehelp.hxx>
39 : #include <xmloff/xmltoken.hxx>
40 : #include <xmloff/xmlerror.hxx>
41 :
42 : #include <sax/tools/converter.hxx>
43 :
44 : #include <svl/zformat.hxx>
45 : #include <svl/languageoptions.hxx>
46 : #include <editeng/editstat.hxx>
47 :
48 : #include "appluno.hxx"
49 : #include "xmlimprt.hxx"
50 : #include "document.hxx"
51 : #include "docsh.hxx"
52 : #include "docuno.hxx"
53 : #include "nameuno.hxx"
54 : #include "xmlbodyi.hxx"
55 : #include "xmlstyli.hxx"
56 : #include "ViewSettingsSequenceDefines.hxx"
57 :
58 : #include "patattr.hxx"
59 :
60 : #include "XMLConverter.hxx"
61 : #include "XMLDetectiveContext.hxx"
62 : #include "XMLTableShapeImportHelper.hxx"
63 : #include "XMLChangeTrackingImportHelper.hxx"
64 : #include "chgviset.hxx"
65 : #include "XMLStylesImportHelper.hxx"
66 : #include "sheetdata.hxx"
67 : #include "rangeutl.hxx"
68 : #include "postit.hxx"
69 : #include "formulaparserpool.hxx"
70 : #include "externalrefmgr.hxx"
71 : #include "editutil.hxx"
72 : #include "editattributemap.hxx"
73 : #include "documentimport.hxx"
74 : #include "pivotsource.hxx"
75 : #include <unonames.hxx>
76 : #include <numformat.hxx>
77 :
78 : #include <comphelper/extract.hxx>
79 :
80 : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
81 : #include <com/sun/star/frame/XModel.hpp>
82 : #include <com/sun/star/sheet/XSheetCellRange.hpp>
83 : #include <com/sun/star/sheet/XCellRangeAddressable.hpp>
84 : #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
85 : #include <com/sun/star/util/XMergeable.hpp>
86 : #include <com/sun/star/sheet/CellInsertMode.hpp>
87 : #include <com/sun/star/sheet/XCellRangeMovement.hpp>
88 : #include <com/sun/star/document/XActionLockable.hpp>
89 : #include <com/sun/star/util/NumberFormat.hpp>
90 : #include <com/sun/star/util/XNumberFormatTypes.hpp>
91 : #include <com/sun/star/sheet/XNamedRanges.hpp>
92 : #include <com/sun/star/sheet/NamedRangeFlag.hpp>
93 : #include <com/sun/star/sheet/XNamedRange.hpp>
94 : #include <com/sun/star/sheet/XLabelRanges.hpp>
95 : #include <com/sun/star/io/XSeekable.hpp>
96 : #include <com/sun/star/beans/XPropertySet.hpp>
97 :
98 : #include <memory>
99 : #include <utility>
100 :
101 : #define SC_LOCALE "Locale"
102 : #define SC_STANDARDFORMAT "StandardFormat"
103 : #define SC_CURRENCYSYMBOL "CurrencySymbol"
104 : #define SC_REPEAT_COLUMN "repeat-column"
105 : #define SC_REPEAT_ROW "repeat-row"
106 : #define SC_FILTER "filter"
107 : #define SC_PRINT_RANGE "print-range"
108 :
109 : using namespace com::sun::star;
110 : using namespace ::xmloff::token;
111 : using namespace ::formula;
112 : using ::com::sun::star::uno::Reference;
113 : using ::com::sun::star::uno::UNO_QUERY;
114 :
115 366 : OUString SAL_CALL ScXMLImport_getImplementationName() throw()
116 : {
117 366 : return OUString( "com.sun.star.comp.Calc.XMLOasisImporter" );
118 : }
119 :
120 4 : uno::Sequence< OUString > SAL_CALL ScXMLImport_getSupportedServiceNames() throw()
121 : {
122 4 : const OUString aServiceName( ScXMLImport_getImplementationName() );
123 4 : return uno::Sequence< OUString > ( &aServiceName, 1 );
124 : }
125 :
126 58 : uno::Reference< uno::XInterface > SAL_CALL ScXMLImport_createInstance(
127 : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
128 : {
129 : // #110680#
130 : // return (cppu::OWeakObject*)new ScXMLImport(IMPORT_ALL);
131 58 : return (cppu::OWeakObject*)new ScXMLImport( comphelper::getComponentContext(rSMgr), ScXMLImport_getImplementationName(), IMPORT_ALL );
132 : }
133 :
134 624 : OUString SAL_CALL ScXMLImport_Meta_getImplementationName() throw()
135 : {
136 624 : return OUString( "com.sun.star.comp.Calc.XMLOasisMetaImporter" );
137 : }
138 :
139 46 : uno::Sequence< OUString > SAL_CALL ScXMLImport_Meta_getSupportedServiceNames() throw()
140 : {
141 46 : const OUString aServiceName( ScXMLImport_Meta_getImplementationName() );
142 46 : return uno::Sequence< OUString > ( &aServiceName, 1 );
143 : }
144 :
145 236 : uno::Reference< uno::XInterface > SAL_CALL ScXMLImport_Meta_createInstance(
146 : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
147 : {
148 : // #110680#
149 : // return (cppu::OWeakObject*)new ScXMLImport(IMPORT_META);
150 236 : return (cppu::OWeakObject*)new ScXMLImport( comphelper::getComponentContext(rSMgr), ScXMLImport_Meta_getImplementationName(), IMPORT_META );
151 : }
152 :
153 612 : OUString SAL_CALL ScXMLImport_Styles_getImplementationName() throw()
154 : {
155 612 : return OUString( "com.sun.star.comp.Calc.XMLOasisStylesImporter" );
156 : }
157 :
158 46 : uno::Sequence< OUString > SAL_CALL ScXMLImport_Styles_getSupportedServiceNames() throw()
159 : {
160 46 : const OUString aServiceName( ScXMLImport_Styles_getImplementationName() );
161 46 : return uno::Sequence< OUString > ( &aServiceName, 1 );
162 : }
163 :
164 270 : uno::Reference< uno::XInterface > SAL_CALL ScXMLImport_Styles_createInstance(
165 : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
166 : {
167 : // #110680#
168 : // return (cppu::OWeakObject*)new ScXMLImport(IMPORT_STYLES|IMPORT_AUTOSTYLES|IMPORT_MASTERSTYLES|IMPORT_FONTDECLS);
169 270 : return (cppu::OWeakObject*)new ScXMLImport( comphelper::getComponentContext(rSMgr), ScXMLImport_Styles_getImplementationName(), IMPORT_STYLES|IMPORT_AUTOSTYLES|IMPORT_MASTERSTYLES|IMPORT_FONTDECLS);
170 : }
171 :
172 560 : OUString SAL_CALL ScXMLImport_Content_getImplementationName() throw()
173 : {
174 560 : return OUString( "com.sun.star.comp.Calc.XMLOasisContentImporter" );
175 : }
176 :
177 46 : uno::Sequence< OUString > SAL_CALL ScXMLImport_Content_getSupportedServiceNames() throw()
178 : {
179 46 : const OUString aServiceName( ScXMLImport_Content_getImplementationName() );
180 46 : return uno::Sequence< OUString > ( &aServiceName, 1 );
181 : }
182 :
183 264 : uno::Reference< uno::XInterface > SAL_CALL ScXMLImport_Content_createInstance(
184 : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
185 : {
186 : // #110680#
187 : // return (cppu::OWeakObject*)new ScXMLImport(IMPORT_META|IMPORT_STYLES|IMPORT_MASTERSTYLES|IMPORT_AUTOSTYLES|IMPORT_CONTENT|IMPORT_SCRIPTS|IMPORT_SETTINGS|IMPORT_FONTDECLS);
188 264 : return (cppu::OWeakObject*)new ScXMLImport( comphelper::getComponentContext(rSMgr), ScXMLImport_Content_getImplementationName(), IMPORT_AUTOSTYLES|IMPORT_CONTENT|IMPORT_SCRIPTS|IMPORT_FONTDECLS);
189 : }
190 :
191 520 : OUString SAL_CALL ScXMLImport_Settings_getImplementationName() throw()
192 : {
193 520 : return OUString( "com.sun.star.comp.Calc.XMLOasisSettingsImporter" );
194 : }
195 :
196 46 : uno::Sequence< OUString > SAL_CALL ScXMLImport_Settings_getSupportedServiceNames() throw()
197 : {
198 46 : const OUString aServiceName( ScXMLImport_Settings_getImplementationName() );
199 46 : return uno::Sequence< OUString > ( &aServiceName, 1 );
200 : }
201 :
202 270 : uno::Reference< uno::XInterface > SAL_CALL ScXMLImport_Settings_createInstance(
203 : const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
204 : {
205 : // #110680#
206 : // return (cppu::OWeakObject*)new ScXMLImport(IMPORT_SETTINGS);
207 270 : return (cppu::OWeakObject*)new ScXMLImport( comphelper::getComponentContext(rSMgr), ScXMLImport_Settings_getImplementationName(), IMPORT_SETTINGS );
208 : }
209 :
210 21130 : const SvXMLTokenMap& ScXMLImport::GetTableRowCellAttrTokenMap()
211 : {
212 : static const SvXMLTokenMapEntry aTableRowCellAttrTokenMap[] =
213 : {
214 : { XML_NAMESPACE_TABLE, XML_STYLE_NAME, XML_TOK_TABLE_ROW_CELL_ATTR_STYLE_NAME },
215 : { XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION_NAME, XML_TOK_TABLE_ROW_CELL_ATTR_CONTENT_VALIDATION_NAME },
216 : { XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_SPANNED, XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_ROWS },
217 : { XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_SPANNED, XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_COLS },
218 : { XML_NAMESPACE_TABLE, XML_NUMBER_MATRIX_COLUMNS_SPANNED, XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_MATRIX_COLS },
219 : { XML_NAMESPACE_TABLE, XML_NUMBER_MATRIX_ROWS_SPANNED, XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_MATRIX_ROWS },
220 : { XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, XML_TOK_TABLE_ROW_CELL_ATTR_REPEATED },
221 : { XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TOK_TABLE_ROW_CELL_ATTR_VALUE_TYPE },
222 : { XML_NAMESPACE_CALC_EXT, XML_VALUE_TYPE, XML_TOK_TABLE_ROW_CELL_ATTR_NEW_VALUE_TYPE },
223 : { XML_NAMESPACE_OFFICE, XML_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_VALUE },
224 : { XML_NAMESPACE_OFFICE, XML_DATE_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_DATE_VALUE },
225 : { XML_NAMESPACE_OFFICE, XML_TIME_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_TIME_VALUE },
226 : { XML_NAMESPACE_OFFICE, XML_STRING_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_STRING_VALUE },
227 : { XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_BOOLEAN_VALUE },
228 : { XML_NAMESPACE_TABLE, XML_FORMULA, XML_TOK_TABLE_ROW_CELL_ATTR_FORMULA },
229 : { XML_NAMESPACE_OFFICE, XML_CURRENCY, XML_TOK_TABLE_ROW_CELL_ATTR_CURRENCY },
230 : XML_TOKEN_MAP_END
231 : };
232 :
233 21130 : if ( !pTableRowCellAttrTokenMap )
234 322 : pTableRowCellAttrTokenMap = new SvXMLTokenMap( aTableRowCellAttrTokenMap );
235 21130 : return *pTableRowCellAttrTokenMap;
236 : }
237 :
238 : // NB: virtually inherit so we can multiply inherit properly
239 : // in ScXMLFlatDocContext_Impl
240 : class ScXMLDocContext_Impl : public virtual SvXMLImportContext
241 : {
242 : protected:
243 7990 : ScXMLImport& GetScImport() { return static_cast<ScXMLImport&>(GetImport()); }
244 :
245 : public:
246 :
247 : ScXMLDocContext_Impl( ScXMLImport& rImport,
248 : sal_uInt16 nPrfx,
249 : const OUString& rLName,
250 : const uno::Reference<xml::sax::XAttributeList>& xAttrList );
251 : virtual ~ScXMLDocContext_Impl();
252 :
253 : virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix,
254 : const OUString& rLocalName,
255 : const uno::Reference<xml::sax::XAttributeList>& xAttrList ) SAL_OVERRIDE;
256 : };
257 :
258 852 : ScXMLDocContext_Impl::ScXMLDocContext_Impl( ScXMLImport& rImport, sal_uInt16 nPrfx,
259 : const OUString& rLName,
260 : const uno::Reference<xml::sax::XAttributeList>& /* xAttrList */ ) :
261 852 : SvXMLImportContext( rImport, nPrfx, rLName )
262 : {
263 :
264 852 : }
265 :
266 1646 : ScXMLDocContext_Impl::~ScXMLDocContext_Impl()
267 : {
268 1646 : }
269 :
270 : // context for flat file xml format
271 : class ScXMLFlatDocContext_Impl
272 : : public ScXMLDocContext_Impl, public SvXMLMetaDocumentContext
273 : {
274 : public:
275 : ScXMLFlatDocContext_Impl( ScXMLImport& i_rImport,
276 : sal_uInt16 i_nPrefix, const OUString & i_rLName,
277 : const uno::Reference<xml::sax::XAttributeList>& i_xAttrList,
278 : const uno::Reference<document::XDocumentProperties>& i_xDocProps);
279 :
280 : virtual ~ScXMLFlatDocContext_Impl();
281 :
282 : virtual SvXMLImportContext *CreateChildContext(
283 : sal_uInt16 i_nPrefix, const OUString& i_rLocalName,
284 : const uno::Reference<xml::sax::XAttributeList>& i_xAttrList) SAL_OVERRIDE;
285 : };
286 :
287 58 : ScXMLFlatDocContext_Impl::ScXMLFlatDocContext_Impl( ScXMLImport& i_rImport,
288 : sal_uInt16 i_nPrefix, const OUString & i_rLName,
289 : const uno::Reference<xml::sax::XAttributeList>& i_xAttrList,
290 : const uno::Reference<document::XDocumentProperties>& i_xDocProps) :
291 : SvXMLImportContext(i_rImport, i_nPrefix, i_rLName),
292 : ScXMLDocContext_Impl(i_rImport, i_nPrefix, i_rLName, i_xAttrList),
293 : SvXMLMetaDocumentContext(i_rImport, i_nPrefix, i_rLName,
294 58 : i_xDocProps)
295 : {
296 58 : }
297 :
298 116 : ScXMLFlatDocContext_Impl::~ScXMLFlatDocContext_Impl() { }
299 :
300 296 : SvXMLImportContext *ScXMLFlatDocContext_Impl::CreateChildContext(
301 : sal_uInt16 i_nPrefix, const OUString& i_rLocalName,
302 : const uno::Reference<xml::sax::XAttributeList>& i_xAttrList)
303 : {
304 : // behave like meta base class iff we encounter office:meta
305 296 : const SvXMLTokenMap& rTokenMap = GetScImport().GetDocElemTokenMap();
306 296 : if ( XML_TOK_DOC_META == rTokenMap.Get( i_nPrefix, i_rLocalName ) ) {
307 : return SvXMLMetaDocumentContext::CreateChildContext(
308 2 : i_nPrefix, i_rLocalName, i_xAttrList );
309 : } else {
310 : return ScXMLDocContext_Impl::CreateChildContext(
311 294 : i_nPrefix, i_rLocalName, i_xAttrList );
312 : }
313 : }
314 :
315 : class ScXMLBodyContext_Impl : public SvXMLImportContext
316 : {
317 322 : ScXMLImport& GetScImport() { return static_cast<ScXMLImport&>(GetImport()); }
318 :
319 : public:
320 :
321 : ScXMLBodyContext_Impl( ScXMLImport& rImport, sal_uInt16 nPrfx,
322 : const OUString& rLName,
323 : const uno::Reference< xml::sax::XAttributeList > & xAttrList );
324 : virtual ~ScXMLBodyContext_Impl();
325 :
326 : virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix,
327 : const OUString& rLocalName,
328 : const uno::Reference< xml::sax::XAttributeList > & xAttrList ) SAL_OVERRIDE;
329 : };
330 :
331 322 : ScXMLBodyContext_Impl::ScXMLBodyContext_Impl( ScXMLImport& rImport,
332 : sal_uInt16 nPrfx, const OUString& rLName,
333 : const uno::Reference< xml::sax::XAttributeList > & /* xAttrList */ ) :
334 322 : SvXMLImportContext( rImport, nPrfx, rLName )
335 : {
336 322 : }
337 :
338 644 : ScXMLBodyContext_Impl::~ScXMLBodyContext_Impl()
339 : {
340 644 : }
341 :
342 322 : SvXMLImportContext *ScXMLBodyContext_Impl::CreateChildContext(
343 : sal_uInt16 /* nPrefix */,
344 : const OUString& rLocalName,
345 : const uno::Reference< xml::sax::XAttributeList > & xAttrList )
346 : {
347 322 : return GetScImport().CreateBodyContext( rLocalName, xAttrList );
348 : }
349 :
350 2672 : SvXMLImportContext *ScXMLDocContext_Impl::CreateChildContext( sal_uInt16 nPrefix,
351 : const OUString& rLocalName,
352 : const uno::Reference<xml::sax::XAttributeList>& xAttrList )
353 : {
354 2672 : SvXMLImportContext *pContext(0);
355 :
356 2672 : const SvXMLTokenMap& rTokenMap(GetScImport().GetDocElemTokenMap());
357 2672 : switch( rTokenMap.Get( nPrefix, rLocalName ) )
358 : {
359 : case XML_TOK_DOC_FONTDECLS:
360 586 : if (GetScImport().getImportFlags() & IMPORT_FONTDECLS)
361 586 : pContext = GetScImport().CreateFontDeclsContext(nPrefix, rLocalName, xAttrList);
362 586 : break;
363 : case XML_TOK_DOC_STYLES:
364 324 : if (GetScImport().getImportFlags() & IMPORT_STYLES)
365 324 : pContext = GetScImport().CreateStylesContext( rLocalName, xAttrList, false);
366 324 : break;
367 : case XML_TOK_DOC_AUTOSTYLES:
368 586 : if (GetScImport().getImportFlags() & IMPORT_AUTOSTYLES)
369 586 : pContext = GetScImport().CreateStylesContext( rLocalName, xAttrList, true);
370 586 : break;
371 : case XML_TOK_DOC_MASTERSTYLES:
372 322 : if (GetScImport().getImportFlags() & IMPORT_MASTERSTYLES)
373 322 : pContext = new ScXMLMasterStylesContext( GetImport(), nPrefix, rLocalName,
374 322 : xAttrList );
375 322 : break;
376 : case XML_TOK_DOC_META:
377 : DBG_WARNING("XML_TOK_DOC_META: should not have come here, maybe document is invalid?");
378 0 : break;
379 : case XML_TOK_DOC_SCRIPTS:
380 266 : if (GetScImport().getImportFlags() & IMPORT_SCRIPTS)
381 266 : pContext = GetScImport().CreateScriptContext( rLocalName );
382 266 : break;
383 : case XML_TOK_DOC_BODY:
384 322 : if (GetScImport().getImportFlags() & IMPORT_CONTENT)
385 : pContext = new ScXMLBodyContext_Impl( GetScImport(), nPrefix,
386 322 : rLocalName, xAttrList );
387 322 : break;
388 : case XML_TOK_DOC_SETTINGS:
389 266 : if (GetScImport().getImportFlags() & IMPORT_SETTINGS)
390 266 : pContext = new XMLDocumentSettingsContext(GetScImport(), nPrefix, rLocalName, xAttrList );
391 266 : break;
392 : }
393 :
394 2672 : if(!pContext)
395 0 : pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
396 :
397 2672 : return pContext;
398 : }
399 :
400 2968 : const SvXMLTokenMap& ScXMLImport::GetDocElemTokenMap()
401 : {
402 2968 : if( !pDocElemTokenMap )
403 : {
404 : static const SvXMLTokenMapEntry aDocTokenMap[] =
405 : {
406 : { XML_NAMESPACE_OFFICE, XML_FONT_FACE_DECLS, XML_TOK_DOC_FONTDECLS },
407 : { XML_NAMESPACE_OFFICE, XML_STYLES, XML_TOK_DOC_STYLES },
408 : { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_STYLES, XML_TOK_DOC_AUTOSTYLES },
409 : { XML_NAMESPACE_OFFICE, XML_MASTER_STYLES, XML_TOK_DOC_MASTERSTYLES },
410 : { XML_NAMESPACE_OFFICE, XML_META, XML_TOK_DOC_META },
411 : { XML_NAMESPACE_OFFICE, XML_SCRIPTS, XML_TOK_DOC_SCRIPTS },
412 : { XML_NAMESPACE_OFFICE, XML_BODY, XML_TOK_DOC_BODY },
413 : { XML_NAMESPACE_OFFICE, XML_SETTINGS, XML_TOK_DOC_SETTINGS },
414 : XML_TOKEN_MAP_END
415 : };
416 :
417 852 : pDocElemTokenMap = new SvXMLTokenMap( aDocTokenMap );
418 :
419 : } // if( !pDocElemTokenMap )
420 :
421 2968 : return *pDocElemTokenMap;
422 : }
423 :
424 866 : const SvXMLTokenMap& ScXMLImport::GetBodyElemTokenMap()
425 : {
426 866 : if( !pBodyElemTokenMap )
427 : {
428 : static const SvXMLTokenMapEntry aBodyTokenMap[] =
429 : {
430 : { XML_NAMESPACE_TABLE, XML_TRACKED_CHANGES, XML_TOK_BODY_TRACKED_CHANGES },
431 : { XML_NAMESPACE_TABLE, XML_CALCULATION_SETTINGS, XML_TOK_BODY_CALCULATION_SETTINGS },
432 : { XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATIONS, XML_TOK_BODY_CONTENT_VALIDATIONS },
433 : { XML_NAMESPACE_TABLE, XML_LABEL_RANGES, XML_TOK_BODY_LABEL_RANGES },
434 : { XML_NAMESPACE_TABLE, XML_TABLE, XML_TOK_BODY_TABLE },
435 : { XML_NAMESPACE_TABLE, XML_NAMED_EXPRESSIONS, XML_TOK_BODY_NAMED_EXPRESSIONS },
436 : { XML_NAMESPACE_TABLE, XML_DATABASE_RANGES, XML_TOK_BODY_DATABASE_RANGES },
437 : { XML_NAMESPACE_TABLE, XML_DATABASE_RANGE, XML_TOK_BODY_DATABASE_RANGE },
438 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_TABLES, XML_TOK_BODY_DATA_PILOT_TABLES },
439 : { XML_NAMESPACE_TABLE, XML_CONSOLIDATION, XML_TOK_BODY_CONSOLIDATION },
440 : { XML_NAMESPACE_TABLE, XML_DDE_LINKS, XML_TOK_BODY_DDE_LINKS },
441 : { XML_NAMESPACE_CALC_EXT, XML_DATA_STREAM_SOURCE, XML_TOK_BODY_DATA_STREAM_SOURCE },
442 : XML_TOKEN_MAP_END
443 : };
444 :
445 322 : pBodyElemTokenMap = new SvXMLTokenMap( aBodyTokenMap );
446 : } // if( !pBodyElemTokenMap )
447 :
448 866 : return *pBodyElemTokenMap;
449 : }
450 :
451 4 : const SvXMLTokenMap& ScXMLImport::GetContentValidationsElemTokenMap()
452 : {
453 4 : if( !pContentValidationsElemTokenMap )
454 : {
455 : static const SvXMLTokenMapEntry aContentValidationsElemTokenMap[] =
456 : {
457 : { XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION, XML_TOK_CONTENT_VALIDATION },
458 : XML_TOKEN_MAP_END
459 : };
460 :
461 2 : pContentValidationsElemTokenMap = new SvXMLTokenMap( aContentValidationsElemTokenMap );
462 : } // if( !pContentValidationsElemTokenMap )
463 :
464 4 : return *pContentValidationsElemTokenMap;
465 : }
466 :
467 4 : const SvXMLTokenMap& ScXMLImport::GetContentValidationElemTokenMap()
468 : {
469 4 : if( !pContentValidationElemTokenMap )
470 : {
471 : static const SvXMLTokenMapEntry aContentValidationElemTokenMap[] =
472 : {
473 : { XML_NAMESPACE_TABLE, XML_HELP_MESSAGE, XML_TOK_CONTENT_VALIDATION_ELEM_HELP_MESSAGE },
474 : { XML_NAMESPACE_TABLE, XML_ERROR_MESSAGE, XML_TOK_CONTENT_VALIDATION_ELEM_ERROR_MESSAGE },
475 : { XML_NAMESPACE_TABLE, XML_ERROR_MACRO, XML_TOK_CONTENT_VALIDATION_ELEM_ERROR_MACRO },
476 : { XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, XML_TOK_CONTENT_VALIDATION_ELEM_EVENT_LISTENERS },
477 : XML_TOKEN_MAP_END
478 : };
479 :
480 2 : pContentValidationElemTokenMap = new SvXMLTokenMap( aContentValidationElemTokenMap );
481 : } // if( !pContentValidationElemTokenMap )
482 :
483 4 : return *pContentValidationElemTokenMap;
484 : }
485 :
486 4 : const SvXMLTokenMap& ScXMLImport::GetContentValidationAttrTokenMap()
487 : {
488 4 : if( !pContentValidationAttrTokenMap )
489 : {
490 : static const SvXMLTokenMapEntry aContentValidationAttrTokenMap[] =
491 : {
492 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_CONTENT_VALIDATION_NAME },
493 : { XML_NAMESPACE_TABLE, XML_CONDITION, XML_TOK_CONTENT_VALIDATION_CONDITION },
494 : { XML_NAMESPACE_TABLE, XML_BASE_CELL_ADDRESS, XML_TOK_CONTENT_VALIDATION_BASE_CELL_ADDRESS },
495 : { XML_NAMESPACE_TABLE, XML_ALLOW_EMPTY_CELL, XML_TOK_CONTENT_VALIDATION_ALLOW_EMPTY_CELL },
496 : { XML_NAMESPACE_TABLE, XML_DISPLAY_LIST, XML_TOK_CONTENT_VALIDATION_DISPLAY_LIST },
497 : XML_TOKEN_MAP_END
498 : };
499 :
500 2 : pContentValidationAttrTokenMap = new SvXMLTokenMap( aContentValidationAttrTokenMap );
501 : } // if( !pContentValidationAttrTokenMap )
502 :
503 4 : return *pContentValidationAttrTokenMap;
504 : }
505 :
506 4 : const SvXMLTokenMap& ScXMLImport::GetContentValidationMessageElemTokenMap()
507 : {
508 4 : if( !pContentValidationMessageElemTokenMap )
509 : {
510 : static const SvXMLTokenMapEntry aContentValidationMessageElemTokenMap[] =
511 : {
512 : { XML_NAMESPACE_TEXT, XML_P, XML_TOK_P },
513 : XML_TOKEN_MAP_END
514 : };
515 :
516 2 : pContentValidationMessageElemTokenMap = new SvXMLTokenMap( aContentValidationMessageElemTokenMap );
517 : } // if( !pContentValidationMessageElemTokenMap )
518 :
519 4 : return *pContentValidationMessageElemTokenMap;
520 : }
521 :
522 0 : const SvXMLTokenMap& ScXMLImport::GetContentValidationHelpMessageAttrTokenMap()
523 : {
524 0 : if( !pContentValidationHelpMessageAttrTokenMap )
525 : {
526 : static const SvXMLTokenMapEntry aContentValidationHelpMessageAttrTokenMap[] =
527 : {
528 : { XML_NAMESPACE_TABLE, XML_TITLE, XML_TOK_HELP_MESSAGE_ATTR_TITLE },
529 : { XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TOK_HELP_MESSAGE_ATTR_DISPLAY },
530 : XML_TOKEN_MAP_END
531 : };
532 :
533 0 : pContentValidationHelpMessageAttrTokenMap = new SvXMLTokenMap( aContentValidationHelpMessageAttrTokenMap );
534 : } // if( !pContentValidationHelpMessageAttrTokenMap )
535 :
536 0 : return *pContentValidationHelpMessageAttrTokenMap;
537 : }
538 :
539 4 : const SvXMLTokenMap& ScXMLImport::GetContentValidationErrorMessageAttrTokenMap()
540 : {
541 4 : if( !pContentValidationErrorMessageAttrTokenMap )
542 : {
543 : static const SvXMLTokenMapEntry aContentValidationErrorMessageAttrTokenMap[] =
544 : {
545 : { XML_NAMESPACE_TABLE, XML_TITLE, XML_TOK_ERROR_MESSAGE_ATTR_TITLE },
546 : { XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TOK_ERROR_MESSAGE_ATTR_DISPLAY },
547 : { XML_NAMESPACE_TABLE, XML_MESSAGE_TYPE, XML_TOK_ERROR_MESSAGE_ATTR_MESSAGE_TYPE },
548 : XML_TOKEN_MAP_END
549 : };
550 :
551 2 : pContentValidationErrorMessageAttrTokenMap = new SvXMLTokenMap( aContentValidationErrorMessageAttrTokenMap );
552 : } // if( !pContentValidationErrorMessageAttrTokenMap )
553 :
554 4 : return *pContentValidationErrorMessageAttrTokenMap;
555 : }
556 :
557 0 : const SvXMLTokenMap& ScXMLImport::GetContentValidationErrorMacroAttrTokenMap()
558 : {
559 0 : if( !pContentValidationErrorMacroAttrTokenMap )
560 : {
561 : static const SvXMLTokenMapEntry aContentValidationErrorMacroAttrTokenMap[] =
562 : {
563 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_ERROR_MACRO_ATTR_NAME },
564 : { XML_NAMESPACE_TABLE, XML_EXECUTE, XML_TOK_ERROR_MACRO_ATTR_EXECUTE },
565 : XML_TOKEN_MAP_END
566 : };
567 :
568 0 : pContentValidationErrorMacroAttrTokenMap = new SvXMLTokenMap( aContentValidationErrorMacroAttrTokenMap );
569 : } // if( !pContentValidationErrorMacroAttrTokenMap )
570 :
571 0 : return *pContentValidationErrorMacroAttrTokenMap;
572 : }
573 :
574 132 : const SvXMLTokenMap& ScXMLImport::GetCondFormatsTokenMap()
575 : {
576 132 : if( !pCondFormatsTokenMap )
577 : {
578 : static const SvXMLTokenMapEntry aCondFormatsElemTokenMap[] =
579 : {
580 : { XML_NAMESPACE_CALC_EXT, XML_CONDITIONAL_FORMAT, XML_TOK_CONDFORMATS_CONDFORMAT },
581 : XML_TOKEN_MAP_END
582 : };
583 :
584 24 : pCondFormatsTokenMap = new SvXMLTokenMap( aCondFormatsElemTokenMap );
585 : }
586 :
587 132 : return *pCondFormatsTokenMap;
588 : }
589 :
590 180 : const SvXMLTokenMap& ScXMLImport::GetCondFormatTokenMap()
591 : {
592 180 : if( !pCondFormatTokenMap )
593 : {
594 : static const SvXMLTokenMapEntry aCondFormatElemTokenMap[] =
595 : {
596 : { XML_NAMESPACE_CALC_EXT, XML_COLOR_SCALE, XML_TOK_CONDFORMAT_COLORSCALE },
597 : { XML_NAMESPACE_CALC_EXT, XML_DATA_BAR, XML_TOK_CONDFORMAT_DATABAR },
598 : { XML_NAMESPACE_CALC_EXT, XML_CONDITION, XML_TOK_CONDFORMAT_CONDITION },
599 : { XML_NAMESPACE_CALC_EXT, XML_ICON_SET, XML_TOK_CONDFORMAT_ICONSET },
600 : { XML_NAMESPACE_CALC_EXT, XML_DATE_IS, XML_TOK_CONDFORMAT_DATE },
601 : XML_TOKEN_MAP_END
602 : };
603 :
604 24 : pCondFormatTokenMap = new SvXMLTokenMap( aCondFormatElemTokenMap );
605 : }
606 :
607 180 : return *pCondFormatTokenMap;
608 : }
609 :
610 132 : const SvXMLTokenMap& ScXMLImport::GetCondFormatAttrMap()
611 : {
612 132 : if( !pCondFormatAttrMap )
613 : {
614 : static const SvXMLTokenMapEntry aCondFormatAttrTokenMap[] =
615 : {
616 : { XML_NAMESPACE_CALC_EXT, XML_TARGET_RANGE_ADDRESS, XML_TOK_CONDFORMAT_TARGET_RANGE },
617 : XML_TOKEN_MAP_END
618 : };
619 :
620 24 : pCondFormatAttrMap = new SvXMLTokenMap( aCondFormatAttrTokenMap );
621 : }
622 :
623 132 : return *pCondFormatAttrMap;
624 : }
625 :
626 0 : const SvXMLTokenMap& ScXMLImport::GetCondDateAttrMap()
627 : {
628 0 : if( !pCondDateAttrMap )
629 : {
630 : static const SvXMLTokenMapEntry aCondDateAttrTokenMap[] =
631 : {
632 : { XML_NAMESPACE_CALC_EXT, XML_DATE, XML_TOK_COND_DATE_VALUE },
633 : { XML_NAMESPACE_CALC_EXT, XML_STYLE, XML_TOK_COND_DATE_STYLE },
634 : XML_TOKEN_MAP_END
635 : };
636 :
637 0 : pCondDateAttrMap = new SvXMLTokenMap( aCondDateAttrTokenMap );
638 : }
639 :
640 0 : return *pCondDateAttrMap;
641 : }
642 :
643 114 : const SvXMLTokenMap& ScXMLImport::GetConditionAttrMap()
644 : {
645 114 : if( !pConditionAttrMap )
646 : {
647 : static const SvXMLTokenMapEntry aConditionAttrTokenMap[] =
648 : {
649 : { XML_NAMESPACE_CALC_EXT, XML_VALUE, XML_TOK_CONDITION_VALUE },
650 : { XML_NAMESPACE_CALC_EXT, XML_APPLY_STYLE_NAME, XML_TOK_CONDITION_APPLY_STYLE_NAME },
651 : { XML_NAMESPACE_CALC_EXT, XML_BASE_CELL_ADDRESS, XML_TOK_CONDITION_BASE_CELL_ADDRESS },
652 : XML_TOKEN_MAP_END
653 : };
654 :
655 12 : pConditionAttrMap = new SvXMLTokenMap( aConditionAttrTokenMap );
656 : }
657 :
658 114 : return *pConditionAttrMap;
659 : }
660 :
661 90 : const SvXMLTokenMap& ScXMLImport::GetColorScaleTokenMap()
662 : {
663 90 : if( !pColorScaleTokenMap )
664 : {
665 : static const SvXMLTokenMapEntry aColorScaleElemTokenMap[] =
666 : {
667 : { XML_NAMESPACE_CALC_EXT, XML_COLOR_SCALE_ENTRY, XML_TOK_COLORSCALE_COLORSCALEENTRY },
668 : XML_TOKEN_MAP_END
669 : };
670 :
671 6 : pColorScaleTokenMap = new SvXMLTokenMap( aColorScaleElemTokenMap );
672 : }
673 :
674 90 : return *pColorScaleTokenMap;
675 : }
676 :
677 90 : const SvXMLTokenMap& ScXMLImport::GetColorScaleEntryAttrMap()
678 : {
679 90 : if( !pColorScaleEntryAttrTokenMap )
680 : {
681 : static const SvXMLTokenMapEntry aColorScaleAttrTokenMap[] =
682 : {
683 : { XML_NAMESPACE_CALC_EXT, XML_TYPE, XML_TOK_COLORSCALEENTRY_TYPE },
684 : { XML_NAMESPACE_CALC_EXT, XML_VALUE, XML_TOK_COLORSCALEENTRY_VALUE },
685 : { XML_NAMESPACE_CALC_EXT, XML_COLOR, XML_TOK_COLORSCALEENTRY_COLOR },
686 : XML_TOKEN_MAP_END
687 : };
688 :
689 6 : pColorScaleEntryAttrTokenMap = new SvXMLTokenMap( aColorScaleAttrTokenMap );
690 : }
691 :
692 90 : return *pColorScaleEntryAttrTokenMap;
693 : }
694 :
695 60 : const SvXMLTokenMap& ScXMLImport::GetFormattingTokenMap()
696 : {
697 60 : if( !pDataBarTokenMap )
698 : {
699 : static const SvXMLTokenMapEntry aDataBarElemTokenMap[] =
700 : {
701 : { XML_NAMESPACE_CALC_EXT, XML_DATA_BAR_ENTRY, XML_TOK_DATABAR_DATABARENTRY },
702 : { XML_NAMESPACE_CALC_EXT, XML_FORMATTING_ENTRY, XML_TOK_FORMATTING_ENTRY },
703 : XML_TOKEN_MAP_END
704 : };
705 :
706 6 : pDataBarTokenMap = new SvXMLTokenMap( aDataBarElemTokenMap );
707 : }
708 :
709 60 : return *pDataBarTokenMap;
710 : }
711 :
712 30 : const SvXMLTokenMap& ScXMLImport::GetDataBarAttrMap()
713 : {
714 30 : if( !pDataBarAttrMap )
715 : {
716 : static const SvXMLTokenMapEntry aDataBarAttrTokenMap[] =
717 : {
718 : { XML_NAMESPACE_CALC_EXT, XML_POSITIVE_COLOR, XML_TOK_DATABAR_POSITIVE_COLOR },
719 : { XML_NAMESPACE_CALC_EXT, XML_NEGATIVE_COLOR, XML_TOK_DATABAR_NEGATIVE_COLOR },
720 : { XML_NAMESPACE_CALC_EXT, XML_GRADIENT, XML_TOK_DATABAR_GRADIENT },
721 : { XML_NAMESPACE_CALC_EXT, XML_AXIS_POSITION, XML_TOK_DATABAR_AXISPOSITION },
722 : { XML_NAMESPACE_CALC_EXT, XML_SHOW_VALUE, XML_TOK_DATABAR_SHOWVALUE },
723 : { XML_NAMESPACE_CALC_EXT, XML_AXIS_COLOR, XML_TOK_DATABAR_AXISCOLOR },
724 : XML_TOKEN_MAP_END
725 : };
726 :
727 6 : pDataBarAttrMap = new SvXMLTokenMap( aDataBarAttrTokenMap );
728 : }
729 :
730 30 : return *pDataBarAttrMap;
731 : }
732 :
733 0 : const SvXMLTokenMap& ScXMLImport::GetIconSetAttrMap()
734 : {
735 0 : if( !pIconSetAttrMap )
736 : {
737 : static const SvXMLTokenMapEntry aIconSetAttrTokenMap[] =
738 : {
739 : { XML_NAMESPACE_CALC_EXT, XML_ICON_SET_TYPE, XML_TOK_ICONSET_TYPE },
740 : { XML_NAMESPACE_CALC_EXT, XML_SHOW_VALUE, XML_TOK_ICONSET_SHOWVALUE },
741 : XML_TOKEN_MAP_END
742 : };
743 :
744 0 : pIconSetAttrMap = new SvXMLTokenMap( aIconSetAttrTokenMap );
745 : }
746 :
747 0 : return *pIconSetAttrMap;
748 : }
749 :
750 60 : const SvXMLTokenMap& ScXMLImport::GetDataBarEntryAttrMap()
751 : {
752 60 : if( !pFormattingEntryAttrMap )
753 : {
754 : static const SvXMLTokenMapEntry aDataBarAttrEntryTokenMap[] =
755 : {
756 : { XML_NAMESPACE_CALC_EXT, XML_TYPE, XML_TOK_DATABARENTRY_TYPE },
757 : { XML_NAMESPACE_CALC_EXT, XML_VALUE, XML_TOK_DATABARENTRY_VALUE },
758 : XML_TOKEN_MAP_END
759 : };
760 :
761 6 : pFormattingEntryAttrMap = new SvXMLTokenMap( aDataBarAttrEntryTokenMap );
762 : }
763 :
764 60 : return *pFormattingEntryAttrMap;
765 : }
766 :
767 0 : const SvXMLTokenMap& ScXMLImport::GetLabelRangesElemTokenMap()
768 : {
769 0 : if( !pLabelRangesElemTokenMap )
770 : {
771 : static const SvXMLTokenMapEntry aLabelRangesElemTokenMap[] =
772 : {
773 : { XML_NAMESPACE_TABLE, XML_LABEL_RANGE, XML_TOK_LABEL_RANGE_ELEM },
774 : XML_TOKEN_MAP_END
775 : };
776 :
777 0 : pLabelRangesElemTokenMap = new SvXMLTokenMap( aLabelRangesElemTokenMap );
778 : } // if( !pLabelRangesElemTokenMap )
779 :
780 0 : return *pLabelRangesElemTokenMap;
781 : }
782 :
783 0 : const SvXMLTokenMap& ScXMLImport::GetLabelRangeAttrTokenMap()
784 : {
785 0 : if( !pLabelRangeAttrTokenMap )
786 : {
787 : static const SvXMLTokenMapEntry aLabelRangeAttrTokenMap[] =
788 : {
789 : { XML_NAMESPACE_TABLE, XML_LABEL_CELL_RANGE_ADDRESS, XML_TOK_LABEL_RANGE_ATTR_LABEL_RANGE },
790 : { XML_NAMESPACE_TABLE, XML_DATA_CELL_RANGE_ADDRESS, XML_TOK_LABEL_RANGE_ATTR_DATA_RANGE },
791 : { XML_NAMESPACE_TABLE, XML_ORIENTATION, XML_TOK_LABEL_RANGE_ATTR_ORIENTATION },
792 : XML_TOKEN_MAP_END
793 : };
794 :
795 0 : pLabelRangeAttrTokenMap = new SvXMLTokenMap( aLabelRangeAttrTokenMap );
796 : } // if( !pLabelRangeAttrTokenMap )
797 :
798 0 : return *pLabelRangeAttrTokenMap;
799 : }
800 :
801 9032 : const SvXMLTokenMap& ScXMLImport::GetTableElemTokenMap()
802 : {
803 9032 : if( !pTableElemTokenMap )
804 : {
805 : static const SvXMLTokenMapEntry aTableTokenMap[] =
806 : {
807 : { XML_NAMESPACE_TABLE, XML_NAMED_EXPRESSIONS, XML_TOK_TABLE_NAMED_EXPRESSIONS },
808 : { XML_NAMESPACE_TABLE, XML_TABLE_COLUMN_GROUP, XML_TOK_TABLE_COL_GROUP },
809 : { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_COLUMNS, XML_TOK_TABLE_HEADER_COLS },
810 : { XML_NAMESPACE_TABLE, XML_TABLE_COLUMNS, XML_TOK_TABLE_COLS },
811 : { XML_NAMESPACE_TABLE, XML_TABLE_COLUMN, XML_TOK_TABLE_COL },
812 : { XML_NAMESPACE_TABLE, XML_TABLE_PROTECTION, XML_TOK_TABLE_PROTECTION },
813 : { XML_NAMESPACE_LO_EXT, XML_TABLE_PROTECTION, XML_TOK_TABLE_PROTECTION_EXT },
814 : { XML_NAMESPACE_OFFICE_EXT, XML_TABLE_PROTECTION, XML_TOK_TABLE_PROTECTION_EXT },
815 : { XML_NAMESPACE_TABLE, XML_TABLE_ROW_GROUP, XML_TOK_TABLE_ROW_GROUP },
816 : { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, XML_TOK_TABLE_HEADER_ROWS },
817 : { XML_NAMESPACE_TABLE, XML_TABLE_ROWS, XML_TOK_TABLE_ROWS },
818 : { XML_NAMESPACE_TABLE, XML_TABLE_ROW, XML_TOK_TABLE_ROW },
819 : { XML_NAMESPACE_TABLE, XML_TABLE_SOURCE, XML_TOK_TABLE_SOURCE },
820 : { XML_NAMESPACE_TABLE, XML_SCENARIO, XML_TOK_TABLE_SCENARIO },
821 : { XML_NAMESPACE_TABLE, XML_SHAPES, XML_TOK_TABLE_SHAPES },
822 : { XML_NAMESPACE_OFFICE, XML_FORMS, XML_TOK_TABLE_FORMS },
823 : { XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, XML_TOK_TABLE_EVENT_LISTENERS },
824 : { XML_NAMESPACE_OFFICE_EXT, XML_EVENT_LISTENERS, XML_TOK_TABLE_EVENT_LISTENERS_EXT },
825 : { XML_NAMESPACE_CALC_EXT, XML_CONDITIONAL_FORMATS, XML_TOK_TABLE_CONDFORMATS },
826 : XML_TOKEN_MAP_END
827 : };
828 :
829 322 : pTableElemTokenMap = new SvXMLTokenMap( aTableTokenMap );
830 : } // if( !pTableElemTokenMap )
831 :
832 9032 : return *pTableElemTokenMap;
833 : }
834 :
835 4 : const SvXMLTokenMap& ScXMLImport::GetTableProtectionAttrTokenMap()
836 : {
837 4 : if (!pTableProtectionElemTokenMap)
838 : {
839 : static const SvXMLTokenMapEntry aTableProtectionTokenMap[] =
840 : {
841 : { XML_NAMESPACE_TABLE, XML_SELECT_PROTECTED_CELLS, XML_TOK_TABLE_SELECT_PROTECTED_CELLS },
842 : { XML_NAMESPACE_TABLE, XML_SELECT_UNPROTECTED_CELLS, XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS },
843 : { XML_NAMESPACE_OFFICE_EXT, XML_SELECT_PROTECTED_CELLS, XML_TOK_TABLE_SELECT_PROTECTED_CELLS_EXT },
844 : { XML_NAMESPACE_LO_EXT, XML_SELECT_PROTECTED_CELLS, XML_TOK_TABLE_SELECT_PROTECTED_CELLS_EXT },
845 : { XML_NAMESPACE_OFFICE_EXT, XML_SELECT_UNPROTECTED_CELLS, XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS_EXT },
846 : { XML_NAMESPACE_LO_EXT, XML_SELECT_UNPROTECTED_CELLS, XML_TOK_TABLE_SELECT_UNPROTECTED_CELLS_EXT },
847 : XML_TOKEN_MAP_END
848 : };
849 4 : pTableProtectionElemTokenMap = new SvXMLTokenMap(aTableProtectionTokenMap);
850 : }
851 :
852 4 : return *pTableProtectionElemTokenMap;
853 : }
854 :
855 52 : const SvXMLTokenMap& ScXMLImport::GetTableRowsElemTokenMap()
856 : {
857 52 : if( !pTableRowsElemTokenMap )
858 : {
859 : static const SvXMLTokenMapEntry aTableRowsElemTokenMap[] =
860 : {
861 : { XML_NAMESPACE_TABLE, XML_TABLE_ROW_GROUP, XML_TOK_TABLE_ROWS_ROW_GROUP },
862 : { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, XML_TOK_TABLE_ROWS_HEADER_ROWS },
863 : { XML_NAMESPACE_TABLE, XML_TABLE_ROWS, XML_TOK_TABLE_ROWS_ROWS },
864 : { XML_NAMESPACE_TABLE, XML_TABLE_ROW, XML_TOK_TABLE_ROWS_ROW },
865 : XML_TOKEN_MAP_END
866 : };
867 :
868 6 : pTableRowsElemTokenMap = new SvXMLTokenMap( aTableRowsElemTokenMap );
869 : } // if( !pTableRowsElemTokenMap )
870 :
871 52 : return *pTableRowsElemTokenMap;
872 : }
873 :
874 40 : const SvXMLTokenMap& ScXMLImport::GetTableColsElemTokenMap()
875 : {
876 40 : if( !pTableColsElemTokenMap )
877 : {
878 : static const SvXMLTokenMapEntry aTableColsElemTokenMap[] =
879 : {
880 : { XML_NAMESPACE_TABLE, XML_TABLE_COLUMN_GROUP, XML_TOK_TABLE_COLS_COL_GROUP },
881 : { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_COLUMNS, XML_TOK_TABLE_COLS_HEADER_COLS },
882 : { XML_NAMESPACE_TABLE, XML_TABLE_COLUMNS, XML_TOK_TABLE_COLS_COLS },
883 : { XML_NAMESPACE_TABLE, XML_TABLE_COLUMN, XML_TOK_TABLE_COLS_COL },
884 : XML_TOKEN_MAP_END
885 : };
886 :
887 4 : pTableColsElemTokenMap = new SvXMLTokenMap( aTableColsElemTokenMap );
888 : } // if( !pTableColsElemTokenMap )
889 :
890 40 : return *pTableColsElemTokenMap;
891 : }
892 :
893 582 : const SvXMLTokenMap& ScXMLImport::GetTableAttrTokenMap()
894 : {
895 582 : if( !pTableAttrTokenMap )
896 : {
897 : static const SvXMLTokenMapEntry aTableAttrTokenMap[] =
898 : {
899 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_TABLE_NAME },
900 : { XML_NAMESPACE_TABLE, XML_STYLE_NAME, XML_TOK_TABLE_STYLE_NAME },
901 : { XML_NAMESPACE_TABLE, XML_PROTECTED, XML_TOK_TABLE_PROTECTED },
902 : { XML_NAMESPACE_TABLE, XML_PRINT_RANGES, XML_TOK_TABLE_PRINT_RANGES },
903 : { XML_NAMESPACE_TABLE, XML_PROTECTION_KEY, XML_TOK_TABLE_PASSWORD },
904 : { XML_NAMESPACE_TABLE, XML_PROTECTION_KEY_DIGEST_ALGORITHM, XML_TOK_TABLE_PASSHASH },
905 : { XML_NAMESPACE_TABLE, XML_PROTECTION_KEY_DIGEST_ALGORITHM_2, XML_TOK_TABLE_PASSHASH_2 },
906 : { XML_NAMESPACE_TABLE, XML_PRINT, XML_TOK_TABLE_PRINT },
907 : XML_TOKEN_MAP_END
908 : };
909 :
910 322 : pTableAttrTokenMap = new SvXMLTokenMap( aTableAttrTokenMap );
911 : } // if( !pTableAttrTokenMap )
912 :
913 582 : return *pTableAttrTokenMap;
914 : }
915 :
916 0 : const SvXMLTokenMap& ScXMLImport::GetTableScenarioAttrTokenMap()
917 : {
918 0 : if( !pTableScenarioAttrTokenMap )
919 : {
920 : static const SvXMLTokenMapEntry aTableScenarioAttrTokenMap[] =
921 : {
922 : { XML_NAMESPACE_TABLE, XML_DISPLAY_BORDER, XML_TOK_TABLE_SCENARIO_ATTR_DISPLAY_BORDER },
923 : { XML_NAMESPACE_TABLE, XML_BORDER_COLOR, XML_TOK_TABLE_SCENARIO_ATTR_BORDER_COLOR },
924 : { XML_NAMESPACE_TABLE, XML_COPY_BACK, XML_TOK_TABLE_SCENARIO_ATTR_COPY_BACK },
925 : { XML_NAMESPACE_TABLE, XML_COPY_STYLES, XML_TOK_TABLE_SCENARIO_ATTR_COPY_STYLES },
926 : { XML_NAMESPACE_TABLE, XML_COPY_FORMULAS, XML_TOK_TABLE_SCENARIO_ATTR_COPY_FORMULAS },
927 : { XML_NAMESPACE_TABLE, XML_IS_ACTIVE, XML_TOK_TABLE_SCENARIO_ATTR_IS_ACTIVE },
928 : { XML_NAMESPACE_TABLE, XML_SCENARIO_RANGES, XML_TOK_TABLE_SCENARIO_ATTR_SCENARIO_RANGES },
929 : { XML_NAMESPACE_TABLE, XML_COMMENT, XML_TOK_TABLE_SCENARIO_ATTR_COMMENT },
930 : { XML_NAMESPACE_TABLE, XML_PROTECTED, XML_TOK_TABLE_SCENARIO_ATTR_PROTECTED },
931 : XML_TOKEN_MAP_END
932 : };
933 :
934 0 : pTableScenarioAttrTokenMap = new SvXMLTokenMap( aTableScenarioAttrTokenMap );
935 : } // if( !pTableScenarioAttrTokenMap )
936 :
937 0 : return *pTableScenarioAttrTokenMap;
938 : }
939 :
940 2322 : const SvXMLTokenMap& ScXMLImport::GetTableColAttrTokenMap()
941 : {
942 2322 : if( !pTableColAttrTokenMap )
943 : {
944 : static const SvXMLTokenMapEntry aTableColAttrTokenMap[] =
945 : {
946 : { XML_NAMESPACE_TABLE, XML_STYLE_NAME, XML_TOK_TABLE_COL_ATTR_STYLE_NAME },
947 : { XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, XML_TOK_TABLE_COL_ATTR_REPEATED },
948 : { XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_TOK_TABLE_COL_ATTR_VISIBILITY },
949 : { XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME, XML_TOK_TABLE_COL_ATTR_DEFAULT_CELL_STYLE_NAME },
950 : XML_TOKEN_MAP_END
951 : };
952 :
953 322 : pTableColAttrTokenMap = new SvXMLTokenMap( aTableColAttrTokenMap );
954 : } // if( !pTableColAttrTokenMap )
955 :
956 2322 : return *pTableColAttrTokenMap;
957 : }
958 :
959 21130 : const SvXMLTokenMap& ScXMLImport::GetTableRowElemTokenMap()
960 : {
961 21130 : if( !pTableRowElemTokenMap )
962 : {
963 : static const SvXMLTokenMapEntry aTableRowTokenMap[] =
964 : {
965 : { XML_NAMESPACE_TABLE, XML_TABLE_CELL, XML_TOK_TABLE_ROW_CELL },
966 : { XML_NAMESPACE_TABLE, XML_COVERED_TABLE_CELL, XML_TOK_TABLE_ROW_COVERED_CELL },
967 : XML_TOKEN_MAP_END
968 : };
969 :
970 322 : pTableRowElemTokenMap = new SvXMLTokenMap( aTableRowTokenMap );
971 : } // if( !pTableRowElemTokenMap )
972 :
973 21130 : return *pTableRowElemTokenMap;
974 : }
975 :
976 6588 : const SvXMLTokenMap& ScXMLImport::GetTableRowAttrTokenMap()
977 : {
978 6588 : if( !pTableRowAttrTokenMap )
979 : {
980 : static const SvXMLTokenMapEntry aTableRowAttrTokenMap[] =
981 : {
982 : { XML_NAMESPACE_TABLE, XML_STYLE_NAME, XML_TOK_TABLE_ROW_ATTR_STYLE_NAME },
983 : { XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_TOK_TABLE_ROW_ATTR_VISIBILITY },
984 : { XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_REPEATED, XML_TOK_TABLE_ROW_ATTR_REPEATED },
985 : { XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME, XML_TOK_TABLE_ROW_ATTR_DEFAULT_CELL_STYLE_NAME },
986 : // { XML_NAMESPACE_TABLE, XML_USE_OPTIMAL_HEIGHT, XML_TOK_TABLE_ROW_ATTR_USE_OPTIMAL_HEIGHT },
987 : XML_TOKEN_MAP_END
988 : };
989 :
990 322 : pTableRowAttrTokenMap = new SvXMLTokenMap( aTableRowAttrTokenMap );
991 : } // if( !pTableRowAttrTokenMap )
992 :
993 6588 : return *pTableRowAttrTokenMap;
994 : }
995 :
996 12928 : const SvXMLTokenMap& ScXMLImport::GetTableRowCellElemTokenMap()
997 : {
998 12928 : if( !pTableRowCellElemTokenMap )
999 : {
1000 : static const SvXMLTokenMapEntry aTableRowCellTokenMap[] =
1001 : {
1002 : { XML_NAMESPACE_TEXT, XML_P, XML_TOK_TABLE_ROW_CELL_P },
1003 : { XML_NAMESPACE_TABLE, XML_SUB_TABLE, XML_TOK_TABLE_ROW_CELL_TABLE },
1004 : { XML_NAMESPACE_OFFICE, XML_ANNOTATION, XML_TOK_TABLE_ROW_CELL_ANNOTATION },
1005 : { XML_NAMESPACE_TABLE, XML_DETECTIVE, XML_TOK_TABLE_ROW_CELL_DETECTIVE },
1006 : { XML_NAMESPACE_TABLE, XML_CELL_RANGE_SOURCE, XML_TOK_TABLE_ROW_CELL_CELL_RANGE_SOURCE },
1007 : XML_TOKEN_MAP_END
1008 : };
1009 :
1010 292 : pTableRowCellElemTokenMap = new SvXMLTokenMap( aTableRowCellTokenMap );
1011 : } // if( !pTableRowCellElemTokenMap )
1012 :
1013 12928 : return *pTableRowCellElemTokenMap;
1014 : }
1015 :
1016 32 : const SvXMLTokenMap& ScXMLImport::GetTableAnnotationAttrTokenMap()
1017 : {
1018 32 : if( !pTableAnnotationAttrTokenMap )
1019 : {
1020 : static const SvXMLTokenMapEntry aTableAnnotationAttrTokenMap[] =
1021 : {
1022 : { XML_NAMESPACE_OFFICE, XML_AUTHOR, XML_TOK_TABLE_ANNOTATION_ATTR_AUTHOR },
1023 : { XML_NAMESPACE_OFFICE, XML_CREATE_DATE, XML_TOK_TABLE_ANNOTATION_ATTR_CREATE_DATE },
1024 : { XML_NAMESPACE_OFFICE, XML_CREATE_DATE_STRING, XML_TOK_TABLE_ANNOTATION_ATTR_CREATE_DATE_STRING },
1025 : { XML_NAMESPACE_OFFICE, XML_DISPLAY, XML_TOK_TABLE_ANNOTATION_ATTR_DISPLAY },
1026 : { XML_NAMESPACE_SVG, XML_X, XML_TOK_TABLE_ANNOTATION_ATTR_X },
1027 : { XML_NAMESPACE_SVG, XML_Y, XML_TOK_TABLE_ANNOTATION_ATTR_Y },
1028 : XML_TOKEN_MAP_END
1029 : };
1030 :
1031 26 : pTableAnnotationAttrTokenMap = new SvXMLTokenMap( aTableAnnotationAttrTokenMap );
1032 : } // if( !pTableAnnotationAttrTokenMap )
1033 :
1034 32 : return *pTableAnnotationAttrTokenMap;
1035 : }
1036 :
1037 0 : const SvXMLTokenMap& ScXMLImport::GetDetectiveElemTokenMap()
1038 : {
1039 0 : if( !pDetectiveElemTokenMap )
1040 : {
1041 : static const SvXMLTokenMapEntry aDetectiveElemTokenMap[]=
1042 : {
1043 : { XML_NAMESPACE_TABLE, XML_HIGHLIGHTED_RANGE, XML_TOK_DETECTIVE_ELEM_HIGHLIGHTED },
1044 : { XML_NAMESPACE_TABLE, XML_OPERATION, XML_TOK_DETECTIVE_ELEM_OPERATION },
1045 : XML_TOKEN_MAP_END
1046 : };
1047 :
1048 0 : pDetectiveElemTokenMap = new SvXMLTokenMap( aDetectiveElemTokenMap );
1049 : } // if( !pDetectiveElemTokenMap )
1050 :
1051 0 : return *pDetectiveElemTokenMap;
1052 : }
1053 :
1054 0 : const SvXMLTokenMap& ScXMLImport::GetDetectiveHighlightedAttrTokenMap()
1055 : {
1056 0 : if( !pDetectiveHighlightedAttrTokenMap )
1057 : {
1058 : static const SvXMLTokenMapEntry aDetectiveHighlightedAttrTokenMap[]=
1059 : {
1060 : { XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, XML_TOK_DETECTIVE_HIGHLIGHTED_ATTR_CELL_RANGE },
1061 : { XML_NAMESPACE_TABLE, XML_DIRECTION, XML_TOK_DETECTIVE_HIGHLIGHTED_ATTR_DIRECTION },
1062 : { XML_NAMESPACE_TABLE, XML_CONTAINS_ERROR, XML_TOK_DETECTIVE_HIGHLIGHTED_ATTR_CONTAINS_ERROR },
1063 : { XML_NAMESPACE_TABLE, XML_MARKED_INVALID, XML_TOK_DETECTIVE_HIGHLIGHTED_ATTR_MARKED_INVALID },
1064 : XML_TOKEN_MAP_END
1065 : };
1066 :
1067 0 : pDetectiveHighlightedAttrTokenMap = new SvXMLTokenMap( aDetectiveHighlightedAttrTokenMap );
1068 : } // if( !pDetectiveHighlightedAttrTokenMap )
1069 :
1070 0 : return *pDetectiveHighlightedAttrTokenMap;
1071 : }
1072 :
1073 0 : const SvXMLTokenMap& ScXMLImport::GetDetectiveOperationAttrTokenMap()
1074 : {
1075 0 : if( !pDetectiveOperationAttrTokenMap )
1076 : {
1077 : static const SvXMLTokenMapEntry aDetectiveOperationAttrTokenMap[]=
1078 : {
1079 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_DETECTIVE_OPERATION_ATTR_NAME },
1080 : { XML_NAMESPACE_TABLE, XML_INDEX, XML_TOK_DETECTIVE_OPERATION_ATTR_INDEX },
1081 : XML_TOKEN_MAP_END
1082 : };
1083 :
1084 0 : pDetectiveOperationAttrTokenMap = new SvXMLTokenMap( aDetectiveOperationAttrTokenMap );
1085 : } // if( !pDetectiveOperationAttrTokenMap )
1086 :
1087 0 : return *pDetectiveOperationAttrTokenMap;
1088 : }
1089 :
1090 0 : const SvXMLTokenMap& ScXMLImport::GetTableCellRangeSourceAttrTokenMap()
1091 : {
1092 0 : if( !pTableCellRangeSourceAttrTokenMap )
1093 : {
1094 : static const SvXMLTokenMapEntry aTableCellRangeSourceAttrTokenMap[] =
1095 : {
1096 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_TABLE_CELL_RANGE_SOURCE_ATTR_NAME },
1097 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TABLE_CELL_RANGE_SOURCE_ATTR_HREF },
1098 : { XML_NAMESPACE_TABLE, XML_FILTER_NAME, XML_TOK_TABLE_CELL_RANGE_SOURCE_ATTR_FILTER_NAME },
1099 : { XML_NAMESPACE_TABLE, XML_FILTER_OPTIONS, XML_TOK_TABLE_CELL_RANGE_SOURCE_ATTR_FILTER_OPTIONS },
1100 : { XML_NAMESPACE_TABLE, XML_LAST_COLUMN_SPANNED, XML_TOK_TABLE_CELL_RANGE_SOURCE_ATTR_LAST_COLUMN },
1101 : { XML_NAMESPACE_TABLE, XML_LAST_ROW_SPANNED, XML_TOK_TABLE_CELL_RANGE_SOURCE_ATTR_LAST_ROW },
1102 : { XML_NAMESPACE_TABLE, XML_REFRESH_DELAY, XML_TOK_TABLE_CELL_RANGE_SOURCE_ATTR_REFRESH_DELAY },
1103 : XML_TOKEN_MAP_END
1104 : };
1105 :
1106 0 : pTableCellRangeSourceAttrTokenMap = new SvXMLTokenMap( aTableCellRangeSourceAttrTokenMap );
1107 : } // if( !pTableCellRangeSourceAttrTokenMap )
1108 :
1109 0 : return *pTableCellRangeSourceAttrTokenMap;
1110 : }
1111 :
1112 124 : const SvXMLTokenMap& ScXMLImport::GetNamedExpressionsElemTokenMap()
1113 : {
1114 124 : if( !pNamedExpressionsElemTokenMap )
1115 : {
1116 : static const SvXMLTokenMapEntry aNamedExpressionsTokenMap[] =
1117 : {
1118 : { XML_NAMESPACE_TABLE, XML_NAMED_RANGE, XML_TOK_NAMED_EXPRESSIONS_NAMED_RANGE },
1119 : { XML_NAMESPACE_TABLE, XML_NAMED_EXPRESSION, XML_TOK_NAMED_EXPRESSIONS_NAMED_EXPRESSION },
1120 : XML_TOKEN_MAP_END
1121 : };
1122 :
1123 22 : pNamedExpressionsElemTokenMap = new SvXMLTokenMap( aNamedExpressionsTokenMap );
1124 : } // if( !pNamedExpressionsElemTokenMap )
1125 :
1126 124 : return *pNamedExpressionsElemTokenMap;
1127 : }
1128 :
1129 74 : const SvXMLTokenMap& ScXMLImport::GetNamedRangeAttrTokenMap()
1130 : {
1131 74 : if( !pNamedRangeAttrTokenMap )
1132 : {
1133 : static const SvXMLTokenMapEntry aNamedRangeAttrTokenMap[] =
1134 : {
1135 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_NAMED_RANGE_ATTR_NAME },
1136 : { XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, XML_TOK_NAMED_RANGE_ATTR_CELL_RANGE_ADDRESS },
1137 : { XML_NAMESPACE_TABLE, XML_BASE_CELL_ADDRESS, XML_TOK_NAMED_RANGE_ATTR_BASE_CELL_ADDRESS },
1138 : { XML_NAMESPACE_TABLE, XML_RANGE_USABLE_AS, XML_TOK_NAMED_RANGE_ATTR_RANGE_USABLE_AS },
1139 : XML_TOKEN_MAP_END
1140 : };
1141 :
1142 22 : pNamedRangeAttrTokenMap = new SvXMLTokenMap( aNamedRangeAttrTokenMap );
1143 : } // if( !pNamedRangeAttrTokenMap )
1144 :
1145 74 : return *pNamedRangeAttrTokenMap;
1146 : }
1147 :
1148 50 : const SvXMLTokenMap& ScXMLImport::GetNamedExpressionAttrTokenMap()
1149 : {
1150 50 : if( !pNamedExpressionAttrTokenMap )
1151 : {
1152 : static const SvXMLTokenMapEntry aNamedExpressionAttrTokenMap[] =
1153 : {
1154 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_NAMED_EXPRESSION_ATTR_NAME },
1155 : { XML_NAMESPACE_TABLE, XML_BASE_CELL_ADDRESS, XML_TOK_NAMED_EXPRESSION_ATTR_BASE_CELL_ADDRESS },
1156 : { XML_NAMESPACE_TABLE, XML_EXPRESSION, XML_TOK_NAMED_EXPRESSION_ATTR_EXPRESSION },
1157 : XML_TOKEN_MAP_END
1158 : };
1159 :
1160 4 : pNamedExpressionAttrTokenMap = new SvXMLTokenMap( aNamedExpressionAttrTokenMap );
1161 : } // if( !pNamedExpressionAttrTokenMap )
1162 :
1163 50 : return *pNamedExpressionAttrTokenMap;
1164 : }
1165 :
1166 32 : const SvXMLTokenMap& ScXMLImport::GetDatabaseRangesElemTokenMap()
1167 : {
1168 32 : if( !pDatabaseRangesElemTokenMap )
1169 : {
1170 : static const SvXMLTokenMapEntry aDatabaseRangesTokenMap[] =
1171 : {
1172 : { XML_NAMESPACE_TABLE, XML_DATABASE_RANGE, XML_TOK_DATABASE_RANGE },
1173 : XML_TOKEN_MAP_END
1174 : };
1175 :
1176 16 : pDatabaseRangesElemTokenMap = new SvXMLTokenMap( aDatabaseRangesTokenMap );
1177 : } // if( !pDatabaseRangesElemTokenMap )
1178 :
1179 32 : return *pDatabaseRangesElemTokenMap;
1180 : }
1181 :
1182 14 : const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeElemTokenMap()
1183 : {
1184 14 : if( !pDatabaseRangeElemTokenMap )
1185 : {
1186 : static const SvXMLTokenMapEntry aDatabaseRangeTokenMap[] =
1187 : {
1188 : { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_SQL, XML_TOK_DATABASE_RANGE_SOURCE_SQL },
1189 : { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_TABLE, XML_TOK_DATABASE_RANGE_SOURCE_TABLE },
1190 : { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_QUERY, XML_TOK_DATABASE_RANGE_SOURCE_QUERY },
1191 : { XML_NAMESPACE_TABLE, XML_FILTER, XML_TOK_FILTER },
1192 : { XML_NAMESPACE_TABLE, XML_SORT, XML_TOK_SORT },
1193 : { XML_NAMESPACE_TABLE, XML_SUBTOTAL_RULES, XML_TOK_DATABASE_RANGE_SUBTOTAL_RULES },
1194 : XML_TOKEN_MAP_END
1195 : };
1196 :
1197 10 : pDatabaseRangeElemTokenMap = new SvXMLTokenMap( aDatabaseRangeTokenMap );
1198 : } // if( !pDatabaseRangeElemTokenMap )
1199 :
1200 14 : return *pDatabaseRangeElemTokenMap;
1201 : }
1202 :
1203 32 : const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeAttrTokenMap()
1204 : {
1205 32 : if( !pDatabaseRangeAttrTokenMap )
1206 : {
1207 : static const SvXMLTokenMapEntry aDatabaseRangeAttrTokenMap[] =
1208 : {
1209 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_DATABASE_RANGE_ATTR_NAME },
1210 : { XML_NAMESPACE_TABLE, XML_IS_SELECTION, XML_TOK_DATABASE_RANGE_ATTR_IS_SELECTION },
1211 : { XML_NAMESPACE_TABLE, XML_ON_UPDATE_KEEP_STYLES, XML_TOK_DATABASE_RANGE_ATTR_ON_UPDATE_KEEP_STYLES },
1212 : { XML_NAMESPACE_TABLE, XML_ON_UPDATE_KEEP_SIZE, XML_TOK_DATABASE_RANGE_ATTR_ON_UPDATE_KEEP_SIZE },
1213 : { XML_NAMESPACE_TABLE, XML_HAS_PERSISTENT_DATA, XML_TOK_DATABASE_RANGE_ATTR_HAS_PERSISTENT_DATA },
1214 : { XML_NAMESPACE_TABLE, XML_ORIENTATION, XML_TOK_DATABASE_RANGE_ATTR_ORIENTATION },
1215 : { XML_NAMESPACE_TABLE, XML_CONTAINS_HEADER, XML_TOK_DATABASE_RANGE_ATTR_CONTAINS_HEADER },
1216 : { XML_NAMESPACE_TABLE, XML_DISPLAY_FILTER_BUTTONS, XML_TOK_DATABASE_RANGE_ATTR_DISPLAY_FILTER_BUTTONS },
1217 : { XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, XML_TOK_DATABASE_RANGE_ATTR_TARGET_RANGE_ADDRESS },
1218 : { XML_NAMESPACE_TABLE, XML_REFRESH_DELAY, XML_TOK_DATABASE_RANGE_ATTR_REFRESH_DELAY },
1219 : XML_TOKEN_MAP_END
1220 : };
1221 :
1222 16 : pDatabaseRangeAttrTokenMap = new SvXMLTokenMap( aDatabaseRangeAttrTokenMap );
1223 : } // if( !pDatabaseRangeAttrTokenMap )
1224 :
1225 32 : return *pDatabaseRangeAttrTokenMap;
1226 : }
1227 :
1228 0 : const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeSourceSQLAttrTokenMap()
1229 : {
1230 0 : if( !pDatabaseRangeSourceSQLAttrTokenMap )
1231 : {
1232 : static const SvXMLTokenMapEntry aDatabaseRangeSourceSQLAttrTokenMap[] =
1233 : {
1234 : { XML_NAMESPACE_TABLE, XML_DATABASE_NAME, XML_TOK_SOURCE_SQL_ATTR_DATABASE_NAME },
1235 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_SOURCE_SQL_ATTR_HREF },
1236 : { XML_NAMESPACE_TABLE, XML_CONNECTION_RESOURCE, XML_TOK_SOURCE_SQL_ATTR_CONNECTION_RESOURCE},
1237 : { XML_NAMESPACE_TABLE, XML_SQL_STATEMENT, XML_TOK_SOURCE_SQL_ATTR_SQL_STATEMENT },
1238 : { XML_NAMESPACE_TABLE, XML_PARSE_SQL_STATEMENT, XML_TOK_SOURCE_SQL_ATTR_PARSE_SQL_STATEMENT },
1239 : XML_TOKEN_MAP_END
1240 : };
1241 :
1242 0 : pDatabaseRangeSourceSQLAttrTokenMap = new SvXMLTokenMap( aDatabaseRangeSourceSQLAttrTokenMap );
1243 : } // if( !pDatabaseRangeSourceSQLAttrTokenMap )
1244 :
1245 0 : return *pDatabaseRangeSourceSQLAttrTokenMap;
1246 : }
1247 :
1248 2 : const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeSourceTableAttrTokenMap()
1249 : {
1250 2 : if( !pDatabaseRangeSourceTableAttrTokenMap )
1251 : {
1252 : static const SvXMLTokenMapEntry aDatabaseRangeSourceTableAttrTokenMap[] =
1253 : {
1254 : { XML_NAMESPACE_TABLE, XML_DATABASE_NAME, XML_TOK_SOURCE_TABLE_ATTR_DATABASE_NAME },
1255 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_SOURCE_TABLE_ATTR_HREF },
1256 : { XML_NAMESPACE_TABLE, XML_CONNECTION_RESOURCE, XML_TOK_SOURCE_TABLE_ATTR_CONNECTION_RESOURCE },
1257 : { XML_NAMESPACE_TABLE, XML_TABLE_NAME, XML_TOK_SOURCE_TABLE_ATTR_TABLE_NAME },
1258 : XML_TOKEN_MAP_END
1259 : };
1260 :
1261 2 : pDatabaseRangeSourceTableAttrTokenMap = new SvXMLTokenMap( aDatabaseRangeSourceTableAttrTokenMap );
1262 : } // if( !pDatabaseRangeSourceTableAttrTokenMap )
1263 :
1264 2 : return *pDatabaseRangeSourceTableAttrTokenMap;
1265 : }
1266 :
1267 0 : const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeSourceQueryAttrTokenMap()
1268 : {
1269 0 : if( !pDatabaseRangeSourceQueryAttrTokenMap )
1270 : {
1271 : static const SvXMLTokenMapEntry aDatabaseRangeSourceQueryAttrTokenMap[] =
1272 : {
1273 : { XML_NAMESPACE_TABLE, XML_DATABASE_NAME, XML_TOK_SOURCE_QUERY_ATTR_DATABASE_NAME },
1274 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_SOURCE_QUERY_ATTR_HREF },
1275 : { XML_NAMESPACE_TABLE, XML_CONNECTION_RESOURCE, XML_TOK_SOURCE_QUERY_ATTR_CONNECTION_RESOURCE },
1276 : { XML_NAMESPACE_TABLE, XML_QUERY_NAME, XML_TOK_SOURCE_QUERY_ATTR_QUERY_NAME },
1277 : XML_TOKEN_MAP_END
1278 : };
1279 :
1280 0 : pDatabaseRangeSourceQueryAttrTokenMap = new SvXMLTokenMap( aDatabaseRangeSourceQueryAttrTokenMap );
1281 : } // if( !pDatabaseRangeSourceQueryAttrTokenMap )
1282 :
1283 0 : return *pDatabaseRangeSourceQueryAttrTokenMap;
1284 : }
1285 :
1286 24 : const SvXMLTokenMap& ScXMLImport::GetFilterElemTokenMap()
1287 : {
1288 24 : if( !pFilterElemTokenMap )
1289 : {
1290 : static const SvXMLTokenMapEntry aFilterTokenMap[] =
1291 : {
1292 : { XML_NAMESPACE_TABLE, XML_FILTER_AND, XML_TOK_FILTER_AND },
1293 : { XML_NAMESPACE_TABLE, XML_FILTER_OR, XML_TOK_FILTER_OR },
1294 : { XML_NAMESPACE_TABLE, XML_FILTER_CONDITION, XML_TOK_FILTER_CONDITION },
1295 : XML_TOKEN_MAP_END
1296 : };
1297 :
1298 6 : pFilterElemTokenMap = new SvXMLTokenMap( aFilterTokenMap );
1299 : } // if( !pFilterElemTokenMap )
1300 :
1301 24 : return *pFilterElemTokenMap;
1302 : }
1303 :
1304 10 : const SvXMLTokenMap& ScXMLImport::GetFilterAttrTokenMap()
1305 : {
1306 10 : if( !pFilterAttrTokenMap )
1307 : {
1308 : static const SvXMLTokenMapEntry aFilterAttrTokenMap[] =
1309 : {
1310 : { XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, XML_TOK_FILTER_ATTR_TARGET_RANGE_ADDRESS },
1311 : { XML_NAMESPACE_TABLE, XML_CONDITION_SOURCE_RANGE_ADDRESS, XML_TOK_FILTER_ATTR_CONDITION_SOURCE_RANGE_ADDRESS },
1312 : { XML_NAMESPACE_TABLE, XML_CONDITION_SOURCE, XML_TOK_FILTER_ATTR_CONDITION_SOURCE },
1313 : { XML_NAMESPACE_TABLE, XML_DISPLAY_DUPLICATES, XML_TOK_FILTER_ATTR_DISPLAY_DUPLICATES },
1314 : XML_TOKEN_MAP_END
1315 : };
1316 :
1317 6 : pFilterAttrTokenMap = new SvXMLTokenMap( aFilterAttrTokenMap );
1318 : } // if( !pFilterAttrTokenMap )
1319 :
1320 10 : return *pFilterAttrTokenMap;
1321 : }
1322 :
1323 16 : const SvXMLTokenMap& ScXMLImport::GetFilterConditionElemTokenMap()
1324 : {
1325 16 : if( !pFilterConditionElemTokenMap )
1326 : {
1327 : static const SvXMLTokenMapEntry aTokenMap[] =
1328 : {
1329 : { XML_NAMESPACE_TABLE, XML_FILTER_SET_ITEM, XML_TOK_CONDITION_FILTER_SET_ITEM },
1330 : XML_TOKEN_MAP_END
1331 : };
1332 :
1333 2 : pFilterConditionElemTokenMap = new SvXMLTokenMap( aTokenMap );
1334 : }
1335 :
1336 16 : return *pFilterConditionElemTokenMap;
1337 : }
1338 :
1339 14 : const SvXMLTokenMap& ScXMLImport::GetFilterConditionAttrTokenMap()
1340 : {
1341 14 : if( !pFilterConditionAttrTokenMap )
1342 : {
1343 : static const SvXMLTokenMapEntry aFilterConditionAttrTokenMap[] =
1344 : {
1345 : { XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, XML_TOK_CONDITION_ATTR_FIELD_NUMBER },
1346 : { XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TOK_CONDITION_ATTR_CASE_SENSITIVE },
1347 : { XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_TOK_CONDITION_ATTR_DATA_TYPE },
1348 : { XML_NAMESPACE_TABLE, XML_VALUE, XML_TOK_CONDITION_ATTR_VALUE },
1349 : { XML_NAMESPACE_TABLE, XML_OPERATOR, XML_TOK_CONDITION_ATTR_OPERATOR },
1350 : XML_TOKEN_MAP_END
1351 : };
1352 :
1353 6 : pFilterConditionAttrTokenMap = new SvXMLTokenMap( aFilterConditionAttrTokenMap );
1354 : } // if( !pFilterConditionAttrTokenMap )
1355 :
1356 14 : return *pFilterConditionAttrTokenMap;
1357 : }
1358 :
1359 16 : const SvXMLTokenMap& ScXMLImport::GetFilterSetItemAttrTokenMap()
1360 : {
1361 16 : if( !pFilterSetItemAttrTokenMap )
1362 : {
1363 : static const SvXMLTokenMapEntry aTokenMap[] =
1364 : {
1365 : { XML_NAMESPACE_TABLE, XML_VALUE, XML_TOK_FILTER_SET_ITEM_ATTR_VALUE },
1366 : XML_TOKEN_MAP_END
1367 : };
1368 :
1369 2 : pFilterSetItemAttrTokenMap = new SvXMLTokenMap( aTokenMap );
1370 : }
1371 :
1372 16 : return *pFilterSetItemAttrTokenMap;
1373 : }
1374 :
1375 4 : const SvXMLTokenMap& ScXMLImport::GetSortElemTokenMap()
1376 : {
1377 4 : if( !pSortElemTokenMap )
1378 : {
1379 : static const SvXMLTokenMapEntry aSortTokenMap[] =
1380 : {
1381 : { XML_NAMESPACE_TABLE, XML_SORT_BY, XML_TOK_SORT_SORT_BY },
1382 : XML_TOKEN_MAP_END
1383 : };
1384 :
1385 4 : pSortElemTokenMap = new SvXMLTokenMap( aSortTokenMap );
1386 : } // if( !pSortElemTokenMap )
1387 :
1388 4 : return *pSortElemTokenMap;
1389 : }
1390 :
1391 4 : const SvXMLTokenMap& ScXMLImport::GetSortAttrTokenMap()
1392 : {
1393 4 : if( !pSortAttrTokenMap )
1394 : {
1395 : static const SvXMLTokenMapEntry aSortAttrTokenMap[] =
1396 : {
1397 : { XML_NAMESPACE_TABLE, XML_BIND_STYLES_TO_CONTENT, XML_TOK_SORT_ATTR_BIND_STYLES_TO_CONTENT },
1398 : { XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, XML_TOK_SORT_ATTR_TARGET_RANGE_ADDRESS },
1399 : { XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TOK_SORT_ATTR_CASE_SENSITIVE },
1400 : { XML_NAMESPACE_TABLE, XML_RFC_LANGUAGE_TAG, XML_TOK_SORT_ATTR_RFC_LANGUAGE_TAG },
1401 : { XML_NAMESPACE_TABLE, XML_LANGUAGE, XML_TOK_SORT_ATTR_LANGUAGE },
1402 : { XML_NAMESPACE_TABLE, XML_SCRIPT, XML_TOK_SORT_ATTR_SCRIPT },
1403 : { XML_NAMESPACE_TABLE, XML_COUNTRY, XML_TOK_SORT_ATTR_COUNTRY },
1404 : { XML_NAMESPACE_TABLE, XML_ALGORITHM, XML_TOK_SORT_ATTR_ALGORITHM },
1405 : XML_TOKEN_MAP_END
1406 : };
1407 :
1408 4 : pSortAttrTokenMap = new SvXMLTokenMap( aSortAttrTokenMap );
1409 : } // if( !pSortAttrTokenMap )
1410 :
1411 4 : return *pSortAttrTokenMap;
1412 : }
1413 :
1414 4 : const SvXMLTokenMap& ScXMLImport::GetSortSortByAttrTokenMap()
1415 : {
1416 4 : if( !pSortSortByAttrTokenMap )
1417 : {
1418 : static const SvXMLTokenMapEntry aSortSortByAttrTokenMap[] =
1419 : {
1420 : { XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, XML_TOK_SORT_BY_ATTR_FIELD_NUMBER },
1421 : { XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_TOK_SORT_BY_ATTR_DATA_TYPE },
1422 : { XML_NAMESPACE_TABLE, XML_ORDER, XML_TOK_SORT_BY_ATTR_ORDER },
1423 : XML_TOKEN_MAP_END
1424 : };
1425 :
1426 4 : pSortSortByAttrTokenMap = new SvXMLTokenMap( aSortSortByAttrTokenMap );
1427 : } // if( !pSortSortByAttrTokenMap )
1428 :
1429 4 : return *pSortSortByAttrTokenMap;
1430 : }
1431 :
1432 0 : const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeSubTotalRulesElemTokenMap()
1433 : {
1434 0 : if( !pDatabaseRangeSubTotalRulesElemTokenMap )
1435 : {
1436 : static const SvXMLTokenMapEntry aDatabaseRangeSubTotalRulesTokenMap[] =
1437 : {
1438 : { XML_NAMESPACE_TABLE, XML_SORT_GROUPS, XML_TOK_SUBTOTAL_RULES_SORT_GROUPS },
1439 : { XML_NAMESPACE_TABLE, XML_SUBTOTAL_RULE, XML_TOK_SUBTOTAL_RULES_SUBTOTAL_RULE },
1440 : XML_TOKEN_MAP_END
1441 : };
1442 :
1443 0 : pDatabaseRangeSubTotalRulesElemTokenMap = new SvXMLTokenMap( aDatabaseRangeSubTotalRulesTokenMap );
1444 : } // if( !pDatabaseRangeSubTotalRulesElemTokenMap )
1445 :
1446 0 : return *pDatabaseRangeSubTotalRulesElemTokenMap;
1447 : }
1448 :
1449 0 : const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeSubTotalRulesAttrTokenMap()
1450 : {
1451 0 : if( !pDatabaseRangeSubTotalRulesAttrTokenMap )
1452 : {
1453 : static const SvXMLTokenMapEntry aDatabaseRangeSubTotalRulesAttrTokenMap[] =
1454 : {
1455 : { XML_NAMESPACE_TABLE, XML_BIND_STYLES_TO_CONTENT, XML_TOK_SUBTOTAL_RULES_ATTR_BIND_STYLES_TO_CONTENT },
1456 : { XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TOK_SUBTOTAL_RULES_ATTR_CASE_SENSITIVE },
1457 : { XML_NAMESPACE_TABLE, XML_PAGE_BREAKS_ON_GROUP_CHANGE, XML_TOK_SUBTOTAL_RULES_ATTR_PAGE_BREAKS_ON_GROUP_CHANGE },
1458 : XML_TOKEN_MAP_END
1459 : };
1460 :
1461 0 : pDatabaseRangeSubTotalRulesAttrTokenMap = new SvXMLTokenMap( aDatabaseRangeSubTotalRulesAttrTokenMap );
1462 : } // if( !pDatabaseRangeSubTotalRulesAttrTokenMap )
1463 :
1464 0 : return *pDatabaseRangeSubTotalRulesAttrTokenMap;
1465 : }
1466 :
1467 0 : const SvXMLTokenMap& ScXMLImport::GetSubTotalRulesSortGroupsAttrTokenMap()
1468 : {
1469 0 : if( !pSubTotalRulesSortGroupsAttrTokenMap )
1470 : {
1471 : static const SvXMLTokenMapEntry aSubTotalRulesSortGroupsAttrTokenMap[] =
1472 : {
1473 : { XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_TOK_SORT_GROUPS_ATTR_DATA_TYPE },
1474 : { XML_NAMESPACE_TABLE, XML_ORDER, XML_TOK_SORT_GROUPS_ATTR_ORDER },
1475 : XML_TOKEN_MAP_END
1476 : };
1477 :
1478 0 : pSubTotalRulesSortGroupsAttrTokenMap = new SvXMLTokenMap( aSubTotalRulesSortGroupsAttrTokenMap );
1479 : } // if( !pSubTotalRulesSortGroupsAttrTokenMap )
1480 :
1481 0 : return *pSubTotalRulesSortGroupsAttrTokenMap;
1482 : }
1483 :
1484 0 : const SvXMLTokenMap& ScXMLImport::GetSubTotalRulesSubTotalRuleElemTokenMap()
1485 : {
1486 0 : if( !pSubTotalRulesSubTotalRuleElemTokenMap )
1487 : {
1488 : static const SvXMLTokenMapEntry aSubTotalRulesSubTotalRuleTokenMap[] =
1489 : {
1490 : { XML_NAMESPACE_TABLE, XML_SUBTOTAL_FIELD, XML_TOK_SUBTOTAL_RULE_SUBTOTAL_FIELD },
1491 : XML_TOKEN_MAP_END
1492 : };
1493 :
1494 0 : pSubTotalRulesSubTotalRuleElemTokenMap = new SvXMLTokenMap( aSubTotalRulesSubTotalRuleTokenMap );
1495 : } // if( !pSubTotalRulesSubTotalRuleElemTokenMap )
1496 :
1497 0 : return *pSubTotalRulesSubTotalRuleElemTokenMap;
1498 : }
1499 :
1500 0 : const SvXMLTokenMap& ScXMLImport::GetSubTotalRulesSubTotalRuleAttrTokenMap()
1501 : {
1502 0 : if( !pSubTotalRulesSubTotalRuleAttrTokenMap )
1503 : {
1504 : static const SvXMLTokenMapEntry aSubTotalRulesSubTotalRuleAttrTokenMap[] =
1505 : {
1506 : { XML_NAMESPACE_TABLE, XML_GROUP_BY_FIELD_NUMBER, XML_TOK_SUBTOTAL_RULE_ATTR_GROUP_BY_FIELD_NUMBER },
1507 : XML_TOKEN_MAP_END
1508 : };
1509 :
1510 0 : pSubTotalRulesSubTotalRuleAttrTokenMap = new SvXMLTokenMap( aSubTotalRulesSubTotalRuleAttrTokenMap );
1511 : } // if( !pSubTotalRulesSubTotalRuleAttrTokenMap )
1512 :
1513 0 : return *pSubTotalRulesSubTotalRuleAttrTokenMap;
1514 : }
1515 :
1516 0 : const SvXMLTokenMap& ScXMLImport::GetSubTotalRuleSubTotalFieldAttrTokenMap()
1517 : {
1518 0 : if( !pSubTotalRuleSubTotalFieldAttrTokenMap )
1519 : {
1520 : static const SvXMLTokenMapEntry aSubTotalRuleSubTotalFieldAttrTokenMap[] =
1521 : {
1522 : { XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, XML_TOK_SUBTOTAL_FIELD_ATTR_FIELD_NUMBER },
1523 : { XML_NAMESPACE_TABLE, XML_FUNCTION, XML_TOK_SUBTOTAL_FIELD_ATTR_FUNCTION },
1524 : XML_TOKEN_MAP_END
1525 : };
1526 :
1527 0 : pSubTotalRuleSubTotalFieldAttrTokenMap = new SvXMLTokenMap( aSubTotalRuleSubTotalFieldAttrTokenMap );
1528 : } // if( !pSubTotalRuleSubTotalFieldAttrTokenMap )
1529 :
1530 0 : return *pSubTotalRuleSubTotalFieldAttrTokenMap;
1531 : }
1532 :
1533 14 : const SvXMLTokenMap& ScXMLImport::GetDataPilotTablesElemTokenMap()
1534 : {
1535 14 : if( !pDataPilotTablesElemTokenMap )
1536 : {
1537 : static const SvXMLTokenMapEntry aDataPilotTablesElemTokenMap[] =
1538 : {
1539 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_TABLE, XML_TOK_DATA_PILOT_TABLE },
1540 : XML_TOKEN_MAP_END
1541 : };
1542 :
1543 10 : pDataPilotTablesElemTokenMap = new SvXMLTokenMap( aDataPilotTablesElemTokenMap );
1544 : } // if( !pDataPilotTablesElemTokenMap )
1545 :
1546 14 : return *pDataPilotTablesElemTokenMap;
1547 : }
1548 :
1549 14 : const SvXMLTokenMap& ScXMLImport::GetDataPilotTableAttrTokenMap()
1550 : {
1551 14 : if( !pDataPilotTableAttrTokenMap )
1552 : {
1553 : static const SvXMLTokenMapEntry aDataPilotTableAttrTokenMap[] =
1554 : {
1555 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_DATA_PILOT_TABLE_ATTR_NAME },
1556 : { XML_NAMESPACE_TABLE, XML_APPLICATION_DATA, XML_TOK_DATA_PILOT_TABLE_ATTR_APPLICATION_DATA },
1557 : { XML_NAMESPACE_TABLE, XML_GRAND_TOTAL, XML_TOK_DATA_PILOT_TABLE_ATTR_GRAND_TOTAL },
1558 : { XML_NAMESPACE_TABLE, XML_IGNORE_EMPTY_ROWS, XML_TOK_DATA_PILOT_TABLE_ATTR_IGNORE_EMPTY_ROWS },
1559 : { XML_NAMESPACE_TABLE, XML_IDENTIFY_CATEGORIES, XML_TOK_DATA_PILOT_TABLE_ATTR_IDENTIFY_CATEGORIES },
1560 : { XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, XML_TOK_DATA_PILOT_TABLE_ATTR_TARGET_RANGE_ADDRESS },
1561 : { XML_NAMESPACE_TABLE, XML_BUTTONS, XML_TOK_DATA_PILOT_TABLE_ATTR_BUTTONS },
1562 : { XML_NAMESPACE_TABLE, XML_SHOW_FILTER_BUTTON, XML_TOK_DATA_PILOT_TABLE_ATTR_SHOW_FILTER_BUTTON },
1563 : { XML_NAMESPACE_TABLE, XML_DRILL_DOWN_ON_DOUBLE_CLICK, XML_TOK_DATA_PILOT_TABLE_ATTR_DRILL_DOWN },
1564 : { XML_NAMESPACE_TABLE, XML_HEADER_GRID_LAYOUT, XML_TOK_DATA_PILOT_TABLE_ATTR_HEADER_GRID_LAYOUT },
1565 : XML_TOKEN_MAP_END
1566 : };
1567 :
1568 10 : pDataPilotTableAttrTokenMap = new SvXMLTokenMap( aDataPilotTableAttrTokenMap );
1569 : } // if( !pDataPilotTableAttrTokenMap )
1570 :
1571 14 : return *pDataPilotTableAttrTokenMap;
1572 : }
1573 :
1574 90 : const SvXMLTokenMap& ScXMLImport::GetDataPilotTableElemTokenMap()
1575 : {
1576 90 : if( !pDataPilotTableElemTokenMap )
1577 : {
1578 : static const SvXMLTokenMapEntry aDataPilotTableElemTokenMap[] =
1579 : {
1580 : { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_SQL, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_SQL },
1581 : { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_TABLE, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_TABLE },
1582 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_GRAND_TOTAL, XML_TOK_DATA_PILOT_TABLE_ELEM_GRAND_TOTAL },
1583 : { XML_NAMESPACE_TABLE_EXT, XML_DATA_PILOT_GRAND_TOTAL, XML_TOK_DATA_PILOT_TABLE_ELEM_GRAND_TOTAL_EXT },
1584 : { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_QUERY, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_QUERY },
1585 : { XML_NAMESPACE_TABLE, XML_SOURCE_SERVICE, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_SERVICE },
1586 : { XML_NAMESPACE_TABLE, XML_SOURCE_CELL_RANGE, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_CELL_RANGE },
1587 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_FIELD, XML_TOK_DATA_PILOT_TABLE_ELEM_DATA_PILOT_FIELD },
1588 : XML_TOKEN_MAP_END
1589 : };
1590 :
1591 10 : pDataPilotTableElemTokenMap = new SvXMLTokenMap( aDataPilotTableElemTokenMap );
1592 : } // if( !pDataPilotTableElemTokenMap )
1593 :
1594 90 : return *pDataPilotTableElemTokenMap;
1595 : }
1596 :
1597 0 : const SvXMLTokenMap& ScXMLImport::GetDataPilotTableSourceServiceAttrTokenMap()
1598 : {
1599 0 : if( !pDataPilotTableSourceServiceAttrTokenMap )
1600 : {
1601 : static const SvXMLTokenMapEntry aDataPilotTableSourceServiceAttrTokenMap[] =
1602 : {
1603 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_SOURCE_SERVICE_ATTR_NAME },
1604 : { XML_NAMESPACE_TABLE, XML_SOURCE_NAME, XML_TOK_SOURCE_SERVICE_ATTR_SOURCE_NAME },
1605 : { XML_NAMESPACE_TABLE, XML_OBJECT_NAME, XML_TOK_SOURCE_SERVICE_ATTR_OBJECT_NAME },
1606 : { XML_NAMESPACE_TABLE, XML_USER_NAME, XML_TOK_SOURCE_SERVICE_ATTR_USER_NAME },
1607 : { XML_NAMESPACE_TABLE, XML_PASSWORD, XML_TOK_SOURCE_SERVICE_ATTR_PASSWORD },
1608 : XML_TOKEN_MAP_END
1609 : };
1610 :
1611 0 : pDataPilotTableSourceServiceAttrTokenMap = new SvXMLTokenMap( aDataPilotTableSourceServiceAttrTokenMap );
1612 : } // if( !pDataPilotTableSourceServiceAttrTokenMap )
1613 :
1614 0 : return *pDataPilotTableSourceServiceAttrTokenMap;
1615 : }
1616 :
1617 0 : const SvXMLTokenMap& ScXMLImport::GetDataPilotGrandTotalAttrTokenMap()
1618 : {
1619 0 : if (!pDataPilotGrandTotalAttrTokenMap)
1620 : {
1621 : static const SvXMLTokenMapEntry aDataPilotGrandTotalAttrTokenMap[] =
1622 : {
1623 : { XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TOK_DATA_PILOT_GRAND_TOTAL_ATTR_DISPLAY },
1624 : { XML_NAMESPACE_TABLE, XML_ORIENTATION, XML_TOK_DATA_PILOT_GRAND_TOTAL_ATTR_ORIENTATION },
1625 : { XML_NAMESPACE_TABLE, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_GRAND_TOTAL_ATTR_DISPLAY_NAME },
1626 : { XML_NAMESPACE_TABLE_EXT, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_GRAND_TOTAL_ATTR_DISPLAY_NAME_EXT },
1627 : XML_TOKEN_MAP_END
1628 : };
1629 :
1630 0 : pDataPilotGrandTotalAttrTokenMap = new SvXMLTokenMap( aDataPilotGrandTotalAttrTokenMap );
1631 : }
1632 :
1633 0 : return *pDataPilotGrandTotalAttrTokenMap;
1634 : }
1635 :
1636 14 : const SvXMLTokenMap& ScXMLImport::GetDataPilotTableSourceCellRangeAttrTokenMap()
1637 : {
1638 14 : if( !pDataPilotTableSourceCellRangeAttrTokenMap )
1639 : {
1640 : static const SvXMLTokenMapEntry aDataPilotTableSourceCellRangeAttrTokenMap[] =
1641 : {
1642 : { XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, XML_TOK_SOURCE_CELL_RANGE_ATTR_CELL_RANGE_ADDRESS },
1643 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_SOURCE_CELL_RANGE_ATTR_NAME },
1644 : XML_TOKEN_MAP_END
1645 : };
1646 :
1647 10 : pDataPilotTableSourceCellRangeAttrTokenMap = new SvXMLTokenMap( aDataPilotTableSourceCellRangeAttrTokenMap );
1648 : } // if( !pDataPilotTableSourceCellRangeAttrTokenMap )
1649 :
1650 14 : return *pDataPilotTableSourceCellRangeAttrTokenMap;
1651 : }
1652 :
1653 2 : const SvXMLTokenMap& ScXMLImport::GetDataPilotTableSourceCellRangeElemTokenMap()
1654 : {
1655 2 : if( !pDataPilotTableSourceCellRangeElemTokenMap )
1656 : {
1657 : static const SvXMLTokenMapEntry aDataPilotTableSourceCellRangeElemTokenMap[] =
1658 : {
1659 : { XML_NAMESPACE_TABLE, XML_FILTER, XML_TOK_SOURCE_CELL_RANGE_ELEM_FILTER},
1660 : XML_TOKEN_MAP_END
1661 : };
1662 :
1663 2 : pDataPilotTableSourceCellRangeElemTokenMap = new SvXMLTokenMap( aDataPilotTableSourceCellRangeElemTokenMap );
1664 : } // if( !pDataPilotTableSourceCellRangeElemTokenMap )
1665 :
1666 2 : return *pDataPilotTableSourceCellRangeElemTokenMap;
1667 : }
1668 :
1669 76 : const SvXMLTokenMap& ScXMLImport::GetDataPilotFieldAttrTokenMap()
1670 : {
1671 76 : if( !pDataPilotFieldAttrTokenMap )
1672 : {
1673 : static const SvXMLTokenMapEntry aDataPilotFieldAttrTokenMap[] =
1674 : {
1675 : { XML_NAMESPACE_TABLE, XML_SOURCE_FIELD_NAME, XML_TOK_DATA_PILOT_FIELD_ATTR_SOURCE_FIELD_NAME },
1676 : { XML_NAMESPACE_TABLE, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_FIELD_ATTR_DISPLAY_NAME },
1677 : { XML_NAMESPACE_TABLE_EXT, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_FIELD_ATTR_DISPLAY_NAME_EXT },
1678 : { XML_NAMESPACE_TABLE, XML_IS_DATA_LAYOUT_FIELD, XML_TOK_DATA_PILOT_FIELD_ATTR_IS_DATA_LAYOUT_FIELD },
1679 : { XML_NAMESPACE_TABLE, XML_FUNCTION, XML_TOK_DATA_PILOT_FIELD_ATTR_FUNCTION },
1680 : { XML_NAMESPACE_TABLE, XML_ORIENTATION, XML_TOK_DATA_PILOT_FIELD_ATTR_ORIENTATION },
1681 : { XML_NAMESPACE_TABLE, XML_SELECTED_PAGE, XML_TOK_DATA_PILOT_FIELD_ATTR_SELECTED_PAGE },
1682 : { XML_NAMESPACE_TABLE, XML_USED_HIERARCHY, XML_TOK_DATA_PILOT_FIELD_ATTR_USED_HIERARCHY },
1683 : XML_TOKEN_MAP_END
1684 : };
1685 :
1686 10 : pDataPilotFieldAttrTokenMap = new SvXMLTokenMap( aDataPilotFieldAttrTokenMap );
1687 : } // if( !pDataPilotFieldAttrTokenMap )
1688 :
1689 76 : return *pDataPilotFieldAttrTokenMap;
1690 : }
1691 :
1692 84 : const SvXMLTokenMap& ScXMLImport::GetDataPilotFieldElemTokenMap()
1693 : {
1694 84 : if( !pDataPilotFieldElemTokenMap )
1695 : {
1696 : static const SvXMLTokenMapEntry aDataPilotFieldElemTokenMap[] =
1697 : {
1698 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_LEVEL, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_LEVEL },
1699 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_FIELD_REFERENCE, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_REFERENCE },
1700 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_GROUPS, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_GROUPS },
1701 : XML_TOKEN_MAP_END
1702 : };
1703 :
1704 10 : pDataPilotFieldElemTokenMap = new SvXMLTokenMap( aDataPilotFieldElemTokenMap );
1705 : } // if( !pDataPilotFieldElemTokenMap )
1706 :
1707 84 : return *pDataPilotFieldElemTokenMap;
1708 : }
1709 :
1710 76 : const SvXMLTokenMap& ScXMLImport::GetDataPilotLevelAttrTokenMap()
1711 : {
1712 76 : if( !pDataPilotLevelAttrTokenMap )
1713 : {
1714 : static const SvXMLTokenMapEntry aDataPilotLevelAttrTokenMap[] =
1715 : {
1716 : { XML_NAMESPACE_TABLE, XML_SHOW_EMPTY, XML_TOK_DATA_PILOT_LEVEL_ATTR_SHOW_EMPTY },
1717 : XML_TOKEN_MAP_END
1718 : };
1719 :
1720 10 : pDataPilotLevelAttrTokenMap = new SvXMLTokenMap( aDataPilotLevelAttrTokenMap );
1721 : } // if( !pDataPilotLevelAttrTokenMap )
1722 :
1723 76 : return *pDataPilotLevelAttrTokenMap;
1724 : }
1725 :
1726 220 : const SvXMLTokenMap& ScXMLImport::GetDataPilotLevelElemTokenMap()
1727 : {
1728 220 : if( !pDataPilotLevelElemTokenMap )
1729 : {
1730 : static const SvXMLTokenMapEntry aDataPilotLevelElemTokenMap[] =
1731 : {
1732 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_SUBTOTALS, XML_TOK_DATA_PILOT_LEVEL_ELEM_DATA_PILOT_SUBTOTALS },
1733 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_MEMBERS, XML_TOK_DATA_PILOT_LEVEL_ELEM_DATA_PILOT_MEMBERS },
1734 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_DISPLAY_INFO, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_DISPLAY_INFO },
1735 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_SORT_INFO, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_SORT_INFO },
1736 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_LAYOUT_INFO, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_LAYOUT_INFO },
1737 : XML_TOKEN_MAP_END
1738 : };
1739 :
1740 10 : pDataPilotLevelElemTokenMap = new SvXMLTokenMap( aDataPilotLevelElemTokenMap );
1741 : } // if( !pDataPilotLevelElemTokenMap )
1742 :
1743 220 : return *pDataPilotLevelElemTokenMap;
1744 : }
1745 :
1746 6 : const SvXMLTokenMap& ScXMLImport::GetDataPilotSubTotalsElemTokenMap()
1747 : {
1748 6 : if( !pDataPilotSubTotalsElemTokenMap )
1749 : {
1750 : static const SvXMLTokenMapEntry aDataPilotSubTotalsElemTokenMap[] =
1751 : {
1752 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_SUBTOTAL, XML_TOK_DATA_PILOT_SUBTOTALS_ELEM_DATA_PILOT_SUBTOTAL },
1753 : XML_TOKEN_MAP_END
1754 : };
1755 :
1756 4 : pDataPilotSubTotalsElemTokenMap = new SvXMLTokenMap( aDataPilotSubTotalsElemTokenMap );
1757 : } // if( !pDataPilotSubTotalsElemTokenMap )
1758 :
1759 6 : return *pDataPilotSubTotalsElemTokenMap;
1760 : }
1761 :
1762 6 : const SvXMLTokenMap& ScXMLImport::GetDataPilotSubTotalAttrTokenMap()
1763 : {
1764 6 : if( !pDataPilotSubTotalAttrTokenMap )
1765 : {
1766 : static const SvXMLTokenMapEntry aDataPilotSubTotalAttrTokenMap[] =
1767 : {
1768 : { XML_NAMESPACE_TABLE, XML_FUNCTION, XML_TOK_DATA_PILOT_SUBTOTAL_ATTR_FUNCTION },
1769 : { XML_NAMESPACE_TABLE, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_SUBTOTAL_ATTR_DISPLAY_NAME },
1770 : { XML_NAMESPACE_TABLE_EXT, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_SUBTOTAL_ATTR_DISPLAY_NAME_EXT },
1771 : XML_TOKEN_MAP_END
1772 : };
1773 :
1774 4 : pDataPilotSubTotalAttrTokenMap = new SvXMLTokenMap( aDataPilotSubTotalAttrTokenMap );
1775 : } // if( !pDataPilotSubTotalAttrTokenMap )
1776 :
1777 6 : return *pDataPilotSubTotalAttrTokenMap;
1778 : }
1779 :
1780 5832 : const SvXMLTokenMap& ScXMLImport::GetDataPilotMembersElemTokenMap()
1781 : {
1782 5832 : if( !pDataPilotMembersElemTokenMap )
1783 : {
1784 : static const SvXMLTokenMapEntry aDataPilotMembersElemTokenMap[] =
1785 : {
1786 : { XML_NAMESPACE_TABLE, XML_DATA_PILOT_MEMBER, XML_TOK_DATA_PILOT_MEMBERS_ELEM_DATA_PILOT_MEMBER },
1787 : XML_TOKEN_MAP_END
1788 : };
1789 :
1790 8 : pDataPilotMembersElemTokenMap = new SvXMLTokenMap( aDataPilotMembersElemTokenMap );
1791 : } // if( !pDataPilotMembersElemTokenMap )
1792 :
1793 5832 : return *pDataPilotMembersElemTokenMap;
1794 : }
1795 :
1796 5832 : const SvXMLTokenMap& ScXMLImport::GetDataPilotMemberAttrTokenMap()
1797 : {
1798 5832 : if( !pDataPilotMemberAttrTokenMap )
1799 : {
1800 : static const SvXMLTokenMapEntry aDataPilotMemberAttrTokenMap[] =
1801 : {
1802 : { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_DATA_PILOT_MEMBER_ATTR_NAME },
1803 : { XML_NAMESPACE_TABLE, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_MEMBER_ATTR_DISPLAY_NAME },
1804 : { XML_NAMESPACE_TABLE_EXT, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_MEMBER_ATTR_DISPLAY_NAME_EXT },
1805 : { XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TOK_DATA_PILOT_MEMBER_ATTR_DISPLAY },
1806 : { XML_NAMESPACE_TABLE, XML_SHOW_DETAILS, XML_TOK_DATA_PILOT_MEMBER_ATTR_SHOW_DETAILS },
1807 : XML_TOKEN_MAP_END
1808 : };
1809 :
1810 8 : pDataPilotMemberAttrTokenMap = new SvXMLTokenMap( aDataPilotMemberAttrTokenMap );
1811 : } // if( !pDataPilotMemberAttrTokenMap )
1812 :
1813 5832 : return *pDataPilotMemberAttrTokenMap;
1814 : }
1815 :
1816 0 : const SvXMLTokenMap& ScXMLImport::GetConsolidationAttrTokenMap()
1817 : {
1818 0 : if( !pConsolidationAttrTokenMap )
1819 : {
1820 : static const SvXMLTokenMapEntry aConsolidationAttrTokenMap[] =
1821 : {
1822 : { XML_NAMESPACE_TABLE, XML_FUNCTION, XML_TOK_CONSOLIDATION_ATTR_FUNCTION },
1823 : { XML_NAMESPACE_TABLE, XML_SOURCE_CELL_RANGE_ADDRESSES, XML_TOK_CONSOLIDATION_ATTR_SOURCE_RANGES },
1824 : { XML_NAMESPACE_TABLE, XML_TARGET_CELL_ADDRESS, XML_TOK_CONSOLIDATION_ATTR_TARGET_ADDRESS },
1825 : { XML_NAMESPACE_TABLE, XML_USE_LABEL, XML_TOK_CONSOLIDATION_ATTR_USE_LABEL },
1826 : { XML_NAMESPACE_TABLE, XML_LINK_TO_SOURCE_DATA, XML_TOK_CONSOLIDATION_ATTR_LINK_TO_SOURCE },
1827 : XML_TOKEN_MAP_END
1828 : };
1829 :
1830 0 : pConsolidationAttrTokenMap = new SvXMLTokenMap( aConsolidationAttrTokenMap );
1831 : } // if( !pConsolidationAttrTokenMap )
1832 :
1833 0 : return *pConsolidationAttrTokenMap;
1834 : }
1835 :
1836 804 : const SvXMLTokenMap& ScXMLImport::GetCellTextParaElemTokenMap()
1837 : {
1838 804 : if (!pCellTextParaElemTokenMap)
1839 : {
1840 : static const SvXMLTokenMapEntry aMap[] =
1841 : {
1842 : { XML_NAMESPACE_TEXT, XML_S, XML_TOK_CELL_TEXT_S },
1843 : { XML_NAMESPACE_TEXT, XML_SPAN, XML_TOK_CELL_TEXT_SPAN },
1844 : { XML_NAMESPACE_TEXT, XML_SHEET_NAME, XML_TOK_CELL_TEXT_SHEET_NAME },
1845 : { XML_NAMESPACE_TEXT, XML_DATE, XML_TOK_CELL_TEXT_DATE },
1846 : { XML_NAMESPACE_TEXT, XML_TITLE, XML_TOK_CELL_TEXT_TITLE },
1847 : { XML_NAMESPACE_TEXT, XML_A, XML_TOK_CELL_TEXT_URL },
1848 : XML_TOKEN_MAP_END
1849 : };
1850 :
1851 78 : pCellTextParaElemTokenMap = new SvXMLTokenMap(aMap);
1852 : }
1853 804 : return *pCellTextParaElemTokenMap;
1854 : }
1855 :
1856 10 : const SvXMLTokenMap& ScXMLImport::GetCellTextSpanElemTokenMap()
1857 : {
1858 10 : if (!pCellTextSpanElemTokenMap)
1859 : {
1860 : static const SvXMLTokenMapEntry aMap[] =
1861 : {
1862 : { XML_NAMESPACE_TEXT, XML_SHEET_NAME, XML_TOK_CELL_TEXT_SPAN_ELEM_SHEET_NAME },
1863 : { XML_NAMESPACE_TEXT, XML_DATE, XML_TOK_CELL_TEXT_SPAN_ELEM_DATE },
1864 : { XML_NAMESPACE_TEXT, XML_TITLE, XML_TOK_CELL_TEXT_SPAN_ELEM_TITLE },
1865 : { XML_NAMESPACE_TEXT, XML_A, XML_TOK_CELL_TEXT_SPAN_ELEM_URL },
1866 : { XML_NAMESPACE_TEXT, XML_S, XML_TOK_CELL_TEXT_SPAN_ELEM_S },
1867 : XML_TOKEN_MAP_END
1868 : };
1869 :
1870 2 : pCellTextSpanElemTokenMap = new SvXMLTokenMap(aMap);
1871 : }
1872 10 : return *pCellTextSpanElemTokenMap;
1873 : }
1874 :
1875 780 : const SvXMLTokenMap& ScXMLImport::GetCellTextSpanAttrTokenMap()
1876 : {
1877 780 : if (!pCellTextSpanAttrTokenMap)
1878 : {
1879 : static const SvXMLTokenMapEntry aMap[] =
1880 : {
1881 : { XML_NAMESPACE_TEXT, XML_STYLE_NAME, XML_TOK_CELL_TEXT_SPAN_ATTR_STYLE_NAME },
1882 : XML_TOKEN_MAP_END
1883 : };
1884 :
1885 76 : pCellTextSpanAttrTokenMap = new SvXMLTokenMap(aMap);
1886 : }
1887 780 : return *pCellTextSpanAttrTokenMap;
1888 : }
1889 :
1890 8 : const SvXMLTokenMap& ScXMLImport::GetCellTextURLAttrTokenMap()
1891 : {
1892 8 : if (!pCellTextURLAttrTokenMap)
1893 : {
1894 : static const SvXMLTokenMapEntry aMap[] =
1895 : {
1896 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_CELL_TEXT_URL_ATTR_UREF },
1897 : { XML_NAMESPACE_XLINK, XML_TYPE, XML_TOK_CELL_TEXT_URL_ATTR_TYPE },
1898 : XML_TOKEN_MAP_END
1899 : };
1900 :
1901 4 : pCellTextURLAttrTokenMap = new SvXMLTokenMap(aMap);
1902 : }
1903 8 : return *pCellTextURLAttrTokenMap;
1904 : }
1905 :
1906 14 : const SvXMLTokenMap& ScXMLImport::GetCellTextSAttrTokenMap()
1907 : {
1908 14 : if (!pCellTextSAttrTokenMap)
1909 : {
1910 : static const SvXMLTokenMapEntry aMap[] =
1911 : {
1912 : { XML_NAMESPACE_TEXT, XML_C, XML_TOK_CELL_TEXT_S_ATTR_C },
1913 : XML_TOKEN_MAP_END
1914 : };
1915 :
1916 8 : pCellTextSAttrTokenMap = new SvXMLTokenMap(aMap);
1917 : }
1918 14 : return *pCellTextSAttrTokenMap;
1919 : }
1920 :
1921 0 : const SvXMLTokenMap& ScXMLImport::GetDataStreamAttrTokenMap()
1922 : {
1923 0 : if (!pDataStreamAttrTokenMap)
1924 : {
1925 : static const SvXMLTokenMapEntry aMap[] =
1926 : {
1927 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_DATA_STREAM_ATTR_URL },
1928 : { XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, XML_TOK_DATA_STREAM_ATTR_RANGE },
1929 : { XML_NAMESPACE_CALC_EXT, XML_EMPTY_LINE_REFRESH, XML_TOK_DATA_STREAM_ATTR_EMPTY_LINE_REFRESH },
1930 : { XML_NAMESPACE_CALC_EXT, XML_INSERTION_POSITION, XML_TOK_DATA_STREAM_ATTR_INSERTION_POSITION },
1931 : XML_TOKEN_MAP_END
1932 : };
1933 0 : pDataStreamAttrTokenMap = new SvXMLTokenMap(aMap);
1934 : }
1935 0 : return *pDataStreamAttrTokenMap;
1936 : }
1937 :
1938 988 : void ScXMLImport::SetPostProcessData( sc::ImportPostProcessData* p )
1939 : {
1940 988 : mpPostProcessData = p;
1941 988 : }
1942 :
1943 14 : sc::PivotTableSources& ScXMLImport::GetPivotTableSources()
1944 : {
1945 14 : if (!mpPivotSources)
1946 10 : mpPivotSources.reset(new sc::PivotTableSources);
1947 :
1948 14 : return *mpPivotSources;
1949 : }
1950 :
1951 1200 : SvXMLImportContext *ScXMLImport::CreateContext( sal_uInt16 nPrefix,
1952 : const OUString& rLocalName,
1953 : const uno::Reference<xml::sax::XAttributeList>& xAttrList )
1954 : {
1955 1200 : SvXMLImportContext *pContext = 0;
1956 :
1957 3082 : if( (XML_NAMESPACE_OFFICE == nPrefix) &&
1958 1910 : ( IsXMLToken(rLocalName, XML_DOCUMENT_STYLES) ||
1959 1380 : IsXMLToken(rLocalName, XML_DOCUMENT_CONTENT) ||
1960 558 : IsXMLToken(rLocalName, XML_DOCUMENT_SETTINGS) )) {
1961 1588 : pContext = new ScXMLDocContext_Impl( *this, nPrefix, rLocalName,
1962 1588 : xAttrList );
1963 700 : } else if ( (XML_NAMESPACE_OFFICE == nPrefix) &&
1964 294 : ( IsXMLToken(rLocalName, XML_DOCUMENT_META)) ) {
1965 236 : pContext = CreateMetaContext(rLocalName);
1966 228 : } else if ( (XML_NAMESPACE_OFFICE == nPrefix) &&
1967 58 : ( IsXMLToken(rLocalName, XML_DOCUMENT)) ) {
1968 : uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
1969 58 : GetModel(), uno::UNO_QUERY_THROW);
1970 : // flat OpenDocument file format
1971 174 : pContext = new ScXMLFlatDocContext_Impl( *this, nPrefix, rLocalName,
1972 232 : xAttrList, xDPS->getDocumentProperties());
1973 : }
1974 : else
1975 112 : pContext = SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList );
1976 :
1977 1200 : return pContext;
1978 : }
1979 :
1980 1098 : ScXMLImport::ScXMLImport(
1981 : const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext > xContext,
1982 : OUString const & implementationName, sal_uInt16 nImportFlag)
1983 : : SvXMLImport( xContext, implementationName, nImportFlag ),
1984 : pDoc( NULL ),
1985 : pChangeTrackingImportHelper(NULL),
1986 : pStylesImportHelper(NULL),
1987 : sNumberFormat(SC_UNONAME_NUMFMT),
1988 : sLocale(SC_LOCALE),
1989 : sCellStyle(SC_UNONAME_CELLSTYL),
1990 : sStandardFormat(SC_STANDARDFORMAT),
1991 : sType(SC_UNONAME_TYPE),
1992 : pDocElemTokenMap( 0 ),
1993 : pStylesElemTokenMap( 0 ),
1994 : pStylesAttrTokenMap( 0 ),
1995 : pStyleElemTokenMap( 0 ),
1996 : pBodyElemTokenMap( 0 ),
1997 : pContentValidationsElemTokenMap( 0 ),
1998 : pContentValidationElemTokenMap( 0 ),
1999 : pContentValidationAttrTokenMap( 0 ),
2000 : pContentValidationMessageElemTokenMap( 0 ),
2001 : pContentValidationHelpMessageAttrTokenMap( 0 ),
2002 : pContentValidationErrorMessageAttrTokenMap( 0 ),
2003 : pContentValidationErrorMacroAttrTokenMap( 0 ),
2004 : pCondFormatsTokenMap( 0 ),
2005 : pCondFormatTokenMap( 0 ),
2006 : pCondFormatAttrMap( 0 ),
2007 : pCondDateAttrMap( 0 ),
2008 : pConditionAttrMap( 0 ),
2009 : pColorScaleTokenMap( 0 ),
2010 : pColorScaleEntryAttrTokenMap( 0 ),
2011 : pDataBarTokenMap( 0 ),
2012 : pDataBarAttrMap( 0 ),
2013 : pFormattingEntryAttrMap( 0 ),
2014 : pIconSetAttrMap( 0 ),
2015 : pLabelRangesElemTokenMap( 0 ),
2016 : pLabelRangeAttrTokenMap( 0 ),
2017 : pTableElemTokenMap( 0 ),
2018 : pTableProtectionElemTokenMap(NULL),
2019 : pTableRowsElemTokenMap( 0 ),
2020 : pTableColsElemTokenMap( 0 ),
2021 : pTableScenarioAttrTokenMap( 0 ),
2022 : pTableAttrTokenMap( 0 ),
2023 : pTableColAttrTokenMap( 0 ),
2024 : pTableRowElemTokenMap( 0 ),
2025 : pTableRowAttrTokenMap( 0 ),
2026 : pTableRowCellElemTokenMap( 0 ),
2027 : pTableRowCellAttrTokenMap( 0 ),
2028 : pTableAnnotationAttrTokenMap( 0 ),
2029 : pDetectiveElemTokenMap( 0 ),
2030 : pDetectiveHighlightedAttrTokenMap( 0 ),
2031 : pDetectiveOperationAttrTokenMap( 0 ),
2032 : pTableCellRangeSourceAttrTokenMap( 0 ),
2033 : pNamedExpressionsElemTokenMap( 0 ),
2034 : pNamedRangeAttrTokenMap( 0 ),
2035 : pNamedExpressionAttrTokenMap( 0 ),
2036 : pDatabaseRangesElemTokenMap( 0 ),
2037 : pDatabaseRangeElemTokenMap( 0 ),
2038 : pDatabaseRangeAttrTokenMap( 0 ),
2039 : pDatabaseRangeSourceSQLAttrTokenMap( 0 ),
2040 : pDatabaseRangeSourceTableAttrTokenMap( 0 ),
2041 : pDatabaseRangeSourceQueryAttrTokenMap( 0 ),
2042 : pFilterElemTokenMap( 0 ),
2043 : pFilterAttrTokenMap( 0 ),
2044 : pFilterConditionElemTokenMap( 0 ),
2045 : pFilterConditionAttrTokenMap( 0 ),
2046 : pFilterSetItemAttrTokenMap( 0 ),
2047 : pSortElemTokenMap( 0 ),
2048 : pSortAttrTokenMap( 0 ),
2049 : pSortSortByAttrTokenMap( 0 ),
2050 : pDatabaseRangeSubTotalRulesElemTokenMap( 0 ),
2051 : pDatabaseRangeSubTotalRulesAttrTokenMap( 0 ),
2052 : pSubTotalRulesSortGroupsAttrTokenMap( 0 ),
2053 : pSubTotalRulesSubTotalRuleElemTokenMap( 0 ),
2054 : pSubTotalRulesSubTotalRuleAttrTokenMap( 0 ),
2055 : pSubTotalRuleSubTotalFieldAttrTokenMap( 0 ),
2056 : pDataPilotTablesElemTokenMap( 0 ),
2057 : pDataPilotTableAttrTokenMap( 0 ),
2058 : pDataPilotTableElemTokenMap( 0 ),
2059 : pDataPilotTableSourceServiceAttrTokenMap( 0 ),
2060 : pDataPilotGrandTotalAttrTokenMap(NULL),
2061 : pDataPilotTableSourceCellRangeElemTokenMap( 0 ),
2062 : pDataPilotTableSourceCellRangeAttrTokenMap( 0 ),
2063 : pDataPilotFieldAttrTokenMap( 0 ),
2064 : pDataPilotFieldElemTokenMap( 0 ),
2065 : pDataPilotLevelAttrTokenMap( 0 ),
2066 : pDataPilotLevelElemTokenMap( 0 ),
2067 : pDataPilotSubTotalsElemTokenMap( 0 ),
2068 : pDataPilotSubTotalAttrTokenMap( 0 ),
2069 : pDataPilotMembersElemTokenMap( 0 ),
2070 : pDataPilotMemberAttrTokenMap( 0 ),
2071 : pConsolidationAttrTokenMap( 0 ),
2072 : pCellTextParaElemTokenMap(NULL),
2073 : pCellTextSpanElemTokenMap(NULL),
2074 : pCellTextSpanAttrTokenMap(NULL),
2075 : pCellTextURLAttrTokenMap(NULL),
2076 : pCellTextSAttrTokenMap(NULL),
2077 : pDataStreamAttrTokenMap(NULL),
2078 : mpPostProcessData(NULL),
2079 : aTables(*this),
2080 : pMyNamedExpressions(NULL),
2081 : pMyLabelRanges(NULL),
2082 : pValidations(NULL),
2083 : pDetectiveOpArray(NULL),
2084 : pSolarMutexGuard(NULL),
2085 : pNumberFormatAttributesExportHelper(NULL),
2086 : pStyleNumberFormats(NULL),
2087 : sPrevStyleName(),
2088 : sPrevCurrency(),
2089 : nSolarMutexLocked(0),
2090 : nProgressCount(0),
2091 : nStyleFamilyMask( 0 ),
2092 : nPrevCellType(0),
2093 : bLoadDoc( true ),
2094 : bRemoveLastChar(false),
2095 : bNullDateSetted(false),
2096 : bSelfImportingXMLSet(false),
2097 : mbLockSolarMutex(true),
2098 : mbImportStyles(true),
2099 1098 : mbHasNewCondFormatData(false)
2100 : {
2101 1098 : pStylesImportHelper = new ScMyStylesImportHelper(*this);
2102 :
2103 1098 : xScPropHdlFactory = new XMLScPropHdlFactory;
2104 1098 : xCellStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScCellStylesProperties, xScPropHdlFactory, false);
2105 1098 : xColumnStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScColumnStylesProperties, xScPropHdlFactory, false);
2106 1098 : xRowStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScRowStylesImportProperties, xScPropHdlFactory, false);
2107 1098 : xTableStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScTableStylesImportProperties, xScPropHdlFactory, false);
2108 :
2109 : // #i66550# needed for 'presentation:event-listener' element for URLs in shapes
2110 1098 : GetNamespaceMap().Add(
2111 1098 : GetXMLToken( XML_NP_PRESENTATION ),
2112 1098 : GetXMLToken( XML_N_PRESENTATION ),
2113 1098 : XML_NAMESPACE_PRESENTATION );
2114 :
2115 : // initialize cell type map.
2116 : const struct { XMLTokenEnum _token; sal_Int16 _type; } aCellTypePairs[] =
2117 : {
2118 : { XML_FLOAT, util::NumberFormat::NUMBER },
2119 : { XML_STRING, util::NumberFormat::TEXT },
2120 : { XML_TIME, util::NumberFormat::TIME },
2121 : { XML_DATE, util::NumberFormat::DATETIME },
2122 : { XML_PERCENTAGE, util::NumberFormat::PERCENT },
2123 : { XML_CURRENCY, util::NumberFormat::CURRENCY },
2124 : { XML_BOOLEAN, util::NumberFormat::LOGICAL }
2125 1098 : };
2126 1098 : size_t n = sizeof(aCellTypePairs)/sizeof(aCellTypePairs[0]);
2127 8784 : for (size_t i = 0; i < n; ++i)
2128 : {
2129 : aCellTypeMap.insert(
2130 : CellTypeMap::value_type(
2131 7686 : GetXMLToken(aCellTypePairs[i]._token), aCellTypePairs[i]._type));
2132 : }
2133 1098 : }
2134 :
2135 3294 : ScXMLImport::~ScXMLImport() throw()
2136 : {
2137 : // delete pI18NMap;
2138 1098 : delete pDocElemTokenMap;
2139 1098 : delete pStylesElemTokenMap;
2140 1098 : delete pStylesAttrTokenMap;
2141 1098 : delete pStyleElemTokenMap;
2142 1098 : delete pBodyElemTokenMap;
2143 1098 : delete pContentValidationsElemTokenMap;
2144 1098 : delete pContentValidationElemTokenMap;
2145 1098 : delete pContentValidationAttrTokenMap;
2146 1098 : delete pContentValidationMessageElemTokenMap;
2147 1098 : delete pContentValidationHelpMessageAttrTokenMap;
2148 1098 : delete pContentValidationErrorMessageAttrTokenMap;
2149 1098 : delete pContentValidationErrorMacroAttrTokenMap;
2150 1098 : delete pCondFormatsTokenMap;
2151 1098 : delete pCondFormatTokenMap;
2152 1098 : delete pCondFormatAttrMap;
2153 1098 : delete pCondDateAttrMap;
2154 1098 : delete pConditionAttrMap;
2155 1098 : delete pColorScaleTokenMap;
2156 1098 : delete pColorScaleEntryAttrTokenMap;
2157 1098 : delete pDataBarTokenMap;
2158 1098 : delete pDataBarAttrMap;
2159 1098 : delete pFormattingEntryAttrMap;
2160 1098 : delete pLabelRangesElemTokenMap;
2161 1098 : delete pLabelRangeAttrTokenMap;
2162 1098 : delete pTableElemTokenMap;
2163 1098 : delete pTableProtectionElemTokenMap;
2164 1098 : delete pTableRowsElemTokenMap;
2165 1098 : delete pTableColsElemTokenMap;
2166 1098 : delete pTableAttrTokenMap;
2167 1098 : delete pTableScenarioAttrTokenMap;
2168 1098 : delete pTableColAttrTokenMap;
2169 1098 : delete pTableRowElemTokenMap;
2170 1098 : delete pTableRowAttrTokenMap;
2171 1098 : delete pTableRowCellElemTokenMap;
2172 1098 : delete pTableRowCellAttrTokenMap;
2173 1098 : delete pTableAnnotationAttrTokenMap;
2174 1098 : delete pDetectiveElemTokenMap;
2175 1098 : delete pDetectiveHighlightedAttrTokenMap;
2176 1098 : delete pDetectiveOperationAttrTokenMap;
2177 1098 : delete pTableCellRangeSourceAttrTokenMap;
2178 1098 : delete pNamedExpressionsElemTokenMap;
2179 1098 : delete pNamedRangeAttrTokenMap;
2180 1098 : delete pNamedExpressionAttrTokenMap;
2181 1098 : delete pDatabaseRangesElemTokenMap;
2182 1098 : delete pDatabaseRangeElemTokenMap;
2183 1098 : delete pDatabaseRangeAttrTokenMap;
2184 1098 : delete pDatabaseRangeSourceSQLAttrTokenMap;
2185 1098 : delete pDatabaseRangeSourceTableAttrTokenMap;
2186 1098 : delete pDatabaseRangeSourceQueryAttrTokenMap;
2187 1098 : delete pFilterElemTokenMap;
2188 1098 : delete pFilterAttrTokenMap;
2189 1098 : delete pFilterConditionElemTokenMap;
2190 1098 : delete pFilterConditionAttrTokenMap;
2191 1098 : delete pFilterSetItemAttrTokenMap;
2192 1098 : delete pSortElemTokenMap;
2193 1098 : delete pSortAttrTokenMap;
2194 1098 : delete pSortSortByAttrTokenMap;
2195 1098 : delete pDatabaseRangeSubTotalRulesElemTokenMap;
2196 1098 : delete pDatabaseRangeSubTotalRulesAttrTokenMap;
2197 1098 : delete pSubTotalRulesSortGroupsAttrTokenMap;
2198 1098 : delete pSubTotalRulesSubTotalRuleElemTokenMap;
2199 1098 : delete pSubTotalRulesSubTotalRuleAttrTokenMap;
2200 1098 : delete pSubTotalRuleSubTotalFieldAttrTokenMap;
2201 1098 : delete pDataPilotTablesElemTokenMap;
2202 1098 : delete pDataPilotTableAttrTokenMap;
2203 1098 : delete pDataPilotTableElemTokenMap;
2204 1098 : delete pDataPilotTableSourceServiceAttrTokenMap;
2205 1098 : delete pDataPilotTableSourceCellRangeAttrTokenMap;
2206 1098 : delete pDataPilotTableSourceCellRangeElemTokenMap;
2207 1098 : delete pDataPilotFieldAttrTokenMap;
2208 1098 : delete pDataPilotFieldElemTokenMap;
2209 1098 : delete pDataPilotLevelAttrTokenMap;
2210 1098 : delete pDataPilotLevelElemTokenMap;
2211 1098 : delete pDataPilotSubTotalsElemTokenMap;
2212 1098 : delete pDataPilotSubTotalAttrTokenMap;
2213 1098 : delete pDataPilotMembersElemTokenMap;
2214 1098 : delete pDataPilotMemberAttrTokenMap;
2215 1098 : delete pConsolidationAttrTokenMap;
2216 1098 : delete pCellTextParaElemTokenMap;
2217 1098 : delete pCellTextSpanElemTokenMap;
2218 1098 : delete pCellTextSpanAttrTokenMap;
2219 1098 : delete pCellTextURLAttrTokenMap;
2220 1098 : delete pCellTextSAttrTokenMap;
2221 1098 : delete pDataStreamAttrTokenMap;
2222 :
2223 1098 : delete pChangeTrackingImportHelper;
2224 1098 : delete pNumberFormatAttributesExportHelper;
2225 1098 : delete pStyleNumberFormats;
2226 1098 : delete pStylesImportHelper;
2227 :
2228 1098 : delete pSolarMutexGuard;
2229 :
2230 1098 : delete pMyNamedExpressions;
2231 1098 : delete pMyLabelRanges;
2232 1098 : delete pValidations;
2233 1098 : delete pDetectiveOpArray;
2234 2196 : }
2235 :
2236 1042 : void ScXMLImport::initialize( const css::uno::Sequence<css::uno::Any>& aArguments )
2237 : throw (css::uno::Exception, css::uno::RuntimeException, std::exception)
2238 : {
2239 1042 : SvXMLImport::initialize(aArguments);
2240 :
2241 1042 : uno::Reference<beans::XPropertySet> xInfoSet = getImportInfo();
2242 1042 : if (!xInfoSet.is())
2243 12 : return;
2244 :
2245 2060 : uno::Reference<beans::XPropertySetInfo> xInfoSetInfo = xInfoSet->getPropertySetInfo();
2246 1030 : if (!xInfoSetInfo.is())
2247 0 : return;
2248 :
2249 1030 : if (xInfoSetInfo->hasPropertyByName(SC_UNO_ODS_LOCK_SOLAR_MUTEX))
2250 1028 : xInfoSet->getPropertyValue(SC_UNO_ODS_LOCK_SOLAR_MUTEX) >>= mbLockSolarMutex;
2251 :
2252 1030 : if (xInfoSetInfo->hasPropertyByName(SC_UNO_ODS_IMPORT_STYLES))
2253 2058 : xInfoSet->getPropertyValue(SC_UNO_ODS_IMPORT_STYLES) >>= mbImportStyles;
2254 : }
2255 :
2256 586 : SvXMLImportContext *ScXMLImport::CreateFontDeclsContext(const sal_uInt16 nPrefix, const OUString& rLocalName,
2257 : const uno::Reference<xml::sax::XAttributeList>& xAttrList)
2258 : {
2259 : XMLFontStylesContext *pFSContext = new XMLFontStylesContext(
2260 586 : *this, nPrefix, rLocalName, xAttrList, osl_getThreadTextEncoding());
2261 586 : SetFontDecls(pFSContext);
2262 586 : SvXMLImportContext* pContext = pFSContext;
2263 586 : return pContext;
2264 : }
2265 :
2266 910 : SvXMLImportContext *ScXMLImport::CreateStylesContext(const OUString& rLocalName,
2267 : const uno::Reference<xml::sax::XAttributeList>& xAttrList, bool bIsAutoStyle )
2268 : {
2269 : SvXMLImportContext* pContext = new XMLTableStylesContext(
2270 910 : *this, XML_NAMESPACE_OFFICE, rLocalName, xAttrList, bIsAutoStyle);
2271 :
2272 910 : if (bIsAutoStyle)
2273 586 : SetAutoStyles(static_cast<SvXMLStylesContext*>(pContext));
2274 : else
2275 324 : SetStyles(static_cast<SvXMLStylesContext*>(pContext));
2276 :
2277 910 : return pContext;
2278 : }
2279 :
2280 322 : SvXMLImportContext *ScXMLImport::CreateBodyContext(const OUString& rLocalName,
2281 : const uno::Reference<xml::sax::XAttributeList>& xAttrList)
2282 : {
2283 322 : return new ScXMLBodyContext(*this, XML_NAMESPACE_OFFICE, rLocalName, xAttrList);
2284 : }
2285 :
2286 236 : SvXMLImportContext *ScXMLImport::CreateMetaContext(
2287 : const OUString& rLocalName )
2288 : {
2289 236 : SvXMLImportContext* pContext = NULL;
2290 :
2291 236 : if (getImportFlags() & IMPORT_META)
2292 : {
2293 : uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
2294 236 : GetModel(), uno::UNO_QUERY_THROW);
2295 : uno::Reference<document::XDocumentProperties> const xDocProps(
2296 472 : (IsStylesOnlyMode()) ? 0 : xDPS->getDocumentProperties());
2297 472 : pContext = new SvXMLMetaDocumentContext(*this,
2298 : XML_NAMESPACE_OFFICE, rLocalName,
2299 708 : xDocProps);
2300 : }
2301 :
2302 236 : if( !pContext )
2303 : pContext = new SvXMLImportContext( *this,
2304 0 : XML_NAMESPACE_OFFICE, rLocalName );
2305 :
2306 236 : return pContext;
2307 : }
2308 :
2309 266 : SvXMLImportContext *ScXMLImport::CreateScriptContext(
2310 : const OUString& rLocalName )
2311 : {
2312 266 : SvXMLImportContext* pContext = NULL;
2313 :
2314 266 : if( !(IsStylesOnlyMode()) )
2315 : {
2316 : pContext = new XMLScriptContext( *this,
2317 : XML_NAMESPACE_OFFICE, rLocalName,
2318 266 : GetModel() );
2319 : }
2320 :
2321 266 : if( !pContext )
2322 : pContext = new SvXMLImportContext( *this, XML_NAMESPACE_OFFICE,
2323 0 : rLocalName );
2324 :
2325 266 : return pContext;
2326 : }
2327 :
2328 294 : void ScXMLImport::SetStatistics(
2329 : const uno::Sequence<beans::NamedValue> & i_rStats)
2330 : {
2331 : static const char* s_stats[] =
2332 : { "TableCount", "CellCount", "ObjectCount", 0 };
2333 :
2334 294 : SvXMLImport::SetStatistics(i_rStats);
2335 :
2336 294 : sal_uInt32 nCount(0);
2337 1008 : for (sal_Int32 i = 0; i < i_rStats.getLength(); ++i) {
2338 2856 : for (const char** pStat = s_stats; *pStat != 0; ++pStat) {
2339 2142 : if (i_rStats[i].Name.equalsAscii(*pStat)) {
2340 714 : sal_Int32 val = 0;
2341 714 : if (i_rStats[i].Value >>= val) {
2342 714 : nCount += val;
2343 : } else {
2344 : OSL_FAIL("ScXMLImport::SetStatistics: invalid entry");
2345 : }
2346 : }
2347 : }
2348 : }
2349 :
2350 294 : if (nCount)
2351 : {
2352 238 : GetProgressBarHelper()->SetReference(nCount);
2353 238 : GetProgressBarHelper()->SetValue(0);
2354 : }
2355 294 : }
2356 :
2357 13552 : ScDocumentImport& ScXMLImport::GetDoc()
2358 : {
2359 13552 : return *mpDocImport;
2360 : }
2361 :
2362 17156 : sal_Int16 ScXMLImport::GetCellType(const OUString& rStrValue) const
2363 : {
2364 17156 : CellTypeMap::const_iterator itr = aCellTypeMap.find(rStrValue);
2365 17156 : if (itr != aCellTypeMap.end())
2366 17156 : return itr->second;
2367 :
2368 0 : return util::NumberFormat::UNDEFINED;
2369 : }
2370 :
2371 586 : XMLShapeImportHelper* ScXMLImport::CreateShapeImport()
2372 : {
2373 586 : return new XMLTableShapeImportHelper(*this);
2374 : }
2375 :
2376 28 : bool ScXMLImport::GetValidation(const OUString& sName, ScMyImportValidation& aValidation)
2377 : {
2378 28 : if (pValidations)
2379 : {
2380 28 : bool bFound(false);
2381 28 : ScMyImportValidations::iterator aItr(pValidations->begin());
2382 28 : ScMyImportValidations::iterator aEndItr(pValidations->end());
2383 104 : while(aItr != aEndItr && !bFound)
2384 : {
2385 48 : if (aItr->sName == sName)
2386 : {
2387 : // source position must be set as string,
2388 : // so sBaseCellAddress no longer has to be converted here
2389 :
2390 28 : bFound = true;
2391 : }
2392 : else
2393 20 : ++aItr;
2394 : }
2395 28 : if (bFound)
2396 28 : aValidation = *aItr;
2397 28 : return bFound;
2398 : }
2399 0 : return false;
2400 : }
2401 :
2402 12 : void ScXMLImport::AddNamedExpression(SCTAB nTab, ScMyNamedExpression* pNamedExp)
2403 : {
2404 12 : ::std::unique_ptr<ScMyNamedExpression> p(pNamedExp);
2405 12 : SheetNamedExpMap::iterator itr = maSheetNamedExpressions.find(nTab);
2406 12 : if (itr == maSheetNamedExpressions.end())
2407 : {
2408 : // No chain exists for this sheet. Create one.
2409 8 : ::std::unique_ptr<ScMyNamedExpressions> pNew(new ScMyNamedExpressions);
2410 8 : ::std::pair<SheetNamedExpMap::iterator, bool> r = o3tl::ptr_container::insert(maSheetNamedExpressions, nTab, std::move(pNew));
2411 8 : if (!r.second)
2412 : // insertion failed.
2413 12 : return;
2414 :
2415 8 : itr = r.first;
2416 : }
2417 12 : ScMyNamedExpressions& r = *itr->second;
2418 12 : o3tl::ptr_container::push_back(r, std::move(p));
2419 : }
2420 :
2421 0 : ScXMLChangeTrackingImportHelper* ScXMLImport::GetChangeTrackingImportHelper()
2422 : {
2423 0 : if (!pChangeTrackingImportHelper)
2424 0 : pChangeTrackingImportHelper = new ScXMLChangeTrackingImportHelper();
2425 0 : return pChangeTrackingImportHelper;
2426 : }
2427 :
2428 324 : void ScXMLImport::InsertStyles()
2429 : {
2430 324 : GetStyles()->CopyStylesToDoc(true);
2431 :
2432 : // if content is going to be loaded with the same import, set bLatinDefaultStyle flag now
2433 324 : if ( getImportFlags() & IMPORT_CONTENT )
2434 58 : ExamineDefaultStyle();
2435 324 : }
2436 :
2437 322 : void ScXMLImport::ExamineDefaultStyle()
2438 : {
2439 322 : if (pDoc)
2440 : {
2441 : // #i62435# after inserting the styles, check if the default style has a latin-script-only
2442 : // number format (then, value cells can be pre-initialized with western script type)
2443 :
2444 322 : const ScPatternAttr* pDefPattern = pDoc->GetDefPattern();
2445 322 : if (pDefPattern && sc::NumFmtUtil::isLatinScript(*pDefPattern, *pDoc))
2446 322 : mpDocImport->setDefaultNumericScript(SCRIPTTYPE_LATIN);
2447 : }
2448 322 : }
2449 :
2450 0 : void ScXMLImport::SetChangeTrackingViewSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue>& rChangeProps)
2451 : {
2452 0 : if (pDoc)
2453 : {
2454 0 : sal_Int32 nCount(rChangeProps.getLength());
2455 0 : if (nCount)
2456 : {
2457 0 : ScXMLImport::MutexGuard aGuard(*this);
2458 0 : sal_Int16 nTemp16(0);
2459 0 : boost::scoped_ptr<ScChangeViewSettings> pViewSettings(new ScChangeViewSettings());
2460 0 : for (sal_Int32 i = 0; i < nCount; ++i)
2461 : {
2462 0 : OUString sName(rChangeProps[i].Name);
2463 0 : if (sName.equalsAscii("ShowChanges"))
2464 0 : pViewSettings->SetShowChanges(::cppu::any2bool(rChangeProps[i].Value));
2465 0 : else if (sName.equalsAscii("ShowAcceptedChanges"))
2466 0 : pViewSettings->SetShowAccepted(::cppu::any2bool(rChangeProps[i].Value));
2467 0 : else if (sName.equalsAscii("ShowRejectedChanges"))
2468 0 : pViewSettings->SetShowRejected(::cppu::any2bool(rChangeProps[i].Value));
2469 0 : else if (sName.equalsAscii("ShowChangesByDatetime"))
2470 0 : pViewSettings->SetHasDate(::cppu::any2bool(rChangeProps[i].Value));
2471 0 : else if (sName.equalsAscii("ShowChangesByDatetimeMode"))
2472 : {
2473 0 : if (rChangeProps[i].Value >>= nTemp16)
2474 0 : pViewSettings->SetTheDateMode(ScChgsDateMode(nTemp16));
2475 : }
2476 0 : else if (sName.equalsAscii("ShowChangesByDatetimeFirstDatetime"))
2477 : {
2478 0 : util::DateTime aDateTime;
2479 0 : if (rChangeProps[i].Value >>= aDateTime)
2480 : {
2481 0 : DateTime aCoreDateTime( DateTime::EMPTY );
2482 0 : ScXMLConverter::ConvertAPIToCoreDateTime(aDateTime, aCoreDateTime);
2483 0 : pViewSettings->SetTheFirstDateTime(aCoreDateTime);
2484 : }
2485 : }
2486 0 : else if (sName.equalsAscii("ShowChangesByDatetimeSecondDatetime"))
2487 : {
2488 0 : util::DateTime aDateTime;
2489 0 : if (rChangeProps[i].Value >>= aDateTime)
2490 : {
2491 0 : DateTime aCoreDateTime( DateTime::EMPTY );
2492 0 : ScXMLConverter::ConvertAPIToCoreDateTime(aDateTime, aCoreDateTime);
2493 0 : pViewSettings->SetTheLastDateTime(aCoreDateTime);
2494 : }
2495 : }
2496 0 : else if (sName.equalsAscii("ShowChangesByAuthor"))
2497 0 : pViewSettings->SetHasAuthor(::cppu::any2bool(rChangeProps[i].Value));
2498 0 : else if (sName.equalsAscii("ShowChangesByAuthorName"))
2499 : {
2500 0 : OUString sOUName;
2501 0 : if (rChangeProps[i].Value >>= sOUName)
2502 : {
2503 0 : OUString sAuthorName(sOUName);
2504 0 : pViewSettings->SetTheAuthorToShow(sAuthorName);
2505 0 : }
2506 : }
2507 0 : else if (sName.equalsAscii("ShowChangesByComment"))
2508 0 : pViewSettings->SetHasComment(::cppu::any2bool(rChangeProps[i].Value));
2509 0 : else if (sName.equalsAscii("ShowChangesByCommentText"))
2510 : {
2511 0 : OUString sOUComment;
2512 0 : if (rChangeProps[i].Value >>= sOUComment)
2513 : {
2514 0 : OUString sComment(sOUComment);
2515 0 : pViewSettings->SetTheComment(sComment);
2516 0 : }
2517 : }
2518 0 : else if (sName.equalsAscii("ShowChangesByRanges"))
2519 0 : pViewSettings->SetHasRange(::cppu::any2bool(rChangeProps[i].Value));
2520 0 : else if (sName.equalsAscii("ShowChangesByRangesList"))
2521 : {
2522 0 : OUString sRanges;
2523 0 : if ((rChangeProps[i].Value >>= sRanges) && !sRanges.isEmpty())
2524 : {
2525 0 : ScRangeList aRangeList;
2526 : ScRangeStringConverter::GetRangeListFromString(
2527 0 : aRangeList, sRanges, GetDocument(), FormulaGrammar::CONV_OOO);
2528 0 : pViewSettings->SetTheRangeList(aRangeList);
2529 0 : }
2530 : }
2531 0 : }
2532 0 : pDoc->SetChangeViewSettings(*pViewSettings);
2533 : }
2534 : }
2535 0 : }
2536 :
2537 266 : void ScXMLImport::SetViewSettings(const uno::Sequence<beans::PropertyValue>& aViewProps)
2538 : {
2539 266 : sal_Int32 nCount(aViewProps.getLength());
2540 266 : sal_Int32 nHeight(0);
2541 266 : sal_Int32 nLeft(0);
2542 266 : sal_Int32 nTop(0);
2543 266 : sal_Int32 nWidth(0);
2544 1592 : for (sal_Int32 i = 0; i < nCount; ++i)
2545 : {
2546 1326 : OUString sName(aViewProps[i].Name);
2547 1326 : if (sName.equalsAscii("VisibleAreaHeight"))
2548 266 : aViewProps[i].Value >>= nHeight;
2549 1060 : else if (sName.equalsAscii("VisibleAreaLeft"))
2550 266 : aViewProps[i].Value >>= nLeft;
2551 794 : else if (sName.equalsAscii("VisibleAreaTop"))
2552 266 : aViewProps[i].Value >>= nTop;
2553 528 : else if (sName.equalsAscii("VisibleAreaWidth"))
2554 266 : aViewProps[i].Value >>= nWidth;
2555 262 : else if (sName.equalsAscii("TrackedChangesViewSettings"))
2556 : {
2557 0 : uno::Sequence<beans::PropertyValue> aChangeProps;
2558 0 : if(aViewProps[i].Value >>= aChangeProps)
2559 0 : SetChangeTrackingViewSettings(aChangeProps);
2560 : }
2561 1326 : }
2562 266 : if (nHeight && nWidth)
2563 : {
2564 266 : if (GetModel().is())
2565 : {
2566 266 : ScModelObj* pDocObj(ScModelObj::getImplementation( GetModel() ));
2567 266 : if (pDocObj)
2568 : {
2569 266 : SfxObjectShell* pEmbeddedObj = pDocObj->GetEmbeddedObject();
2570 266 : if (pEmbeddedObj)
2571 : {
2572 266 : Rectangle aRect;
2573 266 : aRect.setX( nLeft );
2574 266 : aRect.setY( nTop );
2575 266 : aRect.setWidth( nWidth );
2576 266 : aRect.setHeight( nHeight );
2577 266 : pEmbeddedObj->SetVisArea(aRect);
2578 : }
2579 : }
2580 : }
2581 : }
2582 266 : }
2583 :
2584 266 : void ScXMLImport::SetConfigurationSettings(const uno::Sequence<beans::PropertyValue>& aConfigProps)
2585 : {
2586 266 : if (GetModel().is())
2587 : {
2588 266 : uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
2589 266 : if (xMultiServiceFactory.is())
2590 : {
2591 266 : sal_Int32 nCount(aConfigProps.getLength());
2592 266 : OUString sCTName("TrackedChangesProtectionKey");
2593 532 : OUString sVBName("VBACompatibilityMode");
2594 532 : OUString sSCName("ScriptConfiguration");
2595 7576 : for (sal_Int32 i = nCount - 1; i >= 0; --i)
2596 : {
2597 7310 : if (aConfigProps[i].Name == sCTName)
2598 : {
2599 0 : OUString sKey;
2600 0 : if (aConfigProps[i].Value >>= sKey)
2601 : {
2602 0 : uno::Sequence<sal_Int8> aPass;
2603 0 : ::sax::Converter::decodeBase64(aPass, sKey);
2604 0 : if (aPass.getLength())
2605 : {
2606 0 : if (pDoc->GetChangeTrack())
2607 0 : pDoc->GetChangeTrack()->SetProtection(aPass);
2608 : else
2609 : {
2610 0 : std::set<OUString> aUsers;
2611 0 : ScChangeTrack* pTrack = new ScChangeTrack(pDoc, aUsers);
2612 0 : pTrack->SetProtection(aPass);
2613 0 : pDoc->SetChangeTrack(pTrack);
2614 : }
2615 0 : }
2616 0 : }
2617 : }
2618 : // store the following items for later use (after document is loaded)
2619 7310 : else if ((aConfigProps[i].Name == sVBName) || (aConfigProps[i].Name == sSCName))
2620 : {
2621 0 : uno::Reference< beans::XPropertySet > xImportInfo = getImportInfo();
2622 0 : if (xImportInfo.is())
2623 : {
2624 0 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = xImportInfo->getPropertySetInfo();
2625 0 : if (xPropertySetInfo.is() && xPropertySetInfo->hasPropertyByName(aConfigProps[i].Name))
2626 0 : xImportInfo->setPropertyValue( aConfigProps[i].Name, aConfigProps[i].Value );
2627 0 : }
2628 : }
2629 : }
2630 532 : uno::Reference <uno::XInterface> xInterface = xMultiServiceFactory->createInstance("com.sun.star.comp.SpreadsheetSettings");
2631 532 : uno::Reference <beans::XPropertySet> xProperties(xInterface, uno::UNO_QUERY);
2632 266 : if (xProperties.is())
2633 532 : SvXMLUnitConverter::convertPropertySet(xProperties, aConfigProps);
2634 266 : }
2635 : }
2636 266 : }
2637 :
2638 0 : sal_Int32 ScXMLImport::SetCurrencySymbol(const sal_Int32 nKey, const OUString& rCurrency)
2639 : {
2640 0 : uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
2641 0 : if (xNumberFormatsSupplier.is())
2642 : {
2643 0 : uno::Reference <util::XNumberFormats> xLocalNumberFormats(xNumberFormatsSupplier->getNumberFormats());
2644 0 : if (xLocalNumberFormats.is())
2645 : {
2646 0 : OUString sFormatString;
2647 : try
2648 : {
2649 0 : uno::Reference <beans::XPropertySet> xProperties(xLocalNumberFormats->getByKey(nKey));
2650 0 : if (xProperties.is())
2651 : {
2652 0 : lang::Locale aLocale;
2653 0 : if (GetDocument() && (xProperties->getPropertyValue(sLocale) >>= aLocale))
2654 : {
2655 : {
2656 0 : ScXMLImport::MutexGuard aGuard(*this);
2657 0 : LocaleDataWrapper aLocaleData( comphelper::getProcessComponentContext(), LanguageTag( aLocale) );
2658 0 : OUStringBuffer aBuffer(15);
2659 0 : aBuffer.appendAscii("#");
2660 0 : aBuffer.append( aLocaleData.getNumThousandSep() );
2661 0 : aBuffer.appendAscii("##0");
2662 0 : aBuffer.append( aLocaleData.getNumDecimalSep() );
2663 0 : aBuffer.appendAscii("00 [$");
2664 0 : aBuffer.append(rCurrency);
2665 0 : aBuffer.appendAscii("]");
2666 0 : sFormatString = aBuffer.makeStringAndClear();
2667 : }
2668 0 : sal_Int32 nNewKey = xLocalNumberFormats->queryKey(sFormatString, aLocale, true);
2669 0 : if (nNewKey == -1)
2670 0 : nNewKey = xLocalNumberFormats->addNew(sFormatString, aLocale);
2671 0 : return nNewKey;
2672 0 : }
2673 0 : }
2674 : }
2675 0 : catch ( const util::MalformedNumberFormatException& rException )
2676 : {
2677 0 : OUString sErrorMessage("Fehler im Formatstring ");
2678 0 : sErrorMessage += sFormatString;
2679 0 : sErrorMessage += " an Position ";
2680 0 : sErrorMessage += OUString::number(rException.CheckPos);
2681 0 : uno::Sequence<OUString> aSeq(1);
2682 0 : aSeq[0] = sErrorMessage;
2683 0 : uno::Reference<xml::sax::XLocator> xLocator;
2684 0 : SetError(XMLERROR_API | XMLERROR_FLAG_ERROR, aSeq, rException.Message, xLocator);
2685 0 : }
2686 0 : }
2687 : }
2688 0 : return nKey;
2689 : }
2690 :
2691 0 : bool ScXMLImport::IsCurrencySymbol(const sal_Int32 nNumberFormat, const OUString& sCurrentCurrency, const OUString& sBankSymbol)
2692 : {
2693 0 : uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
2694 0 : if (xNumberFormatsSupplier.is())
2695 : {
2696 0 : uno::Reference <util::XNumberFormats> xLocalNumberFormats(xNumberFormatsSupplier->getNumberFormats());
2697 0 : if (xLocalNumberFormats.is())
2698 : {
2699 : try
2700 : {
2701 0 : uno::Reference <beans::XPropertySet> xNumberPropertySet(xLocalNumberFormats->getByKey(nNumberFormat));
2702 0 : if (xNumberPropertySet.is())
2703 : {
2704 0 : OUString sTemp;
2705 0 : if ( xNumberPropertySet->getPropertyValue(OUString(SC_CURRENCYSYMBOL)) >>= sTemp)
2706 : {
2707 0 : if (sCurrentCurrency.equals(sTemp))
2708 0 : return true;
2709 : // #i61657# This may be a legacy currency symbol that changed in the meantime.
2710 0 : if (SvNumberFormatter::GetLegacyOnlyCurrencyEntry( sCurrentCurrency, sBankSymbol) != NULL)
2711 0 : return true;
2712 : // In the rare case that sCurrentCurrency is not the
2713 : // currency symbol, but a matching ISO code
2714 : // abbreviation instead that was obtained through
2715 : // XMLNumberFormatAttributesExportHelper::GetCellType(),
2716 : // check with the number format's symbol. This happens,
2717 : // for example, in the es_BO locale, where a legacy
2718 : // B$,BOB matched B$->BOP, which leads to
2719 : // sCurrentCurrency being BOP, and the previous call
2720 : // with BOP,BOB didn't find an entry, but B$,BOB will.
2721 0 : return SvNumberFormatter::GetLegacyOnlyCurrencyEntry( sTemp, sBankSymbol) != NULL;
2722 0 : }
2723 0 : }
2724 : }
2725 0 : catch ( uno::Exception& )
2726 : {
2727 : OSL_FAIL("Numberformat not found");
2728 : }
2729 0 : }
2730 : }
2731 0 : return false;
2732 : }
2733 :
2734 2458 : void ScXMLImport::SetType(uno::Reference <beans::XPropertySet>& rProperties,
2735 : sal_Int32& rNumberFormat,
2736 : const sal_Int16 nCellType,
2737 : const OUString& rCurrency)
2738 : {
2739 2458 : if (!mbImportStyles)
2740 2458 : return;
2741 :
2742 2458 : if ((nCellType != util::NumberFormat::TEXT) && (nCellType != util::NumberFormat::UNDEFINED))
2743 : {
2744 1042 : if (rNumberFormat == -1)
2745 412 : rProperties->getPropertyValue( sNumberFormat ) >>= rNumberFormat;
2746 : OSL_ENSURE(rNumberFormat != -1, "no NumberFormat");
2747 : bool bIsStandard;
2748 : // sCurrentCurrency may be the ISO code abbreviation if the currency
2749 : // symbol matches such, or if no match found the symbol itself!
2750 1042 : OUString sCurrentCurrency;
2751 : sal_Int32 nCurrentCellType(
2752 : GetNumberFormatAttributesExportHelper()->GetCellType(
2753 1042 : rNumberFormat, sCurrentCurrency, bIsStandard) & ~util::NumberFormat::DEFINED);
2754 1042 : if ((nCellType != nCurrentCellType) && !((nCellType == util::NumberFormat::NUMBER &&
2755 10 : ((nCurrentCellType == util::NumberFormat::SCIENTIFIC) ||
2756 2 : (nCurrentCellType == util::NumberFormat::FRACTION) ||
2757 2 : (nCurrentCellType == util::NumberFormat::LOGICAL) ||
2758 102 : (nCurrentCellType == 0))) || (nCurrentCellType == util::NumberFormat::TEXT)) && !((nCellType == util::NumberFormat::DATETIME) &&
2759 92 : (nCurrentCellType == util::NumberFormat::DATE)))
2760 : {
2761 8 : if (!xNumberFormats.is())
2762 : {
2763 2 : uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
2764 2 : if (xNumberFormatsSupplier.is())
2765 2 : xNumberFormats.set(xNumberFormatsSupplier->getNumberFormats());
2766 : }
2767 8 : if (xNumberFormats.is())
2768 : {
2769 : try
2770 : {
2771 8 : uno::Reference < beans::XPropertySet> xNumberFormatProperties(xNumberFormats->getByKey(rNumberFormat));
2772 8 : if (xNumberFormatProperties.is())
2773 : {
2774 8 : if (nCellType != util::NumberFormat::CURRENCY)
2775 : {
2776 6 : lang::Locale aLocale;
2777 6 : if ( xNumberFormatProperties->getPropertyValue(sLocale) >>= aLocale )
2778 : {
2779 6 : if (!xNumberFormatTypes.is())
2780 2 : xNumberFormatTypes.set(uno::Reference <util::XNumberFormatTypes>(xNumberFormats, uno::UNO_QUERY));
2781 6 : rProperties->setPropertyValue( sNumberFormat, uno::makeAny(xNumberFormatTypes->getStandardFormat(nCellType, aLocale)) );
2782 6 : }
2783 : }
2784 2 : else if (!rCurrency.isEmpty() && !sCurrentCurrency.isEmpty())
2785 : {
2786 0 : if (!sCurrentCurrency.equals(rCurrency))
2787 0 : if (!IsCurrencySymbol(rNumberFormat, sCurrentCurrency, rCurrency))
2788 0 : rProperties->setPropertyValue( sNumberFormat, uno::makeAny(SetCurrencySymbol(rNumberFormat, rCurrency)));
2789 : }
2790 8 : }
2791 : }
2792 0 : catch ( uno::Exception& )
2793 : {
2794 : OSL_FAIL("Numberformat not found");
2795 : }
2796 8 : }
2797 : }
2798 : else
2799 : {
2800 1092 : if ((nCellType == util::NumberFormat::CURRENCY) && !rCurrency.isEmpty() && !sCurrentCurrency.isEmpty() &&
2801 1048 : !sCurrentCurrency.equals(rCurrency) && !IsCurrencySymbol(rNumberFormat, sCurrentCurrency, rCurrency))
2802 0 : rProperties->setPropertyValue( sNumberFormat, uno::makeAny(SetCurrencySymbol(rNumberFormat, rCurrency)));
2803 1042 : }
2804 : }
2805 : }
2806 :
2807 6038 : void ScXMLImport::AddStyleRange(const table::CellRangeAddress& rCellRange)
2808 : {
2809 6038 : if (!mbImportStyles)
2810 6038 : return;
2811 :
2812 6038 : if (!xSheetCellRanges.is() && GetModel().is())
2813 : {
2814 322 : uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
2815 322 : if (xMultiServiceFactory.is())
2816 322 : xSheetCellRanges.set(uno::Reference <sheet::XSheetCellRangeContainer>(xMultiServiceFactory->createInstance("com.sun.star.sheet.SheetCellRanges"), uno::UNO_QUERY));
2817 322 : OSL_ENSURE(xSheetCellRanges.is(), "didn't get SheetCellRanges");
2818 :
2819 : }
2820 6038 : xSheetCellRanges->addRangeAddress(rCellRange, false);
2821 : }
2822 :
2823 2462 : void ScXMLImport::SetStyleToRanges()
2824 : {
2825 2462 : if (!mbImportStyles)
2826 2462 : return;
2827 :
2828 2462 : if (!sPrevStyleName.isEmpty())
2829 : {
2830 2458 : uno::Reference <beans::XPropertySet> xProperties (xSheetCellRanges, uno::UNO_QUERY);
2831 2458 : if (xProperties.is())
2832 : {
2833 2458 : XMLTableStylesContext *pStyles(static_cast<XMLTableStylesContext *>(GetAutoStyles()));
2834 2458 : XMLTableStyleContext* pStyle = NULL;
2835 2458 : if ( pStyles )
2836 : pStyle = const_cast<XMLTableStyleContext*>(static_cast<const XMLTableStyleContext *>(pStyles->FindStyleChildContext(
2837 2458 : XML_STYLE_FAMILY_TABLE_CELL, sPrevStyleName, true)));
2838 2458 : if (pStyle)
2839 : {
2840 1722 : pStyle->FillPropertySet(xProperties);
2841 : // here needs to be the cond format import method
2842 1722 : sal_Int32 nNumberFormat(pStyle->GetNumberFormat());
2843 1722 : SetType(xProperties, nNumberFormat, nPrevCellType, sPrevCurrency);
2844 :
2845 : // store first cell of first range for each style, once per sheet
2846 1722 : uno::Sequence<table::CellRangeAddress> aAddresses(xSheetCellRanges->getRangeAddresses());
2847 1722 : pStyle->ApplyCondFormat(aAddresses);
2848 1722 : if ( aAddresses.getLength() > 0 )
2849 : {
2850 1722 : const table::CellRangeAddress& rRange = aAddresses[0];
2851 1722 : if ( rRange.Sheet != pStyle->GetLastSheet() )
2852 : {
2853 1614 : ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetModel())->GetSheetSaveData();
2854 : pSheetData->AddCellStyle( sPrevStyleName,
2855 1614 : ScAddress( (SCCOL)rRange.StartColumn, (SCROW)rRange.StartRow, (SCTAB)rRange.Sheet ) );
2856 1614 : pStyle->SetLastSheet(rRange.Sheet);
2857 : }
2858 1722 : }
2859 : }
2860 : else
2861 : {
2862 736 : xProperties->setPropertyValue(sCellStyle, uno::makeAny(GetStyleDisplayName( XML_STYLE_FAMILY_TABLE_CELL, sPrevStyleName )));
2863 736 : sal_Int32 nNumberFormat(GetStyleNumberFormats()->GetStyleNumberFormat(sPrevStyleName));
2864 736 : bool bInsert(nNumberFormat == -1);
2865 736 : SetType(xProperties, nNumberFormat, nPrevCellType, sPrevCurrency);
2866 736 : if (bInsert)
2867 464 : GetStyleNumberFormats()->AddStyleNumberFormat(sPrevStyleName, nNumberFormat);
2868 : }
2869 2458 : }
2870 : }
2871 2462 : if (GetModel().is())
2872 : {
2873 2462 : uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
2874 2462 : if (xMultiServiceFactory.is())
2875 : xSheetCellRanges.set(uno::Reference <sheet::XSheetCellRangeContainer>(
2876 2462 : xMultiServiceFactory->createInstance(
2877 2462 : OUString("com.sun.star.sheet.SheetCellRanges")),
2878 2462 : uno::UNO_QUERY));
2879 : }
2880 : OSL_ENSURE(xSheetCellRanges.is(), "didn't get SheetCellRanges");
2881 : }
2882 :
2883 6038 : void ScXMLImport::SetStyleToRange(const ScRange& rRange, const OUString* pStyleName,
2884 : const sal_Int16 nCellType, const OUString* pCurrency)
2885 : {
2886 6038 : if (!mbImportStyles)
2887 6038 : return;
2888 :
2889 6038 : if (sPrevStyleName.isEmpty())
2890 : {
2891 578 : nPrevCellType = nCellType;
2892 578 : if (pStyleName)
2893 578 : sPrevStyleName = *pStyleName;
2894 578 : if (pCurrency)
2895 0 : sPrevCurrency = *pCurrency;
2896 578 : else if (!sPrevCurrency.isEmpty())
2897 2 : sPrevCurrency = sEmpty;
2898 : }
2899 15440 : else if ((nCellType != nPrevCellType) ||
2900 4520 : ((pStyleName && !pStyleName->equals(sPrevStyleName)) ||
2901 7340 : (!pStyleName && !sPrevStyleName.isEmpty())) ||
2902 0 : ((pCurrency && !pCurrency->equals(sPrevCurrency)) ||
2903 3580 : (!pCurrency && !sPrevCurrency.isEmpty())))
2904 : {
2905 1880 : SetStyleToRanges();
2906 1880 : nPrevCellType = nCellType;
2907 1880 : if (pStyleName)
2908 1880 : sPrevStyleName = *pStyleName;
2909 0 : else if(!sPrevStyleName.isEmpty())
2910 0 : sPrevStyleName = sEmpty;
2911 1880 : if (pCurrency)
2912 46 : sPrevCurrency = *pCurrency;
2913 1834 : else if(!sPrevCurrency.isEmpty())
2914 10 : sPrevCurrency = sEmpty;
2915 : }
2916 6038 : table::CellRangeAddress aCellRange;
2917 6038 : aCellRange.StartColumn = rRange.aStart.Col();
2918 6038 : aCellRange.StartRow = rRange.aStart.Row();
2919 6038 : aCellRange.Sheet = rRange.aStart.Tab();
2920 6038 : aCellRange.EndColumn = rRange.aEnd.Col();
2921 6038 : aCellRange.EndRow = rRange.aEnd.Row();
2922 6038 : AddStyleRange(aCellRange);
2923 : }
2924 :
2925 492 : bool ScXMLImport::SetNullDateOnUnitConverter()
2926 : {
2927 492 : if (!bNullDateSetted)
2928 60 : bNullDateSetted = GetMM100UnitConverter().setNullDate(GetModel());
2929 : OSL_ENSURE(bNullDateSetted, "could not set the null date");
2930 492 : return bNullDateSetted;
2931 : }
2932 :
2933 1042 : XMLNumberFormatAttributesExportHelper* ScXMLImport::GetNumberFormatAttributesExportHelper()
2934 : {
2935 1042 : if (!pNumberFormatAttributesExportHelper)
2936 212 : pNumberFormatAttributesExportHelper = new XMLNumberFormatAttributesExportHelper(GetNumberFormatsSupplier());
2937 1042 : return pNumberFormatAttributesExportHelper;
2938 : }
2939 :
2940 1200 : ScMyStyleNumberFormats* ScXMLImport::GetStyleNumberFormats()
2941 : {
2942 1200 : if (!pStyleNumberFormats)
2943 282 : pStyleNumberFormats = new ScMyStyleNumberFormats();
2944 1200 : return pStyleNumberFormats;
2945 : }
2946 :
2947 582 : void ScXMLImport::SetStylesToRangesFinished()
2948 : {
2949 582 : SetStyleToRanges();
2950 582 : sPrevStyleName = sEmpty;
2951 582 : }
2952 :
2953 : // XImporter
2954 1098 : void SAL_CALL ScXMLImport::setTargetDocument( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent >& xDoc )
2955 : throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException, std::exception)
2956 : {
2957 1098 : ScXMLImport::MutexGuard aGuard(*this);
2958 1098 : SvXMLImport::setTargetDocument( xDoc );
2959 :
2960 2196 : uno::Reference<frame::XModel> xModel(xDoc, uno::UNO_QUERY);
2961 1098 : pDoc = ScXMLConverter::GetScDocument( xModel );
2962 : OSL_ENSURE( pDoc, "ScXMLImport::setTargetDocument - no ScDocument!" );
2963 1098 : if (!pDoc)
2964 0 : throw lang::IllegalArgumentException();
2965 :
2966 1098 : mpDocImport.reset(new ScDocumentImport(*pDoc));
2967 1098 : mpComp.reset(new ScCompiler(pDoc, ScAddress()));
2968 1098 : mpComp->SetGrammar(formula::FormulaGrammar::GRAM_ODFF);
2969 :
2970 2196 : uno::Reference<document::XActionLockable> xActionLockable(xDoc, uno::UNO_QUERY);
2971 1098 : if (xActionLockable.is())
2972 2196 : xActionLockable->addActionLock();
2973 1098 : }
2974 :
2975 : // ::com::sun::star::xml::sax::XDocumentHandler
2976 1088 : void SAL_CALL ScXMLImport::startDocument(void)
2977 : throw( ::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException, std::exception )
2978 : {
2979 1088 : ScXMLImport::MutexGuard aGuard(*this);
2980 1088 : SvXMLImport::startDocument();
2981 1088 : if (pDoc && !pDoc->IsImportingXML())
2982 : {
2983 60 : ScModelObj::getImplementation(GetModel())->BeforeXMLLoading();
2984 60 : bSelfImportingXMLSet = true;
2985 : }
2986 :
2987 : // if content and styles are loaded with separate imports,
2988 : // set bLatinDefaultStyle flag at the start of the content import
2989 1088 : sal_uInt16 nFlags = getImportFlags();
2990 1088 : if ( ( nFlags & IMPORT_CONTENT ) && !( nFlags & IMPORT_STYLES ) )
2991 264 : ExamineDefaultStyle();
2992 :
2993 1088 : if (getImportFlags() & IMPORT_CONTENT)
2994 : {
2995 322 : if (GetModel().is())
2996 : {
2997 : // store initial namespaces, to find the ones that were added from the file later
2998 322 : ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetModel())->GetSheetSaveData();
2999 322 : const SvXMLNamespaceMap& rNamespaces = GetNamespaceMap();
3000 322 : pSheetData->StoreInitialNamespaces(rNamespaces);
3001 : }
3002 : }
3003 :
3004 2176 : uno::Reference< beans::XPropertySet > const xImportInfo( getImportInfo() );
3005 : uno::Reference< beans::XPropertySetInfo > const xPropertySetInfo(
3006 2176 : xImportInfo.is() ? xImportInfo->getPropertySetInfo() : 0);
3007 1088 : if (xPropertySetInfo.is())
3008 : {
3009 : OUString const sOrganizerMode(
3010 1030 : "OrganizerMode");
3011 1030 : if (xPropertySetInfo->hasPropertyByName(sOrganizerMode))
3012 : {
3013 1028 : bool bStyleOnly(false);
3014 1028 : if (xImportInfo->getPropertyValue(sOrganizerMode) >>= bStyleOnly)
3015 : {
3016 0 : bLoadDoc = !bStyleOnly;
3017 : }
3018 1030 : }
3019 : }
3020 :
3021 2176 : UnlockSolarMutex();
3022 1088 : }
3023 :
3024 124 : sal_Int32 ScXMLImport::GetRangeType(const OUString& sRangeType) const
3025 : {
3026 124 : sal_Int32 nRangeType(0);
3027 124 : OUStringBuffer sBuffer;
3028 124 : sal_Int16 i = 0;
3029 372 : while (i <= sRangeType.getLength())
3030 : {
3031 124 : if ((i == sRangeType.getLength()) || (sRangeType[i] == ' '))
3032 : {
3033 124 : OUString sTemp = sBuffer.makeStringAndClear();
3034 124 : if (sTemp.equalsAscii(SC_REPEAT_COLUMN))
3035 0 : nRangeType |= sheet::NamedRangeFlag::COLUMN_HEADER;
3036 124 : else if (sTemp.equalsAscii(SC_REPEAT_ROW))
3037 0 : nRangeType |= sheet::NamedRangeFlag::ROW_HEADER;
3038 124 : else if (sTemp.equalsAscii(SC_FILTER))
3039 0 : nRangeType |= sheet::NamedRangeFlag::FILTER_CRITERIA;
3040 124 : else if (sTemp.equalsAscii(SC_PRINT_RANGE))
3041 0 : nRangeType |= sheet::NamedRangeFlag::PRINT_AREA;
3042 : }
3043 0 : else if (i < sRangeType.getLength())
3044 0 : sBuffer.append(sRangeType[i]);
3045 124 : ++i;
3046 : }
3047 124 : return nRangeType;
3048 : }
3049 :
3050 322 : void ScXMLImport::SetLabelRanges()
3051 : {
3052 322 : ScMyLabelRanges* pLabelRanges = GetLabelRanges();
3053 322 : if (pLabelRanges)
3054 : {
3055 0 : uno::Reference <beans::XPropertySet> xPropertySet (GetModel(), uno::UNO_QUERY);
3056 0 : if (xPropertySet.is())
3057 : {
3058 0 : uno::Any aColAny = xPropertySet->getPropertyValue(OUString(SC_UNO_COLLABELRNG));
3059 0 : uno::Any aRowAny = xPropertySet->getPropertyValue(OUString(SC_UNO_ROWLABELRNG));
3060 :
3061 0 : uno::Reference< sheet::XLabelRanges > xColRanges;
3062 0 : uno::Reference< sheet::XLabelRanges > xRowRanges;
3063 :
3064 0 : if ( ( aColAny >>= xColRanges ) && ( aRowAny >>= xRowRanges ) )
3065 : {
3066 0 : table::CellRangeAddress aLabelRange;
3067 0 : table::CellRangeAddress aDataRange;
3068 :
3069 0 : ScMyLabelRanges::iterator aItr = pLabelRanges->begin();
3070 0 : while (aItr != pLabelRanges->end())
3071 : {
3072 0 : sal_Int32 nOffset1(0);
3073 0 : sal_Int32 nOffset2(0);
3074 0 : FormulaGrammar::AddressConvention eConv = FormulaGrammar::CONV_OOO;
3075 :
3076 0 : if (ScRangeStringConverter::GetRangeFromString( aLabelRange, (*aItr)->sLabelRangeStr, GetDocument(), eConv, nOffset1 ) &&
3077 0 : ScRangeStringConverter::GetRangeFromString( aDataRange, (*aItr)->sDataRangeStr, GetDocument(), eConv, nOffset2 ))
3078 : {
3079 0 : if ( (*aItr)->bColumnOrientation )
3080 0 : xColRanges->addNew( aLabelRange, aDataRange );
3081 : else
3082 0 : xRowRanges->addNew( aLabelRange, aDataRange );
3083 : }
3084 :
3085 0 : delete *aItr;
3086 0 : aItr = pLabelRanges->erase(aItr);
3087 : }
3088 0 : }
3089 0 : }
3090 : }
3091 322 : }
3092 :
3093 : namespace {
3094 :
3095 : class RangeNameInserter : public ::std::unary_function<ScMyNamedExpression, void>
3096 : {
3097 : ScDocument* mpDoc;
3098 : ScRangeName& mrRangeName;
3099 : ScXMLImport& mrXmlImport;
3100 :
3101 : public:
3102 30 : RangeNameInserter(ScDocument* pDoc, ScRangeName& rRangeName, ScXMLImport& rXmlImport) :
3103 30 : mpDoc(pDoc), mrRangeName(rRangeName), mrXmlImport(rXmlImport) {}
3104 :
3105 124 : void operator() (const ScMyNamedExpression& r) const
3106 : {
3107 : using namespace formula;
3108 :
3109 124 : const OUString& aType = r.sRangeType;
3110 124 : sal_uInt32 nUnoType = mrXmlImport.GetRangeType(aType);
3111 :
3112 124 : sal_uInt16 nNewType = RT_NAME;
3113 124 : if ( nUnoType & sheet::NamedRangeFlag::FILTER_CRITERIA ) nNewType |= RT_CRITERIA;
3114 124 : if ( nUnoType & sheet::NamedRangeFlag::PRINT_AREA ) nNewType |= RT_PRINTAREA;
3115 124 : if ( nUnoType & sheet::NamedRangeFlag::COLUMN_HEADER ) nNewType |= RT_COLHEADER;
3116 124 : if ( nUnoType & sheet::NamedRangeFlag::ROW_HEADER ) nNewType |= RT_ROWHEADER;
3117 :
3118 124 : if (mpDoc)
3119 : {
3120 : // Insert a new name.
3121 124 : ScAddress aPos;
3122 124 : sal_Int32 nOffset = 0;
3123 : bool bSuccess = ScRangeStringConverter::GetAddressFromString(
3124 124 : aPos, r.sBaseCellAddress, mpDoc, FormulaGrammar::CONV_OOO, nOffset);
3125 :
3126 124 : if (bSuccess)
3127 : {
3128 124 : OUString aContent = r.sContent;
3129 124 : if (!r.bIsExpression)
3130 74 : ScXMLConverter::ParseFormula(aContent, false);
3131 :
3132 : ScRangeData* pData = new ScRangeData(
3133 124 : mpDoc, r.sName, aContent, aPos, nNewType, r.eGrammar);
3134 124 : mrRangeName.insert(pData);
3135 : }
3136 : }
3137 124 : }
3138 : };
3139 :
3140 : }
3141 :
3142 322 : void ScXMLImport::SetNamedRanges()
3143 : {
3144 322 : ScMyNamedExpressions* pNamedExpressions = GetNamedExpressions();
3145 322 : if (!pNamedExpressions)
3146 300 : return;
3147 :
3148 22 : if (!pDoc)
3149 0 : return;
3150 :
3151 : // Insert the namedRanges
3152 22 : ScRangeName* pRangeNames = pDoc->GetRangeName();
3153 22 : ::std::for_each(pNamedExpressions->begin(), pNamedExpressions->end(), RangeNameInserter(pDoc, *pRangeNames, *this));
3154 : }
3155 :
3156 322 : void ScXMLImport::SetSheetNamedRanges()
3157 : {
3158 322 : if (!pDoc)
3159 322 : return;
3160 :
3161 322 : SheetNamedExpMap::const_iterator itr = maSheetNamedExpressions.begin(), itrEnd = maSheetNamedExpressions.end();
3162 330 : for (; itr != itrEnd; ++itr)
3163 : {
3164 8 : SCTAB nTab = itr->first;
3165 8 : ScRangeName* pRangeNames = pDoc->GetRangeName(nTab);
3166 8 : if (!pRangeNames)
3167 0 : continue;
3168 :
3169 8 : const ScMyNamedExpressions& rNames = *itr->second;
3170 8 : ::std::for_each(rNames.begin(), rNames.end(), RangeNameInserter(pDoc, *pRangeNames, *this));
3171 : }
3172 : }
3173 :
3174 1088 : void SAL_CALL ScXMLImport::endDocument()
3175 : throw(::com::sun::star::xml::sax::SAXException,
3176 : ::com::sun::star::uno::RuntimeException,
3177 : std::exception)
3178 : {
3179 1088 : ScXMLImport::MutexGuard aGuard(*this);
3180 1088 : if (getImportFlags() & IMPORT_CONTENT)
3181 : {
3182 322 : if (GetModel().is())
3183 : {
3184 322 : mpDocImport->finalize();
3185 :
3186 322 : uno::Reference<document::XViewDataSupplier> xViewDataSupplier(GetModel(), uno::UNO_QUERY);
3187 322 : if (xViewDataSupplier.is())
3188 : {
3189 322 : uno::Reference<container::XIndexAccess> xIndexAccess(xViewDataSupplier->getViewData());
3190 322 : if (xIndexAccess.is() && xIndexAccess->getCount() > 0)
3191 : {
3192 322 : uno::Sequence< beans::PropertyValue > aSeq;
3193 322 : if (xIndexAccess->getByIndex(0) >>= aSeq)
3194 : {
3195 322 : sal_Int32 nCount (aSeq.getLength());
3196 2344 : for (sal_Int32 i = 0; i < nCount; ++i)
3197 : {
3198 2022 : OUString sName(aSeq[i].Name);
3199 2022 : if (sName.equalsAscii(SC_ACTIVETABLE))
3200 : {
3201 322 : OUString sValue;
3202 322 : if(aSeq[i].Value >>= sValue)
3203 : {
3204 322 : OUString sTabName(sValue);
3205 322 : SCTAB nTab(0);
3206 322 : if (pDoc->GetTable(sTabName, nTab))
3207 : {
3208 264 : pDoc->SetVisibleTab(nTab);
3209 264 : i = nCount;
3210 322 : }
3211 322 : }
3212 : }
3213 2022 : }
3214 322 : }
3215 322 : }
3216 : }
3217 322 : SetLabelRanges();
3218 322 : SetNamedRanges();
3219 322 : SetSheetNamedRanges();
3220 322 : if (mpPivotSources)
3221 : // Process pivot table sources after the named ranges have been set.
3222 10 : mpPivotSources->process();
3223 : }
3224 322 : GetProgressBarHelper()->End(); // make room for subsequent SfxProgressBars
3225 322 : if (pDoc)
3226 : {
3227 322 : pDoc->CompileXML();
3228 :
3229 : // After CompileXML, links must be completely changed to the new URLs.
3230 : // Otherwise, hasExternalFile for API wouldn't work (#i116940#),
3231 : // and typing a new formula would create a second link with the same "real" file name.
3232 322 : if (pDoc->HasExternalRefManager())
3233 110 : pDoc->GetExternalRefManager()->updateAbsAfterLoad();
3234 : }
3235 :
3236 : // If the stream contains cells outside of the current limits, the styles can't be re-created,
3237 : // so stream copying is disabled then.
3238 322 : if (pDoc && GetModel().is() && !pDoc->HasRangeOverflow())
3239 : {
3240 : // set "valid stream" flags after loading (before UpdateRowHeights, so changed formula results
3241 : // in UpdateRowHeights can already clear the flags again)
3242 322 : ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetModel())->GetSheetSaveData();
3243 :
3244 322 : SCTAB nTabCount = pDoc->GetTableCount();
3245 900 : for (SCTAB nTab=0; nTab<nTabCount; ++nTab)
3246 : {
3247 578 : pDoc->SetDrawPageSize(nTab);
3248 578 : if (!pSheetData->IsSheetBlocked( nTab ))
3249 474 : pDoc->SetStreamValid( nTab, true );
3250 : }
3251 : }
3252 322 : aTables.FixupOLEs();
3253 : }
3254 1088 : if (GetModel().is())
3255 : {
3256 1088 : uno::Reference<document::XActionLockable> xActionLockable(GetModel(), uno::UNO_QUERY);
3257 1088 : if (xActionLockable.is())
3258 1088 : xActionLockable->removeActionLock();
3259 : }
3260 1088 : SvXMLImport::endDocument();
3261 :
3262 1088 : if(pDoc && bSelfImportingXMLSet)
3263 60 : ScModelObj::getImplementation(GetModel())->AfterXMLLoading(true);
3264 1088 : }
3265 :
3266 : // XEventListener
3267 4 : void ScXMLImport::DisposingModel()
3268 : {
3269 4 : SvXMLImport::DisposingModel();
3270 4 : pDoc = NULL;
3271 4 : }
3272 :
3273 21368 : ScXMLImport::MutexGuard::MutexGuard(ScXMLImport& rImport) :
3274 21368 : mrImport(rImport)
3275 : {
3276 21368 : mrImport.LockSolarMutex();
3277 21368 : }
3278 :
3279 21368 : ScXMLImport::MutexGuard::~MutexGuard()
3280 : {
3281 21368 : mrImport.UnlockSolarMutex();
3282 21368 : }
3283 :
3284 21896 : void ScXMLImport::LockSolarMutex()
3285 : {
3286 : // #i62677# When called from DocShell/Wrapper, the SolarMutex is already locked,
3287 : // so there's no need to allocate (and later delete) the SolarMutexGuard.
3288 21896 : if (!mbLockSolarMutex)
3289 : {
3290 : DBG_TESTSOLARMUTEX();
3291 43068 : return;
3292 : }
3293 :
3294 724 : if (nSolarMutexLocked == 0)
3295 : {
3296 : OSL_ENSURE(!pSolarMutexGuard, "Solar Mutex is locked");
3297 662 : pSolarMutexGuard = new SolarMutexGuard();
3298 : }
3299 724 : ++nSolarMutexLocked;
3300 : }
3301 :
3302 22984 : void ScXMLImport::UnlockSolarMutex()
3303 : {
3304 22984 : if (nSolarMutexLocked > 0)
3305 : {
3306 724 : nSolarMutexLocked--;
3307 724 : if (nSolarMutexLocked == 0)
3308 : {
3309 : OSL_ENSURE(pSolarMutexGuard, "Solar Mutex is always unlocked");
3310 662 : delete pSolarMutexGuard;
3311 662 : pSolarMutexGuard = NULL;
3312 : }
3313 : }
3314 22984 : }
3315 :
3316 1074 : sal_Int32 ScXMLImport::GetByteOffset()
3317 : {
3318 1074 : sal_Int32 nOffset = -1;
3319 1074 : uno::Reference<xml::sax::XLocator> xLocator = GetLocator();
3320 2148 : uno::Reference<io::XSeekable> xSeek( xLocator, uno::UNO_QUERY ); //! should use different interface
3321 1074 : if ( xSeek.is() )
3322 988 : nOffset = (sal_Int32)xSeek->getPosition();
3323 2148 : return nOffset;
3324 : }
3325 :
3326 0 : void ScXMLImport::SetRangeOverflowType(sal_uInt32 nType)
3327 : {
3328 : // #i31130# Overflow is stored in the document, because the ScXMLImport object
3329 : // isn't available in ScXMLImportWrapper::ImportFromComponent when using the
3330 : // OOo->Oasis transformation.
3331 :
3332 0 : if ( pDoc )
3333 0 : pDoc->SetRangeOverflowType( nType );
3334 0 : }
3335 :
3336 14180 : void ScXMLImport::ProgressBarIncrement(bool bEditCell, sal_Int32 nInc)
3337 : {
3338 14180 : nProgressCount += nInc;
3339 14180 : if (bEditCell || nProgressCount > 100)
3340 : {
3341 80 : GetProgressBarHelper()->Increment(nProgressCount);
3342 80 : nProgressCount = 0;
3343 : }
3344 14180 : }
3345 :
3346 1896 : void ScXMLImport::ExtractFormulaNamespaceGrammar(
3347 : OUString& rFormula, OUString& rFormulaNmsp, FormulaGrammar::Grammar& reGrammar,
3348 : const OUString& rAttrValue, bool bRestrictToExternalNmsp ) const
3349 : {
3350 : // parse the attribute value, extract namespace ID, literal namespace, and formula string
3351 1896 : rFormulaNmsp = OUString();
3352 1896 : sal_uInt16 nNsId = GetNamespaceMap()._GetKeyByAttrName( rAttrValue, 0, &rFormula, &rFormulaNmsp, false );
3353 :
3354 : // check if we have an ODF formula namespace
3355 1896 : if( !bRestrictToExternalNmsp ) switch( nNsId )
3356 : {
3357 : case XML_NAMESPACE_OOOC:
3358 0 : rFormulaNmsp = OUString(); // remove namespace string for built-in grammar
3359 0 : reGrammar = FormulaGrammar::GRAM_PODF;
3360 0 : return;
3361 : case XML_NAMESPACE_OF:
3362 1714 : rFormulaNmsp = OUString(); // remove namespace string for built-in grammar
3363 1714 : reGrammar = FormulaGrammar::GRAM_ODFF;
3364 1714 : return;
3365 : }
3366 :
3367 : /* Find default grammar for formulas without namespace. There may be
3368 : documents in the wild that stored no namespace in ODF 1.0/1.1. Use
3369 : GRAM_PODF then (old style ODF 1.0/1.1 formulas). The default for ODF
3370 : 1.2 and later without namespace is GRAM_ODFF (OpenFormula). */
3371 : FormulaGrammar::Grammar eDefaultGrammar =
3372 182 : (GetDocument()->GetStorageGrammar() == FormulaGrammar::GRAM_PODF) ?
3373 182 : FormulaGrammar::GRAM_PODF : FormulaGrammar::GRAM_ODFF;
3374 :
3375 : /* Check if we have no namespace at all. The value XML_NAMESPACE_NONE
3376 : indicates that there is no colon. If the first character of the
3377 : attribute value is the equality sign, the value XML_NAMESPACE_UNKNOWN
3378 : indicates that there is a colon somewhere in the formula string. */
3379 182 : if( (nNsId == XML_NAMESPACE_NONE) || ((nNsId == XML_NAMESPACE_UNKNOWN) && (rAttrValue.toChar() == '=')) )
3380 : {
3381 158 : rFormula = rAttrValue; // return entire string as formula
3382 158 : reGrammar = eDefaultGrammar;
3383 158 : return;
3384 : }
3385 :
3386 : /* Check if a namespace URL could be resolved from the attribute value.
3387 : Use that namespace only, if the Calc document knows an associated
3388 : external formula parser. This prevents that the range operator in
3389 : conjunction with defined names is confused as namespaces prefix, e.g.
3390 : in the expression 'table:A1' where 'table' is a named reference. */
3391 24 : if( ((nNsId & XML_NAMESPACE_UNKNOWN_FLAG) != 0) && !rFormulaNmsp.isEmpty() &&
3392 0 : GetDocument()->GetFormulaParserPool().hasFormulaParser( rFormulaNmsp ) )
3393 : {
3394 0 : reGrammar = FormulaGrammar::GRAM_EXTERNAL;
3395 0 : return;
3396 : }
3397 :
3398 : /* All attempts failed (e.g. no namespace and no leading equality sign, or
3399 : an invalid namespace prefix), continue with the entire attribute value. */
3400 24 : rFormula = rAttrValue;
3401 24 : rFormulaNmsp = OUString(); // remove any namespace string
3402 24 : reGrammar = eDefaultGrammar;
3403 : }
3404 :
3405 28 : bool ScXMLImport::IsFormulaErrorConstant( const OUString& rStr ) const
3406 : {
3407 28 : if (!mpComp)
3408 0 : return false;
3409 :
3410 28 : return mpComp->GetErrorConstant(rStr) > 0;
3411 : }
3412 :
3413 20888 : ScEditEngineDefaulter* ScXMLImport::GetEditEngine()
3414 : {
3415 20888 : if (!mpEditEngine)
3416 : {
3417 322 : mpEditEngine.reset(new ScEditEngineDefaulter(pDoc->GetEnginePool()));
3418 322 : mpEditEngine->SetRefMapMode(MAP_100TH_MM);
3419 322 : mpEditEngine->SetEditTextObjectPool(pDoc->GetEditPool());
3420 322 : mpEditEngine->SetUpdateMode(false);
3421 322 : mpEditEngine->EnableUndo(false);
3422 322 : mpEditEngine->SetControlWord(mpEditEngine->GetControlWord() & ~EE_CNTRL_ALLOWBIGOBJS);
3423 : }
3424 20888 : return mpEditEngine.get();
3425 : }
3426 :
3427 784 : const ScXMLEditAttributeMap& ScXMLImport::GetEditAttributeMap() const
3428 : {
3429 784 : if (!mpEditAttrMap)
3430 76 : mpEditAttrMap.reset(new ScXMLEditAttributeMap);
3431 784 : return *mpEditAttrMap;
3432 : }
3433 :
3434 0 : void ScXMLImport::NotifyEmbeddedFontRead()
3435 : {
3436 0 : if ( pDoc )
3437 0 : pDoc->SetIsUsingEmbededFonts( true );
3438 0 : }
3439 :
3440 322 : ScMyImpDetectiveOpArray* ScXMLImport::GetDetectiveOpArray()
3441 : {
3442 322 : if (!pDetectiveOpArray)
3443 322 : pDetectiveOpArray = new ScMyImpDetectiveOpArray();
3444 322 : return pDetectiveOpArray;
3445 228 : }
3446 :
3447 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
