Drop unused msysgit dialog of installer
[TortoiseGit.git] / src / TortoiseProc / RebaseDlg.cpp
blobd1894efa7c6705544fe30f0ab28fec5f7da504e1
1 // TortoiseGit - a Windows shell extension for easy version control
3 // Copyright (C) 2008-2014 - TortoiseGit
4 // Copyright (C) 2011-2013 - Sven Strickroth <email@cs-ware.de>
6 // This program is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU General Public License
8 // as published by the Free Software Foundation; either version 2
9 // of the License, or (at your option) any later version.
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software Foundation,
18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 // RebaseDlg.cpp : implementation file
24 #include "stdafx.h"
25 #include "TortoiseProc.h"
26 #include "RebaseDlg.h"
27 #include "AppUtils.h"
28 #include "LoglistUtils.h"
29 #include "MessageBox.h"
30 #include "UnicodeUtils.h"
31 #include "BrowseRefsDlg.h"
32 #include "ProgressDlg.h"
33 #include "SmartHandle.h"
34 #include "../TGitCache/CacheInterface.h"
35 #include "Settings\Settings.h"
36 #include "MassiveGitTask.h"
38 // CRebaseDlg dialog
40 IMPLEMENT_DYNAMIC(CRebaseDlg, CResizableStandAloneDialog)
42 CRebaseDlg::CRebaseDlg(CWnd* pParent /*=NULL*/)
43 : CResizableStandAloneDialog(CRebaseDlg::IDD, pParent)
44 , m_bPickAll(FALSE)
45 , m_bSquashAll(FALSE)
46 , m_bEditAll(FALSE)
47 , m_bAddCherryPickedFrom(FALSE)
48 , m_bStatusWarning(false)
49 , m_bAutoSkipFailedCommit(FALSE)
50 , m_bFinishedRebase(false)
51 , m_bStashed(false)
53 m_RebaseStage=CHOOSE_BRANCH;
54 m_CurrentRebaseIndex=-1;
55 m_bThreadRunning =FALSE;
56 this->m_IsCherryPick = FALSE;
57 m_bForce=FALSE;
58 m_IsFastForward=FALSE;
61 CRebaseDlg::~CRebaseDlg()
65 void CRebaseDlg::DoDataExchange(CDataExchange* pDX)
67 CDialog::DoDataExchange(pDX);
68 DDX_Control(pDX, IDC_REBASE_PROGRESS, m_ProgressBar);
69 DDX_Control(pDX, IDC_STATUS_STATIC, m_CtrlStatusText);
70 DDX_Check(pDX, IDC_PICK_ALL, m_bPickAll);
71 DDX_Check(pDX, IDC_SQUASH_ALL, m_bSquashAll);
72 DDX_Check(pDX, IDC_EDIT_ALL, m_bEditAll);
73 DDX_Control(pDX, IDC_REBASE_SPLIT, m_wndSplitter);
74 DDX_Control(pDX,IDC_COMMIT_LIST,m_CommitList);
75 DDX_Control(pDX,IDC_REBASE_COMBOXEX_BRANCH, this->m_BranchCtrl);
76 DDX_Control(pDX,IDC_REBASE_COMBOXEX_UPSTREAM, this->m_UpstreamCtrl);
77 DDX_Check(pDX, IDC_REBASE_CHECK_FORCE,m_bForce);
78 DDX_Check(pDX, IDC_CHECK_CHERRYPICKED_FROM, m_bAddCherryPickedFrom);
79 DDX_Control(pDX,IDC_REBASE_POST_BUTTON,m_PostButton);
83 BEGIN_MESSAGE_MAP(CRebaseDlg, CResizableStandAloneDialog)
84 ON_BN_CLICKED(IDC_PICK_ALL, &CRebaseDlg::OnBnClickedPickAll)
85 ON_BN_CLICKED(IDC_SQUASH_ALL, &CRebaseDlg::OnBnClickedSquashAll)
86 ON_BN_CLICKED(IDC_EDIT_ALL, &CRebaseDlg::OnBnClickedEditAll)
87 ON_BN_CLICKED(IDC_REBASE_SPLIT, &CRebaseDlg::OnBnClickedRebaseSplit)
88 ON_BN_CLICKED(IDC_REBASE_CONTINUE,OnBnClickedContinue)
89 ON_BN_CLICKED(IDC_REBASE_ABORT, OnBnClickedAbort)
90 ON_WM_SIZE()
91 ON_CBN_SELCHANGE(IDC_REBASE_COMBOXEX_BRANCH, &CRebaseDlg::OnCbnSelchangeBranch)
92 ON_CBN_SELCHANGE(IDC_REBASE_COMBOXEX_UPSTREAM, &CRebaseDlg::OnCbnSelchangeUpstream)
93 ON_MESSAGE(MSG_REBASE_UPDATE_UI, OnRebaseUpdateUI)
94 ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_NEEDSREFRESH, OnGitStatusListCtrlNeedsRefresh)
95 ON_BN_CLICKED(IDC_BUTTON_REVERSE, OnBnClickedButtonReverse)
96 ON_BN_CLICKED(IDC_BUTTON_BROWSE, &CRebaseDlg::OnBnClickedButtonBrowse)
97 ON_BN_CLICKED(IDC_REBASE_CHECK_FORCE, &CRebaseDlg::OnBnClickedRebaseCheckForce)
98 ON_BN_CLICKED(IDC_CHECK_CHERRYPICKED_FROM, &CRebaseDlg::OnBnClickedCheckCherryPickedFrom)
99 ON_BN_CLICKED(IDC_REBASE_POST_BUTTON, &CRebaseDlg::OnBnClickedRebasePostButton)
100 ON_BN_CLICKED(IDC_BUTTON_UP2, &CRebaseDlg::OnBnClickedButtonUp2)
101 ON_BN_CLICKED(IDC_BUTTON_DOWN2, &CRebaseDlg::OnBnClickedButtonDown2)
102 ON_REGISTERED_MESSAGE(WM_TASKBARBTNCREATED, OnTaskbarBtnCreated)
103 ON_NOTIFY(LVN_ITEMCHANGED, IDC_COMMIT_LIST, OnLvnItemchangedLoglist)
104 ON_REGISTERED_MESSAGE(CGitLogListBase::m_RebaseActionMessage, OnRebaseActionMessage)
105 ON_WM_CTLCOLOR()
106 END_MESSAGE_MAP()
108 void CRebaseDlg::AddRebaseAnchor()
110 AddAnchor(IDC_REBASE_TAB,TOP_LEFT,BOTTOM_RIGHT);
111 AddAnchor(IDC_COMMIT_LIST,TOP_LEFT, TOP_RIGHT);
112 AddAnchor(IDC_REBASE_SPLIT,TOP_LEFT, TOP_RIGHT);
113 AddAnchor(IDC_STATUS_STATIC, BOTTOM_LEFT,BOTTOM_RIGHT);
114 AddAnchor(IDC_REBASE_CONTINUE,BOTTOM_RIGHT);
115 AddAnchor(IDC_REBASE_ABORT, BOTTOM_RIGHT);
116 AddAnchor(IDC_REBASE_PROGRESS,BOTTOM_LEFT, BOTTOM_RIGHT);
117 AddAnchor(IDC_PICK_ALL,TOP_LEFT);
118 AddAnchor(IDC_SQUASH_ALL,TOP_LEFT);
119 AddAnchor(IDC_EDIT_ALL,TOP_LEFT);
120 AddAnchor(IDC_BUTTON_UP2,TOP_LEFT);
121 AddAnchor(IDC_BUTTON_DOWN2,TOP_LEFT);
122 AddAnchor(IDC_REBASE_COMBOXEX_UPSTREAM,TOP_LEFT);
123 AddAnchor(IDC_REBASE_COMBOXEX_BRANCH,TOP_LEFT);
124 AddAnchor(IDC_REBASE_STATIC_UPSTREAM,TOP_LEFT);
125 AddAnchor(IDC_REBASE_STATIC_BRANCH,TOP_LEFT);
126 AddAnchor(IDHELP, BOTTOM_RIGHT);
127 AddAnchor(IDC_REBASE_CHECK_FORCE,TOP_RIGHT);
128 AddAnchor(IDC_CHECK_CHERRYPICKED_FROM, TOP_RIGHT);
129 AddAnchor(IDC_REBASE_POST_BUTTON,BOTTOM_LEFT);
131 this->AddOthersToAnchor();
134 BOOL CRebaseDlg::OnInitDialog()
136 CResizableStandAloneDialog::OnInitDialog();
137 CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
139 // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
140 // do this, Explorer would be unable to send that message to our window if we
141 // were running elevated. It's OK to make the call all the time, since if we're
142 // not elevated, this is a no-op.
143 CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
144 typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
145 CAutoLibrary hUser = AtlLoadSystemLibraryUsingFullPath(_T("user32.dll"));
146 if (hUser)
148 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
149 if (pfnChangeWindowMessageFilterEx)
151 pfnChangeWindowMessageFilterEx(m_hWnd, WM_TASKBARBTNCREATED, MSGFLT_ALLOW, &cfs);
154 m_pTaskbarList.Release();
155 if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
156 m_pTaskbarList = nullptr;
158 CRect rectDummy;
159 //IDC_REBASE_DUMY_TAB
161 GetClientRect(m_DlgOrigRect);
162 m_CommitList.GetClientRect(m_CommitListOrigRect);
164 CWnd *pwnd=this->GetDlgItem(IDC_REBASE_DUMY_TAB);
165 pwnd->GetWindowRect(&rectDummy);
166 this->ScreenToClient(rectDummy);
168 if (!m_ctrlTabCtrl.Create(CMFCTabCtrl::STYLE_FLAT, rectDummy, this, IDC_REBASE_TAB))
170 TRACE0("Failed to create output tab window\n");
171 return FALSE; // fail to create
173 m_ctrlTabCtrl.SetResizeMode(CMFCTabCtrl::RESIZE_NO);
174 // Create output panes:
175 //const DWORD dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
176 DWORD dwStyle =LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
178 if (! this->m_FileListCtrl.Create(dwStyle,rectDummy,&this->m_ctrlTabCtrl,0) )
180 TRACE0("Failed to create output windows\n");
181 return FALSE; // fail to create
183 m_FileListCtrl.m_hwndLogicalParent = this;
185 if( ! this->m_LogMessageCtrl.Create(_T("Scintilla"),_T("source"),0,rectDummy,&m_ctrlTabCtrl,0,0) )
187 TRACE0("Failed to create log message control");
188 return FALSE;
190 m_LogMessageCtrl.Init(0);
191 m_LogMessageCtrl.Call(SCI_SETREADONLY, TRUE);
193 dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
195 if (!m_wndOutputRebase.Create(_T("Scintilla"),_T("source"),0,rectDummy, &m_ctrlTabCtrl, 0,0) )
197 TRACE0("Failed to create output windows\n");
198 return -1; // fail to create
200 m_wndOutputRebase.Init(0, FALSE);
201 m_wndOutputRebase.Call(SCI_SETREADONLY, TRUE);
203 m_tooltips.Create(this);
205 m_tooltips.AddTool(IDC_REBASE_CHECK_FORCE,IDS_REBASE_FORCE_TT);
206 m_tooltips.AddTool(IDC_REBASE_ABORT,IDS_REBASE_ABORT_TT);
210 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);
212 m_ctrlTabCtrl.AddTab(&m_FileListCtrl, CString(MAKEINTRESOURCE(IDS_PROC_REVISIONFILES)));
213 m_ctrlTabCtrl.AddTab(&m_LogMessageCtrl, CString(MAKEINTRESOURCE(IDS_PROC_COMMITMESSAGE)), 1);
214 AddRebaseAnchor();
216 AdjustControlSize(IDC_PICK_ALL);
217 AdjustControlSize(IDC_SQUASH_ALL);
218 AdjustControlSize(IDC_EDIT_ALL);
219 AdjustControlSize(IDC_CHECK_CHERRYPICKED_FROM);
221 CString sWindowTitle;
222 GetWindowText(sWindowTitle);
223 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, sWindowTitle);
225 EnableSaveRestore(_T("RebaseDlg"));
227 DWORD yPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RebaseDlgSizer"));
228 RECT rcDlg, rcLogMsg, rcFileList;
229 GetClientRect(&rcDlg);
230 m_CommitList.GetWindowRect(&rcLogMsg);
231 ScreenToClient(&rcLogMsg);
232 this->m_ctrlTabCtrl.GetWindowRect(&rcFileList);
233 ScreenToClient(&rcFileList);
234 if (yPos)
236 RECT rectSplitter;
237 m_wndSplitter.GetWindowRect(&rectSplitter);
238 ScreenToClient(&rectSplitter);
239 int delta = yPos - rectSplitter.top;
240 if ((rcLogMsg.bottom + delta > rcLogMsg.top)&&(rcLogMsg.bottom + delta < rcFileList.bottom - 30))
242 m_wndSplitter.SetWindowPos(NULL, 0, yPos, 0, 0, SWP_NOSIZE);
243 DoSize(delta);
247 if( this->m_RebaseStage == CHOOSE_BRANCH)
249 this->LoadBranchInfo();
252 else
254 this->m_BranchCtrl.EnableWindow(FALSE);
255 this->m_UpstreamCtrl.EnableWindow(FALSE);
256 GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(FALSE);
259 m_CommitList.m_ColumnRegKey = _T("Rebase");
260 m_CommitList.m_IsIDReplaceAction = TRUE;
261 // m_CommitList.m_IsOldFirst = TRUE;
262 m_CommitList.m_IsRebaseReplaceGraph = TRUE;
263 m_CommitList.m_bNoHightlightHead = TRUE;
265 m_CommitList.InsertGitColumn();
267 this->SetControlEnable();
269 if(m_IsCherryPick)
271 this->m_BranchCtrl.SetCurSel(-1);
272 this->m_BranchCtrl.EnableWindow(FALSE);
273 GetDlgItem(IDC_REBASE_CHECK_FORCE)->ShowWindow(SW_HIDE);
274 GetDlgItem(IDC_BUTTON_BROWSE)->EnableWindow(FALSE);
275 GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(FALSE);
276 this->m_UpstreamCtrl.AddString(_T("HEAD"));
277 this->m_UpstreamCtrl.EnableWindow(FALSE);
278 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_CHERRYPICK)));
279 this->m_CommitList.StartFilter();
281 else
283 GetDlgItem(IDC_CHECK_CHERRYPICKED_FROM)->ShowWindow(SW_HIDE);
284 ((CButton *)GetDlgItem(IDC_BUTTON_REVERSE))->SetIcon((HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_SWITCHLEFTRIGHT), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR));
285 SetContinueButtonText();
286 m_CommitList.DeleteAllItems();
287 FetchLogList();
290 m_CommitList.m_ContextMenuMask &= ~(m_CommitList.GetContextMenuBit(CGitLogListBase::ID_CHERRY_PICK)|
291 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_SWITCHTOREV)|
292 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_RESET)|
293 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REVERTREV)|
294 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_MERGEREV) |
295 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_TO_VERSION)|
296 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REVERTTOREV)|
297 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_COMBINE_COMMIT));
299 if(m_CommitList.m_IsOldFirst)
300 this->m_CurrentRebaseIndex = -1;
301 else
302 this->m_CurrentRebaseIndex = (int)m_CommitList.m_logEntries.size();
304 return TRUE;
306 // CRebaseDlg message handlers
308 HBRUSH CRebaseDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
310 if (pWnd->GetDlgCtrlID() == IDC_STATUS_STATIC && nCtlColor == CTLCOLOR_STATIC && m_bStatusWarning)
312 pDC->SetBkColor(RGB(255, 0, 0));
313 pDC->SetTextColor(RGB(255, 255, 255));
314 return CreateSolidBrush(RGB(255, 0, 0));
317 return CResizableStandAloneDialog::OnCtlColor(pDC, pWnd, nCtlColor);
320 void CRebaseDlg::OnBnClickedPickAll()
322 this->UpdateData();
323 if(this->m_bPickAll)
324 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_PICK);
326 this->m_bEditAll=FALSE;
327 this->m_bSquashAll=FALSE;
328 this->UpdateData(FALSE);
331 void CRebaseDlg::OnBnClickedSquashAll()
333 this->UpdateData();
334 if(this->m_bSquashAll)
335 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SQUASH);
337 this->m_bEditAll=FALSE;
338 this->m_bPickAll=FALSE;
339 this->UpdateData(FALSE);
342 void CRebaseDlg::OnBnClickedEditAll()
344 this->UpdateData();
345 if( this->m_bEditAll )
346 SetAllRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_EDIT);
348 this->m_bPickAll=FALSE;
349 this->m_bSquashAll=FALSE;
350 this->UpdateData(FALSE);
353 void CRebaseDlg::SetAllRebaseAction(int action)
355 for (size_t i = 0; i < this->m_CommitList.m_logEntries.size(); ++i)
357 m_CommitList.m_logEntries.GetGitRevAt(i).GetRebaseAction() = action;
359 m_CommitList.Invalidate();
362 void CRebaseDlg::OnBnClickedRebaseSplit()
364 this->UpdateData();
367 LRESULT CRebaseDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
369 switch (message) {
370 case WM_NOTIFY:
371 if (wParam == IDC_REBASE_SPLIT)
373 SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
374 DoSize(pHdr->delta);
376 break;
379 return __super::DefWindowProc(message, wParam, lParam);
382 void CRebaseDlg::DoSize(int delta)
384 this->RemoveAllAnchors();
386 CSplitterControl::ChangeHeight(GetDlgItem(IDC_COMMIT_LIST), delta, CW_TOPALIGN);
387 //CSplitterControl::ChangeHeight(GetDlgItem(), delta, CW_TOPALIGN);
388 CSplitterControl::ChangeHeight(GetDlgItem(IDC_REBASE_TAB), -delta, CW_BOTTOMALIGN);
389 //CSplitterControl::ChangeHeight(GetDlgItem(), -delta, CW_BOTTOMALIGN);
390 CSplitterControl::ChangePos(GetDlgItem(IDC_SQUASH_ALL),0,delta);
391 CSplitterControl::ChangePos(GetDlgItem(IDC_PICK_ALL),0,delta);
392 CSplitterControl::ChangePos(GetDlgItem(IDC_EDIT_ALL),0,delta);
393 CSplitterControl::ChangePos(GetDlgItem(IDC_BUTTON_UP2),0,delta);
394 CSplitterControl::ChangePos(GetDlgItem(IDC_BUTTON_DOWN2),0,delta);
395 CSplitterControl::ChangePos(GetDlgItem(IDC_REBASE_CHECK_FORCE),0,delta);
396 CSplitterControl::ChangePos(GetDlgItem(IDC_CHECK_CHERRYPICKED_FROM), 0, delta);
398 this->AddRebaseAnchor();
399 // adjust the minimum size of the dialog to prevent the resizing from
400 // moving the list control too far down.
401 CRect rcLogMsg;
402 m_CommitList.GetClientRect(rcLogMsg);
403 SetMinTrackSize(CSize(m_DlgOrigRect.Width(), m_DlgOrigRect.Height()-m_CommitListOrigRect.Height()+rcLogMsg.Height()));
405 SetSplitterRange();
406 // m_CommitList.Invalidate();
408 // GetDlgItem(IDC_LOGMESSAGE)->Invalidate();
410 this->m_ctrlTabCtrl.Invalidate();
411 this->m_CommitList.Invalidate();
412 this->m_FileListCtrl.Invalidate();
413 this->m_LogMessageCtrl.Invalidate();
417 void CRebaseDlg::SetSplitterRange()
419 if ((m_CommitList)&&(m_ctrlTabCtrl))
421 CRect rcTop;
422 m_CommitList.GetWindowRect(rcTop);
423 ScreenToClient(rcTop);
424 CRect rcMiddle;
425 m_ctrlTabCtrl.GetWindowRect(rcMiddle);
426 ScreenToClient(rcMiddle);
427 if (rcMiddle.Height() && rcMiddle.Width())
428 m_wndSplitter.SetRange(rcTop.top+60, rcMiddle.bottom-80);
432 void CRebaseDlg::OnSize(UINT nType,int cx, int cy)
434 // first, let the resizing take place
435 __super::OnSize(nType, cx, cy);
437 //set range
438 SetSplitterRange();
441 void CRebaseDlg::SaveSplitterPos()
443 if (!IsIconic())
445 CRegDWORD regPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RebaseDlgSizer"));
446 RECT rectSplitter;
447 m_wndSplitter.GetWindowRect(&rectSplitter);
448 ScreenToClient(&rectSplitter);
449 regPos = rectSplitter.top;
453 void CRebaseDlg::LoadBranchInfo()
455 m_BranchCtrl.SetMaxHistoryItems(0x7FFFFFFF);
456 m_UpstreamCtrl.SetMaxHistoryItems(0x7FFFFFFF);
458 STRING_VECTOR list;
459 list.clear();
460 int current = -1;
461 g_Git.GetBranchList(list,&current,CGit::BRANCH_ALL);
462 m_BranchCtrl.AddString(list);
463 if (current >= 0)
464 m_BranchCtrl.SetCurSel(current);
465 else
466 m_BranchCtrl.AddString(g_Git.GetCurrentBranch(true));
467 list.clear();
468 g_Git.GetBranchList(list, NULL, CGit::BRANCH_ALL_F);
469 m_UpstreamCtrl.AddString(list);
471 AddBranchToolTips(&m_BranchCtrl);
472 AddBranchToolTips(&m_UpstreamCtrl);
474 if(!m_Upstream.IsEmpty())
476 m_UpstreamCtrl.AddString(m_Upstream);
478 else
480 //Select pull-remote from current branch
481 CString currentBranch = g_Git.GetSymbolicRef();
482 CString configName;
483 configName.Format(L"branch.%s.remote", currentBranch);
484 CString pullRemote = g_Git.GetConfigValue(configName);
486 //Select pull-branch from current branch
487 configName.Format(L"branch.%s.merge", currentBranch);
488 CString pullBranch = CGit::StripRefName(g_Git.GetConfigValue(configName));
490 CString defaultUpstream;
491 defaultUpstream.Format(L"remotes/%s/%s", pullRemote, pullBranch);
492 int found = m_UpstreamCtrl.FindStringExact(0, defaultUpstream);
493 if(found >= 0)
494 m_UpstreamCtrl.SetCurSel(found);
495 else
496 m_UpstreamCtrl.SetCurSel(-1);
500 void CRebaseDlg::OnCbnSelchangeBranch()
502 FetchLogList();
505 void CRebaseDlg::OnCbnSelchangeUpstream()
507 FetchLogList();
510 void CRebaseDlg::FetchLogList()
512 CGitHash base,hash,upstream;
513 m_IsFastForward=FALSE;
515 if (m_BranchCtrl.GetString().IsEmpty())
517 m_CommitList.ShowText(CString(MAKEINTRESOURCE(IDS_SELECTBRANCH)));
518 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
519 return;
522 if (g_Git.GetHash(hash, m_BranchCtrl.GetString()))
524 m_CommitList.ShowText(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_BranchCtrl.GetString() + _T("\".")));
525 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
526 return;
529 if (m_UpstreamCtrl.GetString().IsEmpty())
531 m_CommitList.ShowText(CString(MAKEINTRESOURCE(IDS_SELECTUPSTREAM)));
532 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
533 return;
536 if (g_Git.GetHash(upstream, m_UpstreamCtrl.GetString()))
538 m_CommitList.ShowText(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_UpstreamCtrl.GetString() + _T("\".")));
539 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
540 return;
543 if (hash == upstream)
545 m_CommitList.Clear();
546 CString text,fmt;
547 fmt.LoadString(IDS_REBASE_EQUAL_FMT);
548 text.Format(fmt,m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString());
550 m_CommitList.ShowText(text);
551 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
552 return;
555 if (g_Git.IsFastForward(m_BranchCtrl.GetString(), m_UpstreamCtrl.GetString(), &base))
557 //fast forword
558 this->m_IsFastForward=TRUE;
560 m_CommitList.Clear();
561 CString text,fmt;
562 fmt.LoadString(IDS_REBASE_FASTFORWARD_FMT);
563 text.Format(fmt,m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString(),
564 m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString());
566 m_CommitList.ShowText(text);
567 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(true);
568 SetContinueButtonText();
570 return ;
573 if(!this->m_bForce)
575 if (base == upstream)
577 m_CommitList.Clear();
578 CString text,fmt;
579 fmt.LoadString(IDS_REBASE_UPTODATE_FMT);
580 text.Format(fmt,m_BranchCtrl.GetString());
581 m_CommitList.ShowText(text);
582 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(m_CommitList.GetItemCount());
583 SetContinueButtonText();
584 return;
588 m_CommitList.Clear();
589 CString refFrom = g_Git.FixBranchName(m_UpstreamCtrl.GetString());
590 CString refTo = g_Git.FixBranchName(m_BranchCtrl.GetString());
591 CString range;
592 range.Format(_T("%s..%s"), refFrom, refTo);
593 this->m_CommitList.FillGitLog(nullptr, &range, 0);
595 if( m_CommitList.GetItemCount() == 0 )
596 m_CommitList.ShowText(CString(MAKEINTRESOURCE(IDS_PROC_NOTHINGTOREBASE)));
598 #if 0
599 if(m_CommitList.m_logEntries[m_CommitList.m_logEntries.size()-1].m_ParentHash.size() >=0 )
601 if(upstream == m_CommitList.m_logEntries[m_CommitList.m_logEntries.size()-1].m_ParentHash[0])
603 m_CommitList.Clear();
604 m_CommitList.ShowText(_T("Nothing Rebase"));
607 #endif
609 m_tooltips.Pop();
610 AddBranchToolTips(&this->m_BranchCtrl);
611 AddBranchToolTips(&this->m_UpstreamCtrl);
613 // Default all actions to 'pick'
614 std::map<CGitHash, size_t> revIxMap;
615 for (size_t i = 0; i < m_CommitList.m_logEntries.size(); ++i)
617 GitRev& rev = m_CommitList.m_logEntries.GetGitRevAt(i);
618 rev.GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_PICK;
619 revIxMap[rev.m_CommitHash] = i;
622 // Default to skip when already in upstream
623 CString cherryCmd;
624 cherryCmd.Format(L"git.exe cherry \"%s\" \"%s\"", refFrom, refTo);
625 bool bHasSKip = false;
626 g_Git.Run(cherryCmd, [&](const CStringA& line)
628 if (line.GetLength() < 2)
629 return;
630 if (line[0] != '-')
631 return; // Don't skip (only skip commits starting with a '-')
632 CString hash = CUnicodeUtils::GetUnicode(line.Mid(1));
633 hash.Trim();
634 auto itIx = revIxMap.find(CGitHash(hash));
635 if (itIx == revIxMap.end())
636 return; // Not found?? Should not occur...
638 // Found. Skip it.
639 m_CommitList.m_logEntries.GetGitRevAt(itIx->second).GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_SKIP;
640 bHasSKip = true;
643 m_CommitList.Invalidate();
644 if (bHasSKip)
646 m_CtrlStatusText.SetWindowText(CString(MAKEINTRESOURCE(IDS_REBASE_AUTOSKIPPED)));
647 m_bStatusWarning = true;
649 else
651 m_CtrlStatusText.SetWindowText(m_sStatusText);
652 m_bStatusWarning = false;
654 m_CtrlStatusText.Invalidate();
656 if(m_CommitList.m_IsOldFirst)
657 this->m_CurrentRebaseIndex = -1;
658 else
659 this->m_CurrentRebaseIndex = (int)m_CommitList.m_logEntries.size();
661 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(m_CommitList.GetItemCount());
662 SetContinueButtonText();
665 void CRebaseDlg::AddBranchToolTips(CHistoryCombo *pBranch)
667 if(pBranch)
669 CString text=pBranch->GetString();
670 CString tooltip;
672 GitRev rev;
675 rev.GetCommit(text);
677 catch (const char *msg)
679 CMessageBox::Show(m_hWnd, _T("Could not get commit ") + text + _T("\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
682 tooltip.Format(_T("%s: %s\n%s: %s <%s>\n%s: %s\n%s:\n%s\n%s"),
683 CString(MAKEINTRESOURCE(IDS_LOG_REVISION)),
684 rev.m_CommitHash.ToString(),
685 CString(MAKEINTRESOURCE(IDS_LOG_AUTHOR)),
686 rev.GetAuthorName(),
687 rev.GetAuthorEmail(),
688 CString(MAKEINTRESOURCE(IDS_LOG_DATE)),
689 CLoglistUtils::FormatDateAndTime(rev.GetAuthorDate(), DATE_LONGDATE),
690 CString(MAKEINTRESOURCE(IDS_LOG_MESSAGE)),
691 rev.GetSubject(),
692 rev.GetBody());
694 pBranch->DisableTooltip();
695 this->m_tooltips.AddTool(pBranch->GetComboBoxCtrl(),tooltip);
699 BOOL CRebaseDlg::PreTranslateMessage(MSG*pMsg)
701 if (pMsg->message == WM_KEYDOWN)
703 switch (pMsg->wParam)
705 case ' ':
706 if (LogListHasFocus(pMsg->hwnd)
707 && LogListHasMenuItem(CGitLogListBase::ID_REBASE_PICK)
708 && LogListHasMenuItem(CGitLogListBase::ID_REBASE_SQUASH)
709 && LogListHasMenuItem(CGitLogListBase::ID_REBASE_EDIT)
710 && LogListHasMenuItem(CGitLogListBase::ID_REBASE_SKIP))
712 m_CommitList.ShiftSelectedRebaseAction();
713 return TRUE;
715 break;
716 case 'P':
717 if (LogListHasFocus(pMsg->hwnd) && LogListHasMenuItem(CGitLogListBase::ID_REBASE_PICK))
719 m_CommitList.SetSelectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_PICK);
720 return TRUE;
722 break;
723 case 'S':
724 if (LogListHasFocus(pMsg->hwnd) && LogListHasMenuItem(CGitLogListBase::ID_REBASE_SKIP))
726 m_CommitList.SetSelectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SKIP);
727 return TRUE;
729 break;
730 case 'Q':
731 if (LogListHasFocus(pMsg->hwnd) && LogListHasMenuItem(CGitLogListBase::ID_REBASE_SQUASH))
733 m_CommitList.SetSelectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_SQUASH);
734 return TRUE;
736 break;
737 case 'E':
738 if (LogListHasFocus(pMsg->hwnd) && LogListHasMenuItem(CGitLogListBase::ID_REBASE_EDIT))
740 m_CommitList.SetSelectedRebaseAction(CGitLogListBase::LOGACTIONS_REBASE_EDIT);
741 return TRUE;
743 break;
744 case 'A':
745 if(LogListHasFocus(pMsg->hwnd) && GetAsyncKeyState(VK_CONTROL) & 0x8000)
747 // select all entries
748 for (int i = 0; i < m_CommitList.GetItemCount(); ++i)
750 m_CommitList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
752 return TRUE;
754 break;
755 case VK_F5:
757 Refresh();
758 return TRUE;
760 break;
761 case VK_RETURN:
763 if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
765 if (GetDlgItem(IDC_REBASE_CONTINUE)->IsWindowEnabled())
766 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
767 else if (GetDlgItem(IDC_REBASE_ABORT)->IsWindowEnabled())
768 GetDlgItem(IDC_REBASE_ABORT)->SetFocus();
769 else
770 GetDlgItem(IDHELP)->SetFocus();
771 return TRUE;
774 break;
775 /* Avoid TAB control destroy but dialog exist*/
776 case VK_ESCAPE:
777 case VK_CANCEL:
779 TCHAR buff[128] = { 0 };
780 ::GetClassName(pMsg->hwnd,buff,128);
783 /* Use MSFTEDIT_CLASS http://msdn.microsoft.com/en-us/library/bb531344.aspx */
784 if (_tcsnicmp(buff, MSFTEDIT_CLASS, 128) == 0 || //Unicode and MFC 2012 and later
785 _tcsnicmp(buff, RICHEDIT_CLASS, 128) == 0 || //ANSI or MFC 2010
786 _tcsnicmp(buff,_T("Scintilla"),128)==0 ||
787 _tcsnicmp(buff,_T("SysListView32"),128)==0||
788 ::GetParent(pMsg->hwnd) == this->m_ctrlTabCtrl.m_hWnd)
790 this->PostMessage(WM_KEYDOWN,VK_ESCAPE,0);
791 return TRUE;
796 else if (pMsg->message == WM_NEXTDLGCTL)
798 HWND hwnd = GetFocus()->GetSafeHwnd();
799 if (hwnd == m_LogMessageCtrl.GetSafeHwnd() || hwnd == m_wndOutputRebase.GetSafeHwnd())
801 if (GetDlgItem(IDC_REBASE_CONTINUE)->IsWindowEnabled())
802 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
803 else if (GetDlgItem(IDC_REBASE_ABORT)->IsWindowEnabled())
804 GetDlgItem(IDC_REBASE_ABORT)->SetFocus();
805 else
806 GetDlgItem(IDHELP)->SetFocus();
807 return TRUE;
810 m_tooltips.RelayEvent(pMsg);
811 return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
814 bool CRebaseDlg::LogListHasFocus(HWND hwnd)
816 TCHAR buff[128] = { 0 };
817 ::GetClassName(hwnd, buff, 128);
819 if(_tcsnicmp(buff, _T("SysListView32"), 128) == 0)
820 return true;
821 return false;
824 bool CRebaseDlg::LogListHasMenuItem(int i)
826 return (m_CommitList.m_ContextMenuMask & m_CommitList.GetContextMenuBit(i)) != 0;
829 int CRebaseDlg::CheckRebaseCondition()
831 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
833 if( !g_Git.CheckCleanWorkTree() )
835 if (CMessageBox::Show(NULL, IDS_ERROR_NOCLEAN_STASH, IDS_APPNAME, 1, IDI_QUESTION, IDS_STASHBUTTON, IDS_ABORTBUTTON) == 1)
837 CString cmd,out;
838 cmd=_T("git.exe stash");
839 this->AddLogString(cmd);
840 if (g_Git.Run(cmd, &out, CP_UTF8))
842 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
843 return -1;
845 m_bStashed = true;
847 else
848 return -1;
850 //Todo Check $REBASE_ROOT
851 //Todo Check $DOTEST
853 if (!CAppUtils::CheckUserData())
854 return -1;
856 //Todo call pre_rebase_hook
857 return 0;
860 void CRebaseDlg::CheckRestoreStash()
862 if (m_bStashed && CMessageBox::Show(NULL, IDS_DCOMMIT_STASH_POP, IDS_APPNAME, 1, IDI_QUESTION, IDS_STASHBUTTON, IDS_ABORTBUTTON) == 1)
863 CAppUtils::StashPop();
864 m_bStashed = false;
867 int CRebaseDlg::StartRebase()
869 CString cmd,out;
870 m_FileListCtrl.m_bIsRevertTheirMy = !m_IsCherryPick;
872 m_OrigHEADBranch = g_Git.GetCurrentBranch(true);
874 m_OrigHEADHash.Empty();
875 if (g_Git.GetHash(m_OrigHEADHash, _T("HEAD")))
877 AddLogString(CString(MAKEINTRESOURCE(IDS_PROC_NOHEAD)));
878 return -1;
880 //Todo
881 //git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
882 // echo "detached HEAD" > "$DOTEST"/head-name
884 cmd.Format(_T("git.exe update-ref ORIG_HEAD ") + m_OrigHEADHash.ToString());
885 if(g_Git.Run(cmd,&out,CP_UTF8))
887 AddLogString(_T("update ORIG_HEAD Fail"));
888 return -1;
891 m_OrigUpstreamHash.Empty();
892 if (g_Git.GetHash(m_OrigUpstreamHash, m_UpstreamCtrl.GetString()))
894 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_UpstreamCtrl.GetString() + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
895 return -1;
898 if( !this->m_IsCherryPick )
900 cmd.Format(_T("git.exe checkout -f %s --"), m_OrigUpstreamHash.ToString());
901 this->AddLogString(cmd);
902 while (true)
904 out.Empty();
905 if (g_Git.Run(cmd, &out, CP_UTF8))
907 this->AddLogString(out);
908 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
909 return -1;
911 else
912 break;
916 CString log;
917 if( !this->m_IsCherryPick )
919 if (g_Git.GetHash(m_OrigBranchHash, m_BranchCtrl.GetString()))
921 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_BranchCtrl.GetString() + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
922 return -1;
924 log.Format(_T("%s\r\n"), CString(MAKEINTRESOURCE(IDS_PROC_REBASE_STARTREBASE)));
926 else
927 log.Format(_T("%s\r\n"), CString(MAKEINTRESOURCE(IDS_PROC_REBASE_STARTCHERRYPICK)));
929 this->AddLogString(log);
930 return 0;
932 int CRebaseDlg::VerifyNoConflict()
934 CTGitPathList list;
935 if(g_Git.ListConflictFile(list))
937 AddLogString(_T("Get conflict files fail"));
938 return -1;
940 if (!list.IsEmpty())
942 CMessageBox::Show(NULL, IDS_PROGRS_CONFLICTSOCCURED, IDS_APPNAME, MB_OK);
943 return -1;
945 return 0;
949 static bool IsLocalBranch(CString ref)
951 STRING_VECTOR list;
952 g_Git.GetBranchList(list, nullptr, CGit::BRANCH_LOCAL);
953 return std::find(list.begin(), list.end(), ref) != list.end();
956 int CRebaseDlg::FinishRebase()
958 if (m_bFinishedRebase)
959 return 0;
961 m_bFinishedRebase = true;
962 if(this->m_IsCherryPick) //cherry pick mode no "branch", working at upstream branch
964 m_sStatusText.LoadString(IDS_DONE);
965 m_CtrlStatusText.SetWindowText(m_sStatusText);
966 m_bStatusWarning = false;
967 m_CtrlStatusText.Invalidate();
968 return 0;
971 CGitHash head;
972 if (g_Git.GetHash(head, _T("HEAD")))
974 MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash.")), _T("TortoiseGit"), MB_ICONERROR);
975 return -1;
977 CString out,cmd;
979 if (IsLocalBranch(m_BranchCtrl.GetString()))
981 cmd.Format(_T("git.exe checkout -f -B %s %s --"), m_BranchCtrl.GetString(), head.ToString());
982 AddLogString(cmd);
983 while (true)
985 out.Empty();
986 if (g_Git.Run(cmd, &out, CP_UTF8))
988 AddLogString(out);
989 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
990 return -1;
992 else
993 break;
995 AddLogString(out);
998 cmd.Format(_T("git.exe reset --hard %s --"), head.ToString());
999 AddLogString(cmd);
1000 while (true)
1002 out.Empty();
1003 if (g_Git.Run(cmd, &out, CP_UTF8))
1005 AddLogString(out);
1006 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1007 return -1;
1009 else
1010 break;
1012 AddLogString(out);
1014 while (m_ctrlTabCtrl.GetTabsNum() > 1)
1015 m_ctrlTabCtrl.RemoveTab(0);
1016 m_CtrlStatusText.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_REBASEFINISHED)));
1017 m_sStatusText = CString(MAKEINTRESOURCE(IDS_PROC_REBASEFINISHED));
1018 m_bStatusWarning = false;
1019 m_CtrlStatusText.Invalidate();
1021 return 0;
1023 void CRebaseDlg::OnBnClickedContinue()
1025 if( m_RebaseStage == REBASE_DONE)
1027 OnOK();
1028 CheckRestoreStash();
1029 return;
1032 if (m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage == CHOOSE_COMMIT_PICK_MODE)
1034 if (CheckRebaseCondition())
1035 return;
1038 if( this->m_IsFastForward )
1040 CString cmd,out;
1041 if (g_Git.GetHash(m_OrigBranchHash, m_BranchCtrl.GetString()))
1043 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_BranchCtrl.GetString() + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
1044 return;
1046 if (g_Git.GetHash(m_OrigUpstreamHash, m_UpstreamCtrl.GetString()))
1048 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_UpstreamCtrl.GetString() + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
1049 return;
1052 if(!g_Git.IsFastForward(this->m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString()))
1054 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1055 AddLogString(_T("No fast forward possible.\r\nMaybe repository changed"));
1056 return;
1059 if (IsLocalBranch(m_BranchCtrl.GetString()))
1061 cmd.Format(_T("git.exe checkout -f -B %s %s --"), m_BranchCtrl.GetString(), m_UpstreamCtrl.GetString());
1062 AddLogString(cmd);
1063 while (true)
1065 out.Empty();
1066 if (g_Git.Run(cmd, &out, CP_UTF8))
1068 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1069 AddLogString(out);
1070 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1071 return;
1073 else
1074 break;
1076 AddLogString(out);
1077 out.Empty();
1079 cmd.Format(_T("git.exe reset --hard %s --"), g_Git.FixBranchName(this->m_UpstreamCtrl.GetString()));
1080 CString log;
1081 log.Format(IDS_PROC_REBASE_FFTO, m_UpstreamCtrl.GetString());
1082 this->AddLogString(log);
1084 AddLogString(cmd);
1085 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1086 while (true)
1088 out.Empty();
1089 if (g_Git.Run(cmd, &out, CP_UTF8))
1091 AddLogString(CString(MAKEINTRESOURCE(IDS_FAIL)));
1092 AddLogString(out);
1093 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1094 return;
1096 else
1097 break;
1099 AddLogString(out);
1100 AddLogString(CString(MAKEINTRESOURCE(IDS_DONE)));
1101 m_RebaseStage = REBASE_DONE;
1102 UpdateCurrentStatus();
1103 return;
1106 if( m_RebaseStage == CHOOSE_BRANCH|| m_RebaseStage == CHOOSE_COMMIT_PICK_MODE )
1108 if(CheckRebaseCondition())
1109 return ;
1110 m_RebaseStage = REBASE_START;
1111 m_FileListCtrl.Clear();
1112 m_FileListCtrl.SetHasCheckboxes(false);
1113 m_FileListCtrl.m_CurrentVersion = L"";
1114 m_ctrlTabCtrl.SetTabLabel(REBASE_TAB_CONFLICT, CString(MAKEINTRESOURCE(IDS_PROC_CONFLICTFILES)));
1115 m_ctrlTabCtrl.AddTab(&m_wndOutputRebase, CString(MAKEINTRESOURCE(IDS_LOG)), 2);
1118 if( m_RebaseStage == REBASE_FINISH )
1120 if(FinishRebase())
1121 return ;
1123 OnOK();
1126 if( m_RebaseStage == REBASE_SQUASH_CONFLICT)
1128 if(VerifyNoConflict())
1129 return;
1130 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1131 if(this->CheckNextCommitIsSquash())
1132 {//next commit is not squash;
1133 m_RebaseStage = REBASE_SQUASH_EDIT;
1134 this->OnRebaseUpdateUI(0,0);
1135 this->UpdateCurrentStatus();
1136 return ;
1139 m_RebaseStage=REBASE_CONTINUE;
1140 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1141 this->UpdateCurrentStatus();
1145 if( m_RebaseStage == REBASE_CONFLICT )
1147 if(VerifyNoConflict())
1148 return;
1150 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1151 // ***************************************************
1152 // ATTENTION: Similar code in CommitDlg.cpp!!!
1153 // ***************************************************
1154 CMassiveGitTask mgtReAddAfterCommit(_T("add --ignore-errors -f"));
1155 CMassiveGitTask mgtAdd(_T("add -f"));
1156 CMassiveGitTask mgtUpdateIndexForceRemove(_T("update-index --force-remove"));
1157 CMassiveGitTask mgtUpdateIndex(_T("update-index"));
1158 CMassiveGitTask mgtRm(_T("rm --ignore-unmatch"));
1159 CMassiveGitTask mgtRmFCache(_T("rm -f --cache"));
1160 CMassiveGitTask mgtReset(_T("reset"), TRUE, true);
1161 for (int i = 0; i < m_FileListCtrl.GetItemCount(); i++)
1163 CTGitPath *entry = (CTGitPath *)m_FileListCtrl.GetItemData(i);
1164 if (entry->m_Checked)
1166 if (entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
1167 mgtAdd.AddFile(entry->GetGitPathString());
1168 else if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
1169 mgtUpdateIndexForceRemove.AddFile(entry->GetGitPathString());
1170 else
1171 mgtUpdateIndex.AddFile(entry->GetGitPathString());
1173 if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
1174 mgtRm.AddFile(entry->GetGitOldPathString());
1176 else
1178 if (entry->m_Action & CTGitPath::LOGACTIONS_ADDED || entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
1180 mgtRmFCache.AddFile(entry->GetGitPathString());
1181 mgtReAddAfterCommit.AddFile(*entry);
1183 if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED && !entry->GetGitOldPathString().IsEmpty())
1184 mgtReset.AddFile(entry->GetGitOldPathString());
1186 else if(!(entry->m_Action & CTGitPath::LOGACTIONS_UNVER))
1187 mgtReset.AddFile(entry->GetGitPathString());
1191 BOOL cancel = FALSE;
1192 bool successful = true;
1193 successful = successful && mgtAdd.Execute(cancel);
1194 successful = successful && mgtUpdateIndexForceRemove.Execute(cancel);
1195 successful = successful && mgtUpdateIndex.Execute(cancel);
1196 successful = successful && mgtRm.Execute(cancel);
1197 successful = successful && mgtRmFCache.Execute(cancel);
1198 successful = successful && mgtReset.Execute(cancel);
1200 if (!successful)
1202 AddLogString(_T("An error occurred while updating the index."));
1203 return;
1206 CString out =_T("");
1207 CString cmd;
1208 cmd.Format(_T("git.exe commit -C %s"), curRev->m_CommitHash.ToString());
1210 AddLogString(cmd);
1212 if(g_Git.Run(cmd,&out,CP_UTF8))
1214 AddLogString(out);
1215 if(!g_Git.CheckCleanWorkTree())
1217 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1218 return;
1222 AddLogString(out);
1224 // update commit message if needed
1225 CString str = m_LogMessageCtrl.GetText().Trim();
1226 if (str != (curRev->GetSubject() + _T("\n") + curRev->GetBody()).Trim())
1228 if (str.Trim().IsEmpty())
1230 CMessageBox::Show(NULL, IDS_PROC_COMMITMESSAGE_EMPTY,IDS_APPNAME, MB_OK | MB_ICONERROR);
1231 return;
1233 CString tempfile = ::GetTempFile();
1234 CAppUtils::SaveCommitUnicodeFile(tempfile, str);
1236 out.Empty();
1237 cmd.Format(_T("git.exe commit --amend -F \"%s\""), tempfile);
1238 AddLogString(cmd);
1240 if (g_Git.Run(cmd, &out, CP_UTF8))
1242 AddLogString(out);
1243 if (!g_Git.CheckCleanWorkTree())
1245 CMessageBox::Show(NULL, out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1246 return;
1250 AddLogString(out);
1253 if (((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\ReaddUnselectedAddedFilesAfterCommit"), TRUE)) == TRUE)
1255 BOOL cancel = FALSE;
1256 mgtReAddAfterCommit.Execute(cancel);
1259 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1260 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_EDIT)
1262 m_RebaseStage=REBASE_EDIT;
1263 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1264 this->UpdateCurrentStatus();
1265 return;
1267 else
1269 m_RebaseStage=REBASE_CONTINUE;
1270 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1271 this->UpdateCurrentStatus();
1275 if( m_RebaseStage == REBASE_EDIT || m_RebaseStage == REBASE_SQUASH_EDIT )
1277 CString str;
1278 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1280 str=this->m_LogMessageCtrl.GetText();
1281 if(str.Trim().IsEmpty())
1283 CMessageBox::Show(NULL, IDS_PROC_COMMITMESSAGE_EMPTY,IDS_APPNAME, MB_OK | MB_ICONERROR);
1284 return;
1287 CString tempfile=::GetTempFile();
1288 CAppUtils::SaveCommitUnicodeFile(tempfile, str);
1290 CString out,cmd;
1292 if( m_RebaseStage == REBASE_SQUASH_EDIT )
1293 cmd.Format(_T("git.exe commit %s-F \"%s\""), m_SquashFirstMetaData, tempfile);
1294 else
1295 cmd.Format(_T("git.exe commit --amend -F \"%s\""), tempfile);
1297 if(g_Git.Run(cmd,&out,CP_UTF8))
1299 if(!g_Git.CheckCleanWorkTree())
1301 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1302 return;
1306 ::DeleteFile(tempfile);
1307 AddLogString(out);
1308 m_SquashMessage.Empty();
1309 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1310 m_RebaseStage=REBASE_CONTINUE;
1311 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1312 this->UpdateCurrentStatus();
1316 InterlockedExchange(&m_bThreadRunning, TRUE);
1317 SetControlEnable();
1319 if (AfxBeginThread(RebaseThreadEntry, this)==NULL)
1321 InterlockedExchange(&m_bThreadRunning, FALSE);
1322 CMessageBox::Show(NULL, _T("Create Rebase Thread Fail"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1323 SetControlEnable();
1326 int CRebaseDlg::CheckNextCommitIsSquash()
1328 int index;
1329 if(m_CommitList.m_IsOldFirst)
1330 index=m_CurrentRebaseIndex+1;
1331 else
1332 index=m_CurrentRebaseIndex-1;
1334 GitRev *curRev;
1337 if(index<0)
1338 return -1;
1339 if(index>= m_CommitList.GetItemCount())
1340 return -1;
1342 curRev=(GitRev*)m_CommitList.m_arShownList[index];
1344 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1345 return 0;
1346 if (curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SKIP)
1348 if(m_CommitList.m_IsOldFirst)
1349 ++index;
1350 else
1351 --index;
1353 else
1354 return -1;
1356 } while(curRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_SKIP);
1358 return -1;
1361 int CRebaseDlg::GoNext()
1363 if(m_CommitList.m_IsOldFirst)
1364 ++m_CurrentRebaseIndex;
1365 else
1366 --m_CurrentRebaseIndex;
1367 return 0;
1370 int CRebaseDlg::StateAction()
1372 switch(this->m_RebaseStage)
1374 case CHOOSE_BRANCH:
1375 case CHOOSE_COMMIT_PICK_MODE:
1376 if(StartRebase())
1377 return -1;
1378 m_RebaseStage = REBASE_START;
1379 GoNext();
1380 break;
1383 return 0;
1385 void CRebaseDlg::SetContinueButtonText()
1387 CString Text;
1388 switch(this->m_RebaseStage)
1390 case CHOOSE_BRANCH:
1391 case CHOOSE_COMMIT_PICK_MODE:
1392 if(this->m_IsFastForward)
1393 Text.LoadString(IDS_PROC_STARTREBASEFFBUTTON);
1394 else
1395 Text.LoadString(IDS_PROC_STARTREBASEBUTTON);
1396 break;
1398 case REBASE_START:
1399 case REBASE_ERROR:
1400 case REBASE_CONTINUE:
1401 case REBASE_SQUASH_CONFLICT:
1402 Text.LoadString(IDS_CONTINUEBUTTON);
1403 break;
1405 case REBASE_CONFLICT:
1406 Text.LoadString(IDS_COMMITBUTTON);
1407 break;
1408 case REBASE_EDIT:
1409 Text.LoadString(IDS_AMENDBUTTON);
1410 break;
1412 case REBASE_SQUASH_EDIT:
1413 Text.LoadString(IDS_COMMITBUTTON);
1414 break;
1416 case REBASE_ABORT:
1417 case REBASE_FINISH:
1418 Text.LoadString(IDS_FINISHBUTTON);
1419 break;
1421 case REBASE_DONE:
1422 Text.LoadString(IDS_DONE);
1423 break;
1425 this->GetDlgItem(IDC_REBASE_CONTINUE)->SetWindowText(Text);
1428 void CRebaseDlg::SetControlEnable()
1430 switch(this->m_RebaseStage)
1432 case CHOOSE_BRANCH:
1433 case CHOOSE_COMMIT_PICK_MODE:
1435 this->GetDlgItem(IDC_PICK_ALL)->EnableWindow(TRUE);
1436 this->GetDlgItem(IDC_EDIT_ALL)->EnableWindow(TRUE);
1437 this->GetDlgItem(IDC_SQUASH_ALL)->EnableWindow(TRUE);
1438 this->GetDlgItem(IDC_BUTTON_UP2)->EnableWindow(TRUE);
1439 this->GetDlgItem(IDC_BUTTON_DOWN2)->EnableWindow(TRUE);
1441 if(!m_IsCherryPick)
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);
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;
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_PICK_ALL)->EnableWindow(FALSE);
1464 this->GetDlgItem(IDC_EDIT_ALL)->EnableWindow(FALSE);
1465 this->GetDlgItem(IDC_SQUASH_ALL)->EnableWindow(FALSE);
1466 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(FALSE);
1467 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(FALSE);
1468 this->GetDlgItem(IDC_BUTTON_REVERSE)->EnableWindow(FALSE);
1469 this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(FALSE);
1470 this->GetDlgItem(IDC_BUTTON_UP2)->EnableWindow(FALSE);
1471 this->GetDlgItem(IDC_BUTTON_DOWN2)->EnableWindow(FALSE);
1473 if( m_RebaseStage == REBASE_DONE && (this->m_PostButtonTexts.GetCount() != 0) )
1475 this->GetDlgItem(IDC_STATUS_STATIC)->ShowWindow(SW_HIDE);
1476 this->GetDlgItem(IDC_REBASE_POST_BUTTON)->ShowWindow(SW_SHOWNORMAL);
1477 this->m_PostButton.RemoveAll();
1478 this->m_PostButton.AddEntries(m_PostButtonTexts);
1479 //this->GetDlgItem(IDC_REBASE_POST_BUTTON)->SetWindowText(this->m_PostButtonText);
1481 break;
1484 if(m_bThreadRunning)
1486 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1489 else if (m_RebaseStage != REBASE_ERROR)
1491 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1495 void CRebaseDlg::UpdateProgress()
1497 int index;
1498 CRect rect;
1500 if(m_CommitList.m_IsOldFirst)
1501 index = m_CurrentRebaseIndex+1;
1502 else
1503 index = m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1505 int finishedCommits = index - 1; // introduced an variable which shows the number handled revisions for the progress bars
1506 if (m_RebaseStage == REBASE_FINISH || finishedCommits == -1)
1507 finishedCommits = index;
1509 m_ProgressBar.SetRange32(0, m_CommitList.GetItemCount());
1510 m_ProgressBar.SetPos(finishedCommits);
1511 if (m_pTaskbarList)
1513 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1514 m_pTaskbarList->SetProgressValue(m_hWnd, finishedCommits, m_CommitList.GetItemCount());
1517 if(m_CurrentRebaseIndex>=0 && m_CurrentRebaseIndex< m_CommitList.GetItemCount())
1519 CString text;
1520 text.Format(IDS_PROC_REBASING_PROGRESS, index, m_CommitList.GetItemCount());
1521 m_sStatusText = text;
1522 m_CtrlStatusText.SetWindowText(text);
1523 m_bStatusWarning = false;
1524 m_CtrlStatusText.Invalidate();
1527 GitRev *prevRev=NULL, *curRev=NULL;
1529 if( m_CurrentRebaseIndex >= 0 && m_CurrentRebaseIndex< m_CommitList.m_arShownList.GetSize())
1531 curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1534 for (int i = 0; i < m_CommitList.m_arShownList.GetSize(); ++i)
1536 prevRev=(GitRev*)m_CommitList.m_arShownList[i];
1537 if (prevRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_CURRENT)
1539 prevRev->GetRebaseAction() &= ~CGitLogListBase::LOGACTIONS_REBASE_CURRENT;
1540 m_CommitList.GetItemRect(i,&rect,LVIR_BOUNDS);
1541 m_CommitList.InvalidateRect(rect);
1545 if(curRev)
1547 curRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_CURRENT;
1548 m_CommitList.GetItemRect(m_CurrentRebaseIndex,&rect,LVIR_BOUNDS);
1549 m_CommitList.InvalidateRect(rect);
1551 m_CommitList.EnsureVisible(m_CurrentRebaseIndex,FALSE);
1554 void CRebaseDlg::UpdateCurrentStatus()
1556 SetContinueButtonText();
1557 SetControlEnable();
1558 UpdateProgress();
1559 if (m_RebaseStage == REBASE_DONE)
1560 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
1563 void CRebaseDlg::AddLogString(CString str)
1565 this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, FALSE);
1566 CStringA sTextA = m_wndOutputRebase.StringForControl(str);//CUnicodeUtils::GetUTF8(str);
1567 this->m_wndOutputRebase.SendMessage(SCI_DOCUMENTEND);
1568 this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)sTextA);
1569 this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)"\n");
1570 this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, TRUE);
1573 int CRebaseDlg::GetCurrentCommitID()
1575 if(m_CommitList.m_IsOldFirst)
1577 return this->m_CurrentRebaseIndex+1;
1580 else
1582 return m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1586 int CRebaseDlg::DoRebase()
1588 CString cmd,out;
1589 if(m_CurrentRebaseIndex <0)
1590 return 0;
1591 if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1592 return 0;
1594 GitRev *pRev = (GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1595 int mode = pRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_MODE_MASK;
1596 CString nocommit;
1598 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SKIP)
1600 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1601 return 0;
1604 bool nextCommitIsSquash = (CheckNextCommitIsSquash() == 0);
1605 if (nextCommitIsSquash || mode != CGitLogListBase::LOGACTIONS_REBASE_PICK)
1606 { // next commit is squash or not pick
1607 if (!this->m_SquashMessage.IsEmpty())
1608 this->m_SquashMessage += _T("\n\n");
1609 this->m_SquashMessage += pRev->GetSubject();
1610 this->m_SquashMessage += _T("\n");
1611 this->m_SquashMessage += pRev->GetBody().TrimRight();
1613 else
1615 this->m_SquashMessage.Empty();
1616 m_SquashFirstMetaData.Empty();
1619 if (nextCommitIsSquash || mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1620 { // next or this commit is squash
1621 nocommit=_T(" --no-commit ");
1624 if (nextCommitIsSquash && mode != CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1625 m_SquashFirstMetaData.Format(_T("--date=%s --author=\"%s <%s>\" "), pRev->GetAuthorDate().Format(_T("%Y-%m-%dT%H:%M:%S")), pRev->GetAuthorName(), pRev->GetAuthorEmail());
1627 CString log;
1628 log.Format(_T("%s %d: %s"), CGitLogListBase::GetRebaseActionName(mode), GetCurrentCommitID(), pRev->m_CommitHash.ToString());
1629 AddLogString(log);
1630 AddLogString(pRev->GetSubject());
1631 if (pRev->GetSubject().IsEmpty())
1633 CMessageBox::Show(m_hWnd, IDS_PROC_REBASE_EMPTYCOMMITMSG, IDS_APPNAME, MB_OK | MB_ICONEXCLAMATION);
1634 mode = CGitLogListBase::LOGACTIONS_REBASE_EDIT;
1637 CString cherryPickedFrom;
1638 if (m_bAddCherryPickedFrom)
1639 cherryPickedFrom = _T("-x ");
1640 else if (!m_IsCherryPick && nocommit.IsEmpty())
1641 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."
1643 cmd.Format(_T("git.exe cherry-pick %s%s %s"), cherryPickedFrom, nocommit, pRev->m_CommitHash.ToString());
1645 if(g_Git.Run(cmd,&out,CP_UTF8))
1647 AddLogString(out);
1648 CTGitPathList list;
1649 if(g_Git.ListConflictFile(list))
1651 AddLogString(_T("Get conflict files fail"));
1652 return -1;
1654 if (list.IsEmpty())
1656 if (mode == CGitLogListBase::LOGACTIONS_REBASE_PICK)
1658 if (m_pTaskbarList)
1659 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1660 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)
1662 bool resetOK = false;
1663 while (!resetOK)
1665 out.Empty();
1666 if (g_Git.Run(_T("git.exe reset --hard"), &out, CP_UTF8))
1668 AddLogString(out);
1669 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1670 break;
1672 else
1673 resetOK = true;
1676 if (resetOK)
1678 pRev->GetRebaseAction() = CGitLogListBase::LOGACTIONS_REBASE_SKIP;
1679 m_CommitList.Invalidate();
1680 return 0;
1684 m_RebaseStage = REBASE_ERROR;
1685 AddLogString(_T("An unrecoverable error occurred."));
1686 return -1;
1688 if (mode == CGitLogListBase::LOGACTIONS_REBASE_EDIT)
1690 this->m_RebaseStage = REBASE_EDIT ;
1691 return -1; // Edit return -1 to stop rebase.
1693 // Squash Case
1694 if(CheckNextCommitIsSquash())
1695 { // no squash
1696 // let user edit last commmit message
1697 this->m_RebaseStage = REBASE_SQUASH_EDIT;
1698 return -1;
1702 if (m_pTaskbarList)
1703 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1704 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1705 m_RebaseStage = REBASE_SQUASH_CONFLICT;
1706 else
1707 m_RebaseStage = REBASE_CONFLICT;
1708 return -1;
1711 else
1713 AddLogString(out);
1714 if (mode == CGitLogListBase::LOGACTIONS_REBASE_PICK)
1716 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1717 return 0;
1719 if (mode == CGitLogListBase::LOGACTIONS_REBASE_EDIT)
1721 this->m_RebaseStage = REBASE_EDIT ;
1722 return -1; // Edit return -1 to stop rebase.
1725 // Squash Case
1726 if(CheckNextCommitIsSquash())
1727 { // no squash
1728 // let user edit last commmit message
1729 this->m_RebaseStage = REBASE_SQUASH_EDIT;
1730 return -1;
1732 else if (mode == CGitLogListBase::LOGACTIONS_REBASE_SQUASH)
1733 pRev->GetRebaseAction() |= CGitLogListBase::LOGACTIONS_REBASE_DONE;
1736 return 0;
1739 BOOL CRebaseDlg::IsEnd()
1741 if(m_CommitList.m_IsOldFirst)
1742 return m_CurrentRebaseIndex>= this->m_CommitList.GetItemCount();
1743 else
1744 return m_CurrentRebaseIndex<0;
1747 int CRebaseDlg::RebaseThread()
1749 CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
1751 int ret=0;
1752 while(1)
1754 if( m_RebaseStage == REBASE_START )
1756 if( this->StartRebase() )
1758 ret = -1;
1759 break;
1761 m_RebaseStage = REBASE_CONTINUE;
1764 else if( m_RebaseStage == REBASE_CONTINUE )
1766 this->GoNext();
1767 SendMessage(MSG_REBASE_UPDATE_UI);
1768 if(IsEnd())
1770 ret = 0;
1771 m_RebaseStage = REBASE_FINISH;
1774 else
1776 ret = DoRebase();
1778 if( ret )
1780 break;
1785 else if( m_RebaseStage == REBASE_FINISH )
1787 SendMessage(MSG_REBASE_UPDATE_UI);
1788 m_RebaseStage = REBASE_DONE;
1789 break;
1792 else
1794 break;
1796 this->PostMessage(MSG_REBASE_UPDATE_UI);
1799 InterlockedExchange(&m_bThreadRunning, FALSE);
1800 this->PostMessage(MSG_REBASE_UPDATE_UI);
1801 return ret;
1804 void CRebaseDlg::ListConflictFile()
1806 this->m_FileListCtrl.Clear();
1807 m_FileListCtrl.SetHasCheckboxes(true);
1808 CTGitPathList list;
1809 CTGitPath path;
1810 list.AddPath(path);
1812 m_FileListCtrl.m_bIsRevertTheirMy = !m_IsCherryPick;
1814 this->m_FileListCtrl.GetStatus(&list,true);
1815 this->m_FileListCtrl.Show(CTGitPath::LOGACTIONS_UNMERGED|CTGitPath::LOGACTIONS_MODIFIED|CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_DELETED,
1816 CTGitPath::LOGACTIONS_UNMERGED);
1818 m_FileListCtrl.Check(GITSLC_SHOWFILES);
1819 bool hasSubmoduleChange = false;
1820 for (int i = 0; i < m_FileListCtrl.GetItemCount(); i++)
1822 CTGitPath *entry = (CTGitPath *)m_FileListCtrl.GetItemData(i);
1823 if (entry->IsDirectory())
1825 hasSubmoduleChange = true;
1826 break;
1830 if (hasSubmoduleChange)
1832 m_CtrlStatusText.SetWindowText(m_sStatusText + _T(", ") + CString(MAKEINTRESOURCE(IDS_CARE_SUBMODULE_CHANGES)));
1833 m_bStatusWarning = true;
1834 m_CtrlStatusText.Invalidate();
1836 else
1838 m_CtrlStatusText.SetWindowText(m_sStatusText);
1839 m_bStatusWarning = false;
1840 m_CtrlStatusText.Invalidate();
1844 LRESULT CRebaseDlg::OnRebaseUpdateUI(WPARAM,LPARAM)
1846 if (m_RebaseStage == REBASE_FINISH)
1848 FinishRebase();
1849 return 0;
1851 UpdateCurrentStatus();
1852 if (m_RebaseStage == REBASE_DONE && m_pTaskbarList)
1853 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS); // do not show progress on taskbar any more to show we finished
1854 if(m_CurrentRebaseIndex <0)
1855 return 0;
1856 if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1857 return 0;
1858 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1860 switch(m_RebaseStage)
1862 case REBASE_CONFLICT:
1863 case REBASE_SQUASH_CONFLICT:
1865 ListConflictFile();
1866 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_CONFLICT);
1867 if (m_pTaskbarList)
1868 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1869 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1870 CString dotGitPath;
1871 g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, dotGitPath);
1872 CString logMessage;
1873 bool loadedMsg = CGit::LoadTextFile(dotGitPath + _T("MERGE_MSG"), logMessage);
1874 if (!loadedMsg)
1875 logMessage = curRev->GetSubject() + _T("\n") + curRev->GetBody();
1876 this->m_LogMessageCtrl.SetText(logMessage);
1877 break;
1879 case REBASE_EDIT:
1880 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1881 if (m_pTaskbarList)
1882 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
1883 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1884 this->m_LogMessageCtrl.SetText(curRev->GetSubject()+_T("\n")+curRev->GetBody());
1885 break;
1886 case REBASE_SQUASH_EDIT:
1887 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1888 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1889 this->m_LogMessageCtrl.SetText(this->m_SquashMessage);
1890 if (m_pTaskbarList)
1891 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
1892 break;
1893 default:
1894 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1896 return 0;
1898 void CRebaseDlg::OnCancel()
1900 OnBnClickedAbort();
1902 void CRebaseDlg::OnBnClickedAbort()
1904 if (m_pTaskbarList)
1905 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
1907 m_tooltips.Pop();
1909 CString cmd,out;
1910 CString pron = m_OrigUpstreamHash.ToString();
1911 if(m_OrigUpstreamHash.IsEmpty())
1913 __super::OnCancel();
1916 if(m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage== CHOOSE_COMMIT_PICK_MODE)
1918 goto end;
1921 if(CMessageBox::Show(NULL, IDS_PROC_REBASE_ABORT, IDS_APPNAME, MB_YESNO) != IDYES)
1922 goto end;
1924 if(this->m_IsFastForward)
1926 cmd.Format(_T("git.exe reset --hard %s --"),this->m_OrigBranchHash.ToString());
1927 while (true)
1929 out.Empty();
1930 if (g_Git.Run(cmd, &out, CP_UTF8))
1932 AddLogString(out);
1933 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1934 break;
1936 else
1937 break;
1939 __super::OnCancel();
1940 goto end;
1943 if (m_IsCherryPick) // there are not "branch" at cherry pick mode
1945 cmd.Format(_T("git.exe reset --hard %s --"), m_OrigUpstreamHash.ToString());
1946 while (true)
1948 out.Empty();
1949 if (g_Git.Run(cmd, &out, CP_UTF8))
1951 AddLogString(out);
1952 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1953 break;
1955 else
1956 break;
1959 __super::OnCancel();
1960 goto end;
1963 if (m_OrigHEADBranch == m_BranchCtrl.GetString())
1965 if (IsLocalBranch(m_OrigHEADBranch))
1966 cmd.Format(_T("git.exe checkout -f -B %s %s --"), m_BranchCtrl.GetString(), m_OrigBranchHash.ToString());
1967 else
1968 cmd.Format(_T("git.exe checkout -f %s --"), m_OrigBranchHash.ToString());
1969 if (g_Git.Run(cmd, &out, CP_UTF8))
1971 AddLogString(out);
1972 ::MessageBox(m_hWnd, _T("Unrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_ICONERROR);
1973 __super::OnCancel();
1974 goto end;
1977 cmd.Format(_T("git.exe reset --hard %s --"), m_OrigBranchHash.ToString());
1978 while (true)
1980 out.Empty();
1981 if (g_Git.Run(cmd, &out, CP_UTF8))
1983 AddLogString(out);
1984 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1985 break;
1987 else
1988 break;
1991 else
1993 if (m_OrigHEADBranch != g_Git.GetCurrentBranch(true))
1995 if (IsLocalBranch(m_OrigHEADBranch))
1996 cmd.Format(_T("git.exe checkout -f -B %s %s --"), m_OrigHEADBranch, m_OrigHEADHash.ToString());
1997 else
1998 cmd.Format(_T("git.exe checkout -f %s --"), m_OrigHEADHash.ToString());
1999 if (g_Git.Run(cmd, &out, CP_UTF8))
2001 AddLogString(out);
2002 ::MessageBox(m_hWnd, _T("Unrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_ICONERROR);
2003 // continue to restore moved branch
2007 cmd.Format(_T("git.exe reset --hard %s --"), m_OrigHEADHash.ToString());
2008 while (true)
2010 out.Empty();
2011 if (g_Git.Run(cmd, &out, CP_UTF8))
2013 AddLogString(out);
2014 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
2015 break;
2017 else
2018 break;
2021 // restore moved branch
2022 if (IsLocalBranch(m_BranchCtrl.GetString()))
2024 cmd.Format(_T("git.exe branch -f %s %s --"), m_BranchCtrl.GetString(), m_OrigBranchHash.ToString());
2025 if (g_Git.Run(cmd, &out, CP_UTF8))
2027 AddLogString(out);
2028 ::MessageBox(m_hWnd, _T("Unrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_ICONERROR);
2029 __super::OnCancel();
2030 goto end;
2034 __super::OnCancel();
2035 end:
2036 CheckRestoreStash();
2039 void CRebaseDlg::OnBnClickedButtonReverse()
2041 CString temp = m_BranchCtrl.GetString();
2042 m_BranchCtrl.AddString(m_UpstreamCtrl.GetString());
2043 m_UpstreamCtrl.AddString(temp);
2044 OnCbnSelchangeUpstream();
2047 void CRebaseDlg::OnBnClickedButtonBrowse()
2049 if(CBrowseRefsDlg::PickRefForCombo(&m_UpstreamCtrl, gPickRef_NoTag))
2050 OnCbnSelchangeUpstream();
2053 void CRebaseDlg::OnBnClickedRebaseCheckForce()
2055 this->UpdateData();
2056 this->FetchLogList();
2059 void CRebaseDlg::OnBnClickedRebasePostButton()
2061 this->m_Upstream=this->m_UpstreamCtrl.GetString();
2062 this->m_Branch=this->m_BranchCtrl.GetString();
2064 this->EndDialog((int)(IDC_REBASE_POST_BUTTON+this->m_PostButton.GetCurrentEntry()));
2067 LRESULT CRebaseDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
2069 Refresh();
2070 return 0;
2073 void CRebaseDlg::Refresh()
2075 if (m_RebaseStage == REBASE_CONFLICT || m_RebaseStage == REBASE_SQUASH_CONFLICT)
2077 ListConflictFile();
2078 return;
2081 if(this->m_IsCherryPick)
2082 return ;
2084 if(this->m_RebaseStage == CHOOSE_BRANCH )
2086 this->UpdateData();
2087 this->FetchLogList();
2091 void CRebaseDlg::OnBnClickedButtonUp2()
2093 POSITION pos;
2094 pos = m_CommitList.GetFirstSelectedItemPosition();
2096 // do nothing if the first selected item is the first item in the list
2097 if (m_CommitList.GetNextSelectedItem(pos) == 0)
2098 return;
2100 pos = m_CommitList.GetFirstSelectedItemPosition();
2102 bool changed = false;
2103 while(pos)
2105 int index=m_CommitList.GetNextSelectedItem(pos);
2106 if(index>=1)
2108 CGitHash old = m_CommitList.m_logEntries[index-1];
2109 m_CommitList.m_logEntries[index-1] = m_CommitList.m_logEntries[index];
2110 m_CommitList.m_logEntries[index] = old;
2111 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
2112 m_CommitList.SetItemState(index-1, LVIS_SELECTED, LVIS_SELECTED);
2113 m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
2114 changed = true;
2117 if (changed)
2119 pos = m_CommitList.GetFirstSelectedItemPosition();
2120 m_CommitList.EnsureVisible(m_CommitList.GetNextSelectedItem(pos), false);
2121 m_CommitList.Invalidate();
2122 m_CommitList.SetFocus();
2126 void CRebaseDlg::OnBnClickedButtonDown2()
2128 if (m_CommitList.GetSelectedCount() == 0)
2129 return;
2131 POSITION pos;
2132 pos = m_CommitList.GetFirstSelectedItemPosition();
2133 bool changed = false;
2134 // use an array to store all selected item indexes; the user won't select too much items
2135 int* indexes = NULL;
2136 indexes = new int[m_CommitList.GetSelectedCount()];
2137 int i = 0;
2138 while(pos)
2140 indexes[i++] = m_CommitList.GetNextSelectedItem(pos);
2142 // don't move any item if the last selected item is the last item in the m_CommitList
2143 // (that would change the order of the selected items)
2144 if(indexes[m_CommitList.GetSelectedCount() - 1] < m_CommitList.GetItemCount() - 1)
2146 // iterate over the indexes backwards in order to correctly move multiselected items
2147 for (i = m_CommitList.GetSelectedCount() - 1; i >= 0; i--)
2149 int index = indexes[i];
2150 CGitHash old = m_CommitList.m_logEntries[index+1];
2151 m_CommitList.m_logEntries[index+1] = m_CommitList.m_logEntries[index];
2152 m_CommitList.m_logEntries[index] = old;
2153 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
2154 m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
2155 m_CommitList.SetItemState(index+1, LVIS_SELECTED, LVIS_SELECTED);
2156 changed = true;
2159 m_CommitList.EnsureVisible(indexes[m_CommitList.GetSelectedCount() - 1] + 1, false);
2160 delete [] indexes;
2161 indexes = NULL;
2162 if (changed)
2164 m_CommitList.Invalidate();
2165 m_CommitList.SetFocus();
2169 LRESULT CRebaseDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
2171 m_pTaskbarList.Release();
2172 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
2173 SetUUIDOverlayIcon(m_hWnd);
2174 return 0;
2177 void CRebaseDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
2179 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
2180 *pResult = 0;
2181 if(m_CommitList.m_bNoDispUpdates)
2182 return;
2183 if (pNMLV->iItem >= 0)
2185 this->m_CommitList.m_nSearchIndex = pNMLV->iItem;
2186 if (pNMLV->iSubItem != 0)
2187 return;
2188 if ((pNMLV->iItem == m_CommitList.m_arShownList.GetCount()))
2190 // remove the selected state
2191 if (pNMLV->uChanged & LVIF_STATE)
2193 m_CommitList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
2194 FillLogMessageCtrl();
2196 return;
2198 if (pNMLV->uChanged & LVIF_STATE)
2200 FillLogMessageCtrl();
2203 else
2205 FillLogMessageCtrl();
2209 void CRebaseDlg::FillLogMessageCtrl()
2211 int selCount = m_CommitList.GetSelectedCount();
2212 if (selCount == 1 && (m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage == CHOOSE_COMMIT_PICK_MODE))
2214 POSITION pos = m_CommitList.GetFirstSelectedItemPosition();
2215 int selIndex = m_CommitList.GetNextSelectedItem(pos);
2216 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_CommitList.m_arShownList.SafeGetAt(selIndex));
2217 m_FileListCtrl.UpdateWithGitPathList(pLogEntry->GetFiles(&m_CommitList));
2218 m_FileListCtrl.m_CurrentVersion = pLogEntry->m_CommitHash;
2219 m_FileListCtrl.Show(GITSLC_SHOWVERSIONED);
2220 m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
2221 m_LogMessageCtrl.SetText(pLogEntry->GetSubject() + _T("\n") + pLogEntry->GetBody());
2222 m_LogMessageCtrl.Call(SCI_SETREADONLY, TRUE);
2225 void CRebaseDlg::OnBnClickedCheckCherryPickedFrom()
2227 UpdateData();
2230 LRESULT CRebaseDlg::OnRebaseActionMessage(WPARAM, LPARAM)
2232 if (m_RebaseStage == REBASE_ERROR || m_RebaseStage == REBASE_CONFLICT)
2234 GitRev *pRev = (GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
2235 int mode = pRev->GetRebaseAction() & CGitLogListBase::LOGACTIONS_REBASE_MODE_MASK;
2236 if (mode == CGitLogListBase::LOGACTIONS_REBASE_SKIP)
2238 CString out;
2239 bool resetOK = false;
2240 while (!resetOK)
2242 out.Empty();
2243 if (g_Git.Run(_T("git.exe reset --hard"), &out, CP_UTF8))
2245 AddLogString(out);
2246 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
2247 break;
2249 else
2250 resetOK = true;
2253 if (resetOK)
2255 m_FileListCtrl.Clear();
2256 m_RebaseStage = REBASE_CONTINUE;
2257 UpdateCurrentStatus();
2261 return 0;