sc/source/filter/xcl97/XclImpChangeTrack.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <XclImpChangeTrack.hxx>
  21 #include <sot/storage.hxx>
  22 #include <svl/numformat.hxx>
  23 #include <svl/zforlist.hxx>
  24 #include <svl/sharedstringpool.hxx>
  25 #include <sal/log.hxx>
  26 #include <chgviset.hxx>
  27 #include <formulacell.hxx>
  28 #include <chgtrack.hxx>
  29 #include <xihelper.hxx>
  30 #include <xilink.hxx>
  31 #include <externalrefmgr.hxx>
  32 #include <document.hxx>
  33 #include <documentimport.hxx>
  34 #include <excdefs.hxx>
  35
  36
  37 XclImpChangeTrack::XclImpChangeTrack( const XclImpRoot& rRoot, const XclImpStream& rBookStrm ) :
  38     XclImpRoot( rRoot ),
  39     aRecHeader(),
  40     nTabIdCount( 0 ),
  41     bGlobExit( false ),
  42     eNestedMode( nmBase )
  43 {
  44     // Verify that the User Names stream exists before going any further. Excel adds both
  45     // "Revision Log" and "User Names" streams when Change Tracking is active but the Revision log
  46     // remains if Change Tracking is turned off.
  47     tools::SvRef<SotStorageStream> xUserStrm = OpenStream( EXC_STREAM_USERNAMES );
  48     if( !xUserStrm.is() )
  49         return;
  50
  51     xInStrm = OpenStream( EXC_STREAM_REVLOG );
  52     if( !xInStrm.is() )
  53         return;
  54
  55     sal_uInt64 const nStreamLen = xInStrm->TellEnd();
  56     if( (xInStrm->GetErrorCode() == ERRCODE_NONE) && (nStreamLen != STREAM_SEEK_TO_END) )
  57     {
  58         xInStrm->Seek( STREAM_SEEK_TO_BEGIN );
  59         pStrm.reset( new XclImpStream( *xInStrm, GetRoot() ) );
  60         pStrm->CopyDecrypterFrom( rBookStrm );
  61         pChangeTrack.reset(new ScChangeTrack( GetDoc() ));
  62
  63         sOldUsername = pChangeTrack->GetUser();
  64         pChangeTrack->SetUseFixDateTime( true );
  65
  66         ReadRecords();
  67     }
  68 }
  69
  70 XclImpChangeTrack::~XclImpChangeTrack()
  71 {
  72     pChangeTrack.reset();
  73     pStrm.reset();
  74 }
  75
  76 void XclImpChangeTrack::DoAcceptRejectAction( ScChangeAction* pAction )
  77 {
  78     if( !pAction ) return;
  79     switch( aRecHeader.nAccept )
  80     {
  81         case EXC_CHTR_ACCEPT:
  82             pChangeTrack->Accept( pAction );
  83         break;
  84         case EXC_CHTR_REJECT:
  85         break;
  86     }
  87 }
  88
  89 void XclImpChangeTrack::DoAcceptRejectAction( sal_uInt32 nFirst, sal_uInt32 nLast )
  90 {
  91     for( sal_uInt32 nIndex = nFirst; nIndex <= nLast; nIndex++ )
  92         DoAcceptRejectAction( pChangeTrack->GetAction( nIndex ) );
  93 }
  94
  95 void XclImpChangeTrack::DoInsertRange( const ScRange& rRange, bool bEndOfList )
  96 {
  97     sal_uInt32 nFirst = pChangeTrack->GetActionMax() + 1;
  98     pChangeTrack->AppendInsert(rRange, bEndOfList);
  99     sal_uInt32 nLast = pChangeTrack->GetActionMax();
 100     DoAcceptRejectAction( nFirst, nLast );
 101 }
 102
 103 void XclImpChangeTrack::DoDeleteRange( const ScRange& rRange )
 104 {
 105     sal_uLong nFirst, nLast;
 106     pChangeTrack->AppendDeleteRange( rRange,  &GetDoc() , nFirst, nLast );
 107     DoAcceptRejectAction( nFirst, nLast );
 108 }
 109
 110 SCTAB XclImpChangeTrack::ReadTabNum()
 111 {
 112     return static_cast<SCTAB>(GetTabInfo().GetCurrentIndex(
 113                 pStrm->ReaduInt16(), nTabIdCount ));
 114 }
 115
 116 void XclImpChangeTrack::ReadDateTime( DateTime& rDateTime )
 117 {
 118     sal_uInt16 nYear;
 119     sal_uInt8 nMonth, nDay, nHour, nMin, nSec;
 120
 121     nYear = pStrm->ReaduInt16();
 122     nMonth = pStrm->ReaduInt8();
 123     nDay = pStrm->ReaduInt8();
 124     nHour = pStrm->ReaduInt8();
 125     nMin = pStrm->ReaduInt8();
 126     nSec = pStrm->ReaduInt8();
 127
 128     rDateTime.SetYear( nYear );
 129     rDateTime.SetMonth( nMonth );
 130     rDateTime.SetDay( nDay );
 131     rDateTime.SetHour( nHour );
 132     rDateTime.SetMin( nMin );
 133     rDateTime.SetSec( nSec );
 134     rDateTime.SetNanoSec( 0 );
 135 }
 136
 137 bool XclImpChangeTrack::CheckRecord( sal_uInt16 nOpCode )
 138 {
 139     if( (nOpCode != EXC_CHTR_OP_UNKNOWN) && (aRecHeader.nOpCode != nOpCode) )
 140     {
 141         OSL_FAIL( "XclImpChangeTrack::CheckRecord - unknown action" );
 142         return false;
 143     }
 144     return aRecHeader.nIndex != 0;
 145 }
 146
 147 void XclImpChangeTrack::Read3DTabRefInfo( SCTAB& rFirstTab, SCTAB& rLastTab, ExcelToSc8::ExternalTabInfo& rExtInfo )
 148 {
 149     if( LookAtuInt8() == 0x01 )
 150     {
 151         rExtInfo.mbExternal = false;
 152         // internal ref - read tab num and return sc tab num (position in TABID list)
 153         pStrm->Ignore( 3 );
 154         rFirstTab = static_cast< SCTAB >( GetTabInfo().GetCurrentIndex( pStrm->ReaduInt16(), nTabIdCount ) );
 155         sal_uInt8 nFillByte = pStrm->ReaduInt8();
 156         rLastTab = (nFillByte == 0x00) ?
 157             static_cast< SCTAB >( GetTabInfo().GetCurrentIndex( pStrm->ReaduInt16(), nTabIdCount ) ) : rFirstTab;
 158     }
 159     else
 160     {
 161         // external ref - read doc and tab name and find sc tab num
 162         // - URL
 163         OUString aEncUrl( pStrm->ReadUniString() );
 164         OUString aUrl;
 165         bool bSelf;
 166         XclImpUrlHelper::DecodeUrl( aUrl, bSelf, GetRoot(), aEncUrl );
 167         pStrm->Ignore( 1 );
 168         // - sheet name, always separated from URL
 169         OUString aTabName( pStrm->ReadUniString() );
 170         pStrm->Ignore( 1 );
 171
 172         rExtInfo.mbExternal = true;
 173         ScExternalRefManager* pRefMgr = GetDoc().GetExternalRefManager();
 174         pRefMgr->convertToAbsName(aUrl);
 175         rExtInfo.mnFileId = pRefMgr->getExternalFileId(aUrl);
 176         rExtInfo.maTabName = aTabName;
 177         rFirstTab = rLastTab = 0;
 178     }
 179 }
 180
 181 void XclImpChangeTrack::ReadFormula( std::unique_ptr<ScTokenArray>& rpTokenArray, const ScAddress& rPosition )
 182 {
 183     sal_uInt16 nFmlSize = pStrm->ReaduInt16();
 184
 185     // create a memory stream and copy the formula to be able to read simultaneously
 186     // the formula and the additional 3D tab ref data following the formula
 187     // here we have to simulate an Excel record to be able to use an XclImpStream...
 188     // 2do: remove the stream member from formula converter and add it as a parameter
 189     // to the Convert() routine (to prevent the construction/destruction of the
 190     // converter in each formula)
 191     SvMemoryStream aMemStrm;
 192     aMemStrm.WriteUInt16( 0x0001 ).WriteUInt16( nFmlSize );
 193     size_t nRead = pStrm->CopyToStream( aMemStrm, nFmlSize );
 194
 195     // survive reading invalid streams!
 196     // if we can't read as many bytes as required just don't use them and
 197     // assume that this part is broken
 198     if(nRead != nFmlSize)
 199     {
 200         rpTokenArray = nullptr;
 201         pStrm->Ignore(1);
 202         return;
 203     }
 204
 205     XclImpStream aFmlaStrm( aMemStrm, GetRoot() );
 206     aFmlaStrm.StartNextRecord();
 207     XclImpChTrFmlConverter aFmlConv( GetRoot(), *this );
 208
 209     // read the formula, 3D tab refs from extended data
 210     std::unique_ptr<ScTokenArray> pArray;
 211     aFmlConv.Reset( rPosition );
 212     bool bOK = (aFmlConv.Convert( pArray, aFmlaStrm, nFmlSize, false ) == ConvErr::OK);   // JEG : Check This
 213     rpTokenArray = (bOK && pArray) ? std::move( pArray ) : nullptr;
 214     pStrm->Ignore( 1 );
 215 }
 216
 217 void XclImpChangeTrack::ReadCell(
 218     ScCellValue& rCell, sal_uInt32& rFormat, sal_uInt16 nFlags, const ScAddress& rPosition )
 219 {
 220     rCell.clear();
 221     rFormat = 0;
 222     switch( nFlags & EXC_CHTR_TYPE_MASK )
 223     {
 224         case EXC_CHTR_TYPE_EMPTY:
 225         break;
 226         case EXC_CHTR_TYPE_RK:
 227         {
 228             double fValue = XclTools::GetDoubleFromRK( pStrm->ReadInt32() );
 229             if( pStrm->IsValid() )
 230             {
 231                 rCell.meType = CELLTYPE_VALUE;
 232                 rCell.mfValue = fValue;
 233             }
 234         }
 235         break;
 236         case EXC_CHTR_TYPE_DOUBLE:
 237         {
 238             double fValue = pStrm->ReadDouble();
 239             if( pStrm->IsValid() )
 240             {
 241                 rCell.meType = CELLTYPE_VALUE;
 242                 rCell.mfValue = fValue;
 243             }
 244         }
 245         break;
 246         case EXC_CHTR_TYPE_STRING:
 247         {
 248             OUString sString = pStrm->ReadUniString();
 249             if( pStrm->IsValid() )
 250             {
 251                 rCell.meType = CELLTYPE_STRING;
 252                 rCell.mpString = new svl::SharedString(GetDoc().GetSharedStringPool().intern(sString));
 253             }
 254         }
 255         break;
 256         case EXC_CHTR_TYPE_BOOL:
 257         {
 258             double fValue = static_cast<double>(pStrm->ReaduInt16() != 0);
 259             if( pStrm->IsValid() )
 260             {
 261                 rCell.meType = CELLTYPE_VALUE;
 262                 rCell.mfValue = fValue;
 263                 rFormat = GetFormatter().GetStandardFormat( SvNumFormatType::LOGICAL, ScGlobal::eLnge );
 264             }
 265         }
 266         break;
 267         case EXC_CHTR_TYPE_FORMULA:
 268         {
 269             std::unique_ptr<ScTokenArray> pTokenArray;
 270             ReadFormula( pTokenArray, rPosition );
 271             if( pStrm->IsValid() && pTokenArray )
 272             {
 273                 rCell.meType = CELLTYPE_FORMULA;
 274                 rCell.mpFormula = new ScFormulaCell(GetDoc(), rPosition, std::move(pTokenArray));
 275             }
 276         }
 277         break;
 278         default:
 279             OSL_FAIL( "XclImpChangeTrack::ReadCell - unknown data type" );
 280     }
 281 }
 282
 283 void XclImpChangeTrack::ReadChTrInsert()
 284 {
 285     *pStrm >> aRecHeader;
 286     if( !CheckRecord( EXC_CHTR_OP_UNKNOWN ) )
 287         return;
 288
 289     if( (aRecHeader.nOpCode != EXC_CHTR_OP_INSROW) &&
 290         (aRecHeader.nOpCode != EXC_CHTR_OP_INSCOL) &&
 291         (aRecHeader.nOpCode != EXC_CHTR_OP_DELROW) &&
 292         (aRecHeader.nOpCode != EXC_CHTR_OP_DELCOL) )
 293     {
 294         OSL_FAIL( "XclImpChangeTrack::ReadChTrInsert - unknown action" );
 295         return;
 296     }
 297
 298     ScRange aRange;
 299     aRange.aStart.SetTab( ReadTabNum() );
 300     aRange.aEnd.SetTab( aRange.aStart.Tab() );
 301     sal_uInt16 nFlags = pStrm->ReaduInt16();
 302     bool bEndOfList = (nFlags & 0x0001); // row auto-inserted at the bottom.
 303     Read2DRange( aRange );
 304
 305     if( aRecHeader.nOpCode & EXC_CHTR_OP_COLFLAG )
 306         aRange.aEnd.SetRow( GetDocImport().getDoc().MaxRow() );
 307     else
 308         aRange.aEnd.SetCol( GetDocImport().getDoc().MaxCol() );
 309
 310     bool bValid = pStrm->IsValid();
 311     if( FoundNestedMode() )
 312         ReadNestedRecords();
 313
 314     if( bValid )
 315     {
 316         if( aRecHeader.nOpCode & EXC_CHTR_OP_DELFLAG )
 317             DoDeleteRange( aRange );
 318         else
 319             DoInsertRange(aRange, bEndOfList);
 320     }
 321 }
 322
 323 void XclImpChangeTrack::ReadChTrInfo()
 324 {
 325     pStrm->DisableDecryption();
 326     pStrm->Ignore( 32 );
 327     OUString sUsername( pStrm->ReadUniString() );
 328     if( !pStrm->IsValid() ) return;
 329
 330     if( !sUsername.isEmpty() )
 331         pChangeTrack->SetUser( sUsername );
 332     pStrm->Seek( 148 );
 333     if( !pStrm->IsValid() ) return;
 334
 335     DateTime aDateTime( DateTime::EMPTY );
 336     ReadDateTime( aDateTime );
 337     if( pStrm->IsValid() )
 338         pChangeTrack->SetFixDateTimeLocal( aDateTime );
 339 }
 340
 341 void XclImpChangeTrack::ReadChTrCellContent()
 342 {
 343     *pStrm >> aRecHeader;
 344     if( !CheckRecord( EXC_CHTR_OP_CELL ) )
 345         return;
 346
 347     ScAddress aPosition;
 348     SCTAB nTab = ReadTabNum();
 349     aPosition.SetTab( nTab );
 350     sal_uInt16 nValueType;
 351     nValueType = pStrm->ReaduInt16();
 352     sal_uInt16 nOldValueType = (nValueType >> 3) & EXC_CHTR_TYPE_MASK;
 353     sal_uInt16 nNewValueType = nValueType & EXC_CHTR_TYPE_MASK;
 354     pStrm->Ignore( 2 );
 355     Read2DAddress( aPosition );
 356     sal_uInt16 nOldSize;
 357     nOldSize = pStrm->ReaduInt16();
 358     SAL_WARN_IF( (nOldSize == 0) != (nOldValueType == EXC_CHTR_TYPE_EMPTY),
 359         "sc.filter",
 360         "XclImpChangeTrack::ReadChTrCellContent - old value mismatch" );
 361     pStrm->Ignore( 4 );
 362     switch( nValueType & EXC_CHTR_TYPE_FORMATMASK )
 363     {
 364         case 0x0000:                            break;
 365         case 0x1100:    pStrm->Ignore( 16 );    break;
 366         case 0x1300:    pStrm->Ignore( 8 );     break;
 367         default:        OSL_FAIL( "XclImpChangeTrack::ReadChTrCellContent - unknown format info" );
 368     }
 369
 370     ScCellValue aOldCell;
 371     ScCellValue aNewCell;
 372     sal_uInt32 nOldFormat;
 373     sal_uInt32 nNewFormat;
 374     ReadCell(aOldCell, nOldFormat, nOldValueType, aPosition);
 375     ReadCell(aNewCell, nNewFormat, nNewValueType, aPosition);
 376     if( !pStrm->IsValid() || (pStrm->GetRecLeft() > 0) )
 377     {
 378         OSL_FAIL( "XclImpChangeTrack::ReadChTrCellContent - bytes left, action ignored" );
 379         aOldCell.clear();
 380         aNewCell.clear();
 381     }
 382     else
 383     {
 384         ScChangeActionContent* pNewAction =
 385             pChangeTrack->AppendContentOnTheFly(aPosition, aOldCell, aNewCell, nOldFormat, nNewFormat);
 386         DoAcceptRejectAction( pNewAction );
 387     }
 388 }
 389
 390 void XclImpChangeTrack::ReadChTrTabId()
 391 {
 392     if( nTabIdCount == 0 )  // read only 1st time, otherwise calculated by <ReadChTrInsertTab()>
 393         nTabIdCount = static_cast< sal_uInt16 >( pStrm->GetRecLeft() >> 1 );
 394 }
 395
 396 void XclImpChangeTrack::ReadChTrMoveRange()
 397 {
 398     *pStrm >> aRecHeader;
 399     if( !CheckRecord( EXC_CHTR_OP_MOVE ) )
 400         return;
 401
 402     ScRange aSourceRange;
 403     ScRange aDestRange;
 404     aDestRange.aStart.SetTab( ReadTabNum() );
 405     aDestRange.aEnd.SetTab( aDestRange.aStart.Tab() );
 406     Read2DRange( aSourceRange );
 407     Read2DRange( aDestRange );
 408     aSourceRange.aStart.SetTab( ReadTabNum() );
 409     aSourceRange.aEnd.SetTab( aSourceRange.aStart.Tab() );
 410
 411     bool bValid = pStrm->IsValid();
 412     if( FoundNestedMode() )
 413         ReadNestedRecords();
 414
 415     if( bValid )
 416     {
 417         pChangeTrack->AppendMove( aSourceRange, aDestRange, nullptr );
 418         DoAcceptRejectAction( pChangeTrack->GetLast() );
 419     }
 420 }
 421
 422 void XclImpChangeTrack::ReadChTrInsertTab()
 423 {
 424     *pStrm >> aRecHeader;
 425     if( CheckRecord( EXC_CHTR_OP_INSTAB ) )
 426     {
 427         SCTAB nTab = ReadTabNum();
 428         if( pStrm->IsValid() )
 429         {
 430             nTabIdCount++;
 431             DoInsertRange(ScRange(0, 0, nTab, GetDocImport().getDoc().MaxCol(), GetDocImport().getDoc().MaxRow(), nTab), false);
 432         }
 433     }
 434 }
 435
 436 void XclImpChangeTrack::InitNestedMode()
 437 {
 438     OSL_ENSURE( eNestedMode == nmBase, "XclImpChangeTrack::InitNestedMode - unexpected nested mode" );
 439     if( eNestedMode == nmBase )
 440         eNestedMode = nmFound;
 441 }
 442
 443 void XclImpChangeTrack::ReadNestedRecords()
 444 {
 445     OSL_ENSURE( eNestedMode == nmFound, "XclImpChangeTrack::StartNestedMode - missing nested mode" );
 446     if( eNestedMode == nmFound )
 447     {
 448         eNestedMode = nmNested;
 449         ReadRecords();
 450     }
 451 }
 452
 453 bool XclImpChangeTrack::EndNestedMode()
 454 {
 455     OSL_ENSURE( eNestedMode != nmBase, "XclImpChangeTrack::EndNestedMode - missing nested mode" );
 456     bool bReturn = (eNestedMode == nmNested);
 457     eNestedMode = nmBase;
 458     return bReturn;
 459 }
 460
 461 void XclImpChangeTrack::ReadRecords()
 462 {
 463     bool bExitLoop = false;
 464
 465     while( !bExitLoop && !bGlobExit && pStrm->StartNextRecord() )
 466     {
 467         switch( pStrm->GetRecId() )
 468         {
 469             case 0x000A:    bGlobExit = true;               break;
 470             case 0x0137:    ReadChTrInsert();               break;
 471             case 0x0138:    ReadChTrInfo();                 break;
 472             case 0x013B:    ReadChTrCellContent();          break;
 473             case 0x013D:    ReadChTrTabId();                break;
 474             case 0x0140:    ReadChTrMoveRange();            break;
 475             case 0x014D:    ReadChTrInsertTab();            break;
 476             case 0x014E:
 477             case 0x0150:    InitNestedMode();               break;
 478             case 0x014F:
 479             case 0x0151:    bExitLoop = EndNestedMode();    break;
 480         }
 481     }
 482 }
 483
 484 void XclImpChangeTrack::Apply()
 485 {
 486     if( pChangeTrack )
 487     {
 488         pChangeTrack->SetUser( sOldUsername );
 489         pChangeTrack->SetUseFixDateTime( false );
 490
 491         GetDoc().SetChangeTrack( std::move(pChangeTrack) );
 492
 493         ScChangeViewSettings aSettings;
 494         aSettings.SetShowChanges( true );
 495         GetDoc().SetChangeViewSettings( aSettings );
 496     }
 497 }
 498
 499
 500 XclImpChTrFmlConverter::XclImpChTrFmlConverter(
 501     XclImpRoot& rRoot, XclImpChangeTrack& rXclChTr ) :
 502     ExcelToSc8( rRoot ),
 503     rChangeTrack( rXclChTr ) {}
 504
 505 XclImpChTrFmlConverter::~XclImpChTrFmlConverter()
 506 {
 507 }
 508
 509 // virtual, called from ExcToSc8::Convert()
 510 bool XclImpChTrFmlConverter::Read3DTabReference( sal_uInt16 /*nIxti*/, SCTAB& rFirstTab, SCTAB& rLastTab,
 511                                                  ExternalTabInfo& rExtInfo )
 512 {
 513     rChangeTrack.Read3DTabRefInfo( rFirstTab, rLastTab, rExtInfo );
 514     return true;
 515 }
 516
 517 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */