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