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