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