sw/source/core/inc/UndoTable.hxx

   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 #pragma once
  21
  22 #include <o3tl/deleter.hxx>
  23 #include <tools/long.hxx>
  24 #include <tools/solar.h>
  25 #include <ndarr.hxx>
  26 #include <undobj.hxx>
  27 #include <set>
  28 #include <itabenum.hxx>
  29 #include <tblenum.hxx>
  30 #include <memory>
  31 #include <vector>
  32
  33 class SfxItemSet;
  34
  35 struct SwSaveRowSpan;
  36 class SaveTable;
  37 class SwDDEFieldType;
  38 class SwUndoDelete;
  39 class SwSelBoxes;
  40 class SwTable;
  41 class SwTableBox;
  42 class SwStartNode;
  43 class SwTableNode;
  44 class SwTableAutoFormat;
  45 class SwTableSortBoxes;
  46 class SwContentNode;
  47 class SwCursorShell;
  48
  49 namespace sw {
  50
  51 void NotifyTableCollapsedParagraph(const SwContentNode* pNode, SwCursorShell *const pShell);
  52
  53 }
  54
  55 /// Implements undo/redo for Table -> Insert Table.
  56 class SwUndoInsTable final : public SwUndo
  57 {
  58     OUString m_sTableName;
  59     SwInsertTableOptions m_aInsTableOptions;
  60     std::unique_ptr<SwDDEFieldType> m_pDDEFieldType;
  61     std::optional<std::vector<sal_uInt16>> m_oColumnWidth;
  62     std::unique_ptr<SwRedlineData>  m_pRedlineData;
  63     std::unique_ptr<SwTableAutoFormat> m_pAutoFormat;
  64     SwNodeOffset m_nStartNode;
  65     sal_uInt16 m_nRows, m_nColumns;
  66     sal_uInt16 const m_nAdjust;
  67
  68 public:
  69     SwUndoInsTable( const SwPosition&, sal_uInt16 nCols, sal_uInt16 nRows,
  70                     sal_uInt16 eAdjust, const SwInsertTableOptions& rInsTableOpts,
  71                     const SwTableAutoFormat* pTAFormat, const std::vector<sal_uInt16> *pColArr,
  72                   const OUString & rName);
  73
  74     virtual ~SwUndoInsTable() override;
  75
  76     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
  77     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
  78     virtual void RepeatImpl( ::sw::RepeatContext & ) override;
  79
  80     virtual SwRewriter GetRewriter() const override;
  81 };
  82
  83 class SwUndoTextToTable final : public SwUndo, public SwUndRng
  84 {
  85     OUString m_sTableName;
  86     SwInsertTableOptions m_aInsertTableOpts;
  87     std::vector<SwNodeOffset> mvDelBoxes;
  88     std::unique_ptr<SwTableAutoFormat> m_pAutoFormat;
  89     SwHistory* m_pHistory;
  90     sal_Unicode m_cSeparator;
  91     sal_uInt16 m_nAdjust;
  92     bool m_bSplitEnd : 1;
  93
  94 public:
  95     SwUndoTextToTable( const SwPaM&, const SwInsertTableOptions&, sal_Unicode,
  96                     sal_uInt16,
  97                     const SwTableAutoFormat* pAFormat );
  98
  99     virtual ~SwUndoTextToTable() override;
 100
 101     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 102     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 103     virtual void RepeatImpl( ::sw::RepeatContext & ) override;
 104
 105     SwHistory& GetHistory(); // will be created if necessary
 106     void AddFillBox( const SwTableBox& rBox );
 107 };
 108
 109 class SwUndoTableToText final : public SwUndo
 110 {
 111     OUString m_sTableName;
 112     std::unique_ptr<SwDDEFieldType> m_pDDEFieldType;
 113     std::unique_ptr<SaveTable> m_pTableSave;
 114     SwTableToTextSaves m_vBoxSaves;
 115     std::unique_ptr<SwHistory> m_pHistory;
 116     SwNodeOffset m_nStartNode, m_nEndNode;
 117     sal_Unicode m_cSeparator;
 118     sal_uInt16 m_nHeadlineRepeat;
 119     bool m_bCheckNumFormat : 1;
 120
 121 public:
 122     SwUndoTableToText( const SwTable& rTable, sal_Unicode cCh );
 123
 124     virtual ~SwUndoTableToText() override;
 125
 126     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 127     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 128     virtual void RepeatImpl( ::sw::RepeatContext & ) override;
 129
 130     void SetRange( const SwNodeRange& );
 131     void AddBoxPos( SwDoc& rDoc, SwNodeOffset nNdIdx, SwNodeOffset nEndIdx,
 132                     sal_Int32 nContentIdx = SAL_MAX_INT32);
 133 };
 134
 135 class SwUndoAttrTable final : public SwUndo
 136 {
 137     SwNodeOffset m_nStartNode;
 138     std::unique_ptr<SaveTable> m_pSaveTable;
 139     bool m_bClearTableCol : 1;
 140
 141 public:
 142     SwUndoAttrTable( const SwTableNode& rTableNd, bool bClearTabCols = false );
 143
 144     virtual ~SwUndoAttrTable() override;
 145
 146     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 147     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 148 };
 149
 150 class SwUndoTableNumFormat;
 151
 152 class SwUndoTableAutoFormat final : public SwUndo
 153 {
 154     OUString m_TableStyleName;
 155     SwNodeOffset m_nStartNode;
 156     std::unique_ptr<SaveTable> m_pSaveTable;
 157     std::vector< std::shared_ptr<SwUndoTableNumFormat> > m_Undos;
 158     bool m_bSaveContentAttr;
 159     sal_uInt16 m_nRepeatHeading;
 160
 161     void UndoRedo(bool const bUndo, ::sw::UndoRedoContext & rContext);
 162
 163 public:
 164     SwUndoTableAutoFormat( const SwTableNode& rTableNd, const SwTableAutoFormat& );
 165
 166     virtual ~SwUndoTableAutoFormat() override;
 167
 168     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 169     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 170
 171     void SaveBoxContent( const SwTableBox& rBox );
 172 };
 173
 174 using SwUndoSaveSections = std::vector<std::unique_ptr<SwUndoSaveSection, o3tl::default_delete<SwUndoSaveSection>>>;
 175
 176 class SwUndoTableNdsChg final : public SwUndo
 177 {
 178     std::unique_ptr<SaveTable> m_pSaveTable;
 179     std::set<SwNodeOffset> m_Boxes;
 180     struct BoxMove
 181     {
 182         SwNodeOffset index;    ///< Index of this box.
 183         bool      hasMoved; ///< Has this box been moved already.
 184         BoxMove(SwNodeOffset idx, bool moved=false) : index(idx), hasMoved(moved) {};
 185         bool operator<(const BoxMove& other) const { return index < other.index; };
 186     };
 187     std::optional< std::set<BoxMove> > m_xNewSttNds;
 188     std::unique_ptr<SwUndoSaveSections> m_pDelSects;
 189     tools::Long m_nMin, m_nMax;        // for redo of delete column
 190     SwNodeOffset m_nSttNode;
 191     sal_uInt16 m_nCount;
 192     bool m_bFlag;
 193     bool m_bSameHeight;                   // only used for SplitRow
 194
 195     SwUndoTableNdsChg(SwUndoTableNdsChg const&) = delete;
 196     SwUndoTableNdsChg& operator=(SwUndoTableNdsChg const&) = delete;
 197
 198 public:
 199     SwUndoTableNdsChg( SwUndoId UndoId,
 200                     const SwSelBoxes& rBoxes,
 201                     const SwTableNode& rTableNd,
 202                     tools::Long nMn, tools::Long nMx,
 203                     sal_uInt16 nCnt, bool bFlg, bool bSameHeight );
 204
 205     virtual ~SwUndoTableNdsChg() override;
 206
 207     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 208     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 209
 210     void SaveNewBoxes( const SwTableNode& rTableNd, const SwTableSortBoxes& rOld );
 211     void SaveNewBoxes( const SwTableNode& rTableNd, const SwTableSortBoxes& rOld,
 212                        const SwSelBoxes& rBoxes, const std::vector<SwNodeOffset> &rNodeCnts );
 213     void SaveSection( SwStartNode* pSttNd );
 214     void ReNewBoxes( const SwSelBoxes& rBoxes );
 215
 216 };
 217
 218 class SwUndoMove;
 219
 220 class SwUndoTableMerge final : public SwUndo, private SwUndRng
 221 {
 222     SwNodeOffset m_nTableNode;
 223     std::unique_ptr<SaveTable> m_pSaveTable;
 224     std::set<SwNodeOffset> m_Boxes;
 225     std::vector<SwNodeOffset> m_aNewStartNodes;
 226     std::vector<std::unique_ptr<SwUndoMove>> m_vMoves;
 227     std::unique_ptr<SwHistory> m_pHistory;
 228
 229 public:
 230     SwUndoTableMerge( const SwPaM& rTableSel );
 231
 232     virtual ~SwUndoTableMerge() override;
 233
 234     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 235     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 236
 237     void MoveBoxContent( SwDoc& rDoc, SwNodeRange& rRg, SwNode& rPos );
 238
 239     void SetSelBoxes( const SwSelBoxes& rBoxes );
 240
 241     void AddNewBox( SwNodeOffset nSttNdIdx )
 242         { m_aNewStartNodes.push_back( nSttNdIdx ); }
 243
 244     void SaveCollection( const SwTableBox& rBox );
 245 };
 246
 247 class SwUndoTableNumFormat final : public SwUndo
 248 {
 249     std::unique_ptr<SfxItemSet> m_pBoxSet;
 250     std::unique_ptr<SwHistory> m_pHistory;
 251     OUString m_aStr, m_aNewFormula;
 252
 253     sal_uLong m_nFormatIdx, m_nNewFormatIdx;
 254     double m_fNum, m_fNewNum;
 255     SwNodeOffset m_nNode;
 256     SwNodeOffset m_nNodePos;
 257
 258     bool m_bNewFormat : 1;
 259     bool m_bNewFormula : 1;
 260     bool m_bNewValue : 1;
 261
 262 public:
 263     SwUndoTableNumFormat( const SwTableBox& rBox, const SfxItemSet* pNewSet = nullptr );
 264
 265     virtual ~SwUndoTableNumFormat() override;
 266
 267     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 268     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 269
 270     void SetNumFormat( sal_uLong nNewNumFormatIdx, const double& rNewNumber )
 271             { m_nFormatIdx = nNewNumFormatIdx; m_fNum = rNewNumber; }
 272     void SetBox( const SwTableBox& rBox );
 273 };
 274
 275 struct UndoTableCpyTable_Entry;
 276
 277 class SwUndoTableCpyTable final : public SwUndo
 278 {
 279     std::vector<std::unique_ptr<UndoTableCpyTable_Entry>> m_vArr;
 280     std::unique_ptr<SwUndoTableNdsChg> m_pInsRowUndo;
 281
 282     //b6341295: When redlining is active, PrepareRedline has to create the
 283     //redlining attributes for the new and the old table cell content
 284     static std::unique_ptr<SwUndo> PrepareRedline( SwDoc* pDoc, const SwTableBox& rBox,
 285                 SwPosition& rPos, bool& rJoin, bool bRedo );
 286
 287 public:
 288     SwUndoTableCpyTable(const SwDoc& rDoc);
 289
 290     virtual ~SwUndoTableCpyTable() override;
 291
 292     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 293     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 294
 295     void AddBoxBefore( const SwTableBox& rBox, bool bDelContent );
 296     void AddBoxAfter( const SwTableBox& rBox, const SwNodeIndex& rIdx,
 297                 bool bDelContent );
 298
 299     bool IsEmpty() const;
 300     bool InsertRow( SwTable& rTable, const SwSelBoxes& rBoxes, sal_uInt16 nCnt );
 301     void dumpAsXml(xmlTextWriterPtr pWriter) const override;
 302 };
 303
 304 class SwUndoCpyTable final : public SwUndo
 305 {
 306     std::unique_ptr<SwUndoDelete> m_pDelete;
 307     SwNodeOffset m_nTableNode;
 308
 309 public:
 310     SwUndoCpyTable(const SwDoc& rDoc);
 311
 312     virtual ~SwUndoCpyTable() override;
 313
 314     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 315     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 316
 317     void SetTableSttIdx( SwNodeOffset nIdx )           { m_nTableNode = nIdx; }
 318 };
 319
 320 class SwUndoSplitTable final : public SwUndo
 321 {
 322     SwNodeOffset m_nTableNode, m_nOffset;
 323     std::unique_ptr<SwSaveRowSpan> mpSaveRowSpan; // stores row span values at the splitting row
 324     std::unique_ptr<SaveTable> m_pSavedTable;
 325     std::unique_ptr<SwHistory> m_pHistory;
 326     SplitTable_HeadlineOption const m_nMode;
 327     sal_uInt16 m_nFormulaEnd;
 328     bool m_bCalcNewSize;
 329
 330 public:
 331     SwUndoSplitTable( const SwTableNode& rTableNd, std::unique_ptr<SwSaveRowSpan> pRowSp,
 332             SplitTable_HeadlineOption nMode, bool bCalcNewSize );
 333
 334     virtual ~SwUndoSplitTable() override;
 335
 336     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 337     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 338     virtual void RepeatImpl( ::sw::RepeatContext & ) override;
 339
 340     void SetTableNodeOffset( SwNodeOffset nIdx )     { m_nOffset = nIdx - m_nTableNode; }
 341     SwHistory* GetHistory()                 { return m_pHistory.get(); }
 342     void SaveFormula( SwHistory& rHistory );
 343 };
 344
 345 class SwUndoMergeTable final : public SwUndo
 346 {
 347     OUString m_aName;
 348     SwNodeOffset m_nTableNode;
 349     std::unique_ptr<SaveTable> m_pSaveTable, m_pSaveHdl;
 350     std::unique_ptr<SwHistory> m_pHistory;
 351     bool m_bWithPrev;
 352
 353 public:
 354     SwUndoMergeTable( const SwTableNode& rTableNd, const SwTableNode& rDelTableNd,
 355                     bool bWithPrev );
 356
 357     virtual ~SwUndoMergeTable() override;
 358
 359     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 360     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 361     virtual void RepeatImpl( ::sw::RepeatContext & ) override;
 362
 363     void SaveFormula( SwHistory& rHistory );
 364 };
 365
 366 class SwUndoTableHeadline final : public SwUndo
 367 {
 368     SwNodeOffset m_nTableNode;
 369     sal_uInt16 m_nOldHeadline;
 370     sal_uInt16 m_nNewHeadline;
 371
 372 public:
 373     SwUndoTableHeadline( const SwTable&, sal_uInt16 nOldHdl,  sal_uInt16 nNewHdl );
 374
 375     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 376     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 377     virtual void RepeatImpl( ::sw::RepeatContext & ) override;
 378 };
 379
 380 void InsertSort( std::vector<sal_uInt16>& rArr, sal_uInt16 nIdx );
 381
 382 class SwUndoTableStyleMake final : public SwUndo
 383 {
 384     OUString m_sName;
 385     std::unique_ptr<SwTableAutoFormat> m_pAutoFormat;
 386 public:
 387     SwUndoTableStyleMake(OUString aName, const SwDoc& rDoc);
 388
 389     virtual ~SwUndoTableStyleMake() override;
 390
 391     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 392     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 393
 394     virtual SwRewriter GetRewriter() const override;
 395 };
 396
 397 class SwUndoTableStyleDelete final : public SwUndo
 398 {
 399     std::unique_ptr<SwTableAutoFormat> m_pAutoFormat;
 400     std::vector<SwTable*> m_rAffectedTables;
 401 public:
 402     SwUndoTableStyleDelete(std::unique_ptr<SwTableAutoFormat> pAutoFormat, std::vector<SwTable*>&& rAffectedTables, const SwDoc& rDoc);
 403
 404     virtual ~SwUndoTableStyleDelete() override;
 405
 406     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 407     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 408
 409     virtual SwRewriter GetRewriter() const override;
 410 };
 411
 412 class SwUndoTableStyleUpdate final : public SwUndo
 413 {
 414     std::unique_ptr<SwTableAutoFormat> m_pOldFormat, m_pNewFormat;
 415 public:
 416     SwUndoTableStyleUpdate(const SwTableAutoFormat& rNewFormat, const SwTableAutoFormat& rOldFormat, const SwDoc& rDoc);
 417
 418     virtual ~SwUndoTableStyleUpdate() override;
 419
 420     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 421     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 422
 423     virtual SwRewriter GetRewriter() const override;
 424 };
 425
 426 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */