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