src/TortoiseProc/FileDiffDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2016 - TortoiseGit
   4 // Copyright (C) 2003-2008 - TortoiseSVN
   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 #include "stdafx.h"
  21 #include "TortoiseProc.h"
  22 #include "UnicodeUtils.h"
  23 #include "MessageBox.h"
  24 #include "AppUtils.h"
  25 #include "SysImageList.h"
  26 #include "IconMenu.h"
  27 #include "StringUtils.h"
  28 #include "PathUtils.h"
  29 #include "BrowseFolder.h"
  30 #include "FileDiffDlg.h"
  31 #include "GitDiff.h"
  32 #include "LoglistCommonResource.h"
  33 #include "LoglistUtils.h"
  34 #include "BrowseRefsDlg.h"
  35 #include "LogDlg.h"
  36 #include "RefLogDlg.h"
  37 #include "GitStatusListCtrl.h"
  38 #include "FormatMessageWrapper.h"
  39
  40 #define ID_COMPARE 1
  41 #define ID_BLAME 2
  42 #define ID_SAVEAS 3
  43 #define ID_EXPORT 4
  44 #define ID_CLIPBOARD_PATH 5
  45 #define ID_CLIPBOARD_ALL 6
  46 #define ID_LOG 7
  47 #define ID_GNUDIFFCOMPARE 8
  48 #define ID_REVERT1 9
  49 #define ID_REVERT2 10
  50 #define ID_LOGSUBMODULE 11
  51
  52 BOOL    CFileDiffDlg::m_bAscending = TRUE;
  53 int             CFileDiffDlg::m_nSortedColumn = -1;
  54
  55 UINT CFileDiffDlg::WM_DISABLEBUTTONS = RegisterWindowMessage(L"TORTOISEGIT_FILEDIFF_DISABLEBUTTONS");
  56 UINT CFileDiffDlg::WM_DIFFFINISHED = RegisterWindowMessage(L"TORTOISEGIT_FILEDIFF_DIFFFINISHED");
  57
  58 IMPLEMENT_DYNAMIC(CFileDiffDlg, CResizableStandAloneDialog)
  59 CFileDiffDlg::CFileDiffDlg(CWnd* pParent /*=nullptr*/)
  60         : CResizableStandAloneDialog(CFileDiffDlg::IDD, pParent)
  61         , m_bBlame(false)
  62         , m_bCancelled(false)
  63         , m_nIconFolder(0)
  64         , m_bThreadRunning(FALSE)
  65         , m_bIgnoreSpaceAtEol(false)
  66         , m_bIgnoreSpaceChange(false)
  67         , m_bIgnoreAllSpace(false)
  68         , m_bIgnoreBlankLines(false)
  69         , m_bIsBare(false)
  70 {
  71         m_bLoadingRef=FALSE;
  72 }
  73
  74 CFileDiffDlg::~CFileDiffDlg()
  75 {
  76 }
  77
  78 void CFileDiffDlg::DoDataExchange(CDataExchange* pDX)
  79 {
  80         CResizableStandAloneDialog::DoDataExchange(pDX);
  81         DDX_Control(pDX, IDC_FILELIST, m_cFileList);
  82         DDX_Control(pDX, IDC_SWITCHLEFTRIGHT, m_SwitchButton);
  83         DDX_Control(pDX, IDC_REV1BTN, m_cRev1Btn);
  84         DDX_Control(pDX, IDC_REV2BTN, m_cRev2Btn);
  85         DDX_Control(pDX, IDC_FILTER, m_cFilter);
  86         DDX_Control(pDX, IDC_REV1EDIT, m_ctrRev1Edit);
  87         DDX_Control(pDX, IDC_REV2EDIT, m_ctrRev2Edit);
  88         DDX_Control(pDX, IDC_DIFFOPTION, m_cDiffOptionsBtn);
  89 }
  90
  91
  92 BEGIN_MESSAGE_MAP(CFileDiffDlg, CResizableStandAloneDialog)
  93         ON_NOTIFY(NM_DBLCLK, IDC_FILELIST, OnNMDblclkFilelist)
  94         ON_NOTIFY(LVN_GETINFOTIP, IDC_FILELIST, OnLvnGetInfoTipFilelist)
  95         ON_NOTIFY(NM_CUSTOMDRAW, IDC_FILELIST, OnNMCustomdrawFilelist)
  96         ON_WM_CONTEXTMENU()
  97         ON_WM_SETCURSOR()
  98         ON_EN_SETFOCUS(IDC_SECONDURL, &CFileDiffDlg::OnEnSetfocusSecondurl)
  99         ON_EN_SETFOCUS(IDC_FIRSTURL, &CFileDiffDlg::OnEnSetfocusFirsturl)
 100         ON_BN_CLICKED(IDC_SWITCHLEFTRIGHT, &CFileDiffDlg::OnBnClickedSwitchleftright)
 101         ON_NOTIFY(HDN_ITEMCLICK, 0, &CFileDiffDlg::OnHdnItemclickFilelist)
 102         ON_BN_CLICKED(IDC_REV1BTN, &CFileDiffDlg::OnBnClickedRev1btn)
 103         ON_BN_CLICKED(IDC_REV2BTN, &CFileDiffDlg::OnBnClickedRev2btn)
 104         ON_MESSAGE(WM_FILTEREDIT_CANCELCLICKED, OnClickedCancelFilter)
 105         ON_EN_CHANGE(IDC_FILTER, &CFileDiffDlg::OnEnChangeFilter)
 106         ON_WM_TIMER()
 107         ON_MESSAGE(ENAC_UPDATE, &CFileDiffDlg::OnEnUpdate)
 108         ON_MESSAGE(MSG_REF_LOADED, OnRefLoad)
 109         ON_REGISTERED_MESSAGE(WM_DISABLEBUTTONS, OnDisableButtons)
 110         ON_REGISTERED_MESSAGE(WM_DIFFFINISHED, OnDiffFinished)
 111         ON_BN_CLICKED(IDC_DIFFOPTION, OnBnClickedDiffoption)
 112         ON_BN_CLICKED(IDC_LOG, &CFileDiffDlg::OnBnClickedLog)
 113 END_MESSAGE_MAP()
 114
 115
 116 void CFileDiffDlg::SetDiff(const CTGitPath* path, const GitRev& baseRev1, const GitRev& rev2)
 117 {
 118         if (path)
 119         {
 120                 m_path1 = *path;
 121                 m_path2 = *path;
 122                 m_sFilter = path->GetGitPathString();
 123         }
 124         m_rev1 = baseRev1;
 125         m_rev2 = rev2;
 126 }
 127
 128 void CFileDiffDlg::SetDiff(const CTGitPath* path, const CString &baseRev1, const CString& hash2)
 129 {
 130         if (path)
 131         {
 132                 m_path1 = *path;
 133                 m_path2 = *path;
 134                 m_sFilter = path->GetGitPathString();
 135         }
 136
 137         BYTE_VECTOR logout;
 138
 139         if (baseRev1 == GIT_REV_ZERO)
 140         {
 141                 m_rev1.m_CommitHash.Empty();
 142                 m_rev1.GetSubject().LoadString(IDS_git_DEPTH_WORKING);
 143         }
 144         else
 145         {
 146                 if (m_rev1.GetCommit(baseRev1))
 147                         MessageBox(m_rev1.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
 148         }
 149
 150         logout.clear();
 151
 152         if(hash2 == GIT_REV_ZERO)
 153         {
 154                 m_rev2.m_CommitHash.Empty();
 155                 m_rev2.GetSubject().LoadString(IDS_git_DEPTH_WORKING);
 156         }
 157         else
 158         {
 159                 if (m_rev2.GetCommit(hash2))
 160                         MessageBox(m_rev2.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
 161         }
 162 }
 163
 164 void CFileDiffDlg::SetDiff(const CTGitPath* path, const GitRev &baseRev1)
 165 {
 166         if (path)
 167         {
 168                 m_path1 = *path;
 169                 m_path2 = *path;
 170                 m_sFilter = path->GetGitPathString();
 171         }
 172         m_rev1 = baseRev1;
 173         m_rev2.m_CommitHash.Empty();
 174         m_rev2.GetSubject().LoadString(IDS_PROC_PREVIOUSVERSION);
 175
 176         //this->GetDlgItem()->EnableWindow(FALSE);
 177 }
 178
 179 BOOL CFileDiffDlg::OnInitDialog()
 180 {
 181         CResizableStandAloneDialog::OnInitDialog();
 182         CString temp;
 183
 184         CString sWindowTitle;
 185         GetWindowText(sWindowTitle);
 186         CString pathText = g_Git.m_CurrentDir;
 187         if (!m_path1.IsEmpty())
 188                 pathText = g_Git.CombinePath(m_path1);
 189         CAppUtils::SetWindowTitle(m_hWnd, pathText, sWindowTitle);
 190
 191         this->m_ctrRev1Edit.Init();
 192         this->m_ctrRev2Edit.Init();
 193
 194         m_tooltips.AddTool(IDC_SWITCHLEFTRIGHT, IDS_FILEDIFF_SWITCHLEFTRIGHT_TT);
 195
 196         m_cFileList.SetRedraw(false);
 197         m_cFileList.DeleteAllItems();
 198         DWORD exStyle = LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP;
 199         if (CRegDWORD(L"Software\\TortoiseGit\\FullRowSelect", TRUE))
 200                 exStyle |= LVS_EX_FULLROWSELECT;
 201         m_cFileList.SetExtendedStyle(exStyle);
 202
 203         m_nIconFolder = SYS_IMAGE_LIST().GetDirIconIndex();
 204         m_cFileList.SetImageList(&SYS_IMAGE_LIST(), LVSIL_SMALL);
 205
 206         m_SwitchButton.SetImage((HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_SWITCHLEFTRIGHT), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR));
 207         m_SwitchButton.Invalidate();
 208
 209         m_cFilter.SetCancelBitmaps(IDI_CANCELNORMAL, IDI_CANCELPRESSED);
 210         m_cFilter.SetInfoIcon(IDI_FILTEREDIT);
 211         temp.LoadString(IDS_FILEDIFF_FILTERCUE);
 212         temp = L"   " + temp;
 213         m_cFilter.SetCueBanner(temp);
 214         if (!m_sFilter.IsEmpty())
 215                 m_cFilter.SetWindowText(m_sFilter);
 216
 217         int c = m_cFileList.GetHeaderCtrl()->GetItemCount() - 1;
 218         while (c>=0)
 219                 m_cFileList.DeleteColumn(c--);
 220
 221         temp.LoadString(IDS_FILEDIFF_FILE);
 222         m_cFileList.InsertColumn(0, temp);
 223         temp.LoadString(IDS_FILEDIFF_EXT);
 224         m_cFileList.InsertColumn(1, temp);
 225         temp.LoadString(IDS_FILEDIFF_ACTION);
 226         m_cFileList.InsertColumn(2, temp);
 227
 228         temp.LoadString(IDS_FILEDIFF_STATADD);
 229         m_cFileList.InsertColumn(3, temp);
 230         temp.LoadString(IDS_FILEDIFF_STATDEL);
 231         m_cFileList.InsertColumn(4, temp);
 232
 233         int mincol = 0;
 234         int maxcol = m_cFileList.GetHeaderCtrl()->GetItemCount() - 1;
 235         int col;
 236         for (col = mincol; col <= maxcol; col++)
 237                 m_cFileList.SetColumnWidth(col,LVSCW_AUTOSIZE_USEHEADER);
 238
 239         m_cFileList.SetRedraw(true);
 240
 241         AddAnchor(IDC_DIFFSTATIC1, TOP_LEFT, TOP_RIGHT);
 242         AddAnchor(IDC_SWITCHLEFTRIGHT, TOP_RIGHT);
 243         AddAnchor(IDC_FIRSTURL, TOP_LEFT, TOP_RIGHT);
 244         AddAnchor(IDC_REV1BTN, TOP_RIGHT);
 245         //AddAnchor(IDC_DIFFSTATIC2, TOP_LEFT, TOP_RIGHT);
 246         AddAnchor(IDC_SECONDURL, TOP_LEFT, TOP_RIGHT);
 247         AddAnchor(IDC_REV2BTN, TOP_RIGHT);
 248         AddAnchor(IDC_FILTER, TOP_LEFT, TOP_RIGHT);
 249         AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);
 250         AddAnchor(IDC_REV1GROUP,TOP_LEFT,TOP_RIGHT);
 251         AddAnchor(IDC_REV2GROUP,TOP_LEFT,TOP_RIGHT);
 252         AddAnchor(IDC_REV1EDIT,TOP_LEFT);
 253         AddAnchor(IDC_REV2EDIT,TOP_LEFT);
 254         AddAnchor(IDC_DIFFOPTION, TOP_RIGHT);
 255         AddAnchor(IDC_LOG, TOP_RIGHT);
 256
 257         EnableSaveRestore(L"FileDiffDlg");
 258
 259         m_bIsBare = GitAdminDir::IsBareRepo(g_Git.m_CurrentDir);
 260
 261         if(this->m_strRev1.IsEmpty())
 262                 this->m_ctrRev1Edit.SetWindowText(this->m_rev1.m_CommitHash.ToString());
 263         else
 264         {
 265                 if (m_rev1.GetCommit(m_strRev1))
 266                 {
 267                         CString msg;
 268                         msg.Format(IDS_PROC_REFINVALID, (LPCTSTR)m_strRev1);
 269                         m_cFileList.ShowText(msg + L'\n' + m_rev1.GetLastErr());
 270                 }
 271
 272                 this->m_ctrRev1Edit.SetWindowText(m_strRev1);
 273         }
 274
 275         if(this->m_strRev2.IsEmpty())
 276                 this->m_ctrRev2Edit.SetWindowText(this->m_rev2.m_CommitHash.ToString());
 277         else
 278         {
 279                 if (m_rev2.GetCommit(m_strRev2))
 280                 {
 281                         CString msg;
 282                         msg.Format(IDS_PROC_REFINVALID, (LPCTSTR)m_strRev2);
 283                         m_cFileList.ShowText(msg + L'\n' + m_rev1.GetLastErr());
 284                 }
 285
 286                 this->m_ctrRev2Edit.SetWindowText(m_strRev2);
 287         }
 288
 289         SetURLLabels();
 290
 291         InterlockedExchange(&m_bThreadRunning, TRUE);
 292         if (!AfxBeginThread(DiffThreadEntry, this))
 293         {
 294                 InterlockedExchange(&m_bThreadRunning, FALSE);
 295                 CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 296         }
 297
 298         InterlockedExchange(&m_bLoadingRef, TRUE);
 299         if (!AfxBeginThread(LoadRefThreadEntry, this))
 300         {
 301                 InterlockedExchange(&m_bLoadingRef, FALSE);
 302                 CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 303         }
 304
 305         this->m_cRev1Btn.AddEntry(CString(MAKEINTRESOURCE(IDS_REFBROWSE)));
 306         this->m_cRev1Btn.AddEntry(CString(MAKEINTRESOURCE(IDS_LOG)));
 307         this->m_cRev1Btn.AddEntry(CString(MAKEINTRESOURCE(IDS_REFLOG)));
 308
 309         this->m_cRev2Btn.AddEntry(CString(MAKEINTRESOURCE(IDS_REFBROWSE)));
 310         this->m_cRev2Btn.AddEntry(CString(MAKEINTRESOURCE(IDS_LOG)));
 311         this->m_cRev2Btn.AddEntry(CString(MAKEINTRESOURCE(IDS_REFLOG)));
 312
 313         // Start with focus on file list
 314         GetDlgItem(IDC_FILELIST)->SetFocus();
 315
 316         if(m_rev2.m_CommitHash.IsEmpty())
 317                 m_SwitchButton.EnableWindow(FALSE);
 318
 319         m_cDiffOptionsBtn.m_bAlwaysShowArrow = true;
 320
 321         KillTimer(IDT_INPUT);
 322         return FALSE;
 323 }
 324
 325 UINT CFileDiffDlg::DiffThreadEntry(LPVOID pVoid)
 326 {
 327         return reinterpret_cast<CFileDiffDlg*>(pVoid)->DiffThread();
 328 }
 329
 330 UINT CFileDiffDlg::DiffThread()
 331 {
 332         SendMessage(WM_DISABLEBUTTONS);
 333
 334         if( m_rev1.m_CommitHash.IsEmpty() || m_rev2.m_CommitHash.IsEmpty())
 335                 g_Git.RefreshGitIndex();
 336
 337         g_Git.GetCommitDiffList(m_rev2.m_CommitHash.ToString(), m_rev1.m_CommitHash.ToString(), m_arFileList, m_bIgnoreSpaceAtEol, m_bIgnoreSpaceChange, m_bIgnoreAllSpace, m_bIgnoreBlankLines);
 338         Sort();
 339
 340         SendMessage(WM_DIFFFINISHED);
 341
 342         InterlockedExchange(&m_bThreadRunning, FALSE);
 343         return 0;
 344 }
 345
 346 LRESULT CFileDiffDlg::OnDisableButtons(WPARAM, LPARAM)
 347 {
 348         RefreshCursor();
 349         m_cFileList.ShowText(CString(MAKEINTRESOURCE(IDS_FILEDIFF_WAIT)));
 350         m_cFileList.DeleteAllItems();
 351         m_arFileList.Clear();
 352         EnableInputControl(false);
 353         return 0;
 354 }
 355
 356 LRESULT CFileDiffDlg::OnDiffFinished(WPARAM, LPARAM)
 357 {
 358         CString sFilterText;
 359         m_cFilter.GetWindowText(sFilterText);
 360         m_cFileList.SetRedraw(false);
 361         Filter(sFilterText);
 362         if (!m_arFileList.IsEmpty())
 363         {
 364                 // Highlight first entry in file list
 365                 m_cFileList.SetSelectionMark(0);
 366                 m_cFileList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
 367         }
 368
 369         int mincol = 0;
 370         int maxcol = m_cFileList.GetHeaderCtrl()->GetItemCount() - 1;
 371         int col;
 372         for (col = mincol; col <= maxcol; ++col)
 373                 m_cFileList.SetColumnWidth(col, LVSCW_AUTOSIZE_USEHEADER);
 374
 375         m_cFileList.ClearText();
 376         if (m_arFileList.IsEmpty())
 377                 m_cFileList.ShowText(CString(MAKEINTRESOURCE(IDS_COMPAREREV_NODIFF)));
 378         m_cFileList.SetRedraw(true);
 379
 380         InvalidateRect(nullptr);
 381         RefreshCursor();
 382         EnableInputControl(true);
 383         return 0;
 384 }
 385
 386 int CFileDiffDlg::AddEntry(const CTGitPath * fd)
 387 {
 388         int ret = -1;
 389         if (fd)
 390         {
 391                 int index = m_cFileList.GetItemCount();
 392
 393                 int icon_idx = 0;
 394                 if (fd->IsDirectory())
 395                         icon_idx = m_nIconFolder;
 396                 else
 397                         icon_idx = SYS_IMAGE_LIST().GetPathIconIndex(fd->GetGitPathString());
 398
 399                 ret = m_cFileList.InsertItem(index, fd->GetGitPathString(), icon_idx);
 400                 m_cFileList.SetItemText(index, 1, fd->GetFileExtension());
 401                 m_cFileList.SetItemText(index, 2, fd->GetActionName());
 402                 m_cFileList.SetItemText(index, 3, fd->m_StatAdd);
 403                 m_cFileList.SetItemText(index, 4, fd->m_StatDel);
 404         }
 405         return ret;
 406 }
 407
 408 void CFileDiffDlg::EnableInputControl(bool b)
 409 {
 410         this->m_ctrRev1Edit.EnableWindow(b);
 411         this->m_ctrRev2Edit.EnableWindow(b);
 412         this->m_cRev1Btn.EnableWindow(b);
 413         this->m_cRev2Btn.EnableWindow(b);
 414         m_cFilter.EnableWindow(b);
 415         m_SwitchButton.EnableWindow(b);
 416         GetDlgItem(IDC_LOG)->EnableWindow(b && !(m_rev1.m_CommitHash.IsEmpty() || m_rev2.m_CommitHash.IsEmpty()));
 417 }
 418
 419 void CFileDiffDlg::DoDiff(int selIndex, bool blame)
 420 {
 421         CTGitPath* fd2 = m_arFilteredList[selIndex];
 422         CTGitPath* fd1 = fd2;
 423         if (m_rev2.m_CommitHash.IsEmpty() && g_Git.IsInitRepos())
 424         {
 425                 CGitDiff::DiffNull(fd2, GIT_REV_ZERO);
 426                 return;
 427         }
 428         if (fd1->m_Action & CTGitPath::LOGACTIONS_ADDED)
 429         {
 430                 CGitDiff::DiffNull(fd1, m_rev2.m_CommitHash.ToString(), true);
 431                 return;
 432         }
 433         if (fd1->m_Action & CTGitPath::LOGACTIONS_DELETED)
 434         {
 435                 CGitDiff::DiffNull(fd1, m_rev1.m_CommitHash.ToString(), false);
 436                 return;
 437         }
 438         if (fd1->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 439                 fd2 = new CTGitPath(fd1->GetGitOldPathString());
 440         CGitDiff::Diff(fd1, fd2, m_rev2.m_CommitHash.ToString(), m_rev1.m_CommitHash.ToString(), blame, FALSE);
 441         if (fd1 != fd2)
 442                 delete fd2;
 443 }
 444
 445
 446 void CFileDiffDlg::OnNMDblclkFilelist(NMHDR *pNMHDR, LRESULT *pResult)
 447 {
 448         *pResult = 0;
 449         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
 450         int selIndex = pNMLV->iItem;
 451         if (selIndex < 0)
 452                 return;
 453         if (selIndex >= (int)m_arFilteredList.size())
 454                 return;
 455
 456         DoDiff(selIndex, m_bBlame);
 457 }
 458
 459 void CFileDiffDlg::OnLvnGetInfoTipFilelist(NMHDR *pNMHDR, LRESULT *pResult)
 460 {
 461         LPNMLVGETINFOTIP pGetInfoTip = reinterpret_cast<LPNMLVGETINFOTIP>(pNMHDR);
 462         if (pGetInfoTip->iItem >= (int)m_arFilteredList.size())
 463                 return;
 464
 465         CString path = m_path1.GetGitPathString() + L'/' + m_arFilteredList[pGetInfoTip->iItem]->GetGitPathString();
 466         if (pGetInfoTip->cchTextMax > path.GetLength())
 467                         wcsncpy_s(pGetInfoTip->pszText, pGetInfoTip->cchTextMax, path, pGetInfoTip->cchTextMax - 1);
 468
 469         *pResult = 0;
 470 }
 471
 472 void CFileDiffDlg::OnNMCustomdrawFilelist(NMHDR *pNMHDR, LRESULT *pResult)
 473 {
 474         NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
 475         // Take the default processing unless we set this to something else below.
 476         *pResult = CDRF_DODEFAULT;
 477
 478         // First thing - check the draw stage. If it's the control's prepaint
 479         // stage, then tell Windows we want messages for every item.
 480
 481         if ( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage )
 482         {
 483                 *pResult = CDRF_NOTIFYITEMDRAW;
 484         }
 485         else if ( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage )
 486         {
 487                 // This is the prepaint stage for an item. Here's where we set the
 488                 // item's text color. Our return value will tell Windows to draw the
 489                 // item itself, but it will use the new color we set here.
 490
 491                 // Tell Windows to paint the control itself.
 492                 *pResult = CDRF_DODEFAULT;
 493
 494                 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
 495
 496                 if (m_arFilteredList.size() > pLVCD->nmcd.dwItemSpec)
 497                 {
 498                         CTGitPath * fd = m_arFilteredList[pLVCD->nmcd.dwItemSpec];
 499                         switch (fd->m_Action)
 500                         {
 501                         case CTGitPath::LOGACTIONS_ADDED:
 502                                 crText = m_colors.GetColor(CColors::Added);
 503                                 break;
 504                         case CTGitPath::LOGACTIONS_DELETED:
 505                                 crText = m_colors.GetColor(CColors::Deleted);
 506                                 break;
 507                         case CTGitPath::LOGACTIONS_MODIFIED:
 508                                 crText = m_colors.GetColor(CColors::Modified);
 509                                 break;
 510                         default:
 511                                 crText = m_colors.GetColor(CColors::PropertyChanged);
 512                                 break;
 513                         }
 514                 }
 515                 // Store the color back in the NMLVCUSTOMDRAW struct.
 516                 pLVCD->clrText = crText;
 517         }
 518 }
 519
 520 UINT CFileDiffDlg::LoadRefThread()
 521 {
 522         g_Git.GetBranchList(m_Reflist, nullptr, CGit::BRANCH_ALL_F);
 523         g_Git.GetTagList(m_Reflist);
 524
 525         this->PostMessage(MSG_REF_LOADED);
 526         InterlockedExchange(&m_bLoadingRef, FALSE);
 527         return 0;
 528 }
 529
 530 void CFileDiffDlg::OnContextMenu(CWnd* pWnd, CPoint point)
 531 {
 532         if (!pWnd || pWnd != &m_cFileList)
 533                 return;
 534         if (m_cFileList.GetSelectedCount() == 0)
 535                 return;
 536         // if the context menu is invoked through the keyboard, we have to use
 537         // a calculated position on where to anchor the menu on
 538         if ((point.x == -1) && (point.y == -1))
 539         {
 540                 CRect rect;
 541                 m_cFileList.GetItemRect(m_cFileList.GetSelectionMark(), &rect, LVIR_LABEL);
 542                 m_cFileList.ClientToScreen(&rect);
 543                 point = rect.CenterPoint();
 544         }
 545         CIconMenu popup;
 546         if (popup.CreatePopupMenu())
 547         {
 548                 int firstEntry = -1;
 549                 POSITION firstPos = m_cFileList.GetFirstSelectedItemPosition();
 550                 if (firstPos)
 551                         firstEntry = m_cFileList.GetNextSelectedItem(firstPos);
 552
 553                 CString menuText;
 554                 popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);
 555                 popup.AppendMenuIcon(ID_GNUDIFFCOMPARE, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
 556                 popup.AppendMenu(MF_SEPARATOR, NULL);
 557                 if (!m_bIsBare)
 558                 {
 559                         if (!m_rev1.m_CommitHash.IsEmpty())
 560                         {
 561                                 menuText.Format(IDS_FILEDIFF_POPREVERTTOREV, (LPCTSTR)m_rev1.m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()));
 562                                 popup.AppendMenuIcon(ID_REVERT1, menuText, IDI_REVERT);
 563                         }
 564                         if (!m_rev2.m_CommitHash.IsEmpty())
 565                         {
 566                                 menuText.Format(IDS_FILEDIFF_POPREVERTTOREV, (LPCTSTR)m_rev2.m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()));
 567                                 popup.AppendMenuIcon(ID_REVERT2, menuText, IDI_REVERT);
 568                         }
 569                         popup.AppendMenu(MF_SEPARATOR, NULL);
 570                 }
 571                 popup.AppendMenuIcon(ID_LOG, IDS_FILEDIFF_LOG, IDI_LOG);
 572                 if (firstEntry >= 0 && !m_arFilteredList[firstEntry]->IsDirectory())
 573                 {
 574                         if (!m_bIsBare)
 575                         {
 576                                 popup.AppendMenuIcon(ID_BLAME, IDS_FILEDIFF_POPBLAME, IDI_BLAME);
 577                                 popup.AppendMenu(MF_SEPARATOR, NULL);
 578                         }
 579                         popup.AppendMenuIcon(ID_EXPORT, IDS_FILEDIFF_POPEXPORT, IDI_EXPORT);
 580                 }
 581                 else if (firstEntry >= 0)
 582                         popup.AppendMenuIcon(ID_LOGSUBMODULE, IDS_MENULOGSUBMODULE, IDI_LOG);
 583                 popup.AppendMenu(MF_SEPARATOR, NULL);
 584                 popup.AppendMenuIcon(ID_SAVEAS, IDS_FILEDIFF_POPSAVELIST, IDI_SAVEAS);
 585                 popup.AppendMenuIcon(ID_CLIPBOARD_PATH, IDS_STATUSLIST_CONTEXT_COPY, IDI_COPYCLIP);
 586                 popup.AppendMenuIcon(ID_CLIPBOARD_ALL, IDS_STATUSLIST_CONTEXT_COPYEXT, IDI_COPYCLIP);
 587
 588                 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
 589                 m_bCancelled = false;
 590                 switch (cmd)
 591                 {
 592                 case ID_COMPARE:
 593                         {
 594                                 if (!CheckMultipleDiffs())
 595                                         break;
 596                                 POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
 597                                 while (pos)
 598                                 {
 599                                         int index = m_cFileList.GetNextSelectedItem(pos);
 600                                         DoDiff(index, false);
 601                                 }
 602                         }
 603                         break;
 604                 case ID_GNUDIFFCOMPARE:
 605                         {
 606                                 if (!CheckMultipleDiffs())
 607                                         break;
 608                                 POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
 609                                 while (pos)
 610                                 {
 611                                         CTGitPath *fd2 = m_arFilteredList[m_cFileList.GetNextSelectedItem(pos)];
 612                                         CTGitPath *fd1 = fd2;
 613                                         if (fd1->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 614                                                 fd2 = new CTGitPath(fd2->GetGitOldPathString());
 615                                         CAppUtils::StartShowUnifiedDiff(m_hWnd, *fd1, m_rev1.m_CommitHash.ToString(), *fd2, m_rev2.m_CommitHash.ToString(), !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
 616                                         if (fd1 != fd2)
 617                                                 delete fd2;
 618                                 }
 619                         }
 620                         break;
 621                 case ID_REVERT1:
 622                         RevertSelectedItemToVersion(m_rev1.m_CommitHash.ToString());
 623                         break;
 624                 case ID_REVERT2:
 625                         RevertSelectedItemToVersion(m_rev2.m_CommitHash.ToString());
 626                         break;
 627                 case ID_BLAME:
 628                         {
 629                                 if (!CheckMultipleDiffs())
 630                                         break;
 631                                 POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
 632                                 while (pos)
 633                                 {
 634                                         int index = m_cFileList.GetNextSelectedItem(pos);
 635                                         if (m_arFilteredList[index]->m_Action & CTGitPath::LOGACTIONS_DELETED)
 636                                         {
 637                                                 if (!m_rev1.m_CommitHash.IsEmpty())
 638                                                         CAppUtils::LaunchTortoiseBlame(m_arFilteredList[index]->GetWinPathString(), m_rev1.m_CommitHash.ToString());
 639                                                 continue;
 640                                         }
 641                                         if (m_rev2.m_CommitHash.IsEmpty() && (m_arFilteredList[index]->m_Action & CTGitPath::LOGACTIONS_ADDED))
 642                                                 continue;
 643                                         if (m_rev2.m_CommitHash.IsEmpty() && (m_arFilteredList[index]->m_Action & CTGitPath::LOGACTIONS_REPLACED))
 644                                         {
 645                                                 CAppUtils::LaunchTortoiseBlame(m_arFilteredList[index]->GetGitOldPathString(), m_rev1.m_CommitHash.ToString());
 646                                                 continue;
 647                                         }
 648                                         CAppUtils::LaunchTortoiseBlame(m_arFilteredList[index]->GetWinPathString(), m_rev2.m_CommitHash.ToString());
 649                                 }
 650                         }
 651                         break;
 652                 case ID_LOG:
 653                 case ID_LOGSUBMODULE:
 654                         {
 655                                 if (!CheckMultipleDiffs())
 656                                         break;
 657                                 POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
 658                                 while (pos)
 659                                 {
 660                                         int index = m_cFileList.GetNextSelectedItem(pos);
 661                                         CString sCmd = L"/command:log";
 662                                         if (sCmd == ID_LOGSUBMODULE)
 663                                                 sCmd += L" /submodule";
 664                                         sCmd += L" /path:\"" + m_arFilteredList[index]->GetWinPathString() + L"\" ";
 665                                         sCmd += L" /endrev:" + m_rev2.m_CommitHash.ToString();
 666                                         CAppUtils::RunTortoiseGitProc(sCmd);
 667                                 }
 668                         }
 669                         break;
 670                 case ID_SAVEAS:
 671                         {
 672                                 if (m_cFileList.GetSelectedCount() > 0)
 673                                 {
 674                                         CTGitPath savePath;
 675                                         CString pathSave;
 676                                         if (!CAppUtils::FileOpenSave(pathSave, nullptr, IDS_FILEDIFF_POPSAVELIST, IDS_TEXTFILEFILTER, false, m_hWnd, L"txt"))
 677                                                 break;
 678                                         savePath = CTGitPath(pathSave);
 679
 680                                         // now open the selected file for writing
 681                                         try
 682                                         {
 683                                                 CStdioFile file(savePath.GetWinPathString(), CFile::typeBinary | CFile::modeReadWrite | CFile::modeCreate);
 684                                                 CString temp;
 685                                                 if (m_path1.IsEmpty() && m_path2.IsEmpty())
 686                                                         temp.Format(IDS_FILEDIFF_CHANGEDLISTINTROROOT, (LPCTSTR)m_rev1.m_CommitHash.ToString(), (LPCTSTR)m_rev2.m_CommitHash.ToString());
 687                                                 else
 688                                                         temp.Format(IDS_FILEDIFF_CHANGEDLISTINTRO, (LPCTSTR)m_path1.GetGitPathString(), (LPCTSTR)m_rev1.m_CommitHash.ToString(), (LPCTSTR)m_path2.GetGitPathString(), (LPCTSTR)m_rev2.m_CommitHash.ToString());
 689                                                 file.WriteString(temp + L"\r\n");
 690                                                 POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
 691                                                 while (pos)
 692                                                 {
 693                                                         int index = m_cFileList.GetNextSelectedItem(pos);
 694                                                         CTGitPath* fd = m_arFilteredList[index];
 695                                                         file.WriteString(fd->GetGitPathString());
 696                                                         file.WriteString(L"\r\n");
 697                                                 }
 698                                                 file.Close();
 699                                         }
 700                                         catch (CFileException* pE)
 701                                         {
 702                                                 pE->ReportError();
 703                                         }
 704                                 }
 705                         }
 706                         break;
 707                 case ID_CLIPBOARD_PATH:
 708                         {
 709                                 CopySelectionToClipboard();
 710                         }
 711                         break;
 712
 713                 case ID_CLIPBOARD_ALL:
 714                         {
 715                                 CopySelectionToClipboard(TRUE);
 716                         }
 717                         break;
 718                 case ID_EXPORT:
 719                         {
 720                                 // export all changed files to a folder
 721                                 CBrowseFolder browseFolder;
 722                                 browseFolder.m_style = BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
 723                                 if (browseFolder.Show(GetSafeHwnd(), m_strExportDir) == CBrowseFolder::OK)
 724                                 {
 725                                         POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
 726                                         while (pos)
 727                                         {
 728                                                 int index = m_cFileList.GetNextSelectedItem(pos);
 729                                                 CTGitPath* fd = m_arFilteredList[index];
 730                                                 // we cannot export directories or folders
 731                                                 if (fd->m_Action == CTGitPath::LOGACTIONS_DELETED || fd->IsDirectory())
 732                                                         continue;
 733                                                 CPathUtils::MakeSureDirectoryPathExists(m_strExportDir + L'\\' + fd->GetContainingDirectory().GetWinPathString());
 734                                                 CString filename = m_strExportDir + L'\\' + fd->GetWinPathString();
 735                                                 if (m_rev2.m_CommitHash.ToString() == GIT_REV_ZERO)
 736                                                 {
 737                                                         if(!CopyFile(g_Git.CombinePath(fd), filename, false))
 738                                                         {
 739                                                                 MessageBox(CFormatMessageWrapper(), L"TortoiseGit", MB_OK | MB_ICONERROR);
 740                                                                 return;
 741                                                         }
 742                                                 }
 743                                                 else
 744                                                 {
 745                                                         if (g_Git.GetOneFile(m_rev2.m_CommitHash, *fd, filename))
 746                                                         {
 747                                                                 CString out;
 748                                                                 out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, (LPCTSTR)fd->GetGitPathString(), (LPCTSTR)m_rev2.m_CommitHash.ToString(), (LPCTSTR)filename);
 749                                                                 if (CMessageBox::Show(GetSafeHwnd(), g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), L"TortoiseGit", 2, IDI_WARNING, CString(MAKEINTRESOURCE(IDS_IGNOREBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 2)
 750                                                                         return;
 751                                                         }
 752                                                 }
 753                                         }
 754                                 }
 755                         }
 756
 757                         break;
 758
 759                 }
 760         }
 761 }
 762
 763 BOOL CFileDiffDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 764 {
 765         if (pWnd != &m_cFileList)
 766                 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
 767         if (m_bThreadRunning == 0)
 768         {
 769                 HCURSOR hCur = LoadCursor(nullptr, IDC_ARROW);
 770                 SetCursor(hCur);
 771                 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
 772         }
 773         HCURSOR hCur = LoadCursor(nullptr, IDC_WAIT);
 774         SetCursor(hCur);
 775         return TRUE;
 776 }
 777
 778 void CFileDiffDlg::OnEnSetfocusFirsturl()
 779 {
 780         GetDlgItem(IDC_FIRSTURL)->HideCaret();
 781 }
 782
 783 void CFileDiffDlg::OnEnSetfocusSecondurl()
 784 {
 785         GetDlgItem(IDC_SECONDURL)->HideCaret();
 786 }
 787
 788 void CFileDiffDlg::OnBnClickedSwitchleftright()
 789 {
 790         if (m_bThreadRunning)
 791                 return;
 792
 793 #if 0
 794         CString sFilterString;
 795         m_cFilter.GetWindowText(sFilterString);
 796
 797         m_cFileList.SetRedraw(false);
 798         m_cFileList.DeleteAllItems();
 799         for (int i=0; i<(int)m_arFileList.GetCount(); ++i)
 800         {
 801                 CTGitPath fd = m_arFileList[i];
 802                 if (fd.m_Action == CTGitPath::LOGACTIONS_ADDED)
 803                         fd.m_Action = CTGitPath::LOGACTIONS_DELETED;
 804                 else if (fd.m_Action == CTGitPath::LOGACTIONS_DELETED)
 805                         fd.m_Action = CTGitPath::LOGACTIONS_ADDED;
 806                 std::swap(fd.m_StatAdd, fd.m_StatDel);
 807                 (CTGitPath&)m_arFileList[i] = fd;
 808         }
 809         Filter(sFilterString);
 810 #endif
 811
 812         m_cFileList.SetRedraw(true);
 813         CTGitPath path = m_path1;
 814         m_path1 = m_path2;
 815         m_path2 = path;
 816         GitRev rev = m_rev1;
 817         m_rev1 = m_rev2;
 818         m_rev2 = rev;
 819
 820         CString str1,str2;
 821         this->m_ctrRev1Edit.GetWindowText(str1);
 822         this->m_ctrRev2Edit.GetWindowText(str2);
 823
 824         this->m_ctrRev1Edit.SetWindowText(str2);
 825         this->m_ctrRev2Edit.SetWindowText(str1);
 826
 827         SetURLLabels();
 828         //KillTimer(IDT_INPUT);
 829 }
 830
 831 void CFileDiffDlg::SetURLLabels(int mask)
 832 {
 833         if(mask &0x1)
 834         {
 835                 SetDlgItemText(IDC_FIRSTURL, m_rev1.m_CommitHash.ToString().Left(8) + L": " + m_rev1.GetSubject());
 836                 if (!m_rev1.m_CommitHash.IsEmpty())
 837                         m_tooltips.AddTool(IDC_FIRSTURL,
 838                                 CLoglistUtils::FormatDateAndTime(m_rev1.GetAuthorDate(), DATE_SHORTDATE) + L"  " + m_rev1.GetAuthorName());
 839         }
 840
 841         if(mask &0x2)
 842         {
 843                 SetDlgItemText(IDC_SECONDURL,m_rev2.m_CommitHash.ToString().Left(8) + L": " + m_rev2.GetSubject());
 844                 if (!m_rev2.m_CommitHash.IsEmpty())
 845                         m_tooltips.AddTool(IDC_SECONDURL,
 846                                 CLoglistUtils::FormatDateAndTime(m_rev2.GetAuthorDate(), DATE_SHORTDATE) + L"  " + m_rev2.GetAuthorName());
 847         }
 848
 849         this->GetDlgItem(IDC_REV1GROUP)->SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_FILEDIFF_VERSION1BASE)));
 850         this->GetDlgItem(IDC_REV2GROUP)->SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_FILEDIFF_VERSION2)));
 851
 852         if ((mask & 0x3) == 0x3 && !m_rev1.m_CommitHash.IsEmpty() && !m_rev2.m_CommitHash.IsEmpty())
 853                 if(m_rev1.GetCommitterDate() > m_rev2.GetCommitterDate())
 854                         GetDlgItem(IDC_REV1GROUP)->SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_FILEDIFF_VERSION1BASENEWER)));
 855                 else if (m_rev1.GetCommitterDate() < m_rev2.GetCommitterDate())
 856                         GetDlgItem(IDC_REV2GROUP)->SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_FILEDIFF_VERSION2NEWER)));
 857 }
 858
 859 void CFileDiffDlg::ClearURLabels(int mask)
 860 {
 861         if(mask&0x1)
 862         {
 863                 SetDlgItemText(IDC_FIRSTURL, L"");
 864                 m_tooltips.AddTool(IDC_FIRSTURL, L"");
 865         }
 866
 867         if(mask&0x2)
 868         {
 869                 SetDlgItemText(IDC_SECONDURL, L"");
 870                 m_tooltips.AddTool(IDC_SECONDURL, L"");
 871         }
 872 }
 873 BOOL CFileDiffDlg::PreTranslateMessage(MSG* pMsg)
 874 {
 875         if (pMsg->message == WM_KEYDOWN)
 876         {
 877                 switch (pMsg->wParam)
 878                 {
 879                 case 'A':
 880                         {
 881                                 if (GetFocus() != GetDlgItem(IDC_FILELIST))
 882                                         break;
 883                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
 884                                 {
 885                                         // select all entries
 886                                         for (int i=0; i<m_cFileList.GetItemCount(); ++i)
 887                                                 m_cFileList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
 888                                         return TRUE;
 889                                 }
 890                         }
 891                         break;
 892                 case 'C':
 893                 case VK_INSERT:
 894                         {
 895                                 if (GetFocus() != GetDlgItem(IDC_FILELIST))
 896                                         break;
 897                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
 898                                 {
 899                                         CopySelectionToClipboard();
 900                                         return TRUE;
 901                                 }
 902                         }
 903                         break;
 904                 case '\r':
 905                         {
 906                                 if (GetFocus() == GetDlgItem(IDC_FILELIST))
 907                                 {
 908                                         // Return pressed in file list. Show diff, as for double click
 909                                         int selIndex = m_cFileList.GetSelectionMark();
 910                                         if ((selIndex >= 0) && (selIndex < (int)m_arFileList.GetCount()))
 911                                                 DoDiff(selIndex, m_bBlame);
 912                                         return TRUE;
 913                                 }
 914                         }
 915                         break;
 916                 case VK_F5:
 917                         {
 918                                 OnTimer(IDT_INPUT);
 919                         }
 920                         break;
 921                 case VK_ESCAPE:
 922                         if (GetFocus() == GetDlgItem(IDC_FILTER) && m_cFilter.GetWindowTextLength())
 923                         {
 924                                 m_cFilter.SetWindowText(L"");
 925                                 OnClickedCancelFilter(NULL, NULL);
 926                                 return TRUE;
 927                         }
 928                         break;
 929                 }
 930         }
 931         return __super::PreTranslateMessage(pMsg);
 932 }
 933
 934 void CFileDiffDlg::OnCancel()
 935 {
 936         if (m_bThreadRunning)
 937         {
 938                 m_bCancelled = true;
 939                 return;
 940         }
 941         __super::OnCancel();
 942 }
 943
 944 void CFileDiffDlg::OnHdnItemclickFilelist(NMHDR *pNMHDR, LRESULT *pResult)
 945 {
 946         LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);
 947         if (m_bThreadRunning)
 948                 return;
 949
 950         if (m_nSortedColumn == phdr->iItem)
 951                 m_bAscending = !m_bAscending;
 952         else
 953                 m_bAscending = TRUE;
 954         m_nSortedColumn = phdr->iItem;
 955         Sort();
 956
 957         CString temp;
 958         m_cFileList.SetRedraw(FALSE);
 959         m_cFileList.DeleteAllItems();
 960         m_cFilter.GetWindowText(temp);
 961         Filter(temp);
 962
 963         CHeaderCtrl * pHeader = m_cFileList.GetHeaderCtrl();
 964         HDITEM HeaderItem = {0};
 965         HeaderItem.mask = HDI_FORMAT;
 966         for (int i=0; i<pHeader->GetItemCount(); ++i)
 967         {
 968                 pHeader->GetItem(i, &HeaderItem);
 969                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
 970                 pHeader->SetItem(i, &HeaderItem);
 971         }
 972         pHeader->GetItem(m_nSortedColumn, &HeaderItem);
 973         HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
 974         pHeader->SetItem(m_nSortedColumn, &HeaderItem);
 975
 976         m_cFileList.SetRedraw(TRUE);
 977
 978         *pResult = 0;
 979 }
 980
 981 void CFileDiffDlg::Sort()
 982 {
 983         if(m_arFileList.GetCount() < 2)
 984                 return;
 985
 986         std::sort(m_arFileList.m_paths.begin(), m_arFileList.m_paths.end(), &CFileDiffDlg::SortCompare);
 987 }
 988
 989 bool CFileDiffDlg::SortCompare(const CTGitPath& Data1, const CTGitPath& Data2)
 990 {
 991         int result = 0;
 992         int d1, d2;
 993         switch (m_nSortedColumn)
 994         {
 995         case 0:         //path column
 996                 result = Data1.GetWinPathString().Compare(Data2.GetWinPathString());
 997                 break;
 998         case 1:         //extension column
 999                 result = Data1.GetFileExtension().Compare(Data2.GetFileExtension());
1000                 break;
1001         case 2:         //action column
1002                 result = Data1.m_Action - Data2.m_Action;
1003                 break;
1004         case 3:
1005                 d1 = CSorter::A2L(Data1.m_StatAdd);
1006                 d2 = CSorter::A2L(Data2.m_StatAdd);
1007                 result = d1 - d2;
1008                 break;
1009         case 4:
1010                 d1 = CSorter::A2L(Data1.m_StatDel);;
1011                 d2 = CSorter::A2L(Data2.m_StatDel);
1012                 result = d1 - d2;
1013                 break;
1014         default:
1015                 break;
1016         }
1017         // sort by path name as second priority
1018         if (m_nSortedColumn != 0 && result == 0)
1019                 result = Data1.GetWinPathString().Compare(Data2.GetWinPathString());
1020
1021         if (!m_bAscending)
1022                 result = -result;
1023         return result < 0;
1024 }
1025
1026
1027 void CFileDiffDlg::OnBnClickedRev1btn()
1028 {
1029         ClickRevButton(&this->m_cRev1Btn,&this->m_rev1, &this->m_ctrRev1Edit);
1030 }
1031
1032 void CFileDiffDlg::ClickRevButton(CMenuButton *button, GitRev *rev, CACEdit *edit)
1033 {
1034         INT_PTR entry=button->GetCurrentEntry();
1035         if(entry == 0) /* Browse Refence*/
1036         {
1037                 {
1038                         CString str = CBrowseRefsDlg::PickRef();
1039                         if(str.IsEmpty())
1040                                 return;
1041
1042                         if(FillRevFromString(rev,str))
1043                                 return;
1044
1045                         edit->SetWindowText(str);
1046                 }
1047         }
1048
1049         if(entry == 1) /*Log*/
1050         {
1051                 CLogDlg dlg;
1052                 CString revision;
1053                 edit->GetWindowText(revision);
1054                 dlg.SetParams(CTGitPath(), CTGitPath(), revision, revision, 0);
1055                 dlg.SetSelect(true);
1056                 if(dlg.DoModal() == IDOK)
1057                 {
1058                         if (dlg.GetSelectedHash().empty())
1059                                 return;
1060
1061                         if (FillRevFromString(rev, dlg.GetSelectedHash().at(0).ToString()))
1062                                 return;
1063
1064                         edit->SetWindowText(dlg.GetSelectedHash().at(0).ToString());
1065                 }
1066                 else
1067                         return;
1068         }
1069
1070         if(entry == 2) /*RefLog*/
1071         {
1072                 CRefLogDlg dlg;
1073                 if(dlg.DoModal() == IDOK)
1074                 {
1075                         if(FillRevFromString(rev,dlg.m_SelectedHash))
1076                                 return;
1077
1078                         edit->SetWindowText(dlg.m_SelectedHash);
1079                 }
1080                 else
1081                         return;
1082         }
1083
1084         SetURLLabels();
1085
1086         InterlockedExchange(&m_bThreadRunning, TRUE);
1087         if (!AfxBeginThread(DiffThreadEntry, this))
1088         {
1089                 InterlockedExchange(&m_bThreadRunning, FALSE);
1090                 CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
1091         }
1092         KillTimer(IDT_INPUT);
1093 }
1094
1095 void CFileDiffDlg::OnBnClickedRev2btn()
1096 {
1097         ClickRevButton(&this->m_cRev2Btn,&this->m_rev2, &this->m_ctrRev2Edit);
1098 }
1099
1100 LRESULT CFileDiffDlg::OnClickedCancelFilter(WPARAM /*wParam*/, LPARAM /*lParam*/)
1101 {
1102         if (m_bThreadRunning)
1103         {
1104                 SetTimer(IDT_FILTER, 1000, nullptr);
1105                 return 0L;
1106         }
1107
1108         KillTimer(IDT_FILTER);
1109
1110         m_cFileList.SetRedraw(FALSE);
1111         m_arFilteredList.clear();
1112         m_cFileList.DeleteAllItems();
1113
1114         Filter(L"");
1115
1116         m_cFileList.SetRedraw(TRUE);
1117         return 0L;
1118 }
1119
1120 void CFileDiffDlg::OnEnChangeFilter()
1121 {
1122         SetTimer(IDT_FILTER, 1000, nullptr);
1123 }
1124
1125 void CFileDiffDlg::OnTimer(UINT_PTR nIDEvent)
1126 {
1127         if (m_bThreadRunning)
1128                 return;
1129
1130         if( nIDEvent == IDT_FILTER)
1131         {
1132                 CString sFilterText;
1133                 KillTimer(IDT_FILTER);
1134                 m_cFilter.GetWindowText(sFilterText);
1135
1136                 m_cFileList.SetRedraw(FALSE);
1137                 m_cFileList.DeleteAllItems();
1138
1139                 Filter(sFilterText);
1140
1141                 m_cFileList.SetRedraw(TRUE);
1142
1143                 __super::OnTimer(nIDEvent);
1144         }
1145
1146         if( nIDEvent == IDT_INPUT)
1147         {
1148                 KillTimer(IDT_INPUT);
1149                 TRACE(L"Input Timer\r\n");
1150
1151                 GitRev gitrev;
1152                 CString str;
1153                 int mask = 0;
1154                 this->m_ctrRev1Edit.GetWindowText(str);
1155                 if (!gitrev.GetCommit(str))
1156                 {
1157                         m_rev1 = gitrev;
1158                         mask |= 0x1;
1159                 }
1160                 else
1161                 {
1162                         CString msg;
1163                         msg.Format(IDS_PROC_REFINVALID, (LPCTSTR)str);
1164                         m_cFileList.ShowText(msg + L'\n' + gitrev.GetLastErr());
1165                 }
1166
1167                 this->m_ctrRev2Edit.GetWindowText(str);
1168
1169                 if (!gitrev.GetCommit(str))
1170                 {
1171                         m_rev2 = gitrev;
1172                         mask |= 0x2;
1173                 }
1174                 else
1175                 {
1176                         CString msg;
1177                         msg.Format(IDS_PROC_REFINVALID, (LPCTSTR)str);
1178                         m_cFileList.ShowText(msg + L'\n' + gitrev.GetLastErr());
1179                 }
1180
1181                 this->SetURLLabels(mask);
1182
1183                 if(mask == 0x3)
1184                 {
1185                         InterlockedExchange(&m_bThreadRunning, TRUE);
1186                         if (!AfxBeginThread(DiffThreadEntry, this))
1187                         {
1188                                 InterlockedExchange(&m_bThreadRunning, FALSE);
1189                                 CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
1190                         }
1191                 }
1192         }
1193 }
1194
1195 void CFileDiffDlg::Filter(CString sFilterText)
1196 {
1197         sFilterText.MakeLower();
1198
1199         m_arFilteredList.clear();
1200
1201         for (int i=0;i<m_arFileList.GetCount();i++)
1202         {
1203                 CString sPath = m_arFileList[i].GetGitPathString();
1204                 sPath.MakeLower();
1205                 if (sPath.Find(sFilterText) >= 0)
1206                         m_arFilteredList.push_back((CTGitPath*)&(m_arFileList[i]));
1207         }
1208         for (const auto path : m_arFilteredList)
1209                 AddEntry(path);
1210 }
1211
1212 void CFileDiffDlg::CopySelectionToClipboard(BOOL isFull)
1213 {
1214         // copy all selected paths to the clipboard
1215         POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
1216         int index;
1217         CString sTextForClipboard;
1218         while ((index = m_cFileList.GetNextSelectedItem(pos)) >= 0)
1219         {
1220                 sTextForClipboard += m_cFileList.GetItemText(index, 0);
1221                 sTextForClipboard += L'\t';
1222
1223                 if(!isFull)
1224                         sTextForClipboard += L"\r\n";
1225                 else
1226                 {
1227                         sTextForClipboard += m_cFileList.GetItemText(index, 1);
1228                         sTextForClipboard += L'\t';
1229                         sTextForClipboard += m_cFileList.GetItemText(index, 2);
1230                         sTextForClipboard += L'\t';
1231                         sTextForClipboard += m_cFileList.GetItemText(index, 3);
1232                         sTextForClipboard += L'\t';
1233                         sTextForClipboard += m_cFileList.GetItemText(index, 4);
1234                         sTextForClipboard += L"\r\n";
1235                 }
1236         }
1237         CStringUtils::WriteAsciiStringToClipboard(sTextForClipboard);
1238 }
1239
1240
1241 LRESULT CFileDiffDlg::OnRefLoad(WPARAM /*wParam*/, LPARAM /*lParam*/)
1242 {
1243         for (size_t i = 0; i < m_Reflist.size(); ++i)
1244         {
1245                 CString str=m_Reflist[i];
1246
1247                 if (CStringUtils::StartsWith(str, L"remotes/"))
1248                         str=str.Mid(8);
1249
1250                 m_ctrRev1Edit.AddSearchString(str);
1251                 m_ctrRev2Edit.AddSearchString(str);
1252         }
1253         return 0;
1254 }
1255
1256 BOOL CFileDiffDlg::DestroyWindow()
1257 {
1258         return CResizableStandAloneDialog::DestroyWindow();
1259 }
1260
1261 LRESULT CFileDiffDlg::OnEnUpdate(WPARAM /*wParam*/, LPARAM lParam)
1262 {
1263         if(lParam == IDC_REV1EDIT)
1264         {
1265                 OnTextUpdate(&this->m_ctrRev1Edit);
1266                 ClearURLabels(1);
1267         }
1268         if(lParam == IDC_REV2EDIT)
1269         {
1270                 OnTextUpdate(&this->m_ctrRev2Edit);
1271                 ClearURLabels(1<<1);
1272         }
1273         return 0;
1274 }
1275
1276 void CFileDiffDlg::OnTextUpdate(CACEdit * /*pEdit*/)
1277 {
1278         SetTimer(IDT_INPUT, 1000, nullptr);
1279         this->m_cFileList.ShowText(L"Wait For input validate version");
1280 }
1281
1282 int CFileDiffDlg::RevertSelectedItemToVersion(CString rev)
1283 {
1284         if (rev.IsEmpty() || rev == GIT_REV_ZERO)
1285                 return 0;
1286
1287         POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
1288         int index;
1289         int count = 0;
1290         while ((index = m_cFileList.GetNextSelectedItem(pos)) >= 0)
1291         {
1292                 CString cmd, out;
1293                 CTGitPath* fentry = m_arFilteredList[index];
1294                 cmd.Format(L"git.exe checkout %s -- \"%s\"", (LPCTSTR)rev, (LPCTSTR)fentry->GetGitPathString());
1295                 if (g_Git.Run(cmd, &out, CP_UTF8))
1296                 {
1297                         if (CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", 2, IDI_WARNING, CString(MAKEINTRESOURCE(IDS_IGNOREBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 2)
1298                                 break;
1299                 }
1300                 else
1301                         count++;
1302         }
1303
1304         CString out;
1305         out.Format(IDS_STATUSLIST_FILESREVERTED, count, (LPCTSTR)rev);
1306         CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", MB_OK);
1307         return 0;
1308 }
1309
1310 static void AppendMenuChecked(CMenu &menu, UINT nTextID, UINT_PTR nItemID, BOOL checked = FALSE, BOOL enabled = TRUE)
1311 {
1312         CString text;
1313         text.LoadString(nTextID);
1314         menu.AppendMenu(MF_STRING | (enabled ? MF_ENABLED : MF_DISABLED) | (checked ? MF_CHECKED : MF_UNCHECKED), nItemID, text);
1315 }
1316
1317 #define DIFFOPTION_IGNORESPACEATEOL             1
1318 #define DIFFOPTION_IGNORESPACECHANGE    2
1319 #define DIFFOPTION_IGNOREALLSPACE               3
1320 #define DIFFOPTION_IGNORBLANKLINES              4
1321
1322 void CFileDiffDlg::OnBnClickedDiffoption()
1323 {
1324         CMenu popup;
1325         if (popup.CreatePopupMenu())
1326         {
1327                 m_cDiffOptionsBtn.SetCheck(BST_CHECKED);
1328                 AppendMenuChecked(popup, IDS_DIFFOPTION_IGNORESPACEATEOL, DIFFOPTION_IGNORESPACEATEOL, m_bIgnoreSpaceAtEol);
1329                 AppendMenuChecked(popup, IDS_DIFFOPTION_IGNORESPACECHANGE, DIFFOPTION_IGNORESPACECHANGE, m_bIgnoreSpaceChange);
1330                 AppendMenuChecked(popup, IDS_DIFFOPTION_IGNOREALLSPACE, DIFFOPTION_IGNOREALLSPACE, m_bIgnoreAllSpace);
1331                 AppendMenuChecked(popup, IDS_DIFFOPTION_IGNORBLANKLINES, DIFFOPTION_IGNORBLANKLINES, m_bIgnoreBlankLines);
1332
1333                 m_tooltips.Pop();
1334                 RECT rect;
1335                 GetDlgItem(IDC_DIFFOPTION)->GetWindowRect(&rect);
1336                 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, rect.left, rect.bottom, this);
1337                 switch (selection)
1338                 {
1339                 case DIFFOPTION_IGNORESPACEATEOL:
1340                         m_bIgnoreSpaceAtEol = !m_bIgnoreSpaceAtEol;
1341                         OnTimer(IDT_INPUT);
1342                         break;
1343                 case DIFFOPTION_IGNORESPACECHANGE:
1344                         m_bIgnoreSpaceChange = !m_bIgnoreSpaceChange;
1345                         OnTimer(IDT_INPUT);
1346                         break;
1347                 case DIFFOPTION_IGNOREALLSPACE:
1348                         m_bIgnoreAllSpace = !m_bIgnoreAllSpace;
1349                         OnTimer(IDT_INPUT);
1350                         break;
1351                 case DIFFOPTION_IGNORBLANKLINES:
1352                         m_bIgnoreBlankLines = !m_bIgnoreBlankLines;
1353                         OnTimer(IDT_INPUT);
1354                         break;
1355                 default:
1356                         break;
1357                 }
1358                 UpdateData(FALSE);
1359                 m_cDiffOptionsBtn.SetCheck((m_bIgnoreSpaceAtEol || m_bIgnoreSpaceChange || m_bIgnoreAllSpace || m_bIgnoreBlankLines) ? BST_CHECKED : BST_UNCHECKED);
1360         }
1361 }
1362
1363 void CFileDiffDlg::OnBnClickedLog()
1364 {
1365         CLogDlg dlg;
1366         dlg.SetRange(m_rev1.m_CommitHash.ToString() + L".." + m_rev2.m_CommitHash.ToString());
1367         dlg.DoModal();
1368 }
1369
1370 bool CFileDiffDlg::CheckMultipleDiffs()
1371 {
1372         UINT selCount = m_cFileList.GetSelectedCount();
1373         if (selCount > max(3, (DWORD)CRegDWORD(L"Software\\TortoiseGit\\NumDiffWarning", 10)))
1374         {
1375                 CString message;
1376                 message.Format(IDS_STATUSLIST_WARN_MAXDIFF, selCount);
1377                 return ::MessageBox(GetSafeHwnd(), message, L"TortoiseGit", MB_YESNO | MB_ICONQUESTION) == IDYES;
1378         }
1379         return true;
1380 }