src/TortoiseProc/RebaseDlg.cpp

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