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