LibreOffice Module sc (master)  1
XMLTrackedChangesContext.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 <memory>
21 #include "XMLTrackedChangesContext.hxx"
22 #include "XMLChangeTrackingImportHelper.hxx"
23 #include "xmlimprt.hxx"
24 #include "xmlconti.hxx"
25 #include <formulacell.hxx>
26 #include <textuno.hxx>
27 #include <editutil.hxx>
28 #include <document.hxx>
29 #include <xmloff/xmltoken.hxx>
30 #include <xmloff/xmlnamespace.hxx>
31 #include <xmloff/namespacemap.hxx>
32 #include <xmloff/xmluconv.hxx>
33 #include <sax/tools/converter.hxx>
34 #include <svl/sharedstringpool.hxx>
35 #include <comphelper/base64.hxx>
36 #include <com/sun/star/text/XTextCursor.hpp>
37 #include <com/sun/star/text/ControlCharacter.hpp>
38 
39 using namespace com::sun::star;
40 using namespace xmloff::token;
41 
42 namespace {
43 
44 class ScXMLChangeInfoContext : public ScXMLImportContext
45 {
46  ScMyActionInfo aInfo;
47  OUStringBuffer sAuthorBuffer{32};
48  OUStringBuffer sDateTimeBuffer{32};
49  OUStringBuffer sCommentBuffer{64};
50  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
51  sal_uInt32 nParagraphCount;
52 
53 public:
54  ScXMLChangeInfoContext( ScXMLImport& rImport,
55  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
56  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
57 
58  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
59  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
60 
61  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
62 };
63 
64 class ScXMLBigRangeContext : public ScXMLImportContext
65 {
66 public:
67  ScXMLBigRangeContext( ScXMLImport& rImport,
68  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
69  ScBigRange& rBigRange);
70 };
71 
72 class ScXMLCellContentDeletionContext : public ScXMLImportContext
73 {
74  OUString sFormulaAddress;
75  OUString sFormula;
76  OUString sFormulaNmsp;
77  OUString sInputString;
78  ScBigRange aBigRange;
79  double fValue;
80  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
81  ScCellValue maCell;
82  sal_uInt32 nID;
83  sal_Int32 nMatrixCols;
84  sal_Int32 nMatrixRows;
85  formula::FormulaGrammar::Grammar eGrammar;
86  sal_uInt16 nType;
87  ScMatrixMode nMatrixFlag;
88 
89 public:
90  ScXMLCellContentDeletionContext( ScXMLImport& rImport,
91  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
92  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
93 
94  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
95  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
96 
97  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
98 };
99 
100 class ScXMLDependenceContext : public ScXMLImportContext
101 {
102 public:
103  ScXMLDependenceContext( ScXMLImport& rImport,
104  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
105  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
106 };
107 
108 class ScXMLDependingsContext : public ScXMLImportContext
109 {
110  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
111 
112 public:
113  ScXMLDependingsContext( ScXMLImport& rImport,
114  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
115 
116  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
117  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
118 };
119 
120 class ScXMLChangeDeletionContext : public ScXMLImportContext
121 {
122 public:
123  ScXMLChangeDeletionContext( ScXMLImport& rImport,
124  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
125  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
126 
127 };
128 
129 class ScXMLDeletionsContext : public ScXMLImportContext
130 {
131  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
132 
133 public:
134  ScXMLDeletionsContext( ScXMLImport& rImport,
135  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
136 
137  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
138  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
139 };
140 
141 class ScXMLChangeCellContext;
142 
143 class ScXMLChangeTextPContext : public ScXMLImportContext
144 {
145  css::uno::Reference< css::xml::sax::XFastAttributeList> mxAttrList;
146  sal_Int32 mnElement;
147  OUStringBuffer sText;
148  ScXMLChangeCellContext* pChangeCellContext;
149  rtl::Reference<SvXMLImportContext>
150  pTextPContext;
151 
152 public:
153 
154  ScXMLChangeTextPContext( ScXMLImport& rImport, sal_Int32 nElement,
155  const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList,
156  ScXMLChangeCellContext* pChangeCellContext);
157 
158  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
159  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
160 
161  virtual void SAL_CALL characters( const OUString& rChars ) override;
162 
163  virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
164 };
165 
166 class ScXMLChangeCellContext : public ScXMLImportContext
167 {
168  ScCellValue& mrOldCell;
169 
170  OUString sText;
171  OUString& rInputString;
172  rtl::Reference<ScEditEngineTextObj> mpEditTextObj;
173  double fValue;
174  sal_uInt16& rType;
175  bool bEmpty;
176  bool bFirstParagraph;
177  bool bString;
178  bool bFormula;
179 
180 public:
181  ScXMLChangeCellContext( ScXMLImport& rImport,
182  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
183  ScCellValue& rOldCell, OUString& sAddress,
184  OUString& rFormula, OUString& rFormulaNmsp,
185  formula::FormulaGrammar::Grammar& rGrammar,
186  OUString& rInputString, double& fValue, sal_uInt16& nType,
187  ScMatrixMode& nMatrixFlag, sal_Int32& nMatrixCols, sal_Int32& nMatrixRows);
188 
189  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
190  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
191 
192  void CreateTextPContext(bool bIsNewParagraph);
193  bool IsEditCell() const { return mpEditTextObj.is(); }
194  void SetText(const OUString& sTempText) { sText = sTempText; }
195 
196  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
197 };
198 
199 class ScXMLPreviousContext : public ScXMLImportContext
200 {
201  OUString sFormulaAddress;
202  OUString sFormula;
203  OUString sFormulaNmsp;
204  OUString sInputString;
205  double fValue;
206  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
207  ScCellValue maOldCell;
208  sal_uInt32 nID;
209  sal_Int32 nMatrixCols;
210  sal_Int32 nMatrixRows;
211  formula::FormulaGrammar::Grammar eGrammar;
212  sal_uInt16 nType;
213  ScMatrixMode nMatrixFlag;
214 
215 public:
216  ScXMLPreviousContext( ScXMLImport& rImport,
217  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
218  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
219 
220  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
221  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
222 
223  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
224 };
225 
226 class ScXMLContentChangeContext : public ScXMLImportContext
227 {
228  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
229  ScBigRange aBigRange;
230 
231 public:
232  ScXMLContentChangeContext( ScXMLImport& rImport,
233  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
234  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
235 
236  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
237  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
238 
239  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
240 };
241 
242 class ScXMLInsertionContext : public ScXMLImportContext
243 {
244  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
245 
246 public:
247  ScXMLInsertionContext( ScXMLImport& rImport,
248  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
249  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
250 
251  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
252  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
253 
254  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
255 };
256 
257 class ScXMLInsertionCutOffContext : public ScXMLImportContext
258 {
259 public:
260  ScXMLInsertionCutOffContext( ScXMLImport& rImport,
261  const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList,
262  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
263 };
264 
265 class ScXMLMovementCutOffContext : public ScXMLImportContext
266 {
267 public:
268  ScXMLMovementCutOffContext( ScXMLImport& rImport,
269  const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList,
270  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
271 };
272 
273 class ScXMLCutOffsContext : public ScXMLImportContext
274 {
275  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
276 
277 public:
278  ScXMLCutOffsContext( ScXMLImport& rImport,
279  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
280 
281  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
282  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
283 };
284 
285 class ScXMLDeletionContext : public ScXMLImportContext
286 {
287  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
288 
289 public:
290  ScXMLDeletionContext( ScXMLImport& rImport,
291  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
292  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
293 
294  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
295  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
296 
297  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
298 };
299 
300 class ScXMLMovementContext : public ScXMLImportContext
301 {
302  ScBigRange aSourceRange;
303  ScBigRange aTargetRange;
304  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
305 
306 public:
307  ScXMLMovementContext( ScXMLImport& rImport,
308  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
309  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
310 
311  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
312  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
313 
314  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
315 };
316 
317 class ScXMLRejectionContext : public ScXMLImportContext
318 {
319  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
320 
321 public:
322  ScXMLRejectionContext( ScXMLImport& rImport,
323  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
324  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
325 
326  virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
327  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
328 
329  virtual void SAL_CALL endFastElement( sal_Int32 nElement ) override;
330 };
331 
332 }
333 
334 ScXMLTrackedChangesContext::ScXMLTrackedChangesContext( ScXMLImport& rImport,
335  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
336  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
337  ScXMLImportContext( rImport ),
338  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
339 {
340  rImport.LockSolarMutex();
341 
342  if ( !rAttrList.is() )
343  return;
344 
345  auto aIter( rAttrList->find( XML_ELEMENT( TABLE, XML_PROTECTION_KEY ) ) );
346  if (aIter != rAttrList->end())
347  {
348  if( !aIter.isEmpty() )
349  {
350  uno::Sequence<sal_Int8> aPass;
351  ::comphelper::Base64::decode( aPass, aIter.toString() );
352  pChangeTrackingImportHelper->SetProtection(aPass);
353  }
354  }
355 }
356 
357 ScXMLTrackedChangesContext::~ScXMLTrackedChangesContext()
358 {
359  GetScImport().UnlockSolarMutex();
360 }
361 
362 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLTrackedChangesContext::createFastChildContext(
363  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
364 {
365  SvXMLImportContext *pContext(nullptr);
366  sax_fastparser::FastAttributeList *pAttribList =
367  &sax_fastparser::castToFastAttributeList( xAttrList );
368 
369  switch (nElement)
370  {
371  case XML_ELEMENT( TABLE, XML_CELL_CONTENT_CHANGE ):
372  pContext = new ScXMLContentChangeContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
373  break;
374  case XML_ELEMENT( TABLE, XML_INSERTION ):
375  pContext = new ScXMLInsertionContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
376  break;
377  case XML_ELEMENT( TABLE, XML_DELETION ):
378  pContext = new ScXMLDeletionContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
379  break;
380  case XML_ELEMENT( TABLE, XML_MOVEMENT ):
381  pContext = new ScXMLMovementContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
382  break;
383  case XML_ELEMENT( TABLE, XML_REJECTION ):
384  pContext = new ScXMLRejectionContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
385  break;
386  }
387 
388  return pContext;
389 }
390 
391 ScXMLChangeInfoContext::ScXMLChangeInfoContext( ScXMLImport& rImport,
392  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
393  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
394  ScXMLImportContext( rImport ),
395  aInfo(),
396  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
397  nParagraphCount(0)
398 {
399  if ( rAttrList.is() )
400  {
401  for (auto &aIter : *rAttrList)
402  {
403  sal_Int32 nToken = aIter.getToken();
404  if ( nToken == XML_ELEMENT( OFFICE, XML_CHG_AUTHOR ) )
405  sAuthorBuffer = aIter.toString();
406  else if ( nToken == XML_ELEMENT( OFFICE, XML_CHG_DATE_TIME ) )
407  sDateTimeBuffer = aIter.toString();
408  }
409  }
410 }
411 
412 css::uno::Reference< css::xml::sax::XFastContextHandler > ScXMLChangeInfoContext::createFastChildContext(
413  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/ )
414 {
415  SvXMLImportContext *pContext(nullptr);
416 
417  if( nElement == XML_ELEMENT(DC, XML_CREATOR ) )
418  pContext = new ScXMLContentContext(GetScImport(), sAuthorBuffer);
419  else if( nElement == XML_ELEMENT(DC, XML_DATE ) )
420  pContext = new ScXMLContentContext(GetScImport(), sDateTimeBuffer);
421  else if (nElement == XML_ELEMENT(TEXT, XML_P))
422  {
423  if(nParagraphCount)
424  sCommentBuffer.append('\n');
425  ++nParagraphCount;
426  pContext = new ScXMLContentContext( GetScImport(), sCommentBuffer);
427  }
428 
429  return pContext;
430 }
431 
432 void SAL_CALL ScXMLChangeInfoContext::endFastElement( sal_Int32 /*nElement*/ )
433 {
434  aInfo.sUser = sAuthorBuffer.makeStringAndClear();
435  ::sax::Converter::parseDateTime(aInfo.aDateTime,
436  sDateTimeBuffer.makeStringAndClear());
437  aInfo.sComment = sCommentBuffer.makeStringAndClear();
438  pChangeTrackingImportHelper->SetActionInfo(aInfo);
439 }
440 
441 ScXMLBigRangeContext::ScXMLBigRangeContext( ScXMLImport& rImport,
442  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
443  ScBigRange& rBigRange ) :
444  ScXMLImportContext( rImport )
445 {
446  bool bColumn(false);
447  bool bRow(false);
448  bool bTable(false);
449  sal_Int32 nColumn(0);
450  sal_Int32 nRow(0);
451  sal_Int32 nTable(0);
452  sal_Int32 nStartColumn(0);
453  sal_Int32 nEndColumn(0);
454  sal_Int32 nStartRow(0);
455  sal_Int32 nEndRow(0);
456  sal_Int32 nStartTable(0);
457  sal_Int32 nEndTable(0);
458  if ( rAttrList.is() )
459  {
460  for (auto &aIter : *rAttrList)
461  {
462  switch (aIter.getToken())
463  {
464  case XML_ELEMENT( TABLE, XML_COLUMN ):
465  nColumn = aIter.toInt32();
466  bColumn = true;
467  break;
468  case XML_ELEMENT( TABLE, XML_ROW ):
469  nRow = aIter.toInt32();
470  bRow = true;
471  break;
472  case XML_ELEMENT( TABLE, XML_TABLE ):
473  nTable = aIter.toInt32();
474  bTable = true;
475  break;
476  case XML_ELEMENT( TABLE, XML_START_COLUMN ):
477  nStartColumn = aIter.toInt32();
478  break;
479  case XML_ELEMENT( TABLE, XML_END_COLUMN ):
480  nEndColumn = aIter.toInt32();
481  break;
482  case XML_ELEMENT( TABLE, XML_START_ROW ):
483  nStartRow = aIter.toInt32();
484  break;
485  case XML_ELEMENT( TABLE, XML_END_ROW ):
486  nEndRow = aIter.toInt32();
487  break;
488  case XML_ELEMENT( TABLE, XML_START_TABLE ):
489  nStartTable = aIter.toInt32();
490  break;
491  case XML_ELEMENT( TABLE, XML_END_TABLE ):
492  nEndTable = aIter.toInt32();
493  break;
494  }
495  }
496  }
497 
498  if (bColumn)
499  nStartColumn = nEndColumn = nColumn;
500  if (bRow)
501  nStartRow = nEndRow = nRow;
502  if (bTable)
503  nStartTable = nEndTable = nTable;
504  rBigRange.Set(nStartColumn, nStartRow, nStartTable,
505  nEndColumn, nEndRow, nEndTable);
506 }
507 
508 ScXMLCellContentDeletionContext::ScXMLCellContentDeletionContext( ScXMLImport& rImport,
509  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
510  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper) :
511  ScXMLImportContext( rImport ),
512  fValue(0.0),
513  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
514  nID(0),
515  nMatrixCols(0),
516  nMatrixRows(0),
517  eGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT),
518  nType(css::util::NumberFormat::ALL),
519  nMatrixFlag(ScMatrixMode::NONE)
520 {
521  if ( rAttrList.is() )
522  {
523  auto aIter( rAttrList->find( XML_ELEMENT( TABLE, XML_ID ) ) );
524  if (aIter != rAttrList->end())
525  nID = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
526  }
527 }
528 
529 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLCellContentDeletionContext::createFastChildContext(
530  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
531 {
532  SvXMLImportContext *pContext(nullptr);
533  sax_fastparser::FastAttributeList *pAttribList =
534  &sax_fastparser::castToFastAttributeList( xAttrList );
535 
536  switch (nElement)
537  {
538  case XML_ELEMENT( TABLE, XML_CHANGE_TRACK_TABLE_CELL ):
539  pContext = new ScXMLChangeCellContext(GetScImport(), pAttribList,
540  maCell, sFormulaAddress, sFormula, sFormulaNmsp, eGrammar, sInputString, fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows );
541  break;
542  case XML_ELEMENT( TABLE, XML_CELL_ADDRESS ):
543  OSL_ENSURE(!nID, "a action with a ID should not contain a BigRange");
544  pContext = new ScXMLBigRangeContext(GetScImport(), pAttribList, aBigRange);
545  break;
546  }
547 
548  return pContext;
549 }
550 
551 void SAL_CALL ScXMLCellContentDeletionContext::endFastElement( sal_Int32 /*nElement*/ )
552 {
553  std::unique_ptr<ScMyCellInfo> pCellInfo(new ScMyCellInfo(maCell, sFormulaAddress, sFormula, eGrammar, sInputString, fValue, nType,
554  nMatrixFlag, nMatrixCols, nMatrixRows));
555  if (nID)
556  pChangeTrackingImportHelper->AddDeleted(nID, std::move(pCellInfo));
557  else
558  pChangeTrackingImportHelper->AddGenerated(std::move(pCellInfo), aBigRange);
559 }
560 
561 ScXMLDependenceContext::ScXMLDependenceContext( ScXMLImport& rImport,
562  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
563  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper ) :
564  ScXMLImportContext( rImport )
565 {
566  sal_uInt32 nID(0);
567  if ( rAttrList.is() )
568  {
569  auto aIter( rAttrList->find( XML_ELEMENT( TABLE, XML_ID ) ) );
570  if (aIter != rAttrList->end())
571  nID = ScXMLChangeTrackingImportHelper::GetIDFromString(aIter.toView());
572  }
573  pChangeTrackingImportHelper->AddDependence(nID);
574 }
575 
576 ScXMLDependingsContext::ScXMLDependingsContext( ScXMLImport& rImport,
577  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
578  ScXMLImportContext( rImport ),
579  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
580 {
581  // here are no attributes
582 }
583 
584 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLDependingsContext::createFastChildContext(
585  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
586 {
587  SvXMLImportContext *pContext(nullptr);
588  sax_fastparser::FastAttributeList *pAttribList =
589  &sax_fastparser::castToFastAttributeList( xAttrList );
590 
591  // #i80033# read both old (dependence) and new (dependency) elements
592  if (nElement == XML_ELEMENT( TABLE, XML_DEPENDENCE ) ||
593  nElement == XML_ELEMENT( TABLE, XML_DEPENDENCY ))
594  {
595  pContext = new ScXMLDependenceContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
596  }
597 
598  return pContext;
599 }
600 
601 ScXMLChangeDeletionContext::ScXMLChangeDeletionContext( ScXMLImport& rImport,
602  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
603  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper ) :
604  ScXMLImportContext( rImport )
605 {
606  sal_uInt32 nID(0);
607  if ( rAttrList.is() )
608  {
609  auto aIter( rAttrList->find( XML_ELEMENT( TABLE, XML_ID ) ) );
610  if (aIter != rAttrList->end())
611  nID = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
612  }
613  pChangeTrackingImportHelper->AddDeleted(nID);
614 }
615 
616 ScXMLDeletionsContext::ScXMLDeletionsContext( ScXMLImport& rImport,
617  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
618  ScXMLImportContext( rImport ),
619  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
620 {
621  // here are no attributes
622 }
623 
624 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLDeletionsContext::createFastChildContext(
625  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
626 {
627  SvXMLImportContext *pContext(nullptr);
628  sax_fastparser::FastAttributeList *pAttribList =
629  &sax_fastparser::castToFastAttributeList( xAttrList );
630 
631  switch (nElement)
632  {
633  case XML_ELEMENT( TABLE, XML_CHANGE_DELETION ):
634  pContext = new ScXMLChangeDeletionContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
635  break;
636  case XML_ELEMENT( TABLE, XML_CELL_CONTENT_DELETION ):
637  pContext = new ScXMLCellContentDeletionContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
638  break;
639  }
640 
641  return pContext;
642 }
643 
644 ScXMLChangeTextPContext::ScXMLChangeTextPContext( ScXMLImport& rImport,
645  sal_Int32 nElement,
646  const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList,
647  ScXMLChangeCellContext* pTempChangeCellContext) :
648  ScXMLImportContext( rImport ),
649  mxAttrList(xAttrList),
650  mnElement(nElement),
651  pChangeCellContext(pTempChangeCellContext)
652 {
653  // here are no attributes
654 }
655 
656 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLChangeTextPContext::createFastChildContext(
657  sal_Int32 nElement,
658  const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
659 {
660  uno::Reference< xml::sax::XFastContextHandler > xContext;
661  if (IsTokenInNamespace(mnElement, XML_NAMESPACE_TEXT)
662  && (nElement & TOKEN_MASK) == XML_S
663  && !pTextPContext)
664  {
665  sal_Int32 nRepeat(0);
666  for( auto& aIter : sax_fastparser::castToFastAttributeList(mxAttrList) )
667  {
668  if (aIter.getToken() == XML_ELEMENT(TEXT, XML_C))
669  nRepeat = aIter.toInt32();
670  else
671  XMLOFF_WARN_UNKNOWN("sc", aIter);
672  }
673  if (nRepeat)
674  for (sal_Int32 j = 0; j < nRepeat; ++j)
675  sText.append(' ');
676  else
677  sText.append(' ');
678  }
679  else
680  {
681  if (!pChangeCellContext->IsEditCell())
682  pChangeCellContext->CreateTextPContext(false);
683  bool bWasContext (true);
684  if (!pTextPContext)
685  {
686  bWasContext = false;
687  pTextPContext = GetScImport().GetTextImport()->CreateTextChildContext(
688  GetScImport(), mnElement, mxAttrList);
689  }
690  if (pTextPContext)
691  {
692  if (!bWasContext)
693  pTextPContext->characters(sText.makeStringAndClear());
694  xContext = pTextPContext->createFastChildContext(nElement, xAttrList);
695  }
696  }
697 
698  return xContext;
699 }
700 
701 void ScXMLChangeTextPContext::characters( const OUString& rChars )
702 {
703  if (!pTextPContext)
704  sText.append(rChars);
705  else
706  pTextPContext->characters(rChars);
707 }
708 
709 void ScXMLChangeTextPContext::endFastElement(sal_Int32 /*nElement*/)
710 {
711  if (!pTextPContext)
712  pChangeCellContext->SetText(sText.makeStringAndClear());
713 }
714 
715 ScXMLChangeCellContext::ScXMLChangeCellContext( ScXMLImport& rImport,
716  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
717  ScCellValue& rOldCell, OUString& rAddress,
718  OUString& rFormula, OUString& rFormulaNmsp,
719  formula::FormulaGrammar::Grammar& rGrammar,
720  OUString& rTempInputString, double& rDateTimeValue, sal_uInt16& nType,
721  ScMatrixMode& nMatrixFlag, sal_Int32& nMatrixCols, sal_Int32& nMatrixRows )
722  : ScXMLImportContext( rImport )
723  , mrOldCell(rOldCell)
724  , rInputString(rTempInputString)
725  , fValue(0.0)
726  , rType(nType)
727  , bEmpty(true)
728  , bFirstParagraph(true)
729  , bString(true)
730  , bFormula(false)
731 {
732  bool bIsMatrix(false);
733  bool bIsCoveredMatrix(false);
734  if ( rAttrList.is() )
735  {
736  for (auto &aIter : *rAttrList)
737  {
738  switch (aIter.getToken())
739  {
740  case XML_ELEMENT( TABLE, XML_FORMULA ):
741  bEmpty = false;
742  GetScImport().ExtractFormulaNamespaceGrammar( rFormula, rFormulaNmsp, rGrammar, aIter.toString() );
743  bFormula = true;
744  break;
745  case XML_ELEMENT( TABLE, XML_CELL_ADDRESS ):
746  rAddress = aIter.toString();
747  break;
748  case XML_ELEMENT( TABLE, XML_MATRIX_COVERED ):
749  bIsCoveredMatrix = IsXMLToken(aIter, XML_TRUE);
750  break;
751  case XML_ELEMENT( TABLE, XML_NUMBER_MATRIX_COLUMNS_SPANNED ):
752  bIsMatrix = true;
753  nMatrixCols = aIter.toInt32();
754  break;
755  case XML_ELEMENT( TABLE, XML_NUMBER_MATRIX_ROWS_SPANNED ):
756  bIsMatrix = true;
757  nMatrixRows = aIter.toInt32();
758  break;
759  case XML_ELEMENT( OFFICE, XML_VALUE_TYPE ):
760  if (IsXMLToken(aIter, XML_FLOAT))
761  bString = false;
762  else if (IsXMLToken(aIter, XML_DATE))
763  {
764  rType = css::util::NumberFormat::DATE;
765  bString = false;
766  }
767  else if (IsXMLToken(aIter, XML_TIME))
768  {
769  rType = css::util::NumberFormat::TIME;
770  bString = false;
771  }
772  break;
773  case XML_ELEMENT( OFFICE, XML_VALUE ):
774  fValue = aIter.toDouble();
775  bEmpty = false;
776  break;
777  case XML_ELEMENT( OFFICE, XML_DATE_VALUE ):
778  bEmpty = false;
779  if (GetScImport().GetMM100UnitConverter().setNullDate(GetScImport().GetModel()))
780  GetScImport().GetMM100UnitConverter().convertDateTime(rDateTimeValue, aIter.toString());
781  fValue = rDateTimeValue;
782  break;
783  case XML_ELEMENT( OFFICE, XML_TIME_VALUE ):
784  bEmpty = false;
785  ::sax::Converter::convertDuration(rDateTimeValue, aIter.toString());
786  fValue = rDateTimeValue;
787  }
788  }
789  }
790 
791  if (bIsCoveredMatrix)
792  nMatrixFlag = ScMatrixMode::Reference;
793  else if (bIsMatrix && nMatrixRows && nMatrixCols)
794  nMatrixFlag = ScMatrixMode::Formula;
795 }
796 
797 uno::Reference< xml::sax::XFastContextHandler > ScXMLChangeCellContext::createFastChildContext(
798  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
799 {
800  SvXMLImportContext *pContext(nullptr);
801 
802  if (nElement == XML_ELEMENT(TEXT, XML_P))
803  {
804  bEmpty = false;
805  if (bFirstParagraph)
806  {
807  pContext = new ScXMLChangeTextPContext(GetScImport(), nElement, xAttrList, this);
808  bFirstParagraph = false;
809  }
810  else
811  {
812  if (!mpEditTextObj.is())
813  CreateTextPContext(true);
814  pContext = GetScImport().GetTextImport()->CreateTextChildContext(
815  GetScImport(), nElement, xAttrList);
816  }
817  }
818  else
819  XMLOFF_WARN_UNKNOWN_ELEMENT("sc", nElement);
820 
821  return pContext;
822 }
823 
824 void ScXMLChangeCellContext::CreateTextPContext(bool bIsNewParagraph)
825 {
826  if (!GetScImport().GetDocument())
827  return;
828 
829  mpEditTextObj = new ScEditEngineTextObj();
830  mpEditTextObj->GetEditEngine()->SetEditTextObjectPool(GetScImport().GetDocument()->GetEditPool());
831  uno::Reference <text::XText> xText(mpEditTextObj);
832  if (xText.is())
833  {
834  uno::Reference<text::XTextCursor> xTextCursor(xText->createTextCursor());
835  if (bIsNewParagraph)
836  {
837  xText->setString(sText);
838  xTextCursor->gotoEnd(false);
839  xText->insertControlCharacter(xTextCursor, text::ControlCharacter::PARAGRAPH_BREAK, false);
840  }
841  GetScImport().GetTextImport()->SetCursor(xTextCursor);
842  }
843 }
844 
845 void SAL_CALL ScXMLChangeCellContext::endFastElement( sal_Int32 /*nElement*/ )
846 {
847  if (!bEmpty)
848  {
849  ScDocument* pDoc = GetScImport().GetDocument();
850  if (mpEditTextObj.is())
851  {
852  if (GetImport().GetTextImport()->GetCursor().is())
853  {
854  //GetImport().GetTextImport()->GetCursor()->gotoEnd(sal_False);
855  if( GetImport().GetTextImport()->GetCursor()->goLeft( 1, true ) )
856  {
857  GetImport().GetTextImport()->GetText()->insertString(
858  GetImport().GetTextImport()->GetCursorAsRange(), "",
859  true );
860  }
861  }
862 
863  // The cell will own the text object instance.
864  mrOldCell.meType = CELLTYPE_EDIT;
865  mrOldCell.mpEditText = mpEditTextObj->CreateTextObject().release();
866  GetScImport().GetTextImport()->ResetCursor();
867  mpEditTextObj.clear();
868  }
869  else
870  {
871  if (!bFormula)
872  {
873  if (!sText.isEmpty() && bString)
874  {
875  mrOldCell.meType = CELLTYPE_STRING;
876  mrOldCell.mpString = new svl::SharedString(pDoc->GetSharedStringPool().intern(sText));
877  }
878  else
879  {
880  mrOldCell.meType = CELLTYPE_VALUE;
881  mrOldCell.mfValue = fValue;
882  }
883  if (rType == css::util::NumberFormat::DATE || rType == css::util::NumberFormat::TIME)
884  rInputString = sText;
885  }
886  }
887  }
888  else
889  mrOldCell.clear();
890 }
891 
892 ScXMLPreviousContext::ScXMLPreviousContext( ScXMLImport& rImport,
893  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
894  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
895  ScXMLImportContext( rImport ),
896  fValue(0.0),
897  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
898  nID(0),
899  nMatrixCols(0),
900  nMatrixRows(0),
901  eGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT),
902  nType(css::util::NumberFormat::ALL),
903  nMatrixFlag(ScMatrixMode::NONE)
904 {
905  if ( rAttrList.is() )
906  {
907  auto aIter( rAttrList->find( XML_ELEMENT( TABLE, XML_ID ) ) );
908  if (aIter != rAttrList->end())
909  nID = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
910  }
911 }
912 
913 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLPreviousContext::createFastChildContext(
914  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
915 {
916  SvXMLImportContext *pContext(nullptr);
917  sax_fastparser::FastAttributeList *pAttribList =
918  &sax_fastparser::castToFastAttributeList( xAttrList );
919 
920  if ( nElement == XML_ELEMENT( TABLE, XML_CHANGE_TRACK_TABLE_CELL ) )
921  pContext = new ScXMLChangeCellContext(GetScImport(), pAttribList,
922  maOldCell, sFormulaAddress, sFormula, sFormulaNmsp, eGrammar, sInputString, fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows);
923 
924  return pContext;
925 }
926 
927 void SAL_CALL ScXMLPreviousContext::endFastElement( sal_Int32 /*nElement*/ )
928 {
929  pChangeTrackingImportHelper->SetPreviousChange(nID, new ScMyCellInfo(maOldCell, sFormulaAddress, sFormula, eGrammar, sInputString,
930  fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows));
931 }
932 
933 ScXMLContentChangeContext::ScXMLContentChangeContext( ScXMLImport& rImport,
934  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
935  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
936  ScXMLImportContext( rImport ),
937  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
938 {
939  sal_uInt32 nActionNumber(0);
940  sal_uInt32 nRejectingNumber(0);
941  ScChangeActionState nActionState(SC_CAS_VIRGIN);
942 
943  if ( rAttrList.is() )
944  {
945  for (auto &aIter : *rAttrList)
946  {
947  switch (aIter.getToken())
948  {
949  case XML_ELEMENT( TABLE, XML_ID ):
950  nActionNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
951  break;
952  case XML_ELEMENT( TABLE, XML_ACCEPTANCE_STATE ):
953  if (IsXMLToken( aIter, XML_ACCEPTED ))
954  nActionState = SC_CAS_ACCEPTED;
955  else if (IsXMLToken( aIter, XML_REJECTED ))
956  nActionState = SC_CAS_REJECTED;
957  break;
958  case XML_ELEMENT( TABLE, XML_REJECTING_CHANGE_ID ):
959  nRejectingNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
960  }
961  }
962  }
963 
964  pChangeTrackingImportHelper->StartChangeAction(SC_CAT_CONTENT);
965  pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
966  pChangeTrackingImportHelper->SetActionState(nActionState);
967  pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
968 }
969 
970 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLContentChangeContext::createFastChildContext(
971  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
972 {
973  SvXMLImportContext *pContext(nullptr);
974  sax_fastparser::FastAttributeList *pAttribList =
975  &sax_fastparser::castToFastAttributeList( xAttrList );
976 
977  switch (nElement)
978  {
979  case XML_ELEMENT( OFFICE, XML_CHANGE_INFO ):
980  pContext = new ScXMLChangeInfoContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
981  break;
982  case XML_ELEMENT( TABLE, XML_CELL_ADDRESS ):
983  pContext = new ScXMLBigRangeContext(GetScImport(), pAttribList, aBigRange);
984  break;
985  case XML_ELEMENT( TABLE, XML_DEPENDENCIES ):
986  pContext = new ScXMLDependingsContext(GetScImport(), pChangeTrackingImportHelper);
987  break;
988  case XML_ELEMENT( TABLE, XML_DELETIONS ):
989  pContext = new ScXMLDeletionsContext(GetScImport(), pChangeTrackingImportHelper);
990  break;
991  case XML_ELEMENT( TABLE, XML_PREVIOUS ):
992  pContext = new ScXMLPreviousContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
993  break;
994  }
995 
996  return pContext;
997 }
998 
999 void SAL_CALL ScXMLContentChangeContext::endFastElement( sal_Int32 /*nElement*/ )
1000 {
1001  pChangeTrackingImportHelper->SetBigRange(aBigRange);
1002  pChangeTrackingImportHelper->EndChangeAction();
1003 }
1004 
1005 ScXMLInsertionContext::ScXMLInsertionContext( ScXMLImport& rImport,
1006  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
1007  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1008  ScXMLImportContext( rImport ),
1009  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1010 {
1011  sal_uInt32 nActionNumber(0);
1012  sal_uInt32 nRejectingNumber(0);
1013  sal_Int32 nPosition(0);
1014  sal_Int32 nCount(1);
1015  sal_Int32 nTable(0);
1016  ScChangeActionState nActionState(SC_CAS_VIRGIN);
1017  ScChangeActionType nActionType(SC_CAT_INSERT_COLS);
1018 
1019  if ( rAttrList.is() )
1020  {
1021  for (auto &aIter : *rAttrList)
1022  {
1023  switch (aIter.getToken())
1024  {
1025  case XML_ELEMENT( TABLE, XML_ID ):
1026  nActionNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
1027  break;
1028  case XML_ELEMENT( TABLE, XML_ACCEPTANCE_STATE ):
1029  if (IsXMLToken( aIter, XML_ACCEPTED ))
1030  nActionState = SC_CAS_ACCEPTED;
1031  else if (IsXMLToken( aIter, XML_REJECTED ))
1032  nActionState = SC_CAS_REJECTED;
1033  break;
1034  case XML_ELEMENT( TABLE, XML_REJECTING_CHANGE_ID ):
1035  nRejectingNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
1036  break;
1037  case XML_ELEMENT( TABLE, XML_TYPE ):
1038  if (IsXMLToken( aIter, XML_ROW ))
1039  nActionType = SC_CAT_INSERT_ROWS;
1040  else if (IsXMLToken( aIter, XML_TABLE ))
1041  nActionType = SC_CAT_INSERT_TABS;
1042  break;
1043  case XML_ELEMENT( TABLE, XML_POSITION ):
1044  nPosition = aIter.toInt32();
1045  break;
1046  case XML_ELEMENT( TABLE, XML_TABLE ):
1047  nTable = aIter.toInt32();
1048  break;
1049  case XML_ELEMENT( TABLE, XML_COUNT ):
1050  nCount = aIter.toInt32();
1051  break;
1052  }
1053  }
1054  }
1055 
1056  pChangeTrackingImportHelper->StartChangeAction(nActionType);
1057  pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1058  pChangeTrackingImportHelper->SetActionState(nActionState);
1059  pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1060  pChangeTrackingImportHelper->SetPosition(nPosition, nCount, nTable);
1061 }
1062 
1063 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLInsertionContext::createFastChildContext(
1064  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
1065 {
1066  SvXMLImportContext *pContext(nullptr);
1067  sax_fastparser::FastAttributeList *pAttribList =
1068  &sax_fastparser::castToFastAttributeList( xAttrList );
1069 
1070  switch (nElement)
1071  {
1072  case XML_ELEMENT( OFFICE, XML_CHANGE_INFO ):
1073  pContext = new ScXMLChangeInfoContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
1074  break;
1075  case XML_ELEMENT( TABLE, XML_DEPENDENCIES ):
1076  pContext = new ScXMLDependingsContext(GetScImport(), pChangeTrackingImportHelper);
1077  break;
1078  case XML_ELEMENT( TABLE, XML_DELETIONS ):
1079  pContext = new ScXMLDeletionsContext(GetScImport(), pChangeTrackingImportHelper);
1080  break;
1081  }
1082 
1083  return pContext;
1084 }
1085 
1086 void SAL_CALL ScXMLInsertionContext::endFastElement( sal_Int32 /*nElement*/ )
1087 {
1088  pChangeTrackingImportHelper->EndChangeAction();
1089 }
1090 
1091 ScXMLInsertionCutOffContext::ScXMLInsertionCutOffContext( ScXMLImport& rImport,
1092  const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
1093  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper ) :
1094  ScXMLImportContext( rImport )
1095 {
1096  sal_uInt32 nID(0);
1097  sal_Int32 nPosition(0);
1098  for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
1099  {
1100  switch (aIter.getToken())
1101  {
1102  case XML_ELEMENT(TABLE, XML_ID):
1103  nID = ScXMLChangeTrackingImportHelper::GetIDFromString(aIter.toView());
1104  break;
1105  case XML_ELEMENT(TABLE, XML_POSITION):
1106  ::sax::Converter::convertNumber(nPosition, aIter.toView());
1107  break;
1108  }
1109  }
1110  pChangeTrackingImportHelper->SetInsertionCutOff(nID, nPosition);
1111 }
1112 
1113 
1114 ScXMLMovementCutOffContext::ScXMLMovementCutOffContext( ScXMLImport& rImport,
1115  const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
1116  ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper ) :
1117  ScXMLImportContext( rImport )
1118 {
1119  sal_uInt32 nID(0);
1120  sal_Int32 nPosition(0);
1121  sal_Int32 nStartPosition(0);
1122  sal_Int32 nEndPosition(0);
1123  bool bPosition(false);
1124  for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
1125  {
1126  switch (aIter.getToken())
1127  {
1128  case XML_ELEMENT(TABLE, XML_ID):
1129  nID = ScXMLChangeTrackingImportHelper::GetIDFromString(aIter.toView());
1130  break;
1131  case XML_ELEMENT(TABLE, XML_POSITION):
1132  bPosition = true;
1133  ::sax::Converter::convertNumber(nPosition, aIter.toView());
1134  break;
1135  case XML_ELEMENT(TABLE, XML_START_POSITION):
1136  ::sax::Converter::convertNumber(nStartPosition, aIter.toView());
1137  break;
1138  case XML_ELEMENT(TABLE, XML_END_POSITION):
1139  ::sax::Converter::convertNumber(nEndPosition, aIter.toView());
1140  break;
1141  }
1142  }
1143  if (bPosition)
1144  nStartPosition = nEndPosition = nPosition;
1145  pChangeTrackingImportHelper->AddMoveCutOff(nID, nStartPosition, nEndPosition);
1146 }
1147 
1148 ScXMLCutOffsContext::ScXMLCutOffsContext( ScXMLImport& rImport,
1149  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1150  ScXMLImportContext( rImport ),
1151  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1152 {
1153  // here are no attributes
1154 }
1155 
1156 css::uno::Reference< css::xml::sax::XFastContextHandler > ScXMLCutOffsContext::createFastChildContext(
1157  sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
1158 {
1159  SvXMLImportContext *pContext(nullptr);
1160 
1161  if (nElement == XML_ELEMENT(TABLE, XML_INSERTION_CUT_OFF))
1162  pContext = new ScXMLInsertionCutOffContext(GetScImport(), xAttrList, pChangeTrackingImportHelper);
1163  else if (nElement == XML_ELEMENT(TABLE, XML_MOVEMENT_CUT_OFF))
1164  pContext = new ScXMLMovementCutOffContext(GetScImport(), xAttrList, pChangeTrackingImportHelper);
1165 
1166  return pContext;
1167 }
1168 
1169 ScXMLDeletionContext::ScXMLDeletionContext( ScXMLImport& rImport,
1170  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
1171  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1172  ScXMLImportContext( rImport ),
1173  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1174 {
1175  sal_uInt32 nActionNumber(0);
1176  sal_uInt32 nRejectingNumber(0);
1177  sal_Int32 nPosition(0);
1178  sal_Int32 nMultiSpanned(0);
1179  sal_Int32 nTable(0);
1180  ScChangeActionState nActionState(SC_CAS_VIRGIN);
1181  ScChangeActionType nActionType(SC_CAT_DELETE_COLS);
1182 
1183  if ( rAttrList.is() )
1184  {
1185  for (auto &aIter : *rAttrList)
1186  {
1187  sal_Int32 nToken = aIter.getToken();
1188  switch (nToken)
1189  {
1190  case XML_ELEMENT( TABLE, XML_ID ):
1191  nActionNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
1192  break;
1193  case XML_ELEMENT( TABLE, XML_ACCEPTANCE_STATE ):
1194  if (IsXMLToken( aIter, XML_ACCEPTED ))
1195  nActionState = SC_CAS_ACCEPTED;
1196  else if (IsXMLToken( aIter, XML_REJECTED ))
1197  nActionState = SC_CAS_REJECTED;
1198  break;
1199  case XML_ELEMENT( TABLE, XML_REJECTING_CHANGE_ID ):
1200  nRejectingNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
1201  break;
1202  case XML_ELEMENT( TABLE, XML_TYPE ):
1203  if (IsXMLToken( aIter, XML_ROW ))
1204  nActionType = SC_CAT_DELETE_ROWS;
1205  else if (IsXMLToken( aIter, XML_TABLE ))
1206  nActionType = SC_CAT_DELETE_TABS;
1207  break;
1208  case XML_ELEMENT( TABLE, XML_POSITION ):
1209  nPosition = aIter.toInt32();
1210  break;
1211  case XML_ELEMENT( TABLE, XML_TABLE ):
1212  nTable = aIter.toInt32();
1213  break;
1214  case XML_ELEMENT( TABLE, XML_MULTI_DELETION_SPANNED ):
1215  nMultiSpanned = aIter.toInt32();
1216  break;
1217  }
1218  }
1219  }
1220 
1221  pChangeTrackingImportHelper->StartChangeAction(nActionType);
1222  pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1223  pChangeTrackingImportHelper->SetActionState(nActionState);
1224  pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1225  pChangeTrackingImportHelper->SetPosition(nPosition, 1, nTable);
1226  pChangeTrackingImportHelper->SetMultiSpanned(static_cast<sal_Int16>(nMultiSpanned));
1227 }
1228 
1229 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLDeletionContext::createFastChildContext(
1230  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
1231 {
1232  SvXMLImportContext *pContext(nullptr);
1233  sax_fastparser::FastAttributeList *pAttribList =
1234  &sax_fastparser::castToFastAttributeList( xAttrList );
1235 
1236  switch (nElement)
1237  {
1238  case XML_ELEMENT( OFFICE, XML_CHANGE_INFO ):
1239  pContext = new ScXMLChangeInfoContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
1240  break;
1241  case XML_ELEMENT( TABLE, XML_DEPENDENCIES ):
1242  pContext = new ScXMLDependingsContext(GetScImport(), pChangeTrackingImportHelper);
1243  break;
1244  case XML_ELEMENT( TABLE, XML_DELETIONS ):
1245  pContext = new ScXMLDeletionsContext(GetScImport(), pChangeTrackingImportHelper);
1246  break;
1247  case XML_ELEMENT( TABLE, XML_CUT_OFFS ):
1248  case XML_ELEMENT( TABLE, XML_CUT_OFFS2 ): // cut_offs
1249  pContext = new ScXMLCutOffsContext(GetScImport(), pChangeTrackingImportHelper);
1250  }
1251 
1252  return pContext;
1253 }
1254 
1255 void SAL_CALL ScXMLDeletionContext::endFastElement( sal_Int32 /*nElement*/ )
1256 {
1257  pChangeTrackingImportHelper->EndChangeAction();
1258 }
1259 
1260 ScXMLMovementContext::ScXMLMovementContext( ScXMLImport& rImport,
1261  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
1262  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1263  ScXMLImportContext( rImport ),
1264  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1265 {
1266  sal_uInt32 nActionNumber(0);
1267  sal_uInt32 nRejectingNumber(0);
1268  ScChangeActionState nActionState(SC_CAS_VIRGIN);
1269 
1270  if ( rAttrList.is() )
1271  {
1272  for (auto &aIter : *rAttrList)
1273  {
1274  switch (aIter.getToken())
1275  {
1276  case XML_ELEMENT( TABLE, XML_ID ):
1277  nActionNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
1278  break;
1279  case XML_ELEMENT( TABLE, XML_ACCEPTANCE_STATE ):
1280  if (IsXMLToken( aIter, XML_ACCEPTED ))
1281  nActionState = SC_CAS_ACCEPTED;
1282  else if (IsXMLToken( aIter, XML_REJECTED ))
1283  nActionState = SC_CAS_REJECTED;
1284  break;
1285  case XML_ELEMENT( TABLE, XML_REJECTING_CHANGE_ID ):
1286  nRejectingNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
1287  break;
1288  }
1289  }
1290  }
1291 
1292  pChangeTrackingImportHelper->StartChangeAction(SC_CAT_MOVE);
1293  pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1294  pChangeTrackingImportHelper->SetActionState(nActionState);
1295  pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1296 }
1297 
1298 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLMovementContext::createFastChildContext(
1299  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
1300 {
1301  SvXMLImportContext *pContext(nullptr);
1302  sax_fastparser::FastAttributeList *pAttribList =
1303  &sax_fastparser::castToFastAttributeList( xAttrList );
1304 
1305  switch (nElement)
1306  {
1307  case XML_ELEMENT( OFFICE, XML_CHANGE_INFO ):
1308  pContext = new ScXMLChangeInfoContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
1309  break;
1310  case XML_ELEMENT( TABLE, XML_DEPENDENCIES ):
1311  pContext = new ScXMLDependingsContext(GetScImport(), pChangeTrackingImportHelper);
1312  break;
1313  case XML_ELEMENT( TABLE, XML_DELETIONS ):
1314  pContext = new ScXMLDeletionsContext(GetScImport(), pChangeTrackingImportHelper);
1315  break;
1316  case XML_ELEMENT( TABLE, XML_SOURCE_RANGE_ADDRESS ):
1317  pContext = new ScXMLBigRangeContext(GetScImport(), pAttribList, aSourceRange);
1318  break;
1319  case XML_ELEMENT( TABLE, XML_TARGET_RANGE_ADDRESS ):
1320  pContext = new ScXMLBigRangeContext(GetScImport(), pAttribList, aTargetRange);
1321  break;
1322  }
1323 
1324  return pContext;
1325 }
1326 
1327 void SAL_CALL ScXMLMovementContext::endFastElement( sal_Int32 /*nElement*/ )
1328 {
1329  pChangeTrackingImportHelper->SetMoveRanges(aSourceRange, aTargetRange);
1330  pChangeTrackingImportHelper->EndChangeAction();
1331 }
1332 
1333 ScXMLRejectionContext::ScXMLRejectionContext( ScXMLImport& rImport,
1334  const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
1335  ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1336  ScXMLImportContext( rImport ),
1337  pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1338 {
1339  sal_uInt32 nActionNumber(0);
1340  sal_uInt32 nRejectingNumber(0);
1341  ScChangeActionState nActionState(SC_CAS_VIRGIN);
1342 
1343  if ( rAttrList.is() )
1344  {
1345  for (auto &aIter : *rAttrList)
1346  {
1347  switch (aIter.getToken())
1348  {
1349  case XML_ELEMENT( TABLE, XML_ID ):
1350  nActionNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
1351  break;
1352  case XML_ELEMENT( TABLE, XML_ACCEPTANCE_STATE ):
1353  if (IsXMLToken( aIter, XML_ACCEPTED ))
1354  nActionState = SC_CAS_ACCEPTED;
1355  else if (IsXMLToken( aIter, XML_REJECTED ))
1356  nActionState = SC_CAS_REJECTED;
1357  break;
1358  case XML_ELEMENT( TABLE, XML_REJECTING_CHANGE_ID ):
1359  nRejectingNumber = ScXMLChangeTrackingImportHelper::GetIDFromString( aIter.toView() );
1360  break;
1361  }
1362  }
1363  }
1364 
1365  pChangeTrackingImportHelper->StartChangeAction(SC_CAT_MOVE);
1366  pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1367  pChangeTrackingImportHelper->SetActionState(nActionState);
1368  pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1369 }
1370 
1371 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLRejectionContext::createFastChildContext(
1372  sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
1373 {
1374  SvXMLImportContext *pContext(nullptr);
1375  sax_fastparser::FastAttributeList *pAttribList =
1376  &sax_fastparser::castToFastAttributeList( xAttrList );
1377 
1378  switch (nElement)
1379  {
1380  case XML_ELEMENT( OFFICE, XML_CHANGE_INFO ):
1381  pContext = new ScXMLChangeInfoContext(GetScImport(), pAttribList, pChangeTrackingImportHelper);
1382  break;
1383  case XML_ELEMENT( TABLE, XML_DEPENDENCIES ):
1384  pContext = new ScXMLDependingsContext(GetScImport(), pChangeTrackingImportHelper);
1385  break;
1386  case XML_ELEMENT( TABLE, XML_DELETIONS ):
1387  pContext = new ScXMLDeletionsContext(GetScImport(), pChangeTrackingImportHelper);
1388  break;
1389  }
1390 
1391  return pContext;
1392 }
1393 
1394 void SAL_CALL ScXMLRejectionContext::endFastElement( sal_Int32 /*nElement*/ )
1395 {
1396  pChangeTrackingImportHelper->EndChangeAction();
1397 }
1398 
1399 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
util
exports com.sun.star.lib. util
ScChangeActionState
ScChangeActionState
Definition: chgtrack.hxx:76
ScBigRange::Set
void Set(sal_Int32 nCol1, sal_Int32 nRow1, sal_Int32 nTab1, sal_Int32 nCol2, sal_Int32 nRow2, sal_Int32 nTab2)
Definition: bigrange.hxx:124
toDouble
OOO_DLLPUBLIC_DBTOOLS double toDouble(const css::util::Date &rVal, const css::util::Date &_rNullDate=getStandardDate())
svl::SharedStringPool::intern
SharedString intern(const OUString &rStr)
ScDocument::GetSharedStringPool
SC_DLLPUBLIC svl::SharedStringPool & GetSharedStringPool()
Definition: documen2.cxx:566
ScXMLChangeTrackingImportHelper::StartChangeAction
void StartChangeAction(const ScChangeActionType nActionType)
Definition: XMLChangeTrackingImportHelper.cxx:150
ScXMLChangeTrackingImportHelper::SetRejectingNumber
void SetRejectingNumber(const sal_uInt32 nRejectingNumber)
Definition: XMLChangeTrackingImportHelper.hxx:193
XML_INSERTION
XML_INSERTION
toInt32
sal_Int32 toInt32(OUString const &rStr)
XML_MOVEMENT
XML_MOVEMENT
ScChangeActionType
ScChangeActionType
Definition: chgtrack.hxx:62
IsXMLToken
bool IsXMLToken(std::u16string_view rString, enum XMLTokenEnum eToken)
sax_fastparser::castToFastAttributeList
FastAttributeList & castToFastAttributeList(const css::uno::Reference< css::xml::sax::XFastAttributeList > &xAttrList)
sax::Converter::parseDateTime
static bool parseDateTime(css::util::DateTime &rDateTime, std::u16string_view rString)
ScXMLChangeTrackingImportHelper::SetProtection
void SetProtection(const css::uno::Sequence< sal_Int8 > &rProtect)
Definition: XMLChangeTrackingImportHelper.hxx:186
ScXMLChangeTrackingImportHelper::SetPreviousChange
void SetPreviousChange(const sal_uInt32 nPreviousAction, ScMyCellInfo *pCellInfo)
Definition: XMLChangeTrackingImportHelper.cxx:217
ScCellValue
Store arbitrary cell value of any kind.
Definition: cellvalue.hxx:35
ScXMLImport::LockSolarMutex
void LockSolarMutex()
Definition: xmlimprt.cxx:1508
nCount
int nCount
XMLOFF_WARN_UNKNOWN
#define XMLOFF_WARN_UNKNOWN(area, rIter)
ScXMLChangeTrackingImportHelper::GetIDFromString
static sal_uInt32 GetIDFromString(std::string_view sID)
Definition: XMLChangeTrackingImportHelper.cxx:191
ScXMLChangeTrackingImportHelper::SetBigRange
void SetBigRange(const ScBigRange &aBigRange)
Definition: XMLChangeTrackingImportHelper.hxx:195
ScXMLChangeTrackingImportHelper::AddMoveCutOff
void AddMoveCutOff(const sal_uInt32 nID, const sal_Int32 nStartPosition, const sal_Int32 nEndPosition)
Definition: XMLChangeTrackingImportHelper.cxx:296
ScXMLChangeTrackingImportHelper::SetActionState
void SetActionState(const ScChangeActionState nActionState)
Definition: XMLChangeTrackingImportHelper.hxx:192
XML_REJECTION
XML_REJECTION
ScXMLChangeTrackingImportHelper::SetPosition
void SetPosition(const sal_Int32 nPosition, const sal_Int32 nCount, const sal_Int32 nTable)
Definition: XMLChangeTrackingImportHelper.cxx:226
XML_FLOAT
XML_FLOAT
sax_fastparser::FastAttributeList
ScXMLImportContext
This class exists only to provide GetScImport() to its derived classes.
Definition: importcontext.hxx:19
ScXMLTrackedChangesContext::~ScXMLTrackedChangesContext
virtual ~ScXMLTrackedChangesContext() override
Definition: XMLTrackedChangesContext.cxx:357
XML_CELL_CONTENT_CHANGE
XML_CELL_CONTENT_CHANGE
XML_PROTECTION_KEY
XML_PROTECTION_KEY
comphelper::Base64::decode
static void decode(css::uno::Sequence< sal_Int8 > &aPass, const OUString &sBuffer)
SvXMLUnitConverter::convertDateTime
void convertDateTime(OUStringBuffer &rBuffer, const double &fDateTime, bool const bAddTimeIf0AM=false)
XML_ACCEPTED
XML_ACCEPTED
sax::Converter::convertDuration
static void convertDuration(OUStringBuffer &rBuffer, const double fTime)
ScXMLImportContext::GetScImport
ScXMLImport & GetScImport()
Definition: importcontext.cxx:18
ScXMLChangeTrackingImportHelper::SetMultiSpanned
void SetMultiSpanned(const sal_Int16 nMultiSpanned)
Definition: XMLChangeTrackingImportHelper.cxx:272
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:1569
ScXMLTrackedChangesContext::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
Definition: XMLTrackedChangesContext.cxx:362
ScXMLTrackedChangesContext::ScXMLTrackedChangesContext
ScXMLTrackedChangesContext(ScXMLImport &rImport, const rtl::Reference< sax_fastparser::FastAttributeList > &rAttrList, ScXMLChangeTrackingImportHelper *pChangeTrackingImportHelper)
Definition: XMLTrackedChangesContext.cxx:334
XML_TRUE
XML_TRUE
TABLE
TABLE
nToken
DefTokenId nToken
Definition: qproform.cxx:397
XML_CUT_OFFS2
XML_CUT_OFFS2
IsTokenInNamespace
constexpr bool IsTokenInNamespace(sal_Int32 nToken, sal_uInt16 nNamespacePrefix)
ScXMLTrackedChangesContext::pChangeTrackingImportHelper
ScXMLChangeTrackingImportHelper * pChangeTrackingImportHelper
Definition: XMLTrackedChangesContext.hxx:33
XML_ROW
XML_ROW
ScXMLImport::UnlockSolarMutex
void UnlockSolarMutex()
Definition: xmlimprt.cxx:1526
if
if(aStr!=aBuf) UpdateName_Impl(m_xFollowLb.get()
XML_ELEMENT
#define XML_ELEMENT(prefix, name)
SvXMLImport::GetMM100UnitConverter
const SvXMLUnitConverter & GetMM100UnitConverter() const
nType
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:398
XML_DELETION
XML_DELETION
ScMatrixMode
ScMatrixMode
Definition: formulacell.hxx:115
XMLOFF_WARN_UNKNOWN_ELEMENT
#define XMLOFF_WARN_UNKNOWN_ELEMENT(area, token)
ScXMLChangeTrackingImportHelper::SetActionNumber
void SetActionNumber(const sal_uInt32 nActionNumber)
Definition: XMLChangeTrackingImportHelper.hxx:191
ScXMLChangeTrackingImportHelper::SetInsertionCutOff
void SetInsertionCutOff(const sal_uInt32 nID, const sal_Int32 nPosition)
Definition: XMLChangeTrackingImportHelper.cxx:283
ScXMLChangeTrackingImportHelper::SetMoveRanges
void SetMoveRanges(const ScBigRange &aSourceRange, const ScBigRange &aTargetRange)
Definition: XMLChangeTrackingImportHelper.cxx:309
toString
OUString toString(OptionInfo const *info)
sax::Converter::convertNumber
static bool convertNumber(sal_Int32 &rValue, std::u16string_view aString, sal_Int32 nMin=SAL_MIN_INT32, sal_Int32 nMax=SAL_MAX_INT32)
Generated on Sat Sep 11 2021 09:59:07 for LibreOffice Module sc (master) by   doxygen 1.8.10