?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix FF rebase failure (regression of 59b422d3dae39b681fd82a6e4bd356a016eed7c3)
[TortoiseGit.git] / src / TortoiseProc / RebaseDlg.cpp
blob657febfcfaa50bfa9babcfad6fcd7857a5e5c2c0
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
433 if(!m_Upstream.IsEmpty())
434 {
435 m_UpstreamCtrl.AddString(m_Upstream);
436 }
437 else
438 {
439 //Select pull-remote from current branch
440 CString pullRemote, pullBranch;
441 g_Git.GetRemoteTrackedBranchForHEAD(pullRemote, pullBranch);
442
443 CString defaultUpstream;
444 defaultUpstream.Format(L"remotes/%s/%s", pullRemote, pullBranch);
445 int found = m_UpstreamCtrl.FindStringExact(0, defaultUpstream);
446 if(found >= 0)
447 m_UpstreamCtrl.SetCurSel(found);
448 else
449 m_UpstreamCtrl.SetCurSel(-1);
450 }
451 AddBranchToolTips(&m_UpstreamCtrl);
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 --no-track -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 if (CAppUtils::SaveCommitUnicodeFile(tempfile, str))
1189 {
1190 CMessageBox::Show(nullptr, _T("Could not save commit message"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1191 return;
1192 }
1193
1194 out.Empty();
1195 cmd.Format(_T("git.exe commit --amend -F \"%s\""), tempfile);
1196 AddLogString(cmd);
1197
1198 if (g_Git.Run(cmd, &out, CP_UTF8))
1199 {
1200 AddLogString(out);
1201 if (!g_Git.CheckCleanWorkTree())
1202 {
1203 CMessageBox::Show(NULL, out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1204 return;
1205 }
1206 }
1207
1208 AddLogString(out);
1209 }
1210
1211 if (((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\ReaddUnselectedAddedFilesAfterCommit"), TRUE)) == TRUE)
1212 {
1213 BOOL cancel = FALSE;
1214 mgtReAddAfterCommit.Execute(cancel);
1215 }
1216
1217 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1218 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_EDIT)
1219 {
1220 m_RebaseStage=REBASE_EDIT;
1221 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1222 this->UpdateCurrentStatus();
1223 return;
1224 }
1225 else
1226 {
1227 m_RebaseStage=REBASE_CONTINUE;
1228 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1229 this->UpdateCurrentStatus();
1230
1231 if (CheckNextCommitIsSquash() == 0) // remember commit msg after edit if next commit if squash
1232 ResetParentForSquash(str);
1233 else
1234 m_SquashMessage.Empty();
1235 }
1236 }
1237
1238 if ((m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_CONTINUE) && CheckNextCommitIsSquash())
1239 {
1240 while (!g_Git.CheckCleanWorkTree())
1241 {
1242 if (CMessageBox::Show(nullptr, IDS_PROC_REBASE_CONTINUE_NOTCLEAN, IDS_APPNAME, 1, IDI_ERROR, IDS_MSGBOX_RETRY, IDS_IGNOREBUTTON) == 2)
1243 break;
1244 }
1245 }
1246
1247 if( m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_SQUASH_EDIT )
1248 {
1249 CString str;
1250 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1251
1252 str=this->m_LogMessageCtrl.GetText();
1253 if(str.Trim().IsEmpty())
1254 {
1255 CMessageBox::Show(NULL, IDS_PROC_COMMITMESSAGE_EMPTY,IDS_APPNAME, MB_OK | MB_ICONERROR);
1256 return;
1257 }
1258
1259 CString tempfile=::GetTempFile();
1260 if (CAppUtils::SaveCommitUnicodeFile(tempfile, str))
1261 {
1262 CMessageBox::Show(nullptr, _T("Could not save commit message"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1263 return;
1264 }
1265
1266 CString out,cmd;
1267
1268 if( m_RebaseStage == REBASE_SQUASH_EDIT )
1269 cmd.Format(_T("git.exe commit %s-F \"%s\""), m_SquashFirstMetaData, tempfile);
1270 else
1271 cmd.Format(_T("git.exe commit --amend -F \"%s\""), tempfile);
1272
1273 if(g_Git.Run(cmd,&out,CP_UTF8))
1274 {
1275 if(!g_Git.CheckCleanWorkTree())
1276 {
1277 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1278 return;
1279 }
1280 }
1281
1282 ::DeleteFile(tempfile);
1283 AddLogString(out);
1284 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
1285 {
1286 ResetParentForSquash(str);
1287 }
1288 else
1289 m_SquashMessage.Empty();
1290 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1291 m_RebaseStage=REBASE_CONTINUE;
1292 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1293 this->UpdateCurrentStatus();
1294 }
1295
1296
1297 InterlockedExchange(&m_bThreadRunning, TRUE);
1298 SetControlEnable();
1299
1300 if (AfxBeginThread(RebaseThreadEntry, this)==NULL)
1301 {
1302 InterlockedExchange(&m_bThreadRunning, FALSE);
1303 CMessageBox::Show(NULL, _T("Create Rebase Thread Fail"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1304 SetControlEnable();
1305 }
1306 }
1307 void CRebaseDlg::ResetParentForSquash(const CString& commitMessage)
1308 {
1309 m_SquashMessage = commitMessage;
1310 // reset parent so that we can do "git cherry-pick --no-commit" w/o introducing an unwanted commit
1311 CString cmd = _T("git.exe reset --soft HEAD~1");
1312 m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1313 while (true)
1314 {
1315 CString out;
1316 if (g_Git.Run(cmd, &out, CP_UTF8))
1317 {
1318 AddLogString(cmd);
1319 AddLogString(CString(MAKEINTRESOURCE(IDS_FAIL)));
1320 AddLogString(out);
1321 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1322 return;
1323 }
1324 else
1325 break;
1326 }
1327 }
1328 int CRebaseDlg::CheckNextCommitIsSquash()
1329 {
1330 int index;
1331 if(m_CommitList.m_IsOldFirst)
1332 index=m_CurrentRebaseIndex+1;
1333 else
1334 index=m_CurrentRebaseIndex-1;
1335
1336 GitRev *curRev;
1337 do
1338 {
1339 if(index<0)
1340 return -1;
1341 if(index>= m_CommitList.GetItemCount())
1342 return -1;
1343
1344 curRev=(GitRev*)m_CommitList.m_arShownList[index];
1345
1346 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1347 return 0;
1348 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SKIP)
1349 {
1350 if(m_CommitList.m_IsOldFirst)
1351 ++index;
1352 else
1353 --index;
1354 }
1355 else
1356 return -1;
1357
1358 } while(curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SKIP);
1359
1360 return -1;
1361
1362 }
1363 int CRebaseDlg::GoNext()
1364 {
1365 if(m_CommitList.m_IsOldFirst)
1366 ++m_CurrentRebaseIndex;
1367 else
1368 --m_CurrentRebaseIndex;
1369 return 0;
1370
1371 }
1372 int CRebaseDlg::StateAction()
1373 {
1374 switch(this->m_RebaseStage)
1375 {
1376 case CHOOSE_BRANCH:
1377 case CHOOSE_COMMIT_PICK_MODE:
1378 if(StartRebase())
1379 return -1;
1380 m_RebaseStage = REBASE_START;
1381 GoNext();
1382 break;
1383 }
1384
1385 return 0;
1386 }
1387 void CRebaseDlg::SetContinueButtonText()
1388 {
1389 CString Text;
1390 switch(this->m_RebaseStage)
1391 {
1392 case CHOOSE_BRANCH:
1393 case CHOOSE_COMMIT_PICK_MODE:
1394 if(this->m_IsFastForward)
1395 Text.LoadString(IDS_PROC_STARTREBASEFFBUTTON);
1396 else
1397 Text.LoadString(IDS_PROC_STARTREBASEBUTTON);
1398 break;
1399
1400 case REBASE_START:
1401 case REBASE_ERROR:
1402 case REBASE_CONTINUE:
1403 case REBASE_SQUASH_CONFLICT:
1404 Text.LoadString(IDS_CONTINUEBUTTON);
1405 break;
1406
1407 case REBASE_CONFLICT:
1408 Text.LoadString(IDS_COMMITBUTTON);
1409 break;
1410 case REBASE_EDIT:
1411 Text.LoadString(IDS_AMENDBUTTON);
1412 break;
1413
1414 case REBASE_SQUASH_EDIT:
1415 Text.LoadString(IDS_COMMITBUTTON);
1416 break;
1417
1418 case REBASE_ABORT:
1419 case REBASE_FINISH:
1420 Text.LoadString(IDS_FINISHBUTTON);
1421 break;
1422
1423 case REBASE_DONE:
1424 Text.LoadString(IDS_DONE);
1425 break;
1426 }
1427 this->GetDlgItem(IDC_REBASE_CONTINUE)->SetWindowText(Text);
1428 }
1429
1430 void CRebaseDlg::SetControlEnable()
1431 {
1432 switch(this->m_RebaseStage)
1433 {
1434 case CHOOSE_BRANCH:
1435 case CHOOSE_COMMIT_PICK_MODE:
1436
1437 this->GetDlgItem(IDC_SPLITALLOPTIONS)->EnableWindow(TRUE);
1438 this->GetDlgItem(IDC_BUTTON_UP2)->EnableWindow(TRUE);
1439 this->GetDlgItem(IDC_BUTTON_DOWN2)->EnableWindow(TRUE);
1440
1441 if(!m_IsCherryPick)
1442 {
1443 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(TRUE);
1444 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(TRUE);
1445 this->GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(TRUE);
1446 this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(TRUE);
1447 }
1448 this->m_CommitList.m_ContextMenuMask |= m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_PICK)|
1449 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SQUASH)|
1450 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_EDIT)|
1451 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SKIP);
1452 break;
1453
1454 case REBASE_START:
1455 case REBASE_CONTINUE:
1456 case REBASE_ABORT:
1457 case REBASE_ERROR:
1458 case REBASE_FINISH:
1459 case REBASE_CONFLICT:
1460 case REBASE_EDIT:
1461 case REBASE_SQUASH_CONFLICT:
1462 case REBASE_DONE:
1463 this->GetDlgItem(IDC_SPLITALLOPTIONS)->EnableWindow(FALSE);
1464 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(FALSE);
1465 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(FALSE);
1466 this->GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(FALSE);
1467 this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(FALSE);
1468 this->GetDlgItem(IDC_BUTTON_UP2)->EnableWindow(FALSE);
1469 this->GetDlgItem(IDC_BUTTON_DOWN2)->EnableWindow(FALSE);
1470
1471 if( m_RebaseStage == REBASE_DONE && (this->m_PostButtonTexts.GetCount() != 0) )
1472 {
1473 this->GetDlgItem(IDC_STATUS_STATIC)->ShowWindow(SW_HIDE);
1474 this->GetDlgItem(IDC_REBASE_POST_BUTTON)->ShowWindow(SW_SHOWNORMAL);
1475 this->m_PostButton.RemoveAll();
1476 this->m_PostButton.AddEntries(m_PostButtonTexts);
1477 //this->GetDlgItem(IDC_REBASE_POST_BUTTON)->SetWindowText(this->m_PostButtonText);
1478 }
1479 break;
1480 }
1481
1482 if(m_bThreadRunning)
1483 {
1484 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1485
1486 }
1487 else if (m_RebaseStage != REBASE_ERROR)
1488 {
1489 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1490 }
1491 }
1492
1493 void CRebaseDlg::UpdateProgress()
1494 {
1495 int index;
1496 CRect rect;
1497
1498 if(m_CommitList.m_IsOldFirst)
1499 index = m_CurrentRebaseIndex+1;
1500 else
1501 index = m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1502
1503 int finishedCommits = index - 1; // introduced an variable which shows the number handled revisions for the progress bars
1504 if (m_RebaseStage == REBASE_FINISH || finishedCommits == -1)
1505 finishedCommits = index;
1506
1507 m_ProgressBar.SetRange32(0, m_CommitList.GetItemCount());
1508 m_ProgressBar.SetPos(finishedCommits);
1509 if (m_pTaskbarList)
1510 {
1511 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1512 m_pTaskbarList->SetProgressValue(m_hWnd, finishedCommits, m_CommitList.GetItemCount());
1513 }
1514
1515 if(m_CurrentRebaseIndex>=0 && m_CurrentRebaseIndex< m_CommitList.GetItemCount())
1516 {
1517 CString text;
1518 text.Format(IDS_PROC_REBASING_PROGRESS, index, m_CommitList.GetItemCount());
1519 m_sStatusText = text;
1520 m_CtrlStatusText.SetWindowText(text);
1521 m_bStatusWarning = false;
1522 m_CtrlStatusText.Invalidate();
1523 }
1524
1525 GitRev *prevRev=NULL, *curRev=NULL;
1526
1527 if( m_CurrentRebaseIndex >= 0 && m_CurrentRebaseIndex< m_CommitList.m_arShownList.GetSize())
1528 {
1529 curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1530 }
1531
1532 for (int i = 0; i < m_CommitList.m_arShownList.GetSize(); ++i)
1533 {
1534 prevRev=(GitRev*)m_CommitList.m_arShownList[i];
1535 if (prevRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_CURRENT)
1536 {
1537 prevRev->GetRebaseAction() &= ~CGitLogListBase::LOGACTIONS_REBASE_CURRENT;
1538 m_CommitList.GetItemRect(i,&rect,LVIR_BOUNDS);
1539 m_CommitList.InvalidateRect(rect);
1540 }
1541 }
1542
1543 if(curRev)
1544 {
1545 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_CURRENT;
1546 m_CommitList.GetItemRect(m_CurrentRebaseIndex,&rect,LVIR_BOUNDS);
1547 m_CommitList.InvalidateRect(rect);
1548 }
1549 m_CommitList.EnsureVisible(m_CurrentRebaseIndex,FALSE);
1550 }
1551
1552 void CRebaseDlg::UpdateCurrentStatus()
1553 {
1554 SetContinueButtonText();
1555 SetControlEnable();
1556 UpdateProgress();
1557 if (m_RebaseStage == REBASE_DONE)
1558 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
1559 }
1560
1561 void CRebaseDlg::AddLogString(CString str)
1562 {
1563 this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, FALSE);
1564 CStringA sTextA = m_wndOutputRebase.StringForControl(str);//CUnicodeUtils::GetUTF8(str);
1565 this->m_wndOutputRebase.SendMessage(SCI_DOCUMENTEND);
1566 this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)sTextA);
1567 this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)"\n");
1568 this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, TRUE);
1569 }
1570
1571 int CRebaseDlg::GetCurrentCommitID()
1572 {
1573 if(m_CommitList.m_IsOldFirst)
1574 {
1575 return this->m_CurrentRebaseIndex+1;
1576
1577 }
1578 else
1579 {
1580 return m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1581 }
1582 }
1583
1584 int CRebaseDlg::DoRebase()
1585 {
1586 CString cmd,out;
1587 if(m_CurrentRebaseIndex <0)
1588 return 0;
1589 if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1590 return 0;
1591
1592 GitRev *pRev = (GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1593 int mode = pRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_MODE_MASK;
1594 CString nocommit;
1595
1596 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SKIP)
1597 {
1598 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1599 return 0;
1600 }
1601
1602 bool nextCommitIsSquash = (CheckNextCommitIsSquash() == 0);
1603 if (nextCommitIsSquash || mode != CGitLogListBase::LOGACTIONS_REBASE_PICK)
1604 { // next commit is squash or not pick
1605 if (!this->m_SquashMessage.IsEmpty())
1606 this->m_SquashMessage += _T("\n\n");
1607 this->m_SquashMessage += pRev->GetSubject();
1608 this->m_SquashMessage += _T("\n");
1609 this->m_SquashMessage += pRev->GetBody().TrimRight();
1610 if (m_bAddCherryPickedFrom)
1611 {
1612 if (!pRev->GetBody().IsEmpty())
1613 m_SquashMessage += _T("\n");
1614 m_SquashMessage += _T("(cherry picked from commit ");
1615 m_SquashMessage += pRev->m_CommitHash.ToString();
1616 m_SquashMessage += _T(")");
1617 }
1618 }
1619 else
1620 {
1621 this->m_SquashMessage.Empty();
1622 m_SquashFirstMetaData.Empty();
1623 }
1624
1625 if ((nextCommitIsSquash && mode != CGitLogListBase::LOGACTIONS_REBASE_EDIT) || mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1626 { // next or this commit is squash (don't do this on edit->squash sequence)
1627 nocommit=_T(" --no-commit ");
1628 }
1629
1630 if (nextCommitIsSquash && mode != CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1631 m_SquashFirstMetaData.Format(_T("--date=%s --author=\"%s <%s>\" "), pRev->GetAuthorDate().Format(_T("%Y-%m-%dT%H:%M:%S")), pRev->GetAuthorName(), pRev->GetAuthorEmail());
1632
1633 CString log;
1634 log.Format(_T("%s %d: %s"), CGitLogListBase::GetRebaseActionName(mode), GetCurrentCommitID(), pRev->m_CommitHash.ToString());
1635 AddLogString(log);
1636 AddLogString(pRev->GetSubject());
1637 if (pRev->GetSubject().IsEmpty())
1638 {
1639 CMessageBox::Show(m_hWnd, IDS_PROC_REBASE_EMPTYCOMMITMSG, IDS_APPNAME, MB_OK | MB_ICONEXCLAMATION);
1640 mode = CGitLogListBase::LOGACTIONS_REBASE_EDIT;
1641 }
1642
1643 CString cherryPickedFrom;
1644 if (m_bAddCherryPickedFrom)
1645 cherryPickedFrom = _T("-x ");
1646 else if (!m_IsCherryPick && nocommit.IsEmpty())
1647 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."
1648
1649 while (true)
1650 {
1651 cmd.Format(_T("git.exe cherry-pick %s%s %s"), cherryPickedFrom, nocommit, pRev->m_CommitHash.ToString());
1652
1653 if(g_Git.Run(cmd,&out,CP_UTF8))
1654 {
1655 AddLogString(out);
1656 CTGitPathList list;
1657 if(g_Git.ListConflictFile(list))
1658 {
1659 AddLogString(_T("Get conflict files fail"));
1660 return -1;
1661 }
1662 if (list.IsEmpty())
1663 {
1664 if (mode == CGitLogListBase::LOGACTIONS_REBASE_PICK)
1665 {
1666 if (m_pTaskbarList)
1667 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1668 int choose = -1;
1669 if (!m_bAutoSkipFailedCommit)
1670 {
1671 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);
1672 if (choose == 2)
1673 {
1674 m_bAutoSkipFailedCommit = FALSE;
1675 continue; // retry cherry pick
1676 }
1677 }
1678 if (m_bAutoSkipFailedCommit || choose == 1)
1679 {
1680 bool resetOK = false;
1681 while (!resetOK)
1682 {
1683 out.Empty();
1684 if (g_Git.Run(_T("git.exe reset --hard"), &out, CP_UTF8))
1685 {
1686 AddLogString(out);
1687 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1688 break;
1689 }
1690 else
1691 resetOK = true;
1692 }
1693
1694 if (resetOK)
1695 {
1696 pRev->GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_SKIP;
1697 m_CommitList.Invalidate();
1698 return 0;
1699 }
1700 }
1701
1702 m_RebaseStage = REBASE_ERROR;
1703 AddLogString(_T("An unrecoverable error occurred."));
1704 return -1;
1705 }
1706 if (mode == CGitLogListBase::LOGACTIONS_REBASE_EDIT)
1707 {
1708 this->m_RebaseStage = REBASE_EDIT ;
1709 return -1; // Edit return -1 to stop rebase.
1710 }
1711 // Squash Case
1712 if(CheckNextCommitIsSquash())
1713 { // no squash
1714 // let user edit last commmit message
1715 this->m_RebaseStage = REBASE_SQUASH_EDIT;
1716 return -1;
1717 }
1718 }
1719
1720 if (m_pTaskbarList)
1721 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1722 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1723 m_RebaseStage = REBASE_SQUASH_CONFLICT;
1724 else
1725 m_RebaseStage = REBASE_CONFLICT;
1726 return -1;
1727
1728 }
1729 else
1730 {
1731 AddLogString(out);
1732 if (mode == CGitLogListBase::LOGACTIONS_REBASE_PICK)
1733 {
1734 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1735 return 0;
1736 }
1737 if (mode == CGitLogListBase::LOGACTIONS_REBASE_EDIT)
1738 {
1739 this->m_RebaseStage = REBASE_EDIT ;
1740 return -1; // Edit return -1 to stop rebase.
1741 }
1742
1743 // Squash Case
1744 if(CheckNextCommitIsSquash())
1745 { // no squash
1746 // let user edit last commmit message
1747 this->m_RebaseStage = REBASE_SQUASH_EDIT;
1748 return -1;
1749 }
1750 else if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1751 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1752 }
1753
1754 return 0;
1755 }
1756 }
1757
1758 BOOL CRebaseDlg::IsEnd()
1759 {
1760 if(m_CommitList.m_IsOldFirst)
1761 return m_CurrentRebaseIndex>= this->m_CommitList.GetItemCount();
1762 else
1763 return m_CurrentRebaseIndex<0;
1764 }
1765
1766 int CRebaseDlg::RebaseThread()
1767 {
1768 CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
1769
1770 int ret=0;
1771 while(1)
1772 {
1773 if( m_RebaseStage == REBASE_START )
1774 {
1775 if( this->StartRebase() )
1776 {
1777 ret = -1;
1778 break;
1779 }
1780 m_RebaseStage = REBASE_CONTINUE;
1781
1782 }
1783 else if( m_RebaseStage == REBASE_CONTINUE )
1784 {
1785 this->GoNext();
1786 SendMessage(MSG_REBASE_UPDATE_UI);
1787 if(IsEnd())
1788 {
1789 ret = 0;
1790 m_RebaseStage = REBASE_FINISH;
1791
1792 }
1793 else
1794 {
1795 ret = DoRebase();
1796
1797 if( ret )
1798 {
1799 break;
1800 }
1801 }
1802
1803 }
1804 else if( m_RebaseStage == REBASE_FINISH )
1805 {
1806 SendMessage(MSG_REBASE_UPDATE_UI);
1807 m_RebaseStage = REBASE_DONE;
1808 break;
1809
1810 }
1811 else
1812 {
1813 break;
1814 }
1815 this->PostMessage(MSG_REBASE_UPDATE_UI);
1816 }
1817
1818 InterlockedExchange(&m_bThreadRunning, FALSE);
1819 this->PostMessage(MSG_REBASE_UPDATE_UI);
1820 return ret;
1821 }
1822
1823 void CRebaseDlg::ListConflictFile()
1824 {
1825 this->m_FileListCtrl.Clear();
1826 m_FileListCtrl.SetHasCheckboxes(true);
1827 CTGitPathList list;
1828 CTGitPath path;
1829 list.AddPath(path);
1830
1831 m_FileListCtrl.m_bIsRevertTheirMy = !m_IsCherryPick;
1832
1833 this->m_FileListCtrl.GetStatus(&list,true);
1834 this->m_FileListCtrl.Show(CTGitPath::LOGACTIONS_UNMERGED|CTGitPath::LOGACTIONS_MODIFIED|CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_DELETED,
1835 CTGitPath::LOGACTIONS_UNMERGED);
1836
1837 m_FileListCtrl.Check(GITSLC_SHOWFILES);
1838 bool hasSubmoduleChange = false;
1839 for (int i = 0; i < m_FileListCtrl.GetItemCount(); i++)
1840 {
1841 CTGitPath *entry = (CTGitPath *)m_FileListCtrl.GetItemData(i);
1842 if (entry->IsDirectory())
1843 {
1844 hasSubmoduleChange = true;
1845 break;
1846 }
1847 }
1848
1849 if (hasSubmoduleChange)
1850 {
1851 m_CtrlStatusText.SetWindowText(m_sStatusText + _T(", ") + CString(MAKEINTRESOURCE(IDS_CARE_SUBMODULE_CHANGES)));
1852 m_bStatusWarning = true;
1853 m_CtrlStatusText.Invalidate();
1854 }
1855 else
1856 {
1857 m_CtrlStatusText.SetWindowText(m_sStatusText);
1858 m_bStatusWarning = false;
1859 m_CtrlStatusText.Invalidate();
1860 }
1861 }
1862
1863 LRESULT CRebaseDlg::OnRebaseUpdateUI(WPARAM,LPARAM)
1864 {
1865 if (m_RebaseStage == REBASE_FINISH)
1866 {
1867 FinishRebase();
1868 return 0;
1869 }
1870 UpdateCurrentStatus();
1871 if (m_RebaseStage == REBASE_DONE && m_pTaskbarList)
1872 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS); // do not show progress on taskbar any more to show we finished
1873 if(m_CurrentRebaseIndex <0)
1874 return 0;
1875 if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1876 return 0;
1877 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1878
1879 switch(m_RebaseStage)
1880 {
1881 case REBASE_CONFLICT:
1882 case REBASE_SQUASH_CONFLICT:
1883 {
1884 ListConflictFile();
1885 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_CONFLICT);
1886 if (m_pTaskbarList)
1887 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1888 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1889 CString dotGitPath;
1890 g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, dotGitPath);
1891 CString logMessage;
1892 bool loadedMsg = CGit::LoadTextFile(dotGitPath + _T("MERGE_MSG"), logMessage);
1893 if (!loadedMsg)
1894 logMessage = curRev->GetSubject() + _T("\n") + curRev->GetBody();
1895 this->m_LogMessageCtrl.SetText(logMessage);
1896 break;
1897 }
1898 case REBASE_EDIT:
1899 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1900 if (m_pTaskbarList)
1901 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
1902 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1903 if (m_bAddCherryPickedFrom)
1904 {
1905 // Since the new commit is done and the HEAD points to it,
1906 // just using the new body modified by git self.
1907 GitRev headRevision;
1908 headRevision.GetCommit(_T("HEAD"));
1909 m_LogMessageCtrl.SetText(headRevision.GetSubject() + _T("\n") + headRevision.GetBody());
1910 }
1911 else
1912 m_LogMessageCtrl.SetText(curRev->GetSubject() + _T("\n") + curRev->GetBody());
1913 break;
1914 case REBASE_SQUASH_EDIT:
1915 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1916 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1917 this->m_LogMessageCtrl.SetText(this->m_SquashMessage);
1918 if (m_pTaskbarList)
1919 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
1920 break;
1921 default:
1922 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1923 }
1924 return 0;
1925 }
1926 void CRebaseDlg::OnCancel()
1927 {
1928 OnBnClickedAbort();
1929 }
1930 void CRebaseDlg::OnBnClickedAbort()
1931 {
1932 if (m_pTaskbarList)
1933 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
1934
1935 m_tooltips.Pop();
1936
1937 CString cmd,out;
1938 CString pron = m_OrigUpstreamHash.ToString();
1939 if(m_OrigUpstreamHash.IsEmpty())
1940 {
1941 __super::OnCancel();
1942 }
1943
1944 if(m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage== CHOOSE_COMMIT_PICK_MODE)
1945 {
1946 goto end;
1947 }
1948
1949 if(CMessageBox::Show(NULL, IDS_PROC_REBASE_ABORT, IDS_APPNAME, MB_YESNO) != IDYES)
1950 goto end;
1951
1952 if(this->m_IsFastForward)
1953 {
1954 cmd.Format(_T("git.exe reset --hard %s --"),this->m_OrigBranchHash.ToString());
1955 while (true)
1956 {
1957 out.Empty();
1958 if (g_Git.Run(cmd, &out, CP_UTF8))
1959 {
1960 AddLogString(out);
1961 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1962 break;
1963 }
1964 else
1965 break;
1966 }
1967 __super::OnCancel();
1968 goto end;
1969 }
1970
1971 if (m_IsCherryPick) // there are not "branch" at cherry pick mode
1972 {
1973 cmd.Format(_T("git.exe reset --hard %s --"), m_OrigUpstreamHash.ToString());
1974 while (true)
1975 {
1976 out.Empty();
1977 if (g_Git.Run(cmd, &out, CP_UTF8))
1978 {
1979 AddLogString(out);
1980 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1981 break;
1982 }
1983 else
1984 break;
1985 }
1986
1987 __super::OnCancel();
1988 goto end;
1989 }
1990
1991 if (m_OrigHEADBranch == m_BranchCtrl.GetString())
1992 {
1993 if (IsLocalBranch(m_OrigHEADBranch))
1994 cmd.Format(_T("git.exe checkout -f -B %s %s --"), m_BranchCtrl.GetString(), m_OrigBranchHash.ToString());
1995 else
1996 cmd.Format(_T("git.exe checkout -f %s --"), m_OrigBranchHash.ToString());
1997 if (g_Git.Run(cmd, &out, CP_UTF8))
1998 {
1999 AddLogString(out);
2000 ::MessageBox(m_hWnd, _T("Unrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_ICONERROR);
2001 __super::OnCancel();
2002 goto end;
2003 }
2004
2005 cmd.Format(_T("git.exe reset --hard %s --"), m_OrigBranchHash.ToString());
2006 while (true)
2007 {
2008 out.Empty();
2009 if (g_Git.Run(cmd, &out, CP_UTF8))
2010 {
2011 AddLogString(out);
2012 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
2013 break;
2014 }
2015 else
2016 break;
2017 }
2018 }
2019 else
2020 {
2021 if (m_OrigHEADBranch != g_Git.GetCurrentBranch(true))
2022 {
2023 if (IsLocalBranch(m_OrigHEADBranch))
2024 cmd.Format(_T("git.exe checkout -f -B %s %s --"), m_OrigHEADBranch, m_OrigHEADHash.ToString());
2025 else
2026 cmd.Format(_T("git.exe checkout -f %s --"), m_OrigHEADHash.ToString());
2027 if (g_Git.Run(cmd, &out, CP_UTF8))
2028 {
2029 AddLogString(out);
2030 ::MessageBox(m_hWnd, _T("Unrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_ICONERROR);
2031 // continue to restore moved branch
2032 }
2033 }
2034
2035 cmd.Format(_T("git.exe reset --hard %s --"), m_OrigHEADHash.ToString());
2036 while (true)
2037 {
2038 out.Empty();
2039 if (g_Git.Run(cmd, &out, CP_UTF8))
2040 {
2041 AddLogString(out);
2042 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
2043 break;
2044 }
2045 else
2046 break;
2047 }
2048
2049 // restore moved branch
2050 if (IsLocalBranch(m_BranchCtrl.GetString()))
2051 {
2052 cmd.Format(_T("git.exe branch -f %s %s --"), m_BranchCtrl.GetString(), m_OrigBranchHash.ToString());
2053 if (g_Git.Run(cmd, &out, CP_UTF8))
2054 {
2055 AddLogString(out);
2056 ::MessageBox(m_hWnd, _T("Unrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_ICONERROR);
2057 __super::OnCancel();
2058 goto end;
2059 }
2060 }
2061 }
2062 __super::OnCancel();
2063 end:
2064 CheckRestoreStash();
2065 }
2066
2067 void CRebaseDlg::OnBnClickedButtonReverse()
2068 {
2069 CString temp = m_BranchCtrl.GetString();
2070 m_BranchCtrl.AddString(m_UpstreamCtrl.GetString());
2071 m_UpstreamCtrl.AddString(temp);
2072 OnCbnSelchangeUpstream();
2073 }
2074
2075 void CRebaseDlg::OnBnClickedButtonBrowse()
2076 {
2077 if(CBrowseRefsDlg::PickRefForCombo(&m_UpstreamCtrl, gPickRef_NoTag))
2078 OnCbnSelchangeUpstream();
2079 }
2080
2081 void CRebaseDlg::OnBnClickedRebaseCheckForce()
2082 {
2083 this->UpdateData();
2084 this->FetchLogList();
2085 }
2086
2087 void CRebaseDlg::OnBnClickedRebasePostButton()
2088 {
2089 this->m_Upstream=this->m_UpstreamCtrl.GetString();
2090 this->m_Branch=this->m_BranchCtrl.GetString();
2091
2092 this->EndDialog((int)(IDC_REBASE_POST_BUTTON+this->m_PostButton.GetCurrentEntry()));
2093 }
2094
2095 LRESULT CRebaseDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
2096 {
2097 Refresh();
2098 return 0;
2099 }
2100
2101 void CRebaseDlg::Refresh()
2102 {
2103 if (m_RebaseStage == REBASE_CONFLICT || m_RebaseStage == REBASE_SQUASH_CONFLICT)
2104 {
2105 ListConflictFile();
2106 return;
2107 }
2108
2109 if(this->m_IsCherryPick)
2110 return ;
2111
2112 if(this->m_RebaseStage == CHOOSE_BRANCH )
2113 {
2114 this->UpdateData();
2115 this->FetchLogList();
2116 }
2117 }
2118
2119 void CRebaseDlg::OnBnClickedButtonUp2()
2120 {
2121 POSITION pos;
2122 pos = m_CommitList.GetFirstSelectedItemPosition();
2123
2124 // do nothing if the first selected item is the first item in the list
2125 int idx = m_CommitList.GetNextSelectedItem(pos);
2126 if (idx == 0)
2127 return;
2128
2129 bool moveToTop = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
2130 int move = moveToTop ? idx : 1;
2131 pos = m_CommitList.GetFirstSelectedItemPosition();
2132
2133 bool changed = false;
2134 while(pos)
2135 {
2136 int index=m_CommitList.GetNextSelectedItem(pos);
2137 if(index>=1)
2138 {
2139 CGitHash old = m_CommitList.m_logEntries[index - move];
2140 m_CommitList.m_logEntries[index - move] = m_CommitList.m_logEntries[index];
2141 m_CommitList.m_logEntries[index] = old;
2142 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
2143 m_CommitList.SetItemState(index - move, LVIS_SELECTED, LVIS_SELECTED);
2144 m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
2145 changed = true;
2146 }
2147 }
2148 if (changed)
2149 {
2150 pos = m_CommitList.GetFirstSelectedItemPosition();
2151 m_CommitList.EnsureVisible(m_CommitList.GetNextSelectedItem(pos), false);
2152 m_CommitList.Invalidate();
2153 m_CommitList.SetFocus();
2154 }
2155 }
2156
2157 void CRebaseDlg::OnBnClickedButtonDown2()
2158 {
2159 if (m_CommitList.GetSelectedCount() == 0)
2160 return;
2161
2162 bool moveToBottom = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
2163 POSITION pos;
2164 pos = m_CommitList.GetFirstSelectedItemPosition();
2165 bool changed = false;
2166 // use an array to store all selected item indexes; the user won't select too much items
2167 int* indexes = NULL;
2168 indexes = new int[m_CommitList.GetSelectedCount()];
2169 int i = 0;
2170 while(pos)
2171 {
2172 indexes[i++] = m_CommitList.GetNextSelectedItem(pos);
2173 }
2174 int distanceToBottom = m_CommitList.GetItemCount() - 1 - indexes[m_CommitList.GetSelectedCount() - 1];
2175 int move = moveToBottom ? distanceToBottom : 1;
2176 // don't move any item if the last selected item is the last item in the m_CommitList
2177 // (that would change the order of the selected items)
2178 if (distanceToBottom > 0)
2179 {
2180 // iterate over the indexes backwards in order to correctly move multiselected items
2181 for (i = m_CommitList.GetSelectedCount() - 1; i >= 0; i--)
2182 {
2183 int index = indexes[i];
2184 CGitHash old = m_CommitList.m_logEntries[index + move];
2185 m_CommitList.m_logEntries[index + move] = m_CommitList.m_logEntries[index];
2186 m_CommitList.m_logEntries[index] = old;
2187 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
2188 m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
2189 m_CommitList.SetItemState(index + move, LVIS_SELECTED, LVIS_SELECTED);
2190 changed = true;
2191 }
2192 }
2193 m_CommitList.EnsureVisible(indexes[m_CommitList.GetSelectedCount() - 1] + move, false);
2194 delete [] indexes;
2195 indexes = NULL;
2196 if (changed)
2197 {
2198 m_CommitList.Invalidate();
2199 m_CommitList.SetFocus();
2200 }
2201 }
2202
2203 LRESULT CRebaseDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
2204 {
2205 m_pTaskbarList.Release();
2206 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
2207 SetUUIDOverlayIcon(m_hWnd);
2208 return 0;
2209 }
2210
2211 void CRebaseDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
2212 {
2213 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
2214 *pResult = 0;
2215 if(m_CommitList.m_bNoDispUpdates)
2216 return;
2217 if (pNMLV->iItem >= 0)
2218 {
2219 this->m_CommitList.m_nSearchIndex = pNMLV->iItem;
2220 if (pNMLV->iSubItem != 0)
2221 return;
2222 if ((pNMLV->iItem == m_CommitList.m_arShownList.GetCount()))
2223 {
2224 // remove the selected state
2225 if (pNMLV->uChanged & LVIF_STATE)
2226 {
2227 m_CommitList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
2228 FillLogMessageCtrl();
2229 }
2230 return;
2231 }
2232 if (pNMLV->uChanged & LVIF_STATE)
2233 {
2234 FillLogMessageCtrl();
2235 }
2236 }
2237 else
2238 {
2239 FillLogMessageCtrl();
2240 }
2241 }
2242
2243 void CRebaseDlg::FillLogMessageCtrl()
2244 {
2245 int selCount = m_CommitList.GetSelectedCount();
2246 if (selCount == 1 && (m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage == CHOOSE_COMMIT_PICK_MODE))
2247 {
2248 POSITION pos = m_CommitList.GetFirstSelectedItemPosition();
2249 int selIndex = m_CommitList.GetNextSelectedItem(pos);
2250 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_CommitList.m_arShownList.SafeGetAt(selIndex));
2251 m_FileListCtrl.UpdateWithGitPathList(pLogEntry->GetFiles(&m_CommitList));
2252 m_FileListCtrl.m_CurrentVersion = pLogEntry->m_CommitHash;
2253 m_FileListCtrl.Show(GITSLC_SHOWVERSIONED);
2254 m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2255 m_LogMessageCtrl.SetText(pLogEntry->GetSubject() + _T("\n") + pLogEntry->GetBody());
2256 m_LogMessageCtrl.Call(SCI_SETREADONLY, TRUE);
2257 }
2258 }
2259 void CRebaseDlg::OnBnClickedCheckCherryPickedFrom()
2260 {
2261 UpdateData();
2262 }
2263
2264 LRESULT CRebaseDlg::OnRebaseActionMessage(WPARAM, LPARAM)
2265 {
2266 if (m_RebaseStage == REBASE_ERROR || m_RebaseStage == REBASE_CONFLICT)
2267 {
2268 GitRev *pRev = (GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
2269 int mode = pRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_MODE_MASK;
2270 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SKIP)
2271 {
2272 CString out;
2273 bool resetOK = false;
2274 while (!resetOK)
2275 {
2276 out.Empty();
2277 if (g_Git.Run(_T("git.exe reset --hard"), &out, CP_UTF8))
2278 {
2279 AddLogString(out);
2280 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
2281 break;
2282 }
2283 else
2284 resetOK = true;
2285 }
2286
2287 if (resetOK)
2288 {
2289 m_FileListCtrl.Clear();
2290 m_RebaseStage = REBASE_CONTINUE;
2291 UpdateCurrentStatus();
2292 }
2293 }
2294 }
2295 return 0;
2296 }
2297
2298
2299 void CRebaseDlg::OnBnClickedSplitAllOptions()
2300 {
2301 switch (m_SplitAllOptions.GetCurrentEntry())
2302 {
2303 case 0:
2304 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_PICK);
2305 break;
2306 case 1:
2307 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SQUASH);
2308 break;
2309 case 2:
2310 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_EDIT);
2311 break;
2312 default:
2313 ATLASSERT(false);
2314 }
2315 }
Windows Explorer Extension to Operate Git