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