?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed issue #2082: RebaseDlg: Reorder commits via drag'n'drop
[TortoiseGit.git] / src / TortoiseProc / RebaseDlg.cpp
blobb9fc2f3c4f88927c755c1ed418f0b53dfe0da94e
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 return;
1180 }
1181
1182 if (m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage == CHOOSE_COMMIT_PICK_MODE)
1183 {
1184 if (CAppUtils::IsTGitRebaseActive())
1185 return;
1186 if (CheckRebaseCondition())
1187 return;
1188 }
1189
1190 if( this->m_IsFastForward )
1191 {
1192 CString cmd,out;
1193 if (g_Git.GetHash(m_OrigBranchHash, m_BranchCtrl.GetString()))
1194 {
1195 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_BranchCtrl.GetString() + L"\"."), L"TortoiseGit", MB_ICONERROR);
1196 return;
1197 }
1198 if (g_Git.GetHash(m_OrigUpstreamHash, m_UpstreamCtrl.GetString()))
1199 {
1200 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_UpstreamCtrl.GetString() + L"\"."), L"TortoiseGit", MB_ICONERROR);
1201 return;
1202 }
1203
1204 if(!g_Git.IsFastForward(this->m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString()))
1205 {
1206 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1207 AddLogString(L"No fast forward possible.\r\nMaybe repository changed");
1208 return;
1209 }
1210
1211 if (IsLocalBranch(m_BranchCtrl.GetString()))
1212 {
1213 cmd.Format(L"git.exe checkout --no-track -f -B %s %s --", (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)m_UpstreamCtrl.GetString());
1214 AddLogString(cmd);
1215 if (RunGitCmdRetryOrAbort(cmd))
1216 return;
1217 AddLogString(out);
1218 out.Empty();
1219 }
1220 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)g_Git.FixBranchName(this->m_UpstreamCtrl.GetString()));
1221 CString log;
1222 log.Format(IDS_PROC_REBASE_FFTO, m_UpstreamCtrl.GetString());
1223 this->AddLogString(log);
1224
1225 AddLogString(cmd);
1226 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1227 if (RunGitCmdRetryOrAbort(cmd))
1228 return;
1229 AddLogString(out);
1230 AddLogString(CString(MAKEINTRESOURCE(IDS_DONE)));
1231 m_RebaseStage = REBASE_DONE;
1232 UpdateCurrentStatus();
1233
1234 if (m_bRebaseAutoStart)
1235 this->PostMessage(WM_COMMAND, MAKELONG(IDC_REBASE_CONTINUE, BN_CLICKED), (LPARAM)GetDlgItem(IDC_REBASE_CONTINUE)->GetSafeHwnd());
1236
1237 return;
1238 }
1239
1240 if( m_RebaseStage == CHOOSE_BRANCH|| m_RebaseStage == CHOOSE_COMMIT_PICK_MODE )
1241 {
1242 m_RebaseStage = REBASE_START;
1243 m_FileListCtrl.Clear();
1244 m_FileListCtrl.SetHasCheckboxes(false);
1245 m_FileListCtrl.m_CurrentVersion.Empty();
1246 m_ctrlTabCtrl.SetTabLabel(REBASE_TAB_CONFLICT, CString(MAKEINTRESOURCE(IDS_PROC_CONFLICTFILES)));
1247 m_ctrlTabCtrl.AddTab(&m_wndOutputRebase, CString(MAKEINTRESOURCE(IDS_LOG)), 2);
1248 }
1249
1250 if( m_RebaseStage == REBASE_FINISH )
1251 {
1252 if(FinishRebase())
1253 return ;
1254
1255 OnOK();
1256 }
1257
1258 if( m_RebaseStage == REBASE_SQUASH_CONFLICT)
1259 {
1260 if(VerifyNoConflict())
1261 return;
1262 GitRevLoglist* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1263 if(this->CheckNextCommitIsSquash())
1264 {//next commit is not squash;
1265 m_RebaseStage = REBASE_SQUASH_EDIT;
1266 this->OnRebaseUpdateUI(0,0);
1267 this->UpdateCurrentStatus();
1268 return ;
1269 }
1270 m_RebaseStage=REBASE_CONTINUE;
1271 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1272 m_forRewrite.push_back(curRev->m_CommitHash);
1273 this->UpdateCurrentStatus();
1274 }
1275
1276 if( m_RebaseStage == REBASE_CONFLICT )
1277 {
1278 if(VerifyNoConflict())
1279 return;
1280
1281 GitRevLoglist* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1282 // ***************************************************
1283 // ATTENTION: Similar code in CommitDlg.cpp!!!
1284 // ***************************************************
1285 CMassiveGitTask mgtReAddAfterCommit(L"add --ignore-errors -f");
1286 CMassiveGitTask mgtReDelAfterCommit(L"rm --cached --ignore-unmatch");
1287 CMassiveGitTask mgtAdd(L"add -f");
1288 CMassiveGitTask mgtUpdateIndexForceRemove(L"update-index --force-remove");
1289 CMassiveGitTask mgtUpdateIndex(L"update-index");
1290 CMassiveGitTask mgtRm(L"rm --ignore-unmatch");
1291 CMassiveGitTask mgtRmFCache(L"rm -f --cache");
1292 CMassiveGitTask mgtReset(L"reset", TRUE, true);
1293 for (int i = 0; i < m_FileListCtrl.GetItemCount(); i++)
1294 {
1295 auto entry = m_FileListCtrl.GetListEntry(i);
1296 if (entry->m_Checked)
1297 {
1298 if ((entry->m_Action & CTGitPath::LOGACTIONS_UNVER) || entry->IsDirectory())
1299 mgtAdd.AddFile(entry->GetGitPathString());
1300 else if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
1301 mgtUpdateIndexForceRemove.AddFile(entry->GetGitPathString());
1302 else
1303 mgtUpdateIndex.AddFile(entry->GetGitPathString());
1304
1305 if ((entry->m_Action & CTGitPath::LOGACTIONS_REPLACED) && !entry->GetGitOldPathString().IsEmpty())
1306 mgtRm.AddFile(entry->GetGitOldPathString());
1307 }
1308 else
1309 {
1310 if (entry->m_Action & CTGitPath::LOGACTIONS_ADDED || entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
1311 {
1312 mgtRmFCache.AddFile(entry->GetGitPathString());
1313 mgtReAddAfterCommit.AddFile(*entry);
1314
1315 if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED && !entry->GetGitOldPathString().IsEmpty())
1316 {
1317 mgtReset.AddFile(entry->GetGitOldPathString());
1318 mgtReDelAfterCommit.AddFile(entry->GetGitOldPathString());
1319 }
1320 }
1321 else if(!(entry->m_Action & CTGitPath::LOGACTIONS_UNVER))
1322 {
1323 mgtReset.AddFile(entry->GetGitPathString());
1324 if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED && !(entry->m_Action & CTGitPath::LOGACTIONS_MISSING))
1325 mgtReDelAfterCommit.AddFile(entry->GetGitPathString());
1326 }
1327 }
1328 }
1329
1330 BOOL cancel = FALSE;
1331 bool successful = true;
1332 successful = successful && mgtAdd.Execute(cancel);
1333 successful = successful && mgtUpdateIndexForceRemove.Execute(cancel);
1334 successful = successful && mgtUpdateIndex.Execute(cancel);
1335 successful = successful && mgtRm.Execute(cancel);
1336 successful = successful && mgtRmFCache.Execute(cancel);
1337 successful = successful && mgtReset.Execute(cancel);
1338
1339 if (!successful)
1340 {
1341 AddLogString(L"An error occurred while updating the index.");
1342 return;
1343 }
1344
1345 CString out;
1346 CString cmd;
1347 cmd.Format(L"git.exe commit --allow-empty-message -C %s", (LPCTSTR)curRev->m_CommitHash.ToString());
1348
1349 AddLogString(cmd);
1350
1351 if(g_Git.Run(cmd,&out,CP_UTF8))
1352 {
1353 AddLogString(out);
1354 if(!g_Git.CheckCleanWorkTree())
1355 {
1356 CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", MB_OK | MB_ICONERROR);
1357 return;
1358 }
1359 }
1360
1361 AddLogString(out);
1362
1363 // update commit message if needed
1364 CString str = m_LogMessageCtrl.GetText().Trim();
1365 if (str != (curRev->GetSubject() + L'\n' + curRev->GetBody()).Trim())
1366 {
1367 if (str.IsEmpty())
1368 {
1369 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_COMMITMESSAGE_EMPTY,IDS_APPNAME, MB_OK | MB_ICONERROR);
1370 return;
1371 }
1372 CString tempfile = ::GetTempFile();
1373 SCOPE_EXIT{ ::DeleteFile(tempfile); };
1374 if (CAppUtils::SaveCommitUnicodeFile(tempfile, str))
1375 {
1376 CMessageBox::Show(GetSafeHwnd(), L"Could not save commit message", L"TortoiseGit", MB_OK | MB_ICONERROR);
1377 return;
1378 }
1379
1380 out.Empty();
1381 cmd.Format(L"git.exe commit --amend -F \"%s\"", (LPCTSTR)tempfile);
1382 AddLogString(cmd);
1383
1384 if (g_Git.Run(cmd, &out, CP_UTF8))
1385 {
1386 AddLogString(out);
1387 if (!g_Git.CheckCleanWorkTree())
1388 {
1389 CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", MB_OK | MB_ICONERROR);
1390 return;
1391 }
1392 }
1393
1394 AddLogString(out);
1395 }
1396
1397 if (((DWORD)CRegStdDWORD(L"Software\\TortoiseGit\\ReaddUnselectedAddedFilesAfterCommit", TRUE)) == TRUE)
1398 {
1399 BOOL cancel2 = FALSE;
1400 mgtReAddAfterCommit.Execute(cancel2);
1401 mgtReDelAfterCommit.Execute(cancel2);
1402 }
1403
1404 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1405 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_EDIT)
1406 {
1407 m_RebaseStage=REBASE_EDIT;
1408 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1409 this->UpdateCurrentStatus();
1410 return;
1411 }
1412 else
1413 {
1414 m_RebaseStage=REBASE_CONTINUE;
1415 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1416 this->UpdateCurrentStatus();
1417
1418 if (CheckNextCommitIsSquash() == 0) // remember commit msg after edit if next commit if squash
1419 ResetParentForSquash(str);
1420 else
1421 {
1422 m_SquashMessage.Empty();
1423 CGitHash head;
1424 if (g_Git.GetHash(head, L"HEAD"))
1425 {
1426 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1427 return;
1428 }
1429 m_rewrittenCommitsMap[curRev->m_CommitHash] = head;
1430 }
1431 }
1432 }
1433
1434 if ((m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_CONTINUE || m_bSplitCommit || m_RebaseStage == REBASE_SQUASH_EDIT) && CheckNextCommitIsSquash() && (m_bSplitCommit || !g_Git.CheckCleanWorkTree(true)))
1435 {
1436 if (!m_bSplitCommit && CMessageBox::Show(GetSafeHwnd(), IDS_PROC_REBASE_CONTINUE_NOTCLEAN, IDS_APPNAME, 1, IDI_ERROR, IDS_MSGBOX_OK, IDS_ABORTBUTTON) == 2)
1437 return;
1438 BOOL isFirst = TRUE;
1439 do
1440 {
1441 CCommitDlg dlg;
1442 if (isFirst)
1443 dlg.m_sLogMessage = m_LogMessageCtrl.GetText();
1444 dlg.m_bWholeProject = true;
1445 dlg.m_bSelectFilesForCommit = true;
1446 dlg.m_bCommitAmend = isFirst && (m_RebaseStage != REBASE_SQUASH_EDIT); // do not amend on squash_edit stage, we need a normal commit there
1447 if (isFirst && m_RebaseStage == REBASE_SQUASH_EDIT)
1448 {
1449 if (m_iSquashdate != 2)
1450 dlg.SetTime(m_SquashFirstMetaData.time);
1451 dlg.SetAuthor(m_SquashFirstMetaData.GetAuthor());
1452 }
1453 CTGitPathList gpl;
1454 gpl.AddPath(CTGitPath());
1455 dlg.m_pathList = gpl;
1456 dlg.m_bAmendDiffToLastCommit = !m_bSplitCommit;
1457 dlg.m_bNoPostActions = true;
1458 if (dlg.m_bCommitAmend)
1459 dlg.m_AmendStr = dlg.m_sLogMessage;
1460 dlg.m_bWarnDetachedHead = false;
1461
1462 if (dlg.DoModal() != IDOK)
1463 return;
1464
1465 isFirst = !m_bSplitCommit; // only select amend on second+ runs if not in split commit mode
1466
1467 m_SquashMessage.Empty();
1468 } while (!g_Git.CheckCleanWorkTree() || (m_bSplitCommit && CMessageBox::Show(GetSafeHwnd(), IDS_REBASE_ADDANOTHERCOMMIT, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION) == IDYES));
1469
1470 m_bSplitCommit = FALSE;
1471 UpdateData(FALSE);
1472
1473 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1474 m_RebaseStage = REBASE_CONTINUE;
1475 GitRevLoglist* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1476 CGitHash head;
1477 if (g_Git.GetHash(head, L"HEAD"))
1478 {
1479 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1480 return;
1481 }
1482 m_rewrittenCommitsMap[curRev->m_CommitHash] = head;
1483 for (const auto& hash : m_forRewrite)
1484 m_rewrittenCommitsMap[hash] = head;
1485 m_forRewrite.clear();
1486 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1487 this->UpdateCurrentStatus();
1488 }
1489
1490 if( m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_SQUASH_EDIT )
1491 {
1492 CString str;
1493 GitRevLoglist* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1494
1495 str=this->m_LogMessageCtrl.GetText();
1496 if(str.Trim().IsEmpty())
1497 {
1498 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_COMMITMESSAGE_EMPTY,IDS_APPNAME, MB_OK | MB_ICONERROR);
1499 return;
1500 }
1501
1502 CString tempfile=::GetTempFile();
1503 SCOPE_EXIT{ ::DeleteFile(tempfile); };
1504 if (CAppUtils::SaveCommitUnicodeFile(tempfile, str))
1505 {
1506 CMessageBox::Show(GetSafeHwnd(), L"Could not save commit message", L"TortoiseGit", MB_OK | MB_ICONERROR);
1507 return;
1508 }
1509
1510 CString out,cmd;
1511
1512 if (m_RebaseStage == REBASE_SQUASH_EDIT)
1513 cmd.Format(L"git.exe commit %s-F \"%s\"", (LPCTSTR)m_SquashFirstMetaData.GetAsParam(m_iSquashdate == 2), (LPCTSTR)tempfile);
1514 else
1515 {
1516 CString options;
1517 int isEmpty = IsCommitEmpty(curRev->m_CommitHash);
1518 if (isEmpty == 1)
1519 options = L"--allow-empty ";
1520 else if (isEmpty < 0)
1521 return;
1522 cmd.Format(L"git.exe commit --amend %s-F \"%s\"", (LPCTSTR)options, (LPCTSTR)tempfile);
1523 }
1524
1525 if(g_Git.Run(cmd,&out,CP_UTF8))
1526 {
1527 if(!g_Git.CheckCleanWorkTree())
1528 {
1529 CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", MB_OK | MB_ICONERROR);
1530 return;
1531 }
1532 }
1533
1534 AddLogString(out);
1535 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
1536 {
1537 ResetParentForSquash(str);
1538 }
1539 else
1540 m_SquashMessage.Empty();
1541 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1542 m_RebaseStage=REBASE_CONTINUE;
1543 CGitHash head;
1544 if (g_Git.GetHash(head, L"HEAD"))
1545 {
1546 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1547 return;
1548 }
1549 m_rewrittenCommitsMap[curRev->m_CommitHash] = head; // we had a reset to parent, so this is not the correct hash
1550 for (const auto& hash : m_forRewrite)
1551 m_rewrittenCommitsMap[hash] = head;
1552 m_forRewrite.clear();
1553 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1554 this->UpdateCurrentStatus();
1555 }
1556
1557
1558 InterlockedExchange(&m_bThreadRunning, TRUE);
1559 SetControlEnable();
1560
1561 if (!AfxBeginThread(RebaseThreadEntry, this))
1562 {
1563 InterlockedExchange(&m_bThreadRunning, FALSE);
1564 CMessageBox::Show(GetSafeHwnd(), L"Create Rebase Thread Fail", L"TortoiseGit", MB_OK | MB_ICONERROR);
1565 SetControlEnable();
1566 }
1567 }
1568
1569 void CRebaseDlg::ResetParentForSquash(const CString& commitMessage)
1570 {
1571 m_SquashMessage = commitMessage;
1572 // reset parent so that we can do "git cherry-pick --no-commit" w/o introducing an unwanted commit
1573 CString cmd = L"git.exe reset --soft HEAD~1";
1574 m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1575 if (RunGitCmdRetryOrAbort(cmd))
1576 return;
1577 }
1578
1579 int CRebaseDlg::CheckNextCommitIsSquash()
1580 {
1581 int index;
1582 if(m_CommitList.m_IsOldFirst)
1583 index=m_CurrentRebaseIndex+1;
1584 else
1585 index=m_CurrentRebaseIndex-1;
1586
1587 GitRevLoglist* curRev;
1588 do
1589 {
1590 if(index<0)
1591 return -1;
1592 if(index>= m_CommitList.GetItemCount())
1593 return -1;
1594
1595 curRev = m_CommitList.m_arShownList.SafeGetAt(index);
1596
1597 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1598 return 0;
1599 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SKIP)
1600 {
1601 if(m_CommitList.m_IsOldFirst)
1602 ++index;
1603 else
1604 --index;
1605 }
1606 else
1607 return -1;
1608
1609 } while(curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SKIP);
1610
1611 return -1;
1612 }
1613
1614 int CRebaseDlg::GoNext()
1615 {
1616 if(m_CommitList.m_IsOldFirst)
1617 ++m_CurrentRebaseIndex;
1618 else
1619 --m_CurrentRebaseIndex;
1620 return 0;
1621 }
1622
1623 void CRebaseDlg::SetContinueButtonText()
1624 {
1625 CString Text;
1626 switch(this->m_RebaseStage)
1627 {
1628 case CHOOSE_BRANCH:
1629 case CHOOSE_COMMIT_PICK_MODE:
1630 if(this->m_IsFastForward)
1631 Text.LoadString(IDS_PROC_STARTREBASEFFBUTTON);
1632 else
1633 Text.LoadString(IDS_PROC_STARTREBASEBUTTON);
1634 break;
1635
1636 case REBASE_START:
1637 case REBASE_ERROR:
1638 case REBASE_CONTINUE:
1639 case REBASE_SQUASH_CONFLICT:
1640 Text.LoadString(IDS_CONTINUEBUTTON);
1641 break;
1642
1643 case REBASE_CONFLICT:
1644 Text.LoadString(IDS_COMMITBUTTON);
1645 break;
1646 case REBASE_EDIT:
1647 Text.LoadString(IDS_AMENDBUTTON);
1648 break;
1649
1650 case REBASE_SQUASH_EDIT:
1651 Text.LoadString(IDS_COMMITBUTTON);
1652 break;
1653
1654 case REBASE_ABORT:
1655 case REBASE_FINISH:
1656 Text.LoadString(IDS_FINISHBUTTON);
1657 break;
1658
1659 case REBASE_DONE:
1660 Text.LoadString(IDS_DONE);
1661 break;
1662 }
1663 this->GetDlgItem(IDC_REBASE_CONTINUE)->SetWindowText(Text);
1664 }
1665
1666 void CRebaseDlg::SetControlEnable()
1667 {
1668 switch(this->m_RebaseStage)
1669 {
1670 case CHOOSE_BRANCH:
1671 case CHOOSE_COMMIT_PICK_MODE:
1672
1673 this->GetDlgItem(IDC_SPLITALLOPTIONS)->EnableWindow(TRUE);
1674 this->GetDlgItem(IDC_BUTTON_UP)->EnableWindow(TRUE);
1675 this->GetDlgItem(IDC_BUTTON_DOWN)->EnableWindow(TRUE);
1676 this->GetDlgItem(IDC_BUTTON_ADD)->EnableWindow(!m_bPreserveMerges);
1677 m_CommitList.EnableDragnDrop(true);
1678
1679 if(!m_IsCherryPick)
1680 {
1681 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(TRUE);
1682 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(TRUE);
1683 this->GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(TRUE);
1684 this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(TRUE);
1685 this->GetDlgItem(IDC_REBASE_CHECK_PRESERVEMERGES)->EnableWindow(TRUE);
1686 }
1687 this->m_CommitList.m_ContextMenuMask |= m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_PICK)|
1688 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SQUASH)|
1689 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_EDIT)|
1690 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SKIP)|
1691 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_LOG);
1692 break;
1693
1694 case REBASE_START:
1695 case REBASE_CONTINUE:
1696 case REBASE_ABORT:
1697 case REBASE_ERROR:
1698 case REBASE_FINISH:
1699 case REBASE_CONFLICT:
1700 case REBASE_EDIT:
1701 case REBASE_SQUASH_CONFLICT:
1702 case REBASE_DONE:
1703 this->GetDlgItem(IDC_SPLITALLOPTIONS)->EnableWindow(FALSE);
1704 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(FALSE);
1705 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(FALSE);
1706 this->GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(FALSE);
1707 this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(FALSE);
1708 this->GetDlgItem(IDC_REBASE_CHECK_PRESERVEMERGES)->EnableWindow(FALSE);
1709 this->GetDlgItem(IDC_BUTTON_UP)->EnableWindow(FALSE);
1710 this->GetDlgItem(IDC_BUTTON_DOWN)->EnableWindow(FALSE);
1711 m_CommitList.EnableDragnDrop(false);
1712 this->GetDlgItem(IDC_BUTTON_ADD)->EnableWindow(FALSE);
1713
1714 if( m_RebaseStage == REBASE_DONE && (this->m_PostButtonTexts.GetCount() != 0) )
1715 {
1716 this->GetDlgItem(IDC_STATUS_STATIC)->ShowWindow(SW_HIDE);
1717 this->GetDlgItem(IDC_REBASE_POST_BUTTON)->ShowWindow(SW_SHOWNORMAL);
1718 this->m_PostButton.RemoveAll();
1719 this->m_PostButton.AddEntries(m_PostButtonTexts);
1720 //this->GetDlgItem(IDC_REBASE_POST_BUTTON)->SetWindowText(this->m_PostButtonText);
1721 }
1722 break;
1723 }
1724
1725 GetDlgItem(IDC_REBASE_SPLIT_COMMIT)->ShowWindow((m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_SQUASH_EDIT) ? SW_SHOW : SW_HIDE);
1726
1727 if(m_bThreadRunning)
1728 {
1729 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1730
1731 }
1732 else if (m_RebaseStage != REBASE_ERROR)
1733 {
1734 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1735 }
1736 }
1737
1738 void CRebaseDlg::UpdateProgress()
1739 {
1740 int index;
1741 CRect rect;
1742
1743 if(m_CommitList.m_IsOldFirst)
1744 index = m_CurrentRebaseIndex+1;
1745 else
1746 index = m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1747
1748 int finishedCommits = index - 1; // introduced an variable which shows the number handled revisions for the progress bars
1749 if (m_RebaseStage == REBASE_FINISH || finishedCommits == -1)
1750 finishedCommits = index;
1751
1752 m_ProgressBar.SetRange32(0, m_CommitList.GetItemCount());
1753 m_ProgressBar.SetPos(finishedCommits);
1754 if (m_pTaskbarList)
1755 {
1756 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1757 m_pTaskbarList->SetProgressValue(m_hWnd, finishedCommits, m_CommitList.GetItemCount());
1758 }
1759
1760 if(m_CurrentRebaseIndex>=0 && m_CurrentRebaseIndex< m_CommitList.GetItemCount())
1761 {
1762 CString text;
1763 text.Format(IDS_PROC_REBASING_PROGRESS, index, m_CommitList.GetItemCount());
1764 m_sStatusText = text;
1765 m_CtrlStatusText.SetWindowText(text);
1766 m_bStatusWarning = false;
1767 m_CtrlStatusText.Invalidate();
1768 }
1769
1770 GitRevLoglist* prevRev = nullptr, *curRev = nullptr;
1771
1772 if (m_CurrentRebaseIndex >= 0 && m_CurrentRebaseIndex < (int)m_CommitList.m_arShownList.size())
1773 curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1774
1775 for (int i = 0; i < (int)m_CommitList.m_arShownList.size(); ++i)
1776 {
1777 prevRev = m_CommitList.m_arShownList.SafeGetAt(i);
1778 if (prevRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_CURRENT)
1779 {
1780 prevRev->GetRebaseAction() &= ~CGitLogListBase::LOGACTIONS_REBASE_CURRENT;
1781 m_CommitList.GetItemRect(i,&rect,LVIR_BOUNDS);
1782 m_CommitList.InvalidateRect(rect);
1783 }
1784 }
1785
1786 if(curRev)
1787 {
1788 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_CURRENT;
1789 m_CommitList.GetItemRect(m_CurrentRebaseIndex,&rect,LVIR_BOUNDS);
1790 m_CommitList.InvalidateRect(rect);
1791 }
1792 m_CommitList.EnsureVisible(m_CurrentRebaseIndex,FALSE);
1793 }
1794
1795 void CRebaseDlg::UpdateCurrentStatus()
1796 {
1797 SetContinueButtonText();
1798 SetControlEnable();
1799 UpdateProgress();
1800 if (m_RebaseStage == REBASE_DONE)
1801 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
1802 }
1803
1804 void CRebaseDlg::AddLogString(CString str)
1805 {
1806 this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, FALSE);
1807 CStringA sTextA = m_wndOutputRebase.StringForControl(str);//CUnicodeUtils::GetUTF8(str);
1808 this->m_wndOutputRebase.SendMessage(SCI_DOCUMENTEND);
1809 this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)sTextA);
1810 this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)"\n");
1811 this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, TRUE);
1812 }
1813
1814 int CRebaseDlg::GetCurrentCommitID()
1815 {
1816 if(m_CommitList.m_IsOldFirst)
1817 return this->m_CurrentRebaseIndex+1;
1818 else
1819 return m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1820 }
1821
1822 int CRebaseDlg::IsCommitEmpty(const CGitHash& hash)
1823 {
1824 CString cmd, tree, ptree;
1825 cmd.Format(L"git.exe rev-parse -q --verify %s^{tree}", (LPCTSTR)hash.ToString());
1826 if (g_Git.Run(cmd, &tree, CP_UTF8))
1827 {
1828 AddLogString(cmd);
1829 AddLogString(tree);
1830 return -1;
1831 }
1832 cmd.Format(L"git.exe rev-parse -q --verify %s^^{tree}", (LPCTSTR)hash.ToString());
1833 if (g_Git.Run(cmd, &ptree, CP_UTF8))
1834 ptree = L"4b825dc642cb6eb9a060e54bf8d69288fbee4904"; // empty tree
1835 return tree == ptree;
1836 }
1837
1838 int CRebaseDlg::DoRebase()
1839 {
1840 CString cmd,out;
1841 if(m_CurrentRebaseIndex <0)
1842 return 0;
1843 if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1844 return 0;
1845
1846 GitRevLoglist* pRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
1847 int mode = pRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_MODE_MASK;
1848 CString nocommit;
1849
1850 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SKIP)
1851 {
1852 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1853 return 0;
1854 }
1855
1856 bool nextCommitIsSquash = (CheckNextCommitIsSquash() == 0);
1857 if (nextCommitIsSquash || mode != CGitLogListBase::LOGACTIONS_REBASE_PICK)
1858 { // next commit is squash or not pick
1859 if (!this->m_SquashMessage.IsEmpty())
1860 this->m_SquashMessage += L"\n\n";
1861 this->m_SquashMessage += pRev->GetSubject();
1862 this->m_SquashMessage += L'\n';
1863 this->m_SquashMessage += pRev->GetBody().TrimRight();
1864 if (m_bAddCherryPickedFrom)
1865 {
1866 if (!pRev->GetBody().IsEmpty())
1867 m_SquashMessage += L'\n';
1868 m_SquashMessage += L"(cherry picked from commit ";
1869 m_SquashMessage += pRev->m_CommitHash.ToString();
1870 m_SquashMessage += L')';
1871 }
1872 }
1873 else
1874 {
1875 this->m_SquashMessage.Empty();
1876 m_SquashFirstMetaData.Empty();
1877 }
1878
1879 if (nextCommitIsSquash && mode != CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1880 m_SquashFirstMetaData = SquashFirstMetaData(pRev);
1881
1882 if ((nextCommitIsSquash && mode != CGitLogListBase::LOGACTIONS_REBASE_EDIT) || mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1883 { // next or this commit is squash (don't do this on edit->squash sequence)
1884 nocommit = L" --no-commit ";
1885 if (m_iSquashdate == 1)
1886 m_SquashFirstMetaData.UpdateDate(pRev);
1887 }
1888
1889 CString log;
1890 log.Format(L"%s %d: %s", (LPCTSTR)CGitLogListBase::GetRebaseActionName(mode), GetCurrentCommitID(), (LPCTSTR)pRev->m_CommitHash.ToString());
1891 AddLogString(log);
1892 AddLogString(pRev->GetSubject());
1893 if (pRev->GetSubject().IsEmpty())
1894 {
1895 CMessageBox::Show(m_hWnd, IDS_PROC_REBASE_EMPTYCOMMITMSG, IDS_APPNAME, MB_OK | MB_ICONEXCLAMATION);
1896 mode = CGitLogListBase::LOGACTIONS_REBASE_EDIT;
1897 }
1898
1899 CString cherryPickedFrom;
1900 if (m_bAddCherryPickedFrom)
1901 cherryPickedFrom = L"-x ";
1902 else if (!m_IsCherryPick && nocommit.IsEmpty())
1903 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."
1904
1905 int isEmpty = IsCommitEmpty(pRev->m_CommitHash);
1906 if (isEmpty == 1)
1907 cherryPickedFrom += L"--allow-empty ";
1908 else if (isEmpty < 0)
1909 return -1;
1910
1911 if (m_IsCherryPick && pRev->m_ParentHash.size() > 1)
1912 {
1913 CString msg;
1914 msg.Format(IDS_CHERRYPICK_MERGECOMMIT, (LPCTSTR)pRev->m_CommitHash.ToString(), (LPCTSTR)pRev->GetSubject());
1915 CString parent1;
1916 parent1.Format(IDS_PARENT, 1);
1917 CString parent2;
1918 parent2.Format(IDS_PARENT, 2);
1919 CString cancel;
1920 cancel.LoadString(IDS_MSGBOX_CANCEL);
1921 auto ret = CMessageBox::Show(m_hWnd, msg, L"TortoiseGit", 3, IDI_QUESTION, parent1, parent2, cancel);
1922 if (ret == 3)
1923 return - 1;
1924
1925 cherryPickedFrom.AppendFormat(L"-m %d ", ret);
1926 }
1927
1928 while (true)
1929 {
1930 cmd.Format(L"git.exe cherry-pick %s%s %s", (LPCTSTR)cherryPickedFrom, (LPCTSTR)nocommit, (LPCTSTR)pRev->m_CommitHash.ToString());
1931 if (m_bPreserveMerges)
1932 {
1933 bool parentRewritten = false;
1934 CGitHash currentHeadHash;
1935 if (g_Git.GetHash(currentHeadHash, L"HEAD"))
1936 {
1937 m_RebaseStage = REBASE_ERROR;
1938 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1939 return -1;
1940 }
1941 if (!m_currentCommits.empty())
1942 {
1943 for (const auto& commit : m_currentCommits)
1944 m_rewrittenCommitsMap[commit] = currentHeadHash;
1945 m_currentCommits.clear();
1946 }
1947 m_currentCommits.push_back(pRev->m_CommitHash);
1948 GIT_REV_LIST possibleParents = pRev->m_ParentHash;
1949 GIT_REV_LIST newParents;
1950 for (auto it = possibleParents.cbegin(); it != possibleParents.cend(); it = possibleParents.begin())
1951 {
1952 CGitHash parent = *it;
1953 possibleParents.erase(it);
1954
1955 const auto rewrittenParent = m_rewrittenCommitsMap.find(parent);
1956 if (rewrittenParent == m_rewrittenCommitsMap.cend())
1957 {
1958 auto droppedCommitParents = m_droppedCommitsMap.find(parent);
1959 if (droppedCommitParents != m_droppedCommitsMap.cend())
1960 {
1961 parentRewritten = true;
1962 for (auto droppedIt = droppedCommitParents->second.crbegin(); droppedIt != droppedCommitParents->second.crend(); ++droppedIt)
1963 possibleParents.insert(possibleParents.begin(), *droppedIt);
1964 continue;
1965 }
1966
1967 newParents.push_back(parent);
1968 continue;
1969 }
1970
1971 if (rewrittenParent->second.IsEmpty() && parent == pRev->m_ParentHash[0] && pRev->ParentsCount() > 1)
1972 {
1973 m_RebaseStage = REBASE_ERROR;
1974 AddLogString(L"");
1975 AddLogString(L"Unrecoverable error: Merge commit parent missing.");
1976 return -1;
1977 }
1978
1979 CGitHash newParent = rewrittenParent->second;
1980 if (newParent.IsEmpty()) // use current HEAD as fallback
1981 newParent = currentHeadHash;
1982
1983 if (newParent != parent)
1984 parentRewritten = true;
1985
1986 if (std::find(newParents.begin(), newParents.end(), newParent) == newParents.end())
1987 newParents.push_back(newParent);
1988 }
1989 if (pRev->ParentsCount() > 1)
1990 {
1991 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1992 {
1993 m_RebaseStage = REBASE_ERROR;
1994 AddLogString(L"Cannot squash merge commit on rebase.");
1995 return -1;
1996 }
1997 if (!parentRewritten && nocommit.IsEmpty())
1998 cmd.Format(L"git.exe reset --hard %s", (LPCTSTR)pRev->m_CommitHash.ToString());
1999 else
2000 {
2001 CString parentString;
2002 for (const auto& parent : newParents)
2003 parentString += L' ' + parent.ToString();
2004 cmd.Format(L"git.exe checkout %s", (LPCTSTR)newParents[0].ToString());
2005 if (RunGitCmdRetryOrAbort(cmd))
2006 {
2007 m_RebaseStage = REBASE_ERROR;
2008 return -1;
2009 }
2010 cmd.Format(L"git.exe merge --no-ff%s %s", (LPCTSTR)nocommit, (LPCTSTR)parentString);
2011 if (nocommit.IsEmpty())
2012 {
2013 if (g_Git.Run(cmd, &out, CP_UTF8))
2014 {
2015 AddLogString(cmd);
2016 AddLogString(out);
2017 int hasConflicts = g_Git.HasWorkingTreeConflicts();
2018 if (hasConflicts > 0)
2019 {
2020 m_RebaseStage = REBASE_CONFLICT;
2021 return -1;
2022 }
2023 else if (hasConflicts < 0)
2024 AddLogString(g_Git.GetGitLastErr(L"Checking for conflicts failed.", CGit::GIT_CMD_CHECKCONFLICTS));
2025 AddLogString(L"An unrecoverable error occurred.");
2026 m_RebaseStage = REBASE_ERROR;
2027 return -1;
2028 }
2029 CGitHash newHeadHash;
2030 if (g_Git.GetHash(newHeadHash, L"HEAD"))
2031 {
2032 m_RebaseStage = REBASE_ERROR;
2033 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
2034 return -1;
2035 }
2036 // do nothing if already up2date
2037 if (currentHeadHash != newHeadHash)
2038 cmd.Format(L"git.exe commit --amend -C %s", (LPCTSTR)pRev->m_CommitHash.ToString());
2039 }
2040 }
2041 }
2042 else
2043 {
2044 if (mode != CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
2045 {
2046 cmd.Format(L"git.exe checkout %s", (LPCTSTR)newParents[0].ToString());
2047 if (RunGitCmdRetryOrAbort(cmd))
2048 {
2049 m_RebaseStage = REBASE_ERROR;
2050 return -1;
2051 }
2052 }
2053 cmd.Format(L"git.exe cherry-pick %s%s %s", (LPCTSTR)cherryPickedFrom, (LPCTSTR)nocommit, (LPCTSTR)pRev->m_CommitHash.ToString());
2054 }
2055 }
2056
2057 if(g_Git.Run(cmd,&out,CP_UTF8))
2058 {
2059 AddLogString(out);
2060 int hasConflicts = g_Git.HasWorkingTreeConflicts();
2061 if (hasConflicts < 0)
2062 {
2063 AddLogString(g_Git.GetGitLastErr(L"Checking for conflicts failed.", CGit::GIT_CMD_CHECKCONFLICTS));
2064 return -1;
2065 }
2066 if (!hasConflicts)
2067 {
2068 if (mode == CGitLogListBase::LOGACTIONS_REBASE_PICK)
2069 {
2070 if (m_pTaskbarList)
2071 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
2072 int choose = -1;
2073 if (!m_bAutoSkipFailedCommit)
2074 {
2075 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);
2076 if (choose == 2)
2077 {
2078 m_bAutoSkipFailedCommit = FALSE;
2079 continue; // retry cherry pick
2080 }
2081 }
2082 if (m_bAutoSkipFailedCommit || choose == 1)
2083 {
2084 if (!RunGitCmdRetryOrAbort(L"git.exe reset --hard"))
2085 {
2086 pRev->GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_SKIP;
2087 m_CommitList.Invalidate();
2088 return 0;
2089 }
2090 }
2091
2092 m_RebaseStage = REBASE_ERROR;
2093 AddLogString(L"An unrecoverable error occurred.");
2094 return -1;
2095 }
2096 if (mode == CGitLogListBase::LOGACTIONS_REBASE_EDIT)
2097 {
2098 this->m_RebaseStage = REBASE_EDIT ;
2099 return -1; // Edit return -1 to stop rebase.
2100 }
2101 // Squash Case
2102 if(CheckNextCommitIsSquash())
2103 { // no squash
2104 // let user edit last commmit message
2105 this->m_RebaseStage = REBASE_SQUASH_EDIT;
2106 return -1;
2107 }
2108 }
2109
2110 if (m_pTaskbarList)
2111 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
2112 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
2113 m_RebaseStage = REBASE_SQUASH_CONFLICT;
2114 else
2115 m_RebaseStage = REBASE_CONFLICT;
2116 return -1;
2117
2118 }
2119 else
2120 {
2121 AddLogString(out);
2122 if (mode == CGitLogListBase::LOGACTIONS_REBASE_PICK)
2123 {
2124 if (nocommit.IsEmpty())
2125 {
2126 CGitHash head;
2127 if (g_Git.GetHash(head, L"HEAD"))
2128 {
2129 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
2130 m_RebaseStage = REBASE_ERROR;
2131 return -1;
2132 }
2133 m_rewrittenCommitsMap[pRev->m_CommitHash] = head;
2134 }
2135 else
2136 m_forRewrite.push_back(pRev->m_CommitHash);
2137 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
2138 return 0;
2139 }
2140 if (mode == CGitLogListBase::LOGACTIONS_REBASE_EDIT)
2141 {
2142 this->m_RebaseStage = REBASE_EDIT ;
2143 return -1; // Edit return -1 to stop rebase.
2144 }
2145
2146 // Squash Case
2147 if(CheckNextCommitIsSquash())
2148 { // no squash
2149 // let user edit last commmit message
2150 this->m_RebaseStage = REBASE_SQUASH_EDIT;
2151 return -1;
2152 }
2153 else if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
2154 {
2155 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
2156 m_forRewrite.push_back(pRev->m_CommitHash);
2157 }
2158 }
2159
2160 return 0;
2161 }
2162 }
2163
2164 BOOL CRebaseDlg::IsEnd()
2165 {
2166 if(m_CommitList.m_IsOldFirst)
2167 return m_CurrentRebaseIndex>= this->m_CommitList.GetItemCount();
2168 else
2169 return m_CurrentRebaseIndex<0;
2170 }
2171
2172 int CRebaseDlg::RebaseThread()
2173 {
2174 CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
2175
2176 int ret=0;
2177 while(1)
2178 {
2179 if( m_RebaseStage == REBASE_START )
2180 {
2181 if( this->StartRebase() )
2182 {
2183 ret = -1;
2184 break;
2185 }
2186 m_RebaseStage = REBASE_CONTINUE;
2187 }
2188 else if( m_RebaseStage == REBASE_CONTINUE )
2189 {
2190 this->GoNext();
2191 SendMessage(MSG_REBASE_UPDATE_UI);
2192 if(IsEnd())
2193 {
2194 ret = 0;
2195 m_RebaseStage = REBASE_FINISH;
2196 }
2197 else
2198 {
2199 ret = DoRebase();
2200 if( ret )
2201 break;
2202 }
2203 }
2204 else if( m_RebaseStage == REBASE_FINISH )
2205 {
2206 SendMessage(MSG_REBASE_UPDATE_UI);
2207 m_RebaseStage = REBASE_DONE;
2208 break;
2209 }
2210 else
2211 break;
2212 this->PostMessage(MSG_REBASE_UPDATE_UI);
2213 }
2214
2215 InterlockedExchange(&m_bThreadRunning, FALSE);
2216 this->PostMessage(MSG_REBASE_UPDATE_UI);
2217 return ret;
2218 }
2219
2220 void CRebaseDlg::ListConflictFile(bool noStoreScrollPosition)
2221 {
2222 if (!noStoreScrollPosition)
2223 m_FileListCtrl.StoreScrollPos();
2224 this->m_FileListCtrl.Clear();
2225 m_FileListCtrl.SetHasCheckboxes(true);
2226 CTGitPathList list;
2227 CTGitPath path;
2228 list.AddPath(path);
2229
2230 if (!m_IsCherryPick)
2231 {
2232 CString adminDir;
2233 if (GitAdminDir::GetAdminDirPath(g_Git.m_CurrentDir, adminDir))
2234 CreateDirectory(adminDir + L"tgitrebase.active", nullptr);
2235 }
2236
2237 this->m_FileListCtrl.GetStatus(&list,true);
2238 m_FileListCtrl.Show(CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED | CTGitPath::LOGACTIONS_ADDED | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_REPLACED, CTGitPath::LOGACTIONS_UNMERGED);
2239
2240 m_FileListCtrl.Check(GITSLC_SHOWFILES);
2241 bool hasSubmoduleChange = false;
2242 for (int i = 0; i < m_FileListCtrl.GetItemCount(); i++)
2243 {
2244 auto entry = m_FileListCtrl.GetListEntry(i);
2245 if (entry->IsDirectory())
2246 {
2247 hasSubmoduleChange = true;
2248 break;
2249 }
2250 }
2251
2252 if (hasSubmoduleChange)
2253 {
2254 m_CtrlStatusText.SetWindowText(m_sStatusText + L", " + CString(MAKEINTRESOURCE(IDS_CARE_SUBMODULE_CHANGES)));
2255 m_bStatusWarning = true;
2256 m_CtrlStatusText.Invalidate();
2257 }
2258 else
2259 {
2260 m_CtrlStatusText.SetWindowText(m_sStatusText);
2261 m_bStatusWarning = false;
2262 m_CtrlStatusText.Invalidate();
2263 }
2264 }
2265
2266 LRESULT CRebaseDlg::OnRebaseUpdateUI(WPARAM,LPARAM)
2267 {
2268 if (m_RebaseStage == REBASE_FINISH)
2269 {
2270 FinishRebase();
2271 return 0;
2272 }
2273 UpdateCurrentStatus();
2274
2275 if (m_RebaseStage == REBASE_DONE && m_bRebaseAutoEnd)
2276 {
2277 m_bRebaseAutoEnd = false;
2278 this->PostMessage(WM_COMMAND, MAKELONG(IDC_REBASE_CONTINUE, BN_CLICKED), (LPARAM)GetDlgItem(IDC_REBASE_CONTINUE)->GetSafeHwnd());
2279 }
2280
2281 if (m_RebaseStage == REBASE_DONE && m_pTaskbarList)
2282 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS); // do not show progress on taskbar any more to show we finished
2283 if(m_CurrentRebaseIndex <0)
2284 return 0;
2285 if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
2286 return 0;
2287 GitRev* curRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
2288
2289 switch(m_RebaseStage)
2290 {
2291 case REBASE_CONFLICT:
2292 case REBASE_SQUASH_CONFLICT:
2293 {
2294 ListConflictFile(true);
2295 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_CONFLICT);
2296 if (m_pTaskbarList)
2297 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
2298 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2299 CString logMessage;
2300 if (m_IsCherryPick)
2301 {
2302 CString dotGitPath;
2303 GitAdminDir::GetAdminDirPath(g_Git.m_CurrentDir, dotGitPath);
2304 // vanilla git also re-uses MERGE_MSG on conflict (listing all conflicted files)
2305 // and it's also needed for cherry-pick in order to get cherry-picked-from included on conflicts
2306 CGit::LoadTextFile(dotGitPath + L"MERGE_MSG", logMessage);
2307 }
2308 if (logMessage.IsEmpty())
2309 logMessage = curRev->GetSubject() + L'\n' + curRev->GetBody();
2310 this->m_LogMessageCtrl.SetText(logMessage);
2311 break;
2312 }
2313 case REBASE_EDIT:
2314 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
2315 if (m_pTaskbarList)
2316 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
2317 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2318 if (m_bAddCherryPickedFrom)
2319 {
2320 // Since the new commit is done and the HEAD points to it,
2321 // just using the new body modified by git self.
2322 GitRev headRevision;
2323 if (headRevision.GetCommit(L"HEAD"))
2324 MessageBox(headRevision.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
2325
2326 m_LogMessageCtrl.SetText(headRevision.GetSubject() + L'\n' + headRevision.GetBody());
2327 }
2328 else
2329 m_LogMessageCtrl.SetText(curRev->GetSubject() + L'\n' + curRev->GetBody());
2330 break;
2331 case REBASE_SQUASH_EDIT:
2332 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
2333 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2334 this->m_LogMessageCtrl.SetText(this->m_SquashMessage);
2335 if (m_pTaskbarList)
2336 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
2337 break;
2338 default:
2339 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
2340 }
2341 return 0;
2342 }
2343
2344 void CRebaseDlg::OnCancel()
2345 {
2346 OnBnClickedAbort();
2347 }
2348
2349 void CRebaseDlg::OnBnClickedAbort()
2350 {
2351 if (m_pTaskbarList)
2352 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
2353
2354 m_tooltips.Pop();
2355
2356 if(m_OrigUpstreamHash.IsEmpty())
2357 {
2358 __super::OnCancel();
2359 }
2360
2361 if(m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage== CHOOSE_COMMIT_PICK_MODE)
2362 {
2363 goto end;
2364 }
2365
2366 if (CMessageBox::Show(GetSafeHwnd(), IDS_PROC_REBASE_ABORT, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION) != IDYES)
2367 goto end;
2368
2369 if(this->m_IsFastForward)
2370 {
2371 CString cmd;
2372 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)this->m_OrigBranchHash.ToString());
2373 RunGitCmdRetryOrAbort(cmd);
2374 __super::OnCancel();
2375 goto end;
2376 }
2377
2378 if (m_IsCherryPick) // there are not "branch" at cherry pick mode
2379 {
2380 CString cmd;
2381 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)m_OrigUpstreamHash.ToString());
2382 RunGitCmdRetryOrAbort(cmd);
2383 __super::OnCancel();
2384 goto end;
2385 }
2386
2387 if (m_OrigHEADBranch == m_BranchCtrl.GetString())
2388 {
2389 CString cmd, out;
2390 if (IsLocalBranch(m_OrigHEADBranch))
2391 cmd.Format(L"git.exe checkout -f -B %s %s --", (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)m_OrigBranchHash.ToString());
2392 else
2393 cmd.Format(L"git.exe checkout -f %s --", (LPCTSTR)m_OrigBranchHash.ToString());
2394 if (g_Git.Run(cmd, &out, CP_UTF8))
2395 {
2396 AddLogString(out);
2397 ::MessageBox(m_hWnd, L"Unrecoverable error on cleanup:\n" + out, L"TortoiseGit", MB_ICONERROR);
2398 __super::OnCancel();
2399 goto end;
2400 }
2401
2402 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)m_OrigBranchHash.ToString());
2403 RunGitCmdRetryOrAbort(cmd);
2404 }
2405 else
2406 {
2407 CString cmd, out;
2408 if (m_OrigHEADBranch != g_Git.GetCurrentBranch(true))
2409 {
2410 if (IsLocalBranch(m_OrigHEADBranch))
2411 cmd.Format(L"git.exe checkout -f -B %s %s --", (LPCTSTR)m_OrigHEADBranch, (LPCTSTR)m_OrigHEADHash.ToString());
2412 else
2413 cmd.Format(L"git.exe checkout -f %s --", (LPCTSTR)m_OrigHEADHash.ToString());
2414 if (g_Git.Run(cmd, &out, CP_UTF8))
2415 {
2416 AddLogString(out);
2417 ::MessageBox(m_hWnd, L"Unrecoverable error on cleanup:\n" + out, L"TortoiseGit", MB_ICONERROR);
2418 // continue to restore moved branch
2419 }
2420 }
2421
2422 cmd.Format(L"git.exe reset --hard %s --", (LPCTSTR)m_OrigHEADHash.ToString());
2423 RunGitCmdRetryOrAbort(cmd);
2424
2425 // restore moved branch
2426 if (IsLocalBranch(m_BranchCtrl.GetString()))
2427 {
2428 cmd.Format(L"git.exe branch -f %s %s --", (LPCTSTR)m_BranchCtrl.GetString(), (LPCTSTR)m_OrigBranchHash.ToString());
2429 if (g_Git.Run(cmd, &out, CP_UTF8))
2430 {
2431 AddLogString(out);
2432 ::MessageBox(m_hWnd, L"Unrecoverable error on cleanup:\n" + out, L"TortoiseGit", MB_ICONERROR);
2433 __super::OnCancel();
2434 goto end;
2435 }
2436 }
2437 }
2438 __super::OnCancel();
2439 end:
2440 CleanUpRebaseActiveFolder();
2441 CheckRestoreStash();
2442 }
2443
2444 void CRebaseDlg::OnBnClickedButtonReverse()
2445 {
2446 CString temp = m_BranchCtrl.GetString();
2447 m_BranchCtrl.AddString(m_UpstreamCtrl.GetString());
2448 m_UpstreamCtrl.AddString(temp);
2449 OnCbnSelchangeUpstream();
2450 }
2451
2452 void CRebaseDlg::OnBnClickedButtonBrowse()
2453 {
2454 if(CBrowseRefsDlg::PickRefForCombo(&m_UpstreamCtrl))
2455 OnCbnSelchangeUpstream();
2456 }
2457
2458 void CRebaseDlg::OnBnClickedRebaseCheckForce()
2459 {
2460 this->UpdateData();
2461 GetDlgItem(IDC_BUTTON_ADD)->EnableWindow(!m_bPreserveMerges);
2462 this->FetchLogList();
2463 }
2464
2465 void CRebaseDlg::OnBnClickedRebasePostButton()
2466 {
2467 this->m_Upstream=this->m_UpstreamCtrl.GetString();
2468 this->m_Branch=this->m_BranchCtrl.GetString();
2469
2470 this->EndDialog((int)(IDC_REBASE_POST_BUTTON+this->m_PostButton.GetCurrentEntry()));
2471 }
2472
2473 LRESULT CRebaseDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
2474 {
2475 Refresh();
2476 return 0;
2477 }
2478
2479 void CRebaseDlg::Refresh()
2480 {
2481 if (m_RebaseStage == REBASE_CONFLICT || m_RebaseStage == REBASE_SQUASH_CONFLICT)
2482 {
2483 ListConflictFile(false);
2484 return;
2485 }
2486
2487 if(this->m_IsCherryPick)
2488 return ;
2489
2490 if(this->m_RebaseStage == CHOOSE_BRANCH )
2491 {
2492 this->UpdateData();
2493 this->FetchLogList();
2494 }
2495 }
2496
2497 void CRebaseDlg::OnBnClickedButtonUp()
2498 {
2499 POSITION pos;
2500 pos = m_CommitList.GetFirstSelectedItemPosition();
2501
2502 bool moveToTop = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
2503 // do nothing if the first selected item is the first item in the list
2504 if (!moveToTop && m_CommitList.GetNextSelectedItem(pos) == 0)
2505 return;
2506
2507 pos = m_CommitList.GetFirstSelectedItemPosition();
2508
2509 int count = 0;
2510 bool changed = false;
2511 while(pos)
2512 {
2513 int index=m_CommitList.GetNextSelectedItem(pos);
2514 count = moveToTop ? count : (index - 1);
2515 while (index > count)
2516 {
2517 CGitHash old = m_CommitList.m_logEntries[index - 1];
2518 m_CommitList.m_logEntries[index - 1] = m_CommitList.m_logEntries[index];
2519 m_CommitList.m_logEntries[index] = old;
2520 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
2521 m_CommitList.SetItemState(index - 1, LVIS_SELECTED, LVIS_SELECTED);
2522 m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
2523 changed = true;
2524 index--;
2525 }
2526 count++;
2527 }
2528 if (changed)
2529 {
2530 pos = m_CommitList.GetFirstSelectedItemPosition();
2531 m_CommitList.EnsureVisible(m_CommitList.GetNextSelectedItem(pos), false);
2532 m_CommitList.Invalidate();
2533 m_CommitList.SetFocus();
2534 }
2535 }
2536
2537 void CRebaseDlg::OnBnClickedButtonDown()
2538 {
2539 if (m_CommitList.GetSelectedCount() == 0)
2540 return;
2541
2542 bool moveToBottom = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
2543 POSITION pos;
2544 pos = m_CommitList.GetFirstSelectedItemPosition();
2545 bool changed = false;
2546 // use an array to store all selected item indexes; the user won't select too much items
2547 auto indexes = std::make_unique<int[]>(m_CommitList.GetSelectedCount());
2548 int i = 0;
2549 while(pos)
2550 indexes.get()[i++] = m_CommitList.GetNextSelectedItem(pos);
2551 // don't move any item if the last selected item is the last item in the m_CommitList
2552 // (that would change the order of the selected items)
2553 if (!moveToBottom && indexes.get()[m_CommitList.GetSelectedCount() - 1] >= m_CommitList.GetItemCount() - 1)
2554 return;
2555 int count = m_CommitList.GetItemCount() - 1;
2556 // iterate over the indexes backwards in order to correctly move multiselected items
2557 for (i = m_CommitList.GetSelectedCount() - 1; i >= 0; i--)
2558 {
2559 int index = indexes.get()[i];
2560 count = moveToBottom ? count : (index + 1);
2561 while (index < count)
2562 {
2563 CGitHash old = m_CommitList.m_logEntries[index + 1];
2564 m_CommitList.m_logEntries[index + 1] = m_CommitList.m_logEntries[index];
2565 m_CommitList.m_logEntries[index] = old;
2566 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
2567 m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
2568 m_CommitList.SetItemState(index + 1, LVIS_SELECTED, LVIS_SELECTED);
2569 changed = true;
2570 index++;
2571 }
2572 count--;
2573 }
2574 m_CommitList.EnsureVisible(indexes.get()[m_CommitList.GetSelectedCount() - 1] + 1, false);
2575 if (changed)
2576 {
2577 m_CommitList.Invalidate();
2578 m_CommitList.SetFocus();
2579 }
2580 }
2581
2582 LRESULT CRebaseDlg::OnCommitsReordered(WPARAM wParam, LPARAM /*lParam*/)
2583 {
2584 POSITION pos = m_CommitList.GetFirstSelectedItemPosition();
2585 int first = m_CommitList.GetNextSelectedItem(pos);
2586 int last = first;
2587 while (pos)
2588 last = m_CommitList.GetNextSelectedItem(pos);
2589 ++last;
2590
2591 for (int i = first; i < last; ++i)
2592 m_CommitList.SetItemState(i, 0, LVIS_SELECTED);
2593
2594 int dest = (int)wParam;
2595 if (dest > first)
2596 {
2597 std::rotate(m_CommitList.m_logEntries.begin() + first, m_CommitList.m_logEntries.begin() + last, m_CommitList.m_logEntries.begin() + dest);
2598 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
2599 for (int i = first + dest - last; i < dest; ++i)
2600 m_CommitList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2601 }
2602 else
2603 {
2604 std::rotate(m_CommitList.m_logEntries.begin() + dest, m_CommitList.m_logEntries.begin() + first, m_CommitList.m_logEntries.begin() + last);
2605 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
2606 for (int i = dest; i < dest + (last - first); ++i)
2607 m_CommitList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2608 }
2609
2610 m_CommitList.Invalidate();
2611
2612 return 0;
2613 }
2614
2615 LRESULT CRebaseDlg::OnTaskbarBtnCreated(WPARAM wParam, LPARAM lParam)
2616 {
2617 m_pTaskbarList.Release();
2618 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
2619 return __super::OnTaskbarButtonCreated(wParam, lParam);
2620 }
2621
2622 void CRebaseDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
2623 {
2624 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
2625 *pResult = 0;
2626 if(m_CommitList.m_bNoDispUpdates)
2627 return;
2628 if (pNMLV->iItem >= 0)
2629 {
2630 this->m_CommitList.m_nSearchIndex = pNMLV->iItem;
2631 if (pNMLV->iSubItem != 0)
2632 return;
2633 if (pNMLV->iItem == (int)m_CommitList.m_arShownList.size())
2634 {
2635 // remove the selected state
2636 if (pNMLV->uChanged & LVIF_STATE)
2637 {
2638 m_CommitList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
2639 FillLogMessageCtrl();
2640 }
2641 return;
2642 }
2643 if (pNMLV->uChanged & LVIF_STATE)
2644 FillLogMessageCtrl();
2645 }
2646 else
2647 FillLogMessageCtrl();
2648 }
2649
2650 void CRebaseDlg::FillLogMessageCtrl()
2651 {
2652 int selCount = m_CommitList.GetSelectedCount();
2653 if (selCount == 1 && (m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage == CHOOSE_COMMIT_PICK_MODE))
2654 {
2655 POSITION pos = m_CommitList.GetFirstSelectedItemPosition();
2656 int selIndex = m_CommitList.GetNextSelectedItem(pos);
2657 GitRevLoglist* pLogEntry = m_CommitList.m_arShownList.SafeGetAt(selIndex);
2658 m_FileListCtrl.UpdateWithGitPathList(pLogEntry->GetFiles(&m_CommitList));
2659 m_FileListCtrl.m_CurrentVersion = pLogEntry->m_CommitHash;
2660 m_FileListCtrl.Show(GITSLC_SHOWVERSIONED);
2661 m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2662 m_LogMessageCtrl.SetText(pLogEntry->GetSubject() + L'\n' + pLogEntry->GetBody());
2663 m_LogMessageCtrl.Call(SCI_SETREADONLY, TRUE);
2664 }
2665 }
2666 void CRebaseDlg::OnBnClickedCheckCherryPickedFrom()
2667 {
2668 UpdateData();
2669 }
2670
2671 LRESULT CRebaseDlg::OnRebaseActionMessage(WPARAM, LPARAM)
2672 {
2673 if (m_RebaseStage == REBASE_ERROR || m_RebaseStage == REBASE_CONFLICT)
2674 {
2675 GitRevLoglist* pRev = m_CommitList.m_arShownList.SafeGetAt(m_CurrentRebaseIndex);
2676 int mode = pRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_MODE_MASK;
2677 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SKIP)
2678 {
2679 if (!RunGitCmdRetryOrAbort(L"git.exe reset --hard"))
2680 {
2681 m_FileListCtrl.Clear();
2682 m_RebaseStage = REBASE_CONTINUE;
2683 UpdateCurrentStatus();
2684 }
2685 }
2686 }
2687 return 0;
2688 }
2689
2690
2691 void CRebaseDlg::OnBnClickedSplitAllOptions()
2692 {
2693 switch (m_SplitAllOptions.GetCurrentEntry())
2694 {
2695 case 0:
2696 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_PICK);
2697 break;
2698 case 1:
2699 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SQUASH);
2700 break;
2701 case 2:
2702 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_EDIT);
2703 break;
2704 case 3:
2705 m_CommitList.SetUnselectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SKIP);
2706 break;
2707 case 4:
2708 m_CommitList.SetUnselectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SQUASH);
2709 break;
2710 case 5:
2711 m_CommitList.SetUnselectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_EDIT);
2712 break;
2713 default:
2714 ATLASSERT(false);
2715 }
2716 }
2717
2718 void CRebaseDlg::OnBnClickedRebaseSplitCommit()
2719 {
2720 UpdateData();
2721 }
2722
2723 static bool GetCompareHash(const CString& ref, const CGitHash& hash)
2724 {
2725 CGitHash refHash;
2726 if (g_Git.GetHash(refHash, ref))
2727 MessageBox(nullptr, g_Git.GetGitLastErr(L"Could not get hash of \"" + ref + L"\"."), L"TortoiseGit", MB_ICONERROR);
2728 return refHash.IsEmpty() || (hash == refHash);
2729 }
2730
2731 void CRebaseDlg::OnBnClickedButtonOnto()
2732 {
2733 m_Onto = CBrowseRefsDlg::PickRef(false, m_Onto);
2734 if (!m_Onto.IsEmpty())
2735 {
2736 // make sure that the user did not select upstream, selected branch or HEAD
2737 CGitHash hash;
2738 if (g_Git.GetHash(hash, m_Onto))
2739 {
2740 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_BranchCtrl.GetString() + L"\"."), L"TortoiseGit", MB_ICONERROR);
2741 m_Onto.Empty();
2742 ((CButton*)GetDlgItem(IDC_BUTTON_ONTO))->SetCheck(m_Onto.IsEmpty() ? BST_UNCHECKED : BST_CHECKED);
2743 return;
2744 }
2745 if (GetCompareHash(L"HEAD", hash) || GetCompareHash(m_UpstreamCtrl.GetString(), hash) || GetCompareHash(m_BranchCtrl.GetString(), hash))
2746 m_Onto.Empty();
2747 }
2748 if (m_Onto.IsEmpty())
2749 m_tooltips.DelTool(IDC_BUTTON_ONTO);
2750 else
2751 m_tooltips.AddTool(IDC_BUTTON_ONTO, m_Onto);
2752 ((CButton*)GetDlgItem(IDC_BUTTON_ONTO))->SetCheck(m_Onto.IsEmpty() ? BST_UNCHECKED : BST_CHECKED);
2753 FetchLogList();
2754 }
2755
2756 void CRebaseDlg::OnHelp()
2757 {
2758 HtmlHelp(0x20000 + (m_IsCherryPick ? IDD_REBASECHERRYPICK : IDD_REBASE));
2759 }
2760
2761 int CRebaseDlg::RunGitCmdRetryOrAbort(const CString& cmd)
2762 {
2763 while (true)
2764 {
2765 CString out;
2766 if (g_Git.Run(cmd, &out, CP_UTF8))
2767 {
2768 AddLogString(cmd);
2769 AddLogString(CString(MAKEINTRESOURCE(IDS_FAIL)));
2770 AddLogString(out);
2771 CString msg;
2772 msg.Format(L"\"%s\" failed.\n%s", (LPCTSTR)cmd, (LPCTSTR)out);
2773 if (CMessageBox::Show(GetSafeHwnd(), msg, L"TortoiseGit", 1, IDI_ERROR, CString(MAKEINTRESOURCE(IDS_MSGBOX_RETRY)), CString(MAKEINTRESOURCE(IDS_MSGBOX_ABORT))) != 1)
2774 return -1;
2775 }
2776 else
2777 return 0;
2778 }
2779 }
2780
2781 LRESULT CRebaseDlg::OnThemeChanged()
2782 {
2783 CMFCVisualManager::GetInstance()->DestroyInstance();
2784 return 0;
2785 }
2786
2787 void CRebaseDlg::OnSysColorChange()
2788 {
2789 __super::OnSysColorChange();
2790 m_LogMessageCtrl.SetColors(true);
2791 m_LogMessageCtrl.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
2792 m_wndOutputRebase.SetColors(true);
2793 m_wndOutputRebase.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
2794 }
2795
2796 void CRebaseDlg::OnBnClickedButtonAdd()
2797 {
2798 CLogDlg dlg;
2799 // tell the dialog to use mode for selecting revisions
2800 dlg.SetSelect(true);
2801 // allow multi-select
2802 dlg.SingleSelection(false);
2803 if (dlg.DoModal() != IDOK)
2804 return;
2805
2806 auto selectedHashes = dlg.GetSelectedHash();
2807 for (auto it = selectedHashes.crbegin(); it != selectedHashes.crend(); ++it)
2808 {
2809 GitRevLoglist* pRev = m_CommitList.m_logEntries.m_pLogCache->GetCacheData(*it);
2810 if (pRev->GetCommit(*it))
2811 return;
2812 if (pRev->GetParentFromHash(pRev->m_CommitHash))
2813 return;
2814 pRev->GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_PICK;
2815 if (m_CommitList.m_IsOldFirst)
2816 {
2817 m_CommitList.m_logEntries.push_back(pRev->m_CommitHash);
2818 m_CommitList.m_arShownList.SafeAdd(pRev);
2819 }
2820 else
2821 {
2822 m_CommitList.m_logEntries.insert(m_CommitList.m_logEntries.cbegin(), pRev->m_CommitHash);
2823 m_CommitList.m_arShownList.SafeAddFront(pRev);
2824 }
2825 }
2826 m_CommitList.SetItemCountEx((int)m_CommitList.m_logEntries.size());
2827 m_CommitList.Invalidate();
2828
2829 if (m_CommitList.m_IsOldFirst)
2830 m_CurrentRebaseIndex = -1;
2831 else
2832 m_CurrentRebaseIndex = (int)m_CommitList.m_logEntries.size();
2833 }
Windows Explorer Extension to Operate Git