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