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