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