src/TortoiseProc/RebaseDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2013 - TortoiseGit
   4 // Copyright (C) 2011-2013 - 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 "LoglistUtils.h"
  29 #include "MessageBox.h"
  30 #include "UnicodeUtils.h"
  31 #include "BrowseRefsDlg.h"
  32 #include "ProgressDlg.h"
  33 #include "SmartHandle.h"
  34 #include "../TGitCache/CacheInterface.h"
  35 #include "Settings\Settings.h"
  36 #include "MassiveGitTask.h"
  37
  38 // CRebaseDlg dialog
  39
  40 IMPLEMENT_DYNAMIC(CRebaseDlg, CResizableStandAloneDialog)
  41
  42 CRebaseDlg::CRebaseDlg(CWnd* pParent /*=NULL*/)
  43         : CResizableStandAloneDialog(CRebaseDlg::IDD, pParent)
  44         , m_bPickAll(FALSE)
  45         , m_bSquashAll(FALSE)
  46         , m_bEditAll(FALSE)
  47         , m_bAddCherryPickedFrom(FALSE)
  48 {
  49         m_RebaseStage=CHOOSE_BRANCH;
  50         m_CurrentRebaseIndex=-1;
  51         m_bThreadRunning =FALSE;
  52         this->m_IsCherryPick = FALSE;
  53         m_bForce=FALSE;
  54         m_IsFastForward=FALSE;
  55 }
  56
  57 CRebaseDlg::~CRebaseDlg()
  58 {
  59 }
  60
  61 void CRebaseDlg::DoDataExchange(CDataExchange* pDX)
  62 {
  63         CDialog::DoDataExchange(pDX);
  64         DDX_Control(pDX, IDC_REBASE_PROGRESS, m_ProgressBar);
  65         DDX_Control(pDX, IDC_STATUS_STATIC, m_CtrlStatusText);
  66         DDX_Check(pDX, IDC_PICK_ALL, m_bPickAll);
  67         DDX_Check(pDX, IDC_SQUASH_ALL, m_bSquashAll);
  68         DDX_Check(pDX, IDC_EDIT_ALL, m_bEditAll);
  69         DDX_Control(pDX, IDC_REBASE_SPLIT, m_wndSplitter);
  70         DDX_Control(pDX,IDC_COMMIT_LIST,m_CommitList);
  71         DDX_Control(pDX,IDC_REBASE_COMBOXEX_BRANCH, this->m_BranchCtrl);
  72         DDX_Control(pDX,IDC_REBASE_COMBOXEX_UPSTREAM,   this->m_UpstreamCtrl);
  73         DDX_Check(pDX, IDC_REBASE_CHECK_FORCE,m_bForce);
  74         DDX_Check(pDX, IDC_CHECK_CHERRYPICKED_FROM, m_bAddCherryPickedFrom);
  75         DDX_Control(pDX,IDC_REBASE_POST_BUTTON,m_PostButton);
  76 }
  77
  78
  79 BEGIN_MESSAGE_MAP(CRebaseDlg, CResizableStandAloneDialog)
  80         ON_BN_CLICKED(IDC_PICK_ALL, &CRebaseDlg::OnBnClickedPickAll)
  81         ON_BN_CLICKED(IDC_SQUASH_ALL, &CRebaseDlg::OnBnClickedSquashAll)
  82         ON_BN_CLICKED(IDC_EDIT_ALL, &CRebaseDlg::OnBnClickedEditAll)
  83         ON_BN_CLICKED(IDC_REBASE_SPLIT, &CRebaseDlg::OnBnClickedRebaseSplit)
  84         ON_BN_CLICKED(IDC_REBASE_CONTINUE,OnBnClickedContinue)
  85         ON_BN_CLICKED(IDC_REBASE_ABORT,  OnBnClickedAbort)
  86         ON_WM_SIZE()
  87         ON_CBN_SELCHANGE(IDC_REBASE_COMBOXEX_BRANCH,   &CRebaseDlg::OnCbnSelchangeBranch)
  88         ON_CBN_SELCHANGE(IDC_REBASE_COMBOXEX_UPSTREAM, &CRebaseDlg::OnCbnSelchangeUpstream)
  89         ON_MESSAGE(MSG_REBASE_UPDATE_UI, OnRebaseUpdateUI)
  90         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_NEEDSREFRESH, OnGitStatusListCtrlNeedsRefresh)
  91         ON_BN_CLICKED(IDC_BUTTON_BROWSE, &CRebaseDlg::OnBnClickedButtonBrowse)
  92         ON_BN_CLICKED(IDC_REBASE_CHECK_FORCE, &CRebaseDlg::OnBnClickedRebaseCheckForce)
  93         ON_BN_CLICKED(IDC_CHECK_CHERRYPICKED_FROM, &CRebaseDlg::OnBnClickedCheckCherryPickedFrom)
  94         ON_BN_CLICKED(IDC_REBASE_POST_BUTTON, &CRebaseDlg::OnBnClickedRebasePostButton)
  95         ON_BN_CLICKED(IDC_BUTTON_UP2, &CRebaseDlg::OnBnClickedButtonUp2)
  96         ON_BN_CLICKED(IDC_BUTTON_DOWN2, &CRebaseDlg::OnBnClickedButtonDown2)
  97         ON_REGISTERED_MESSAGE(WM_TASKBARBTNCREATED, OnTaskbarBtnCreated)
  98         ON_NOTIFY(LVN_ITEMCHANGED, IDC_COMMIT_LIST, OnLvnItemchangedLoglist)
  99 END_MESSAGE_MAP()
 100
 101 void CRebaseDlg::AddRebaseAnchor()
 102 {
 103         AddAnchor(IDC_REBASE_TAB,TOP_LEFT,BOTTOM_RIGHT);
 104         AddAnchor(IDC_COMMIT_LIST,TOP_LEFT, TOP_RIGHT);
 105         AddAnchor(IDC_REBASE_SPLIT,TOP_LEFT, TOP_RIGHT);
 106         AddAnchor(IDC_STATUS_STATIC, BOTTOM_LEFT,BOTTOM_RIGHT);
 107         AddAnchor(IDC_REBASE_CONTINUE,BOTTOM_RIGHT);
 108         AddAnchor(IDC_REBASE_ABORT, BOTTOM_RIGHT);
 109         AddAnchor(IDC_REBASE_PROGRESS,BOTTOM_LEFT, BOTTOM_RIGHT);
 110         AddAnchor(IDC_PICK_ALL,TOP_LEFT);
 111         AddAnchor(IDC_SQUASH_ALL,TOP_LEFT);
 112         AddAnchor(IDC_EDIT_ALL,TOP_LEFT);
 113         AddAnchor(IDC_BUTTON_UP2,TOP_LEFT);
 114         AddAnchor(IDC_BUTTON_DOWN2,TOP_LEFT);
 115         AddAnchor(IDC_REBASE_COMBOXEX_UPSTREAM,TOP_LEFT);
 116         AddAnchor(IDC_REBASE_COMBOXEX_BRANCH,TOP_LEFT);
 117         AddAnchor(IDC_REBASE_STATIC_UPSTREAM,TOP_LEFT);
 118         AddAnchor(IDC_REBASE_STATIC_BRANCH,TOP_LEFT);
 119         AddAnchor(IDHELP, BOTTOM_RIGHT);
 120         AddAnchor(IDC_REBASE_CHECK_FORCE,TOP_RIGHT);
 121         AddAnchor(IDC_CHECK_CHERRYPICKED_FROM, TOP_RIGHT);
 122         AddAnchor(IDC_REBASE_POST_BUTTON,BOTTOM_LEFT);
 123
 124         this->AddOthersToAnchor();
 125 }
 126
 127 BOOL CRebaseDlg::OnInitDialog()
 128 {
 129         CResizableStandAloneDialog::OnInitDialog();
 130         CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
 131
 132         // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
 133         // do this, Explorer would be unable to send that message to our window if we
 134         // were running elevated. It's OK to make the call all the time, since if we're
 135         // not elevated, this is a no-op.
 136         CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
 137         typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
 138         CAutoLibrary hUser = AtlLoadSystemLibraryUsingFullPath(_T("user32.dll"));
 139         if (hUser)
 140         {
 141                 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
 142                 if (pfnChangeWindowMessageFilterEx)
 143                 {
 144                         pfnChangeWindowMessageFilterEx(m_hWnd, WM_TASKBARBTNCREATED, MSGFLT_ALLOW, &cfs);
 145                 }
 146         }
 147         m_pTaskbarList.Release();
 148         if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
 149                 m_pTaskbarList = nullptr;
 150
 151         CRect rectDummy;
 152         //IDC_REBASE_DUMY_TAB
 153
 154         GetClientRect(m_DlgOrigRect);
 155         m_CommitList.GetClientRect(m_CommitListOrigRect);
 156
 157         CWnd *pwnd=this->GetDlgItem(IDC_REBASE_DUMY_TAB);
 158         pwnd->GetWindowRect(&rectDummy);
 159         this->ScreenToClient(rectDummy);
 160
 161         if (!m_ctrlTabCtrl.Create(CMFCTabCtrl::STYLE_FLAT, rectDummy, this, IDC_REBASE_TAB))
 162         {
 163                 TRACE0("Failed to create output tab window\n");
 164                 return FALSE;      // fail to create
 165         }
 166         m_ctrlTabCtrl.SetResizeMode(CMFCTabCtrl::RESIZE_NO);
 167         // Create output panes:
 168         //const DWORD dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
 169         DWORD dwStyle =LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
 170
 171         if (! this->m_FileListCtrl.Create(dwStyle,rectDummy,&this->m_ctrlTabCtrl,0) )
 172         {
 173                 TRACE0("Failed to create output windows\n");
 174                 return FALSE;      // fail to create
 175         }
 176         m_FileListCtrl.m_hwndLogicalParent = this;
 177
 178         if( ! this->m_LogMessageCtrl.Create(_T("Scintilla"),_T("source"),0,rectDummy,&m_ctrlTabCtrl,0,0) )
 179         {
 180                 TRACE0("Failed to create log message control");
 181                 return FALSE;
 182         }
 183         m_LogMessageCtrl.Init(0);
 184         m_LogMessageCtrl.Call(SCI_SETREADONLY, TRUE);
 185
 186         dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
 187
 188         if (!m_wndOutputRebase.Create(_T("Scintilla"),_T("source"),0,rectDummy, &m_ctrlTabCtrl, 0,0) )
 189         {
 190                 TRACE0("Failed to create output windows\n");
 191                 return -1;      // fail to create
 192         }
 193         m_wndOutputRebase.Init(0);
 194         m_wndOutputRebase.Call(SCI_SETREADONLY, TRUE);
 195
 196         m_tooltips.Create(this);
 197
 198         m_tooltips.AddTool(IDC_REBASE_CHECK_FORCE,IDS_REBASE_FORCE_TT);
 199         m_tooltips.AddTool(IDC_REBASE_ABORT,IDS_REBASE_ABORT_TT);
 200
 201
 202
 203         m_FileListCtrl.Init(GITSLC_COLEXT | GITSLC_COLSTATUS |GITSLC_COLADD|GITSLC_COLDEL , _T("RebaseDlg"),(GITSLC_POPALL ^ (GITSLC_POPCOMMIT|GITSLC_POPRESTORE)), false, true, GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD| GITSLC_COLDEL);
 204
 205         m_ctrlTabCtrl.AddTab(&m_FileListCtrl, CString(MAKEINTRESOURCE(IDS_PROC_REVISIONFILES)));
 206         m_ctrlTabCtrl.AddTab(&m_LogMessageCtrl, CString(MAKEINTRESOURCE(IDS_PROC_COMMITMESSAGE)), 1);
 207         AddRebaseAnchor();
 208
 209         AdjustControlSize(IDC_PICK_ALL);
 210         AdjustControlSize(IDC_SQUASH_ALL);
 211         AdjustControlSize(IDC_EDIT_ALL);
 212         AdjustControlSize(IDC_CHECK_CHERRYPICKED_FROM);
 213
 214         CString sWindowTitle;
 215         GetWindowText(sWindowTitle);
 216         CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, sWindowTitle);
 217
 218         EnableSaveRestore(_T("RebaseDlg"));
 219
 220         DWORD yPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RebaseDlgSizer"));
 221         RECT rcDlg, rcLogMsg, rcFileList;
 222         GetClientRect(&rcDlg);
 223         m_CommitList.GetWindowRect(&rcLogMsg);
 224         ScreenToClient(&rcLogMsg);
 225         this->m_ctrlTabCtrl.GetWindowRect(&rcFileList);
 226         ScreenToClient(&rcFileList);
 227         if (yPos)
 228         {
 229                 RECT rectSplitter;
 230                 m_wndSplitter.GetWindowRect(&rectSplitter);
 231                 ScreenToClient(&rectSplitter);
 232                 int delta = yPos - rectSplitter.top;
 233                 if ((rcLogMsg.bottom + delta > rcLogMsg.top)&&(rcLogMsg.bottom + delta < rcFileList.bottom - 30))
 234                 {
 235                         m_wndSplitter.SetWindowPos(NULL, 0, yPos, 0, 0, SWP_NOSIZE);
 236                         DoSize(delta);
 237                 }
 238         }
 239
 240         if( this->m_RebaseStage == CHOOSE_BRANCH)
 241         {
 242                 this->LoadBranchInfo();
 243
 244         }
 245         else
 246         {
 247                 this->m_BranchCtrl.EnableWindow(FALSE);
 248                 this->m_UpstreamCtrl.EnableWindow(FALSE);
 249         }
 250
 251         m_CommitList.m_ColumnRegKey = _T("Rebase");
 252         m_CommitList.m_IsIDReplaceAction = TRUE;
 253 //      m_CommitList.m_IsOldFirst = TRUE;
 254         m_CommitList.m_IsRebaseReplaceGraph = TRUE;
 255         m_CommitList.m_bNoHightlightHead = TRUE;
 256
 257         m_CommitList.InsertGitColumn();
 258
 259         this->SetControlEnable();
 260
 261         if(!this->m_PreCmd.IsEmpty())
 262         {
 263                 CProgressDlg progress;
 264                 progress.m_GitCmd=m_PreCmd;
 265                 progress.m_bAutoCloseOnSuccess=true;
 266                 progress.DoModal();
 267         }
 268
 269         if(m_IsCherryPick)
 270         {
 271                 this->m_BranchCtrl.SetCurSel(-1);
 272                 this->m_BranchCtrl.EnableWindow(FALSE);
 273                 GetDlgItem(IDC_REBASE_CHECK_FORCE)->ShowWindow(SW_HIDE);
 274                 GetDlgItem(IDC_BUTTON_BROWSE)->EnableWindow(FALSE);
 275                 this->m_UpstreamCtrl.AddString(_T("HEAD"));
 276                 this->m_UpstreamCtrl.EnableWindow(FALSE);
 277                 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_CHERRYPICK)));
 278                 this->m_CommitList.StartFilter();
 279         }
 280         else
 281         {
 282                 GetDlgItem(IDC_CHECK_CHERRYPICKED_FROM)->ShowWindow(SW_HIDE);
 283                 SetContinueButtonText();
 284                 m_CommitList.DeleteAllItems();
 285                 FetchLogList();
 286         }
 287
 288         m_CommitList.m_ContextMenuMask &= ~(m_CommitList.GetContextMenuBit(CGitLogListBase::ID_CHERRY_PICK)|
 289                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_SWITCHTOREV)|
 290                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_RESET)|
 291                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REVERTREV)|
 292                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_TO_VERSION)|
 293                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REVERTTOREV)|
 294                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_COMBINE_COMMIT));
 295
 296         if(m_CommitList.m_IsOldFirst)
 297                 this->m_CurrentRebaseIndex = -1;
 298         else
 299                 this->m_CurrentRebaseIndex = (int)m_CommitList.m_logEntries.size();
 300
 301
 302         if(this->CheckRebaseCondition())
 303         {
 304                 /* Disable Start Rebase */
 305                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
 306         }
 307
 308         return TRUE;
 309 }
 310 // CRebaseDlg message handlers
 311
 312 void CRebaseDlg::OnBnClickedPickAll()
 313 {
 314         this->UpdateData();
 315         if(this->m_bPickAll)
 316                 this->SetAllRebaseAction(CTGitPath::LOGACTIONS_REBASE_PICK);
 317
 318         this->m_bEditAll=FALSE;
 319         this->m_bSquashAll=FALSE;
 320         this->UpdateData(FALSE);
 321 }
 322
 323 void CRebaseDlg::OnBnClickedSquashAll()
 324 {
 325         this->UpdateData();
 326         if(this->m_bSquashAll)
 327                 this->SetAllRebaseAction(CTGitPath::LOGACTIONS_REBASE_SQUASH);
 328
 329         this->m_bEditAll=FALSE;
 330         this->m_bPickAll=FALSE;
 331         this->UpdateData(FALSE);
 332 }
 333
 334 void CRebaseDlg::OnBnClickedEditAll()
 335 {
 336         this->UpdateData();
 337         if( this->m_bEditAll )
 338                 this->SetAllRebaseAction(CTGitPath::LOGACTIONS_REBASE_EDIT);
 339
 340         this->m_bPickAll=FALSE;
 341         this->m_bSquashAll=FALSE;
 342         this->UpdateData(FALSE);
 343 }
 344
 345 void CRebaseDlg::SetAllRebaseAction(int action)
 346 {
 347         for (int i = 0; i < this->m_CommitList.m_logEntries.size(); ++i)
 348         {
 349                 m_CommitList.m_logEntries.GetGitRevAt(i).GetAction(&m_CommitList)=action;
 350         }
 351         m_CommitList.Invalidate();
 352 }
 353
 354 void CRebaseDlg::OnBnClickedRebaseSplit()
 355 {
 356         this->UpdateData();
 357 }
 358
 359 LRESULT CRebaseDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
 360 {
 361         switch (message) {
 362         case WM_NOTIFY:
 363                 if (wParam == IDC_REBASE_SPLIT)
 364                 {
 365                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
 366                         DoSize(pHdr->delta);
 367                 }
 368                 break;
 369         }
 370
 371         return __super::DefWindowProc(message, wParam, lParam);
 372 }
 373
 374 void CRebaseDlg::DoSize(int delta)
 375 {
 376         this->RemoveAllAnchors();
 377
 378         CSplitterControl::ChangeHeight(GetDlgItem(IDC_COMMIT_LIST), delta, CW_TOPALIGN);
 379         //CSplitterControl::ChangeHeight(GetDlgItem(), delta, CW_TOPALIGN);
 380         CSplitterControl::ChangeHeight(GetDlgItem(IDC_REBASE_TAB), -delta, CW_BOTTOMALIGN);
 381         //CSplitterControl::ChangeHeight(GetDlgItem(), -delta, CW_BOTTOMALIGN);
 382         CSplitterControl::ChangePos(GetDlgItem(IDC_SQUASH_ALL),0,delta);
 383         CSplitterControl::ChangePos(GetDlgItem(IDC_PICK_ALL),0,delta);
 384         CSplitterControl::ChangePos(GetDlgItem(IDC_EDIT_ALL),0,delta);
 385         CSplitterControl::ChangePos(GetDlgItem(IDC_BUTTON_UP2),0,delta);
 386         CSplitterControl::ChangePos(GetDlgItem(IDC_BUTTON_DOWN2),0,delta);
 387         CSplitterControl::ChangePos(GetDlgItem(IDC_REBASE_CHECK_FORCE),0,delta);
 388
 389         this->AddRebaseAnchor();
 390         // adjust the minimum size of the dialog to prevent the resizing from
 391         // moving the list control too far down.
 392         CRect rcLogMsg;
 393         m_CommitList.GetClientRect(rcLogMsg);
 394         SetMinTrackSize(CSize(m_DlgOrigRect.Width(), m_DlgOrigRect.Height()-m_CommitListOrigRect.Height()+rcLogMsg.Height()));
 395
 396         SetSplitterRange();
 397 //      m_CommitList.Invalidate();
 398
 399 //      GetDlgItem(IDC_LOGMESSAGE)->Invalidate();
 400
 401         this->m_ctrlTabCtrl.Invalidate();
 402         this->m_CommitList.Invalidate();
 403         this->m_FileListCtrl.Invalidate();
 404         this->m_LogMessageCtrl.Invalidate();
 405
 406 }
 407
 408 void CRebaseDlg::SetSplitterRange()
 409 {
 410         if ((m_CommitList)&&(m_ctrlTabCtrl))
 411         {
 412                 CRect rcTop;
 413                 m_CommitList.GetWindowRect(rcTop);
 414                 ScreenToClient(rcTop);
 415                 CRect rcMiddle;
 416                 m_ctrlTabCtrl.GetWindowRect(rcMiddle);
 417                 ScreenToClient(rcMiddle);
 418                 if (rcMiddle.Height() && rcMiddle.Width())
 419                         m_wndSplitter.SetRange(rcTop.top+60, rcMiddle.bottom-80);
 420         }
 421 }
 422
 423 void CRebaseDlg::OnSize(UINT nType,int cx, int cy)
 424 {
 425         // first, let the resizing take place
 426         __super::OnSize(nType, cx, cy);
 427
 428         //set range
 429         SetSplitterRange();
 430 }
 431
 432 void CRebaseDlg::SaveSplitterPos()
 433 {
 434         if (!IsIconic())
 435         {
 436                 CRegDWORD regPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RebaseDlgSizer"));
 437                 RECT rectSplitter;
 438                 m_wndSplitter.GetWindowRect(&rectSplitter);
 439                 ScreenToClient(&rectSplitter);
 440                 regPos = rectSplitter.top;
 441         }
 442 }
 443
 444 void CRebaseDlg::LoadBranchInfo()
 445 {
 446         m_BranchCtrl.SetMaxHistoryItems(0x7FFFFFFF);
 447         m_UpstreamCtrl.SetMaxHistoryItems(0x7FFFFFFF);
 448
 449         STRING_VECTOR list;
 450         list.clear();
 451         int current;
 452         g_Git.GetBranchList(list,&current,CGit::BRANCH_ALL);
 453         m_BranchCtrl.AddString(list);
 454         m_BranchCtrl.SetCurSel(current);
 455         list.clear();
 456         g_Git.GetBranchList(list, NULL, CGit::BRANCH_ALL_F);
 457         m_UpstreamCtrl.AddString(list);
 458
 459         AddBranchToolTips(&m_BranchCtrl);
 460         AddBranchToolTips(&m_UpstreamCtrl);
 461
 462         if(!m_Upstream.IsEmpty())
 463         {
 464                 m_UpstreamCtrl.AddString(m_Upstream);
 465                 m_UpstreamCtrl.SetCurSel(m_UpstreamCtrl.GetCount()-1);
 466         }
 467         else
 468         {
 469                 //Select pull-remote from current branch
 470                 CString currentBranch = g_Git.GetSymbolicRef();
 471                 CString configName;
 472                 configName.Format(L"branch.%s.remote", currentBranch);
 473                 CString pullRemote = g_Git.GetConfigValue(configName);
 474
 475                 //Select pull-branch from current branch
 476                 configName.Format(L"branch.%s.merge", currentBranch);
 477                 CString pullBranch = CGit::StripRefName(g_Git.GetConfigValue(configName));
 478
 479                 CString defaultUpstream;
 480                 defaultUpstream.Format(L"remotes/%s/%s", pullRemote, pullBranch);
 481                 int found = m_UpstreamCtrl.FindStringExact(0, defaultUpstream);
 482                 if(found >= 0)
 483                         m_UpstreamCtrl.SetCurSel(found);
 484                 else
 485                         m_UpstreamCtrl.SetCurSel(-1);
 486         }
 487 }
 488
 489 void CRebaseDlg::OnCbnSelchangeBranch()
 490 {
 491         FetchLogList();
 492 }
 493
 494 void CRebaseDlg::OnCbnSelchangeUpstream()
 495 {
 496         FetchLogList();
 497 }
 498
 499 void CRebaseDlg::FetchLogList()
 500 {
 501         CGitHash base,hash,upstream;
 502         m_IsFastForward=FALSE;
 503
 504         if (g_Git.GetHash(hash, m_BranchCtrl.GetString()))
 505         {
 506                 m_CommitList.ShowText(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_BranchCtrl.GetString() + _T("\".")));
 507                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
 508                 return;
 509         }
 510         if (g_Git.GetHash(upstream, m_UpstreamCtrl.GetString()))
 511         {
 512                 m_CommitList.ShowText(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_UpstreamCtrl.GetString() + _T("\".")));
 513                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
 514                 return;
 515         }
 516
 517         if (hash == upstream)
 518         {
 519                 m_CommitList.Clear();
 520                 CString text,fmt;
 521                 fmt.LoadString(IDS_REBASE_EQUAL_FMT);
 522                 text.Format(fmt,m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString());
 523
 524                 m_CommitList.ShowText(text);
 525                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(false);
 526                 return;
 527         }
 528
 529         if (g_Git.IsFastForward(m_BranchCtrl.GetString(), m_UpstreamCtrl.GetString(), &base))
 530         {
 531                 //fast forword
 532                 this->m_IsFastForward=TRUE;
 533
 534                 m_CommitList.Clear();
 535                 CString text,fmt;
 536                 fmt.LoadString(IDS_REBASE_FASTFORWARD_FMT);
 537                 text.Format(fmt,m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString(),
 538                                                 m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString());
 539
 540                 m_CommitList.ShowText(text);
 541                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(true);
 542                 SetContinueButtonText();
 543
 544                 return ;
 545         }
 546
 547         if(!this->m_bForce)
 548         {
 549                 if (base == upstream)
 550                 {
 551                         m_CommitList.Clear();
 552                         CString text,fmt;
 553                         fmt.LoadString(IDS_REBASE_UPTODATE_FMT);
 554                         text.Format(fmt,m_BranchCtrl.GetString());
 555                         m_CommitList.ShowText(text);
 556                         this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(m_CommitList.GetItemCount());
 557                         SetContinueButtonText();
 558                         return;
 559                 }
 560         }
 561
 562         m_CommitList.Clear();
 563         CString from,to;
 564         from = m_UpstreamCtrl.GetString();
 565         to = m_BranchCtrl.GetString();
 566         this->m_CommitList.FillGitLog(NULL,0,&from,&to);
 567
 568         if( m_CommitList.GetItemCount() == 0 )
 569                 m_CommitList.ShowText(CString(MAKEINTRESOURCE(IDS_PROC_NOTHINGTOREBASE)));
 570
 571 #if 0
 572         if(m_CommitList.m_logEntries[m_CommitList.m_logEntries.size()-1].m_ParentHash.size() >=0 )
 573         {
 574                 if(upstream ==  m_CommitList.m_logEntries[m_CommitList.m_logEntries.size()-1].m_ParentHash[0])
 575                 {
 576                         m_CommitList.Clear();
 577                         m_CommitList.ShowText(_T("Nothing Rebase"));
 578                 }
 579         }
 580 #endif
 581
 582         m_tooltips.Pop();
 583         AddBranchToolTips(&this->m_BranchCtrl);
 584         AddBranchToolTips(&this->m_UpstreamCtrl);
 585
 586         for (int i = 0; i < m_CommitList.m_logEntries.size(); ++i)
 587         {
 588                 m_CommitList.m_logEntries.GetGitRevAt(i).GetAction(&m_CommitList) = CTGitPath::LOGACTIONS_REBASE_PICK;
 589         }
 590
 591         m_CommitList.Invalidate();
 592
 593         if(m_CommitList.m_IsOldFirst)
 594                 this->m_CurrentRebaseIndex = -1;
 595         else
 596                 this->m_CurrentRebaseIndex = (int)m_CommitList.m_logEntries.size();
 597
 598         this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(m_CommitList.GetItemCount());
 599         SetContinueButtonText();
 600 }
 601
 602 void CRebaseDlg::AddBranchToolTips(CHistoryCombo *pBranch)
 603 {
 604         if(pBranch)
 605         {
 606                 CString text=pBranch->GetString();
 607                 CString tooltip;
 608
 609                 GitRev rev;
 610                 rev.GetCommit(text);
 611
 612                 tooltip.Format(_T("%s: %s\n%s: %s <%s>\n%s: %s\n%s:\n%s\n%s"),
 613                         CString(MAKEINTRESOURCE(IDS_LOG_REVISION)),
 614                         rev.m_CommitHash.ToString(),
 615                         CString(MAKEINTRESOURCE(IDS_LOG_AUTHOR)),
 616                         rev.GetAuthorName(),
 617                         rev.GetAuthorEmail(),
 618                         CString(MAKEINTRESOURCE(IDS_LOG_DATE)),
 619                         CLoglistUtils::FormatDateAndTime(rev.GetAuthorDate(), DATE_LONGDATE),
 620                         CString(MAKEINTRESOURCE(IDS_LOG_MESSAGE)),
 621                         rev.GetSubject(),
 622                         rev.GetBody());
 623
 624                 pBranch->DisableTooltip();
 625                 this->m_tooltips.AddTool(pBranch->GetComboBoxCtrl(),tooltip);
 626         }
 627 }
 628
 629 BOOL CRebaseDlg::PreTranslateMessage(MSG*pMsg)
 630 {
 631         if (pMsg->message == WM_KEYDOWN)
 632         {
 633                 switch (pMsg->wParam)
 634                 {
 635                 case ' ':
 636                         if(LogListHasFocus(pMsg->hwnd))
 637                         {
 638                                 m_CommitList.ShiftSelectedAction();
 639                                 return TRUE;
 640                         }
 641                         break;
 642                 case 'P':
 643                         if(LogListHasFocus(pMsg->hwnd))
 644                         {
 645                                 m_CommitList.SetSelectedAction(CTGitPath::LOGACTIONS_REBASE_PICK);
 646                                 return TRUE;
 647                         }
 648                         break;
 649                 case 'S':
 650                         if(LogListHasFocus(pMsg->hwnd))
 651                         {
 652                                 m_CommitList.SetSelectedAction(CTGitPath::LOGACTIONS_REBASE_SKIP);
 653                                 return TRUE;
 654                         }
 655                         break;
 656                 case 'Q':
 657                         if(LogListHasFocus(pMsg->hwnd))
 658                         {
 659                                 m_CommitList.SetSelectedAction(CTGitPath::LOGACTIONS_REBASE_SQUASH);
 660                                 return TRUE;
 661                         }
 662                         break;
 663                 case 'E':
 664                         if(LogListHasFocus(pMsg->hwnd))
 665                         {
 666                                 m_CommitList.SetSelectedAction(CTGitPath::LOGACTIONS_REBASE_EDIT);
 667                                 return TRUE;
 668                         }
 669                         break;
 670                 case 'A':
 671                         if(LogListHasFocus(pMsg->hwnd) && GetAsyncKeyState(VK_CONTROL) & 0x8000)
 672                         {
 673                                 // select all entries
 674                                 for (int i = 0; i < m_CommitList.GetItemCount(); ++i)
 675                                 {
 676                                         m_CommitList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
 677                                 }
 678                                 return TRUE;
 679                         }
 680                         break;
 681                 case VK_F5:
 682                         {
 683                                 Refresh();
 684                                 return TRUE;
 685                         }
 686                         break;
 687                 case VK_RETURN:
 688                         {
 689                                 if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
 690                                 {
 691                                         if (GetDlgItem(IDC_REBASE_CONTINUE)->IsWindowEnabled())
 692                                                 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
 693                                         else if (GetDlgItem(IDC_REBASE_ABORT)->IsWindowEnabled())
 694                                                 GetDlgItem(IDC_REBASE_ABORT)->SetFocus();
 695                                         else
 696                                                 GetDlgItem(IDHELP)->SetFocus();
 697                                         return TRUE;
 698                                 }
 699                         }
 700                         break;
 701                 /* Avoid TAB control destroy but dialog exist*/
 702                 case VK_ESCAPE:
 703                 case VK_CANCEL:
 704                         {
 705                                 TCHAR buff[128];
 706                                 ::GetClassName(pMsg->hwnd,buff,128);
 707
 708
 709                                 if(_tcsnicmp(buff,_T("RichEdit20W"),128)==0 ||
 710                                    _tcsnicmp(buff,_T("Scintilla"),128)==0 ||
 711                                    _tcsnicmp(buff,_T("SysListView32"),128)==0||
 712                                    ::GetParent(pMsg->hwnd) == this->m_ctrlTabCtrl.m_hWnd)
 713                                 {
 714                                         this->PostMessage(WM_KEYDOWN,VK_ESCAPE,0);
 715                                         return TRUE;
 716                                 }
 717                         }
 718                 }
 719         }
 720         else if (pMsg->message == WM_NEXTDLGCTL)
 721         {
 722                 if (GetFocus()->GetSafeHwnd() == m_LogMessageCtrl.GetSafeHwnd())
 723                 {
 724                         if (GetDlgItem(IDC_REBASE_CONTINUE)->IsWindowEnabled())
 725                                 GetDlgItem(IDC_REBASE_CONTINUE)->SetFocus();
 726                         else if (GetDlgItem(IDC_REBASE_ABORT)->IsWindowEnabled())
 727                                 GetDlgItem(IDC_REBASE_ABORT)->SetFocus();
 728                         else
 729                                 GetDlgItem(IDHELP)->SetFocus();
 730                         return TRUE;
 731                 }
 732         }
 733         m_tooltips.RelayEvent(pMsg);
 734         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
 735 }
 736
 737 bool CRebaseDlg::LogListHasFocus(HWND hwnd)
 738 {
 739         TCHAR buff[128];
 740         ::GetClassName(hwnd, buff, 128);
 741
 742         if(_tcsnicmp(buff, _T("SysListView32"), 128) == 0)
 743                 return true;
 744         return false;
 745 }
 746
 747 int CRebaseDlg::CheckRebaseCondition()
 748 {
 749         this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 750
 751         if( !g_Git.CheckCleanWorkTree()  )
 752         {
 753                 if (CMessageBox::Show(NULL, IDS_ERROR_NOCLEAN_STASH, IDS_APPNAME, 1, IDI_QUESTION, IDS_STASHBUTTON, IDS_ABORTBUTTON) == 1)
 754                 {
 755                         CString cmd,out;
 756                         cmd=_T("git.exe stash");
 757                         this->AddLogString(cmd);
 758                         if (g_Git.Run(cmd, &out, CP_UTF8))
 759                         {
 760                                 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
 761                                 return -1;
 762                         }
 763
 764                 }
 765                 else
 766                         return -1;
 767         }
 768         //Todo Check $REBASE_ROOT
 769         //Todo Check $DOTEST
 770
 771         if (!CAppUtils::CheckUserData())
 772                 return -1;
 773
 774         //Todo call pre_rebase_hook
 775         return 0;
 776 }
 777 int CRebaseDlg::StartRebase()
 778 {
 779         CString cmd,out;
 780         m_FileListCtrl.m_bIsRevertTheirMy = !m_IsCherryPick;
 781         if(!this->m_IsCherryPick)
 782         {
 783                 //Todo call comment_for_reflog
 784                 cmd.Format(_T("git.exe checkout %s"),this->m_BranchCtrl.GetString());
 785                 this->AddLogString(cmd);
 786                 while (true)
 787                 {
 788                         out.Empty();
 789                         if (g_Git.Run(cmd, &out, CP_UTF8))
 790                         {
 791                                 this->AddLogString(out);
 792                                 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
 793                                         return -1;
 794                         }
 795                         else
 796                                 break;
 797                 }
 798
 799                 this->AddLogString(out);
 800         }
 801
 802         cmd=_T("git.exe rev-parse --verify HEAD");
 803         if(g_Git.Run(cmd,&out,CP_UTF8))
 804         {
 805                 AddLogString(CString(MAKEINTRESOURCE(IDS_PROC_NOHEAD)));
 806                 return -1;
 807         }
 808         //Todo
 809         //git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
 810         //              echo "detached HEAD" > "$DOTEST"/head-name
 811
 812         cmd.Format(_T("git.exe update-ref ORIG_HEAD HEAD"));
 813         if(g_Git.Run(cmd,&out,CP_UTF8))
 814         {
 815                 AddLogString(_T("update ORIG_HEAD Fail"));
 816                 return -1;
 817         }
 818
 819         m_OrigUpstreamHash.Empty();
 820         if (g_Git.GetHash(m_OrigUpstreamHash, m_UpstreamCtrl.GetString()))
 821         {
 822                 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_UpstreamCtrl.GetString() + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
 823                 return -1;
 824         }
 825
 826         if( !this->m_IsCherryPick )
 827         {
 828                 cmd.Format(_T("git.exe checkout -f %s"), m_OrigUpstreamHash.ToString());
 829                 this->AddLogString(cmd);
 830                 while (true)
 831                 {
 832                         out.Empty();
 833                         if (g_Git.Run(cmd, &out, CP_UTF8))
 834                         {
 835                                 this->AddLogString(out);
 836                                 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
 837                                         return -1;
 838                         }
 839                         else
 840                                 break;
 841                 }
 842         }
 843
 844         CString log;
 845         if( !this->m_IsCherryPick )
 846         {
 847                 if (g_Git.GetHash(m_OrigBranchHash, m_BranchCtrl.GetString()))
 848                 {
 849                         MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_BranchCtrl.GetString() + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
 850                         return -1;
 851                 }
 852                 log.Format(_T("%s\r\n"), CString(MAKEINTRESOURCE(IDS_PROC_REBASE_STARTREBASE)));
 853         }
 854         else
 855                 log.Format(_T("%s\r\n"), CString(MAKEINTRESOURCE(IDS_PROC_REBASE_STARTCHERRYPICK)));
 856
 857         this->AddLogString(log);
 858         return 0;
 859 }
 860 int CRebaseDlg::VerifyNoConflict()
 861 {
 862         CTGitPathList list;
 863         if(g_Git.ListConflictFile(list))
 864         {
 865                 AddLogString(_T("Get conflict files fail"));
 866                 return -1;
 867         }
 868         if( list.GetCount() != 0 )
 869         {
 870                 CMessageBox::Show(NULL, IDS_PROGRS_CONFLICTSOCCURED, IDS_APPNAME, MB_OK);
 871                 return -1;
 872         }
 873         return 0;
 874
 875 }
 876 int CRebaseDlg::FinishRebase()
 877 {
 878         if(this->m_IsCherryPick) //cherry pick mode no "branch", working at upstream branch
 879                 return 0;
 880
 881         CGitHash head;
 882         if (g_Git.GetHash(head, _T("HEAD")))
 883         {
 884                 MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash.")), _T("TortoiseGit"), MB_ICONERROR);
 885                 return -1;
 886         }
 887         CString out,cmd;
 888
 889         cmd.Format(_T("git.exe checkout -f %s"),this->m_BranchCtrl.GetString());
 890         AddLogString(cmd);
 891         while (true)
 892         {
 893                 out.Empty();
 894                 if (g_Git.Run(cmd, &out, CP_UTF8))
 895                 {
 896                         AddLogString(out);
 897                         if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
 898                                 return -1;
 899                 }
 900                 else
 901                         break;
 902         }
 903         AddLogString(out);
 904
 905         cmd.Format(_T("git.exe reset --hard %s"), head.ToString());
 906         AddLogString(cmd);
 907         while (true)
 908         {
 909                 out.Empty();
 910                 if (g_Git.Run(cmd, &out, CP_UTF8))
 911                 {
 912                         AddLogString(out);
 913                         if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
 914                                 return -1;
 915                 }
 916                 else
 917                         break;
 918         }
 919         AddLogString(out);
 920
 921         while (m_ctrlTabCtrl.GetTabsNum() > 1)
 922                 m_ctrlTabCtrl.RemoveTab(0);
 923         m_CtrlStatusText.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_REBASEFINISHED)));
 924
 925         return 0;
 926 }
 927 void CRebaseDlg::OnBnClickedContinue()
 928 {
 929         if( m_RebaseStage == REBASE_DONE)
 930         {
 931                 OnOK();
 932                 return;
 933         }
 934
 935         if( this->m_IsFastForward )
 936         {
 937                 CString cmd,out;
 938                 CString oldbranch = g_Git.GetCurrentBranch();
 939                 if( oldbranch != m_BranchCtrl.GetString() )
 940                 {
 941                         cmd.Format(_T("git.exe checkout %s"),m_BranchCtrl.GetString());
 942                         AddLogString(cmd);
 943                         while (true)
 944                         {
 945                                 out.Empty();
 946                                 if (g_Git.Run(cmd, &out, CP_UTF8))
 947                                 {
 948                                         this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 949                                         AddLogString(out);
 950                                         if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
 951                                                 return;
 952                                 }
 953                                 else
 954                                         break;
 955                         }
 956                 }
 957                 AddLogString(out);
 958                 out.Empty();
 959                 if (g_Git.GetHash(m_OrigBranchHash, m_BranchCtrl.GetString()))
 960                 {
 961                         MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_BranchCtrl.GetString() + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
 962                         return;
 963                 }
 964                 if (g_Git.GetHash(m_OrigUpstreamHash, m_UpstreamCtrl.GetString()))
 965                 {
 966                         MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + m_UpstreamCtrl.GetString() + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
 967                         return;
 968                 }
 969
 970                 if(!g_Git.IsFastForward(this->m_BranchCtrl.GetString(),this->m_UpstreamCtrl.GetString()))
 971                 {
 972                         this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 973                         AddLogString(_T("No fast forward possible.\r\nMaybe repository changed"));
 974                         return;
 975                 }
 976
 977                 cmd.Format(_T("git.exe reset --hard %s"),g_Git.FixBranchName(this->m_UpstreamCtrl.GetString()));
 978                 CString log;
 979                 log.Format(IDS_PROC_REBASE_FFTO, m_UpstreamCtrl.GetString());
 980                 this->AddLogString(log);
 981
 982                 AddLogString(cmd);
 983                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
 984                 while (true)
 985                 {
 986                         out.Empty();
 987                         if (g_Git.Run(cmd, &out, CP_UTF8))
 988                         {
 989                                 AddLogString(CString(MAKEINTRESOURCE(IDS_FAIL)));
 990                                 AddLogString(out);
 991                                 if (CMessageBox::Show(m_hWnd, out + _T("\nRetry?"), _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
 992                                         return;
 993                         }
 994                         else
 995                                 break;
 996                 }
 997                 AddLogString(out);
 998                 AddLogString(CString(MAKEINTRESOURCE(IDS_DONE)));
 999                 m_RebaseStage = REBASE_DONE;
1000                 UpdateCurrentStatus();
1001                 return;
1002
1003         }
1004         if( m_RebaseStage == CHOOSE_BRANCH|| m_RebaseStage == CHOOSE_COMMIT_PICK_MODE )
1005         {
1006                 if(CheckRebaseCondition())
1007                         return ;
1008                 m_RebaseStage = REBASE_START;
1009                 m_FileListCtrl.Clear();
1010                 m_FileListCtrl.SetHasCheckboxes(false);
1011                 m_FileListCtrl.m_CurrentVersion = L"";
1012                 m_ctrlTabCtrl.SetTabLabel(REBASE_TAB_CONFLICT, CString(MAKEINTRESOURCE(IDS_PROC_CONFLICTFILES)));
1013                 m_ctrlTabCtrl.AddTab(&m_wndOutputRebase, CString(MAKEINTRESOURCE(IDS_LOG)), 2);
1014         }
1015
1016         if( m_RebaseStage == REBASE_FINISH )
1017         {
1018                 if(FinishRebase())
1019                         return ;
1020
1021                 OnOK();
1022         }
1023
1024         if( m_RebaseStage == REBASE_SQUASH_CONFLICT)
1025         {
1026                 if(VerifyNoConflict())
1027                         return;
1028                 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1029                 if(this->CheckNextCommitIsSquash())
1030                 {//next commit is not squash;
1031                         m_RebaseStage = REBASE_SQUASH_EDIT;
1032                         this->OnRebaseUpdateUI(0,0);
1033                         this->UpdateCurrentStatus();
1034                         return ;
1035
1036                 }
1037                 m_RebaseStage=REBASE_CONTINUE;
1038                 curRev->GetAction(&m_CommitList)|=CTGitPath::LOGACTIONS_REBASE_DONE;
1039                 this->UpdateCurrentStatus();
1040
1041         }
1042
1043         if( m_RebaseStage == REBASE_CONFLICT )
1044         {
1045                 if(VerifyNoConflict())
1046                         return;
1047
1048                 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1049                 // ***************************************************
1050                 // ATTENTION: Similar code in CommitDlg.cpp!!!
1051                 // ***************************************************
1052                 CMassiveGitTask mgtReAddAfterCommit(_T("add --ignore-errors -f"));
1053                 for (int i = 0; i < m_FileListCtrl.GetItemCount(); i++)
1054                 {
1055                         CString cmd, out;
1056                         CTGitPath *entry = (CTGitPath *)m_FileListCtrl.GetItemData(i);
1057                         if (entry->m_Checked)
1058                         {
1059                                 if (entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
1060                                         cmd.Format(_T("git.exe add -f -- \"%s\""), entry->GetGitPathString());
1061                                 else if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
1062                                         cmd.Format(_T("git.exe update-index --force-remove -- \"%s\""), entry->GetGitPathString());
1063                                 else
1064                                         cmd.Format(_T("git.exe update-index -- \"%s\""), entry->GetGitPathString());
1065
1066                                 if (g_Git.Run(cmd, &out, CP_UTF8))
1067                                 {
1068                                         CMessageBox::Show(NULL, out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1069                                         return;
1070                                 }
1071
1072                                 if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
1073                                         cmd.Format(_T("git.exe rm -- \"%s\""), entry->GetGitOldPathString());
1074
1075                                 g_Git.Run(cmd, &out, CP_UTF8);
1076                         }
1077                         else
1078                         {
1079                                 if (entry->m_Action & CTGitPath::LOGACTIONS_ADDED || entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
1080                                 {
1081                                         cmd.Format(_T("git.exe rm -f --cache -- \"%s\""), entry->GetGitPathString());
1082                                         if (g_Git.Run(cmd, &out, CP_UTF8))
1083                                         {
1084                                                 CMessageBox::Show(NULL, out, _T("TortoiseGit"), MB_OK| MB_ICONERROR);
1085                                                 return;
1086                                         }
1087                                         mgtReAddAfterCommit.AddFile(*entry);
1088
1089                                         if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED && !entry->GetGitOldPathString().IsEmpty())
1090                                         {
1091                                                 cmd.Format(_T("git.exe reset -- \"%s\""), entry->GetGitOldPathString());
1092                                                 g_Git.Run(cmd, &out, CP_UTF8);
1093                                         }
1094                                 }
1095                                 else if(!(entry->m_Action & CTGitPath::LOGACTIONS_UNVER))
1096                                 {
1097                                         cmd.Format(_T("git.exe reset -- \"%s\""), entry->GetGitPathString());
1098                                         g_Git.Run(cmd, &out, CP_UTF8);
1099                                 }
1100                         }
1101                 }
1102
1103                 CString out =_T("");
1104                 CString cmd;
1105                 cmd.Format(_T("git.exe commit -C %s"), curRev->m_CommitHash.ToString());
1106
1107                 AddLogString(cmd);
1108
1109                 if(g_Git.Run(cmd,&out,CP_UTF8))
1110                 {
1111                         AddLogString(out);
1112                         if(!g_Git.CheckCleanWorkTree())
1113                         {
1114                                 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1115                                 return;
1116                         }
1117                 }
1118
1119                 AddLogString(out);
1120
1121                 if (((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\ReaddUnselectedAddedFilesAfterCommit"), TRUE)) == TRUE)
1122                 {
1123                         BOOL cancel;
1124                         mgtReAddAfterCommit.Execute(cancel);
1125                 }
1126
1127                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1128                 if( curRev->GetAction(&m_CommitList) & CTGitPath::LOGACTIONS_REBASE_EDIT)
1129                 {
1130                         m_RebaseStage=REBASE_EDIT;
1131                         this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1132                         this->UpdateCurrentStatus();
1133                         return;
1134                 }
1135                 else
1136                 {
1137                         m_RebaseStage=REBASE_CONTINUE;
1138                         curRev->GetAction(&m_CommitList)|=CTGitPath::LOGACTIONS_REBASE_DONE;
1139                         this->UpdateCurrentStatus();
1140                 }
1141         }
1142
1143         if( m_RebaseStage == REBASE_EDIT ||  m_RebaseStage == REBASE_SQUASH_EDIT )
1144         {
1145                 CString str;
1146                 GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1147
1148                 str=this->m_LogMessageCtrl.GetText();
1149                 if(str.Trim().IsEmpty())
1150                 {
1151                         CMessageBox::Show(NULL, IDS_PROC_COMMITMESSAGE_EMPTY,IDS_APPNAME, MB_OK | MB_ICONERROR);
1152                                 return;
1153                 }
1154
1155                 CString tempfile=::GetTempFile();
1156                 CAppUtils::SaveCommitUnicodeFile(tempfile, str);
1157
1158                 CString out,cmd;
1159
1160                 if(  m_RebaseStage == REBASE_SQUASH_EDIT )
1161                         cmd.Format(_T("git.exe commit -F \"%s\""), tempfile);
1162                 else
1163                         cmd.Format(_T("git.exe commit --amend -F \"%s\""), tempfile);
1164
1165                 if(g_Git.Run(cmd,&out,CP_UTF8))
1166                 {
1167                         if(!g_Git.CheckCleanWorkTree())
1168                         {
1169                                 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1170                                 return;
1171                         }
1172                 }
1173
1174                 CFile::Remove(tempfile);
1175                 AddLogString(out);
1176                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1177                 m_RebaseStage=REBASE_CONTINUE;
1178                 curRev->GetAction(&m_CommitList)|=CTGitPath::LOGACTIONS_REBASE_DONE;
1179                 this->UpdateCurrentStatus();
1180         }
1181
1182
1183         InterlockedExchange(&m_bThreadRunning, TRUE);
1184         SetControlEnable();
1185
1186         if (AfxBeginThread(RebaseThreadEntry, this)==NULL)
1187         {
1188                 InterlockedExchange(&m_bThreadRunning, FALSE);
1189                 CMessageBox::Show(NULL, _T("Create Rebase Thread Fail"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1190                 SetControlEnable();
1191         }
1192 }
1193 int CRebaseDlg::CheckNextCommitIsSquash()
1194 {
1195         int index;
1196         if(m_CommitList.m_IsOldFirst)
1197                 index=m_CurrentRebaseIndex+1;
1198         else
1199                 index=m_CurrentRebaseIndex-1;
1200
1201         GitRev *curRev;
1202         do
1203         {
1204                 if(index<0)
1205                         return -1;
1206                 if(index>= m_CommitList.GetItemCount())
1207                         return -1;
1208
1209                 curRev=(GitRev*)m_CommitList.m_arShownList[index];
1210
1211                 if( curRev->GetAction(&m_CommitList)&CTGitPath::LOGACTIONS_REBASE_SQUASH )
1212                         return 0;
1213                 if( curRev->GetAction(&m_CommitList)&CTGitPath::LOGACTIONS_REBASE_SKIP)
1214                 {
1215                         if(m_CommitList.m_IsOldFirst)
1216                                 ++index;
1217                         else
1218                                 --index;
1219                 }
1220                 else
1221                         return -1;
1222
1223         }while(curRev->GetAction(&m_CommitList)&CTGitPath::LOGACTIONS_REBASE_SKIP);
1224
1225         return -1;
1226
1227 }
1228 int CRebaseDlg::GoNext()
1229 {
1230         if(m_CommitList.m_IsOldFirst)
1231                 ++m_CurrentRebaseIndex;
1232         else
1233                 --m_CurrentRebaseIndex;
1234         return 0;
1235
1236 }
1237 int CRebaseDlg::StateAction()
1238 {
1239         switch(this->m_RebaseStage)
1240         {
1241         case CHOOSE_BRANCH:
1242         case CHOOSE_COMMIT_PICK_MODE:
1243                 if(StartRebase())
1244                         return -1;
1245                 m_RebaseStage = REBASE_START;
1246                 GoNext();
1247                 break;
1248         }
1249
1250         return 0;
1251 }
1252 void CRebaseDlg::SetContinueButtonText()
1253 {
1254         CString Text;
1255         switch(this->m_RebaseStage)
1256         {
1257         case CHOOSE_BRANCH:
1258         case CHOOSE_COMMIT_PICK_MODE:
1259                 if(this->m_IsFastForward)
1260                         Text.LoadString(IDS_PROC_STARTREBASEFFBUTTON);
1261                 else
1262                         Text.LoadString(IDS_PROC_STARTREBASEBUTTON);
1263                 break;
1264
1265         case REBASE_START:
1266         case REBASE_ERROR:
1267         case REBASE_CONTINUE:
1268         case REBASE_SQUASH_CONFLICT:
1269                 Text.LoadString(IDS_CONTINUEBUTTON);
1270                 break;
1271
1272         case REBASE_CONFLICT:
1273                 Text.LoadString(IDS_COMMITBUTTON);
1274                 break;
1275         case REBASE_EDIT:
1276                 Text.LoadString(IDS_AMENDBUTTON);
1277                 break;
1278
1279         case REBASE_SQUASH_EDIT:
1280                 Text.LoadString(IDS_COMMITBUTTON);
1281                 break;
1282
1283         case REBASE_ABORT:
1284         case REBASE_FINISH:
1285                 Text.LoadString(IDS_FINISHBUTTON);
1286                 break;
1287
1288         case REBASE_DONE:
1289                 Text.LoadString(IDS_DONE);
1290                 break;
1291         }
1292         this->GetDlgItem(IDC_REBASE_CONTINUE)->SetWindowText(Text);
1293 }
1294
1295 void CRebaseDlg::SetControlEnable()
1296 {
1297         switch(this->m_RebaseStage)
1298         {
1299         case CHOOSE_BRANCH:
1300         case CHOOSE_COMMIT_PICK_MODE:
1301
1302                 this->GetDlgItem(IDC_PICK_ALL)->EnableWindow(TRUE);
1303                 this->GetDlgItem(IDC_EDIT_ALL)->EnableWindow(TRUE);
1304                 this->GetDlgItem(IDC_SQUASH_ALL)->EnableWindow(TRUE);
1305                 this->GetDlgItem(IDC_BUTTON_UP2)->EnableWindow(TRUE);
1306                 this->GetDlgItem(IDC_BUTTON_DOWN2)->EnableWindow(TRUE);
1307
1308                 if(!m_IsCherryPick)
1309                 {
1310                         this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(TRUE);
1311                         this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(TRUE);
1312                         this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(TRUE);
1313                 }
1314                 //this->m_CommitList.m_IsEnableRebaseMenu=TRUE;
1315                 this->m_CommitList.m_ContextMenuMask |= m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_PICK)|
1316                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SQUASH)|
1317                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_EDIT)|
1318                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SKIP);
1319                 break;
1320
1321         case REBASE_START:
1322         case REBASE_CONTINUE:
1323         case REBASE_ABORT:
1324         case REBASE_ERROR:
1325         case REBASE_FINISH:
1326         case REBASE_CONFLICT:
1327         case REBASE_EDIT:
1328         case REBASE_SQUASH_CONFLICT:
1329         case REBASE_DONE:
1330                 this->GetDlgItem(IDC_PICK_ALL)->EnableWindow(FALSE);
1331                 this->GetDlgItem(IDC_EDIT_ALL)->EnableWindow(FALSE);
1332                 this->GetDlgItem(IDC_SQUASH_ALL)->EnableWindow(FALSE);
1333                 this->GetDlgItem(IDC_REBASE_COMBOXEX_BRANCH)->EnableWindow(FALSE);
1334                 this->GetDlgItem(IDC_REBASE_COMBOXEX_UPSTREAM)->EnableWindow(FALSE);
1335                 this->GetDlgItem(IDC_REBASE_CHECK_FORCE)->EnableWindow(FALSE);
1336                 this->GetDlgItem(IDC_BUTTON_UP2)->EnableWindow(FALSE);
1337                 this->GetDlgItem(IDC_BUTTON_DOWN2)->EnableWindow(FALSE);
1338                 //this->m_CommitList.m_IsEnableRebaseMenu=FALSE;
1339                 this->m_CommitList.m_ContextMenuMask &= ~(m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_PICK)|
1340                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SQUASH)|
1341                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_EDIT)|
1342                                                                                                 m_CommitList.GetContextMenuBit(CGitLogListBase::ID_REBASE_SKIP));
1343
1344                 if( m_RebaseStage == REBASE_DONE && (this->m_PostButtonTexts.GetCount() != 0) )
1345                 {
1346                         this->GetDlgItem(IDC_STATUS_STATIC)->ShowWindow(SW_HIDE);
1347                         this->GetDlgItem(IDC_REBASE_POST_BUTTON)->ShowWindow(SW_SHOWNORMAL);
1348                         this->m_PostButton.RemoveAll();
1349                         this->m_PostButton.AddEntries(m_PostButtonTexts);
1350                         //this->GetDlgItem(IDC_REBASE_POST_BUTTON)->SetWindowText(this->m_PostButtonText);
1351                 }
1352                 break;
1353         }
1354
1355         if(m_bThreadRunning)
1356         {
1357                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1358
1359         }
1360         else if (m_RebaseStage != REBASE_ERROR)
1361         {
1362                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(TRUE);
1363         }
1364 }
1365
1366 void CRebaseDlg::UpdateProgress()
1367 {
1368         int index;
1369         CRect rect;
1370
1371         if(m_CommitList.m_IsOldFirst)
1372                 index = m_CurrentRebaseIndex+1;
1373         else
1374                 index = m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1375
1376         m_ProgressBar.SetRange32(1, m_CommitList.GetItemCount());
1377         m_ProgressBar.SetPos(index);
1378         if (m_pTaskbarList)
1379         {
1380                 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1381                 m_pTaskbarList->SetProgressValue(m_hWnd, index, m_CommitList.GetItemCount());
1382         }
1383
1384         if(m_CurrentRebaseIndex>=0 && m_CurrentRebaseIndex< m_CommitList.GetItemCount())
1385         {
1386                 CString text;
1387                 text.Format(IDS_PROC_REBASING_PROGRESS, index, m_CommitList.GetItemCount());
1388                 m_CtrlStatusText.SetWindowText(text);
1389
1390         }
1391
1392         GitRev *prevRev=NULL, *curRev=NULL;
1393
1394         if( m_CurrentRebaseIndex >= 0 && m_CurrentRebaseIndex< m_CommitList.m_arShownList.GetSize())
1395         {
1396                 curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1397         }
1398
1399         for (int i = 0; i < m_CommitList.m_arShownList.GetSize(); ++i)
1400         {
1401                 prevRev=(GitRev*)m_CommitList.m_arShownList[i];
1402                 if(prevRev->GetAction(&m_CommitList) & CTGitPath::LOGACTIONS_REBASE_CURRENT)
1403                 {
1404                         prevRev->GetAction(&m_CommitList) &= ~ CTGitPath::LOGACTIONS_REBASE_CURRENT;
1405                         m_CommitList.GetItemRect(i,&rect,LVIR_BOUNDS);
1406                         m_CommitList.InvalidateRect(rect);
1407                 }
1408         }
1409
1410         if(curRev)
1411         {
1412                 curRev->GetAction(&m_CommitList) |= CTGitPath::LOGACTIONS_REBASE_CURRENT;
1413                 m_CommitList.GetItemRect(m_CurrentRebaseIndex,&rect,LVIR_BOUNDS);
1414                 m_CommitList.InvalidateRect(rect);
1415         }
1416         m_CommitList.EnsureVisible(m_CurrentRebaseIndex,FALSE);
1417 }
1418
1419 void CRebaseDlg::UpdateCurrentStatus()
1420 {
1421         SetContinueButtonText();
1422         SetControlEnable();
1423         UpdateProgress();
1424 }
1425
1426 void CRebaseDlg::AddLogString(CString str)
1427 {
1428         this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, FALSE);
1429         CStringA sTextA = m_wndOutputRebase.StringForControl(str);//CUnicodeUtils::GetUTF8(str);
1430         this->m_wndOutputRebase.SendMessage(SCI_DOCUMENTEND);
1431         this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)sTextA);
1432         this->m_wndOutputRebase.SendMessage(SCI_REPLACESEL, 0, (LPARAM)(LPCSTR)"\n");
1433         this->m_wndOutputRebase.SendMessage(SCI_SETREADONLY, TRUE);
1434 }
1435
1436 int CRebaseDlg::GetCurrentCommitID()
1437 {
1438         if(m_CommitList.m_IsOldFirst)
1439         {
1440                 return this->m_CurrentRebaseIndex+1;
1441
1442         }
1443         else
1444         {
1445                 return m_CommitList.GetItemCount()-m_CurrentRebaseIndex;
1446         }
1447 }
1448
1449 int CRebaseDlg::DoRebase()
1450 {
1451         CString cmd,out;
1452         if(m_CurrentRebaseIndex <0)
1453                 return 0;
1454         if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1455                 return 0;
1456
1457         GitRev *pRev = (GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1458         int mode=pRev->GetAction(&m_CommitList) & CTGitPath::LOGACTIONS_REBASE_MODE_MASK;
1459         CString nocommit;
1460
1461         if( mode== CTGitPath::LOGACTIONS_REBASE_SKIP)
1462         {
1463                 pRev->GetAction(&m_CommitList)|= CTGitPath::LOGACTIONS_REBASE_DONE;
1464                 return 0;
1465         }
1466
1467         if (!CheckNextCommitIsSquash() || mode != CTGitPath::LOGACTIONS_REBASE_PICK)
1468         { // next commit is squash or not pick
1469                 if (!this->m_SquashMessage.IsEmpty())
1470                         this->m_SquashMessage += _T("\n\n");
1471                 this->m_SquashMessage += pRev->GetSubject();
1472                 this->m_SquashMessage += _T("\n");
1473                 this->m_SquashMessage += pRev->GetBody().TrimRight();
1474         }
1475         else
1476                 this->m_SquashMessage.Empty();
1477
1478         if (!CheckNextCommitIsSquash() || mode == CTGitPath::LOGACTIONS_REBASE_SQUASH)
1479         { // next or this commit is squash
1480                 nocommit=_T(" --no-commit ");
1481         }
1482
1483         CString log;
1484         log.Format(_T("%s %d: %s"),CTGitPath::GetActionName(mode),this->GetCurrentCommitID(),pRev->m_CommitHash.ToString());
1485         AddLogString(log);
1486         AddLogString(pRev->GetSubject());
1487         if (pRev->GetSubject().IsEmpty())
1488         {
1489                 CMessageBox::Show(m_hWnd, IDS_PROC_REBASE_EMPTYCOMMITMSG, IDS_APPNAME, MB_OK | MB_ICONEXCLAMATION);
1490                 mode = CTGitPath::LOGACTIONS_REBASE_EDIT;
1491         }
1492
1493         CString cherryPickedFrom;
1494         if (m_bAddCherryPickedFrom)
1495                 cherryPickedFrom = _T("-x ");
1496
1497         cmd.Format(_T("git.exe cherry-pick %s%s %s"), cherryPickedFrom, nocommit, pRev->m_CommitHash.ToString());
1498
1499         if(g_Git.Run(cmd,&out,CP_UTF8))
1500         {
1501                 AddLogString(out);
1502                 CTGitPathList list;
1503                 if(g_Git.ListConflictFile(list))
1504                 {
1505                         AddLogString(_T("Get conflict files fail"));
1506                         return -1;
1507                 }
1508                 if(list.GetCount() == 0 )
1509                 {
1510                         if(mode ==  CTGitPath::LOGACTIONS_REBASE_PICK)
1511                         {
1512                                 m_RebaseStage = REBASE_ERROR;
1513                                 AddLogString(_T("An unrecoverable error occoured."));
1514                                 return -1;
1515                         }
1516                         if(mode == CTGitPath::LOGACTIONS_REBASE_EDIT)
1517                         {
1518                                 this->m_RebaseStage = REBASE_EDIT ;
1519                                 return -1; // Edit return -1 to stop rebase.
1520                         }
1521                         // Squash Case
1522                         if(CheckNextCommitIsSquash())
1523                         {   // no squash
1524                                 // let user edit last commmit message
1525                                 this->m_RebaseStage = REBASE_SQUASH_EDIT;
1526                                 return -1;
1527                         }
1528                 }
1529                 if(mode == CTGitPath::LOGACTIONS_REBASE_SQUASH)
1530                         m_RebaseStage = REBASE_SQUASH_CONFLICT;
1531                 else
1532                         m_RebaseStage = REBASE_CONFLICT;
1533                 return -1;
1534
1535         }
1536         else
1537         {
1538                 AddLogString(out);
1539                 if(mode ==  CTGitPath::LOGACTIONS_REBASE_PICK)
1540                 {
1541                         pRev->GetAction(&m_CommitList)|= CTGitPath::LOGACTIONS_REBASE_DONE;
1542                         return 0;
1543                 }
1544                 if(mode == CTGitPath::LOGACTIONS_REBASE_EDIT)
1545                 {
1546                         this->m_RebaseStage = REBASE_EDIT ;
1547                         return -1; // Edit return -1 to stop rebase.
1548                 }
1549
1550                 // Squash Case
1551                 if(CheckNextCommitIsSquash())
1552                 {   // no squash
1553                         // let user edit last commmit message
1554                         this->m_RebaseStage = REBASE_SQUASH_EDIT;
1555                         return -1;
1556                 }
1557                 else if(mode == CTGitPath::LOGACTIONS_REBASE_SQUASH)
1558                         pRev->GetAction(&m_CommitList)|= CTGitPath::LOGACTIONS_REBASE_DONE;
1559         }
1560
1561         return 0;
1562 }
1563
1564 BOOL CRebaseDlg::IsEnd()
1565 {
1566         if(m_CommitList.m_IsOldFirst)
1567                 return m_CurrentRebaseIndex>= this->m_CommitList.GetItemCount();
1568         else
1569                 return m_CurrentRebaseIndex<0;
1570 }
1571
1572 int CRebaseDlg::RebaseThread()
1573 {
1574         CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
1575
1576         int ret=0;
1577         while(1)
1578         {
1579                 if( m_RebaseStage == REBASE_START )
1580                 {
1581                         if( this->StartRebase() )
1582                         {
1583                                 ret = -1;
1584                                 break;
1585                         }
1586                         m_RebaseStage = REBASE_CONTINUE;
1587
1588                 }
1589                 else if( m_RebaseStage == REBASE_CONTINUE )
1590                 {
1591                         this->GoNext();
1592                         SendMessage(MSG_REBASE_UPDATE_UI);
1593                         if(IsEnd())
1594                         {
1595                                 ret = 0;
1596                                 m_RebaseStage = REBASE_FINISH;
1597
1598                         }
1599                         else
1600                         {
1601                                 ret = DoRebase();
1602
1603                                 if( ret )
1604                                 {
1605                                         break;
1606                                 }
1607                         }
1608
1609                 }
1610                 else if( m_RebaseStage == REBASE_FINISH )
1611                 {
1612                         SendMessage(MSG_REBASE_UPDATE_UI);
1613                         m_RebaseStage = REBASE_DONE;
1614                         break;
1615
1616                 }
1617                 else
1618                 {
1619                         break;
1620                 }
1621                 this->PostMessage(MSG_REBASE_UPDATE_UI);
1622         }
1623
1624         InterlockedExchange(&m_bThreadRunning, FALSE);
1625         this->PostMessage(MSG_REBASE_UPDATE_UI);
1626         return ret;
1627 }
1628
1629 void CRebaseDlg::ListConflictFile()
1630 {
1631         this->m_FileListCtrl.Clear();
1632         m_FileListCtrl.SetHasCheckboxes(true);
1633         CTGitPathList list;
1634         CTGitPath path;
1635         list.AddPath(path);
1636
1637         m_FileListCtrl.m_bIsRevertTheirMy = !m_IsCherryPick;
1638
1639         this->m_FileListCtrl.GetStatus(&list,true);
1640         this->m_FileListCtrl.Show(CTGitPath::LOGACTIONS_UNMERGED|CTGitPath::LOGACTIONS_MODIFIED|CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_DELETED,
1641                                                            CTGitPath::LOGACTIONS_UNMERGED);
1642
1643         m_FileListCtrl.Check(GITSLC_SHOWFILES);
1644 }
1645
1646 LRESULT CRebaseDlg::OnRebaseUpdateUI(WPARAM,LPARAM)
1647 {
1648         if (m_RebaseStage == REBASE_FINISH)
1649         {
1650                 FinishRebase();
1651                 if (m_pTaskbarList)
1652                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
1653                 return 0;
1654         }
1655         UpdateCurrentStatus();
1656         if(m_CurrentRebaseIndex <0)
1657                 return 0;
1658         if(m_CurrentRebaseIndex >= m_CommitList.GetItemCount() )
1659                 return 0;
1660         GitRev *curRev=(GitRev*)m_CommitList.m_arShownList[m_CurrentRebaseIndex];
1661
1662         switch(m_RebaseStage)
1663         {
1664         case REBASE_CONFLICT:
1665         case REBASE_SQUASH_CONFLICT:
1666                 ListConflictFile();
1667                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_CONFLICT);
1668                 if (m_pTaskbarList)
1669                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1670                 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1671                 this->m_LogMessageCtrl.SetText(curRev->GetSubject()+_T("\n")+curRev->GetBody());
1672                 break;
1673         case REBASE_EDIT:
1674                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1675                 if (m_pTaskbarList)
1676                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
1677                 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1678                 this->m_LogMessageCtrl.SetText(curRev->GetSubject()+_T("\n")+curRev->GetBody());
1679                 break;
1680         case REBASE_SQUASH_EDIT:
1681                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_MESSAGE);
1682                 this->m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1683                 this->m_LogMessageCtrl.SetText(this->m_SquashMessage);
1684                 if (m_pTaskbarList)
1685                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
1686                 break;
1687         default:
1688                 this->m_ctrlTabCtrl.SetActiveTab(REBASE_TAB_LOG);
1689         }
1690         return 0;
1691 }
1692 void CRebaseDlg::OnCancel()
1693 {
1694         OnBnClickedAbort();
1695 }
1696 void CRebaseDlg::OnBnClickedAbort()
1697 {
1698         if (m_pTaskbarList)
1699                 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
1700
1701         CString cmd,out;
1702         CString pron = m_OrigUpstreamHash.ToString();
1703         if(m_OrigUpstreamHash.IsEmpty())
1704         {
1705                 __super::OnCancel();
1706         }
1707
1708         if(m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage== CHOOSE_COMMIT_PICK_MODE)
1709         {
1710                 return;
1711         }
1712
1713         if(CMessageBox::Show(NULL, IDS_PROC_REBASE_ABORT, IDS_APPNAME, MB_YESNO) != IDYES)
1714                 return;
1715
1716         if(this->m_IsFastForward)
1717         {
1718                 cmd.Format(_T("git.exe reset --hard  %s"),this->m_OrigBranchHash.ToString());
1719                 while (true)
1720                 {
1721                         out.Empty();
1722                         if (g_Git.Run(cmd, &out, CP_UTF8))
1723                         {
1724                                 AddLogString(out);
1725                                 if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1726                                         break;
1727                         }
1728                         else
1729                                 break;
1730                 }
1731                 __super::OnCancel();
1732                 return;
1733         }
1734         cmd.Format(_T("git.exe checkout -f %s"),g_Git.FixBranchName(this->m_UpstreamCtrl.GetString()));
1735         while (true)
1736         {
1737                 out.Empty();
1738                 if (g_Git.Run(cmd, &out, CP_UTF8))
1739                 {
1740                         AddLogString(out);
1741                         if (CMessageBox::Show(this->m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1742                         {
1743                                 __super::OnCancel();
1744                                 return;
1745                         }
1746                 }
1747                 else
1748                         break;
1749         }
1750
1751         cmd.Format(_T("git.exe reset --hard  %s"),this->m_OrigUpstreamHash.ToString());
1752         while (true)
1753         {
1754                 out.Empty();
1755                 if (g_Git.Run(cmd, &out, CP_UTF8))
1756                 {
1757                         AddLogString(out);
1758                         if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1759                         {
1760                                 __super::OnCancel();
1761                                 return;
1762                         }
1763                 }
1764                 else
1765                         break;
1766         }
1767
1768         if(this->m_IsCherryPick) //there are not "branch" at cherry pick mode
1769         {
1770                 __super::OnCancel();
1771                 return;
1772         }
1773
1774         cmd.Format(_T("git checkout -f %s"),this->m_BranchCtrl.GetString());
1775         if(g_Git.Run(cmd,&out,CP_UTF8))
1776         {
1777                 AddLogString(out);
1778                 ::MessageBox(this->m_hWnd, _T("Unrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_ICONERROR);
1779                 __super::OnCancel();
1780                 return;
1781         }
1782
1783         cmd.Format(_T("git.exe reset --hard  %s"),this->m_OrigBranchHash.ToString());
1784         while (true)
1785         {
1786                 out.Empty();
1787                 if (g_Git.Run(cmd, &out, CP_UTF8))
1788                 {
1789                         AddLogString(out);
1790                         if (CMessageBox::Show(m_hWnd, _T("Retry?\nUnrecoverable error on cleanup:\n") + out, _T("TortoiseGit"), MB_YESNO | MB_ICONERROR) != IDYES)
1791                                 break;
1792                 }
1793                 else
1794                         break;
1795         }
1796         __super::OnCancel();
1797 }
1798
1799 void CRebaseDlg::OnBnClickedButtonBrowse()
1800 {
1801         if(CBrowseRefsDlg::PickRefForCombo(&m_UpstreamCtrl, gPickRef_NoTag))
1802                 OnCbnSelchangeUpstream();
1803 }
1804
1805 void CRebaseDlg::OnBnClickedRebaseCheckForce()
1806 {
1807         this->UpdateData();
1808         this->FetchLogList();
1809         if(this->CheckRebaseCondition())
1810         {
1811                 /* Disable Start Rebase */
1812                 this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1813         }
1814 }
1815
1816 void CRebaseDlg::OnBnClickedRebasePostButton()
1817 {
1818         this->m_Upstream=this->m_UpstreamCtrl.GetString();
1819         this->m_Branch=this->m_BranchCtrl.GetString();
1820
1821         this->EndDialog((int)(IDC_REBASE_POST_BUTTON+this->m_PostButton.GetCurrentEntry()));
1822 }
1823
1824 LRESULT CRebaseDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
1825 {
1826         Refresh();
1827         return 0;
1828 }
1829
1830 void CRebaseDlg::Refresh()
1831 {
1832         if (m_RebaseStage == REBASE_CONFLICT || m_RebaseStage == REBASE_SQUASH_CONFLICT)
1833         {
1834                 ListConflictFile();
1835                 return;
1836         }
1837
1838         if(this->m_IsCherryPick)
1839                 return ;
1840
1841         if(this->m_RebaseStage == CHOOSE_BRANCH )
1842         {
1843                 this->UpdateData();
1844                 this->FetchLogList();
1845                 if(this->CheckRebaseCondition())
1846                 {
1847                         /* Disable Start Rebase */
1848                         this->GetDlgItem(IDC_REBASE_CONTINUE)->EnableWindow(FALSE);
1849                 }
1850         }
1851 }
1852
1853 void CRebaseDlg::OnBnClickedButtonUp2()
1854 {
1855         POSITION pos;
1856         pos = m_CommitList.GetFirstSelectedItemPosition();
1857
1858         // do nothing if the first selected item is the first item in the list
1859         if (m_CommitList.GetNextSelectedItem(pos) == 0)
1860                 return;
1861
1862         pos = m_CommitList.GetFirstSelectedItemPosition();
1863
1864         bool changed = false;
1865         while(pos)
1866         {
1867                 int index=m_CommitList.GetNextSelectedItem(pos);
1868                 if(index>=1)
1869                 {
1870                         CGitHash old = m_CommitList.m_logEntries[index-1];
1871                         m_CommitList.m_logEntries[index-1] = m_CommitList.m_logEntries[index];
1872                         m_CommitList.m_logEntries[index] = old;
1873                         m_CommitList.SetItemState(index-1, LVIS_SELECTED, LVIS_SELECTED);
1874                         m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
1875                         changed = true;
1876                 }
1877         }
1878         if (changed)
1879         {
1880                 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
1881                 m_CommitList.Invalidate();
1882                 m_CommitList.SetFocus();
1883         }
1884 }
1885
1886 void CRebaseDlg::OnBnClickedButtonDown2()
1887 {
1888         if (m_CommitList.GetSelectedCount() == 0)
1889                 return;
1890
1891         POSITION pos;
1892         pos = m_CommitList.GetFirstSelectedItemPosition();
1893         bool changed = false;
1894         // use an array to store all selected item indexes; the user won't select too much items
1895         int* indexes = NULL;
1896         indexes = new int[m_CommitList.GetSelectedCount()];
1897         int i = 0;
1898         while(pos)
1899         {
1900                 indexes[i++] = m_CommitList.GetNextSelectedItem(pos);
1901         }
1902         // don't move any item if the last selected item is the last item in the m_CommitList
1903         // (that would change the order of the selected items)
1904         if(indexes[m_CommitList.GetSelectedCount() - 1] < m_CommitList.GetItemCount() - 1)
1905         {
1906                 // iterate over the indexes backwards in order to correctly move multiselected items
1907                 for (i = m_CommitList.GetSelectedCount() - 1; i >= 0; i--)
1908                 {
1909                         int index = indexes[i];
1910                         CGitHash old = m_CommitList.m_logEntries[index+1];
1911                         m_CommitList.m_logEntries[index+1] = m_CommitList.m_logEntries[index];
1912                         m_CommitList.m_logEntries[index] = old;
1913                         m_CommitList.SetItemState(index, 0, LVIS_SELECTED);
1914                         m_CommitList.SetItemState(index+1, LVIS_SELECTED, LVIS_SELECTED);
1915                         changed = true;
1916                 }
1917         }
1918         delete [] indexes;
1919         indexes = NULL;
1920         if (changed)
1921         {
1922                 m_CommitList.RecalculateShownList(&m_CommitList.m_arShownList);
1923                 m_CommitList.Invalidate();
1924                 m_CommitList.SetFocus();
1925         }
1926 }
1927
1928 LRESULT CRebaseDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
1929 {
1930         m_pTaskbarList.Release();
1931         m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
1932         return 0;
1933 }
1934
1935 void CRebaseDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1936 {
1937         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1938         *pResult = 0;
1939         if(m_CommitList.m_bNoDispUpdates)
1940                 return;
1941         if (pNMLV->iItem >= 0)
1942         {
1943                 this->m_CommitList.m_nSearchIndex = pNMLV->iItem;
1944                 if (pNMLV->iSubItem != 0)
1945                         return;
1946                 if ((pNMLV->iItem == m_CommitList.m_arShownList.GetCount()))
1947                 {
1948                         // remove the selected state
1949                         if (pNMLV->uChanged & LVIF_STATE)
1950                         {
1951                                 m_CommitList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
1952                                 FillLogMessageCtrl();
1953                         }
1954                         return;
1955                 }
1956                 if (pNMLV->uChanged & LVIF_STATE)
1957                 {
1958                         FillLogMessageCtrl();
1959                 }
1960         }
1961         else
1962         {
1963                 FillLogMessageCtrl();
1964         }
1965 }
1966
1967 void CRebaseDlg::FillLogMessageCtrl()
1968 {
1969         int selCount = m_CommitList.GetSelectedCount();
1970         if (selCount == 1 && (m_RebaseStage == CHOOSE_BRANCH || m_RebaseStage == CHOOSE_COMMIT_PICK_MODE))
1971         {
1972                 POSITION pos = m_CommitList.GetFirstSelectedItemPosition();
1973                 int selIndex = m_CommitList.GetNextSelectedItem(pos);
1974                 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_CommitList.m_arShownList.SafeGetAt(selIndex));
1975                 m_FileListCtrl.UpdateWithGitPathList(pLogEntry->GetFiles(&m_CommitList));
1976                 m_FileListCtrl.m_CurrentVersion = pLogEntry->m_CommitHash;
1977                 m_FileListCtrl.Show(GITSLC_SHOWVERSIONED);
1978                 m_LogMessageCtrl.Call(SCI_SETREADONLY, FALSE);
1979                 m_LogMessageCtrl.SetText(pLogEntry->GetSubject() + _T("\n") + pLogEntry->GetBody());
1980                 m_LogMessageCtrl.Call(SCI_SETREADONLY, TRUE);
1981         }
1982 }
1983 void CRebaseDlg::OnBnClickedCheckCherryPickedFrom()
1984 {
1985         UpdateData();
1986 }