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