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