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