src/TortoiseProc/FileDiffDlg.cpp

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