src/TortoiseProc/RebaseDlg.cpp

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