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