src/TortoiseProc/RebaseDlg.cpp

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