src/TortoiseMerge/Undo.cpp

   1 // TortoiseGitMerge - a Diff/Patch program
   2
   3 // Copyright (C) 2023 - TortoiseGit
   4 // Copyright (C) 2006-2007, 2010-2011, 2013,2015, 2021-2022 - TortoiseSVN
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20
  21 #include "stdafx.h"
  22 #include "Undo.h"
  23
  24 #include "BaseView.h"
  25
  26 void viewstate::AddViewLineFromView(CBaseView *pView, int nViewLine, bool bAddEmptyLine)
  27 {
  28         // is undo good place for this ?
  29         if (!pView || !pView->m_pViewData)
  30                 return;
  31         replacedlines[nViewLine] = pView->m_pViewData->GetData(nViewLine);
  32         if (bAddEmptyLine)
  33         {
  34                 addedlines.push_back(nViewLine + 1);
  35                 pView->AddEmptyViewLine(nViewLine);
  36         }
  37 }
  38
  39 void viewstate::Clear()
  40 {
  41         difflines.clear();
  42         linestates.clear();
  43         linelines.clear();
  44         linesEOL.clear();
  45         markedlines.clear();
  46         addedlines.clear();
  47
  48         removedlines.clear();
  49         replacedlines.clear();
  50         modifies = false;
  51 }
  52
  53 void CUndo::MarkAsOriginalState(bool bLeft, bool bRight, bool bBottom)
  54 {
  55         // find highest index of changing step
  56         if (bLeft) // left is selected for mark
  57                 m_originalstateLeft = 0;
  58         if (bRight) // right is selected for mark
  59                 m_originalstateRight = 0;
  60         if (bBottom) // bottom is selected for mark
  61                 m_originalstateBottom = 0;
  62 }
  63
  64 CUndo& CUndo::GetInstance()
  65 {
  66         static CUndo instance;
  67         return instance;
  68 }
  69
  70 CUndo::CUndo()
  71 {
  72 }
  73
  74 CUndo::~CUndo()
  75 {
  76 }
  77
  78 void CUndo::AddState(const allviewstate& allstate, POINT pt)
  79 {
  80         if (allstate.left.modifies)
  81                 ++m_originalstateLeft;
  82         if (allstate.right.modifies)
  83                 ++m_originalstateRight;
  84         if (allstate.bottom.modifies)
  85                 ++m_originalstateBottom;
  86
  87         m_viewstates.push_back(allstate);
  88         m_caretpoints.push_back(pt);
  89         // a new action that can be undone clears the redo since
  90         // after this there is nothing to redo anymore
  91         m_redoviewstates.clear();
  92         m_redocaretpoints.clear();
  93         m_redogroups.clear();
  94 }
  95
  96 bool CUndo::Undo(CBaseView * pLeft, CBaseView * pRight, CBaseView * pBottom)
  97 {
  98         if (!CanUndo())
  99                 return false;
 100
 101         if (m_groups.size() && m_groups.back() == m_caretpoints.size())
 102         {
 103                 m_groups.pop_back();
 104                 std::list<int>::size_type b = m_groups.back();
 105                 m_redogroups.push_back(b);
 106                 m_redogroups.push_back(m_caretpoints.size());
 107                 m_groups.pop_back();
 108                 while (b < m_caretpoints.size())
 109                         UndoOne(pLeft, pRight, pBottom);
 110         }
 111         else
 112                 UndoOne(pLeft, pRight, pBottom);
 113
 114         updateActiveView(pLeft, pRight, pBottom);
 115
 116         return true;
 117 }
 118
 119 void CUndo::UndoOne(CBaseView * pLeft, CBaseView * pRight, CBaseView * pBottom)
 120 {
 121         allviewstate allstate = m_viewstates.back();
 122         POINT pt = m_caretpoints.back();
 123
 124         if (pLeft->IsTarget())
 125                 m_redocaretpoints.push_back(pLeft->GetCaretPosition());
 126         else if (pRight->IsTarget())
 127                 m_redocaretpoints.push_back(pRight->GetCaretPosition());
 128         else if (pBottom->IsTarget())
 129                 m_redocaretpoints.push_back(pBottom->GetCaretPosition());
 130
 131         if (allstate.left.modifies)
 132                 --m_originalstateLeft;
 133         if (allstate.right.modifies)
 134                 --m_originalstateRight;
 135         if (allstate.bottom.modifies)
 136                 --m_originalstateBottom;
 137
 138         allstate.left   = Do(allstate.left, pLeft, pt);
 139         allstate.right  = Do(allstate.right, pRight, pt);
 140         allstate.bottom = Do(allstate.bottom, pBottom, pt);
 141
 142         m_redoviewstates.push_back(allstate);
 143
 144         m_viewstates.pop_back();
 145         m_caretpoints.pop_back();
 146 }
 147
 148 bool CUndo::Redo(CBaseView * pLeft, CBaseView * pRight, CBaseView * pBottom)
 149 {
 150         if (!CanRedo())
 151                 return false;
 152
 153         if (m_redogroups.size() && m_redogroups.back() == m_redocaretpoints.size())
 154         {
 155                 m_redogroups.pop_back();
 156                 std::list<int>::size_type b = m_redogroups.back();
 157                 m_groups.push_back(b);
 158                 m_groups.push_back(m_redocaretpoints.size());
 159                 m_redogroups.pop_back();
 160                 while (b < m_redocaretpoints.size())
 161                         RedoOne(pLeft, pRight, pBottom);
 162         }
 163         else
 164                 RedoOne(pLeft, pRight, pBottom);
 165
 166         updateActiveView(pLeft, pRight, pBottom);
 167
 168         return true;
 169 }
 170
 171 void CUndo::RedoOne(CBaseView* pLeft, CBaseView* pRight, CBaseView* pBottom)
 172 {
 173         allviewstate allstate = m_redoviewstates.back();
 174         POINT pt = m_redocaretpoints.back();
 175
 176         if (pLeft->IsTarget())
 177                 m_caretpoints.push_back(pLeft->GetCaretPosition());
 178         else if (pRight->IsTarget())
 179                 m_caretpoints.push_back(pRight->GetCaretPosition());
 180         else if (pBottom->IsTarget())
 181                 m_caretpoints.push_back(pBottom->GetCaretPosition());
 182
 183         if (allstate.left.modifies)
 184                 ++m_originalstateLeft;
 185         if (allstate.right.modifies)
 186                 ++m_originalstateRight;
 187         if (allstate.bottom.modifies)
 188                 ++m_originalstateBottom;
 189
 190         allstate.left = Do(allstate.left, pLeft, pt);
 191         allstate.right = Do(allstate.right, pRight, pt);
 192         allstate.bottom = Do(allstate.bottom, pBottom, pt);
 193
 194         m_viewstates.push_back(allstate);
 195
 196         m_redoviewstates.pop_back();
 197         m_redocaretpoints.pop_back();
 198 }
 199
 200 void CUndo::updateActiveView(CBaseView* pLeft, CBaseView* pRight, CBaseView* pBottom) const
 201 {
 202         CBaseView* pActiveView = nullptr;
 203
 204         if (pBottom && pBottom->IsTarget())
 205         {
 206                 pActiveView = pBottom;
 207         }
 208         else if (pRight && pRight->IsTarget())
 209         {
 210                 pActiveView = pRight;
 211         }
 212         else
 213         // if (pLeft && pLeft->IsTarget())
 214         {
 215                 pActiveView = pLeft;
 216         }
 217
 218         if (pActiveView)
 219         {
 220                 pActiveView->ClearSelection();
 221                 pActiveView->BuildAllScreen2ViewVector();
 222                 pActiveView->RecalcAllVertScrollBars();
 223                 pActiveView->RecalcAllHorzScrollBars();
 224                 pActiveView->EnsureCaretVisible();
 225                 pActiveView->UpdateCaret();
 226
 227                 if (pLeft)
 228                 {
 229                         pLeft->SetModified(m_originalstateLeft != 0);
 230                         pLeft->ClearStepModifiedMark();
 231                 }
 232                 if (pRight)
 233                 {
 234                         pRight->SetModified(m_originalstateRight != 0);
 235                         pRight->ClearStepModifiedMark();
 236                 }
 237                 if (pBottom)
 238                 {
 239                         pBottom->SetModified(m_originalstateBottom != 0);
 240                         pBottom->ClearStepModifiedMark();
 241                 }
 242                 pActiveView->RefreshViews();
 243         }
 244 }
 245 viewstate CUndo::Do(const viewstate& state, CBaseView * pView, const POINT& pt)
 246 {
 247         if (!pView)
 248                 return state;
 249
 250         CViewData* viewData = pView->m_pViewData;
 251         if (!viewData)
 252                 return state;
 253
 254         viewstate revstate; // the reversed viewstate
 255         revstate.modifies = state.modifies;
 256
 257         for (std::list<int>::const_reverse_iterator it = state.addedlines.rbegin(); it != state.addedlines.rend(); ++it)
 258         {
 259                 revstate.removedlines[*it] = viewData->GetData(*it);
 260                 viewData->RemoveData(*it);
 261         }
 262         for (std::map<int, DWORD>::const_iterator it = state.linelines.begin(); it != state.linelines.end(); ++it)
 263         {
 264                 revstate.linelines[it->first] = viewData->GetLineNumber(it->first);
 265                 viewData->SetLineNumber(it->first, it->second);
 266         }
 267         for (auto it = state.linestates.cbegin(); it != state.linestates.cend(); ++it)
 268         {
 269                 revstate.linestates[it->first] = viewData->GetState(it->first);
 270                 viewData->SetState(it->first, it->second);
 271         }
 272         for (std::map<int, EOL>::const_iterator it = state.linesEOL.begin(); it != state.linesEOL.end(); ++it)
 273         {
 274                 revstate.linesEOL[it->first] = viewData->GetLineEnding(it->first);
 275                 viewData->SetLineEnding(it->first, it->second);
 276         }
 277         for (std::map<int, bool>::const_iterator it = state.markedlines.begin(); it != state.markedlines.end(); ++it)
 278         {
 279                 revstate.markedlines[it->first] = viewData->GetMarked(it->first);
 280                 viewData->SetMarked(it->first, it->second);
 281         }
 282         for (std::map<int, CString>::const_iterator it = state.difflines.begin(); it != state.difflines.end(); ++it)
 283         {
 284                 revstate.difflines[it->first] = viewData->GetLine(it->first);
 285                 viewData->SetLine(it->first, it->second);
 286         }
 287         for (std::map<int, viewdata>::const_iterator it = state.removedlines.begin(); it != state.removedlines.end(); ++it)
 288         {
 289                 revstate.addedlines.push_back(it->first);
 290                 viewData->InsertData(it->first, it->second);
 291         }
 292         for (std::map<int, viewdata>::const_iterator it = state.replacedlines.begin(); it != state.replacedlines.end(); ++it)
 293         {
 294                 revstate.replacedlines[it->first] = viewData->GetData(it->first);
 295                 viewData->SetData(it->first, it->second);
 296         }
 297
 298         if (pView->IsTarget())
 299         {
 300                 pView->SetCaretViewPosition(pt);
 301                 pView->EnsureCaretVisible();
 302         }
 303         return revstate;
 304 }
 305
 306 void CUndo::Clear()
 307 {
 308         m_viewstates.clear();
 309         m_caretpoints.clear();
 310         m_groups.clear();
 311         m_redoviewstates.clear();
 312         m_redocaretpoints.clear();
 313         m_redogroups.clear();
 314         m_originalstateLeft = 0;
 315         m_originalstateRight = 0;
 316         m_originalstateBottom = 0;
 317         m_groupCount = 0;
 318 }