src/TortoiseMerge/Undo.cpp

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