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