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