LibreOffice Module sc (master)  1
xmlimprt.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #include <sal/config.h>
21 #include <sal/log.hxx>
22 #include <osl/diagnose.h>
23 
24 #include <svl/zforlist.hxx>
25 
26 #include <xmloff/nmspmap.hxx>
27 #include <xmloff/xmlnmspe.hxx>
28 #include <xmloff/xmltkmap.hxx>
29 #include <xmloff/xmlictxt.hxx>
30 #include <xmloff/xmlmetai.hxx>
31 #include <sfx2/objsh.hxx>
32 #include <unotools/streamwrap.hxx>
33 #include <xmloff/xmlscripti.hxx>
34 #include <xmloff/XMLFontStylesContext.hxx>
35 #include <xmloff/DocumentSettingsContext.hxx>
36 #include <xmloff/xmluconv.hxx>
37 #include <xmloff/numehelp.hxx>
38 #include <xmloff/xmltoken.hxx>
39 #include <xmloff/xmlerror.hxx>
40 #include <xmloff/ProgressBarHelper.hxx>
41 
42 #include <svl/languageoptions.hxx>
43 #include <editeng/editstat.hxx>
44 #include <formula/errorcodes.hxx>
45 #include <vcl/svapp.hxx>
46 
47 #include <appluno.hxx>
48 #include "xmlimprt.hxx"
49 #include "importcontext.hxx"
50 #include <document.hxx>
51 #include <docsh.hxx>
52 #include <docuno.hxx>
53 #include "xmlbodyi.hxx"
54 #include "xmlstyli.hxx"
55 #include <ViewSettingsSequenceDefines.hxx>
56 
57 #include <compiler.hxx>
58 
59 #include "XMLConverter.hxx"
60 #include "XMLDetectiveContext.hxx"
61 #include "XMLTableShapeImportHelper.hxx"
62 #include "XMLChangeTrackingImportHelper.hxx"
63 #include <chgviset.hxx>
64 #include "XMLStylesImportHelper.hxx"
65 #include <sheetdata.hxx>
66 #include <rangeutl.hxx>
67 #include <formulaparserpool.hxx>
68 #include <externalrefmgr.hxx>
69 #include <editutil.hxx>
70 #include "editattributemap.hxx"
71 #include <documentimport.hxx>
72 #include "pivotsource.hxx"
73 #include <unonames.hxx>
74 #include <numformat.hxx>
75 #include <sizedev.hxx>
76 #include <scdll.hxx>
77 #include "xmlstyle.hxx"
78 
79 #include <comphelper/base64.hxx>
80 #include <comphelper/extract.hxx>
81 #include <comphelper/propertysequence.hxx>
82 #include <comphelper/processfactory.hxx>
83 
84 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
85 #include <com/sun/star/frame/XModel.hpp>
86 #include <com/sun/star/io/IOException.hpp>
87 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
88 #include <com/sun/star/document/XActionLockable.hpp>
89 #include <com/sun/star/util/MalformedNumberFormatException.hpp>
90 #include <com/sun/star/util/NumberFormat.hpp>
91 #include <com/sun/star/util/XNumberFormatTypes.hpp>
92 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
93 #include <com/sun/star/sheet/NamedRangeFlag.hpp>
94 #include <com/sun/star/sheet/XLabelRanges.hpp>
95 #include <com/sun/star/io/XSeekable.hpp>
96 #include <com/sun/star/beans/XPropertySet.hpp>
97 #include <com/sun/star/sheet/XSheetCellRangeContainer.hpp>
98 #include <cellsuno.hxx>
99 
100 #include <memory>
101 #include <utility>
102 
103 #define SC_LOCALE "Locale"
104 #define SC_CURRENCYSYMBOL "CurrencySymbol"
105 #define SC_REPEAT_ROW "repeat-row"
106 #define SC_FILTER "filter"
107 #define SC_PRINT_RANGE "print-range"
108 
109 using namespace com::sun::star;
110 using namespace ::xmloff::token;
111 using namespace ::formula;
112 
113 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
114 Calc_XMLOasisImporter_get_implementation(
115  css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& )
116 {
117  return cppu::acquire(static_cast<cppu::OWeakObject*>(
118  new ScXMLImport(
119  context,
120  "com.sun.star.comp.Calc.XMLOasisImporter",
121  SvXMLImportFlags::ALL,
122  { "com.sun.star.comp.Calc.XMLOasisImporter" } )));
123 }
124 
125 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
126 Calc_XMLOasisMetaImporter_get_implementation(
127  css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& )
128 {
129  return cppu::acquire(static_cast<cppu::OWeakObject*>(
130  new ScXMLImport(
131  context,
132  "com.sun.star.comp.Calc.XMLOasisMetaImporter",
133  SvXMLImportFlags::META,
134  { "com.sun.star.comp.Calc.XMLOasisMetaImporter" } )));
135 }
136 
137 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
138 Calc_XMLOasisStylesImporter_get_implementation(
139  css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& )
140 {
141  return cppu::acquire(static_cast<cppu::OWeakObject*>(
142  new ScXMLImport(
143  context,
144  "com.sun.star.comp.Calc.XMLOasisStylesImporter",
145  SvXMLImportFlags::STYLES|SvXMLImportFlags::AUTOSTYLES|SvXMLImportFlags::MASTERSTYLES|SvXMLImportFlags::FONTDECLS,
146  { "com.sun.star.comp.Calc.XMLOasisStylesImporter" } )));
147 }
148 
149 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
150 Calc_XMLOasisContentImporter_get_implementation(
151  css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& )
152 {
153  return cppu::acquire(static_cast<cppu::OWeakObject*>(new ScXMLImport(
154  context,
155  "com.sun.star.comp.Calc.XMLOasisContentImporter",
156  SvXMLImportFlags::AUTOSTYLES|SvXMLImportFlags::CONTENT|SvXMLImportFlags::SCRIPTS|SvXMLImportFlags::FONTDECLS,
157  uno::Sequence< OUString > { "com.sun.star.comp.Calc.XMLOasisContentImporter" })));
158 }
159 
160 
161 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
162 Calc_XMLOasisSettingsImporter_get_implementation(
163  css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& )
164 {
165  return cppu::acquire(static_cast<cppu::OWeakObject*>(
166  new ScXMLImport(
167  context,
168  "com.sun.star.comp.Calc.XMLOasisSettingsImporter",
169  SvXMLImportFlags::SETTINGS,
170  { "com.sun.star.comp.Calc.XMLOasisSettingsImporter" } )));
171 }
172 
173 const SvXMLTokenMap& ScXMLImport::GetTableRowCellAttrTokenMap()
174 {
175  static const SvXMLTokenMapEntry aTableRowCellAttrTokenMap[] =
176  {
177  { XML_NAMESPACE_TABLE, XML_STYLE_NAME, XML_TOK_TABLE_ROW_CELL_ATTR_STYLE_NAME },
178  { XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION_NAME, XML_TOK_TABLE_ROW_CELL_ATTR_CONTENT_VALIDATION_NAME },
179  { XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_SPANNED, XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_ROWS },
180  { XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_SPANNED, XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_COLS },
181  { XML_NAMESPACE_TABLE, XML_NUMBER_MATRIX_COLUMNS_SPANNED, XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_MATRIX_COLS },
182  { XML_NAMESPACE_TABLE, XML_NUMBER_MATRIX_ROWS_SPANNED, XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_MATRIX_ROWS },
183  { XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, XML_TOK_TABLE_ROW_CELL_ATTR_REPEATED },
184  { XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TOK_TABLE_ROW_CELL_ATTR_VALUE_TYPE },
185  { XML_NAMESPACE_CALC_EXT, XML_VALUE_TYPE, XML_TOK_TABLE_ROW_CELL_ATTR_NEW_VALUE_TYPE },
186  { XML_NAMESPACE_OFFICE, XML_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_VALUE },
187  { XML_NAMESPACE_OFFICE, XML_DATE_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_DATE_VALUE },
188  { XML_NAMESPACE_OFFICE, XML_TIME_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_TIME_VALUE },
189  { XML_NAMESPACE_OFFICE, XML_STRING_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_STRING_VALUE },
190  { XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TOK_TABLE_ROW_CELL_ATTR_BOOLEAN_VALUE },
191  { XML_NAMESPACE_TABLE, XML_FORMULA, XML_TOK_TABLE_ROW_CELL_ATTR_FORMULA },
192  { XML_NAMESPACE_OFFICE, XML_CURRENCY, XML_TOK_TABLE_ROW_CELL_ATTR_CURRENCY },
193  XML_TOKEN_MAP_END
194  };
195 
196  if ( !pTableRowCellAttrTokenMap )
197  pTableRowCellAttrTokenMap.reset(new SvXMLTokenMap( aTableRowCellAttrTokenMap ));
198  return *pTableRowCellAttrTokenMap;
199 }
200 
201 namespace {
202 
203 // NB: virtually inherit so we can multiply inherit properly
204 // in ScXMLFlatDocContext_Impl
205 class ScXMLDocContext_Impl : public virtual SvXMLImportContext
206 {
207 protected:
208  ScXMLImport& GetScImport() { return static_cast<ScXMLImport&>(GetImport()); }
209 
210 public:
211  ScXMLDocContext_Impl( ScXMLImport& rImport );
212 
213  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL
214  createFastChildContext( sal_Int32 nElement,
215  const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList ) override;
216 
217  virtual void SAL_CALL startFastElement (sal_Int32 nElement,
218  const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList) override;
219 
220  virtual void SAL_CALL characters(const OUString & aChars) override;
221 
222  virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
223 };
224 
225 }
226 
227 ScXMLDocContext_Impl::ScXMLDocContext_Impl( ScXMLImport& rImport ) :
228 SvXMLImportContext( rImport )
229 {
230 }
231 
232 namespace {
233 
234 // context for flat file xml format
235 class ScXMLFlatDocContext_Impl
236  : public ScXMLDocContext_Impl, public SvXMLMetaDocumentContext
237 {
238 public:
239 
240  ScXMLFlatDocContext_Impl( ScXMLImport& i_rImport,
241  const uno::Reference<document::XDocumentProperties>& i_xDocProps);
242 
243  virtual void SAL_CALL startFastElement (sal_Int32 nElement,
244  const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList) override;
245 
246  virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
247 
248  virtual void SAL_CALL characters( const OUString& aChars ) override;
249 
250  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL
251  createFastChildContext( sal_Int32 nElement,
252  const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList ) override;
253 };
254 
255 }
256 
257 ScXMLFlatDocContext_Impl::ScXMLFlatDocContext_Impl( ScXMLImport& i_rImport,
258  const uno::Reference<document::XDocumentProperties>& i_xDocProps) :
259 SvXMLImportContext(i_rImport),
260 ScXMLDocContext_Impl(i_rImport),
261 SvXMLMetaDocumentContext(i_rImport, i_xDocProps)
262 {
263 }
264 
265 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
266  ScXMLFlatDocContext_Impl::createFastChildContext( sal_Int32 nElement,
267  const uno::Reference< xml::sax::XFastAttributeList > & xAttrList )
268 {
269  if ( nElement == XML_ELEMENT( OFFICE, XML_META ) )
270  return SvXMLMetaDocumentContext::createFastChildContext( nElement, xAttrList );
271  else
272  return ScXMLDocContext_Impl::createFastChildContext( nElement, xAttrList );
273 }
274 
275 void SAL_CALL ScXMLFlatDocContext_Impl::startFastElement(sal_Int32 nElement,
276  const uno::Reference< xml::sax::XFastAttributeList > & xAttrList)
277 {
278  SvXMLMetaDocumentContext::startFastElement( nElement, xAttrList );
279 }
280 
281 void SAL_CALL ScXMLFlatDocContext_Impl::endFastElement(sal_Int32 nElement)
282 {
283  SvXMLMetaDocumentContext::endFastElement( nElement );
284 }
285 
286 void SAL_CALL ScXMLFlatDocContext_Impl::characters(const OUString& rChars)
287 {
288  SvXMLMetaDocumentContext::characters(rChars);
289 }
290 
291 namespace {
292 
293 class ScXMLBodyContext_Impl : public ScXMLImportContext
294 {
295 public:
296  ScXMLBodyContext_Impl( ScXMLImport& rImport );
297 
298  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL
299  createFastChildContext( sal_Int32 nElement,
300  const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList ) override;
301 };
302 
303 }
304 
305 ScXMLBodyContext_Impl::ScXMLBodyContext_Impl( ScXMLImport& rImport ) :
306 ScXMLImportContext( rImport )
307 {
308 }
309 
310 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
311  ScXMLBodyContext_Impl::createFastChildContext( sal_Int32 /*nElement*/,
312  const uno::Reference< xml::sax::XFastAttributeList > & xAttrList )
313 {
314  sax_fastparser::FastAttributeList *pAttribList =
315  &sax_fastparser::castToFastAttributeList( xAttrList );
316  return GetScImport().CreateBodyContext( pAttribList );
317 }
318 
319 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
320  ScXMLDocContext_Impl::createFastChildContext( sal_Int32 nElement,
321  const uno::Reference< xml::sax::XFastAttributeList > & /*xAttrList*/ )
322 {
323  SvXMLImportContext *pContext(nullptr);
324 
325  switch( nElement )
326  {
327  case XML_ELEMENT( OFFICE, XML_BODY ):
328  if (GetScImport().getImportFlags() & SvXMLImportFlags::CONTENT)
329  pContext = new ScXMLBodyContext_Impl( GetScImport() );
330  break;
331  case XML_ELEMENT( OFFICE, XML_SCRIPTS ):
332  if (GetScImport().getImportFlags() & SvXMLImportFlags::SCRIPTS)
333  pContext = GetScImport().CreateScriptContext();
334  break;
335  case XML_ELEMENT( OFFICE, XML_SETTINGS ):
336  if (GetScImport().getImportFlags() & SvXMLImportFlags::SETTINGS)
337  pContext = new XMLDocumentSettingsContext(GetScImport());
338  break;
339  case XML_ELEMENT(OFFICE, XML_STYLES):
340  if (GetScImport().getImportFlags() & SvXMLImportFlags::STYLES)
341  pContext = GetScImport().CreateStylesContext( false);
342  break;
343  case XML_ELEMENT(OFFICE, XML_AUTOMATIC_STYLES):
344  if (GetScImport().getImportFlags() & SvXMLImportFlags::AUTOSTYLES)
345  pContext = GetScImport().CreateStylesContext( true);
346  break;
347  case XML_ELEMENT(OFFICE, XML_FONT_FACE_DECLS):
348  if (GetScImport().getImportFlags() & SvXMLImportFlags::FONTDECLS)
349  pContext = GetScImport().CreateFontDeclsContext();
350  break;
351  case XML_ELEMENT(OFFICE, XML_MASTER_STYLES):
352  if (GetScImport().getImportFlags() & SvXMLImportFlags::MASTERSTYLES)
353  pContext = new ScXMLMasterStylesContext( GetImport() );
354  break;
355  case XML_ELEMENT(OFFICE, XML_META):
356  SAL_INFO("sc", "XML_ELEMENT(OFFICE, XML_META): should not have come here, maybe document is invalid?");
357  break;
358  }
359 
360  return pContext;
361 }
362 
363 void SAL_CALL ScXMLDocContext_Impl::startFastElement(sal_Int32 /*nElement*/,
364  const uno::Reference< xml::sax::XFastAttributeList > & /*xAttrList*/)
365 {
366 }
367 
368 void SAL_CALL ScXMLDocContext_Impl::endFastElement(sal_Int32 /*nElement*/)
369 {
370 }
371 
372 void SAL_CALL ScXMLDocContext_Impl::characters(const OUString &)
373 {
374 }
375 
376 const SvXMLTokenMap& ScXMLImport::GetTableElemTokenMap()
377 {
378  if( !pTableElemTokenMap )
379  {
380  static const SvXMLTokenMapEntry aTableTokenMap[] =
381  {
382  { XML_NAMESPACE_TABLE, XML_NAMED_EXPRESSIONS, XML_TOK_TABLE_NAMED_EXPRESSIONS },
383  { XML_NAMESPACE_TABLE, XML_TABLE_COLUMN_GROUP, XML_TOK_TABLE_COL_GROUP },
384  { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_COLUMNS, XML_TOK_TABLE_HEADER_COLS },
385  { XML_NAMESPACE_TABLE, XML_TABLE_COLUMNS, XML_TOK_TABLE_COLS },
386  { XML_NAMESPACE_TABLE, XML_TABLE_COLUMN, XML_TOK_TABLE_COL },
387  { XML_NAMESPACE_TABLE, XML_TABLE_PROTECTION, XML_TOK_TABLE_PROTECTION },
388  { XML_NAMESPACE_LO_EXT, XML_TABLE_PROTECTION, XML_TOK_TABLE_PROTECTION_EXT },
389  { XML_NAMESPACE_OFFICE_EXT, XML_TABLE_PROTECTION, XML_TOK_TABLE_PROTECTION_EXT },
390  { XML_NAMESPACE_TABLE, XML_TABLE_ROW_GROUP, XML_TOK_TABLE_ROW_GROUP },
391  { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, XML_TOK_TABLE_HEADER_ROWS },
392  { XML_NAMESPACE_TABLE, XML_TABLE_ROWS, XML_TOK_TABLE_ROWS },
393  { XML_NAMESPACE_TABLE, XML_TABLE_ROW, XML_TOK_TABLE_ROW },
394  { XML_NAMESPACE_TABLE, XML_TABLE_SOURCE, XML_TOK_TABLE_SOURCE },
395  { XML_NAMESPACE_TABLE, XML_SCENARIO, XML_TOK_TABLE_SCENARIO },
396  { XML_NAMESPACE_TABLE, XML_SHAPES, XML_TOK_TABLE_SHAPES },
397  { XML_NAMESPACE_OFFICE, XML_FORMS, XML_TOK_TABLE_FORMS },
398  { XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, XML_TOK_TABLE_EVENT_LISTENERS },
399  { XML_NAMESPACE_OFFICE_EXT, XML_EVENT_LISTENERS, XML_TOK_TABLE_EVENT_LISTENERS_EXT },
400  { XML_NAMESPACE_CALC_EXT, XML_CONDITIONAL_FORMATS, XML_TOK_TABLE_CONDFORMATS },
401  XML_TOKEN_MAP_END
402  };
403 
404  pTableElemTokenMap.reset(new SvXMLTokenMap( aTableTokenMap ));
405  } // if( !pTableElemTokenMap )
406 
407  return *pTableElemTokenMap;
408 }
409 
410 const SvXMLTokenMap& ScXMLImport::GetTableRowsElemTokenMap()
411 {
412  if( !pTableRowsElemTokenMap )
413  {
414  static const SvXMLTokenMapEntry aTableRowsElemTokenMap[] =
415  {
416  { XML_NAMESPACE_TABLE, XML_TABLE_ROW_GROUP, XML_TOK_TABLE_ROWS_ROW_GROUP },
417  { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, XML_TOK_TABLE_ROWS_HEADER_ROWS },
418  { XML_NAMESPACE_TABLE, XML_TABLE_ROWS, XML_TOK_TABLE_ROWS_ROWS },
419  { XML_NAMESPACE_TABLE, XML_TABLE_ROW, XML_TOK_TABLE_ROWS_ROW },
420  XML_TOKEN_MAP_END
421  };
422 
423  pTableRowsElemTokenMap.reset(new SvXMLTokenMap( aTableRowsElemTokenMap ));
424  } // if( !pTableRowsElemTokenMap )
425 
426  return *pTableRowsElemTokenMap;
427 }
428 
429 const SvXMLTokenMap& ScXMLImport::GetTableRowElemTokenMap()
430 {
431  if( !pTableRowElemTokenMap )
432  {
433  static const SvXMLTokenMapEntry aTableRowTokenMap[] =
434  {
435  { XML_NAMESPACE_TABLE, XML_TABLE_CELL, XML_TOK_TABLE_ROW_CELL },
436  { XML_NAMESPACE_TABLE, XML_COVERED_TABLE_CELL, XML_TOK_TABLE_ROW_COVERED_CELL },
437  XML_TOKEN_MAP_END
438  };
439 
440  pTableRowElemTokenMap.reset(new SvXMLTokenMap( aTableRowTokenMap ));
441  } // if( !pTableRowElemTokenMap )
442 
443  return *pTableRowElemTokenMap;
444 }
445 
446 const SvXMLTokenMap& ScXMLImport::GetTableRowAttrTokenMap()
447 {
448  if( !pTableRowAttrTokenMap )
449  {
450  static const SvXMLTokenMapEntry aTableRowAttrTokenMap[] =
451  {
452  { XML_NAMESPACE_TABLE, XML_STYLE_NAME, XML_TOK_TABLE_ROW_ATTR_STYLE_NAME },
453  { XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_TOK_TABLE_ROW_ATTR_VISIBILITY },
454  { XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_REPEATED, XML_TOK_TABLE_ROW_ATTR_REPEATED },
455  { XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME, XML_TOK_TABLE_ROW_ATTR_DEFAULT_CELL_STYLE_NAME },
456  // { XML_NAMESPACE_TABLE, XML_USE_OPTIMAL_HEIGHT, XML_TOK_TABLE_ROW_ATTR_USE_OPTIMAL_HEIGHT },
457  XML_TOKEN_MAP_END
458  };
459 
460  pTableRowAttrTokenMap.reset(new SvXMLTokenMap( aTableRowAttrTokenMap ));
461  } // if( !pTableRowAttrTokenMap )
462 
463  return *pTableRowAttrTokenMap;
464 }
465 
466 const SvXMLTokenMap& ScXMLImport::GetTableRowCellElemTokenMap()
467 {
468  if( !pTableRowCellElemTokenMap )
469  {
470  static const SvXMLTokenMapEntry aTableRowCellTokenMap[] =
471  {
472  { XML_NAMESPACE_TEXT, XML_P, XML_TOK_TABLE_ROW_CELL_P },
473  { XML_NAMESPACE_TABLE, XML_SUB_TABLE, XML_TOK_TABLE_ROW_CELL_TABLE },
474  { XML_NAMESPACE_OFFICE, XML_ANNOTATION, XML_TOK_TABLE_ROW_CELL_ANNOTATION },
475  { XML_NAMESPACE_TABLE, XML_DETECTIVE, XML_TOK_TABLE_ROW_CELL_DETECTIVE },
476  { XML_NAMESPACE_TABLE, XML_CELL_RANGE_SOURCE, XML_TOK_TABLE_ROW_CELL_CELL_RANGE_SOURCE },
477  XML_TOKEN_MAP_END
478  };
479 
480  pTableRowCellElemTokenMap.reset(new SvXMLTokenMap( aTableRowCellTokenMap ));
481  } // if( !pTableRowCellElemTokenMap )
482 
483  return *pTableRowCellElemTokenMap;
484 }
485 
486 const SvXMLTokenMap& ScXMLImport::GetTableAnnotationAttrTokenMap()
487 {
488  if( !pTableAnnotationAttrTokenMap )
489  {
490  static const SvXMLTokenMapEntry aTableAnnotationAttrTokenMap[] =
491  {
492  { XML_NAMESPACE_OFFICE, XML_AUTHOR, XML_TOK_TABLE_ANNOTATION_ATTR_AUTHOR },
493  { XML_NAMESPACE_OFFICE, XML_CREATE_DATE, XML_TOK_TABLE_ANNOTATION_ATTR_CREATE_DATE },
494  { XML_NAMESPACE_OFFICE, XML_CREATE_DATE_STRING, XML_TOK_TABLE_ANNOTATION_ATTR_CREATE_DATE_STRING },
495  { XML_NAMESPACE_OFFICE, XML_DISPLAY, XML_TOK_TABLE_ANNOTATION_ATTR_DISPLAY },
496  { XML_NAMESPACE_SVG, XML_X, XML_TOK_TABLE_ANNOTATION_ATTR_X },
497  { XML_NAMESPACE_SVG, XML_Y, XML_TOK_TABLE_ANNOTATION_ATTR_Y },
498  XML_TOKEN_MAP_END
499  };
500 
501  pTableAnnotationAttrTokenMap.reset(new SvXMLTokenMap( aTableAnnotationAttrTokenMap ));
502  } // if( !pTableAnnotationAttrTokenMap )
503 
504  return *pTableAnnotationAttrTokenMap;
505 }
506 
507 
508 void ScXMLImport::SetPostProcessData( sc::ImportPostProcessData* p )
509 {
510  mpPostProcessData = p;
511 }
512 
513 sc::PivotTableSources& ScXMLImport::GetPivotTableSources()
514 {
515  if (!mpPivotSources)
516  mpPivotSources.reset(new sc::PivotTableSources);
517 
518  return *mpPivotSources;
519 }
520 
521 SvXMLImportContext *ScXMLImport::CreateFastContext( sal_Int32 nElement,
522  const uno::Reference< xml::sax::XFastAttributeList >& /*xAttrList*/ )
523 {
524  SvXMLImportContext *pContext = nullptr;
525 
526  switch( nElement )
527  {
528  case XML_ELEMENT( OFFICE, XML_DOCUMENT_STYLES ):
529  case XML_ELEMENT( OFFICE, XML_DOCUMENT_CONTENT ):
530  case XML_ELEMENT( OFFICE, XML_DOCUMENT_SETTINGS ):
531  pContext = new ScXMLDocContext_Impl( *this );
532  break;
533 
534  case XML_ELEMENT( OFFICE, XML_DOCUMENT_META ):
535  pContext = CreateMetaContext(nElement);
536  break;
537 
538  case XML_ELEMENT( OFFICE, XML_DOCUMENT ):
539  {
540  uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
541  GetModel(), uno::UNO_QUERY_THROW);
542  // flat OpenDocument file format
543  pContext = new ScXMLFlatDocContext_Impl( *this,
544  xDPS->getDocumentProperties());
545  break;
546  }
547 
548  }
549 
550  return pContext;
551 }
552 
553 constexpr OUStringLiteral gsNumberFormat(SC_UNONAME_NUMFMT);
554 constexpr OUStringLiteral gsLocale(SC_LOCALE);
555 constexpr OUStringLiteral gsCellStyle(SC_UNONAME_CELLSTYL);
556 
557 ScXMLImport::ScXMLImport(
558  const css::uno::Reference< css::uno::XComponentContext >& rContext,
559  OUString const & implementationName, SvXMLImportFlags nImportFlag,
560  const css::uno::Sequence< OUString > & sSupportedServiceNames)
561 : SvXMLImport( rContext, implementationName, nImportFlag, sSupportedServiceNames ),
562  pDoc( nullptr ),
563  mpPostProcessData(nullptr),
564  aTables(*this),
565  sPrevStyleName(),
566  sPrevCurrency(),
567  nSolarMutexLocked(0),
568  nProgressCount(0),
569  nPrevCellType(0),
570  bLoadDoc( true ),
571  bNullDateSetted(false),
572  bSelfImportingXMLSet(false),
573  mbLockSolarMutex(true),
574  mbImportStyles(true),
575  mbHasNewCondFormatData(false)
576 {
577  pStylesImportHelper.reset(new ScMyStylesImportHelper(*this));
578 
579  xScPropHdlFactory = new XMLScPropHdlFactory;
580  xCellStylesPropertySetMapper = new XMLPropertySetMapper(aXMLScCellStylesProperties, xScPropHdlFactory, false);
581  xColumnStylesPropertySetMapper = new XMLPropertySetMapper(aXMLScColumnStylesProperties, xScPropHdlFactory, false);
582  xRowStylesPropertySetMapper = new XMLPropertySetMapper(aXMLScRowStylesImportProperties, xScPropHdlFactory, false);
583  xTableStylesPropertySetMapper = new XMLPropertySetMapper(aXMLScTableStylesImportProperties, xScPropHdlFactory, false);
584 
585  // #i66550# needed for 'presentation:event-listener' element for URLs in shapes
586  GetNamespaceMap().Add(
587  GetXMLToken( XML_NP_PRESENTATION ),
588  GetXMLToken( XML_N_PRESENTATION ),
589  XML_NAMESPACE_PRESENTATION );
590 }
591 
592 ScXMLImport::~ScXMLImport() throw()
593 {
594  // delete pI18NMap;
595  pTableElemTokenMap.reset();
596  pTableRowsElemTokenMap.reset();
597  pTableRowElemTokenMap.reset();
598  pTableRowAttrTokenMap.reset();
599  pTableRowCellElemTokenMap.reset();
600  pTableRowCellAttrTokenMap.reset();
601  pTableAnnotationAttrTokenMap.reset();
602 
603  pChangeTrackingImportHelper.reset();
604  pNumberFormatAttributesExportHelper.reset();
605  pStyleNumberFormats.reset();
606  pStylesImportHelper.reset();
607 
608  m_pMyNamedExpressions.reset();
609  pMyLabelRanges.reset();
610  pValidations.reset();
611  pDetectiveOpArray.reset();
612 
613  //call SvXMLImport dtor contents before deleting pSolarMutexGuard
614  cleanup();
615 
616  pSolarMutexGuard.reset();
617 }
618 
619 void ScXMLImport::initialize( const css::uno::Sequence<css::uno::Any>& aArguments )
620 {
621  SvXMLImport::initialize(aArguments);
622 
623  uno::Reference<beans::XPropertySet> xInfoSet = getImportInfo();
624  if (!xInfoSet.is())
625  return;
626 
627  uno::Reference<beans::XPropertySetInfo> xInfoSetInfo = xInfoSet->getPropertySetInfo();
628  if (!xInfoSetInfo.is())
629  return;
630 
631  if (xInfoSetInfo->hasPropertyByName(SC_UNO_ODS_LOCK_SOLAR_MUTEX))
632  xInfoSet->getPropertyValue(SC_UNO_ODS_LOCK_SOLAR_MUTEX) >>= mbLockSolarMutex;
633 
634  if (xInfoSetInfo->hasPropertyByName(SC_UNO_ODS_IMPORT_STYLES))
635  xInfoSet->getPropertyValue(SC_UNO_ODS_IMPORT_STYLES) >>= mbImportStyles;
636 }
637 
638 SvXMLImportContext *ScXMLImport::CreateFontDeclsContext()
639 {
640  XMLFontStylesContext *pFSContext = new XMLFontStylesContext(
641  *this, osl_getThreadTextEncoding());
642  SetFontDecls(pFSContext);
643  SvXMLImportContext* pContext = pFSContext;
644  return pContext;
645 }
646 
647 SvXMLImportContext *ScXMLImport::CreateStylesContext( bool bIsAutoStyle )
648 {
649  SvXMLImportContext* pContext = new XMLTableStylesContext(
650  *this, bIsAutoStyle);
651 
652  if (bIsAutoStyle)
653  SetAutoStyles(static_cast<SvXMLStylesContext*>(pContext));
654  else
655  SetStyles(static_cast<SvXMLStylesContext*>(pContext));
656 
657  return pContext;
658 }
659 
660 SvXMLImportContext *ScXMLImport::CreateBodyContext(const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList)
661 {
662  return new ScXMLBodyContext(*this, rAttrList);
663 }
664 
665 SvXMLImportContext *ScXMLImport::CreateMetaContext(
666  const sal_Int32 /*nElement*/ )
667 {
668  SvXMLImportContext* pContext = nullptr;
669 
670  if (getImportFlags() & SvXMLImportFlags::META)
671  {
672  uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
673  GetModel(), uno::UNO_QUERY_THROW);
674  uno::Reference<document::XDocumentProperties> const xDocProps(
675  (IsStylesOnlyMode()) ? nullptr : xDPS->getDocumentProperties());
676  pContext = new SvXMLMetaDocumentContext(*this, xDocProps);
677  }
678 
679  return pContext;
680 }
681 
682 SvXMLImportContext *ScXMLImport::CreateScriptContext()
683 {
684  SvXMLImportContext* pContext = nullptr;
685 
686  if( !(IsStylesOnlyMode()) )
687  {
688  pContext = new XMLScriptContext( *this, GetModel() );
689  }
690 
691  return pContext;
692 }
693 
694 void ScXMLImport::SetStatistics(const uno::Sequence<beans::NamedValue> & i_rStats)
695 {
696  static const char* s_stats[] =
697  { "TableCount", "CellCount", "ObjectCount", nullptr };
698 
699  SvXMLImport::SetStatistics(i_rStats);
700 
701  sal_uInt32 nCount(0);
702  for (const auto& rStat : i_rStats) {
703  for (const char** pStat = s_stats; *pStat != nullptr; ++pStat) {
704  if (rStat.Name.equalsAscii(*pStat)) {
705  sal_Int32 val = 0;
706  if (rStat.Value >>= val) {
707  nCount += val;
708  } else {
709  OSL_FAIL("ScXMLImport::SetStatistics: invalid entry");
710  }
711  }
712  }
713  }
714 
715  if (nCount)
716  {
717  GetProgressBarHelper()->SetReference(nCount);
718  GetProgressBarHelper()->SetValue(0);
719  }
720 }
721 
722 ScDocumentImport& ScXMLImport::GetDoc()
723 {
724  return *mpDocImport;
725 }
726 
727 sal_Int16 ScXMLImport::GetCellType(const char* rStrValue, const sal_Int32 nStrLength)
728 {
729  sal_Int16 nCellType = util::NumberFormat::UNDEFINED;
730  if (rStrValue != nullptr)
731  {
732  switch (rStrValue[0])
733  {
734  case 'b':
735  if (nStrLength == 7 && !strcmp(rStrValue, "boolean"))
736  nCellType = util::NumberFormat::LOGICAL;
737  break;
738  case 'c':
739  if (nStrLength == 8 && !strcmp(rStrValue, "currency"))
740  nCellType = util::NumberFormat::CURRENCY;
741  break;
742  case 'd':
743  if (nStrLength == 4 && !strcmp(rStrValue, "date"))
744  nCellType = util::NumberFormat::DATETIME;
745  break;
746  case 'f':
747  if (nStrLength == 5 && !strcmp(rStrValue, "float"))
748  nCellType = util::NumberFormat::NUMBER;
749  break;
750  case 'p':
751  if (nStrLength == 10 && !strcmp(rStrValue, "percentage"))
752  nCellType = util::NumberFormat::PERCENT;
753  break;
754  case 's':
755  if (nStrLength == 6 && !strcmp(rStrValue, "string"))
756  nCellType = util::NumberFormat::TEXT;
757  break;
758  case 't':
759  if (nStrLength == 4 && !strcmp(rStrValue, "time"))
760  nCellType = util::NumberFormat::TIME;
761  break;
762  }
763  }
764 
765  return nCellType;
766 }
767 
768 XMLShapeImportHelper* ScXMLImport::CreateShapeImport()
769 {
770  return new XMLTableShapeImportHelper(*this);
771 }
772 
773 bool ScXMLImport::GetValidation(const OUString& sName, ScMyImportValidation& aValidation)
774 {
775  if (pValidations)
776  {
777  auto aItr = std::find_if(pValidations->begin(), pValidations->end(),
778  [&sName](const ScMyImportValidation& rValidation) { return rValidation.sName == sName; });
779  if (aItr != pValidations->end())
780  {
781  // source position must be set as string,
782  // so sBaseCellAddress no longer has to be converted here
783  aValidation = *aItr;
784  return true;
785  }
786  }
787  return false;
788 }
789 
790 void ScXMLImport::AddNamedExpression(SCTAB nTab, ScMyNamedExpression* pNamedExp)
791 {
792  ::std::unique_ptr<ScMyNamedExpression> p(pNamedExp);
793  SheetNamedExpMap::iterator itr = m_SheetNamedExpressions.find(nTab);
794  if (itr == m_SheetNamedExpressions.end())
795  {
796  // No chain exists for this sheet. Create one.
797  ::std::pair<SheetNamedExpMap::iterator, bool> r =
798  m_SheetNamedExpressions.insert(std::make_pair(nTab, std::make_unique<ScMyNamedExpressions>()));
799  if (!r.second)
800  // insertion failed.
801  return;
802 
803  itr = r.first;
804  }
805  ScMyNamedExpressions& r = *itr->second;
806  r.push_back(std::move(p));
807 }
808 
809 ScXMLChangeTrackingImportHelper* ScXMLImport::GetChangeTrackingImportHelper()
810 {
811  if (!pChangeTrackingImportHelper)
812  pChangeTrackingImportHelper.reset(new ScXMLChangeTrackingImportHelper());
813  return pChangeTrackingImportHelper.get();
814 }
815 
816 void ScXMLImport::InsertStyles()
817 {
818  GetStyles()->CopyStylesToDoc(true);
819 
820  // if content is going to be loaded with the same import, set bLatinDefaultStyle flag now
821  if ( getImportFlags() & SvXMLImportFlags::CONTENT )
822  ExamineDefaultStyle();
823 }
824 
825 void ScXMLImport::ExamineDefaultStyle()
826 {
827  if (pDoc)
828  {
829  // #i62435# after inserting the styles, check if the default style has a latin-script-only
830  // number format (then, value cells can be pre-initialized with western script type)
831 
832  const ScPatternAttr* pDefPattern = pDoc->GetDefPattern();
833  if (pDefPattern && sc::NumFmtUtil::isLatinScript(*pDefPattern, *pDoc))
834  mpDocImport->setDefaultNumericScript(SvtScriptType::LATIN);
835  }
836 }
837 
838 void ScXMLImport::SetChangeTrackingViewSettings(const css::uno::Sequence<css::beans::PropertyValue>& rChangeProps)
839 {
840  if (!pDoc)
841  return;
842 
843  if (!rChangeProps.hasElements())
844  return;
845 
846  ScXMLImport::MutexGuard aGuard(*this);
847  sal_Int16 nTemp16(0);
848  std::unique_ptr<ScChangeViewSettings> pViewSettings(new ScChangeViewSettings());
849  for (const auto& rChangeProp : rChangeProps)
850  {
851  OUString sName(rChangeProp.Name);
852  if (sName == "ShowChanges")
853  pViewSettings->SetShowChanges(::cppu::any2bool(rChangeProp.Value));
854  else if (sName == "ShowAcceptedChanges")
855  pViewSettings->SetShowAccepted(::cppu::any2bool(rChangeProp.Value));
856  else if (sName == "ShowRejectedChanges")
857  pViewSettings->SetShowRejected(::cppu::any2bool(rChangeProp.Value));
858  else if (sName == "ShowChangesByDatetime")
859  pViewSettings->SetHasDate(::cppu::any2bool(rChangeProp.Value));
860  else if (sName == "ShowChangesByDatetimeMode")
861  {
862  if (rChangeProp.Value >>= nTemp16)
863  pViewSettings->SetTheDateMode(static_cast<SvxRedlinDateMode>(nTemp16));
864  }
865  else if (sName == "ShowChangesByDatetimeFirstDatetime")
866  {
867  util::DateTime aDateTime;
868  if (rChangeProp.Value >>= aDateTime)
869  {
870  pViewSettings->SetTheFirstDateTime(::DateTime(aDateTime));
871  }
872  }
873  else if (sName == "ShowChangesByDatetimeSecondDatetime")
874  {
875  util::DateTime aDateTime;
876  if (rChangeProp.Value >>= aDateTime)
877  {
878  pViewSettings->SetTheLastDateTime(::DateTime(aDateTime));
879  }
880  }
881  else if (sName == "ShowChangesByAuthor")
882  pViewSettings->SetHasAuthor(::cppu::any2bool(rChangeProp.Value));
883  else if (sName == "ShowChangesByAuthorName")
884  {
885  OUString sOUName;
886  if (rChangeProp.Value >>= sOUName)
887  {
888  pViewSettings->SetTheAuthorToShow(sOUName);
889  }
890  }
891  else if (sName == "ShowChangesByComment")
892  pViewSettings->SetHasComment(::cppu::any2bool(rChangeProp.Value));
893  else if (sName == "ShowChangesByCommentText")
894  {
895  OUString sOUComment;
896  if (rChangeProp.Value >>= sOUComment)
897  {
898  pViewSettings->SetTheComment(sOUComment);
899  }
900  }
901  else if (sName == "ShowChangesByRanges")
902  pViewSettings->SetHasRange(::cppu::any2bool(rChangeProp.Value));
903  else if (sName == "ShowChangesByRangesList")
904  {
905  OUString sRanges;
906  if ((rChangeProp.Value >>= sRanges) && !sRanges.isEmpty())
907  {
908  ScRangeList aRangeList;
909  ScRangeStringConverter::GetRangeListFromString(
910  aRangeList, sRanges, GetDocument(), FormulaGrammar::CONV_OOO);
911  pViewSettings->SetTheRangeList(aRangeList);
912  }
913  }
914  }
915  pDoc->SetChangeViewSettings(*pViewSettings);
916 }
917 
918 void ScXMLImport::SetViewSettings(const uno::Sequence<beans::PropertyValue>& aViewProps)
919 {
920  sal_Int32 nHeight(0);
921  sal_Int32 nLeft(0);
922  sal_Int32 nTop(0);
923  sal_Int32 nWidth(0);
924  for (const auto& rViewProp : aViewProps)
925  {
926  OUString sName(rViewProp.Name);
927  if (sName == "VisibleAreaHeight")
928  rViewProp.Value >>= nHeight;
929  else if (sName == "VisibleAreaLeft")
930  rViewProp.Value >>= nLeft;
931  else if (sName == "VisibleAreaTop")
932  rViewProp.Value >>= nTop;
933  else if (sName == "VisibleAreaWidth")
934  rViewProp.Value >>= nWidth;
935  else if (sName == "TrackedChangesViewSettings")
936  {
937  uno::Sequence<beans::PropertyValue> aChangeProps;
938  if(rViewProp.Value >>= aChangeProps)
939  SetChangeTrackingViewSettings(aChangeProps);
940  }
941  }
942  if (!(nHeight && nWidth && GetModel().is()))
943  return;
944 
945  ScModelObj* pDocObj(comphelper::getUnoTunnelImplementation<ScModelObj>( GetModel() ));
946  if (!pDocObj)
947  return;
948 
949  SfxObjectShell* pEmbeddedObj = pDocObj->GetEmbeddedObject();
950  if (pEmbeddedObj)
951  {
952  tools::Rectangle aRect;
953  aRect.setX( nLeft );
954  aRect.setY( nTop );
955  aRect.setWidth( nWidth );
956  aRect.setHeight( nHeight );
957  pEmbeddedObj->SetVisArea(aRect);
958  }
959 }
960 
961 void ScXMLImport::SetConfigurationSettings(const uno::Sequence<beans::PropertyValue>& aConfigProps)
962 {
963  if (!GetModel().is())
964  return;
965 
966  uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
967  if (!xMultiServiceFactory.is())
968  return;
969 
970  sal_Int32 nCount(aConfigProps.getLength());
971  css::uno::Sequence<css::beans::PropertyValue> aFilteredProps(nCount);
972  sal_Int32 nFilteredPropsLen = 0;
973  for (sal_Int32 i = nCount - 1; i >= 0; --i)
974  {
975  if (aConfigProps[i].Name == "TrackedChangesProtectionKey")
976  {
977  OUString sKey;
978  if (aConfigProps[i].Value >>= sKey)
979  {
980  uno::Sequence<sal_Int8> aPass;
981  ::comphelper::Base64::decode(aPass, sKey);
982  if (aPass.hasElements())
983  {
984  if (pDoc->GetChangeTrack())
985  pDoc->GetChangeTrack()->SetProtection(aPass);
986  else
987  {
988  std::set<OUString> aUsers;
989  std::unique_ptr<ScChangeTrack> pTrack( new ScChangeTrack(pDoc, aUsers) );
990  pTrack->SetProtection(aPass);
991  pDoc->SetChangeTrack(std::move(pTrack));
992  }
993  }
994  }
995  }
996  // store the following items for later use (after document is loaded)
997  else if ((aConfigProps[i].Name == "VBACompatibilityMode") || (aConfigProps[i].Name == "ScriptConfiguration"))
998  {
999  uno::Reference< beans::XPropertySet > xImportInfo = getImportInfo();
1000  if (xImportInfo.is())
1001  {
1002  uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = xImportInfo->getPropertySetInfo();
1003  if (xPropertySetInfo.is() && xPropertySetInfo->hasPropertyByName(aConfigProps[i].Name))
1004  xImportInfo->setPropertyValue( aConfigProps[i].Name, aConfigProps[i].Value );
1005  }
1006  }
1007  if (aConfigProps[i].Name != "LinkUpdateMode")
1008  {
1009  aFilteredProps[nFilteredPropsLen++] = aConfigProps[i];
1010  }
1011  }
1012  aFilteredProps.realloc(nFilteredPropsLen);
1013  uno::Reference <uno::XInterface> xInterface = xMultiServiceFactory->createInstance("com.sun.star.comp.SpreadsheetSettings");
1014  uno::Reference <beans::XPropertySet> xProperties(xInterface, uno::UNO_QUERY);
1015  if (xProperties.is())
1016  SvXMLUnitConverter::convertPropertySet(xProperties, aFilteredProps);
1017 }
1018 
1019 sal_Int32 ScXMLImport::SetCurrencySymbol(const sal_Int32 nKey, const OUString& rCurrency)
1020 {
1021  uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
1022  if (xNumberFormatsSupplier.is())
1023  {
1024  uno::Reference <util::XNumberFormats> xLocalNumberFormats(xNumberFormatsSupplier->getNumberFormats());
1025  if (xLocalNumberFormats.is())
1026  {
1027  OUString sFormatString;
1028  try
1029  {
1030  uno::Reference <beans::XPropertySet> xProperties(xLocalNumberFormats->getByKey(nKey));
1031  if (xProperties.is())
1032  {
1033  lang::Locale aLocale;
1034  if (GetDocument() && (xProperties->getPropertyValue(gsLocale) >>= aLocale))
1035  {
1036  {
1037  ScXMLImport::MutexGuard aGuard(*this);
1038  LocaleDataWrapper aLocaleData( comphelper::getProcessComponentContext(), LanguageTag( aLocale) );
1039  OUStringBuffer aBuffer(15);
1040  aBuffer.append("#");
1041  aBuffer.append( aLocaleData.getNumThousandSep() );
1042  aBuffer.append("##0");
1043  aBuffer.append( aLocaleData.getNumDecimalSep() );
1044  aBuffer.append("00 [$");
1045  aBuffer.append(rCurrency);
1046  aBuffer.append("]");
1047  sFormatString = aBuffer.makeStringAndClear();
1048  }
1049  sal_Int32 nNewKey = xLocalNumberFormats->queryKey(sFormatString, aLocale, true);
1050  if (nNewKey == -1)
1051  nNewKey = xLocalNumberFormats->addNew(sFormatString, aLocale);
1052  return nNewKey;
1053  }
1054  }
1055  }
1056  catch ( const util::MalformedNumberFormatException& rException )
1057  {
1058  OUString sErrorMessage ="Error in Formatstring " +
1059  sFormatString + " at position " +
1060  OUString::number(rException.CheckPos);
1061  uno::Sequence<OUString> aSeq { sErrorMessage };
1062  uno::Reference<xml::sax::XLocator> xLocator;
1063  SetError(XMLERROR_API | XMLERROR_FLAG_ERROR, aSeq, rException.Message, xLocator);
1064  }
1065  }
1066  }
1067  return nKey;
1068 }
1069 
1070 bool ScXMLImport::IsCurrencySymbol(const sal_Int32 nNumberFormat, const OUString& sCurrentCurrency, const OUString& sBankSymbol)
1071 {
1072  uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
1073  if (xNumberFormatsSupplier.is())
1074  {
1075  uno::Reference <util::XNumberFormats> xLocalNumberFormats(xNumberFormatsSupplier->getNumberFormats());
1076  if (xLocalNumberFormats.is())
1077  {
1078  try
1079  {
1080  uno::Reference <beans::XPropertySet> xNumberPropertySet(xLocalNumberFormats->getByKey(nNumberFormat));
1081  if (xNumberPropertySet.is())
1082  {
1083  OUString sTemp;
1084  if ( xNumberPropertySet->getPropertyValue(SC_CURRENCYSYMBOL) >>= sTemp)
1085  {
1086  if (sCurrentCurrency == sTemp)
1087  return true;
1088  // A release that saved an unknown currency may have
1089  // saved the currency symbol of the number format
1090  // instead of an ISO code bank symbol. In another
1091  // release we may have a match for that. In this case
1092  // sCurrentCurrency is the ISO code obtained through
1093  // XMLNumberFormatAttributesExportHelper::GetCellType()
1094  // and sBankSymbol is the currency symbol.
1095  if (sCurrentCurrency.getLength() == 3 && sBankSymbol == sTemp)
1096  return true;
1097  // #i61657# This may be a legacy currency symbol that changed in the meantime.
1098  if (SvNumberFormatter::GetLegacyOnlyCurrencyEntry( sCurrentCurrency, sBankSymbol) != nullptr)
1099  return true;
1100  // In the rare case that sCurrentCurrency is not the
1101  // currency symbol, but a matching ISO code
1102  // abbreviation instead that was obtained through
1103  // XMLNumberFormatAttributesExportHelper::GetCellType(),
1104  // check with the number format's symbol. This happens,
1105  // for example, in the es_BO locale, where a legacy
1106  // B$,BOB matched B$->BOP, which leads to
1107  // sCurrentCurrency being BOP, and the previous call
1108  // with BOP,BOB didn't find an entry, but B$,BOB will.
1109  return SvNumberFormatter::GetLegacyOnlyCurrencyEntry( sTemp, sBankSymbol) != nullptr;
1110  }
1111  }
1112  }
1113  catch ( uno::Exception& )
1114  {
1115  OSL_FAIL("Numberformat not found");
1116  }
1117  }
1118  }
1119  return false;
1120 }
1121 
1122 void ScXMLImport::SetType(const uno::Reference <beans::XPropertySet>& rProperties,
1123  sal_Int32& rNumberFormat,
1124  const sal_Int16 nCellType,
1125  const OUString& rCurrency)
1126 {
1127  if (!mbImportStyles)
1128  return;
1129 
1130  if ((nCellType == util::NumberFormat::TEXT) || (nCellType == util::NumberFormat::UNDEFINED))
1131  return;
1132 
1133  if (rNumberFormat == -1)
1134  rProperties->getPropertyValue( gsNumberFormat ) >>= rNumberFormat;
1135  OSL_ENSURE(rNumberFormat != -1, "no NumberFormat");
1136  bool bIsStandard;
1137  // sCurrentCurrency may be the ISO code abbreviation if the currency
1138  // symbol matches such, or if no match found the symbol itself!
1139  OUString sCurrentCurrency;
1140  sal_Int32 nCurrentCellType(
1141  GetNumberFormatAttributesExportHelper()->GetCellType(
1142  rNumberFormat, sCurrentCurrency, bIsStandard) & ~util::NumberFormat::DEFINED);
1143  // If the (numeric) cell type (number, currency, date, time, boolean)
1144  // is different from the format type then for some combinations we may
1145  // have to apply a format, e.g. in case the generator deduced format
1146  // from type and did not apply a format but we don't keep a dedicated
1147  // type internally. Specifically this is necessary if the cell type is
1148  // not number but the format type is (i.e. General). Currency cells
1149  // need extra attention, see calls of ScXMLImport::IsCurrencySymbol()
1150  // and description within there and ScXMLImport::SetCurrencySymbol().
1151  if ((nCellType != nCurrentCellType) &&
1152  (nCellType != util::NumberFormat::NUMBER) &&
1153  (bIsStandard || (nCellType == util::NumberFormat::CURRENCY)))
1154  {
1155  if (!xNumberFormats.is())
1156  {
1157  uno::Reference <util::XNumberFormatsSupplier> xNumberFormatsSupplier(GetNumberFormatsSupplier());
1158  if (xNumberFormatsSupplier.is())
1159  xNumberFormats.set(xNumberFormatsSupplier->getNumberFormats());
1160  }
1161  if (xNumberFormats.is())
1162  {
1163  try
1164  {
1165  uno::Reference < beans::XPropertySet> xNumberFormatProperties(xNumberFormats->getByKey(rNumberFormat));
1166  if (xNumberFormatProperties.is())
1167  {
1168  if (nCellType != util::NumberFormat::CURRENCY)
1169  {
1170  lang::Locale aLocale;
1171  if ( xNumberFormatProperties->getPropertyValue(gsLocale) >>= aLocale )
1172  {
1173  if (!xNumberFormatTypes.is())
1174  xNumberFormatTypes.set(uno::Reference <util::XNumberFormatTypes>(xNumberFormats, uno::UNO_QUERY));
1175  rProperties->setPropertyValue( gsNumberFormat, uno::makeAny(xNumberFormatTypes->getStandardFormat(nCellType, aLocale)) );
1176  }
1177  }
1178  else if (!rCurrency.isEmpty() && !sCurrentCurrency.isEmpty())
1179  {
1180  if (sCurrentCurrency != rCurrency)
1181  if (!IsCurrencySymbol(rNumberFormat, sCurrentCurrency, rCurrency))
1182  rProperties->setPropertyValue( gsNumberFormat, uno::makeAny(SetCurrencySymbol(rNumberFormat, rCurrency)));
1183  }
1184  }
1185  }
1186  catch ( uno::Exception& )
1187  {
1188  OSL_FAIL("Numberformat not found");
1189  }
1190  }
1191  }
1192  else
1193  {
1194  if ((nCellType == util::NumberFormat::CURRENCY) && !rCurrency.isEmpty() && !sCurrentCurrency.isEmpty() &&
1195  sCurrentCurrency != rCurrency && !IsCurrencySymbol(rNumberFormat, sCurrentCurrency, rCurrency))
1196  rProperties->setPropertyValue( gsNumberFormat, uno::makeAny(SetCurrencySymbol(rNumberFormat, rCurrency)));
1197  }
1198 }
1199 
1200 void ScXMLImport::SetStyleToRanges()
1201 {
1202  if (!mbImportStyles)
1203  return;
1204 
1205  if (!sPrevStyleName.isEmpty())
1206  {
1207  uno::Reference <beans::XPropertySet> xProperties (xSheetCellRanges, uno::UNO_QUERY);
1208  if (xProperties.is())
1209  {
1210  XMLTableStylesContext *pStyles(static_cast<XMLTableStylesContext *>(GetAutoStyles()));
1211  XMLTableStyleContext* pStyle = nullptr;
1212  if ( pStyles )
1213  pStyle = const_cast<XMLTableStyleContext*>(static_cast<const XMLTableStyleContext *>(pStyles->FindStyleChildContext(
1214  XmlStyleFamily::TABLE_CELL, sPrevStyleName, true)));
1215  if (pStyle)
1216  {
1217  pStyle->FillPropertySet(xProperties);
1218  // here needs to be the cond format import method
1219  sal_Int32 nNumberFormat(pStyle->GetNumberFormat());
1220  SetType(xProperties, nNumberFormat, nPrevCellType, sPrevCurrency);
1221 
1222  css::uno::Any aAny = xProperties->getPropertyValue("FormatID");
1223  sal_uInt64 nKey = 0;
1224  if ((aAny >>= nKey) && nKey)
1225  {
1226  ScFormatSaveData* pFormatSaveData = comphelper::getUnoTunnelImplementation<ScModelObj>(GetModel())->GetFormatSaveData();
1227  pFormatSaveData->maIDToName.insert(std::pair<sal_uInt64, OUString>(nKey, sPrevStyleName));
1228  }
1229 
1230  // store first cell of first range for each style, once per sheet
1231  uno::Sequence<table::CellRangeAddress> aAddresses(xSheetCellRanges->getRangeAddresses());
1232  pStyle->ApplyCondFormat(aAddresses);
1233  if ( aAddresses.hasElements() )
1234  {
1235  const table::CellRangeAddress& rRange = aAddresses[0];
1236  if ( rRange.Sheet != pStyle->GetLastSheet() )
1237  {
1238  ScSheetSaveData* pSheetData = comphelper::getUnoTunnelImplementation<ScModelObj>(GetModel())->GetSheetSaveData();
1239  pSheetData->AddCellStyle( sPrevStyleName,
1240  ScAddress( static_cast<SCCOL>(rRange.StartColumn), static_cast<SCROW>(rRange.StartRow), static_cast<SCTAB>(rRange.Sheet) ) );
1241  pStyle->SetLastSheet(rRange.Sheet);
1242  }
1243  }
1244  }
1245  else
1246  {
1247  xProperties->setPropertyValue(gsCellStyle, uno::makeAny(GetStyleDisplayName( XmlStyleFamily::TABLE_CELL, sPrevStyleName )));
1248  sal_Int32 nNumberFormat(GetStyleNumberFormats()->GetStyleNumberFormat(sPrevStyleName));
1249  bool bInsert(nNumberFormat == -1);
1250  SetType(xProperties, nNumberFormat, nPrevCellType, sPrevCurrency);
1251  if (bInsert)
1252  GetStyleNumberFormats()->AddStyleNumberFormat(sPrevStyleName, nNumberFormat);
1253  }
1254  }
1255  }
1256  if (GetModel().is())
1257  {
1258  uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
1259  if (xMultiServiceFactory.is())
1260  xSheetCellRanges.set(uno::Reference <sheet::XSheetCellRangeContainer>(
1261  xMultiServiceFactory->createInstance("com.sun.star.sheet.SheetCellRanges"),
1262  uno::UNO_QUERY));
1263  }
1264  OSL_ENSURE(xSheetCellRanges.is(), "didn't get SheetCellRanges");
1265 }
1266 
1267 void ScXMLImport::SetStyleToRanges(const ScRangeList& rRanges, const OUString* pStyleName,
1268  const sal_Int16 nCellType, const OUString* pCurrency)
1269 {
1270  if (!mbImportStyles)
1271  return;
1272 
1273  if (sPrevStyleName.isEmpty())
1274  {
1275  nPrevCellType = nCellType;
1276  if (pStyleName)
1277  sPrevStyleName = *pStyleName;
1278  if (pCurrency)
1279  sPrevCurrency = *pCurrency;
1280  else if (!sPrevCurrency.isEmpty())
1281  sPrevCurrency.clear();
1282  }
1283  else if ((nCellType != nPrevCellType) ||
1284  ((pStyleName && *pStyleName != sPrevStyleName) ||
1285  (!pStyleName && !sPrevStyleName.isEmpty())) ||
1286  ((pCurrency && *pCurrency != sPrevCurrency) ||
1287  (!pCurrency && !sPrevCurrency.isEmpty())))
1288  {
1289  SetStyleToRanges();
1290  nPrevCellType = nCellType;
1291  if (pStyleName)
1292  sPrevStyleName = *pStyleName;
1293  else if(!sPrevStyleName.isEmpty())
1294  sPrevStyleName.clear();
1295  if (pCurrency)
1296  sPrevCurrency = *pCurrency;
1297  else if(!sPrevCurrency.isEmpty())
1298  sPrevCurrency.clear();
1299  }
1300 
1301  if (!xSheetCellRanges.is() && GetModel().is())
1302  {
1303  uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
1304  if (xMultiServiceFactory.is())
1305  xSheetCellRanges.set(uno::Reference <sheet::XSheetCellRangeContainer>(xMultiServiceFactory->createInstance("com.sun.star.sheet.SheetCellRanges"), uno::UNO_QUERY));
1306  OSL_ENSURE(xSheetCellRanges.is(), "didn't get SheetCellRanges");
1307 
1308  }
1309  static_cast<ScCellRangesObj*>(xSheetCellRanges.get())->SetNewRanges(rRanges);
1310 }
1311 
1312 bool ScXMLImport::SetNullDateOnUnitConverter()
1313 {
1314  if (!bNullDateSetted)
1315  bNullDateSetted = GetMM100UnitConverter().setNullDate(GetModel());
1316  OSL_ENSURE(bNullDateSetted, "could not set the null date");
1317  return bNullDateSetted;
1318 }
1319 
1320 XMLNumberFormatAttributesExportHelper* ScXMLImport::GetNumberFormatAttributesExportHelper()
1321 {
1322  if (!pNumberFormatAttributesExportHelper)
1323  pNumberFormatAttributesExportHelper.reset(new XMLNumberFormatAttributesExportHelper(GetNumberFormatsSupplier()));
1324  return pNumberFormatAttributesExportHelper.get();
1325 }
1326 
1327 ScMyStyleNumberFormats* ScXMLImport::GetStyleNumberFormats()
1328 {
1329  if (!pStyleNumberFormats)
1330  pStyleNumberFormats.reset(new ScMyStyleNumberFormats);
1331  return pStyleNumberFormats.get();
1332 }
1333 
1334 void ScXMLImport::SetStylesToRangesFinished()
1335 {
1336  SetStyleToRanges();
1337  sPrevStyleName.clear();
1338 }
1339 
1340 // XImporter
1341 void SAL_CALL ScXMLImport::setTargetDocument( const css::uno::Reference< css::lang::XComponent >& xDoc )
1342 {
1343  ScXMLImport::MutexGuard aGuard(*this);
1344  SvXMLImport::setTargetDocument( xDoc );
1345 
1346  uno::Reference<frame::XModel> xModel(xDoc, uno::UNO_QUERY);
1347  pDoc = ScXMLConverter::GetScDocument( xModel );
1348  OSL_ENSURE( pDoc, "ScXMLImport::setTargetDocument - no ScDocument!" );
1349  if (!pDoc)
1350  throw lang::IllegalArgumentException();
1351 
1352  mpDocImport.reset(new ScDocumentImport(*pDoc));
1353  mpComp.reset(new ScCompiler(pDoc, ScAddress(), formula::FormulaGrammar::GRAM_ODFF));
1354 
1355  uno::Reference<document::XActionLockable> xActionLockable(xDoc, uno::UNO_QUERY);
1356  if (xActionLockable.is())
1357  xActionLockable->addActionLock();
1358 }
1359 
1360 // css::xml::sax::XDocumentHandler
1361 void SAL_CALL ScXMLImport::startDocument()
1362 {
1363  ScXMLImport::MutexGuard aGuard(*this);
1364  SvXMLImport::startDocument();
1365  if (pDoc && !pDoc->IsImportingXML())
1366  {
1367  comphelper::getUnoTunnelImplementation<ScModelObj>(GetModel())->BeforeXMLLoading();
1368  bSelfImportingXMLSet = true;
1369  }
1370 
1371  // if content and styles are loaded with separate imports,
1372  // set bLatinDefaultStyle flag at the start of the content import
1373  SvXMLImportFlags nFlags = getImportFlags();
1374  if ( ( nFlags & SvXMLImportFlags::CONTENT ) && !( nFlags & SvXMLImportFlags::STYLES ) )
1375  ExamineDefaultStyle();
1376 
1377  if (getImportFlags() & SvXMLImportFlags::CONTENT)
1378  {
1379  if (GetModel().is())
1380  {
1381  // store initial namespaces, to find the ones that were added from the file later
1382  ScSheetSaveData* pSheetData = comphelper::getUnoTunnelImplementation<ScModelObj>(GetModel())->GetSheetSaveData();
1383  const SvXMLNamespaceMap& rNamespaces = GetNamespaceMap();
1384  pSheetData->StoreInitialNamespaces(rNamespaces);
1385  }
1386  }
1387 
1388  uno::Reference< beans::XPropertySet > const xImportInfo( getImportInfo() );
1389  uno::Reference< beans::XPropertySetInfo > const xPropertySetInfo(
1390  xImportInfo.is() ? xImportInfo->getPropertySetInfo() : nullptr);
1391  if (xPropertySetInfo.is())
1392  {
1393  OUString const sOrganizerMode(
1394  "OrganizerMode");
1395  if (xPropertySetInfo->hasPropertyByName(sOrganizerMode))
1396  {
1397  bool bStyleOnly(false);
1398  if (xImportInfo->getPropertyValue(sOrganizerMode) >>= bStyleOnly)
1399  {
1400  bLoadDoc = !bStyleOnly;
1401  }
1402  }
1403  }
1404 
1405  UnlockSolarMutex();
1406 }
1407 
1408 sal_Int32 ScXMLImport::GetRangeType(const OUString& sRangeType)
1409 {
1410  sal_Int32 nRangeType(0);
1411  OUStringBuffer sBuffer;
1412  sal_Int32 i = 0;
1413  while (i <= sRangeType.getLength())
1414  {
1415  if ((i == sRangeType.getLength()) || (sRangeType[i] == ' '))
1416  {
1417  OUString sTemp = sBuffer.makeStringAndClear();
1418  if (sTemp == "repeat-column")
1419  nRangeType |= sheet::NamedRangeFlag::COLUMN_HEADER;
1420  else if (sTemp == SC_REPEAT_ROW)
1421  nRangeType |= sheet::NamedRangeFlag::ROW_HEADER;
1422  else if (sTemp == SC_FILTER)
1423  nRangeType |= sheet::NamedRangeFlag::FILTER_CRITERIA;
1424  else if (sTemp == SC_PRINT_RANGE)
1425  nRangeType |= sheet::NamedRangeFlag::PRINT_AREA;
1426  }
1427  else if (i < sRangeType.getLength())
1428  sBuffer.append(sRangeType[i]);
1429  ++i;
1430  }
1431  return nRangeType;
1432 }
1433 
1434 void ScXMLImport::SetLabelRanges()
1435 {
1436  if (!pMyLabelRanges)
1437  return;
1438 
1439  uno::Reference <beans::XPropertySet> xPropertySet (GetModel(), uno::UNO_QUERY);
1440  if (!xPropertySet.is())
1441  return;
1442 
1443  uno::Any aColAny = xPropertySet->getPropertyValue(SC_UNO_COLLABELRNG);
1444  uno::Any aRowAny = xPropertySet->getPropertyValue(SC_UNO_ROWLABELRNG);
1445 
1446  uno::Reference< sheet::XLabelRanges > xColRanges;
1447  uno::Reference< sheet::XLabelRanges > xRowRanges;
1448 
1449  if ( !(( aColAny >>= xColRanges ) && ( aRowAny >>= xRowRanges )) )
1450  return;
1451 
1452  table::CellRangeAddress aLabelRange;
1453  table::CellRangeAddress aDataRange;
1454 
1455  for (const auto& rxLabelRange : *pMyLabelRanges)
1456  {
1457  sal_Int32 nOffset1(0);
1458  sal_Int32 nOffset2(0);
1459  FormulaGrammar::AddressConvention eConv = FormulaGrammar::CONV_OOO;
1460 
1461  if (ScRangeStringConverter::GetRangeFromString( aLabelRange, rxLabelRange->sLabelRangeStr, GetDocument(), eConv, nOffset1 ) &&
1462  ScRangeStringConverter::GetRangeFromString( aDataRange, rxLabelRange->sDataRangeStr, GetDocument(), eConv, nOffset2 ))
1463  {
1464  if ( rxLabelRange->bColumnOrientation )
1465  xColRanges->addNew( aLabelRange, aDataRange );
1466  else
1467  xRowRanges->addNew( aLabelRange, aDataRange );
1468  }
1469  }
1470 
1471  pMyLabelRanges->clear();
1472 }
1473 
1474 namespace {
1475 
1476 class RangeNameInserter
1477 {
1478  ScDocument* mpDoc;
1479  ScRangeName& mrRangeName;
1480 
1481 public:
1482  RangeNameInserter(ScDocument* pDoc, ScRangeName& rRangeName) :
1483  mpDoc(pDoc), mrRangeName(rRangeName) {}
1484 
1485  void operator() (const std::unique_ptr<ScMyNamedExpression>& p) const
1486  {
1487  using namespace formula;
1488 
1489  const OUString& aType = p->sRangeType;
1490  sal_uInt32 nUnoType = ScXMLImport::GetRangeType(aType);
1491 
1492  ScRangeData::Type nNewType = ScRangeData::Type::Name;
1493  if ( nUnoType & sheet::NamedRangeFlag::FILTER_CRITERIA ) nNewType |= ScRangeData::Type::Criteria;
1494  if ( nUnoType & sheet::NamedRangeFlag::PRINT_AREA ) nNewType |= ScRangeData::Type::PrintArea;
1495  if ( nUnoType & sheet::NamedRangeFlag::COLUMN_HEADER ) nNewType |= ScRangeData::Type::ColHeader;
1496  if ( nUnoType & sheet::NamedRangeFlag::ROW_HEADER ) nNewType |= ScRangeData::Type::RowHeader;
1497 
1498  if (!mpDoc)
1499  return;
1500 
1501  // Insert a new name.
1502  ScAddress aPos;
1503  sal_Int32 nOffset = 0;
1504  bool bSuccess = ScRangeStringConverter::GetAddressFromString(
1505  aPos, p->sBaseCellAddress, mpDoc, FormulaGrammar::CONV_OOO, nOffset);
1506 
1507  if (bSuccess)
1508  {
1509  OUString aContent = p->sContent;
1510  if (!p->bIsExpression)
1511  ScXMLConverter::ConvertCellRangeAddress(aContent);
1512 
1513  ScRangeData* pData = new ScRangeData(
1514  mpDoc, p->sName, aContent, aPos, nNewType, p->eGrammar);
1515  mrRangeName.insert(pData);
1516  }
1517  }
1518 };
1519 
1520 }
1521 
1522 void ScXMLImport::SetNamedRanges()
1523 {
1524  if (!m_pMyNamedExpressions)
1525  return;
1526 
1527  if (!pDoc)
1528  return;
1529 
1530  // Insert the namedRanges
1531  ScRangeName* pRangeNames = pDoc->GetRangeName();
1532  ::std::for_each(m_pMyNamedExpressions->begin(), m_pMyNamedExpressions->end(), RangeNameInserter(pDoc, *pRangeNames));
1533 }
1534 
1535 void ScXMLImport::SetSheetNamedRanges()
1536 {
1537  if (!pDoc)
1538  return;
1539 
1540  for (auto const& itr : m_SheetNamedExpressions)
1541  {
1542  const SCTAB nTab = itr.first;
1543  ScRangeName* pRangeNames = pDoc->GetRangeName(nTab);
1544  if (!pRangeNames)
1545  continue;
1546 
1547  const ScMyNamedExpressions& rNames = *itr.second;
1548  ::std::for_each(rNames.begin(), rNames.end(), RangeNameInserter(pDoc, *pRangeNames));
1549  }
1550 }
1551 
1552 void ScXMLImport::SetStringRefSyntaxIfMissing()
1553 {
1554  if (!pDoc)
1555  return;
1556 
1557  ScCalcConfig aCalcConfig = pDoc->GetCalcConfig();
1558 
1559  // Has any string ref syntax been imported?
1560  // If not, we need to take action
1561  if ( !aCalcConfig.mbHasStringRefSyntax )
1562  {
1563  aCalcConfig.meStringRefAddressSyntax = formula::FormulaGrammar::CONV_A1_XL_A1;
1564  pDoc->SetCalcConfig(aCalcConfig);
1565  }
1566 }
1567 
1568 void SAL_CALL ScXMLImport::endDocument()
1569 {
1570  ScXMLImport::MutexGuard aGuard(*this);
1571  if (getImportFlags() & SvXMLImportFlags::CONTENT)
1572  {
1573  if (GetModel().is())
1574  {
1575  mpDocImport->finalize();
1576 
1577  uno::Reference<document::XViewDataSupplier> xViewDataSupplier(GetModel(), uno::UNO_QUERY);
1578  if (xViewDataSupplier.is())
1579  {
1580  uno::Reference<container::XIndexAccess> xIndexAccess(xViewDataSupplier->getViewData());
1581  if (xIndexAccess.is() && xIndexAccess->getCount() > 0)
1582  {
1583  uno::Sequence< beans::PropertyValue > aSeq;
1584  if (xIndexAccess->getByIndex(0) >>= aSeq)
1585  {
1586  for (const auto& rProp : std::as_const(aSeq))
1587  {
1588  OUString sName(rProp.Name);
1589  if (sName == SC_ACTIVETABLE)
1590  {
1591  OUString sTabName;
1592  if(rProp.Value >>= sTabName)
1593  {
1594  SCTAB nTab(0);
1595  if (pDoc->GetTable(sTabName, nTab))
1596  {
1597  pDoc->SetVisibleTab(nTab);
1598  break;
1599  }
1600  }
1601  }
1602  }
1603  }
1604  }
1605  }
1606  SetLabelRanges();
1607  SetNamedRanges();
1608  SetSheetNamedRanges();
1609  SetStringRefSyntaxIfMissing();
1610  if (mpPivotSources)
1611  // Process pivot table sources after the named ranges have been set.
1612  mpPivotSources->process();
1613  }
1614  GetProgressBarHelper()->End(); // make room for subsequent SfxProgressBars
1615  if (pDoc)
1616  {
1617  pDoc->CompileXML();
1618 
1619  // After CompileXML, links must be completely changed to the new URLs.
1620  // Otherwise, hasExternalFile for API wouldn't work (#i116940#),
1621  // and typing a new formula would create a second link with the same "real" file name.
1622  if (pDoc->HasExternalRefManager())
1623  pDoc->GetExternalRefManager()->updateAbsAfterLoad();
1624  }
1625 
1626  // If the stream contains cells outside of the current limits, the styles can't be re-created,
1627  // so stream copying is disabled then.
1628  if (pDoc && GetModel().is() && !pDoc->HasRangeOverflow())
1629  {
1630  // set "valid stream" flags after loading (before UpdateRowHeights, so changed formula results
1631  // in UpdateRowHeights can already clear the flags again)
1632  ScSheetSaveData* pSheetData = comphelper::getUnoTunnelImplementation<ScModelObj>(GetModel())->GetSheetSaveData();
1633 
1634  SCTAB nTabCount = pDoc->GetTableCount();
1635  for (SCTAB nTab=0; nTab<nTabCount; ++nTab)
1636  {
1637  pDoc->SetDrawPageSize(nTab);
1638  if (!pSheetData->IsSheetBlocked( nTab ))
1639  pDoc->SetStreamValid( nTab, true );
1640  }
1641  }
1642 
1643  // There are rows with optimal height which need to be updated
1644  if (pDoc && !maRecalcRowRanges.empty())
1645  {
1646  bool bLockHeight = pDoc->IsAdjustHeightLocked();
1647  if (bLockHeight)
1648  {
1649  pDoc->UnlockAdjustHeight();
1650  }
1651 
1652  ScSizeDeviceProvider aProv(static_cast<ScDocShell*>(pDoc->GetDocumentShell()));
1653  ScDocRowHeightUpdater aUpdater(*pDoc, aProv.GetDevice(), aProv.GetPPTX(), aProv.GetPPTY(), &maRecalcRowRanges);
1654  aUpdater.update();
1655 
1656  if (bLockHeight)
1657  {
1658  pDoc->LockAdjustHeight();
1659  }
1660  }
1661 
1662  aTables.FixupOLEs();
1663  }
1664  if (GetModel().is())
1665  {
1666  uno::Reference<document::XActionLockable> xActionLockable(GetModel(), uno::UNO_QUERY);
1667  if (xActionLockable.is())
1668  xActionLockable->removeActionLock();
1669  }
1670  SvXMLImport::endDocument();
1671 
1672  if (pDoc)
1673  {
1674  pDoc->BroadcastUno(SfxHint(SfxHintId::ScClearCache));
1675  }
1676 
1677  if(pDoc && bSelfImportingXMLSet)
1678  comphelper::getUnoTunnelImplementation<ScModelObj>(GetModel())->AfterXMLLoading();
1679 }
1680 
1681 // XEventListener
1682 void ScXMLImport::DisposingModel()
1683 {
1684  SvXMLImport::DisposingModel();
1685  pDoc = nullptr;
1686 }
1687 
1688 ScXMLImport::MutexGuard::MutexGuard(ScXMLImport& rImport) :
1689  mrImport(rImport)
1690 {
1691  mrImport.LockSolarMutex();
1692 }
1693 
1694 ScXMLImport::MutexGuard::~MutexGuard()
1695 {
1696  mrImport.UnlockSolarMutex();
1697 }
1698 
1699 void ScXMLImport::LockSolarMutex()
1700 {
1701  // #i62677# When called from DocShell/Wrapper, the SolarMutex is already locked,
1702  // so there's no need to allocate (and later delete) the SolarMutexGuard.
1703  if (!mbLockSolarMutex)
1704  {
1705  DBG_TESTSOLARMUTEX();
1706  return;
1707  }
1708 
1709  if (nSolarMutexLocked == 0)
1710  {
1711  OSL_ENSURE(!pSolarMutexGuard, "Solar Mutex is locked");
1712  pSolarMutexGuard.reset(new SolarMutexGuard());
1713  }
1714  ++nSolarMutexLocked;
1715 }
1716 
1717 void ScXMLImport::UnlockSolarMutex()
1718 {
1719  if (nSolarMutexLocked > 0)
1720  {
1721  nSolarMutexLocked--;
1722  if (nSolarMutexLocked == 0)
1723  {
1724  OSL_ENSURE(pSolarMutexGuard, "Solar Mutex is always unlocked");
1725  pSolarMutexGuard.reset();
1726  }
1727  }
1728 }
1729 
1730 sal_Int32 ScXMLImport::GetByteOffset() const
1731 {
1732  sal_Int32 nOffset = -1;
1733  uno::Reference<xml::sax::XLocator> xLocator = GetLocator();
1734  uno::Reference<io::XSeekable> xSeek( xLocator, uno::UNO_QUERY );
1735  if ( xSeek.is() )
1736  nOffset = static_cast<sal_Int32>(xSeek->getPosition());
1737  return nOffset;
1738 }
1739 
1740 void ScXMLImport::SetRangeOverflowType(ErrCode nType)
1741 {
1742  // #i31130# Overflow is stored in the document, because the ScXMLImport object
1743  // isn't available in ScXMLImportWrapper::ImportFromComponent when using the
1744  // OOo->Oasis transformation.
1745 
1746  if ( pDoc )
1747  pDoc->SetRangeOverflowType( nType );
1748 }
1749 
1750 void ScXMLImport::ProgressBarIncrement()
1751 {
1752  nProgressCount++;
1753  if (nProgressCount > 100)
1754  {
1755  GetProgressBarHelper()->Increment(nProgressCount);
1756  nProgressCount = 0;
1757  }
1758 }
1759 
1760 void ScXMLImport::ExtractFormulaNamespaceGrammar(
1761  OUString& rFormula, OUString& rFormulaNmsp, FormulaGrammar::Grammar& reGrammar,
1762  const OUString& rAttrValue, bool bRestrictToExternalNmsp ) const
1763 {
1764  // parse the attribute value, extract namespace ID, literal namespace, and formula string
1765  rFormulaNmsp.clear();
1766  sal_uInt16 nNsId = GetNamespaceMap().GetKeyByQName(rAttrValue, nullptr, &rFormula, &rFormulaNmsp, SvXMLNamespaceMap::QNameMode::AttrValue);
1767 
1768  // check if we have an ODF formula namespace
1769  if( !bRestrictToExternalNmsp ) switch( nNsId )
1770  {
1771  case XML_NAMESPACE_OOOC:
1772  rFormulaNmsp.clear(); // remove namespace string for built-in grammar
1773  reGrammar = FormulaGrammar::GRAM_PODF;
1774  return;
1775  case XML_NAMESPACE_OF:
1776  rFormulaNmsp.clear(); // remove namespace string for built-in grammar
1777  reGrammar = FormulaGrammar::GRAM_ODFF;
1778  return;
1779  }
1780 
1781  /* Find default grammar for formulas without namespace. There may be
1782  documents in the wild that stored no namespace in ODF 1.0/1.1. Use
1783  GRAM_PODF then (old style ODF 1.0/1.1 formulas). The default for ODF
1784  1.2 and later without namespace is GRAM_ODFF (OpenFormula). */
1785  FormulaGrammar::Grammar eDefaultGrammar =
1786  (GetDocument()->GetStorageGrammar() == FormulaGrammar::GRAM_PODF) ?
1787  FormulaGrammar::GRAM_PODF : FormulaGrammar::GRAM_ODFF;
1788 
1789  /* Check if we have no namespace at all. The value XML_NAMESPACE_NONE
1790  indicates that there is no colon. If the first character of the
1791  attribute value is the equality sign, the value XML_NAMESPACE_UNKNOWN
1792  indicates that there is a colon somewhere in the formula string. */
1793  if( (nNsId == XML_NAMESPACE_NONE) || ((nNsId == XML_NAMESPACE_UNKNOWN) && (rAttrValue.toChar() == '=')) )
1794  {
1795  rFormula = rAttrValue; // return entire string as formula
1796  reGrammar = eDefaultGrammar;
1797  return;
1798  }
1799 
1800  /* Check if a namespace URL could be resolved from the attribute value.
1801  Use that namespace only, if the Calc document knows an associated
1802  external formula parser. This prevents that the range operator in
1803  conjunction with defined names is confused as namespaces prefix, e.g.
1804  in the expression 'table:A1' where 'table' is a named reference. */
1805  if( ((nNsId & XML_NAMESPACE_UNKNOWN_FLAG) != 0) && !rFormulaNmsp.isEmpty() &&
1806  GetDocument()->GetFormulaParserPool().hasFormulaParser( rFormulaNmsp ) )
1807  {
1808  reGrammar = FormulaGrammar::GRAM_EXTERNAL;
1809  return;
1810  }
1811 
1812  /* All attempts failed (e.g. no namespace and no leading equality sign, or
1813  an invalid namespace prefix), continue with the entire attribute value. */
1814  rFormula = rAttrValue;
1815  rFormulaNmsp.clear(); // remove any namespace string
1816  reGrammar = eDefaultGrammar;
1817 }
1818 
1819 FormulaError ScXMLImport::GetFormulaErrorConstant( const OUString& rStr ) const
1820 {
1821  if (!mpComp)
1822  return FormulaError::NONE;
1823 
1824  return mpComp->GetErrorConstant(rStr);
1825 }
1826 
1827 ScEditEngineDefaulter* ScXMLImport::GetEditEngine()
1828 {
1829  if (!mpEditEngine)
1830  {
1831  mpEditEngine.reset(new ScEditEngineDefaulter(pDoc->GetEnginePool()));
1832  mpEditEngine->SetRefMapMode(MapMode(MapUnit::Map100thMM));
1833  mpEditEngine->SetEditTextObjectPool(pDoc->GetEditPool());
1834  mpEditEngine->SetUpdateMode(false);
1835  mpEditEngine->EnableUndo(false);
1836  mpEditEngine->SetControlWord(mpEditEngine->GetControlWord() & ~EEControlBits::ALLOWBIGOBJS);
1837  }
1838  return mpEditEngine.get();
1839 }
1840 
1841 const ScXMLEditAttributeMap& ScXMLImport::GetEditAttributeMap() const
1842 {
1843  if (!mpEditAttrMap)
1844  mpEditAttrMap.reset(new ScXMLEditAttributeMap);
1845  return *mpEditAttrMap;
1846 }
1847 
1848 void ScXMLImport::NotifyEmbeddedFontRead()
1849 {
1850  if (pDoc)
1851  pDoc->SetEmbedFonts(true);
1852 }
1853 
1854 ScMyImpDetectiveOpArray* ScXMLImport::GetDetectiveOpArray()
1855 {
1856  if (!pDetectiveOpArray)
1857  pDetectiveOpArray.reset(new ScMyImpDetectiveOpArray());
1858  return pDetectiveOpArray.get();
1859 }
1860 
1861 extern "C" SAL_DLLPUBLIC_EXPORT bool TestImportFODS(SvStream &rStream)
1862 {
1863  ScDLL::Init();
1864 
1865  SfxObjectShellLock xDocSh(new ScDocShell);
1866  xDocSh->DoInitNew();
1867  uno::Reference<frame::XModel> xModel(xDocSh->GetModel());
1868 
1869  uno::Reference<lang::XMultiServiceFactory> xMultiServiceFactory(comphelper::getProcessServiceFactory());
1870  uno::Reference<io::XInputStream> xStream(new ::utl::OSeekableInputStreamWrapper(rStream));
1871  uno::Reference<uno::XInterface> xInterface(xMultiServiceFactory->createInstance("com.sun.star.comp.Writer.XmlFilterAdaptor"), uno::UNO_SET_THROW);
1872 
1873  css::uno::Sequence<OUString> aUserData(7);
1874  aUserData[0] = "com.sun.star.comp.filter.OdfFlatXml";
1875  aUserData[2] = "com.sun.star.comp.Calc.XMLOasisImporter";
1876  aUserData[3] = "com.sun.star.comp.Calc.XMLOasisExporter";
1877  aUserData[6] = "true";
1878  uno::Sequence<beans::PropertyValue> aAdaptorArgs(comphelper::InitPropertySequence(
1879  {
1880  { "UserData", uno::Any(aUserData) },
1881  }));
1882  css::uno::Sequence<uno::Any> aOuterArgs(1);
1883  aOuterArgs[0] <<= aAdaptorArgs;
1884 
1885  uno::Reference<lang::XInitialization> xInit(xInterface, uno::UNO_QUERY_THROW);
1886  xInit->initialize(aOuterArgs);
1887 
1888  uno::Reference<document::XImporter> xImporter(xInterface, uno::UNO_QUERY_THROW);
1889  uno::Sequence<beans::PropertyValue> aArgs(comphelper::InitPropertySequence(
1890  {
1891  { "InputStream", uno::Any(xStream) },
1892  { "URL", uno::Any(OUString("private:stream")) },
1893  }));
1894  xImporter->setTargetDocument(xModel);
1895 
1896  uno::Reference<document::XFilter> xFilter(xInterface, uno::UNO_QUERY_THROW);
1897  //SetLoading hack because the document properties will be re-initted
1898  //by the xml filter and during the init, while it's considered uninitialized,
1899  //setting a property will inform the document it's modified, which attempts
1900  //to update the properties, which throws cause the properties are uninitialized
1901  xDocSh->SetLoading(SfxLoadedFlags::NONE);
1902  bool ret = xFilter->filter(aArgs);
1903  xDocSh->SetLoading(SfxLoadedFlags::ALL);
1904 
1905  xDocSh->DoClose();
1906 
1907  return ret;
1908 }
1909 
1910 extern "C" SAL_DLLPUBLIC_EXPORT bool TestImportXLSX(SvStream &rStream)
1911 {
1912  ScDLL::Init();
1913 
1914  SfxObjectShellLock xDocSh(new ScDocShell);
1915  xDocSh->DoInitNew();
1916  uno::Reference<frame::XModel> xModel(xDocSh->GetModel());
1917 
1918  uno::Reference<lang::XMultiServiceFactory> xMultiServiceFactory(comphelper::getProcessServiceFactory());
1919  uno::Reference<io::XInputStream> xStream(new utl::OSeekableInputStreamWrapper(rStream));
1920 
1921  uno::Reference<document::XFilter> xFilter(xMultiServiceFactory->createInstance("com.sun.star.comp.oox.xls.ExcelFilter"), uno::UNO_QUERY_THROW);
1922 
1923  uno::Reference<document::XImporter> xImporter(xFilter, uno::UNO_QUERY_THROW);
1924  uno::Sequence<beans::PropertyValue> aArgs(comphelper::InitPropertySequence(
1925  {
1926  { "InputStream", uno::makeAny(xStream) },
1927  { "InputMode", uno::makeAny(true) },
1928  }));
1929  xImporter->setTargetDocument(xModel);
1930 
1931  //SetLoading hack because the document properties will be re-initted
1932  //by the xml filter and during the init, while it's considered uninitialized,
1933  //setting a property will inform the document it's modified, which attempts
1934  //to update the properties, which throws cause the properties are uninitialized
1935  xDocSh->SetLoading(SfxLoadedFlags::NONE);
1936  bool ret = false;
1937  try
1938  {
1939  ret = xFilter->filter(aArgs);
1940  }
1941  catch (const css::io::IOException&)
1942  {
1943  }
1944  catch (const css::lang::WrappedTargetRuntimeException&)
1945  {
1946  }
1947  xDocSh->SetLoading(SfxLoadedFlags::ALL);
1948 
1949  xDocSh->DoClose();
1950 
1951  return ret;
1952 }
1953 
1954 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
ScRangeStringConverter::GetRangeFromString
static bool GetRangeFromString(ScRange &rRange, const OUString &rRangeStr, const ScDocument *pDocument, formula::FormulaGrammar::AddressConvention eConv, sal_Int32 &nOffset, sal_Unicode cSeparator= ' ', sal_Unicode cQuote= '\'')
SC_REPEAT_ROW
#define SC_REPEAT_ROW
Definition: xmlimprt.cxx:105
XML_NAMESPACE_LO_EXT
constexpr sal_uInt16 XML_NAMESPACE_LO_EXT
SfxObjectShell::SetVisArea
virtual void SetVisArea(const tools::Rectangle &rVisArea)
ScXMLImport::GetTableAnnotationAttrTokenMap
const SvXMLTokenMap & GetTableAnnotationAttrTokenMap()
Definition: xmlimprt.cxx:486
ScXMLImport::SetStringRefSyntaxIfMissing
void SetStringRefSyntaxIfMissing()
Definition: xmlimprt.cxx:1552
ScXMLImport::xSheetCellRanges
css::uno::Reference< css::sheet::XSheetCellRangeContainer > xSheetCellRanges
Definition: xmlimprt.hxx:247
ScXMLImport::CreateFastContext
virtual SvXMLImportContext * CreateFastContext(sal_Int32 nElement, const ::css::uno::Reference< ::css::xml::sax::XFastAttributeList > &xAttrList) override
Definition: xmlimprt.cxx:521
ScDocument::HasExternalRefManager
bool HasExternalRefManager() const
Definition: document.hxx:1003
XML_NUMBER_ROWS_REPEATED
XML_NUMBER_ROWS_REPEATED
XML_TABLE_COLUMN_GROUP
XML_TABLE_COLUMN_GROUP
XML_NUMBER_ROWS_SPANNED
XML_NUMBER_ROWS_SPANNED
ScSizeDeviceProvider::GetPPTY
double GetPPTY() const
Definition: sizedev.hxx:42
tools::Rectangle::setHeight
void setHeight(long n)
XML_VALUE_TYPE
XML_VALUE_TYPE
ScRangeStringConverter::GetAddressFromString
static bool GetAddressFromString(ScAddress &rAddress, const OUString &rAddressStr, const ScDocument *pDocument, formula::FormulaGrammar::AddressConvention eConv, sal_Int32 &nOffset, sal_Unicode cSeparator= ' ', sal_Unicode cQuote= '\'')
String to Range core.
Definition: rangeutl.cxx:437
XML_STYLE_NAME
XML_STYLE_NAME
SvXMLImport::SetStyles
void SetStyles(SvXMLStylesContext *pStyles)
SvNumberFormatter::GetLegacyOnlyCurrencyEntry
static const NfCurrencyEntry * GetLegacyOnlyCurrencyEntry(const OUString &rSymbol, const OUString &rAbbrev)
XML_DISPLAY
XML_DISPLAY
ScXMLImport::CreateScriptContext
SvXMLImportContext * CreateScriptContext()
Definition: xmlimprt.cxx:682
ScXMLImport::xNumberFormatTypes
css::uno::Reference< css::util::XNumberFormatTypes > xNumberFormatTypes
Definition: xmlimprt.hxx:245
ScXMLImport::aTables
ScMyTables aTables
Lift cycle managed elsewhere, no need to delete.
Definition: xmlimprt.hxx:230
Calc_XMLOasisStylesImporter_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * Calc_XMLOasisStylesImporter_get_implementation(css::uno::XComponentContext *context, css::uno::Sequence< css::uno::Any > const &)
Definition: xmlimprt.cxx:138
ScXMLEditAttributeMap
Provide mapping from ODF text formatting styles to EditEngine's, for rich-text cell content import...
Definition: editattributemap.hxx:21
XML_ANNOTATION
XML_ANNOTATION
SC_UNO_ODS_LOCK_SOLAR_MUTEX
#define SC_UNO_ODS_LOCK_SOLAR_MUTEX
Definition: unonames.hxx:700
XML_DOCUMENT_META
XML_DOCUMENT_META
ScXMLImport::nProgressCount
sal_Int32 nProgressCount
Definition: xmlimprt.hxx:252
XML_DOCUMENT_STYLES
XML_DOCUMENT_STYLES
ScDocument::SetChangeViewSettings
SC_DLLPUBLIC void SetChangeViewSettings(const ScChangeViewSettings &rNew)
Definition: documen2.cxx:1109
SC_ACTIVETABLE
#define SC_ACTIVETABLE
Definition: ViewSettingsSequenceDefines.hxx:90
TestImportFODS
SAL_DLLPUBLIC_EXPORT bool TestImportFODS(SvStream &rStream)
Definition: xmlimprt.cxx:1861
pData
std::unique_ptr< ContentProperties > pData
ScXMLImport::pDoc
ScDocument * pDoc
Definition: xmlimprt.hxx:204
XML_DEFAULT_CELL_STYLE_NAME
XML_DEFAULT_CELL_STYLE_NAME
SvXMLMetaDocumentContext::endFastElement
virtual void SAL_CALL endFastElement(sal_Int32 nElement) override
ScChangeTrack::SetProtection
void SetProtection(const css::uno::Sequence< sal_Int8 > &rPass)
Definition: chgtrack.hxx:1134
sc::PivotTableSources
Store pivot table data that need to be post-processed at the end of the import.
Definition: pivotsource.hxx:26
ScXMLImport::GetDocument
ScDocument * GetDocument()
Definition: xmlimprt.hxx:296
ScDocument::SetDrawPageSize
SC_DLLPUBLIC void SetDrawPageSize(SCTAB nTab)
Definition: documen9.cxx:193
XML_DETECTIVE
XML_DETECTIVE
XML_EVENT_LISTENERS
XML_EVENT_LISTENERS
ScDocument::GetRangeName
SC_DLLPUBLIC ScRangeName * GetRangeName(SCTAB nTab) const
Definition: documen3.cxx:168
ScExternalRefManager::updateAbsAfterLoad
void updateAbsAfterLoad()
Replace the original URL with the real URL that was generated from the relative URL.
Definition: externalrefmgr.cxx:3037
ScSheetSaveData::StoreInitialNamespaces
void StoreInitialNamespaces(const SvXMLNamespaceMap &rNamespaces)
Definition: sheetdata.cxx:172
XML_VALUE
XML_VALUE
XML_NAMESPACE_OF
constexpr sal_uInt16 XML_NAMESPACE_OF
XML_NAMESPACE_NONE
const sal_uInt16 XML_NAMESPACE_NONE
sc::ImportPostProcessData
Stores data imported from the file that need to be processed at the end of the import process...
Definition: importfilterdata.hxx:23
ScXMLConverter::GetScDocument
static ScDocument * GetScDocument(const css::uno::Reference< css::frame::XModel > &xModel)
Definition: XMLConverter.cxx:34
SvXMLImport::GetNamespaceMap
SvXMLNamespaceMap & GetNamespaceMap()
ScXMLImport::maRecalcRowRanges
std::vector< ScDocRowHeightUpdater::TabRanges > maRecalcRowRanges
Definition: xmlimprt.hxx:232
ScXMLImport::CreateFontDeclsContext
SvXMLImportContext * CreateFontDeclsContext()
Definition: xmlimprt.cxx:638
ScXMLImport::pTableAnnotationAttrTokenMap
std::unique_ptr< SvXMLTokenMap > pTableAnnotationAttrTokenMap
Definition: xmlimprt.hxx:226
XMLTableStyleContext::GetLastSheet
SCTAB GetLastSheet() const
Definition: xmlstyli.hxx:110
XML_TABLE_ROW_GROUP
XML_TABLE_ROW_GROUP
sax_fastparser::castToFastAttributeList
FastAttributeList & castToFastAttributeList(const css::uno::Reference< css::xml::sax::XFastAttributeList > &xAttrList)
ScXMLImport::GetTableRowCellElemTokenMap
const SvXMLTokenMap & GetTableRowCellElemTokenMap()
Definition: xmlimprt.cxx:466
ScXMLImport::pTableRowsElemTokenMap
std::unique_ptr< SvXMLTokenMap > pTableRowsElemTokenMap
Definition: xmlimprt.hxx:221
XMLTableStyleContext::SetLastSheet
void SetLastSheet(SCTAB nNew)
Definition: xmlstyli.hxx:111
XML_NAMESPACE_TEXT
constexpr sal_uInt16 XML_NAMESPACE_TEXT
ScXMLImport::GetEditAttributeMap
const ScXMLEditAttributeMap & GetEditAttributeMap() const
Definition: xmlimprt.cxx:1841
Name
OUString Name
ScXMLImport::sPrevCurrency
OUString sPrevCurrency
Definition: xmlimprt.hxx:250
SfxObjectShell::GetModel
css::uno::Reference< css::frame::XModel > GetModel() const
LocaleDataWrapper
ScXMLImport::mbLockSolarMutex
bool mbLockSolarMutex
Definition: xmlimprt.hxx:257
ScDocumentImport
Accessor class to ScDocument.
Definition: documentimport.hxx:40
ScXMLImport::pValidations
std::unique_ptr< ScMyImportValidations > pValidations
Definition: xmlimprt.hxx:238
EEControlBits
EEControlBits
ScXMLImport::sPrevStyleName
OUString sPrevStyleName
Definition: xmlimprt.hxx:249
XML_NAMESPACE_UNKNOWN
const sal_uInt16 XML_NAMESPACE_UNKNOWN
ScDocument::IsAdjustHeightLocked
bool IsAdjustHeightLocked() const
Definition: document.hxx:1535
XMLERROR_API
#define XMLERROR_API
XML_TOKEN_MAP_END
#define XML_TOKEN_MAP_END
SvXMLImport::SetFontDecls
void SetFontDecls(XMLFontStylesContext *pFontDecls)
Value
Value
ScXMLImport::CreateMetaContext
SvXMLImportContext * CreateMetaContext(sal_Int32 nElement)
Definition: xmlimprt.cxx:665
ScXMLImport::xRowStylesPropertySetMapper
rtl::Reference< XMLPropertySetMapper > xRowStylesPropertySetMapper
Definition: xmlimprt.hxx:217
ScXMLImport::SetNullDateOnUnitConverter
bool SetNullDateOnUnitConverter()
Definition: xmlimprt.cxx:1312
xStream
Reference< XInputStream > xStream
XML_X
XML_X
XML_TABLE_CELL
XML_TABLE_CELL
SvXMLImportFlags
SvXMLImportFlags
ScDocument::GetTableCount
SC_DLLPUBLIC SCTAB GetTableCount() const
Definition: document.cxx:314
ScXMLImport::LockSolarMutex
void LockSolarMutex()
Definition: xmlimprt.cxx:1699
XML_TABLE_HEADER_COLUMNS
XML_TABLE_HEADER_COLUMNS
XML_NUMBER_COLUMNS_REPEATED
XML_NUMBER_COLUMNS_REPEATED
ScXMLImport::mpDocImport
std::unique_ptr< ScDocumentImport > mpDocImport
Definition: xmlimprt.hxx:205
ScXMLImport::mpPostProcessData
sc::ImportPostProcessData * mpPostProcessData
Definition: xmlimprt.hxx:228
XMLTableStyleContext::FillPropertySet
virtual void FillPropertySet(const css::uno::Reference< css::beans::XPropertySet > &rPropSet) override
Definition: xmlstyli.cxx:527
nCount
int nCount
ScXMLImport::mpPivotSources
std::unique_ptr< sc::PivotTableSources > mpPivotSources
Definition: xmlimprt.hxx:208
ScDocument::GetTable
SC_DLLPUBLIC bool GetTable(const OUString &rName, SCTAB &rTab) const
Definition: document.cxx:260
ScDocument::GetExternalRefManager
SC_DLLPUBLIC ScExternalRefManager * GetExternalRefManager() const
Definition: documen3.cxx:604
XML_VISIBILITY
XML_VISIBILITY
ScXMLImport::IsCurrencySymbol
bool IsCurrencySymbol(const sal_Int32 nNumberFormat, const OUString &sCurrencySymbol, const OUString &sBankSymbol)
Definition: xmlimprt.cxx:1070
ScXMLImport::SetCurrencySymbol
sal_Int32 SetCurrencySymbol(const sal_Int32 nKey, const OUString &rCurrency)
Definition: xmlimprt.cxx:1019
ScXMLImport::bSelfImportingXMLSet
bool bSelfImportingXMLSet
Definition: xmlimprt.hxx:256
XML_NAMESPACE_UNKNOWN_FLAG
const sal_uInt16 XML_NAMESPACE_UNKNOWN_FLAG
XML_DOCUMENT_SETTINGS
XML_DOCUMENT_SETTINGS
XML_NUMBER_COLUMNS_SPANNED
XML_NUMBER_COLUMNS_SPANNED
ScMyTables::FixupOLEs
void FixupOLEs()
Definition: xmlsubti.hxx:77
ScXMLImport::GetFormulaErrorConstant
FormulaError GetFormulaErrorConstant(const OUString &rStr) const
Definition: xmlimprt.cxx:1819
SvXMLImport::initialize
virtual void SAL_CALL initialize(const css::uno::Sequence< css::uno::Any > &aArguments) override
comphelper::InitPropertySequence
css::uno::Sequence< css::beans::PropertyValue > InitPropertySequence(::std::initializer_list< ::std::pair< OUString, css::uno::Any > > vInit)
ScXMLImport::ScXMLImport
ScXMLImport(const ScXMLImport &)=delete
sName
const char * sName
ScDocument::GetChangeTrack
ScChangeTrack * GetChangeTrack() const
Definition: document.hxx:2392
tools::Rectangle::setWidth
void setWidth(long n)
ScXMLImport::endDocument
virtual void SAL_CALL endDocument() override
Definition: xmlimprt.cxx:1568
ScXMLImport::CreateStylesContext
SvXMLImportContext * CreateStylesContext(bool bAutoStyles)
Definition: xmlimprt.cxx:647
SvXMLImport::GetStyles
SvXMLStylesContext * GetStyles()
ScXMLImport::bNullDateSetted
bool bNullDateSetted
Definition: xmlimprt.hxx:255
ScSizeDeviceProvider::GetDevice
OutputDevice * GetDevice() const
Definition: sizedev.hxx:40
ScXMLImport::InsertStyles
void InsertStyles()
Definition: xmlimprt.cxx:816
ScXMLImport::m_SheetNamedExpressions
SheetNamedExpMap m_SheetNamedExpressions
Definition: xmlimprt.hxx:235
XML_FORMS
XML_FORMS
SvXMLMetaDocumentContext::createFastChildContext
virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList > &xAttrList) override
ScXMLImport::pTableRowAttrTokenMap
std::unique_ptr< SvXMLTokenMap > pTableRowAttrTokenMap
Definition: xmlimprt.hxx:223
ScXMLImport::GetValidation
bool GetValidation(const OUString &sName, ScMyImportValidation &aValidation)
Definition: xmlimprt.cxx:773
XMLTableStyleContext::ApplyCondFormat
void ApplyCondFormat(const css::uno::Sequence< css::table::CellRangeAddress > &xCellRanges)
Definition: xmlstyli.cxx:483
sax_fastparser::FastAttributeList
ScDocument::SetVisibleTab
SC_DLLPUBLIC void SetVisibleTab(SCTAB nTab)
Definition: document.hxx:860
ScXMLImport::pTableRowCellAttrTokenMap
std::unique_ptr< SvXMLTokenMap > pTableRowCellAttrTokenMap
Definition: xmlimprt.hxx:225
ScXMLImport::ExamineDefaultStyle
void ExamineDefaultStyle()
Definition: xmlimprt.cxx:825
ScXMLImportContext
This class exists only to provide GetScImport() to its derived classes.
Definition: importcontext.hxx:20
ProgressBarHelper::Increment
void Increment(sal_Int32 nInc=1)
LocaleDataWrapper::getNumDecimalSep
const OUString & getNumDecimalSep() const
ScXMLImport::GetTableRowElemTokenMap
const SvXMLTokenMap & GetTableRowElemTokenMap()
Definition: xmlimprt.cxx:429
Calc_XMLOasisSettingsImporter_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * Calc_XMLOasisSettingsImporter_get_implementation(css::uno::XComponentContext *context, css::uno::Sequence< css::uno::Any > const &)
Definition: xmlimprt.cxx:162
Calc_XMLOasisContentImporter_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * Calc_XMLOasisContentImporter_get_implementation(css::uno::XComponentContext *context, css::uno::Sequence< css::uno::Any > const &)
Definition: xmlimprt.cxx:150
aXMLScTableStylesImportProperties
const XMLPropertyMapEntry aXMLScTableStylesImportProperties[]
Definition: xmlstyle.cxx:155
ScDocument::IsImportingXML
bool IsImportingXML() const
Definition: document.hxx:2137
ScXMLImport::SetStatistics
virtual void SetStatistics(const css::uno::Sequence< css::beans::NamedValue > &i_rStats) override
Definition: xmlimprt.cxx:694
XML_TABLE_ROW
XML_TABLE_ROW
XMLTableStyleContext::GetNumberFormat
sal_Int32 GetNumberFormat()
Definition: xmlstyli.cxx:598
ScXMLImport::SetPostProcessData
void SetPostProcessData(sc::ImportPostProcessData *p)
Definition: xmlimprt.cxx:508
i
int i
XML_TABLE_SOURCE
XML_TABLE_SOURCE
ScXMLImport::SetConfigurationSettings
virtual void SetConfigurationSettings(const css::uno::Sequence< css::beans::PropertyValue > &aConfigProps) override
Definition: xmlimprt.cxx:961
XML_NAMESPACE_PRESENTATION
constexpr sal_uInt16 XML_NAMESPACE_PRESENTATION
SvXMLStylesContext::CopyStylesToDoc
void CopyStylesToDoc(bool bOverwrite, bool bFinish=true)
tools::Rectangle::setY
void setY(long y)
XML_SHAPES
XML_SHAPES
ScXMLImport::mpEditAttrMap
std::unique_ptr< ScXMLEditAttributeMap > mpEditAttrMap
Definition: xmlimprt.hxx:210
ScXMLImport::pTableRowElemTokenMap
std::unique_ptr< SvXMLTokenMap > pTableRowElemTokenMap
Definition: xmlimprt.hxx:222
ScDocument::CompileXML
void CompileXML()
Definition: document.cxx:3973
ScXMLImport::startDocument
virtual void SAL_CALL startDocument() override
Definition: xmlimprt.cxx:1361
SvXMLMetaDocumentContext::startFastElement
virtual void SAL_CALL startFastElement(sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList > &xAttrList) override
comphelper::Base64::decode
static void decode(css::uno::Sequence< sal_Int8 > &aPass, const OUString &sBuffer)
ScDLL::Init
static SC_DLLPUBLIC void Init()
DLL-init/exit-code must be linked to the DLL only.
Definition: scdll.cxx:105
SfxObjectShell::SetLoading
void SetLoading(SfxLoadedFlags nFlags)
ScXMLImport::pStyleNumberFormats
std::unique_ptr< ScMyStyleNumberFormats > pStyleNumberFormats
Definition: xmlimprt.hxx:243
ScModelObj::GetEmbeddedObject
SfxObjectShell * GetEmbeddedObject() const
Definition: docuno.cxx:455
ScXMLImport::SetStyleToRanges
void SetStyleToRanges()
Definition: xmlimprt.cxx:1200
XML_CURRENCY
XML_CURRENCY
ScDocument::HasRangeOverflow
bool HasRangeOverflow() const
Definition: document.hxx:2129
ScXMLImport::mpComp
std::unique_ptr< ScCompiler > mpComp
Definition: xmlimprt.hxx:206
ScDocument::GetFormulaParserPool
ScFormulaParserPool & GetFormulaParserPool() const
Returns the pool containing external formula parsers.
Definition: documen3.cxx:633
ScXMLConverter::ConvertCellRangeAddress
static void ConvertCellRangeAddress(OUString &sFormula)
Definition: XMLConverter.cxx:311
ScDocument::GetEnginePool
SC_DLLPUBLIC SfxItemPool * GetEnginePool() const
Definition: documen2.cxx:449
SC_CURRENCYSYMBOL
#define SC_CURRENCYSYMBOL
Definition: xmlimprt.cxx:104
ScDocument::UnlockAdjustHeight
SC_DLLPUBLIC void UnlockAdjustHeight()
Definition: document.cxx:1815
ScFormulaParserPool::hasFormulaParser
bool hasFormulaParser(const OUString &rNamespace)
Returns true, if a formula parser is registered for the passed namespace.
Definition: formulaparserpool.cxx:117
ScXMLImport::pMyLabelRanges
std::unique_ptr< ScMyLabelRanges > pMyLabelRanges
Definition: xmlimprt.hxx:237
gsNumberFormat
constexpr OUStringLiteral gsNumberFormat(SC_UNONAME_NUMFMT)
aXMLScColumnStylesProperties
const XMLPropertyMapEntry aXMLScColumnStylesProperties[]
Definition: xmlstyle.cxx:116
XML_SUB_TABLE
XML_SUB_TABLE
XML_STRING_VALUE
XML_STRING_VALUE
SC_UNO_ODS_IMPORT_STYLES
#define SC_UNO_ODS_IMPORT_STYLES
Definition: unonames.hxx:701
ScXMLImport::nSolarMutexLocked
sal_uInt32 nSolarMutexLocked
Definition: xmlimprt.hxx:251
XML_CONDITIONAL_FORMATS
XML_CONDITIONAL_FORMATS
SvXMLUnitConverter::setNullDate
bool setNullDate(const css::uno::Reference< css::frame::XModel > &xModel)
SvXMLImport::GetProgressBarHelper
ProgressBarHelper * GetProgressBarHelper()
ScRangeStringConverter::GetRangeListFromString
static bool GetRangeListFromString(ScRangeList &rRangeList, const OUString &rRangeListStr, const ScDocument *pDocument, formula::FormulaGrammar::AddressConvention eConv, sal_Unicode cSeparator= ' ', sal_Unicode cQuote= '\'')
Definition: rangeutl.cxx:528
ScXMLImport::MutexGuard
Use this class to manage solar mutex locking instead of calling LockSolarMutex() and UnlockSolarMutex...
Definition: xmlimprt.hxx:392
ScDocument::BroadcastUno
void BroadcastUno(const SfxHint &rHint)
Definition: documen3.cxx:930
ScXMLImport::m_pMyNamedExpressions
std::unique_ptr< ScMyNamedExpressions > m_pMyNamedExpressions
Definition: xmlimprt.hxx:234
ScXMLImport::pTableElemTokenMap
std::unique_ptr< SvXMLTokenMap > pTableElemTokenMap
Definition: xmlimprt.hxx:220
SC_LOCALE
#define SC_LOCALE
Definition: xmlimprt.cxx:103
ScDocument::GetStorageGrammar
formula::FormulaGrammar::Grammar GetStorageGrammar() const
Definition: document.hxx:2439
ScXMLImport::GetCellType
static sal_Int16 GetCellType(const char *rStrValue, const sal_Int32 nStrLength)
Definition: xmlimprt.cxx:727
ScXMLImport::GetTableRowsElemTokenMap
const SvXMLTokenMap & GetTableRowsElemTokenMap()
Definition: xmlimprt.cxx:410
ScXMLImport::MutexGuard::mrImport
ScXMLImport & mrImport
Definition: xmlimprt.hxx:398
ScXMLImport::GetTableElemTokenMap
const SvXMLTokenMap & GetTableElemTokenMap()
Definition: xmlimprt.cxx:376
SvXMLImport::cleanup
void cleanup()
ScXMLImport::ExtractFormulaNamespaceGrammar
void ExtractFormulaNamespaceGrammar(OUString &rFormula, OUString &rFormulaNmsp,::formula::FormulaGrammar::Grammar &reGrammar, const OUString &rAttrValue, bool bRestrictToExternalNmsp=false) const
Extracts the formula string, the formula grammar namespace URL, and a grammar enum value from the pas...
Definition: xmlimprt.cxx:1760
XML_CELL_RANGE_SOURCE
XML_CELL_RANGE_SOURCE
ScCalcConfig::meStringRefAddressSyntax
formula::FormulaGrammar::AddressConvention meStringRefAddressSyntax
Definition: calcconfig.hxx:53
ScMyNamedExpressions
::std::list< std::unique_ptr< ScMyNamedExpression > > ScMyNamedExpressions
Definition: xmlimprt.hxx:159
ScFormatSaveData::maIDToName
std::map< sal_uInt64, OUString > maIDToName
Definition: sheetdata.hxx:177
XML_AUTHOR
XML_AUTHOR
FormulaError
FormulaError
ScXMLImport::GetNumberFormatAttributesExportHelper
XMLNumberFormatAttributesExportHelper * GetNumberFormatAttributesExportHelper()
Definition: xmlimprt.cxx:1320
ScXMLImport::mpEditEngine
std::unique_ptr< ScEditEngineDefaulter > mpEditEngine
Definition: xmlimprt.hxx:207
XML_COVERED_TABLE_CELL
XML_COVERED_TABLE_CELL
ScXMLImport::GetRangeType
static sal_Int32 GetRangeType(const OUString &sRangeType)
Definition: xmlimprt.cxx:1408
SC_PRINT_RANGE
#define SC_PRINT_RANGE
Definition: xmlimprt.cxx:107
ScXMLImport::pNumberFormatAttributesExportHelper
std::unique_ptr< XMLNumberFormatAttributesExportHelper > pNumberFormatAttributesExportHelper
Definition: xmlimprt.hxx:242
SC_UNONAME_CELLSTYL
#define SC_UNONAME_CELLSTYL
Definition: unonames.hxx:97
ScXMLImport::GetEditEngine
ScEditEngineDefaulter * GetEditEngine()
Definition: xmlimprt.cxx:1827
ScDocument::SetRangeOverflowType
void SetRangeOverflowType(ErrCode nType)
Definition: document.hxx:2128
ScCalcConfig
Configuration options for formula interpreter.
Definition: calcconfig.hxx:43
Calc_XMLOasisImporter_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * Calc_XMLOasisImporter_get_implementation(css::uno::XComponentContext *context, css::uno::Sequence< css::uno::Any > const &)
Definition: xmlimprt.cxx:114
XML_NUMBER_MATRIX_ROWS_SPANNED
XML_NUMBER_MATRIX_ROWS_SPANNED
ScXMLImport::xNumberFormats
css::uno::Reference< css::util::XNumberFormats > xNumberFormats
Definition: xmlimprt.hxx:244
ScXMLImport::CreateBodyContext
SvXMLImportContext * CreateBodyContext(const rtl::Reference< sax_fastparser::FastAttributeList > &rAttrList)
Definition: xmlimprt.cxx:660
TestImportXLSX
SAL_DLLPUBLIC_EXPORT bool TestImportXLSX(SvStream &rStream)
Definition: xmlimprt.cxx:1910
SvXMLImport::startDocument
virtual void SAL_CALL startDocument() override
ScXMLImport::nPrevCellType
sal_Int16 nPrevCellType
Definition: xmlimprt.hxx:253
ScXMLImport::SetViewSettings
virtual void SetViewSettings(const css::uno::Sequence< css::beans::PropertyValue > &aViewProps) override
Definition: xmlimprt.cxx:918
ScXMLImport::SetNamedRanges
void SetNamedRanges()
Definition: xmlimprt.cxx:1522
ScXMLImportContext::createFastChildContext
virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList > &Attribs) override
Definition: importcontext.cxx:45
ScXMLImport::SetLabelRanges
void SetLabelRanges()
Definition: xmlimprt.cxx:1434
XML_NUMBER_MATRIX_COLUMNS_SPANNED
XML_NUMBER_MATRIX_COLUMNS_SPANNED
comphelper::getProcessServiceFactory
Reference< XMultiServiceFactory > getProcessServiceFactory()
aBuffer
std::unique_ptr< char[]> aBuffer
XML_DOCUMENT
XML_DOCUMENT
ScXMLImport::IsStylesOnlyMode
bool IsStylesOnlyMode() const
Definition: xmlimprt.hxx:303
ScDocument::SetStreamValid
void SetStreamValid(SCTAB nTab, bool bSet, bool bIgnoreLock=false)
Definition: document.cxx:925
ScXMLImport::pSolarMutexGuard
std::unique_ptr< SolarMutexGuard > pSolarMutexGuard
Definition: xmlimprt.hxx:240
XML_NAMESPACE_OOOC
constexpr sal_uInt16 XML_NAMESPACE_OOOC
ScXMLImport::initialize
virtual void SAL_CALL initialize(const css::uno::Sequence< css::uno::Any > &aArguments) override
Definition: xmlimprt.cxx:619
SC_FILTER
#define SC_FILTER
Definition: xmlimprt.cxx:106
ScDocument::LockAdjustHeight
void LockAdjustHeight()
Definition: document.hxx:1536
XML_Y
XML_Y
ScXMLImport::pTableRowCellElemTokenMap
std::unique_ptr< SvXMLTokenMap > pTableRowCellElemTokenMap
Definition: xmlimprt.hxx:224
XML_DOCUMENT_CONTENT
XML_DOCUMENT_CONTENT
SvXMLImport::getImportFlags
SvXMLImportFlags getImportFlags() const
SvXMLImport::GetStyleDisplayName
OUString GetStyleDisplayName(XmlStyleFamily nFamily, const OUString &rName) const
ScCalcConfig::mbHasStringRefSyntax
bool mbHasStringRefSyntax
Definition: calcconfig.hxx:56
XML_TABLE_COLUMNS
XML_TABLE_COLUMNS
GetXMLToken
const OUString & GetXMLToken(enum XMLTokenEnum eToken)
ScXMLImport::GetStyleNumberFormats
ScMyStyleNumberFormats * GetStyleNumberFormats()
Definition: xmlimprt.cxx:1327
XML_BOOLEAN_VALUE
XML_BOOLEAN_VALUE
ScXMLImport::GetTableRowCellAttrTokenMap
const SvXMLTokenMap & GetTableRowCellAttrTokenMap()
Definition: xmlimprt.cxx:173
ScSheetSaveData::AddCellStyle
void AddCellStyle(const OUString &rName, const ScAddress &rCellPos)
Definition: sheetdata.cxx:41
ScXMLImport::xColumnStylesPropertySetMapper
rtl::Reference< XMLPropertySetMapper > xColumnStylesPropertySetMapper
Definition: xmlimprt.hxx:216
ScDocument::GetCalcConfig
const ScCalcConfig & GetCalcConfig() const
Definition: document.hxx:2523
ScXMLImport::pStylesImportHelper
std::unique_ptr< ScMyStylesImportHelper > pStylesImportHelper
Definition: xmlimprt.hxx:212
ScDocument::SetEmbedFonts
void SetEmbedFonts(bool bUse)
Definition: document.hxx:587
ScXMLImport::xTableStylesPropertySetMapper
rtl::Reference< XMLPropertySetMapper > xTableStylesPropertySetMapper
Definition: xmlimprt.hxx:218
XML_CREATE_DATE
XML_CREATE_DATE
SC_UNONAME_NUMFMT
#define SC_UNONAME_NUMFMT
Definition: unonames.hxx:106
ScDocument::SetChangeTrack
SC_DLLPUBLIC void SetChangeTrack(std::unique_ptr< ScChangeTrack > pTrack)
only for import filter, deletes any existing ChangeTrack via EndChangeTracking() and takes ownership ...
Definition: documen2.cxx:272
XML_NAMESPACE_TABLE
constexpr sal_uInt16 XML_NAMESPACE_TABLE
SAL_INFO
#define SAL_INFO(area, stream)
SvXMLImport::GetLocator
const css::uno::Reference< css::xml::sax::XLocator > & GetLocator() const
ScXMLImport::UnlockSolarMutex
void UnlockSolarMutex()
Definition: xmlimprt.cxx:1717
SfxObjectShell::DoInitNew
bool DoInitNew(SfxMedium *pMedium=nullptr)
XMLERROR_FLAG_ERROR
#define XMLERROR_FLAG_ERROR
XML_N_PRESENTATION
XML_N_PRESENTATION
ScXMLImport::GetChangeTrackingImportHelper
ScXMLChangeTrackingImportHelper * GetChangeTrackingImportHelper()
Definition: xmlimprt.cxx:809
XML_P
XML_P
SvXMLImport::SetStatistics
virtual void SetStatistics(const css::uno::Sequence< css::beans::NamedValue > &i_rStats)
aXMLScRowStylesImportProperties
const XMLPropertyMapEntry aXMLScRowStylesImportProperties[]
Definition: xmlstyle.cxx:124
ScXMLImport::pDetectiveOpArray
std::unique_ptr< ScMyImpDetectiveOpArray > pDetectiveOpArray
Definition: xmlimprt.hxx:239
XML_ELEMENT
#define XML_ELEMENT(prefix, name)
SvXMLNamespaceMap::Add
sal_uInt16 Add(const OUString &rPrefix, const OUString &rName, sal_uInt16 nKey=XML_NAMESPACE_UNKNOWN)
ScXMLImport::DisposingModel
virtual void DisposingModel() override
Definition: xmlimprt.cxx:1682
SvXMLImport::GetMM100UnitConverter
const SvXMLUnitConverter & GetMM100UnitConverter() const
PERCENT
const OUString PERCENT("Percent")
SvXMLImport::GetModel
const css::uno::Reference< css::frame::XModel > & GetModel() const
p
void * p
comphelper::getProcessComponentContext
Reference< XComponentContext > getProcessComponentContext()
nType
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:401
ProgressBarHelper::SetValue
void SetValue(sal_Int32 nValue)
SvXMLUnitConverter::convertPropertySet
static void convertPropertySet(css::uno::Sequence< css::beans::PropertyValue > &rProps, const css::uno::Reference< css::beans::XPropertySet > &aProperties)
SvXMLImport::SetError
void SetError(sal_Int32 nId, const css::uno::Sequence< OUString > &rMsgParams, const OUString &rExceptionMessage, const css::uno::Reference< css::xml::sax::XLocator > &rLocator)
XML_NAMED_EXPRESSIONS
XML_NAMED_EXPRESSIONS
aSeq
Sequence< sal_Int8 > aSeq
ScDocument::GetDefPattern
SC_DLLPUBLIC ScPatternAttr * GetDefPattern() const
Definition: document.cxx:6059
SC_UNO_COLLABELRNG
#define SC_UNO_COLLABELRNG
Definition: unonames.hxx:41
ScXMLImport::bLoadDoc
bool bLoadDoc
Definition: xmlimprt.hxx:254
XML_TABLE_COLUMN
XML_TABLE_COLUMN
ScMyStyleNumberFormats::AddStyleNumberFormat
void AddStyleNumberFormat(const OUString &rStyleName, const sal_Int32 nNumberFormat)
Definition: XMLStylesImportHelper.cxx:28
XML_TABLE_PROTECTION
XML_TABLE_PROTECTION
s_stats
const struct statistic s_stats[]
SvXMLImport::SetAutoStyles
void SetAutoStyles(SvXMLStylesContext *pAutoStyles)
ScDocument::GetEditPool
SC_DLLPUBLIC SfxItemPool * GetEditPool() const
Definition: documen2.cxx:444
ScXMLImport::GetTableRowAttrTokenMap
const SvXMLTokenMap & GetTableRowAttrTokenMap()
Definition: xmlimprt.cxx:446
aXMLScCellStylesProperties
const XMLPropertyMapEntry aXMLScCellStylesProperties[]
Definition: xmlstyle.cxx:61
ScXMLImport::GetDetectiveOpArray
ScMyImpDetectiveOpArray * GetDetectiveOpArray()
Definition: xmlimprt.cxx:1854
gsLocale
constexpr OUStringLiteral gsLocale(SC_LOCALE)
LocaleDataWrapper::getNumThousandSep
const OUString & getNumThousandSep() const
SvXMLStylesContext::FindStyleChildContext
const SvXMLStyleContext * FindStyleChildContext(XmlStyleFamily nFamily, const OUString &rName, bool bCreateIndex=false) const
XML_SCENARIO
XML_SCENARIO
SvXMLImport::getImportInfo
const css::uno::Reference< css::beans::XPropertySet > & getImportInfo() const
ProgressBarHelper::SetReference
void SetReference(sal_Int32 nVal)
ScXMLImport::SetChangeTrackingViewSettings
void SetChangeTrackingViewSettings(const css::uno::Sequence< css::beans::PropertyValue > &rChangeProps)
Definition: xmlimprt.cxx:838
XML_NP_PRESENTATION
XML_NP_PRESENTATION
sc::NumFmtUtil::isLatinScript
static bool isLatinScript(const ScPatternAttr &rPat, ScDocument &rDoc)
Check if the attribute pattern has a number format that only produces latin script output...
Definition: numformat.cxx:33
ScDocument::GetDocumentShell
SfxObjectShell * GetDocumentShell() const
Definition: document.hxx:1058
xModel
Reference< XModel > xModel
ScXMLImport::mbImportStyles
bool mbImportStyles
Definition: xmlimprt.hxx:258
XML_CONTENT_VALIDATION_NAME
XML_CONTENT_VALIDATION_NAME
gsCellStyle
constexpr OUStringLiteral gsCellStyle(SC_UNONAME_CELLSTYL)
DBG_TESTSOLARMUTEX
#define DBG_TESTSOLARMUTEX()
ScXMLImport::~ScXMLImport
virtual ~ScXMLImport() override
Definition: xmlimprt.cxx:592
SvXMLImport::DisposingModel
virtual void DisposingModel()
if
if(!pCandidateA->getEnd().equal(pCandidateB->getStart()))
ScXMLImport::xScPropHdlFactory
rtl::Reference< XMLPropertyHandlerFactory > xScPropHdlFactory
Definition: xmlimprt.hxx:214
tools::Rectangle::setX
void setX(long x)
XML_NAMESPACE_CALC_EXT
constexpr sal_uInt16 XML_NAMESPACE_CALC_EXT
ScSheetSaveData::IsSheetBlocked
bool IsSheetBlocked(SCTAB nTab) const
Definition: sheetdata.cxx:100
ScXMLImport::AddNamedExpression
void AddNamedExpression(ScMyNamedExpression *pMyNamedExpression)
Definition: xmlimprt.hxx:325
XML_CREATE_DATE_STRING
XML_CREATE_DATE_STRING
SvXMLImport::setTargetDocument
virtual void SAL_CALL setTargetDocument(const css::uno::Reference< css::lang::XComponent > &xDoc) override
ScXMLImport::xCellStylesPropertySetMapper
rtl::Reference< XMLPropertySetMapper > xCellStylesPropertySetMapper
Definition: xmlimprt.hxx:215
ScXMLImport::GetByteOffset
sal_Int32 GetByteOffset() const
Definition: xmlimprt.cxx:1730
SC_UNO_ROWLABELRNG
#define SC_UNO_ROWLABELRNG
Definition: unonames.hxx:45
XML_DATE_VALUE
XML_DATE_VALUE
ScXMLImport::ProgressBarIncrement
void ProgressBarIncrement()
Definition: xmlimprt.cxx:1750
ScXMLImport::GetPivotTableSources
sc::PivotTableSources & GetPivotTableSources()
Definition: xmlimprt.cxx:513
SvXMLMetaDocumentContext::characters
virtual void SAL_CALL characters(const OUString &aChars) override
XML_NAMESPACE_OFFICE_EXT
constexpr sal_uInt16 XML_NAMESPACE_OFFICE_EXT
XML_TABLE_HEADER_ROWS
XML_TABLE_HEADER_ROWS
XML_TIME_VALUE
XML_TIME_VALUE
SvXMLImport::GetAutoStyles
SvXMLStylesContext * GetAutoStyles()
ScDocument::SetCalcConfig
SC_DLLPUBLIC void SetCalcConfig(const ScCalcConfig &rConfig)
Definition: document10.cxx:200
ScXMLImport::setTargetDocument
virtual void SAL_CALL setTargetDocument(const css::uno::Reference< css::lang::XComponent > &xDoc) override
Definition: xmlimprt.cxx:1341
XML_TABLE_ROWS
XML_TABLE_ROWS
XML_NAMESPACE_SVG
constexpr sal_uInt16 XML_NAMESPACE_SVG
SvXMLImport::GetNumberFormatsSupplier
css::uno::Reference< css::util::XNumberFormatsSupplier > & GetNumberFormatsSupplier()
ScXMLImport::SetType
void SetType(const css::uno::Reference< css::beans::XPropertySet > &rProperties, sal_Int32 &rNumberFormat, const sal_Int16 nCellType, const OUString &rCurrency)
Definition: xmlimprt.cxx:1122
ScXMLImport::MutexGuard::MutexGuard
MutexGuard(ScXMLImport &rImport)
Definition: xmlimprt.cxx:1688
Calc_XMLOasisMetaImporter_get_implementation
SAL_DLLPUBLIC_EXPORT css::uno::XInterface * Calc_XMLOasisMetaImporter_get_implementation(css::uno::XComponentContext *context, css::uno::Sequence< css::uno::Any > const &)
Definition: xmlimprt.cxx:126
ScSizeDeviceProvider::GetPPTX
double GetPPTX() const
Definition: sizedev.hxx:41
ScRangeName::insert
SC_DLLPUBLIC bool insert(ScRangeData *p, bool bReuseFreeIndex=true)
Insert object into set.
Definition: rangenam.cxx:810
ScXMLImport::CreateShapeImport
virtual XMLShapeImportHelper * CreateShapeImport() override
Definition: xmlimprt.cxx:768
ScXMLImport::GetDoc
ScDocumentImport & GetDoc()
Definition: xmlimprt.cxx:722
SCTAB
sal_Int16 SCTAB
Definition: types.hxx:23
SvXMLNamespaceMap::GetKeyByQName
sal_uInt16 GetKeyByQName(const OUString &rQName, OUString *pPrefix, OUString *pLocalName, OUString *pNamespace, QNameMode eMode) const
SvXMLImport::endDocument
virtual void SAL_CALL endDocument() override
cppu::any2bool
bool any2bool(const css::uno::Any &rAny)
ScXMLImport::SetStylesToRangesFinished
void SetStylesToRangesFinished()
Definition: xmlimprt.cxx:1334
ScXMLImport::SetRangeOverflowType
void SetRangeOverflowType(ErrCode nType)
Definition: xmlimprt.cxx:1740
XML_NAMESPACE_OFFICE
constexpr sal_uInt16 XML_NAMESPACE_OFFICE
ScXMLImport::SetSheetNamedRanges
void SetSheetNamedRanges()
Definition: xmlimprt.cxx:1535
ScXMLImport::NotifyEmbeddedFontRead
virtual void NotifyEmbeddedFontRead() override
Definition: xmlimprt.cxx:1848
XML_FORMULA
XML_FORMULA
ScXMLImport::pChangeTrackingImportHelper
std::unique_ptr< ScXMLChangeTrackingImportHelper > pChangeTrackingImportHelper
Definition: xmlimprt.hxx:211
Generated on Sat Aug 8 2020 10:28:47 for LibreOffice Module sc (master) by   doxygen 1.8.10