src/TortoiseProc/RebaseDlg.cpp

   1 // RebaseDlg.cpp : implementation file
   2 //
   3
   4 #include "stdafx.h"
   5 #include "TortoiseProc.h"
   6 #include "RebaseDlg.h"
   7 #include "AppUtils.h"
   8 #include "MessageBox.h"
   9 #include "UnicodeUtils.h"
  10 #include "BrowseRefsDlg.h"
  11 #include "ProgressDlg.h"
  12 // CRebaseDlg dialog
  13
  14 IMPLEMENT_DYNAMIC(CRebaseDlg, CResizableStandAloneDialog)
  15
  16 CRebaseDlg::CRebaseDlg(CWnd* pParent /*=NULL*/)
  17         : CResizableStandAloneDialog(CRebaseDlg::IDD, pParent)
  18     , m_bPickAll(FALSE)
  19     , m_bSquashAll(FALSE)
  20     , m_bEditAll(FALSE)
  21 {
  22         m_RebaseStage=CHOOSE_BRANCH;
  23         m_CurrentRebaseIndex=-1;
  24         m_bThreadRunning =FALSE;
  25         this->m_IsCherryPick = FALSE;
  26         m_bForce=FALSE;
  27         m_IsFastForward=FALSE;
  28 }
  29
  30 CRebaseDlg::~CRebaseDlg()
  31 {
  32 }
  33
  34 void CRebaseDlg::DoDataExchange(CDataExchange* pDX)
  35 {
  36     CDialog::DoDataExchange(pDX);
  37     DDX_Control(pDX, IDC_REBASE_PROGRESS, m_ProgressBar);
  38     DDX_Control(pDX, IDC_STATUS_STATIC, m_CtrlStatusText);
  39     DDX_Check(pDX, IDC_PICK_ALL, m_bPickAll);
  40     DDX_Check(pDX, IDC_SQUASH_ALL, m_bSquashAll);
  41     DDX_Check(pDX, IDC_EDIT_ALL, m_bEditAll);
  42         DDX_Control(pDX, IDC_REBASE_SPLIT, m_wndSplitter);
  43         DDX_Control(pDX,IDC_COMMIT_LIST,m_CommitList);
  44         DDX_Control(pDX,IDC_REBASE_COMBOXEX_BRANCH, this->m_BranchCtrl);
  45         DDX_Control(pDX,IDC_REBASE_COMBOXEX_UPSTREAM,   this->m_UpstreamCtrl);
  46         DDX_Check(pDX, IDC_REBASE_CHECK_FORCE,m_bForce);
  47
  48 }
  49
  50
  51 BEGIN_MESSAGE_MAP(CRebaseDlg, CResizableStandAloneDialog)
  52     ON_BN_CLICKED(IDC_PICK_ALL, &CRebaseDlg::OnBnClickedPickAll)
  53     ON_BN_CLICKED(IDC_SQUASH_ALL, &CRebaseDlg::OnBnClickedSquashAll)
  54     ON_BN_CLICKED(IDC_EDIT_ALL, &CRebaseDlg::OnBnClickedEditAll)
  55     ON_BN_CLICKED(IDC_REBASE_SPLIT, &CRebaseDlg::OnBnClickedRebaseSplit)
  56         ON_BN_CLICKED(IDC_REBASE_CONTINUE,OnBnClickedContinue)
  57         ON_BN_CLICKED(IDC_REBASE_ABORT,  OnBnClickedAbort)
  58         ON_WM_SIZE()
  59         ON_CBN_SELCHANGE(IDC_REBASE_COMBOXEX_BRANCH,   &CRebaseDlg::OnCbnSelchangeBranch)
  60         ON_CBN_SELCHANGE(IDC_REBASE_COMBOXEX_UPSTREAM, &CRebaseDlg::OnCbnSelchangeUpstream)
  61         ON_MESSAGE(MSG_REBASE_UPDATE_UI, OnRebaseUpdateUI)
  62         ON_BN_CLICKED(IDC_BUTTON_BROWSE, &CRebaseDlg::OnBnClickedButtonBrowse)
  63         ON_BN_CLICKED(IDC_REBASE_CHECK_FORCE, &CRebaseDlg::OnBnClickedRebaseCheckForce)
  64         ON_STN_CLICKED(IDC_STATUS_STATIC, &CRebaseDlg::OnStnClickedStatusStatic)
  65         ON_BN_CLICKED(IDC_REBASE_POST_BUTTON, &CRebaseDlg::OnBnClickedRebasePostButton)
  66 END_MESSAGE_MAP()
  67
  68 void CRebaseDlg::AddRebaseAnchor()
  69 {
  70         AddAnchor(IDC_REBASE_TAB,TOP_LEFT,BOTTOM_RIGHT);
  71         AddAnchor(IDC_COMMIT_LIST,TOP_LEFT, TOP_RIGHT);
  72         AddAnchor(IDC_REBASE_SPLIT,TOP_LEFT, TOP_RIGHT);
  73         AddAnchor(IDC_STATUS_STATIC, BOTTOM_LEFT,BOTTOM_RIGHT);
  74         AddAnchor(IDC_REBASE_CONTINUE,BOTTOM_RIGHT);
  75         AddAnchor(IDC_REBASE_ABORT, BOTTOM_RIGHT);
  76         AddAnchor(IDC_REBASE_PROGRESS,BOTTOM_LEFT, BOTTOM_RIGHT);
  77         AddAnchor(IDC_PICK_ALL,TOP_LEFT);
  78         AddAnchor(IDC_SQUASH_ALL,TOP_LEFT);
  79         AddAnchor(IDC_EDIT_ALL,TOP_LEFT);
  80         AddAnchor(IDC_REBASE_COMBOXEX_UPSTREAM,TOP_LEFT);
  81         AddAnchor(IDC_REBASE_COMBOXEX_BRANCH,TOP_LEFT);
  82         AddAnchor(IDC_REBASE_STATIC_UPSTREAM,TOP_LEFT);
  83         AddAnchor(IDC_REBASE_STATIC_BRANCH,TOP_LEFT);
  84         AddAnchor(IDHELP, BOTTOM_RIGHT);
  85         AddAnchor(IDC_REBASE_CHECK_FORCE,TOP_RIGHT);
  86         AddAnchor(IDC_REBASE_POST_BUTTON,BOTTOM_LEFT);
  87
  88         this->AddOthersToAnchor();
  89 }
  90
  91 BOOL CRebaseDlg::OnInitDialog()
  92 {
  93         CResizableStandAloneDialog::OnInitDialog();
  94
  95         CRect rectDummy;
  96         //IDC_REBASE_DUMY_TAB
  97
  98         GetClientRect(m_DlgOrigRect);
  99         m_CommitList.GetClientRect(m_CommitListOrigRect);
 100
 101         CWnd *pwnd=this->GetDlgItem(IDC_REBASE_DUMY_TAB);
 102         pwnd->GetWindowRect(&rectDummy);
 103         this->ScreenToClient(rectDummy);
 104
 105         if (!m_ctrlTabCtrl.Create(CMFCTabCtrl::STYLE_FLAT, rectDummy, this, IDC_REBASE_TAB))
 106         {
 107                 TRACE0("Failed to create output tab window\n");
 108                 return FALSE;      // fail to create
 109         }
 110         m_ctrlTabCtrl.SetResizeMode(CMFCTabCtrl::RESIZE_NO);
 111         // Create output panes:
 112         //const DWORD dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
 113         DWORD dwStyle =LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP |LVS_SINGLESEL |WS_CHILD | WS_VISIBLE;
 114
 115         if (! this->m_FileListCtrl.Create(dwStyle,rectDummy,&this->m_ctrlTabCtrl,0) )
 116         {
 117                 TRACE0("Failed to create output windows\n");
 118                 return FALSE;      // fail to create
 119         }
 120
 121         if( ! this->m_LogMessageCtrl.Create(_T("Scintilla"),_T("source"),0,rectDummy,&m_ctrlTabCtrl,0,0) )
 122         {
 123                 TRACE0("Failed to create log message control");
 124                 return FALSE;
 125         }
 126         m_LogMessageCtrl.Init(0);
 127
 128         dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
 129
 130         if (!m_wndOutputRebase.Create(_T("Scintilla"),_T("source"),0,rectDummy, &m_ctrlTabCtrl, 0,0) )
 131         {
 132                 TRACE0("Failed to create output windows\n");
 133                 return -1;      // fail to create
 134         }
 135         m_wndOutputRebase.Init(0);
 136         m_wndOutputRebase.Call(SCI_SETREADONLY, TRUE);
 137
 138         m_tooltips.Create(this);
 139
 140         m_tooltips.AddTool(IDC_REBASE_CHECK_FORCE,IDS_REBASE_FORCE_TT);
 141         m_tooltips.AddTool(IDC_REBASE_ABORT,IDS_REBASE_ABORT_TT);
 142
 143
 144
 145         m_FileListCtrl.Init(SVNSLC_COLEXT | SVNSLC_COLSTATUS |SVNSLC_COLADD|SVNSLC_COLDEL , _T("RebaseDlg"),(SVNSLC_POPALL ^ SVNSLC_POPCOMMIT),false);
 146
 147         m_ctrlTabCtrl.AddTab(&m_FileListCtrl,_T("Conflict File"));
 148         m_ctrlTabCtrl.AddTab(&m_LogMessageCtrl,_T("Commit Message"),1);
 149         m_ctrlTabCtrl.AddTab(&m_wndOutputRebase,_T("Log"),2);
 150         AddRebaseAnchor();
 151
 152
 153         EnableSaveRestore(_T("RebaseDlg"));
 154
 155         DWORD yPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RebaseDlgSizer"));
 156         RECT rcDlg, rcLogMsg, rcFileList;
 157         GetClientRect(&rcDlg);
 158         m_CommitList.GetWindowRect(&rcLogMsg);
 159         ScreenToClient(&rcLogMsg);
 160         this->m_ctrlTabCtrl.GetWindowRect(&rcFileList);
 161         ScreenToClient(&rcFileList);
 162         if (yPos)
 163         {
 164                 RECT rectSplitter;
 165                 m_wndSplitter.GetWindowRect(&rectSplitter);
 166                 ScreenToClient(&rectSplitter);
 167                 int delta = yPos - rectSplitter.top;
 168                 if ((rcLogMsg.bottom + delta > rcLogMsg.top)&&(rcLogMsg.bottom + delta < rcFileList.bottom - 30))
 169                 {
 170                         m_wndSplitter.SetWindowPos(NULL, 0, yPos, 0, 0, SWP_NOSIZE);
 171                         DoSize(delta);
 172                 }
 173         }
 174
 175         if( this->m_RebaseStage == CHOOSE_BRANCH)
 176         {
 177                 this->LoadBranchInfo();
 178
 179         }else
 180         {
 181                 this->m_BranchCtrl.EnableWindow(FALSE);
 182                 this->m_UpstreamCtrl.EnableWindow(FALSE);
 183         }
 184
 185         m_CommitList.m_IsIDReplaceAction = TRUE;
 186 //      m_CommitList.m_IsOldFirst = TRUE;
 187         m_CommitList.m_IsRebaseReplaceGraph = TRUE;
 188
 189         m_CommitList.InsertGitColumn();
 190
 191         this->SetControlEnable();
 192
 193         if(!this->m_PreCmd.IsEmpty())
 194         {
 195                 CProgressDlg progress;
 196                 progress.m_GitCmd=m_PreCmd;
 197                 progress.m_bAutoCloseOnSuccess=true;
 198                 progress.DoModal();
 199         }
 200
 201         if(m_IsCherryPick)
 202         {
 203                 this->m_BranchCtrl.SetCurSel(-1);
 204                 this->m_BranchCtrl.EnableWindow(FALSE);
 205                 this->m_UpstreamCtrl.EnableWindow(FALSE);
 206                 this->SetWindowText(_T("Cherry Pick"));
 207                 this->m_CommitList.StartFilter();
 208
 209         }else
 210         {
 211                 SetContinueButtonText();
 212                 m_CommitList.DeleteAllItems();
 213                 FetchLogList();
 214         }
 215
 216         m_CommitList.m_ContextMenuMask &= ~(m_CommitList.GetContextMenuBit(CGitLogListBase::ID_CHERRY_PICK)|
 217                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_SWITCHTOREV)|
 218                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_RESET)|
 219                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REVERTREV)|
 220                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_TO_VERSION)|
 221                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REVERTTOREV)|
 222                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_COMBINE_COMMIT));
 223
 224         if(m_CommitList.m_IsOldFirst)
 225                 this->m_CurrentRebaseIndex = -1;
 226         else
 227                 this->m_CurrentRebaseIndex = m_CommitList.m_logEntries.size();
 228
 229
 230         return TRUE;
 231 }
 232 // CRebaseDlg message handlers
 233
 234 void CRebaseDlg::OnBnClickedPickAll()
 235 {
 236     // TODO: Add your control notification handler code here
 237         this->UpdateData();
 238         if(this->m_bPickAll)
 239                 this->SetAllRebaseAction(CTGitPath::LOGACTIONS_REBASE_PICK);
 240
 241         this->m_bEditAll=FALSE;
 242         this->m_bSquashAll=FALSE;
 243         this->UpdateData(FALSE);
 244
 245 }
 246
 247 void CRebaseDlg::OnBnClickedSquashAll()
 248 {
 249     // TODO: Add your control notification handler code here
 250         this->UpdateData();
 251         if(this->m_bSquashAll)
 252                 this->SetAllRebaseAction(CTGitPath::LOGACTIONS_REBASE_SQUASH);
 253
 254         this->m_bEditAll=FALSE;
 255         this->m_bPickAll=FALSE;
 256         this->UpdateData(FALSE);
 257
 258 }
 259
 260 void CRebaseDlg::OnBnClickedEditAll()
 261 {
 262     // TODO: Add your control notification handler code here
 263         this->UpdateData();
 264         if( this->m_bEditAll )
 265                 this->SetAllRebaseAction(CTGitPath::LOGACTIONS_REBASE_EDIT);
 266
 267         this->m_bPickAll=FALSE;
 268         this->m_bSquashAll=FALSE;
 269         this->UpdateData(FALSE);
 270
 271 }
 272
 273 void CRebaseDlg::SetAllRebaseAction(int action)
 274 {
 275         for(int i=0;i<this->m_CommitList.m_logEntries.size();i++)
 276         {
 277                 m_CommitList.m_logEntries[i].m_Action=action;
 278         }
 279         m_CommitList.Invalidate();
 280 }
 281
 282 void CRebaseDlg::OnBnClickedRebaseSplit()
 283 {
 284         this->UpdateData();
 285     // TODO: Add your control notification handler code here
 286 }
 287
 288 LRESULT CRebaseDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
 289 {
 290         switch (message) {
 291         case WM_NOTIFY:
 292                 if (wParam == IDC_REBASE_SPLIT)
 293                 {
 294                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
 295                         DoSize(pHdr->delta);
 296                 }
 297                 break;
 298         }
 299
 300         return __super::DefWindowProc(message, wParam, lParam);
 301 }
 302
 303 void CRebaseDlg::DoSize(int delta)
 304 {
 305
 306         this->RemoveAllAnchors();
 307
 308         CSplitterControl::ChangeHeight(GetDlgItem(IDC_COMMIT_LIST), delta, CW_TOPALIGN);
 309         //CSplitterControl::ChangeHeight(GetDlgItem(), delta, CW_TOPALIGN);
 310         CSplitterControl::ChangeHeight(GetDlgItem(IDC_REBASE_TAB), -delta, CW_BOTTOMALIGN);
 311         //CSplitterControl::ChangeHeight(GetDlgItem(), -delta, CW_BOTTOMALIGN);
 312         CSplitterControl::ChangePos(GetDlgItem(IDC_SQUASH_ALL),0,delta);
 313         CSplitterControl::ChangePos(GetDlgItem(IDC_PICK_ALL),0,delta);
 314         CSplitterControl::ChangePos(GetDlgItem(IDC_EDIT_ALL),0,delta);
 315
 316         this->AddRebaseAnchor();
 317         // adjust the minimum size of the dialog to prevent the resizing from
 318         // moving the list control too far down.
 319         CRect rcLogMsg;
 320         m_CommitList.GetClientRect(rcLogMsg);
 321         SetMinTrackSize(CSize(m_DlgOrigRect.Width(), m_DlgOrigRect.Height()-m_CommitListOrigRect.Height()+rcLogMsg.Height()));
 322
 323         SetSplitterRange();
 324 //      m_CommitList.Invalidate();
 325
 326 //      GetDlgItem(IDC_LOGMESSAGE)->Invalidate();
 327
 328         this->m_ctrlTabCtrl.Invalidate();
 329         this->m_CommitList.Invalidate();
 330         this->m_FileListCtrl.Invalidate();
 331         this->m_LogMessageCtrl.Invalidate();
 332
 333 }
 334
 335 void CRebaseDlg::SetSplitterRange()
 336 {
 337         if ((m_CommitList)&&(m_ctrlTabCtrl))
 338         {
 339                 CRect rcTop;
 340                 m_CommitList.GetWindowRect(rcTop);
 341                 ScreenToClient(rcTop);
 342                 CRect rcMiddle;
 343                 m_ctrlTabCtrl.GetWindowRect(rcMiddle);
 344                 ScreenToClient(rcMiddle);
 345                 if (rcMiddle.Height() && rcMiddle.Width())
 346                         m_wndSplitter.SetRange(rcTop.top+60, rcMiddle.bottom-80);
 347         }
 348 }
 349
 350 void CRebaseDlg::OnSize(UINT nType,int cx, int cy)
 351 {
 352          // first, let the resizing take place
 353     __super::OnSize(nType, cx, cy);
 354
 355     //set range
 356     SetSplitterRange();
 357 }
 358
 359 void CRebaseDlg::SaveSplitterPos()
 360 {
 361         if (!IsIconic())
 362         {
 363                 CRegDWORD regPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RebaseDlgSizer"));
 364                 RECT rectSplitter;
 365                 m_wndSplitter.GetWindowRect(&rectSplitter);
 366                 ScreenToClient(&rectSplitter);
 367                 regPos = rectSplitter.top;
 368         }
 369 }
 370
 371 void CRebaseDlg::LoadBranchInfo()
 372 {
 373         m_BranchCtrl.SetMaxHistoryItems(0x7FFFFFFF);
 374         m_UpstreamCtrl.SetMaxHistoryItems(0x7FFFFFFF);
 375
 376         STRING_VECTOR list;
 377         list.clear();
 378         int current;
 379         g_Git.GetBranchList(list,&current,CGit::BRANCH_ALL);
 380         m_BranchCtrl.AddString(list);
 381         m_UpstreamCtrl.AddString(list);
 382
 383         m_BranchCtrl.SetCurSel(current);
 384
 385         AddBranchToolTips(&m_BranchCtrl);
 386         AddBranchToolTips(&m_UpstreamCtrl);
 387
 388         if(!m_Upstream.IsEmpty())
 389         {
 390                 m_UpstreamCtrl.AddString(m_Upstream);
 391                 m_UpstreamCtrl.SetCurSel(m_UpstreamCtrl.GetCount()-1);
 392         }
 393         else
 394         {
 395                 //Select pull-remote from current branch
 396                 CString currentBranch = g_Git.GetSymbolicRef();
 397                 CString configName;
 398                 configName.Format(L"branch.%s.remote", currentBranch);
 399                 CString pullRemote = g_Git.GetConfigValue(configName);
 400
 401                 //Select pull-branch from current branch
 402                 configName.Format(L"branch.%s.merge", currentBranch);
 403                 CString pullBranch = CGit::StripRefName(g_Git.GetConfigValue(configName));
 404
 405                 CString defaultUpstream;
 406                 defaultUpstream.Format(L"remotes/%s/%s", pullRemote, pullBranch);
 407                 int found = m_UpstreamCtrl.FindStringExact(0, defaultUpstream);
 408                 if(found >= 0)
 409                         m_UpstreamCtrl.SetCurSel(found);
 410         }
 411 }
 412
 413 void CRebaseDlg::OnCbnSelchangeBranch()
 414 {
 415         FetchLogList();
 416 }
 417
 418 void CRebaseDlg::OnCbnSelchangeUpstream()
 419 {
 420         FetchLogList();
 421 }
 422
 423 void CRebaseDlg::FetchLogList()
 424 {
 425         CString base,hash;
 426         CString cmd;
 427         m_IsFastForward=FALSE;
 428         cmd.Format(_T("git.exe merge-base %s %s"), m_UpstreamCtrl.GetString(),m_BranchCtrl.GetString());
 429         if(g_Git.Run(cmd,&base,CP_ACP))
 430         {
 431                 CMessageBox::Show(NULL,base,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 432                 return;
 433         }
 434         base=base.Left(40);
 435
 436         hash=g_Git.GetHash(m_BranchCtrl.GetString());
 437
 438         if(hash == g_Git.GetHash(this->m_UpstreamCtrl.GetString()))
 439         {
 440                 m_CommitList.Clear();
 441                 CString text,fmt;
 442                 fmt.LoadString(IDS_REBASE_EQUAL_FMT);
 443                 text.Format(fmt,m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString());
 444
 445                 m_CommitList.ShowText(text);
 446                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
 447                 return;
 448         }
 449
 450         hash=hash.Left(40);
 451
 452         if(hash == base )
 453         {
 454                 //fast forword
 455                 this->m_IsFastForward=TRUE;
 456
 457                 m_CommitList.Clear();
 458                 CString text,fmt;
 459                 fmt.LoadString(IDS_REBASE_FASTFORWARD_FMT);
 460                 text.Format(fmt,m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString(),
 461                                                 m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString());
 462
 463                 m_CommitList.ShowText(text);
 464                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(true);
 465                 SetContinueButtonText();
 466
 467                 return ;
 468         }
 469
 470         hash.Empty();
 471
 472         if(!this->m_bForce)
 473         {
 474                 cmd.Format(_T("git.exe rev-parse %s"), m_UpstreamCtrl.GetString());
 475                 if( g_Git.Run(cmd,&hash,CP_ACP))
 476                 {
 477                         CMessageBox::Show(NULL,base,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 478                         return;
 479                 }
 480                 hash=hash.Left(40);
 481
 482                 if( base == hash )
 483                 {
 484                         m_CommitList.Clear();
 485                         CString text,fmt;
 486                         fmt.LoadString(IDS_REBASE_UPTODATE_FMT);
 487                         text.Format(fmt,m_BranchCtrl.GetString());
 488                         m_CommitList.ShowText(text);
 489                         this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(m_CommitList.GetItemCount());
 490                         SetContinueButtonText();
 491                         return;
 492                 }
 493         }
 494
 495         m_CommitList.Clear();
 496         this->m_CommitList.FillGitLog(NULL,0,&m_UpstreamCtrl.GetString(),&m_BranchCtrl.GetString());
 497         if( m_CommitList.GetItemCount() == 0 )
 498                 m_CommitList.ShowText(_T("Nothing to Rebase"));
 499
 500         hash=g_Git.GetHash(m_UpstreamCtrl.GetString());
 501
 502 #if 0
 503         if(m_CommitList.m_logEntries[m_CommitList.m_logEntries.size()-1].m_ParentHash.size() >=0 )
 504         {
 505                 if(hash ==  m_CommitList.m_logEntries[m_CommitList.m_logEntries.size()-1].m_ParentHash[0])
 506                 {
 507                         m_CommitList.Clear();
 508                         m_CommitList.ShowText(_T("Nothing Rebase"));
 509                 }
 510         }
 511 #endif
 512
 513         m_tooltips.Pop();
 514         AddBranchToolTips(&this->m_BranchCtrl);
 515         AddBranchToolTips(&this->m_UpstreamCtrl);
 516
 517         for(int i=0;i<m_CommitList.m_logEntries.size();i++)
 518         {
 519                 m_CommitList.m_logEntries[i].m_Action = CTGitPath::LOGACTIONS_REBASE_PICK;
 520         }
 521
 522         m_CommitList.Invalidate();
 523
 524         if(m_CommitList.m_IsOldFirst)
 525                 this->m_CurrentRebaseIndex = -1;
 526         else
 527                 this->m_CurrentRebaseIndex = m_CommitList.m_logEntries.size();
 528
 529         this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(m_CommitList.GetItemCount());
 530         SetContinueButtonText();
 531 }
 532
 533 void CRebaseDlg::AddBranchToolTips(CHistoryCombo *pBranch)
 534 {
 535         if(pBranch)
 536         {
 537                 CString text=pBranch->GetString();
 538                 CString tooltip;
 539                 BYTE_VECTOR data;
 540                 g_Git.GetLog(data,text,NULL,1,0);
 541                 GitRev rev;
 542                 rev.ParserFromLog(data);
 543                 tooltip.Format(_T("CommitHash:%s\nCommit by: %s  %s\n <b>%s</b> \n %s"),
 544                         rev.m_CommitHash,
 545                         rev.m_AuthorName,
 546                         CAppUtils::FormatDateAndTime(rev.m_AuthorDate,DATE_LONGDATE),
 547                         rev.m_Subject,
 548                         rev.m_Body);
 549
 550                 pBranch->DisableTooltip();
 551                 this->m_tooltips.AddTool(pBranch->GetComboBoxCtrl(),tooltip);
 552         }
 553 }
 554
 555 BOOL CRebaseDlg::PreTranslateMessage(MSG*pMsg)
 556 {
 557         m_tooltips.RelayEvent(pMsg);
 558         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
 559 }
 560 int CRebaseDlg::CheckRebaseCondition()
 561 {
 562         this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 563
 564         if( !g_Git.CheckCleanWorkTree()  )
 565         {
 566                 CMessageBox::Show(NULL,_T("Rebase Need Clean Working Tree"),_T("TortoiseGit"),MB_OK);
 567                 return -1;
 568         }
 569         //Todo Check $REBASE_ROOT
 570         //Todo Check $DOTEST
 571
 572         CString cmd;
 573         cmd=_T("git.exe var GIT_COMMITTER_IDENT");
 574         if(g_Git.Run(cmd,NULL,CP_UTF8))
 575                 return -1;
 576
 577         //Todo call pre_rebase_hook
 578         return 0;
 579 }
 580 int CRebaseDlg::StartRebase()
 581 {
 582         CString cmd,out;
 583
 584         if(!this->m_IsCherryPick)
 585         {
 586                 //Todo call comment_for_reflog
 587                 cmd.Format(_T("git.exe checkout %s"),this->m_BranchCtrl.GetString());
 588                 this->AddLogString(cmd);
 589
 590                 if(g_Git.Run(cmd,&out,CP_UTF8))
 591                         return -1;
 592
 593                 this->AddLogString(out);
 594         }
 595
 596         cmd=_T("git.exe rev-parse --verify HEAD");
 597         if(g_Git.Run(cmd,&out,CP_UTF8))
 598         {
 599                 AddLogString(_T("No Head"));
 600                 return -1;
 601         }
 602         //Todo
 603         //git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
 604         //              echo "detached HEAD" > "$DOTEST"/head-name
 605
 606         cmd.Format(_T("git.exe update-ref ORIG_HEAD HEAD"));
 607         if(g_Git.Run(cmd,&out,CP_UTF8))
 608         {
 609                 AddLogString(_T("update ORIG_HEAD Fail"));
 610                 return -1;
 611         }
 612
 613         if( !this->m_IsCherryPick )
 614         {
 615                 cmd.Format(_T("git.exe checkout %s"),this->m_UpstreamCtrl.GetString());
 616                 this->AddLogString(cmd);
 617
 618                 out.Empty();
 619                 if(g_Git.Run(cmd,&out,CP_UTF8))
 620                 {
 621                         return -1;
 622                 }
 623         }
 624
 625         m_OrigUpstreamHash.Empty();
 626         m_OrigUpstreamHash= g_Git.GetHash(this->m_UpstreamCtrl.GetString());
 627         if(m_OrigUpstreamHash.IsEmpty())
 628         {
 629                 this->AddLogString(m_OrigUpstreamHash);
 630                 return -1;
 631         }
 632
 633         if( !this->m_IsCherryPick )
 634         {
 635                 cmd.Format(_T("git.exe rev-parse %s"),this->m_BranchCtrl.GetString());
 636                 if(g_Git.Run(cmd,&this->m_OrigBranchHash,CP_UTF8))
 637                 {
 638                         this->AddLogString(m_OrigBranchHash);
 639                         return -1;
 640                 }
 641                 this->AddLogString(_T("Start Rebase\r\n"));
 642
 643         }else
 644                 this->AddLogString(_T("Start Cherry-pick\r\n"));
 645
 646         return 0;
 647 }
 648 int  CRebaseDlg::VerifyNoConflict()
 649 {
 650         CTGitPathList list;
 651         if(g_Git.ListConflictFile(list))
 652         {
 653                 AddLogString(_T("Get conflict files fail"));
 654                 return -1;
 655         }
 656         if( list.GetCount() != 0 )
 657         {
 658                 CMessageBox::Show(NULL,_T("There are conflict file, you should mark it resolve"),_T("TortoiseGit"),MB_OK);
 659                 return -1;
 660         }
 661         return 0;
 662
 663 }
 664 int CRebaseDlg::FinishRebase()
 665 {
 666         if(this->m_IsCherryPick) //cherry pick mode no "branch", working at upstream branch
 667                 return 0;
 668
 669         CString cmd,out;
 670         cmd.Format(_T("git.exe branch -f %s"),this->m_BranchCtrl.GetString());
 671         if(g_Git.Run(cmd,&out,CP_UTF8))
 672         {
 673                 AddLogString(out);
 674                 return -1;
 675         }
 676         out.Empty();
 677         cmd.Format(_T("git.exe reset --hard %s"),this->m_OrigUpstreamHash);
 678         if(g_Git.Run(cmd,&out,CP_UTF8))
 679         {
 680                 AddLogString(out);
 681                 return -1;
 682         }
 683         out.Empty();
 684         cmd.Format(_T("git.exe checkout -f %s"),this->m_BranchCtrl.GetString());
 685         if(g_Git.Run(cmd,&out,CP_UTF8))
 686         {
 687                 AddLogString(out);
 688                 return -1;
 689         }
 690         return 0;
 691 }
 692 void CRebaseDlg::OnBnClickedContinue()
 693 {
 694         if( m_RebaseStage == REBASE_DONE)
 695         {
 696                 OnOK();
 697                 return;
 698         }
 699
 700         if( this->m_IsFastForward )
 701         {
 702                 CString cmd,out;
 703                 CString oldbranch = g_Git.GetCurrentBranch();
 704                 if( oldbranch != m_BranchCtrl.GetString() )
 705                 {
 706                         cmd.Format(_T("git.exe checkout %s"),m_BranchCtrl.GetString());
 707                         AddLogString(cmd);
 708                         if( g_Git.Run(cmd,&out,CP_ACP) )
 709                         {
 710                                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 711                                 AddLogString(out);
 712                                 return;
 713                         }
 714                 }
 715                 AddLogString(out);
 716                 out.Empty();
 717                 m_OrigBranchHash = g_Git.GetHash(m_BranchCtrl.GetString());
 718                 m_OrigUpstreamHash = g_Git.GetHash(this->m_UpstreamCtrl.GetString());
 719
 720                 if(!g_Git.IsFastForward(this->m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString()))
 721                 {
 722                         this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 723                         AddLogString(_T("No fast forward\r\nMaybe repository changed"));
 724                         return;
 725                 }
 726
 727                 cmd.Format(_T("git.exe reset --hard %s"),this->m_UpstreamCtrl.GetString());
 728                 this->AddLogString(CString(_T("Fast forward to "))+m_UpstreamCtrl.GetString());
 729
 730                 AddLogString(cmd);
 731                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 732                 if(g_Git.Run(cmd,&out,CP_ACP))
 733                 {
 734                         AddLogString(_T("Fail"));
 735                         AddLogString(out);
 736                         return;
 737                 }
 738                 AddLogString(out);
 739                 AddLogString(_T("Done"));
 740                 m_RebaseStage = REBASE_DONE;
 741                 UpdateCurrentStatus();
 742                 return;
 743
 744         }
 745         if( m_RebaseStage == CHOOSE_BRANCH|| m_RebaseStage == CHOOSE_COMMIT_PICK_MODE )
 746         {
 747                 if(CheckRebaseCondition())
 748                         return ;
 749                 m_RebaseStage = REBASE_START;
 750         }
 751
 752
 753         if( m_RebaseStage == REBASE_FINISH )
 754         {
 755                 if(FinishRebase())
 756                         return ;
 757
 758                 OnOK();
 759         }
 760
 761         if( m_RebaseStage == REBASE_SQUASH_CONFLICT)
 762         {
 763                 if(VerifyNoConflict())
 764                         return;
 765                 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
 766                 if(this->CheckNextCommitIsSquash())
 767                 {//next commit is not squash;
 768                         m_RebaseStage = REBASE_SQUASH_EDIT;
 769                         this->OnRebaseUpdateUI(0,0);
 770                         this->UpdateCurrentStatus();
 771                         return ;
 772
 773                 }
 774                 m_RebaseStage=REBASE_CONTINUE;
 775                 curRev->m_Action|=CTGitPath::LOGACTIONS_REBASE_DONE;
 776                 this->UpdateCurrentStatus();
 777
 778         }
 779
 780         if( m_RebaseStage == REBASE_CONFLICT )
 781         {
 782                 if(VerifyNoConflict())
 783                         return;
 784
 785                 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
 786
 787                 CString out =_T("");
 788                 CString cmd;
 789                 cmd.Format(_T("git.exe commit -C %s"), curRev->m_CommitHash);
 790
 791                 if(g_Git.Run(cmd,&out,CP_UTF8))
 792                 {
 793                         if(!g_Git.CheckCleanWorkTree())
 794                         {
 795                                 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 796                                 return;
 797                         }
 798                 }
 799
 800                 AddLogString(out);
 801                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 802                 if( curRev->m_Action & CTGitPath::LOGACTIONS_REBASE_EDIT)
 803                 {
 804                         m_RebaseStage=REBASE_EDIT;
 805                         this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
 806                         this->UpdateCurrentStatus();
 807                         return;
 808                 }
 809                 else
 810                 {
 811                         m_RebaseStage=REBASE_CONTINUE;
 812                         curRev->m_Action|=CTGitPath::LOGACTIONS_REBASE_DONE;
 813                         this->UpdateCurrentStatus();
 814                 }
 815
 816         }
 817
 818         if( m_RebaseStage == REBASE_EDIT ||  m_RebaseStage == REBASE_SQUASH_EDIT )
 819         {
 820                 CString str;
 821                 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
 822
 823                 str=this->m_LogMessageCtrl.GetText();
 824                 if(str.Trim().IsEmpty())
 825                 {
 826                         CMessageBox::Show(NULL,_T("Commit Message Is Empty"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 827                                 return;
 828                 }
 829
 830                 CString tempfile=::GetTempFile();
 831                 CFile file(tempfile,CFile::modeReadWrite|CFile::modeCreate );
 832                 CStringA log=CUnicodeUtils::GetUTF8( str);
 833                 file.Write(log,log.GetLength());
 834                 //file.WriteString(m_sLogMessage);
 835                 file.Close();
 836
 837                 CString out,cmd;
 838
 839                 if(  m_RebaseStage == REBASE_SQUASH_EDIT )
 840                         cmd.Format(_T("git.exe commit -F \"%s\""), tempfile);
 841                 else
 842                         cmd.Format(_T("git.exe commit --amend -F \"%s\""), tempfile);
 843
 844                 if(g_Git.Run(cmd,&out,CP_UTF8))
 845                 {
 846                         if(!g_Git.CheckCleanWorkTree())
 847                         {
 848                                 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 849                                 return;
 850                         }
 851                 }
 852
 853                 CFile::Remove(tempfile);
 854                 AddLogString(out);
 855                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 856                 m_RebaseStage=REBASE_CONTINUE;
 857                 curRev->m_Action|=CTGitPath::LOGACTIONS_REBASE_DONE;
 858                 this->UpdateCurrentStatus();
 859         }
 860
 861
 862         InterlockedExchange(&m_bThreadRunning, TRUE);
 863         SetControlEnable();
 864
 865         if (AfxBeginThread(RebaseThreadEntry, this)==NULL)
 866         {
 867                 InterlockedExchange(&m_bThreadRunning, FALSE);
 868                 CMessageBox::Show(NULL, _T("Create Rebase Thread Fail"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 869                 SetControlEnable();
 870         }
 871 }
 872 int CRebaseDlg::CheckNextCommitIsSquash()
 873 {
 874         int index;
 875         if(m_CommitList.m_IsOldFirst)
 876                 index=m_CurrentRebaseIndex+1;
 877         else
 878                 index=m_CurrentRebaseIndex-1;
 879
 880         GitRev *curRev;
 881         do
 882         {
 883                 if(index<0)
 884                         return -1;
 885                 if(index>= m_CommitList.GetItemCount())
 886                         return -1;
 887
 888                 curRev=(GitRev*)m_CommitList.m_arShownList[index];
 889
 890                 if( curRev->m_Action&CTGitPath::LOGACTIONS_REBASE_SQUASH )
 891                         return 0;
 892                 if( curRev->m_Action&CTGitPath::LOGACTIONS_REBASE_SKIP)
 893                 {
 894                         if(m_CommitList.m_IsOldFirst)
 895                                 index++;
 896                         else
 897                                 index--;
 898                 }else
 899                         return -1;
 900
 901         }while(curRev->m_Action&CTGitPath::LOGACTIONS_REBASE_SKIP);
 902
 903         return -1;
 904
 905 }
 906 int CRebaseDlg::GoNext()
 907 {
 908         if(m_CommitList.m_IsOldFirst)
 909                 m_CurrentRebaseIndex++;
 910         else
 911                 m_CurrentRebaseIndex--;
 912         return 0;
 913
 914 }
 915 int CRebaseDlg::StateAction()
 916 {
 917         switch(this->m_RebaseStage)
 918         {
 919         case CHOOSE_BRANCH:
 920         case CHOOSE_COMMIT_PICK_MODE:
 921                 if(StartRebase())
 922                         return -1;
 923                 m_RebaseStage = REBASE_START;
 924                 GoNext();
 925                 break;
 926         }
 927
 928         return 0;
 929 }
 930 void CRebaseDlg::SetContinueButtonText()
 931 {
 932         CString Text;
 933         switch(this->m_RebaseStage)
 934         {
 935         case CHOOSE_BRANCH:
 936         case CHOOSE_COMMIT_PICK_MODE:
 937                 if(this->m_IsFastForward)
 938                         Text = _T("Start(FastFwd)");
 939                 else
 940                         Text = _T("Start");
 941                 break;
 942
 943         case REBASE_START:
 944         case REBASE_CONTINUE:
 945         case REBASE_SQUASH_CONFLICT:
 946                 Text = _T("Continue");
 947                 break;
 948
 949         case REBASE_CONFLICT:
 950                 Text = _T("Commit");
 951                 break;
 952         case REBASE_EDIT:
 953                 Text = _T("Amend");
 954                 break;
 955
 956         case REBASE_SQUASH_EDIT:
 957                 Text = _T("Commit");
 958                 break;
 959
 960         case REBASE_ABORT:
 961         case REBASE_FINISH:
 962                 Text = _T("Finish");
 963                 break;
 964
 965         case REBASE_DONE:
 966                 Text = _T("Done");
 967                 break;
 968         }
 969         this->GetDlgItem(IDC_REBASE_CONTINUE)->SetWindowText(Text);
 970 }
 971
 972 void CRebaseDlg::SetControlEnable()
 973 {
 974         switch(this->m_RebaseStage)
 975         {
 976         case CHOOSE_BRANCH:
 977         case CHOOSE_COMMIT_PICK_MODE:
 978
 979                 this->GetDlgItem(IDC_PICK_ALL)->EnableWindow(TRUE);
 980                 this->GetDlgItem(IDC_EDIT_ALL)->EnableWindow(TRUE);
 981                 this->GetDlgItem(IDC_SQUASH_ALL)->EnableWindow(TRUE);
 982                 if(!m_IsCherryPick)
 983                 {
 984                         this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(TRUE);
 985                         this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(TRUE);
 986                 }
 987                 //this->m_CommitList.m_IsEnableRebaseMenu=TRUE;
 988                 this->m_CommitList.m_ContextMenuMask |= m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_PICK)|
 989                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SQUASH)|
 990                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_EDIT)|
 991                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SKIP);
 992                 break;
 993
 994         case REBASE_START:
 995         case REBASE_CONTINUE:
 996         case REBASE_ABORT:
 997         case REBASE_FINISH:
 998         case REBASE_CONFLICT:
 999         case REBASE_EDIT:
1000         case REBASE_SQUASH_CONFLICT:
1001         case REBASE_DONE:
1002                 this->GetDlgItem(IDC_PICK_ALL)->EnableWindow(FALSE);
1003                 this->GetDlgItem(IDC_EDIT_ALL)->EnableWindow(FALSE);
1004                 this->GetDlgItem(IDC_SQUASH_ALL)->EnableWindow(FALSE);
1005                 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(FALSE);
1006                 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(FALSE);
1007                 //this->m_CommitList.m_IsEnableRebaseMenu=FALSE;
1008                 this->m_CommitList.m_ContextMenuMask &= ~(m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_PICK)|
1009                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SQUASH)|
1010                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_EDIT)|
1011                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SKIP));
1012
1013                 if( m_RebaseStage == REBASE_DONE && (!this->m_PostButtonText.IsEmpty()) )
1014                 {
1015                         this->GetDlgItem(IDC_STATUS_STATIC)->ShowWindow(SW_HIDE);
1016                         this->GetDlgItem(IDC_REBASE_POST_BUTTON)->ShowWindow(SW_SHOWNORMAL);
1017                         this->GetDlgItem(IDC_REBASE_POST_BUTTON)->SetWindowText(this->m_PostButtonText);
1018                 }
1019                 break;
1020         }
1021
1022         if(m_bThreadRunning)
1023         {
1024                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1025                 this->GetDlgItem(IDC_REBASE_ABORT)->EnableWindow(FALSE);
1026
1027         }else
1028         {
1029                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1030                 this->GetDlgItem(IDC_REBASE_ABORT)->EnableWindow(TRUE);
1031         }
1032 }
1033
1034 void CRebaseDlg::UpdateProgress()
1035 {
1036         int index;
1037         CRect rect;
1038
1039         if(m_CommitList.m_IsOldFirst)
1040                 index = m_CurrentRebaseIndex+1;
1041         else
1042                 index = m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1043
1044         m_ProgressBar.SetRange(1,m_CommitList.GetItemCount());
1045         m_ProgressBar.SetPos(index);
1046
1047         if(m_CurrentRebaseIndex>=0 && m_CurrentRebaseIndex< m_CommitList.GetItemCount())
1048         {
1049                 CString text;
1050                 text.Format(_T("Rebasing...(%d/%d)"),index,m_CommitList.GetItemCount());
1051                 m_CtrlStatusText.SetWindowText(text);
1052
1053         }
1054
1055         GitRev *prevRev=NULL, *curRev=NULL;
1056
1057         if( m_CurrentRebaseIndex >= 0 && m_CurrentRebaseIndex< m_CommitList.m_arShownList.GetSize())
1058         {
1059                 curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1060         }
1061
1062         for(int i=0;i<m_CommitList.m_arShownList.GetSize();i++)
1063         {
1064                 prevRev=(GitRev*)m_CommitList.m_arShownList[i];
1065                 if(prevRev->m_Action & CTGitPath::LOGACTIONS_REBASE_CURRENT)
1066                 {
1067                         prevRev->m_Action &= ~ CTGitPath::LOGACTIONS_REBASE_CURRENT;
1068                         m_CommitList.GetItemRect(i,&rect,LVIR_BOUNDS);
1069                         m_CommitList.InvalidateRect(rect);
1070                 }
1071         }
1072
1073         if(curRev)
1074         {
1075                 curRev->m_Action |= CTGitPath::LOGACTIONS_REBASE_CURRENT;
1076                 m_CommitList.GetItemRect(m_CurrentRebaseIndex,&rect,LVIR_BOUNDS);
1077                 m_CommitList.InvalidateRect(rect);
1078         }
1079         m_CommitList.EnsureVisible(m_CurrentRebaseIndex,FALSE);
1080
1081 }
1082
1083 void CRebaseDlg::UpdateCurrentStatus()
1084 {
1085         if( m_CurrentRebaseIndex < 0 && m_RebaseStage!= REBASE_DONE)
1086         {
1087                 if(m_CommitList.m_IsOldFirst)
1088                         m_RebaseStage = CRebaseDlg::REBASE_START;
1089                 else
1090                         m_RebaseStage = CRebaseDlg::REBASE_FINISH;
1091         }
1092
1093         if( m_CurrentRebaseIndex == m_CommitList.m_arShownList.GetSize() && m_RebaseStage!= REBASE_DONE)
1094         {
1095                 if(m_CommitList.m_IsOldFirst)
1096                         m_RebaseStage = CRebaseDlg::REBASE_DONE;
1097                 else
1098                         m_RebaseStage = CRebaseDlg::REBASE_FINISH;
1099         }
1100
1101         SetContinueButtonText();
1102         SetControlEnable();
1103         UpdateProgress();
1104 }
1105
1106 void CRebaseDlg::AddLogString(CString str)
1107 {
1108         this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, FALSE);
1109         CStringA sTextA = m_wndOutputRebase.StringForControl(str);//CUnicodeUtils::GetUTF8(str);
1110         this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)sTextA);
1111         this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)"\n");
1112         this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, TRUE);
1113 }
1114
1115 int CRebaseDlg::GetCurrentCommitID()
1116 {
1117         if(m_CommitList.m_IsOldFirst)
1118         {
1119                 return this->m_CurrentRebaseIndex+1;
1120
1121         }else
1122         {
1123                 return m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1124         }
1125 }
1126
1127 int CRebaseDlg::DoRebase()
1128 {
1129         CString cmd,out;
1130         if(m_CurrentRebaseIndex <0)
1131                 return 0;
1132         if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1133                 return 0;
1134
1135         GitRev *pRev = (GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1136         int mode=pRev->m_Action & CTGitPath::LOGACTIONS_REBASE_MODE_MASK;
1137         CString nocommit;
1138
1139         if( mode== CTGitPath::LOGACTIONS_REBASE_SKIP)
1140         {
1141                 pRev->m_Action|= CTGitPath::LOGACTIONS_REBASE_DONE;
1142                 return 0;
1143         }
1144
1145         if( mode != CTGitPath::LOGACTIONS_REBASE_PICK )
1146         {
1147                 this->m_SquashMessage+= pRev->m_Subject;
1148                 this->m_SquashMessage+= _T("\n");
1149                 this->m_SquashMessage+= pRev->m_Body;
1150         }
1151         else
1152                 this->m_SquashMessage.Empty();
1153
1154         if(mode == CTGitPath::LOGACTIONS_REBASE_SQUASH)
1155                 nocommit=_T(" --no-commit ");
1156
1157         CString log;
1158         log.Format(_T("%s %d:%s"),CTGitPath::GetActionName(mode),this->GetCurrentCommitID(),pRev->m_CommitHash);
1159         AddLogString(log);
1160         AddLogString(pRev->m_Subject);
1161         cmd.Format(_T("git.exe cherry-pick %s %s"),nocommit,pRev->m_CommitHash);
1162
1163         if(g_Git.Run(cmd,&out,CP_UTF8))
1164         {
1165                 AddLogString(out);
1166                 CTGitPathList list;
1167                 if(g_Git.ListConflictFile(list))
1168                 {
1169                         AddLogString(_T("Get conflict files fail"));
1170                         return -1;
1171                 }
1172                 if(list.GetCount() == 0 )
1173                 {
1174                         if(mode ==  CTGitPath::LOGACTIONS_REBASE_PICK)
1175                         {
1176                                 pRev->m_Action|= CTGitPath::LOGACTIONS_REBASE_DONE;
1177                                 return 0;
1178                         }
1179                         if(mode == CTGitPath::LOGACTIONS_REBASE_EDIT)
1180                         {
1181                                 this->m_RebaseStage = REBASE_EDIT ;
1182                                 return -1; // Edit return -1 to stop rebase.
1183                         }
1184                         // Squash Case
1185                         if(CheckNextCommitIsSquash())
1186                         {   // no squash
1187                                 // let user edit last commmit message
1188                                 this->m_RebaseStage = REBASE_SQUASH_EDIT;
1189                                 return -1;
1190                         }
1191                 }
1192                 if(mode == CTGitPath::LOGACTIONS_REBASE_SQUASH)
1193                         m_RebaseStage = REBASE_SQUASH_CONFLICT;
1194                 else
1195                         m_RebaseStage = REBASE_CONFLICT;
1196                 return -1;
1197
1198         }else
1199         {
1200                 AddLogString(out);
1201                 if(mode ==  CTGitPath::LOGACTIONS_REBASE_PICK)
1202                 {
1203                         pRev->m_Action|= CTGitPath::LOGACTIONS_REBASE_DONE;
1204                         return 0;
1205                 }
1206                 if(mode == CTGitPath::LOGACTIONS_REBASE_EDIT)
1207                 {
1208                         this->m_RebaseStage = REBASE_EDIT ;
1209                         return -1; // Edit return -1 to stop rebase.
1210                 }
1211
1212                 // Squash Case
1213                 if(CheckNextCommitIsSquash())
1214                 {   // no squash
1215                         // let user edit last commmit message
1216                         this->m_RebaseStage = REBASE_SQUASH_EDIT;
1217                         return -1;
1218                 }
1219         }
1220
1221         return 0;
1222 }
1223
1224 BOOL CRebaseDlg::IsEnd()
1225 {
1226         if(m_CommitList.m_IsOldFirst)
1227                 return m_CurrentRebaseIndex>= this->m_CommitList.GetItemCount();
1228         else
1229                 return m_CurrentRebaseIndex<0;
1230 }
1231
1232 int CRebaseDlg::RebaseThread()
1233 {
1234         int ret=0;
1235         while(1)
1236         {
1237                 if( m_RebaseStage == REBASE_START )
1238                 {
1239                         if( this->StartRebase() )
1240                         {
1241                                 InterlockedExchange(&m_bThreadRunning, FALSE);
1242                                 ret = -1;
1243                                 break;
1244                         }
1245                         m_RebaseStage = REBASE_CONTINUE;
1246
1247                 }else if( m_RebaseStage == REBASE_CONTINUE )
1248                 {
1249                         this->GoNext();
1250                         if(IsEnd())
1251                         {
1252                                 ret = 0;
1253                                 m_RebaseStage = REBASE_FINISH;
1254
1255                         }else
1256                         {
1257                                 ret = DoRebase();
1258
1259                                 if( ret )
1260                                 {
1261                                         break;
1262                                 }
1263                         }
1264
1265                 }else if( m_RebaseStage == REBASE_FINISH )
1266                 {
1267                         FinishRebase();
1268                         m_RebaseStage = REBASE_DONE;
1269                         break;
1270
1271                 }else
1272                 {
1273                         break;
1274                 }
1275                 this->PostMessage(MSG_REBASE_UPDATE_UI);
1276                 //this->UpdateCurrentStatus();
1277         }
1278
1279         InterlockedExchange(&m_bThreadRunning, FALSE);
1280         this->PostMessage(MSG_REBASE_UPDATE_UI);
1281         return ret;
1282 }
1283
1284 void CRebaseDlg::ListConflictFile()
1285 {
1286         this->m_FileListCtrl.Clear();
1287         CTGitPathList list;
1288         CTGitPath path;
1289         list.AddPath(path);
1290
1291         this->m_FileListCtrl.GetStatus(&list,true);
1292         this->m_FileListCtrl.Show(CTGitPath::LOGACTIONS_UNMERGED|CTGitPath::LOGACTIONS_MODIFIED|CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_DELETED,
1293                                                            CTGitPath::LOGACTIONS_UNMERGED);
1294         if( this->m_FileListCtrl.GetItemCount() == 0 )
1295         {
1296
1297         }
1298 }
1299
1300 LRESULT CRebaseDlg::OnRebaseUpdateUI(WPARAM,LPARAM)
1301 {
1302         UpdateCurrentStatus();
1303         if(m_CurrentRebaseIndex <0)
1304                 return 0;
1305         if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1306                 return 0;
1307         GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1308
1309         switch(m_RebaseStage)
1310         {
1311         case REBASE_CONFLICT:
1312         case REBASE_SQUASH_CONFLICT:
1313                 ListConflictFile();
1314                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_CONFLICT);
1315                 this->m_LogMessageCtrl.SetText(curRev->m_Subject+_T("\n")+curRev->m_Body);
1316                 break;
1317         case REBASE_EDIT:
1318                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1319                 this->m_LogMessageCtrl.SetText(curRev->m_Subject+_T("\n")+curRev->m_Body);
1320                 break;
1321         case REBASE_SQUASH_EDIT:
1322                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1323                 this->m_LogMessageCtrl.SetText(this->m_SquashMessage);
1324                 break;
1325         default:
1326                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1327         }
1328         return 0;
1329 }
1330 void CRebaseDlg::OnCancel()
1331 {
1332         OnBnClickedAbort();
1333 }
1334 void CRebaseDlg::OnBnClickedAbort()
1335 {
1336         CString cmd,out;
1337         if(m_OrigUpstreamHash.IsEmpty())
1338         {
1339                 __super::OnCancel();
1340         }
1341
1342         if(m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage== CHOOSE_COMMIT_PICK_MODE)
1343         {
1344                 return;
1345         }
1346
1347         if(CMessageBox::Show(NULL,_T("Are you sure you want to abort the rebase process?"),_T("TortoiseGit"),MB_YESNO) != IDYES)
1348                 return;
1349
1350         if(this->m_IsFastForward)
1351         {
1352                 cmd.Format(_T("git.exe reset --hard  %s"),this->m_OrigBranchHash.Left(40));
1353                 if(g_Git.Run(cmd,&out,CP_UTF8))
1354                 {
1355                         AddLogString(out);
1356                         return ;
1357                 }
1358                 __super::OnCancel();
1359                 return;
1360         }
1361         cmd.Format(_T("git.exe checkout -f %s"),this->m_UpstreamCtrl.GetString());
1362         if(g_Git.Run(cmd,&out,CP_UTF8))
1363         {
1364                 AddLogString(out);
1365                 return ;
1366         }
1367
1368         cmd.Format(_T("git.exe reset --hard  %s"),this->m_OrigUpstreamHash.Left(40));
1369         if(g_Git.Run(cmd,&out,CP_UTF8))
1370         {
1371                 AddLogString(out);
1372                 return ;
1373         }
1374
1375         if(this->m_IsCherryPick) //there are not "branch" at cherry pick mode
1376                 return;
1377
1378         cmd.Format(_T("git checkout -f %s"),this->m_BranchCtrl.GetString());
1379         if(g_Git.Run(cmd,&out,CP_UTF8))
1380         {
1381                 AddLogString(out);
1382                 return ;
1383         }
1384
1385         cmd.Format(_T("git.exe reset --hard  %s"),this->m_OrigBranchHash.Left(40));
1386         if(g_Git.Run(cmd,&out,CP_UTF8))
1387         {
1388                 AddLogString(out);
1389                 return ;
1390         }
1391         __super::OnCancel();
1392 }
1393
1394 void CRebaseDlg::OnBnClickedButtonBrowse()
1395 {
1396         if(CBrowseRefsDlg::PickRefForCombo(&m_UpstreamCtrl, gPickRef_NoTag))
1397                 OnCbnSelchangeUpstream();
1398 }
1399
1400 void CRebaseDlg::OnBnClickedRebaseCheckForce()
1401 {
1402         // TODO: Add your control notification handler code here
1403         this->UpdateData();
1404         this->FetchLogList();
1405 }
1406
1407 void CRebaseDlg::OnStnClickedStatusStatic()
1408 {
1409         // TODO: Add your control notification handler code here
1410 }
1411
1412 void CRebaseDlg::OnBnClickedRebasePostButton()
1413 {
1414         // TODO: Add your control notification handler code here
1415         this->m_Upstream=this->m_UpstreamCtrl.GetString();
1416         this->m_Branch=this->m_BranchCtrl.GetString();
1417
1418         this->EndDialog(IDC_REBASE_POST_BUTTON);
1419 }