sc/source/filter/xml/XMLTrackedChangesContext.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: XMLTrackedChangesContext.cxx,v $
  10  * $Revision: 1.32 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 #include "XMLTrackedChangesContext.hxx"
  35 #include "xmlimprt.hxx"
  36 #include "xmlconti.hxx"
  37 #include "XMLConverter.hxx"
  38 #include "cell.hxx"
  39 #include "textuno.hxx"
  40 #include "editutil.hxx"
  41 #include <xmloff/xmltoken.hxx>
  42 #include <xmloff/xmlnmspe.hxx>
  43 #include <xmloff/nmspmap.hxx>
  44 #include <xmloff/xmluconv.hxx>
  45 #include <svtools/zforlist.hxx>
  46 #include <com/sun/star/text/XTextCursor.hpp>
  47 #include <com/sun/star/text/ControlCharacter.hpp>
  48
  49 using rtl::OUString;
  50 using namespace com::sun::star;
  51 using namespace xmloff::token;
  52
  53 //-----------------------------------------------------------------------------
  54
  55 class ScXMLChangeInfoContext : public SvXMLImportContext
  56 {
  57         ScMyActionInfo                                          aInfo;
  58         ::rtl::OUStringBuffer               sAuthorBuffer;
  59         ::rtl::OUStringBuffer               sDateTimeBuffer;
  60         ::rtl::OUStringBuffer               sCommentBuffer;
  61         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
  62         sal_uInt32                                                      nParagraphCount;
  63
  64         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
  65         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
  66
  67 public:
  68         ScXMLChangeInfoContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
  69                                                                           const ::com::sun::star::uno::Reference<
  70                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
  71                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
  72         virtual ~ScXMLChangeInfoContext();
  73
  74         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
  75                                                                                                         const ::rtl::OUString& rLocalName,
  76                                                                                                         const ::com::sun::star::uno::Reference<
  77                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
  78
  79         virtual void EndElement();
  80 };
  81
  82 //-----------------------------------------------------------------------------
  83
  84 class ScXMLBigRangeContext : public SvXMLImportContext
  85 {
  86         ScBigRange&                     rBigRange;
  87
  88         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
  89         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
  90
  91 public:
  92         ScXMLBigRangeContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
  93                                                                           const ::com::sun::star::uno::Reference<
  94                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
  95                                                                           ScBigRange& rBigRange);
  96         virtual ~ScXMLBigRangeContext();
  97
  98         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
  99                                                                                                         const ::rtl::OUString& rLocalName,
 100                                                                                                         const ::com::sun::star::uno::Reference<
 101                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 102
 103         virtual void EndElement();
 104 };
 105
 106 //-----------------------------------------------------------------------------
 107
 108 class ScXMLCellContentDeletionContext : public SvXMLImportContext
 109 {
 110         rtl::OUString                                           sFormulaAddress;
 111         rtl::OUString                                           sFormula;
 112     rtl::OUString                       sInputString;
 113         ScBigRange                                                      aBigRange;
 114         double                                                          fValue;
 115         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 116         ScBaseCell*                                                     pCell;
 117         sal_uInt32                                                      nID;
 118         sal_Int32                                                       nMatrixCols;
 119         sal_Int32                                                       nMatrixRows;
 120     formula::FormulaGrammar::Grammar                  eGrammar;
 121         sal_uInt16                                                      nType;
 122         sal_uInt8                                                       nMatrixFlag;
 123         sal_Bool                                                        bBigRange;
 124         sal_Bool                                                        bContainsCell;
 125
 126         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 127         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 128
 129 public:
 130         ScXMLCellContentDeletionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 131                                                                           const ::com::sun::star::uno::Reference<
 132                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 133                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 134         virtual ~ScXMLCellContentDeletionContext();
 135
 136         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 137                                                                                                         const ::rtl::OUString& rLocalName,
 138                                                                                                         const ::com::sun::star::uno::Reference<
 139                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 140
 141         virtual void EndElement();
 142 };
 143
 144 //-----------------------------------------------------------------------------
 145
 146 class ScXMLDependenceContext : public SvXMLImportContext
 147 {
 148         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 149
 150         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 151         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 152
 153 public:
 154         ScXMLDependenceContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 155                                                                           const ::com::sun::star::uno::Reference<
 156                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 157                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 158         virtual ~ScXMLDependenceContext();
 159
 160         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 161                                                                                                         const ::rtl::OUString& rLocalName,
 162                                                                                                         const ::com::sun::star::uno::Reference<
 163                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 164
 165         virtual void EndElement();
 166 };
 167
 168 //-----------------------------------------------------------------------------
 169
 170 class ScXMLDependingsContext : public SvXMLImportContext
 171 {
 172         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 173
 174         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 175         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 176
 177 public:
 178         ScXMLDependingsContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 179                                                                           const ::com::sun::star::uno::Reference<
 180                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 181                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 182         virtual ~ScXMLDependingsContext();
 183
 184         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 185                                                                                                         const ::rtl::OUString& rLocalName,
 186                                                                                                         const ::com::sun::star::uno::Reference<
 187                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 188
 189         virtual void EndElement();
 190 };
 191
 192 //-----------------------------------------------------------------------------
 193
 194 class ScXMLChangeDeletionContext : public SvXMLImportContext
 195 {
 196         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 197
 198         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 199         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 200
 201 public:
 202         ScXMLChangeDeletionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 203                                                                           const ::com::sun::star::uno::Reference<
 204                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 205                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 206         virtual ~ScXMLChangeDeletionContext();
 207
 208         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 209                                                                                                         const ::rtl::OUString& rLocalName,
 210                                                                                                         const ::com::sun::star::uno::Reference<
 211                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 212
 213         virtual void EndElement();
 214 };
 215
 216 //-----------------------------------------------------------------------------
 217
 218 class ScXMLDeletionsContext : public SvXMLImportContext
 219 {
 220         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 221
 222         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 223         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 224
 225 public:
 226         ScXMLDeletionsContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 227                                                                           const ::com::sun::star::uno::Reference<
 228                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 229                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 230         virtual ~ScXMLDeletionsContext();
 231
 232         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 233                                                                                                         const ::rtl::OUString& rLocalName,
 234                                                                                                         const ::com::sun::star::uno::Reference<
 235                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 236
 237         virtual void EndElement();
 238 };
 239
 240 //-----------------------------------------------------------------------------
 241
 242 class ScXMLChangeCellContext;
 243
 244 class ScXMLChangeTextPContext : public SvXMLImportContext
 245 {
 246         ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList> xAttrList;
 247         rtl::OUString                           sLName;
 248         rtl::OUStringBuffer                     sText;
 249         ScXMLChangeCellContext*         pChangeCellContext;
 250         SvXMLImportContext*                     pTextPContext;
 251         USHORT                                          nPrefix;
 252
 253         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 254         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 255
 256 public:
 257
 258         ScXMLChangeTextPContext( ScXMLImport& rImport, USHORT nPrfx,
 259                                            const ::rtl::OUString& rLName,
 260                                            const ::com::sun::star::uno::Reference<
 261                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 262                                                 ScXMLChangeCellContext* pChangeCellContext);
 263
 264         virtual ~ScXMLChangeTextPContext();
 265
 266         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 267                                                                          const ::rtl::OUString& rLocalName,
 268                                                                          const ::com::sun::star::uno::Reference<
 269                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 270
 271         virtual void Characters( const ::rtl::OUString& rChars );
 272
 273         virtual void EndElement();
 274 };
 275
 276 //-----------------------------------------------------------------------------
 277
 278 class ScXMLChangeCellContext : public SvXMLImportContext
 279 {
 280         rtl::OUString                   sText;
 281     rtl::OUString&          rInputString;
 282         ScBaseCell*&                    rOldCell;
 283         ScEditEngineTextObj*    pEditTextObj;
 284         double&                                 rDateTimeValue;
 285         double                                  fValue;
 286         sal_uInt16&                             rType;
 287 //    sal_Bool                bIsMatrix;
 288 //    sal_Bool                bIsCoveredMatrix;
 289         sal_Bool                                bEmpty;
 290         sal_Bool                                bFirstParagraph;
 291         sal_Bool                                bString;
 292         sal_Bool                                bFormula;
 293
 294         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 295         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 296
 297 public:
 298         ScXMLChangeCellContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 299                                                                           const ::com::sun::star::uno::Reference<
 300                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 301                                                                           ScBaseCell*& rOldCell, rtl::OUString& sAddress, rtl::OUString& sFormula,
 302                                       formula::FormulaGrammar::Grammar& rGrammar,
 303                                       rtl::OUString& rInputString, double& fValue, sal_uInt16& nType,
 304                                                                           sal_uInt8& nMatrixFlag, sal_Int32& nMatrixCols, sal_Int32& nMatrixRows);
 305         virtual ~ScXMLChangeCellContext();
 306
 307         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 308                                                                                                         const ::rtl::OUString& rLocalName,
 309                                                                                                         const ::com::sun::star::uno::Reference<
 310                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 311
 312         void CreateTextPContext(sal_Bool bIsNewParagraph);
 313         sal_Bool IsEditCell() { return pEditTextObj != 0; }
 314         void SetText(const rtl::OUString& sTempText) { sText = sTempText; }
 315
 316         virtual void EndElement();
 317 };
 318
 319 //-----------------------------------------------------------------------------
 320
 321 class ScXMLPreviousContext : public SvXMLImportContext
 322 {
 323         rtl::OUString                                           sFormulaAddress;
 324         rtl::OUString                                           sFormula;
 325     rtl::OUString                       sInputString;
 326         double                                                          fValue;
 327         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 328         ScBaseCell*                                                     pOldCell;
 329         sal_uInt32                                                      nID;
 330         sal_Int32                                                       nMatrixCols;
 331         sal_Int32                                                       nMatrixRows;
 332     formula::FormulaGrammar::Grammar                  eGrammar;
 333         sal_uInt16                                                      nType;
 334         sal_uInt8                                                       nMatrixFlag;
 335
 336         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 337         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 338
 339 public:
 340         ScXMLPreviousContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 341                                                                           const ::com::sun::star::uno::Reference<
 342                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 343                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 344         virtual ~ScXMLPreviousContext();
 345
 346         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 347                                                                                                         const ::rtl::OUString& rLocalName,
 348                                                                                                         const ::com::sun::star::uno::Reference<
 349                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 350
 351         virtual void EndElement();
 352 };
 353
 354 //-----------------------------------------------------------------------------
 355
 356 class ScXMLContentChangeContext : public SvXMLImportContext
 357 {
 358         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 359         ScBigRange                                                      aBigRange;
 360
 361         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 362         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 363
 364 public:
 365         ScXMLContentChangeContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 366                                                                           const ::com::sun::star::uno::Reference<
 367                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 368                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 369         virtual ~ScXMLContentChangeContext();
 370
 371         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 372                                                                                                         const ::rtl::OUString& rLocalName,
 373                                                                                                         const ::com::sun::star::uno::Reference<
 374                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 375         virtual void EndElement();
 376 };
 377
 378 //-----------------------------------------------------------------------------
 379
 380 class ScXMLInsertionContext : public SvXMLImportContext
 381 {
 382         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 383
 384         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 385         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 386
 387 public:
 388         ScXMLInsertionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 389                                                                           const ::com::sun::star::uno::Reference<
 390                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 391                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 392         virtual ~ScXMLInsertionContext();
 393
 394         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 395                                                                                                         const ::rtl::OUString& rLocalName,
 396                                                                                                         const ::com::sun::star::uno::Reference<
 397                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 398         virtual void EndElement();
 399 };
 400
 401 //-----------------------------------------------------------------------------
 402
 403 class ScXMLInsertionCutOffContext : public SvXMLImportContext
 404 {
 405         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 406
 407         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 408         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 409
 410 public:
 411         ScXMLInsertionCutOffContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 412                                                                           const ::com::sun::star::uno::Reference<
 413                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 414                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 415         virtual ~ScXMLInsertionCutOffContext();
 416
 417         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 418                                                                                                         const ::rtl::OUString& rLocalName,
 419                                                                                                         const ::com::sun::star::uno::Reference<
 420                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 421         virtual void EndElement();
 422 };
 423
 424 //-----------------------------------------------------------------------------
 425
 426 class ScXMLMovementCutOffContext : public SvXMLImportContext
 427 {
 428         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 429
 430         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 431         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 432
 433 public:
 434         ScXMLMovementCutOffContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 435                                                                           const ::com::sun::star::uno::Reference<
 436                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 437                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 438         virtual ~ScXMLMovementCutOffContext();
 439
 440         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 441                                                                                                         const ::rtl::OUString& rLocalName,
 442                                                                                                         const ::com::sun::star::uno::Reference<
 443                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 444         virtual void EndElement();
 445 };
 446
 447 //-----------------------------------------------------------------------------
 448
 449 class ScXMLCutOffsContext : public SvXMLImportContext
 450 {
 451         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 452
 453         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 454         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 455
 456 public:
 457         ScXMLCutOffsContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 458                                                                           const ::com::sun::star::uno::Reference<
 459                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 460                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 461         virtual ~ScXMLCutOffsContext();
 462
 463         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 464                                                                                                         const ::rtl::OUString& rLocalName,
 465                                                                                                         const ::com::sun::star::uno::Reference<
 466                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 467         virtual void EndElement();
 468 };
 469
 470 //-----------------------------------------------------------------------------
 471
 472 class ScXMLDeletionContext : public SvXMLImportContext
 473 {
 474         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 475
 476         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 477         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 478
 479 public:
 480         ScXMLDeletionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 481                                                                           const ::com::sun::star::uno::Reference<
 482                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 483                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 484         virtual ~ScXMLDeletionContext();
 485
 486         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 487                                                                                                         const ::rtl::OUString& rLocalName,
 488                                                                                                         const ::com::sun::star::uno::Reference<
 489                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 490         virtual void EndElement();
 491 };
 492
 493 //-----------------------------------------------------------------------------
 494
 495 class ScXMLMovementContext : public SvXMLImportContext
 496 {
 497         ScBigRange                                                      aSourceRange;
 498         ScBigRange                                                      aTargetRange;
 499         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 500
 501         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 502         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 503
 504 public:
 505         ScXMLMovementContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 506                                                                           const ::com::sun::star::uno::Reference<
 507                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 508                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 509         virtual ~ScXMLMovementContext();
 510
 511         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 512                                                                                                         const ::rtl::OUString& rLocalName,
 513                                                                                                         const ::com::sun::star::uno::Reference<
 514                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 515         virtual void EndElement();
 516 };
 517
 518 //-----------------------------------------------------------------------------
 519
 520 class ScXMLRejectionContext : public SvXMLImportContext
 521 {
 522         ScXMLChangeTrackingImportHelper*        pChangeTrackingImportHelper;
 523
 524         const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
 525         ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
 526
 527 public:
 528         ScXMLRejectionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
 529                                                                           const ::com::sun::star::uno::Reference<
 530                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 531                                                                           ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
 532         virtual ~ScXMLRejectionContext();
 533
 534         virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
 535                                                                                                         const ::rtl::OUString& rLocalName,
 536                                                                                                         const ::com::sun::star::uno::Reference<
 537                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
 538         virtual void EndElement();
 539 };
 540
 541 //------------------------------------------------------------------
 542
 543 ScXMLTrackedChangesContext::ScXMLTrackedChangesContext( ScXMLImport& rImport,
 544                                                                                           USHORT nPrfx,
 545                                                                                           const ::rtl::OUString& rLName,
 546                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
 547                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
 548         SvXMLImportContext( rImport, nPrfx, rLName ),
 549         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
 550 {
 551         rImport.LockSolarMutex();
 552         pChangeTrackingImportHelper->SetChangeTrack(sal_True);
 553
 554         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 555         for( sal_Int16 i=0; i < nAttrCount; ++i )
 556         {
 557                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 558                 rtl::OUString aLocalName;
 559                 sal_uInt16 nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
 560                                                                                         sAttrName, &aLocalName ));
 561                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 562                 if (nPrefix == XML_NAMESPACE_TABLE)
 563                 {
 564                         if (IsXMLToken(aLocalName, XML_PROTECTION_KEY))
 565                         {
 566                                 if (sValue.getLength())
 567                                 {
 568                                         uno::Sequence<sal_Int8> aPass;
 569                                         SvXMLUnitConverter::decodeBase64(aPass, sValue);
 570                                         pChangeTrackingImportHelper->SetProtection(aPass);
 571                                 }
 572                         }
 573                 }
 574         }
 575 }
 576
 577 ScXMLTrackedChangesContext::~ScXMLTrackedChangesContext()
 578 {
 579         GetScImport().UnlockSolarMutex();
 580 }
 581
 582 SvXMLImportContext *ScXMLTrackedChangesContext::CreateChildContext( USHORT nPrefix,
 583                                                                          const ::rtl::OUString& rLocalName,
 584                                                                          const ::com::sun::star::uno::Reference<
 585                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 586 {
 587         SvXMLImportContext *pContext(0);
 588
 589         if (nPrefix == XML_NAMESPACE_TABLE)
 590         {
 591                 if (IsXMLToken(rLocalName, XML_CELL_CONTENT_CHANGE))
 592                 {
 593                         pContext = new ScXMLContentChangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
 594                 }
 595                 else if (IsXMLToken(rLocalName, XML_INSERTION))
 596                 {
 597                         pContext = new ScXMLInsertionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
 598                 }
 599                 else if (IsXMLToken(rLocalName, XML_DELETION))
 600                 {
 601                         pContext = new ScXMLDeletionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
 602                 }
 603                 else if (IsXMLToken(rLocalName, XML_MOVEMENT))
 604                 {
 605                         pContext = new ScXMLMovementContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
 606                 }
 607                 else if (IsXMLToken(rLocalName, XML_REJECTION))
 608                 {
 609                         pContext = new ScXMLRejectionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
 610                 }
 611         }
 612
 613         if( !pContext )
 614                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
 615
 616         return pContext;
 617 }
 618
 619 void ScXMLTrackedChangesContext::EndElement()
 620 {
 621 }
 622
 623 ScXMLChangeInfoContext::ScXMLChangeInfoContext(  ScXMLImport& rImport,
 624                                                                                           USHORT nPrfx,
 625                                                                                           const ::rtl::OUString& rLName,
 626                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
 627                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
 628         SvXMLImportContext( rImport, nPrfx, rLName ),
 629         aInfo(),
 630         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
 631         nParagraphCount(0)
 632 {
 633         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 634         for( sal_Int16 i=0; i < nAttrCount; ++i )
 635         {
 636                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 637                 rtl::OUString aLocalName;
 638                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
 639                                                                                         sAttrName, &aLocalName ));
 640                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 641
 642                 if (nPrefix == XML_NAMESPACE_OFFICE)
 643                 {
 644                         if (IsXMLToken(aLocalName, XML_CHG_AUTHOR))
 645                         {
 646                                 sAuthorBuffer = sValue;
 647                         }
 648                         else if (IsXMLToken(aLocalName, XML_CHG_DATE_TIME))
 649                         {
 650                                 sDateTimeBuffer = sValue;
 651                         }
 652                 }
 653         }
 654 }
 655
 656 ScXMLChangeInfoContext::~ScXMLChangeInfoContext()
 657 {
 658 }
 659
 660 SvXMLImportContext *ScXMLChangeInfoContext::CreateChildContext( USHORT nPrefix,
 661                                                                          const ::rtl::OUString& rLocalName,
 662                                                                          const ::com::sun::star::uno::Reference<
 663                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 664 {
 665         SvXMLImportContext *pContext(0);
 666
 667         if( XML_NAMESPACE_DC == nPrefix )
 668         {
 669                 if( IsXMLToken( rLocalName, XML_CREATOR ) )
 670                         pContext = new ScXMLContentContext(GetScImport(), nPrefix,
 671                                                                                         rLocalName, xAttrList, sAuthorBuffer);
 672                 else if( IsXMLToken( rLocalName, XML_DATE ) )
 673                         pContext = new ScXMLContentContext(GetScImport(), nPrefix,
 674                                                                                         rLocalName, xAttrList, sDateTimeBuffer);
 675         }
 676         else if ((nPrefix == XML_NAMESPACE_TEXT) && (IsXMLToken(rLocalName, XML_P)) )
 677         {
 678                 if(nParagraphCount)
 679                         sCommentBuffer.append(static_cast<sal_Unicode>('\n'));
 680                 ++nParagraphCount;
 681                 pContext = new ScXMLContentContext( GetScImport(), nPrefix, rLocalName, xAttrList, sCommentBuffer);
 682         }
 683
 684         if( !pContext )
 685                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
 686
 687         return pContext;
 688 }
 689
 690 void ScXMLChangeInfoContext::EndElement()
 691 {
 692         aInfo.sUser = sAuthorBuffer.makeStringAndClear();
 693         GetScImport().GetMM100UnitConverter().convertDateTime(aInfo.aDateTime, sDateTimeBuffer.makeStringAndClear());
 694         aInfo.sComment = sCommentBuffer.makeStringAndClear();
 695         pChangeTrackingImportHelper->SetActionInfo(aInfo);
 696 }
 697
 698 ScXMLBigRangeContext::ScXMLBigRangeContext(  ScXMLImport& rImport,
 699                                                                                           USHORT nPrfx,
 700                                                                                           const ::rtl::OUString& rLName,
 701                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
 702                                                                                         ScBigRange& rTempBigRange ) :
 703         SvXMLImportContext( rImport, nPrfx, rLName ),
 704         rBigRange(rTempBigRange)
 705 {
 706         sal_Bool bColumn(sal_False);
 707         sal_Bool bRow(sal_False);
 708         sal_Bool bTable(sal_False);
 709     sal_Int32 nColumn(0);
 710     sal_Int32 nRow(0);
 711     sal_Int32 nTable(0);
 712     sal_Int32 nStartColumn(0);
 713     sal_Int32 nEndColumn(0);
 714     sal_Int32 nStartRow(0);
 715     sal_Int32 nEndRow(0);
 716     sal_Int32 nStartTable(0);
 717     sal_Int32 nEndTable(0);
 718         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 719         for( sal_Int16 i=0; i < nAttrCount; ++i )
 720         {
 721                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 722                 rtl::OUString aLocalName;
 723                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
 724                                                                                         sAttrName, &aLocalName ));
 725                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 726
 727                 if (nPrefix == XML_NAMESPACE_TABLE)
 728                 {
 729                         if (IsXMLToken(aLocalName, XML_COLUMN))
 730                         {
 731                                 SvXMLUnitConverter::convertNumber(nColumn, sValue);
 732                                 bColumn = sal_True;
 733                         }
 734                         else if (IsXMLToken(aLocalName, XML_ROW))
 735                         {
 736                                 SvXMLUnitConverter::convertNumber(nRow, sValue);
 737                                 bRow = sal_True;
 738                         }
 739                         else if (IsXMLToken(aLocalName, XML_TABLE))
 740                         {
 741                                 SvXMLUnitConverter::convertNumber(nTable, sValue);
 742                                 bTable = sal_True;
 743                         }
 744                         else if (IsXMLToken(aLocalName, XML_START_COLUMN))
 745                                 SvXMLUnitConverter::convertNumber(nStartColumn, sValue);
 746                         else if (IsXMLToken(aLocalName, XML_END_COLUMN))
 747                                 SvXMLUnitConverter::convertNumber(nEndColumn, sValue);
 748                         else if (IsXMLToken(aLocalName, XML_START_ROW))
 749                                 SvXMLUnitConverter::convertNumber(nStartRow, sValue);
 750                         else if (IsXMLToken(aLocalName, XML_END_ROW))
 751                                 SvXMLUnitConverter::convertNumber(nEndRow, sValue);
 752                         else if (IsXMLToken(aLocalName, XML_START_TABLE))
 753                                 SvXMLUnitConverter::convertNumber(nStartTable, sValue);
 754                         else if (IsXMLToken(aLocalName, XML_END_TABLE))
 755                                 SvXMLUnitConverter::convertNumber(nEndTable, sValue);
 756                 }
 757         }
 758         if (bColumn)
 759                 nStartColumn = nEndColumn = nColumn;
 760         if (bRow)
 761                 nStartRow = nEndRow = nRow;
 762         if (bTable)
 763                 nStartTable = nEndTable = nTable;
 764         rBigRange.Set(nStartColumn, nStartRow, nStartTable,
 765                 nEndColumn, nEndRow, nEndTable);
 766 }
 767
 768 ScXMLBigRangeContext::~ScXMLBigRangeContext()
 769 {
 770 }
 771
 772 SvXMLImportContext *ScXMLBigRangeContext::CreateChildContext( USHORT nPrefix,
 773                                                                          const ::rtl::OUString& rLocalName,
 774                                                                          const ::com::sun::star::uno::Reference<
 775                                         ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
 776 {
 777         return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
 778 }
 779
 780 void ScXMLBigRangeContext::EndElement()
 781 {
 782 }
 783
 784 ScXMLCellContentDeletionContext::ScXMLCellContentDeletionContext(  ScXMLImport& rImport,
 785                                                                                           USHORT nPrfx,
 786                                                                                           const ::rtl::OUString& rLName,
 787                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
 788                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper) :
 789         SvXMLImportContext( rImport, nPrfx, rLName ),
 790         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
 791         pCell(NULL),
 792         nID(0),
 793         nMatrixCols(0),
 794         nMatrixRows(0),
 795         nType(NUMBERFORMAT_ALL),
 796         nMatrixFlag(MM_NONE),
 797         bBigRange(sal_False),
 798         bContainsCell(sal_False)
 799 {
 800         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 801         for( sal_Int16 i=0; i < nAttrCount; ++i )
 802         {
 803                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 804                 rtl::OUString aLocalName;
 805                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
 806                                                                                         sAttrName, &aLocalName ));
 807                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 808
 809                 if (nPrefix == XML_NAMESPACE_TABLE)
 810                 {
 811                         if (IsXMLToken(aLocalName, XML_ID))
 812                                 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
 813                 }
 814         }
 815 }
 816
 817 ScXMLCellContentDeletionContext::~ScXMLCellContentDeletionContext()
 818 {
 819 }
 820
 821 SvXMLImportContext *ScXMLCellContentDeletionContext::CreateChildContext( USHORT nPrefix,
 822                                                                          const ::rtl::OUString& rLocalName,
 823                                                                          const ::com::sun::star::uno::Reference<
 824                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 825 {
 826         SvXMLImportContext *pContext(0);
 827
 828         if (nPrefix == XML_NAMESPACE_TABLE)
 829         {
 830                 if (IsXMLToken(rLocalName, XML_CHANGE_TRACK_TABLE_CELL))
 831                 {
 832                         bContainsCell = sal_True;
 833                         pContext = new ScXMLChangeCellContext(GetScImport(), nPrefix, rLocalName, xAttrList,
 834                                 pCell, sFormulaAddress, sFormula, eGrammar, sInputString, fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows );
 835                 }
 836                 else if (IsXMLToken(rLocalName, XML_CELL_ADDRESS))
 837                 {
 838                         DBG_ASSERT(!nID, "a action with a ID should not contain a BigRange");
 839                         bBigRange = sal_True;
 840                         pContext = new ScXMLBigRangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, aBigRange);
 841                 }
 842         }
 843
 844         if( !pContext )
 845                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
 846
 847         return pContext;
 848 }
 849
 850 void ScXMLCellContentDeletionContext::EndElement()
 851 {
 852     ScMyCellInfo* pCellInfo(new ScMyCellInfo(pCell, sFormulaAddress, sFormula, eGrammar, sInputString, fValue, nType,
 853             nMatrixFlag, nMatrixCols, nMatrixRows));
 854         if (nID)
 855                 pChangeTrackingImportHelper->AddDeleted(nID, pCellInfo);
 856         else
 857                 pChangeTrackingImportHelper->AddGenerated(pCellInfo, aBigRange);
 858 }
 859
 860 ScXMLDependenceContext::ScXMLDependenceContext(  ScXMLImport& rImport,
 861                                                                                           USHORT nPrfx,
 862                                                                                           const ::rtl::OUString& rLName,
 863                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
 864                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
 865         SvXMLImportContext( rImport, nPrfx, rLName ),
 866         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
 867 {
 868     sal_uInt32 nID(0);
 869         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 870         for( sal_Int16 i=0; i < nAttrCount; ++i )
 871         {
 872                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 873                 rtl::OUString aLocalName;
 874                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
 875                                                                                         sAttrName, &aLocalName ));
 876                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 877
 878                 if (nPrefix == XML_NAMESPACE_TABLE)
 879                 {
 880                         if (IsXMLToken(aLocalName, XML_ID))
 881                                 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
 882                 }
 883         }
 884         pChangeTrackingImportHelper->AddDependence(nID);
 885 }
 886
 887 ScXMLDependenceContext::~ScXMLDependenceContext()
 888 {
 889 }
 890
 891 SvXMLImportContext *ScXMLDependenceContext::CreateChildContext( USHORT nPrefix,
 892                                                                          const ::rtl::OUString& rLocalName,
 893                                                                          const ::com::sun::star::uno::Reference<
 894                                         ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
 895 {
 896         return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
 897 }
 898
 899 void ScXMLDependenceContext::EndElement()
 900 {
 901 }
 902
 903 ScXMLDependingsContext::ScXMLDependingsContext(  ScXMLImport& rImport,
 904                                                                                           USHORT nPrfx,
 905                                                                                           const ::rtl::OUString& rLName,
 906                                             const uno::Reference<xml::sax::XAttributeList>& /* xAttrList */,
 907                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
 908         SvXMLImportContext( rImport, nPrfx, rLName ),
 909         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
 910 {
 911         // here are no attributes
 912 }
 913
 914 ScXMLDependingsContext::~ScXMLDependingsContext()
 915 {
 916 }
 917
 918 SvXMLImportContext *ScXMLDependingsContext::CreateChildContext( USHORT nPrefix,
 919                                                                          const ::rtl::OUString& rLocalName,
 920                                                                          const ::com::sun::star::uno::Reference<
 921                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 922 {
 923         SvXMLImportContext *pContext(0);
 924
 925         if (nPrefix == XML_NAMESPACE_TABLE)
 926         {
 927         // #i80033# read both old (dependence) and new (dependency) elements
 928         if (IsXMLToken(rLocalName, XML_DEPENDENCE) || IsXMLToken(rLocalName, XML_DEPENDENCY))
 929                         pContext = new ScXMLDependenceContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
 930         }
 931
 932         if( !pContext )
 933                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
 934
 935         return pContext;
 936 }
 937
 938 void ScXMLDependingsContext::EndElement()
 939 {
 940 }
 941
 942 ScXMLChangeDeletionContext::ScXMLChangeDeletionContext(  ScXMLImport& rImport,
 943                                                                                           USHORT nPrfx,
 944                                                                                           const ::rtl::OUString& rLName,
 945                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
 946                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
 947         SvXMLImportContext( rImport, nPrfx, rLName ),
 948         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
 949 {
 950     sal_uInt32 nID(0);
 951         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 952         for( sal_Int16 i=0; i < nAttrCount; ++i )
 953         {
 954                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 955                 rtl::OUString aLocalName;
 956                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
 957                                                                                         sAttrName, &aLocalName ));
 958                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 959
 960                 if (nPrefix == XML_NAMESPACE_TABLE)
 961                 {
 962                         if (IsXMLToken(aLocalName, XML_ID))
 963                                 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
 964                 }
 965         }
 966         pChangeTrackingImportHelper->AddDeleted(nID);
 967 }
 968
 969 ScXMLChangeDeletionContext::~ScXMLChangeDeletionContext()
 970 {
 971 }
 972
 973 SvXMLImportContext *ScXMLChangeDeletionContext::CreateChildContext( USHORT nPrefix,
 974                                                                          const ::rtl::OUString& rLocalName,
 975                                                                          const ::com::sun::star::uno::Reference<
 976                                         ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
 977 {
 978         return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
 979 }
 980
 981 void ScXMLChangeDeletionContext::EndElement()
 982 {
 983 }
 984
 985 ScXMLDeletionsContext::ScXMLDeletionsContext(  ScXMLImport& rImport,
 986                                                                                           USHORT nPrfx,
 987                                                                                           const ::rtl::OUString& rLName,
 988                                             const uno::Reference<xml::sax::XAttributeList>& /* xAttrList */,
 989                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
 990         SvXMLImportContext( rImport, nPrfx, rLName ),
 991         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
 992 {
 993         // here are no attributes
 994 }
 995
 996 ScXMLDeletionsContext::~ScXMLDeletionsContext()
 997 {
 998 }
 999
1000 SvXMLImportContext *ScXMLDeletionsContext::CreateChildContext( USHORT nPrefix,
1001                                                                          const ::rtl::OUString& rLocalName,
1002                                                                          const ::com::sun::star::uno::Reference<
1003                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1004 {
1005         SvXMLImportContext *pContext(0);
1006
1007         if (nPrefix == XML_NAMESPACE_TABLE)
1008         {
1009                 if (IsXMLToken(rLocalName, XML_CHANGE_DELETION))
1010                         pContext = new ScXMLChangeDeletionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1011                 else if (IsXMLToken(rLocalName, XML_CELL_CONTENT_DELETION))
1012                         pContext = new ScXMLCellContentDeletionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1013         }
1014
1015         if( !pContext )
1016                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1017
1018         return pContext;
1019 }
1020
1021 void ScXMLDeletionsContext::EndElement()
1022 {
1023 }
1024
1025 ScXMLChangeTextPContext::ScXMLChangeTextPContext( ScXMLImport& rImport,
1026                                                                           USHORT nPrfx,
1027                                                                           const ::rtl::OUString& rLName,
1028                                                                           const ::com::sun::star::uno::Reference<
1029                                                                           ::com::sun::star::xml::sax::XAttributeList>& xTempAttrList,
1030                                                                           ScXMLChangeCellContext* pTempChangeCellContext) :
1031         SvXMLImportContext( rImport, nPrfx, rLName ),
1032         xAttrList(xTempAttrList),
1033         sLName(rLName),
1034         sText(),
1035         pChangeCellContext(pTempChangeCellContext),
1036         pTextPContext(NULL),
1037         nPrefix(nPrfx)
1038 {
1039         // here are no attributes
1040 }
1041
1042 ScXMLChangeTextPContext::~ScXMLChangeTextPContext()
1043 {
1044         if (pTextPContext)
1045                 delete pTextPContext;
1046 }
1047
1048 SvXMLImportContext *ScXMLChangeTextPContext::CreateChildContext( USHORT nTempPrefix,
1049                                                                                         const ::rtl::OUString& rLName,
1050                                                                                         const ::com::sun::star::uno::Reference<
1051                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xTempAttrList )
1052 {
1053         SvXMLImportContext *pContext(0);
1054
1055         if ((nPrefix == XML_NAMESPACE_TEXT) && (IsXMLToken(rLName, XML_S)) && !pTextPContext)
1056         {
1057                 sal_Int32 nRepeat(0);
1058                 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1059                 for( sal_Int16 i=0; i < nAttrCount; ++i )
1060                 {
1061                         const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1062                         const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1063                         rtl::OUString aLocalName;
1064                         USHORT nPrfx(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1065                                                                                                 sAttrName, &aLocalName ));
1066                         if ((nPrfx == XML_NAMESPACE_TEXT) && (IsXMLToken(aLocalName, XML_C)))
1067                                 nRepeat = sValue.toInt32();
1068                 }
1069                 if (nRepeat)
1070                         for (sal_Int32 j = 0; j < nRepeat; ++j)
1071                                 sText.append(static_cast<sal_Unicode>(' '));
1072                 else
1073                         sText.append(static_cast<sal_Unicode>(' '));
1074         }
1075         else
1076         {
1077                 if (!pChangeCellContext->IsEditCell())
1078                         pChangeCellContext->CreateTextPContext(sal_False);
1079                 sal_Bool bWasContext (sal_True);
1080                 if (!pTextPContext)
1081                 {
1082                         bWasContext = sal_False;
1083                         pTextPContext = GetScImport().GetTextImport()->CreateTextChildContext(
1084                                                                         GetScImport(), nPrefix, sLName, xAttrList);
1085                 }
1086                 if (pTextPContext)
1087                 {
1088                         if (!bWasContext)
1089                                 pTextPContext->Characters(sText.makeStringAndClear());
1090                         pContext = pTextPContext->CreateChildContext(nTempPrefix, rLName, xTempAttrList);
1091                 }
1092         }
1093
1094         if( !pContext )
1095                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
1096
1097         return pContext;
1098 }
1099
1100 void ScXMLChangeTextPContext::Characters( const ::rtl::OUString& rChars )
1101 {
1102         if (!pTextPContext)
1103                 sText.append(rChars);
1104         else
1105                 pTextPContext->Characters(rChars);
1106 }
1107
1108 void ScXMLChangeTextPContext::EndElement()
1109 {
1110         if (!pTextPContext)
1111                 pChangeCellContext->SetText(sText.makeStringAndClear());
1112 }
1113
1114 ScXMLChangeCellContext::ScXMLChangeCellContext(  ScXMLImport& rImport,
1115                                                                                           USHORT nPrfx,
1116                                                                                           const ::rtl::OUString& rLName,
1117                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1118                                                                                         ScBaseCell*& rTempOldCell, rtl::OUString& rAddress, rtl::OUString& rFormula,
1119                                             formula::FormulaGrammar::Grammar& rGrammar,
1120                                             rtl::OUString& rTempInputString, double& fDateTimeValue, sal_uInt16& nType,
1121                                                                                         sal_uInt8& nMatrixFlag, sal_Int32& nMatrixCols, sal_Int32& nMatrixRows ) :
1122         SvXMLImportContext( rImport, nPrfx, rLName ),
1123     rInputString(rTempInputString),
1124         rOldCell(rTempOldCell),
1125         pEditTextObj(NULL),
1126         rDateTimeValue(fDateTimeValue),
1127         rType(nType),
1128         bEmpty(sal_True),
1129         bFirstParagraph(sal_True),
1130         bString(sal_True),
1131         bFormula(sal_False)
1132 {
1133     const formula::FormulaGrammar::Grammar eStorageGrammar = rGrammar = GetScImport().GetDocument()->GetStorageGrammar();
1134         sal_Bool bIsMatrix(sal_False);
1135         sal_Bool bIsCoveredMatrix(sal_False);
1136         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1137         for( sal_Int16 i=0; i < nAttrCount; ++i )
1138         {
1139                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1140                 rtl::OUString aLocalName;
1141                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1142                                                                                         sAttrName, &aLocalName ));
1143                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1144
1145                 if (nPrefix == XML_NAMESPACE_TABLE)
1146                 {
1147                         if (IsXMLToken(aLocalName, XML_FORMULA))
1148                         {
1149                                 bEmpty = sal_False;
1150                                 sal_uInt16 nFormulaPrefix = GetImport().GetNamespaceMap().
1151                                                 _GetKeyByAttrName( sValue, &rFormula, sal_False );
1152
1153                 if (!ScXMLImport::IsAcceptedFormulaNamespace( nFormulaPrefix,
1154                             sValue, rGrammar, eStorageGrammar))
1155                     rFormula = sValue;
1156                                 bFormula = sal_True;
1157                         }
1158                         else if (IsXMLToken(aLocalName, XML_CELL_ADDRESS))
1159                         {
1160                                 rAddress = sValue;
1161                         }
1162                         else if (IsXMLToken(aLocalName, XML_MATRIX_COVERED))
1163                         {
1164                                 bIsCoveredMatrix = IsXMLToken(sValue, XML_TRUE);
1165                         }
1166                         else if (IsXMLToken(aLocalName, XML_NUMBER_MATRIX_COLUMNS_SPANNED))
1167                         {
1168                                 bIsMatrix = sal_True;
1169                                 SvXMLUnitConverter::convertNumber(nMatrixCols, sValue);
1170                         }
1171                         else if (IsXMLToken(aLocalName, XML_NUMBER_MATRIX_ROWS_SPANNED))
1172                         {
1173                                 bIsMatrix = sal_True;
1174                                 SvXMLUnitConverter::convertNumber(nMatrixRows, sValue);
1175                         }
1176                 }
1177                 else if (nPrefix == XML_NAMESPACE_OFFICE)
1178                 {
1179                         if (IsXMLToken(aLocalName, XML_VALUE_TYPE))
1180                         {
1181                                 if (IsXMLToken(sValue, XML_FLOAT))
1182                                         bString = sal_False;
1183                                 else if (IsXMLToken(sValue, XML_DATE))
1184                 {
1185                                         rType = NUMBERFORMAT_DATE;
1186                                         bString = sal_False;
1187                 }
1188                                 else if (IsXMLToken(sValue, XML_TIME))
1189                 {
1190                                         rType = NUMBERFORMAT_TIME;
1191                                         bString = sal_False;
1192                 }
1193                         }
1194                         else if (IsXMLToken(aLocalName, XML_VALUE))
1195                         {
1196                                 SvXMLUnitConverter::convertDouble(fValue, sValue);
1197                                 bEmpty = sal_False;
1198                         }
1199                         else if (IsXMLToken(aLocalName, XML_DATE_VALUE))
1200                         {
1201                                 bEmpty = sal_False;
1202                                 if (GetScImport().GetMM100UnitConverter().setNullDate(GetScImport().GetModel()))
1203                                         GetScImport().GetMM100UnitConverter().convertDateTime(rDateTimeValue, sValue);
1204                 fValue = rDateTimeValue;
1205                         }
1206                         else if (IsXMLToken(aLocalName, XML_TIME_VALUE))
1207                         {
1208                                 bEmpty = sal_False;
1209                                 GetScImport().GetMM100UnitConverter().convertTime(rDateTimeValue, sValue);
1210                 fValue = rDateTimeValue;
1211                         }
1212         }
1213         }
1214         if (bIsCoveredMatrix)
1215                 nMatrixFlag = MM_REFERENCE;
1216         else if (bIsMatrix && nMatrixRows && nMatrixCols)
1217                 nMatrixFlag = MM_FORMULA;
1218 }
1219
1220 ScXMLChangeCellContext::~ScXMLChangeCellContext()
1221 {
1222 }
1223
1224 SvXMLImportContext *ScXMLChangeCellContext::CreateChildContext( USHORT nPrefix,
1225                                                                          const ::rtl::OUString& rLocalName,
1226                                                                          const ::com::sun::star::uno::Reference<
1227                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1228 {
1229         SvXMLImportContext *pContext(0);
1230
1231         if ((nPrefix == XML_NAMESPACE_TEXT) && (IsXMLToken(rLocalName, XML_P)))
1232         {
1233                 bEmpty = sal_False;
1234                 if (bFirstParagraph)
1235                 {
1236                         pContext = new ScXMLChangeTextPContext(GetScImport(), nPrefix, rLocalName, xAttrList, this);
1237                         bFirstParagraph = sal_False;
1238                 }
1239                 else
1240                 {
1241                         if (!pEditTextObj)
1242                                 CreateTextPContext(sal_True);
1243                         pContext = GetScImport().GetTextImport()->CreateTextChildContext(
1244                                 GetScImport(), nPrefix, rLocalName, xAttrList);
1245                 }
1246         }
1247
1248         if( !pContext )
1249                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1250
1251         return pContext;
1252 }
1253
1254 void ScXMLChangeCellContext::CreateTextPContext(sal_Bool bIsNewParagraph)
1255 {
1256         if (GetScImport().GetDocument())
1257         {
1258                 pEditTextObj = new ScEditEngineTextObj();
1259                 pEditTextObj->acquire();
1260                 pEditTextObj->GetEditEngine()->SetEditTextObjectPool(GetScImport().GetDocument()->GetEditPool());
1261                 uno::Reference <text::XText> xText(pEditTextObj);
1262                 if (xText.is())
1263                 {
1264                         uno::Reference<text::XTextCursor> xTextCursor(xText->createTextCursor());
1265                         if (bIsNewParagraph)
1266                         {
1267                                 xText->setString(sText);
1268                                 xTextCursor->gotoEnd(sal_False);
1269                                 uno::Reference < text::XTextRange > xTextRange (xTextCursor, uno::UNO_QUERY);
1270                                 if (xTextRange.is())
1271                                         xText->insertControlCharacter(xTextRange, text::ControlCharacter::PARAGRAPH_BREAK, sal_False);
1272                         }
1273                         GetScImport().GetTextImport()->SetCursor(xTextCursor);
1274                 }
1275         }
1276 }
1277
1278 void ScXMLChangeCellContext::EndElement()
1279 {
1280         if (!bEmpty)
1281         {
1282                 if (pEditTextObj)
1283                 {
1284                         if (GetImport().GetTextImport()->GetCursor().is())
1285                         {
1286                                 //GetImport().GetTextImport()->GetCursor()->gotoEnd(sal_False);
1287                                 if( GetImport().GetTextImport()->GetCursor()->goLeft( 1, sal_True ) )
1288                                 {
1289                                         OUString sEmpty;
1290                                         GetImport().GetTextImport()->GetText()->insertString(
1291                                                 GetImport().GetTextImport()->GetCursorAsRange(), sEmpty,
1292                                                 sal_True );
1293                                 }
1294                         }
1295                         if (GetScImport().GetDocument())
1296                                 rOldCell = new ScEditCell(pEditTextObj->CreateTextObject(), GetScImport().GetDocument(), GetScImport().GetDocument()->GetEditPool());
1297                         GetScImport().GetTextImport()->ResetCursor();
1298                         // delete pEditTextObj;
1299                         pEditTextObj->release();
1300                 }
1301                 else
1302                 {
1303                         if (!bFormula)
1304                         {
1305                                 if (sText.getLength() && bString)
1306                                         rOldCell = new ScStringCell(sText);
1307                                 else
1308                                         rOldCell = new ScValueCell(fValue);
1309                             if (rType == NUMBERFORMAT_DATE || rType == NUMBERFORMAT_TIME)
1310                     rInputString = sText;
1311                         }
1312                         else
1313                         {
1314                                 // do nothing, this has to do later (on another place)
1315                                 /*ScAddress aCellPos;
1316                                 rOldCell = new ScFormulaCell(GetScImport().GetDocument(), aCellPos, sFormula);
1317                                 if (bString)
1318                                         static_cast<ScFormulaCell*>(rOldCell)->SetString(sValue);
1319                                 else
1320                                         static_cast<ScFormulaCell*>(rOldCell)->SetDouble(fValue);
1321                                 static_cast<ScFormulaCell*>(rOldCell)->SetInChangeTrack(sal_True);
1322                                 if (bIsCoveredMatrix)
1323                                         static_cast<ScFormulaCell*>(rOldCell)->SetMatrixFlag(MM_REFERENCE);
1324                                 else if (bIsMatrix && nMatrixRows && nMatrixCols)
1325                                 {
1326                                         static_cast<ScFormulaCell*>(rOldCell)->SetMatrixFlag(MM_FORMULA);
1327                                         static_cast<ScFormulaCell*>(rOldCell)->SetMatColsRows(static_cast<SCCOL>(nMatrixCols), static_cast<SCROW>(nMatrixRows));
1328                                 }*/
1329                         }
1330                 }
1331         }
1332         else
1333                 rOldCell = NULL;
1334 }
1335
1336 ScXMLPreviousContext::ScXMLPreviousContext(  ScXMLImport& rImport,
1337                                                                                           USHORT nPrfx,
1338                                                                                           const ::rtl::OUString& rLName,
1339                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1340                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1341         SvXMLImportContext( rImport, nPrfx, rLName ),
1342         sFormulaAddress(),
1343         sFormula(),
1344         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
1345         pOldCell(NULL),
1346         nID(0),
1347         nMatrixCols(0),
1348         nMatrixRows(0),
1349     eGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT),
1350         nType(NUMBERFORMAT_ALL),
1351         nMatrixFlag(MM_NONE)
1352 {
1353         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1354         for( sal_Int16 i=0; i < nAttrCount; ++i )
1355         {
1356                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1357                 rtl::OUString aLocalName;
1358                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1359                                                                                         sAttrName, &aLocalName ));
1360                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1361
1362                 if (nPrefix == XML_NAMESPACE_TABLE)
1363                 {
1364                         if (IsXMLToken(aLocalName, XML_ID))
1365                                 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
1366                 }
1367         }
1368 }
1369
1370 ScXMLPreviousContext::~ScXMLPreviousContext()
1371 {
1372 }
1373
1374 SvXMLImportContext *ScXMLPreviousContext::CreateChildContext( USHORT nPrefix,
1375                                                                          const ::rtl::OUString& rLocalName,
1376                                                                          const ::com::sun::star::uno::Reference<
1377                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1378 {
1379         SvXMLImportContext *pContext(0);
1380
1381         if ((nPrefix == XML_NAMESPACE_TABLE) && (IsXMLToken(rLocalName, XML_CHANGE_TRACK_TABLE_CELL)))
1382                 pContext = new ScXMLChangeCellContext(GetScImport(), nPrefix, rLocalName, xAttrList,
1383                         pOldCell, sFormulaAddress, sFormula, eGrammar, sInputString, fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows);
1384
1385         if( !pContext )
1386                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1387
1388         return pContext;
1389 }
1390
1391 void ScXMLPreviousContext::EndElement()
1392 {
1393     pChangeTrackingImportHelper->SetPreviousChange(nID, new ScMyCellInfo(pOldCell, sFormulaAddress, sFormula, eGrammar, sInputString,
1394         fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows));
1395 }
1396
1397 ScXMLContentChangeContext::ScXMLContentChangeContext(  ScXMLImport& rImport,
1398                                                                                           USHORT nPrfx,
1399                                                                                           const ::rtl::OUString& rLName,
1400                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1401                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1402         SvXMLImportContext( rImport, nPrfx, rLName ),
1403         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1404 {
1405         sal_uInt32 nActionNumber(0);
1406         sal_uInt32 nRejectingNumber(0);
1407         ScChangeActionState nActionState(SC_CAS_VIRGIN);
1408
1409         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1410         for( sal_Int16 i=0; i < nAttrCount; ++i )
1411         {
1412                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1413                 rtl::OUString aLocalName;
1414                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1415                                                                                         sAttrName, &aLocalName ));
1416                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1417
1418                 if (nPrefix == XML_NAMESPACE_TABLE)
1419                 {
1420                         if (IsXMLToken(aLocalName, XML_ID))
1421                         {
1422                                 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1423                         }
1424                         else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1425                         {
1426                                 if (IsXMLToken(sValue, XML_ACCEPTED))
1427                                         nActionState = SC_CAS_ACCEPTED;
1428                                 else if (IsXMLToken(sValue, XML_REJECTED))
1429                                         nActionState = SC_CAS_REJECTED;
1430                         }
1431                         else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1432                         {
1433                                 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1434                         }
1435                 }
1436         }
1437
1438         pChangeTrackingImportHelper->StartChangeAction(SC_CAT_CONTENT);
1439         pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1440         pChangeTrackingImportHelper->SetActionState(nActionState);
1441         pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1442 }
1443
1444 ScXMLContentChangeContext::~ScXMLContentChangeContext()
1445 {
1446 }
1447
1448 SvXMLImportContext *ScXMLContentChangeContext::CreateChildContext( USHORT nPrefix,
1449                                                                          const ::rtl::OUString& rLocalName,
1450                                                                          const ::com::sun::star::uno::Reference<
1451                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1452 {
1453         SvXMLImportContext *pContext(0);
1454
1455         if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
1456         {
1457                 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1458         }
1459         else if (nPrefix == XML_NAMESPACE_TABLE)
1460         {
1461                 if (IsXMLToken(rLocalName, XML_CELL_ADDRESS))
1462                 {
1463                         pContext = new ScXMLBigRangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, aBigRange);
1464                 }
1465                 else if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
1466                 {
1467                         pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1468                 }
1469                 else if (IsXMLToken(rLocalName, XML_DELETIONS))
1470                         pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1471                 else if (IsXMLToken(rLocalName, XML_PREVIOUS))
1472                 {
1473                         pContext = new ScXMLPreviousContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1474                 }
1475         }
1476
1477         if( !pContext )
1478                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1479
1480         return pContext;
1481 }
1482
1483 void ScXMLContentChangeContext::EndElement()
1484 {
1485         pChangeTrackingImportHelper->SetBigRange(aBigRange);
1486         pChangeTrackingImportHelper->EndChangeAction();
1487 }
1488
1489 ScXMLInsertionContext::ScXMLInsertionContext( ScXMLImport& rImport,
1490                                                                                           USHORT nPrfx,
1491                                                                                           const ::rtl::OUString& rLName,
1492                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1493                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1494         SvXMLImportContext( rImport, nPrfx, rLName ),
1495         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1496 {
1497         sal_uInt32 nActionNumber(0);
1498         sal_uInt32 nRejectingNumber(0);
1499         sal_Int32 nPosition(0);
1500         sal_Int32 nCount(1);
1501         sal_Int32 nTable(0);
1502         ScChangeActionState nActionState(SC_CAS_VIRGIN);
1503         ScChangeActionType nActionType(SC_CAT_INSERT_COLS);
1504
1505         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1506         for( sal_Int16 i=0; i < nAttrCount; ++i )
1507         {
1508                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1509                 rtl::OUString aLocalName;
1510                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1511                                                                                         sAttrName, &aLocalName ));
1512                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1513
1514                 if (nPrefix == XML_NAMESPACE_TABLE)
1515                 {
1516                         if (IsXMLToken(aLocalName, XML_ID))
1517                         {
1518                                 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1519                         }
1520                         else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1521                         {
1522                                 if (IsXMLToken(sValue, XML_ACCEPTED))
1523                                         nActionState = SC_CAS_ACCEPTED;
1524                                 else if (IsXMLToken(sValue, XML_REJECTED))
1525                                         nActionState = SC_CAS_REJECTED;
1526                         }
1527                         else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1528                         {
1529                                 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1530                         }
1531                         else if (IsXMLToken(aLocalName, XML_TYPE))
1532                         {
1533                                 if (IsXMLToken(sValue, XML_ROW))
1534                                         nActionType = SC_CAT_INSERT_ROWS;
1535                                 else if (IsXMLToken(sValue, XML_TABLE))
1536                                         nActionType = SC_CAT_INSERT_TABS;
1537                         }
1538                         else if (IsXMLToken(aLocalName, XML_POSITION))
1539                         {
1540                                 SvXMLUnitConverter::convertNumber(nPosition, sValue);
1541                         }
1542                         else if (IsXMLToken(aLocalName, XML_TABLE))
1543                         {
1544                                 SvXMLUnitConverter::convertNumber(nTable, sValue);
1545                         }
1546                         else if (IsXMLToken(aLocalName, XML_COUNT))
1547                         {
1548                                 SvXMLUnitConverter::convertNumber(nCount, sValue);
1549                         }
1550                 }
1551         }
1552
1553         pChangeTrackingImportHelper->StartChangeAction(nActionType);
1554         pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1555         pChangeTrackingImportHelper->SetActionState(nActionState);
1556         pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1557         pChangeTrackingImportHelper->SetPosition(nPosition, nCount, nTable);
1558 }
1559
1560 ScXMLInsertionContext::~ScXMLInsertionContext()
1561 {
1562 }
1563
1564 SvXMLImportContext *ScXMLInsertionContext::CreateChildContext( USHORT nPrefix,
1565                                                                          const ::rtl::OUString& rLocalName,
1566                                                                          const ::com::sun::star::uno::Reference<
1567                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1568 {
1569         SvXMLImportContext *pContext(0);
1570
1571         if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
1572         {
1573                 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1574         }
1575         else if (nPrefix == XML_NAMESPACE_TABLE)
1576         {
1577                 if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
1578                         pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1579                 else if (IsXMLToken(rLocalName, XML_DELETIONS))
1580                         pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1581         }
1582
1583         if( !pContext )
1584                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1585
1586         return pContext;
1587 }
1588
1589 void ScXMLInsertionContext::EndElement()
1590 {
1591         pChangeTrackingImportHelper->EndChangeAction();
1592 }
1593
1594 ScXMLInsertionCutOffContext::ScXMLInsertionCutOffContext( ScXMLImport& rImport,
1595                                                                                           USHORT nPrfx,
1596                                                                                           const ::rtl::OUString& rLName,
1597                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1598                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1599         SvXMLImportContext( rImport, nPrfx, rLName ),
1600         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1601 {
1602         sal_uInt32 nID(0);
1603         sal_Int32 nPosition(0);
1604         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1605         for( sal_Int16 i=0; i < nAttrCount; ++i )
1606         {
1607                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1608                 rtl::OUString aLocalName;
1609                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1610                                                                                         sAttrName, &aLocalName ));
1611                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1612
1613                 if (nPrefix == XML_NAMESPACE_TABLE)
1614                 {
1615                         if (IsXMLToken(aLocalName, XML_ID))
1616                         {
1617                                 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
1618                         }
1619                         else if (IsXMLToken(aLocalName, XML_POSITION))
1620                         {
1621                                 SvXMLUnitConverter::convertNumber(nPosition, sValue);
1622                         }
1623                 }
1624         }
1625         pChangeTrackingImportHelper->SetInsertionCutOff(nID, nPosition);
1626 }
1627
1628 ScXMLInsertionCutOffContext::~ScXMLInsertionCutOffContext()
1629 {
1630 }
1631
1632 SvXMLImportContext *ScXMLInsertionCutOffContext::CreateChildContext( USHORT nPrefix,
1633                                                                          const ::rtl::OUString& rLocalName,
1634                                                                          const ::com::sun::star::uno::Reference<
1635                                         ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
1636 {
1637         return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1638 }
1639
1640 void ScXMLInsertionCutOffContext::EndElement()
1641 {
1642 }
1643
1644 ScXMLMovementCutOffContext::ScXMLMovementCutOffContext( ScXMLImport& rImport,
1645                                                                                           USHORT nPrfx,
1646                                                                                           const ::rtl::OUString& rLName,
1647                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1648                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1649         SvXMLImportContext( rImport, nPrfx, rLName ),
1650         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1651 {
1652         sal_uInt32 nID(0);
1653         sal_Int32 nPosition(0);
1654         sal_Int32 nStartPosition(0);
1655         sal_Int32 nEndPosition(0);
1656         sal_Bool bPosition(sal_False);
1657         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1658         for( sal_Int16 i=0; i < nAttrCount; ++i )
1659         {
1660                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1661                 rtl::OUString aLocalName;
1662                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1663                                                                                         sAttrName, &aLocalName ));
1664                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1665
1666                 if (nPrefix == XML_NAMESPACE_TABLE)
1667                 {
1668                         if (IsXMLToken(aLocalName, XML_ID))
1669                         {
1670                                 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
1671                         }
1672                         else if (IsXMLToken(aLocalName, XML_POSITION))
1673                         {
1674                                 bPosition = sal_True;
1675                                 SvXMLUnitConverter::convertNumber(nPosition, sValue);
1676                         }
1677                         else if (IsXMLToken(aLocalName, XML_START_POSITION))
1678                         {
1679                                 SvXMLUnitConverter::convertNumber(nStartPosition, sValue);
1680                         }
1681                         else if (IsXMLToken(aLocalName, XML_END_POSITION))
1682                         {
1683                                 SvXMLUnitConverter::convertNumber(nEndPosition, sValue);
1684                         }
1685                 }
1686         }
1687         if (bPosition)
1688                 nStartPosition = nEndPosition = nPosition;
1689         pChangeTrackingImportHelper->AddMoveCutOff(nID, nStartPosition, nEndPosition);
1690 }
1691
1692 ScXMLMovementCutOffContext::~ScXMLMovementCutOffContext()
1693 {
1694 }
1695
1696 SvXMLImportContext *ScXMLMovementCutOffContext::CreateChildContext( USHORT nPrefix,
1697                                                                          const ::rtl::OUString& rLocalName,
1698                                                                          const ::com::sun::star::uno::Reference<
1699                                         ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
1700 {
1701         return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1702 }
1703
1704 void ScXMLMovementCutOffContext::EndElement()
1705 {
1706 }
1707
1708 ScXMLCutOffsContext::ScXMLCutOffsContext( ScXMLImport& rImport,
1709                                                                                           USHORT nPrfx,
1710                                                                                           const ::rtl::OUString& rLName,
1711                                             const uno::Reference<xml::sax::XAttributeList>& /* xAttrList */,
1712                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1713         SvXMLImportContext( rImport, nPrfx, rLName ),
1714         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1715 {
1716         // here are no attributes
1717 }
1718
1719 ScXMLCutOffsContext::~ScXMLCutOffsContext()
1720 {
1721 }
1722
1723 SvXMLImportContext *ScXMLCutOffsContext::CreateChildContext( USHORT nPrefix,
1724                                                                          const ::rtl::OUString& rLocalName,
1725                                                                          const ::com::sun::star::uno::Reference<
1726                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1727 {
1728         SvXMLImportContext *pContext(0);
1729
1730         if (nPrefix == XML_NAMESPACE_TABLE)
1731         {
1732                 if (IsXMLToken(rLocalName, XML_INSERTION_CUT_OFF))
1733                         pContext = new ScXMLInsertionCutOffContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1734                 else if (IsXMLToken(rLocalName, XML_MOVEMENT_CUT_OFF))
1735                         pContext = new ScXMLMovementCutOffContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1736         }
1737
1738         if( !pContext )
1739                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1740
1741         return pContext;
1742 }
1743
1744 void ScXMLCutOffsContext::EndElement()
1745 {
1746 }
1747
1748 ScXMLDeletionContext::ScXMLDeletionContext( ScXMLImport& rImport,
1749                                                                                           USHORT nPrfx,
1750                                                                                           const ::rtl::OUString& rLName,
1751                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1752                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1753         SvXMLImportContext( rImport, nPrfx, rLName ),
1754         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1755 {
1756         sal_uInt32 nActionNumber(0);
1757         sal_uInt32 nRejectingNumber(0);
1758         sal_Int32 nPosition(0);
1759         sal_Int32 nMultiSpanned(0);
1760         sal_Int32 nTable(0);
1761         ScChangeActionState nActionState(SC_CAS_VIRGIN);
1762         ScChangeActionType nActionType(SC_CAT_DELETE_COLS);
1763
1764         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1765         for( sal_Int16 i=0; i < nAttrCount; i++ )
1766         {
1767                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1768                 rtl::OUString aLocalName;
1769                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1770                                                                                         sAttrName, &aLocalName ));
1771                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1772
1773                 if (nPrefix == XML_NAMESPACE_TABLE)
1774                 {
1775                         if (IsXMLToken(aLocalName, XML_ID))
1776                         {
1777                                 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1778                         }
1779                         else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1780                         {
1781                                 if (IsXMLToken(sValue, XML_ACCEPTED))
1782                                         nActionState = SC_CAS_ACCEPTED;
1783                                 else if (IsXMLToken(sValue, XML_REJECTED))
1784                                         nActionState = SC_CAS_REJECTED;
1785                         }
1786                         else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1787                         {
1788                                 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1789                         }
1790                         else if (IsXMLToken(aLocalName, XML_TYPE))
1791                         {
1792                                 if (IsXMLToken(sValue, XML_ROW))
1793                                 {
1794                                         nActionType = SC_CAT_DELETE_ROWS;
1795                                 }
1796                                 else if (IsXMLToken(aLocalName, XML_TABLE))
1797                                 {
1798                                         nActionType = SC_CAT_DELETE_TABS;
1799                                 }
1800                         }
1801                         else if (IsXMLToken(aLocalName, XML_POSITION))
1802                         {
1803                                 SvXMLUnitConverter::convertNumber(nPosition, sValue);
1804                         }
1805                         else if (IsXMLToken(aLocalName, XML_TABLE))
1806                         {
1807                                 SvXMLUnitConverter::convertNumber(nTable, sValue);
1808                         }
1809                         else if (IsXMLToken(aLocalName, XML_MULTI_DELETION_SPANNED))
1810                         {
1811                                 SvXMLUnitConverter::convertNumber(nMultiSpanned, sValue);
1812                         }
1813                 }
1814         }
1815
1816         pChangeTrackingImportHelper->StartChangeAction(nActionType);
1817         pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1818         pChangeTrackingImportHelper->SetActionState(nActionState);
1819         pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1820         pChangeTrackingImportHelper->SetPosition(nPosition, 1, nTable);
1821         pChangeTrackingImportHelper->SetMultiSpanned(static_cast<sal_Int16>(nMultiSpanned));
1822 }
1823
1824 ScXMLDeletionContext::~ScXMLDeletionContext()
1825 {
1826 }
1827
1828 SvXMLImportContext *ScXMLDeletionContext::CreateChildContext( USHORT nPrefix,
1829                                                                          const ::rtl::OUString& rLocalName,
1830                                                                          const ::com::sun::star::uno::Reference<
1831                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1832 {
1833         SvXMLImportContext *pContext(0);
1834
1835         if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
1836         {
1837                 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1838         }
1839         else if (nPrefix == XML_NAMESPACE_TABLE)
1840         {
1841                 if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
1842                         pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1843                 else if (IsXMLToken(rLocalName, XML_DELETIONS))
1844                         pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1845                 else if (IsXMLToken(rLocalName, XML_CUT_OFFS) || rLocalName.equalsAsciiL("cut_offs", 8))
1846                         pContext = new ScXMLCutOffsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1847                 else
1848                 {
1849                         DBG_ERROR("don't know this");
1850                 }
1851         }
1852
1853         if( !pContext )
1854                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1855
1856         return pContext;
1857 }
1858
1859 void ScXMLDeletionContext::EndElement()
1860 {
1861         pChangeTrackingImportHelper->EndChangeAction();
1862 }
1863
1864 ScXMLMovementContext::ScXMLMovementContext( ScXMLImport& rImport,
1865                                                                                           USHORT nPrfx,
1866                                                                                           const ::rtl::OUString& rLName,
1867                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1868                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1869         SvXMLImportContext( rImport, nPrfx, rLName ),
1870         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1871 {
1872         sal_uInt32 nActionNumber(0);
1873         sal_uInt32 nRejectingNumber(0);
1874         ScChangeActionState nActionState(SC_CAS_VIRGIN);
1875
1876         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1877         for( sal_Int16 i=0; i < nAttrCount; ++i )
1878         {
1879                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1880                 rtl::OUString aLocalName;
1881                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1882                                                                                         sAttrName, &aLocalName ));
1883                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1884
1885                 if (nPrefix == XML_NAMESPACE_TABLE)
1886                 {
1887                         if (IsXMLToken(aLocalName, XML_ID))
1888                         {
1889                                 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1890                         }
1891                         else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1892                         {
1893                                 if (IsXMLToken(sValue, XML_ACCEPTED))
1894                                         nActionState = SC_CAS_ACCEPTED;
1895                                 else if (IsXMLToken(sValue, XML_REJECTED))
1896                                         nActionState = SC_CAS_REJECTED;
1897                         }
1898                         else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1899                         {
1900                                 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1901                         }
1902                 }
1903         }
1904
1905         pChangeTrackingImportHelper->StartChangeAction(SC_CAT_MOVE);
1906         pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1907         pChangeTrackingImportHelper->SetActionState(nActionState);
1908         pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1909 }
1910
1911 ScXMLMovementContext::~ScXMLMovementContext()
1912 {
1913 }
1914
1915 SvXMLImportContext *ScXMLMovementContext::CreateChildContext( USHORT nPrefix,
1916                                                                          const ::rtl::OUString& rLocalName,
1917                                                                          const ::com::sun::star::uno::Reference<
1918                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1919 {
1920         SvXMLImportContext *pContext(0);
1921
1922         if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
1923         {
1924                 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1925         }
1926         else if (nPrefix == XML_NAMESPACE_TABLE)
1927         {
1928                 if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
1929                         pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1930                 else if (IsXMLToken(rLocalName, XML_DELETIONS))
1931                         pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1932                 else if (IsXMLToken(rLocalName, XML_SOURCE_RANGE_ADDRESS))
1933                         pContext = new ScXMLBigRangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, aSourceRange);
1934                 else if (IsXMLToken(rLocalName, XML_TARGET_RANGE_ADDRESS))
1935                         pContext = new ScXMLBigRangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, aTargetRange);
1936         }
1937
1938         if( !pContext )
1939                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1940
1941         return pContext;
1942 }
1943
1944 void ScXMLMovementContext::EndElement()
1945 {
1946         pChangeTrackingImportHelper->SetMoveRanges(aSourceRange, aTargetRange);
1947         pChangeTrackingImportHelper->EndChangeAction();
1948 }
1949
1950 ScXMLRejectionContext::ScXMLRejectionContext( ScXMLImport& rImport,
1951                                                                                           USHORT nPrfx,
1952                                                                                           const ::rtl::OUString& rLName,
1953                                                                                         const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1954                                                                                         ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1955         SvXMLImportContext( rImport, nPrfx, rLName ),
1956         pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1957 {
1958         sal_uInt32 nActionNumber(0);
1959         sal_uInt32 nRejectingNumber(0);
1960         ScChangeActionState nActionState(SC_CAS_VIRGIN);
1961
1962         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1963         for( sal_Int16 i=0; i < nAttrCount; ++i )
1964         {
1965                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1966                 rtl::OUString aLocalName;
1967                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1968                                                                                         sAttrName, &aLocalName ));
1969                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1970
1971                 if (nPrefix == XML_NAMESPACE_TABLE)
1972                 {
1973                         if (IsXMLToken(aLocalName, XML_ID))
1974                         {
1975                                 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1976                         }
1977                         else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1978                         {
1979                                 if (IsXMLToken(sValue, XML_ACCEPTED))
1980                                         nActionState = SC_CAS_ACCEPTED;
1981                                 else if (IsXMLToken(sValue, XML_REJECTED))
1982                                         nActionState = SC_CAS_REJECTED;
1983                         }
1984                         else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1985                         {
1986                                 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1987                         }
1988                 }
1989         }
1990
1991         pChangeTrackingImportHelper->StartChangeAction(SC_CAT_MOVE);
1992         pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1993         pChangeTrackingImportHelper->SetActionState(nActionState);
1994         pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1995 }
1996
1997 ScXMLRejectionContext::~ScXMLRejectionContext()
1998 {
1999 }
2000
2001 SvXMLImportContext *ScXMLRejectionContext::CreateChildContext( USHORT nPrefix,
2002                                                                          const ::rtl::OUString& rLocalName,
2003                                                                          const ::com::sun::star::uno::Reference<
2004                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
2005 {
2006         SvXMLImportContext *pContext(0);
2007
2008         if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
2009         {
2010                 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
2011         }
2012         else if (nPrefix == XML_NAMESPACE_TABLE)
2013         {
2014                 if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
2015                         pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
2016                 else if (IsXMLToken(rLocalName, XML_DELETIONS))
2017                         pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
2018         }
2019
2020         if( !pContext )
2021                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
2022
2023         return pContext;
2024 }
2025
2026 void ScXMLRejectionContext::EndElement()
2027 {
2028         pChangeTrackingImportHelper->EndChangeAction();
2029 }
2030
2031
2032