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.set(fValue);
 232             }
 233         }
 234         break;
 235         case EXC_CHTR_TYPE_DOUBLE:
 236         {
 237             double fValue = pStrm->ReadDouble();
 238             if( pStrm->IsValid() )
 239             {
 240                 rCell.set(fValue);
 241             }
 242         }
 243         break;
 244         case EXC_CHTR_TYPE_STRING:
 245         {
 246             OUString sString = pStrm->ReadUniString();
 247             if( pStrm->IsValid() )
 248             {
 249                 rCell.set(GetDoc().GetSharedStringPool().intern(sString));
 250             }
 251         }
 252         break;
 253         case EXC_CHTR_TYPE_BOOL:
 254         {
 255             double fValue = static_cast<double>(pStrm->ReaduInt16() != 0);
 256             if( pStrm->IsValid() )
 257             {
 258                 rCell.set(fValue);
 259                 rFormat = GetFormatter().GetStandardFormat( SvNumFormatType::LOGICAL, ScGlobal::eLnge );
 260             }
 261         }
 262         break;
 263         case EXC_CHTR_TYPE_FORMULA:
 264         {
 265             std::unique_ptr<ScTokenArray> pTokenArray;
 266             ReadFormula( pTokenArray, rPosition );
 267             if( pStrm->IsValid() && pTokenArray )
 268             {
 269                 rCell.set(new ScFormulaCell(GetDoc(), rPosition, std::move(pTokenArray)));
 270             }
 271         }
 272         break;
 273         default:
 274             OSL_FAIL( "XclImpChangeTrack::ReadCell - unknown data type" );
 275     }
 276 }
 277
 278 void XclImpChangeTrack::ReadChTrInsert()
 279 {
 280     *pStrm >> aRecHeader;
 281     if( !CheckRecord( EXC_CHTR_OP_UNKNOWN ) )
 282         return;
 283
 284     if( (aRecHeader.nOpCode != EXC_CHTR_OP_INSROW) &&
 285         (aRecHeader.nOpCode != EXC_CHTR_OP_INSCOL) &&
 286         (aRecHeader.nOpCode != EXC_CHTR_OP_DELROW) &&
 287         (aRecHeader.nOpCode != EXC_CHTR_OP_DELCOL) )
 288     {
 289         OSL_FAIL( "XclImpChangeTrack::ReadChTrInsert - unknown action" );
 290         return;
 291     }
 292
 293     ScRange aRange;
 294     aRange.aStart.SetTab( ReadTabNum() );
 295     aRange.aEnd.SetTab( aRange.aStart.Tab() );
 296     sal_uInt16 nFlags = pStrm->ReaduInt16();
 297     bool bEndOfList = (nFlags & 0x0001); // row auto-inserted at the bottom.
 298     Read2DRange( aRange );
 299
 300     if( aRecHeader.nOpCode & EXC_CHTR_OP_COLFLAG )
 301         aRange.aEnd.SetRow( GetDocImport().getDoc().MaxRow() );
 302     else
 303         aRange.aEnd.SetCol( GetDocImport().getDoc().MaxCol() );
 304
 305     bool bValid = pStrm->IsValid();
 306     if( FoundNestedMode() )
 307         ReadNestedRecords();
 308
 309     if( bValid )
 310     {
 311         if( aRecHeader.nOpCode & EXC_CHTR_OP_DELFLAG )
 312             DoDeleteRange( aRange );
 313         else
 314             DoInsertRange(aRange, bEndOfList);
 315     }
 316 }
 317
 318 void XclImpChangeTrack::ReadChTrInfo()
 319 {
 320     pStrm->DisableDecryption();
 321     pStrm->Ignore( 32 );
 322     OUString sUsername( pStrm->ReadUniString() );
 323     if( !pStrm->IsValid() ) return;
 324
 325     if( !sUsername.isEmpty() )
 326         pChangeTrack->SetUser( sUsername );
 327     pStrm->Seek( 148 );
 328     if( !pStrm->IsValid() ) return;
 329
 330     DateTime aDateTime( DateTime::EMPTY );
 331     ReadDateTime( aDateTime );
 332     if( pStrm->IsValid() )
 333         pChangeTrack->SetFixDateTimeLocal( aDateTime );
 334 }
 335
 336 void XclImpChangeTrack::ReadChTrCellContent()
 337 {
 338     *pStrm >> aRecHeader;
 339     if( !CheckRecord( EXC_CHTR_OP_CELL ) )
 340         return;
 341
 342     ScAddress aPosition;
 343     SCTAB nTab = ReadTabNum();
 344     aPosition.SetTab( nTab );
 345     sal_uInt16 nValueType;
 346     nValueType = pStrm->ReaduInt16();
 347     sal_uInt16 nOldValueType = (nValueType >> 3) & EXC_CHTR_TYPE_MASK;
 348     sal_uInt16 nNewValueType = nValueType & EXC_CHTR_TYPE_MASK;
 349     pStrm->Ignore( 2 );
 350     Read2DAddress( aPosition );
 351     sal_uInt16 nOldSize;
 352     nOldSize = pStrm->ReaduInt16();
 353     SAL_WARN_IF( (nOldSize == 0) != (nOldValueType == EXC_CHTR_TYPE_EMPTY),
 354         "sc.filter",
 355         "XclImpChangeTrack::ReadChTrCellContent - old value mismatch" );
 356     pStrm->Ignore( 4 );
 357     switch( nValueType & EXC_CHTR_TYPE_FORMATMASK )
 358     {
 359         case 0x0000:                            break;
 360         case 0x1100:    pStrm->Ignore( 16 );    break;
 361         case 0x1300:    pStrm->Ignore( 8 );     break;
 362         default:        OSL_FAIL( "XclImpChangeTrack::ReadChTrCellContent - unknown format info" );
 363     }
 364
 365     ScCellValue aOldCell;
 366     ScCellValue aNewCell;
 367     sal_uInt32 nOldFormat;
 368     sal_uInt32 nNewFormat;
 369     ReadCell(aOldCell, nOldFormat, nOldValueType, aPosition);
 370     ReadCell(aNewCell, nNewFormat, nNewValueType, aPosition);
 371     if( !pStrm->IsValid() || (pStrm->GetRecLeft() > 0) )
 372     {
 373         OSL_FAIL( "XclImpChangeTrack::ReadChTrCellContent - bytes left, action ignored" );
 374         aOldCell.clear();
 375         aNewCell.clear();
 376     }
 377     else
 378     {
 379         ScChangeActionContent* pNewAction =
 380             pChangeTrack->AppendContentOnTheFly(aPosition, aOldCell, aNewCell, nOldFormat, nNewFormat);
 381         DoAcceptRejectAction( pNewAction );
 382     }
 383 }
 384
 385 void XclImpChangeTrack::ReadChTrTabId()
 386 {
 387     if( nTabIdCount == 0 )  // read only 1st time, otherwise calculated by <ReadChTrInsertTab()>
 388         nTabIdCount = static_cast< sal_uInt16 >( pStrm->GetRecLeft() >> 1 );
 389 }
 390
 391 void XclImpChangeTrack::ReadChTrMoveRange()
 392 {
 393     *pStrm >> aRecHeader;
 394     if( !CheckRecord( EXC_CHTR_OP_MOVE ) )
 395         return;
 396
 397     ScRange aSourceRange;
 398     ScRange aDestRange;
 399     aDestRange.aStart.SetTab( ReadTabNum() );
 400     aDestRange.aEnd.SetTab( aDestRange.aStart.Tab() );
 401     Read2DRange( aSourceRange );
 402     Read2DRange( aDestRange );
 403     aSourceRange.aStart.SetTab( ReadTabNum() );
 404     aSourceRange.aEnd.SetTab( aSourceRange.aStart.Tab() );
 405
 406     bool bValid = pStrm->IsValid();
 407     if( FoundNestedMode() )
 408         ReadNestedRecords();
 409
 410     if( bValid )
 411     {
 412         pChangeTrack->AppendMove( aSourceRange, aDestRange, nullptr );
 413         DoAcceptRejectAction( pChangeTrack->GetLast() );
 414     }
 415 }
 416
 417 void XclImpChangeTrack::ReadChTrInsertTab()
 418 {
 419     *pStrm >> aRecHeader;
 420     if( CheckRecord( EXC_CHTR_OP_INSTAB ) )
 421     {
 422         SCTAB nTab = ReadTabNum();
 423         if( pStrm->IsValid() )
 424         {
 425             nTabIdCount++;
 426             DoInsertRange(ScRange(0, 0, nTab, GetDocImport().getDoc().MaxCol(), GetDocImport().getDoc().MaxRow(), nTab), false);
 427         }
 428     }
 429 }
 430
 431 void XclImpChangeTrack::InitNestedMode()
 432 {
 433     OSL_ENSURE( eNestedMode == nmBase, "XclImpChangeTrack::InitNestedMode - unexpected nested mode" );
 434     if( eNestedMode == nmBase )
 435         eNestedMode = nmFound;
 436 }
 437
 438 void XclImpChangeTrack::ReadNestedRecords()
 439 {
 440     OSL_ENSURE( eNestedMode == nmFound, "XclImpChangeTrack::StartNestedMode - missing nested mode" );
 441     if( eNestedMode == nmFound )
 442     {
 443         eNestedMode = nmNested;
 444         ReadRecords();
 445     }
 446 }
 447
 448 bool XclImpChangeTrack::EndNestedMode()
 449 {
 450     OSL_ENSURE( eNestedMode != nmBase, "XclImpChangeTrack::EndNestedMode - missing nested mode" );
 451     bool bReturn = (eNestedMode == nmNested);
 452     eNestedMode = nmBase;
 453     return bReturn;
 454 }
 455
 456 void XclImpChangeTrack::ReadRecords()
 457 {
 458     bool bExitLoop = false;
 459
 460     while( !bExitLoop && !bGlobExit && pStrm->StartNextRecord() )
 461     {
 462         switch( pStrm->GetRecId() )
 463         {
 464             case 0x000A:    bGlobExit = true;               break;
 465             case 0x0137:    ReadChTrInsert();               break;
 466             case 0x0138:    ReadChTrInfo();                 break;
 467             case 0x013B:    ReadChTrCellContent();          break;
 468             case 0x013D:    ReadChTrTabId();                break;
 469             case 0x0140:    ReadChTrMoveRange();            break;
 470             case 0x014D:    ReadChTrInsertTab();            break;
 471             case 0x014E:
 472             case 0x0150:    InitNestedMode();               break;
 473             case 0x014F:
 474             case 0x0151:    bExitLoop = EndNestedMode();    break;
 475         }
 476     }
 477 }
 478
 479 void XclImpChangeTrack::Apply()
 480 {
 481     if( pChangeTrack )
 482     {
 483         pChangeTrack->SetUser( sOldUsername );
 484         pChangeTrack->SetUseFixDateTime( false );
 485
 486         GetDoc().SetChangeTrack( std::move(pChangeTrack) );
 487
 488         ScChangeViewSettings aSettings;
 489         aSettings.SetShowChanges( true );
 490         GetDoc().SetChangeViewSettings( aSettings );
 491     }
 492 }
 493
 494
 495 XclImpChTrFmlConverter::XclImpChTrFmlConverter(
 496     XclImpRoot& rRoot, XclImpChangeTrack& rXclChTr ) :
 497     ExcelToSc8( rRoot ),
 498     rChangeTrack( rXclChTr ) {}
 499
 500 XclImpChTrFmlConverter::~XclImpChTrFmlConverter()
 501 {
 502 }
 503
 504 // virtual, called from ExcToSc8::Convert()
 505 bool XclImpChTrFmlConverter::Read3DTabReference( sal_uInt16 /*nIxti*/, SCTAB& rFirstTab, SCTAB& rLastTab,
 506                                                  ExternalTabInfo& rExtInfo )
 507 {
 508     rChangeTrack.Read3DTabRefInfo( rFirstTab, rLastTab, rExtInfo );
 509     return true;
 510 }
 511
 512 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */