src/Git/GitStatusListCtrl.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2017 - TortoiseGit
   4 // Copyright (C) 2003-2008, 2013-2015 - 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
  21 #include "stdafx.h"
  22 #include "resource.h"
  23 #include "..\\TortoiseShell\resource.h"
  24 #include "GitStatusListCtrl.h"
  25 #include "MessageBox.h"
  26 #include "MyMemDC.h"
  27 #include "UnicodeUtils.h"
  28 #include "AppUtils.h"
  29 #include "PathUtils.h"
  30 #include "TempFile.h"
  31 #include "StringUtils.h"
  32 #include "LoglistUtils.h"
  33 #include "Git.h"
  34 #include "GitRev.h"
  35 #include "GitDiff.h"
  36 #include "GitProgressDlg.h"
  37 #include "SysImageList.h"
  38 #include "TGitPath.h"
  39 #include "registry.h"
  40 #include "InputDlg.h"
  41 #include "GitAdminDir.h"
  42 #include "GitDataObject.h"
  43 #include "ProgressCommands/AddProgressCommand.h"
  44 #include "IconMenu.h"
  45 #include "FormatMessageWrapper.h"
  46 #include "BrowseFolder.h"
  47 #include "SysInfo.h"
  48
  49 const UINT CGitStatusListCtrl::GITSLNM_ITEMCOUNTCHANGED
  50                                         = ::RegisterWindowMessage(L"GITSLNM_ITEMCOUNTCHANGED");
  51 const UINT CGitStatusListCtrl::GITSLNM_NEEDSREFRESH
  52                                         = ::RegisterWindowMessage(L"GITSLNM_NEEDSREFRESH");
  53 const UINT CGitStatusListCtrl::GITSLNM_ADDFILE
  54                                         = ::RegisterWindowMessage(L"GITSLNM_ADDFILE");
  55 const UINT CGitStatusListCtrl::GITSLNM_CHECKCHANGED
  56                                         = ::RegisterWindowMessage(L"GITSLNM_CHECKCHANGED");
  57 const UINT CGitStatusListCtrl::GITSLNM_ITEMCHANGED
  58                                         = ::RegisterWindowMessage(L"GITSLNM_ITEMCHANGED");
  59
  60 struct icompare
  61 {
  62         bool operator() (const std::wstring& lhs, const std::wstring& rhs) const
  63         {
  64                 // no logical comparison here: we need this sorted strictly
  65                 return _wcsicmp(lhs.c_str(), rhs.c_str()) < 0;
  66         }
  67 };
  68
  69 class CIShellFolderHook : public IShellFolder
  70 {
  71 public:
  72         CIShellFolderHook(LPSHELLFOLDER sf, const CTGitPathList& pathlist)
  73         {
  74                 sf->AddRef();
  75                 m_iSF = sf;
  76                 // it seems the paths in the HDROP need to be sorted, otherwise
  77                 // it might not work properly or even crash.
  78                 // to get the items sorted, we just add them to a set
  79                 for (int i = 0; i < pathlist.GetCount(); ++i)
  80                         sortedpaths.insert((LPCTSTR)g_Git.CombinePath(pathlist[i].GetWinPath()));
  81         }
  82
  83         ~CIShellFolderHook() { m_iSF->Release(); }
  84
  85         // IUnknown methods --------
  86         virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, __RPC__deref_out void **ppvObject) { return m_iSF->QueryInterface(riid, ppvObject); }
  87         virtual ULONG STDMETHODCALLTYPE AddRef(void) { return m_iSF->AddRef(); }
  88         virtual ULONG STDMETHODCALLTYPE Release(void) { return m_iSF->Release(); }
  89
  90         // IShellFolder methods ----
  91         virtual HRESULT STDMETHODCALLTYPE GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT *rgfReserved, void **ppv);
  92
  93         virtual HRESULT STDMETHODCALLTYPE CompareIDs(LPARAM lParam, __RPC__in PCUIDLIST_RELATIVE pidl1, __RPC__in PCUIDLIST_RELATIVE pidl2) { return m_iSF->CompareIDs(lParam, pidl1, pidl2); }
  94         virtual HRESULT STDMETHODCALLTYPE GetDisplayNameOf(__RPC__in_opt PCUITEMID_CHILD pidl, SHGDNF uFlags, __RPC__out STRRET *pName) { return m_iSF->GetDisplayNameOf(pidl, uFlags, pName); }
  95         virtual HRESULT STDMETHODCALLTYPE CreateViewObject(__RPC__in_opt HWND hwndOwner, __RPC__in REFIID riid, __RPC__deref_out_opt void **ppv) { return m_iSF->CreateViewObject(hwndOwner, riid, ppv); }
  96         virtual HRESULT STDMETHODCALLTYPE EnumObjects(__RPC__in_opt HWND hwndOwner, SHCONTF grfFlags, __RPC__deref_out_opt IEnumIDList **ppenumIDList) { return m_iSF->EnumObjects(hwndOwner, grfFlags, ppenumIDList); }
  97         virtual HRESULT STDMETHODCALLTYPE BindToObject(__RPC__in PCUIDLIST_RELATIVE pidl, __RPC__in_opt IBindCtx *pbc, __RPC__in REFIID riid, __RPC__deref_out_opt void **ppv) { return m_iSF->BindToObject(pidl, pbc, riid, ppv); }
  98         virtual HRESULT STDMETHODCALLTYPE ParseDisplayName(__RPC__in_opt HWND hwnd, __RPC__in_opt IBindCtx *pbc, __RPC__in_string LPWSTR pszDisplayName, __reserved ULONG *pchEaten, __RPC__deref_out_opt PIDLIST_RELATIVE *ppidl, __RPC__inout_opt ULONG *pdwAttributes) { return m_iSF->ParseDisplayName(hwnd, pbc, pszDisplayName, pchEaten, ppidl, pdwAttributes); }
  99         virtual HRESULT STDMETHODCALLTYPE GetAttributesOf(UINT cidl, __RPC__in_ecount_full_opt(cidl) PCUITEMID_CHILD_ARRAY apidl, __RPC__inout SFGAOF *rgfInOut) { return m_iSF->GetAttributesOf(cidl, apidl, rgfInOut); }
 100         virtual HRESULT STDMETHODCALLTYPE BindToStorage(__RPC__in PCUIDLIST_RELATIVE pidl, __RPC__in_opt IBindCtx *pbc, __RPC__in REFIID riid, __RPC__deref_out_opt void **ppv) { return m_iSF->BindToStorage(pidl, pbc, riid, ppv); }
 101         virtual HRESULT STDMETHODCALLTYPE SetNameOf(__in_opt HWND hwnd, __in PCUITEMID_CHILD pidl, __in LPCWSTR pszName, __in SHGDNF uFlags, __deref_opt_out PITEMID_CHILD *ppidlOut) { return m_iSF->SetNameOf(hwnd, pidl, pszName, uFlags, ppidlOut); }
 102
 103 protected:
 104         LPSHELLFOLDER m_iSF;
 105         std::set<std::wstring, icompare> sortedpaths;
 106 };
 107
 108 HRESULT STDMETHODCALLTYPE CIShellFolderHook::GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT *rgfReserved, void **ppv)
 109 {
 110         if (InlineIsEqualGUID(riid, IID_IDataObject))
 111         {
 112                 HRESULT hres = m_iSF->GetUIObjectOf(hwndOwner, cidl, apidl, IID_IDataObject, nullptr, ppv);
 113                 if (FAILED(hres))
 114                         return hres;
 115
 116                 IDataObject * idata = (LPDATAOBJECT)(*ppv);
 117                 // the IDataObject returned here doesn't have a HDROP, so we create one ourselves and add it to the IDataObject
 118                 // the HDROP is necessary for most context menu handlers
 119                 int nLength = 0;
 120                 for (auto it = sortedpaths.cbegin(); it != sortedpaths.cend(); ++it)
 121                 {
 122                         nLength += (int)it->size();
 123                         nLength += 1; // '\0' separator
 124                 }
 125                 int nBufferSize = sizeof(DROPFILES) + ((nLength + 5)*sizeof(TCHAR));
 126                 auto pBuffer = std::make_unique<char[]>(nBufferSize);
 127                 SecureZeroMemory(pBuffer.get(), nBufferSize);
 128                 DROPFILES* df = (DROPFILES*)pBuffer.get();
 129                 df->pFiles = sizeof(DROPFILES);
 130                 df->fWide = 1;
 131                 TCHAR* pFilenames = (TCHAR*)((BYTE*)(pBuffer.get()) + sizeof(DROPFILES));
 132                 TCHAR* pCurrentFilename = pFilenames;
 133
 134                 for (auto it = sortedpaths.cbegin(); it != sortedpaths.cend(); ++it)
 135                 {
 136                         wcscpy_s(pCurrentFilename, it->size() + 1, it->c_str());
 137                         pCurrentFilename += it->size();
 138                         *pCurrentFilename = '\0'; // separator between file names
 139                         pCurrentFilename++;
 140                 }
 141                 *pCurrentFilename = '\0'; // terminate array
 142                 pCurrentFilename++;
 143                 *pCurrentFilename = '\0'; // terminate array
 144                 STGMEDIUM medium = { 0 };
 145                 medium.tymed = TYMED_HGLOBAL;
 146                 medium.hGlobal = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE, nBufferSize + 20);
 147                 if (medium.hGlobal)
 148                 {
 149                         LPVOID pMem = ::GlobalLock(medium.hGlobal);
 150                         if (pMem)
 151                         {
 152                                 memcpy(pMem, pBuffer.get(), nBufferSize);
 153                                 GlobalUnlock(medium.hGlobal);
 154                                 FORMATETC formatetc = { 0 };
 155                                 formatetc.cfFormat = CF_HDROP;
 156                                 formatetc.dwAspect = DVASPECT_CONTENT;
 157                                 formatetc.lindex = -1;
 158                                 formatetc.tymed = TYMED_HGLOBAL;
 159                                 medium.pUnkForRelease = nullptr;
 160                                 hres = idata->SetData(&formatetc, &medium, TRUE);
 161                                 return hres;
 162                         }
 163                 }
 164                 return E_OUTOFMEMORY;
 165         }
 166         else
 167         {
 168                 // just pass it on to the base object
 169                 return m_iSF->GetUIObjectOf(hwndOwner, cidl, apidl, riid, rgfReserved, ppv);
 170         }
 171 }
 172
 173 IContextMenu2 *         g_IContext2 = nullptr;
 174 IContextMenu3 *         g_IContext3 = nullptr;
 175 CIShellFolderHook *     g_pFolderhook = nullptr;
 176 IShellFolder *          g_psfDesktopFolder = nullptr;
 177 LPITEMIDLIST *          g_pidlArray = nullptr;
 178 int                     g_pidlArrayItems = 0;
 179
 180 #define SHELL_MIN_CMD   10000
 181 #define SHELL_MAX_CMD   20000
 182
 183 HRESULT CALLBACK dfmCallback(IShellFolder * /*psf*/, HWND /*hwnd*/, IDataObject * /*pdtobj*/, UINT uMsg, WPARAM /*wParam*/, LPARAM /*lParam*/)
 184 {
 185         switch (uMsg)
 186         {
 187         case DFM_MERGECONTEXTMENU:
 188                 return S_OK;
 189         case DFM_INVOKECOMMAND:
 190         case DFM_INVOKECOMMANDEX:
 191         case DFM_GETDEFSTATICID: // Required for Windows 7 to pick a default
 192                 return S_FALSE;
 193         }
 194         return E_NOTIMPL;
 195 }
 196
 197 BEGIN_MESSAGE_MAP(CGitStatusListCtrl, CResizableColumnsListCtrl<CListCtrl>)
 198         ON_NOTIFY(HDN_ITEMCLICKA, 0, OnHdnItemclick)
 199         ON_NOTIFY(HDN_ITEMCLICKW, 0, OnHdnItemclick)
 200         ON_NOTIFY_REFLECT_EX(LVN_ITEMCHANGED, OnLvnItemchanged)
 201         ON_WM_CONTEXTMENU()
 202         ON_NOTIFY_REFLECT(NM_DBLCLK, OnNMDblclk)
 203         ON_NOTIFY_REFLECT(LVN_GETINFOTIP, OnLvnGetInfoTip)
 204         ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnNMCustomdraw)
 205         ON_NOTIFY_REFLECT(LVN_GETDISPINFO, OnLvnGetdispinfo)
 206         ON_WM_SETCURSOR()
 207         ON_WM_GETDLGCODE()
 208         ON_NOTIFY_REFLECT(NM_RETURN, OnNMReturn)
 209         ON_WM_KEYDOWN()
 210         ON_WM_PAINT()
 211         ON_WM_SYSCOLORCHANGE()
 212         ON_NOTIFY_REFLECT(LVN_BEGINDRAG, OnBeginDrag)
 213 END_MESSAGE_MAP()
 214
 215 CGitStatusListCtrl::CGitStatusListCtrl() : CResizableColumnsListCtrl<CListCtrl>()
 216         , m_pbCanceled(nullptr)
 217         , m_pStatLabel(nullptr)
 218         , m_pSelectButton(nullptr)
 219         , m_pConfirmButton(nullptr)
 220         , m_bBusy(false)
 221         , m_bWaitCursor(false)
 222         , m_bEmpty(false)
 223         , m_bShowIgnores(false)
 224         , m_bIgnoreRemoveOnly(false)
 225         , m_bCheckChildrenWithParent(false)
 226         , m_bUnversionedLast(true)
 227         , m_bHasChangeLists(false)
 228         , m_bHasCheckboxes(false)
 229         , m_bCheckIfGroupsExist(true)
 230         , m_bFileDropsEnabled(false)
 231         , m_bOwnDrag(false)
 232         , m_dwDefaultColumns(0)
 233         , m_bAscending(false)
 234         , m_nSortedColumn(-1)
 235         , m_bHasExternalsFromDifferentRepos(false)
 236         , m_amend(false)
 237         , m_bDoNotAutoselectSubmodules(false)
 238         , m_bNoAutoselectMissing(false)
 239         , m_bHasWC(true)
 240         , m_hwndLogicalParent(nullptr)
 241         , m_bHasUnversionedItems(FALSE)
 242         , m_nTargetCount(0)
 243         , m_bHasExternals(false)
 244         , m_bHasIgnoreGroup(false)
 245         , m_nUnversioned(0)
 246         , m_nNormal(0)
 247         , m_nModified(0)
 248         , m_nAdded(0)
 249         , m_nDeleted(0)
 250         , m_nConflicted(0)
 251         , m_nTotal(0)
 252         , m_nSelected(0)
 253         , m_nRenamed(0)
 254         , m_nShownUnversioned(0)
 255         , m_nShownModified(0)
 256         , m_nShownAdded(0)
 257         , m_nShownDeleted(0)
 258         , m_nShownConflicted(0)
 259         , m_nShownFiles(0)
 260         , m_nShownSubmodules(0)
 261         , m_dwShow(0)
 262         , m_bShowFolders(false)
 263         , m_bUpdate(false)
 264         , m_dwContextMenus(0)
 265         , m_nIconFolder(0)
 266         , m_nRestoreOvl(0)
 267         , m_pContextMenu(nullptr)
 268         , m_hShellMenu(nullptr)
 269         , m_nBackgroundImageID(0)
 270         , m_FileLoaded(0)
 271         , m_bIsRevertTheirMy(false)
 272         , m_nLineAdded(0)
 273         , m_nLineDeleted(0)
 274         , m_nBlockItemChangeHandler(0)
 275 {
 276         m_critSec.Init();
 277         m_bNoAutoselectMissing = CRegDWORD(L"Software\\TortoiseGit\\AutoselectMissingFiles", FALSE) == TRUE;
 278 }
 279
 280 CGitStatusListCtrl::~CGitStatusListCtrl()
 281 {
 282         ClearStatusArray();
 283 }
 284
 285 void CGitStatusListCtrl::ClearStatusArray()
 286 {
 287 #if 0
 288         CAutoWriteLock locker(m_guard);
 289         for (size_t i = 0; i < m_arStatusArray.size(); ++i)
 290         {
 291                 delete m_arStatusArray[i];
 292         }
 293         m_arStatusArray.clear();
 294 #endif
 295 }
 296
 297 void CGitStatusListCtrl::Init(DWORD dwColumns, const CString& sColumnInfoContainer, unsigned __int64 dwContextMenus /* = GitSLC_POPALL */, bool bHasCheckboxes /* = true */, bool bHasWC /* = true */, DWORD allowedColumns /* = 0xffffffff */)
 298 {
 299         CAutoWriteLock locker(m_guard);
 300
 301         m_dwDefaultColumns = dwColumns | 1;
 302         m_dwContextMenus = dwContextMenus;
 303         m_bHasCheckboxes = bHasCheckboxes;
 304         m_bHasWC = bHasWC;
 305         m_bWaitCursor = true;
 306
 307         // set the extended style of the listcontrol
 308         DWORD exStyle = LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP | LVS_EX_SUBITEMIMAGES;
 309         exStyle |= (bHasCheckboxes ? LVS_EX_CHECKBOXES : 0);
 310         SetRedraw(false);
 311         SetExtendedStyle(exStyle);
 312         CResizableColumnsListCtrl::Init();
 313
 314         SetWindowTheme(m_hWnd, L"Explorer", nullptr);
 315
 316         m_nIconFolder = SYS_IMAGE_LIST().GetDirIconIndex();
 317         m_nRestoreOvl = SYS_IMAGE_LIST().AddIcon((HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_RESTOREOVL), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE));
 318         SYS_IMAGE_LIST().SetOverlayImage(m_nRestoreOvl, OVL_RESTORE);
 319         SetImageList(&SYS_IMAGE_LIST(), LVSIL_SMALL);
 320
 321         // keep CSorter::operator() in sync!!
 322         static UINT standardColumnNames[GITSLC_NUMCOLUMNS]
 323                         = { IDS_STATUSLIST_COLFILE
 324                         , IDS_STATUSLIST_COLFILENAME
 325                         , IDS_STATUSLIST_COLEXT
 326                         , IDS_STATUSLIST_COLSTATUS
 327                         , IDS_STATUSLIST_COLADD
 328                         , IDS_STATUSLIST_COLDEL
 329                         , IDS_STATUSLIST_COLLASTMODIFIED
 330                         , IDS_STATUSLIST_COLSIZE
 331                         };
 332
 333         m_ColumnManager.SetNames(standardColumnNames,GITSLC_NUMCOLUMNS);
 334         m_ColumnManager.ReadSettings(m_dwDefaultColumns, 0xffffffff & ~(allowedColumns | m_dwDefaultColumns), sColumnInfoContainer, GITSLC_NUMCOLUMNS);
 335         m_ColumnManager.SetRightAlign(4);
 336         m_ColumnManager.SetRightAlign(5);
 337         m_ColumnManager.SetRightAlign(7);
 338
 339         // enable file drops
 340         if (!m_pDropTarget)
 341         {
 342                 m_pDropTarget = std::make_unique<CGitStatusListCtrlDropTarget>(this);
 343                 RegisterDragDrop(m_hWnd, m_pDropTarget.get());
 344                 // create the supported formats:
 345                 FORMATETC ftetc = { 0 };
 346                 ftetc.dwAspect = DVASPECT_CONTENT;
 347                 ftetc.lindex = -1;
 348                 ftetc.tymed = TYMED_HGLOBAL;
 349                 ftetc.cfFormat = CF_HDROP;
 350                 m_pDropTarget->AddSuportedFormat(ftetc);
 351         }
 352
 353         SetRedraw(true);
 354         m_bWaitCursor = false;
 355 }
 356
 357 bool CGitStatusListCtrl::SetBackgroundImage(UINT nID)
 358 {
 359         m_nBackgroundImageID = nID;
 360         return CAppUtils::SetListCtrlBackgroundImage(GetSafeHwnd(), nID);
 361 }
 362
 363 BOOL CGitStatusListCtrl::GetStatus ( const CTGitPathList* pathList
 364                                                                         , bool bUpdate /* = FALSE */
 365                                                                         , bool bShowIgnores /* = false */
 366                                                                         , bool bShowUnRev /* = false */
 367                                                                         , bool bShowLocalChangesIgnored /* = false */)
 368 {
 369         CAutoWriteLock locker(m_guard);
 370
 371         m_bEmpty = false;
 372         m_bBusy = true;
 373         m_bWaitCursor = true;
 374         Invalidate();
 375
 376         m_bIsRevertTheirMy = g_Git.IsRebaseRunning() > 0;
 377
 378         int mask= CGitStatusListCtrl::FILELIST_MODIFY;
 379         if(bShowIgnores)
 380                 mask|= CGitStatusListCtrl::FILELIST_IGNORE;
 381         if(bShowUnRev)
 382                 mask|= CGitStatusListCtrl::FILELIST_UNVER;
 383         if (bShowLocalChangesIgnored)
 384                 mask |= CGitStatusListCtrl::FILELIST_LOCALCHANGESIGNORED;
 385         this->UpdateFileList(mask, bUpdate, pathList);
 386
 387         if (pathList && m_setDirectFiles.empty())
 388         {
 389                 // remember files which are selected by users so that those can be preselected
 390                 for (int i = 0; i < pathList->GetCount(); ++i)
 391                         if (!(*pathList)[i].IsDirectory())
 392                                 m_setDirectFiles.insert((*pathList)[i].GetGitPathString());
 393         }
 394
 395 #if 0
 396         int refetchcounter = 0;
 397         BOOL bRet = TRUE;
 398         Invalidate();
 399         // force the cursor to change
 400         POINT pt;
 401         GetCursorPos(&pt);
 402         SetCursorPos(pt.x, pt.y);
 403
 404         m_mapFilenameToChecked.clear();
 405         //m_StatusUrlList.Clear();
 406         bool bHasChangelists = (m_changelists.size() > 1 || (!m_changelists.empty() && !m_bHasIgnoreGroup));
 407         m_changelists.clear();
 408         for (size_t i=0; i < m_arStatusArray.size(); i++)
 409         {
 410                 FileEntry * entry = m_arStatusArray[i];
 411                 if ( bHasChangelists && entry->checked)
 412                 {
 413                         // If change lists are present, remember all checked entries
 414                         CString path = entry->GetPath().GetGitPathString();
 415                         m_mapFilenameToChecked[path] = true;
 416                 }
 417                 if ( (entry->status==git_wc_status_unversioned || entry->status==git_wc_status_missing ) && entry->checked )
 418                 {
 419                         // The user manually selected an unversioned or missing file. We remember
 420                         // this so that the selection can be restored when refreshing.
 421                         CString path = entry->GetPath().GetGitPathString();
 422                         m_mapFilenameToChecked[path] = true;
 423                 }
 424                 else if ( entry->status > git_wc_status_normal && !entry->checked )
 425                 {
 426                         // The user manually deselected a versioned file. We remember
 427                         // this so that the deselection can be restored when refreshing.
 428                         CString path = entry->GetPath().GetGitPathString();
 429                         m_mapFilenameToChecked[path] = false;
 430                 }
 431         }
 432
 433         // use a sorted path list to make sure we fetch the status of
 434         // parent items first, *then* the child items (if any)
 435         CTGitPathList sortedPathList = pathList;
 436         sortedPathList.SortByPathname();
 437         do
 438         {
 439                 bRet = TRUE;
 440                 m_nTargetCount = 0;
 441                 m_bHasExternalsFromDifferentRepos = FALSE;
 442                 m_bHasExternals = FALSE;
 443                 m_bHasUnversionedItems = FALSE;
 444                 m_bHasChangeLists = false;
 445                 m_bShowIgnores = bShowIgnores;
 446                 m_nSortedColumn = 0;
 447                 m_bBlock = TRUE;
 448                 m_bBusy = true;
 449                 m_bEmpty = false;
 450                 Invalidate();
 451
 452                 // first clear possible status data left from
 453                 // previous GetStatus() calls
 454                 ClearStatusArray();
 455
 456                 m_StatusFileList = sortedPathList;
 457
 458                 // Since Git_client_status() returns all files, even those in
 459                 // folders included with Git:externals we need to check if all
 460                 // files we get here belongs to the same repository.
 461                 // It is possible to commit changes in an external folder, as long
 462                 // as the folder belongs to the same repository (but another path),
 463                 // but it is not possible to commit all files if the externals are
 464                 // from a different repository.
 465                 //
 466                 // To check if all files belong to the same repository, we compare the
 467                 // UUID's - if they're identical then the files belong to the same
 468                 // repository and can be committed. But if they're different, then
 469                 // tell the user to commit all changes in the external folders
 470                 // first and exit.
 471                 CStringA sUUID;                                 // holds the repo UUID
 472                 CTGitPathList arExtPaths;               // list of Git:external paths
 473
 474                 GitConfig config;
 475
 476                 m_sURL.Empty();
 477
 478                 m_nTargetCount = sortedPathList.GetCount();
 479
 480                 GitStatus status(m_pbCanceled);
 481                 if(m_nTargetCount > 1 && sortedPathList.AreAllPathsFilesInOneDirectory())
 482                 {
 483                         // This is a special case, where we've been given a list of files
 484                         // all from one folder
 485                         // We handle them by setting a status filter, then requesting the Git status of
 486                         // all the files in the directory, filtering for the ones we're interested in
 487                         status.SetFilter(sortedPathList);
 488
 489                         // if all selected entries are files, we don't do a recursive status
 490                         // fetching. But if only one is a directory, we have to recurse.
 491                         git_depth_t depth = git_depth_files;
 492                         // We have set a filter. If all selected items were files or we fetch
 493                         // the status not recursively, then we have to include
 494                         // ignored items too - the user has selected them
 495                         bool bShowIgnoresRight = true;
 496                         for (int fcindex=0; fcindex<sortedPathList.GetCount(); ++fcindex)
 497                         {
 498                                 if (sortedPathList[fcindex].IsDirectory())
 499                                 {
 500                                         depth = git_depth_infinity;
 501                                         bShowIgnoresRight = false;
 502                                         break;
 503                                 }
 504                         }
 505                         if(!FetchStatusForSingleTarget(config, status, sortedPathList.GetCommonDirectory(), bUpdate, sUUID, arExtPaths, true, depth, bShowIgnoresRight))
 506                                 bRet = FALSE;
 507                 }
 508                 else
 509                 {
 510                         for(int nTarget = 0; nTarget < m_nTargetCount; nTarget++)
 511                         {
 512                                 // check whether the path we want the status for is already fetched due to status-fetching
 513                                 // of a parent path.
 514                                 // this check is only done for file paths, because folder paths could be included already
 515                                 // but not recursively
 516                                 if (sortedPathList[nTarget].IsDirectory() || !GetListEntry(sortedPathList[nTarget]))
 517                                 {
 518                                         if(!FetchStatusForSingleTarget(config, status, sortedPathList[nTarget], bUpdate, sUUID,
 519                                                 arExtPaths, false, git_depth_infinity, bShowIgnores))
 520                                         {
 521                                                 bRet = FALSE;
 522                                         }
 523                                 }
 524                         }
 525                 }
 526
 527                 // remove the 'helper' files of conflicted items from the list.
 528                 // otherwise they would appear as unversioned files.
 529                 for (INT_PTR cind = 0; cind < m_ConflictFileList.GetCount(); ++cind)
 530                 {
 531                         for (size_t i=0; i < m_arStatusArray.size(); i++)
 532                         {
 533                                 if (m_arStatusArray[i]->GetPath().IsEquivalentTo(m_ConflictFileList[cind]))
 534                                 {
 535                                         delete m_arStatusArray[i];
 536                                         m_arStatusArray.erase(m_arStatusArray.cbegin() + i);
 537                                         break;
 538                                 }
 539                         }
 540                 }
 541                 refetchcounter++;
 542         } while(!BuildStatistics() && (refetchcounter < 2) && (*m_pbCanceled==false));
 543
 544         m_bBlock = FALSE;
 545         m_bBusy = false;
 546         GetCursorPos(&pt);
 547         SetCursorPos(pt.x, pt.y);
 548         return bRet;
 549 #endif
 550         m_bBusy = false;
 551         m_bWaitCursor = false;
 552         BuildStatistics();
 553         return TRUE;
 554 }
 555
 556 // Get the show-flags bitmap value which corresponds to a particular Git status
 557 DWORD CGitStatusListCtrl::GetShowFlagsFromGitStatus(git_wc_status_kind status)
 558 {
 559         switch (status)
 560         {
 561         case git_wc_status_none:
 562         case git_wc_status_unversioned:
 563                 return GITSLC_SHOWUNVERSIONED;
 564         case git_wc_status_ignored:
 565                 if (!m_bShowIgnores)
 566                         return GITSLC_SHOWDIRECTS;
 567                 return GITSLC_SHOWDIRECTS|GITSLC_SHOWIGNORED;
 568         case git_wc_status_normal:
 569                 return GITSLC_SHOWNORMAL;
 570         case git_wc_status_added:
 571                 return GITSLC_SHOWADDED;
 572         case git_wc_status_deleted:
 573                 return GITSLC_SHOWREMOVED;
 574         case git_wc_status_modified:
 575                 return GITSLC_SHOWMODIFIED;
 576         case git_wc_status_conflicted:
 577                 return GITSLC_SHOWCONFLICTED;
 578         default:
 579                 // we should NEVER get here!
 580                 ASSERT(FALSE);
 581                 break;
 582         }
 583         return 0;
 584 }
 585
 586 void CGitStatusListCtrl::Show(unsigned int dwShow, unsigned int dwCheck /*=0*/, bool /*bShowFolders*/ /* = true */,BOOL UpdateStatusList,bool UseStoredCheckStatus)
 587 {
 588         m_bWaitCursor = true;
 589         m_bBusy = true;
 590         m_bEmpty = false;
 591         Invalidate();
 592
 593         WORD langID = (WORD)CRegStdDWORD(L"Software\\TortoiseGit\\LanguageID", GetUserDefaultLangID());
 594         SetRedraw(FALSE);
 595         {
 596                 CAutoWriteLock locker(m_guard);
 597                 DeleteAllItems();
 598                 m_nSelected = 0;
 599
 600                 m_nShownUnversioned = 0;
 601                 m_nShownModified = 0;
 602                 m_nShownAdded = 0;
 603                 m_nShownDeleted = 0;
 604                 m_nShownConflicted = 0;
 605                 m_nShownFiles = 0;
 606                 m_nShownSubmodules = 0;
 607
 608                 m_dwShow = dwShow;
 609
 610                 if (UpdateStatusList)
 611                 {
 612                         m_arStatusArray.clear();
 613                         for (int i = 0; i < m_StatusFileList.GetCount(); ++i)
 614                                 m_arStatusArray.push_back(&m_StatusFileList[i]);
 615
 616                         for (int i = 0; i < m_UnRevFileList.GetCount(); ++i)
 617                                 m_arStatusArray.push_back(&m_UnRevFileList[i]);
 618
 619                         for (int i = 0; i < m_IgnoreFileList.GetCount(); ++i)
 620                                 m_arStatusArray.push_back(&m_IgnoreFileList[i]);
 621                 }
 622                 PrepareGroups();
 623                 if (m_nSortedColumn >= 0)
 624                 {
 625                         CSorter predicate(&m_ColumnManager, m_nSortedColumn, m_bAscending);
 626                         std::stable_sort(m_arStatusArray.begin(), m_arStatusArray.end(), predicate);
 627                 }
 628
 629                 int index = 0;
 630                 for (size_t i = 0; i < m_arStatusArray.size(); ++i)
 631                 {
 632                         //set default checkbox status
 633                         auto entry = const_cast<CTGitPath*>(m_arStatusArray[i]);
 634                         CString path = entry->GetGitPathString();
 635                         if (!m_mapFilenameToChecked.empty() && m_mapFilenameToChecked.find(path) != m_mapFilenameToChecked.end())
 636                                 entry->m_Checked = m_mapFilenameToChecked[path];
 637                         else if (!UseStoredCheckStatus)
 638                         {
 639                                 bool autoSelectSubmodules = !(entry->IsDirectory() && m_bDoNotAutoselectSubmodules);
 640                                 if (((entry->m_Action & dwCheck) && !(m_bNoAutoselectMissing && entry->m_Action & CTGitPath::LOGACTIONS_MISSING) || dwShow & GITSLC_SHOWDIRECTFILES && m_setDirectFiles.find(path) != m_setDirectFiles.end()) && autoSelectSubmodules)
 641                                         entry->m_Checked = true;
 642                                 else
 643                                         entry->m_Checked = false;
 644                                 m_mapFilenameToChecked[path] = entry->m_Checked;
 645                         }
 646
 647                         if (entry->m_Action & dwShow)
 648                         {
 649                                 AddEntry(entry, langID, index);
 650                                 index++;
 651                         }
 652                 }
 653         }
 654
 655         AdjustColumnWidths();
 656
 657         SetRedraw(TRUE);
 658         GetStatisticsString();
 659
 660         CHeaderCtrl * pHeader = GetHeaderCtrl();
 661         HDITEM HeaderItem = {0};
 662         HeaderItem.mask = HDI_FORMAT;
 663         for (int i=0; i<pHeader->GetItemCount(); ++i)
 664         {
 665                 pHeader->GetItem(i, &HeaderItem);
 666                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
 667                 pHeader->SetItem(i, &HeaderItem);
 668         }
 669         if (m_nSortedColumn >= 0)
 670         {
 671                 pHeader->GetItem(m_nSortedColumn, &HeaderItem);
 672                 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
 673                 pHeader->SetItem(m_nSortedColumn, &HeaderItem);
 674         }
 675
 676         RestoreScrollPos();
 677
 678         m_bWaitCursor = false;
 679         m_bBusy = false;
 680         m_bEmpty = (GetItemCount() == 0);
 681         Invalidate();
 682
 683         this->BuildStatistics();
 684
 685 #if 0
 686
 687         m_bShowFolders = bShowFolders;
 688
 689         int nTopIndex = GetTopIndex();
 690         POSITION posSelectedEntry = GetFirstSelectedItemPosition();
 691         int nSelectedEntry = 0;
 692         if (posSelectedEntry)
 693                 nSelectedEntry = GetNextSelectedItem(posSelectedEntry);
 694         SetRedraw(FALSE);
 695         DeleteAllItems();
 696
 697         PrepareGroups();
 698
 699         m_arListArray.clear();
 700
 701         m_arListArray.reserve(m_arStatusArray.size());
 702         SetItemCount (static_cast<int>(m_arStatusArray.size()));
 703
 704         int listIndex = 0;
 705         for (size_t i=0; i < m_arStatusArray.size(); ++i)
 706         {
 707                 FileEntry * entry = m_arStatusArray[i];
 708                 if ((entry->inexternal) && (!(dwShow & SVNSLC_SHOWINEXTERNALS)))
 709                         continue;
 710                 if ((entry->differentrepo || entry->isNested) && (! (dwShow & SVNSLC_SHOWEXTERNALFROMDIFFERENTREPO)))
 711                         continue;
 712                 if (entry->IsFolder() && (!bShowFolders))
 713                         continue;       // don't show folders if they're not wanted.
 714
 715 #if 0
 716                 git_wc_status_kind status = GitStatus::GetMoreImportant(entry->status, entry->remotestatus);
 717                 DWORD showFlags = GetShowFlagsFromGitStatus(status);
 718                 if (entry->switched)
 719                         showFlags |= SVNSLC_SHOWSWITCHED;
 720                 if (!entry->changelist.IsEmpty())
 721                         showFlags |= SVNSLC_SHOWINCHANGELIST;
 722 #endif
 723                 bool bAllowCheck = ((entry->changelist.Compare(GITSLC_IGNORECHANGELIST) != 0)
 724                         && (m_bCheckIfGroupsExist || (m_changelists.empty() || (m_changelists.size() == 1 && m_bHasIgnoreGroup))));
 725
 726                 // status_ignored is a special case - we must have the 'direct' flag set to add a status_ignored item
 727 #if 0
 728                 if (status != Git_wc_status_ignored || (entry->direct) || (dwShow & GitSLC_SHOWIGNORED))
 729                 {
 730                         if ((!entry->IsFolder()) && (status == Git_wc_status_deleted) && (dwShow & SVNSLC_SHOWREMOVEDANDPRESENT))
 731                         {
 732                                 if (PathFileExists(entry->GetPath().GetWinPath()))
 733                                 {
 734                                         m_arListArray.push_back(i);
 735                                         if ((dwCheck & SVNSLC_SHOWREMOVEDANDPRESENT)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))
 736                                         {
 737                                                 if (bAllowCheck)
 738                                                         entry->checked = true;
 739                                         }
 740                                         AddEntry(entry, langID, listIndex++);
 741                                 }
 742                         }
 743                         else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFILES)&&(entry->direct)&&(!entry->IsFolder())))
 744                         {
 745                                 m_arListArray.push_back(i);
 746                                 if ((dwCheck & showFlags)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))
 747                                 {
 748                                         if (bAllowCheck)
 749                                                 entry->checked = true;
 750                                 }
 751                                 AddEntry(entry, langID, listIndex++);
 752                         }
 753                         else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFOLDER)&&(entry->direct)&&entry->IsFolder()))
 754                         {
 755                                 m_arListArray.push_back(i);
 756                                 if ((dwCheck & showFlags)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))
 757                                 {
 758                                         if (bAllowCheck)
 759                                                 entry->checked = true;
 760                                 }
 761                                 AddEntry(entry, langID, listIndex++);
 762                         }
 763                 }
 764 #endif
 765         }
 766
 767         SetItemCount(listIndex);
 768
 769         m_ColumnManager.UpdateRelevance (m_arStatusArray, m_arListArray);
 770
 771         AdjustColumnWidths();
 772
 773         SetRedraw(TRUE);
 774         GetStatisticsString();
 775
 776         CHeaderCtrl * pHeader = GetHeaderCtrl();
 777         HDITEM HeaderItem = {0};
 778         HeaderItem.mask = HDI_FORMAT;
 779         for (int i=0; i<pHeader->GetItemCount(); ++i)
 780         {
 781                 pHeader->GetItem(i, &HeaderItem);
 782                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
 783                 pHeader->SetItem(i, &HeaderItem);
 784         }
 785         if (m_nSortedColumn)
 786         {
 787                 pHeader->GetItem(m_nSortedColumn, &HeaderItem);
 788                 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
 789                 pHeader->SetItem(m_nSortedColumn, &HeaderItem);
 790         }
 791
 792         if (nSelectedEntry)
 793         {
 794                 SetItemState(nSelectedEntry, LVIS_SELECTED, LVIS_SELECTED);
 795                 EnsureVisible(nSelectedEntry, false);
 796         }
 797         else
 798         {
 799                 // Restore the item at the top of the list.
 800                 for (int i=0;GetTopIndex() != nTopIndex;i++)
 801                 {
 802                         if ( !EnsureVisible(nTopIndex+i,false) )
 803                                 break;
 804                 }
 805         }
 806
 807         m_bEmpty = (GetItemCount() == 0);
 808         Invalidate();
 809 #endif
 810 }
 811
 812 void CGitStatusListCtrl::StoreScrollPos()
 813 {
 814         m_sScrollPos.enabled = true;
 815         m_sScrollPos.nTopIndex = GetTopIndex();
 816         m_sScrollPos.selMark = GetSelectionMark();
 817         POSITION posSelectedEntry = GetFirstSelectedItemPosition();
 818         m_sScrollPos.nSelectedEntry = 0;
 819         if (posSelectedEntry)
 820                 m_sScrollPos.nSelectedEntry = GetNextSelectedItem(posSelectedEntry);
 821 }
 822
 823 void CGitStatusListCtrl::RestoreScrollPos()
 824 {
 825         if (!m_sScrollPos.enabled || CRegDWORD(L"Software\\TortoiseGit\\RememberFileListPosition", TRUE) != TRUE)
 826                 return;
 827
 828         if (m_sScrollPos.nSelectedEntry)
 829         {
 830                 SetItemState(m_sScrollPos.nSelectedEntry, LVIS_SELECTED, LVIS_SELECTED);
 831                 EnsureVisible(m_sScrollPos.nSelectedEntry, false);
 832         }
 833         else
 834         {
 835                 // Restore the item at the top of the list.
 836                 for (int i = 0; GetTopIndex() != m_sScrollPos.nTopIndex; ++i)
 837                 {
 838                         if (!EnsureVisible(m_sScrollPos.nTopIndex + i, false))
 839                                 break;
 840                 }
 841         }
 842         if (m_sScrollPos.selMark >= 0)
 843         {
 844                 SetSelectionMark(m_sScrollPos.selMark);
 845                 SetItemState(m_sScrollPos.selMark, LVIS_FOCUSED, LVIS_FOCUSED);
 846         }
 847         m_sScrollPos.enabled = false;
 848 }
 849
 850 int CGitStatusListCtrl::GetColumnIndex(int mask)
 851 {
 852         for (int i = 0; i < 32; ++i)
 853                 if(mask&0x1)
 854                         return i;
 855                 else
 856                         mask=mask>>1;
 857         return -1;
 858 }
 859
 860 CString CGitStatusListCtrl::GetCellText(int listIndex, int column)
 861 {
 862         static CString from(MAKEINTRESOURCE(IDS_STATUSLIST_FROM));
 863         static bool abbreviateRenamings(((DWORD)CRegDWORD(L"Software\\TortoiseGit\\AbbreviateRenamings", FALSE)) == TRUE);
 864         static bool relativeTimes = (CRegDWORD(L"Software\\TortoiseGit\\RelativeTimes", FALSE) != FALSE);
 865         static const CString empty;
 866
 867         CAutoReadLock locker(m_guard);
 868         const auto* entry = GetListEntry(listIndex);
 869         if (!entry)
 870                 return empty;
 871
 872         switch (column)
 873         {
 874         case 0: // relative path
 875                 if (!(entry->m_Action & (CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_COPY) && !entry->GetGitOldPathString().IsEmpty()))
 876                         return entry->GetGitPathString();
 877
 878                 if (!abbreviateRenamings)
 879                 {
 880                         CString entryname = entry->GetGitPathString();
 881                         entryname += L' ';
 882                         // relative path
 883                         entryname.AppendFormat(from, (LPCTSTR)entry->GetGitOldPathString());
 884                         return entryname;
 885                 }
 886
 887                 return entry->GetAbbreviatedRename();
 888
 889         case 1: // GITSLC_COLFILENAME
 890                 return entry->GetFileOrDirectoryName();
 891
 892         case 2: // GITSLC_COLEXT
 893                 return entry->GetFileExtension();
 894
 895         case 3: // GITSLC_COLSTATUS
 896                 return entry->GetActionName();
 897
 898         case 4: // GITSLC_COLADD
 899                 return entry->m_StatAdd;
 900
 901         case 5: // GITSLC_COLDEL
 902                 return entry->m_StatDel;
 903
 904         case 6: // GITSLC_COLMODIFICATIONDATE
 905                 if (!(entry->m_Action & CTGitPath::LOGACTIONS_DELETED) && m_ColumnManager.IsRelevant(GetColumnIndex(GITSLC_COLMODIFICATIONDATE)))
 906                 {
 907                         CString modificationDate;
 908                         __int64 filetime = entry->GetLastWriteTime();
 909                         if (filetime)
 910                         {
 911                                 FILETIME* f = (FILETIME*)(__int64*)&filetime;
 912                                 modificationDate = CLoglistUtils::FormatDateAndTime(CTime(CGit::filetime_to_time_t(f)), DATE_SHORTDATE, true, relativeTimes);
 913                         }
 914                         return modificationDate;
 915                 }
 916                 return empty;
 917
 918         case 7: // GITSLC_COLSIZE
 919                 if (!(entry->IsDirectory() || !m_ColumnManager.IsRelevant(GetColumnIndex(GITSLC_COLSIZE))))
 920                 {
 921                         TCHAR buf[100] = { 0 };
 922                         StrFormatByteSize64(entry->GetFileSize(), buf, 100);
 923                         return buf;
 924                 }
 925                 return empty;
 926
 927 #if 0
 928         default: // user-defined properties
 929                 if (column < m_ColumnManager.GetColumnCount())
 930                 {
 931                         assert(m_ColumnManager.IsUserProp(column));
 932
 933                         const CString& name = m_ColumnManager.GetName(column);
 934                         auto propEntry = m_PropertyMap.find(entry->GetPath());
 935                         if (propEntry != m_PropertyMap.end())
 936                         {
 937                                 if (propEntry->second.HasProperty(name))
 938                                 {
 939                                         const CString& propVal = propEntry->second[name];
 940                                         return propVal.IsEmpty()
 941                                                 ? m_sNoPropValueText
 942                                                 : propVal;
 943                                 }
 944                         }
 945                 }
 946 #endif
 947         }
 948         return empty;
 949 }
 950
 951 void CGitStatusListCtrl::AddEntry(CTGitPath * GitPath, WORD /*langID*/, int listIndex)
 952 {
 953         CAutoWriteLock locker(m_guard);
 954         ScopedInDecrement blocker(m_nBlockItemChangeHandler);
 955         CString path = GitPath->GetGitPathString();
 956
 957         int index = listIndex;
 958         // Load the icons *now* so the icons are cached when showing them later in the
 959         // WM_PAINT handler.
 960         // Problem is that (at least on Win10), loading the icons in the WM_PAINT
 961         // handler triggers an OLE operation, which should not happen in WM_PAINT at all
 962         // (see ..\VC\atlmfc\src\mfc\olemsgf.cpp, COleMessageFilter::OnMessagePending() for details about this)
 963         // By loading the icons here, they get cached and the OLE operation won't happen
 964         // later in the WM_PAINT handler.
 965         // This solves the 'hang' which happens in the commit dialog if images are
 966         // shown in the file list.
 967         int icon_idx = 0;
 968         if (GitPath->IsDirectory())
 969         {
 970                 icon_idx = m_nIconFolder;
 971                 m_nShownSubmodules++;
 972         }
 973         else
 974         {
 975                 icon_idx = SYS_IMAGE_LIST().GetPathIconIndex(*GitPath);
 976                 m_nShownFiles++;
 977         }
 978         switch (GitPath->m_Action)
 979         {
 980         case CTGitPath::LOGACTIONS_ADDED:
 981         case CTGitPath::LOGACTIONS_COPY:
 982                 m_nShownAdded++;
 983                 break;
 984         case CTGitPath::LOGACTIONS_DELETED:
 985         case CTGitPath::LOGACTIONS_MISSING:
 986         case CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING:
 987                 m_nShownDeleted++;
 988                 break;
 989         case CTGitPath::LOGACTIONS_REPLACED:
 990         case CTGitPath::LOGACTIONS_MODIFIED:
 991         case CTGitPath::LOGACTIONS_MERGED:
 992                 m_nShownModified++;
 993                 break;
 994         case CTGitPath::LOGACTIONS_UNMERGED:
 995         case CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ADDED:
 996         case CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_MODIFIED:
 997                 m_nShownConflicted++;
 998                 break;
 999         case CTGitPath::LOGACTIONS_UNVER:
1000                 m_nShownUnversioned++;
1001                 break;
1002         default:
1003                 m_nShownUnversioned++;
1004                 break;
1005         }
1006
1007         LVITEM lvItem = { 0 };
1008         lvItem.iItem = listIndex;
1009         lvItem.lParam = (LPARAM)GitPath;
1010         lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_PARAM;
1011         lvItem.pszText = LPSTR_TEXTCALLBACK;
1012         lvItem.stateMask = LVIS_OVERLAYMASK;
1013         if (m_restorepaths.find(GitPath->GetWinPathString()) != m_restorepaths.end())
1014                 lvItem.state = INDEXTOOVERLAYMASK(OVL_RESTORE);
1015         lvItem.iImage = icon_idx;
1016         InsertItem(&lvItem);
1017
1018         SetCheck(index, GitPath->m_Checked);
1019         if (GitPath->m_Checked)
1020                 m_nSelected++;
1021
1022         if ((GitPath->m_Action & CTGitPath::LOGACTIONS_SKIPWORKTREE) || (GitPath->m_Action & CTGitPath::LOGACTIONS_ASSUMEVALID))
1023                 SetItemGroup(index, 3);
1024         else if (GitPath->m_Action & CTGitPath::LOGACTIONS_IGNORE)
1025                 SetItemGroup(index, 2);
1026         else if( GitPath->m_Action & CTGitPath::LOGACTIONS_UNVER)
1027                 SetItemGroup(index,1);
1028         else
1029                 SetItemGroup(index, GitPath->m_ParentNo&(PARENT_MASK|MERGE_MASK));
1030 }
1031
1032 bool CGitStatusListCtrl::SetItemGroup(int item, int groupindex)
1033 {
1034         CAutoWriteLock locker(m_guard);
1035 //      if (!(m_dwContextMenus & SVNSLC_POPCHANGELISTS))
1036 //              return false;
1037         if (groupindex < 0)
1038                 return false;
1039         LVITEM i = {0};
1040         i.mask = LVIF_GROUPID;
1041         i.iItem = item;
1042         i.iSubItem = 0;
1043         i.iGroupId = groupindex;
1044
1045         return !!SetItem(&i);
1046 }
1047
1048 void CGitStatusListCtrl::OnHdnItemclick(NMHDR *pNMHDR, LRESULT *pResult)
1049 {
1050         LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);
1051         *pResult = 0;
1052
1053         CAutoReadWeakLock lock(m_guard);
1054         if (!lock.IsAcquired())
1055                 return;
1056
1057         if (m_arStatusArray.empty())
1058                 return;
1059
1060         if (m_nSortedColumn == phdr->iItem)
1061                 m_bAscending = !m_bAscending;
1062         else
1063                 m_bAscending = TRUE;
1064         m_nSortedColumn = phdr->iItem;
1065         Show(m_dwShow, 0, m_bShowFolders,false,true);
1066 }
1067
1068 BOOL CGitStatusListCtrl::OnLvnItemchanged(NMHDR *pNMHDR, LRESULT *pResult)
1069 {
1070         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1071         *pResult = 0;
1072         CWnd* pParent = GetLogicalParent();
1073         if (pParent && pParent->GetSafeHwnd())
1074                 pParent->SendMessage(GITSLNM_ITEMCHANGED, pNMLV->iItem);
1075
1076         if (m_nBlockItemChangeHandler)
1077                 return FALSE;
1078
1079         if ((pNMLV->uNewState==0)||(pNMLV->uNewState & LVIS_SELECTED)||(pNMLV->uNewState & LVIS_FOCUSED))
1080                 return FALSE;
1081
1082         CAutoWriteWeakLock writeLock(m_guard);
1083         if (!writeLock.IsAcquired())
1084         {
1085                 NotifyCheck();
1086                 return FALSE;
1087         }
1088
1089         bool bSelected = !!(ListView_GetItemState(m_hWnd, pNMLV->iItem, LVIS_SELECTED) & LVIS_SELECTED);
1090         int nListItems = GetItemCount();
1091
1092         // was the item checked?
1093
1094         if (GetCheck(pNMLV->iItem))
1095         {
1096                 {
1097                         ScopedInDecrement blocker(m_nBlockItemChangeHandler);
1098                         CheckEntry(pNMLV->iItem, nListItems);
1099                 }
1100                 if (bSelected)
1101                 {
1102                         ScopedInDecrement blocker(m_nBlockItemChangeHandler);
1103                         POSITION pos = GetFirstSelectedItemPosition();
1104                         int index;
1105                         while ((index = GetNextSelectedItem(pos)) >= 0)
1106                         {
1107                                 if (index != pNMLV->iItem)
1108                                         CheckEntry(index, nListItems);
1109                         }
1110                 }
1111         }
1112         else
1113         {
1114                 {
1115                         ScopedInDecrement blocker(m_nBlockItemChangeHandler);
1116                         UncheckEntry(pNMLV->iItem, nListItems);
1117                 }
1118                 if (bSelected)
1119                 {
1120                         ScopedInDecrement blocker(m_nBlockItemChangeHandler);
1121                         POSITION pos = GetFirstSelectedItemPosition();
1122                         int index;
1123                         while ((index = GetNextSelectedItem(pos)) >= 0)
1124                         {
1125                                 if (index != pNMLV->iItem)
1126                                         UncheckEntry(index, nListItems);
1127                         }
1128                 }
1129         }
1130
1131         GetStatisticsString();
1132         NotifyCheck();
1133
1134         return FALSE;
1135 }
1136
1137 void CGitStatusListCtrl::CheckEntry(int index, int /*nListItems*/)
1138 {
1139         CAutoWriteLock locker(m_guard);
1140         auto path = GetListEntry(index);
1141         if (!path)
1142                 return;
1143         m_mapFilenameToChecked[path->GetGitPathString()] = true;
1144         SetCheck(index, TRUE);
1145         // if an unversioned item was checked, then we need to check if
1146         // the parent folders are unversioned too. If the parent folders actually
1147         // are unversioned, then check those too.
1148 #if 0
1149         if (entry->status == git_wc_status_unversioned)
1150         {
1151                 // we need to check the parent folder too
1152                 const CTGitPath& folderpath = entry->path;
1153                 for (int i=0; i< nListItems; ++i)
1154                 {
1155                         FileEntry * testEntry = GetListEntry(i);
1156                         ASSERT(testEntry);
1157                         if (!testEntry)
1158                                 continue;
1159                         if (!testEntry->checked)
1160                         {
1161                                 if (testEntry->path.IsAncestorOf(folderpath) && (!testEntry->path.IsEquivalentTo(folderpath)))
1162                                 {
1163                                         SetEntryCheck(testEntry,i,true);
1164                                         m_nSelected++;
1165                                 }
1166                         }
1167                 }
1168         }
1169         bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
1170         if ( (entry->status == git_wc_status_deleted) || (m_bCheckChildrenWithParent) || (bShift) )
1171         {
1172                 // if a deleted folder gets checked, we have to check all
1173                 // children of that folder too.
1174                 if (entry->path.IsDirectory())
1175                         SetCheckOnAllDescendentsOf(entry, true);
1176
1177                 // if a deleted file or folder gets checked, we have to
1178                 // check all parents of this item too.
1179                 for (int i=0; i<nListItems; ++i)
1180                 {
1181                         FileEntry * testEntry = GetListEntry(i);
1182                         ASSERT(testEntry);
1183                         if (!testEntry)
1184                                 continue;
1185                         if (!testEntry->checked)
1186                         {
1187                                 if (testEntry->path.IsAncestorOf(entry->path) && (!testEntry->path.IsEquivalentTo(entry->path)))
1188                                 {
1189                                         if ((testEntry->status == git_wc_status_deleted)||(m_bCheckChildrenWithParent))
1190                                         {
1191                                                 SetEntryCheck(testEntry,i,true);
1192                                                 m_nSelected++;
1193                                                 // now we need to check all children of this parent folder
1194                                                 SetCheckOnAllDescendentsOf(testEntry, true);
1195                                         }
1196                                 }
1197                         }
1198                 }
1199         }
1200 #endif
1201         if ( !path->m_Checked )
1202         {
1203                 path->m_Checked = TRUE;
1204                 m_nSelected++;
1205         }
1206 }
1207
1208 void CGitStatusListCtrl::UncheckEntry(int index, int /*nListItems*/)
1209 {
1210         CAutoWriteLock locker(m_guard);
1211         auto path = GetListEntry(index);
1212         if (!path)
1213                 return;
1214         SetCheck(index, FALSE);
1215         m_mapFilenameToChecked[path->GetGitPathString()] = false;
1216         // item was unchecked
1217 #if 0
1218         if (entry->path.IsDirectory())
1219         {
1220                 // disable all files within an unselected folder, except when unchecking a folder with property changes
1221                 bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
1222                 if ( (entry->status != git_wc_status_modified) || (bShift) )
1223                 {
1224                         SetCheckOnAllDescendentsOf(entry, false);
1225                 }
1226         }
1227         else if (entry->status == git_wc_status_deleted)
1228         {
1229                 // a "deleted" file was unchecked, so uncheck all parent folders
1230                 // and all children of those parents
1231                 for (int i=0; i<nListItems; i++)
1232                 {
1233                         FileEntry * testEntry = GetListEntry(i);
1234                         ASSERT(testEntry);
1235                         if (!testEntry)
1236                                 continue;
1237                         if (testEntry->checked)
1238                         {
1239                                 if (testEntry->path.IsAncestorOf(entry->path))
1240                                 {
1241                                         if (testEntry->status == git_wc_status_deleted)
1242                                         {
1243                                                 SetEntryCheck(testEntry,i,false);
1244                                                 m_nSelected--;
1245
1246                                                 SetCheckOnAllDescendentsOf(testEntry, false);
1247                                         }
1248                                 }
1249                         }
1250                 }
1251         }
1252 #endif
1253         if ( path->m_Checked )
1254         {
1255                 path->m_Checked  = FALSE;
1256                 m_nSelected--;
1257         }
1258 }
1259 void CGitStatusListCtrl::BuildStatistics()
1260 {
1261         CAutoReadLock locker(m_guard);
1262
1263         // now gather some statistics
1264         m_nUnversioned = 0;
1265         m_nNormal = 0;
1266         m_nModified = 0;
1267         m_nAdded = 0;
1268         m_nDeleted = 0;
1269         m_nConflicted = 0;
1270         m_nTotal = 0;
1271         m_nSelected = 0;
1272         m_nLineAdded = 0;
1273         m_nLineDeleted = 0;
1274         m_nRenamed = 0;
1275
1276         for (size_t i = 0; i < m_arStatusArray.size(); ++i)
1277         {
1278                 int status = m_arStatusArray[i]->m_Action;
1279
1280                 m_nLineAdded += _wtol(m_arStatusArray[i]->m_StatAdd);
1281                 m_nLineDeleted += _wtol(m_arStatusArray[i]->m_StatDel);
1282
1283                 if(status&(CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_COPY))
1284                         m_nAdded++;
1285
1286                 if(status&CTGitPath::LOGACTIONS_DELETED)
1287                         m_nDeleted++;
1288
1289                 if(status&(CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_MODIFIED))
1290                         m_nModified++;
1291
1292                 if(status&CTGitPath::LOGACTIONS_UNMERGED)
1293                         m_nConflicted++;
1294
1295                 if(status&(CTGitPath::LOGACTIONS_IGNORE|CTGitPath::LOGACTIONS_UNVER))
1296                         m_nUnversioned++;
1297
1298                 if(status&(CTGitPath::LOGACTIONS_REPLACED))
1299                         m_nRenamed++;
1300
1301                 if (m_arStatusArray[i]->m_Checked)
1302                         m_nSelected++;
1303         }
1304 }
1305
1306 int CGitStatusListCtrl::GetGroupFromPoint(POINT * ppt)
1307 {
1308         // the point must be relative to the upper left corner of the control
1309
1310         if (!ppt)
1311                 return -1;
1312         if (!IsGroupViewEnabled())
1313                 return -1;
1314
1315         POINT pt = *ppt;
1316         pt.x = 10;
1317         UINT flags = 0;
1318         int nItem = -1;
1319         RECT rc;
1320         GetWindowRect(&rc);
1321         while (((flags & LVHT_BELOW) == 0)&&(pt.y < rc.bottom))
1322         {
1323                 nItem = HitTest(pt, &flags);
1324                 if ((flags & LVHT_ONITEM)||(flags & LVHT_EX_GROUP_HEADER))
1325                 {
1326                         // the first item below the point
1327
1328                         // check if the point is too much right (i.e. if the point
1329                         // is farther to the right than the width of the item)
1330                         RECT r;
1331                         GetItemRect(nItem, &r, LVIR_LABEL);
1332                         if (ppt->x > r.right)
1333                                 return -1;
1334
1335                         LVITEM lv = {0};
1336                         lv.mask = LVIF_GROUPID;
1337                         lv.iItem = nItem;
1338                         GetItem(&lv);
1339                         int groupID = lv.iGroupId;
1340                         // now we search upwards and check if the item above this one
1341                         // belongs to another group. If it belongs to the same group,
1342                         // we're not over a group header
1343                         while (pt.y >= 0)
1344                         {
1345                                 pt.y -= 2;
1346                                 nItem = HitTest(pt, &flags);
1347                                 if ((flags & LVHT_ONITEM)&&(nItem >= 0))
1348                                 {
1349                                         // the first item below the point
1350                                         LVITEM lv2 = {0};
1351                                         lv2.mask = LVIF_GROUPID;
1352                                         lv2.iItem = nItem;
1353                                         GetItem(&lv2);
1354                                         if (lv2.iGroupId != groupID)
1355                                                 return groupID;
1356                                         else
1357                                                 return -1;
1358                                 }
1359                         }
1360                         if (pt.y < 0)
1361                                 return groupID;
1362                         return -1;
1363                 }
1364                 pt.y += 2;
1365         };
1366         return -1;
1367 }
1368
1369 void CGitStatusListCtrl::OnContextMenuGroup(CWnd * /*pWnd*/, CPoint point)
1370 {
1371         POINT clientpoint = point;
1372         ScreenToClient(&clientpoint);
1373         if ((IsGroupViewEnabled())&&(GetGroupFromPoint(&clientpoint) >= 0))
1374         {
1375                 CAutoReadWeakLock readLock(m_guard);
1376                 if (!readLock.IsAcquired())
1377                         return;
1378
1379                 CMenu popup;
1380                 if (popup.CreatePopupMenu())
1381                 {
1382                         CString temp;
1383                         temp.LoadString(IDS_STATUSLIST_CHECKGROUP);
1384                         popup.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_CHECKGROUP, temp);
1385                         temp.LoadString(IDS_STATUSLIST_UNCHECKGROUP);
1386                         popup.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_UNCHECKGROUP, temp);
1387                         int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
1388                         bool bCheck = false;
1389                         switch (cmd)
1390                         {
1391                         case IDGITLC_CHECKGROUP:
1392                                 bCheck = true;
1393                                 // fall through here
1394                         case IDGITLC_UNCHECKGROUP:
1395                                 {
1396                                         int group = GetGroupFromPoint(&clientpoint);
1397                                         // go through all items and check/uncheck those assigned to the group
1398                                         // but block the OnLvnItemChanged handler
1399                                         for (int i=0; i<GetItemCount(); ++i)
1400                                         {
1401                                                 LVITEM lv = { 0 };
1402                                                 lv.mask = LVIF_GROUPID;
1403                                                 lv.iItem = i;
1404                                                 GetItem(&lv);
1405
1406                                                 if (lv.iGroupId == group)
1407                                                 {
1408                                                         auto entry = GetListEntry(i);
1409                                                         if (entry)
1410                                                         {
1411                                                                 bool bOldCheck = entry->m_Checked;
1412                                                                 SetEntryCheck(entry, i, bCheck);
1413                                                                 if (bCheck != bOldCheck)
1414                                                                 {
1415                                                                         if (bCheck)
1416                                                                                 m_nSelected++;
1417                                                                         else
1418                                                                                 m_nSelected--;
1419                                                                 }
1420                                                         }
1421                                                 }
1422
1423                                         }
1424                                         GetStatisticsString();
1425                                         NotifyCheck();
1426                                 }
1427                                 break;
1428                         }
1429                 }
1430         }
1431 }
1432
1433 void CGitStatusListCtrl::OnContextMenuList(CWnd * pWnd, CPoint point)
1434 {
1435         bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
1436
1437         CAutoWriteWeakLock writeLock(m_guard);
1438         if (!writeLock.IsAcquired())
1439                 return;
1440
1441         auto selectedCount = GetSelectedCount();
1442         int selIndex = GetSelectionMark();
1443         int selSubitem = -1;
1444         if (selectedCount > 0)
1445         {
1446                 CPoint pt = point;
1447                 ScreenToClient(&pt);
1448                 LVHITTESTINFO hittest = { 0 };
1449                 hittest.flags = LVHT_ONITEM;
1450                 hittest.pt = pt;
1451                 if (this->SubItemHitTest(&hittest) >= 0)
1452                         selSubitem = hittest.iSubItem;
1453         }
1454         if ((point.x == -1) && (point.y == -1))
1455         {
1456                 CRect rect;
1457                 GetItemRect(selIndex, &rect, LVIR_LABEL);
1458                 ClientToScreen(&rect);
1459                 point = rect.CenterPoint();
1460         }
1461         if (selectedCount == 0 && m_bHasCheckboxes)
1462         {
1463                 // nothing selected could mean the context menu is requested for
1464                 // a group header
1465                 OnContextMenuGroup(pWnd, point);
1466         }
1467         else if (selIndex >= 0)
1468         {
1469                 auto filepath = GetListEntry(selIndex);
1470                 if (!filepath)
1471                         return;
1472
1473                 //const CTGitPath& filepath = entry->path;
1474                 int wcStatus = filepath->m_Action;
1475                 // entry is selected, now show the popup menu
1476                 CIconMenu popup;
1477                 CMenu changelistSubMenu;
1478                 CMenu ignoreSubMenu;
1479                 CIconMenu clipSubMenu;
1480                 CMenu shellMenu;
1481                 if (popup.CreatePopupMenu())
1482                 {
1483                         //Add Menu for version controlled file
1484
1485                         if (selectedCount > 0 && (wcStatus & CTGitPath::LOGACTIONS_UNMERGED))
1486                         {
1487                                 if (selectedCount == 1 && (m_dwContextMenus & GITSLC_POPCONFLICT))
1488                                 {
1489                                         popup.AppendMenuIcon(IDGITLC_EDITCONFLICT, IDS_MENUCONFLICT, IDI_CONFLICT);
1490                                         popup.SetDefaultItem(IDGITLC_EDITCONFLICT, FALSE);
1491                                 }
1492                                 if (m_dwContextMenus & GITSLC_POPRESOLVE)
1493                                 {
1494                                         popup.AppendMenuIcon(IDGITLC_RESOLVECONFLICT, IDS_STATUSLIST_CONTEXT_RESOLVED, IDI_RESOLVE);
1495                                         CString tmp, mineTitle, theirsTitle;
1496                                         CAppUtils::GetConflictTitles(nullptr, mineTitle, theirsTitle, m_bIsRevertTheirMy);
1497                                         tmp.Format(IDS_SVNPROGRESS_MENURESOLVEUSING, (LPCTSTR)theirsTitle);
1498                                         if (m_bIsRevertTheirMy)
1499                                         {
1500                                                 popup.AppendMenuIcon(IDGITLC_RESOLVEMINE, tmp, IDI_RESOLVE);
1501                                                 tmp.Format(IDS_SVNPROGRESS_MENURESOLVEUSING, (LPCTSTR)mineTitle);
1502                                                 popup.AppendMenuIcon(IDGITLC_RESOLVETHEIRS, tmp, IDI_RESOLVE);
1503                                         }
1504                                         else
1505                                         {
1506                                                 popup.AppendMenuIcon(IDGITLC_RESOLVETHEIRS, tmp, IDI_RESOLVE);
1507                                                 tmp.Format(IDS_SVNPROGRESS_MENURESOLVEUSING, (LPCTSTR)mineTitle);
1508                                                 popup.AppendMenuIcon(IDGITLC_RESOLVEMINE, tmp, IDI_RESOLVE);
1509                                         }
1510                                 }
1511                                 if ((m_dwContextMenus & GITSLC_POPCONFLICT)||(m_dwContextMenus & GITSLC_POPRESOLVE))
1512                                         popup.AppendMenu(MF_SEPARATOR);
1513                         }
1514
1515                         if (selectedCount > 0)
1516                         {
1517                                 if (wcStatus & (CTGitPath::LOGACTIONS_UNVER | CTGitPath::LOGACTIONS_IGNORE))
1518                                 {
1519                                         if (m_dwContextMenus & GITSLC_POPADD)
1520                                                 popup.AppendMenuIcon(IDGITLC_ADD, IDS_STATUSLIST_CONTEXT_ADD, IDI_ADD);
1521                                         if (m_dwContextMenus & GITSLC_POPCOMMIT)
1522                                                 popup.AppendMenuIcon(IDGITLC_COMMIT, IDS_STATUSLIST_CONTEXT_COMMIT, IDI_COMMIT);
1523                                 }
1524                         }
1525
1526                         if (!(wcStatus & (CTGitPath::LOGACTIONS_UNVER | CTGitPath::LOGACTIONS_IGNORE)) && !((wcStatus & CTGitPath::LOGACTIONS_MISSING) && wcStatus != (CTGitPath::LOGACTIONS_MISSING | CTGitPath::LOGACTIONS_DELETED) && wcStatus != (CTGitPath::LOGACTIONS_MISSING | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MODIFIED)) && selectedCount > 0)
1527                         {
1528                                 bool bEntryAdded = false;
1529                                 if (m_dwContextMenus & GITSLC_POPCOMPAREWITHBASE)
1530                                 {
1531                                         if(filepath->m_ParentNo & MERGE_MASK)
1532                                                 popup.AppendMenuIcon(IDGITLC_COMPARE, IDS_TREE_DIFF, IDI_DIFF);
1533                                         else
1534                                                 popup.AppendMenuIcon(IDGITLC_COMPARE, IDS_LOG_COMPAREWITHBASE, IDI_DIFF);
1535
1536                                         if (!(wcStatus & (CTGitPath::LOGACTIONS_UNMERGED)) || selectedCount != 1)
1537                                                 popup.SetDefaultItem(IDGITLC_COMPARE, FALSE);
1538                                         bEntryAdded = true;
1539                                 }
1540
1541                                 if (!g_Git.IsInitRepos() && (m_dwContextMenus & GITSLC_POPGNUDIFF))
1542                                 {
1543                                         popup.AppendMenuIcon(IDGITLC_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
1544                                         bEntryAdded = true;
1545                                 }
1546
1547                                 if ((m_dwContextMenus & this->GetContextMenuBit(IDGITLC_COMPAREWC)) && m_bHasWC)
1548                                 {
1549                                         if ((!m_CurrentVersion.IsEmpty()) && m_CurrentVersion != GIT_REV_ZERO)
1550                                         {
1551                                                 popup.AppendMenuIcon(IDGITLC_COMPAREWC, IDS_LOG_POPUP_COMPARE, IDI_DIFF);
1552                                                 bEntryAdded = true;
1553                                         }
1554                                 }
1555
1556                                 if (bEntryAdded)
1557                                         popup.AppendMenu(MF_SEPARATOR);
1558                         }
1559
1560                         if (!m_Rev1.IsEmpty() && !m_Rev2.IsEmpty())
1561                         {
1562                                 if (m_dwContextMenus & this->GetContextMenuBit(IDGITLC_COMPARETWOREVISIONS))
1563                                 {
1564                                         popup.AppendMenuIcon(IDGITLC_COMPARETWOREVISIONS, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);
1565                                         popup.SetDefaultItem(IDGITLC_COMPARETWOREVISIONS, FALSE);
1566                                 }
1567                                 if (m_dwContextMenus & this->GetContextMenuBit(IDGITLC_GNUDIFF2REVISIONS))
1568                                         popup.AppendMenuIcon(IDGITLC_GNUDIFF2REVISIONS, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
1569                         }
1570
1571                         //Select Multi item
1572                         if (selectedCount > 0)
1573                         {
1574                                 if (selectedCount == 2 && (m_dwContextMenus & GITSLC_POPCOMPARETWOFILES) && (m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO))
1575                                 {
1576                                         POSITION pos = GetFirstSelectedItemPosition();
1577                                         int index = GetNextSelectedItem(pos);
1578                                         if (index >= 0)
1579                                         {
1580                                                 auto entry2 = GetListEntry(index);
1581                                                 bool firstEntryExistsAndIsFile = entry2 && !entry2->IsDirectory();
1582                                                 index = GetNextSelectedItem(pos);
1583                                                 if (index >= 0)
1584                                                 {
1585                                                         entry2 = GetListEntry(index);
1586                                                         if (firstEntryExistsAndIsFile && entry2 && !entry2->IsDirectory())
1587                                                                 popup.AppendMenuIcon(IDGITLC_COMPARETWOFILES, IDS_STATUSLIST_CONTEXT_COMPARETWOFILES, IDI_DIFF);
1588                                                 }
1589                                         }
1590                                 }
1591                         }
1592
1593                         if (selectedCount > 0 && (!(wcStatus & (CTGitPath::LOGACTIONS_UNVER | CTGitPath::LOGACTIONS_IGNORE))) && m_bHasWC)
1594                         {
1595                                 if ((m_dwContextMenus & GITSLC_POPCOMMIT) && (this->m_CurrentVersion.IsEmpty() || this->m_CurrentVersion == GIT_REV_ZERO) && !(wcStatus & (CTGitPath::LOGACTIONS_SKIPWORKTREE | CTGitPath::LOGACTIONS_ASSUMEVALID)))
1596                                         popup.AppendMenuIcon(IDGITLC_COMMIT, IDS_STATUSLIST_CONTEXT_COMMIT, IDI_COMMIT);
1597
1598                                 if ((m_dwContextMenus & GITSLC_POPREVERT) && (this->m_CurrentVersion.IsEmpty() || this->m_CurrentVersion == GIT_REV_ZERO))
1599                                         popup.AppendMenuIcon(IDGITLC_REVERT, IDS_MENUREVERT, IDI_REVERT);
1600
1601                                 if ((m_dwContextMenus & GITSLC_POPSKIPWORKTREE) && (this->m_CurrentVersion.IsEmpty() || this->m_CurrentVersion == GIT_REV_ZERO) && !(wcStatus & (CTGitPath::LOGACTIONS_ADDED | CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_SKIPWORKTREE)))
1602                                         popup.AppendMenuIcon(IDGITLC_SKIPWORKTREE, IDS_STATUSLIST_SKIPWORKTREE);
1603
1604                                 if ((m_dwContextMenus & GITSLC_POPASSUMEVALID) && (this->m_CurrentVersion.IsEmpty() || this->m_CurrentVersion == GIT_REV_ZERO) && !(wcStatus & (CTGitPath::LOGACTIONS_ADDED | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_UNMERGED | CTGitPath::LOGACTIONS_ASSUMEVALID)))
1605                                         popup.AppendMenuIcon(IDGITLC_ASSUMEVALID, IDS_MENUASSUMEVALID);
1606
1607                                 if ((m_dwContextMenus & GITLC_POPUNSETIGNORELOCALCHANGES) && (this->m_CurrentVersion.IsEmpty() || this->m_CurrentVersion == GIT_REV_ZERO) && (wcStatus & (CTGitPath::LOGACTIONS_SKIPWORKTREE | CTGitPath::LOGACTIONS_ASSUMEVALID)))
1608                                         popup.AppendMenuIcon(IDGITLC_UNSETIGNORELOCALCHANGES, IDS_STATUSLIST_UNSETIGNORELOCALCHANGES);
1609
1610                                 if (m_dwContextMenus & GITSLC_POPRESTORE && !filepath->IsDirectory())
1611                                 {
1612                                         if (m_restorepaths.find(filepath->GetWinPathString()) == m_restorepaths.end())
1613                                                 popup.AppendMenuIcon(IDGITLC_CREATERESTORE, IDS_MENUCREATERESTORE, IDI_RESTORE);
1614                                         else
1615                                                 popup.AppendMenuIcon(IDGITLC_RESTOREPATH, IDS_MENURESTORE, IDI_RESTORE);
1616                                 }
1617
1618                                 if ((m_dwContextMenus & GetContextMenuBit(IDGITLC_REVERTTOREV)) && ( !this->m_CurrentVersion.IsEmpty() )
1619                                         && this->m_CurrentVersion != GIT_REV_ZERO && !(wcStatus & CTGitPath::LOGACTIONS_DELETED))
1620                                 {
1621                                         popup.AppendMenuIcon(IDGITLC_REVERTTOREV, IDS_LOG_POPUP_REVERTTOREV, IDI_REVERT);
1622                                 }
1623
1624                                 if ((m_dwContextMenus & GetContextMenuBit(IDGITLC_REVERTTOPARENT)) && ( !this->m_CurrentVersion.IsEmpty() )
1625                                         && this->m_CurrentVersion != GIT_REV_ZERO && !(wcStatus & CTGitPath::LOGACTIONS_ADDED))
1626                                 {
1627                                         popup.AppendMenuIcon(IDGITLC_REVERTTOPARENT, IDS_LOG_POPUP_REVERTTOPARENT, IDI_REVERT);
1628                                 }
1629                         }
1630
1631                         if (selectedCount == 1 && !(wcStatus & (CTGitPath::LOGACTIONS_UNVER | CTGitPath::LOGACTIONS_IGNORE)))
1632                         {
1633                                 if (m_dwContextMenus & GITSLC_POPSHOWLOG)
1634                                         popup.AppendMenuIcon(IDGITLC_LOG, IDS_REPOBROWSE_SHOWLOG, IDI_LOG);
1635                                 if (m_dwContextMenus & GITSLC_POPSHOWLOGSUBMODULE && filepath->IsDirectory())
1636                                         popup.AppendMenuIcon(IDGITLC_LOGSUBMODULE, IDS_LOG_SUBMODULE, IDI_LOG);
1637                                 if (m_dwContextMenus & GITSLC_POPSHOWLOGOLDNAME && (wcStatus & (CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_COPY) && !filepath->GetGitOldPathString().IsEmpty()))
1638                                         popup.AppendMenuIcon(IDGITLC_LOGOLDNAME, IDS_STATUSLIST_SHOWLOGOLDNAME, IDI_LOG);
1639                                 if ((m_dwContextMenus & GITSLC_POPBLAME) && !filepath->IsDirectory() && !(wcStatus & CTGitPath::LOGACTIONS_DELETED) && !((wcStatus & CTGitPath::LOGACTIONS_ADDED) && (m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)) && m_bHasWC)
1640                                         popup.AppendMenuIcon(IDGITLC_BLAME, IDS_MENUBLAME, IDI_BLAME);
1641                         }
1642
1643                         if (selectedCount > 0)
1644                         {
1645                                 if ((m_dwContextMenus & GetContextMenuBit(IDGITLC_EXPORT)) && !(wcStatus & (CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING)))
1646                                         popup.AppendMenuIcon(IDGITLC_EXPORT, IDS_LOG_POPUP_EXPORT, IDI_EXPORT);
1647                         }
1648
1649                         if (selectedCount == 1)
1650                         {
1651                                 if (m_dwContextMenus & this->GetContextMenuBit(IDGITLC_SAVEAS) && ! filepath->IsDirectory() && !(wcStatus & CTGitPath::LOGACTIONS_DELETED))
1652                                         popup.AppendMenuIcon(IDGITLC_SAVEAS, IDS_LOG_POPUP_SAVE, IDI_SAVEAS);
1653
1654                                 if (m_dwContextMenus & GITSLC_POPOPEN && !filepath->IsDirectory() && !(wcStatus & (CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING)))
1655                                 {
1656                                         popup.AppendMenuIcon(IDGITLC_VIEWREV, IDS_LOG_POPUP_VIEWREV);
1657                                         popup.AppendMenuIcon(IDGITLC_OPEN, IDS_REPOBROWSE_OPEN, IDI_OPEN);
1658                                         popup.AppendMenuIcon(IDGITLC_OPENWITH, IDS_LOG_POPUP_OPENWITH, IDI_OPEN);
1659                                 }
1660
1661                                 if (m_dwContextMenus & GITSLC_POPEXPLORE && !(wcStatus & CTGitPath::LOGACTIONS_DELETED) && m_bHasWC)
1662                                         popup.AppendMenuIcon(IDGITLC_EXPLORE, IDS_STATUSLIST_CONTEXT_EXPLORE, IDI_EXPLORER);
1663
1664                                 if (m_dwContextMenus & GITSLC_PREPAREDIFF && !(wcStatus & CTGitPath::LOGACTIONS_DELETED))
1665                                 {
1666                                         popup.AppendMenu(MF_SEPARATOR);
1667                                         popup.AppendMenuIcon(IDGITLC_PREPAREDIFF, IDS_PREPAREDIFF, IDI_DIFF);
1668                                         if (!m_sMarkForDiffFilename.IsEmpty())
1669                                         {
1670                                                 CString diffWith;
1671                                                 if (filepath->GetGitPathString() == m_sMarkForDiffFilename)
1672                                                         diffWith = m_sMarkForDiffVersion;
1673                                                 else
1674                                                 {
1675                                                         PathCompactPathEx(CStrBuf(diffWith, 2 * GIT_HASH_SIZE), m_sMarkForDiffFilename, 2 * GIT_HASH_SIZE, 0);
1676                                                         diffWith += L':' + m_sMarkForDiffVersion.Left(g_Git.GetShortHASHLength());
1677                                                 }
1678                                                 CString menuEntry;
1679                                                 menuEntry.Format(IDS_MENUDIFFNOW, (LPCTSTR)diffWith);
1680                                                 popup.AppendMenuIcon(IDGITLC_PREPAREDIFF_COMPARE, menuEntry, IDI_DIFF);
1681                                         }
1682                                 }
1683                         }
1684                         if (selectedCount > 0)
1685                         {
1686 //                              if (((wcStatus == git_wc_status_unversioned)||(wcStatus == git_wc_status_ignored))&&(m_dwContextMenus & SVNSLC_POPDELETE))
1687 //                                      popup.AppendMenuIcon(IDSVNLC_DELETE, IDS_MENUREMOVE, IDI_DELETE);
1688 //                              if ((wcStatus != Git_wc_status_unversioned)&&(wcStatus != git_wc_status_ignored)&&(wcStatus != Git_wc_status_deleted)&&(wcStatus != Git_wc_status_added)&&(m_dwContextMenus & GitSLC_POPDELETE))
1689 //                              {
1690 //                                      if (bShift)
1691 //                                              popup.AppendMenuIcon(IDGitLC_REMOVE, IDS_MENUREMOVEKEEP, IDI_DELETE);
1692 //                                      else
1693 //                                              popup.AppendMenuIcon(IDGitLC_REMOVE, IDS_MENUREMOVE, IDI_DELETE);
1694 //                              }
1695                                 if ((wcStatus & (CTGitPath::LOGACTIONS_UNVER | CTGitPath::LOGACTIONS_IGNORE | CTGitPath::LOGACTIONS_MISSING))/*||(wcStatus == git_wc_status_deleted)*/)
1696                                 {
1697                                         if (m_dwContextMenus & GITSLC_POPDELETE)
1698                                                 popup.AppendMenuIcon(IDGITLC_DELETE, IDS_MENUREMOVE, IDI_DELETE);
1699                                 }
1700                                 if ( (wcStatus & CTGitPath::LOGACTIONS_UNVER || wcStatus & CTGitPath::LOGACTIONS_DELETED) )
1701                                 {
1702                                         if (m_dwContextMenus & GITSLC_POPIGNORE)
1703                                         {
1704                                                 CTGitPathList ignorelist;
1705                                                 FillListOfSelectedItemPaths(ignorelist);
1706                                                 //check if all selected entries have the same extension
1707                                                 bool bSameExt = true;
1708                                                 CString sExt;
1709                                                 for (int i=0; i<ignorelist.GetCount(); ++i)
1710                                                 {
1711                                                         if (sExt.IsEmpty() && (i==0))
1712                                                                 sExt = ignorelist[i].GetFileExtension();
1713                                                         else if (sExt.CompareNoCase(ignorelist[i].GetFileExtension())!=0)
1714                                                                 bSameExt = false;
1715                                                 }
1716                                                 if (bSameExt)
1717                                                 {
1718                                                         if (ignoreSubMenu.CreateMenu())
1719                                                         {
1720                                                                 CString ignorepath;
1721                                                                 if (ignorelist.GetCount()==1)
1722                                                                         ignorepath = ignorelist[0].GetFileOrDirectoryName();
1723                                                                 else
1724                                                                         ignorepath.Format(IDS_MENUIGNOREMULTIPLE, ignorelist.GetCount());
1725                                                                 ignoreSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_IGNORE, ignorepath);
1726                                                                 ignorepath = L'*' + sExt;
1727                                                                 ignoreSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_IGNOREMASK, ignorepath);
1728                                                                 if (ignorelist.GetCount() == 1 && !ignorelist[0].GetContainingDirectory().GetGitPathString().IsEmpty())
1729                                                                         ignoreSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_IGNOREFOLDER, ignorelist[0].GetContainingDirectory().GetGitPathString());
1730                                                                 CString temp;
1731                                                                 temp.LoadString(IDS_MENUIGNORE);
1732                                                                 popup.InsertMenu((UINT)-1, MF_BYPOSITION | MF_POPUP, (UINT_PTR)ignoreSubMenu.m_hMenu, temp);
1733                                                         }
1734                                                 }
1735                                                 else
1736                                                 {
1737                                                         CString temp;
1738                                                         if (ignorelist.GetCount()==1)
1739                                                                 temp.LoadString(IDS_MENUIGNORE);
1740                                                         else
1741                                                                 temp.Format(IDS_MENUIGNOREMULTIPLE, ignorelist.GetCount());
1742                                                         popup.AppendMenuIcon(IDGITLC_IGNORE, temp, IDI_IGNORE);
1743                                                         temp.Format(IDS_MENUIGNOREMULTIPLEMASK, ignorelist.GetCount());
1744                                                         popup.AppendMenuIcon(IDGITLC_IGNOREMASK, temp, IDI_IGNORE);
1745                                                 }
1746                                         }
1747                                 }
1748                         }
1749
1750
1751
1752                         if (selectedCount > 0)
1753                         {
1754                                 popup.AppendMenu(MF_SEPARATOR);
1755
1756                                 if (clipSubMenu.CreatePopupMenu())
1757                                 {
1758                                         CString temp;
1759                                         clipSubMenu.AppendMenuIcon(IDGITLC_COPYFULL, IDS_STATUSLIST_CONTEXT_COPYFULLPATHS, IDI_COPYCLIP);
1760                                         clipSubMenu.AppendMenuIcon(IDGITLC_COPYRELPATHS, IDS_STATUSLIST_CONTEXT_COPYRELPATHS, IDI_COPYCLIP);
1761                                         clipSubMenu.AppendMenuIcon(IDGITLC_COPYFILENAMES, IDS_STATUSLIST_CONTEXT_COPYFILENAMES, IDI_COPYCLIP);
1762                                         clipSubMenu.AppendMenuIcon(IDGITLC_COPYEXT, IDS_STATUSLIST_CONTEXT_COPYEXT, IDI_COPYCLIP);
1763                                         if (selSubitem >= 0)
1764                                         {
1765                                                 temp.Format(IDS_STATUSLIST_CONTEXT_COPYCOL, (LPCWSTR)m_ColumnManager.GetName(selSubitem));
1766                                                 clipSubMenu.AppendMenuIcon(IDGITLC_COPYCOL, temp, IDI_COPYCLIP);
1767                                         }
1768                                         temp.LoadString(IDS_LOG_POPUP_COPYTOCLIPBOARD);
1769                                         popup.InsertMenu((UINT)-1, MF_BYPOSITION | MF_POPUP, (UINT_PTR)clipSubMenu.m_hMenu, temp);
1770                                 }
1771
1772 #if 0
1773                                 if ((m_dwContextMenus & SVNSLC_POPCHANGELISTS))
1774                                         &&(wcStatus != git_wc_status_unversioned)&&(wcStatus != git_wc_status_none))
1775                                 {
1776                                         popup.AppendMenu(MF_SEPARATOR);
1777                                         // changelist commands
1778                                         size_t numChangelists = GetNumberOfChangelistsInSelection();
1779                                         if (numChangelists > 0)
1780                                                 popup.AppendMenuIcon(IDSVNLC_REMOVEFROMCS, IDS_STATUSLIST_CONTEXT_REMOVEFROMCS);
1781                                         if ((!entry->IsFolder())&&(changelistSubMenu.CreateMenu()))
1782                                         {
1783                                                 CString temp;
1784                                                 temp.LoadString(IDS_STATUSLIST_CONTEXT_CREATECS);
1785                                                 changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_CREATECS, temp);
1786
1787                                                 if (entry->changelist.Compare(SVNSLC_IGNORECHANGELIST))
1788                                                 {
1789                                                         changelistSubMenu.AppendMenu(MF_SEPARATOR);
1790                                                         changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_CREATEIGNORECS, SVNSLC_IGNORECHANGELIST);
1791                                                 }
1792
1793                                                 if (!m_changelists.empty())
1794                                                 {
1795                                                         // find the changelist names
1796                                                         bool bNeedSeparator = true;
1797                                                         int cmdID = IDSVNLC_MOVETOCS;
1798                                                         for (auto it = m_changelists.cbegin(); it != m_changelists.cend(); ++it)
1799                                                         {
1800                                                                 if ((entry->changelist.Compare(it->first))&&(it->first.Compare(SVNSLC_IGNORECHANGELIST)))
1801                                                                 {
1802                                                                         if (bNeedSeparator)
1803                                                                         {
1804                                                                                 changelistSubMenu.AppendMenu(MF_SEPARATOR);
1805                                                                                 bNeedSeparator = false;
1806                                                                         }
1807                                                                         changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, cmdID, it->first);
1808                                                                         cmdID++;
1809                                                                 }
1810                                                         }
1811                                                 }
1812                                                 temp.LoadString(IDS_STATUSLIST_CONTEXT_MOVETOCS);
1813                                                 popup.AppendMenu(MF_POPUP|MF_STRING, (UINT_PTR)changelistSubMenu.GetSafeHmenu(), temp);
1814                                         }
1815                                 }
1816 #endif
1817                         }
1818
1819                         m_hShellMenu = nullptr;
1820                         if (selectedCount > 0 && !(wcStatus & (CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MISSING)) && m_bHasWC && (m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO) && shellMenu.CreatePopupMenu())
1821                         {
1822                                 // insert the shell context menu
1823                                 popup.AppendMenu(MF_SEPARATOR);
1824                                 popup.InsertMenu((UINT)-1, MF_BYPOSITION | MF_POPUP, (UINT_PTR)shellMenu.m_hMenu, CString(MAKEINTRESOURCE(IDS_STATUSLIST_CONTEXT_SHELL)));
1825                                 m_hShellMenu = shellMenu.m_hMenu;
1826                         }
1827
1828                         int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this);
1829                         g_IContext2 = nullptr;
1830                         g_IContext3 = nullptr;
1831                         if (m_pContextMenu)
1832                         {
1833                                 if (cmd >= SHELL_MIN_CMD && cmd <= SHELL_MAX_CMD) // see if returned idCommand belongs to shell menu entries)
1834                                 {
1835                                         CMINVOKECOMMANDINFOEX cmi = { 0 };
1836                                         cmi.cbSize = sizeof(CMINVOKECOMMANDINFOEX);
1837                                         cmi.fMask = CMIC_MASK_UNICODE | CMIC_MASK_PTINVOKE;
1838                                         if (GetKeyState(VK_CONTROL) < 0)
1839                                                 cmi.fMask |= CMIC_MASK_CONTROL_DOWN;
1840                                         if (bShift)
1841                                                 cmi.fMask |= CMIC_MASK_SHIFT_DOWN;
1842                                         cmi.hwnd = m_hWnd;
1843                                         cmi.lpVerb = MAKEINTRESOURCEA(cmd - SHELL_MIN_CMD);
1844                                         cmi.lpVerbW = MAKEINTRESOURCEW(cmd - SHELL_MIN_CMD);
1845                                         cmi.nShow = SW_SHOWNORMAL;
1846                                         cmi.ptInvoke = point;
1847
1848                                         m_pContextMenu->InvokeCommand((LPCMINVOKECOMMANDINFO)&cmi);
1849
1850                                         cmd = 0;
1851                                 }
1852                                 m_pContextMenu->Release();
1853                                 m_pContextMenu = nullptr;
1854                         }
1855                         if (g_pFolderhook)
1856                         {
1857                                 delete g_pFolderhook;
1858                                 g_pFolderhook = nullptr;
1859                         }
1860                         if (g_psfDesktopFolder)
1861                         {
1862                                 g_psfDesktopFolder->Release();
1863                                 g_psfDesktopFolder = nullptr;
1864                         }
1865                         for (int i = 0; i < g_pidlArrayItems; i++)
1866                         {
1867                                 if (g_pidlArray[i])
1868                                         CoTaskMemFree(g_pidlArray[i]);
1869                         }
1870                         if (g_pidlArray)
1871                                 CoTaskMemFree(g_pidlArray);
1872                         g_pidlArray = nullptr;
1873                         g_pidlArrayItems = 0;
1874
1875                         m_bWaitCursor = true;
1876                         bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
1877                         //int iItemCountBeforeMenuCmd = GetItemCount();
1878                         //bool bForce = false;
1879                         switch (cmd)
1880                         {
1881                         case IDGITLC_VIEWREV:
1882                                 OpenFile(filepath, ALTERNATIVEEDITOR);
1883                                 break;
1884
1885                         case IDGITLC_OPEN:
1886                                 OpenFile(filepath,OPEN);
1887                                 break;
1888
1889                         case IDGITLC_OPENWITH:
1890                                 OpenFile(filepath,OPEN_WITH);
1891                                 break;
1892
1893                         case IDGITLC_EXPLORE:
1894                                 CAppUtils::ExploreTo(GetSafeHwnd(), g_Git.CombinePath(filepath));
1895                                 break;
1896
1897                         case IDGITLC_PREPAREDIFF:
1898                                 m_sMarkForDiffFilename = filepath->GetGitPathString();
1899                                 m_sMarkForDiffVersion = m_CurrentVersion;
1900                                 break;
1901
1902                         case IDGITLC_PREPAREDIFF_COMPARE:
1903                                 {
1904                                         CTGitPath savedFile(m_sMarkForDiffFilename);
1905                                         CGitDiff::Diff(filepath, &savedFile, m_CurrentVersion, m_sMarkForDiffVersion, false, false, 0, bShift);
1906                                 }
1907                                 break;
1908
1909                         case IDGITLC_CREATERESTORE:
1910                                 {
1911                                         POSITION pos = GetFirstSelectedItemPosition();
1912                                         while (pos)
1913                                         {
1914                                                 int index = GetNextSelectedItem(pos);
1915                                                 auto entry2 = GetListEntry(index);
1916                                                 if (!entry2 || entry2->IsDirectory())
1917                                                         continue;
1918                                                 if (m_restorepaths.find(entry2->GetWinPathString()) != m_restorepaths.end())
1919                                                         continue;
1920                                                 CTGitPath tempFile = CTempFiles::Instance().GetTempFilePath(false);
1921                                                 // delete the temp file: the temp file has the FILE_ATTRIBUTE_TEMPORARY flag set
1922                                                 // and copying the real file over it would leave that temp flag.
1923                                                 DeleteFile(tempFile.GetWinPath());
1924                                                 if (CopyFile(g_Git.CombinePath(entry2), tempFile.GetWinPath(), FALSE))
1925                                                 {
1926                                                         m_restorepaths[entry2->GetWinPathString()] = tempFile.GetWinPathString();
1927                                                         SetItemState(index, INDEXTOOVERLAYMASK(OVL_RESTORE), LVIS_OVERLAYMASK);
1928                                                 }
1929                                         }
1930                                         Invalidate();
1931                                 }
1932                                 break;
1933
1934                         case IDGITLC_RESTOREPATH:
1935                                 {
1936                                         if (CMessageBox::Show(m_hWnd, IDS_STATUSLIST_RESTOREPATH, IDS_APPNAME, 2, IDI_QUESTION, IDS_RESTOREBUTTON, IDS_ABORTBUTTON) == 2)
1937                                                 break;
1938                                         POSITION pos = GetFirstSelectedItemPosition();
1939                                         while (pos)
1940                                         {
1941                                                 int index = GetNextSelectedItem(pos);
1942                                                 auto entry2 = GetListEntry(index);
1943                                                 if (!entry2)
1944                                                         continue;
1945                                                 if (m_restorepaths.find(entry2->GetWinPathString()) == m_restorepaths.end())
1946                                                         continue;
1947                                                 if (CopyFile(m_restorepaths[entry2->GetWinPathString()], g_Git.CombinePath(entry2), FALSE))
1948                                                 {
1949                                                         m_restorepaths.erase(entry2->GetWinPathString());
1950                                                         SetItemState(index, 0, LVIS_OVERLAYMASK);
1951                                                 }
1952                                         }
1953                                         Invalidate();
1954                                 }
1955                                 break;
1956
1957                         // Compare current version and work copy.
1958                         case IDGITLC_COMPAREWC:
1959                                 {
1960                                         if (!CheckMultipleDiffs())
1961                                                 break;
1962                                         POSITION pos = GetFirstSelectedItemPosition();
1963                                         while ( pos )
1964                                         {
1965                                                 int index = GetNextSelectedItem(pos);
1966                                                 StartDiffWC(index);
1967                                         }
1968                                 }
1969                                 break;
1970
1971                         // Compare with base version. when current version is zero, compare workcopy and HEAD.
1972                         case IDGITLC_COMPARE:
1973                                 {
1974                                         if (!CheckMultipleDiffs())
1975                                                 break;
1976                                         POSITION pos = GetFirstSelectedItemPosition();
1977                                         while ( pos )
1978                                         {
1979                                                 int index = GetNextSelectedItem(pos);
1980                                                 StartDiff(index);
1981                                         }
1982                                 }
1983                                 break;
1984
1985                         case IDGITLC_COMPARETWOREVISIONS:
1986                                 {
1987                                         if (!CheckMultipleDiffs())
1988                                                 break;
1989                                         POSITION pos = GetFirstSelectedItemPosition();
1990                                         while ( pos )
1991                                         {
1992                                                 int index = GetNextSelectedItem(pos);
1993                                                 StartDiffTwo(index);
1994                                         }
1995                                 }
1996                                 break;
1997
1998                         case IDGITLC_COMPARETWOFILES:
1999                                 {
2000                                         POSITION pos = GetFirstSelectedItemPosition();
2001                                         if (pos)
2002                                         {
2003                                                 auto firstfilepath = GetListEntry(GetNextSelectedItem(pos));
2004                                                 if (!firstfilepath)
2005                                                         break;
2006
2007                                                 auto secondfilepath = GetListEntry(GetNextSelectedItem(pos));
2008                                                 if (!secondfilepath)
2009                                                         break;
2010
2011                                                 CString sCmd;
2012                                                 sCmd.Format(L"/command:diff /path:\"%s\" /endrev:%s /path2:\"%s\" /startrev:%s /hwnd:%p", firstfilepath->GetWinPath(), firstfilepath->Exists() ? GIT_REV_ZERO : L"HEAD", secondfilepath->GetWinPath(), secondfilepath->Exists() ? GIT_REV_ZERO : L"HEAD", (void*)m_hWnd);
2013                                                 if (bShift)
2014                                                         sCmd += L" /alternative";
2015                                                 CAppUtils::RunTortoiseGitProc(sCmd);
2016                                         }
2017                                 }
2018                                 break;
2019
2020                         case IDGITLC_GNUDIFF1:
2021                                 {
2022                                         if (!CheckMultipleDiffs())
2023                                                 break;
2024                                         POSITION pos = GetFirstSelectedItemPosition();
2025                                         while (pos)
2026                                         {
2027                                                 auto selectedFilepath = GetListEntry(GetNextSelectedItem(pos));
2028                                                 if (m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)
2029                                                 {
2030                                                         CString fromwhere;
2031                                                         if (m_amend)
2032                                                                 fromwhere = L"~1";
2033                                                         CAppUtils::StartShowUnifiedDiff(m_hWnd, *selectedFilepath, GitRev::GetHead() + fromwhere, *selectedFilepath, GitRev::GetWorkingCopy(), bShift);
2034                                                 }
2035                                                 else
2036                                                 {
2037                                                         if ((selectedFilepath->m_ParentNo & (PARENT_MASK | MERGE_MASK)) == 0)
2038                                                                 CAppUtils::StartShowUnifiedDiff(m_hWnd, *selectedFilepath, m_CurrentVersion + L"~1", *selectedFilepath, m_CurrentVersion, bShift);
2039                                                         else
2040                                                         {
2041                                                                 CString str;
2042                                                                 if (!(selectedFilepath->m_ParentNo & MERGE_MASK))
2043                                                                         str.Format(L"%s^%d", (LPCTSTR)m_CurrentVersion, (selectedFilepath->m_ParentNo & PARENT_MASK) + 1);
2044
2045                                                                 CAppUtils::StartShowUnifiedDiff(m_hWnd, *selectedFilepath, str, *selectedFilepath, m_CurrentVersion, bShift, false, false, false, !!(selectedFilepath->m_ParentNo & MERGE_MASK));
2046                                                         }
2047                                                 }
2048                                         }
2049                                 }
2050                                 break;
2051
2052                         case IDGITLC_GNUDIFF2REVISIONS:
2053                                 {
2054                                         if (!CheckMultipleDiffs())
2055                                                 break;
2056                                         POSITION pos = GetFirstSelectedItemPosition();
2057                                         while (pos)
2058                                         {
2059                                                 auto entry = GetListEntry(GetNextSelectedItem(pos));
2060                                                 CAppUtils::StartShowUnifiedDiff(m_hWnd, *entry, m_Rev2, *entry, m_Rev1, bShift);
2061                                         }
2062                                 }
2063                                 break;
2064
2065                         case IDGITLC_ADD:
2066                                 {
2067                                         CTGitPathList paths;
2068                                         FillListOfSelectedItemPaths(paths, true);
2069
2070                                         CGitProgressDlg progDlg;
2071                                         AddProgressCommand addCommand;
2072                                         progDlg.SetCommand(&addCommand);
2073                                         addCommand.SetShowCommitButtonAfterAdd((m_dwContextMenus & GITSLC_POPCOMMIT) != 0);
2074                                         addCommand.SetPathList(paths);
2075                                         progDlg.SetItemCount(paths.GetCount());
2076                                         progDlg.DoModal();
2077
2078                                         // reset unchecked status
2079                                         POSITION pos = GetFirstSelectedItemPosition();
2080                                         int index;
2081                                         while ((index = GetNextSelectedItem(pos)) >= 0)
2082                                                 m_mapFilenameToChecked.erase(GetListEntry(index)->GetGitPathString());
2083
2084                                         if (GetLogicalParent() && GetLogicalParent()->GetSafeHwnd())
2085                                                 GetLogicalParent()->SendMessage(GITSLNM_NEEDSREFRESH);
2086
2087                                         SetRedraw(TRUE);
2088                                 }
2089                                 break;
2090
2091                         case IDGITLC_DELETE:
2092                                 DeleteSelectedFiles();
2093                                 break;
2094
2095                         case IDGITLC_BLAME:
2096                                 {
2097                                         CAppUtils::LaunchTortoiseBlame(g_Git.CombinePath(filepath), m_CurrentVersion);
2098                                 }
2099                                 break;
2100
2101                         case IDGITLC_LOG:
2102                         case IDGITLC_LOGSUBMODULE:
2103                                 {
2104                                         CString sCmd;
2105                                         sCmd.Format(L"/command:log /path:\"%s\"", (LPCTSTR)g_Git.CombinePath(filepath));
2106                                         if (cmd == IDGITLC_LOG && filepath->IsDirectory())
2107                                                 sCmd += L" /submodule";
2108                                         if (!m_sDisplayedBranch.IsEmpty())
2109                                                 sCmd += L" /range:\"" + m_sDisplayedBranch + L'"';
2110                                         CAppUtils::RunTortoiseGitProc(sCmd, false, !(cmd == IDGITLC_LOGSUBMODULE));
2111                                 }
2112                                 break;
2113
2114                         case IDGITLC_LOGOLDNAME:
2115                                 {
2116                                         CTGitPath oldName(filepath->GetGitOldPathString());
2117                                         CString sCmd;
2118                                         sCmd.Format(L"/command:log /path:\"%s\"", (LPCTSTR)g_Git.CombinePath(oldName));
2119                                         if (!m_sDisplayedBranch.IsEmpty())
2120                                                 sCmd += L" /range:\"" + m_sDisplayedBranch + L'"';
2121                                         CAppUtils::RunTortoiseGitProc(sCmd);
2122                                 }
2123                                 break;
2124
2125                         case IDGITLC_EDITCONFLICT:
2126                                 {
2127                                         if (CAppUtils::ConflictEdit(*filepath, bShift, m_bIsRevertTheirMy, GetLogicalParent() ? GetLogicalParent()->GetSafeHwnd() : nullptr))
2128                                         {
2129                                                 CString conflictedFile = g_Git.CombinePath(filepath);
2130                                                 if (!PathFileExists(conflictedFile) && GetLogicalParent() && GetLogicalParent()->GetSafeHwnd())
2131                                                 {
2132                                                         GetLogicalParent()->SendMessage(GITSLNM_NEEDSREFRESH);
2133                                                         break;
2134                                                 }
2135                                                 StoreScrollPos();
2136                                                 Show(m_dwShow, 0, m_bShowFolders, 0, true);
2137                                         }
2138                                 }
2139                                 break;
2140
2141                         case IDGITLC_RESOLVETHEIRS: //follow up
2142                         case IDGITLC_RESOLVEMINE:   //follow up
2143                         case IDGITLC_RESOLVECONFLICT:
2144                                 {
2145                                         if (CMessageBox::Show(m_hWnd, IDS_PROC_RESOLVE, IDS_APPNAME, MB_ICONQUESTION | MB_YESNO)==IDYES)
2146                                         {
2147                                                 bool needsFullRefresh = false;
2148                                                 POSITION pos = GetFirstSelectedItemPosition();
2149                                                 while (pos != 0)
2150                                                 {
2151                                                         int index;
2152                                                         index = GetNextSelectedItem(pos);
2153                                                         auto fentry = GetListEntry(index);
2154                                                         if (!fentry)
2155                                                                 continue;
2156
2157                                                         CAppUtils::resolve_with resolveWith = CAppUtils::RESOLVE_WITH_CURRENT;
2158                                                         if (((!this->m_bIsRevertTheirMy) && cmd == IDGITLC_RESOLVETHEIRS) || ((this->m_bIsRevertTheirMy) && cmd == IDGITLC_RESOLVEMINE))
2159                                                                 resolveWith = CAppUtils::RESOLVE_WITH_THEIRS;
2160                                                         else if (((!this->m_bIsRevertTheirMy) && cmd == IDGITLC_RESOLVEMINE) || ((this->m_bIsRevertTheirMy) && cmd == IDGITLC_RESOLVETHEIRS))
2161                                                                 resolveWith = CAppUtils::RESOLVE_WITH_MINE;
2162                                                         if (CAppUtils::ResolveConflict(*fentry, resolveWith) == 0 && fentry->m_Action & CTGitPath::LOGACTIONS_UNMERGED)
2163                                                                 needsFullRefresh = true;
2164                                                 }
2165                                                 if (needsFullRefresh && CRegDWORD(L"Software\\TortoiseGit\\RefreshFileListAfterResolvingConflict", TRUE) == TRUE)
2166                                                 {
2167                                                         CWnd* pParent = GetLogicalParent();
2168                                                         if (pParent && pParent->GetSafeHwnd())
2169                                                                 pParent->SendMessage(GITSLNM_NEEDSREFRESH);
2170                                                         SetRedraw(TRUE);
2171                                                         break;
2172                                                 }
2173                                                 StoreScrollPos();
2174                                                 Show(m_dwShow, 0, m_bShowFolders,0,true);
2175                                         }
2176                                 }
2177                                 break;
2178
2179                         case IDGITLC_IGNORE:
2180                                 {
2181                                         CTGitPathList ignorelist;
2182                                         //std::vector<CString> toremove;
2183                                         FillListOfSelectedItemPaths(ignorelist, true);
2184
2185                                         if(!CAppUtils::IgnoreFile(ignorelist,false))
2186                                                 break;
2187
2188                                         SetRedraw(FALSE);
2189                                         CWnd* pParent = GetLogicalParent();
2190                                         if (pParent && pParent->GetSafeHwnd())
2191                                         {
2192                                                 pParent->SendMessage(GITSLNM_NEEDSREFRESH);
2193                                         }
2194                                         SetRedraw(TRUE);
2195                                 }
2196                                 break;
2197
2198                         case IDGITLC_IGNOREMASK:
2199                                 {
2200                                         CString common;
2201                                         CString ext=filepath->GetFileExtension();
2202                                         CTGitPathList ignorelist;
2203                                         FillListOfSelectedItemPaths(ignorelist, true);
2204
2205                                         if (!CAppUtils::IgnoreFile(ignorelist,true))
2206                                                 break;
2207
2208                                         SetRedraw(FALSE);
2209                                         CWnd* pParent = GetLogicalParent();
2210                                         if (pParent && pParent->GetSafeHwnd())
2211                                         {
2212                                                 pParent->SendMessage(GITSLNM_NEEDSREFRESH);
2213                                         }
2214
2215                                         SetRedraw(TRUE);
2216                                 }
2217                                 break;
2218
2219                         case IDGITLC_IGNOREFOLDER:
2220                                 {
2221                                         CTGitPathList ignorelist;
2222                                         ignorelist.AddPath(filepath->GetContainingDirectory());
2223
2224                                         if (!CAppUtils::IgnoreFile(ignorelist, false))
2225                                                 break;
2226
2227                                         SetRedraw(FALSE);
2228                                         CWnd *pParent = GetLogicalParent();
2229                                         if (pParent && pParent->GetSafeHwnd())
2230                                                 pParent->SendMessage(GITSLNM_NEEDSREFRESH);
2231
2232                                         SetRedraw(TRUE);
2233                                 }
2234                                 break;
2235                         case IDGITLC_COMMIT:
2236                                 {
2237                                         CTGitPathList targetList;
2238                                         FillListOfSelectedItemPaths(targetList);
2239                                         CTGitPath tempFile = CTempFiles::Instance().GetTempFilePath(false);
2240                                         VERIFY(targetList.WriteToFile(tempFile.GetWinPathString()));
2241                                         CString commandline = L"/command:commit /pathfile:\"";
2242                                         commandline += tempFile.GetWinPathString();
2243                                         commandline += L'"';
2244                                         commandline += L" /deletepathfile";
2245                                         CAppUtils::RunTortoiseGitProc(commandline);
2246                                 }
2247                                 break;
2248                         case IDGITLC_REVERT:
2249                                 {
2250                                         // If at least one item is not in the status "added"
2251                                         // we ask for a confirmation
2252                                         BOOL bConfirm = FALSE;
2253                                         POSITION pos = GetFirstSelectedItemPosition();
2254                                         int index;
2255                                         while ((index = GetNextSelectedItem(pos)) >= 0)
2256                                         {
2257                                                 auto fentry = GetListEntry(index);
2258                                                 if(fentry && fentry->m_Action &CTGitPath::LOGACTIONS_MODIFIED && !fentry->IsDirectory())
2259                                                 {
2260                                                         bConfirm = TRUE;
2261                                                         break;
2262                                                 }
2263                                         }
2264
2265                                         CString str;
2266                                         str.Format(IDS_PROC_WARNREVERT, selectedCount);
2267
2268                                         if (!bConfirm || MessageBox(str, L"TortoiseGit", MB_YESNO | MB_ICONQUESTION) == IDYES)
2269                                         {
2270                                                 CTGitPathList targetList;
2271                                                 FillListOfSelectedItemPaths(targetList);
2272
2273                                                 // make sure that the list is reverse sorted, so that
2274                                                 // children are removed before any parents
2275                                                 targetList.SortByPathname(true);
2276
2277                                                 // put all reverted files in the trashbin, except the ones with 'added'
2278                                                 // status because they are not restored by the revert.
2279                                                 CTGitPathList delList;
2280                                                 POSITION pos2 = GetFirstSelectedItemPosition();
2281                                                 int index2;
2282                                                 while ((index2 = GetNextSelectedItem(pos2)) >= 0)
2283                                                 {
2284                                                         auto entry = GetListEntry(index2);
2285                                                         if (entry&&(!(entry->m_Action& CTGitPath::LOGACTIONS_ADDED))
2286                                                                         && (!(entry->m_Action& CTGitPath::LOGACTIONS_REPLACED)) && !entry->IsDirectory())
2287                                                         {
2288                                                                 CTGitPath fullpath;
2289                                                                 fullpath.SetFromWin(g_Git.CombinePath(entry));
2290                                                                 delList.AddPath(fullpath);
2291                                                         }
2292                                                 }
2293                                                 if (DWORD(CRegDWORD(L"Software\\TortoiseGit\\RevertWithRecycleBin", TRUE)))
2294                                                         delList.DeleteAllFiles(true);
2295
2296                                                 CString revertToCommit = L"HEAD";
2297                                                 if (m_amend)
2298                                                         revertToCommit = L"HEAD~1";
2299                                                 CString err;
2300                                                 if (g_Git.Revert(revertToCommit, targetList, err))
2301                                                         MessageBox(L"Revert failed:\n" + err, L"TortoiseGit", MB_ICONERROR);
2302                                                 else
2303                                                 {
2304                                                         bool updateStatusList = false;
2305                                                         for (int i = 0 ; i < targetList.GetCount(); ++i)
2306                                                         {
2307                                                                 int nListboxEntries = GetItemCount();
2308                                                                 for (int nItem=0; nItem<nListboxEntries; ++nItem)
2309                                                                 {
2310                                                                         auto path = GetListEntry(nItem);
2311                                                                         if (path->GetGitPathString()==targetList[i].GetGitPathString() && !path->IsDirectory())
2312                                                                         {
2313                                                                                 if(path->m_Action & CTGitPath::LOGACTIONS_ADDED)
2314                                                                                 {
2315                                                                                         path->m_Action = CTGitPath::LOGACTIONS_UNVER;
2316                                                                                         SetEntryCheck(path,nItem,false);
2317                                                                                         updateStatusList = true;
2318 #if 0 // revert an added file and some entry will be cloned (part 1/2)
2319                                                                                         SetItemGroup(nItem,1);
2320                                                                                         this->m_StatusFileList.RemoveItem(*path);
2321                                                                                         this->m_UnRevFileList.AddPath(*path);
2322                                                                                         //this->m_IgnoreFileList.RemoveItem(*path);
2323 #endif
2324                                                                                 }
2325                                                                                 else
2326                                                                                 {
2327                                                                                         if (GetCheck(nItem))
2328                                                                                                 m_nSelected--;
2329                                                                                         RemoveListEntry(nItem);
2330                                                                                 }
2331                                                                                 break;
2332                                                                         }
2333                                                                         else if (path->GetGitPathString()==targetList[i].GetGitPathString() && path->IsDirectory() && path->IsWCRoot())
2334                                                                         {
2335                                                                                 CString sCmd;
2336                                                                                 sCmd.Format(L"/command:revert /path:\"%s\"", (LPCTSTR)path->GetGitPathString());
2337                                                                                 CCommonAppUtils::RunTortoiseGitProc(sCmd);
2338                                                                         }
2339                                                                 }
2340                                                         }
2341                                                         SetRedraw(TRUE);
2342 #if 0 // revert an added file and some entry will be cloned (part 2/2)
2343                                                         Show(m_dwShow, 0, m_bShowFolders,updateStatusList,true);
2344                                                         NotifyCheck();
2345 #else
2346                                                         if (updateStatusList && GetLogicalParent() && GetLogicalParent()->GetSafeHwnd())
2347                                                                 GetLogicalParent()->SendMessage(GITSLNM_NEEDSREFRESH);
2348 #endif
2349                                                 }
2350                                         }
2351                                 }
2352                                 break;
2353
2354                         case IDGITLC_ASSUMEVALID:
2355                                 SetGitIndexFlagsForSelectedFiles(IDS_PROC_MARK_ASSUMEVALID, BST_CHECKED, BST_INDETERMINATE);
2356                                 break;
2357                         case IDGITLC_SKIPWORKTREE:
2358                                 SetGitIndexFlagsForSelectedFiles(IDS_PROC_MARK_SKIPWORKTREE, BST_INDETERMINATE, BST_CHECKED);
2359                                 break;
2360                         case IDGITLC_UNSETIGNORELOCALCHANGES:
2361                                 SetGitIndexFlagsForSelectedFiles(IDS_PROC_UNSET_IGNORELOCALCHANGES, BST_UNCHECKED, BST_UNCHECKED);
2362                                 break;
2363                         case IDGITLC_COPYFULL:
2364                         case IDGITLC_COPYRELPATHS:
2365                         case IDGITLC_COPYFILENAMES:
2366                                 CopySelectedEntriesToClipboard(GITSLC_COLFILENAME, cmd);
2367                                 break;
2368                         case IDGITLC_COPYEXT:
2369                                 CopySelectedEntriesToClipboard((DWORD)-1, 0);
2370                                 break;
2371                         case IDGITLC_COPYCOL:
2372                                 CopySelectedEntriesToClipboard((DWORD)1 << selSubitem, 0);
2373                                 break;
2374                         case IDGITLC_EXPORT:
2375                                 FilesExport();
2376                                 break;
2377                         case IDGITLC_SAVEAS:
2378                                 FileSaveAs(filepath);
2379                                 break;
2380
2381                         case IDGITLC_REVERTTOREV:
2382                                 RevertSelectedItemToVersion();
2383                                 break;
2384                         case IDGITLC_REVERTTOPARENT:
2385                                 RevertSelectedItemToVersion(true);
2386                                 break;
2387 #if 0
2388                         case IDSVNLC_COMMIT:
2389                                 {
2390                                         CTSVNPathList targetList;
2391                                         FillListOfSelectedItemPaths(targetList);
2392                                         CTSVNPath tempFile = CTempFiles::Instance().GetTempFilePath(false);
2393                                         VERIFY(targetList.WriteToFile(tempFile.GetWinPathString()));
2394                                         CString commandline = CPathUtils::GetAppDirectory();
2395                                         commandline += L"TortoiseGitProc.exe /command:commit /pathfile:\"";
2396                                         commandline += tempFile.GetWinPathString();
2397                                         commandline += L'"';
2398                                         commandline += L" /deletepathfile";
2399                                         CAppUtils::LaunchApplication(commandline, nullptr, false);
2400                                 }
2401                                 break;
2402                         case IDSVNLC_CREATEIGNORECS:
2403                                 CreateChangeList(SVNSLC_IGNORECHANGELIST);
2404                                 break;
2405                         case IDSVNLC_CREATECS:
2406                                 {
2407                                         CCreateChangelistDlg dlg;
2408                                         if (dlg.DoModal() == IDOK)
2409                                                 CreateChangeList(dlg.m_sName);
2410                                 }
2411                                 break;
2412                         default:
2413                                 {
2414                                         if (cmd < IDSVNLC_MOVETOCS)
2415                                                 break;
2416                                         CTSVNPathList changelistItems;
2417                                         FillListOfSelectedItemPaths(changelistItems);
2418
2419                                         // find the changelist name
2420                                         CString sChangelist;
2421                                         int cmdID = IDSVNLC_MOVETOCS;
2422                                         SetRedraw(FALSE);
2423                                         for (auto it = m_changelists.cbegin(); it != m_changelists.cend(); ++it)
2424                                         {
2425                                                 if ((it->first.Compare(SVNSLC_IGNORECHANGELIST))&&(entry->changelist.Compare(it->first)))
2426                                                 {
2427                                                         if (cmd == cmdID)
2428                                                                 sChangelist = it->first;
2429                                                         cmdID++;
2430                                                 }
2431                                         }
2432                                         if (!sChangelist.IsEmpty())
2433                                         {
2434                                                 SVN git;
2435                                                 if (git.AddToChangeList(changelistItems, sChangelist, git_depth_empty))
2436                                                 {
2437                                                         // The changelists were moved, but we now need to run through the selected items again
2438                                                         // and update their changelist
2439                                                         POSITION pos = GetFirstSelectedItemPosition();
2440                                                         int index;
2441                                                         while ((index = GetNextSelectedItem(pos)) >= 0)
2442                                                         {
2443                                                                 FileEntry * e = GetListEntry(index);
2444                                                                 e->changelist = sChangelist;
2445                                                                 if (!e->IsFolder())
2446                                                                 {
2447                                                                         if (m_changelists.find(e->changelist)!=m_changelists.end())
2448                                                                                 SetItemGroup(index, m_changelists[e->changelist]);
2449                                                                         else
2450                                                                                 SetItemGroup(index, 0);
2451                                                                 }
2452                                                         }
2453                                                 }
2454                                                 else
2455                                                         MessageBox(git.GetLastErrorMessage(), L"TortoiseGit", MB_ICONERROR);
2456                                         }
2457                                         SetRedraw(TRUE);
2458                                 }
2459                                 break;
2460 #endif
2461
2462                         } // switch (cmd)
2463                         m_bWaitCursor = false;
2464                         GetStatisticsString();
2465                         //int iItemCountAfterMenuCmd = GetItemCount();
2466                         //if (iItemCountAfterMenuCmd != iItemCountBeforeMenuCmd)
2467                         //{
2468                         //      CWnd* pParent = GetParent();
2469                         //      if (pParent && pParent->GetSafeHwnd())
2470                         //      {
2471                         //              pParent->SendMessage(SVNSLNM_ITEMCOUNTCHANGED);
2472                         //      }
2473                         //}
2474                 } // if (popup.CreatePopupMenu())
2475         } // if (selIndex >= 0)
2476 }
2477
2478 void CGitStatusListCtrl::SetGitIndexFlagsForSelectedFiles(UINT message, BOOL assumevalid, BOOL skipworktree)
2479 {
2480         if (CMessageBox::Show(GetSafeHwnd(), message, IDS_APPNAME, MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION) != IDYES)
2481                 return;
2482
2483         CAutoReadLock locker(m_guard);
2484
2485         CAutoRepository repository(g_Git.GetGitRepository());
2486         if (!repository)
2487         {
2488                 MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONERROR);
2489                 return;
2490         }
2491
2492         CAutoIndex gitindex;
2493         if (git_repository_index(gitindex.GetPointer(), repository))
2494         {
2495                 MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONERROR);
2496                 return;
2497         }
2498
2499         POSITION pos = GetFirstSelectedItemPosition();
2500         int index = -1;
2501         while ((index = GetNextSelectedItem(pos)) >= 0)
2502         {
2503                 auto path = GetListEntry(index);
2504                 if (path == nullptr)
2505                         continue;
2506
2507                 size_t idx;
2508                 if (!git_index_find(&idx, gitindex, CUnicodeUtils::GetMulti(path->GetGitPathString(), CP_UTF8)))
2509                 {
2510                         git_index_entry *e = const_cast<git_index_entry *>(git_index_get_byindex(gitindex, idx)); // HACK
2511                         if (assumevalid == BST_UNCHECKED)
2512                                 e->flags &= ~GIT_IDXENTRY_VALID;
2513                         else if (assumevalid == BST_CHECKED)
2514                                 e->flags |= GIT_IDXENTRY_VALID;
2515                         if (skipworktree == BST_UNCHECKED)
2516                                 e->flags_extended &= ~GIT_IDXENTRY_SKIP_WORKTREE;
2517                         else if (skipworktree == BST_CHECKED)
2518                                 e->flags_extended |= GIT_IDXENTRY_SKIP_WORKTREE;
2519                         git_index_add(gitindex, e);
2520                 }
2521                 else
2522                         MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONERROR);
2523         }
2524
2525         if (git_index_write(gitindex))
2526         {
2527                 MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONERROR);
2528                 return;
2529         }
2530
2531         if (nullptr != GetLogicalParent() && nullptr != GetLogicalParent()->GetSafeHwnd())
2532                 GetLogicalParent()->SendMessage(GITSLNM_NEEDSREFRESH);
2533
2534         SetRedraw(TRUE);
2535 }
2536
2537 void CGitStatusListCtrl::OnContextMenu(CWnd* pWnd, CPoint point)
2538 {
2539         __super::OnContextMenu(pWnd, point);
2540         if (pWnd == this)
2541                 OnContextMenuList(pWnd, point);
2542 }
2543
2544 void CGitStatusListCtrl::OnNMDblclk(NMHDR *pNMHDR, LRESULT *pResult)
2545 {
2546         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
2547         *pResult = 0;
2548
2549         CAutoReadWeakLock readLock(m_guard);
2550         if (!readLock.IsAcquired())
2551                 return;
2552
2553         if (pNMLV->iItem < 0)
2554                 return;
2555
2556         auto file = GetListEntry(pNMLV->iItem);
2557
2558         if (file->m_Action & (CTGitPath::LOGACTIONS_UNVER | CTGitPath::LOGACTIONS_IGNORE)) {
2559                 StartDiffWC(pNMLV->iItem);
2560                 return;
2561         }
2562         if( file->m_Action&CTGitPath::LOGACTIONS_UNMERGED )
2563         {
2564                 if (CAppUtils::ConflictEdit(*file, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000), m_bIsRevertTheirMy, GetLogicalParent() ? GetLogicalParent()->GetSafeHwnd() : nullptr))
2565                 {
2566                         CString conflictedFile = g_Git.CombinePath(file);
2567                         if (!PathFileExists(conflictedFile) && GetLogicalParent() && GetLogicalParent()->GetSafeHwnd())
2568                         {
2569                                 GetLogicalParent()->SendMessage(GITSLNM_NEEDSREFRESH);
2570                                 return;
2571                         }
2572                         StoreScrollPos();
2573                         Show(m_dwShow, 0, m_bShowFolders, 0, true);
2574                 }
2575         }
2576         else if ((file->m_Action & CTGitPath::LOGACTIONS_MISSING) && file->m_Action != (CTGitPath::LOGACTIONS_MISSING | CTGitPath::LOGACTIONS_DELETED) && file->m_Action != (CTGitPath::LOGACTIONS_MISSING | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MODIFIED))
2577                 return;
2578         else
2579         {
2580                 if (!m_Rev1.IsEmpty() && !m_Rev2.IsEmpty())
2581                         StartDiffTwo(pNMLV->iItem);
2582                 else
2583                         StartDiff(pNMLV->iItem);
2584         }
2585 }
2586 void CGitStatusListCtrl::StartDiffTwo(int fileindex)
2587 {
2588         if(fileindex<0)
2589                 return;
2590
2591         CAutoReadLock locker(m_guard);
2592         auto ptr = GetListEntry(fileindex);
2593         if (!ptr)
2594                 return;
2595         CTGitPath file1 = *ptr;
2596
2597         if (file1.m_Action & CTGitPath::LOGACTIONS_ADDED)
2598                 CGitDiff::DiffNull(&file1, m_Rev1, true, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2599         else if (file1.m_Action & CTGitPath::LOGACTIONS_DELETED)
2600                 CGitDiff::DiffNull(&file1, m_Rev2, false, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2601         else
2602                 CGitDiff::Diff(&file1, &file1, m_Rev1, m_Rev2, false, false, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2603 }
2604
2605 void CGitStatusListCtrl::StartDiffWC(int fileindex)
2606 {
2607         if(fileindex<0)
2608                 return;
2609
2610         CAutoReadLock locker(m_guard);
2611         if (m_CurrentVersion.IsEmpty())
2612                 m_CurrentVersion == GIT_REV_ZERO;
2613
2614         auto ptr = GetListEntry(fileindex);
2615         if (!ptr)
2616                 return;
2617         CTGitPath file1 = *ptr;
2618         file1.m_Action = 0; // reset action, so that diff is not started as added/deleted file; see issue #1757
2619
2620         CGitDiff::Diff(&file1, &file1, GIT_REV_ZERO, m_CurrentVersion, false, false, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2621 }
2622
2623 void CGitStatusListCtrl::StartDiff(int fileindex)
2624 {
2625         if(fileindex<0)
2626                 return;
2627
2628         CAutoReadLock locker(m_guard);
2629         auto ptr = GetListEntry(fileindex);
2630         if (!ptr)
2631                 return;
2632         CTGitPath file1 = *ptr;
2633         CTGitPath file2;
2634         if(file1.m_Action & (CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_COPY))
2635                 file2.SetFromGit(file1.GetGitOldPathString());
2636         else
2637                 file2=file1;
2638
2639         if(this->m_CurrentVersion.IsEmpty() || m_CurrentVersion== GIT_REV_ZERO)
2640         {
2641                 CString fromwhere;
2642                 if(m_amend && (file1.m_Action & CTGitPath::LOGACTIONS_ADDED) == 0)
2643                         fromwhere = L"~1";
2644                 if( g_Git.IsInitRepos())
2645                         CGitDiff::DiffNull(GetListEntry(fileindex),
2646                         GIT_REV_ZERO, true, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2647                 else if( file1.m_Action&CTGitPath::LOGACTIONS_ADDED )
2648                         CGitDiff::DiffNull(GetListEntry(fileindex),
2649                         m_CurrentVersion + fromwhere, true, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2650                 else if( file1.m_Action&CTGitPath::LOGACTIONS_DELETED )
2651                         CGitDiff::DiffNull(GetListEntry(fileindex),
2652                         GitRev::GetHead() + fromwhere, false, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2653                 else
2654                         CGitDiff::Diff(&file1,&file2,
2655                                         CString(GIT_REV_ZERO),
2656                                         GitRev::GetHead() + fromwhere, false, false, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2657         }
2658         else
2659         {
2660                 CGitHash hash;
2661                 CString fromwhere = m_CurrentVersion + L"~1";
2662                 if(m_amend)
2663                         fromwhere = m_CurrentVersion + L"~2";
2664                 bool revfail = !!g_Git.GetHash(hash, fromwhere);
2665                 if (revfail || (file1.m_Action & file1.LOGACTIONS_ADDED))
2666                         CGitDiff::DiffNull(&file1, m_CurrentVersion, true, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2667                 else if (file1.m_Action & file1.LOGACTIONS_DELETED)
2668                 {
2669                         if (file1.m_ParentNo > 0)
2670                                 fromwhere.Format(L"%s^%d", (LPCTSTR)m_CurrentVersion, file1.m_ParentNo + 1);
2671
2672                         CGitDiff::DiffNull(&file1, fromwhere, false, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2673                 }
2674                 else
2675                 {
2676                         if( file1.m_ParentNo & MERGE_MASK)
2677                         {
2678                                 CTGitPath base, theirs, mine, merge;
2679
2680                                 CString temppath;
2681                                 GetTempPath(temppath);
2682                                 temppath.TrimRight(L'\\');
2683
2684                                 mine.SetFromGit(temppath + L'\\' + file1.GetFileOrDirectoryName() + L".LOCAL" + file1.GetFileExtension());
2685                                 theirs.SetFromGit(temppath + L'\\' + file1.GetFileOrDirectoryName() + L".REMOTE" + file1.GetFileExtension());
2686                                 base.SetFromGit(temppath + L'\\' + file1.GetFileOrDirectoryName() + L".BASE" + file1.GetFileExtension());
2687
2688                                 CFile tempfile;
2689                                 //create a empty file, incase stage is not three
2690                                 tempfile.Open(mine.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
2691                                 tempfile.Close();
2692                                 tempfile.Open(theirs.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
2693                                 tempfile.Close();
2694                                 tempfile.Open(base.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
2695                                 tempfile.Close();
2696
2697                                 merge.SetFromGit(temppath + L'\\' + file1.GetFileOrDirectoryName() + L".Merged" + file1.GetFileExtension());
2698
2699                                 int parent1=-1, parent2 =-1;
2700                                 for (size_t i = 0; i < m_arStatusArray.size(); ++i)
2701                                 {
2702                                         if(m_arStatusArray[i]->GetGitPathString() == file1.GetGitPathString())
2703                                         {
2704                                                 if(m_arStatusArray[i]->m_ParentNo & MERGE_MASK)
2705                                                 {
2706                                                 }
2707                                                 else
2708                                                 {
2709                                                         if(parent1<0)
2710                                                                 parent1 = m_arStatusArray[i]->m_ParentNo & PARENT_MASK;
2711                                                         else if (parent2 <0)
2712                                                                 parent2 = m_arStatusArray[i]->m_ParentNo & PARENT_MASK;
2713                                                 }
2714                                         }
2715                                 }
2716
2717                                 if(g_Git.GetOneFile(m_CurrentVersion, file1, (CString&)merge.GetWinPathString()))
2718                                         CMessageBox::Show(GetSafeHwnd(), IDS_STATUSLIST_FAILEDGETMERGEFILE, IDS_APPNAME, MB_OK | MB_ICONERROR);
2719
2720                                 if(parent1>=0)
2721                                 {
2722                                         CString str;
2723                                         str.Format(L"%s^%d", (LPCTSTR)this->m_CurrentVersion, parent1 + 1);
2724
2725                                         if(g_Git.GetOneFile(str, file1, (CString&)mine.GetWinPathString()))
2726                                                 CMessageBox::Show(GetSafeHwnd(), IDS_STATUSLIST_FAILEDGETMERGEFILE, IDS_APPNAME, MB_OK | MB_ICONERROR);
2727                                 }
2728
2729                                 if(parent2>=0)
2730                                 {
2731                                         CString str;
2732                                         str.Format(L"%s^%d", (LPCTSTR)this->m_CurrentVersion, parent2 + 1);
2733
2734                                         if(g_Git.GetOneFile(str, file1, (CString&)theirs.GetWinPathString()))
2735                                                 CMessageBox::Show(GetSafeHwnd(), IDS_STATUSLIST_FAILEDGETMERGEFILE, IDS_APPNAME, MB_OK | MB_ICONERROR);
2736                                 }
2737
2738                                 if(parent1>=0 && parent2>=0)
2739                                 {
2740                                         CString cmd, output;
2741                                         cmd.Format(L"git.exe merge-base %s^%d %s^%d", (LPCTSTR)this->m_CurrentVersion, parent1 + 1,
2742                                                 (LPCTSTR)m_CurrentVersion, parent2 + 1);
2743
2744                                         if (!g_Git.Run(cmd, &output, nullptr, CP_UTF8))
2745                                         {
2746                                                 if (g_Git.GetOneFile(output.Left(2 * GIT_HASH_SIZE), file1, (CString&)base.GetWinPathString()))
2747                                                         CMessageBox::Show(GetSafeHwnd(), IDS_STATUSLIST_FAILEDGETBASEFILE, IDS_APPNAME, MB_OK | MB_ICONERROR);
2748                                         }
2749                                 }
2750                                 CAppUtils::StartExtMerge(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000), base, theirs, mine, merge, L"BASE", L"REMOTE", L"LOCAL");
2751                         }
2752                         else
2753                         {
2754                                 CString str;
2755                                 if( (file1.m_ParentNo&PARENT_MASK) == 0)
2756                                         str = L"~1";
2757                                 else
2758                                         str.Format(L"^%d", (file1.m_ParentNo & PARENT_MASK) + 1);
2759                                 CGitDiff::Diff(&file1,&file2,
2760                                         m_CurrentVersion,
2761                                         m_CurrentVersion + str, false, false, 0, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2762                         }
2763                 }
2764         }
2765 }
2766
2767 CString CGitStatusListCtrl::GetStatisticsString(bool simple)
2768 {
2769         CString sNormal = CString(MAKEINTRESOURCE(IDS_STATUSNORMAL));
2770         CString sAdded = CString(MAKEINTRESOURCE(IDS_STATUSADDED));
2771         CString sDeleted = CString(MAKEINTRESOURCE(IDS_STATUSDELETED));
2772         CString sModified = CString(MAKEINTRESOURCE(IDS_STATUSMODIFIED));
2773         CString sConflicted = CString(MAKEINTRESOURCE(IDS_STATUSCONFLICTED));
2774         CString sUnversioned = CString(MAKEINTRESOURCE(IDS_STATUSUNVERSIONED));
2775         CString sRenamed = CString(MAKEINTRESOURCE(IDS_STATUSREPLACED));
2776         CString sToolTip;
2777         if(simple)
2778         {
2779                 sToolTip.Format(IDS_STATUSLIST_STATUSLINE1,
2780                         this->m_nLineAdded,this->m_nLineDeleted,
2781                                 (LPCTSTR)sModified, m_nModified,
2782                                 (LPCTSTR)sAdded, m_nAdded,
2783                                 (LPCTSTR)sDeleted, m_nDeleted,
2784                                 (LPCTSTR)sRenamed, m_nRenamed
2785                         );
2786         }
2787         else
2788         {
2789                 sToolTip.Format(IDS_STATUSLIST_STATUSLINE2,
2790                         this->m_nLineAdded,this->m_nLineDeleted,
2791                                 (LPCTSTR)sNormal, m_nNormal,
2792                                 (LPCTSTR)sUnversioned, m_nUnversioned,
2793                                 (LPCTSTR)sModified, m_nModified,
2794                                 (LPCTSTR)sAdded, m_nAdded,
2795                                 (LPCTSTR)sDeleted, m_nDeleted,
2796                                 (LPCTSTR)sConflicted, m_nConflicted
2797                         );
2798         }
2799         CString sStats;
2800         sStats.Format(IDS_COMMITDLG_STATISTICSFORMAT, m_nSelected, GetItemCount());
2801         if (m_pStatLabel)
2802                 m_pStatLabel->SetWindowText(sStats);
2803
2804         if (m_pSelectButton)
2805         {
2806                 if (m_nSelected == 0)
2807                         m_pSelectButton->SetCheck(BST_UNCHECKED);
2808                 else if (m_nSelected != GetItemCount())
2809                         m_pSelectButton->SetCheck(BST_INDETERMINATE);
2810                 else
2811                         m_pSelectButton->SetCheck(BST_CHECKED);
2812         }
2813
2814         if (m_pConfirmButton)
2815                 m_pConfirmButton->EnableWindow(m_nSelected>0);
2816
2817         return sToolTip;
2818 }
2819
2820 CString CGitStatusListCtrl::GetCommonDirectory(bool bStrict)
2821 {
2822         CAutoReadLock locker(m_guard);
2823         if (!bStrict)
2824         {
2825                 // not strict means that the selected folder has priority
2826                 if (!m_StatusFileList.GetCommonDirectory().IsEmpty())
2827                         return m_StatusFileList.GetCommonDirectory().GetWinPath();
2828         }
2829
2830         CTGitPathList list;
2831         int nListItems = GetItemCount();
2832         for (int i=0; i<nListItems; ++i)
2833         {
2834                 auto* entry = GetListEntry(i);
2835                 if (entry->IsEmpty())
2836                         continue;
2837                 list.AddPath(*entry);
2838         }
2839         return list.GetCommonRoot().GetWinPath();
2840 }
2841
2842 void CGitStatusListCtrl::SelectAll(bool bSelect, bool /*bIncludeNoCommits*/)
2843 {
2844         CWaitCursor waitCursor;
2845         // block here so the LVN_ITEMCHANGED messages
2846         // get ignored
2847         ScopedInDecrement blocker(m_nBlockItemChangeHandler);
2848
2849         {
2850                 CAutoWriteLock locker(m_guard);
2851                 SetRedraw(FALSE);
2852
2853                 int nListItems = GetItemCount();
2854                 if (bSelect)
2855                         m_nSelected = nListItems;
2856                 else
2857                         m_nSelected = 0;
2858
2859                 for (int i=0; i<nListItems; ++i)
2860                 {
2861                         auto path = GetListEntry(i);
2862                         if (!path)
2863                                 continue;
2864                         //if ((bIncludeNoCommits)||(entry->GetChangeList().Compare(SVNSLC_IGNORECHANGELIST)))
2865                         SetEntryCheck(path,i,bSelect);
2866                 }
2867         }
2868         SetRedraw(TRUE);
2869         GetStatisticsString();
2870         NotifyCheck();
2871 }
2872
2873 void CGitStatusListCtrl::Check(DWORD dwCheck, bool check)
2874 {
2875         CWaitCursor waitCursor;
2876         // block here so the LVN_ITEMCHANGED messages
2877         // get ignored
2878         {
2879                 CAutoWriteLock locker(m_guard);
2880                 SetRedraw(FALSE);
2881                 ScopedInDecrement blocker(m_nBlockItemChangeHandler);
2882
2883                 int nListItems = GetItemCount();
2884
2885                 for (int i = 0; i < nListItems; ++i)
2886                 {
2887                         auto entry = GetListEntry(i);
2888                         if (!entry)
2889                                 continue;
2890
2891                         DWORD showFlags = entry->m_Action;
2892                         if (entry->IsDirectory())
2893                                 showFlags |= GITSLC_SHOWSUBMODULES;
2894                         else
2895                                 showFlags |= GITSLC_SHOWFILES;
2896
2897                         if (check && (showFlags & dwCheck) && !GetCheck(i) && !(entry->IsDirectory() && m_bDoNotAutoselectSubmodules && !(dwCheck & GITSLC_SHOWSUBMODULES)))
2898                         {
2899                                 SetEntryCheck(entry, i, true);
2900                                 m_nSelected++;
2901                         }
2902                         else if (!check && (showFlags & dwCheck) && GetCheck(i))
2903                         {
2904                                 SetEntryCheck(entry, i, false);
2905                                 m_nSelected--;
2906                         }
2907                 }
2908         }
2909         SetRedraw(TRUE);
2910         GetStatisticsString();
2911         NotifyCheck();
2912 }
2913
2914 void CGitStatusListCtrl::OnLvnGetInfoTip(NMHDR *pNMHDR, LRESULT *pResult)
2915 {
2916         LPNMLVGETINFOTIP pGetInfoTip = reinterpret_cast<LPNMLVGETINFOTIP>(pNMHDR);
2917         *pResult = 0;
2918         if (CRegDWORD(L"Software\\TortoiseGit\\ShowListFullPathTooltip", TRUE) != TRUE)
2919                 return;
2920
2921         CAutoReadWeakLock readLock(m_guard);
2922         if (!readLock.IsAcquired())
2923                 return;
2924
2925         auto entry = GetListEntry(pGetInfoTip->iItem);
2926
2927         if (entry)
2928                 if (pGetInfoTip->cchTextMax > entry->GetGitPathString().GetLength() + g_Git.m_CurrentDir.GetLength())
2929                 {
2930                         CString str = g_Git.CombinePath(entry->GetWinPathString());
2931                         wcsncpy_s(pGetInfoTip->pszText, pGetInfoTip->cchTextMax, str.GetBuffer(), pGetInfoTip->cchTextMax - 1);
2932                 }
2933 }
2934
2935 void CGitStatusListCtrl::OnNMCustomdraw(NMHDR *pNMHDR, LRESULT *pResult)
2936 {
2937         NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
2938
2939         // Take the default processing unless we set this to something else below.
2940         *pResult = CDRF_DODEFAULT;
2941
2942         // First thing - check the draw stage. If it's the control's prepaint
2943         // stage, then tell Windows we want messages for every item.
2944
2945         switch (pLVCD->nmcd.dwDrawStage)
2946         {
2947         case CDDS_PREPAINT:
2948                 *pResult = CDRF_NOTIFYITEMDRAW;
2949                 break;
2950         case CDDS_ITEMPREPAINT:
2951                 {
2952                         // This is the prepaint stage for an item. Here's where we set the
2953                         // item's text color. Our return value will tell Windows to draw the
2954                         // item itself, but it will use the new color we set here.
2955
2956                         // Tell Windows to paint the control itself.
2957                         *pResult = CDRF_DODEFAULT;
2958                         CAutoReadWeakLock readLock(m_guard, 0);
2959                         if (!readLock.IsAcquired())
2960                                 return;
2961
2962                         COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
2963
2964                         if (m_arStatusArray.size() > (DWORD_PTR)pLVCD->nmcd.dwItemSpec)
2965                         {
2966                                 auto entry = GetListEntry((int)pLVCD->nmcd.dwItemSpec);
2967                                 if (!entry)
2968                                         return;
2969
2970                                 // coloring
2971                                 // ========
2972                                 // black  : unversioned, normal
2973                                 // purple : added
2974                                 // blue   : modified
2975                                 // brown  : missing, deleted, replaced
2976                                 // green  : merged (or potential merges)
2977                                 // red    : conflicts or sure conflicts
2978                                 if(entry->m_Action & CTGitPath::LOGACTIONS_GRAY)
2979                                         crText = RGB(128,128,128);
2980                                 else if(entry->m_Action & CTGitPath::LOGACTIONS_UNMERGED)
2981                                         crText = m_Colors.GetColor(CColors::Conflict);
2982                                 else if(entry->m_Action & (CTGitPath::LOGACTIONS_MODIFIED))
2983                                         crText = m_Colors.GetColor(CColors::Modified);
2984                                 else if(entry->m_Action & (CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_COPY))
2985                                         crText = m_Colors.GetColor(CColors::Added);
2986                                 else if(entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
2987                                         crText = m_Colors.GetColor(CColors::Deleted);
2988                                 else if(entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
2989                                         crText = m_Colors.GetColor(CColors::Renamed);
2990                                 else if(entry->m_Action & CTGitPath::LOGACTIONS_MERGED)
2991                                         crText = m_Colors.GetColor(CColors::Merged);
2992                                 else
2993                                         crText = GetSysColor(COLOR_WINDOWTEXT);
2994                                 // Store the color back in the NMLVCUSTOMDRAW struct.
2995                                 pLVCD->clrText = crText;
2996                         }
2997                 }
2998                 break;
2999         }
3000 }
3001
3002 void CGitStatusListCtrl::OnLvnGetdispinfo(NMHDR* pNMHDR, LRESULT* pResult)
3003 {
3004         auto pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
3005         *pResult = 0;
3006
3007         // Create a pointer to the item
3008         LV_ITEM* pItem = &(pDispInfo)->item;
3009
3010         CAutoReadWeakLock readLock(m_guard, 0);
3011         if (readLock.IsAcquired())
3012         {
3013                 if (pItem->mask & LVIF_TEXT)
3014                 {
3015                         CString text = GetCellText(pItem->iItem, pItem->iSubItem);
3016                         lstrcpyn(pItem->pszText, text, pItem->cchTextMax - 1);
3017                 }
3018         }
3019         else
3020                 pItem->mask = 0;
3021 }
3022
3023 BOOL CGitStatusListCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
3024 {
3025         if (pWnd != this)
3026                 return CListCtrl::OnSetCursor(pWnd, nHitTest, message);
3027         if (!m_bWaitCursor && !m_bBusy)
3028         {
3029                 HCURSOR hCur = LoadCursor(nullptr, IDC_ARROW);
3030                 SetCursor(hCur);
3031                 return CListCtrl::OnSetCursor(pWnd, nHitTest, message);
3032         }
3033         HCURSOR hCur = LoadCursor(nullptr, IDC_WAIT);
3034         SetCursor(hCur);
3035         return TRUE;
3036 }
3037
3038 void CGitStatusListCtrl::RemoveListEntry(int index)
3039 {
3040         CAutoWriteLock locker(m_guard);
3041         DeleteItem(index);
3042
3043         m_arStatusArray.erase(m_arStatusArray.cbegin() + index);
3044
3045 #if 0
3046         delete m_arStatusArray[m_arListArray[index]];
3047         m_arStatusArray.erase(m_arStatusArray.begin()+m_arListArray[index]);
3048         m_arListArray.erase(m_arListArray.begin()+index);
3049         for (int i=index; i< (int)m_arListArray.size(); ++i)
3050         {
3051                 m_arListArray[i]--;
3052         }
3053 #endif
3054 }
3055
3056 ///< Set a checkbox on an entry in the listbox
3057 // NEVER, EVER call SetCheck directly, because you'll end-up with the checkboxes and the 'checked' flag getting out of sync
3058 void CGitStatusListCtrl::SetEntryCheck(CTGitPath* pEntry, int listboxIndex, bool bCheck)
3059 {
3060         CAutoWriteLock locker(m_guard);
3061         pEntry->m_Checked = bCheck;
3062         m_mapFilenameToChecked[pEntry->GetGitPathString()] = bCheck;
3063         SetCheck(listboxIndex, bCheck);
3064 }
3065
3066 void CGitStatusListCtrl::ResetChecked(const CTGitPath& entry)
3067 {
3068         CAutoWriteLock locker(m_guard);
3069         CTGitPath adjustedEntry;
3070         if (g_Git.m_CurrentDir[g_Git.m_CurrentDir.GetLength() - 1] == L'\\')
3071                 adjustedEntry.SetFromWin(entry.GetWinPathString().Right(entry.GetWinPathString().GetLength() - g_Git.m_CurrentDir.GetLength()));
3072         else
3073                 adjustedEntry.SetFromWin(entry.GetWinPathString().Right(entry.GetWinPathString().GetLength() - g_Git.m_CurrentDir.GetLength() - 1));
3074         if (entry.IsDirectory())
3075         {
3076                 STRING_VECTOR toDelete;
3077                 for (auto it = m_mapFilenameToChecked.begin(); it != m_mapFilenameToChecked.end(); ++it)
3078                 {
3079                         if (adjustedEntry.IsAncestorOf(it->first))
3080                                 toDelete.emplace_back(it->first);
3081                 }
3082                 for (const auto& file : toDelete)
3083                         m_mapFilenameToChecked.erase(file);
3084                 return;
3085         }
3086         m_mapFilenameToChecked.erase(adjustedEntry.GetGitPathString());
3087 }
3088
3089 #if 0
3090 void CGitStatusListCtrl::SetCheckOnAllDescendentsOf(const FileEntry* parentEntry, bool bCheck)
3091 {
3092         CAutoWriteLock locker(m_guard);
3093         int nListItems = GetItemCount();
3094         for (int j=0; j< nListItems ; ++j)
3095         {
3096                 FileEntry * childEntry = GetListEntry(j);
3097                 ASSERT(childEntry);
3098                 if (!childEntry || childEntry == parentEntry)
3099                         continue;
3100                 if (childEntry->checked != bCheck)
3101                 {
3102                         if (parentEntry->path.IsAncestorOf(childEntry->path))
3103                         {
3104                                 SetEntryCheck(childEntry,j,bCheck);
3105                                 if(bCheck)
3106                                         m_nSelected++;
3107                                 else
3108                                         m_nSelected--;
3109                         }
3110                 }
3111         }
3112 }
3113 #endif
3114
3115 void CGitStatusListCtrl::WriteCheckedNamesToPathList(CTGitPathList& pathList)
3116 {
3117         pathList.Clear();
3118         CAutoReadLock locker(m_guard);
3119         int nListItems = GetItemCount();
3120         for (int i = 0; i< nListItems; ++i)
3121         {
3122                 auto entry = GetListEntry(i);
3123                 if (entry->m_Checked)
3124                         pathList.AddPath(*entry);
3125         }
3126         pathList.SortByPathname();
3127 }
3128
3129
3130 /// Build a path list of all the selected items in the list (NOTE - SELECTED, not CHECKED)
3131 void CGitStatusListCtrl::FillListOfSelectedItemPaths(CTGitPathList& pathList, bool /*bNoIgnored*/)
3132 {
3133         pathList.Clear();
3134
3135         CAutoReadLock locker(m_guard);
3136         POSITION pos = GetFirstSelectedItemPosition();
3137         int index;
3138         while ((index = GetNextSelectedItem(pos)) >= 0)
3139         {
3140                 auto entry = GetListEntry(index);
3141                 //if ((bNoIgnored)&&(entry->status == git_wc_status_ignored))
3142                 //      continue;
3143                 pathList.AddPath(*entry);
3144         }
3145 }
3146
3147 UINT CGitStatusListCtrl::OnGetDlgCode()
3148 {
3149         // we want to process the return key and not have that one
3150         // routed to the default pushbutton
3151         return CListCtrl::OnGetDlgCode() | DLGC_WANTALLKEYS;
3152 }
3153
3154 void CGitStatusListCtrl::OnNMReturn(NMHDR * /*pNMHDR*/, LRESULT *pResult)
3155 {
3156         *pResult = 0;
3157         CAutoReadWeakLock readLock(m_guard);
3158         if (!readLock.IsAcquired())
3159                 return;
3160         if (!CheckMultipleDiffs())
3161                 return;
3162         bool needsRefresh = false;
3163         bool resolvedTreeConfict = false;
3164         POSITION pos = GetFirstSelectedItemPosition();
3165         while ( pos )
3166         {
3167                 int index = GetNextSelectedItem(pos);
3168                 if (index < 0)
3169                         return;
3170                 auto file = GetListEntry(index);
3171                 if (file == nullptr)
3172                         return;
3173                 if (file->m_Action & (CTGitPath::LOGACTIONS_UNVER | CTGitPath::LOGACTIONS_IGNORE))
3174                         StartDiffWC(index);
3175                 else if ((file->m_Action & CTGitPath::LOGACTIONS_UNMERGED))
3176                 {
3177                         if (CAppUtils::ConflictEdit(*file, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000), m_bIsRevertTheirMy, GetLogicalParent() ? GetLogicalParent()->GetSafeHwnd() : nullptr))
3178                         {
3179                                 CString conflictedFile = g_Git.CombinePath(file);
3180                                 needsRefresh = needsRefresh || !PathFileExists(conflictedFile);
3181                                 resolvedTreeConfict = resolvedTreeConfict || (file->m_Action & CTGitPath::LOGACTIONS_UNMERGED) == 0;
3182                         }
3183                 }
3184                 else if ((file->m_Action & CTGitPath::LOGACTIONS_MISSING) && file->m_Action != (CTGitPath::LOGACTIONS_MISSING | CTGitPath::LOGACTIONS_DELETED) && file->m_Action != (CTGitPath::LOGACTIONS_MISSING | CTGitPath::LOGACTIONS_DELETED | CTGitPath::LOGACTIONS_MODIFIED))
3185                         continue;
3186                 else
3187                 {
3188                         if (!m_Rev1.IsEmpty() && !m_Rev2.IsEmpty())
3189                                 StartDiffTwo(index);
3190                         else
3191                                 StartDiff(index);
3192                 }
3193         }
3194         if (needsRefresh && GetLogicalParent() && GetLogicalParent()->GetSafeHwnd())
3195                 GetLogicalParent()->SendMessage(GITSLNM_NEEDSREFRESH);
3196         else if (resolvedTreeConfict)
3197         {
3198                 StoreScrollPos();
3199                 Show(m_dwShow, 0, m_bShowFolders, 0, true);
3200         }
3201 }
3202
3203 void CGitStatusListCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
3204 {
3205         // Since we catch all keystrokes (to have the enter key processed here instead
3206         // of routed to the default pushbutton) we have to make sure that other
3207         // keys like Tab and Esc still do what they're supposed to do
3208         // Tab = change focus to next/previous control
3209         // Esc = quit the dialog
3210         switch (nChar)
3211         {
3212         case (VK_TAB):
3213                 {
3214                         ::PostMessage(GetLogicalParent()->GetSafeHwnd(), WM_NEXTDLGCTL, GetKeyState(VK_SHIFT)&0x8000, 0);
3215                         return;
3216                 }
3217                 break;
3218         case (VK_ESCAPE):
3219                 {
3220                         ::SendMessage(GetLogicalParent()->GetSafeHwnd(), WM_CLOSE, 0, 0);
3221                 }
3222                 break;
3223         }
3224
3225         CListCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
3226 }
3227
3228 void CGitStatusListCtrl::PreSubclassWindow()
3229 {
3230         __super::PreSubclassWindow();
3231         EnableToolTips(TRUE);
3232         SetWindowTheme(GetSafeHwnd(), L"Explorer", nullptr);
3233 }
3234
3235 void CGitStatusListCtrl::OnPaint()
3236 {
3237         LRESULT defres = Default();
3238         if ((m_bBusy) || (m_bEmpty))
3239         {
3240                 CString str;
3241                 if (m_bBusy)
3242                 {
3243                         if (m_sBusy.IsEmpty())
3244                                 str.LoadString(IDS_STATUSLIST_BUSYMSG);
3245                         else
3246                                 str = m_sBusy;
3247                 }
3248                 else
3249                 {
3250                         if (m_sEmpty.IsEmpty())
3251                                 str.LoadString(IDS_STATUSLIST_EMPTYMSG);
3252                         else
3253                                 str = m_sEmpty;
3254                 }
3255                 COLORREF clrText = ::GetSysColor(COLOR_WINDOWTEXT);
3256                 COLORREF clrTextBk;
3257                 if (IsWindowEnabled())
3258                         clrTextBk = ::GetSysColor(COLOR_WINDOW);
3259                 else
3260                         clrTextBk = ::GetSysColor(COLOR_3DFACE);
3261
3262                 CRect rc;
3263                 GetClientRect(&rc);
3264                 CHeaderCtrl* pHC = GetHeaderCtrl();
3265                 if (pHC)
3266                 {
3267                         CRect rcH;
3268                         pHC->GetItemRect(0, &rcH);
3269                         rc.top += rcH.bottom;
3270                 }
3271                 CDC* pDC = GetDC();
3272                 {
3273                         CMyMemDC memDC(pDC, &rc);
3274
3275                         memDC.SetTextColor(clrText);
3276                         memDC.SetBkColor(clrTextBk);
3277                         memDC.BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), pDC, rc.left, rc.top, SRCCOPY);
3278                         rc.top += 10;
3279                         CGdiObject * oldfont = memDC.SelectStockObject(DEFAULT_GUI_FONT);
3280                         memDC.DrawText(str, rc, DT_CENTER | DT_VCENTER |
3281                                 DT_WORDBREAK | DT_NOPREFIX | DT_NOCLIP);
3282                         memDC.SelectObject(oldfont);
3283                 }
3284                 ReleaseDC(pDC);
3285         }
3286         if (defres)
3287         {
3288                 // the Default() call did not process the WM_PAINT message!
3289                 // Validate the update region ourselves to avoid
3290                 // an endless loop repainting
3291                 CRect rc;
3292                 GetUpdateRect(&rc, FALSE);
3293                 if (!rc.IsRectEmpty())
3294                         ValidateRect(rc);
3295         }
3296 }
3297
3298 void CGitStatusListCtrl::OnBeginDrag(NMHDR* pNMHDR, LRESULT* pResult)
3299 {
3300         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
3301
3302         CAutoReadLock locker(m_guard);
3303
3304         CTGitPathList pathList;
3305         FillListOfSelectedItemPaths(pathList);
3306         if (pathList.IsEmpty())
3307                 return;
3308
3309         auto pdsrc = std::make_unique<CIDropSource>();
3310         if (!pdsrc)
3311                 return;
3312         pdsrc->AddRef();
3313
3314         GitDataObject* pdobj = new GitDataObject(pathList, m_Rev2.IsEmpty() ? m_CurrentVersion : m_Rev2);
3315         if (!pdobj)
3316                 return;
3317         pdobj->AddRef();
3318
3319         CDragSourceHelper dragsrchelper;
3320
3321         SetRedraw(false);
3322         dragsrchelper.InitializeFromWindow(m_hWnd, pNMLV->ptAction, pdobj);
3323         SetRedraw(true);
3324         //dragsrchelper.InitializeFromBitmap()
3325         pdsrc->m_pIDataObj = pdobj;
3326         pdsrc->m_pIDataObj->AddRef();
3327
3328         // Initiate the Drag & Drop
3329         DWORD dwEffect;
3330         m_bOwnDrag = true;
3331         ::DoDragDrop(pdobj, pdsrc.get(), DROPEFFECT_MOVE | DROPEFFECT_COPY, &dwEffect);
3332         m_bOwnDrag = false;
3333         pdsrc->Release();
3334         pdsrc.release();
3335         pdobj->Release();
3336
3337         *pResult = 0;
3338 }
3339
3340 bool CGitStatusListCtrl::EnableFileDrop()
3341 {
3342         m_bFileDropsEnabled = true;
3343         return true;
3344 }
3345
3346 bool CGitStatusListCtrl::HasPath(const CTGitPath& path)
3347 {
3348         CAutoReadLock locker(m_guard);
3349         CTGitPath adjustedEntry;
3350         if (g_Git.m_CurrentDir[g_Git.m_CurrentDir.GetLength() - 1] == L'\\')
3351                 adjustedEntry.SetFromWin(path.GetWinPathString().Right(path.GetWinPathString().GetLength() - g_Git.m_CurrentDir.GetLength()));
3352         else
3353                 adjustedEntry.SetFromWin(path.GetWinPathString().Right(path.GetWinPathString().GetLength() - g_Git.m_CurrentDir.GetLength() - 1));
3354         for (size_t i=0; i < m_arStatusArray.size(); ++i)
3355         {
3356                 if (m_arStatusArray[i]->IsEquivalentTo(adjustedEntry))
3357                         return true;
3358         }
3359
3360         return false;
3361 }
3362
3363 BOOL CGitStatusListCtrl::PreTranslateMessage(MSG* pMsg)
3364 {
3365         if (pMsg->message == WM_KEYDOWN)
3366         {
3367                 switch (pMsg->wParam)
3368                 {
3369                 case 'A':
3370                         {
3371                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
3372                                 {
3373                                         // select all entries
3374                                         for (int i=0; i<GetItemCount(); ++i)
3375                                                 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
3376                                         return TRUE;
3377                                 }
3378                         }
3379                         break;
3380                 case 'C':
3381                 case VK_INSERT:
3382                         {
3383                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
3384                                 {
3385                                         // copy all selected paths to the clipboard
3386                                         if (GetAsyncKeyState(VK_SHIFT)&0x8000)
3387                                                 CopySelectedEntriesToClipboard(GITSLC_COLFILENAME | GITSLC_COLSTATUS, IDGITLC_COPYRELPATHS);
3388                                         else
3389                                                 CopySelectedEntriesToClipboard(GITSLC_COLFILENAME, IDGITLC_COPYRELPATHS);
3390                                         return TRUE;
3391                                 }
3392                         }
3393                         break;
3394                 case VK_DELETE:
3395                         {
3396                                 if ((GetSelectedCount() > 0) && (m_dwContextMenus & GITSLC_POPDELETE))
3397                                 {
3398                                         CAutoReadLock locker(m_guard);
3399                                         auto filepath = GetListEntry(GetSelectionMark());
3400                                         if (filepath != nullptr && (filepath->m_Action & (CTGitPath::LOGACTIONS_UNVER | CTGitPath::LOGACTIONS_IGNORE)))
3401                                                 DeleteSelectedFiles();
3402                                 }
3403                         }
3404                         break;
3405                 }
3406         }
3407
3408         return __super::PreTranslateMessage(pMsg);
3409 }
3410
3411 bool CGitStatusListCtrl::CopySelectedEntriesToClipboard(DWORD dwCols, int cmd)
3412 {
3413         if (GetSelectedCount() == 0)
3414                 return false;
3415
3416         CString sClipboard;
3417
3418         bool bMultipleColumnSelected = ((dwCols & dwCols - 1) != 0); //  multiple columns are selected (clear least signifient bit and check for zero)
3419
3420 #define ADDTOCLIPBOARDSTRING(x) sClipboard += (sClipboard.IsEmpty() || (sClipboard.Right(1)==L"\n")) ? (x) : ('\t' + x)
3421 #define ADDNEWLINETOCLIPBOARDSTRING() sClipboard += (sClipboard.IsEmpty()) ? L"" : L"\r\n"
3422
3423         // first add the column titles as the first line
3424         DWORD selection = 0;
3425         int count = m_ColumnManager.GetColumnCount();
3426         for (int column = 0; column < count; ++column)
3427         {
3428                 if ((dwCols == -1 && m_ColumnManager.IsVisible(column)) || (column < GITSLC_NUMCOLUMNS && (dwCols & (1 << column))))
3429                 {
3430                         if (bMultipleColumnSelected)
3431                                 ADDTOCLIPBOARDSTRING(m_ColumnManager.GetName(column));
3432
3433                         selection |= 1 << column;
3434                 }
3435         }
3436
3437         if (bMultipleColumnSelected)
3438                 ADDNEWLINETOCLIPBOARDSTRING();
3439
3440         // maybe clear first line when only one column is selected (btw by select not by dwCols) is simpler(not faster) way
3441         // but why no title on single column output ?
3442         // if (selection & selection-1) == 0 ) sClipboard = "";
3443
3444         CAutoReadLock locker(m_guard);
3445
3446         POSITION pos = GetFirstSelectedItemPosition();
3447         while (pos)
3448         {
3449                 int index = GetNextSelectedItem(pos);
3450                 // we selected only cols we want, so not other then select test needed
3451                 for (int column = 0; column < count; ++column)
3452                 {
3453                         if (cmd && (GITSLC_COLFILENAME & (1 << column)))
3454                         {
3455                                 auto* entry = GetListEntry(index);
3456                                 if (entry)
3457                                 {
3458                                         CString sPath;
3459                                         switch (cmd)
3460                                         {
3461                                         case IDGITLC_COPYFULL:
3462                                                 sPath = g_Git.CombinePath(entry);
3463                                                 break;
3464                                         case IDGITLC_COPYRELPATHS:
3465                                                 sPath = entry->GetGitPathString();
3466                                                 break;
3467                                         case IDGITLC_COPYFILENAMES:
3468                                                 sPath = entry->GetFileOrDirectoryName();
3469                                                 break;
3470                                         }
3471                                         ADDTOCLIPBOARDSTRING(sPath);
3472                                 }
3473                         }
3474                         else if (selection & (1 << column))
3475                                 ADDTOCLIPBOARDSTRING(GetCellText(index, column));
3476                 }
3477
3478                 ADDNEWLINETOCLIPBOARDSTRING();
3479         }
3480
3481         return CStringUtils::WriteAsciiStringToClipboard(sClipboard);
3482 }
3483
3484 size_t CGitStatusListCtrl::GetNumberOfChangelistsInSelection()
3485 {
3486 #if 0
3487         CAutoReadLock locker(m_guard);
3488         std::set<CString> changelists;
3489         POSITION pos = GetFirstSelectedItemPosition();
3490         int index;
3491         while ((index = GetNextSelectedItem(pos)) >= 0)
3492         {
3493                 FileEntry * entry = GetListEntry(index);
3494                 if (!entry->changelist.IsEmpty())
3495                         changelists.insert(entry->changelist);
3496         }
3497         return changelists.size();
3498 #endif
3499         return 0;
3500 }
3501
3502 bool CGitStatusListCtrl::PrepareGroups(bool bForce /* = false */)
3503 {
3504         CAutoWriteLock locker(m_guard);
3505         bool bHasGroups=false;
3506         int     max =0;
3507
3508         for (size_t i = 0; i < m_arStatusArray.size(); ++i)
3509         {
3510                 int ParentNo = m_arStatusArray[i]->m_ParentNo&PARENT_MASK;
3511                 if( ParentNo > max)
3512                         max=m_arStatusArray[i]->m_ParentNo&PARENT_MASK;
3513         }
3514
3515         if (((m_dwShow & GITSLC_SHOWUNVERSIONED) && !m_UnRevFileList.IsEmpty()) ||
3516                 ((m_dwShow & GITSLC_SHOWIGNORED) && !m_IgnoreFileList.IsEmpty()) ||
3517                 (m_dwShow & (GITSLC_SHOWASSUMEVALID | GITSLC_SHOWSKIPWORKTREE) && !m_LocalChangesIgnoredFileList.IsEmpty()) ||
3518                 max>0 || bForce)
3519         {
3520                 bHasGroups = true;
3521         }
3522
3523         RemoveAllGroups();
3524         EnableGroupView(bHasGroups);
3525
3526         TCHAR groupname[1024] = { 0 };
3527         int groupindex = 0;
3528
3529         if(bHasGroups)
3530         {
3531                 LVGROUP grp = {0};
3532                 grp.cbSize = sizeof(LVGROUP);
3533                 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
3534                 groupindex=0;
3535
3536                 //if(m_UnRevFileList.GetCount()>0)
3537                 if(max >0)
3538                 {
3539                         wcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_MERGEDFILES)), 1023);
3540                         grp.pszHeader = groupname;
3541                         grp.iGroupId = MERGE_MASK;
3542                         grp.uAlign = LVGA_HEADER_LEFT;
3543                         InsertGroup(0, &grp);
3544
3545                         CAutoRepository repository(g_Git.GetGitRepository());
3546                         if (!repository)
3547                                 MessageBox(CGit::GetLibGit2LastErr(L"Could not open repository."), L"TortoiseGit", MB_OK | MB_ICONERROR);
3548                         for (int i = 0; i <= max; ++i)
3549                         {
3550                                 CString str;
3551                                 str.Format(IDS_STATUSLIST_GROUP_DIFFWITHPARENT, i+1);
3552                                 if (repository)
3553                                 {
3554                                         CString rev;
3555                                         rev.Format(L"%s^%d", (LPCTSTR)m_CurrentVersion, i + 1);
3556                                         CGitHash hash;
3557                                         if (!CGit::GetHash(repository, hash, rev))
3558                                                 str += L": " + hash.ToString().Left(g_Git.GetShortHASHLength());
3559                                 }
3560                                 grp.pszHeader = str.GetBuffer();
3561                                 str.ReleaseBuffer();
3562                                 grp.iGroupId = i;
3563                                 grp.uAlign = LVGA_HEADER_LEFT;
3564                                 InsertGroup(i+1, &grp);
3565                         }
3566                 }
3567                 else
3568                 {
3569                         wcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_MODIFIEDFILES)), 1023);
3570                         grp.pszHeader = groupname;
3571                         grp.iGroupId = groupindex;
3572                         grp.uAlign = LVGA_HEADER_LEFT;
3573                         InsertGroup(groupindex++, &grp);
3574
3575                         {
3576                                 wcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_NOTVERSIONEDFILES)), 1023);
3577                                 grp.pszHeader = groupname;
3578                                 grp.iGroupId = groupindex;
3579                                 grp.uAlign = LVGA_HEADER_LEFT;
3580                                 InsertGroup(groupindex++, &grp);
3581                         }
3582
3583                         //if(m_IgnoreFileList.GetCount()>0)
3584                         {
3585                                 wcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_IGNOREDFILES)), 1023);
3586                                 grp.pszHeader = groupname;
3587                                 grp.iGroupId = groupindex;
3588                                 grp.uAlign = LVGA_HEADER_LEFT;
3589                                 InsertGroup(groupindex++, &grp);
3590                         }
3591
3592                         {
3593                                 wcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_IGNORELOCALCHANGES)), 1023);
3594                                 grp.pszHeader = groupname;
3595                                 grp.iGroupId = groupindex;
3596                                 grp.uAlign = LVGA_HEADER_LEFT;
3597                                 InsertGroup(groupindex++, &grp);
3598                         }
3599                 }
3600         }
3601
3602 #if 0
3603         m_bHasIgnoreGroup = false;
3604
3605         // now add the items which don't belong to a group
3606         LVGROUP grp = {0};
3607         grp.cbSize = sizeof(LVGROUP);
3608         grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
3609         CString sUnassignedName(MAKEINTRESOURCE(IDS_STATUSLIST_UNASSIGNED_CHANGESET));
3610         wcsncpy_s(groupname, 1024, (LPCTSTR)sUnassignedName, 1023);
3611         grp.pszHeader = groupname;
3612         grp.iGroupId = groupindex;
3613         grp.uAlign = LVGA_HEADER_LEFT;
3614         InsertGroup(groupindex++, &grp);
3615
3616         for (auto it = m_changelists.cbegin(); it != m_changelists.cend(); ++it)
3617         {
3618                 if (it->first.Compare(SVNSLC_IGNORECHANGELIST)!=0)
3619                 {
3620                         LVGROUP grp = {0};
3621                         grp.cbSize = sizeof(LVGROUP);
3622                         grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
3623                         wcsncpy_s(groupname, 1024, it->first, 1023);
3624                         grp.pszHeader = groupname;
3625                         grp.iGroupId = groupindex;
3626                         grp.uAlign = LVGA_HEADER_LEFT;
3627                         it->second = InsertGroup(groupindex++, &grp);
3628                 }
3629                 else
3630                         m_bHasIgnoreGroup = true;
3631         }
3632
3633         if (m_bHasIgnoreGroup)
3634         {
3635                 // and now add the group 'ignore-on-commit'
3636                 std::map<CString,int>::iterator it = m_changelists.find(SVNSLC_IGNORECHANGELIST);
3637                 if (it != m_changelists.end())
3638                 {
3639                         grp.cbSize = sizeof(LVGROUP);
3640                         grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
3641                         wcsncpy_s(groupname, 1024, SVNSLC_IGNORECHANGELIST, 1023);
3642                         grp.pszHeader = groupname;
3643                         grp.iGroupId = groupindex;
3644                         grp.uAlign = LVGA_HEADER_LEFT;
3645                         it->second = InsertGroup(groupindex, &grp);
3646                 }
3647         }
3648 #endif
3649         return bHasGroups;
3650 }
3651
3652 void CGitStatusListCtrl::NotifyCheck()
3653 {
3654         CWnd* pParent = GetLogicalParent();
3655         if (pParent && pParent->GetSafeHwnd())
3656         {
3657                 pParent->SendMessage(GITSLNM_CHECKCHANGED, m_nSelected);
3658         }
3659 }
3660
3661 int CGitStatusListCtrl::UpdateFileList(const CTGitPathList* list)
3662 {
3663         CAutoWriteLock locker(m_guard);
3664         m_CurrentVersion = GIT_REV_ZERO;
3665
3666         g_Git.GetWorkingTreeChanges(m_StatusFileList, m_amend, list);
3667
3668         BOOL bDeleteChecked = FALSE;
3669         int deleteFromIndex = 0;
3670         bool needsRefresh = false;
3671         for (int i = 0; i < m_StatusFileList.GetCount(); ++i)
3672         {
3673                 auto gitpatch = const_cast<CTGitPath*>(&m_StatusFileList[i]);
3674                 gitpatch->m_Checked = TRUE;
3675
3676                 if ((gitpatch->m_Action & (CTGitPath::LOGACTIONS_ADDED | CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_MODIFIED)) && !gitpatch->Exists())
3677                 {
3678                         if (!bDeleteChecked)
3679                         {
3680                                 CString message;
3681                                 message.Format(IDS_ASK_REMOVE_FROM_INDEX, gitpatch->GetWinPath());
3682                                 deleteFromIndex = CMessageBox::ShowCheck(GetSafeHwnd(), message, L"TortoiseGit", 1, IDI_EXCLAMATION, CString(MAKEINTRESOURCE(IDS_RESTORE_FROM_INDEX)), CString(MAKEINTRESOURCE(IDS_REMOVE_FROM_INDEX)), CString(MAKEINTRESOURCE(IDS_IGNOREBUTTON)), nullptr, CString(MAKEINTRESOURCE(IDS_DO_SAME_FOR_REST)), &bDeleteChecked);
3683                         }
3684                         if (deleteFromIndex == 1)
3685                         {
3686                                 CString err;
3687                                 if (g_Git.Run(L"git.exe checkout -- \"" + gitpatch->GetWinPathString() + L'"', &err, CP_UTF8))
3688                                         MessageBox(L"Restoring from index failed:\n" + err, L"TortoiseGit", MB_ICONERROR);
3689                                 else
3690                                         needsRefresh = true;
3691                         }
3692                         else if (deleteFromIndex == 2)
3693                         {
3694                                 CString err;
3695                                 if (g_Git.Run(L"git.exe rm -f --cache -- \"" + gitpatch->GetWinPathString() + L'"', &err, CP_UTF8))
3696                                         MessageBox(L"Removing from index failed:\n" + err, L"TortoiseGit", MB_ICONERROR);
3697                                 else
3698                                         needsRefresh = true;
3699                         }
3700                 }
3701
3702                 m_arStatusArray.push_back(&m_StatusFileList[i]);
3703         }
3704
3705         if (needsRefresh)
3706                 MessageBox(L"Due to changes to the index, please refresh the dialog (e.g., by pressing F5).", L"TortoiseGit", MB_ICONINFORMATION);
3707
3708         return 0;
3709 }
3710
3711 int CGitStatusListCtrl::UpdateWithGitPathList(CTGitPathList &list)
3712 {
3713         CAutoWriteLock locker(m_guard);
3714         m_arStatusArray.clear();
3715         for (int i = 0; i < list.GetCount(); ++i)
3716         {
3717                 auto gitpath = const_cast<CTGitPath*>(&list[i]);
3718
3719                 if(gitpath ->m_Action & CTGitPath::LOGACTIONS_HIDE)
3720                         continue;
3721
3722                 gitpath->m_Checked = TRUE;
3723                 m_arStatusArray.push_back(&list[i]);
3724         }
3725         return 0;
3726 }
3727
3728 int CGitStatusListCtrl::UpdateUnRevFileList(CTGitPathList &list)
3729 {
3730         CAutoWriteLock locker(m_guard);
3731         m_UnRevFileList = list;
3732         for (int i = 0; i < m_UnRevFileList.GetCount(); ++i)
3733         {
3734                 auto gitpatch = const_cast<CTGitPath*>(&m_UnRevFileList[i]);
3735                 gitpatch->m_Checked = FALSE;
3736                 m_arStatusArray.push_back(&m_UnRevFileList[i]);
3737         }
3738         return 0;
3739 }
3740
3741 int CGitStatusListCtrl::UpdateUnRevFileList(const CTGitPathList* List)
3742 {
3743         CAutoWriteLock locker(m_guard);
3744         CString err;
3745         if (m_UnRevFileList.FillUnRev(CTGitPath::LOGACTIONS_UNVER, List, &err))
3746         {
3747                 MessageBox(L"Failed to get UnRev file list\n" + err, L"TortoiseGit", MB_OK | MB_ICONERROR);
3748                 return -1;
3749         }
3750
3751         if (m_StatusFileList.m_Action & CTGitPath::LOGACTIONS_DELETED)
3752         {
3753                 int unrev = 0;
3754                 int status = 0;
3755                 while (unrev < m_UnRevFileList.GetCount() && status < m_StatusFileList.GetCount())
3756                 {
3757                         auto cmp = CTGitPath::Compare(m_UnRevFileList[unrev], m_StatusFileList[status]);
3758                         if (cmp < 1)
3759                         {
3760                                 ++unrev;
3761                                 continue;
3762                         }
3763                         if (cmp == 1)
3764                                 m_UnRevFileList.RemovePath(m_StatusFileList[status]);
3765                         ++status;
3766                 }
3767         }
3768
3769         for (int i = 0; i < m_UnRevFileList.GetCount(); ++i)
3770         {
3771                 auto gitpatch = const_cast<CTGitPath*>(&m_UnRevFileList[i]);
3772                 gitpatch->m_Checked = FALSE;
3773                 m_arStatusArray.push_back(&m_UnRevFileList[i]);
3774         }
3775         return 0;
3776 }
3777
3778 int CGitStatusListCtrl::UpdateIgnoreFileList(const CTGitPathList* List)
3779 {
3780         CAutoWriteLock locker(m_guard);
3781         CString err;
3782         if (m_IgnoreFileList.FillUnRev(CTGitPath::LOGACTIONS_IGNORE, List, &err))
3783         {
3784                 MessageBox(L"Failed to get Ignore file list\n" + err, L"TortoiseGit", MB_OK | MB_ICONERROR);
3785                 return -1;
3786         }
3787
3788         for (int i = 0; i < m_IgnoreFileList.GetCount(); ++i)
3789         {
3790                 auto gitpatch = const_cast<CTGitPath*>(&m_IgnoreFileList[i]);
3791                 gitpatch->m_Checked = FALSE;
3792                 m_arStatusArray.push_back(&m_IgnoreFileList[i]);
3793         }
3794         return 0;
3795 }
3796
3797 int CGitStatusListCtrl::UpdateLocalChangesIgnoredFileList(const CTGitPathList* list)
3798 {
3799         CAutoWriteLock locker(m_guard);
3800         m_LocalChangesIgnoredFileList.FillBasedOnIndexFlags(GIT_IDXENTRY_VALID, GIT_IDXENTRY_SKIP_WORKTREE, list);
3801         for (int i = 0; i < m_LocalChangesIgnoredFileList.GetCount(); ++i)
3802         {
3803                 auto gitpatch = const_cast<CTGitPath*>(&m_LocalChangesIgnoredFileList[i]);
3804                 gitpatch->m_Checked = FALSE;
3805                 m_arStatusArray.push_back(&m_LocalChangesIgnoredFileList[i]);
3806         }
3807         return 0;
3808 }
3809
3810 int CGitStatusListCtrl::UpdateFileList(int mask, bool once, const CTGitPathList* List)
3811 {
3812         CAutoWriteLock locker(m_guard);
3813         if(mask&CGitStatusListCtrl::FILELIST_MODIFY)
3814         {
3815                 if(once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_MODIFY)))
3816                 {
3817                         UpdateFileList(List);
3818                         m_FileLoaded|=CGitStatusListCtrl::FILELIST_MODIFY;
3819                 }
3820         }
3821         if (mask & CGitStatusListCtrl::FILELIST_UNVER || mask & CGitStatusListCtrl::FILELIST_IGNORE)
3822         {
3823                 if(once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_UNVER)))
3824                 {
3825                         UpdateUnRevFileList(List);
3826                         m_FileLoaded|=CGitStatusListCtrl::FILELIST_UNVER;
3827                 }
3828                 if(mask&CGitStatusListCtrl::FILELIST_IGNORE && (once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_IGNORE))))
3829                 {
3830                         UpdateIgnoreFileList(List);
3831                         m_FileLoaded |= CGitStatusListCtrl::FILELIST_IGNORE;
3832                 }
3833         }
3834         if (mask & CGitStatusListCtrl::FILELIST_LOCALCHANGESIGNORED && (once || (!(m_FileLoaded & CGitStatusListCtrl::FILELIST_LOCALCHANGESIGNORED))))
3835         {
3836                 UpdateLocalChangesIgnoredFileList(List);
3837                 m_FileLoaded |= CGitStatusListCtrl::FILELIST_LOCALCHANGESIGNORED;
3838         }
3839         return 0;
3840 }
3841
3842 void CGitStatusListCtrl::Clear()
3843 {
3844         CAutoWriteLock locker(m_guard);
3845         m_FileLoaded=0;
3846         this->DeleteAllItems();
3847         this->m_arListArray.clear();
3848         this->m_arStatusArray.clear();
3849         this->m_changelists.clear();
3850 }
3851
3852 bool CGitStatusListCtrl::CheckMultipleDiffs()
3853 {
3854         UINT selCount = GetSelectedCount();
3855         if (selCount > max(3, (DWORD)CRegDWORD(L"Software\\TortoiseGit\\NumDiffWarning", 10)))
3856         {
3857                 CString message;
3858                 message.Format(IDS_STATUSLIST_WARN_MAXDIFF, selCount);
3859                 return MessageBox(message, L"TortoiseGit", MB_YESNO | MB_ICONQUESTION) == IDYES;
3860         }
3861         return true;
3862 }
3863
3864 //////////////////////////////////////////////////////////////////////////
3865 bool CGitStatusListCtrlDropTarget::OnDrop(FORMATETC* pFmtEtc, STGMEDIUM& medium, DWORD* /*pdwEffect*/, POINTL pt)
3866 {
3867         if (pFmtEtc->cfFormat == CF_HDROP && medium.tymed == TYMED_HGLOBAL)
3868         {
3869                 HDROP hDrop = (HDROP)GlobalLock(medium.hGlobal);
3870                 if (hDrop)
3871                 {
3872                         TCHAR szFileName[MAX_PATH] = {0};
3873
3874                         UINT cFiles = DragQueryFile(hDrop, 0xFFFFFFFF, nullptr, 0);
3875
3876                         POINT clientpoint;
3877                         clientpoint.x = pt.x;
3878                         clientpoint.y = pt.y;
3879                         ScreenToClient(m_hTargetWnd, &clientpoint);
3880                         if ((m_pGitStatusListCtrl->IsGroupViewEnabled()) && (m_pGitStatusListCtrl->GetGroupFromPoint(&clientpoint) >= 0))
3881                         {
3882 #if 0
3883                                 CTGitPathList changelistItems;
3884                                 for (UINT i = 0; i < cFiles; ++i)
3885                                 {
3886                                         if (DragQueryFile(hDrop, i, szFileName, _countof(szFileName)))
3887                                                 changelistItems.AddPath(CTGitPath(szFileName));
3888                                 }
3889                                 // find the changelist name
3890                                 CString sChangelist;
3891                                 LONG_PTR nGroup = m_pGitStatusListCtrl->GetGroupFromPoint(&clientpoint);
3892                                 for (std::map<CString, int>::iterator it = m_pGitStatusListCtrl->m_changelists.begin(); it != m_pGitStatusListCtrl->m_changelists.end(); ++it)
3893                                         if (it->second == nGroup)
3894                                                 sChangelist = it->first;
3895
3896                                 if (!sChangelist.IsEmpty())
3897                                 {
3898                                         CGit git;
3899                                         if (git.AddToChangeList(changelistItems, sChangelist, git_depth_empty))
3900                                         {
3901                                                 for (int l=0; l<changelistItems.GetCount(); ++l)
3902                                                 {
3903                                                         int index = m_pGitStatusListCtrl->GetIndex(changelistItems[l]);
3904                                                         if (index >= 0)
3905                                                         {
3906                                                                 auto e = m_pGitStatusListCtrl->GetListEntry(index);
3907                                                                 if (e)
3908                                                                 {
3909                                                                         e->changelist = sChangelist;
3910                                                                         if (!e->IsFolder())
3911                                                                         {
3912                                                                                 if (m_pGitStatusListCtrl->m_changelists.find(e->changelist) != m_pGitStatusListCtrl->m_changelists.end())
3913                                                                                         m_pGitStatusListCtrl->SetItemGroup(index, m_pGitStatusListCtrl->m_changelists[e->changelist]);
3914                                                                                 else
3915                                                                                         m_pGitStatusListCtrl->SetItemGroup(index, 0);
3916                                                                         }
3917                                                                 }
3918                                                         }
3919                                                         else
3920                                                         {
3921                                                                 HWND hParentWnd = GetParent(m_hTargetWnd);
3922                                                                 if (hParentWnd)
3923                                                                         ::SendMessage(hParentWnd, CGitStatusListCtrl::GITSLNM_ADDFILE, 0, (LPARAM)changelistItems[l].GetWinPath());
3924                                                         }
3925                                                 }
3926                                         }
3927                                         else
3928                                                 CMessageBox::Show(m_pGitStatusListCtrl->m_hWnd, git.GetLastErrorMessage(), L"TortoiseGit", MB_ICONERROR);
3929                                 }
3930                                 else
3931                                 {
3932                                         SVN git;
3933                                         if (git.RemoveFromChangeList(changelistItems, CStringArray(), git_depth_empty))
3934                                         {
3935                                                 for (int l=0; l<changelistItems.GetCount(); ++l)
3936                                                 {
3937                                                         int index = m_pGitStatusListCtrl->GetIndex(changelistItems[l]);
3938                                                         if (index >= 0)
3939                                                         {
3940                                                                 auto e = m_pGitStatusListCtrl->GetListEntry(index);
3941                                                                 if (e)
3942                                                                 {
3943                                                                         e->changelist = sChangelist;
3944                                                                         m_pGitStatusListCtrl->SetItemGroup(index, 0);
3945                                                                 }
3946                                                         }
3947                                                         else
3948                                                         {
3949                                                                 HWND hParentWnd = GetParent(m_hTargetWnd);
3950                                                                 if (hParentWnd)
3951                                                                         ::SendMessage(hParentWnd, CGitStatusListCtrl::GITSLNM_ADDFILE, 0, (LPARAM)changelistItems[l].GetWinPath());
3952                                                         }
3953                                                 }
3954                                         }
3955                                         else
3956                                                 CMessageBox::Show(m_pGitStatusListCtrl->m_hWnd, git.GetLastErrorMessage(), L"TortoiseGit", MB_ICONERROR);
3957                                 }
3958 #endif
3959                         }
3960                         else
3961                         {
3962                                 for (UINT i = 0; i < cFiles; ++i)
3963                                 {
3964                                         if (!DragQueryFile(hDrop, i, szFileName, _countof(szFileName)))
3965                                                 continue;
3966
3967                                         HWND hParentWnd = GetParent(m_hTargetWnd);
3968                                         if (hParentWnd)
3969                                                 ::SendMessage(hParentWnd, CGitStatusListCtrl::GITSLNM_ADDFILE, 0, (LPARAM)szFileName);
3970                                 }
3971                         }
3972                 }
3973                 GlobalUnlock(medium.hGlobal);
3974         }
3975         return true; //let base free the medium
3976 }
3977
3978 HRESULT STDMETHODCALLTYPE CGitStatusListCtrlDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD __RPC_FAR* pdwEffect)
3979 {
3980         CIDropTarget::DragOver(grfKeyState, pt, pdwEffect);
3981         *pdwEffect = DROPEFFECT_COPY;
3982         if (m_pGitStatusListCtrl)
3983         {
3984                 POINT clientpoint;
3985                 clientpoint.x = pt.x;
3986                 clientpoint.y = pt.y;
3987                 ScreenToClient(m_hTargetWnd, &clientpoint);
3988                 if ((m_pGitStatusListCtrl->IsGroupViewEnabled()) && (m_pGitStatusListCtrl->GetGroupFromPoint(&clientpoint) >= 0))
3989                         *pdwEffect = DROPEFFECT_NONE;
3990                 else if ((!m_pGitStatusListCtrl->m_bFileDropsEnabled) || (m_pGitStatusListCtrl->m_bOwnDrag))
3991                         *pdwEffect = DROPEFFECT_NONE;
3992         }
3993         return S_OK;
3994 }
3995
3996 void CGitStatusListCtrl::FilesExport()
3997 {
3998         CAutoReadLock locker(m_guard);
3999         CString exportDir;
4000         // export all changed files to a folder
4001         CBrowseFolder browseFolder;
4002         browseFolder.m_style = BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
4003         if (browseFolder.Show(GetSafeHwnd(), exportDir) != CBrowseFolder::OK)
4004                 return;
4005
4006         POSITION pos = GetFirstSelectedItemPosition();
4007         int index;
4008         while ((index = GetNextSelectedItem(pos)) >= 0)
4009         {
4010                 auto fd = GetListEntry(index);
4011                 // we cannot export directories or folders
4012                 if ((fd->m_Action & CTGitPath::LOGACTIONS_DELETED) || fd->IsDirectory())
4013                         continue;
4014
4015                 CPathUtils::MakeSureDirectoryPathExists(exportDir + L'\\' + fd->GetContainingDirectory().GetWinPathString());
4016                 CString filename = exportDir + L'\\' + fd->GetWinPathString();
4017                 if (m_CurrentVersion == GIT_REV_ZERO)
4018                 {
4019                         if (!CopyFile(g_Git.CombinePath(fd), filename, false))
4020                         {
4021                                 MessageBox(CFormatMessageWrapper(), L"TortoiseGit", MB_OK | MB_ICONERROR);
4022                                 return;
4023                         }
4024                 }
4025                 else
4026                 {
4027                         if (g_Git.GetOneFile(m_CurrentVersion, *fd, filename))
4028                         {
4029                                 CString out;
4030                                 out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, (LPCTSTR)fd->GetGitPathString(), (LPCTSTR)m_CurrentVersion, (LPCTSTR)filename);
4031                                 if (CMessageBox::Show(GetSafeHwnd(), g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), L"TortoiseGit", 2, IDI_WARNING, CString(MAKEINTRESOURCE(IDS_IGNOREBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 2)
4032                                         return;
4033                         }
4034                 }
4035         }
4036 }
4037
4038 void CGitStatusListCtrl::FileSaveAs(CTGitPath *path)
4039 {
4040         CAutoReadLock locker(m_guard);
4041         CString filename;
4042         filename.Format(L"%s\\%s-%s%s", (LPCTSTR)g_Git.CombinePath(path->GetContainingDirectory()), (LPCTSTR)path->GetBaseFilename(), (LPCTSTR)m_CurrentVersion.Left(g_Git.GetShortHASHLength()), (LPCTSTR)path->GetFileExtension());
4043         if (!CAppUtils::FileOpenSave(filename, nullptr, 0, 0, false, GetSafeHwnd()))
4044                 return;
4045         if (m_CurrentVersion == GIT_REV_ZERO)
4046         {
4047                 if (!CopyFile(g_Git.CombinePath(path), filename, false))
4048                 {
4049                         MessageBox(CFormatMessageWrapper(), L"TortoiseGit", MB_OK | MB_ICONERROR);
4050                         return;
4051                 }
4052         }
4053         else
4054         {
4055                 if (g_Git.GetOneFile(m_CurrentVersion, *path, filename))
4056                 {
4057                         CString out;
4058                         out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, (LPCTSTR)path->GetGitPathString(), (LPCTSTR)m_CurrentVersion, (LPCTSTR)filename);
4059                         CMessageBox::Show(GetSafeHwnd(), g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), L"TortoiseGit", MB_OK);
4060                         return;
4061                 }
4062         }
4063 }
4064
4065 int CGitStatusListCtrl::RevertSelectedItemToVersion(bool parent)
4066 {
4067         CAutoReadLock locker(m_guard);
4068         if(this->m_CurrentVersion.IsEmpty())
4069                 return 0;
4070         if(this->m_CurrentVersion == GIT_REV_ZERO)
4071                 return 0;
4072
4073         POSITION pos = GetFirstSelectedItemPosition();
4074         int index;
4075         CString cmd,out;
4076         std::map<CString, int> versionMap;
4077         while ((index = GetNextSelectedItem(pos)) >= 0)
4078         {
4079                 auto fentry = GetListEntry(index);
4080                 CString version;
4081                 if (parent)
4082                 {
4083                         int parentNo = fentry->m_ParentNo & PARENT_MASK;
4084                         CString ref;
4085                         ref.Format(L"%s^%d", (LPCTSTR)m_CurrentVersion, parentNo + 1);
4086                         CGitHash hash;
4087                         if (g_Git.GetHash(hash, ref))
4088                         {
4089                                 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of ref \"" + ref + L"\"."), L"TortoiseGit", MB_ICONERROR);
4090                                 continue;
4091                         }
4092
4093                         version = hash.ToString();
4094                 }
4095                 else
4096                         version = m_CurrentVersion;
4097
4098                 CString filename = fentry->GetGitPathString();
4099                 if (!fentry->GetGitOldPathString().IsEmpty())
4100                         filename = fentry->GetGitOldPathString();
4101                 cmd.Format(L"git.exe checkout %s -- \"%s\"", (LPCTSTR)version, (LPCTSTR)filename);
4102                 out.Empty();
4103                 if (g_Git.Run(cmd, &out, CP_UTF8))
4104                 {
4105                         if (MessageBox(out, L"TortoiseGit", MB_ICONEXCLAMATION | MB_OKCANCEL) == IDCANCEL)
4106                                 continue;
4107                 }
4108                 else
4109                         versionMap[version]++;
4110         }
4111
4112         out.Empty();
4113         for (auto it = versionMap.cbegin(); it != versionMap.cend(); ++it)
4114         {
4115                 CString versionEntry;
4116                 versionEntry.Format(IDS_STATUSLIST_FILESREVERTED, it->second, (LPCTSTR)it->first);
4117                 out += versionEntry + L"\r\n";
4118         }
4119         if (!out.IsEmpty())
4120         {
4121                 if (GetLogicalParent() && GetLogicalParent()->GetSafeHwnd())
4122                         GetLogicalParent()->SendMessage(GITSLNM_NEEDSREFRESH);
4123                 CMessageBox::Show(GetSafeHwnd(), out, L"TortoiseGit", MB_OK);
4124         }
4125         return 0;
4126 }
4127
4128 void CGitStatusListCtrl::OpenFile(CTGitPath*filepath,int mode)
4129 {
4130         CString file;
4131         if(this->m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)
4132                 file = g_Git.CombinePath(filepath);
4133         else
4134         {
4135                 file = CTempFiles::Instance().GetTempFilePath(false, *filepath, m_CurrentVersion).GetWinPathString();
4136                 CString cmd,out;
4137                 if(g_Git.GetOneFile(m_CurrentVersion, *filepath, file))
4138                 {
4139                         out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, (LPCTSTR)filepath->GetGitPathString(), (LPCTSTR)m_CurrentVersion, (LPCTSTR)file);
4140                         CMessageBox::Show(GetSafeHwnd(), g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), L"TortoiseGit", MB_OK);
4141                         return;
4142                 }
4143                 SetFileAttributes(file, FILE_ATTRIBUTE_READONLY);
4144         }
4145         if(mode == ALTERNATIVEEDITOR)
4146         {
4147                 CAppUtils::LaunchAlternativeEditor(file);
4148                 return;
4149         }
4150
4151         if (mode == OPEN)
4152                 CAppUtils::ShellOpen(file, GetSafeHwnd());
4153         else
4154                 CAppUtils::ShowOpenWithDialog(file, GetSafeHwnd());
4155 }
4156
4157 void CGitStatusListCtrl::DeleteSelectedFiles()
4158 {
4159         CAutoWriteLock locker(m_guard);
4160         //Collect paths
4161         std::vector<int> selectIndex;
4162
4163         POSITION pos = GetFirstSelectedItemPosition();
4164         int index;
4165         while ((index = GetNextSelectedItem(pos)) >= 0)
4166                 selectIndex.push_back(index);
4167
4168         CAutoRepository repo = g_Git.GetGitRepository();
4169         if (!repo)
4170         {
4171                 MessageBox(g_Git.GetLibGit2LastErr(L"Could not open repository."), L"TortoiseGit", MB_OK);
4172                 return;
4173         }
4174         CAutoIndex gitIndex;
4175         if (git_repository_index(gitIndex.GetPointer(), repo))
4176         {
4177                 g_Git.GetLibGit2LastErr(L"Could not open index.");
4178                 return;
4179         }
4180         int needWriteIndex = 0;
4181
4182         //Create file-list ('\0' separated) for SHFileOperation
4183         CString filelist;
4184         for (size_t i = 0; i < selectIndex.size(); ++i)
4185         {
4186                 index = selectIndex[i];
4187
4188                 auto path = GetListEntry(index);
4189                 if (path == nullptr)
4190                         continue;
4191
4192                 // do not report errors as we could remove an unversioned file
4193                 needWriteIndex += git_index_remove_bypath(gitIndex, CUnicodeUtils::GetUTF8(path->GetGitPathString())) == 0 ? 1 : 0;
4194
4195                 if (!path->Exists())
4196                         continue;
4197
4198                 filelist += path->GetWinPathString();
4199                 filelist += L'|';
4200         }
4201         filelist += L'|';
4202         int len = filelist.GetLength();
4203         auto buf = std::make_unique<TCHAR[]>(len + 2);
4204         wcscpy_s(buf.get(), len + 2, filelist);
4205         CStringUtils::PipesToNulls(buf.get(), len + 2);
4206         SHFILEOPSTRUCT fileop;
4207         fileop.hwnd = this->m_hWnd;
4208         fileop.wFunc = FO_DELETE;
4209         fileop.pFrom = buf.get();
4210         fileop.pTo = nullptr;
4211         fileop.fFlags = FOF_NO_CONNECTED_ELEMENTS | ((GetAsyncKeyState(VK_SHIFT) & 0x8000) ? 0 : FOF_ALLOWUNDO);
4212         fileop.lpszProgressTitle = L"deleting file";
4213         int result = SHFileOperation(&fileop);
4214
4215         if ((result == 0 || len == 1) && (!fileop.fAnyOperationsAborted))
4216         {
4217                 if (needWriteIndex && git_index_write(gitIndex))
4218                         MessageBox(g_Git.GetLibGit2LastErr(L"Could not write index."), L"TortoiseGit", MB_OK);
4219
4220                 if (needWriteIndex)
4221                 {
4222                         CWnd* pParent = GetLogicalParent();
4223                         if (pParent && pParent->GetSafeHwnd())
4224                                 pParent->SendMessage(GITSLNM_NEEDSREFRESH);
4225                         SetRedraw(TRUE);
4226                         return;
4227                 }
4228
4229                 SetRedraw(FALSE);
4230                 POSITION pos2 = nullptr;
4231                 while ((pos2 = GetFirstSelectedItemPosition()) != nullptr)
4232                 {
4233                         int index2 = GetNextSelectedItem(pos2);
4234                         if (GetCheck(index2))
4235                                 m_nSelected--;
4236                         m_nTotal--;
4237
4238                         RemoveListEntry(index2);
4239                 }
4240                 SetRedraw(TRUE);
4241         }
4242 }
4243
4244 BOOL CGitStatusListCtrl::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
4245 {
4246         switch (message)
4247         {
4248         case WM_MENUCHAR:   // only supported by IContextMenu3
4249                 if (g_IContext3)
4250                 {
4251                         g_IContext3->HandleMenuMsg2(message, wParam, lParam, pResult);
4252                         return TRUE;
4253                 }
4254                 break;
4255
4256         case WM_DRAWITEM:
4257         case WM_MEASUREITEM:
4258                 if (wParam)
4259                         break; // if wParam != 0 then the message is not menu-related
4260
4261         case WM_INITMENU:
4262         case WM_INITMENUPOPUP:
4263         {
4264                 HMENU hMenu = (HMENU)wParam;
4265                 if ((hMenu == m_hShellMenu) && (GetMenuItemCount(hMenu) == 0))
4266                 {
4267                         // the shell submenu is populated only on request, i.e. right
4268                         // before the submenu is shown
4269                         if (g_pFolderhook)
4270                         {
4271                                 delete g_pFolderhook;
4272                                 g_pFolderhook = nullptr;
4273                         }
4274                         CTGitPathList targetList;
4275                         FillListOfSelectedItemPaths(targetList);
4276                         if (!targetList.IsEmpty())
4277                         {
4278                                 // get IShellFolder interface of Desktop (root of shell namespace)
4279                                 if (g_psfDesktopFolder)
4280                                         g_psfDesktopFolder->Release();
4281                                 SHGetDesktopFolder(&g_psfDesktopFolder);    // needed to obtain full qualified pidl
4282
4283                                 // ParseDisplayName creates a PIDL from a file system path relative to the IShellFolder interface
4284                                 // but since we use the Desktop as our interface and the Desktop is the namespace root
4285                                 // that means that it's a fully qualified PIDL, which is what we need
4286
4287                                 if (g_pidlArray)
4288                                 {
4289                                         for (int i = 0; i < g_pidlArrayItems; i++)
4290                                         {
4291                                                 if (g_pidlArray[i])
4292                                                         CoTaskMemFree(g_pidlArray[i]);
4293                                         }
4294                                         CoTaskMemFree(g_pidlArray);
4295                                         g_pidlArray = nullptr;
4296                                         g_pidlArrayItems = 0;
4297                                 }
4298                                 int nItems = targetList.GetCount();
4299                                 g_pidlArray = (LPITEMIDLIST *)CoTaskMemAlloc((nItems + 10) * sizeof(LPITEMIDLIST));
4300                                 SecureZeroMemory(g_pidlArray, (nItems + 10) * sizeof(LPITEMIDLIST));
4301                                 int succeededItems = 0;
4302                                 PIDLIST_RELATIVE pidl = nullptr;
4303
4304                                 int bufsize = 1024;
4305                                 auto filepath = std::make_unique<WCHAR[]>(bufsize);
4306                                 for (int i = 0; i < nItems; i++)
4307                                 {
4308                                         CString fullPath = g_Git.CombinePath(targetList[i].GetWinPath());
4309                                         if (bufsize < fullPath.GetLength())
4310                                         {
4311                                                 bufsize = fullPath.GetLength() + 3;
4312                                                 filepath = std::make_unique<WCHAR[]>(bufsize);
4313                                         }
4314                                         wcscpy_s(filepath.get(), bufsize, fullPath);
4315                                         if (SUCCEEDED(g_psfDesktopFolder->ParseDisplayName(nullptr, 0, filepath.get(), nullptr, &pidl, nullptr)))
4316                                                 g_pidlArray[succeededItems++] = pidl; // copy pidl to pidlArray
4317                                 }
4318                                 if (succeededItems == 0)
4319                                 {
4320                                         CoTaskMemFree(g_pidlArray);
4321                                         g_pidlArray = nullptr;
4322                                 }
4323
4324                                 g_pidlArrayItems = succeededItems;
4325
4326                                 if (g_pidlArrayItems)
4327                                 {
4328                                         CString ext = targetList[0].GetFileExtension();
4329
4330                                         ASSOCIATIONELEMENT const rgAssocItem[] =
4331                                         {
4332                                                 { ASSOCCLASS_PROGID_STR, nullptr, ext },
4333                                                 { ASSOCCLASS_SYSTEM_STR, nullptr, ext },
4334                                                 { ASSOCCLASS_APP_STR, nullptr, ext },
4335                                                 { ASSOCCLASS_STAR, nullptr, nullptr },
4336                                                 { ASSOCCLASS_FOLDER, nullptr, nullptr },
4337                                         };
4338                                         IQueryAssociations* pIQueryAssociations = nullptr;
4339                                         if (FAILED(AssocCreateForClasses(rgAssocItem, ARRAYSIZE(rgAssocItem), IID_IQueryAssociations, (void**)&pIQueryAssociations)))
4340                                                 pIQueryAssociations = nullptr; // not a problem, it works without this
4341
4342                                         g_pFolderhook = new CIShellFolderHook(g_psfDesktopFolder, targetList);
4343                                         LPCONTEXTMENU icm1 = nullptr;
4344
4345                                         DEFCONTEXTMENU dcm = { 0 };
4346                                         dcm.hwnd = m_hWnd;
4347                                         dcm.psf = g_pFolderhook;
4348                                         dcm.cidl = g_pidlArrayItems;
4349                                         dcm.apidl = (PCUITEMID_CHILD_ARRAY)g_pidlArray;
4350                                         dcm.punkAssociationInfo = pIQueryAssociations;
4351                                         if (SUCCEEDED(SHCreateDefaultContextMenu(&dcm, IID_IContextMenu, (void**)&icm1)))
4352                                         {
4353                                                 int iMenuType = 0;  // to know which version of IContextMenu is supported
4354                                                 if (icm1)
4355                                                 {   // since we got an IContextMenu interface we can now obtain the higher version interfaces via that
4356                                                         if (icm1->QueryInterface(IID_IContextMenu3, (void**)&m_pContextMenu) == S_OK)
4357                                                                 iMenuType = 3;
4358                                                         else if (icm1->QueryInterface(IID_IContextMenu2, (void**)&m_pContextMenu) == S_OK)
4359                                                                 iMenuType = 2;
4360
4361                                                         if (m_pContextMenu)
4362                                                                 icm1->Release(); // we can now release version 1 interface, cause we got a higher one
4363                                                         else
4364                                                         {
4365                                                                 // since no higher versions were found
4366                                                                 // redirect ppContextMenu to version 1 interface
4367                                                                 iMenuType = 1;
4368                                                                 m_pContextMenu = icm1;
4369                                                         }
4370                                                 }
4371                                                 if (m_pContextMenu)
4372                                                 {
4373                                                         // lets fill the our popup menu
4374                                                         UINT flags = CMF_NORMAL;
4375                                                         flags |= (GetKeyState(VK_SHIFT) & 0x8000) != 0 ? CMF_EXTENDEDVERBS : 0;
4376                                                         m_pContextMenu->QueryContextMenu(hMenu, 0, SHELL_MIN_CMD, SHELL_MAX_CMD, flags);
4377
4378
4379                                                         // subclass window to handle menu related messages in CShellContextMenu
4380                                                         if (iMenuType > 1)  // only subclass if its version 2 or 3
4381                                                         {
4382                                                                 if (iMenuType == 2)
4383                                                                         g_IContext2 = (LPCONTEXTMENU2)m_pContextMenu;
4384                                                                 else    // version 3
4385                                                                         g_IContext3 = (LPCONTEXTMENU3)m_pContextMenu;
4386                                                         }
4387                                                 }
4388                                         }
4389                                         if (pIQueryAssociations)
4390                                                 pIQueryAssociations->Release();
4391                                 }
4392                         }
4393                         if (g_IContext3)
4394                                 g_IContext3->HandleMenuMsg2(message, wParam, lParam, pResult);
4395                         else if (g_IContext2)
4396                                 g_IContext2->HandleMenuMsg(message, wParam, lParam);
4397                         return TRUE;
4398                 }
4399         }
4400
4401         break;
4402         default:
4403                 break;
4404         }
4405
4406         return __super::OnWndMsg(message, wParam, lParam, pResult);
4407 }
4408
4409 CTGitPath* CGitStatusListCtrl::GetListEntry(int index)
4410 {
4411         ATLASSERT(m_guard.GetCurrentThreadStatus());
4412         auto entry = reinterpret_cast<CTGitPath*>(GetItemData(index));
4413         ASSERT(entry);
4414         return entry;
4415 }
4416
4417 void CGitStatusListCtrl::OnSysColorChange()
4418 {
4419         __super::OnSysColorChange();
4420         if (m_nBackgroundImageID)
4421                 CAppUtils::SetListCtrlBackgroundImage(GetSafeHwnd(), m_nBackgroundImageID);
4422 }