sc/source/ui/undo/undocell.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 <undocell.hxx>
  21
  22 #include <scitems.hxx>
  23 #include <editeng/editobj.hxx>
  24 #include <sfx2/app.hxx>
  25 #include <svx/svdocapt.hxx> //
  26 #include <comphelper/lok.hxx>
  27 #include <osl/diagnose.h>
  28
  29 #include <document.hxx>
  30 #include <patattr.hxx>
  31 #include <docsh.hxx>
  32 #include <tabvwsh.hxx>
  33 #include <globstr.hrc>
  34 #include <scresid.hxx>
  35 #include <global.hxx>
  36 #include <formulacell.hxx>
  37 #include <target.hxx>
  38 #include <undoolk.hxx>
  39 #include <detdata.hxx>
  40 #include <stlpool.hxx>
  41 #include <printfun.hxx>
  42 #include <rangenam.hxx>
  43 #include <chgtrack.hxx>
  44 #include <stringutil.hxx>
  45 #include <utility>
  46
  47 namespace HelperNotifyChanges
  48 {
  49     static void NotifyIfChangesListeners(const ScDocShell& rDocShell, const ScAddress &rPos,
  50         const ScUndoEnterData::ValuesType &rOldValues, const OUString& rType = u"cell-change"_ustr)
  51     {
  52         ScModelObj* pModelObj = rDocShell.GetModel();
  53         if (pModelObj)
  54         {
  55             ScRangeList aChangeRanges;
  56
  57             for (const auto & rOldValue : rOldValues)
  58             {
  59                 aChangeRanges.push_back( ScRange(rPos.Col(), rPos.Row(), rOldValue.mnTab));
  60             }
  61
  62             if (getMustPropagateChangesModel(pModelObj))
  63                 Notify(*pModelObj, aChangeRanges, rType);
  64             if (pModelObj) // possibly need to invalidate getCellArea results
  65             {
  66                 Notify(*pModelObj, aChangeRanges, isDataAreaInvalidateType(rType)
  67                     ? u"data-area-invalidate"_ustr : u"data-area-extend"_ustr);
  68             }
  69         }
  70     }
  71 }
  72
  73
  74 ScUndoCursorAttr::ScUndoCursorAttr( ScDocShell* pNewDocShell,
  75             SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
  76             const ScPatternAttr* pOldPat, const ScPatternAttr* pNewPat,
  77             const ScPatternAttr* pApplyPat ) :
  78     ScSimpleUndo( pNewDocShell ),
  79     nCol( nNewCol ),
  80     nRow( nNewRow ),
  81     nTab( nNewTab ),
  82     aOldPattern( pOldPat ),
  83     aNewPattern( pNewPat ),
  84     aApplyPattern( pApplyPat ),
  85     pOldEditData( static_cast<EditTextObject*>(nullptr) ),
  86     pNewEditData( static_cast<EditTextObject*>(nullptr) )
  87 {
  88 }
  89
  90 ScUndoCursorAttr::~ScUndoCursorAttr()
  91 {
  92 }
  93
  94 OUString ScUndoCursorAttr::GetComment() const
  95 {
  96     //! own text for automatic attribution
  97     return ScResId( STR_UNDO_CURSORATTR ); // "Attribute"
  98 }
  99
 100 void ScUndoCursorAttr::SetEditData( std::unique_ptr<EditTextObject> pOld, std::unique_ptr<EditTextObject> pNew )
 101 {
 102     pOldEditData = std::move(pOld);
 103     pNewEditData = std::move(pNew);
 104 }
 105
 106 void ScUndoCursorAttr::DoChange( const CellAttributeHolder& rWhichPattern, const std::unique_ptr<EditTextObject>& pEditData ) const
 107 {
 108     ScDocument& rDoc = pDocShell->GetDocument();
 109     ScAddress aPos(nCol, nRow, nTab);
 110     rDoc.SetPattern( nCol, nRow, nTab, rWhichPattern );
 111
 112     if (rDoc.GetCellType(aPos) == CELLTYPE_EDIT && pEditData)
 113         rDoc.SetEditText(aPos, *pEditData, nullptr);
 114
 115     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 116     if (pViewShell)
 117     {
 118         pViewShell->SetTabNo( nTab );
 119         pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, false, false );
 120         pViewShell->AdjustBlockHeight();
 121     }
 122
 123     const SfxItemSet& rApplySet = aApplyPattern.getScPatternAttr()->GetItemSet();
 124     bool bPaintExt = ( rApplySet.GetItemState( ATTR_SHADOW ) != SfxItemState::DEFAULT ||
 125                        rApplySet.GetItemState( ATTR_CONDITIONAL ) != SfxItemState::DEFAULT );
 126     bool bPaintRows = ( rApplySet.GetItemState( ATTR_HOR_JUSTIFY ) != SfxItemState::DEFAULT );
 127
 128     sal_uInt16 nFlags = SC_PF_TESTMERGE;
 129     if (bPaintExt)
 130         nFlags |= SC_PF_LINES;
 131     if (bPaintRows)
 132         nFlags |= SC_PF_WHOLEROWS;
 133     pDocShell->PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PaintPartFlags::Grid, nFlags );
 134 }
 135
 136 void ScUndoCursorAttr::Undo()
 137 {
 138     BeginUndo();
 139     DoChange(aOldPattern, pOldEditData);
 140     EndUndo();
 141 }
 142
 143 void ScUndoCursorAttr::Redo()
 144 {
 145     BeginRedo();
 146     DoChange(aNewPattern, pNewEditData);
 147     EndRedo();
 148 }
 149
 150 void ScUndoCursorAttr::Repeat(SfxRepeatTarget& rTarget)
 151 {
 152     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 153         pViewTarget->GetViewShell()->ApplySelectionPattern( *aApplyPattern.getScPatternAttr() );
 154 }
 155
 156 bool ScUndoCursorAttr::CanRepeat(SfxRepeatTarget& rTarget) const
 157 {
 158     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 159 }
 160
 161 ScUndoEnterData::Value::Value() : mnTab(-1), mbHasFormat(false), mnFormat(0) {}
 162
 163 ScUndoEnterData::ScUndoEnterData(
 164     ScDocShell* pNewDocShell, const ScAddress& rPos, ValuesType& rOldValues,
 165     OUString aNewStr, std::unique_ptr<EditTextObject> pObj ) :
 166     ScSimpleUndo( pNewDocShell ),
 167     maNewString(std::move(aNewStr)),
 168     mpNewEditData(std::move(pObj)),
 169     mnEndChangeAction(0),
 170     maPos(rPos)
 171 {
 172     maOldValues.swap(rOldValues);
 173
 174     SetChangeTrack();
 175 }
 176
 177 OUString ScUndoEnterData::GetComment() const
 178 {
 179     return ScResId( STR_UNDO_ENTERDATA ); // "Input"
 180 }
 181
 182 void ScUndoEnterData::DoChange() const
 183 {
 184     // only when needed (old or new Edit cell, or Attribute)?
 185     bool bHeightChanged = false;
 186     for (const auto & i : maOldValues)
 187     {
 188         if (pDocShell->AdjustRowHeight(maPos.Row(), maPos.Row(), i.mnTab))
 189             bHeightChanged = true;
 190     }
 191
 192     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 193     if (pViewShell)
 194     {
 195         if (comphelper::LibreOfficeKit::isActive() && bHeightChanged)
 196         {
 197             ScTabViewShell::notifyAllViewsHeaderInvalidation(pViewShell, ROW_HEADER, maPos.Tab());
 198             ScTabViewShell::notifyAllViewsSheetGeomInvalidation(
 199                 pViewShell, false /* bColumns */, true /* bRows */, true /* bSizes*/,
 200                 false /* bHidden */, false /* bFiltered */, false /* bGroups */, maPos.Tab());
 201         }
 202         pViewShell->SetTabNo(maPos.Tab());
 203         pViewShell->MoveCursorAbs(maPos.Col(), maPos.Row(), SC_FOLLOW_JUMP, false, false);
 204     }
 205
 206     pDocShell->PostDataChanged();
 207 }
 208
 209 void ScUndoEnterData::SetChangeTrack()
 210 {
 211     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 212     if ( pChangeTrack )
 213     {
 214         mnEndChangeAction = pChangeTrack->GetActionMax() + 1;
 215         ScAddress aPos(maPos);
 216         for (const Value & rOldValue : maOldValues)
 217         {
 218             aPos.SetTab(rOldValue.mnTab);
 219             sal_uLong nFormat = 0;
 220             if (rOldValue.mbHasFormat)
 221                 nFormat = rOldValue.mnFormat;
 222             pChangeTrack->AppendContent(aPos, rOldValue.maCell, nFormat);
 223         }
 224         if ( mnEndChangeAction > pChangeTrack->GetActionMax() )
 225             mnEndChangeAction = 0;       // nothing is appended
 226     }
 227     else
 228         mnEndChangeAction = 0;
 229 }
 230
 231 void ScUndoEnterData::Undo()
 232 {
 233     BeginUndo();
 234
 235     ScDocument& rDoc = pDocShell->GetDocument();
 236     for (const Value & rVal : maOldValues)
 237     {
 238         ScCellValue aNewCell;
 239         aNewCell.assign(rVal.maCell, rDoc, ScCloneFlags::StartListening);
 240         ScAddress aPos = maPos;
 241         aPos.SetTab(rVal.mnTab);
 242         aNewCell.release(rDoc, aPos);
 243
 244         if (rVal.mbHasFormat)
 245             rDoc.ApplyAttr(maPos.Col(), maPos.Row(), rVal.mnTab,
 246                             SfxUInt32Item(ATTR_VALUE_FORMAT, rVal.mnFormat));
 247         else
 248         {
 249             ScPatternAttr* pPattern(new ScPatternAttr(*rDoc.GetPattern(maPos.Col(), maPos.Row(), rVal.mnTab)));
 250             pPattern->GetItemSet().ClearItem( ATTR_VALUE_FORMAT );
 251             rDoc.SetPattern(maPos.Col(), maPos.Row(), rVal.mnTab, CellAttributeHolder(pPattern, true));
 252         }
 253         pDocShell->PostPaintCell(maPos.Col(), maPos.Row(), rVal.mnTab);
 254     }
 255
 256     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 257     size_t nCount = maOldValues.size();
 258     if ( pChangeTrack && mnEndChangeAction >= sal::static_int_cast<sal_uLong>(nCount) )
 259         pChangeTrack->Undo( mnEndChangeAction - nCount + 1, mnEndChangeAction );
 260
 261     DoChange();
 262     EndUndo();
 263
 264     HelperNotifyChanges::NotifyIfChangesListeners(*pDocShell, maPos, maOldValues, u"undo"_ustr);
 265 }
 266
 267 void ScUndoEnterData::Redo()
 268 {
 269     BeginRedo();
 270
 271     ScDocument& rDoc = pDocShell->GetDocument();
 272     for (const Value & rOldValue : maOldValues)
 273     {
 274         SCTAB nTab = rOldValue.mnTab;
 275         if (mpNewEditData)
 276         {
 277             ScAddress aPos = maPos;
 278             aPos.SetTab(nTab);
 279             // edit text will be cloned.
 280             rDoc.SetEditText(aPos, *mpNewEditData, nullptr);
 281         }
 282         else
 283             rDoc.SetString(maPos.Col(), maPos.Row(), nTab, maNewString);
 284
 285         pDocShell->PostPaintCell(maPos.Col(), maPos.Row(), nTab);
 286     }
 287
 288     SetChangeTrack();
 289
 290     DoChange();
 291     EndRedo();
 292
 293     HelperNotifyChanges::NotifyIfChangesListeners(*pDocShell, maPos, maOldValues, u"redo"_ustr);
 294 }
 295
 296 void ScUndoEnterData::Repeat(SfxRepeatTarget& rTarget)
 297 {
 298     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 299     {
 300         OUString aTemp = maNewString;
 301         pViewTarget->GetViewShell()->EnterDataAtCursor( aTemp );
 302     }
 303 }
 304
 305 bool ScUndoEnterData::CanRepeat(SfxRepeatTarget& rTarget) const
 306 {
 307     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 308 }
 309
 310 ScUndoEnterValue::ScUndoEnterValue(
 311     ScDocShell* pNewDocShell, const ScAddress& rNewPos,
 312     ScCellValue aUndoCell, double nVal ) :
 313     ScSimpleUndo( pNewDocShell ),
 314     aPos        ( rNewPos ),
 315     maOldCell(std::move(aUndoCell)),
 316     nValue      ( nVal )
 317 {
 318     SetChangeTrack();
 319 }
 320
 321 ScUndoEnterValue::~ScUndoEnterValue()
 322 {
 323 }
 324
 325 OUString ScUndoEnterValue::GetComment() const
 326 {
 327     return ScResId( STR_UNDO_ENTERDATA ); // "Input"
 328 }
 329
 330 void ScUndoEnterValue::SetChangeTrack()
 331 {
 332     ScDocument& rDoc = pDocShell->GetDocument();
 333     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 334     if ( pChangeTrack )
 335     {
 336         nEndChangeAction = pChangeTrack->GetActionMax() + 1;
 337         pChangeTrack->AppendContent(aPos, maOldCell);
 338         if ( nEndChangeAction > pChangeTrack->GetActionMax() )
 339             nEndChangeAction = 0;       // nothing is appended
 340     }
 341     else
 342         nEndChangeAction = 0;
 343 }
 344
 345 void ScUndoEnterValue::Undo()
 346 {
 347     BeginUndo();
 348
 349     ScDocument& rDoc = pDocShell->GetDocument();
 350     ScCellValue aNewCell;
 351     aNewCell.assign(maOldCell, rDoc, ScCloneFlags::StartListening);
 352     aNewCell.release(rDoc, aPos);
 353
 354     pDocShell->PostPaintCell( aPos );
 355
 356     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 357     if ( pChangeTrack )
 358         pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
 359
 360     EndUndo();
 361 }
 362
 363 void ScUndoEnterValue::Redo()
 364 {
 365     BeginRedo();
 366
 367     ScDocument& rDoc = pDocShell->GetDocument();
 368     rDoc.SetValue( aPos.Col(), aPos.Row(), aPos.Tab(), nValue );
 369     pDocShell->PostPaintCell( aPos );
 370
 371     SetChangeTrack();
 372
 373     EndRedo();
 374 }
 375
 376 void ScUndoEnterValue::Repeat(SfxRepeatTarget& /* rTarget */)
 377 {
 378     // makes no sense
 379 }
 380
 381 bool ScUndoEnterValue::CanRepeat(SfxRepeatTarget& /* rTarget */) const
 382 {
 383     return false;
 384 }
 385
 386 ScUndoSetCell::ScUndoSetCell( ScDocShell* pDocSh, const ScAddress& rPos, ScCellValue aOldVal, ScCellValue aNewVal ) :
 387     ScSimpleUndo(pDocSh), maPos(rPos), maOldValue(std::move(aOldVal)), maNewValue(std::move(aNewVal)), mnEndChangeAction(0)
 388 {
 389     SetChangeTrack();
 390 }
 391
 392 ScUndoSetCell::~ScUndoSetCell() {}
 393
 394 void ScUndoSetCell::Undo()
 395 {
 396     BeginUndo();
 397     SetValue(maOldValue);
 398     MoveCursorToCell();
 399     pDocShell->PostPaintCell(maPos);
 400
 401     ScDocument& rDoc = pDocShell->GetDocument();
 402     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 403     if (pChangeTrack)
 404         pChangeTrack->Undo(mnEndChangeAction, mnEndChangeAction);
 405
 406     EndUndo();
 407 }
 408
 409 void ScUndoSetCell::Redo()
 410 {
 411     BeginRedo();
 412     SetValue(maNewValue);
 413     MoveCursorToCell();
 414     pDocShell->PostPaintCell(maPos);
 415     SetChangeTrack();
 416     EndRedo();
 417 }
 418
 419 void ScUndoSetCell::Repeat( SfxRepeatTarget& /*rTarget*/ )
 420 {
 421     // Makes no sense.
 422 }
 423
 424 bool ScUndoSetCell::CanRepeat( SfxRepeatTarget& /*rTarget*/ ) const
 425 {
 426     return false;
 427 }
 428
 429 OUString ScUndoSetCell::GetComment() const
 430 {
 431     return ScResId(STR_UNDO_ENTERDATA); // "Input"
 432 }
 433
 434 void ScUndoSetCell::SetChangeTrack()
 435 {
 436     ScDocument& rDoc = pDocShell->GetDocument();
 437     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 438     if (pChangeTrack)
 439     {
 440         mnEndChangeAction = pChangeTrack->GetActionMax() + 1;
 441
 442         pChangeTrack->AppendContent(maPos, maOldValue);
 443
 444         if (mnEndChangeAction > pChangeTrack->GetActionMax())
 445             mnEndChangeAction = 0;       // Nothing is appended
 446     }
 447     else
 448         mnEndChangeAction = 0;
 449 }
 450
 451 void ScUndoSetCell::SetValue( const ScCellValue& rVal )
 452 {
 453     ScDocument& rDoc = pDocShell->GetDocument();
 454
 455     switch (rVal.getType())
 456     {
 457         case CELLTYPE_NONE:
 458             // empty cell
 459             rDoc.SetEmptyCell(maPos);
 460         break;
 461         case CELLTYPE_VALUE:
 462             rDoc.SetValue(maPos, rVal.getDouble());
 463         break;
 464         case CELLTYPE_STRING:
 465         {
 466             ScSetStringParam aParam;
 467             aParam.setTextInput();
 468             // Undo only cell content, without setting any number format.
 469             aParam.meSetTextNumFormat = ScSetStringParam::Keep;
 470             rDoc.SetString(maPos, rVal.getSharedString()->getString(), &aParam);
 471         }
 472         break;
 473         case CELLTYPE_EDIT:
 474             rDoc.SetEditText(maPos, rVal.getEditText()->Clone());
 475         break;
 476         case CELLTYPE_FORMULA:
 477             rDoc.SetFormulaCell(maPos, rVal.getFormula()->Clone());
 478         break;
 479         default:
 480             ;
 481     }
 482 }
 483
 484 void ScUndoSetCell::MoveCursorToCell()
 485 {
 486     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 487     if ( pViewShell )
 488     {
 489         pViewShell->SetTabNo( maPos.Tab() );
 490         pViewShell->MoveCursorAbs( maPos.Col(), maPos.Row(), SC_FOLLOW_JUMP, false, false );
 491     }
 492 }
 493
 494 ScUndoPageBreak::ScUndoPageBreak( ScDocShell* pNewDocShell,
 495             SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
 496             bool bNewColumn, bool bNewInsert ) :
 497     ScSimpleUndo( pNewDocShell ),
 498     nCol( nNewCol ),
 499     nRow( nNewRow ),
 500     nTab( nNewTab ),
 501     bColumn( bNewColumn ),
 502     bInsert( bNewInsert )
 503 {
 504 }
 505
 506 ScUndoPageBreak::~ScUndoPageBreak()
 507 {
 508 }
 509
 510 OUString ScUndoPageBreak::GetComment() const
 511 {
 512     //"Column break" | "Row break"  "insert" | "delete"
 513     return bColumn ?
 514         ( bInsert ?
 515             ScResId( STR_UNDO_INSCOLBREAK ) :
 516             ScResId( STR_UNDO_DELCOLBREAK )
 517         ) :
 518         ( bInsert ?
 519             ScResId( STR_UNDO_INSROWBREAK ) :
 520             ScResId( STR_UNDO_DELROWBREAK )
 521         );
 522 }
 523
 524 void ScUndoPageBreak::DoChange( bool bInsertP ) const
 525 {
 526     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 527
 528     if (pViewShell)
 529     {
 530         pViewShell->SetTabNo( nTab );
 531         pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, false, false );
 532
 533         if (bInsertP)
 534             pViewShell->InsertPageBreak(bColumn, false);
 535         else
 536             pViewShell->DeletePageBreak(bColumn, false);
 537
 538         pDocShell->GetDocument().InvalidatePageBreaks(nTab);
 539     }
 540 }
 541
 542 void ScUndoPageBreak::Undo()
 543 {
 544     BeginUndo();
 545     DoChange(!bInsert);
 546     EndUndo();
 547 }
 548
 549 void ScUndoPageBreak::Redo()
 550 {
 551     BeginRedo();
 552     DoChange(bInsert);
 553     EndRedo();
 554 }
 555
 556 void ScUndoPageBreak::Repeat(SfxRepeatTarget& rTarget)
 557 {
 558     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 559     {
 560         ScTabViewShell& rViewShell = *pViewTarget->GetViewShell();
 561
 562         if (bInsert)
 563             rViewShell.InsertPageBreak(bColumn);
 564         else
 565             rViewShell.DeletePageBreak(bColumn);
 566     }
 567 }
 568
 569 bool ScUndoPageBreak::CanRepeat(SfxRepeatTarget& rTarget) const
 570 {
 571     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 572 }
 573
 574 ScUndoPrintZoom::ScUndoPrintZoom( ScDocShell* pNewDocShell,
 575             SCTAB nT, sal_uInt16 nOS, sal_uInt16 nOP, sal_uInt16 nNS, sal_uInt16 nNP ) :
 576     ScSimpleUndo( pNewDocShell ),
 577     nTab( nT ),
 578     nOldScale( nOS ),
 579     nOldPages( nOP ),
 580     nNewScale( nNS ),
 581     nNewPages( nNP )
 582 {
 583 }
 584
 585 ScUndoPrintZoom::~ScUndoPrintZoom()
 586 {
 587 }
 588
 589 OUString ScUndoPrintZoom::GetComment() const
 590 {
 591     return ScResId( STR_UNDO_PRINTSCALE );
 592 }
 593
 594 void ScUndoPrintZoom::DoChange( bool bUndo )
 595 {
 596     sal_uInt16 nScale = bUndo ? nOldScale : nNewScale;
 597     sal_uInt16 nPages = bUndo ? nOldPages : nNewPages;
 598
 599     ScDocument& rDoc = pDocShell->GetDocument();
 600     OUString aStyleName = rDoc.GetPageStyle( nTab );
 601     ScStyleSheetPool* pStylePool = rDoc.GetStyleSheetPool();
 602     SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aStyleName, SfxStyleFamily::Page );
 603     OSL_ENSURE( pStyleSheet, "PageStyle not found" );
 604     if ( pStyleSheet )
 605     {
 606         SfxItemSet& rSet = pStyleSheet->GetItemSet();
 607         rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALE, nScale ) );
 608         rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALETOPAGES, nPages ) );
 609
 610         ScPrintFunc aPrintFunc( pDocShell, pDocShell->GetPrinter(), nTab );
 611         aPrintFunc.UpdatePages();
 612     }
 613 }
 614
 615 void ScUndoPrintZoom::Undo()
 616 {
 617     BeginUndo();
 618     DoChange(true);
 619     EndUndo();
 620 }
 621
 622 void ScUndoPrintZoom::Redo()
 623 {
 624     BeginRedo();
 625     DoChange(false);
 626     EndRedo();
 627 }
 628
 629 void ScUndoPrintZoom::Repeat(SfxRepeatTarget& rTarget)
 630 {
 631     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 632     {
 633         ScTabViewShell& rViewShell = *pViewTarget->GetViewShell();
 634         ScViewData& rViewData = rViewShell.GetViewData();
 635         rViewData.GetDocShell()->SetPrintZoom( rViewData.GetTabNo(), nNewScale, nNewPages );
 636     }
 637 }
 638
 639 bool ScUndoPrintZoom::CanRepeat(SfxRepeatTarget& rTarget) const
 640 {
 641     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 642 }
 643
 644 ScUndoThesaurus::ScUndoThesaurus(
 645     ScDocShell* pNewDocShell, SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
 646     ScCellValue aOldText, ScCellValue aNewText ) :
 647     ScSimpleUndo( pNewDocShell ),
 648     nCol( nNewCol ),
 649     nRow( nNewRow ),
 650     nTab( nNewTab ),
 651     maOldText(std::move(aOldText)),
 652     maNewText(std::move(aNewText))
 653 {
 654     SetChangeTrack(maOldText);
 655 }
 656
 657 ScUndoThesaurus::~ScUndoThesaurus() {}
 658
 659 OUString ScUndoThesaurus::GetComment() const
 660 {
 661     return ScResId( STR_UNDO_THESAURUS );    // "Thesaurus"
 662 }
 663
 664 void ScUndoThesaurus::SetChangeTrack( const ScCellValue& rOldCell )
 665 {
 666     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 667     if ( pChangeTrack )
 668     {
 669         nEndChangeAction = pChangeTrack->GetActionMax() + 1;
 670         pChangeTrack->AppendContent(ScAddress(nCol, nRow, nTab), rOldCell);
 671         if ( nEndChangeAction > pChangeTrack->GetActionMax() )
 672             nEndChangeAction = 0;       // nothing is appended
 673     }
 674     else
 675         nEndChangeAction = 0;
 676 }
 677
 678 void ScUndoThesaurus::DoChange( bool bUndo, const ScCellValue& rText )
 679 {
 680     ScDocument& rDoc = pDocShell->GetDocument();
 681
 682     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 683     if (pViewShell)
 684     {
 685         pViewShell->SetTabNo( nTab );
 686         pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, false, false );
 687     }
 688
 689     ScAddress aPos(nCol, nRow, nTab);
 690     rText.commit(rDoc, aPos);
 691     if (!bUndo)
 692         SetChangeTrack(maOldText);
 693
 694     pDocShell->PostPaintCell( nCol, nRow, nTab );
 695 }
 696
 697 void ScUndoThesaurus::Undo()
 698 {
 699     BeginUndo();
 700     DoChange(true, maOldText);
 701     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 702     if ( pChangeTrack )
 703         pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
 704     EndUndo();
 705 }
 706
 707 void ScUndoThesaurus::Redo()
 708 {
 709     BeginRedo();
 710     DoChange(false, maNewText);
 711     EndRedo();
 712 }
 713
 714 void ScUndoThesaurus::Repeat(SfxRepeatTarget& rTarget)
 715 {
 716     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 717         pViewTarget->GetViewShell()->DoThesaurus();
 718 }
 719
 720 bool ScUndoThesaurus::CanRepeat(SfxRepeatTarget& rTarget) const
 721 {
 722     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 723 }
 724
 725
 726 ScUndoReplaceNote::ScUndoReplaceNote( ScDocShell& rDocShell, const ScAddress& rPos,
 727         const ScNoteData& rNoteData, bool bInsert, std::unique_ptr<SdrUndoAction> pDrawUndo ) :
 728     ScSimpleUndo( &rDocShell ),
 729     maPos( rPos ),
 730     mpDrawUndo( std::move(pDrawUndo) )
 731 {
 732     OSL_ENSURE( rNoteData.mxCaption, "ScUndoReplaceNote::ScUndoReplaceNote - missing note caption" );
 733     if (bInsert)
 734     {
 735         maNewData = rNoteData;
 736     }
 737     else
 738     {
 739         maOldData = rNoteData;
 740     }
 741 }
 742
 743 ScUndoReplaceNote::ScUndoReplaceNote( ScDocShell& rDocShell, const ScAddress& rPos,
 744         ScNoteData aOldData, ScNoteData aNewData, std::unique_ptr<SdrUndoAction> pDrawUndo ) :
 745     ScSimpleUndo( &rDocShell ),
 746     maPos( rPos ),
 747     maOldData(std::move( aOldData )),
 748     maNewData(std::move( aNewData )),
 749     mpDrawUndo( std::move(pDrawUndo) )
 750 {
 751     OSL_ENSURE( maOldData.mxCaption || maNewData.mxCaption, "ScUndoReplaceNote::ScUndoReplaceNote - missing note captions" );
 752     OSL_ENSURE( !maOldData.mxInitData && !maNewData.mxInitData, "ScUndoReplaceNote::ScUndoReplaceNote - unexpected uninitialized note" );
 753 }
 754
 755 ScUndoReplaceNote::~ScUndoReplaceNote()
 756 {
 757     mpDrawUndo.reset();
 758 }
 759
 760 void ScUndoReplaceNote::Undo()
 761 {
 762     BeginUndo();
 763     DoSdrUndoAction( mpDrawUndo.get(), &pDocShell->GetDocument() );
 764     /*  Undo insert -> remove new note.
 765         Undo remove -> insert old note.
 766         Undo replace -> remove new note, insert old note. */
 767     DoRemoveNote( maNewData );
 768     DoInsertNote( maOldData );
 769     pDocShell->PostPaintCell( maPos );
 770     EndUndo();
 771 }
 772
 773 void ScUndoReplaceNote::Redo()
 774 {
 775     BeginRedo();
 776     RedoSdrUndoAction( mpDrawUndo.get() );
 777     /*  Redo insert -> insert new note.
 778         Redo remove -> remove old note.
 779         Redo replace -> remove old note, insert new note. */
 780     DoRemoveNote( maOldData );
 781     DoInsertNote( maNewData );
 782     pDocShell->PostPaintCell( maPos );
 783     EndRedo();
 784 }
 785
 786 void ScUndoReplaceNote::Repeat( SfxRepeatTarget& /*rTarget*/ )
 787 {
 788 }
 789
 790 bool ScUndoReplaceNote::CanRepeat( SfxRepeatTarget& /*rTarget*/ ) const
 791 {
 792     return false;
 793 }
 794
 795 OUString ScUndoReplaceNote::GetComment() const
 796 {
 797     return ScResId( maNewData.mxCaption ?
 798         (maOldData.mxCaption ? STR_UNDO_EDITNOTE : STR_UNDO_INSERTNOTE) : STR_UNDO_DELETENOTE );
 799 }
 800
 801 void ScUndoReplaceNote::DoInsertNote( const ScNoteData& rNoteData )
 802 {
 803     if( rNoteData.mxCaption )
 804     {
 805         ScDocument& rDoc = pDocShell->GetDocument();
 806         OSL_ENSURE( !rDoc.GetNote(maPos), "ScUndoReplaceNote::DoInsertNote - unexpected cell note" );
 807         ScPostIt* pNote = new ScPostIt( rDoc, maPos, rNoteData, false );
 808         rDoc.SetNote( maPos, std::unique_ptr<ScPostIt>(pNote) );
 809         ScDocShell::LOKCommentNotify(LOKCommentNotificationType::Add, rDoc, maPos, pNote);
 810     }
 811 }
 812
 813 void ScUndoReplaceNote::DoRemoveNote( const ScNoteData& rNoteData )
 814 {
 815     if( !rNoteData.mxCaption )
 816         return;
 817
 818     ScDocument& rDoc = pDocShell->GetDocument();
 819     OSL_ENSURE( rDoc.GetNote(maPos), "ScUndoReplaceNote::DoRemoveNote - missing cell note" );
 820     if( std::unique_ptr<ScPostIt> pNote = rDoc.ReleaseNote( maPos ) )
 821     {
 822         /*  Forget pointer to caption object to suppress removing the
 823             caption object from the drawing layer while deleting pNote
 824             (removing the caption is done by a drawing undo action). */
 825         pNote->ForgetCaption();
 826         ScDocShell::LOKCommentNotify(LOKCommentNotificationType::Remove, rDoc, maPos, pNote.get());
 827     }
 828 }
 829
 830 ScUndoShowHideNote::ScUndoShowHideNote( ScDocShell& rDocShell, const ScAddress& rPos, bool bShow ) :
 831     ScSimpleUndo( &rDocShell ),
 832     maPos( rPos ),
 833     mbShown( bShow )
 834 {
 835 }
 836
 837 ScUndoShowHideNote::~ScUndoShowHideNote()
 838 {
 839 }
 840
 841 void ScUndoShowHideNote::Undo()
 842 {
 843     BeginUndo();
 844     if( ScPostIt* pNote = pDocShell->GetDocument().GetNote(maPos) )
 845         pNote->ShowCaption( maPos, !mbShown );
 846     EndUndo();
 847 }
 848
 849 void ScUndoShowHideNote::Redo()
 850 {
 851     BeginRedo();
 852     if( ScPostIt* pNote = pDocShell->GetDocument().GetNote(maPos) )
 853         pNote->ShowCaption( maPos, mbShown );
 854     EndRedo();
 855 }
 856
 857 void ScUndoShowHideNote::Repeat( SfxRepeatTarget& /*rTarget*/ )
 858 {
 859 }
 860
 861 bool ScUndoShowHideNote::CanRepeat( SfxRepeatTarget& /*rTarget*/ ) const
 862 {
 863     return false;
 864 }
 865
 866 OUString ScUndoShowHideNote::GetComment() const
 867 {
 868     return ScResId( mbShown ? STR_UNDO_SHOWNOTE : STR_UNDO_HIDENOTE );
 869 }
 870
 871 ScUndoDetective::ScUndoDetective( ScDocShell* pNewDocShell,
 872                                     std::unique_ptr<SdrUndoAction> pDraw, const ScDetOpData* pOperation,
 873                                     std::unique_ptr<ScDetOpList> pUndoList ) :
 874     ScSimpleUndo( pNewDocShell ),
 875     pOldList    ( std::move(pUndoList) ),
 876     nAction     ( 0 ),
 877     pDrawUndo   ( std::move(pDraw) )
 878 {
 879     bIsDelete = ( pOperation == nullptr );
 880     if (!bIsDelete)
 881     {
 882         nAction = static_cast<sal_uInt16>(pOperation->GetOperation());
 883         aPos = pOperation->GetPos();
 884     }
 885 }
 886
 887 ScUndoDetective::~ScUndoDetective()
 888 {
 889     pDrawUndo.reset();
 890     pOldList.reset();
 891 }
 892
 893 OUString ScUndoDetective::GetComment() const
 894 {
 895     TranslateId pId = STR_UNDO_DETDELALL;
 896     if ( !bIsDelete )
 897         switch ( static_cast<ScDetOpType>(nAction) )
 898         {
 899             case SCDETOP_ADDSUCC:   pId = STR_UNDO_DETADDSUCC;  break;
 900             case SCDETOP_DELSUCC:   pId = STR_UNDO_DETDELSUCC;  break;
 901             case SCDETOP_ADDPRED:   pId = STR_UNDO_DETADDPRED;  break;
 902             case SCDETOP_DELPRED:   pId = STR_UNDO_DETDELPRED;  break;
 903             case SCDETOP_ADDERROR:  pId = STR_UNDO_DETADDERROR; break;
 904         }
 905
 906     return ScResId(pId);
 907 }
 908
 909 void ScUndoDetective::Undo()
 910 {
 911     BeginUndo();
 912
 913     ScDocument& rDoc = pDocShell->GetDocument();
 914     DoSdrUndoAction(pDrawUndo.get(), &rDoc);
 915
 916     if (bIsDelete)
 917     {
 918         if ( pOldList )
 919             rDoc.SetDetOpList( std::unique_ptr<ScDetOpList>(new ScDetOpList(*pOldList)) );
 920     }
 921     else
 922     {
 923         // Remove entry from list
 924
 925         ScDetOpList* pList = rDoc.GetDetOpList();
 926         if (pList && pList->Count())
 927         {
 928             ScDetOpDataVector& rVec = pList->GetDataVector();
 929             ScDetOpDataVector::iterator it = rVec.begin() + rVec.size() - 1;
 930             if ( it->GetOperation() == static_cast<ScDetOpType>(nAction) && it->GetPos() == aPos )
 931                 rVec.erase( it);
 932             else
 933             {
 934                 OSL_FAIL("Detective entry could not be found in list");
 935             }
 936         }
 937     }
 938
 939     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 940     if (pViewShell)
 941         pViewShell->RecalcPPT();    //! use broadcast instead?
 942
 943     EndUndo();
 944 }
 945
 946 void ScUndoDetective::Redo()
 947 {
 948     BeginRedo();
 949
 950     RedoSdrUndoAction(pDrawUndo.get());
 951
 952     ScDocument& rDoc = pDocShell->GetDocument();
 953
 954     if (bIsDelete)
 955         rDoc.ClearDetectiveOperations();
 956     else
 957         rDoc.AddDetectiveOperation( ScDetOpData( aPos, static_cast<ScDetOpType>(nAction) ) );
 958
 959     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 960     if (pViewShell)
 961         pViewShell->RecalcPPT();    //! use broadcast instead?
 962
 963     EndRedo();
 964 }
 965
 966 void ScUndoDetective::Repeat(SfxRepeatTarget& /* rTarget */)
 967 {
 968     // makes no sense
 969 }
 970
 971 bool ScUndoDetective::CanRepeat(SfxRepeatTarget& /* rTarget */) const
 972 {
 973     return false;
 974 }
 975
 976 ScUndoRangeNames::ScUndoRangeNames( ScDocShell* pNewDocShell,
 977                                     std::unique_ptr<ScRangeName> pOld, std::unique_ptr<ScRangeName> pNew, SCTAB nTab ) :
 978     ScSimpleUndo( pNewDocShell ),
 979     pOldRanges  ( std::move(pOld) ),
 980     pNewRanges  ( std::move(pNew) ),
 981     mnTab       ( nTab )
 982 {
 983 }
 984
 985 ScUndoRangeNames::~ScUndoRangeNames()
 986 {
 987     pOldRanges.reset();
 988     pNewRanges.reset();
 989 }
 990
 991 OUString ScUndoRangeNames::GetComment() const
 992 {
 993     return ScResId( STR_UNDO_RANGENAMES );
 994 }
 995
 996 void ScUndoRangeNames::DoChange( bool bUndo )
 997 {
 998     ScDocument& rDoc = pDocShell->GetDocument();
 999     rDoc.PreprocessRangeNameUpdate();
1000
1001     if ( bUndo )
1002     {
1003         auto p = std::make_unique<ScRangeName>(*pOldRanges);
1004         if (mnTab >= 0)
1005             rDoc.SetRangeName( mnTab, std::move(p) );
1006         else
1007             rDoc.SetRangeName( std::move(p) );
1008     }
1009     else
1010     {
1011         auto p = std::make_unique<ScRangeName>(*pNewRanges);
1012         if (mnTab >= 0)
1013             rDoc.SetRangeName( mnTab, std::move(p) );
1014         else
1015             rDoc.SetRangeName( std::move(p) );
1016     }
1017
1018     rDoc.CompileHybridFormula();
1019
1020     SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScAreasChanged ) );
1021 }
1022
1023 void ScUndoRangeNames::Undo()
1024 {
1025     BeginUndo();
1026     DoChange( true );
1027     EndUndo();
1028 }
1029
1030 void ScUndoRangeNames::Redo()
1031 {
1032     BeginRedo();
1033     DoChange( false );
1034     EndRedo();
1035 }
1036
1037 void ScUndoRangeNames::Repeat(SfxRepeatTarget& /* rTarget */)
1038 {
1039     // makes no sense
1040 }
1041
1042 bool ScUndoRangeNames::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1043 {
1044     return false;
1045 }
1046
1047 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */