sw/source/core/undo/unsort.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 <memory>
  21 #include <UndoSort.hxx>
  22 #include <doc.hxx>
  23 #include <swundo.hxx>
  24 #include <pam.hxx>
  25 #include <swtable.hxx>
  26 #include <ndtxt.hxx>
  27 #include <UndoCore.hxx>
  28 #include <UndoTable.hxx>
  29 #include <sortopt.hxx>
  30 #include <docsort.hxx>
  31 #include <node2lay.hxx>
  32
  33 SwUndoSort::SwUndoSort(const SwPaM& rRg, const SwSortOptions& rOpt)
  34     : SwUndo(SwUndoId::SORT_TXT, &rRg.GetDoc())
  35     , SwUndRng(rRg)
  36     , m_nTableNode(0)
  37 {
  38     m_pSortOptions.reset( new SwSortOptions(rOpt) );
  39 }
  40
  41 SwUndoSort::SwUndoSort( SwNodeOffset nStt, SwNodeOffset nEnd, const SwTableNode& rTableNd,
  42                         const SwSortOptions& rOpt, bool bSaveTable )
  43     : SwUndo(SwUndoId::SORT_TBL, &rTableNd.GetDoc())
  44 {
  45     m_nSttNode = nStt;
  46     m_nEndNode = nEnd;
  47     m_nTableNode   = rTableNd.GetIndex();
  48
  49     m_pSortOptions.reset( new SwSortOptions(rOpt) );
  50     if( bSaveTable )
  51         m_pUndoAttrTable.reset( new SwUndoAttrTable( rTableNd ) );
  52 }
  53
  54 SwUndoSort::~SwUndoSort()
  55 {
  56     m_pSortOptions.reset();
  57     m_pUndoAttrTable.reset();
  58 }
  59
  60 void SwUndoSort::UndoImpl(::sw::UndoRedoContext & rContext)
  61 {
  62     SwDoc & rDoc = rContext.GetDoc();
  63     if(m_pSortOptions->bTable)
  64     {
  65         // Undo for Table
  66         RemoveIdxFromSection( rDoc, m_nSttNode, &m_nEndNode );
  67
  68         if( m_pUndoAttrTable )
  69         {
  70             m_pUndoAttrTable->UndoImpl(rContext);
  71         }
  72
  73         SwTableNode* pTableNd = rDoc.GetNodes()[ m_nTableNode ]->GetTableNode();
  74
  75         // #i37739# A simple 'MakeFrames' after the node sorting
  76         // does not work if the table is inside a frame and has no prev/next.
  77         SwNode2LayoutSaveUpperFrames aNode2Layout(*pTableNd);
  78
  79         pTableNd->DelFrames();
  80         const SwTable& rTable = pTableNd->GetTable();
  81
  82         SwMovedBoxes aMovedList;
  83         for (std::unique_ptr<SwSortUndoElement> const& pElement : m_SortList)
  84         {
  85             const SwTableBox* pSource = rTable.GetTableBox(pElement->maSourceString);
  86             const SwTableBox* pTarget = rTable.GetTableBox(pElement->maTargetString);
  87
  88             // move back
  89             MoveCell(&rDoc, pTarget, pSource,
  90                      USHRT_MAX != aMovedList.GetPos(pSource) );
  91
  92             // store moved entry in list
  93             aMovedList.push_back(pTarget);
  94         }
  95
  96         // Restore table frames:
  97         // #i37739# A simple 'MakeFrames' after the node sorting
  98         // does not work if the table is inside a frame and has no prev/next.
  99         const SwNodeOffset nIdx = pTableNd->GetIndex();
 100         aNode2Layout.RestoreUpperFrames( rDoc.GetNodes(), nIdx, nIdx + 1 );
 101     }
 102     else
 103     {
 104         // Undo for Text
 105         SwPaM & rPam( AddUndoRedoPaM(rContext) );
 106         RemoveIdxFromRange(rPam, true);
 107
 108         // create index for (sorted) positions
 109         // The IndexList must be created based on (asc.) sorted SourcePosition.
 110         std::vector<SwNodeIndex> aIdxList;
 111         aIdxList.reserve(m_SortList.size());
 112
 113         for (size_t i = 0; i < m_SortList.size(); ++i)
 114         {
 115             for (std::unique_ptr<SwSortUndoElement> const& pElement : m_SortList)
 116             {
 117                 if (pElement->mnSourceNodeOffset == (m_nSttNode + SwNodeOffset(i)))
 118                 {
 119                     aIdxList.push_back( SwNodeIndex(rDoc.GetNodes(), pElement->mnTargetNodeOffset));
 120                     break;
 121                 }
 122             }
 123         }
 124
 125         for (size_t i = 0; i < m_SortList.size(); ++i)
 126         {
 127             SwNodeIndex aIdx( rDoc.GetNodes(), m_nSttNode + SwNodeOffset(i) );
 128             SwNodeRange aRg( aIdxList[i], SwNodeOffset(0), aIdxList[i], SwNodeOffset(1) );
 129             rDoc.getIDocumentContentOperations().MoveNodeRange(aRg, aIdx.GetNode(),
 130                 SwMoveFlags::DEFAULT);
 131         }
 132         // delete indices
 133         aIdxList.clear();
 134         SetPaM(rPam, true);
 135     }
 136 }
 137
 138 void SwUndoSort::RedoImpl(::sw::UndoRedoContext & rContext)
 139 {
 140     SwDoc & rDoc = rContext.GetDoc();
 141
 142     if(m_pSortOptions->bTable)
 143     {
 144         // Redo for Table
 145         RemoveIdxFromSection( rDoc, m_nSttNode, &m_nEndNode );
 146
 147         SwTableNode* pTableNd = rDoc.GetNodes()[ m_nTableNode ]->GetTableNode();
 148
 149         // #i37739# A simple 'MakeFrames' after the node sorting
 150         // does not work if the table is inside a frame and has no prev/next.
 151         SwNode2LayoutSaveUpperFrames aNode2Layout(*pTableNd);
 152
 153         pTableNd->DelFrames();
 154         const SwTable& rTable = pTableNd->GetTable();
 155
 156         SwMovedBoxes aMovedList;
 157         for (std::unique_ptr<SwSortUndoElement> const& pElement: m_SortList)
 158         {
 159             const SwTableBox* pSource = rTable.GetTableBox(pElement->maSourceString);
 160             const SwTableBox* pTarget = rTable.GetTableBox(pElement->maTargetString);
 161
 162             // move back
 163             MoveCell(&rDoc, pSource, pTarget,
 164                      USHRT_MAX != aMovedList.GetPos( pTarget ) );
 165             // store moved entry in list
 166             aMovedList.push_back( pSource );
 167         }
 168
 169         if( m_pUndoAttrTable )
 170         {
 171             m_pUndoAttrTable->RedoImpl(rContext);
 172         }
 173
 174         // Restore table frames:
 175         // #i37739# A simple 'MakeFrames' after the node sorting
 176         // does not work if the table is inside a frame and has no prev/next.
 177         const SwNodeOffset nIdx = pTableNd->GetIndex();
 178         aNode2Layout.RestoreUpperFrames( rDoc.GetNodes(), nIdx, nIdx + 1 );
 179     }
 180     else
 181     {
 182         // Redo for Text
 183         SwPaM & rPam( AddUndoRedoPaM(rContext) );
 184         SetPaM(rPam);
 185         RemoveIdxFromRange(rPam, true);
 186
 187         std::vector<SwNodeIndex> aIdxList;
 188         aIdxList.reserve(m_SortList.size());
 189
 190         for (size_t i = 0; i < m_SortList.size(); ++i)
 191         {   // current position is starting point
 192             aIdxList.push_back( SwNodeIndex(rDoc.GetNodes(), m_SortList[i]->mnSourceNodeOffset) );
 193         }
 194
 195         for (size_t i = 0; i < m_SortList.size(); ++i)
 196         {
 197             SwNodeIndex aIdx( rDoc.GetNodes(), m_nSttNode + SwNodeOffset(i));
 198             SwNodeRange aRg( aIdxList[i], SwNodeOffset(0), aIdxList[i], SwNodeOffset(1) );
 199             rDoc.getIDocumentContentOperations().MoveNodeRange(aRg, aIdx.GetNode(),
 200                 SwMoveFlags::DEFAULT);
 201         }
 202         // delete indices
 203         aIdxList.clear();
 204         SetPaM(rPam, true);
 205         SwTextNode const*const pTNd = rPam.GetPointNode().GetTextNode();
 206         if( pTNd )
 207         {
 208             rPam.GetPoint()->SetContent( pTNd->GetText().getLength() );
 209         }
 210     }
 211 }
 212
 213 void SwUndoSort::RepeatImpl(::sw::RepeatContext & rContext)
 214 {
 215     // table not repeat capable
 216     if(!m_pSortOptions->bTable)
 217     {
 218         SwPaM *const pPam = & rContext.GetRepeatPaM();
 219         SwDoc& rDoc = pPam->GetDoc();
 220
 221         if( !SwDoc::IsInTable( pPam->Start()->GetNode() ) )
 222             rDoc.SortText(*pPam, *m_pSortOptions);
 223     }
 224 }
 225
 226 void SwUndoSort::Insert( const OUString& rOrgPos, const OUString& rNewPos)
 227 {
 228     m_SortList.push_back(std::make_unique<SwSortUndoElement>(rOrgPos, rNewPos));
 229 }
 230
 231 void SwUndoSort::Insert( SwNodeOffset nOrgPos, SwNodeOffset nNewPos)
 232 {
 233     m_SortList.push_back(std::make_unique<SwSortUndoElement>(nOrgPos, nNewPos));
 234 }
 235
 236 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */