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