sc/source/ui/docshell/docsh3.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 <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
  21 #include <com/sun/star/document/XDocumentProperties.hpp>
  22
  23 #include "scitems.hxx"
  24 #include "rangelst.hxx"
  25 #include <editeng/flstitem.hxx>
  26 #include <editeng/paperinf.hxx>
  27 #include <editeng/sizeitem.hxx>
  28 #include <rtl/strbuf.hxx>
  29 #include <sfx2/viewfrm.hxx>
  30 #include <sfx2/app.hxx>
  31 #include <sfx2/docfile.hxx>
  32 #include <sfx2/printer.hxx>
  33 #include <svx/postattr.hxx>
  34 #include <unotools/misccfg.hxx>
  35 #include <vcl/virdev.hxx>
  36 #include <vcl/msgbox.hxx>
  37
  38 #include "docsh.hxx"
  39 #include "docshimp.hxx"
  40 #include "scmod.hxx"
  41 #include "tabvwsh.hxx"
  42 #include "viewdata.hxx"
  43 #include "docpool.hxx"
  44 #include "stlpool.hxx"
  45 #include "patattr.hxx"
  46 #include "uiitems.hxx"
  47 #include "hints.hxx"
  48 #include "docoptio.hxx"
  49 #include "viewopti.hxx"
  50 #include "pntlock.hxx"
  51 #include "chgtrack.hxx"
  52 #include "docfunc.hxx"
  53 #include "formulacell.hxx"
  54 #include "chgviset.hxx"
  55 #include "progress.hxx"
  56 #include "redcom.hxx"
  57 #include "sc.hrc"
  58 #include "inputopt.hxx"
  59 #include "drwlayer.hxx"
  60 #include "inputhdl.hxx"
  61 #include "conflictsdlg.hxx"
  62 #include "globstr.hrc"
  63 #include "markdata.hxx"
  64 #include <memory>
  65
  66 #include <comphelper/lok.hxx>
  67 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  68
  69 //          Redraw - Benachrichtigungen
  70
  71 void ScDocShell::PostEditView( ScEditEngineDefaulter* pEditEngine, const ScAddress& rCursorPos )
  72 {
  73 //  Broadcast( ScEditViewHint( pEditEngine, rCursorPos ) );
  74
  75         //  Test: nur aktive ViewShell
  76
  77     ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
  78     if (pViewSh && pViewSh->GetViewData().GetDocShell() == this)
  79     {
  80         ScEditViewHint aHint( pEditEngine, rCursorPos );
  81         pViewSh->Notify( *this, aHint );
  82     }
  83 }
  84
  85 void ScDocShell::PostDataChanged()
  86 {
  87     Broadcast( SfxSimpleHint( FID_DATACHANGED ) );
  88     SfxGetpApp()->Broadcast(SfxSimpleHint( FID_ANYDATACHANGED ));      // Navigator
  89     aDocument.ClearFormulaContext();
  90     //! Navigator direkt benachrichtigen!
  91 }
  92
  93 void ScDocShell::PostPaint( SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
  94                             SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab, sal_uInt16 nPart,
  95                             sal_uInt16 nExtFlags )
  96 {
  97     ScRange aRange(nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
  98     PostPaint(aRange, nPart, nExtFlags);
  99 }
 100
 101 void ScDocShell::PostPaint( const ScRangeList& rRanges, sal_uInt16 nPart, sal_uInt16 nExtFlags )
 102 {
 103     ScRangeList aPaintRanges;
 104     for (size_t i = 0, n = rRanges.size(); i < n; ++i)
 105     {
 106         const ScRange& rRange = *rRanges[i];
 107         SCCOL nCol1 = rRange.aStart.Col(), nCol2 = rRange.aEnd.Col();
 108         SCROW nRow1 = rRange.aStart.Row(), nRow2 = rRange.aEnd.Row();
 109         SCTAB nTab1 = rRange.aStart.Tab(), nTab2 = rRange.aEnd.Tab();
 110
 111         if (!ValidCol(nCol1)) nCol1 = MAXCOL;
 112         if (!ValidRow(nRow1)) nRow1 = MAXROW;
 113         if (!ValidCol(nCol2)) nCol2 = MAXCOL;
 114         if (!ValidRow(nRow2)) nRow2 = MAXROW;
 115
 116         if ( pPaintLockData )
 117         {
 118             // #i54081# PAINT_EXTRAS still has to be broadcast because it changes the
 119             // current sheet if it's invalid. All other flags added to pPaintLockData.
 120             sal_uInt16 nLockPart = nPart & ~PAINT_EXTRAS;
 121             if ( nLockPart )
 122             {
 123                 //! nExtFlags ???
 124                 pPaintLockData->AddRange( ScRange( nCol1, nRow1, nTab1,
 125                                                    nCol2, nRow2, nTab2 ), nLockPart );
 126             }
 127
 128             nPart &= PAINT_EXTRAS;  // for broadcasting
 129             if (!nPart)
 130                 continue;
 131         }
 132
 133         if (nExtFlags & SC_PF_LINES)            // Platz fuer Linien beruecksichtigen
 134         {
 135                                                 //! Abfrage auf versteckte Spalten/Zeilen!
 136             if (nCol1>0) --nCol1;
 137             if (nCol2<MAXCOL) ++nCol2;
 138             if (nRow1>0) --nRow1;
 139             if (nRow2<MAXROW) ++nRow2;
 140         }
 141
 142                                                 // um zusammengefasste erweitern
 143         if (nExtFlags & SC_PF_TESTMERGE)
 144             aDocument.ExtendMerge( nCol1, nRow1, nCol2, nRow2, nTab1 );
 145
 146         if ( nCol1 != 0 || nCol2 != MAXCOL )
 147         {
 148             //  Extend to whole rows if SC_PF_WHOLEROWS is set, or rotated or non-left
 149             //  aligned cells are contained (see UpdatePaintExt).
 150             //  Special handling for RTL text (#i9731#) is unnecessary now with full
 151             //  support of right-aligned text.
 152
 153             if ( ( nExtFlags & SC_PF_WHOLEROWS ) ||
 154                  aDocument.HasAttrib( nCol1,nRow1,nTab1,
 155                                       MAXCOL,nRow2,nTab2, HASATTR_ROTATE | HASATTR_RIGHTORCENTER ) )
 156             {
 157                 nCol1 = 0;
 158                 nCol2 = MAXCOL;
 159             }
 160         }
 161         aPaintRanges.Append(ScRange(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2));
 162     }
 163
 164     Broadcast(ScPaintHint(aPaintRanges.Combine(), nPart));
 165
 166     // LOK: we are supposed to update the row / columns headers (and actually
 167     // the document size too - cell size affects that, obviously)
 168     if ((nPart & (PAINT_TOP | PAINT_LEFT)) && comphelper::LibreOfficeKit::isActive() && aDocument.GetDrawLayer())
 169         aDocument.GetDrawLayer()->libreOfficeKitCallback(LOK_CALLBACK_DOCUMENT_SIZE_CHANGED, "");
 170 }
 171
 172 void ScDocShell::PostPaintGridAll()
 173 {
 174     PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
 175 }
 176
 177 void ScDocShell::PostPaintCell( SCCOL nCol, SCROW nRow, SCTAB nTab )
 178 {
 179     PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PAINT_GRID, SC_PF_TESTMERGE );
 180 }
 181
 182 void ScDocShell::PostPaintCell( const ScAddress& rPos )
 183 {
 184     PostPaintCell( rPos.Col(), rPos.Row(), rPos.Tab() );
 185 }
 186
 187 void ScDocShell::PostPaintExtras()
 188 {
 189     PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_EXTRAS );
 190 }
 191
 192 void ScDocShell::UpdatePaintExt( sal_uInt16& rExtFlags, const ScRange& rRange )
 193 {
 194     if ( ( rExtFlags & SC_PF_LINES ) == 0 && aDocument.HasAttrib( rRange, HASATTR_PAINTEXT ) )
 195     {
 196         //  If the range contains lines, shadow or conditional formats,
 197         //  set SC_PF_LINES to include one extra cell in all directions.
 198
 199         rExtFlags |= SC_PF_LINES;
 200     }
 201
 202     if ( ( rExtFlags & SC_PF_WHOLEROWS ) == 0 &&
 203          ( rRange.aStart.Col() != 0 || rRange.aEnd.Col() != MAXCOL ) &&
 204          aDocument.HasAttrib( rRange, HASATTR_ROTATE | HASATTR_RIGHTORCENTER ) )
 205     {
 206         //  If the range contains (logically) right- or center-aligned cells,
 207         //  or rotated cells, set SC_PF_WHOLEROWS to paint the whole rows.
 208         //  This test isn't needed after the cell changes, because it's also
 209         //  tested in PostPaint. UpdatePaintExt may later be changed to do this
 210         //  only if called before the changes.
 211
 212         rExtFlags |= SC_PF_WHOLEROWS;
 213     }
 214 }
 215
 216 void ScDocShell::UpdatePaintExt( sal_uInt16& rExtFlags, SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
 217                                                    SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab )
 218 {
 219     UpdatePaintExt( rExtFlags, ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab ) );
 220 }
 221
 222 void ScDocShell::LockPaint_Impl(bool bDoc)
 223 {
 224     if ( !pPaintLockData )
 225         pPaintLockData = new ScPaintLockData;
 226     pPaintLockData->IncLevel(bDoc);
 227 }
 228
 229 void ScDocShell::UnlockPaint_Impl(bool bDoc)
 230 {
 231     if ( pPaintLockData )
 232     {
 233         if ( pPaintLockData->GetLevel(bDoc) )
 234             pPaintLockData->DecLevel(bDoc);
 235         if (!pPaintLockData->GetLevel(!bDoc) && !pPaintLockData->GetLevel(bDoc))
 236         {
 237             //      Paint jetzt ausfuehren
 238
 239             ScPaintLockData* pPaint = pPaintLockData;
 240             pPaintLockData = nullptr;                      // nicht weitersammeln
 241
 242             ScRangeListRef xRangeList = pPaint->GetRangeList();
 243             if (xRangeList)
 244             {
 245                 sal_uInt16 nParts = pPaint->GetParts();
 246                 for ( size_t i = 0, nCount = xRangeList->size(); i < nCount; i++ )
 247                 {
 248                     //! nExtFlags ???
 249                     ScRange aRange = *(*xRangeList)[i];
 250                     PostPaint( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aStart.Tab(),
 251                                 aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aEnd.Tab(),
 252                                 nParts );
 253                 }
 254             }
 255
 256             if ( pPaint->GetModified() )
 257                 SetDocumentModified();
 258
 259             delete pPaint;
 260         }
 261     }
 262     else
 263     {
 264         OSL_FAIL("UnlockPaint ohne LockPaint");
 265     }
 266 }
 267
 268 void ScDocShell::LockDocument_Impl(sal_uInt16 nNew)
 269 {
 270     if (!nDocumentLock)
 271     {
 272         ScDrawLayer* pDrawLayer = aDocument.GetDrawLayer();
 273         if (pDrawLayer)
 274             pDrawLayer->setLock(true);
 275     }
 276     nDocumentLock = nNew;
 277 }
 278
 279 void ScDocShell::UnlockDocument_Impl(sal_uInt16 nNew)
 280 {
 281     nDocumentLock = nNew;
 282     if (!nDocumentLock)
 283     {
 284         ScDrawLayer* pDrawLayer = aDocument.GetDrawLayer();
 285         if (pDrawLayer)
 286             pDrawLayer->setLock(false);
 287     }
 288 }
 289
 290 void ScDocShell::SetLockCount(sal_uInt16 nNew)
 291 {
 292     if (nNew)                   // setzen
 293     {
 294         if ( !pPaintLockData )
 295             pPaintLockData = new ScPaintLockData;
 296         pPaintLockData->SetDocLevel(nNew-1);
 297         LockDocument_Impl(nNew);
 298     }
 299     else if (pPaintLockData)    // loeschen
 300     {
 301         pPaintLockData->SetDocLevel(0);  // bei Unlock sofort ausfuehren
 302         UnlockPaint_Impl(true);                 // jetzt
 303         UnlockDocument_Impl(0);
 304     }
 305 }
 306
 307 void ScDocShell::LockPaint()
 308 {
 309     LockPaint_Impl(false);
 310 }
 311
 312 void ScDocShell::UnlockPaint()
 313 {
 314     UnlockPaint_Impl(false);
 315 }
 316
 317 void ScDocShell::LockDocument()
 318 {
 319     LockPaint_Impl(true);
 320     LockDocument_Impl(nDocumentLock + 1);
 321 }
 322
 323 void ScDocShell::UnlockDocument()
 324 {
 325     if (nDocumentLock)
 326     {
 327         UnlockPaint_Impl(true);
 328         UnlockDocument_Impl(nDocumentLock - 1);
 329     }
 330     else
 331     {
 332         OSL_FAIL("UnlockDocument without LockDocument");
 333     }
 334 }
 335
 336 void ScDocShell::SetInplace( bool bInplace )
 337 {
 338     if (bIsInplace != bInplace)
 339     {
 340         bIsInplace = bInplace;
 341         CalcOutputFactor();
 342     }
 343 }
 344
 345 void ScDocShell::CalcOutputFactor()
 346 {
 347     if (bIsInplace)
 348     {
 349         nPrtToScreenFactor = 1.0;           // passt sonst nicht zur inaktiven Darstellung
 350         return;
 351     }
 352
 353     bool bTextWysiwyg = SC_MOD()->GetInputOptions().GetTextWysiwyg();
 354     if (bTextWysiwyg)
 355     {
 356         nPrtToScreenFactor = 1.0;
 357         return;
 358     }
 359
 360     OUString aTestString(
 361             "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890123456789");
 362     long nPrinterWidth = 0;
 363     long nWindowWidth = 0;
 364     const ScPatternAttr* pPattern = static_cast<const ScPatternAttr*>(&aDocument.GetPool()->
 365                                             GetDefaultItem(ATTR_PATTERN));
 366
 367     vcl::Font aDefFont;
 368     OutputDevice* pRefDev = GetRefDevice();
 369     MapMode aOldMode = pRefDev->GetMapMode();
 370     vcl::Font aOldFont = pRefDev->GetFont();
 371
 372     pRefDev->SetMapMode(MAP_PIXEL);
 373     pPattern->GetFont(aDefFont, SC_AUTOCOL_BLACK, pRefDev); // font color doesn't matter here
 374     pRefDev->SetFont(aDefFont);
 375     nPrinterWidth = pRefDev->PixelToLogic( Size( pRefDev->GetTextWidth(aTestString), 0 ), MAP_100TH_MM ).Width();
 376     pRefDev->SetFont(aOldFont);
 377     pRefDev->SetMapMode(aOldMode);
 378
 379     ScopedVclPtrInstance< VirtualDevice > pVirtWindow( *Application::GetDefaultDevice() );
 380     pVirtWindow->SetMapMode(MAP_PIXEL);
 381     pPattern->GetFont(aDefFont, SC_AUTOCOL_BLACK, pVirtWindow);    // font color doesn't matter here
 382     pVirtWindow->SetFont(aDefFont);
 383     nWindowWidth = pVirtWindow->GetTextWidth(aTestString);
 384     nWindowWidth = (long) ( nWindowWidth / ScGlobal::nScreenPPTX * HMM_PER_TWIPS );
 385
 386     if (nPrinterWidth && nWindowWidth)
 387         nPrtToScreenFactor = nPrinterWidth / (double) nWindowWidth;
 388     else
 389     {
 390         OSL_FAIL("GetTextSize gibt 0 ??");
 391         nPrtToScreenFactor = 1.0;
 392     }
 393 }
 394
 395 void ScDocShell::InitOptions(bool bForLoading)      // called from InitNew and Load
 396 {
 397     //  Einstellungen aus dem SpellCheckCfg kommen in Doc- und ViewOptions
 398
 399     sal_uInt16 nDefLang, nCjkLang, nCtlLang;
 400     bool bAutoSpell;
 401     ScModule::GetSpellSettings( nDefLang, nCjkLang, nCtlLang, bAutoSpell );
 402     ScModule* pScMod = SC_MOD();
 403
 404     ScDocOptions  aDocOpt  = pScMod->GetDocOptions();
 405     ScFormulaOptions aFormulaOpt = pScMod->GetFormulaOptions();
 406     ScViewOptions aViewOpt = pScMod->GetViewOptions();
 407     aDocOpt.SetAutoSpell( bAutoSpell );
 408
 409     // zweistellige Jahreszahleneingabe aus Extras->Optionen->Allgemein->Sonstiges
 410     aDocOpt.SetYear2000( sal::static_int_cast<sal_uInt16>( ::utl::MiscCfg().GetYear2000() ) );
 411
 412     if (bForLoading)
 413     {
 414         // #i112123# No style:decimal-places attribute means automatic decimals, not the configured default,
 415         // so it must not be taken from the global options.
 416         // Calculation settings are handled separately in ScXMLBodyContext::EndElement.
 417         aDocOpt.SetStdPrecision( SvNumberFormatter::UNLIMITED_PRECISION );
 418
 419         // fdo#78294 The default null-date if
 420         // <table:null-date table:date-value='...' />
 421         // is absent is 1899-12-30 regardless what the configuration is set to.
 422         // Import filters may override this value.
 423         aDocOpt.SetDate( 30, 12, 1899);
 424     }
 425
 426     aDocument.SetDocOptions( aDocOpt );
 427     aDocument.SetViewOptions( aViewOpt );
 428     SetFormulaOptions( aFormulaOpt, bForLoading );
 429
 430     //  Druck-Optionen werden jetzt direkt vor dem Drucken gesetzt
 431
 432     aDocument.SetLanguage( (LanguageType) nDefLang, (LanguageType) nCjkLang, (LanguageType) nCtlLang );
 433 }
 434
 435 Printer* ScDocShell::GetDocumentPrinter()       // fuer OLE
 436 {
 437     return aDocument.GetPrinter();
 438 }
 439
 440 SfxPrinter* ScDocShell::GetPrinter(bool bCreateIfNotExist)
 441 {
 442     return aDocument.GetPrinter(bCreateIfNotExist);
 443 }
 444
 445 void ScDocShell::UpdateFontList()
 446 {
 447     delete pImpl->pFontList;
 448     // pImpl->pFontList = new FontList( GetPrinter(), Application::GetDefaultDevice() );
 449     pImpl->pFontList = new FontList( GetRefDevice(), nullptr, false ); // sal_False or sal_True???
 450     SvxFontListItem aFontListItem( pImpl->pFontList, SID_ATTR_CHAR_FONTLIST );
 451     PutItem( aFontListItem );
 452
 453     CalcOutputFactor();
 454 }
 455
 456 OutputDevice* ScDocShell::GetRefDevice()
 457 {
 458     return aDocument.GetRefDevice();
 459 }
 460
 461 sal_uInt16 ScDocShell::SetPrinter( SfxPrinter* pNewPrinter, SfxPrinterChangeFlags nDiffFlags )
 462 {
 463     SfxPrinter *pOld = aDocument.GetPrinter( false );
 464     if ( pOld && pOld->IsPrinting() )
 465         return SFX_PRINTERROR_BUSY;
 466
 467     if (nDiffFlags & SfxPrinterChangeFlags::PRINTER)
 468     {
 469         if ( aDocument.GetPrinter() != pNewPrinter )
 470         {
 471             aDocument.SetPrinter( pNewPrinter );
 472             aDocument.SetPrintOptions();
 473
 474             // MT: Use UpdateFontList: Will use Printer fonts only if needed!
 475             /*
 476             delete pImpl->pFontList;
 477             pImpl->pFontList = new FontList( pNewPrinter, Application::GetDefaultDevice() );
 478             SvxFontListItem aFontListItem( pImpl->pFontList, SID_ATTR_CHAR_FONTLIST );
 479             PutItem( aFontListItem );
 480
 481             CalcOutputFactor();
 482             */
 483             if ( SC_MOD()->GetInputOptions().GetTextWysiwyg() )
 484                 UpdateFontList();
 485
 486             ScModule* pScMod = SC_MOD();
 487             SfxViewFrame *pFrame = SfxViewFrame::GetFirst( this );
 488             while (pFrame)
 489             {
 490                 SfxViewShell* pSh = pFrame->GetViewShell();
 491                 if (ScTabViewShell* pViewSh = dynamic_cast<ScTabViewShell*>(pSh))
 492                 {
 493                     ScInputHandler* pInputHdl = pScMod->GetInputHdl(pViewSh);
 494                     if (pInputHdl)
 495                         pInputHdl->UpdateRefDevice();
 496                 }
 497                 pFrame = SfxViewFrame::GetNext( *pFrame, this );
 498             }
 499         }
 500     }
 501     else if (nDiffFlags & SfxPrinterChangeFlags::JOBSETUP)
 502     {
 503         SfxPrinter* pOldPrinter = aDocument.GetPrinter();
 504         if (pOldPrinter)
 505         {
 506             pOldPrinter->SetJobSetup( pNewPrinter->GetJobSetup() );
 507
 508             //  #i6706# Call SetPrinter with the old printer again, so the drawing layer
 509             //  RefDevice is set (calling ReformatAllTextObjects and rebuilding charts),
 510             //  because the JobSetup (printer device settings) may affect text layout.
 511             aDocument.SetPrinter( pOldPrinter );
 512             CalcOutputFactor();                         // also with the new settings
 513         }
 514     }
 515
 516     if (nDiffFlags & SfxPrinterChangeFlags::OPTIONS)
 517     {
 518         aDocument.SetPrintOptions();        //! aus neuem Printer ???
 519     }
 520
 521     if (nDiffFlags & (SfxPrinterChangeFlags::CHG_ORIENTATION | SfxPrinterChangeFlags::CHG_SIZE))
 522     {
 523         OUString aStyle = aDocument.GetPageStyle( GetCurTab() );
 524         ScStyleSheetPool* pStPl = aDocument.GetStyleSheetPool();
 525         SfxStyleSheet* pStyleSheet = static_cast<SfxStyleSheet*>(pStPl->Find(aStyle, SfxStyleFamily::Page));
 526         if (pStyleSheet)
 527         {
 528             SfxItemSet& rSet = pStyleSheet->GetItemSet();
 529
 530             if (nDiffFlags & SfxPrinterChangeFlags::CHG_ORIENTATION)
 531             {
 532                 const SvxPageItem& rOldItem = static_cast<const SvxPageItem&>(rSet.Get(ATTR_PAGE));
 533                 bool bWasLand = rOldItem.IsLandscape();
 534                 bool bNewLand = ( pNewPrinter->GetOrientation() == ORIENTATION_LANDSCAPE );
 535                 if (bNewLand != bWasLand)
 536                 {
 537                     SvxPageItem aNewItem( rOldItem );
 538                     aNewItem.SetLandscape( bNewLand );
 539                     rSet.Put( aNewItem );
 540
 541                     //  Groesse umdrehen
 542                     Size aOldSize = static_cast<const SvxSizeItem&>(rSet.Get(ATTR_PAGE_SIZE)).GetSize();
 543                     Size aNewSize(aOldSize.Height(),aOldSize.Width());
 544                     SvxSizeItem aNewSItem(ATTR_PAGE_SIZE,aNewSize);
 545                     rSet.Put( aNewSItem );
 546                 }
 547             }
 548             if (nDiffFlags & SfxPrinterChangeFlags::CHG_SIZE)
 549             {
 550                 SvxSizeItem aPaperSizeItem( ATTR_PAGE_SIZE, SvxPaperInfo::GetPaperSize(pNewPrinter) );
 551                 rSet.Put( aPaperSizeItem );
 552             }
 553         }
 554     }
 555
 556     PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB,PAINT_ALL);
 557
 558     return 0;
 559 }
 560
 561 ScChangeAction* ScDocShell::GetChangeAction( const ScAddress& rPos )
 562 {
 563     ScChangeTrack* pTrack = GetDocument().GetChangeTrack();
 564     if (!pTrack)
 565         return nullptr;
 566
 567     SCTAB nTab = rPos.Tab();
 568
 569     const ScChangeAction* pFound = nullptr;
 570     long nModified = 0;
 571     const ScChangeAction* pAction = pTrack->GetFirst();
 572     while (pAction)
 573     {
 574         ScChangeActionType eType = pAction->GetType();
 575         //! ScViewUtil::IsActionShown( *pAction, *pSettings, *pDoc )...
 576         if ( pAction->IsVisible() && eType != SC_CAT_DELETE_TABS )
 577         {
 578             const ScBigRange& rBig = pAction->GetBigRange();
 579             if ( rBig.aStart.Tab() == nTab )
 580             {
 581                 ScRange aRange = rBig.MakeRange();
 582
 583                 if ( eType == SC_CAT_DELETE_ROWS )
 584                     aRange.aEnd.SetRow( aRange.aStart.Row() );
 585                 else if ( eType == SC_CAT_DELETE_COLS )
 586                     aRange.aEnd.SetCol( aRange.aStart.Col() );
 587
 588                 if ( aRange.In( rPos ) )
 589                 {
 590                     pFound = pAction;       // der letzte gewinnt
 591                     ++nModified;
 592                 }
 593             }
 594             if ( pAction->GetType() == SC_CAT_MOVE )
 595             {
 596                 ScRange aRange =
 597                     static_cast<const ScChangeActionMove*>(pAction)->
 598                     GetFromRange().MakeRange();
 599                 if ( aRange.In( rPos ) )
 600                 {
 601                     pFound = pAction;
 602                     ++nModified;
 603                 }
 604             }
 605         }
 606         pAction = pAction->GetNext();
 607     }
 608
 609     return const_cast<ScChangeAction*>(pFound);
 610 }
 611
 612 void ScDocShell::SetChangeComment( ScChangeAction* pAction, const OUString& rComment )
 613 {
 614     if (pAction)
 615     {
 616         pAction->SetComment( rComment );
 617         //! Undo ???
 618         SetDocumentModified();
 619
 620         //  Dialog-Notify
 621         ScChangeTrack* pTrack = GetDocument().GetChangeTrack();
 622         if (pTrack)
 623         {
 624             sal_uLong nNumber = pAction->GetActionNumber();
 625             pTrack->NotifyModified( SC_CTM_CHANGE, nNumber, nNumber );
 626         }
 627     }
 628 }
 629
 630 void ScDocShell::ExecuteChangeCommentDialog( ScChangeAction* pAction, vcl::Window* pParent, bool bPrevNext)
 631 {
 632     if (!pAction) return;           // ohne Aktion ist nichts..
 633
 634     OUString aComment = pAction->GetComment();
 635     OUString aAuthor = pAction->GetUser();
 636
 637     DateTime aDT = pAction->GetDateTime();
 638     OUString aDate = ScGlobal::pLocaleData->getDate( aDT );
 639     aDate += " ";
 640     aDate += ScGlobal::pLocaleData->getTime( aDT, false );
 641
 642     SfxItemSet aSet( GetPool(),
 643                       SID_ATTR_POSTIT_AUTHOR, SID_ATTR_POSTIT_AUTHOR,
 644                       SID_ATTR_POSTIT_DATE,   SID_ATTR_POSTIT_DATE,
 645                       SID_ATTR_POSTIT_TEXT,   SID_ATTR_POSTIT_TEXT,
 646                       0 );
 647
 648     aSet.Put( SvxPostItTextItem  ( aComment, SID_ATTR_POSTIT_TEXT ) );
 649     aSet.Put( SvxPostItAuthorItem( aAuthor,  SID_ATTR_POSTIT_AUTHOR ) );
 650     aSet.Put( SvxPostItDateItem  ( aDate,    SID_ATTR_POSTIT_DATE ) );
 651
 652     std::unique_ptr<ScRedComDialog> pDlg(new ScRedComDialog( pParent, aSet,this,pAction,bPrevNext));
 653
 654     pDlg->Execute();
 655 }
 656
 657 void ScDocShell::CompareDocument( ScDocument& rOtherDoc )
 658 {
 659     ScChangeTrack* pTrack = aDocument.GetChangeTrack();
 660     if ( pTrack && pTrack->GetFirst() )
 661     {
 662         //! Changes vorhanden -> Nachfrage ob geloescht werden soll
 663     }
 664
 665     aDocument.EndChangeTracking();
 666     aDocument.StartChangeTracking();
 667
 668     OUString aOldUser;
 669     pTrack = aDocument.GetChangeTrack();
 670     if ( pTrack )
 671     {
 672         aOldUser = pTrack->GetUser();
 673
 674         //  check if comparing to same document
 675
 676         OUString aThisFile;
 677         const SfxMedium* pThisMed = GetMedium();
 678         if (pThisMed)
 679             aThisFile = pThisMed->GetName();
 680         OUString aOtherFile;
 681         SfxObjectShell* pOtherSh = rOtherDoc.GetDocumentShell();
 682         if (pOtherSh)
 683         {
 684             const SfxMedium* pOtherMed = pOtherSh->GetMedium();
 685             if (pOtherMed)
 686                 aOtherFile = pOtherMed->GetName();
 687         }
 688         bool bSameDoc = ( aThisFile == aOtherFile && !aThisFile.isEmpty() );
 689         if ( !bSameDoc )
 690         {
 691             //  create change actions from comparing with the name of the user
 692             //  who last saved the document
 693             //  (only if comparing different documents)
 694
 695             using namespace ::com::sun::star;
 696             uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
 697                 GetModel(), uno::UNO_QUERY_THROW);
 698             uno::Reference<document::XDocumentProperties> xDocProps(
 699                 xDPS->getDocumentProperties());
 700             OSL_ENSURE(xDocProps.is(), "no DocumentProperties");
 701             OUString aDocUser = xDocProps->getModifiedBy();
 702
 703             if ( !aDocUser.isEmpty() )
 704                 pTrack->SetUser( aDocUser );
 705         }
 706     }
 707
 708     aDocument.CompareDocument( rOtherDoc );
 709
 710     pTrack = aDocument.GetChangeTrack();
 711     if ( pTrack )
 712         pTrack->SetUser( aOldUser );
 713
 714     PostPaintGridAll();
 715     SetDocumentModified();
 716 }
 717
 718 //              Merge (Aenderungen zusammenfuehren)
 719
 720 static inline bool lcl_Equal( const ScChangeAction* pA, const ScChangeAction* pB, bool bIgnore100Sec )
 721 {
 722     return pA && pB &&
 723         pA->GetActionNumber() == pB->GetActionNumber() &&
 724         pA->GetType()         == pB->GetType() &&
 725         pA->GetUser()         == pB->GetUser() &&
 726         (bIgnore100Sec ?
 727          pA->GetDateTimeUTC().IsEqualIgnoreNanoSec( pB->GetDateTimeUTC() ) :
 728          pA->GetDateTimeUTC() == pB->GetDateTimeUTC());
 729     //  State nicht vergleichen, falls eine alte Aenderung akzeptiert wurde
 730 }
 731
 732 static bool lcl_FindAction( ScDocument* pDoc, const ScChangeAction* pAction, ScDocument* pSearchDoc, const ScChangeAction* pFirstSearchAction, const ScChangeAction* pLastSearchAction, bool bIgnore100Sec )
 733 {
 734     if ( !pDoc || !pAction || !pSearchDoc || !pFirstSearchAction || !pLastSearchAction )
 735     {
 736         return false;
 737     }
 738
 739     sal_uLong nLastSearchAction = pLastSearchAction->GetActionNumber();
 740     const ScChangeAction* pA = pFirstSearchAction;
 741     while ( pA && pA->GetActionNumber() <= nLastSearchAction )
 742     {
 743         if ( pAction->GetType() == pA->GetType() &&
 744              pAction->GetUser() == pA->GetUser() &&
 745              (bIgnore100Sec ?
 746                 pAction->GetDateTimeUTC().IsEqualIgnoreNanoSec( pA->GetDateTimeUTC() ) :
 747                 pAction->GetDateTimeUTC() == pA->GetDateTimeUTC() ) &&
 748              pAction->GetBigRange() == pA->GetBigRange() )
 749         {
 750             OUString aActionDesc;
 751             pAction->GetDescription(aActionDesc, pDoc, true);
 752             OUString aADesc;
 753             pA->GetDescription(aADesc, pSearchDoc, true);
 754             if (aActionDesc.equals(aADesc))
 755             {
 756                 OSL_FAIL( "lcl_FindAction(): found equal action!" );
 757                 return true;
 758             }
 759         }
 760         pA = pA->GetNext();
 761     }
 762
 763     return false;
 764 }
 765
 766 void ScDocShell::MergeDocument( ScDocument& rOtherDoc, bool bShared, bool bCheckDuplicates, sal_uLong nOffset, ScChangeActionMergeMap* pMergeMap, bool bInverseMap )
 767 {
 768     ScTabViewShell* pViewSh = GetBestViewShell( false );    //! Funktionen an die DocShell
 769     if (!pViewSh)
 770         return;
 771
 772     ScChangeTrack* pSourceTrack = rOtherDoc.GetChangeTrack();
 773     if (!pSourceTrack)
 774         return;             //! nichts zu tun - Fehlermeldung?
 775
 776     ScChangeTrack* pThisTrack = aDocument.GetChangeTrack();
 777     if ( !pThisTrack )
 778     {   // anschalten
 779         aDocument.StartChangeTracking();
 780         pThisTrack = aDocument.GetChangeTrack();
 781         OSL_ENSURE(pThisTrack,"ChangeTracking nicht angeschaltet?");
 782         if ( !bShared )
 783         {
 784             // visuelles RedLining einschalten
 785             ScChangeViewSettings aChangeViewSet;
 786             aChangeViewSet.SetShowChanges(true);
 787             aDocument.SetChangeViewSettings(aChangeViewSet);
 788         }
 789     }
 790
 791     // include Nano seconds in compare?
 792     bool bIgnore100Sec = !pSourceTrack->IsTimeNanoSeconds() ||
 793             !pThisTrack->IsTimeNanoSeconds();
 794
 795     //  gemeinsame Ausgangsposition suchen
 796     sal_uLong nFirstNewNumber = 0;
 797     const ScChangeAction* pSourceAction = pSourceTrack->GetFirst();
 798     const ScChangeAction* pThisAction = pThisTrack->GetFirst();
 799     // skip identical actions
 800     while ( lcl_Equal( pSourceAction, pThisAction, bIgnore100Sec ) )
 801     {
 802         nFirstNewNumber = pSourceAction->GetActionNumber() + 1;
 803         pSourceAction = pSourceAction->GetNext();
 804         pThisAction = pThisAction->GetNext();
 805     }
 806     //  pSourceAction und pThisAction zeigen jetzt auf die ersten "eigenen" Aktionen
 807     //  Die gemeinsamen Aktionen davor interessieren ueberhaupt nicht
 808
 809     //! Abfrage, ob die Dokumente vor dem Change-Tracking gleich waren !!!
 810
 811     const ScChangeAction* pFirstMergeAction = pSourceAction;
 812     const ScChangeAction* pFirstSearchAction = pThisAction;
 813
 814     // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
 815     const ScChangeAction* pLastSearchAction = pThisTrack->GetLast();
 816
 817     //  MergeChangeData aus den folgenden Aktionen erzeugen
 818     sal_uLong nNewActionCount = 0;
 819     const ScChangeAction* pCount = pSourceAction;
 820     while ( pCount )
 821     {
 822         if ( bShared || !ScChangeTrack::MergeIgnore( *pCount, nFirstNewNumber ) )
 823             ++nNewActionCount;
 824         pCount = pCount->GetNext();
 825     }
 826     if (!nNewActionCount)
 827         return;             //! nichts zu tun - Fehlermeldung?
 828                             //  ab hier kein return mehr
 829
 830     ScProgress aProgress( this, OUString("..."),
 831                     nNewActionCount, true );
 832
 833     sal_uLong nLastMergeAction = pSourceTrack->GetLast()->GetActionNumber();
 834     // UpdateReference-Undo, gueltige Referenzen fuer den letzten gemeinsamen Zustand
 835     pSourceTrack->MergePrepare( const_cast<ScChangeAction*>(pFirstMergeAction), bShared );
 836
 837     //  MergeChangeData an alle noch folgenden Aktionen in diesem Dokument anpassen
 838     //  -> Referenzen gueltig fuer dieses Dokument
 839     while ( pThisAction )
 840     {
 841         // #i87049# [Collaboration] Conflict between delete row and insert content is not merged correctly
 842         if ( !bShared || !ScChangeTrack::MergeIgnore( *pThisAction, nFirstNewNumber ) )
 843         {
 844             ScChangeActionType eType = pThisAction->GetType();
 845             switch ( eType )
 846             {
 847                 case SC_CAT_INSERT_COLS :
 848                 case SC_CAT_INSERT_ROWS :
 849                 case SC_CAT_INSERT_TABS :
 850                     pSourceTrack->AppendInsert( pThisAction->GetBigRange().MakeRange() );
 851                 break;
 852                 case SC_CAT_DELETE_COLS :
 853                 case SC_CAT_DELETE_ROWS :
 854                 case SC_CAT_DELETE_TABS :
 855                 {
 856                     const ScChangeActionDel* pDel = static_cast<const ScChangeActionDel*>(pThisAction);
 857                     if ( pDel->IsTopDelete() && !pDel->IsTabDeleteCol() )
 858                     {   // deleted Table enthaelt deleted Cols, die nicht
 859                         sal_uLong nStart, nEnd;
 860                         pSourceTrack->AppendDeleteRange(
 861                             pDel->GetOverAllRange().MakeRange(), nullptr, nStart, nEnd );
 862                     }
 863                 }
 864                 break;
 865                 case SC_CAT_MOVE :
 866                 {
 867                     const ScChangeActionMove* pMove = static_cast<const ScChangeActionMove*>(pThisAction);
 868                     pSourceTrack->AppendMove( pMove->GetFromRange().MakeRange(),
 869                         pMove->GetBigRange().MakeRange(), nullptr );
 870                 }
 871                 break;
 872                 default:
 873                 {
 874                     // added to avoid warnings
 875                 }
 876             }
 877         }
 878         pThisAction = pThisAction->GetNext();
 879     }
 880
 881     LockPaint();    // #i73877# no repainting after each action
 882
 883     //  MergeChangeData in das aktuelle Dokument uebernehmen
 884     bool bHasRejected = false;
 885     OUString aOldUser = pThisTrack->GetUser();
 886     pThisTrack->SetUseFixDateTime( true );
 887     ScMarkData& rMarkData = pViewSh->GetViewData().GetMarkData();
 888     ScMarkData aOldMarkData( rMarkData );
 889     pSourceAction = pFirstMergeAction;
 890     while ( pSourceAction && pSourceAction->GetActionNumber() <= nLastMergeAction )
 891     {
 892         bool bMergeAction = false;
 893         if ( bShared )
 894         {
 895             if ( !bCheckDuplicates || !lcl_FindAction( &rOtherDoc, pSourceAction, &aDocument, pFirstSearchAction, pLastSearchAction, bIgnore100Sec ) )
 896             {
 897                 bMergeAction = true;
 898             }
 899         }
 900         else
 901         {
 902             if ( !ScChangeTrack::MergeIgnore( *pSourceAction, nFirstNewNumber ) )
 903             {
 904                 bMergeAction = true;
 905             }
 906         }
 907
 908         if ( bMergeAction )
 909         {
 910             ScChangeActionType eSourceType = pSourceAction->GetType();
 911             if ( !bShared && pSourceAction->IsDeletedIn() )
 912             {
 913                 //! muss hier noch festgestellt werden, ob wirklich in
 914                 //! _diesem_ Dokument geloescht?
 915
 916                 //  liegt in einem Bereich, der in diesem Dokument geloescht wurde
 917                 //  -> wird weggelassen
 918                 //! ??? Loesch-Aktion rueckgaengig machen ???
 919                 //! ??? Aktion irgendwo anders speichern  ???
 920 #if OSL_DEBUG_LEVEL > 0
 921                 OUString aValue;
 922                 if ( eSourceType == SC_CAT_CONTENT )
 923                     static_cast<const ScChangeActionContent*>(pSourceAction)->GetNewString( aValue, &aDocument );
 924                 OStringBuffer aError(OUStringToOString(aValue,
 925                     osl_getThreadTextEncoding()));
 926                 aError.append(" weggelassen");
 927                 OSL_FAIL( aError.getStr() );
 928 #endif
 929             }
 930             else
 931             {
 932                 //! Datum/Autor/Kommentar der Source-Aktion uebernehmen!
 933
 934                 pThisTrack->SetUser( pSourceAction->GetUser() );
 935                 pThisTrack->SetFixDateTimeUTC( pSourceAction->GetDateTimeUTC() );
 936                 sal_uLong nOldActionMax = pThisTrack->GetActionMax();
 937
 938                 bool bExecute = true;
 939                 sal_uLong nReject = pSourceAction->GetRejectAction();
 940                 if ( nReject )
 941                 {
 942                     if ( bShared )
 943                     {
 944                         if ( nReject >= nFirstNewNumber )
 945                         {
 946                             nReject += nOffset;
 947                         }
 948                         ScChangeAction* pOldAction = pThisTrack->GetAction( nReject );
 949                         if ( pOldAction && pOldAction->IsVirgin() )
 950                         {
 951                             pThisTrack->Reject( pOldAction );
 952                             bHasRejected = true;
 953                             bExecute = false;
 954                         }
 955                     }
 956                     else
 957                     {
 958                         //  alte Aktion (aus den gemeinsamen) ablehnen
 959                         ScChangeAction* pOldAction = pThisTrack->GetAction( nReject );
 960                         if (pOldAction && pOldAction->GetState() == SC_CAS_VIRGIN)
 961                         {
 962                             //! was passiert bei Aktionen, die in diesem Dokument accepted worden sind???
 963                             //! Fehlermeldung oder was???
 964                             //! oder Reject-Aenderung normal ausfuehren
 965
 966                             pThisTrack->Reject(pOldAction);
 967                             bHasRejected = true;                // fuer Paint
 968                         }
 969                         bExecute = false;
 970                     }
 971                 }
 972
 973                 if ( bExecute )
 974                 {
 975                     //  normal ausfuehren
 976                     ScRange aSourceRange = pSourceAction->GetBigRange().MakeRange();
 977                     rMarkData.SelectOneTable( aSourceRange.aStart.Tab() );
 978                     switch ( eSourceType )
 979                     {
 980                         case SC_CAT_CONTENT:
 981                         {
 982                             //! Test, ob es ganz unten im Dokument war, dann automatisches
 983                             //! Zeilen-Einfuegen ???
 984
 985                             OSL_ENSURE( aSourceRange.aStart == aSourceRange.aEnd, "huch?" );
 986                             ScAddress aPos = aSourceRange.aStart;
 987                             OUString aValue;
 988                             static_cast<const ScChangeActionContent*>(pSourceAction)->GetNewString( aValue, &aDocument );
 989                             sal_uInt8 eMatrix = MM_NONE;
 990                             const ScCellValue& rCell = static_cast<const ScChangeActionContent*>(pSourceAction)->GetNewCell();
 991                             if (rCell.meType == CELLTYPE_FORMULA)
 992                                 eMatrix = rCell.mpFormula->GetMatrixFlag();
 993                             switch ( eMatrix )
 994                             {
 995                                 case MM_NONE :
 996                                     pViewSh->EnterData( aPos.Col(), aPos.Row(), aPos.Tab(), aValue );
 997                                 break;
 998                                 case MM_FORMULA :
 999                                 {
1000                                     SCCOL nCols;
1001                                     SCROW nRows;
1002                                     rCell.mpFormula->GetMatColsRows(nCols, nRows);
1003                                     aSourceRange.aEnd.SetCol( aPos.Col() + nCols - 1 );
1004                                     aSourceRange.aEnd.SetRow( aPos.Row() + nRows - 1 );
1005                                     aValue = aValue.copy(1, aValue.getLength()-2); // remove the 1st and last characters.
1006                                     GetDocFunc().EnterMatrix( aSourceRange,
1007                                         nullptr, nullptr, aValue, false, false,
1008                                         EMPTY_OUSTRING, formula::FormulaGrammar::GRAM_DEFAULT );
1009                                 }
1010                                 break;
1011                                 case MM_REFERENCE :     // do nothing
1012                                 break;
1013                             }
1014                         }
1015                         break;
1016                         case SC_CAT_INSERT_TABS :
1017                         {
1018                             OUString aName;
1019                             aDocument.CreateValidTabName( aName );
1020                             GetDocFunc().InsertTable( aSourceRange.aStart.Tab(), aName, true, false );
1021                         }
1022                         break;
1023                         case SC_CAT_INSERT_ROWS:
1024                             GetDocFunc().InsertCells( aSourceRange, nullptr, INS_INSROWS_BEFORE, true, false );
1025                         break;
1026                         case SC_CAT_INSERT_COLS:
1027                             GetDocFunc().InsertCells( aSourceRange, nullptr, INS_INSCOLS_BEFORE, true, false );
1028                         break;
1029                         case SC_CAT_DELETE_TABS :
1030                             GetDocFunc().DeleteTable( aSourceRange.aStart.Tab(), true, false );
1031                         break;
1032                         case SC_CAT_DELETE_ROWS:
1033                         {
1034                             const ScChangeActionDel* pDel = static_cast<const ScChangeActionDel*>(pSourceAction);
1035                             if ( pDel->IsTopDelete() )
1036                             {
1037                                 aSourceRange = pDel->GetOverAllRange().MakeRange();
1038                                 GetDocFunc().DeleteCells( aSourceRange, nullptr, DEL_DELROWS, false );
1039
1040                                 // #i101099# [Collaboration] Changes are not correctly shown
1041                                 if ( bShared )
1042                                 {
1043                                     ScChangeAction* pAct = pThisTrack->GetLast();
1044                                     if ( pAct && pAct->GetType() == eSourceType && pAct->IsDeletedIn() && !pSourceAction->IsDeletedIn() )
1045                                     {
1046                                         pAct->RemoveAllDeletedIn();
1047                                     }
1048                                 }
1049                             }
1050                         }
1051                         break;
1052                         case SC_CAT_DELETE_COLS:
1053                         {
1054                             const ScChangeActionDel* pDel = static_cast<const ScChangeActionDel*>(pSourceAction);
1055                             if ( pDel->IsTopDelete() && !pDel->IsTabDeleteCol() )
1056                             {   // deleted Table enthaelt deleted Cols, die nicht
1057                                 aSourceRange = pDel->GetOverAllRange().MakeRange();
1058                                 GetDocFunc().DeleteCells( aSourceRange, nullptr, DEL_DELCOLS, false );
1059                             }
1060                         }
1061                         break;
1062                         case SC_CAT_MOVE :
1063                         {
1064                             const ScChangeActionMove* pMove = static_cast<const ScChangeActionMove*>(pSourceAction);
1065                             ScRange aFromRange( pMove->GetFromRange().MakeRange() );
1066                             GetDocFunc().MoveBlock( aFromRange,
1067                                 aSourceRange.aStart, true, true, false, false );
1068                         }
1069                         break;
1070                         default:
1071                         {
1072                             // added to avoid warnings
1073                         }
1074                     }
1075                 }
1076                 const OUString& rComment = pSourceAction->GetComment();
1077                 if ( !rComment.isEmpty() )
1078                 {
1079                     ScChangeAction* pAct = pThisTrack->GetLast();
1080                     if ( pAct && pAct->GetActionNumber() > nOldActionMax )
1081                         pAct->SetComment( rComment );
1082                     else
1083                         OSL_FAIL( "MergeDocument: wohin mit dem Kommentar?!?" );
1084                 }
1085
1086                 // Referenzen anpassen
1087                 pSourceTrack->MergeOwn( const_cast<ScChangeAction*>(pSourceAction), nFirstNewNumber, bShared );
1088
1089                 // merge action state
1090                 if ( bShared && !pSourceAction->IsRejected() )
1091                 {
1092                     ScChangeAction* pAct = pThisTrack->GetLast();
1093                     if ( pAct && pAct->GetActionNumber() > nOldActionMax )
1094                     {
1095                         ScChangeTrack::MergeActionState( pAct, pSourceAction );
1096                     }
1097                 }
1098
1099                 // fill merge map
1100                 if ( bShared && pMergeMap )
1101                 {
1102                     ScChangeAction* pAct = pThisTrack->GetLast();
1103                     if ( pAct && pAct->GetActionNumber() > nOldActionMax )
1104                     {
1105                         sal_uLong nActionMax = pAct->GetActionNumber();
1106                         sal_uLong nActionCount = nActionMax - nOldActionMax;
1107                         sal_uLong nAction = nActionMax - nActionCount + 1;
1108                         sal_uLong nSourceAction = pSourceAction->GetActionNumber() - nActionCount + 1;
1109                         while ( nAction <= nActionMax )
1110                         {
1111                             if ( bInverseMap )
1112                             {
1113                                 (*pMergeMap)[ nAction++ ] = nSourceAction++;
1114                             }
1115                             else
1116                             {
1117                                 (*pMergeMap)[ nSourceAction++ ] = nAction++;
1118                             }
1119                         }
1120                     }
1121                 }
1122             }
1123             aProgress.SetStateCountDown( --nNewActionCount );
1124         }
1125         pSourceAction = pSourceAction->GetNext();
1126     }
1127
1128     rMarkData = aOldMarkData;
1129     pThisTrack->SetUser(aOldUser);
1130     pThisTrack->SetUseFixDateTime( false );
1131
1132     pSourceTrack->Clear();      //! der ist jetzt verhunzt
1133
1134     if (bHasRejected)
1135         PostPaintGridAll();         // Reject() paintet nicht selber
1136
1137     UnlockPaint();
1138 }
1139
1140 bool ScDocShell::MergeSharedDocument( ScDocShell* pSharedDocShell )
1141 {
1142     if ( !pSharedDocShell )
1143     {
1144         return false;
1145     }
1146
1147     ScChangeTrack* pThisTrack = aDocument.GetChangeTrack();
1148     if ( !pThisTrack )
1149     {
1150         return false;
1151     }
1152
1153     ScDocument& rSharedDoc = pSharedDocShell->GetDocument();
1154     ScChangeTrack* pSharedTrack = rSharedDoc.GetChangeTrack();
1155     if ( !pSharedTrack )
1156     {
1157         return false;
1158     }
1159
1160     // reset show changes
1161     ScChangeViewSettings aChangeViewSet;
1162     aChangeViewSet.SetShowChanges( false );
1163     aDocument.SetChangeViewSettings( aChangeViewSet );
1164
1165     // find first merge action in this document
1166     bool bIgnore100Sec = !pThisTrack->IsTimeNanoSeconds() || !pSharedTrack->IsTimeNanoSeconds();
1167     ScChangeAction* pThisAction = pThisTrack->GetFirst();
1168     ScChangeAction* pSharedAction = pSharedTrack->GetFirst();
1169     while ( lcl_Equal( pThisAction, pSharedAction, bIgnore100Sec ) )
1170     {
1171         pThisAction = pThisAction->GetNext();
1172         pSharedAction = pSharedAction->GetNext();
1173     }
1174
1175     if ( pSharedAction )
1176     {
1177         if ( pThisAction )
1178         {
1179             // merge own changes into shared document
1180             sal_uLong nActStartShared = pSharedAction->GetActionNumber();
1181             sal_uLong nActEndShared = pSharedTrack->GetActionMax();
1182             ScDocument* pTmpDoc = new ScDocument;
1183             for ( sal_Int32 nIndex = 0; nIndex < aDocument.GetTableCount(); ++nIndex )
1184             {
1185                 OUString sTabName;
1186                 pTmpDoc->CreateValidTabName( sTabName );
1187                 pTmpDoc->InsertTab( SC_TAB_APPEND, sTabName );
1188             }
1189             aDocument.GetChangeTrack()->Clone( pTmpDoc );
1190             ScChangeActionMergeMap aOwnInverseMergeMap;
1191             pSharedDocShell->MergeDocument( *pTmpDoc, true, true, 0, &aOwnInverseMergeMap, true );
1192             delete pTmpDoc;
1193             sal_uLong nActStartOwn = nActEndShared + 1;
1194             sal_uLong nActEndOwn = pSharedTrack->GetActionMax();
1195
1196             // find conflicts
1197             ScConflictsList aConflictsList;
1198             ScConflictsFinder aFinder( pSharedTrack, nActStartShared, nActEndShared, nActStartOwn, nActEndOwn, aConflictsList );
1199             if ( aFinder.Find() )
1200             {
1201                 ScConflictsListHelper::TransformConflictsList( aConflictsList, nullptr, &aOwnInverseMergeMap );
1202                 bool bLoop = true;
1203                 while ( bLoop )
1204                 {
1205                     bLoop = false;
1206                     ScopedVclPtrInstance< ScConflictsDlg > aDlg( GetActiveDialogParent(), GetViewData(), &rSharedDoc, aConflictsList );
1207                     if ( aDlg->Execute() == RET_CANCEL )
1208                     {
1209                         ScopedVclPtrInstance<QueryBox> aBox( GetActiveDialogParent(), WinBits( WB_YES_NO | WB_DEF_YES ),
1210                             ScGlobal::GetRscString( STR_DOC_WILLNOTBESAVED ) );
1211                         if ( aBox->Execute() == RET_YES )
1212                         {
1213                             return false;
1214                         }
1215                         else
1216                         {
1217                             bLoop = true;
1218                         }
1219                     }
1220                 }
1221             }
1222
1223             // undo own changes in shared document
1224             pSharedTrack->Undo( nActStartOwn, nActEndOwn );
1225
1226             // clone change track for merging into own document
1227             pTmpDoc = new ScDocument;
1228             for ( sal_Int32 nIndex = 0; nIndex < aDocument.GetTableCount(); ++nIndex )
1229             {
1230                 OUString sTabName;
1231                 pTmpDoc->CreateValidTabName( sTabName );
1232                 pTmpDoc->InsertTab( SC_TAB_APPEND, sTabName );
1233             }
1234             pThisTrack->Clone( pTmpDoc );
1235
1236             // undo own changes since last save in own document
1237             sal_uLong nStartShared = pThisAction->GetActionNumber();
1238             ScChangeAction* pAction = pThisTrack->GetLast();
1239             while ( pAction && pAction->GetActionNumber() >= nStartShared )
1240             {
1241                 pThisTrack->Reject( pAction, true );
1242                 pAction = pAction->GetPrev();
1243             }
1244
1245             // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
1246             pThisTrack->Undo( nStartShared, pThisTrack->GetActionMax(), true );
1247
1248             // merge shared changes into own document
1249             ScChangeActionMergeMap aSharedMergeMap;
1250             MergeDocument( rSharedDoc, true, true, 0, &aSharedMergeMap );
1251             sal_uLong nEndShared = pThisTrack->GetActionMax();
1252
1253             // resolve conflicts for shared non-content actions
1254             if ( !aConflictsList.empty() )
1255             {
1256                 ScConflictsListHelper::TransformConflictsList( aConflictsList, &aSharedMergeMap, nullptr );
1257                 ScConflictsResolver aResolver( pThisTrack, aConflictsList );
1258                 pAction = pThisTrack->GetAction( nEndShared );
1259                 while ( pAction && pAction->GetActionNumber() >= nStartShared )
1260                 {
1261                     aResolver.HandleAction( pAction, true /*bIsSharedAction*/,
1262                         false /*bHandleContentAction*/, true /*bHandleNonContentAction*/ );
1263                     pAction = pAction->GetPrev();
1264                 }
1265             }
1266             nEndShared = pThisTrack->GetActionMax();
1267
1268             // only show changes from shared document
1269             aChangeViewSet.SetShowChanges( true );
1270             aChangeViewSet.SetShowAccepted( true );
1271             aChangeViewSet.SetHasActionRange();
1272             aChangeViewSet.SetTheActionRange( nStartShared, nEndShared );
1273             aDocument.SetChangeViewSettings( aChangeViewSet );
1274
1275             // merge own changes back into own document
1276             sal_uLong nStartOwn = nEndShared + 1;
1277             ScChangeActionMergeMap aOwnMergeMap;
1278             MergeDocument( *pTmpDoc, true, true, nEndShared - nStartShared + 1, &aOwnMergeMap );
1279             delete pTmpDoc;
1280             sal_uLong nEndOwn = pThisTrack->GetActionMax();
1281
1282             // resolve conflicts for shared content actions and own actions
1283             if ( !aConflictsList.empty() )
1284             {
1285                 ScConflictsListHelper::TransformConflictsList( aConflictsList, nullptr, &aOwnMergeMap );
1286                 ScConflictsResolver aResolver( pThisTrack, aConflictsList );
1287                 pAction = pThisTrack->GetAction( nEndShared );
1288                 while ( pAction && pAction->GetActionNumber() >= nStartShared )
1289                 {
1290                     aResolver.HandleAction( pAction, true /*bIsSharedAction*/,
1291                         true /*bHandleContentAction*/, false /*bHandleNonContentAction*/ );
1292                     pAction = pAction->GetPrev();
1293                 }
1294
1295                 pAction = pThisTrack->GetAction( nEndOwn );
1296                 while ( pAction && pAction->GetActionNumber() >= nStartOwn )
1297                 {
1298                     aResolver.HandleAction( pAction, false /*bIsSharedAction*/,
1299                         true /*bHandleContentAction*/, true /*bHandleNonContentAction*/ );
1300                     pAction = pAction->GetPrev();
1301                 }
1302             }
1303         }
1304         else
1305         {
1306             // merge shared changes into own document
1307             sal_uLong nStartShared = pThisTrack->GetActionMax() + 1;
1308             MergeDocument( rSharedDoc, true, true );
1309             sal_uLong nEndShared = pThisTrack->GetActionMax();
1310
1311             // only show changes from shared document
1312             aChangeViewSet.SetShowChanges( true );
1313             aChangeViewSet.SetShowAccepted( true );
1314             aChangeViewSet.SetHasActionRange();
1315             aChangeViewSet.SetTheActionRange( nStartShared, nEndShared );
1316             aDocument.SetChangeViewSettings( aChangeViewSet );
1317         }
1318
1319         // update view
1320         PostPaintExtras();
1321         PostPaintGridAll();
1322
1323         ScopedVclPtrInstance< InfoBox > aInfoBox( GetActiveDialogParent(), ScGlobal::GetRscString( STR_DOC_UPDATED ) );
1324         aInfoBox->Execute();
1325     }
1326
1327     return ( pThisAction != nullptr );
1328 }
1329
1330 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */