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