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