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