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