src/TortoiseProc/RebaseDlg.cpp

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