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