src/TortoiseProc/FileDiffDlg.cpp

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