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