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_TOKEN_MAP_END
1039 };
1040
1041 pDatabaseRangeSourceTableAttrTokenMap = new SvXMLTokenMap( aDatabaseRangeSourceTableAttrTokenMap );
1042 } // if( !pDatabaseRangeSourceTableAttrTokenMap )
1043
1044 return *pDatabaseRangeSourceTableAttrTokenMap;
1045 }
1046
GetDatabaseRangeSourceQueryAttrTokenMap()1047 const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeSourceQueryAttrTokenMap()
1048 {
1049 if( !pDatabaseRangeSourceQueryAttrTokenMap )
1050 {
1051 static __FAR_DATA SvXMLTokenMapEntry aDatabaseRangeSourceQueryAttrTokenMap[] =
1052 {
1053 { XML_NAMESPACE_TABLE, XML_DATABASE_NAME, XML_TOK_SOURCE_QUERY_ATTR_DATABASE_NAME },
1054 { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_SOURCE_QUERY_ATTR_HREF },
1055 { XML_NAMESPACE_TABLE, XML_CONNECTION_RESOURCE, XML_TOK_SOURCE_QUERY_ATTR_CONNECTION_RESSOURCE },
1056 { XML_NAMESPACE_TABLE, XML_QUERY_NAME, XML_TOK_SOURCE_QUERY_ATTR_QUERY_NAME },
1057 XML_TOKEN_MAP_END
1058 };
1059
1060 pDatabaseRangeSourceQueryAttrTokenMap = new SvXMLTokenMap( aDatabaseRangeSourceQueryAttrTokenMap );
1061 } // if( !pDatabaseRangeSourceQueryAttrTokenMap )
1062
1063 return *pDatabaseRangeSourceQueryAttrTokenMap;
1064 }
1065
GetFilterElemTokenMap()1066 const SvXMLTokenMap& ScXMLImport::GetFilterElemTokenMap()
1067 {
1068 if( !pFilterElemTokenMap )
1069 {
1070 static __FAR_DATA SvXMLTokenMapEntry aFilterTokenMap[] =
1071 {
1072 { XML_NAMESPACE_TABLE, XML_FILTER_AND, XML_TOK_FILTER_AND },
1073 { XML_NAMESPACE_TABLE, XML_FILTER_OR, XML_TOK_FILTER_OR },
1074 { XML_NAMESPACE_TABLE, XML_FILTER_CONDITION, XML_TOK_FILTER_CONDITION },
1075 XML_TOKEN_MAP_END
1076 };
1077
1078 pFilterElemTokenMap = new SvXMLTokenMap( aFilterTokenMap );
1079 } // if( !pFilterElemTokenMap )
1080
1081 return *pFilterElemTokenMap;
1082 }
1083
GetFilterAttrTokenMap()1084 const SvXMLTokenMap& ScXMLImport::GetFilterAttrTokenMap()
1085 {
1086 if( !pFilterAttrTokenMap )
1087 {
1088 static __FAR_DATA SvXMLTokenMapEntry aFilterAttrTokenMap[] =
1089 {
1090 { XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, XML_TOK_FILTER_ATTR_TARGET_RANGE_ADDRESS },
1091 { XML_NAMESPACE_TABLE, XML_CONDITION_SOURCE_RANGE_ADDRESS, XML_TOK_FILTER_ATTR_CONDITION_SOURCE_RANGE_ADDRESS },
1092 { XML_NAMESPACE_TABLE, XML_CONDITION_SOURCE, XML_TOK_FILTER_ATTR_CONDITION_SOURCE },
1093 { XML_NAMESPACE_TABLE, XML_DISPLAY_DUPLICATES, XML_TOK_FILTER_ATTR_DISPLAY_DUPLICATES },
1094 XML_TOKEN_MAP_END
1095 };
1096
1097 pFilterAttrTokenMap = new SvXMLTokenMap( aFilterAttrTokenMap );
1098 } // if( !pFilterAttrTokenMap )
1099
1100 return *pFilterAttrTokenMap;
1101 }
1102
GetFilterConditionAttrTokenMap()1103 const SvXMLTokenMap& ScXMLImport::GetFilterConditionAttrTokenMap()
1104 {
1105 if( !pFilterConditionAttrTokenMap )
1106 {
1107 static __FAR_DATA SvXMLTokenMapEntry aFilterConditionAttrTokenMap[] =
1108 {
1109 { XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, XML_TOK_CONDITION_ATTR_FIELD_NUMBER },
1110 { XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TOK_CONDITION_ATTR_CASE_SENSITIVE },
1111 { XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_TOK_CONDITION_ATTR_DATA_TYPE },
1112 { XML_NAMESPACE_TABLE, XML_VALUE, XML_TOK_CONDITION_ATTR_VALUE },
1113 { XML_NAMESPACE_TABLE, XML_OPERATOR, XML_TOK_CONDITION_ATTR_OPERATOR },
1114 XML_TOKEN_MAP_END
1115 };
1116
1117 pFilterConditionAttrTokenMap = new SvXMLTokenMap( aFilterConditionAttrTokenMap );
1118 } // if( !pFilterConditionAttrTokenMap )
1119
1120 return *pFilterConditionAttrTokenMap;
1121 }
1122
GetSortElemTokenMap()1123 const SvXMLTokenMap& ScXMLImport::GetSortElemTokenMap()
1124 {
1125 if( !pSortElemTokenMap )
1126 {
1127 static __FAR_DATA SvXMLTokenMapEntry aSortTokenMap[] =
1128 {
1129 { XML_NAMESPACE_TABLE, XML_SORT_BY, XML_TOK_SORT_SORT_BY },
1130 XML_TOKEN_MAP_END
1131 };
1132
1133 pSortElemTokenMap = new SvXMLTokenMap( aSortTokenMap );
1134 } // if( !pSortElemTokenMap )
1135
1136 return *pSortElemTokenMap;
1137 }
1138
GetSortAttrTokenMap()1139 const SvXMLTokenMap& ScXMLImport::GetSortAttrTokenMap()
1140 {
1141 if( !pSortAttrTokenMap )
1142 {
1143 static __FAR_DATA SvXMLTokenMapEntry aSortAttrTokenMap[] =
1144 {
1145 { XML_NAMESPACE_TABLE, XML_BIND_STYLES_TO_CONTENT, XML_TOK_SORT_ATTR_BIND_STYLES_TO_CONTENT },
1146 { XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, XML_TOK_SORT_ATTR_TARGET_RANGE_ADDRESS },
1147 { XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TOK_SORT_ATTR_CASE_SENSITIVE },
1148 { XML_NAMESPACE_TABLE, XML_LANGUAGE, XML_TOK_SORT_ATTR_LANGUAGE },
1149 { XML_NAMESPACE_TABLE, XML_COUNTRY, XML_TOK_SORT_ATTR_COUNTRY },
1150 { XML_NAMESPACE_TABLE, XML_ALGORITHM, XML_TOK_SORT_ATTR_ALGORITHM },
1151 XML_TOKEN_MAP_END
1152 };
1153
1154 pSortAttrTokenMap = new SvXMLTokenMap( aSortAttrTokenMap );
1155 } // if( !pSortAttrTokenMap )
1156
1157 return *pSortAttrTokenMap;
1158 }
1159
GetSortSortByAttrTokenMap()1160 const SvXMLTokenMap& ScXMLImport::GetSortSortByAttrTokenMap()
1161 {
1162 if( !pSortSortByAttrTokenMap )
1163 {
1164 static __FAR_DATA SvXMLTokenMapEntry aSortSortByAttrTokenMap[] =
1165 {
1166 { XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, XML_TOK_SORT_BY_ATTR_FIELD_NUMBER },
1167 { XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_TOK_SORT_BY_ATTR_DATA_TYPE },
1168 { XML_NAMESPACE_TABLE, XML_ORDER, XML_TOK_SORT_BY_ATTR_ORDER },
1169 XML_TOKEN_MAP_END
1170 };
1171
1172 pSortSortByAttrTokenMap = new SvXMLTokenMap( aSortSortByAttrTokenMap );
1173 } // if( !pSortSortByAttrTokenMap )
1174
1175 return *pSortSortByAttrTokenMap;
1176 }
1177
GetDatabaseRangeSubTotalRulesElemTokenMap()1178 const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeSubTotalRulesElemTokenMap()
1179 {
1180 if( !pDatabaseRangeSubTotalRulesElemTokenMap )
1181 {
1182 static __FAR_DATA SvXMLTokenMapEntry aDatabaseRangeSubTotalRulesTokenMap[] =
1183 {
1184 { XML_NAMESPACE_TABLE, XML_SORT_GROUPS, XML_TOK_SUBTOTAL_RULES_SORT_GROUPS },
1185 { XML_NAMESPACE_TABLE, XML_SUBTOTAL_RULE, XML_TOK_SUBTOTAL_RULES_SUBTOTAL_RULE },
1186 XML_TOKEN_MAP_END
1187 };
1188
1189 pDatabaseRangeSubTotalRulesElemTokenMap = new SvXMLTokenMap( aDatabaseRangeSubTotalRulesTokenMap );
1190 } // if( !pDatabaseRangeSubTotalRulesElemTokenMap )
1191
1192 return *pDatabaseRangeSubTotalRulesElemTokenMap;
1193 }
1194
GetDatabaseRangeSubTotalRulesAttrTokenMap()1195 const SvXMLTokenMap& ScXMLImport::GetDatabaseRangeSubTotalRulesAttrTokenMap()
1196 {
1197 if( !pDatabaseRangeSubTotalRulesAttrTokenMap )
1198 {
1199 static __FAR_DATA SvXMLTokenMapEntry aDatabaseRangeSubTotalRulesAttrTokenMap[] =
1200 {
1201 { XML_NAMESPACE_TABLE, XML_BIND_STYLES_TO_CONTENT, XML_TOK_SUBTOTAL_RULES_ATTR_BIND_STYLES_TO_CONTENT },
1202 { XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TOK_SUBTOTAL_RULES_ATTR_CASE_SENSITIVE },
1203 { XML_NAMESPACE_TABLE, XML_PAGE_BREAKS_ON_GROUP_CHANGE, XML_TOK_SUBTOTAL_RULES_ATTR_PAGE_BREAKS_ON_GROUP_CHANGE },
1204 XML_TOKEN_MAP_END
1205 };
1206
1207 pDatabaseRangeSubTotalRulesAttrTokenMap = new SvXMLTokenMap( aDatabaseRangeSubTotalRulesAttrTokenMap );
1208 } // if( !pDatabaseRangeSubTotalRulesAttrTokenMap )
1209
1210 return *pDatabaseRangeSubTotalRulesAttrTokenMap;
1211 }
1212
GetSubTotalRulesSortGroupsAttrTokenMap()1213 const SvXMLTokenMap& ScXMLImport::GetSubTotalRulesSortGroupsAttrTokenMap()
1214 {
1215 if( !pSubTotalRulesSortGroupsAttrTokenMap )
1216 {
1217 static __FAR_DATA SvXMLTokenMapEntry aSubTotalRulesSortGroupsAttrTokenMap[] =
1218 {
1219 { XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_TOK_SORT_GROUPS_ATTR_DATA_TYPE },
1220 { XML_NAMESPACE_TABLE, XML_ORDER, XML_TOK_SORT_GROUPS_ATTR_ORDER },
1221 XML_TOKEN_MAP_END
1222 };
1223
1224 pSubTotalRulesSortGroupsAttrTokenMap = new SvXMLTokenMap( aSubTotalRulesSortGroupsAttrTokenMap );
1225 } // if( !pSubTotalRulesSortGroupsAttrTokenMap )
1226
1227 return *pSubTotalRulesSortGroupsAttrTokenMap;
1228 }
1229
GetSubTotalRulesSubTotalRuleElemTokenMap()1230 const SvXMLTokenMap& ScXMLImport::GetSubTotalRulesSubTotalRuleElemTokenMap()
1231 {
1232 if( !pSubTotalRulesSubTotalRuleElemTokenMap )
1233 {
1234 static __FAR_DATA SvXMLTokenMapEntry aSubTotalRulesSubTotalRuleTokenMap[] =
1235 {
1236 { XML_NAMESPACE_TABLE, XML_SUBTOTAL_FIELD, XML_TOK_SUBTOTAL_RULE_SUBTOTAL_FIELD },
1237 XML_TOKEN_MAP_END
1238 };
1239
1240 pSubTotalRulesSubTotalRuleElemTokenMap = new SvXMLTokenMap( aSubTotalRulesSubTotalRuleTokenMap );
1241 } // if( !pSubTotalRulesSubTotalRuleElemTokenMap )
1242
1243 return *pSubTotalRulesSubTotalRuleElemTokenMap;
1244 }
1245
GetSubTotalRulesSubTotalRuleAttrTokenMap()1246 const SvXMLTokenMap& ScXMLImport::GetSubTotalRulesSubTotalRuleAttrTokenMap()
1247 {
1248 if( !pSubTotalRulesSubTotalRuleAttrTokenMap )
1249 {
1250 static __FAR_DATA SvXMLTokenMapEntry aSubTotalRulesSubTotalRuleAttrTokenMap[] =
1251 {
1252 { XML_NAMESPACE_TABLE, XML_GROUP_BY_FIELD_NUMBER, XML_TOK_SUBTOTAL_RULE_ATTR_GROUP_BY_FIELD_NUMBER },
1253 XML_TOKEN_MAP_END
1254 };
1255
1256 pSubTotalRulesSubTotalRuleAttrTokenMap = new SvXMLTokenMap( aSubTotalRulesSubTotalRuleAttrTokenMap );
1257 } // if( !pSubTotalRulesSubTotalRuleAttrTokenMap )
1258
1259 return *pSubTotalRulesSubTotalRuleAttrTokenMap;
1260 }
1261
GetSubTotalRuleSubTotalFieldAttrTokenMap()1262 const SvXMLTokenMap& ScXMLImport::GetSubTotalRuleSubTotalFieldAttrTokenMap()
1263 {
1264 if( !pSubTotalRuleSubTotalFieldAttrTokenMap )
1265 {
1266 static __FAR_DATA SvXMLTokenMapEntry aSubTotalRuleSubTotalFieldAttrTokenMap[] =
1267 {
1268 { XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, XML_TOK_SUBTOTAL_FIELD_ATTR_FIELD_NUMBER },
1269 { XML_NAMESPACE_TABLE, XML_FUNCTION, XML_TOK_SUBTOTAL_FIELD_ATTR_FUNCTION },
1270 XML_TOKEN_MAP_END
1271 };
1272
1273 pSubTotalRuleSubTotalFieldAttrTokenMap = new SvXMLTokenMap( aSubTotalRuleSubTotalFieldAttrTokenMap );
1274 } // if( !pSubTotalRuleSubTotalFieldAttrTokenMap )
1275
1276 return *pSubTotalRuleSubTotalFieldAttrTokenMap;
1277 }
1278
GetDataPilotTablesElemTokenMap()1279 const SvXMLTokenMap& ScXMLImport::GetDataPilotTablesElemTokenMap()
1280 {
1281 if( !pDataPilotTablesElemTokenMap )
1282 {
1283 static __FAR_DATA SvXMLTokenMapEntry aDataPilotTablesElemTokenMap[] =
1284 {
1285 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_TABLE, XML_TOK_DATA_PILOT_TABLE },
1286 XML_TOKEN_MAP_END
1287 };
1288
1289 pDataPilotTablesElemTokenMap = new SvXMLTokenMap( aDataPilotTablesElemTokenMap );
1290 } // if( !pDataPilotTablesElemTokenMap )
1291
1292 return *pDataPilotTablesElemTokenMap;
1293 }
1294
GetDataPilotTableAttrTokenMap()1295 const SvXMLTokenMap& ScXMLImport::GetDataPilotTableAttrTokenMap()
1296 {
1297 if( !pDataPilotTableAttrTokenMap )
1298 {
1299 static __FAR_DATA SvXMLTokenMapEntry aDataPilotTableAttrTokenMap[] =
1300 {
1301 { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_DATA_PILOT_TABLE_ATTR_NAME },
1302 { XML_NAMESPACE_TABLE, XML_APPLICATION_DATA, XML_TOK_DATA_PILOT_TABLE_ATTR_APPLICATION_DATA },
1303 { XML_NAMESPACE_TABLE, XML_GRAND_TOTAL, XML_TOK_DATA_PILOT_TABLE_ATTR_GRAND_TOTAL },
1304 { XML_NAMESPACE_TABLE, XML_IGNORE_EMPTY_ROWS, XML_TOK_DATA_PILOT_TABLE_ATTR_IGNORE_EMPTY_ROWS },
1305 { XML_NAMESPACE_TABLE, XML_IDENTIFY_CATEGORIES, XML_TOK_DATA_PILOT_TABLE_ATTR_IDENTIFY_CATEGORIES },
1306 { XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, XML_TOK_DATA_PILOT_TABLE_ATTR_TARGET_RANGE_ADDRESS },
1307 { XML_NAMESPACE_TABLE, XML_BUTTONS, XML_TOK_DATA_PILOT_TABLE_ATTR_BUTTONS },
1308 { XML_NAMESPACE_TABLE, XML_SHOW_FILTER_BUTTON, XML_TOK_DATA_PILOT_TABLE_ATTR_SHOW_FILTER_BUTTON },
1309 { XML_NAMESPACE_TABLE, XML_DRILL_DOWN_ON_DOUBLE_CLICK, XML_TOK_DATA_PILOT_TABLE_ATTR_DRILL_DOWN },
1310 XML_TOKEN_MAP_END
1311 };
1312
1313 pDataPilotTableAttrTokenMap = new SvXMLTokenMap( aDataPilotTableAttrTokenMap );
1314 } // if( !pDataPilotTableAttrTokenMap )
1315
1316 return *pDataPilotTableAttrTokenMap;
1317 }
1318
GetDataPilotTableElemTokenMap()1319 const SvXMLTokenMap& ScXMLImport::GetDataPilotTableElemTokenMap()
1320 {
1321 if( !pDataPilotTableElemTokenMap )
1322 {
1323 static __FAR_DATA SvXMLTokenMapEntry aDataPilotTableElemTokenMap[] =
1324 {
1325 { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_SQL, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_SQL },
1326 { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_TABLE, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_TABLE },
1327 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_GRAND_TOTAL, XML_TOK_DATA_PILOT_TABLE_ELEM_GRAND_TOTAL },
1328 { XML_NAMESPACE_TABLE_EXT, XML_DATA_PILOT_GRAND_TOTAL, XML_TOK_DATA_PILOT_TABLE_ELEM_GRAND_TOTAL_EXT },
1329 { XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_QUERY, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_QUERY },
1330 { XML_NAMESPACE_TABLE, XML_SOURCE_SERVICE, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_SERVICE },
1331 { XML_NAMESPACE_TABLE, XML_SOURCE_CELL_RANGE, XML_TOK_DATA_PILOT_TABLE_ELEM_SOURCE_CELL_RANGE },
1332 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_FIELD, XML_TOK_DATA_PILOT_TABLE_ELEM_DATA_PILOT_FIELD },
1333 XML_TOKEN_MAP_END
1334 };
1335
1336 pDataPilotTableElemTokenMap = new SvXMLTokenMap( aDataPilotTableElemTokenMap );
1337 } // if( !pDataPilotTableElemTokenMap )
1338
1339 return *pDataPilotTableElemTokenMap;
1340 }
1341
GetDataPilotTableSourceServiceAttrTokenMap()1342 const SvXMLTokenMap& ScXMLImport::GetDataPilotTableSourceServiceAttrTokenMap()
1343 {
1344 if( !pDataPilotTableSourceServiceAttrTokenMap )
1345 {
1346 static __FAR_DATA SvXMLTokenMapEntry aDataPilotTableSourceServiceAttrTokenMap[] =
1347 {
1348 { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_SOURCE_SERVICE_ATTR_NAME },
1349 { XML_NAMESPACE_TABLE, XML_SOURCE_NAME, XML_TOK_SOURCE_SERVICE_ATTR_SOURCE_NAME },
1350 { XML_NAMESPACE_TABLE, XML_OBJECT_NAME, XML_TOK_SOURCE_SERVICE_ATTR_OBJECT_NAME },
1351 { XML_NAMESPACE_TABLE, XML_USER_NAME, XML_TOK_SOURCE_SERVICE_ATTR_USER_NAME },
1352 { XML_NAMESPACE_TABLE, XML_PASSWORD, XML_TOK_SOURCE_SERVICE_ATTR_PASSWORD },
1353 XML_TOKEN_MAP_END
1354 };
1355
1356 pDataPilotTableSourceServiceAttrTokenMap = new SvXMLTokenMap( aDataPilotTableSourceServiceAttrTokenMap );
1357 } // if( !pDataPilotTableSourceServiceAttrTokenMap )
1358
1359 return *pDataPilotTableSourceServiceAttrTokenMap;
1360 }
1361
GetDataPilotGrandTotalAttrTokenMap()1362 const SvXMLTokenMap& ScXMLImport::GetDataPilotGrandTotalAttrTokenMap()
1363 {
1364 if (!pDataPilotGrandTotalAttrTokenMap)
1365 {
1366 static __FAR_DATA SvXMLTokenMapEntry aDataPilotGrandTotalAttrTokenMap[] =
1367 {
1368 { XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TOK_DATA_PILOT_GRAND_TOTAL_ATTR_DISPLAY },
1369 { XML_NAMESPACE_TABLE, XML_ORIENTATION, XML_TOK_DATA_PILOT_GRAND_TOTAL_ATTR_ORIENTATION },
1370 { XML_NAMESPACE_TABLE, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_GRAND_TOTAL_ATTR_DISPLAY_NAME },
1371 { XML_NAMESPACE_TABLE_EXT, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_GRAND_TOTAL_ATTR_DISPLAY_NAME_EXT },
1372 XML_TOKEN_MAP_END
1373 };
1374
1375 pDataPilotGrandTotalAttrTokenMap = new SvXMLTokenMap( aDataPilotGrandTotalAttrTokenMap );
1376 }
1377
1378 return *pDataPilotGrandTotalAttrTokenMap;
1379 }
1380
GetDataPilotTableSourceCellRangeAttrTokenMap()1381 const SvXMLTokenMap& ScXMLImport::GetDataPilotTableSourceCellRangeAttrTokenMap()
1382 {
1383 if( !pDataPilotTableSourceCellRangeAttrTokenMap )
1384 {
1385 static __FAR_DATA SvXMLTokenMapEntry aDataPilotTableSourceCellRangeAttrTokenMap[] =
1386 {
1387 { XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, XML_TOK_SOURCE_CELL_RANGE_ATTR_CELL_RANGE_ADDRESS},
1388 XML_TOKEN_MAP_END
1389 };
1390
1391 pDataPilotTableSourceCellRangeAttrTokenMap = new SvXMLTokenMap( aDataPilotTableSourceCellRangeAttrTokenMap );
1392 } // if( !pDataPilotTableSourceCellRangeAttrTokenMap )
1393
1394 return *pDataPilotTableSourceCellRangeAttrTokenMap;
1395 }
1396
GetDataPilotTableSourceCellRangeElemTokenMap()1397 const SvXMLTokenMap& ScXMLImport::GetDataPilotTableSourceCellRangeElemTokenMap()
1398 {
1399 if( !pDataPilotTableSourceCellRangeElemTokenMap )
1400 {
1401 static __FAR_DATA SvXMLTokenMapEntry aDataPilotTableSourceCellRangeElemTokenMap[] =
1402 {
1403 { XML_NAMESPACE_TABLE, XML_FILTER, XML_TOK_SOURCE_CELL_RANGE_ELEM_FILTER},
1404 XML_TOKEN_MAP_END
1405 };
1406
1407 pDataPilotTableSourceCellRangeElemTokenMap = new SvXMLTokenMap( aDataPilotTableSourceCellRangeElemTokenMap );
1408 } // if( !pDataPilotTableSourceCellRangeElemTokenMap )
1409
1410 return *pDataPilotTableSourceCellRangeElemTokenMap;
1411 }
1412
GetDataPilotFieldAttrTokenMap()1413 const SvXMLTokenMap& ScXMLImport::GetDataPilotFieldAttrTokenMap()
1414 {
1415 if( !pDataPilotFieldAttrTokenMap )
1416 {
1417 static __FAR_DATA SvXMLTokenMapEntry aDataPilotFieldAttrTokenMap[] =
1418 {
1419 { XML_NAMESPACE_TABLE, XML_SOURCE_FIELD_NAME, XML_TOK_DATA_PILOT_FIELD_ATTR_SOURCE_FIELD_NAME },
1420 { XML_NAMESPACE_TABLE, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_FIELD_ATTR_DISPLAY_NAME },
1421 { XML_NAMESPACE_TABLE_EXT, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_FIELD_ATTR_DISPLAY_NAME_EXT },
1422 { XML_NAMESPACE_TABLE, XML_IS_DATA_LAYOUT_FIELD, XML_TOK_DATA_PILOT_FIELD_ATTR_IS_DATA_LAYOUT_FIELD },
1423 { XML_NAMESPACE_TABLE, XML_FUNCTION, XML_TOK_DATA_PILOT_FIELD_ATTR_FUNCTION },
1424 { XML_NAMESPACE_TABLE, XML_ORIENTATION, XML_TOK_DATA_PILOT_FIELD_ATTR_ORIENTATION },
1425 { XML_NAMESPACE_TABLE, XML_SELECTED_PAGE, XML_TOK_DATA_PILOT_FIELD_ATTR_SELECTED_PAGE },
1426 { XML_NAMESPACE_TABLE, XML_USED_HIERARCHY, XML_TOK_DATA_PILOT_FIELD_ATTR_USED_HIERARCHY },
1427 XML_TOKEN_MAP_END
1428 };
1429
1430 pDataPilotFieldAttrTokenMap = new SvXMLTokenMap( aDataPilotFieldAttrTokenMap );
1431 } // if( !pDataPilotFieldAttrTokenMap )
1432
1433 return *pDataPilotFieldAttrTokenMap;
1434 }
1435
GetDataPilotFieldElemTokenMap()1436 const SvXMLTokenMap& ScXMLImport::GetDataPilotFieldElemTokenMap()
1437 {
1438 if( !pDataPilotFieldElemTokenMap )
1439 {
1440 static __FAR_DATA SvXMLTokenMapEntry aDataPilotFieldElemTokenMap[] =
1441 {
1442 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_LEVEL, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_LEVEL },
1443 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_FIELD_REFERENCE, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_REFERENCE },
1444 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_GROUPS, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_GROUPS },
1445 XML_TOKEN_MAP_END
1446 };
1447
1448 pDataPilotFieldElemTokenMap = new SvXMLTokenMap( aDataPilotFieldElemTokenMap );
1449 } // if( !pDataPilotFieldElemTokenMap )
1450
1451 return *pDataPilotFieldElemTokenMap;
1452 }
1453
GetDataPilotLevelAttrTokenMap()1454 const SvXMLTokenMap& ScXMLImport::GetDataPilotLevelAttrTokenMap()
1455 {
1456 if( !pDataPilotLevelAttrTokenMap )
1457 {
1458 static __FAR_DATA SvXMLTokenMapEntry aDataPilotLevelAttrTokenMap[] =
1459 {
1460 { XML_NAMESPACE_TABLE, XML_SHOW_EMPTY, XML_TOK_DATA_PILOT_LEVEL_ATTR_SHOW_EMPTY },
1461 XML_TOKEN_MAP_END
1462 };
1463
1464 pDataPilotLevelAttrTokenMap = new SvXMLTokenMap( aDataPilotLevelAttrTokenMap );
1465 } // if( !pDataPilotLevelAttrTokenMap )
1466
1467 return *pDataPilotLevelAttrTokenMap;
1468 }
1469
GetDataPilotLevelElemTokenMap()1470 const SvXMLTokenMap& ScXMLImport::GetDataPilotLevelElemTokenMap()
1471 {
1472 if( !pDataPilotLevelElemTokenMap )
1473 {
1474 static __FAR_DATA SvXMLTokenMapEntry aDataPilotLevelElemTokenMap[] =
1475 {
1476 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_SUBTOTALS, XML_TOK_DATA_PILOT_LEVEL_ELEM_DATA_PILOT_SUBTOTALS },
1477 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_MEMBERS, XML_TOK_DATA_PILOT_LEVEL_ELEM_DATA_PILOT_MEMBERS },
1478 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_DISPLAY_INFO, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_DISPLAY_INFO },
1479 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_SORT_INFO, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_SORT_INFO },
1480 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_LAYOUT_INFO, XML_TOK_DATA_PILOT_FIELD_ELEM_DATA_PILOT_LAYOUT_INFO },
1481 XML_TOKEN_MAP_END
1482 };
1483
1484 pDataPilotLevelElemTokenMap = new SvXMLTokenMap( aDataPilotLevelElemTokenMap );
1485 } // if( !pDataPilotLevelElemTokenMap )
1486
1487 return *pDataPilotLevelElemTokenMap;
1488 }
1489
GetDataPilotSubTotalsElemTokenMap()1490 const SvXMLTokenMap& ScXMLImport::GetDataPilotSubTotalsElemTokenMap()
1491 {
1492 if( !pDataPilotSubTotalsElemTokenMap )
1493 {
1494 static __FAR_DATA SvXMLTokenMapEntry aDataPilotSubTotalsElemTokenMap[] =
1495 {
1496 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_SUBTOTAL, XML_TOK_DATA_PILOT_SUBTOTALS_ELEM_DATA_PILOT_SUBTOTAL },
1497 XML_TOKEN_MAP_END
1498 };
1499
1500 pDataPilotSubTotalsElemTokenMap = new SvXMLTokenMap( aDataPilotSubTotalsElemTokenMap );
1501 } // if( !pDataPilotSubTotalsElemTokenMap )
1502
1503 return *pDataPilotSubTotalsElemTokenMap;
1504 }
1505
GetDataPilotSubTotalAttrTokenMap()1506 const SvXMLTokenMap& ScXMLImport::GetDataPilotSubTotalAttrTokenMap()
1507 {
1508 if( !pDataPilotSubTotalAttrTokenMap )
1509 {
1510 static __FAR_DATA SvXMLTokenMapEntry aDataPilotSubTotalAttrTokenMap[] =
1511 {
1512 { XML_NAMESPACE_TABLE, XML_FUNCTION, XML_TOK_DATA_PILOT_SUBTOTAL_ATTR_FUNCTION },
1513 { XML_NAMESPACE_TABLE, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_SUBTOTAL_ATTR_DISPLAY_NAME },
1514 { XML_NAMESPACE_TABLE_EXT, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_SUBTOTAL_ATTR_DISPLAY_NAME_EXT },
1515 XML_TOKEN_MAP_END
1516 };
1517
1518 pDataPilotSubTotalAttrTokenMap = new SvXMLTokenMap( aDataPilotSubTotalAttrTokenMap );
1519 } // if( !pDataPilotSubTotalAttrTokenMap )
1520
1521 return *pDataPilotSubTotalAttrTokenMap;
1522 }
1523
GetDataPilotMembersElemTokenMap()1524 const SvXMLTokenMap& ScXMLImport::GetDataPilotMembersElemTokenMap()
1525 {
1526 if( !pDataPilotMembersElemTokenMap )
1527 {
1528 static __FAR_DATA SvXMLTokenMapEntry aDataPilotMembersElemTokenMap[] =
1529 {
1530 { XML_NAMESPACE_TABLE, XML_DATA_PILOT_MEMBER, XML_TOK_DATA_PILOT_MEMBERS_ELEM_DATA_PILOT_MEMBER },
1531 XML_TOKEN_MAP_END
1532 };
1533
1534 pDataPilotMembersElemTokenMap = new SvXMLTokenMap( aDataPilotMembersElemTokenMap );
1535 } // if( !pDataPilotMembersElemTokenMap )
1536
1537 return *pDataPilotMembersElemTokenMap;
1538 }
1539
GetDataPilotMemberAttrTokenMap()1540 const SvXMLTokenMap& ScXMLImport::GetDataPilotMemberAttrTokenMap()
1541 {
1542 if( !pDataPilotMemberAttrTokenMap )
1543 {
1544 static __FAR_DATA SvXMLTokenMapEntry aDataPilotMemberAttrTokenMap[] =
1545 {
1546 { XML_NAMESPACE_TABLE, XML_NAME, XML_TOK_DATA_PILOT_MEMBER_ATTR_NAME },
1547 { XML_NAMESPACE_TABLE, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_MEMBER_ATTR_DISPLAY_NAME },
1548 { XML_NAMESPACE_TABLE_EXT, XML_DISPLAY_NAME, XML_TOK_DATA_PILOT_MEMBER_ATTR_DISPLAY_NAME_EXT },
1549 { XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TOK_DATA_PILOT_MEMBER_ATTR_DISPLAY },
1550 { XML_NAMESPACE_TABLE, XML_SHOW_DETAILS, XML_TOK_DATA_PILOT_MEMBER_ATTR_SHOW_DETAILS },
1551 XML_TOKEN_MAP_END
1552 };
1553
1554 pDataPilotMemberAttrTokenMap = new SvXMLTokenMap( aDataPilotMemberAttrTokenMap );
1555 } // if( !pDataPilotMemberAttrTokenMap )
1556
1557 return *pDataPilotMemberAttrTokenMap;
1558 }
1559
GetConsolidationAttrTokenMap()1560 const SvXMLTokenMap& ScXMLImport::GetConsolidationAttrTokenMap()
1561 {
1562 if( !pConsolidationAttrTokenMap )
1563 {
1564 static __FAR_DATA SvXMLTokenMapEntry aConsolidationAttrTokenMap[] =
1565 {
1566 { XML_NAMESPACE_TABLE, XML_FUNCTION, XML_TOK_CONSOLIDATION_ATTR_FUNCTION },
1567 { XML_NAMESPACE_TABLE, XML_SOURCE_CELL_RANGE_ADDRESSES, XML_TOK_CONSOLIDATION_ATTR_SOURCE_RANGES },
1568 { XML_NAMESPACE_TABLE, XML_TARGET_CELL_ADDRESS, XML_TOK_CONSOLIDATION_ATTR_TARGET_ADDRESS },
1569 { XML_NAMESPACE_TABLE, XML_USE_LABEL, XML_TOK_CONSOLIDATION_ATTR_USE_LABEL },
1570 { XML_NAMESPACE_TABLE, XML_LINK_TO_SOURCE_DATA, XML_TOK_CONSOLIDATION_ATTR_LINK_TO_SOURCE },
1571 XML_TOKEN_MAP_END
1572 };
1573
1574 pConsolidationAttrTokenMap = new SvXMLTokenMap( aConsolidationAttrTokenMap );
1575 } // if( !pConsolidationAttrTokenMap )
1576
1577 return *pConsolidationAttrTokenMap;
1578 }
1579
1580
CreateContext(sal_uInt16 nPrefix,const OUString & rLocalName,const uno::Reference<xml::sax::XAttributeList> & xAttrList)1581 SvXMLImportContext *ScXMLImport::CreateContext( sal_uInt16 nPrefix,
1582 const OUString& rLocalName,
1583 const uno::Reference<xml::sax::XAttributeList>& xAttrList )
1584 {
1585 SvXMLImportContext *pContext = 0;
1586
1587 if( (XML_NAMESPACE_OFFICE == nPrefix) &&
1588 ( IsXMLToken(rLocalName, XML_DOCUMENT_STYLES) ||
1589 IsXMLToken(rLocalName, XML_DOCUMENT_CONTENT) ||
1590 IsXMLToken(rLocalName, XML_DOCUMENT_SETTINGS) )) {
1591 pContext = new ScXMLDocContext_Impl( *this, nPrefix, rLocalName,
1592 xAttrList );
1593 } else if ( (XML_NAMESPACE_OFFICE == nPrefix) &&
1594 ( IsXMLToken(rLocalName, XML_DOCUMENT_META)) ) {
1595 pContext = CreateMetaContext(rLocalName);
1596 } else if ( (XML_NAMESPACE_OFFICE == nPrefix) &&
1597 ( IsXMLToken(rLocalName, XML_DOCUMENT)) ) {
1598 uno::Reference<xml::sax::XDocumentHandler> xDocBuilder(
1599 mxServiceFactory->createInstance(::rtl::OUString::createFromAscii(
1600 "com.sun.star.xml.dom.SAXDocumentBuilder")),
1601 uno::UNO_QUERY_THROW);
1602 uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
1603 GetModel(), uno::UNO_QUERY_THROW);
1604 // flat OpenDocument file format
1605 pContext = new ScXMLFlatDocContext_Impl( *this, nPrefix, rLocalName,
1606 xAttrList, xDPS->getDocumentProperties(), xDocBuilder);
1607 }
1608 else
1609 pContext = SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList );
1610
1611 return pContext;
1612 }
1613
1614 // #110680#
ScXMLImport(const::com::sun::star::uno::Reference<::com::sun::star::lang::XMultiServiceFactory> xServiceFactory,const sal_uInt16 nImportFlag)1615 ScXMLImport::ScXMLImport(
1616 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceFactory,
1617 const sal_uInt16 nImportFlag)
1618 : SvXMLImport( xServiceFactory, nImportFlag ),
1619 pDoc( NULL ),
1620 pChangeTrackingImportHelper(NULL),
1621 pStylesImportHelper(NULL),
1622 sNumberFormat(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_NUMFMT)),
1623 sLocale(RTL_CONSTASCII_USTRINGPARAM(SC_LOCALE)),
1624 sCellStyle(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_CELLSTYL)),
1625 sStandardFormat(RTL_CONSTASCII_USTRINGPARAM(SC_STANDARDFORMAT)),
1626 sType(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_TYPE)),
1627 // pScAutoStylePool(new SvXMLAutoStylePoolP),
1628 // pParaItemMapper( 0 ),
1629 // pI18NMap( new SvI18NMap ),
1630 pDocElemTokenMap( 0 ),
1631 pStylesElemTokenMap( 0 ),
1632 pStylesAttrTokenMap( 0 ),
1633 pStyleElemTokenMap( 0 ),
1634 pBodyElemTokenMap( 0 ),
1635 pContentValidationsElemTokenMap( 0 ),
1636 pContentValidationElemTokenMap( 0 ),
1637 pContentValidationAttrTokenMap( 0 ),
1638 pContentValidationMessageElemTokenMap( 0 ),
1639 pContentValidationHelpMessageAttrTokenMap( 0 ),
1640 pContentValidationErrorMessageAttrTokenMap( 0 ),
1641 pContentValidationErrorMacroAttrTokenMap( 0 ),
1642 pLabelRangesElemTokenMap( 0 ),
1643 pLabelRangeAttrTokenMap( 0 ),
1644 pTableElemTokenMap( 0 ),
1645 pTableRowsElemTokenMap( 0 ),
1646 pTableColsElemTokenMap( 0 ),
1647 pTableScenarioAttrTokenMap( 0 ),
1648 pTableAttrTokenMap( 0 ),
1649 pTableColAttrTokenMap( 0 ),
1650 pTableRowElemTokenMap( 0 ),
1651 pTableRowAttrTokenMap( 0 ),
1652 pTableRowCellElemTokenMap( 0 ),
1653 pTableRowCellAttrTokenMap( 0 ),
1654 pTableAnnotationAttrTokenMap( 0 ),
1655 pDetectiveElemTokenMap( 0 ),
1656 pDetectiveHighlightedAttrTokenMap( 0 ),
1657 pDetectiveOperationAttrTokenMap( 0 ),
1658 pTableCellRangeSourceAttrTokenMap( 0 ),
1659 pNamedExpressionsElemTokenMap( 0 ),
1660 pNamedRangeAttrTokenMap( 0 ),
1661 pNamedExpressionAttrTokenMap( 0 ),
1662 pDatabaseRangesElemTokenMap( 0 ),
1663 pDatabaseRangeElemTokenMap( 0 ),
1664 pDatabaseRangeAttrTokenMap( 0 ),
1665 pDatabaseRangeSourceSQLAttrTokenMap( 0 ),
1666 pDatabaseRangeSourceTableAttrTokenMap( 0 ),
1667 pDatabaseRangeSourceQueryAttrTokenMap( 0 ),
1668 pFilterElemTokenMap( 0 ),
1669 pFilterAttrTokenMap( 0 ),
1670 pFilterConditionAttrTokenMap( 0 ),
1671 pSortElemTokenMap( 0 ),
1672 pSortAttrTokenMap( 0 ),
1673 pSortSortByAttrTokenMap( 0 ),
1674 pDatabaseRangeSubTotalRulesElemTokenMap( 0 ),
1675 pDatabaseRangeSubTotalRulesAttrTokenMap( 0 ),
1676 pSubTotalRulesSortGroupsAttrTokenMap( 0 ),
1677 pSubTotalRulesSubTotalRuleElemTokenMap( 0 ),
1678 pSubTotalRulesSubTotalRuleAttrTokenMap( 0 ),
1679 pSubTotalRuleSubTotalFieldAttrTokenMap( 0 ),
1680 pDataPilotTablesElemTokenMap( 0 ),
1681 pDataPilotTableAttrTokenMap( 0 ),
1682 pDataPilotTableElemTokenMap( 0 ),
1683 pDataPilotTableSourceServiceAttrTokenMap( 0 ),
1684 pDataPilotGrandTotalAttrTokenMap(NULL),
1685 pDataPilotTableSourceCellRangeElemTokenMap( 0 ),
1686 pDataPilotTableSourceCellRangeAttrTokenMap( 0 ),
1687 pDataPilotFieldAttrTokenMap( 0 ),
1688 pDataPilotFieldElemTokenMap( 0 ),
1689 pDataPilotLevelAttrTokenMap( 0 ),
1690 pDataPilotLevelElemTokenMap( 0 ),
1691 pDataPilotSubTotalsElemTokenMap( 0 ),
1692 pDataPilotSubTotalAttrTokenMap( 0 ),
1693 pDataPilotMembersElemTokenMap( 0 ),
1694 pDataPilotMemberAttrTokenMap( 0 ),
1695 pConsolidationAttrTokenMap( 0 ),
1696 aTables(*this),
1697 pMyNamedExpressions(NULL),
1698 pMyLabelRanges(NULL),
1699 pValidations(NULL),
1700 pDetectiveOpArray(NULL),
1701 pScUnoGuard(NULL),
1702 pNumberFormatAttributesExportHelper(NULL),
1703 pStyleNumberFormats(NULL),
1704 sPrevStyleName(),
1705 sPrevCurrency(),
1706 nSolarMutexLocked(0),
1707 nProgressCount(0),
1708 nStyleFamilyMask( 0 ),
1709 nPrevCellType(0),
1710 bLoadDoc( sal_True ),
1711 bRemoveLastChar(sal_False),
1712 bNullDateSetted(sal_False),
1713 bSelfImportingXMLSet(sal_False),
1714 bLatinDefaultStyle(sal_False),
1715 bFromWrapper(sal_False)
1716 {
1717 pStylesImportHelper = new ScMyStylesImportHelper(*this);
1718
1719 xScPropHdlFactory = new XMLScPropHdlFactory;
1720 xCellStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScCellStylesProperties, xScPropHdlFactory);
1721 xColumnStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScColumnStylesProperties, xScPropHdlFactory);
1722 xRowStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScRowStylesImportProperties, xScPropHdlFactory);
1723 xTableStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScTableStylesImportProperties, xScPropHdlFactory);
1724
1725 // #i66550# needed for 'presentation:event-listener' element for URLs in shapes
1726 GetNamespaceMap().Add(
1727 GetXMLToken( XML_NP_PRESENTATION ),
1728 GetXMLToken( XML_N_PRESENTATION ),
1729 XML_NAMESPACE_PRESENTATION );
1730
1731 // initialize cell type map.
1732 const struct { XMLTokenEnum _token; sal_Int16 _type; } aCellTypePairs[] =
1733 {
1734 { XML_FLOAT, util::NumberFormat::NUMBER },
1735 { XML_STRING, util::NumberFormat::TEXT },
1736 { XML_TIME, util::NumberFormat::TIME },
1737 { XML_DATE, util::NumberFormat::DATETIME },
1738 { XML_PERCENTAGE, util::NumberFormat::PERCENT },
1739 { XML_CURRENCY, util::NumberFormat::CURRENCY },
1740 { XML_BOOLEAN, util::NumberFormat::LOGICAL }
1741 };
1742 size_t n = sizeof(aCellTypePairs)/sizeof(aCellTypePairs[0]);
1743 for (size_t i = 0; i < n; ++i)
1744 {
1745 aCellTypeMap.insert(
1746 CellTypeMap::value_type(
1747 GetXMLToken(aCellTypePairs[i]._token), aCellTypePairs[i]._type));
1748 }
1749 }
1750
~ScXMLImport()1751 ScXMLImport::~ScXMLImport() throw()
1752 {
1753 // delete pI18NMap;
1754 delete pDocElemTokenMap;
1755 delete pStylesElemTokenMap;
1756 delete pStylesAttrTokenMap;
1757 delete pStyleElemTokenMap;
1758 delete pBodyElemTokenMap;
1759 delete pContentValidationsElemTokenMap;
1760 delete pContentValidationElemTokenMap;
1761 delete pContentValidationAttrTokenMap;
1762 delete pContentValidationMessageElemTokenMap;
1763 delete pContentValidationHelpMessageAttrTokenMap;
1764 delete pContentValidationErrorMessageAttrTokenMap;
1765 delete pContentValidationErrorMacroAttrTokenMap;
1766 delete pLabelRangesElemTokenMap;
1767 delete pLabelRangeAttrTokenMap;
1768 delete pTableElemTokenMap;
1769 delete pTableRowsElemTokenMap;
1770 delete pTableColsElemTokenMap;
1771 delete pTableAttrTokenMap;
1772 delete pTableScenarioAttrTokenMap;
1773 delete pTableColAttrTokenMap;
1774 delete pTableRowElemTokenMap;
1775 delete pTableRowAttrTokenMap;
1776 delete pTableRowCellElemTokenMap;
1777 delete pTableRowCellAttrTokenMap;
1778 delete pTableAnnotationAttrTokenMap;
1779 delete pDetectiveElemTokenMap;
1780 delete pDetectiveHighlightedAttrTokenMap;
1781 delete pDetectiveOperationAttrTokenMap;
1782 delete pTableCellRangeSourceAttrTokenMap;
1783 delete pNamedExpressionsElemTokenMap;
1784 delete pNamedRangeAttrTokenMap;
1785 delete pNamedExpressionAttrTokenMap;
1786 delete pDatabaseRangesElemTokenMap;
1787 delete pDatabaseRangeElemTokenMap;
1788 delete pDatabaseRangeAttrTokenMap;
1789 delete pDatabaseRangeSourceSQLAttrTokenMap;
1790 delete pDatabaseRangeSourceTableAttrTokenMap;
1791 delete pDatabaseRangeSourceQueryAttrTokenMap;
1792 delete pFilterElemTokenMap;
1793 delete pFilterAttrTokenMap;
1794 delete pFilterConditionAttrTokenMap;
1795 delete pSortElemTokenMap;
1796 delete pSortAttrTokenMap;
1797 delete pSortSortByAttrTokenMap;
1798 delete pDatabaseRangeSubTotalRulesElemTokenMap;
1799 delete pDatabaseRangeSubTotalRulesAttrTokenMap;
1800 delete pSubTotalRulesSortGroupsAttrTokenMap;
1801 delete pSubTotalRulesSubTotalRuleElemTokenMap;
1802 delete pSubTotalRulesSubTotalRuleAttrTokenMap;
1803 delete pSubTotalRuleSubTotalFieldAttrTokenMap;
1804 delete pDataPilotTablesElemTokenMap;
1805 delete pDataPilotTableAttrTokenMap;
1806 delete pDataPilotTableElemTokenMap;
1807 delete pDataPilotTableSourceServiceAttrTokenMap;
1808 delete pDataPilotTableSourceCellRangeAttrTokenMap;
1809 delete pDataPilotTableSourceCellRangeElemTokenMap;
1810 delete pDataPilotFieldAttrTokenMap;
1811 delete pDataPilotFieldElemTokenMap;
1812 delete pDataPilotLevelAttrTokenMap;
1813 delete pDataPilotLevelElemTokenMap;
1814 delete pDataPilotSubTotalsElemTokenMap;
1815 delete pDataPilotSubTotalAttrTokenMap;
1816 delete pDataPilotMembersElemTokenMap;
1817 delete pDataPilotMemberAttrTokenMap;
1818 delete pConsolidationAttrTokenMap;
1819
1820 // if (pScAutoStylePool)
1821 // delete pScAutoStylePool;
1822 if (pChangeTrackingImportHelper)
1823 delete pChangeTrackingImportHelper;
1824 if (pNumberFormatAttributesExportHelper)
1825 delete pNumberFormatAttributesExportHelper;
1826 if (pStyleNumberFormats)
1827 delete pStyleNumberFormats;
1828 if (pStylesImportHelper)
1829 delete pStylesImportHelper;
1830
1831 if (pScUnoGuard)
1832 delete pScUnoGuard;
1833
1834 if (pMyNamedExpressions)
1835 delete pMyNamedExpressions;
1836 if (pMyLabelRanges)
1837 delete pMyLabelRanges;
1838 if (pValidations)
1839 delete pValidations;
1840 if (pDetectiveOpArray)
1841 delete pDetectiveOpArray;
1842 }
1843
1844 // ---------------------------------------------------------------------
1845
CreateFontDeclsContext(const sal_uInt16 nPrefix,const::rtl::OUString & rLocalName,const uno::Reference<xml::sax::XAttributeList> & xAttrList)1846 SvXMLImportContext *ScXMLImport::CreateFontDeclsContext(const sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName,
1847 const uno::Reference<xml::sax::XAttributeList>& xAttrList)
1848 {
1849 SvXMLImportContext *pContext = NULL;
1850 if (!pContext)
1851 {
1852 XMLFontStylesContext *pFSContext(
1853 new XMLFontStylesContext( *this, nPrefix,
1854 rLocalName, xAttrList,
1855 gsl_getSystemTextEncoding() ));
1856 SetFontDecls( pFSContext );
1857 pContext = pFSContext;
1858 }
1859 return pContext;
1860 }
1861
CreateStylesContext(const::rtl::OUString & rLocalName,const uno::Reference<xml::sax::XAttributeList> & xAttrList,sal_Bool bIsAutoStyle)1862 SvXMLImportContext *ScXMLImport::CreateStylesContext(const ::rtl::OUString& rLocalName,
1863 const uno::Reference<xml::sax::XAttributeList>& xAttrList, sal_Bool bIsAutoStyle )
1864 {
1865 SvXMLImportContext *pContext(NULL);
1866 if (!pContext)
1867 {
1868 pContext = new XMLTableStylesContext(*this, XML_NAMESPACE_OFFICE, rLocalName, xAttrList, bIsAutoStyle);
1869 if (bIsAutoStyle)
1870 //xAutoStyles = pContext;
1871 SetAutoStyles((SvXMLStylesContext*)pContext);
1872 else
1873 //xStyles = pContext;
1874 SetStyles((SvXMLStylesContext*)pContext);
1875 }
1876 return pContext;
1877 }
1878
CreateBodyContext(const::rtl::OUString & rLocalName,const uno::Reference<xml::sax::XAttributeList> & xAttrList)1879 SvXMLImportContext *ScXMLImport::CreateBodyContext(const ::rtl::OUString& rLocalName,
1880 const uno::Reference<xml::sax::XAttributeList>& xAttrList)
1881 {
1882 //GetShapeImport()->SetAutoStylesContext((XMLTableStylesContext *)&xAutoStyles);
1883 //GetChartImport()->SetAutoStylesContext(GetAutoStyles()/*(XMLTableStylesContext *)&xAutoStyles*/);
1884
1885 return new ScXMLBodyContext(*this, XML_NAMESPACE_OFFICE, rLocalName, xAttrList);
1886 }
1887
CreateMetaContext(const OUString & rLocalName)1888 SvXMLImportContext *ScXMLImport::CreateMetaContext(
1889 const OUString& rLocalName )
1890 {
1891 SvXMLImportContext *pContext(0);
1892
1893 if (getImportFlags() & IMPORT_META)
1894 {
1895 uno::Reference<xml::sax::XDocumentHandler> xDocBuilder(
1896 mxServiceFactory->createInstance(::rtl::OUString::createFromAscii(
1897 "com.sun.star.xml.dom.SAXDocumentBuilder")),
1898 uno::UNO_QUERY_THROW);
1899 uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
1900 GetModel(), uno::UNO_QUERY_THROW);
1901 uno::Reference<document::XDocumentProperties> const xDocProps(
1902 (IsStylesOnlyMode()) ? 0 : xDPS->getDocumentProperties());
1903 pContext = new SvXMLMetaDocumentContext(*this,
1904 XML_NAMESPACE_OFFICE, rLocalName,
1905 xDocProps, xDocBuilder);
1906 }
1907
1908 if( !pContext )
1909 pContext = new SvXMLImportContext( *this,
1910 XML_NAMESPACE_OFFICE, rLocalName );
1911
1912 return pContext;
1913 }
1914
CreateScriptContext(const OUString & rLocalName)1915 SvXMLImportContext *ScXMLImport::CreateScriptContext(
1916 const OUString& rLocalName )
1917 {
1918 SvXMLImportContext *pContext(0);
1919
1920 if( !(IsStylesOnlyMode()) )
1921 {
1922 pContext = new XMLScriptContext( *this,
1923 XML_NAMESPACE_OFFICE, rLocalName,
1924 GetModel() );
1925 }
1926
1927 if( !pContext )
1928 pContext = new SvXMLImportContext( *this, XML_NAMESPACE_OFFICE,
1929 rLocalName );
1930
1931 return pContext;
1932 }
1933
SetStatistics(const uno::Sequence<beans::NamedValue> & i_rStats)1934 void ScXMLImport::SetStatistics(
1935 const uno::Sequence<beans::NamedValue> & i_rStats)
1936 {
1937 static const char* s_stats[] =
1938 { "TableCount", "CellCount", "ObjectCount", 0 };
1939
1940 SvXMLImport::SetStatistics(i_rStats);
1941
1942 sal_uInt32 nCount(0);
1943 for (sal_Int32 i = 0; i < i_rStats.getLength(); ++i) {
1944 for (const char** pStat = s_stats; *pStat != 0; ++pStat) {
1945 if (i_rStats[i].Name.equalsAscii(*pStat)) {
1946 sal_Int32 val = 0;
1947 if (i_rStats[i].Value >>= val) {
1948 nCount += val;
1949 } else {
1950 DBG_ERROR("ScXMLImport::SetStatistics: invalid entry");
1951 }
1952 }
1953 }
1954 }
1955
1956 if (nCount)
1957 {
1958 GetProgressBarHelper()->SetReference(nCount);
1959 GetProgressBarHelper()->SetValue(0);
1960 }
1961 }
1962
GetCellType(const OUString & rStrValue) const1963 sal_Int16 ScXMLImport::GetCellType(const OUString& rStrValue) const
1964 {
1965 CellTypeMap::const_iterator itr = aCellTypeMap.find(rStrValue);
1966 if (itr != aCellTypeMap.end())
1967 return itr->second;
1968
1969 return util::NumberFormat::UNDEFINED;
1970 }
1971
CreateShapeImport()1972 XMLShapeImportHelper* ScXMLImport::CreateShapeImport()
1973 {
1974 /*UniReference < XMLPropertySetMapper > xShapeStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScShapeStylesProperties, xScPropHdlFactory);
1975 SvXMLImportPropertyMapper *pShapeStylesImportPropertySetMapper = new SvXMLImportPropertyMapper( xShapeStylesPropertySetMapper );*/
1976
1977 return new XMLTableShapeImportHelper( *this/*, pShapeStylesImportPropertySetMapper*/ );
1978 }
1979
GetValidation(const rtl::OUString & sName,ScMyImportValidation & aValidation)1980 sal_Bool ScXMLImport::GetValidation(const rtl::OUString& sName, ScMyImportValidation& aValidation)
1981 {
1982 if (pValidations)
1983 {
1984 sal_Bool bFound(sal_False);
1985 ScMyImportValidations::iterator aItr(pValidations->begin());
1986 ScMyImportValidations::iterator aEndItr(pValidations->end());
1987 while(aItr != aEndItr && !bFound)
1988 {
1989 if (aItr->sName == sName)
1990 {
1991 // #b4974740# source position must be set as string,
1992 // so sBaseCellAddress no longer has to be converted here
1993
1994 bFound = sal_True;
1995 }
1996 else
1997 ++aItr;
1998 }
1999 if (bFound)
2000 aValidation = *aItr;
2001 return bFound;
2002 }
2003 return sal_False;
2004 }
2005
GetChangeTrackingImportHelper()2006 ScXMLChangeTrackingImportHelper* ScXMLImport::GetChangeTrackingImportHelper()
2007 {
2008 if (!pChangeTrackingImportHelper)
2009 pChangeTrackingImportHelper = new ScXMLChangeTrackingImportHelper();
2010 return pChangeTrackingImportHelper;
2011 }
2012
InsertStyles()2013 void ScXMLImport::InsertStyles()
2014 {
2015 GetStyles()->CopyStylesToDoc(sal_True);
2016
2017 // if content is going to be loaded with the same import, set bLatinDefaultStyle flag now
2018 if ( getImportFlags() & IMPORT_CONTENT )
2019 ExamineDefaultStyle();
2020 }
2021
ExamineDefaultStyle()2022 void ScXMLImport::ExamineDefaultStyle()
2023 {
2024 if (pDoc)
2025 {
2026 // #i62435# after inserting the styles, check if the default style has a latin-script-only
2027 // number format (then, value cells can be pre-initialized with western script type)
2028
2029 const ScPatternAttr* pDefPattern = pDoc->GetDefPattern();
2030 SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2031 if ( pFormatter && pDefPattern )
2032 {
2033 sal_uInt32 nKey = pDefPattern->GetNumberFormat(pFormatter);
2034 const SvNumberformat* pFormat = pFormatter->GetEntry(nKey);
2035 if ( pFormat && pFormat->IsStandard() )
2036 {
2037 // The standard format is all-latin if the decimal separator doesn't
2038 // have a different script type
2039
2040 String aDecSep;
2041 LanguageType nFormatLang = pFormat->GetLanguage();
2042 if ( nFormatLang == LANGUAGE_SYSTEM )
2043 aDecSep = ScGlobal::pLocaleData->getNumDecimalSep();
2044 else
2045 {
2046 LocaleDataWrapper aLocaleData( pDoc->GetServiceManager(),
2047 MsLangId::convertLanguageToLocale( nFormatLang ) );
2048 aDecSep = aLocaleData.getNumDecimalSep();
2049 }
2050
2051 sal_uInt8 nScript = pDoc->GetStringScriptType( aDecSep );
2052 if ( nScript == 0 || nScript == SCRIPTTYPE_LATIN )
2053 bLatinDefaultStyle = sal_True;
2054 }
2055 }
2056 }
2057 }
2058
SetChangeTrackingViewSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue> & rChangeProps)2059 void ScXMLImport::SetChangeTrackingViewSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue>& rChangeProps)
2060 {
2061 if (pDoc)
2062 {
2063 sal_Int32 nCount(rChangeProps.getLength());
2064 if (nCount)
2065 {
2066 LockSolarMutex();
2067 sal_Int16 nTemp16(0);
2068 ScChangeViewSettings* pViewSettings(new ScChangeViewSettings());
2069 for (sal_Int32 i = 0; i < nCount; ++i)
2070 {
2071 rtl::OUString sName(rChangeProps[i].Name);
2072 if (sName.compareToAscii("ShowChanges") == 0)
2073 pViewSettings->SetShowChanges(::cppu::any2bool(rChangeProps[i].Value));
2074 else if (sName.compareToAscii("ShowAcceptedChanges") == 0)
2075 pViewSettings->SetShowAccepted(::cppu::any2bool(rChangeProps[i].Value));
2076 else if (sName.compareToAscii("ShowRejectedChanges") == 0)
2077 pViewSettings->SetShowRejected(::cppu::any2bool(rChangeProps[i].Value));
2078 else if (sName.compareToAscii("ShowChangesByDatetime") == 0)
2079 pViewSettings->SetHasDate(::cppu::any2bool(rChangeProps[i].Value));
2080 else if (sName.compareToAscii("ShowChangesByDatetimeMode") == 0)
2081 {
2082 if (rChangeProps[i].Value >>= nTemp16)
2083 pViewSettings->SetTheDateMode(ScChgsDateMode(nTemp16));
2084 }
2085 else if (sName.compareToAscii("ShowChangesByDatetimeFirstDatetime") == 0)
2086 {
2087 util::DateTime aDateTime;
2088 if (rChangeProps[i].Value >>= aDateTime)
2089 {
2090 DateTime aCoreDateTime;
2091 ScXMLConverter::ConvertAPIToCoreDateTime(aDateTime, aCoreDateTime);
2092 pViewSettings->SetTheFirstDateTime(aCoreDateTime);
2093 }
2094 }
2095 else if (sName.compareToAscii("ShowChangesByDatetimeSecondDatetime") == 0)
2096 {
2097 util::DateTime aDateTime;
2098 if (rChangeProps[i].Value >>= aDateTime)
2099 {
2100 DateTime aCoreDateTime;
2101 ScXMLConverter::ConvertAPIToCoreDateTime(aDateTime, aCoreDateTime);
2102 pViewSettings->SetTheLastDateTime(aCoreDateTime);
2103 }
2104 }
2105 else if (sName.compareToAscii("ShowChangesByAuthor") == 0)
2106 pViewSettings->SetHasAuthor(::cppu::any2bool(rChangeProps[i].Value));
2107 else if (sName.compareToAscii("ShowChangesByAuthorName") == 0)
2108 {
2109 rtl::OUString sOUName;
2110 if (rChangeProps[i].Value >>= sOUName)
2111 {
2112 String sAuthorName(sOUName);
2113 pViewSettings->SetTheAuthorToShow(sAuthorName);
2114 }
2115 }
2116 else if (sName.compareToAscii("ShowChangesByComment") == 0)
2117 pViewSettings->SetHasComment(::cppu::any2bool(rChangeProps[i].Value));
2118 else if (sName.compareToAscii("ShowChangesByCommentText") == 0)
2119 {
2120 rtl::OUString sOUComment;
2121 if (rChangeProps[i].Value >>= sOUComment)
2122 {
2123 String sComment(sOUComment);
2124 pViewSettings->SetTheComment(sComment);
2125 }
2126 }
2127 else if (sName.compareToAscii("ShowChangesByRanges") == 0)
2128 pViewSettings->SetHasRange(::cppu::any2bool(rChangeProps[i].Value));
2129 else if (sName.compareToAscii("ShowChangesByRangesList") == 0)
2130 {
2131 rtl::OUString sRanges;
2132 if ((rChangeProps[i].Value >>= sRanges) && sRanges.getLength())
2133 {
2134 ScRangeList aRangeList;
2135 ScRangeStringConverter::GetRangeListFromString(
2136 aRangeList, sRanges, GetDocument(), FormulaGrammar::CONV_OOO);
2137 pViewSettings->SetTheRangeList(aRangeList);
2138 }
2139 }
2140 }
2141 pDoc->SetChangeViewSettings(*pViewSettings);
2142 UnlockSolarMutex();
2143 }
2144 }
2145 }
2146
SetViewSettings(const uno::Sequence<beans::PropertyValue> & aViewProps)2147 void ScXMLImport::SetViewSettings(const uno::Sequence<beans::PropertyValue>& aViewProps)
2148 {
2149 sal_Int32 nCount(aViewProps.getLength());
2150 sal_Int32 nHeight(0);
2151 sal_Int32 nLeft(0);
2152 sal_Int32 nTop(0);
2153 sal_Int32 nWidth(0);
2154 for (sal_Int32 i = 0; i < nCount; ++i)
2155 {
2156 rtl::OUString sName(aViewProps[i].Name);
2157 if (sName.compareToAscii("VisibleAreaHeight") == 0)
2158 aViewProps[i].Value >>= nHeight;
2159 else if (sName.compareToAscii("VisibleAreaLeft") == 0)
2160 aViewProps[i].Value >>= nLeft;
2161 else if (sName.compareToAscii("VisibleAreaTop") == 0)
2162 aViewProps[i].Value >>= nTop;
2163 else if (sName.compareToAscii("VisibleAreaWidth") == 0)
2164 aViewProps[i].Value >>= nWidth;
2165 else if (sName.compareToAscii("TrackedChangesViewSettings") == 0)
2166 {
2167 uno::Sequence<beans::PropertyValue> aChangeProps;
2168 if(aViewProps[i].Value >>= aChangeProps)
2169 SetChangeTrackingViewSettings(aChangeProps);
2170 }
2171 }
2172 if (nHeight && nWidth)
2173 {
2174 if (GetModel().is())
2175 {
2176 ScModelObj* pDocObj(ScModelObj::getImplementation( GetModel() ));
2177 if (pDocObj)
2178 {
2179 SfxObjectShell* pEmbeddedObj = pDocObj->GetEmbeddedObject();
2180 if (pEmbeddedObj)
2181 {
2182 Rectangle aRect;
2183 aRect.setX( nLeft );
2184 aRect.setY( nTop );
2185 aRect.setWidth( nWidth );
2186 aRect.setHeight( nHeight );
2187 pEmbeddedObj->SetVisArea(aRect);
2188 }
2189 }
2190 }
2191 }
2192 }
2193
SetConfigurationSettings(const uno::Sequence<beans::PropertyValue> & aConfigProps)2194 void ScXMLImport::SetConfigurationSettings(const uno::Sequence<beans::PropertyValue>& aConfigProps)
2195 {
2196 if (GetModel().is())
2197 {
2198 uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
2199 if (xMultiServiceFactory.is())
2200 {
2201 sal_Int32 nCount(aConfigProps.getLength());
2202 rtl::OUString sCTName(RTL_CONSTASCII_USTRINGPARAM("TrackedChangesProtectionKey"));
2203 rtl::OUString sVBName(RTL_CONSTASCII_USTRINGPARAM("VBACompatibilityMode"));
2204 rtl::OUString sSCName(RTL_CONSTASCII_USTRINGPARAM("ScriptConfiguration"));
2205 for (sal_Int32 i = nCount - 1; i >= 0; --i)
2206 {
2207 if (aConfigProps[i].Name == sCTName)
2208 {
2209 rtl::OUString sKey;
2210 if (aConfigProps[i].Value >>= sKey)
2211 {
2212 uno::Sequence<sal_Int8> aPass;
2213 SvXMLUnitConverter::decodeBase64(aPass, sKey);
2214 if (aPass.getLength())
2215 {
2216 if (pDoc->GetChangeTrack())
2217 pDoc->GetChangeTrack()->SetProtection(aPass);
2218 else
2219 {
2220 ScStrCollection aUsers;
2221 ScChangeTrack* pTrack = new ScChangeTrack(pDoc, aUsers);
2222 pTrack->SetProtection(aPass);
2223 pDoc->SetChangeTrack(pTrack);
2224 }
2225 }
2226 }
2227 }
2228 // store the following items for later use (after document is loaded)
2229 else if ((aConfigProps[i].Name == sVBName) || (aConfigProps[i].Name == sSCName))
2230 {
2231 uno::Reference< beans::XPropertySet > xImportInfo = getImportInfo();
2232 if (xImportInfo.is())
2233 {
2234 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = xImportInfo->getPropertySetInfo();
2235 if (xPropertySetInfo.is() && xPropertySetInfo->hasPropertyByName(aConfigProps[i].Name))
2236 xImportInfo->setPropertyValue( aConfigProps[i].Name, aConfigProps[i].Value );
2237 }
2238 }
2239 }
2240 uno::Reference <uno::XInterface> xInterface = xMultiServiceFactory->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.SpreadsheetSettings")));
2241 uno::Reference <beans::XPropertySet> xProperties(xInterface, uno::UNO_QUERY);
2242 if (xProperties.is())
2243 SvXMLUnitConverter::convertPropertySet(xProperties, aConfigProps);
2244 }
2245 }
2246 }
2247
SetCurrencySymbol(const sal_Int32 nKey,const rtl::OUString & rCurrency)2248 sal_Int32 ScXMLImport::SetCurrencySymbol(const sal_Int32 nKey, const rtl::OUString& rCurrency)
2249 {
2250 uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
2251 if (xNumberFormatsSupplier.is())
2252 {
2253 uno::Reference <util::XNumberFormats> xLocalNumberFormats(xNumberFormatsSupplier->getNumberFormats());
2254 if (xLocalNumberFormats.is())
2255 {
2256 rtl::OUString sFormatString;
2257 try
2258 {
2259 uno::Reference <beans::XPropertySet> xProperties(xLocalNumberFormats->getByKey(nKey));
2260 if (xProperties.is())
2261 {
2262 lang::Locale aLocale;
2263 if (GetDocument() && (xProperties->getPropertyValue(sLocale) >>= aLocale))
2264 {
2265 LockSolarMutex();
2266 LocaleDataWrapper aLocaleData( GetDocument()->GetServiceManager(), aLocale );
2267 rtl::OUStringBuffer aBuffer(15);
2268 aBuffer.appendAscii("#");
2269 aBuffer.append( aLocaleData.getNumThousandSep() );
2270 aBuffer.appendAscii("##0");
2271 aBuffer.append( aLocaleData.getNumDecimalSep() );
2272 aBuffer.appendAscii("00 [$");
2273 aBuffer.append(rCurrency);
2274 aBuffer.appendAscii("]");
2275 UnlockSolarMutex();
2276 sFormatString = aBuffer.makeStringAndClear();
2277 sal_Int32 nNewKey = xLocalNumberFormats->queryKey(sFormatString, aLocale, sal_True);
2278 if (nNewKey == -1)
2279 nNewKey = xLocalNumberFormats->addNew(sFormatString, aLocale);
2280 return nNewKey;
2281 }
2282 }
2283 }
2284 catch ( util::MalformedNumberFormatException& rException )
2285 {
2286 rtl::OUString sErrorMessage(RTL_CONSTASCII_USTRINGPARAM("Fehler im Formatstring "));
2287 sErrorMessage += sFormatString;
2288 sErrorMessage += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" an Position "));
2289 sErrorMessage += rtl::OUString::valueOf(rException.CheckPos);
2290 uno::Sequence<rtl::OUString> aSeq(1);
2291 aSeq[0] = sErrorMessage;
2292 uno::Reference<xml::sax::XLocator> xLocator;
2293 SetError(XMLERROR_API | XMLERROR_FLAG_ERROR, aSeq, rException.Message, xLocator);
2294 }
2295 }
2296 }
2297 return nKey;
2298 }
2299
IsCurrencySymbol(const sal_Int32 nNumberFormat,const rtl::OUString & sCurrentCurrency,const rtl::OUString & sBankSymbol)2300 sal_Bool ScXMLImport::IsCurrencySymbol(const sal_Int32 nNumberFormat, const rtl::OUString& sCurrentCurrency, const rtl::OUString& sBankSymbol)
2301 {
2302 uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
2303 if (xNumberFormatsSupplier.is())
2304 {
2305 uno::Reference <util::XNumberFormats> xLocalNumberFormats(xNumberFormatsSupplier->getNumberFormats());
2306 if (xLocalNumberFormats.is())
2307 {
2308 try
2309 {
2310 uno::Reference <beans::XPropertySet> xNumberPropertySet(xLocalNumberFormats->getByKey(nNumberFormat));
2311 if (xNumberPropertySet.is())
2312 {
2313 rtl::OUString sTemp;
2314 if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_CURRENCYSYMBOL))) >>= sTemp)
2315 {
2316 if (sCurrentCurrency.equals(sTemp))
2317 return sal_True;
2318 // #i61657# This may be a legacy currency symbol that changed in the meantime.
2319 if (SvNumberFormatter::GetLegacyOnlyCurrencyEntry( sCurrentCurrency, sBankSymbol) != NULL)
2320 return true;
2321 // In the rare case that sCurrentCurrency is not the
2322 // currency symbol, but a matching ISO code
2323 // abbreviation instead that was obtained through
2324 // XMLNumberFormatAttributesExportHelper::GetCellType(),
2325 // check with the number format's symbol. This happens,
2326 // for example, in the es_BO locale, where a legacy
2327 // B$,BOB matched B$->BOP, which leads to
2328 // sCurrentCurrency being BOP, and the previous call
2329 // with BOP,BOB didn't find an entry, but B$,BOB will.
2330 return SvNumberFormatter::GetLegacyOnlyCurrencyEntry( sTemp, sBankSymbol) != NULL;
2331 }
2332 }
2333 }
2334 catch ( uno::Exception& )
2335 {
2336 DBG_ERROR("Numberformat not found");
2337 }
2338 }
2339 }
2340 return sal_False;
2341 }
2342
SetType(uno::Reference<beans::XPropertySet> & rProperties,sal_Int32 & rNumberFormat,const sal_Int16 nCellType,const rtl::OUString & rCurrency)2343 void ScXMLImport::SetType(uno::Reference <beans::XPropertySet>& rProperties,
2344 sal_Int32& rNumberFormat,
2345 const sal_Int16 nCellType,
2346 const rtl::OUString& rCurrency)
2347 {
2348 if ((nCellType != util::NumberFormat::TEXT) && (nCellType != util::NumberFormat::UNDEFINED))
2349 {
2350 if (rNumberFormat == -1)
2351 rProperties->getPropertyValue( sNumberFormat ) >>= rNumberFormat;
2352 DBG_ASSERT(rNumberFormat != -1, "no NumberFormat");
2353 sal_Bool bIsStandard;
2354 // sCurrentCurrency may be the ISO code abbreviation if the currency
2355 // symbol matches such, or if no match found the symbol itself!
2356 rtl::OUString sCurrentCurrency;
2357 sal_Int32 nCurrentCellType(
2358 GetNumberFormatAttributesExportHelper()->GetCellType(
2359 rNumberFormat, sCurrentCurrency, bIsStandard) & ~util::NumberFormat::DEFINED);
2360 if ((nCellType != nCurrentCellType) && !((nCellType == util::NumberFormat::NUMBER &&
2361 ((nCurrentCellType == util::NumberFormat::SCIENTIFIC) ||
2362 (nCurrentCellType == util::NumberFormat::FRACTION) ||
2363 (nCurrentCellType == util::NumberFormat::LOGICAL) ||
2364 (nCurrentCellType == 0))) || (nCurrentCellType == util::NumberFormat::TEXT)) && !((nCellType == util::NumberFormat::DATETIME) &&
2365 (nCurrentCellType == util::NumberFormat::DATE)))
2366 {
2367 if (!xNumberFormats.is())
2368 {
2369 uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
2370 if (xNumberFormatsSupplier.is())
2371 xNumberFormats.set(xNumberFormatsSupplier->getNumberFormats());
2372 }
2373 if (xNumberFormats.is())
2374 {
2375 try
2376 {
2377 uno::Reference < beans::XPropertySet> xNumberFormatProperties(xNumberFormats->getByKey(rNumberFormat));
2378 if (xNumberFormatProperties.is())
2379 {
2380 if (nCellType != util::NumberFormat::CURRENCY)
2381 {
2382 lang::Locale aLocale;
2383 if ( xNumberFormatProperties->getPropertyValue(sLocale) >>= aLocale )
2384 {
2385 if (!xNumberFormatTypes.is())
2386 xNumberFormatTypes.set(uno::Reference <util::XNumberFormatTypes>(xNumberFormats, uno::UNO_QUERY));
2387 rProperties->setPropertyValue( sNumberFormat, uno::makeAny(xNumberFormatTypes->getStandardFormat(nCellType, aLocale)) );
2388 }
2389 }
2390 else if (rCurrency.getLength() && sCurrentCurrency.getLength())
2391 {
2392 if (!sCurrentCurrency.equals(rCurrency))
2393 if (!IsCurrencySymbol(rNumberFormat, sCurrentCurrency, rCurrency))
2394 rProperties->setPropertyValue( sNumberFormat, uno::makeAny(SetCurrencySymbol(rNumberFormat, rCurrency)));
2395 }
2396 }
2397 }
2398 catch ( uno::Exception& )
2399 {
2400 DBG_ERROR("Numberformat not found");
2401 }
2402 }
2403 }
2404 else
2405 {
2406 if ((nCellType == util::NumberFormat::CURRENCY) && rCurrency.getLength() && sCurrentCurrency.getLength() &&
2407 !sCurrentCurrency.equals(rCurrency) && !IsCurrencySymbol(rNumberFormat, sCurrentCurrency, rCurrency))
2408 rProperties->setPropertyValue( sNumberFormat, uno::makeAny(SetCurrencySymbol(rNumberFormat, rCurrency)));
2409 }
2410 }
2411 }
2412
AddStyleRange(const table::CellRangeAddress & rCellRange)2413 void ScXMLImport::AddStyleRange(const table::CellRangeAddress& rCellRange)
2414 {
2415 if (!xSheetCellRanges.is() && GetModel().is())
2416 {
2417 uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
2418 if (xMultiServiceFactory.is())
2419 xSheetCellRanges.set(uno::Reference <sheet::XSheetCellRangeContainer>(xMultiServiceFactory->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.SheetCellRanges"))), uno::UNO_QUERY));
2420 DBG_ASSERT(xSheetCellRanges.is(), "didn't get SheetCellRanges");
2421
2422 }
2423 xSheetCellRanges->addRangeAddress(rCellRange, sal_False);
2424 }
2425
SetStyleToRanges()2426 void ScXMLImport::SetStyleToRanges()
2427 {
2428 if (sPrevStyleName.getLength())
2429 {
2430 uno::Reference <beans::XPropertySet> xProperties (xSheetCellRanges, uno::UNO_QUERY);
2431 if (xProperties.is())
2432 {
2433 XMLTableStylesContext *pStyles((XMLTableStylesContext *)GetAutoStyles());
2434 XMLTableStyleContext* pStyle( pStyles ? (XMLTableStyleContext *)pStyles->FindStyleChildContext(
2435 XML_STYLE_FAMILY_TABLE_CELL, sPrevStyleName, sal_True) : NULL );
2436 if (pStyle)
2437 {
2438 pStyle->FillPropertySet(xProperties);
2439 sal_Int32 nNumberFormat(pStyle->GetNumberFormat());
2440 SetType(xProperties, nNumberFormat, nPrevCellType, sPrevCurrency);
2441
2442 // store first cell of first range for each style, once per sheet
2443 uno::Sequence<table::CellRangeAddress> aAddresses(xSheetCellRanges->getRangeAddresses());
2444 if ( aAddresses.getLength() > 0 )
2445 {
2446 const table::CellRangeAddress& rRange = aAddresses[0];
2447 if ( rRange.Sheet != pStyle->GetLastSheet() )
2448 {
2449 ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetModel())->GetSheetSaveData();
2450 pSheetData->AddCellStyle( sPrevStyleName,
2451 ScAddress( (SCCOL)rRange.StartColumn, (SCROW)rRange.StartRow, (SCTAB)rRange.Sheet ) );
2452 pStyle->SetLastSheet(rRange.Sheet);
2453 }
2454 }
2455 }
2456 else
2457 {
2458 xProperties->setPropertyValue(sCellStyle, uno::makeAny(GetStyleDisplayName( XML_STYLE_FAMILY_TABLE_CELL, sPrevStyleName )));
2459 sal_Int32 nNumberFormat(GetStyleNumberFormats()->GetStyleNumberFormat(sPrevStyleName));
2460 sal_Bool bInsert(nNumberFormat == -1);
2461 SetType(xProperties, nNumberFormat, nPrevCellType, sPrevCurrency);
2462 if (bInsert)
2463 GetStyleNumberFormats()->AddStyleNumberFormat(sPrevStyleName, nNumberFormat);
2464 }
2465 }
2466 }
2467 if (GetModel().is())
2468 {
2469 uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
2470 if (xMultiServiceFactory.is())
2471 xSheetCellRanges.set(uno::Reference <sheet::XSheetCellRangeContainer>(
2472 xMultiServiceFactory->createInstance(
2473 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.SheetCellRanges"))),
2474 uno::UNO_QUERY));
2475 }
2476 DBG_ASSERT(xSheetCellRanges.is(), "didn't get SheetCellRanges");
2477 }
2478
SetStyleToRange(const ScRange & rRange,const rtl::OUString * pStyleName,const sal_Int16 nCellType,const rtl::OUString * pCurrency)2479 void ScXMLImport::SetStyleToRange(const ScRange& rRange, const rtl::OUString* pStyleName,
2480 const sal_Int16 nCellType, const rtl::OUString* pCurrency)
2481 {
2482 if (!sPrevStyleName.getLength())
2483 {
2484 nPrevCellType = nCellType;
2485 if (pStyleName)
2486 sPrevStyleName = *pStyleName;
2487 if (pCurrency)
2488 sPrevCurrency = *pCurrency;
2489 else if (sPrevCurrency.getLength())
2490 sPrevCurrency = sEmpty;
2491 }
2492 else if ((nCellType != nPrevCellType) ||
2493 ((pStyleName && !pStyleName->equals(sPrevStyleName)) ||
2494 (!pStyleName && sPrevStyleName.getLength())) ||
2495 ((pCurrency && !pCurrency->equals(sPrevCurrency)) ||
2496 (!pCurrency && sPrevCurrency.getLength())))
2497 {
2498 SetStyleToRanges();
2499 nPrevCellType = nCellType;
2500 if (pStyleName)
2501 sPrevStyleName = *pStyleName;
2502 else if(sPrevStyleName.getLength())
2503 sPrevStyleName = sEmpty;
2504 if (pCurrency)
2505 sPrevCurrency = *pCurrency;
2506 else if(sPrevCurrency.getLength())
2507 sPrevCurrency = sEmpty;
2508 }
2509 table::CellRangeAddress aCellRange;
2510 aCellRange.StartColumn = rRange.aStart.Col();
2511 aCellRange.StartRow = rRange.aStart.Row();
2512 aCellRange.Sheet = rRange.aStart.Tab();
2513 aCellRange.EndColumn = rRange.aEnd.Col();
2514 aCellRange.EndRow = rRange.aEnd.Row();
2515 AddStyleRange(aCellRange);
2516 }
2517
SetNullDateOnUnitConverter()2518 sal_Bool ScXMLImport::SetNullDateOnUnitConverter()
2519 {
2520 if (!bNullDateSetted)
2521 bNullDateSetted = GetMM100UnitConverter().setNullDate(GetModel());
2522 DBG_ASSERT(bNullDateSetted, "could not set the null date");
2523 return bNullDateSetted;
2524 }
2525
GetNumberFormatAttributesExportHelper()2526 XMLNumberFormatAttributesExportHelper* ScXMLImport::GetNumberFormatAttributesExportHelper()
2527 {
2528 if (!pNumberFormatAttributesExportHelper)
2529 pNumberFormatAttributesExportHelper = new XMLNumberFormatAttributesExportHelper(GetNumberFormatsSupplier());
2530 return pNumberFormatAttributesExportHelper;
2531 }
2532
GetStyleNumberFormats()2533 ScMyStyleNumberFormats* ScXMLImport::GetStyleNumberFormats()
2534 {
2535 if (!pStyleNumberFormats)
2536 pStyleNumberFormats = new ScMyStyleNumberFormats();
2537 return pStyleNumberFormats;
2538 }
2539
SetStylesToRangesFinished()2540 void ScXMLImport::SetStylesToRangesFinished()
2541 {
2542 SetStyleToRanges();
2543 sPrevStyleName = sEmpty;
2544 }
2545
2546 // XImporter
setTargetDocument(const::com::sun::star::uno::Reference<::com::sun::star::lang::XComponent> & xDoc)2547 void SAL_CALL ScXMLImport::setTargetDocument( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent >& xDoc )
2548 {
2549 LockSolarMutex();
2550 SvXMLImport::setTargetDocument( xDoc );
2551
2552 uno::Reference<frame::XModel> xModel(xDoc, uno::UNO_QUERY);
2553 pDoc = ScXMLConverter::GetScDocument( xModel );
2554 DBG_ASSERT( pDoc, "ScXMLImport::setTargetDocument - no ScDocument!" );
2555 if (!pDoc)
2556 throw lang::IllegalArgumentException();
2557
2558 bFromWrapper = pDoc->IsXMLFromWrapper(); // UnlockSolarMutex below still works normally
2559
2560 uno::Reference<document::XActionLockable> xActionLockable(xDoc, uno::UNO_QUERY);
2561 if (xActionLockable.is())
2562 xActionLockable->addActionLock();
2563 UnlockSolarMutex();
2564 }
2565
2566 // XServiceInfo
getImplementationName()2567 ::rtl::OUString SAL_CALL ScXMLImport::getImplementationName( )
2568 {
2569 switch( getImportFlags() )
2570 {
2571 case IMPORT_ALL:
2572 return ScXMLImport_getImplementationName();
2573 case (IMPORT_STYLES|IMPORT_MASTERSTYLES|IMPORT_AUTOSTYLES|IMPORT_FONTDECLS):
2574 return ScXMLImport_Styles_getImplementationName();
2575 case (IMPORT_AUTOSTYLES|IMPORT_CONTENT|IMPORT_SCRIPTS|IMPORT_FONTDECLS):
2576 return ScXMLImport_Content_getImplementationName();
2577 case IMPORT_META:
2578 return ScXMLImport_Meta_getImplementationName();
2579 case IMPORT_SETTINGS:
2580 return ScXMLImport_Settings_getImplementationName();
2581 default:
2582 // generic name for 'unknown' cases
2583 return ScXMLImport_getImplementationName();
2584 }
2585 }
2586
2587 // ::com::sun::star::xml::sax::XDocumentHandler
startDocument(void)2588 void SAL_CALL ScXMLImport::startDocument(void)
2589 {
2590 LockSolarMutex();
2591 SvXMLImport::startDocument();
2592 if (pDoc && !pDoc->IsImportingXML())
2593 {
2594 ScModelObj::getImplementation(GetModel())->BeforeXMLLoading();
2595 bSelfImportingXMLSet = sal_True;
2596 }
2597
2598 // if content and styles are loaded with separate imports,
2599 // set bLatinDefaultStyle flag at the start of the content import
2600 sal_uInt16 nFlags = getImportFlags();
2601 if ( ( nFlags & IMPORT_CONTENT ) && !( nFlags & IMPORT_STYLES ) )
2602 ExamineDefaultStyle();
2603
2604 if (getImportFlags() & IMPORT_CONTENT)
2605 {
2606 if (GetModel().is())
2607 {
2608 // store initial namespaces, to find the ones that were added from the file later
2609 ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetModel())->GetSheetSaveData();
2610 const SvXMLNamespaceMap& rNamespaces = GetNamespaceMap();
2611 pSheetData->StoreInitialNamespaces(rNamespaces);
2612 }
2613 }
2614
2615 uno::Reference< beans::XPropertySet > const xImportInfo( getImportInfo() );
2616 uno::Reference< beans::XPropertySetInfo > const xPropertySetInfo(
2617 xImportInfo.is() ? xImportInfo->getPropertySetInfo() : 0);
2618 if (xPropertySetInfo.is())
2619 {
2620 ::rtl::OUString const sOrganizerMode(
2621 RTL_CONSTASCII_USTRINGPARAM("OrganizerMode"));
2622 if (xPropertySetInfo->hasPropertyByName(sOrganizerMode))
2623 {
2624 sal_Bool bStyleOnly(sal_False);
2625 if (xImportInfo->getPropertyValue(sOrganizerMode) >>= bStyleOnly)
2626 {
2627 bLoadDoc = !bStyleOnly;
2628 }
2629 }
2630 }
2631
2632 UnlockSolarMutex();
2633 }
2634
GetRangeType(const rtl::OUString sRangeType) const2635 sal_Int32 ScXMLImport::GetRangeType(const rtl::OUString sRangeType) const
2636 {
2637 sal_Int32 nRangeType(0);
2638 rtl::OUStringBuffer sBuffer;
2639 sal_Int16 i = 0;
2640 while (i <= sRangeType.getLength())
2641 {
2642 if ((sRangeType[i] == ' ') || (i == sRangeType.getLength()))
2643 {
2644 rtl::OUString sTemp = sBuffer.makeStringAndClear();
2645 if (sTemp.compareToAscii(SC_REPEAT_COLUMN) == 0)
2646 nRangeType |= sheet::NamedRangeFlag::COLUMN_HEADER;
2647 else if (sTemp.compareToAscii(SC_REPEAT_ROW) == 0)
2648 nRangeType |= sheet::NamedRangeFlag::ROW_HEADER;
2649 else if (sTemp.compareToAscii(SC_FILTER) == 0)
2650 nRangeType |= sheet::NamedRangeFlag::FILTER_CRITERIA;
2651 else if (sTemp.compareToAscii(SC_PRINT_RANGE) == 0)
2652 nRangeType |= sheet::NamedRangeFlag::PRINT_AREA;
2653 }
2654 else if (i < sRangeType.getLength())
2655 sBuffer.append(sRangeType[i]);
2656 ++i;
2657 }
2658 return nRangeType;
2659 }
2660
SetLabelRanges()2661 void ScXMLImport::SetLabelRanges()
2662 {
2663 ScMyLabelRanges* pLabelRanges = GetLabelRanges();
2664 if (pLabelRanges)
2665 {
2666 uno::Reference <beans::XPropertySet> xPropertySet (GetModel(), uno::UNO_QUERY);
2667 if (xPropertySet.is())
2668 {
2669 uno::Any aColAny = xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_COLLABELRNG)));
2670 uno::Any aRowAny = xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_ROWLABELRNG)));
2671
2672 uno::Reference< sheet::XLabelRanges > xColRanges;
2673 uno::Reference< sheet::XLabelRanges > xRowRanges;
2674
2675 if ( ( aColAny >>= xColRanges ) && ( aRowAny >>= xRowRanges ) )
2676 {
2677 table::CellRangeAddress aLabelRange;
2678 table::CellRangeAddress aDataRange;
2679
2680 ScMyLabelRanges::iterator aItr = pLabelRanges->begin();
2681 while (aItr != pLabelRanges->end())
2682 {
2683 sal_Int32 nOffset1(0);
2684 sal_Int32 nOffset2(0);
2685 FormulaGrammar::AddressConvention eConv = FormulaGrammar::CONV_OOO;
2686
2687 if (ScRangeStringConverter::GetRangeFromString( aLabelRange, (*aItr)->sLabelRangeStr, GetDocument(), eConv, nOffset1 ) &&
2688 ScRangeStringConverter::GetRangeFromString( aDataRange, (*aItr)->sDataRangeStr, GetDocument(), eConv, nOffset2 ))
2689 {
2690 if ( (*aItr)->bColumnOrientation )
2691 xColRanges->addNew( aLabelRange, aDataRange );
2692 else
2693 xRowRanges->addNew( aLabelRange, aDataRange );
2694 }
2695
2696 delete *aItr;
2697 aItr = pLabelRanges->erase(aItr);
2698 }
2699 }
2700 }
2701 }
2702 }
2703
SetNamedRanges()2704 void ScXMLImport::SetNamedRanges()
2705 {
2706 ScMyNamedExpressions* pNamedExpressions(GetNamedExpressions());
2707 if (pNamedExpressions)
2708 {
2709 uno::Reference <beans::XPropertySet> xPropertySet (GetModel(), uno::UNO_QUERY);
2710 if (xPropertySet.is())
2711 {
2712 uno::Reference <sheet::XNamedRanges2> xNamedRanges(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_NAMEDRANGES))), uno::UNO_QUERY);
2713 if (xNamedRanges.is())
2714 {
2715 ScMyNamedExpressions::iterator aItr(pNamedExpressions->begin());
2716 ScMyNamedExpressions::const_iterator aEndItr(pNamedExpressions->end());
2717 table::CellAddress aCellAddress;
2718 rtl::OUString sTempContent(RTL_CONSTASCII_USTRINGPARAM("0"));
2719 while (aItr != aEndItr)
2720 {
2721 sal_Int32 nOffset(0);
2722 if (ScRangeStringConverter::GetAddressFromString(
2723 aCellAddress, (*aItr)->sBaseCellAddress, GetDocument(), FormulaGrammar::CONV_OOO, nOffset ))
2724 {
2725 try
2726 {
2727 //xNamedRanges->addNewByName((*aItr)->sName, sTempContent, aCellAddress, GetRangeType((*aItr)->sRangeType));//String::CreateFromInt32( (*aItr)->nNameScope)
2728 String sTabName;
2729 GetDocument()->GetName( (*aItr)->nNameScope, sTabName);
2730 xNamedRanges->addNewByScopeName( sTabName, (*aItr)->sName, sTempContent, aCellAddress, GetRangeType((*aItr)->sRangeType) );
2731 }
2732 catch( uno::RuntimeException& )
2733 {
2734 DBG_ERROR("here are some Named Ranges with the same name");
2735 uno::Reference < container::XIndexAccess > xIndex(xNamedRanges, uno::UNO_QUERY);
2736 if (xIndex.is())
2737 {
2738 sal_Int32 nMax(xIndex->getCount());
2739 sal_Bool bInserted(sal_False);
2740 sal_Int32 nCount(1);
2741 rtl::OUStringBuffer sName((*aItr)->sName);
2742 sName.append(sal_Unicode('_'));
2743 while (!bInserted && nCount <= nMax)
2744 {
2745 rtl::OUStringBuffer sTemp(sName);
2746 sTemp.append(rtl::OUString::valueOf(nCount));
2747 try
2748 {
2749 xNamedRanges->addNewByName(sTemp.makeStringAndClear(), sTempContent, aCellAddress, GetRangeType((*aItr)->sRangeType));
2750 bInserted = sal_True;
2751 }
2752 catch( uno::RuntimeException& )
2753 {
2754 ++nCount;
2755 }
2756 }
2757 }
2758 }
2759 }
2760 ++aItr;
2761 }
2762 aItr = pNamedExpressions->begin();
2763 while (aItr != aEndItr)
2764 {
2765 sal_Int32 nOffset(0);
2766 if (ScRangeStringConverter::GetAddressFromString(
2767 aCellAddress, (*aItr)->sBaseCellAddress, GetDocument(), FormulaGrammar::CONV_OOO, nOffset ))
2768 {
2769 //uno::Reference <sheet::XNamedRange> xNamedRange(xNamedRanges->getByName((*aItr)->sName), uno::UNO_QUERY);
2770 String sTableName;
2771 GetDocument()->GetName( (*aItr)->nNameScope, sTableName );
2772 rtl::OUString sRangeScope( sTableName);
2773 uno::Reference <sheet::XNamedRange2> xNamedRange(xNamedRanges->getByScopeName( sRangeScope,(*aItr)->sName), uno::UNO_QUERY);
2774 if (xNamedRange.is())
2775 {
2776 LockSolarMutex();
2777 ScNamedRangeObj* pNamedRangeObj = ScNamedRangeObj::getImplementation( xNamedRange);
2778 if (pNamedRangeObj)
2779 {
2780 sTempContent = (*aItr)->sContent;
2781 // Get rid of leading sheet dots in simple ranges.
2782 if (!(*aItr)->bIsExpression)
2783 ScXMLConverter::ParseFormula( sTempContent, false);
2784 pNamedRangeObj->SetContentWithGrammar( sTempContent, (*aItr)->eGrammar);
2785 }
2786 UnlockSolarMutex();
2787 }
2788 }
2789 delete *aItr;
2790 aItr = pNamedExpressions->erase(aItr);
2791 }
2792 }
2793 }
2794 }
2795 }
2796
endDocument(void)2797 void SAL_CALL ScXMLImport::endDocument(void)
2798 {
2799 LockSolarMutex();
2800 if (getImportFlags() & IMPORT_CONTENT)
2801 {
2802 if (GetModel().is())
2803 {
2804 uno::Reference<document::XViewDataSupplier> xViewDataSupplier(GetModel(), uno::UNO_QUERY);
2805 if (xViewDataSupplier.is())
2806 {
2807 uno::Reference<container::XIndexAccess> xIndexAccess(xViewDataSupplier->getViewData());
2808 if (xIndexAccess.is() && xIndexAccess->getCount() > 0)
2809 {
2810 uno::Sequence< beans::PropertyValue > aSeq;
2811 if (xIndexAccess->getByIndex(0) >>= aSeq)
2812 {
2813 sal_Int32 nCount (aSeq.getLength());
2814 for (sal_Int32 i = 0; i < nCount; ++i)
2815 {
2816 rtl::OUString sName(aSeq[i].Name);
2817 if (sName.compareToAscii(SC_ACTIVETABLE) == 0)
2818 {
2819 rtl::OUString sValue;
2820 if(aSeq[i].Value >>= sValue)
2821 {
2822 String sTabName(sValue);
2823 SCTAB nTab(0);
2824 if (pDoc->GetTable(sTabName, nTab))
2825 {
2826 pDoc->SetVisibleTab(nTab);
2827 i = nCount;
2828 }
2829 }
2830 }
2831 }
2832 }
2833 }
2834 }
2835 SetLabelRanges();
2836 SetNamedRanges();
2837 }
2838 GetProgressBarHelper()->End(); // make room for subsequent SfxProgressBars
2839 if (pDoc)
2840 {
2841 pDoc->CompileXML();
2842
2843 // After CompileXML, links must be completely changed to the new URLs.
2844 // Otherwise, hasExternalFile for API wouldn't work (#i116940#),
2845 // and typing a new formula would create a second link with the same "real" file name.
2846 if (pDoc->HasExternalRefManager())
2847 pDoc->GetExternalRefManager()->updateAbsAfterLoad();
2848 }
2849
2850 // If the stream contains cells outside of the current limits, the styles can't be re-created,
2851 // so stream copying is disabled then.
2852 if (pDoc && GetModel().is() && !pDoc->HasRangeOverflow())
2853 {
2854 // set "valid stream" flags after loading (before UpdateRowHeights, so changed formula results
2855 // in UpdateRowHeights can already clear the flags again)
2856 ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetModel())->GetSheetSaveData();
2857
2858 SCTAB nTabCount = pDoc->GetTableCount();
2859 for (SCTAB nTab=0; nTab<nTabCount; ++nTab)
2860 if (!pSheetData->IsSheetBlocked( nTab ))
2861 pDoc->SetStreamValid( nTab, sal_True );
2862 }
2863
2864 aTables.UpdateRowHeights();
2865 aTables.ResizeShapes();
2866 }
2867 if (GetModel().is())
2868 {
2869 uno::Reference<document::XActionLockable> xActionLockable(GetModel(), uno::UNO_QUERY);
2870 if (xActionLockable.is())
2871 xActionLockable->removeActionLock();
2872 }
2873 SvXMLImport::endDocument();
2874
2875 if (pDoc && bSelfImportingXMLSet)
2876 {
2877 ScModelObj::getImplementation(GetModel())->AfterXMLLoading(sal_True);
2878 }
2879
2880 UnlockSolarMutex();
2881 }
2882
2883 // XEventListener
DisposingModel()2884 void ScXMLImport::DisposingModel()
2885 {
2886 SvXMLImport::DisposingModel();
2887 pDoc = NULL;
2888 }
2889
LockSolarMutex()2890 void ScXMLImport::LockSolarMutex()
2891 {
2892 // #i62677# When called from DocShell/Wrapper, the SolarMutex is already locked,
2893 // so there's no need to allocate (and later delete) the ScUnoGuard.
2894 if (bFromWrapper)
2895 {
2896 DBG_TESTSOLARMUTEX();
2897 return;
2898 }
2899
2900 if (nSolarMutexLocked == 0)
2901 {
2902 DBG_ASSERT(!pScUnoGuard, "Solar Mutex is locked");
2903 pScUnoGuard = new ScUnoGuard();
2904 }
2905 ++nSolarMutexLocked;
2906 }
2907
2908
UnlockSolarMutex()2909 void ScXMLImport::UnlockSolarMutex()
2910 {
2911 if (nSolarMutexLocked > 0)
2912 {
2913 nSolarMutexLocked--;
2914 if (nSolarMutexLocked == 0)
2915 {
2916 DBG_ASSERT(pScUnoGuard, "Solar Mutex is always unlocked");
2917 delete pScUnoGuard;
2918 pScUnoGuard = NULL;
2919 }
2920 }
2921 }
2922
GetByteOffset()2923 sal_Int32 ScXMLImport::GetByteOffset()
2924 {
2925 sal_Int32 nOffset = -1;
2926 uno::Reference<xml::sax::XLocator> xLocator = GetLocator();
2927 uno::Reference<io::XSeekable> xSeek( xLocator, uno::UNO_QUERY ); //! should use different interface
2928 if ( xSeek.is() )
2929 nOffset = (sal_Int32)xSeek->getPosition();
2930 return nOffset;
2931 }
2932
SetRangeOverflowType(sal_uInt32 nType)2933 void ScXMLImport::SetRangeOverflowType(sal_uInt32 nType)
2934 {
2935 // #i31130# Overflow is stored in the document, because the ScXMLImport object
2936 // isn't available in ScXMLImportWrapper::ImportFromComponent when using the
2937 // OOo->Oasis transformation.
2938
2939 if ( pDoc )
2940 pDoc->SetRangeOverflowType( nType );
2941 }
2942
ProgressBarIncrement(sal_Bool bEditCell,sal_Int32 nInc)2943 void ScXMLImport::ProgressBarIncrement(sal_Bool bEditCell, sal_Int32 nInc)
2944 {
2945 nProgressCount += nInc;
2946 if (bEditCell || nProgressCount > 100)
2947 {
2948 GetProgressBarHelper()->Increment(nProgressCount);
2949 nProgressCount = 0;
2950 }
2951 }
2952
GetVisibleSheet()2953 sal_Int32 ScXMLImport::GetVisibleSheet()
2954 {
2955 // Get the visible sheet number from model's view data (after settings were loaded),
2956 // or 0 (default: first sheet) if no settings available.
2957
2958 uno::Reference<document::XViewDataSupplier> xSupp(GetModel(), uno::UNO_QUERY);
2959 if (xSupp.is())
2960 {
2961 uno::Reference<container::XIndexAccess> xIndex = xSupp->getViewData();
2962 if ( xIndex.is() && xIndex->getCount() > 0 )
2963 {
2964 uno::Any aAny( xIndex->getByIndex(0) );
2965 uno::Sequence<beans::PropertyValue> aViewSettings; // settings for (first) view
2966 if ( aAny >>= aViewSettings )
2967 {
2968 sal_Int32 nCount = aViewSettings.getLength();
2969 for (sal_Int32 i = 0; i < nCount; ++i)
2970 {
2971 if ( aViewSettings[i].Name.compareToAscii(SC_ACTIVETABLE) == 0 )
2972 {
2973 rtl::OUString sValue;
2974 if(aViewSettings[i].Value >>= sValue)
2975 {
2976 String sTabName(sValue);
2977 SCTAB nTab = 0;
2978 if (pDoc->GetTable(sTabName, nTab))
2979 return nTab;
2980 }
2981 }
2982 }
2983 }
2984 }
2985 }
2986
2987 return 0;
2988 }
2989
ExtractFormulaNamespaceGrammar(OUString & rFormula,OUString & rFormulaNmsp,FormulaGrammar::Grammar & reGrammar,const OUString & rAttrValue,bool bRestrictToExternalNmsp) const2990 void ScXMLImport::ExtractFormulaNamespaceGrammar(
2991 OUString& rFormula, OUString& rFormulaNmsp, FormulaGrammar::Grammar& reGrammar,
2992 const OUString& rAttrValue, bool bRestrictToExternalNmsp ) const
2993 {
2994 // parse the attribute value, extract namespace ID, literal namespace, and formula string
2995 rFormulaNmsp = OUString();
2996 sal_uInt16 nNsId = GetNamespaceMap()._GetKeyByAttrName( rAttrValue, 0, &rFormula, &rFormulaNmsp, sal_False );
2997
2998 // check if we have an ODF formula namespace
2999 if( !bRestrictToExternalNmsp ) switch( nNsId )
3000 {
3001 case XML_NAMESPACE_OOOC:
3002 rFormulaNmsp = OUString(); // remove namespace string for built-in grammar
3003 reGrammar = FormulaGrammar::GRAM_PODF;
3004 return;
3005 case XML_NAMESPACE_OF:
3006 rFormulaNmsp = OUString(); // remove namespace string for built-in grammar
3007 reGrammar = FormulaGrammar::GRAM_ODFF;
3008 return;
3009 }
3010
3011 /* Find default grammar for formulas without namespace. There may be
3012 documents in the wild that stored no namespace in ODF 1.0/1.1. Use
3013 GRAM_PODF then (old style ODF 1.0/1.1 formulas). The default for ODF
3014 1.2 and later without namespace is GRAM_ODFF (OpenFormula). */
3015 FormulaGrammar::Grammar eDefaultGrammar =
3016 (GetDocument()->GetStorageGrammar() == FormulaGrammar::GRAM_PODF) ?
3017 FormulaGrammar::GRAM_PODF : FormulaGrammar::GRAM_ODFF;
3018
3019 /* Check if we have no namespace at all. The value XML_NAMESPACE_NONE
3020 indicates that there is no colon. If the first character of the
3021 attribute value is the equality sign, the value XML_NAMESPACE_UNKNOWN
3022 indicates that there is a colon somewhere in the formula string. */
3023 if( (nNsId == XML_NAMESPACE_NONE) || ((nNsId == XML_NAMESPACE_UNKNOWN) && (rAttrValue.toChar() == '=')) )
3024 {
3025 rFormula = rAttrValue; // return entire string as formula
3026 reGrammar = eDefaultGrammar;
3027 return;
3028 }
3029
3030 /* Check if a namespace URL could be resolved from the attribute value.
3031 Use that namespace only, if the Calc document knows an associated
3032 external formula parser. This prevents that the range operator in
3033 conjunction with defined names is confused as namespaces prefix, e.g.
3034 in the expression 'table:A1' where 'table' is a named reference. */
3035 if( ((nNsId & XML_NAMESPACE_UNKNOWN_FLAG) != 0) && (rFormulaNmsp.getLength() > 0) &&
3036 GetDocument()->GetFormulaParserPool().hasFormulaParser( rFormulaNmsp ) )
3037 {
3038 reGrammar = FormulaGrammar::GRAM_EXTERNAL;
3039 return;
3040 }
3041
3042 /* All attempts failed (e.g. no namespace and no leading equality sign, or
3043 an invalid namespace prefix), continue with the entire attribute value. */
3044 rFormula = rAttrValue;
3045 rFormulaNmsp = OUString(); // remove any namespace string
3046 reGrammar = eDefaultGrammar;
3047 }
3048