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