src/TortoiseProc/FileDiffDlg.cpp

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