src/TortoiseProc/RebaseDlg.cpp

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