src/TortoiseProc/RebaseDlg.cpp

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