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