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