sc/source/filter/xml/XMLTrackedChangesContext.cxx

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