src/TortoiseProc/RebaseDlg.cpp

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