?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't import ogdf namespace
[TortoiseGit.git] / src / TortoiseProc / RebaseDlg.cpp
bloba09a14c1d6febd112d2cee7ce8dea29052a83106
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2018 - TortoiseGit
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 // RebaseDlg.cpp : implementation file
21 //
22
23 #include "stdafx.h"
24 #include "TortoiseProc.h"
25 #include "RebaseDlg.h"
26 #include "AppUtils.h"
27 #include "LoglistUtils.h"
28 #include "MessageBox.h"
29 #include "UnicodeUtils.h"
30 #include "BrowseRefsDlg.h"
31 #include "ProgressDlg.h"
32 #include "SmartHandle.h"
33 #include "../TGitCache/CacheInterface.h"
34 #include "Settings/Settings.h"
35 #include "MassiveGitTask.h"
36 #include "CommitDlg.h"
37 #include "StringUtils.h"
38 #include "Hooks.h"
39 #include "LogDlg.h"
40
41 // CRebaseDlg dialog
42
43 IMPLEMENT_DYNAMIC(CRebaseDlg, CResizableStandAloneDialog)
44
45 CRebaseDlg::CRebaseDlg(CWnd* pParent /*=nullptr*/)
46 : CResizableStandAloneDialog(CRebaseDlg::IDD, pParent)
47 , m_bAddCherryPickedFrom(FALSE)
48 , m_bStatusWarning(false)
49 , m_bAutoSkipFailedCommit(FALSE)
50 , m_bFinishedRebase(false)
51 , m_bStashed(false)
52 , m_bSplitCommit(FALSE)
53 , m_bPreserveMerges(FALSE)
54 , m_bRebaseAutoStart(false)
55 , m_bRebaseAutoEnd(false)
56 , m_RebaseStage(CHOOSE_BRANCH)
57 , m_CurrentRebaseIndex(-1)
58 , m_bThreadRunning(FALSE)
59 , m_IsCherryPick(FALSE)
60 , m_bForce(BST_UNCHECKED)
61 , m_IsFastForward(FALSE)
62 , m_iSquashdate((int)CRegDWORD(L"Software\\TortoiseGit\\SquashDate", 0))
63 , m_bAbort(FALSE)
64 {
65 }
66
67 CRebaseDlg::~CRebaseDlg()
68 {
69 }
70
71 void CRebaseDlg::DoDataExchange(CDataExchange* pDX)
72 {
73 CDialog::DoDataExchange(pDX);
74 DDX_Control(pDX, IDC_REBASE_PROGRESS, m_ProgressBar);
75 DDX_Control(pDX, IDC_STATUS_STATIC, m_CtrlStatusText);
76 DDX_Control(pDX, IDC_REBASE_SPLIT, m_wndSplitter);
77 DDX_Control(pDX,IDC_COMMIT_LIST,m_CommitList);
78 DDX_Control(pDX,IDC_REBASE_COMBOXEX_BRANCH, this->m_BranchCtrl);
79 DDX_Control(pDX,IDC_REBASE_COMBOXEX_UPSTREAM, this->m_UpstreamCtrl);
80 DDX_Check(pDX, IDC_REBASE_CHECK_FORCE,m_bForce);
81 DDX_Check(pDX, IDC_REBASE_CHECK_PRESERVEMERGES, m_bPreserveMerges);
82 DDX_Check(pDX, IDC_CHECK_CHERRYPICKED_FROM, m_bAddCherryPickedFrom);
83 DDX_Control(pDX,IDC_REBASE_POST_BUTTON,m_PostButton);
84 DDX_Control(pDX, IDC_SPLITALLOPTIONS, m_SplitAllOptions);
85 DDX_Check(pDX, IDC_REBASE_SPLIT_COMMIT, m_bSplitCommit);
86 }
87
88
89 BEGIN_MESSAGE_MAP(CRebaseDlg, CResizableStandAloneDialog)
90 ON_BN_CLICKED(IDC_REBASE_SPLIT, &CRebaseDlg::OnBnClickedRebaseSplit)
91 ON_BN_CLICKED(IDC_REBASE_CONTINUE,OnBnClickedContinue)
92 ON_BN_CLICKED(IDC_REBASE_ABORT, OnBnClickedAbort)
93 ON_WM_SIZE()
94 ON_WM_THEMECHANGED()
95 ON_WM_SYSCOLORCHANGE()
96 ON_CBN_SELCHANGE(IDC_REBASE_COMBOXEX_BRANCH, &CRebaseDlg::OnCbnSelchangeBranch)
97 ON_CBN_SELCHANGE(IDC_REBASE_COMBOXEX_UPSTREAM, &CRebaseDlg::OnCbnSelchangeUpstream)
98 ON_MESSAGE(MSG_REBASE_UPDATE_UI, OnRebaseUpdateUI)
99 ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_NEEDSREFRESH, OnGitStatusListCtrlNeedsRefresh)
100 ON_BN_CLICKED(IDC_BUTTON_REVERSE, OnBnClickedButtonReverse)
101 ON_BN_CLICKED(IDC_BUTTON_BROWSE, &CRebaseDlg::OnBnClickedButtonBrowse)
102 ON_BN_CLICKED(IDC_REBASE_CHECK_FORCE, &CRebaseDlg::OnBnClickedRebaseCheckForce)
103 ON_BN_CLICKED(IDC_REBASE_CHECK_PRESERVEMERGES, &CRebaseDlg::OnBnClickedRebaseCheckForce)
104 ON_BN_CLICKED(IDC_CHECK_CHERRYPICKED_FROM, &CRebaseDlg::OnBnClickedCheckCherryPickedFrom)
105 ON_BN_CLICKED(IDC_REBASE_POST_BUTTON, &CRebaseDlg::OnBnClickedRebasePostButton)
106 ON_BN_CLICKED(IDC_BUTTON_UP, &CRebaseDlg::OnBnClickedButtonUp)
107 ON_BN_CLICKED(IDC_BUTTON_DOWN, &CRebaseDlg::OnBnClickedButtonDown)
108 ON_REGISTERED_MESSAGE(TaskBarButtonCreated, OnTaskbarBtnCreated)
109 ON_NOTIFY(LVN_ITEMCHANGED, IDC_COMMIT_LIST, OnLvnItemchangedLoglist)
110 ON_REGISTERED_MESSAGE(CGitLogListBase::m_RebaseActionMessage, OnRebaseActionMessage)
111 ON_WM_CTLCOLOR()
112 ON_BN_CLICKED(IDC_SPLITALLOPTIONS, &CRebaseDlg::OnBnClickedSplitAllOptions)
113 ON_BN_CLICKED(IDC_REBASE_SPLIT_COMMIT, &CRebaseDlg::OnBnClickedRebaseSplitCommit)
114 ON_BN_CLICKED(IDC_BUTTON_ONTO, &CRebaseDlg::OnBnClickedButtonOnto)
115 ON_BN_CLICKED(IDHELP, OnHelp)
116 ON_BN_CLICKED(IDC_BUTTON_ADD, &CRebaseDlg::OnBnClickedButtonAdd)
117 ON_MESSAGE(MSG_COMMITS_REORDERED, OnCommitsReordered)
118 END_MESSAGE_MAP()
119
120 void CRebaseDlg::CleanUpRebaseActiveFolder()
121 {
122 if (m_IsCherryPick)
123 return;
124 CString adminDir;
125 if (GitAdminDir::GetAdminDirPath(g_Git.m_CurrentDir, adminDir))
126 {
127 CString dir(adminDir + L"tgitrebase.active");
128 ::DeleteFile(dir + L"\\head-name");
129 ::DeleteFile(dir + L"\\onto");
130 ::RemoveDirectory(dir);
131 }
132 }
133
134 void CRebaseDlg::AddRebaseAnchor()
135 {
136 AdjustControlSize(IDC_CHECK_CHERRYPICKED_FROM);
137 AdjustControlSize(IDC_REBASE_SPLIT_COMMIT);
138 AdjustControlSize(IDC_REBASE_CHECK_FORCE);
139 AdjustControlSize(IDC_REBASE_CHECK_PRESERVEMERGES);
140
141 AddAnchor(IDC_REBASE_TAB,TOP_LEFT,BOTTOM_RIGHT);
142 AddAnchor(IDC_COMMIT_LIST,TOP_LEFT, TOP_RIGHT);
143 AddAnchor(IDC_REBASE_SPLIT,TOP_LEFT, TOP_RIGHT);
144 AddAnchor(IDC_STATUS_STATIC, BOTTOM_LEFT,BOTTOM_RIGHT);
145 AddAnchor(IDC_REBASE_CONTINUE,BOTTOM_RIGHT);
146 AddAnchor(IDC_REBASE_ABORT, BOTTOM_RIGHT);
147 AddAnchor(IDC_REBASE_PROGRESS,BOTTOM_LEFT, BOTTOM_RIGHT);
148 AddAnchor(IDC_SPLITALLOPTIONS, TOP_LEFT);
149 AddAnchor(IDC_BUTTON_UP, TOP_LEFT);
150 AddAnchor(IDC_BUTTON_DOWN, TOP_LEFT);
151 AddAnchor(IDC_BUTTON_ADD, TOP_LEFT);
152 AddAnchor(IDC_REBASE_COMBOXEX_UPSTREAM, TOP_CENTER, TOP_RIGHT);
153 AddAnchor(IDC_REBASE_COMBOXEX_BRANCH, TOP_LEFT, TOP_CENTER);
154 AddAnchor(IDC_BUTTON_REVERSE, TOP_CENTER);
155 AddAnchor(IDC_BUTTON_BROWSE, TOP_RIGHT);
156 AddAnchor(IDC_BUTTON_ONTO, TOP_RIGHT);
157 AddAnchor(IDC_REBASE_STATIC_UPSTREAM, TOP_CENTER);
158 AddAnchor(IDC_REBASE_STATIC_BRANCH,TOP_LEFT);
159 AddAnchor(IDHELP, BOTTOM_RIGHT);
160 AddAnchor(IDC_REBASE_CHECK_FORCE, TOP_CENTER, TOP_RIGHT);
161 AddAnchor(IDC_REBASE_CHECK_PRESERVEMERGES, TOP_LEFT, TOP_CENTER);
162 AddAnchor(IDC_CHECK_CHERRYPICKED_FROM, TOP_RIGHT);
163 AddAnchor(IDC_REBASE_SPLIT_COMMIT, BOTTOM_RIGHT);
164 AddAnchor(IDC_REBASE_POST_BUTTON,BOTTOM_LEFT);
165
166 this->AddOthersToAnchor();
167 }
168
169 BOOL CRebaseDlg::OnInitDialog()
170 {
171 CResizableStandAloneDialog::OnInitDialog();
172 CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
173
174 // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
175 // do this, Explorer would be unable to send that message to our window if we
176 // were running elevated. It's OK to make the call all the time, since if we're
177 // not elevated, this is a no-op.
178 CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
179 typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
180 CAutoLibrary hUser = AtlLoadSystemLibraryUsingFullPath(L"user32.dll");
181 if (hUser)
182 {
183 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
184 if (pfnChangeWindowMessageFilterEx)
185 {
186 pfnChangeWindowMessageFilterEx(m_hWnd, TaskBarButtonCreated, MSGFLT_ALLOW, &cfs);
187 }
188 }
189 m_pTaskbarList.Release();
190 if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
191 m_pTaskbarList = nullptr;
192
193 CRect rectDummy;
194 //IDC_REBASE_DUMY_TAB
195
196 GetClientRect(m_DlgOrigRect);
197 m_CommitList.GetClientRect(m_CommitListOrigRect);
198
199 CWnd *pwnd=this->GetDlgItem(IDC_REBASE_DUMY_TAB);
200 pwnd->GetWindowRect(&rectDummy);
201 this->ScreenToClient(rectDummy);
202
203 if (!m_ctrlTabCtrl.Create(CMFCTabCtrl::STYLE_FLAT, rectDummy, this, IDC_REBASE_TAB))
204 {
205 TRACE0("Failed to create output tab window\n");
206 return FALSE; // fail to create
207 }
208 m_ctrlTabCtrl.SetResizeMode(CMFCTabCtrl::RESIZE_NO);
209 // Create output panes:
210 //const DWORD dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
211 DWORD dwStyle =LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
212
213 if (! this->m_FileListCtrl.Create(dwStyle,rectDummy,&this->m_ctrlTabCtrl,0) )
214 {
215 TRACE0("Failed to create output windows\n");
216 return FALSE; // fail to create
217 }
218 m_FileListCtrl.m_hwndLogicalParent = this;
219
220 if (!m_LogMessageCtrl.Create(L"Scintilla", L"source", 0, rectDummy, &m_ctrlTabCtrl, 0, 0))
221 {
222 TRACE0("Failed to create log message control");
223 return FALSE;
224 }
225 m_ProjectProperties.ReadProps();
226 m_LogMessageCtrl.Init(m_ProjectProperties);
227 m_LogMessageCtrl.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
228 m_LogMessageCtrl.Call(SCI_SETREADONLY, TRUE);
229
230 dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
231
232 if (!m_wndOutputRebase.Create(L"Scintilla", L"source", 0, rectDummy, &m_ctrlTabCtrl, 0, 0))
233 {
234 TRACE0("Failed to create output windows\n");
235 return -1; // fail to create
236 }
237 m_wndOutputRebase.Init(-1);
238 m_wndOutputRebase.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
239 m_wndOutputRebase.Call(SCI_SETREADONLY, TRUE);
240
241 m_tooltips.AddTool(IDC_REBASE_CHECK_FORCE,IDS_REBASE_FORCE_TT);
242 m_tooltips.AddTool(IDC_REBASE_ABORT, IDS_REBASE_ABORT_TT);
243 m_tooltips.AddTool(IDC_REBASE_CHECK_PRESERVEMERGES, IDS_REBASE_PRESERVEMERGES_TT);
244
245 {
246 CString temp;
247 temp.LoadString(IDS_PROC_REBASE_SELECTALL_PICK);
248 m_SplitAllOptions.AddEntry(temp);
249 temp.LoadString(IDS_PROC_REBASE_SELECTALL_SQUASH);
250 m_SplitAllOptions.AddEntry(temp);
251 temp.LoadString(IDS_PROC_REBASE_SELECTALL_EDIT);
252 m_SplitAllOptions.AddEntry(temp);
253 temp.LoadString(IDS_PROC_REBASE_UNSELECTED_SKIP);
254 m_SplitAllOptions.AddEntry(temp);
255 temp.LoadString(IDS_PROC_REBASE_UNSELECTED_SQUASH);
256 m_SplitAllOptions.AddEntry(temp);
257 temp.LoadString(IDS_PROC_REBASE_UNSELECTED_EDIT);
258 m_SplitAllOptions.AddEntry(temp);
259 }
260
261 m_FileListCtrl.Init(GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD | GITSLC_COLDEL, L"RebaseDlg", (GITSLC_POPALL ^ (GITSLC_POPCOMMIT | GITSLC_POPRESTORE)), false, true, GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD| GITSLC_COLDEL);
262
263 m_ctrlTabCtrl.AddTab(&m_FileListCtrl, CString(MAKEINTRESOURCE(IDS_PROC_REVISIONFILES)));
264 m_ctrlTabCtrl.AddTab(&m_LogMessageCtrl, CString(MAKEINTRESOURCE(IDS_PROC_COMMITMESSAGE)), 1);
265 AddRebaseAnchor();
266
267 CString sWindowTitle;
268 GetWindowText(sWindowTitle);
269 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, sWindowTitle);
270
271 EnableSaveRestore(L"RebaseDlg");
272
273 DWORD yPos = CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RebaseDlgSizer");
274 RECT rcDlg, rcLogMsg, rcFileList;
275 GetClientRect(&rcDlg);
276 m_CommitList.GetWindowRect(&rcLogMsg);
277 ScreenToClient(&rcLogMsg);
278 this->m_ctrlTabCtrl.GetWindowRect(&rcFileList);
279 ScreenToClient(&rcFileList);
280 if (yPos)
281 {
282 RECT rectSplitter;
283 m_wndSplitter.GetWindowRect(&rectSplitter);
284 ScreenToClient(&rectSplitter);
285 int delta = yPos - rectSplitter.top;
286 if ((rcLogMsg.bottom + delta > rcLogMsg.top)&&(rcLogMsg.bottom + delta < rcFileList.bottom - 30))
287 {
288 m_wndSplitter.SetWindowPos(nullptr, 0, yPos, 0, 0, SWP_NOSIZE);
289 DoSize(delta);
290 }
291 }
292
293 if (this->m_RebaseStage == CHOOSE_BRANCH && !m_IsCherryPick)
294 this->LoadBranchInfo();
295 else
296 {
297 this->m_BranchCtrl.EnableWindow(FALSE);
298 this->m_UpstreamCtrl.EnableWindow(FALSE);
299 GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(FALSE);
300 }
301
302 m_CommitList.m_ColumnRegKey = L"Rebase";
303 m_CommitList.m_IsIDReplaceAction = TRUE;
304 // m_CommitList.m_IsOldFirst = TRUE;
305 m_CommitList.m_IsRebaseReplaceGraph = TRUE;
306 m_CommitList.m_bNoHightlightHead = TRUE;
307 m_CommitList.m_bIsCherryPick = !!m_IsCherryPick;
308
309 m_CommitList.InsertGitColumn();
310
311 this->SetControlEnable();
312
313 if(m_IsCherryPick)
314 {
315 this->m_BranchCtrl.SetCurSel(-1);
316 this->m_BranchCtrl.EnableWindow(FALSE);
317 GetDlgItem(IDC_REBASE_CHECK_FORCE)->ShowWindow(SW_HIDE);
318 GetDlgItem(IDC_REBASE_CHECK_PRESERVEMERGES)->ShowWindow(SW_HIDE);
319 GetDlgItem(IDC_BUTTON_BROWSE)->EnableWindow(FALSE);
320 GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(FALSE);
321 GetDlgItem(IDC_BUTTON_ONTO)->EnableWindow(FALSE);
322 this->m_UpstreamCtrl.AddString(L"HEAD");
323 this->m_UpstreamCtrl.EnableWindow(FALSE);
324 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_CHERRYPICK)));
325 // fill shown list
326 for (DWORD i = 0; i < m_CommitList.m_logEntries.size(); ++i)
327 m_CommitList.m_arShownList.SafeAdd(&m_CommitList.m_logEntries.GetGitRevAt(i));
328 m_CommitList.SetItemCountEx((int)m_CommitList.m_arShownList.size());
329 }
330 else
331 {
332 ((CButton*)GetDlgItem(IDC_BUTTON_ONTO))->SetCheck(m_Onto.IsEmpty() ? BST_UNCHECKED : BST_CHECKED);
333 GetDlgItem(IDC_CHECK_CHERRYPICKED_FROM)->ShowWindow(SW_HIDE);
334 int iconWidth = GetSystemMetrics(SM_CXSMICON);
335 int iconHeight = GetSystemMetrics(SM_CYSMICON);
336 ((CButton*)GetDlgItem(IDC_BUTTON_REVERSE))->SetIcon(CCommonAppUtils::LoadIconEx(IDI_SWITCHLEFTRIGHT, iconWidth, iconHeight));
337 SetContinueButtonText();
338 m_CommitList.DeleteAllItems();
339 FetchLogList();
340 }
341
342 m_CommitList.m_ContextMenuMask &= ~(m_CommitList.GetContextMenuBit(CGitLogListBase::ID_CHERRY_PICK)|
343 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_SWITCHTOREV)|
344 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_RESET)|
345 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REVERTREV)|
346 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_MERGEREV) |
347 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_TO_VERSION)|
348 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REVERTTOREV)|
349 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_COMBINE_COMMIT));
350
351 if(m_CommitList.m_IsOldFirst)
352 this->m_CurrentRebaseIndex = -1;
353 else
354 this->m_CurrentRebaseIndex = (int)m_CommitList.m_logEntries.size();
355
356 if (GetDlgItem(IDC_REBASE_CONTINUE)->IsWindowEnabled() && m_bRebaseAutoStart)
357 this->PostMessage(WM_COMMAND, MAKELONG(IDC_REBASE_CONTINUE, BN_CLICKED), (LPARAM)GetDlgItem(IDC_REBASE_CONTINUE)->GetSafeHwnd());
358
359 return TRUE;
360 }
361 // CRebaseDlg message handlers
362
363 HBRUSH CRebaseDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
364 {
365 if (pWnd->GetDlgCtrlID() == IDC_STATUS_STATIC && nCtlColor == CTLCOLOR_STATIC && m_bStatusWarning)
366 {
367 pDC->SetBkColor(RGB(255, 0, 0));
368 pDC->SetTextColor(RGB(255, 255, 255));
369 return CreateSolidBrush(RGB(255, 0, 0));
370 }
371
372 return CResizableStandAloneDialog::OnCtlColor(pDC, pWnd, nCtlColor);
373 }
374
375 void CRebaseDlg::SetAllRebaseAction(int action)
376 {
377 for (size_t i = 0; i < this->m_CommitList.m_logEntries.size(); ++i)
378 {
379 if (action == CGitLogListBase::LOGACTIONS_REBASE_SQUASH && (i == this->m_CommitList.m_logEntries.size() - 1 || (!m_IsCherryPick && m_CommitList.m_logEntries.GetGitRevAt(i).ParentsCount() != 1)))
380 continue;
381 m_CommitList.m_logEntries.GetGitRevAt(i).GetRebaseAction() = action;
382 }
383 m_CommitList.Invalidate();
384 }
385
386 void CRebaseDlg::OnBnClickedRebaseSplit()
387 {
388 this->UpdateData();
389 }
390
391 LRESULT CRebaseDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
392 {
393 switch (message) {
394 case WM_NOTIFY:
395 if (wParam == IDC_REBASE_SPLIT)
396 {
397 SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
398 DoSize(pHdr->delta);
399 }
400 break;
401 }
402
403 return __super::DefWindowProc(message, wParam, lParam);
404 }
405
406 void CRebaseDlg::DoSize(int delta)
407 {
408 this->RemoveAllAnchors();
409
410 auto hdwp = BeginDeferWindowPos(9);
411 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_LIST), 0, 0, 0, delta);
412 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_REBASE_TAB), 0, delta, 0, 0);
413 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_SPLITALLOPTIONS), 0, delta, 0, delta);
414 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_BUTTON_UP), 0, delta, 0, delta);
415 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_BUTTON_DOWN), 0, delta, 0, delta);
416 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_BUTTON_ADD), 0, delta, 0, delta);
417 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_REBASE_CHECK_FORCE), 0, delta, 0, delta);
418 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_REBASE_CHECK_PRESERVEMERGES), 0, delta, 0, delta);
419 hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECK_CHERRYPICKED_FROM), 0, delta, 0, delta);
420 EndDeferWindowPos(hdwp);
421
422 this->AddRebaseAnchor();
423 // adjust the minimum size of the dialog to prevent the resizing from
424 // moving the list control too far down.
425 CRect rcLogMsg;
426 m_CommitList.GetClientRect(rcLogMsg);
427 SetMinTrackSize(CSize(m_DlgOrigRect.Width(), m_DlgOrigRect.Height()-m_CommitListOrigRect.Height()+rcLogMsg.Height()));
428
429 SetSplitterRange();
430 // m_CommitList.Invalidate();
431
432 // GetDlgItem(IDC_LOGMESSAGE)->Invalidate();
433
434 this->m_ctrlTabCtrl.Invalidate();
435 this->m_CommitList.Invalidate();
436 this->m_FileListCtrl.Invalidate();
437 this->m_LogMessageCtrl.Invalidate();
438 m_SplitAllOptions.Invalidate();
439 GetDlgItem(IDC_REBASE_CHECK_FORCE)->Invalidate();
440 GetDlgItem(IDC_REBASE_CHECK_PRESERVEMERGES)->Invalidate();
441 GetDlgItem(IDC_CHECK_CHERRYPICKED_FROM)->Invalidate();
442 GetDlgItem(IDC_BUTTON_UP)->Invalidate();
443 GetDlgItem(IDC_BUTTON_DOWN)->Invalidate();
444 GetDlgItem(IDC_BUTTON_ADD)->Invalidate();
445 }
446
447 void CRebaseDlg::SetSplitterRange()
448 {
449 if ((m_CommitList)&&(m_ctrlTabCtrl))
450 {
451 CRect rcTop;
452 m_CommitList.GetWindowRect(rcTop);
453 ScreenToClient(rcTop);
454 CRect rcMiddle;
455 m_ctrlTabCtrl.GetWindowRect(rcMiddle);
456 ScreenToClient(rcMiddle);
457 if (rcMiddle.Height() && rcMiddle.Width())
458 m_wndSplitter.SetRange(rcTop.top+60, rcMiddle.bottom-80);
459 }
460 }
461
462 void CRebaseDlg::OnSize(UINT nType,int cx, int cy)
463 {
464 // first, let the resizing take place
465 __super::OnSize(nType, cx, cy);
466
467 //set range
468 SetSplitterRange();
469 }
470
471 void CRebaseDlg::SaveSplitterPos()
472 {
473 if (!IsIconic())
474 {
475 CRegDWORD regPos = CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RebaseDlgSizer");
476 RECT rectSplitter;
477 m_wndSplitter.GetWindowRect(&rectSplitter);
478 ScreenToClient(&rectSplitter);
479 regPos = rectSplitter.top;
480 }
481 }
482
483 void CRebaseDlg::LoadBranchInfo()
484 {
485 m_BranchCtrl.SetMaxHistoryItems(0x7FFFFFFF);
486 m_UpstreamCtrl.SetMaxHistoryItems(0x7FFFFFFF);
487
488 STRING_VECTOR list;
489 list.clear();
490 int current = -1;
491 g_Git.GetBranchList(list,&current,CGit::BRANCH_ALL);
492 m_BranchCtrl.SetList(list);
493 if (current >= 0)
494 m_BranchCtrl.SetCurSel(current);
495 else
496 m_BranchCtrl.AddString(g_Git.GetCurrentBranch(true));
497 list.clear();
498 g_Git.GetBranchList(list, nullptr, CGit::BRANCH_ALL_F);
499 g_Git.GetTagList(list);
500 m_UpstreamCtrl.SetList(list);
501
502 AddBranchToolTips(&m_BranchCtrl);
503
504 if(!m_Upstream.IsEmpty())
505 m_UpstreamCtrl.AddString(m_Upstream);
506 else
507 {
508 //Select pull-remote from current branch
509 CString pullRemote, pullBranch;
510 g_Git.GetRemoteTrackedBranchForHEAD(pullRemote, pullBranch);
511
512 CString defaultUpstream;
513 defaultUpstream.Format(L"remotes/%s/%s", (LPCTSTR)pullRemote, (LPCTSTR)pullBranch);
514 int found = m_UpstreamCtrl.FindStringExact(0, defaultUpstream);
515 if(found >= 0)
516 m_UpstreamCtrl.SetCurSel(found);
517 else
518 m_UpstreamCtrl.SetCurSel(-1);
519 }
520 AddBranchToolTips(&m_UpstreamCtrl);
521 }
522
523 void CRebaseDlg::OnCbnSelchangeBranch()
524 {
525 FetchLogList();
526 }
527
528 void CRebaseDlg::OnCbnSelchangeUpstream()
529 {
530 FetchLogList();
531 }
532
533 void CRebaseDlg::FetchLogList()
534 {
535 CGitHash base,hash,upstream;
536 m_IsFastForward=FALSE;
537
538 if (m_BranchCtrl.GetString().IsEmpty())
539 {
540 m_CommitList.ShowText(CString(MAKEINTRESOURCE(IDS_SELECTBRANCH)));
541 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
542 return;
543 }
544
545 if (g_Git.GetHash(hash, m_BranchCtrl.GetString()))
546 {
547 m_CommitList.ShowText(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_BranchCtrl.GetString() + L"\"."));
548 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
549 return;
550 }
551
552 if (m_UpstreamCtrl.GetString().IsEmpty())
553 {
554 m_CommitList.ShowText(CString(MAKEINTRESOURCE(IDS_SELECTUPSTREAM)));
555 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
556 return;
557 }
558
559 if (g_Git.GetHash(upstream, m_UpstreamCtrl.GetString()))
560 {
561 m_CommitList.ShowText(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_UpstreamCtrl.GetString() + L"\"."));
562 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
563 return;
564 }
565
566 if (hash == upstream)
567 {
568 m_CommitList.Clear();
569 CString text;
570 text.FormatMessage(IDS_REBASE_EQUAL_FMT, (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)this->m_UpstreamCtrl.GetString());
571
572 m_CommitList.ShowText(text);
573 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
574 if (m_bRebaseAutoStart)
575 PostMessage(WM_COMMAND, MAKELONG(IDC_REBASE_ABORT, BN_CLICKED), (LPARAM)GetDlgItem(IDC_REBASE_ABORT)->GetSafeHwnd());
576 return;
577 }
578
579 if (g_Git.IsFastForward(m_BranchCtrl.GetString(), m_UpstreamCtrl.GetString(), &base) && m_Onto.IsEmpty())
580 {
581 this->m_IsFastForward=TRUE;
582
583 m_CommitList.Clear();
584 CString text;
585 text.FormatMessage(IDS_REBASE_FASTFORWARD_FMT, (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)this->m_UpstreamCtrl.GetString(),
586 (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)this->m_UpstreamCtrl.GetString());
587
588 m_CommitList.ShowText(text);
589 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(true);
590 SetContinueButtonText();
591
592 return ;
593 }
594
595 if (!m_bForce && m_Onto.IsEmpty())
596 {
597 if (base == upstream)
598 {
599 m_CommitList.Clear();
600 CString text;
601 text.Format(IDS_REBASE_UPTODATE_FMT, (LPCTSTR)m_BranchCtrl.GetString());
602 m_CommitList.ShowText(text);
603 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
604 SetContinueButtonText();
605 if (m_bRebaseAutoStart)
606 PostMessage(WM_COMMAND, MAKELONG(IDC_REBASE_ABORT, BN_CLICKED), (LPARAM)GetDlgItem(IDC_REBASE_ABORT)->GetSafeHwnd());
607 return;
608 }
609 }
610
611 m_CommitList.Clear();
612 CString refFrom = g_Git.FixBranchName(m_UpstreamCtrl.GetString());
613 CString refTo = g_Git.FixBranchName(m_BranchCtrl.GetString());
614 CString range;
615 range.Format(L"%s..%s", (LPCTSTR)refFrom, (LPCTSTR)refTo);
616 this->m_CommitList.FillGitLog(nullptr, &range, (m_bPreserveMerges ? 0 : CGit::LOG_INFO_NO_MERGE) | CGit::LOG_ORDER_TOPOORDER);
617
618 if( m_CommitList.GetItemCount() == 0 )
619 m_CommitList.ShowText(CString(MAKEINTRESOURCE(IDS_PROC_NOTHINGTOREBASE)));
620
621 m_rewrittenCommitsMap.clear();
622 if (m_bPreserveMerges)
623 {
624 CGitHash head;
625 if (g_Git.GetHash(head, L"HEAD"))
626 {
627 AddLogString(CString(MAKEINTRESOURCE(IDS_PROC_NOHEAD)));
628 return;
629 }
630 CGitHash upstreamHash;
631 if (g_Git.GetHash(upstreamHash, m_Onto.IsEmpty() ? m_UpstreamCtrl.GetString() : m_Onto))
632 {
633 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + (m_Onto.IsEmpty() ? m_UpstreamCtrl.GetString() : m_Onto) + L"\"."), L"TortoiseGit", MB_ICONERROR);
634 return;
635 }
636 CString mergecmd;
637 mergecmd.Format(L"git merge-base --all %s %s", (LPCTSTR)head.ToString(), (LPCTSTR)upstreamHash.ToString());
638 g_Git.Run(mergecmd, [&](const CStringA& line)
639 {
640 CGitHash hash;
641 hash.ConvertFromStrA(line);
642 if (hash.IsEmpty())
643 return;
644 m_rewrittenCommitsMap[hash] = upstreamHash;
645 });
646
647 std::vector<size_t> toDrop;
648 for (size_t i = m_CommitList.m_arShownList.size(); i-- > 0;)
649 {
650 bool preserve = false;
651 GitRevLoglist* pRev = m_CommitList.m_arShownList.SafeGetAt(i);
652 for (const auto& parent : pRev->m_ParentHash)
653 {
654 const auto rewrittenParent = m_rewrittenCommitsMap.find(parent);
655 if (rewrittenParent != m_rewrittenCommitsMap.cend())
656 {
657 preserve = true;
658 break;
659 }
660 }
661 if (preserve)
662 m_rewrittenCommitsMap[pRev->m_CommitHash] = CGitHash();
663 else
664 toDrop.push_back(i);
665 }
666
667 // Drop already included commits
668 std::vector<CGitHash> nonCherryPicked;
669 CString cherryCmd;
670 cherryCmd.Format(L"git rev-list \"%s...%s\" --left-right --cherry-pick", (LPCTSTR)refFrom, (LPCTSTR)refTo);
671 g_Git.Run(cherryCmd, [&](const CStringA& line)
672 {
673 if (line.GetLength() < 2)
674 return;
675 if (line[0] != '>')
676 return;
677 CString hash = CUnicodeUtils::GetUnicode(line.Mid(1));
678 hash.Trim();
679 nonCherryPicked.emplace_back(hash);
680 });
681 for (size_t i = m_CommitList.m_arShownList.size(); i-- > 0;)
682 {
683 GitRevLoglist* pRev = m_CommitList.m_arShownList.SafeGetAt(i);
684 pRev->GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_PICK;
685 if (m_rewrittenCommitsMap.find(pRev->m_CommitHash) != m_rewrittenCommitsMap.cend() && std::find(nonCherryPicked.cbegin(), nonCherryPicked.cend(), pRev->m_CommitHash) == nonCherryPicked.cend())
686 {
687 m_droppedCommitsMap[pRev->m_CommitHash].clear();
688 m_droppedCommitsMap[pRev->m_CommitHash].push_back(pRev->m_ParentHash[0]);
689 toDrop.push_back(i);
690 m_rewrittenCommitsMap.erase(pRev->m_CommitHash);
691 }
692 }
693 std::sort(toDrop.begin(), toDrop.end());
694 toDrop.erase(unique(toDrop.begin(), toDrop.end()), toDrop.end());
695 for (auto it = toDrop.crbegin(); it != toDrop.crend(); ++it)
696 {
697 m_CommitList.m_arShownList.SafeRemoveAt(*it);
698 m_CommitList.m_logEntries.erase(m_CommitList.m_logEntries.begin() + *it);
699 }
700 m_CommitList.SetItemCountEx((int)m_CommitList.m_logEntries.size());
701 }
702
703 #if 0
704 if(m_CommitList.m_logEntries[m_CommitList.m_logEntries.size()-1].m_ParentHash.size() >=0 )
705 {
706 if(upstream == m_CommitList.m_logEntries[m_CommitList.m_logEntries.size()-1].m_ParentHash[0])
707 {
708 m_CommitList.Clear();
709 m_CommitList.ShowText(L"Nothing Rebase");
710 }
711 }
712 #endif
713
714 m_tooltips.Pop();
715 AddBranchToolTips(&this->m_BranchCtrl);
716 AddBranchToolTips(&this->m_UpstreamCtrl);
717
718 bool bHasSKip = false;
719 if (!m_bPreserveMerges)
720 {
721 // Default all actions to 'pick'
722 std::unordered_map<CGitHash, size_t> revIxMap;
723 for (size_t i = 0; i < m_CommitList.m_logEntries.size(); ++i)
724 {
725 GitRevLoglist& rev = m_CommitList.m_logEntries.GetGitRevAt(i);
726 rev.GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_PICK;
727 revIxMap[rev.m_CommitHash] = i;
728 }
729
730 // Default to skip when already in upstream
731 if (!m_Onto.IsEmpty())
732 refFrom = g_Git.FixBranchName(m_Onto);
733 CString cherryCmd;
734 cherryCmd.Format(L"git.exe cherry \"%s\" \"%s\"", (LPCTSTR)refFrom, (LPCTSTR)refTo);
735 g_Git.Run(cherryCmd, [&](const CStringA& line)
736 {
737 if (line.GetLength() < 2)
738 return;
739 if (line[0] != '-')
740 return; // Don't skip (only skip commits starting with a '-')
741 CString hash = CUnicodeUtils::GetUnicode(line.Mid(1));
742 hash.Trim();
743 auto itIx = revIxMap.find(CGitHash(hash));
744 if (itIx == revIxMap.end())
745 return; // Not found?? Should not occur...
746
747 // Found. Skip it.
748 m_CommitList.m_logEntries.GetGitRevAt(itIx->second).GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_SKIP;
749 bHasSKip = true;
750 });
751 }
752 m_CommitList.Invalidate();
753 if (bHasSKip)
754 {
755 m_CtrlStatusText.SetWindowText(CString(MAKEINTRESOURCE(IDS_REBASE_AUTOSKIPPED)));
756 m_bStatusWarning = true;
757 }
758 else
759 {
760 m_CtrlStatusText.SetWindowText(m_sStatusText);
761 m_bStatusWarning = false;
762 }
763 m_CtrlStatusText.Invalidate();
764
765 if(m_CommitList.m_IsOldFirst)
766 this->m_CurrentRebaseIndex = -1;
767 else
768 this->m_CurrentRebaseIndex = (int)m_CommitList.m_logEntries.size();
769
770 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(m_bPreserveMerges || m_CommitList.GetItemCount());
771 SetContinueButtonText();
772 }
773
774 void CRebaseDlg::AddBranchToolTips(CHistoryCombo *pBranch)
775 {
776 if(pBranch)
777 {
778 CString text=pBranch->GetString();
779 CString tooltip;
780
781 if (text.IsEmpty())
782 {
783 pBranch->DisableTooltip();
784 return;
785 }
786
787 GitRev rev;
788 if (rev.GetCommit(text + L"^{}"))
789 {
790 MessageBox(L"Failed to get commit.\n" + rev.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
791 pBranch->DisableTooltip();
792 return;
793 }
794
795 tooltip.Format(L"%s: %s\n%s: %s <%s>\n%s: %s\n%s:\n%s\n%s",
796 (LPCTSTR)CString(MAKEINTRESOURCE(IDS_LOG_REVISION)),
797 (LPCTSTR)rev.m_CommitHash.ToString(),
798 (LPCTSTR)CString(MAKEINTRESOURCE(IDS_LOG_AUTHOR)),
799 (LPCTSTR)rev.GetAuthorName(),
800 (LPCTSTR)rev.GetAuthorEmail(),
801 (LPCTSTR)CString(MAKEINTRESOURCE(IDS_LOG_DATE)),
802 (LPCTSTR)CLoglistUtils::FormatDateAndTime(rev.GetAuthorDate(), DATE_LONGDATE),
803 (LPCTSTR)CString(MAKEINTRESOURCE(IDS_LOG_MESSAGE)),
804 (LPCTSTR)rev.GetSubject(),
805 (LPCTSTR)rev.GetBody());
806
807 pBranch->DisableTooltip();
808 this->m_tooltips.AddTool(pBranch->GetComboBoxCtrl(),tooltip);
809 }
810 }
811
812 BOOL CRebaseDlg::PreTranslateMessage(MSG*pMsg)
813 {
814 if (pMsg->message == WM_KEYDOWN)
815 {
816 switch (pMsg->wParam)
817 {
818 case ' ':
819 if (LogListHasFocus(pMsg->hwnd)
820 && LogListHasMenuItem(CGitLogListBase::ID_REBASE_PICK)
821 && LogListHasMenuItem(CGitLogListBase::ID_REBASE_SQUASH)
822 && LogListHasMenuItem(CGitLogListBase::ID_REBASE_EDIT)
823 && LogListHasMenuItem(CGitLogListBase::ID_REBASE_SKIP))
824 {
825 m_CommitList.ShiftSelectedRebaseAction();
826 return TRUE;
827 }
828 break;
829 case 'P':
830 if (LogListHasFocus(pMsg->hwnd) && LogListHasMenuItem(CGitLogListBase::ID_REBASE_PICK))
831 {
832 m_CommitList.SetSelectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_PICK);
833 return TRUE;
834 }
835 break;
836 case 'S':
837 if (LogListHasFocus(pMsg->hwnd) && LogListHasMenuItem(CGitLogListBase::ID_REBASE_SKIP))
838 {
839 m_CommitList.SetSelectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SKIP);
840 return TRUE;
841 }
842 break;
843 case 'Q':
844 if (LogListHasFocus(pMsg->hwnd) && LogListHasMenuItem(CGitLogListBase::ID_REBASE_SQUASH))
845 {
846 m_CommitList.SetSelectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SQUASH);
847 return TRUE;
848 }
849 break;
850 case 'E':
851 if (LogListHasFocus(pMsg->hwnd) && LogListHasMenuItem(CGitLogListBase::ID_REBASE_EDIT))
852 {
853 m_CommitList.SetSelectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_EDIT);
854 return TRUE;
855 }
856 break;
857 case 'U':
858 if (LogListHasFocus(pMsg->hwnd) && GetDlgItem(IDC_BUTTON_UP)->IsWindowEnabled() == TRUE)
859 {
860 OnBnClickedButtonUp();
861 return TRUE;
862 }
863 break;
864 case 'D':
865 if (LogListHasFocus(pMsg->hwnd) && GetDlgItem(IDC_BUTTON_DOWN)->IsWindowEnabled() == TRUE)
866 {
867 OnBnClickedButtonDown();
868 return TRUE;
869 }
870 break;
871 case 'A':
872 if(LogListHasFocus(pMsg->hwnd) && GetAsyncKeyState(VK_CONTROL) & 0x8000)
873 {
874 // select all entries
875 for (int i = 0; i < m_CommitList.GetItemCount(); ++i)
876 m_CommitList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
877 return TRUE;
878 }
879 break;
880 case VK_F5:
881 {
882 Refresh();
883 return TRUE;
884 }
885 break;
886 case VK_RETURN:
887 {
888 if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
889 {
890 if (GetDlgItem(IDC_REBASE_CONTINUE)->IsWindowEnabled())
891 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
892 else if (GetDlgItem(IDC_REBASE_ABORT)->IsWindowEnabled())
893 GetDlgItem(IDC_REBASE_ABORT)->SetFocus();
894 else
895 GetDlgItem(IDHELP)->SetFocus();
896 return TRUE;
897 }
898 }
899 break;
900 /* Avoid TAB control destroy but dialog exist*/
901 case VK_ESCAPE:
902 case VK_CANCEL:
903 {
904 TCHAR buff[128] = { 0 };
905 ::GetClassName(pMsg->hwnd,buff,128);
906
907
908 /* Use MSFTEDIT_CLASS http://msdn.microsoft.com/en-us/library/bb531344.aspx */
909 if (_wcsnicmp(buff, MSFTEDIT_CLASS, 128) == 0 || //Unicode and MFC 2012 and later
910 _wcsnicmp(buff, RICHEDIT_CLASS, 128) == 0 || //ANSI or MFC 2010
911 _wcsnicmp(buff, L"Scintilla", 128) == 0 ||
912 _wcsnicmp(buff, L"SysListView32", 128) == 0 ||
913 ::GetParent(pMsg->hwnd) == this->m_ctrlTabCtrl.m_hWnd)
914 {
915 this->PostMessage(WM_KEYDOWN,VK_ESCAPE,0);
916 return TRUE;
917 }
918 }
919 }
920 }
921 else if (pMsg->message == WM_NEXTDLGCTL)
922 {
923 HWND hwnd = GetFocus()->GetSafeHwnd();
924 if (hwnd == m_LogMessageCtrl.GetSafeHwnd() || hwnd == m_wndOutputRebase.GetSafeHwnd())
925 {
926 if (GetDlgItem(IDC_REBASE_CONTINUE)->IsWindowEnabled())
927 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
928 else if (GetDlgItem(IDC_REBASE_ABORT)->IsWindowEnabled())
929 GetDlgItem(IDC_REBASE_ABORT)->SetFocus();
930 else
931 GetDlgItem(IDHELP)->SetFocus();
932 return TRUE;
933 }
934 }
935 return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
936 }
937
938 bool CRebaseDlg::LogListHasFocus(HWND hwnd)
939 {
940 TCHAR buff[128] = { 0 };
941 ::GetClassName(hwnd, buff, 128);
942
943 if (_wcsnicmp(buff, L"SysListView32", 128) == 0)
944 return true;
945 return false;
946 }
947
948 bool CRebaseDlg::LogListHasMenuItem(int i)
949 {
950 return (m_CommitList.m_ContextMenuMask & m_CommitList.GetContextMenuBit(i)) != 0;
951 }
952
953 int CRebaseDlg::CheckRebaseCondition()
954 {
955 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
956
957 if( !g_Git.CheckCleanWorkTree() )
958 {
959 if ((!m_IsCherryPick && g_Git.GetConfigValueBool(L"rebase.autostash")) || CMessageBox::Show(GetSafeHwnd(), IDS_ERROR_NOCLEAN_STASH, IDS_APPNAME, 1, IDI_QUESTION, IDS_STASHBUTTON, IDS_ABORTBUTTON) == 1)
960 {
961 CString out;
962 CString cmd = L"git.exe stash";
963 this->AddLogString(cmd);
964 if (g_Git.Run(cmd, &out, CP_UTF8))
965 {
966 MessageBox(out, L"TortoiseGit", MB_OK | MB_ICONERROR);
967 return -1;
968 }
969 m_bStashed = true;
970 }
971 else
972 return -1;
973 }
974 //Todo Check $REBASE_ROOT
975 //Todo Check $DOTEST
976
977 if (!CAppUtils::CheckUserData(GetSafeHwnd()))
978 return -1;
979
980 if (!m_IsCherryPick)
981 {
982 CString error;
983 DWORD exitcode = 0xFFFFFFFF;
984 if (CHooks::Instance().PreRebase(g_Git.m_CurrentDir, m_UpstreamCtrl.GetString(), m_BranchCtrl.GetString(), exitcode, error))
985 {
986 if (exitcode)
987 {
988 CString temp;
989 temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
990 MessageBox(temp, L"TortoiseGit", MB_OK | MB_ICONERROR);
991 return -1;
992 }
993 }
994 }
995
996 return 0;
997 }
998
999 void CRebaseDlg::CheckRestoreStash()
1000 {
1001 bool autoStash = !m_IsCherryPick && g_Git.GetConfigValueBool(L"rebase.autostash");
1002 if (m_bStashed && (autoStash || CMessageBox::Show(GetSafeHwnd(), IDS_DCOMMIT_STASH_POP, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION) == IDYES))
1003 CAppUtils::StashPop(GetSafeHwnd(), autoStash ? 0 : 1);
1004 m_bStashed = false;
1005 }
1006
1007 int CRebaseDlg::StartRebase()
1008 {
1009 CString cmd,out;
1010 m_OrigHEADBranch = g_Git.GetCurrentBranch(true);
1011
1012 m_OrigHEADHash.Empty();
1013 if (g_Git.GetHash(m_OrigHEADHash, L"HEAD"))
1014 {
1015 AddLogString(CString(MAKEINTRESOURCE(IDS_PROC_NOHEAD)));
1016 return -1;
1017 }
1018 //Todo
1019 //git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
1020 // echo "detached HEAD" > "$DOTEST"/head-name
1021
1022 cmd.Format(L"git.exe update-ref ORIG_HEAD %s", (LPCTSTR)m_OrigHEADHash.ToString());
1023 if(g_Git.Run(cmd,&out,CP_UTF8))
1024 {
1025 AddLogString(L"update ORIG_HEAD Fail");
1026 return -1;
1027 }
1028
1029 m_OrigUpstreamHash.Empty();
1030 if (g_Git.GetHash(m_OrigUpstreamHash, (m_IsCherryPick || m_Onto.IsEmpty()) ? m_UpstreamCtrl.GetString() : m_Onto))
1031 {
1032 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + ((m_IsCherryPick || m_Onto.IsEmpty()) ? m_UpstreamCtrl.GetString() : m_Onto) + L"\"."), L"TortoiseGit", MB_ICONERROR);
1033 return -1;
1034 }
1035
1036 if( !this->m_IsCherryPick )
1037 {
1038 cmd.Format(L"git.exe checkout -f %s --", (LPCTSTR)m_OrigUpstreamHash.ToString());
1039 this->AddLogString(cmd);
1040 if (RunGitCmdRetryOrAbort(cmd))
1041 return -1;
1042 }
1043
1044 CString log;
1045 if( !this->m_IsCherryPick )
1046 {
1047 if (g_Git.GetHash(m_OrigBranchHash, m_BranchCtrl.GetString()))
1048 {
1049 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_BranchCtrl.GetString() + L"\"."), L"TortoiseGit", MB_ICONERROR);
1050 return -1;
1051 }
1052 log.Format(L"%s\r\n", (LPCTSTR)CString(MAKEINTRESOURCE(IDS_PROC_REBASE_STARTREBASE)));
1053 }
1054 else
1055 log.Format(L"%s\r\n", (LPCTSTR)CString(MAKEINTRESOURCE(IDS_PROC_REBASE_STARTCHERRYPICK)));
1056
1057 this->AddLogString(log);
1058 return 0;
1059 }
1060 int CRebaseDlg::VerifyNoConflict()
1061 {
1062 int hasConflicts = g_Git.HasWorkingTreeConflicts();
1063 if (hasConflicts < 0)
1064 {
1065 AddLogString(g_Git.GetGitLastErr(L"Checking for conflicts failed.", CGit::GIT_CMD_CHECKCONFLICTS));
1066 return -1;
1067 }
1068 if (hasConflicts)
1069 {
1070 CMessageBox::Show(GetSafeHwnd(), IDS_PROGRS_CONFLICTSOCCURRED, IDS_APPNAME, MB_OK | MB_ICONEXCLAMATION);
1071 auto locker(m_FileListCtrl.AcquireReadLock());
1072 auto pos = m_FileListCtrl.GetFirstSelectedItemPosition();
1073 while (pos)
1074 m_FileListCtrl.SetItemState(m_FileListCtrl.GetNextSelectedItem(pos), 0, LVIS_SELECTED);
1075 int nListItems = m_FileListCtrl.GetItemCount();
1076 for (int i = 0; i < nListItems; ++i)
1077 {
1078 auto entry = m_FileListCtrl.GetListEntry(i);
1079 if (entry->m_Action & CTGitPath::LOGACTIONS_UNMERGED)
1080 {
1081 m_FileListCtrl.EnsureVisible(i, FALSE);
1082 m_FileListCtrl.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
1083 m_FileListCtrl.SetFocus();
1084 return -1;
1085 }
1086 }
1087 return -1;
1088 }
1089 CleanUpRebaseActiveFolder();
1090 return 0;
1091 }
1092
1093 int CRebaseDlg::FinishRebase()
1094 {
1095 if (m_bFinishedRebase)
1096 return 0;
1097
1098 m_bFinishedRebase = true;
1099 if(this->m_IsCherryPick) //cherry pick mode no "branch", working at upstream branch
1100 {
1101 m_sStatusText.LoadString(IDS_DONE);
1102 m_CtrlStatusText.SetWindowText(m_sStatusText);
1103 m_bStatusWarning = false;
1104 m_CtrlStatusText.Invalidate();
1105 return 0;
1106 }
1107
1108 RewriteNotes();
1109
1110 CGitHash head;
1111 if (g_Git.GetHash(head, L"HEAD"))
1112 {
1113 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1114 return -1;
1115 }
1116
1117 m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1118
1119 if (g_Git.IsLocalBranch(m_BranchCtrl.GetString()))
1120 {
1121 CString cmd;
1122 cmd.Format(L"git.exe checkout -f -B %s %s --", (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)head.ToString());
1123 AddLogString(cmd);
1124 if (RunGitCmdRetryOrAbort(cmd))
1125 return -1;
1126 }
1127
1128 CString cmd;
1129 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)head.ToString());
1130 AddLogString(cmd);
1131 if (RunGitCmdRetryOrAbort(cmd))
1132 return -1;
1133
1134 while (m_ctrlTabCtrl.GetTabsNum() > 1)
1135 m_ctrlTabCtrl.RemoveTab(0);
1136 m_CtrlStatusText.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_REBASEFINISHED)));
1137 m_sStatusText.LoadString(IDS_PROC_REBASEFINISHED);
1138 m_bStatusWarning = false;
1139 m_CtrlStatusText.Invalidate();
1140
1141 m_bRebaseAutoEnd = m_bRebaseAutoStart;
1142
1143 return 0;
1144 }
1145
1146 void CRebaseDlg::RewriteNotes()
1147 {
1148 CString rewrites;
1149 for (const auto& entry : m_rewrittenCommitsMap)
1150 {
1151 if (entry.second.IsEmpty())
1152 continue;
1153 rewrites += entry.first.ToString();
1154 rewrites += L' ';
1155 rewrites += entry.second.ToString();
1156 rewrites += L'\n';
1157 }
1158 if (rewrites.IsEmpty())
1159 return;
1160 CString tmpfile = GetTempFile();
1161 tmpfile.Replace(L'\\', L'/');
1162 if (!CStringUtils::WriteStringToTextFile(tmpfile, rewrites))
1163 return;
1164 SCOPE_EXIT{ ::DeleteFile(tmpfile); };
1165 CString pipefile = GetTempFile();
1166 pipefile.Replace(L'\\', L'/');
1167 CString pipecmd;
1168 pipecmd.Format(L"git notes copy --for-rewrite=rebase < %s", (LPCTSTR)tmpfile);
1169 if (!CStringUtils::WriteStringToTextFile(pipefile, pipecmd))
1170 return;
1171 SCOPE_EXIT{ ::DeleteFile(pipefile); };
1172 CString out;
1173 g_Git.Run(L"bash.exe " + pipefile, &out, CP_UTF8);
1174 }
1175
1176 void CRebaseDlg::OnBnClickedContinue()
1177 {
1178 if( m_RebaseStage == REBASE_DONE)
1179 {
1180 OnOK();
1181 CleanUpRebaseActiveFolder();
1182 CheckRestoreStash();
1183 SaveSplitterPos();
1184 return;
1185 }
1186
1187 if (m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage == CHOOSE_COMMIT_PICK_MODE)
1188 {
1189 if (CAppUtils::IsTGitRebaseActive(GetSafeHwnd()))
1190 return;
1191 if (CheckRebaseCondition())
1192 return;
1193 }
1194
1195 m_bAbort = FALSE;
1196 if( this->m_IsFastForward )
1197 {
1198 GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1199 CString cmd,out;
1200 if (g_Git.GetHash(m_OrigBranchHash, m_BranchCtrl.GetString()))
1201 {
1202 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_BranchCtrl.GetString() + L"\"."), L"TortoiseGit", MB_ICONERROR);
1203 GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1204 return;
1205 }
1206 if (g_Git.GetHash(m_OrigUpstreamHash, m_UpstreamCtrl.GetString()))
1207 {
1208 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_UpstreamCtrl.GetString() + L"\"."), L"TortoiseGit", MB_ICONERROR);
1209 GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1210 return;
1211 }
1212
1213 if(!g_Git.IsFastForward(this->m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString()))
1214 {
1215 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1216 AddLogString(L"No fast forward possible.\r\nMaybe repository changed");
1217 GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1218 return;
1219 }
1220
1221 if (g_Git.IsLocalBranch(m_BranchCtrl.GetString()))
1222 {
1223 cmd.Format(L"git.exe checkout --no-track -f -B %s %s --", (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)m_UpstreamCtrl.GetString());
1224 AddLogString(cmd);
1225 if (RunGitCmdRetryOrAbort(cmd))
1226 {
1227 GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1228 return;
1229 }
1230 AddLogString(out);
1231 out.Empty();
1232 }
1233 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)g_Git.FixBranchName(this->m_UpstreamCtrl.GetString()));
1234 CString log;
1235 log.Format(IDS_PROC_REBASE_FFTO, (LPCTSTR)m_UpstreamCtrl.GetString());
1236 this->AddLogString(log);
1237
1238 AddLogString(cmd);
1239 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1240 if (RunGitCmdRetryOrAbort(cmd))
1241 {
1242 GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1243 return;
1244 }
1245 AddLogString(out);
1246 AddLogString(CString(MAKEINTRESOURCE(IDS_DONE)));
1247 m_RebaseStage = REBASE_DONE;
1248 UpdateCurrentStatus();
1249
1250 if (m_bRebaseAutoStart)
1251 this->PostMessage(WM_COMMAND, MAKELONG(IDC_REBASE_CONTINUE, BN_CLICKED), (LPARAM)GetDlgItem(IDC_REBASE_CONTINUE)->GetSafeHwnd());
1252
1253 return;
1254 }
1255
1256 if( m_RebaseStage == CHOOSE_BRANCH|| m_RebaseStage == CHOOSE_COMMIT_PICK_MODE )
1257 {
1258 m_RebaseStage = REBASE_START;
1259 m_FileListCtrl.Clear();
1260 m_FileListCtrl.SetHasCheckboxes(false);
1261 m_FileListCtrl.m_CurrentVersion.Empty();
1262 m_ctrlTabCtrl.SetTabLabel(REBASE_TAB_CONFLICT, CString(MAKEINTRESOURCE(IDS_PROC_CONFLICTFILES)));
1263 m_ctrlTabCtrl.AddTab(&m_wndOutputRebase, CString(MAKEINTRESOURCE(IDS_LOG)), 2);
1264 m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1265 }
1266
1267 if( m_RebaseStage == REBASE_FINISH )
1268 {
1269 if(FinishRebase())
1270 return ;
1271
1272 SaveSplitterPos();
1273 OnOK();
1274 }
1275
1276 if( m_RebaseStage == REBASE_SQUASH_CONFLICT)
1277 {
1278 if(VerifyNoConflict())
1279 return;
1280 if (CAppUtils::MessageContainsConflictHints(GetSafeHwnd(), m_LogMessageCtrl.GetText()))
1281 return;
1282 GitRevLoglist* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1283 if(this->CheckNextCommitIsSquash())
1284 {//next commit is not squash;
1285 m_RebaseStage = REBASE_SQUASH_EDIT;
1286 this->OnRebaseUpdateUI(0,0);
1287 this->UpdateCurrentStatus();
1288 return ;
1289 }
1290 m_RebaseStage=REBASE_CONTINUE;
1291 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1292 m_forRewrite.push_back(curRev->m_CommitHash);
1293 this->UpdateCurrentStatus();
1294 }
1295
1296 if( m_RebaseStage == REBASE_CONFLICT )
1297 {
1298 if(VerifyNoConflict())
1299 return;
1300
1301 if (CAppUtils::MessageContainsConflictHints(GetSafeHwnd(), m_LogMessageCtrl.GetText()))
1302 return;
1303
1304 m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1305
1306 GitRevLoglist* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1307 // ***************************************************
1308 // ATTENTION: Similar code in CommitDlg.cpp!!!
1309 // ***************************************************
1310 CMassiveGitTask mgtReAddAfterCommit(L"add --ignore-errors -f");
1311 CMassiveGitTask mgtReDelAfterCommit(L"rm --cached --ignore-unmatch");
1312 CMassiveGitTask mgtAdd(L"add -f");
1313 CMassiveGitTask mgtUpdateIndexForceRemove(L"update-index --force-remove");
1314 CMassiveGitTask mgtUpdateIndex(L"update-index");
1315 CMassiveGitTask mgtRm(L"rm --ignore-unmatch");
1316 CMassiveGitTask mgtRmFCache(L"rm -f --cache");
1317 CMassiveGitTask mgtReset(L"reset", TRUE, true);
1318 auto locker(m_FileListCtrl.AcquireReadLock());
1319 for (int i = 0; i < m_FileListCtrl.GetItemCount(); i++)
1320 {
1321 auto entry = m_FileListCtrl.GetListEntry(i);
1322 if (entry->m_Checked)
1323 {
1324 if ((entry->m_Action & CTGitPath::LOGACTIONS_UNVER) || (entry->IsDirectory() && !(entry->m_Action & CTGitPath::LOGACTIONS_DELETED)))
1325 mgtAdd.AddFile(entry->GetGitPathString());
1326 else if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
1327 mgtUpdateIndexForceRemove.AddFile(entry->GetGitPathString());
1328 else
1329 mgtUpdateIndex.AddFile(entry->GetGitPathString());
1330
1331 if ((entry->m_Action & CTGitPath::LOGACTIONS_REPLACED) && !entry->GetGitOldPathString().IsEmpty())
1332 mgtRm.AddFile(entry->GetGitOldPathString());
1333 }
1334 else
1335 {
1336 if (entry->m_Action & CTGitPath::LOGACTIONS_ADDED || entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
1337 {
1338 mgtRmFCache.AddFile(entry->GetGitPathString());
1339 mgtReAddAfterCommit.AddFile(*entry);
1340
1341 if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED && !entry->GetGitOldPathString().IsEmpty())
1342 {
1343 mgtReset.AddFile(entry->GetGitOldPathString());
1344 mgtReDelAfterCommit.AddFile(entry->GetGitOldPathString());
1345 }
1346 }
1347 else if(!(entry->m_Action & CTGitPath::LOGACTIONS_UNVER))
1348 {
1349 mgtReset.AddFile(entry->GetGitPathString());
1350 if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED && !(entry->m_Action & CTGitPath::LOGACTIONS_MISSING))
1351 mgtReDelAfterCommit.AddFile(entry->GetGitPathString());
1352 }
1353 }
1354 }
1355
1356 BOOL cancel = FALSE;
1357 bool successful = true;
1358 successful = successful && mgtAdd.Execute(cancel);
1359 successful = successful && mgtUpdateIndexForceRemove.Execute(cancel);
1360 successful = successful && mgtUpdateIndex.Execute(cancel);
1361 successful = successful && mgtRm.Execute(cancel);
1362 successful = successful && mgtRmFCache.Execute(cancel);
1363 successful = successful && mgtReset.Execute(cancel);
1364
1365 if (!successful)
1366 {
1367 AddLogString(L"An error occurred while updating the index.");
1368 return;
1369 }
1370
1371 CString out;
1372 CString cmd;
1373 cmd.Format(L"git.exe commit --allow-empty-message -C %s", (LPCTSTR)curRev->m_CommitHash.ToString());
1374
1375 AddLogString(cmd);
1376
1377 if(g_Git.Run(cmd,&out,CP_UTF8))
1378 {
1379 AddLogString(out);
1380 if(!g_Git.CheckCleanWorkTree())
1381 {
1382 CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", MB_OK | MB_ICONERROR);
1383 return;
1384 }
1385 }
1386
1387 AddLogString(out);
1388
1389 // update commit message if needed
1390 CString str = m_LogMessageCtrl.GetText().Trim();
1391 if (str != (curRev->GetSubject() + L'\n' + curRev->GetBody()).Trim())
1392 {
1393 if (str.IsEmpty())
1394 {
1395 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_COMMITMESSAGE_EMPTY,IDS_APPNAME, MB_OK | MB_ICONERROR);
1396 return;
1397 }
1398 CString tempfile = ::GetTempFile();
1399 SCOPE_EXIT{ ::DeleteFile(tempfile); };
1400 if (CAppUtils::SaveCommitUnicodeFile(tempfile, str))
1401 {
1402 CMessageBox::Show(GetSafeHwnd(), L"Could not save commit message", L"TortoiseGit", MB_OK | MB_ICONERROR);
1403 return;
1404 }
1405
1406 out.Empty();
1407 cmd.Format(L"git.exe commit --amend -F \"%s\"", (LPCTSTR)tempfile);
1408 AddLogString(cmd);
1409
1410 if (g_Git.Run(cmd, &out, CP_UTF8))
1411 {
1412 AddLogString(out);
1413 if (!g_Git.CheckCleanWorkTree())
1414 {
1415 CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", MB_OK | MB_ICONERROR);
1416 return;
1417 }
1418 }
1419
1420 AddLogString(out);
1421 }
1422
1423 if (((DWORD)CRegStdDWORD(L"Software\\TortoiseGit\\ReaddUnselectedAddedFilesAfterCommit", TRUE)) == TRUE)
1424 {
1425 BOOL cancel2 = FALSE;
1426 mgtReAddAfterCommit.Execute(cancel2);
1427 mgtReDelAfterCommit.Execute(cancel2);
1428 }
1429
1430 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_EDIT)
1431 {
1432 m_RebaseStage=REBASE_EDIT;
1433 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1434 this->UpdateCurrentStatus();
1435 return;
1436 }
1437 else
1438 {
1439 m_RebaseStage=REBASE_CONTINUE;
1440 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1441 this->UpdateCurrentStatus();
1442
1443 if (CheckNextCommitIsSquash() == 0) // remember commit msg after edit if next commit if squash
1444 ResetParentForSquash(str);
1445 else
1446 {
1447 m_SquashMessage.Empty();
1448 CGitHash head;
1449 if (g_Git.GetHash(head, L"HEAD"))
1450 {
1451 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1452 return;
1453 }
1454 m_rewrittenCommitsMap[curRev->m_CommitHash] = head;
1455 }
1456 }
1457 }
1458
1459 if ((m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_CONTINUE || m_bSplitCommit || m_RebaseStage == REBASE_SQUASH_EDIT) && CheckNextCommitIsSquash() && (m_bSplitCommit || !g_Git.CheckCleanWorkTree(true)))
1460 {
1461 if (!m_bSplitCommit && CMessageBox::Show(GetSafeHwnd(), IDS_PROC_REBASE_CONTINUE_NOTCLEAN, IDS_APPNAME, 1, IDI_ERROR, IDS_MSGBOX_OK, IDS_ABORTBUTTON) == 2)
1462 return;
1463 BOOL isFirst = TRUE;
1464 do
1465 {
1466 CCommitDlg dlg;
1467 if (isFirst)
1468 dlg.m_sLogMessage = m_LogMessageCtrl.GetText();
1469 dlg.m_bWholeProject = true;
1470 dlg.m_bSelectFilesForCommit = true;
1471 dlg.m_bCommitAmend = isFirst && (m_RebaseStage != REBASE_SQUASH_EDIT); // do not amend on squash_edit stage, we need a normal commit there
1472 if (isFirst && m_RebaseStage == REBASE_SQUASH_EDIT)
1473 {
1474 if (m_iSquashdate != 2)
1475 dlg.SetTime(m_SquashFirstMetaData.time);
1476 dlg.SetAuthor(m_SquashFirstMetaData.GetAuthor());
1477 }
1478 CTGitPathList gpl;
1479 gpl.AddPath(CTGitPath());
1480 dlg.m_pathList = gpl;
1481 dlg.m_bAmendDiffToLastCommit = !m_bSplitCommit;
1482 dlg.m_bNoPostActions = true;
1483 if (dlg.m_bCommitAmend)
1484 dlg.m_AmendStr = dlg.m_sLogMessage;
1485 dlg.m_bWarnDetachedHead = false;
1486
1487 if (dlg.DoModal() != IDOK)
1488 return;
1489
1490 isFirst = !m_bSplitCommit; // only select amend on second+ runs if not in split commit mode
1491
1492 m_SquashMessage.Empty();
1493 } while (!g_Git.CheckCleanWorkTree() || (m_bSplitCommit && CMessageBox::Show(GetSafeHwnd(), IDS_REBASE_ADDANOTHERCOMMIT, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION) == IDYES));
1494
1495 m_bSplitCommit = FALSE;
1496 UpdateData(FALSE);
1497
1498 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1499 m_RebaseStage = REBASE_CONTINUE;
1500 GitRevLoglist* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1501 CGitHash head;
1502 if (g_Git.GetHash(head, L"HEAD"))
1503 {
1504 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1505 return;
1506 }
1507 m_rewrittenCommitsMap[curRev->m_CommitHash] = head;
1508 for (const auto& hash : m_forRewrite)
1509 m_rewrittenCommitsMap[hash] = head;
1510 m_forRewrite.clear();
1511 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1512 this->UpdateCurrentStatus();
1513 }
1514
1515 if( m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_SQUASH_EDIT )
1516 {
1517 CString str;
1518 GitRevLoglist* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1519
1520 str=this->m_LogMessageCtrl.GetText();
1521 if(str.Trim().IsEmpty())
1522 {
1523 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_COMMITMESSAGE_EMPTY,IDS_APPNAME, MB_OK | MB_ICONERROR);
1524 return;
1525 }
1526
1527 CString tempfile=::GetTempFile();
1528 SCOPE_EXIT{ ::DeleteFile(tempfile); };
1529 if (CAppUtils::SaveCommitUnicodeFile(tempfile, str))
1530 {
1531 CMessageBox::Show(GetSafeHwnd(), L"Could not save commit message", L"TortoiseGit", MB_OK | MB_ICONERROR);
1532 return;
1533 }
1534
1535 CString out,cmd;
1536
1537 if (m_RebaseStage == REBASE_SQUASH_EDIT)
1538 cmd.Format(L"git.exe commit %s-F \"%s\"", (LPCTSTR)m_SquashFirstMetaData.GetAsParam(m_iSquashdate == 2), (LPCTSTR)tempfile);
1539 else
1540 {
1541 CString options;
1542 int isEmpty = IsCommitEmpty(curRev->m_CommitHash);
1543 if (isEmpty == 1)
1544 options = L"--allow-empty ";
1545 else if (isEmpty < 0)
1546 return;
1547 cmd.Format(L"git.exe commit --amend %s-F \"%s\"", (LPCTSTR)options, (LPCTSTR)tempfile);
1548 }
1549
1550 if(g_Git.Run(cmd,&out,CP_UTF8))
1551 {
1552 if(!g_Git.CheckCleanWorkTree())
1553 {
1554 CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", MB_OK | MB_ICONERROR);
1555 return;
1556 }
1557 }
1558
1559 AddLogString(out);
1560 if (CheckNextCommitIsSquash() == 0 && m_RebaseStage != REBASE_SQUASH_EDIT) // remember commit msg after edit if next commit if squash; but don't do this if ...->squash(reset here)->pick->squash
1561 {
1562 ResetParentForSquash(str);
1563 }
1564 else
1565 m_SquashMessage.Empty();
1566 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1567 m_RebaseStage=REBASE_CONTINUE;
1568 CGitHash head;
1569 if (g_Git.GetHash(head, L"HEAD"))
1570 {
1571 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1572 return;
1573 }
1574 m_rewrittenCommitsMap[curRev->m_CommitHash] = head; // we had a reset to parent, so this is not the correct hash
1575 for (const auto& hash : m_forRewrite)
1576 m_rewrittenCommitsMap[hash] = head;
1577 m_forRewrite.clear();
1578 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1579 this->UpdateCurrentStatus();
1580 }
1581
1582
1583 InterlockedExchange(&m_bThreadRunning, TRUE);
1584 SetControlEnable();
1585
1586 if (!AfxBeginThread(RebaseThreadEntry, this))
1587 {
1588 InterlockedExchange(&m_bThreadRunning, FALSE);
1589 CMessageBox::Show(GetSafeHwnd(), L"Create Rebase Thread Fail", L"TortoiseGit", MB_OK | MB_ICONERROR);
1590 SetControlEnable();
1591 }
1592 }
1593
1594 void CRebaseDlg::ResetParentForSquash(const CString& commitMessage)
1595 {
1596 m_SquashMessage = commitMessage;
1597 // reset parent so that we can do "git cherry-pick --no-commit" w/o introducing an unwanted commit
1598 CString cmd = L"git.exe reset --soft HEAD~1";
1599 m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1600 if (RunGitCmdRetryOrAbort(cmd))
1601 return;
1602 }
1603
1604 int CRebaseDlg::CheckNextCommitIsSquash()
1605 {
1606 int index;
1607 if(m_CommitList.m_IsOldFirst)
1608 index=m_CurrentRebaseIndex+1;
1609 else
1610 index=m_CurrentRebaseIndex-1;
1611
1612 GitRevLoglist* curRev;
1613 do
1614 {
1615 if(index<0)
1616 return -1;
1617 if(index>= m_CommitList.GetItemCount())
1618 return -1;
1619
1620 curRev = m_CommitList.m_arShownList.SafeGetAt(index);
1621
1622 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1623 return 0;
1624 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SKIP)
1625 {
1626 if(m_CommitList.m_IsOldFirst)
1627 ++index;
1628 else
1629 --index;
1630 }
1631 else
1632 return -1;
1633
1634 } while(curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SKIP);
1635
1636 return -1;
1637 }
1638
1639 int CRebaseDlg::GoNext()
1640 {
1641 if(m_CommitList.m_IsOldFirst)
1642 ++m_CurrentRebaseIndex;
1643 else
1644 --m_CurrentRebaseIndex;
1645 return 0;
1646 }
1647
1648 void CRebaseDlg::SetContinueButtonText()
1649 {
1650 CString Text;
1651 switch(this->m_RebaseStage)
1652 {
1653 case CHOOSE_BRANCH:
1654 case CHOOSE_COMMIT_PICK_MODE:
1655 if(this->m_IsFastForward)
1656 Text.LoadString(IDS_PROC_STARTREBASEFFBUTTON);
1657 else
1658 Text.LoadString(IDS_PROC_STARTREBASEBUTTON);
1659 break;
1660
1661 case REBASE_START:
1662 case REBASE_ERROR:
1663 case REBASE_CONTINUE:
1664 case REBASE_SQUASH_CONFLICT:
1665 Text.LoadString(IDS_CONTINUEBUTTON);
1666 break;
1667
1668 case REBASE_CONFLICT:
1669 Text.LoadString(IDS_COMMITBUTTON);
1670 break;
1671 case REBASE_EDIT:
1672 Text.LoadString(IDS_AMENDBUTTON);
1673 break;
1674
1675 case REBASE_SQUASH_EDIT:
1676 Text.LoadString(IDS_COMMITBUTTON);
1677 break;
1678
1679 case REBASE_ABORT:
1680 case REBASE_FINISH:
1681 Text.LoadString(IDS_FINISHBUTTON);
1682 break;
1683
1684 case REBASE_DONE:
1685 Text.LoadString(IDS_DONE);
1686 break;
1687 }
1688 this->GetDlgItem(IDC_REBASE_CONTINUE)->SetWindowText(Text);
1689 }
1690
1691 void CRebaseDlg::SetControlEnable()
1692 {
1693 switch(this->m_RebaseStage)
1694 {
1695 case CHOOSE_BRANCH:
1696 case CHOOSE_COMMIT_PICK_MODE:
1697
1698 this->GetDlgItem(IDC_SPLITALLOPTIONS)->EnableWindow(TRUE);
1699 this->GetDlgItem(IDC_BUTTON_UP)->EnableWindow(TRUE);
1700 this->GetDlgItem(IDC_BUTTON_DOWN)->EnableWindow(TRUE);
1701 this->GetDlgItem(IDC_BUTTON_ADD)->EnableWindow(!m_bPreserveMerges);
1702 m_CommitList.EnableDragnDrop(true);
1703
1704 if(!m_IsCherryPick)
1705 {
1706 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(TRUE);
1707 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(TRUE);
1708 this->GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(TRUE);
1709 this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(TRUE);
1710 this->GetDlgItem(IDC_REBASE_CHECK_PRESERVEMERGES)->EnableWindow(TRUE);
1711 }
1712 this->m_CommitList.m_ContextMenuMask |= m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_PICK)|
1713 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SQUASH)|
1714 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_EDIT)|
1715 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SKIP)|
1716 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_LOG);
1717 break;
1718
1719 case REBASE_START:
1720 case REBASE_CONTINUE:
1721 case REBASE_ABORT:
1722 case REBASE_ERROR:
1723 case REBASE_FINISH:
1724 case REBASE_CONFLICT:
1725 case REBASE_EDIT:
1726 case REBASE_SQUASH_CONFLICT:
1727 case REBASE_DONE:
1728 this->GetDlgItem(IDC_SPLITALLOPTIONS)->EnableWindow(FALSE);
1729 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(FALSE);
1730 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(FALSE);
1731 this->GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(FALSE);
1732 this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(FALSE);
1733 this->GetDlgItem(IDC_REBASE_CHECK_PRESERVEMERGES)->EnableWindow(FALSE);
1734 this->GetDlgItem(IDC_BUTTON_UP)->EnableWindow(FALSE);
1735 this->GetDlgItem(IDC_BUTTON_DOWN)->EnableWindow(FALSE);
1736 m_CommitList.EnableDragnDrop(false);
1737 this->GetDlgItem(IDC_BUTTON_ADD)->EnableWindow(FALSE);
1738
1739 if( m_RebaseStage == REBASE_DONE && (this->m_PostButtonTexts.GetCount() != 0) )
1740 {
1741 this->GetDlgItem(IDC_STATUS_STATIC)->ShowWindow(SW_HIDE);
1742 this->GetDlgItem(IDC_REBASE_POST_BUTTON)->ShowWindow(SW_SHOWNORMAL);
1743 this->m_PostButton.RemoveAll();
1744 this->m_PostButton.AddEntries(m_PostButtonTexts);
1745 //this->GetDlgItem(IDC_REBASE_POST_BUTTON)->SetWindowText(this->m_PostButtonText);
1746 }
1747 break;
1748 }
1749
1750 GetDlgItem(IDC_REBASE_SPLIT_COMMIT)->ShowWindow((m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_SQUASH_EDIT) ? SW_SHOW : SW_HIDE);
1751
1752 if(m_bThreadRunning)
1753 {
1754 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1755
1756 }
1757 else if (m_RebaseStage != REBASE_ERROR)
1758 {
1759 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1760 }
1761 }
1762
1763 void CRebaseDlg::UpdateProgress()
1764 {
1765 int index;
1766 CRect rect;
1767
1768 if(m_CommitList.m_IsOldFirst)
1769 index = m_CurrentRebaseIndex+1;
1770 else
1771 index = m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1772
1773 int finishedCommits = index - 1; // introduced an variable which shows the number handled revisions for the progress bars
1774 if (m_RebaseStage == REBASE_FINISH || finishedCommits == -1)
1775 finishedCommits = index;
1776
1777 m_ProgressBar.SetRange32(0, m_CommitList.GetItemCount());
1778 m_ProgressBar.SetPos(finishedCommits);
1779 if (m_pTaskbarList)
1780 {
1781 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1782 m_pTaskbarList->SetProgressValue(m_hWnd, finishedCommits, m_CommitList.GetItemCount());
1783 }
1784
1785 if(m_CurrentRebaseIndex>=0 && m_CurrentRebaseIndex< m_CommitList.GetItemCount())
1786 {
1787 CString text;
1788 text.FormatMessage(IDS_PROC_REBASING_PROGRESS, index, m_CommitList.GetItemCount());
1789 m_sStatusText = text;
1790 m_CtrlStatusText.SetWindowText(text);
1791 m_bStatusWarning = false;
1792 m_CtrlStatusText.Invalidate();
1793 }
1794
1795 GitRevLoglist* prevRev = nullptr, *curRev = nullptr;
1796
1797 if (m_CurrentRebaseIndex >= 0 && m_CurrentRebaseIndex < (int)m_CommitList.m_arShownList.size())
1798 curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1799
1800 for (int i = 0; i < (int)m_CommitList.m_arShownList.size(); ++i)
1801 {
1802 prevRev = m_CommitList.m_arShownList.SafeGetAt(i);
1803 if (prevRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_CURRENT)
1804 {
1805 prevRev->GetRebaseAction() &= ~CGitLogListBase::LOGACTIONS_REBASE_CURRENT;
1806 m_CommitList.GetItemRect(i,&rect,LVIR_BOUNDS);
1807 m_CommitList.InvalidateRect(rect);
1808 }
1809 }
1810
1811 if(curRev)
1812 {
1813 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_CURRENT;
1814 m_CommitList.GetItemRect(m_CurrentRebaseIndex,&rect,LVIR_BOUNDS);
1815 m_CommitList.InvalidateRect(rect);
1816 }
1817 m_CommitList.EnsureVisible(m_CurrentRebaseIndex,FALSE);
1818 }
1819
1820 void CRebaseDlg::UpdateCurrentStatus()
1821 {
1822 SetContinueButtonText();
1823 SetControlEnable();
1824 UpdateProgress();
1825 if (m_RebaseStage == REBASE_DONE)
1826 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
1827 }
1828
1829 void CRebaseDlg::AddLogString(const CString& str)
1830 {
1831 this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, FALSE);
1832 CStringA sTextA = m_wndOutputRebase.StringForControl(str);//CUnicodeUtils::GetUTF8(str);
1833 this->m_wndOutputRebase.SendMessage(SCI_DOCUMENTEND);
1834 this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)sTextA);
1835 this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)"\n");
1836 this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, TRUE);
1837 }
1838
1839 int CRebaseDlg::GetCurrentCommitID()
1840 {
1841 if(m_CommitList.m_IsOldFirst)
1842 return this->m_CurrentRebaseIndex+1;
1843 else
1844 return m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1845 }
1846
1847 int CRebaseDlg::IsCommitEmpty(const CGitHash& hash)
1848 {
1849 CString cmd, tree, ptree;
1850 cmd.Format(L"git.exe rev-parse -q --verify %s^{tree}", (LPCTSTR)hash.ToString());
1851 if (g_Git.Run(cmd, &tree, CP_UTF8))
1852 {
1853 AddLogString(cmd);
1854 AddLogString(tree);
1855 return -1;
1856 }
1857 cmd.Format(L"git.exe rev-parse -q --verify %s^^{tree}", (LPCTSTR)hash.ToString());
1858 if (g_Git.Run(cmd, &ptree, CP_UTF8))
1859 ptree = L"4b825dc642cb6eb9a060e54bf8d69288fbee4904"; // empty tree
1860 return tree == ptree;
1861 }
1862
1863 int CRebaseDlg::DoRebase()
1864 {
1865 CString cmd,out;
1866 if(m_CurrentRebaseIndex <0)
1867 return 0;
1868 if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1869 return 0;
1870
1871 GitRevLoglist* pRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1872 int mode = pRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_MODE_MASK;
1873 CString nocommit;
1874
1875 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SKIP)
1876 {
1877 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1878 return 0;
1879 }
1880
1881 bool nextCommitIsSquash = (CheckNextCommitIsSquash() == 0);
1882 if (nextCommitIsSquash || mode != CGitLogListBase::LOGACTIONS_REBASE_PICK)
1883 { // next commit is squash or not pick
1884 if (!this->m_SquashMessage.IsEmpty())
1885 this->m_SquashMessage += L"\n\n";
1886 this->m_SquashMessage += pRev->GetSubject();
1887 this->m_SquashMessage += L'\n';
1888 this->m_SquashMessage += pRev->GetBody().TrimRight();
1889 if (m_bAddCherryPickedFrom)
1890 {
1891 if (!pRev->GetBody().IsEmpty())
1892 m_SquashMessage += L'\n';
1893 m_SquashMessage += L"(cherry picked from commit ";
1894 m_SquashMessage += pRev->m_CommitHash.ToString();
1895 m_SquashMessage += L')';
1896 }
1897 }
1898 else
1899 {
1900 this->m_SquashMessage.Empty();
1901 m_SquashFirstMetaData.Empty();
1902 }
1903
1904 if (nextCommitIsSquash && mode != CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1905 m_SquashFirstMetaData = SquashFirstMetaData(pRev);
1906
1907 if ((nextCommitIsSquash && mode != CGitLogListBase::LOGACTIONS_REBASE_EDIT) || mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1908 { // next or this commit is squash (don't do this on edit->squash sequence)
1909 nocommit = L" --no-commit ";
1910 if (m_iSquashdate == 1)
1911 m_SquashFirstMetaData.UpdateDate(pRev);
1912 }
1913
1914 CString log;
1915 log.Format(L"%s %d: %s", (LPCTSTR)CGitLogListBase::GetRebaseActionName(mode), GetCurrentCommitID(), (LPCTSTR)pRev->m_CommitHash.ToString());
1916 AddLogString(log);
1917 AddLogString(pRev->GetSubject());
1918 if (pRev->GetSubject().IsEmpty())
1919 {
1920 CMessageBox::Show(m_hWnd, IDS_PROC_REBASE_EMPTYCOMMITMSG, IDS_APPNAME, MB_OK | MB_ICONEXCLAMATION);
1921 mode = CGitLogListBase::LOGACTIONS_REBASE_EDIT;
1922 }
1923
1924 CString cherryPickedFrom;
1925 if (m_bAddCherryPickedFrom)
1926 cherryPickedFrom = L"-x ";
1927 else if (!m_IsCherryPick && nocommit.IsEmpty())
1928 cherryPickedFrom = L"--ff "; // for issue #1833: "If the current HEAD is the same as the parent of the cherry-picked commit, then a fast forward to this commit will be performed."
1929
1930 int isEmpty = IsCommitEmpty(pRev->m_CommitHash);
1931 if (isEmpty == 1)
1932 cherryPickedFrom += L"--allow-empty ";
1933 else if (isEmpty < 0)
1934 return -1;
1935
1936 if (m_IsCherryPick && pRev->m_ParentHash.size() > 1)
1937 {
1938 CString msg;
1939 msg.FormatMessage(IDS_CHERRYPICK_MERGECOMMIT, (LPCTSTR)pRev->m_CommitHash.ToString(), (LPCTSTR)pRev->GetSubject());
1940 CString parent1;
1941 parent1.Format(IDS_PARENT, 1);
1942 parent1.AppendFormat(L"\n(%s)", (LPCTSTR)pRev->m_ParentHash.at(0).ToString());
1943 CString parent2;
1944 parent2.Format(IDS_PARENT, 2);
1945 parent2.AppendFormat(L"\n(%s)", (LPCTSTR)pRev->m_ParentHash.at(1).ToString());
1946 CString cancel;
1947 cancel.LoadString(IDS_MSGBOX_CANCEL);
1948 auto ret = CMessageBox::Show(m_hWnd, msg, L"TortoiseGit", 3, IDI_QUESTION, parent1, parent2, cancel);
1949 if (ret == 3)
1950 return - 1;
1951
1952 cherryPickedFrom.AppendFormat(L"-m %d ", ret);
1953 }
1954
1955 while (true)
1956 {
1957 cmd.Format(L"git.exe cherry-pick %s%s %s", (LPCTSTR)cherryPickedFrom, (LPCTSTR)nocommit, (LPCTSTR)pRev->m_CommitHash.ToString());
1958 if (m_bPreserveMerges)
1959 {
1960 bool parentRewritten = false;
1961 CGitHash currentHeadHash;
1962 if (g_Git.GetHash(currentHeadHash, L"HEAD"))
1963 {
1964 m_RebaseStage = REBASE_ERROR;
1965 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1966 return -1;
1967 }
1968 if (!m_currentCommits.empty())
1969 {
1970 for (const auto& commit : m_currentCommits)
1971 m_rewrittenCommitsMap[commit] = currentHeadHash;
1972 m_currentCommits.clear();
1973 }
1974 m_currentCommits.push_back(pRev->m_CommitHash);
1975 GIT_REV_LIST possibleParents = pRev->m_ParentHash;
1976 GIT_REV_LIST newParents;
1977 for (auto it = possibleParents.cbegin(); it != possibleParents.cend(); it = possibleParents.begin())
1978 {
1979 CGitHash parent = *it;
1980 possibleParents.erase(it);
1981
1982 const auto rewrittenParent = m_rewrittenCommitsMap.find(parent);
1983 if (rewrittenParent == m_rewrittenCommitsMap.cend())
1984 {
1985 auto droppedCommitParents = m_droppedCommitsMap.find(parent);
1986 if (droppedCommitParents != m_droppedCommitsMap.cend())
1987 {
1988 parentRewritten = true;
1989 for (auto droppedIt = droppedCommitParents->second.crbegin(); droppedIt != droppedCommitParents->second.crend(); ++droppedIt)
1990 possibleParents.insert(possibleParents.begin(), *droppedIt);
1991 continue;
1992 }
1993
1994 newParents.push_back(parent);
1995 continue;
1996 }
1997
1998 if (rewrittenParent->second.IsEmpty() && parent == pRev->m_ParentHash[0] && pRev->ParentsCount() > 1)
1999 {
2000 m_RebaseStage = REBASE_ERROR;
2001 AddLogString(L"");
2002 AddLogString(L"Unrecoverable error: Merge commit parent missing.");
2003 return -1;
2004 }
2005
2006 CGitHash newParent = rewrittenParent->second;
2007 if (newParent.IsEmpty()) // use current HEAD as fallback
2008 newParent = currentHeadHash;
2009
2010 if (newParent != parent)
2011 parentRewritten = true;
2012
2013 if (std::find(newParents.begin(), newParents.end(), newParent) == newParents.end())
2014 newParents.push_back(newParent);
2015 }
2016 if (pRev->ParentsCount() > 1)
2017 {
2018 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
2019 {
2020 m_RebaseStage = REBASE_ERROR;
2021 AddLogString(L"Cannot squash merge commit on rebase.");
2022 return -1;
2023 }
2024 if (!parentRewritten && nocommit.IsEmpty())
2025 cmd.Format(L"git.exe reset --hard %s", (LPCTSTR)pRev->m_CommitHash.ToString());
2026 else
2027 {
2028 CString parentString;
2029 for (const auto& parent : newParents)
2030 parentString += L' ' + parent.ToString();
2031 cmd.Format(L"git.exe checkout %s", (LPCTSTR)newParents[0].ToString());
2032 if (RunGitCmdRetryOrAbort(cmd))
2033 {
2034 m_RebaseStage = REBASE_ERROR;
2035 return -1;
2036 }
2037 cmd.Format(L"git.exe merge --no-ff%s %s", (LPCTSTR)nocommit, (LPCTSTR)parentString);
2038 if (nocommit.IsEmpty())
2039 {
2040 if (g_Git.Run(cmd, &out, CP_UTF8))
2041 {
2042 AddLogString(cmd);
2043 AddLogString(out);
2044 int hasConflicts = g_Git.HasWorkingTreeConflicts();
2045 if (hasConflicts > 0)
2046 {
2047 m_RebaseStage = REBASE_CONFLICT;
2048 return -1;
2049 }
2050 else if (hasConflicts < 0)
2051 AddLogString(g_Git.GetGitLastErr(L"Checking for conflicts failed.", CGit::GIT_CMD_CHECKCONFLICTS));
2052 AddLogString(L"An unrecoverable error occurred.");
2053 m_RebaseStage = REBASE_ERROR;
2054 return -1;
2055 }
2056 CGitHash newHeadHash;
2057 if (g_Git.GetHash(newHeadHash, L"HEAD"))
2058 {
2059 m_RebaseStage = REBASE_ERROR;
2060 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
2061 return -1;
2062 }
2063 // do nothing if already up2date
2064 if (currentHeadHash != newHeadHash)
2065 cmd.Format(L"git.exe commit --amend -C %s", (LPCTSTR)pRev->m_CommitHash.ToString());
2066 }
2067 }
2068 }
2069 else
2070 {
2071 if (mode != CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
2072 {
2073 cmd.Format(L"git.exe checkout %s", (LPCTSTR)newParents[0].ToString());
2074 if (RunGitCmdRetryOrAbort(cmd))
2075 {
2076 m_RebaseStage = REBASE_ERROR;
2077 return -1;
2078 }
2079 }
2080 cmd.Format(L"git.exe cherry-pick %s%s %s", (LPCTSTR)cherryPickedFrom, (LPCTSTR)nocommit, (LPCTSTR)pRev->m_CommitHash.ToString());
2081 }
2082 }
2083
2084 if(g_Git.Run(cmd,&out,CP_UTF8))
2085 {
2086 AddLogString(out);
2087 int hasConflicts = g_Git.HasWorkingTreeConflicts();
2088 if (hasConflicts < 0)
2089 {
2090 AddLogString(g_Git.GetGitLastErr(L"Checking for conflicts failed.", CGit::GIT_CMD_CHECKCONFLICTS));
2091 return -1;
2092 }
2093 if (!hasConflicts)
2094 {
2095 if (mode == CGitLogListBase::LOGACTIONS_REBASE_PICK)
2096 {
2097 if (m_pTaskbarList)
2098 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
2099 int choose = -1;
2100 if (!m_bAutoSkipFailedCommit)
2101 {
2102 choose = CMessageBox::ShowCheck(GetSafeHwnd(), IDS_CHERRYPICKFAILEDSKIP, IDS_APPNAME, 1, IDI_QUESTION, IDS_SKIPBUTTON, IDS_MSGBOX_RETRY, IDS_MSGBOX_CANCEL, nullptr, IDS_DO_SAME_FOR_REST, &m_bAutoSkipFailedCommit);
2103 if (choose == 2)
2104 {
2105 m_bAutoSkipFailedCommit = FALSE;
2106 continue; // retry cherry pick
2107 }
2108 }
2109 if (m_bAutoSkipFailedCommit || choose == 1)
2110 {
2111 if (!RunGitCmdRetryOrAbort(L"git.exe reset --hard"))
2112 {
2113 pRev->GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_SKIP;
2114 m_CommitList.Invalidate();
2115 return 0;
2116 }
2117 }
2118
2119 m_RebaseStage = REBASE_ERROR;
2120 AddLogString(L"An unrecoverable error occurred.");
2121 return -1;
2122 }
2123 if (mode == CGitLogListBase::LOGACTIONS_REBASE_EDIT)
2124 {
2125 this->m_RebaseStage = REBASE_EDIT ;
2126 return -1; // Edit return -1 to stop rebase.
2127 }
2128 // Squash Case
2129 if(CheckNextCommitIsSquash())
2130 { // no squash
2131 // let user edit last commmit message
2132 this->m_RebaseStage = REBASE_SQUASH_EDIT;
2133 return -1;
2134 }
2135 }
2136
2137 if (m_pTaskbarList)
2138 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
2139 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
2140 m_RebaseStage = REBASE_SQUASH_CONFLICT;
2141 else
2142 m_RebaseStage = REBASE_CONFLICT;
2143 return -1;
2144
2145 }
2146 else
2147 {
2148 AddLogString(out);
2149 if (mode == CGitLogListBase::LOGACTIONS_REBASE_PICK)
2150 {
2151 if (nocommit.IsEmpty())
2152 {
2153 CGitHash head;
2154 if (g_Git.GetHash(head, L"HEAD"))
2155 {
2156 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
2157 m_RebaseStage = REBASE_ERROR;
2158 return -1;
2159 }
2160 m_rewrittenCommitsMap[pRev->m_CommitHash] = head;
2161 }
2162 else
2163 m_forRewrite.push_back(pRev->m_CommitHash);
2164 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
2165 return 0;
2166 }
2167 if (mode == CGitLogListBase::LOGACTIONS_REBASE_EDIT)
2168 {
2169 this->m_RebaseStage = REBASE_EDIT ;
2170 return -1; // Edit return -1 to stop rebase.
2171 }
2172
2173 // Squash Case
2174 if(CheckNextCommitIsSquash())
2175 { // no squash
2176 // let user edit last commmit message
2177 this->m_RebaseStage = REBASE_SQUASH_EDIT;
2178 return -1;
2179 }
2180 else if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
2181 {
2182 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
2183 m_forRewrite.push_back(pRev->m_CommitHash);
2184 }
2185 }
2186
2187 return 0;
2188 }
2189 }
2190
2191 BOOL CRebaseDlg::IsEnd()
2192 {
2193 if(m_CommitList.m_IsOldFirst)
2194 return m_CurrentRebaseIndex>= this->m_CommitList.GetItemCount();
2195 else
2196 return m_CurrentRebaseIndex<0;
2197 }
2198
2199 int CRebaseDlg::RebaseThread()
2200 {
2201 CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
2202
2203 int ret=0;
2204 while (!m_bAbort)
2205 {
2206 if( m_RebaseStage == REBASE_START )
2207 {
2208 if( this->StartRebase() )
2209 {
2210 ret = -1;
2211 break;
2212 }
2213 m_RebaseStage = REBASE_CONTINUE;
2214 }
2215 else if( m_RebaseStage == REBASE_CONTINUE )
2216 {
2217 this->GoNext();
2218 SendMessage(MSG_REBASE_UPDATE_UI);
2219 if(IsEnd())
2220 {
2221 ret = 0;
2222 m_RebaseStage = REBASE_FINISH;
2223 }
2224 else
2225 {
2226 ret = DoRebase();
2227 if( ret )
2228 break;
2229 }
2230 }
2231 else if( m_RebaseStage == REBASE_FINISH )
2232 {
2233 SendMessage(MSG_REBASE_UPDATE_UI);
2234 m_RebaseStage = REBASE_DONE;
2235 break;
2236 }
2237 else
2238 break;
2239 this->PostMessage(MSG_REBASE_UPDATE_UI);
2240 }
2241
2242 InterlockedExchange(&m_bThreadRunning, FALSE);
2243 this->PostMessage(MSG_REBASE_UPDATE_UI);
2244 if (m_bAbort)
2245 PostMessage(WM_COMMAND, MAKELONG(IDC_REBASE_ABORT, BN_CLICKED), (LPARAM)GetDlgItem(IDC_REBASE_ABORT)->GetSafeHwnd());
2246 return ret;
2247 }
2248
2249 void CRebaseDlg::ListConflictFile(bool noStoreScrollPosition)
2250 {
2251 if (!noStoreScrollPosition)
2252 m_FileListCtrl.StoreScrollPos();
2253 this->m_FileListCtrl.Clear();
2254 m_FileListCtrl.SetHasCheckboxes(true);
2255
2256 if (!m_IsCherryPick)
2257 {
2258 CString adminDir;
2259 if (GitAdminDir::GetAdminDirPath(g_Git.m_CurrentDir, adminDir))
2260 {
2261 CString dir(adminDir + L"tgitrebase.active");
2262 ::CreateDirectory(dir, nullptr);
2263 CStringUtils::WriteStringToTextFile(dir + L"\\head-name", m_BranchCtrl.GetString());
2264 CStringUtils::WriteStringToTextFile(dir + L"\\onto", m_Onto.IsEmpty() ? m_UpstreamCtrl.GetString() : m_Onto);
2265 }
2266 }
2267
2268 this->m_FileListCtrl.GetStatus(nullptr, true);
2269 m_FileListCtrl.Show(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_REPLACED, CTGitPath::LOGACTIONS_UNMERGED);
2270
2271 m_FileListCtrl.Check(GITSLC_SHOWFILES);
2272 bool hasSubmoduleChange = false;
2273 auto locker(m_FileListCtrl.AcquireReadLock());
2274 for (int i = 0; i < m_FileListCtrl.GetItemCount(); i++)
2275 {
2276 auto entry = m_FileListCtrl.GetListEntry(i);
2277 if (entry->IsDirectory())
2278 {
2279 hasSubmoduleChange = true;
2280 break;
2281 }
2282 }
2283
2284 if (hasSubmoduleChange)
2285 {
2286 m_CtrlStatusText.SetWindowText(m_sStatusText + L", " + CString(MAKEINTRESOURCE(IDS_CARE_SUBMODULE_CHANGES)));
2287 m_bStatusWarning = true;
2288 m_CtrlStatusText.Invalidate();
2289 }
2290 else
2291 {
2292 m_CtrlStatusText.SetWindowText(m_sStatusText);
2293 m_bStatusWarning = false;
2294 m_CtrlStatusText.Invalidate();
2295 }
2296 }
2297
2298 LRESULT CRebaseDlg::OnRebaseUpdateUI(WPARAM,LPARAM)
2299 {
2300 if (m_RebaseStage == REBASE_FINISH)
2301 {
2302 FinishRebase();
2303 return 0;
2304 }
2305 UpdateCurrentStatus();
2306
2307 if (m_RebaseStage == REBASE_DONE && m_bRebaseAutoEnd)
2308 {
2309 m_bRebaseAutoEnd = false;
2310 this->PostMessage(WM_COMMAND, MAKELONG(IDC_REBASE_CONTINUE, BN_CLICKED), (LPARAM)GetDlgItem(IDC_REBASE_CONTINUE)->GetSafeHwnd());
2311 }
2312
2313 if (m_RebaseStage == REBASE_DONE && m_pTaskbarList)
2314 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS); // do not show progress on taskbar any more to show we finished
2315 if(m_CurrentRebaseIndex <0)
2316 return 0;
2317 if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
2318 return 0;
2319 GitRev* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
2320
2321 switch(m_RebaseStage)
2322 {
2323 case REBASE_CONFLICT:
2324 case REBASE_SQUASH_CONFLICT:
2325 {
2326 ListConflictFile(true);
2327 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_CONFLICT);
2328 if (m_pTaskbarList)
2329 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
2330 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2331 CString logMessage;
2332 if (m_IsCherryPick)
2333 {
2334 CString dotGitPath;
2335 GitAdminDir::GetWorktreeAdminDirPath(g_Git.m_CurrentDir, dotGitPath);
2336 // vanilla git also re-uses MERGE_MSG on conflict (listing all conflicted files)
2337 // and it's also needed for cherry-pick in order to get cherry-picked-from included on conflicts
2338 CGit::LoadTextFile(dotGitPath + L"MERGE_MSG", logMessage);
2339 }
2340 if (logMessage.IsEmpty())
2341 logMessage = curRev->GetSubject() + L'\n' + curRev->GetBody();
2342 this->m_LogMessageCtrl.SetText(logMessage);
2343 break;
2344 }
2345 case REBASE_EDIT:
2346 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
2347 if (m_pTaskbarList)
2348 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
2349 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2350 if (m_bAddCherryPickedFrom)
2351 {
2352 // Since the new commit is done and the HEAD points to it,
2353 // just using the new body modified by git self.
2354 GitRev headRevision;
2355 if (headRevision.GetCommit(L"HEAD"))
2356 MessageBox(headRevision.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
2357
2358 m_LogMessageCtrl.SetText(headRevision.GetSubject() + L'\n' + headRevision.GetBody());
2359 }
2360 else
2361 m_LogMessageCtrl.SetText(curRev->GetSubject() + L'\n' + curRev->GetBody());
2362 break;
2363 case REBASE_SQUASH_EDIT:
2364 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
2365 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2366 this->m_LogMessageCtrl.SetText(this->m_SquashMessage);
2367 if (m_pTaskbarList)
2368 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
2369 break;
2370 default:
2371 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
2372 }
2373 return 0;
2374 }
2375
2376 void CRebaseDlg::OnCancel()
2377 {
2378 OnBnClickedAbort();
2379 }
2380
2381 void CRebaseDlg::OnBnClickedAbort()
2382 {
2383 if (m_bThreadRunning)
2384 {
2385 if (CMessageBox::Show(GetSafeHwnd(), IDS_PROC_REBASE_ABORT, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION) != IDYES)
2386 return;
2387 m_bAbort = TRUE;
2388 return;
2389 }
2390
2391 if (m_pTaskbarList)
2392 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
2393
2394 m_tooltips.Pop();
2395
2396 SaveSplitterPos();
2397
2398 if(m_OrigUpstreamHash.IsEmpty())
2399 {
2400 __super::OnCancel();
2401 }
2402
2403 if(m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage== CHOOSE_COMMIT_PICK_MODE)
2404 {
2405 goto end;
2406 }
2407
2408 if (!m_bAbort && CMessageBox::Show(GetSafeHwnd(), IDS_PROC_REBASE_ABORT, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION) != IDYES)
2409 goto end;
2410
2411 m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
2412 if(this->m_IsFastForward)
2413 {
2414 CString cmd;
2415 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)this->m_OrigBranchHash.ToString());
2416 RunGitCmdRetryOrAbort(cmd);
2417 __super::OnCancel();
2418 goto end;
2419 }
2420
2421 if (m_IsCherryPick) // there are not "branch" at cherry pick mode
2422 {
2423 CString cmd;
2424 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)m_OrigUpstreamHash.ToString());
2425 RunGitCmdRetryOrAbort(cmd);
2426 __super::OnCancel();
2427 goto end;
2428 }
2429
2430 if (m_OrigHEADBranch == m_BranchCtrl.GetString())
2431 {
2432 CString cmd, out;
2433 if (g_Git.IsLocalBranch(m_OrigHEADBranch))
2434 cmd.Format(L"git.exe checkout -f -B %s %s --", (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)m_OrigBranchHash.ToString());
2435 else
2436 cmd.Format(L"git.exe checkout -f %s --", (LPCTSTR)m_OrigBranchHash.ToString());
2437 if (g_Git.Run(cmd, &out, CP_UTF8))
2438 {
2439 AddLogString(out);
2440 ::MessageBox(m_hWnd, L"Unrecoverable error on cleanup:\n" + out, L"TortoiseGit", MB_ICONERROR);
2441 __super::OnCancel();
2442 goto end;
2443 }
2444
2445 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)m_OrigBranchHash.ToString());
2446 RunGitCmdRetryOrAbort(cmd);
2447 }
2448 else
2449 {
2450 CString cmd, out;
2451 if (m_OrigHEADBranch != g_Git.GetCurrentBranch(true))
2452 {
2453 if (g_Git.IsLocalBranch(m_OrigHEADBranch))
2454 cmd.Format(L"git.exe checkout -f -B %s %s --", (LPCTSTR)m_OrigHEADBranch, (LPCTSTR)m_OrigHEADHash.ToString());
2455 else
2456 cmd.Format(L"git.exe checkout -f %s --", (LPCTSTR)m_OrigHEADHash.ToString());
2457 if (g_Git.Run(cmd, &out, CP_UTF8))
2458 {
2459 AddLogString(out);
2460 ::MessageBox(m_hWnd, L"Unrecoverable error on cleanup:\n" + out, L"TortoiseGit", MB_ICONERROR);
2461 // continue to restore moved branch
2462 }
2463 }
2464
2465 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)m_OrigHEADHash.ToString());
2466 RunGitCmdRetryOrAbort(cmd);
2467
2468 // restore moved branch
2469 if (g_Git.IsLocalBranch(m_BranchCtrl.GetString()))
2470 {
2471 cmd.Format(L"git.exe branch -f %s %s --", (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)m_OrigBranchHash.ToString());
2472 if (g_Git.Run(cmd, &out, CP_UTF8))
2473 {
2474 AddLogString(out);
2475 ::MessageBox(m_hWnd, L"Unrecoverable error on cleanup:\n" + out, L"TortoiseGit", MB_ICONERROR);
2476 __super::OnCancel();
2477 goto end;
2478 }
2479 }
2480 }
2481 __super::OnCancel();
2482 end:
2483 CleanUpRebaseActiveFolder();
2484 CheckRestoreStash();
2485 }
2486
2487 void CRebaseDlg::OnBnClickedButtonReverse()
2488 {
2489 CString temp = m_BranchCtrl.GetString();
2490 m_BranchCtrl.AddString(m_UpstreamCtrl.GetString());
2491 m_UpstreamCtrl.AddString(temp);
2492 OnCbnSelchangeUpstream();
2493 }
2494
2495 void CRebaseDlg::OnBnClickedButtonBrowse()
2496 {
2497 if (CBrowseRefsDlg::PickRefForCombo(m_UpstreamCtrl))
2498 OnCbnSelchangeUpstream();
2499 }
2500
2501 void CRebaseDlg::OnBnClickedRebaseCheckForce()
2502 {
2503 this->UpdateData();
2504 GetDlgItem(IDC_BUTTON_ADD)->EnableWindow(!m_bPreserveMerges);
2505 this->FetchLogList();
2506 }
2507
2508 void CRebaseDlg::OnBnClickedRebasePostButton()
2509 {
2510 this->m_Upstream=this->m_UpstreamCtrl.GetString();
2511 this->m_Branch=this->m_BranchCtrl.GetString();
2512
2513 this->EndDialog((int)(IDC_REBASE_POST_BUTTON+this->m_PostButton.GetCurrentEntry()));
2514 }
2515
2516 LRESULT CRebaseDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
2517 {
2518 Refresh();
2519 return 0;
2520 }
2521
2522 void CRebaseDlg::Refresh()
2523 {
2524 if (m_RebaseStage == REBASE_CONFLICT || m_RebaseStage == REBASE_SQUASH_CONFLICT)
2525 {
2526 ListConflictFile(false);
2527 return;
2528 }
2529
2530 if(this->m_IsCherryPick)
2531 return ;
2532
2533 if(this->m_RebaseStage == CHOOSE_BRANCH )
2534 {
2535 this->UpdateData();
2536 this->FetchLogList();
2537 }
2538 }
2539
2540 void CRebaseDlg::OnBnClickedButtonUp()
2541 {
2542 POSITION pos;
2543 pos = m_CommitList.GetFirstSelectedItemPosition();
2544
2545 bool moveToTop = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
2546 // do nothing if the first selected item is the first item in the list
2547 if (!moveToTop && m_CommitList.GetNextSelectedItem(pos) == 0)
2548 return;
2549
2550 pos = m_CommitList.GetFirstSelectedItemPosition();
2551
2552 int count = 0;
2553 bool changed = false;
2554 while(pos)
2555 {
2556 int index=m_CommitList.GetNextSelectedItem(pos);
2557 count = moveToTop ? count : (index - 1);
2558 while (index > count)
2559 {
2560 std::swap(m_CommitList.m_logEntries[index], m_CommitList.m_logEntries[index - 1]);
2561 std::swap(m_CommitList.m_arShownList[index], m_CommitList.m_arShownList[index - 1]);
2562 m_CommitList.SetItemState(index - 1, LVIS_SELECTED, LVIS_SELECTED);
2563 m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
2564 changed = true;
2565 index--;
2566 }
2567 count++;
2568 }
2569 if (changed)
2570 {
2571 pos = m_CommitList.GetFirstSelectedItemPosition();
2572 m_CommitList.EnsureVisible(m_CommitList.GetNextSelectedItem(pos), false);
2573 m_CommitList.Invalidate();
2574 m_CommitList.SetFocus();
2575 }
2576 }
2577
2578 void CRebaseDlg::OnBnClickedButtonDown()
2579 {
2580 if (m_CommitList.GetSelectedCount() == 0)
2581 return;
2582
2583 bool moveToBottom = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
2584 POSITION pos;
2585 pos = m_CommitList.GetFirstSelectedItemPosition();
2586 bool changed = false;
2587 // use an array to store all selected item indexes; the user won't select too much items
2588 auto indexes = std::make_unique<int[]>(m_CommitList.GetSelectedCount());
2589 int i = 0;
2590 while(pos)
2591 indexes[i++] = m_CommitList.GetNextSelectedItem(pos);
2592 // don't move any item if the last selected item is the last item in the m_CommitList
2593 // (that would change the order of the selected items)
2594 if (!moveToBottom && indexes[m_CommitList.GetSelectedCount() - 1] >= m_CommitList.GetItemCount() - 1)
2595 return;
2596 int count = m_CommitList.GetItemCount() - 1;
2597 // iterate over the indexes backwards in order to correctly move multiselected items
2598 for (i = m_CommitList.GetSelectedCount() - 1; i >= 0; i--)
2599 {
2600 int index = indexes[i];
2601 count = moveToBottom ? count : (index + 1);
2602 while (index < count)
2603 {
2604 std::swap(m_CommitList.m_logEntries[index], m_CommitList.m_logEntries[index + 1]);
2605 std::swap(m_CommitList.m_arShownList[index], m_CommitList.m_arShownList[index + 1]);
2606 m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
2607 m_CommitList.SetItemState(index + 1, LVIS_SELECTED, LVIS_SELECTED);
2608 changed = true;
2609 index++;
2610 }
2611 count--;
2612 }
2613 m_CommitList.EnsureVisible(indexes[m_CommitList.GetSelectedCount() - 1] + 1, false);
2614 if (changed)
2615 {
2616 m_CommitList.Invalidate();
2617 m_CommitList.SetFocus();
2618 }
2619 }
2620
2621 LRESULT CRebaseDlg::OnCommitsReordered(WPARAM wParam, LPARAM /*lParam*/)
2622 {
2623 POSITION pos = m_CommitList.GetFirstSelectedItemPosition();
2624 int first = m_CommitList.GetNextSelectedItem(pos);
2625 int last = first;
2626 while (pos)
2627 last = m_CommitList.GetNextSelectedItem(pos);
2628 ++last;
2629
2630 for (int i = first; i < last; ++i)
2631 m_CommitList.SetItemState(i, 0, LVIS_SELECTED);
2632
2633 int dest = (int)wParam;
2634 if (dest > first)
2635 {
2636 std::rotate(m_CommitList.m_logEntries.begin() + first, m_CommitList.m_logEntries.begin() + last, m_CommitList.m_logEntries.begin() + dest);
2637 std::rotate(m_CommitList.m_arShownList.begin() + first, m_CommitList.m_arShownList.begin() + last, m_CommitList.m_arShownList.begin() + dest);
2638 for (int i = first + dest - last; i < dest; ++i)
2639 m_CommitList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2640 }
2641 else
2642 {
2643 std::rotate(m_CommitList.m_logEntries.begin() + dest, m_CommitList.m_logEntries.begin() + first, m_CommitList.m_logEntries.begin() + last);
2644 std::rotate(m_CommitList.m_arShownList.begin() + dest, m_CommitList.m_arShownList.begin() + first, m_CommitList.m_arShownList.begin() + last);
2645 for (int i = dest; i < dest + (last - first); ++i)
2646 m_CommitList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2647 }
2648
2649 m_CommitList.Invalidate();
2650
2651 return 0;
2652 }
2653
2654 LRESULT CRebaseDlg::OnTaskbarBtnCreated(WPARAM wParam, LPARAM lParam)
2655 {
2656 m_pTaskbarList.Release();
2657 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
2658 return __super::OnTaskbarButtonCreated(wParam, lParam);
2659 }
2660
2661 void CRebaseDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
2662 {
2663 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
2664 *pResult = 0;
2665 if(m_CommitList.m_bNoDispUpdates)
2666 return;
2667 if (pNMLV->iItem >= 0)
2668 {
2669 this->m_CommitList.m_nSearchIndex = pNMLV->iItem;
2670 if (pNMLV->iSubItem != 0)
2671 return;
2672 if (pNMLV->iItem == (int)m_CommitList.m_arShownList.size())
2673 {
2674 // remove the selected state
2675 if (pNMLV->uChanged & LVIF_STATE)
2676 {
2677 m_CommitList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
2678 FillLogMessageCtrl();
2679 }
2680 return;
2681 }
2682 if (pNMLV->uChanged & LVIF_STATE)
2683 FillLogMessageCtrl();
2684 }
2685 else
2686 FillLogMessageCtrl();
2687 }
2688
2689 void CRebaseDlg::FillLogMessageCtrl()
2690 {
2691 int selCount = m_CommitList.GetSelectedCount();
2692 if (selCount == 1 && (m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage == CHOOSE_COMMIT_PICK_MODE))
2693 {
2694 POSITION pos = m_CommitList.GetFirstSelectedItemPosition();
2695 int selIndex = m_CommitList.GetNextSelectedItem(pos);
2696 GitRevLoglist* pLogEntry = m_CommitList.m_arShownList.SafeGetAt(selIndex);
2697 m_FileListCtrl.UpdateWithGitPathList(pLogEntry->GetFiles(&m_CommitList));
2698 m_FileListCtrl.m_CurrentVersion = pLogEntry->m_CommitHash.ToString();
2699 m_FileListCtrl.Show(GITSLC_SHOWVERSIONED);
2700 m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2701 m_LogMessageCtrl.SetText(pLogEntry->GetSubject() + L'\n' + pLogEntry->GetBody());
2702 m_LogMessageCtrl.Call(SCI_SETREADONLY, TRUE);
2703 }
2704 }
2705 void CRebaseDlg::OnBnClickedCheckCherryPickedFrom()
2706 {
2707 UpdateData();
2708 }
2709
2710 LRESULT CRebaseDlg::OnRebaseActionMessage(WPARAM, LPARAM)
2711 {
2712 if (m_RebaseStage == REBASE_ERROR || m_RebaseStage == REBASE_CONFLICT)
2713 {
2714 GitRevLoglist* pRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
2715 int mode = pRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_MODE_MASK;
2716 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SKIP)
2717 {
2718 if (!RunGitCmdRetryOrAbort(L"git.exe reset --hard"))
2719 {
2720 m_FileListCtrl.Clear();
2721 m_RebaseStage = REBASE_CONTINUE;
2722 UpdateCurrentStatus();
2723 }
2724 }
2725 }
2726 return 0;
2727 }
2728
2729
2730 void CRebaseDlg::OnBnClickedSplitAllOptions()
2731 {
2732 switch (m_SplitAllOptions.GetCurrentEntry())
2733 {
2734 case 0:
2735 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_PICK);
2736 break;
2737 case 1:
2738 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SQUASH);
2739 break;
2740 case 2:
2741 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_EDIT);
2742 break;
2743 case 3:
2744 m_CommitList.SetUnselectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SKIP);
2745 break;
2746 case 4:
2747 m_CommitList.SetUnselectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SQUASH);
2748 break;
2749 case 5:
2750 m_CommitList.SetUnselectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_EDIT);
2751 break;
2752 default:
2753 ATLASSERT(false);
2754 }
2755 }
2756
2757 void CRebaseDlg::OnBnClickedRebaseSplitCommit()
2758 {
2759 UpdateData();
2760 }
2761
2762 static bool GetCompareHash(const CString& ref, const CGitHash& hash)
2763 {
2764 CGitHash refHash;
2765 if (g_Git.GetHash(refHash, ref))
2766 MessageBox(nullptr, g_Git.GetGitLastErr(L"Could not get hash of \"" + ref + L"\"."), L"TortoiseGit", MB_ICONERROR);
2767 return refHash.IsEmpty() || (hash == refHash);
2768 }
2769
2770 void CRebaseDlg::OnBnClickedButtonOnto()
2771 {
2772 m_Onto = CBrowseRefsDlg::PickRef(false, m_Onto);
2773 if (!m_Onto.IsEmpty())
2774 {
2775 // make sure that the user did not select upstream, selected branch or HEAD
2776 CGitHash hash;
2777 if (g_Git.GetHash(hash, m_Onto))
2778 {
2779 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_BranchCtrl.GetString() + L"\"."), L"TortoiseGit", MB_ICONERROR);
2780 m_Onto.Empty();
2781 ((CButton*)GetDlgItem(IDC_BUTTON_ONTO))->SetCheck(m_Onto.IsEmpty() ? BST_UNCHECKED : BST_CHECKED);
2782 return;
2783 }
2784 if (GetCompareHash(L"HEAD", hash) || GetCompareHash(m_UpstreamCtrl.GetString(), hash) || GetCompareHash(m_BranchCtrl.GetString(), hash))
2785 m_Onto.Empty();
2786 }
2787 if (m_Onto.IsEmpty())
2788 m_tooltips.DelTool(IDC_BUTTON_ONTO);
2789 else
2790 m_tooltips.AddTool(IDC_BUTTON_ONTO, m_Onto);
2791 ((CButton*)GetDlgItem(IDC_BUTTON_ONTO))->SetCheck(m_Onto.IsEmpty() ? BST_UNCHECKED : BST_CHECKED);
2792 FetchLogList();
2793 }
2794
2795 void CRebaseDlg::OnHelp()
2796 {
2797 HtmlHelp(0x20000 + (m_IsCherryPick ? IDD_REBASECHERRYPICK : IDD_REBASE));
2798 }
2799
2800 int CRebaseDlg::RunGitCmdRetryOrAbort(const CString& cmd)
2801 {
2802 while (true)
2803 {
2804 CString out;
2805 if (g_Git.Run(cmd, &out, CP_UTF8))
2806 {
2807 AddLogString(cmd);
2808 AddLogString(CString(MAKEINTRESOURCE(IDS_FAIL)));
2809 AddLogString(out);
2810 CString msg;
2811 msg.Format(L"\"%s\" failed.\n%s", (LPCTSTR)cmd, (LPCTSTR)out);
2812 if (CMessageBox::Show(GetSafeHwnd(), msg, L"TortoiseGit", 1, IDI_ERROR, CString(MAKEINTRESOURCE(IDS_MSGBOX_RETRY)), CString(MAKEINTRESOURCE(IDS_MSGBOX_ABORT))) != 1)
2813 return -1;
2814 }
2815 else
2816 return 0;
2817 }
2818 }
2819
2820 LRESULT CRebaseDlg::OnThemeChanged()
2821 {
2822 CMFCVisualManager::GetInstance()->DestroyInstance();
2823 return 0;
2824 }
2825
2826 void CRebaseDlg::OnSysColorChange()
2827 {
2828 __super::OnSysColorChange();
2829 m_LogMessageCtrl.SetColors(true);
2830 m_LogMessageCtrl.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
2831 m_wndOutputRebase.SetColors(true);
2832 m_wndOutputRebase.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
2833 }
2834
2835 void CRebaseDlg::OnBnClickedButtonAdd()
2836 {
2837 CLogDlg dlg;
2838 // tell the dialog to use mode for selecting revisions
2839 dlg.SetSelect(true);
2840 // allow multi-select
2841 dlg.SingleSelection(false);
2842 if (dlg.DoModal() != IDOK || dlg.GetSelectedHash().empty())
2843 return;
2844
2845 auto selectedHashes = dlg.GetSelectedHash();
2846 for (auto it = selectedHashes.crbegin(); it != selectedHashes.crend(); ++it)
2847 {
2848 GitRevLoglist* pRev = m_CommitList.m_logEntries.m_pLogCache->GetCacheData(*it);
2849 if (pRev->GetCommit(it->ToString()))
2850 return;
2851 if (pRev->GetParentFromHash(pRev->m_CommitHash))
2852 return;
2853 pRev->GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_PICK;
2854 if (m_CommitList.m_IsOldFirst)
2855 {
2856 m_CommitList.m_logEntries.push_back(pRev->m_CommitHash);
2857 m_CommitList.m_arShownList.SafeAdd(pRev);
2858 }
2859 else
2860 {
2861 m_CommitList.m_logEntries.insert(m_CommitList.m_logEntries.cbegin(), pRev->m_CommitHash);
2862 m_CommitList.m_arShownList.SafeAddFront(pRev);
2863 }
2864 }
2865 m_CommitList.SetItemCountEx((int)m_CommitList.m_logEntries.size());
2866 m_CommitList.Invalidate();
2867
2868 if (m_CommitList.m_IsOldFirst)
2869 m_CurrentRebaseIndex = -1;
2870 else
2871 m_CurrentRebaseIndex = (int)m_CommitList.m_logEntries.size();
2872 }
Windows Explorer Extension to Operate Git