src/TortoiseProc/RebaseDlg.cpp

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