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