src/TortoiseProc/RebaseDlg.cpp

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