?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed issue #1205: Add "Last modified" column to commit dialog
[TortoiseGit.git] / src / Git / GitStatusListCtrl.cpp
blob57f323bca9018777e117b96947eb80dd6c03de21
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2012 - TortoiseGit
4 // Copyright (C) 2003-2008 - 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 "SVNProgressDlg.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 "MassiveGitTask.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_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
87 ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
88 ON_WM_PAINT()
89 ON_NOTIFY(HDN_BEGINTRACKA, 0, &CGitStatusListCtrl::OnHdnBegintrack)
90 ON_NOTIFY(HDN_BEGINTRACKW, 0, &CGitStatusListCtrl::OnHdnBegintrack)
91 ON_NOTIFY(HDN_ITEMCHANGINGA, 0, &CGitStatusListCtrl::OnHdnItemchanging)
92 ON_NOTIFY(HDN_ITEMCHANGINGW, 0, &CGitStatusListCtrl::OnHdnItemchanging)
93 ON_WM_DESTROY()
94 ON_NOTIFY_REFLECT(LVN_BEGINDRAG, OnBeginDrag)
95 ON_NOTIFY_REFLECT(LVN_ITEMCHANGING, &CGitStatusListCtrl::OnLvnItemchanging)
96 END_MESSAGE_MAP()
97
98
99
100 CGitStatusListCtrl::CGitStatusListCtrl() : CListCtrl()
101 //, m_HeadRev(GitRev::REV_HEAD)
102 , m_pbCanceled(NULL)
103 , m_pStatLabel(NULL)
104 , m_pSelectButton(NULL)
105 , m_pConfirmButton(NULL)
106 , m_bBusy(false)
107 , m_bEmpty(false)
108 , m_bShowIgnores(false)
109 , m_pDropTarget(NULL)
110 , m_bIgnoreRemoveOnly(false)
111 , m_bCheckChildrenWithParent(false)
112 , m_bUnversionedLast(true)
113 , m_bHasChangeLists(false)
114 , m_bHasLocks(false)
115 , m_bBlock(false)
116 , m_bBlockUI(false)
117 , m_bHasCheckboxes(false)
118 , m_bCheckIfGroupsExist(true)
119 , m_bFileDropsEnabled(false)
120 , m_bOwnDrag(false)
121 , m_dwDefaultColumns(0)
122 , m_ColumnManager(this)
123 , m_bAscending(false)
124 , m_nSortedColumn(-1)
125 , m_bHasExternalsFromDifferentRepos(false)
126 , m_sNoPropValueText(MAKEINTRESOURCE(IDS_STATUSLIST_NOPROPVALUE))
127 , m_amend(false)
128 , m_bDoNotAutoselectSubmodules(false)
129 , m_bHasWC(true)
130 {
131 m_FileLoaded=0;
132 m_critSec.Init();
133 m_bIsRevertTheirMy = false;
134 this->m_nLineAdded =this->m_nLineDeleted =0;
135 }
136
137 CGitStatusListCtrl::~CGitStatusListCtrl()
138 {
139 // if (m_pDropTarget)
140 // delete m_pDropTarget;
141 ClearStatusArray();
142 }
143
144 void CGitStatusListCtrl::ClearStatusArray()
145 {
146 #if 0
147 Locker lock(m_critSec);
148 for (size_t i=0; i < m_arStatusArray.size(); i++)
149 {
150 delete m_arStatusArray[i];
151 }
152 m_arStatusArray.clear();
153 #endif
154 }
155 #if 0
156 CGitStatusListCtrl::FileEntry * CGitStatusListCtrl::GetListEntry(UINT_PTR index)
157 {
158
159 if (index >= (UINT_PTR)m_arListArray.size())
160 return NULL;
161 if (m_arListArray[index] >= m_arStatusArray.size())
162 return NULL;
163 return m_arStatusArray[m_arListArray[index]];
164
165 return NULL;
166 }
167 #endif
168 #if 0
169 CGitStatusListCtrl::FileEntry * CGitStatusListCtrl::GetVisibleListEntry(const CTGitPath& path)
170 {
171 int itemCount = GetItemCount();
172 for (int i=0; i < itemCount; i++)
173 {
174 FileEntry * entry = GetListEntry(i);
175 if (entry->GetPath().IsEquivalentTo(path))
176 return entry;
177 }
178 return NULL;
179 }
180 #endif
181 #if 0
182 CGitStatusListCtrl::FileEntry * CGitStatusListCtrl::GetListEntry(const CTGitPath& path)
183 {
184
185 for (size_t i=0; i < m_arStatusArray.size(); i++)
186 {
187 FileEntry * entry = m_arStatusArray[i];
188 if (entry->GetPath().IsEquivalentTo(path))
189 return entry;
190 }
191
192 return NULL;
193 }
194 #endif
195
196 #if 0
197 int CGitStatusListCtrl::GetIndex(const CTGitPath& path)
198 {
199 int itemCount = GetItemCount();
200 for (int i=0; i < itemCount; i++)
201 {
202 FileEntry * entry = GetListEntry(i);
203 if (entry->GetPath().IsEquivalentTo(path))
204 return i;
205 }
206 return -1;
207 }
208 #endif
209
210 void CGitStatusListCtrl::Init(DWORD dwColumns, const CString& sColumnInfoContainer, unsigned __int64 dwContextMenus /* = GitSLC_POPALL */, bool bHasCheckboxes /* = true */, bool bHasWC /* = true */, DWORD allowedColumns /* = 0xffffffff */)
211 {
212 Locker lock(m_critSec);
213
214 m_dwDefaultColumns = dwColumns | 1;
215 m_dwContextMenus = dwContextMenus;
216 m_bHasCheckboxes = bHasCheckboxes;
217 m_bHasWC = bHasWC;
218
219 // set the extended style of the listcontrol
220 // 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.
221 CRegDWORD regFullRowSelect(_T("Software\\TortoiseGit\\FullRowSelect"), TRUE);
222 DWORD exStyle = LVS_EX_HEADERDRAGDROP | LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP | LVS_EX_SUBITEMIMAGES;
223 if (DWORD(regFullRowSelect))
224 exStyle |= LVS_EX_FULLROWSELECT;
225 exStyle |= (bHasCheckboxes ? LVS_EX_CHECKBOXES : 0);
226 SetRedraw(false);
227 SetExtendedStyle(exStyle);
228
229 SetWindowTheme(m_hWnd, L"Explorer", NULL);
230
231 m_nIconFolder = SYS_IMAGE_LIST().GetDirIconIndex();
232 m_nRestoreOvl = SYS_IMAGE_LIST().AddIcon((HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_RESTOREOVL), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE));
233 SYS_IMAGE_LIST().SetOverlayImage(m_nRestoreOvl, OVL_RESTORE);
234 SetImageList(&SYS_IMAGE_LIST(), LVSIL_SMALL);
235
236 // keep CSorter::operator() in sync!!
237 static UINT standardColumnNames[GITSLC_NUMCOLUMNS]
238 = { IDS_STATUSLIST_COLFILE
239 , IDS_STATUSLIST_COLFILENAME
240 , IDS_STATUSLIST_COLEXT
241 , IDS_STATUSLIST_COLSTATUS
242 , IDS_STATUSLIST_COLADD
243 , IDS_STATUSLIST_COLDEL
244 , IDS_STATUSLIST_COLLASTMODIFIED
245 };
246
247 m_ColumnManager.SetNames(standardColumnNames,GITSLC_NUMCOLUMNS);
248 m_ColumnManager.ReadSettings(m_dwDefaultColumns, 0xffffffff & ~(allowedColumns | m_dwDefaultColumns), sColumnInfoContainer, GITSLC_NUMCOLUMNS);
249
250 // enable file drops
251 #if 0
252 if (m_pDropTarget == NULL)
253 {
254 m_pDropTarget = new CGitStatusListCtrlDropTarget(this);
255 RegisterDragDrop(m_hWnd,m_pDropTarget);
256 // create the supported formats:
257 FORMATETC ftetc={0};
258 ftetc.dwAspect = DVASPECT_CONTENT;
259 ftetc.lindex = -1;
260 ftetc.tymed = TYMED_HGLOBAL;
261 ftetc.cfFormat=CF_HDROP;
262 m_pDropTarget->AddSuportedFormat(ftetc);
263 }
264 #endif
265
266 SetRedraw(true);
267 }
268
269 bool CGitStatusListCtrl::SetBackgroundImage(UINT nID)
270 {
271 return CAppUtils::SetListCtrlBackgroundImage(GetSafeHwnd(), nID);
272 }
273
274 BOOL CGitStatusListCtrl::GetStatus ( const CTGitPathList* pathList
275 , bool bUpdate /* = FALSE */
276 , bool bShowIgnores /* = false */
277 , bool bShowUnRev
278 , bool /*bShowUserProps*/ /* = false */)
279 {
280 Locker lock(m_critSec);
281 int mask= CGitStatusListCtrl::FILELIST_MODIFY;
282 if(bShowIgnores)
283 mask|= CGitStatusListCtrl::FILELIST_IGNORE;
284 if(bShowUnRev)
285 mask|= CGitStatusListCtrl::FILELIST_UNVER;
286 this->UpdateFileList(mask,bUpdate,(CTGitPathList*)pathList);
287
288
289 #if 0
290 int refetchcounter = 0;
291 BOOL bRet = TRUE;
292 Invalidate();
293 // force the cursor to change
294 POINT pt;
295 GetCursorPos(&pt);
296 SetCursorPos(pt.x, pt.y);
297
298 m_mapFilenameToChecked.clear();
299 //m_StatusUrlList.Clear();
300 bool bHasChangelists = (m_changelists.size()>1 || (m_changelists.size()>0 && !m_bHasIgnoreGroup));
301 m_changelists.clear();
302 for (size_t i=0; i < m_arStatusArray.size(); i++)
303 {
304 FileEntry * entry = m_arStatusArray[i];
305 if ( bHasChangelists && entry->checked)
306 {
307 // If change lists are present, remember all checked entries
308 CString path = entry->GetPath().GetGitPathString();
309 m_mapFilenameToChecked[path] = true;
310 }
311 if ( (entry->status==git_wc_status_unversioned || entry->status==git_wc_status_missing ) && entry->checked )
312 {
313 // The user manually selected an unversioned or missing file. We remember
314 // this so that the selection can be restored when refreshing.
315 CString path = entry->GetPath().GetGitPathString();
316 m_mapFilenameToChecked[path] = true;
317 }
318 else if ( entry->status > git_wc_status_normal && !entry->checked )
319 {
320 // The user manually deselected a versioned file. We remember
321 // this so that the deselection can be restored when refreshing.
322 CString path = entry->GetPath().GetGitPathString();
323 m_mapFilenameToChecked[path] = false;
324 }
325 }
326
327 // use a sorted path list to make sure we fetch the status of
328 // parent items first, *then* the child items (if any)
329 CTGitPathList sortedPathList = pathList;
330 sortedPathList.SortByPathname();
331 do
332 {
333 bRet = TRUE;
334 m_nTargetCount = 0;
335 m_bHasExternalsFromDifferentRepos = FALSE;
336 m_bHasExternals = FALSE;
337 m_bHasUnversionedItems = FALSE;
338 m_bHasLocks = false;
339 m_bHasChangeLists = false;
340 m_bShowIgnores = bShowIgnores;
341 m_nSortedColumn = 0;
342 m_bBlock = TRUE;
343 m_bBusy = true;
344 m_bEmpty = false;
345 Invalidate();
346
347 // first clear possible status data left from
348 // previous GetStatus() calls
349 ClearStatusArray();
350
351 m_StatusFileList = sortedPathList;
352
353 // Since Git_client_status() returns all files, even those in
354 // folders included with Git:externals we need to check if all
355 // files we get here belongs to the same repository.
356 // It is possible to commit changes in an external folder, as long
357 // as the folder belongs to the same repository (but another path),
358 // but it is not possible to commit all files if the externals are
359 // from a different repository.
360 //
361 // To check if all files belong to the same repository, we compare the
362 // UUID's - if they're identical then the files belong to the same
363 // repository and can be committed. But if they're different, then
364 // tell the user to commit all changes in the external folders
365 // first and exit.
366 CStringA sUUID; // holds the repo UUID
367 CTGitPathList arExtPaths; // list of Git:external paths
368
369 GitConfig config;
370
371 m_sURL.Empty();
372
373 m_nTargetCount = sortedPathList.GetCount();
374
375 GitStatus status(m_pbCanceled);
376 if(m_nTargetCount > 1 && sortedPathList.AreAllPathsFilesInOneDirectory())
377 {
378 // This is a special case, where we've been given a list of files
379 // all from one folder
380 // We handle them by setting a status filter, then requesting the Git status of
381 // all the files in the directory, filtering for the ones we're interested in
382 status.SetFilter(sortedPathList);
383
384 // if all selected entries are files, we don't do a recursive status
385 // fetching. But if only one is a directory, we have to recurse.
386 git_depth_t depth = git_depth_files;
387 // We have set a filter. If all selected items were files or we fetch
388 // the status not recursively, then we have to include
389 // ignored items too - the user has selected them
390 bool bShowIgnoresRight = true;
391 for (int fcindex=0; fcindex<sortedPathList.GetCount(); ++fcindex)
392 {
393 if (sortedPathList[fcindex].IsDirectory())
394 {
395 depth = git_depth_infinity;
396 bShowIgnoresRight = false;
397 break;
398 }
399 }
400 if(!FetchStatusForSingleTarget(config, status, sortedPathList.GetCommonDirectory(), bUpdate, sUUID, arExtPaths, true, depth, bShowIgnoresRight))
401 {
402 bRet = FALSE;
403 }
404 }
405 else
406 {
407 for(int nTarget = 0; nTarget < m_nTargetCount; nTarget++)
408 {
409 // check whether the path we want the status for is already fetched due to status-fetching
410 // of a parent path.
411 // this check is only done for file paths, because folder paths could be included already
412 // but not recursively
413 if (sortedPathList[nTarget].IsDirectory() || GetListEntry(sortedPathList[nTarget]) == NULL)
414 {
415 if(!FetchStatusForSingleTarget(config, status, sortedPathList[nTarget], bUpdate, sUUID,
416 arExtPaths, false, git_depth_infinity, bShowIgnores))
417 {
418 bRet = FALSE;
419 }
420 }
421 }
422 }
423
424 // remove the 'helper' files of conflicted items from the list.
425 // otherwise they would appear as unversioned files.
426 for (INT_PTR cind = 0; cind < m_ConflictFileList.GetCount(); ++cind)
427 {
428 for (size_t i=0; i < m_arStatusArray.size(); i++)
429 {
430 if (m_arStatusArray[i]->GetPath().IsEquivalentTo(m_ConflictFileList[cind]))
431 {
432 delete m_arStatusArray[i];
433 m_arStatusArray.erase(m_arStatusArray.begin()+i);
434 break;
435 }
436 }
437 }
438 refetchcounter++;
439 } while(!BuildStatistics() && (refetchcounter < 2) && (*m_pbCanceled==false));
440
441 if (bShowUserProps)
442 FetchUserProperties();
443
444 m_ColumnManager.UpdateUserPropList (m_arStatusArray);
445
446 m_bBlock = FALSE;
447 m_bBusy = false;
448 GetCursorPos(&pt);
449 SetCursorPos(pt.x, pt.y);
450 return bRet;
451 #endif
452 BuildStatistics();
453 return TRUE;
454 }
455
456 //
457 // Fetch all local properties for all elements in the status array
458 //
459 void CGitStatusListCtrl::FetchUserProperties()
460 {
461 #if 0
462 GitPool globalPool;
463
464 for (size_t i = 0, count = m_arStatusArray.size(); i < count; ++i)
465 {
466 // local / temp pool to hold parameters and props for a single item
467
468 GitPool localPool ((apr_pool_t*)globalPool);
469
470 // open working copy for this path
471
472 const char* path = m_arStatusArray[i]->path.GetGitApiPath (localPool);
473
474 Git_wc_adm_access_t *adm_access = NULL;
475 Git_error_t * error = Git_wc_adm_probe_open3 ( &adm_access
476 , NULL
477 , path
478 , FALSE // no write lock
479 , 0 // lock just the directory/file itself
480 , NULL
481 , NULL
482 , localPool);
483 if (error == NULL)
484 {
485 // get the props and add them to the status info
486
487 apr_hash_t* props = NULL;
488 Git_error_t * error = Git_wc_prop_list ( &props
489 , path
490 , adm_access
491 , localPool);
492 if (error == NULL)
493 {
494 for ( apr_hash_index_t *index
495 = apr_hash_first (localPool, props)
496 ; index != NULL
497 ; index = apr_hash_next (index))
498 {
499 // extract next entry from hash
500
501 const char* key = NULL;
502 ptrdiff_t keyLen;
503 const char** val = NULL;
504
505 apr_hash_this ( index
506 , reinterpret_cast<const void**>(&key)
507 , &keyLen
508 , reinterpret_cast<void**>(&val));
509
510 // decode / dispatch it
511
512 CString name = CUnicodeUtils::GetUnicode (key);
513 CString value = CUnicodeUtils::GetUnicode (*val);
514
515 // store in property container (truncate it after ~100 chars)
516
517 m_arStatusArray[i]->present_props[name]
518 = value.Left (GitSLC_MAXUSERPROPLENGTH);
519 }
520 }
521 error = Git_wc_adm_close2 (adm_access, localPool);
522 }
523 Git_error_clear (error);
524 }
525 #endif
526 }
527
528 // Get the show-flags bitmap value which corresponds to a particular Git status
529 DWORD CGitStatusListCtrl::GetShowFlagsFromGitStatus(git_wc_status_kind status)
530 {
531 switch (status)
532 {
533 case git_wc_status_none:
534 case git_wc_status_unversioned:
535 return GITSLC_SHOWUNVERSIONED;
536 case git_wc_status_ignored:
537 if (!m_bShowIgnores)
538 return GITSLC_SHOWDIRECTS;
539 return GITSLC_SHOWDIRECTS|GITSLC_SHOWIGNORED;
540 case git_wc_status_incomplete:
541 return GITSLC_SHOWINCOMPLETE;
542 case git_wc_status_normal:
543 return GITSLC_SHOWNORMAL;
544 case git_wc_status_external:
545 return GITSLC_SHOWEXTERNAL;
546 case git_wc_status_added:
547 return GITSLC_SHOWADDED;
548 case git_wc_status_missing:
549 return GITSLC_SHOWMISSING;
550 case git_wc_status_deleted:
551 return GITSLC_SHOWREMOVED;
552 case git_wc_status_replaced:
553 return GITSLC_SHOWREPLACED;
554 case git_wc_status_modified:
555 return GITSLC_SHOWMODIFIED;
556 case git_wc_status_merged:
557 return GITSLC_SHOWMERGED;
558 case git_wc_status_conflicted:
559 return GITSLC_SHOWCONFLICTED;
560 case git_wc_status_obstructed:
561 return GITSLC_SHOWOBSTRUCTED;
562 default:
563 // we should NEVER get here!
564 ASSERT(FALSE);
565 break;
566 }
567 return 0;
568 }
569
570 void CGitStatusListCtrl::Show(unsigned int dwShow, unsigned int dwCheck /*=0*/, bool /*bShowFolders*/ /* = true */,BOOL UpdateStatusList,bool UseStoredCheckStatus)
571 {
572 CWinApp * pApp = AfxGetApp();
573 if (pApp)
574 pApp->DoWaitCursor(1);
575
576 Locker lock(m_critSec);
577 WORD langID = (WORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
578
579 //SetItemCount(listIndex);
580 SetRedraw(FALSE);
581 DeleteAllItems();
582 m_nSelected = 0;
583
584 m_nShownUnversioned = 0;
585 m_nShownModified = 0;
586 m_nShownAdded = 0;
587 m_nShownDeleted = 0;
588 m_nShownConflicted = 0;
589 m_nShownFiles = 0;
590 m_nShownSubmodules = 0;
591
592 if(UpdateStatusList)
593 {
594 m_arStatusArray.clear();
595 for(int i=0;i<this->m_StatusFileList.GetCount();i++)
596 {
597 m_arStatusArray.push_back((CTGitPath*)&m_StatusFileList[i]);
598 }
599
600 for(int i=0;i<this->m_UnRevFileList.GetCount();i++)
601 {
602 m_arStatusArray.push_back((CTGitPath*)&m_UnRevFileList[i]);
603 }
604
605 for(int i=0;i<this->m_IgnoreFileList.GetCount();i++)
606 {
607 m_arStatusArray.push_back((CTGitPath*)&m_IgnoreFileList[i]);
608 }
609 }
610 PrepareGroups();
611 if (m_nSortedColumn >= 0)
612 {
613 CSorter predicate (&m_ColumnManager, m_nSortedColumn, m_bAscending);
614 std::sort(m_arStatusArray.begin(), m_arStatusArray.end(), predicate);
615 }
616
617 int index =0;
618 for(int i=0;i<this->m_arStatusArray.size();i++)
619 {
620 //set default checkbox status
621 CTGitPath* entry = ((CTGitPath*)m_arStatusArray[i]);
622 CString path = entry->GetGitPathString();
623 if (m_mapFilenameToChecked.size()!=0 && m_mapFilenameToChecked.find(path) != m_mapFilenameToChecked.end())
624 {
625 entry->m_Checked=m_mapFilenameToChecked[path];
626 }
627 else if (!UseStoredCheckStatus)
628 {
629 bool autoSelectSubmodules = !(entry->IsDirectory() && m_bDoNotAutoselectSubmodules);
630 if(entry->m_Action & dwCheck && autoSelectSubmodules)
631 entry->m_Checked=true;
632 else
633 entry->m_Checked=false;
634 m_mapFilenameToChecked[path] = entry->m_Checked;
635 }
636
637 if(entry->m_Action & dwShow)
638 {
639 AddEntry(entry,langID,index);
640 index++;
641 }
642 }
643
644 int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;
645 for (int col = 0; col <= maxcol; col++)
646 SetColumnWidth (col, m_ColumnManager.GetWidth (col, true));
647
648 SetRedraw(TRUE);
649 GetStatisticsString();
650
651 CHeaderCtrl * pHeader = GetHeaderCtrl();
652 HDITEM HeaderItem = {0};
653 HeaderItem.mask = HDI_FORMAT;
654 for (int i=0; i<pHeader->GetItemCount(); ++i)
655 {
656 pHeader->GetItem(i, &HeaderItem);
657 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
658 pHeader->SetItem(i, &HeaderItem);
659 }
660 if (m_nSortedColumn >= 0)
661 {
662 pHeader->GetItem(m_nSortedColumn, &HeaderItem);
663 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
664 pHeader->SetItem(m_nSortedColumn, &HeaderItem);
665 }
666
667 #if 0
668 if (nSelectedEntry)
669 {
670 SetItemState(nSelectedEntry, LVIS_SELECTED, LVIS_SELECTED);
671 EnsureVisible(nSelectedEntry, false);
672 }
673 else
674 {
675 // Restore the item at the top of the list.
676 for (int i=0;GetTopIndex() != nTopIndex;i++)
677 {
678 if ( !EnsureVisible(nTopIndex+i,false) )
679 {
680 break;
681 }
682 }
683 }
684 #endif
685 if (pApp)
686 pApp->DoWaitCursor(-1);
687
688 Invalidate();
689
690 m_dwShow = dwShow;
691
692 this->BuildStatistics();
693
694 #if 0
695
696 CWinApp * pApp = AfxGetApp();
697 if (pApp)
698 pApp->DoWaitCursor(1);
699
700 m_bShowFolders = bShowFolders;
701
702 int nTopIndex = GetTopIndex();
703 POSITION posSelectedEntry = GetFirstSelectedItemPosition();
704 int nSelectedEntry = 0;
705 if (posSelectedEntry)
706 nSelectedEntry = GetNextSelectedItem(posSelectedEntry);
707 SetRedraw(FALSE);
708 DeleteAllItems();
709
710 PrepareGroups();
711
712 m_arListArray.clear();
713
714 m_arListArray.reserve(m_arStatusArray.size());
715 SetItemCount (static_cast<int>(m_arStatusArray.size()));
716
717 int listIndex = 0;
718 for (size_t i=0; i < m_arStatusArray.size(); ++i)
719 {
720 FileEntry * entry = m_arStatusArray[i];
721 if ((entry->inexternal) && (!(dwShow & SVNSLC_SHOWINEXTERNALS)))
722 continue;
723 if ((entry->differentrepo || entry->isNested) && (! (dwShow & SVNSLC_SHOWEXTERNALFROMDIFFERENTREPO)))
724 continue;
725 if (entry->IsFolder() && (!bShowFolders))
726 continue; // don't show folders if they're not wanted.
727
728 #if 0
729 git_wc_status_kind status = GitStatus::GetMoreImportant(entry->status, entry->remotestatus);
730 DWORD showFlags = GetShowFlagsFromGitStatus(status);
731 if (entry->IsLocked())
732 showFlags |= SVNSLC_SHOWLOCKS;
733 if (entry->switched)
734 showFlags |= SVNSLC_SHOWSWITCHED;
735 if (!entry->changelist.IsEmpty())
736 showFlags |= SVNSLC_SHOWINCHANGELIST;
737 #endif
738 bool bAllowCheck = ((entry->changelist.Compare(GITSLC_IGNORECHANGELIST) != 0)
739 && (m_bCheckIfGroupsExist || (m_changelists.size()==0 || (m_changelists.size()==1 && m_bHasIgnoreGroup))));
740
741 // status_ignored is a special case - we must have the 'direct' flag set to add a status_ignored item
742 #if 0
743 if (status != Git_wc_status_ignored || (entry->direct) || (dwShow & GitSLC_SHOWIGNORED))
744 {
745 if ((!entry->IsFolder()) && (status == Git_wc_status_deleted) && (dwShow & SVNSLC_SHOWREMOVEDANDPRESENT))
746 {
747 if (PathFileExists(entry->GetPath().GetWinPath()))
748 {
749 m_arListArray.push_back(i);
750 if ((dwCheck & SVNSLC_SHOWREMOVEDANDPRESENT)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))
751 {
752 if (bAllowCheck)
753 entry->checked = true;
754 }
755 AddEntry(entry, langID, listIndex++);
756 }
757 }
758 else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFILES)&&(entry->direct)&&(!entry->IsFolder())))
759 {
760 m_arListArray.push_back(i);
761 if ((dwCheck & showFlags)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))
762 {
763 if (bAllowCheck)
764 entry->checked = true;
765 }
766 AddEntry(entry, langID, listIndex++);
767 }
768 else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFOLDER)&&(entry->direct)&&entry->IsFolder()))
769 {
770 m_arListArray.push_back(i);
771 if ((dwCheck & showFlags)||((dwCheck & SVNSLC_SHOWDIRECTS)&&(entry->direct)))
772 {
773 if (bAllowCheck)
774 entry->checked = true;
775 }
776 AddEntry(entry, langID, listIndex++);
777 }
778 }
779 #endif
780 }
781
782 SetItemCount(listIndex);
783
784 m_ColumnManager.UpdateRelevance (m_arStatusArray, m_arListArray);
785
786 int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;
787 for (int col = 0; col <= maxcol; col++)
788 SetColumnWidth (col, m_ColumnManager.GetWidth (col, true));
789
790 SetRedraw(TRUE);
791 GetStatisticsString();
792
793 CHeaderCtrl * pHeader = GetHeaderCtrl();
794 HDITEM HeaderItem = {0};
795 HeaderItem.mask = HDI_FORMAT;
796 for (int i=0; i<pHeader->GetItemCount(); ++i)
797 {
798 pHeader->GetItem(i, &HeaderItem);
799 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
800 pHeader->SetItem(i, &HeaderItem);
801 }
802 if (m_nSortedColumn)
803 {
804 pHeader->GetItem(m_nSortedColumn, &HeaderItem);
805 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
806 pHeader->SetItem(m_nSortedColumn, &HeaderItem);
807 }
808
809 if (nSelectedEntry)
810 {
811 SetItemState(nSelectedEntry, LVIS_SELECTED, LVIS_SELECTED);
812 EnsureVisible(nSelectedEntry, false);
813 }
814 else
815 {
816 // Restore the item at the top of the list.
817 for (int i=0;GetTopIndex() != nTopIndex;i++)
818 {
819 if ( !EnsureVisible(nTopIndex+i,false) )
820 {
821 break;
822 }
823 }
824 }
825
826 if (pApp)
827 pApp->DoWaitCursor(-1);
828
829 m_bEmpty = (GetItemCount() == 0);
830 Invalidate();
831 #endif
832
833 }
834
835 void CGitStatusListCtrl::Show(unsigned int /*dwShow*/, const CTGitPathList& checkedList, bool /*bShowFolders*/ /* = true */)
836 {
837 DeleteAllItems();
838 for(int i=0;i<checkedList.GetCount();i++)
839 this->AddEntry((CTGitPath *)&checkedList[i],0,i);
840 return ;
841 #if 0
842
843 Locker lock(m_critSec);
844 WORD langID = (WORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
845
846 CWinApp * pApp = AfxGetApp();
847 if (pApp)
848 pApp->DoWaitCursor(1);
849 m_dwShow = dwShow;
850 m_bShowFolders = bShowFolders;
851 m_nSelected = 0;
852 int nTopIndex = GetTopIndex();
853 POSITION posSelectedEntry = GetFirstSelectedItemPosition();
854 int nSelectedEntry = 0;
855 if (posSelectedEntry)
856 nSelectedEntry = GetNextSelectedItem(posSelectedEntry);
857 SetRedraw(FALSE);
858 DeleteAllItems();
859
860 PrepareGroups();
861
862 m_arListArray.clear();
863
864 m_arListArray.reserve(m_arStatusArray.size());
865 SetItemCount (static_cast<int>(m_arStatusArray.size()));
866
867 int listIndex = 0;
868 for (size_t i=0; i < m_arStatusArray.size(); ++i)
869 {
870 FileEntry * entry = m_arStatusArray[i];
871 if ((entry->inexternal) && (!(dwShow & SVNSLC_SHOWINEXTERNALS)))
872 continue;
873 if ((entry->differentrepo || entry->isNested) && (! (dwShow & SVNSLC_SHOWEXTERNALFROMDIFFERENTREPO)))
874 continue;
875 if (entry->IsFolder() && (!bShowFolders))
876 continue; // don't show folders if they're not wanted.
877 #if 0
878 git_wc_status_kind status = SVNStatus::GetMoreImportant(entry->status, entry->remotestatus);
879 DWORD showFlags = GetShowFlagsFromSVNStatus(status);
880 if (entry->IsLocked())
881 showFlags |= SVNSLC_SHOWLOCKS;
882 if (!entry->changelist.IsEmpty())
883 showFlags |= SVNSLC_SHOWINCHANGELIST;
884
885 // status_ignored is a special case - we must have the 'direct' flag set to add a status_ignored item
886 if (status != git_wc_status_ignored || (entry->direct) || (dwShow & SVNSLC_SHOWIGNORED))
887 {
888 for (int npath = 0; npath < checkedList.GetCount(); ++npath)
889 {
890 if (entry->GetPath().IsEquivalentTo(checkedList[npath]))
891 {
892 entry->checked = true;
893 break;
894 }
895 }
896 if ((!entry->IsFolder()) && (status == git_wc_status_deleted) && (dwShow & SVNSLC_SHOWREMOVEDANDPRESENT))
897 {
898 if (PathFileExists(entry->GetPath().GetWinPath()))
899 {
900 m_arListArray.push_back(i);
901 AddEntry(entry, langID, listIndex++);
902 }
903 }
904 else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFILES)&&(entry->direct)&&(!entry->IsFolder())))
905 {
906 m_arListArray.push_back(i);
907 AddEntry(entry, langID, listIndex++);
908 }
909 else if ((dwShow & showFlags)||((dwShow & SVNSLC_SHOWDIRECTFOLDER)&&(entry->direct)&&entry->IsFolder()))
910 {
911 m_arListArray.push_back(i);
912 AddEntry(entry, langID, listIndex++);
913 }
914 else if (entry->switched)
915 {
916 m_arListArray.push_back(i);
917 AddEntry(entry, langID, listIndex++);
918 }
919 }
920 #endif
921 }
922
923 SetItemCount(listIndex);
924
925 int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;
926 for (int col = 0; col <= maxcol; col++)
927 SetColumnWidth (col, m_ColumnManager.GetWidth (col, true));
928
929 SetRedraw(TRUE);
930 GetStatisticsString();
931
932 CHeaderCtrl * pHeader = GetHeaderCtrl();
933 HDITEM HeaderItem = {0};
934 HeaderItem.mask = HDI_FORMAT;
935 for (int i=0; i<pHeader->GetItemCount(); ++i)
936 {
937 pHeader->GetItem(i, &HeaderItem);
938 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
939 pHeader->SetItem(i, &HeaderItem);
940 }
941 if (m_nSortedColumn)
942 {
943 pHeader->GetItem(m_nSortedColumn, &HeaderItem);
944 HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
945 pHeader->SetItem(m_nSortedColumn, &HeaderItem);
946 }
947
948 if (nSelectedEntry)
949 {
950 SetItemState(nSelectedEntry, LVIS_SELECTED, LVIS_SELECTED);
951 EnsureVisible(nSelectedEntry, false);
952 }
953 else
954 {
955 // Restore the item at the top of the list.
956 for (int i=0;GetTopIndex() != nTopIndex;i++)
957 {
958 if ( !EnsureVisible(nTopIndex+i,false) )
959 {
960 break;
961 }
962 }
963 }
964
965 if (pApp)
966 pApp->DoWaitCursor(-1);
967
968 m_bEmpty = (GetItemCount() == 0);
969 Invalidate();
970 #endif
971
972 }
973 int CGitStatusListCtrl::GetColumnIndex(int mask)
974 {
975 int i=0;
976 for(i=0;i<32;i++)
977 if(mask&0x1)
978 return i;
979 else
980 mask=mask>>1;
981 return -1;
982 }
983 void CGitStatusListCtrl::AddEntry(CTGitPath * GitPath, WORD /*langID*/, int listIndex)
984 {
985 static CString from(MAKEINTRESOURCE(IDS_STATUSLIST_FROM));
986 static HINSTANCE hResourceHandle(AfxGetResourceHandle());
987 static bool abbreviateRenamings(((DWORD)CRegDWORD(_T("Software\\TortoiseGit\\AbbreviateRenamings"), FALSE)) == TRUE);
988 static bool relativeTimes = (CRegDWORD(_T("Software\\TortoiseGit\\RelativeTimes"), FALSE) != FALSE);
989
990 CString path = GitPath->GetGitPathString();
991
992 m_bBlock = TRUE;
993 int index = listIndex;
994 int nCol = 1;
995 CString entryname = GitPath->GetGitPathString();
996 int icon_idx = 0;
997 if (GitPath->IsDirectory())
998 {
999 icon_idx = m_nIconFolder;
1000 m_nShownSubmodules++;
1001 }
1002 else
1003 {
1004 icon_idx = SYS_IMAGE_LIST().GetPathIconIndex(*GitPath);
1005 m_nShownFiles++;
1006 }
1007 switch (GitPath->m_Action)
1008 {
1009 case CTGitPath::LOGACTIONS_ADDED:
1010 case CTGitPath::LOGACTIONS_COPY:
1011 m_nShownAdded++;
1012 break;
1013 case CTGitPath::LOGACTIONS_DELETED:
1014 m_nShownDeleted++;
1015 break;
1016 case CTGitPath::LOGACTIONS_REPLACED:
1017 case CTGitPath::LOGACTIONS_MODIFIED:
1018 case CTGitPath::LOGACTIONS_MERGED:
1019 m_nShownModified++;
1020 break;
1021 case CTGitPath::LOGACTIONS_UNMERGED:
1022 m_nShownConflicted++;
1023 break;
1024 case CTGitPath::LOGACTIONS_UNVER:
1025 m_nShownUnversioned++;
1026 break;
1027 default:
1028 m_nShownUnversioned++;
1029 break;
1030 }
1031 if(GitPath->m_Action & (CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_COPY) && !GitPath->GetGitOldPathString().IsEmpty())
1032 {
1033 if (!abbreviateRenamings)
1034 {
1035 // relative path
1036 CString rename;
1037 rename.Format(from, GitPath->GetGitOldPathString());
1038 entryname += _T(" ") + rename;
1039 }
1040 else
1041 {
1042 CTGitPathList tgpl;
1043 tgpl.AddPath(*GitPath);
1044 CTGitPath old(GitPath->GetGitOldPathString());
1045 tgpl.AddPath(old);
1046 CString commonRoot = tgpl.GetCommonRoot().GetGitPathString();
1047 if (!commonRoot.IsEmpty())
1048 commonRoot += _T("/");
1049 if (old.GetFileOrDirectoryName() == GitPath->GetFileOrDirectoryName() && old.GetContainingDirectory().GetGitPathString() != "" && GitPath->GetContainingDirectory().GetGitPathString())
1050 {
1051 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();
1052 }
1053 else if (!commonRoot.IsEmpty())
1054 {
1055 entryname = commonRoot + _T("{") + GitPath->GetGitOldPathString().Mid(commonRoot.GetLength()) + _T(" => ") + GitPath->GetGitPathString().Mid(commonRoot.GetLength()) + _T("}");
1056 }
1057 else
1058 {
1059 entryname = GitPath->GetGitOldPathString().Mid(commonRoot.GetLength()) + _T(" => ") + GitPath->GetGitPathString().Mid(commonRoot.GetLength());
1060 }
1061 }
1062 }
1063
1064 InsertItem(index, entryname, icon_idx);
1065 if (m_restorepaths.find(GitPath->GetWinPathString()) != m_restorepaths.end())
1066 SetItemState(index, INDEXTOOVERLAYMASK(OVL_RESTORE), TVIS_OVERLAYMASK);
1067
1068 this->SetItemData(index, (DWORD_PTR)GitPath);
1069 // SVNSLC_COLFILENAME
1070 SetItemText(index, nCol++, GitPath->GetFileOrDirectoryName());
1071 // SVNSLC_COLEXT
1072 SetItemText(index, nCol++, GitPath->GetFileExtension());
1073 // SVNSLC_COLSTATUS
1074 SetItemText(index, nCol++, GitPath->GetActionName());
1075
1076 SetItemText(index, GetColumnIndex(GITSLC_COLADD),GitPath->m_StatAdd);
1077 SetItemText(index, GetColumnIndex(GITSLC_COLDEL),GitPath->m_StatDel);
1078
1079 {
1080 CString modificationDate;
1081 __int64 filetime = GitPath->GetLastWriteTime();
1082 if (filetime && (GitPath->m_Action != CTGitPath::LOGACTIONS_DELETED))
1083 {
1084 FILETIME* f = (FILETIME*)(__int64*)&filetime;
1085 modificationDate = CLoglistUtils::FormatDateAndTime(CTime(g_Git.filetime_to_time_t(f)), DATE_SHORTDATE, true, relativeTimes);
1086 }
1087 SetItemText(index, GetColumnIndex(GITSLC_COLMODIFICATIONDATE), modificationDate);
1088 }
1089
1090 SetCheck(index, GitPath->m_Checked);
1091 if (GitPath->m_Checked)
1092 m_nSelected++;
1093
1094
1095 if( GitPath->m_Action & CTGitPath::LOGACTIONS_IGNORE)
1096 SetItemGroup(index, 2);
1097 else if( GitPath->m_Action & CTGitPath::LOGACTIONS_UNVER)
1098 SetItemGroup(index,1);
1099 else
1100 {
1101 SetItemGroup(index, GitPath->m_ParentNo&(PARENT_MASK|MERGE_MASK));
1102 }
1103
1104 m_bBlock = FALSE;
1105
1106
1107 }
1108 #if 0
1109 void CGitStatusListCtrl::AddEntry(FileEntry * entry, WORD langID, int listIndex)
1110 {
1111 static HINSTANCE hResourceHandle(AfxGetResourceHandle());
1112
1113 CString path = entry->GetPath().GetGitPathString();
1114 if ( m_mapFilenameToChecked.size()!=0 && m_mapFilenameToChecked.find(path) != m_mapFilenameToChecked.end() )
1115 {
1116 // The user manually de-/selected an item. We now restore this status
1117 // when refreshing.
1118 entry->checked = m_mapFilenameToChecked[path];
1119 }
1120
1121 m_bBlock = TRUE;
1122 TCHAR buf[100];
1123 int index = listIndex;
1124 int nCol = 1;
1125 CString entryname = entry->GetDisplayName();
1126 int icon_idx = 0;
1127 if (entry->isfolder)
1128 icon_idx = m_nIconFolder;
1129 else
1130 {
1131 icon_idx = SYS_IMAGE_LIST().GetPathIconIndex(entry->path);
1132 }
1133 // relative path
1134 InsertItem(index, entryname, icon_idx);
1135 // SVNSLC_COLFILENAME
1136 SetItemText(index, nCol++, entry->path.GetFileOrDirectoryName());
1137 // SVNSLC_COLEXT
1138 SetItemText(index, nCol++, entry->path.GetFileExtension());
1139 // SVNSLC_COLSTATUS
1140 if (entry->isNested)
1141 {
1142 CString sTemp(MAKEINTRESOURCE(IDS_STATUSLIST_NESTED));
1143 SetItemText(index, nCol++, sTemp);
1144 }
1145 else
1146 {
1147 GitStatus::GetStatusString(hResourceHandle, entry->status, buf, _countof(buf), (WORD)langID);
1148 if ((entry->copied)&&(_tcslen(buf)>1))
1149 _tcscat_s(buf, 100, _T(" (+)"));
1150 if ((entry->switched)&&(_tcslen(buf)>1))
1151 _tcscat_s(buf, 100, _T(" (s)"));
1152 SetItemText(index, nCol++, buf);
1153 }
1154 // SVNSLC_COLREMOTESTATUS
1155 if (entry->isNested)
1156 {
1157 CString sTemp(MAKEINTRESOURCE(IDS_STATUSLIST_NESTED));
1158 SetItemText(index, nCol++, sTemp);
1159 }
1160 else
1161 {
1162 #if 0
1163 SVNStatus::GetStatusString(hResourceHandle, entry->remotestatus, buf, _countof(buf), (WORD)langID);
1164 if ((entry->copied)&&(_tcslen(buf)>1))
1165 _tcscat_s(buf, 100, _T(" (+)"));
1166 if ((entry->switched)&&(_tcslen(buf)>1))
1167 _tcscat_s(buf, 100, _T(" (s)"));
1168 #endif
1169 SetItemText(index, nCol++, buf);
1170 }
1171 // SVNSLC_COLTEXTSTATUS
1172 if (entry->isNested)
1173 {
1174 CString sTemp(MAKEINTRESOURCE(IDS_STATUSLIST_NESTED));
1175 SetItemText(index, nCol++, sTemp);
1176 }
1177 else
1178 {
1179 #if 0
1180 SVNStatus::GetStatusString(hResourceHandle, entry->textstatus, buf, _countof(buf), (WORD)langID);
1181 if ((entry->copied)&&(_tcslen(buf)>1))
1182 _tcscat_s(buf, 100, _T(" (+)"));
1183 if ((entry->switched)&&(_tcslen(buf)>1))
1184 _tcscat_s(buf, 100, _T(" (s)"));
1185 #endif
1186 SetItemText(index, nCol++, buf);
1187 }
1188 // SVNSLC_COLPROPSTATUS
1189 if (entry->isNested)
1190 {
1191 SetItemText(index, nCol++, _T(""));
1192 }
1193 else
1194 {
1195 #if 0
1196 SVNStatus::GetStatusString(hResourceHandle, entry->propstatus, buf, _countof(buf), (WORD)langID);
1197 if ((entry->copied)&&(_tcslen(buf)>1))
1198 _tcscat_s(buf, 100, _T(" (+)"));
1199 if ((entry->switched)&&(_tcslen(buf)>1))
1200 _tcscat_s(buf, 100, _T(" (s)"));
1201 #endif
1202 SetItemText(index, nCol++, buf);
1203 }
1204 // SVNSLC_COLREMOTETEXT
1205 if (entry->isNested)
1206 {
1207 SetItemText(index, nCol++, _T(""));
1208 }
1209 else
1210 {
1211 #if 0
1212 SVNStatus::GetStatusString(hResourceHandle, entry->remotetextstatus, buf, _countof(buf), (WORD)langID);
1213 SetItemText(index, nCol++, buf);
1214 #endif
1215 }
1216 // SVNSLC_COLREMOTEPROP
1217 if (entry->isNested)
1218 {
1219 SetItemText(index, nCol++, _T(""));
1220 }
1221 else
1222 {
1223 // SVNStatus::GetStatusString(hResourceHandle, entry->remotepropstatus, buf, _countof(buf), (WORD)langID);
1224 SetItemText(index, nCol++, buf);
1225 }
1226 // SVNSLC_COLURL
1227 // SetItemText(index, nCol++, entry->url);
1228 // SVNSLC_COLLOCK
1229 #if 0
1230 if (!m_HeadRev.IsHead())
1231 {
1232 // we have contacted the repository
1233
1234 // decision-matrix
1235 // wc repository text
1236 // "" "" ""
1237 // "" UID1 owner
1238 // UID1 UID1 owner
1239 // UID1 "" lock has been broken
1240 // UID1 UID2 lock has been stolen
1241 if (entry->lock_token.IsEmpty() || (entry->lock_token.Compare(entry->lock_remotetoken)==0))
1242 {
1243 if (entry->lock_owner.IsEmpty())
1244 SetItemText(index, nCol++, entry->lock_remoteowner);
1245 else
1246 SetItemText(index, nCol++, entry->lock_owner);
1247 }
1248 else if (entry->lock_remotetoken.IsEmpty())
1249 {
1250 // broken lock
1251 CString temp(MAKEINTRESOURCE(IDS_STATUSLIST_LOCKBROKEN));
1252 SetItemText(index, nCol++, temp);
1253 }
1254 else
1255 {
1256 // stolen lock
1257 CString temp;
1258 temp.Format(IDS_STATUSLIST_LOCKSTOLEN, (LPCTSTR)entry->lock_remoteowner);
1259 SetItemText(index, nCol++, temp);
1260 }
1261 }
1262 else
1263 SetItemText(index, nCol++, entry->lock_owner);
1264 // SVNSLC_COLLOCKCOMMENT
1265 SetItemText(index, nCol++, entry->lock_comment);
1266 // SVNSLC_COLAUTHOR
1267 SetItemText(index, nCol++, entry->last_commit_author);
1268 // SVNSLC_COLREVISION
1269 CString temp;
1270 temp.Format(_T("%ld"), entry->last_commit_rev);
1271 if (entry->last_commit_rev > 0)
1272 SetItemText(index, nCol++, temp);
1273 else
1274 SetItemText(index, nCol++, _T(""));
1275 // SVNSLC_COLREMOTEREVISION
1276 temp.Format(_T("%ld"), entry->remoterev);
1277 if (entry->remoterev > 0)
1278 SetItemText(index, nCol++, temp);
1279 else
1280 SetItemText(index, nCol++, _T(""));
1281 // SVNSLC_COLDATE
1282 TCHAR datebuf[SVN_DATE_BUFFER];
1283 apr_time_t date = entry->last_commit_date;
1284 SVN::formatDate(datebuf, date, true);
1285 if (date)
1286 SetItemText(index, nCol++, datebuf);
1287 else
1288 SetItemText(index, nCol++, _T(""));
1289 // SVNSLC_COLSVNNEEDSLOCK
1290 BOOL bFoundSVNNeedsLock = entry->present_props.IsNeedsLockSet();
1291 CString strSVNNeedsLock = (bFoundSVNNeedsLock) ? _T("*") : _T("");
1292 SetItemText(index, nCol++, strSVNNeedsLock);
1293 // SVNSLC_COLCOPYFROM
1294 if (m_sURL.Compare(entry->copyfrom_url.Left(m_sURL.GetLength()))==0)
1295 temp = entry->copyfrom_url.Mid(m_sURL.GetLength());
1296 else
1297 temp = entry->copyfrom_url;
1298 SetItemText(index, nCol++, temp);
1299 // SVNSLC_COLMODIFICATIONDATE
1300 __int64 filetime = entry->GetPath().GetLastWriteTime();
1301 if ( (filetime) && (entry->status!=git_wc_status_deleted) )
1302 {
1303 FILETIME* f = (FILETIME*)(__int64*)&filetime;
1304 TCHAR datebuf[SVN_DATE_BUFFER];
1305 SVN::formatDate(datebuf,*f,true);
1306 SetItemText(index, nCol++, datebuf);
1307 }
1308 else
1309 {
1310 SetItemText(index, nCol++, _T(""));
1311 }
1312
1313 // user-defined properties
1314 for ( int i = SVNSLC_NUMCOLUMNS, count = m_ColumnManager.GetColumnCount()
1315 ; i < count
1316 ; ++i)
1317 {
1318 assert (i == nCol++);
1319 assert (m_ColumnManager.IsUserProp (i));
1320
1321 CString name = m_ColumnManager.GetName(i);
1322 if (entry->present_props.HasProperty (name))
1323 {
1324 const CString& propVal = entry->present_props [name];
1325 if (propVal.IsEmpty())
1326 SetItemText(index, i, m_sNoPropValueText);
1327 else
1328 SetItemText(index, i, propVal);
1329 }
1330 else
1331 SetItemText(index, i, _T(""));
1332 }
1333
1334 SetCheck(index, entry->checked);
1335 if (entry->checked)
1336 m_nSelected++;
1337 if (m_changelists.find(entry->changelist) != m_changelists.end())
1338 SetItemGroup(index, m_changelists[entry->changelist]);
1339 else
1340 SetItemGroup(index, 0);
1341 m_bBlock = FALSE;
1342 #endif
1343 }
1344 #endif
1345 bool CGitStatusListCtrl::SetItemGroup(int item, int groupindex)
1346 {
1347 // if ((m_dwContextMenus & SVNSLC_POPCHANGELISTS) == NULL)
1348 // return false;
1349 if (groupindex < 0)
1350 return false;
1351 LVITEM i = {0};
1352 i.mask = LVIF_GROUPID;
1353 i.iItem = item;
1354 i.iSubItem = 0;
1355 i.iGroupId = groupindex;
1356
1357 return !!SetItem(&i);
1358 }
1359
1360 void CGitStatusListCtrl::OnHdnItemclick(NMHDR *pNMHDR, LRESULT *pResult)
1361 {
1362 LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);
1363 *pResult = 0;
1364 if (m_bBlock)
1365 return;
1366 m_bBlock = TRUE;
1367 if (m_nSortedColumn == phdr->iItem)
1368 m_bAscending = !m_bAscending;
1369 else
1370 m_bAscending = TRUE;
1371 m_nSortedColumn = phdr->iItem;
1372 Show(m_dwShow, 0, m_bShowFolders,false,true);
1373
1374 m_bBlock = FALSE;
1375 }
1376
1377 void CGitStatusListCtrl::OnLvnItemchanging(NMHDR *pNMHDR, LRESULT *pResult)
1378 {
1379 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1380 *pResult = 0;
1381
1382 #define ISCHECKED(x) ((x) ? ((((x)&LVIS_STATEIMAGEMASK)>>12)-1) : FALSE)
1383 if ((m_bBlock)&&(m_bBlockUI))
1384 {
1385 // if we're blocked, prevent changing of the check state
1386 if ((!ISCHECKED(pNMLV->uOldState) && ISCHECKED(pNMLV->uNewState))||
1387 (ISCHECKED(pNMLV->uOldState) && !ISCHECKED(pNMLV->uNewState)))
1388 *pResult = TRUE;
1389 }
1390 }
1391
1392 BOOL CGitStatusListCtrl::OnLvnItemchanged(NMHDR *pNMHDR, LRESULT *pResult)
1393 {
1394 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1395 *pResult = 0;
1396 CWnd* pParent = GetParent();
1397 if (NULL != pParent && NULL != pParent->GetSafeHwnd())
1398 {
1399 pParent->SendMessage(GITSLNM_ITEMCHANGED, pNMLV->iItem);
1400 }
1401
1402 if ((pNMLV->uNewState==0)||(pNMLV->uNewState & LVIS_SELECTED)||(pNMLV->uNewState & LVIS_FOCUSED))
1403 return FALSE;
1404
1405 if (m_bBlock)
1406 return FALSE;
1407
1408 bool bSelected = !!(ListView_GetItemState(m_hWnd, pNMLV->iItem, LVIS_SELECTED) & LVIS_SELECTED);
1409 int nListItems = GetItemCount();
1410
1411 m_bBlock = TRUE;
1412 // was the item checked?
1413
1414 //CTGitPath *gitpath=(CTGitPath*)GetItemData(pNMLV->iItem);
1415 //gitpath->m_Checked=GetCheck(pNMLV->iItem);
1416
1417 if (GetCheck(pNMLV->iItem))
1418 {
1419 CheckEntry(pNMLV->iItem, nListItems);
1420 if (bSelected)
1421 {
1422 POSITION pos = GetFirstSelectedItemPosition();
1423 int index;
1424 while ((index = GetNextSelectedItem(pos)) >= 0)
1425 {
1426 if (index != pNMLV->iItem)
1427 CheckEntry(index, nListItems);
1428 }
1429 }
1430 }
1431 else
1432 {
1433 UncheckEntry(pNMLV->iItem, nListItems);
1434 if (bSelected)
1435 {
1436 POSITION pos = GetFirstSelectedItemPosition();
1437 int index;
1438 while ((index = GetNextSelectedItem(pos)) >= 0)
1439 {
1440 if (index != pNMLV->iItem)
1441 UncheckEntry(index, nListItems);
1442 }
1443 }
1444 }
1445
1446 GetStatisticsString();
1447 m_bBlock = FALSE;
1448 NotifyCheck();
1449
1450 return FALSE;
1451 }
1452
1453 void CGitStatusListCtrl::OnColumnResized(NMHDR *pNMHDR, LRESULT *pResult)
1454 {
1455 m_ColumnManager.OnColumnResized(pNMHDR,pResult);
1456
1457 *pResult = FALSE;
1458 }
1459
1460 void CGitStatusListCtrl::OnColumnMoved(NMHDR *pNMHDR, LRESULT *pResult)
1461 {
1462 m_ColumnManager.OnColumnMoved(pNMHDR, pResult);
1463
1464 Invalidate(FALSE);
1465 }
1466
1467 void CGitStatusListCtrl::CheckEntry(int index, int /*nListItems*/)
1468 {
1469 Locker lock(m_critSec);
1470 //FileEntry * entry = GetListEntry(index);
1471 CTGitPath *path=(CTGitPath*)GetItemData(index);
1472 ASSERT(path != NULL);
1473 if (path == NULL)
1474 return;
1475 m_mapFilenameToChecked[path->GetGitPathString()] = true;
1476 SetCheck(index, TRUE);
1477 //entry = GetListEntry(index);
1478 // if an unversioned item was checked, then we need to check if
1479 // the parent folders are unversioned too. If the parent folders actually
1480 // are unversioned, then check those too.
1481 #if 0
1482 if (entry->status == git_wc_status_unversioned)
1483 {
1484 // we need to check the parent folder too
1485 const CTGitPath& folderpath = entry->path;
1486 for (int i=0; i< nListItems; ++i)
1487 {
1488 FileEntry * testEntry = GetListEntry(i);
1489 ASSERT(testEntry != NULL);
1490 if (testEntry == NULL)
1491 continue;
1492 if (!testEntry->checked)
1493 {
1494 if (testEntry->path.IsAncestorOf(folderpath) && (!testEntry->path.IsEquivalentTo(folderpath)))
1495 {
1496 SetEntryCheck(testEntry,i,true);
1497 m_nSelected++;
1498 }
1499 }
1500 }
1501 }
1502 bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
1503 if ( (entry->status == git_wc_status_deleted) || (m_bCheckChildrenWithParent) || (bShift) )
1504 {
1505 // if a deleted folder gets checked, we have to check all
1506 // children of that folder too.
1507 if (entry->path.IsDirectory())
1508 {
1509 SetCheckOnAllDescendentsOf(entry, true);
1510 }
1511
1512 // if a deleted file or folder gets checked, we have to
1513 // check all parents of this item too.
1514 for (int i=0; i<nListItems; ++i)
1515 {
1516 FileEntry * testEntry = GetListEntry(i);
1517 ASSERT(testEntry != NULL);
1518 if (testEntry == NULL)
1519 continue;
1520 if (!testEntry->checked)
1521 {
1522 if (testEntry->path.IsAncestorOf(entry->path) && (!testEntry->path.IsEquivalentTo(entry->path)))
1523 {
1524 if ((testEntry->status == git_wc_status_deleted)||(m_bCheckChildrenWithParent))
1525 {
1526 SetEntryCheck(testEntry,i,true);
1527 m_nSelected++;
1528 // now we need to check all children of this parent folder
1529 SetCheckOnAllDescendentsOf(testEntry, true);
1530 }
1531 }
1532 }
1533 }
1534 }
1535 #endif
1536 if ( !path->m_Checked )
1537 {
1538 path->m_Checked = TRUE;
1539 m_nSelected++;
1540 }
1541 }
1542
1543 void CGitStatusListCtrl::UncheckEntry(int index, int /*nListItems*/)
1544 {
1545 Locker lock(m_critSec);
1546 CTGitPath *path=(CTGitPath*)GetItemData(index);
1547 ASSERT(path != NULL);
1548 if (path == NULL)
1549 return;
1550 SetCheck(index, FALSE);
1551 m_mapFilenameToChecked[path->GetGitPathString()] = false;
1552 //entry = GetListEntry(index);
1553 // item was unchecked
1554 #if 0
1555 if (entry->path.IsDirectory())
1556 {
1557 // disable all files within an unselected folder, except when unchecking a folder with property changes
1558 bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
1559 if ( (entry->status != git_wc_status_modified) || (bShift) )
1560 {
1561 SetCheckOnAllDescendentsOf(entry, false);
1562 }
1563 }
1564 else if (entry->status == git_wc_status_deleted)
1565 {
1566 // a "deleted" file was unchecked, so uncheck all parent folders
1567 // and all children of those parents
1568 for (int i=0; i<nListItems; i++)
1569 {
1570 FileEntry * testEntry = GetListEntry(i);
1571 ASSERT(testEntry != NULL);
1572 if (testEntry == NULL)
1573 continue;
1574 if (testEntry->checked)
1575 {
1576 if (testEntry->path.IsAncestorOf(entry->path))
1577 {
1578 if (testEntry->status == git_wc_status_deleted)
1579 {
1580 SetEntryCheck(testEntry,i,false);
1581 m_nSelected--;
1582
1583 SetCheckOnAllDescendentsOf(testEntry, false);
1584 }
1585 }
1586 }
1587 }
1588 }
1589 #endif
1590 if ( path->m_Checked )
1591 {
1592 path->m_Checked = FALSE;
1593 m_nSelected--;
1594 }
1595 }
1596 #if 0
1597 bool CGitStatusListCtrl::EntryPathCompareNoCase(const FileEntry* pEntry1, const FileEntry* pEntry2)
1598 {
1599 return pEntry1->path < pEntry2->path;
1600 }
1601
1602 bool CGitStatusListCtrl::IsEntryVersioned(const FileEntry* pEntry1)
1603 {
1604 return pEntry1->status != git_wc_status_unversioned;
1605 }
1606 #endif
1607 bool CGitStatusListCtrl::BuildStatistics()
1608 {
1609
1610 bool bRefetchStatus = false;
1611
1612 // now gather some statistics
1613 m_nUnversioned = 0;
1614 m_nNormal = 0;
1615 m_nModified = 0;
1616 m_nAdded = 0;
1617 m_nDeleted = 0;
1618 m_nConflicted = 0;
1619 m_nTotal = 0;
1620 m_nSelected = 0;
1621 m_nLineAdded = 0;
1622 m_nLineDeleted = 0;
1623 m_nRenamed = 0;
1624
1625 for (int i=0; i < (int)m_arStatusArray.size(); ++i)
1626 {
1627 int status=((CTGitPath*)m_arStatusArray[i])->m_Action;
1628
1629 m_nLineAdded += _tstol(((CTGitPath*)m_arStatusArray[i])->m_StatAdd);
1630 m_nLineDeleted += _tstol(((CTGitPath*)m_arStatusArray[i])->m_StatDel);
1631
1632 if(status&(CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_COPY))
1633 m_nAdded++;
1634
1635 if(status&CTGitPath::LOGACTIONS_DELETED)
1636 m_nDeleted++;
1637
1638 if(status&(CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_MODIFIED))
1639 m_nModified++;
1640
1641 if(status&CTGitPath::LOGACTIONS_UNMERGED)
1642 m_nConflicted++;
1643
1644 if(status&(CTGitPath::LOGACTIONS_IGNORE|CTGitPath::LOGACTIONS_UNVER))
1645 m_nUnversioned++;
1646
1647 if(status&(CTGitPath::LOGACTIONS_REPLACED))
1648 m_nRenamed++;
1649
1650 if(((CTGitPath*)m_arStatusArray[i])->m_Checked)
1651 m_nSelected++;
1652
1653 // } // switch (entry->status)
1654 // } // if (entry)
1655 } // for (int i=0; i < (int)m_arStatusArray.size(); ++i)
1656 return !bRefetchStatus;
1657
1658 return FALSE;
1659 }
1660
1661
1662 int CGitStatusListCtrl::GetGroupFromPoint(POINT * ppt)
1663 {
1664 // the point must be relative to the upper left corner of the control
1665
1666 if (ppt == NULL)
1667 return -1;
1668 if (!IsGroupViewEnabled())
1669 return -1;
1670
1671 POINT pt = *ppt;
1672 pt.x = 10;
1673 UINT flags = 0;
1674 int nItem = -1;
1675 RECT rc;
1676 GetWindowRect(&rc);
1677 while (((flags & LVHT_BELOW) == 0)&&(pt.y < rc.bottom))
1678 {
1679 nItem = HitTest(pt, &flags);
1680 if ((flags & LVHT_ONITEM)||(flags & LVHT_EX_GROUP_HEADER))
1681 {
1682 // the first item below the point
1683
1684 // check if the point is too much right (i.e. if the point
1685 // is farther to the right than the width of the item)
1686 RECT r;
1687 GetItemRect(nItem, &r, LVIR_LABEL);
1688 if (ppt->x > r.right)
1689 return -1;
1690
1691 LVITEM lv = {0};
1692 lv.mask = LVIF_GROUPID;
1693 lv.iItem = nItem;
1694 GetItem(&lv);
1695 int groupID = lv.iGroupId;
1696 // now we search upwards and check if the item above this one
1697 // belongs to another group. If it belongs to the same group,
1698 // we're not over a group header
1699 while (pt.y >= 0)
1700 {
1701 pt.y -= 2;
1702 nItem = HitTest(pt, &flags);
1703 if ((flags & LVHT_ONITEM)&&(nItem >= 0))
1704 {
1705 // the first item below the point
1706 LVITEM lv = {0};
1707 lv.mask = LVIF_GROUPID;
1708 lv.iItem = nItem;
1709 GetItem(&lv);
1710 if (lv.iGroupId != groupID)
1711 return groupID;
1712 else
1713 return -1;
1714 }
1715 }
1716 if (pt.y < 0)
1717 return groupID;
1718 return -1;
1719 }
1720 pt.y += 2;
1721 };
1722 return -1;
1723 }
1724
1725 void CGitStatusListCtrl::OnContextMenuGroup(CWnd * /*pWnd*/, CPoint point)
1726 {
1727 POINT clientpoint = point;
1728 ScreenToClient(&clientpoint);
1729 if ((IsGroupViewEnabled())&&(GetGroupFromPoint(&clientpoint) >= 0))
1730 {
1731 CMenu popup;
1732 if (popup.CreatePopupMenu())
1733 {
1734 CString temp;
1735 temp.LoadString(IDS_STATUSLIST_CHECKGROUP);
1736 popup.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_CHECKGROUP, temp);
1737 temp.LoadString(IDS_STATUSLIST_UNCHECKGROUP);
1738 popup.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_UNCHECKGROUP, temp);
1739 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1740 bool bCheck = false;
1741 switch (cmd)
1742 {
1743 case IDGITLC_CHECKGROUP:
1744 bCheck = true;
1745 // fall through here
1746 case IDGITLC_UNCHECKGROUP:
1747 {
1748 int group = GetGroupFromPoint(&clientpoint);
1749 // go through all items and check/uncheck those assigned to the group
1750 // but block the OnLvnItemChanged handler
1751 m_bBlock = true;
1752 LVITEM lv;
1753 for (int i=0; i<GetItemCount(); ++i)
1754 {
1755 SecureZeroMemory(&lv, sizeof(LVITEM));
1756 lv.mask = LVIF_GROUPID;
1757 lv.iItem = i;
1758 GetItem(&lv);
1759
1760 if (lv.iGroupId == group)
1761 {
1762 CTGitPath * entry = (CTGitPath*)GetItemData(i);
1763 if (entry)
1764 {
1765 bool bOldCheck = entry->m_Checked;
1766 SetEntryCheck(entry, i, bCheck);
1767 if (bCheck != bOldCheck)
1768 {
1769 if (bCheck)
1770 m_nSelected++;
1771 else
1772 m_nSelected--;
1773 }
1774 }
1775 }
1776
1777 }
1778 GetStatisticsString();
1779 NotifyCheck();
1780 m_bBlock = false;
1781 }
1782 break;
1783 }
1784 }
1785 }
1786 }
1787
1788 void CGitStatusListCtrl::OnContextMenuList(CWnd * pWnd, CPoint point)
1789 {
1790
1791 //WORD langID = (WORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
1792
1793 //bool bShift = !!(GetAsyncKeyState(VK_SHIFT) & 0x8000);
1794 CTGitPath * filepath;
1795
1796 int selIndex = GetSelectionMark();
1797 if ((point.x == -1) && (point.y == -1))
1798 {
1799 CRect rect;
1800 GetItemRect(selIndex, &rect, LVIR_LABEL);
1801 ClientToScreen(&rect);
1802 point = rect.CenterPoint();
1803 }
1804 if ((GetSelectedCount() == 0) && (m_bHasCheckboxes))
1805 {
1806 // nothing selected could mean the context menu is requested for
1807 // a group header
1808 OnContextMenuGroup(pWnd, point);
1809 }
1810 else if (selIndex >= 0)
1811 {
1812 //FileEntry * entry = GetListEntry(selIndex);
1813
1814 filepath = (CTGitPath * )GetItemData(selIndex);
1815
1816 ASSERT(filepath != NULL);
1817 if (filepath == NULL)
1818 return;
1819
1820 //const CTGitPath& filepath = entry->path;
1821 int wcStatus = filepath->m_Action;
1822 // entry is selected, now show the popup menu
1823 Locker lock(m_critSec);
1824 CIconMenu popup;
1825 CMenu changelistSubMenu;
1826 CMenu ignoreSubMenu;
1827 if (popup.CreatePopupMenu())
1828 {
1829 //Add Menu for version controlled file
1830
1831 if (GetSelectedCount() > 0 && wcStatus & CTGitPath::LOGACTIONS_UNMERGED)
1832 {
1833 if (GetSelectedCount() == 1 && (m_dwContextMenus & GITSLC_POPCONFLICT)/*&&(entry->textstatus == git_wc_status_conflicted)*/)
1834 {
1835 popup.AppendMenuIcon(IDGITLC_EDITCONFLICT, IDS_MENUCONFLICT, IDI_CONFLICT);
1836 }
1837 if (m_dwContextMenus & GITSLC_POPRESOLVE)
1838 {
1839 popup.AppendMenuIcon(IDGITLC_RESOLVECONFLICT, IDS_STATUSLIST_CONTEXT_RESOLVED, IDI_RESOLVE);
1840 }
1841 if ((m_dwContextMenus & GITSLC_POPRESOLVE)/*&&(entry->textstatus == git_wc_status_conflicted)*/)
1842 {
1843 popup.AppendMenuIcon(IDGITLC_RESOLVETHEIRS, IDS_SVNPROGRESS_MENUUSETHEIRS, IDI_RESOLVE);
1844 popup.AppendMenuIcon(IDGITLC_RESOLVEMINE, IDS_SVNPROGRESS_MENUUSEMINE, IDI_RESOLVE);
1845 }
1846 if ((m_dwContextMenus & GITSLC_POPCONFLICT)||(m_dwContextMenus & GITSLC_POPRESOLVE))
1847 popup.AppendMenu(MF_SEPARATOR);
1848 }
1849
1850 if (GetSelectedCount() > 0)
1851 {
1852 if (wcStatus & CTGitPath::LOGACTIONS_UNVER)
1853 if (m_dwContextMenus & GITSLC_POPADD)
1854 {
1855 //if ( entry->IsFolder() )
1856 //{
1857 // popup.AppendMenuIcon(IDSVNLC_ADD_RECURSIVE, IDS_STATUSLIST_CONTEXT_ADD_RECURSIVE, IDI_ADD);
1858 //}
1859 //else
1860 {
1861 popup.AppendMenuIcon(IDGITLC_ADD, IDS_STATUSLIST_CONTEXT_ADD, IDI_ADD);
1862 }
1863 }
1864 }
1865
1866 if (!(wcStatus &CTGitPath::LOGACTIONS_UNVER))
1867 {
1868 if ( (m_dwContextMenus & GITSLC_POPCOMPAREWITHBASE) && GetSelectedCount()>0)
1869 {
1870 if(filepath->m_ParentNo & MERGE_MASK)
1871 popup.AppendMenuIcon(IDGITLC_COMPARE, IDS_TREE_DIFF, IDI_DIFF);
1872 else
1873 popup.AppendMenuIcon(IDGITLC_COMPARE, IDS_LOG_COMPAREWITHBASE, IDI_DIFF);
1874
1875 popup.SetDefaultItem(IDGITLC_COMPARE, FALSE);
1876 }
1877
1878 if ((m_dwContextMenus & this->GetContextMenuBit(IDGITLC_COMPAREWC)) && GetSelectedCount()>0 && m_bHasWC)
1879 {
1880 if( (!m_CurrentVersion.IsEmpty()) && m_CurrentVersion != GIT_REV_ZERO)
1881 popup.AppendMenuIcon(IDGITLC_COMPAREWC, IDS_LOG_POPUP_COMPARE, IDI_DIFF);
1882 }
1883 //Select one items
1884 if (GetSelectedCount() == 1)
1885 {
1886 bool bEntryAdded = false;
1887 //if (entry->remotestatus <= git_wc_status_normal)
1888 //{
1889 // if (wcStatus > git_wc_status_normal)
1890 // {
1891 // if ((m_dwContextMenus & SVNSLC_POPGNUDIFF)&&(wcStatus != git_wc_status_deleted)&&(wcStatus != git_wc_status_missing))
1892 // {
1893 if(!g_Git.IsInitRepos() && (m_dwContextMenus&GITSLC_POPGNUDIFF))
1894 {
1895 popup.AppendMenuIcon(IDGITLC_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
1896
1897 bEntryAdded = true;
1898 }
1899 // }
1900 // }
1901 //
1902 //}
1903 //else if (wcStatus != git_wc_status_deleted)
1904 //{
1905 // if (m_dwContextMenus & SVNSLC_POPCOMPARE)
1906 // {
1907 // popup.AppendMenuIcon(IDSVNLC_COMPAREWC, IDS_LOG_POPUP_COMPARE, IDI_DIFF);
1908 // popup.SetDefaultItem(IDSVNLC_COMPARE, FALSE);
1909 // bEntryAdded = true;
1910 // }
1911 // if (m_dwContextMenus & SVNSLC_POPGNUDIFF)
1912 // {
1913 // popup.AppendMenuIcon(IDSVNLC_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
1914 // bEntryAdded = true;
1915 // }
1916 //}
1917 if (bEntryAdded)
1918 popup.AppendMenu(MF_SEPARATOR);
1919 }
1920 //else if (GetSelectedCount() > 1)
1921 //{
1922 // if (m_dwContextMenus & SVNSLC_POPCOMMIT)
1923 // {
1924 // popup.AppendMenuIcon(IDSVNLC_COMMIT, IDS_STATUSLIST_CONTEXT_COMMIT, IDI_COMMIT);
1925 // popup.SetDefaultItem(IDSVNLC_COMPARE, FALSE);
1926 // }
1927 //}
1928 }
1929
1930 if( (!this->m_Rev1.IsEmpty()) || (!this->m_Rev1.IsEmpty()) )
1931 {
1932 if(GetSelectedCount() == 1)
1933 {
1934 if (m_dwContextMenus & this->GetContextMenuBit(IDGITLC_COMPARETWO))
1935 {
1936 popup.AppendMenuIcon(IDGITLC_COMPARETWO, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);
1937 popup.SetDefaultItem(IDGITLC_COMPARETWO, FALSE);
1938 }
1939 if (m_dwContextMenus & this->GetContextMenuBit(IDGITLC_GNUDIFF2))
1940 {
1941 popup.AppendMenuIcon(IDGITLC_GNUDIFF2, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
1942 }
1943 }
1944 }
1945
1946 //Select Multi item
1947 if (GetSelectedCount() > 0)
1948 {
1949 if ((GetSelectedCount() == 2) && (m_dwContextMenus & this->GetContextMenuBit(GITSLC_POPCOMPARETWOFILES)) && (this->m_CurrentVersion.IsEmpty() || this->m_CurrentVersion == GIT_REV_ZERO))
1950 {
1951 POSITION pos = GetFirstSelectedItemPosition();
1952 int index = GetNextSelectedItem(pos);
1953 if (index >= 0)
1954 {
1955 CTGitPath * entry2 = NULL;
1956 bool bothItemsAreExistingFiles = true;
1957 entry2 = (CTGitPath * )GetItemData(index);
1958 if (entry2)
1959 bothItemsAreExistingFiles = !entry2->IsDirectory() && entry2->Exists();
1960 index = GetNextSelectedItem(pos);
1961 if (index >= 0)
1962 {
1963 entry2 = (CTGitPath * )GetItemData(index);
1964 if (entry2)
1965 bothItemsAreExistingFiles = bothItemsAreExistingFiles && !entry2->IsDirectory() && entry2->Exists();
1966 if (bothItemsAreExistingFiles)
1967 popup.AppendMenuIcon(IDGITLC_COMPARETWOFILES, IDS_STATUSLIST_CONTEXT_COMPARETWOFILES, IDI_DIFF);
1968 }
1969 }
1970 }
1971 // if ((GetSelectedCount() == 2)&&(m_dwContextMenus & SVNSLC_POPREPAIRMOVE))
1972 // {
1973 // POSITION pos = GetFirstSelectedItemPosition();
1974 // int index = GetNextSelectedItem(pos);
1975 // if (index >= 0)
1976 // {
1977 // FileEntry * entry = GetListEntry(index);
1978 // git_wc_status_kind status1 = git_wc_status_none;
1979 // git_wc_status_kind status2 = git_wc_status_none;
1980 // if (entry)
1981 // status1 = entry->status;
1982 // index = GetNextSelectedItem(pos);
1983 // if (index >= 0)
1984 // {
1985 // entry = GetListEntry(index);
1986 // if (entry)
1987 // status2 = entry->status;
1988 // if ((status1 == git_wc_status_missing && status2 == git_wc_status_unversioned) ||
1989 // (status2 == git_wc_status_missing && status1 == git_wc_status_unversioned))
1990 // {
1991 // popup.AppendMenuIcon(IDSVNLC_REPAIRMOVE, IDS_STATUSLIST_CONTEXT_REPAIRMOVE);
1992 // }
1993 // }
1994 // }
1995 // }
1996 // if (wcStatus > git_wc_status_normal)
1997 // {
1998 // if (m_dwContextMenus & SVNSLC_POPREVERT)
1999 // {
2000 // // reverting missing folders is not possible
2001 // if (!entry->IsFolder() || (wcStatus != git_wc_status_missing))
2002 // {
2003 // popup.AppendMenuIcon(IDSVNLC_REVERT, IDS_MENUREVERT, IDI_REVERT);
2004 // }
2005 // }
2006 // }
2007 // if (entry->remotestatus > git_wc_status_normal)
2008 // {
2009 // if (m_dwContextMenus & SVNSLC_POPUPDATE)
2010 // {
2011 // popup.AppendMenuIcon(IDSVNLC_UPDATE, IDS_MENUUPDATE, IDI_UPDATE);
2012 // }
2013 // }
2014 }
2015
2016 if ( (GetSelectedCount() >0 ) && (!(wcStatus & CTGitPath::LOGACTIONS_UNVER)) && m_bHasWC)
2017 {
2018 if ((m_dwContextMenus & GITSLC_POPREVERT) && (this->m_CurrentVersion.IsEmpty() || this->m_CurrentVersion == GIT_REV_ZERO))
2019 {
2020 popup.AppendMenuIcon(IDGITLC_REVERT, IDS_MENUREVERT, IDI_REVERT);
2021 }
2022
2023 if (m_dwContextMenus & GITSLC_POPRESTORE && !filepath->IsDirectory())
2024 {
2025 if (m_restorepaths.find(filepath->GetWinPathString()) == m_restorepaths.end())
2026 popup.AppendMenuIcon(IDGITLC_CREATERESTORE, IDS_MENUCREATERESTORE, IDI_RESTORE);
2027 else
2028 popup.AppendMenuIcon(IDGITLC_RESTOREPATH, IDS_MENURESTORE, IDI_RESTORE);
2029 }
2030
2031 if ((m_dwContextMenus & GetContextMenuBit(IDGITLC_REVERTTOREV)) && ( !this->m_CurrentVersion.IsEmpty() )
2032 && this->m_CurrentVersion != GIT_REV_ZERO && !(wcStatus & CTGitPath::LOGACTIONS_DELETED))
2033 {
2034 popup.AppendMenuIcon(IDGITLC_REVERTTOREV, IDS_LOG_POPUP_REVERTTOREV, IDI_REVERT);
2035 }
2036 }
2037
2038 if ((GetSelectedCount() == 1)&&(!(wcStatus & CTGitPath::LOGACTIONS_UNVER))
2039 &&(!(wcStatus & CTGitPath::LOGACTIONS_IGNORE)))
2040 {
2041 if (m_dwContextMenus & GITSLC_POPSHOWLOG)
2042 {
2043 popup.AppendMenuIcon(IDGITLC_LOG, IDS_REPOBROWSE_SHOWLOG, IDI_LOG);
2044 }
2045 if (m_dwContextMenus & GITSLC_POPSHOWLOGOLDNAME && (wcStatus & (CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_COPY) && !filepath->GetGitOldPathString().IsEmpty()))
2046 {
2047 popup.AppendMenuIcon(IDGITLC_LOGOLDNAME, IDS_STATUSLIST_SHOWLOGOLDNAME, IDI_LOG);
2048 }
2049 if (m_dwContextMenus & GITSLC_POPBLAME && ! filepath->IsDirectory() && !(wcStatus & CTGitPath::LOGACTIONS_DELETED) && m_bHasWC)
2050 {
2051 popup.AppendMenuIcon(IDGITLC_BLAME, IDS_MENUBLAME, IDI_BLAME);
2052 }
2053 }
2054 // if ((wcStatus != git_wc_status_deleted)&&(wcStatus != git_wc_status_missing) && (GetSelectedCount() == 1))
2055 if ( (GetSelectedCount() == 1) )
2056 {
2057 if (m_dwContextMenus & this->GetContextMenuBit(IDGITLC_SAVEAS) && ! filepath->IsDirectory() && !(wcStatus & CTGitPath::LOGACTIONS_DELETED))
2058 {
2059 popup.AppendMenuIcon(IDGITLC_SAVEAS, IDS_LOG_POPUP_SAVE, IDI_SAVEAS);
2060 }
2061
2062 if (m_dwContextMenus & GITSLC_POPOPEN && ! filepath->IsDirectory() && !(wcStatus & CTGitPath::LOGACTIONS_DELETED))
2063 {
2064 popup.AppendMenuIcon(IDGITLC_VIEWREV, IDS_LOG_POPUP_VIEWREV);
2065 popup.AppendMenuIcon(IDGITLC_OPEN, IDS_REPOBROWSE_OPEN, IDI_OPEN);
2066 popup.AppendMenuIcon(IDGITLC_OPENWITH, IDS_LOG_POPUP_OPENWITH, IDI_OPEN);
2067 if (wcStatus &CTGitPath::LOGACTIONS_UNVER) {
2068 popup.SetDefaultItem(IDGITLC_OPEN, FALSE);
2069 }
2070 }
2071
2072 if (m_dwContextMenus & GITSLC_POPEXPLORE && !(wcStatus & CTGitPath::LOGACTIONS_DELETED) && m_bHasWC)
2073 {
2074 popup.AppendMenuIcon(IDGITLC_EXPLORE, IDS_STATUSLIST_CONTEXT_EXPLORE, IDI_EXPLORER);
2075 }
2076
2077 }
2078 if (GetSelectedCount() > 0)
2079 {
2080 // if (((wcStatus == git_wc_status_unversioned)||(wcStatus == git_wc_status_ignored))&&(m_dwContextMenus & SVNSLC_POPDELETE))
2081 // {
2082 // popup.AppendMenuIcon(IDSVNLC_DELETE, IDS_MENUREMOVE, IDI_DELETE);
2083 // }
2084 // 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))
2085 // {
2086 // if (bShift)
2087 // popup.AppendMenuIcon(IDGitLC_REMOVE, IDS_MENUREMOVEKEEP, IDI_DELETE);
2088 // else
2089 // popup.AppendMenuIcon(IDGitLC_REMOVE, IDS_MENUREMOVE, IDI_DELETE);
2090 // }
2091 if ((wcStatus & CTGitPath::LOGACTIONS_UNVER)/*||(wcStatus == git_wc_status_deleted)*/)
2092 {
2093 if (m_dwContextMenus & GITSLC_POPDELETE)
2094 {
2095 popup.AppendMenuIcon(IDGITLC_DELETE, IDS_MENUREMOVE, IDI_DELETE);
2096 }
2097 }
2098 if ( (wcStatus & CTGitPath::LOGACTIONS_UNVER || wcStatus & CTGitPath::LOGACTIONS_DELETED) )
2099 {
2100 if (m_dwContextMenus & GITSLC_POPIGNORE)
2101 {
2102
2103 CTGitPathList ignorelist;
2104 FillListOfSelectedItemPaths(ignorelist);
2105 //check if all selected entries have the same extension
2106 bool bSameExt = true;
2107 CString sExt;
2108 for (int i=0; i<ignorelist.GetCount(); ++i)
2109 {
2110 if (sExt.IsEmpty() && (i==0))
2111 sExt = ignorelist[i].GetFileExtension();
2112 else if (sExt.CompareNoCase(ignorelist[i].GetFileExtension())!=0)
2113 bSameExt = false;
2114 }
2115 if (bSameExt)
2116 {
2117 if (ignoreSubMenu.CreateMenu())
2118 {
2119 CString ignorepath;
2120 if (ignorelist.GetCount()==1)
2121 ignorepath = ignorelist[0].GetFileOrDirectoryName();
2122 else
2123 ignorepath.Format(IDS_MENUIGNOREMULTIPLE, ignorelist.GetCount());
2124 ignoreSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_IGNORE, ignorepath);
2125 ignorepath = _T("*")+sExt;
2126 ignoreSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDGITLC_IGNOREMASK, ignorepath);
2127 CString temp;
2128 temp.LoadString(IDS_MENUIGNORE);
2129 popup.InsertMenu((UINT)-1, MF_BYPOSITION | MF_POPUP, (UINT_PTR)ignoreSubMenu.m_hMenu, temp);
2130 }
2131 }
2132 else
2133 {
2134 CString temp;
2135 if (ignorelist.GetCount()==1)
2136 {
2137 temp.LoadString(IDS_MENUIGNORE);
2138 }
2139 else
2140 {
2141 temp.Format(IDS_MENUIGNOREMULTIPLE, ignorelist.GetCount());
2142 }
2143 popup.AppendMenuIcon(IDGITLC_IGNORE, temp, IDI_IGNORE);
2144 }
2145 }
2146 }
2147 }
2148
2149
2150
2151 if (GetSelectedCount() > 0)
2152 {
2153 popup.AppendMenu(MF_SEPARATOR);
2154 popup.AppendMenuIcon(IDGITLC_COPY, IDS_STATUSLIST_CONTEXT_COPY, IDI_COPYCLIP);
2155 popup.AppendMenuIcon(IDGITLC_COPYEXT, IDS_STATUSLIST_CONTEXT_COPYEXT, IDI_COPYCLIP);
2156 #if 0
2157 if ((m_dwContextMenus & SVNSLC_POPCHANGELISTS))
2158 &&(wcStatus != git_wc_status_unversioned)&&(wcStatus != git_wc_status_none))
2159 {
2160 popup.AppendMenu(MF_SEPARATOR);
2161 // changelist commands
2162 size_t numChangelists = GetNumberOfChangelistsInSelection();
2163 if (numChangelists > 0)
2164 {
2165 popup.AppendMenuIcon(IDSVNLC_REMOVEFROMCS, IDS_STATUSLIST_CONTEXT_REMOVEFROMCS);
2166 }
2167 if ((!entry->IsFolder())&&(changelistSubMenu.CreateMenu()))
2168 {
2169 CString temp;
2170 temp.LoadString(IDS_STATUSLIST_CONTEXT_CREATECS);
2171 changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_CREATECS, temp);
2172
2173 if (entry->changelist.Compare(SVNSLC_IGNORECHANGELIST))
2174 {
2175 changelistSubMenu.AppendMenu(MF_SEPARATOR);
2176 changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, IDSVNLC_CREATEIGNORECS, SVNSLC_IGNORECHANGELIST);
2177 }
2178
2179 if (m_changelists.size() > 0)
2180 {
2181 // find the changelist names
2182 bool bNeedSeparator = true;
2183 int cmdID = IDSVNLC_MOVETOCS;
2184 for (std::map<CString, int>::const_iterator it = m_changelists.begin(); it != m_changelists.end(); ++it)
2185 {
2186 if ((entry->changelist.Compare(it->first))&&(it->first.Compare(SVNSLC_IGNORECHANGELIST)))
2187 {
2188 if (bNeedSeparator)
2189 {
2190 changelistSubMenu.AppendMenu(MF_SEPARATOR);
2191 bNeedSeparator = false;
2192 }
2193 changelistSubMenu.AppendMenu(MF_STRING | MF_ENABLED, cmdID, it->first);
2194 cmdID++;
2195 }
2196 }
2197 }
2198 temp.LoadString(IDS_STATUSLIST_CONTEXT_MOVETOCS);
2199 popup.AppendMenu(MF_POPUP|MF_STRING, (UINT_PTR)changelistSubMenu.GetSafeHmenu(), temp);
2200 }
2201 }
2202 #endif
2203 }
2204
2205 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
2206
2207 m_bBlock = TRUE;
2208 AfxGetApp()->DoWaitCursor(1);
2209 //int iItemCountBeforeMenuCmd = GetItemCount();
2210 //bool bForce = false;
2211 switch (cmd)
2212 {
2213 case IDGITLC_VIEWREV:
2214 OpenFile(filepath, ALTERNATIVEEDITOR);
2215 break;
2216 case IDGITLC_OPEN:
2217 OpenFile(filepath,OPEN);
2218 break;
2219 case IDGITLC_OPENWITH:
2220 OpenFile(filepath,OPEN_WITH);
2221 break;
2222 case IDGITLC_EXPLORE:
2223 {
2224 ShellExecute(this->m_hWnd, _T("explore"), filepath->GetDirectory().GetWinPath(), NULL, NULL, SW_SHOW);
2225 }
2226 break;
2227 case IDGITLC_CREATERESTORE:
2228 {
2229 POSITION pos = GetFirstSelectedItemPosition();
2230 while (pos)
2231 {
2232 int index = GetNextSelectedItem(pos);
2233 CTGitPath * entry2 = (CTGitPath * )GetItemData(index);
2234 ASSERT(entry2 != NULL);
2235 if (entry2 == NULL)
2236 continue;
2237 if (m_restorepaths.find(entry2->GetWinPathString()) != m_restorepaths.end())
2238 continue;
2239 CTGitPath tempFile = CTempFiles::Instance().GetTempFilePath(false);
2240 if (CopyFile(g_Git.m_CurrentDir + _T("\\") + entry2->GetWinPathString(), tempFile.GetWinPath(), FALSE))
2241 {
2242 m_restorepaths[entry2->GetWinPathString()] = tempFile.GetWinPathString();
2243 SetItemState(index, INDEXTOOVERLAYMASK(OVL_RESTORE), LVIS_OVERLAYMASK);
2244 }
2245 }
2246 Invalidate();
2247 }
2248 break;
2249 case IDGITLC_RESTOREPATH:
2250 {
2251 if (CMessageBox::Show(m_hWnd, IDS_STATUSLIST_RESTOREPATH, IDS_APPNAME, 2, IDI_QUESTION, IDS_RESTOREBUTTON, IDS_ABORTBUTTON) == 2)
2252 break;
2253 POSITION pos = GetFirstSelectedItemPosition();
2254 while (pos)
2255 {
2256 int index = GetNextSelectedItem(pos);
2257 CTGitPath * entry2 = (CTGitPath * )GetItemData(index);
2258 ASSERT(entry2 != NULL);
2259 if (entry2 == NULL)
2260 continue;
2261 if (m_restorepaths.find(entry2->GetWinPathString()) == m_restorepaths.end())
2262 continue;
2263 if (CopyFile(m_restorepaths[entry2->GetWinPathString()], g_Git.m_CurrentDir + _T("\\") + entry2->GetWinPathString(), FALSE))
2264 {
2265 m_restorepaths.erase(entry2->GetWinPathString());
2266 SetItemState(index, 0, LVIS_OVERLAYMASK);
2267 }
2268 }
2269 Invalidate();
2270 }
2271 break;
2272 // Compare current version and work copy.
2273 case IDGITLC_COMPAREWC:
2274 {
2275 POSITION pos = GetFirstSelectedItemPosition();
2276 while ( pos )
2277 {
2278 int index = GetNextSelectedItem(pos);
2279 StartDiffWC(index);
2280 }
2281 }
2282 break;
2283 // Compare with base version. when current version is zero, compare workcopy and HEAD.
2284 case IDGITLC_COMPARE:
2285 {
2286 POSITION pos = GetFirstSelectedItemPosition();
2287 while ( pos )
2288 {
2289 int index = GetNextSelectedItem(pos);
2290 StartDiff(index);
2291 }
2292 }
2293 break;
2294 case IDGITLC_COMPARETWO:
2295 {
2296 POSITION pos = GetFirstSelectedItemPosition();
2297 while ( pos )
2298 {
2299 int index = GetNextSelectedItem(pos);
2300 StartDiffTwo(index);
2301 }
2302 }
2303 break;
2304 case IDGITLC_COMPARETWOFILES:
2305 {
2306 POSITION pos = GetFirstSelectedItemPosition();
2307 CTGitPath * firstfilepath = NULL, * secondfilepath = NULL;
2308 if (pos)
2309 {
2310 firstfilepath = (CTGitPath * )GetItemData(GetNextSelectedItem(pos));
2311 ASSERT(firstfilepath != NULL);
2312 if (firstfilepath == NULL)
2313 break;
2314
2315 secondfilepath = (CTGitPath * )GetItemData(GetNextSelectedItem(pos));
2316 ASSERT(secondfilepath != NULL);
2317 if (secondfilepath == NULL)
2318 break;
2319
2320 CString sCmd;
2321 sCmd.Format(_T("/command:diff /path:\"%s\" /path2:\"%s\" /hwnd:%ld"), firstfilepath->GetWinPath(), secondfilepath->GetWinPath(), (unsigned long)m_hWnd);
2322 CAppUtils::RunTortoiseProc(sCmd);
2323 }
2324 }
2325 break;
2326 case IDGITLC_GNUDIFF1:
2327 {
2328 // SVNDiff diff(NULL, this->m_hWnd, true);
2329 //
2330 // if (entry->remotestatus <= git_wc_status_normal)
2331 // CAppUtils::StartShowUnifiedDiff(m_hWnd, entry->path, SVNRev::REV_BASE, entry->path, SVNRev::REV_WC);
2332 // else
2333 // CAppUtils::StartShowUnifiedDiff(m_hWnd, entry->path, SVNRev::REV_WC, entry->path, SVNRev::REV_HEAD);
2334 if(m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)
2335 {
2336 CString fromwhere;
2337 if(m_amend)
2338 fromwhere = _T("~1");
2339 CAppUtils::StartShowUnifiedDiff(m_hWnd,*filepath,GitRev::GetHead()+fromwhere,
2340 *filepath,GitRev::GetWorkingCopy());
2341 }
2342 else
2343 {
2344 if((filepath->m_ParentNo&(PARENT_MASK|MERGE_MASK)) ==0)
2345 CAppUtils::StartShowUnifiedDiff(m_hWnd,*filepath,m_CurrentVersion+_T("~1"),
2346 *filepath,m_CurrentVersion);
2347 else
2348 {
2349 CString str;
2350 if(filepath->m_ParentNo & MERGE_MASK)
2351 {
2352 }
2353 else
2354 {
2355 str.Format(_T("%s^%d"),m_CurrentVersion,(filepath->m_ParentNo&PARENT_MASK)+1);
2356 }
2357
2358 CAppUtils::StartShowUnifiedDiff(m_hWnd,*filepath, str,
2359 *filepath, m_CurrentVersion, false, false, false,
2360 !!(filepath->m_ParentNo & MERGE_MASK));
2361 }
2362 }
2363 }
2364 break;
2365 case IDGITLC_GNUDIFF2:
2366 {
2367 CAppUtils::StartShowUnifiedDiff(m_hWnd, *filepath, m_Rev2, *filepath, m_Rev1);
2368 }
2369 break;
2370
2371 case IDGITLC_ADD:
2372 { // The add went ok, but we now need to run through the selected items again
2373 // and update their status
2374 std::vector<int> selectIndex;
2375
2376 POSITION pos = GetFirstSelectedItemPosition();
2377 int index;
2378 CMassiveGitTask mgt(L"add -f");
2379 while ((index = GetNextSelectedItem(pos)) >= 0)
2380 {
2381 CTGitPath * path = (CTGitPath *)GetItemData(index);
2382 ASSERT(path);
2383 if(path == NULL)
2384 continue;
2385
2386 selectIndex.push_back(index);
2387 mgt.AddFile(*path);
2388 }
2389 BOOL cancel = FALSE;
2390 mgt.Execute(cancel);
2391
2392 if (NULL != GetParent() && NULL != GetParent()->GetSafeHwnd())
2393 GetParent()->SendMessage(GITSLNM_NEEDSREFRESH);
2394
2395 SetRedraw(TRUE);
2396 }
2397 break;
2398
2399 case IDGITLC_DELETE:
2400 {
2401 //Collect paths
2402 std::vector<int> selectIndex;
2403
2404 POSITION pos = GetFirstSelectedItemPosition();
2405 int index;
2406 while ((index = GetNextSelectedItem(pos)) >= 0)
2407 {
2408 selectIndex.push_back(index);
2409 }
2410
2411 //Create file-list ('\0' separated) for SHFileOperation
2412 CString filelist;
2413 for(int i=0;i<selectIndex.size();i++)
2414 {
2415 index=selectIndex[i];
2416
2417 CTGitPath * path=(CTGitPath*)GetItemData(index);
2418 ASSERT(path);
2419 if(path == NULL)
2420 continue;
2421
2422 filelist += path->GetWinPathString();
2423 filelist += _T("|");
2424 }
2425 filelist += _T("|");
2426 int len = filelist.GetLength();
2427 TCHAR * buf = new TCHAR[len+2];
2428 _tcscpy_s(buf, len+2, filelist);
2429 for (int i=0; i<len; ++i)
2430 if (buf[i] == '|')
2431 buf[i] = 0;
2432 SHFILEOPSTRUCT fileop;
2433 fileop.hwnd = this->m_hWnd;
2434 fileop.wFunc = FO_DELETE;
2435 fileop.pFrom = buf;
2436 fileop.pTo = NULL;
2437 fileop.fFlags = FOF_NO_CONNECTED_ELEMENTS | ((GetAsyncKeyState(VK_SHIFT) & 0x8000) ? 0 : FOF_ALLOWUNDO);
2438 fileop.lpszProgressTitle = _T("deleting file");
2439 int result = SHFileOperation(&fileop);
2440 delete [] buf;
2441
2442 if ( (result==0) && (!fileop.fAnyOperationsAborted) )
2443 {
2444 SetRedraw(FALSE);
2445 POSITION pos = NULL;
2446 while ((pos = GetFirstSelectedItemPosition()) != 0)
2447 {
2448 int index = GetNextSelectedItem(pos);
2449 if (GetCheck(index))
2450 m_nSelected--;
2451 m_nTotal--;
2452
2453 RemoveListEntry(index);
2454 }
2455 SetRedraw(TRUE);
2456 }
2457 }
2458 break;
2459
2460 case IDGITLC_BLAME:
2461 {
2462 CAppUtils::LaunchTortoiseBlame(g_Git.m_CurrentDir+_T("\\")+filepath->GetWinPath(), m_CurrentVersion);
2463 }
2464 break;
2465
2466 case IDGITLC_LOG:
2467 {
2468 CString sCmd;
2469 sCmd.Format(_T("/command:log /path:\"%s\""), g_Git.m_CurrentDir + _T("\\") + filepath->GetWinPath());
2470 CAppUtils::RunTortoiseProc(sCmd);
2471 }
2472 break;
2473
2474 case IDGITLC_LOGOLDNAME:
2475 {
2476 CTGitPath oldName(filepath->GetGitOldPathString());
2477 CString sCmd;
2478 sCmd.Format(_T("/command:log /path:\"%s\""), g_Git.m_CurrentDir + _T("\\") + oldName.GetWinPath());
2479 CAppUtils::RunTortoiseProc(sCmd);
2480 }
2481 break;
2482
2483
2484 case IDGITLC_EDITCONFLICT:
2485 {
2486 CAppUtils::ConflictEdit(*filepath,false,this->m_bIsRevertTheirMy);
2487 break;
2488 }
2489 case IDGITLC_RESOLVETHEIRS: //follow up
2490 case IDGITLC_RESOLVEMINE: //follow up
2491 case IDGITLC_RESOLVECONFLICT:
2492 {
2493 if (CMessageBox::Show(m_hWnd, IDS_PROC_RESOLVE, IDS_APPNAME, MB_ICONQUESTION | MB_YESNO)==IDYES)
2494 {
2495 POSITION pos = GetFirstSelectedItemPosition();
2496 while (pos != 0)
2497 {
2498 int index;
2499 index = GetNextSelectedItem(pos);
2500 CTGitPath * fentry =(CTGitPath*) this->GetItemData(index);
2501 if(fentry == NULL)
2502 continue;
2503 CString gitcmd,output;
2504 output.Empty();
2505
2506 if ( ((!this->m_bIsRevertTheirMy)&&cmd == IDGITLC_RESOLVETHEIRS) ||
2507 ((this->m_bIsRevertTheirMy)&&cmd == IDGITLC_RESOLVEMINE) )
2508 {
2509 gitcmd.Format(_T("git.exe checkout-index -f --stage=3 -- \"%s\""),fentry->GetGitPathString());
2510 if (g_Git.Run(gitcmd, &output,CP_UTF8))
2511 {
2512 CMessageBox::Show(m_hWnd, output, _T("TortoiseGit"), MB_ICONERROR);
2513 continue;
2514 }
2515 }
2516 output.Empty();
2517 if ( ((!this->m_bIsRevertTheirMy)&&cmd == IDGITLC_RESOLVEMINE) ||
2518 ((this->m_bIsRevertTheirMy)&&cmd == IDGITLC_RESOLVETHEIRS) )
2519 {
2520 gitcmd.Format(_T("git.exe checkout-index -f --stage=2 -- \"%s\""),fentry->GetGitPathString());
2521 if (g_Git.Run(gitcmd, &output,CP_UTF8))
2522 {
2523 CMessageBox::Show(m_hWnd, output, _T("TortoiseGit"), MB_ICONERROR);
2524 continue;
2525 }
2526
2527 }
2528 output.Empty();
2529 if ( fentry->m_Action & CTGitPath::LOGACTIONS_UNMERGED)
2530 {
2531 gitcmd.Format(_T("git.exe add -f -- \"%s\""),fentry->GetGitPathString());
2532 if (g_Git.Run(gitcmd, &output,CP_UTF8))
2533 {
2534 CMessageBox::Show(m_hWnd, output, _T("TortoiseGit"), MB_ICONERROR);
2535 }
2536 else
2537 {
2538 fentry->m_Action |= CTGitPath::LOGACTIONS_MODIFIED;
2539 fentry->m_Action &=~CTGitPath::LOGACTIONS_UNMERGED;
2540 }
2541 }
2542
2543 CAppUtils::RemoveTempMergeFile(*fentry);
2544
2545 }
2546 Show(m_dwShow, 0, m_bShowFolders,0,true);
2547 }
2548 }
2549 break;
2550
2551 case IDGITLC_IGNORE:
2552 {
2553 CTGitPathList ignorelist;
2554 //std::vector<CString> toremove;
2555 FillListOfSelectedItemPaths(ignorelist, true);
2556 SetRedraw(FALSE);
2557
2558 if(!CAppUtils::IgnoreFile(ignorelist,false))
2559 break;
2560
2561 for(int i=0;i<ignorelist.GetCount();i++)
2562 {
2563 int nListboxEntries = GetItemCount();
2564 for (int nItem=0; nItem<nListboxEntries; ++nItem)
2565 {
2566 CTGitPath *path=(CTGitPath*)GetItemData(nItem);
2567 if (path->GetGitPathString()==ignorelist[i].GetGitPathString())
2568 {
2569 RemoveListEntry(nItem);
2570 break;
2571 }
2572 }
2573 }
2574 SetRedraw(TRUE);
2575 }
2576 #if 0
2577 CTSVNPathList ignorelist;
2578 std::vector<CString> toremove;
2579 FillListOfSelectedItemPaths(ignorelist, true);
2580 SetRedraw(FALSE);
2581 for (int j=0; j<ignorelist.GetCount(); ++j)
2582 {
2583 int nListboxEntries = GetItemCount();
2584 for (int i=0; i<nListboxEntries; ++i)
2585 {
2586 if (GetListEntry(i)->GetPath().IsEquivalentTo(ignorelist[j]))
2587 {
2588 selIndex = i;
2589 break;
2590 }
2591 }
2592 CString name = CPathUtils::PathPatternEscape(ignorelist[j].GetFileOrDirectoryName());
2593 CTSVNPath parentfolder = ignorelist[j].GetContainingDirectory();
2594 SVNProperties props(parentfolder, SVNRev::REV_WC, false);
2595 CStringA value;
2596 for (int i=0; i<props.GetCount(); i++)
2597 {
2598 CString propname(props.GetItemName(i).c_str());
2599 if (propname.CompareNoCase(_T("git:ignore"))==0)
2600 {
2601 stdstring stemp;
2602 // treat values as normal text even if they're not
2603 value = (char *)props.GetItemValue(i).c_str();
2604 }
2605 }
2606 if (value.IsEmpty())
2607 value = name;
2608 else
2609 {
2610 value = value.Trim("\n\r");
2611 value += "\n";
2612 value += name;
2613 value.Remove('\r');
2614 }
2615 if (!props.Add(_T("git:ignore"), (LPCSTR)value))
2616 {
2617 CString temp;
2618 temp.Format(IDS_ERR_FAILEDIGNOREPROPERTY, (LPCTSTR)name);
2619 CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);
2620 break;
2621 }
2622 if (GetCheck(selIndex))
2623 m_nSelected--;
2624 m_nTotal--;
2625
2626 // now, if we ignored a folder, remove all its children
2627 if (ignorelist[j].IsDirectory())
2628 {
2629 for (int i=0; i<(int)m_arListArray.size(); ++i)
2630 {
2631 FileEntry * entry = GetListEntry(i);
2632 if (entry->status == git_wc_status_unversioned)
2633 {
2634 if (!ignorelist[j].IsEquivalentTo(entry->GetPath())&&(ignorelist[j].IsAncestorOf(entry->GetPath())))
2635 {
2636 entry->status = git_wc_status_ignored;
2637 entry->textstatus = git_wc_status_ignored;
2638 if (GetCheck(i))
2639 m_nSelected--;
2640 toremove.push_back(entry->GetPath().GetSVNPathString());
2641 }
2642 }
2643 }
2644 }
2645
2646 CTSVNPath basepath = m_arStatusArray[m_arListArray[selIndex]]->basepath;
2647
2648 FileEntry * entry = m_arStatusArray[m_arListArray[selIndex]];
2649 if ( entry->status == git_wc_status_unversioned ) // keep "deleted" items
2650 toremove.push_back(entry->GetPath().GetSVNPathString());
2651
2652 if (!m_bIgnoreRemoveOnly)
2653 {
2654 SVNStatus status;
2655 git_wc_status2_t * s;
2656 CTSVNPath gitPath;
2657 s = status.GetFirstFileStatus(parentfolder, gitPath, false, git_depth_empty);
2658 // first check if the folder isn't already present in the list
2659 bool bFound = false;
2660 nListboxEntries = GetItemCount();
2661 for (int i=0; i<nListboxEntries; ++i)
2662 {
2663 FileEntry * entry = GetListEntry(i);
2664 if (entry->path.IsEquivalentTo(gitPath))
2665 {
2666 bFound = true;
2667 break;
2668 }
2669 }
2670 if (!bFound)
2671 {
2672 if (s!=0)
2673 {
2674 FileEntry * entry = new FileEntry();
2675 entry->path = gitPath;
2676 entry->basepath = basepath;
2677 entry->status = SVNStatus::GetMoreImportant(s->text_status, s->prop_status);
2678 entry->textstatus = s->text_status;
2679 entry->propstatus = s->prop_status;
2680 entry->remotestatus = SVNStatus::GetMoreImportant(s->repos_text_status, s->repos_prop_status);
2681 entry->remotetextstatus = s->repos_text_status;
2682 entry->remotepropstatus = s->repos_prop_status;
2683 entry->inunversionedfolder = FALSE;
2684 entry->checked = true;
2685 entry->inexternal = false;
2686 entry->direct = false;
2687 entry->isfolder = true;
2688 entry->last_commit_date = 0;
2689 entry->last_commit_rev = 0;
2690 entry->remoterev = 0;
2691 if (s->entry)
2692 {
2693 if (s->entry->url)
2694 {
2695 entry->url = CUnicodeUtils::GetUnicode(CPathUtils::PathUnescape(s->entry->url));
2696 }
2697 }
2698 if (s->entry && s->entry->present_props)
2699 {
2700 entry->present_props = s->entry->present_props;
2701 }
2702 m_arStatusArray.push_back(entry);
2703 m_arListArray.push_back(m_arStatusArray.size()-1);
2704 AddEntry(entry, langID, GetItemCount());
2705 }
2706 }
2707 }
2708 }
2709 for (std::vector<CString>::iterator it = toremove.begin(); it != toremove.end(); ++it)
2710 {
2711 int nListboxEntries = GetItemCount();
2712 for (int i=0; i<nListboxEntries; ++i)
2713 {
2714 if (GetListEntry(i)->path.GetSVNPathString().Compare(*it)==0)
2715 {
2716 RemoveListEntry(i);
2717 break;
2718 }
2719 }
2720 }
2721 SetRedraw(TRUE);
2722 }
2723 #endif
2724 break;
2725 case IDGITLC_IGNOREMASK:
2726 {
2727 CString common;
2728 CString ext=filepath->GetFileExtension();
2729 CTGitPathList ignorelist;
2730 FillListOfSelectedItemPaths(ignorelist, true);
2731 SetRedraw(FALSE);
2732
2733 CAppUtils::IgnoreFile(ignorelist,true);
2734
2735 common=ignorelist.GetCommonRoot().GetGitPathString();
2736
2737 for (int i=0; i< GetItemCount(); ++i)
2738 {
2739 CTGitPath *path=(CTGitPath*)GetItemData(i);
2740 if(!( path->m_Action & CTGitPath::LOGACTIONS_UNVER))
2741 continue;
2742 if( path->GetGitPathString().Left(common.GetLength()) == common )
2743 {
2744 if (path->GetFileExtension()==ext)
2745 {
2746 RemoveListEntry(i);
2747 i--; // remove index i at item, new one will replace.
2748 }
2749 }
2750 }
2751
2752 CWnd* pParent = GetParent();
2753 if (NULL != pParent && NULL != pParent->GetSafeHwnd())
2754 {
2755 pParent->SendMessage(GITSLNM_NEEDSREFRESH);
2756 }
2757
2758 SetRedraw(TRUE);
2759 }
2760 #if 0
2761 std::set<CTSVNPath> parentlist;
2762 for (int i=0; i<ignorelist.GetCount(); ++i)
2763 {
2764 parentlist.insert(ignorelist[i].GetContainingDirectory());
2765 }
2766 std::set<CTSVNPath>::iterator it;
2767 std::vector<CString> toremove;
2768
2769 for (it = parentlist.begin(); it != parentlist.end(); ++it)
2770 {
2771 CTSVNPath parentFolder = (*it).GetDirectory();
2772 SVNProperties props(parentFolder, SVNRev::REV_WC, false);
2773 CStringA value;
2774 for (int i=0; i<props.GetCount(); i++)
2775 {
2776 CString propname(props.GetItemName(i).c_str());
2777 if (propname.CompareNoCase(_T("git:ignore"))==0)
2778 {
2779 stdstring stemp;
2780 // treat values as normal text even if they're not
2781 value = (char *)props.GetItemValue(i).c_str();
2782 }
2783 }
2784 if (value.IsEmpty())
2785 value = name;
2786 else
2787 {
2788 value = value.Trim("\n\r");
2789 value += "\n";
2790 value += name;
2791 value.Remove('\r');
2792 }
2793 if (!props.Add(_T("git:ignore"), (LPCSTR)value))
2794 {
2795 CString temp;
2796 temp.Format(IDS_ERR_FAILEDIGNOREPROPERTY, (LPCTSTR)name);
2797 CMessageBox::Show(this->m_hWnd, temp, _T("TortoiseGit"), MB_ICONERROR);
2798 }
2799 else
2800 {
2801 CTSVNPath basepath;
2802 int nListboxEntries = GetItemCount();
2803 for (int i=0; i<nListboxEntries; ++i)
2804 {
2805 FileEntry * entry = GetListEntry(i);
2806 ASSERT(entry != NULL);
2807 if (entry == NULL)
2808 continue;
2809 if (basepath.IsEmpty())
2810 basepath = entry->basepath;
2811 // since we ignored files with a mask (e.g. *.exe)
2812 // we have to find find all files in the same
2813 // folder (IsAncestorOf() returns TRUE for _all_ children,
2814 // not just the immediate ones) which match the
2815 // mask and remove them from the list too.
2816 if ((entry->status == git_wc_status_unversioned)&&(parentFolder.IsAncestorOf(entry->path)))
2817 {
2818 CString f = entry->path.GetSVNPathString();
2819 if (f.Mid(parentFolder.GetSVNPathString().GetLength()).Find('/')<=0)
2820 {
2821 if (CStringUtils::WildCardMatch(name, f))
2822 {
2823 if (GetCheck(i))
2824 m_nSelected--;
2825 m_nTotal--;
2826 toremove.push_back(f);
2827 }
2828 }
2829 }
2830 }
2831 if (!m_bIgnoreRemoveOnly)
2832 {
2833 SVNStatus status;
2834 git_wc_status2_t * s;
2835 CTSVNPath gitPath;
2836 s = status.GetFirstFileStatus(parentFolder, gitPath, false, git_depth_empty);
2837 if (s!=0)
2838 {
2839 // first check if the folder isn't already present in the list
2840 bool bFound = false;
2841 for (int i=0; i<nListboxEntries; ++i)
2842 {
2843 FileEntry * entry = GetListEntry(i);
2844 if (entry->path.IsEquivalentTo(gitPath))
2845 {
2846 bFound = true;
2847 break;
2848 }
2849 }
2850 if (!bFound)
2851 {
2852 FileEntry * entry = new FileEntry();
2853 entry->path = gitPath;
2854 entry->basepath = basepath;
2855 entry->status = SVNStatus::GetMoreImportant(s->text_status, s->prop_status);
2856 entry->textstatus = s->text_status;
2857 entry->propstatus = s->prop_status;
2858 entry->remotestatus = SVNStatus::GetMoreImportant(s->repos_text_status, s->repos_prop_status);
2859 entry->remotetextstatus = s->repos_text_status;
2860 entry->remotepropstatus = s->repos_prop_status;
2861 entry->inunversionedfolder = false;
2862 entry->checked = true;
2863 entry->inexternal = false;
2864 entry->direct = false;
2865 entry->isfolder = true;
2866 entry->last_commit_date = 0;
2867 entry->last_commit_rev = 0;
2868 entry->remoterev = 0;
2869 if (s->entry)
2870 {
2871 if (s->entry->url)
2872 {
2873 entry->url = CUnicodeUtils::GetUnicode(CPathUtils::PathUnescape(s->entry->url));
2874 }
2875 }
2876 if (s->entry && s->entry->present_props)
2877 {
2878 entry->present_props = s->entry->present_props;
2879 }
2880 m_arStatusArray.push_back(entry);
2881 m_arListArray.push_back(m_arStatusArray.size()-1);
2882 AddEntry(entry, langID, GetItemCount());
2883 }
2884 }
2885 }
2886 }
2887 }
2888 for (std::vector<CString>::iterator it = toremove.begin(); it != toremove.end(); ++it)
2889 {
2890 int nListboxEntries = GetItemCount();
2891 for (int i=0; i<nListboxEntries; ++i)
2892 {
2893 if (GetListEntry(i)->path.GetSVNPathString().Compare(*it)==0)
2894 {
2895 RemoveListEntry(i);
2896 break;
2897 }
2898 }
2899 }
2900 SetRedraw(TRUE);
2901 }
2902 #endif
2903 break;
2904
2905 case IDGITLC_REVERT:
2906 {
2907 // If at least one item is not in the status "added"
2908 // we ask for a confirmation
2909 BOOL bConfirm = FALSE;
2910 POSITION pos = GetFirstSelectedItemPosition();
2911 int index;
2912 while ((index = GetNextSelectedItem(pos)) >= 0)
2913 {
2914 //FileEntry * fentry = GetListEntry(index);
2915 CTGitPath *fentry=(CTGitPath*)GetItemData(index);
2916 if(fentry && fentry->m_Action &CTGitPath::LOGACTIONS_MODIFIED )
2917 {
2918 bConfirm = TRUE;
2919 break;
2920 }
2921 }
2922
2923 CString str;
2924 str.Format(IDS_PROC_WARNREVERT,GetSelectedCount());
2925
2926 if (!bConfirm || CMessageBox::Show(this->m_hWnd, str, _T("TortoiseGit"), MB_YESNO | MB_ICONQUESTION)==IDYES)
2927 {
2928 CTGitPathList targetList;
2929 FillListOfSelectedItemPaths(targetList);
2930
2931 // make sure that the list is reverse sorted, so that
2932 // children are removed before any parents
2933 targetList.SortByPathname(true);
2934
2935 // put all reverted files in the trashbin, except the ones with 'added'
2936 // status because they are not restored by the revert.
2937 CTGitPathList delList;
2938 POSITION pos = GetFirstSelectedItemPosition();
2939 int index;
2940 while ((index = GetNextSelectedItem(pos)) >= 0)
2941 {
2942 CTGitPath *entry=(CTGitPath *)GetItemData(index);
2943 if (entry&&(!(entry->m_Action& CTGitPath::LOGACTIONS_ADDED))
2944 && (!(entry->m_Action& CTGitPath::LOGACTIONS_REPLACED)))
2945 {
2946 CTGitPath fullpath;
2947 fullpath.SetFromWin(g_Git.m_CurrentDir+_T("\\")+entry->GetWinPath());
2948 delList.AddPath(fullpath);
2949 }
2950 }
2951 if (DWORD(CRegDWORD(_T("Software\\TortoiseGit\\RevertWithRecycleBin"), TRUE)))
2952 delList.DeleteAllFiles(true);
2953
2954 CString revertToCommit = _T("HEAD");
2955 if (m_amend)
2956 revertToCommit = _T("HEAD~1");
2957 if (g_Git.Revert(revertToCommit, targetList))
2958 {
2959 CMessageBox::Show(this->m_hWnd, _T("Revert Fail"), _T("TortoiseGit"), MB_ICONERROR);
2960 }
2961 else
2962 {
2963 bool updateStatusList = false;
2964 for(int i=0;i<targetList.GetCount();i++)
2965 {
2966 int nListboxEntries = GetItemCount();
2967 for (int nItem=0; nItem<nListboxEntries; ++nItem)
2968 {
2969 CTGitPath *path=(CTGitPath*)GetItemData(nItem);
2970 if (path->GetGitPathString()==targetList[i].GetGitPathString())
2971 {
2972 if(path->m_Action & CTGitPath::LOGACTIONS_ADDED)
2973 {
2974 path->m_Action = CTGitPath::LOGACTIONS_UNVER;
2975 SetEntryCheck(path,nItem,false);
2976 updateStatusList = true;
2977 SetItemGroup(nItem,1);
2978 this->m_StatusFileList.RemoveItem(*path);
2979 this->m_UnRevFileList.AddPath(*path);
2980 //this->m_IgnoreFileList.RemoveItem(*path);
2981
2982 }
2983 else
2984 {
2985 RemoveListEntry(nItem);
2986 }
2987 break;
2988 }
2989 }
2990 }
2991 SetRedraw(TRUE);
2992 SaveColumnWidths();
2993 Show(m_dwShow, 0, m_bShowFolders,updateStatusList,true);
2994 NotifyCheck();
2995 }
2996 }
2997 }
2998 break;
2999
3000 case IDGITLC_COPY:
3001 CopySelectedEntriesToClipboard(0);
3002 break;
3003 case IDGITLC_COPYEXT:
3004 CopySelectedEntriesToClipboard((DWORD)-1);
3005 break;
3006
3007 case IDGITLC_SAVEAS:
3008 FileSaveAs(filepath);
3009 break;
3010
3011 case IDGITLC_REVERTTOREV:
3012 RevertSelectedItemToVersion();
3013 break;
3014 #if 0
3015 case IDSVNLC_PROPERTIES:
3016 {
3017 CTSVNPathList targetList;
3018 FillListOfSelectedItemPaths(targetList);
3019 CEditPropertiesDlg dlg;
3020 dlg.SetPathList(targetList);
3021 dlg.DoModal();
3022 if (dlg.HasChanged())
3023 {
3024 // since the user might have changed/removed/added
3025 // properties recursively, we don't really know
3026 // which items have changed their status.
3027 // So tell the parent to do a refresh.
3028 CWnd* pParent = GetParent();
3029 if (NULL != pParent && NULL != pParent->GetSafeHwnd())
3030 {
3031 pParent->SendMessage(SVNSLNM_NEEDSREFRESH);
3032 }
3033 }
3034 }
3035 break;
3036 case IDSVNLC_COMMIT:
3037 {
3038 CTSVNPathList targetList;
3039 FillListOfSelectedItemPaths(targetList);
3040 CTSVNPath tempFile = CTempFiles::Instance().GetTempFilePath(false);
3041 VERIFY(targetList.WriteToFile(tempFile.GetWinPathString()));
3042 CString commandline = CPathUtils::GetAppDirectory();
3043 commandline += _T("TortoiseProc.exe /command:commit /pathfile:\"");
3044 commandline += tempFile.GetWinPathString();
3045 commandline += _T("\"");
3046 commandline += _T(" /deletepathfile");
3047 CAppUtils::LaunchApplication(commandline, NULL, false);
3048 }
3049 break;
3050
3051 case IDSVNLC_COMPAREWC:
3052 {
3053 POSITION pos = GetFirstSelectedItemPosition();
3054 while ( pos )
3055 {
3056 int index = GetNextSelectedItem(pos);
3057 FileEntry * entry = GetListEntry(index);
3058 ASSERT(entry != NULL);
3059 if (entry == NULL)
3060 continue;
3061 SVNDiff diff(NULL, m_hWnd, true);
3062 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
3063 git_revnum_t baseRev = entry->Revision;
3064 diff.DiffFileAgainstBase(
3065 entry->path, baseRev, entry->textstatus, entry->propstatus);
3066 }
3067 }
3068 break;
3069 case IDSVNLC_GNUDIFF1:
3070 {
3071 SVNDiff diff(NULL, this->m_hWnd, true);
3072
3073 if (entry->remotestatus <= git_wc_status_normal)
3074 CAppUtils::StartShowUnifiedDiff(m_hWnd, entry->path, SVNRev::REV_BASE, entry->path, SVNRev::REV_WC);
3075 else
3076 CAppUtils::StartShowUnifiedDiff(m_hWnd, entry->path, SVNRev::REV_WC, entry->path, SVNRev::REV_HEAD);
3077 }
3078 break;
3079 case IDSVNLC_UPDATE:
3080 {
3081 CTSVNPathList targetList;
3082 FillListOfSelectedItemPaths(targetList);
3083 bool bAllExist = true;
3084 for (int i=0; i<targetList.GetCount(); ++i)
3085 {
3086 if (!targetList[i].Exists())
3087 {
3088 bAllExist = false;
3089 break;
3090 }
3091 }
3092 if (bAllExist)
3093 {
3094 CSVNProgressDlg dlg;
3095 dlg.SetCommand(CSVNProgressDlg::SVNProgress_Update);
3096 dlg.SetPathList(targetList);
3097 dlg.SetRevision(SVNRev::REV_HEAD);
3098 dlg.DoModal();
3099 }
3100 else
3101 {
3102 CString sTempFile = CTempFiles::Instance().GetTempFilePath(false).GetWinPathString();
3103 targetList.WriteToFile(sTempFile, false);
3104 CString sCmd;
3105 sCmd.Format(_T("\"%s\" /command:update /rev /pathfile:\"%s\" /deletepathfile"),
3106 (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseProc.exe")), (LPCTSTR)sTempFile);
3107
3108 CAppUtils::LaunchApplication(sCmd, NULL, false);
3109 }
3110 }
3111 break;
3112
3113 case IDSVNLC_REMOVE:
3114 {
3115 SVN git;
3116 CTSVNPathList itemsToRemove;
3117 FillListOfSelectedItemPaths(itemsToRemove);
3118
3119 // We must sort items before removing, so that files are always removed
3120 // *before* their parents
3121 itemsToRemove.SortByPathname(true);
3122
3123 bool bSuccess = false;
3124 if (git.Remove(itemsToRemove, FALSE, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000)))
3125 {
3126 bSuccess = true;
3127 }
3128 else
3129 {
3130 if ((git.Err->apr_err == SVN_ERR_UNVERSIONED_RESOURCE) ||
3131 (git.Err->apr_err == SVN_ERR_CLIENT_MODIFIED))
3132 {
3133 CString msg, yes, no, yestoall;
3134 msg.Format(IDS_PROC_REMOVEFORCE, (LPCTSTR)git.GetLastErrorMessage());
3135 yes.LoadString(IDS_MSGBOX_YES);
3136 no.LoadString(IDS_MSGBOX_NO);
3137 yestoall.LoadString(IDS_PROC_YESTOALL);
3138 UINT ret = CMessageBox::Show(m_hWnd, msg, _T("TortoiseGit"), 2, IDI_ERROR, yes, no, yestoall);
3139 if ((ret == 1)||(ret==3))
3140 {
3141 if (!git.Remove(itemsToRemove, TRUE, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000)))
3142 {
3143 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
3144 }
3145 else
3146 bSuccess = true;
3147 }
3148 }
3149 else
3150 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
3151 }
3152 if (bSuccess)
3153 {
3154 // The remove went ok, but we now need to run through the selected items again
3155 // and update their status
3156 POSITION pos = GetFirstSelectedItemPosition();
3157 int index;
3158 std::vector<int> entriesToRemove;
3159 while ((index = GetNextSelectedItem(pos)) >= 0)
3160 {
3161 FileEntry * e = GetListEntry(index);
3162 if (!bShift &&
3163 ((e->textstatus == git_wc_status_unversioned)||
3164 (e->textstatus == git_wc_status_none)||
3165 (e->textstatus == git_wc_status_ignored)))
3166 {
3167 if (GetCheck(index))
3168 m_nSelected--;
3169 m_nTotal--;
3170 entriesToRemove.push_back(index);
3171 }
3172 else
3173 {
3174 e->textstatus = git_wc_status_deleted;
3175 e->status = git_wc_status_deleted;
3176 SetEntryCheck(e,index,true);
3177 }
3178 }
3179 for (std::vector<int>::reverse_iterator it = entriesToRemove.rbegin(); it != entriesToRemove.rend(); ++it)
3180 {
3181 RemoveListEntry(*it);
3182 }
3183 }
3184 SaveColumnWidths();
3185 Show(m_dwShow, 0, m_bShowFolders);
3186 NotifyCheck();
3187 }
3188 break;
3189 case IDSVNLC_DELETE:
3190 {
3191 CTSVNPathList pathlist;
3192 FillListOfSelectedItemPaths(pathlist);
3193 pathlist.RemoveChildren();
3194 CString filelist;
3195 for (INT_PTR i=0; i<pathlist.GetCount(); ++i)
3196 {
3197 filelist += pathlist[i].GetWinPathString();
3198 filelist += _T("|");
3199 }
3200 filelist += _T("|");
3201 int len = filelist.GetLength();
3202 TCHAR * buf = new TCHAR[len+2];
3203 _tcscpy_s(buf, len+2, filelist);
3204 for (int i=0; i<len; ++i)
3205 if (buf[i] == '|')
3206 buf[i] = 0;
3207 SHFILEOPSTRUCT fileop;
3208 fileop.hwnd = this->m_hWnd;
3209 fileop.wFunc = FO_DELETE;
3210 fileop.pFrom = buf;
3211 fileop.pTo = NULL;
3212 fileop.fFlags = FOF_NO_CONNECTED_ELEMENTS | ((GetAsyncKeyState(VK_SHIFT) & 0x8000) ? 0 : FOF_ALLOWUNDO);
3213 fileop.lpszProgressTitle = _T("deleting file");
3214 int result = SHFileOperation(&fileop);
3215 delete [] buf;
3216
3217 if ( (result==0) && (!fileop.fAnyOperationsAborted) )
3218 {
3219 SetRedraw(FALSE);
3220 POSITION pos = NULL;
3221 CTSVNPathList deletedlist; // to store list of deleted folders
3222 while ((pos = GetFirstSelectedItemPosition()) != 0)
3223 {
3224 int index = GetNextSelectedItem(pos);
3225 if (GetCheck(index))
3226 m_nSelected--;
3227 m_nTotal--;
3228 FileEntry * fentry = GetListEntry(index);
3229 if ((fentry)&&(fentry->isfolder))
3230 deletedlist.AddPath(fentry->path);
3231 RemoveListEntry(index);
3232 }
3233 // now go through the list of deleted folders
3234 // and remove all their children from the list too!
3235 int nListboxEntries = GetItemCount();
3236 for (int folderindex = 0; folderindex < deletedlist.GetCount(); ++folderindex)
3237 {
3238 CTSVNPath folderpath = deletedlist[folderindex];
3239 for (int i=0; i<nListboxEntries; ++i)
3240 {
3241 FileEntry * entry = GetListEntry(i);
3242 if (folderpath.IsAncestorOf(entry->path))
3243 {
3244 RemoveListEntry(i--);
3245 nListboxEntries--;
3246 }
3247 }
3248 }
3249 SetRedraw(TRUE);
3250 }
3251 }
3252 break;
3253
3254
3255 case IDSVNLC_ADD:
3256 {
3257 SVN git;
3258 CTSVNPathList itemsToAdd;
3259 FillListOfSelectedItemPaths(itemsToAdd);
3260
3261 // We must sort items before adding, so that folders are always added
3262 // *before* any of their children
3263 itemsToAdd.SortByPathname();
3264
3265 ProjectProperties props;
3266 props.ReadPropsPathList(itemsToAdd);
3267 if (git.Add(itemsToAdd, &props, git_depth_empty, TRUE, TRUE, TRUE))
3268 {
3269 // The add went ok, but we now need to run through the selected items again
3270 // and update their status
3271 POSITION pos = GetFirstSelectedItemPosition();
3272 int index;
3273 while ((index = GetNextSelectedItem(pos)) >= 0)
3274 {
3275 FileEntry * e = GetListEntry(index);
3276 e->textstatus = git_wc_status_added;
3277 e->propstatus = git_wc_status_none;
3278 e->status = git_wc_status_added;
3279 SetEntryCheck(e,index,true);
3280 }
3281 }
3282 else
3283 {
3284 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
3285 }
3286 SaveColumnWidths();
3287 Show(m_dwShow, 0, m_bShowFolders);
3288 NotifyCheck();
3289 }
3290 break;
3291 case IDSVNLC_ADD_RECURSIVE:
3292 {
3293 CTSVNPathList itemsToAdd;
3294 FillListOfSelectedItemPaths(itemsToAdd);
3295
3296 CAddDlg dlg;
3297 dlg.m_pathList = itemsToAdd;
3298 if (dlg.DoModal() == IDOK)
3299 {
3300 if (dlg.m_pathList.GetCount() == 0)
3301 break;
3302 CSVNProgressDlg progDlg;
3303 progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Add);
3304 progDlg.SetPathList(dlg.m_pathList);
3305 ProjectProperties props;
3306 props.ReadPropsPathList(dlg.m_pathList);
3307 progDlg.SetProjectProperties(props);
3308 progDlg.SetItemCount(dlg.m_pathList.GetCount());
3309 progDlg.DoModal();
3310
3311 // refresh!
3312 CWnd* pParent = GetParent();
3313 if (NULL != pParent && NULL != pParent->GetSafeHwnd())
3314 {
3315 pParent->SendMessage(SVNSLNM_NEEDSREFRESH);
3316 }
3317 }
3318 }
3319 break;
3320
3321 case IDSVNLC_REPAIRMOVE:
3322 {
3323 POSITION pos = GetFirstSelectedItemPosition();
3324 int index = GetNextSelectedItem(pos);
3325 FileEntry * entry1 = NULL;
3326 FileEntry * entry2 = NULL;
3327 if (index >= 0)
3328 {
3329 entry1 = GetListEntry(index);
3330 git_wc_status_kind status1 = git_wc_status_none;
3331 git_wc_status_kind status2 = git_wc_status_none;
3332 if (entry1)
3333 {
3334 status1 = entry1->status;
3335 index = GetNextSelectedItem(pos);
3336 if (index >= 0)
3337 {
3338 entry2 = GetListEntry(index);
3339 if (entry2)
3340 {
3341 status2 = entry2->status;
3342 if (status2 == git_wc_status_missing && status1 == git_wc_status_unversioned)
3343 {
3344 FileEntry * tempentry = entry1;
3345 entry1 = entry2;
3346 entry2 = tempentry;
3347 }
3348 // entry1 was renamed to entry2 but outside of Subversion
3349 // fix this by moving entry2 back to entry1 first,
3350 // then do an git-move from entry1 to entry2
3351 if (MoveFile(entry2->GetPath().GetWinPath(), entry1->GetPath().GetWinPath()))
3352 {
3353 SVN git;
3354 if (!git.Move(CTSVNPathList(entry1->GetPath()), entry2->GetPath(), TRUE))
3355 {
3356 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
3357 }
3358 else
3359 {
3360 // check the previously unversioned item
3361 entry1->checked = true;
3362 // fixing the move was successful. We have to adjust the new status of the
3363 // files.
3364 // Since we don't know if the moved/renamed file had local modifications or not,
3365 // we can't guess the new status. That means we have to refresh...
3366 CWnd* pParent = GetParent();
3367 if (NULL != pParent && NULL != pParent->GetSafeHwnd())
3368 {
3369 pParent->SendMessage(SVNSLNM_NEEDSREFRESH);
3370 }
3371 }
3372 }
3373 else
3374 {
3375 LPVOID lpMsgBuf;
3376 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
3377 FORMAT_MESSAGE_FROM_SYSTEM |
3378 FORMAT_MESSAGE_IGNORE_INSERTS,
3379 NULL,
3380 GetLastError(),
3381 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
3382 (LPTSTR) &lpMsgBuf,
3383 0,
3384 NULL
3385 );
3386 MessageBox((LPCTSTR)lpMsgBuf, _T("Error"), MB_OK | MB_ICONINFORMATION );
3387 LocalFree( lpMsgBuf );
3388 }
3389 }
3390 }
3391 }
3392 }
3393 }
3394 break;
3395 case IDSVNLC_REMOVEFROMCS:
3396 {
3397 CTSVNPathList changelistItems;
3398 FillListOfSelectedItemPaths(changelistItems);
3399 SVN git;
3400 SetRedraw(FALSE);
3401 if (git.RemoveFromChangeList(changelistItems, CStringArray(), git_depth_empty))
3402 {
3403 // The changelists were removed, but we now need to run through the selected items again
3404 // and update their changelist
3405 POSITION pos = GetFirstSelectedItemPosition();
3406 int index;
3407 std::vector<int> entriesToRemove;
3408 while ((index = GetNextSelectedItem(pos)) >= 0)
3409 {
3410 FileEntry * e = GetListEntry(index);
3411 if (e)
3412 {
3413 e->changelist.Empty();
3414 if (e->status == git_wc_status_normal)
3415 {
3416 // remove the entry completely
3417 entriesToRemove.push_back(index);
3418 }
3419 else
3420 SetItemGroup(index, 0);
3421 }
3422 }
3423 for (std::vector<int>::reverse_iterator it = entriesToRemove.rbegin(); it != entriesToRemove.rend(); ++it)
3424 {
3425 RemoveListEntry(*it);
3426 }
3427 // TODO: Should we go through all entries here and check if we also could
3428 // remove the changelist from m_changelists ?
3429 }
3430 else
3431 {
3432 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
3433 }
3434 SetRedraw(TRUE);
3435 }
3436 break;
3437 case IDSVNLC_CREATEIGNORECS:
3438 CreateChangeList(SVNSLC_IGNORECHANGELIST);
3439 break;
3440 case IDSVNLC_CREATECS:
3441 {
3442 CCreateChangelistDlg dlg;
3443 if (dlg.DoModal() == IDOK)
3444 {
3445 CreateChangeList(dlg.m_sName);
3446 }
3447 }
3448 break;
3449 default:
3450 {
3451 if (cmd < IDSVNLC_MOVETOCS)
3452 break;
3453 CTSVNPathList changelistItems;
3454 FillListOfSelectedItemPaths(changelistItems);
3455
3456 // find the changelist name
3457 CString sChangelist;
3458 int cmdID = IDSVNLC_MOVETOCS;
3459 SetRedraw(FALSE);
3460 for (std::map<CString, int>::const_iterator it = m_changelists.begin(); it != m_changelists.end(); ++it)
3461 {
3462 if ((it->first.Compare(SVNSLC_IGNORECHANGELIST))&&(entry->changelist.Compare(it->first)))
3463 {
3464 if (cmd == cmdID)
3465 {
3466 sChangelist = it->first;
3467 }
3468 cmdID++;
3469 }
3470 }
3471 if (!sChangelist.IsEmpty())
3472 {
3473 SVN git;
3474 if (git.AddToChangeList(changelistItems, sChangelist, git_depth_empty))
3475 {
3476 // The changelists were moved, but we now need to run through the selected items again
3477 // and update their changelist
3478 POSITION pos = GetFirstSelectedItemPosition();
3479 int index;
3480 while ((index = GetNextSelectedItem(pos)) >= 0)
3481 {
3482 FileEntry * e = GetListEntry(index);
3483 e->changelist = sChangelist;
3484 if (!e->IsFolder())
3485 {
3486 if (m_changelists.find(e->changelist)!=m_changelists.end())
3487 SetItemGroup(index, m_changelists[e->changelist]);
3488 else
3489 SetItemGroup(index, 0);
3490 }
3491 }
3492 }
3493 else
3494 {
3495 CMessageBox::Show(m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
3496 }
3497 }
3498 SetRedraw(TRUE);
3499 }
3500 break;
3501 #endif
3502
3503 } // switch (cmd)
3504 m_bBlock = FALSE;
3505 AfxGetApp()->DoWaitCursor(-1);
3506 GetStatisticsString();
3507 //int iItemCountAfterMenuCmd = GetItemCount();
3508 //if (iItemCountAfterMenuCmd != iItemCountBeforeMenuCmd)
3509 //{
3510 // CWnd* pParent = GetParent();
3511 // if (NULL != pParent && NULL != pParent->GetSafeHwnd())
3512 // {
3513 // pParent->SendMessage(SVNSLNM_ITEMCOUNTCHANGED);
3514 // }
3515 //}
3516 } // if (popup.CreatePopupMenu())
3517 } // if (selIndex >= 0)
3518
3519 }
3520
3521 void CGitStatusListCtrl::OnContextMenuHeader(CWnd * pWnd, CPoint point)
3522 {
3523 Locker lock(m_critSec);
3524 m_ColumnManager.OnContextMenuHeader(pWnd,point,!!IsGroupViewEnabled());
3525 }
3526
3527 void CGitStatusListCtrl::OnContextMenu(CWnd* pWnd, CPoint point)
3528 {
3529
3530 if (pWnd == this)
3531 {
3532 OnContextMenuList(pWnd, point);
3533 } // if (pWnd == this)
3534 else if (pWnd == GetHeaderCtrl())
3535 {
3536 OnContextMenuHeader(pWnd, point);
3537 }
3538 }
3539
3540 void CGitStatusListCtrl::OnNMDblclk(NMHDR *pNMHDR, LRESULT *pResult)
3541 {
3542
3543 Locker lock(m_critSec);
3544 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
3545 *pResult = 0;
3546 if (m_bBlock)
3547 return;
3548
3549 if (pNMLV->iItem < 0)
3550 {
3551 if (!IsGroupViewEnabled())
3552 return;
3553 POINT pt;
3554 DWORD ptW = GetMessagePos();
3555 pt.x = GET_X_LPARAM(ptW);
3556 pt.y = GET_Y_LPARAM(ptW);
3557 ScreenToClient(&pt);
3558 int group = GetGroupFromPoint(&pt);
3559 if (group < 0)
3560 return;
3561 // check/uncheck the whole group depending on the check-state
3562 // of the first item in the group
3563 m_bBlock = true;
3564 bool bCheck = false;
3565 bool bFirst = false;
3566 LVITEM lv;
3567 for (int i=0; i<GetItemCount(); ++i)
3568 {
3569 SecureZeroMemory(&lv, sizeof(LVITEM));
3570 lv.mask = LVIF_GROUPID;
3571 lv.iItem = i;
3572 GetItem(&lv);
3573 if (lv.iGroupId == group)
3574 {
3575 CTGitPath *entry=(CTGitPath*)GetItemData(i);
3576
3577 if (!bFirst)
3578 {
3579 bCheck = !GetCheck(i);
3580 bFirst = true;
3581 }
3582 if (entry)
3583 {
3584 bool bOldCheck = !!GetCheck(i);
3585 SetEntryCheck(entry, i, bCheck);
3586 if (bCheck != bOldCheck)
3587 {
3588 if (bCheck)
3589 m_nSelected++;
3590 else
3591 m_nSelected--;
3592 }
3593 }
3594 }
3595 }
3596 GetStatisticsString();
3597 m_bBlock = false;
3598 NotifyCheck();
3599 return;
3600 }
3601
3602 CTGitPath *file=(CTGitPath*)GetItemData(pNMLV->iItem);
3603
3604 if (file->m_Action == CTGitPath::LOGACTIONS_UNVER) {
3605 OpenFile(file, OPEN);
3606 return;
3607 }
3608 if( file->m_Action&CTGitPath::LOGACTIONS_UNMERGED )
3609 {
3610 CAppUtils::ConflictEdit(*file,false,m_bIsRevertTheirMy);
3611
3612 }
3613 else
3614 {
3615 if( (!m_Rev1.IsEmpty()) || (!m_Rev1.IsEmpty())) // m_Rev1 twice???
3616 StartDiffTwo(pNMLV->iItem);
3617 else
3618 StartDiff(pNMLV->iItem);
3619 }
3620
3621 }
3622 void CGitStatusListCtrl::StartDiffTwo(int fileindex)
3623 {
3624 if(fileindex<0)
3625 return;
3626
3627 CTGitPath file1=*(CTGitPath*)GetItemData(fileindex);
3628
3629 CGitDiff::Diff(&file1,&file1,
3630 m_Rev1,
3631 m_Rev2);
3632
3633 }
3634 void CGitStatusListCtrl::StartDiffWC(int fileindex)
3635 {
3636 if(fileindex<0)
3637 return;
3638
3639 CString Ver;
3640 if(this->m_CurrentVersion.IsEmpty() || m_CurrentVersion== GIT_REV_ZERO)
3641 return;
3642
3643 CTGitPath file1=*(CTGitPath*)GetItemData(fileindex);
3644
3645 CGitDiff::Diff(&file1,&file1, GIT_REV_ZERO, m_CurrentVersion);
3646
3647 }
3648
3649 void CGitStatusListCtrl::StartDiff(int fileindex)
3650 {
3651 if(fileindex<0)
3652 return;
3653
3654 CTGitPath file1=*(CTGitPath*)GetItemData(fileindex);
3655 CTGitPath file2;
3656 if(file1.m_Action & (CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_COPY))
3657 {
3658 file2.SetFromGit(file1.GetGitOldPathString());
3659 }
3660 else
3661 {
3662 file2=file1;
3663 }
3664
3665 if(this->m_CurrentVersion.IsEmpty() || m_CurrentVersion== GIT_REV_ZERO)
3666 {
3667 CString fromwhere;
3668 if(m_amend && (file1.m_Action & CTGitPath::LOGACTIONS_ADDED) == 0)
3669 fromwhere = _T("~1");
3670 if( g_Git.IsInitRepos())
3671 CGitDiff::DiffNull((CTGitPath*)GetItemData(fileindex),
3672 GIT_REV_ZERO);
3673 else if( file1.m_Action&CTGitPath::LOGACTIONS_ADDED )
3674 CGitDiff::DiffNull((CTGitPath*)GetItemData(fileindex),
3675 m_CurrentVersion+fromwhere,true);
3676 else if( file1.m_Action&CTGitPath::LOGACTIONS_DELETED )
3677 CGitDiff::DiffNull((CTGitPath*)GetItemData(fileindex),
3678 GitRev::GetHead()+fromwhere,false);
3679 else
3680 CGitDiff::Diff(&file1,&file2,
3681 CString(GIT_REV_ZERO),
3682 GitRev::GetHead()+fromwhere);
3683 }
3684 else
3685 {
3686 GitRev rev;
3687 CString fromwhere = m_CurrentVersion+_T("~1");
3688 if(m_amend)
3689 fromwhere = m_CurrentVersion+_T("~2");
3690 if(rev.GetCommit(fromwhere) || (file1.m_Action == file1.LOGACTIONS_ADDED))
3691 {
3692 CGitDiff::DiffNull(&file1,m_CurrentVersion,true);
3693
3694 }
3695 else if (file1.m_Action == file1.LOGACTIONS_DELETED)
3696 {
3697 if (file1.m_ParentNo > 0)
3698 fromwhere.Format(_T("%s^%d"), m_CurrentVersion, file1.m_ParentNo + 1);
3699
3700 CGitDiff::DiffNull(&file1,fromwhere,false);
3701 }
3702 else
3703 {
3704 if( file1.m_ParentNo & MERGE_MASK)
3705 {
3706
3707 CTGitPath base, theirs, mine, merge;
3708
3709 CString temppath;
3710 GetTempPath(temppath);
3711 temppath.TrimRight(_T("\\"));
3712
3713 mine.SetFromGit(temppath + _T("\\") + file1.GetFileOrDirectoryName() + _T(".LOCAL") + file1.GetFileExtension());
3714 theirs.SetFromGit(temppath + _T("\\") + file1.GetFileOrDirectoryName() + _T(".REMOTE") + file1.GetFileExtension());
3715 base.SetFromGit(temppath + _T("\\") + file1.GetFileOrDirectoryName() + _T(".BASE") + file1.GetFileExtension());
3716
3717 CFile tempfile;
3718 //create a empty file, incase stage is not three
3719 tempfile.Open(mine.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
3720 tempfile.Close();
3721 tempfile.Open(theirs.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
3722 tempfile.Close();
3723 tempfile.Open(base.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
3724 tempfile.Close();
3725
3726 merge.SetFromGit(temppath + _T("\\") + file1.GetFileOrDirectoryName() + _T(".Merged") + file1.GetFileExtension());
3727
3728 int parent1=-1, parent2 =-1;
3729 for(int i=0;i<this->m_arStatusArray.size();i++)
3730 {
3731 if(m_arStatusArray[i]->GetGitPathString() == file1.GetGitPathString())
3732 {
3733 if(m_arStatusArray[i]->m_ParentNo & MERGE_MASK)
3734 {
3735 }
3736 else
3737 {
3738 if(parent1<0)
3739 {
3740 parent1 = m_arStatusArray[i]->m_ParentNo & PARENT_MASK;
3741 }
3742 else if (parent2 <0)
3743 {
3744 parent2 = m_arStatusArray[i]->m_ParentNo & PARENT_MASK;
3745 }
3746 }
3747 }
3748 }
3749
3750 if(g_Git.GetOneFile(m_CurrentVersion, file1, (CString&)merge.GetWinPathString()))
3751 {
3752 CMessageBox::Show(NULL, IDS_STATUSLIST_FAILEDGETMERGEFILE, IDS_APPNAME, MB_OK | MB_ICONERROR);
3753 }
3754
3755 if(parent1>=0)
3756 {
3757 CString str;
3758 str.Format(_T("%s^%d"),this->m_CurrentVersion, parent1+1);
3759
3760 if(g_Git.GetOneFile(str, file1, (CString&)mine.GetWinPathString()))
3761 {
3762 CMessageBox::Show(NULL, IDS_STATUSLIST_FAILEDGETMERGEFILE, IDS_APPNAME, MB_OK | MB_ICONERROR);
3763 }
3764 }
3765
3766 if(parent2>=0)
3767 {
3768 CString str;
3769 str.Format(_T("%s^%d"),this->m_CurrentVersion, parent2+1);
3770
3771 if(g_Git.GetOneFile(str, file1, (CString&)theirs.GetWinPathString()))
3772 {
3773 CMessageBox::Show(NULL, IDS_STATUSLIST_FAILEDGETMERGEFILE, IDS_APPNAME, MB_OK | MB_ICONERROR);
3774 }
3775 }
3776
3777 if(parent1>=0 && parent2>=0)
3778 {
3779 CString cmd, output;
3780 cmd.Format(_T("git.exe merge-base %s^%d %s^%d"), this->m_CurrentVersion, parent1+1,
3781 this->m_CurrentVersion,parent2+1);
3782
3783 if (g_Git.Run(cmd, &output, NULL, CP_UTF8))
3784 {
3785 }
3786 else
3787 {
3788 if(g_Git.GetOneFile(output.Left(40), file1, (CString&)base.GetWinPathString()))
3789 {
3790 CMessageBox::Show(NULL, IDS_STATUSLIST_FAILEDGETBASEFILE, IDS_APPNAME, MB_OK | MB_ICONERROR);
3791 }
3792 }
3793 }
3794 CAppUtils::StartExtMerge(base, theirs, mine, merge,_T("BASE"),_T("REMOTE"),_T("LOCAL"));
3795
3796 }
3797 else
3798 {
3799 CString str;
3800 if( (file1.m_ParentNo&PARENT_MASK) == 0)
3801 {
3802 str = _T("~1");
3803 }
3804 else
3805 {
3806 str.Format(_T("^%d"), (file1.m_ParentNo&PARENT_MASK)+1);
3807 }
3808 CGitDiff::Diff(&file1,&file2,
3809 m_CurrentVersion,
3810 m_CurrentVersion+str);
3811 }
3812 }
3813 }
3814 #if 0
3815 if (fileindex < 0)
3816 return;
3817 FileEntry * entry = GetListEntry(fileindex);
3818 ASSERT(entry != NULL);
3819 if (entry == NULL)
3820 return;
3821 if (((entry->status == git_wc_status_normal)&&(entry->remotestatus <= git_wc_status_normal))||
3822 (entry->status == git_wc_status_unversioned)||(entry->status == git_wc_status_none))
3823 {
3824 int ret = (int)ShellExecute(this->m_hWnd, NULL, entry->path.GetWinPath(), NULL, NULL, SW_SHOW);
3825 if (ret <= HINSTANCE_ERROR)
3826 {
3827 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");
3828 cmd += entry->path.GetWinPathString();
3829 CAppUtils::LaunchApplication(cmd, NULL, false);
3830 }
3831 return;
3832 }
3833
3834 GitDiff diff(NULL, m_hWnd, true);
3835 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
3836 diff.DiffWCFile(
3837 entry->path, entry->textstatus, entry->propstatus,
3838 entry->remotetextstatus, entry->remotepropstatus);
3839 #endif
3840 }
3841
3842 CString CGitStatusListCtrl::GetStatisticsString(bool simple)
3843 {
3844
3845 CString sNormal, sAdded, sDeleted, sModified, sConflicted, sUnversioned, sRenamed;
3846 WORD langID = (WORD)(DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
3847 TCHAR buf[MAX_STATUS_STRING_LENGTH];
3848 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_normal, buf, _countof(buf), langID);
3849 sNormal = buf;
3850 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_added, buf, _countof(buf), langID);
3851 sAdded = buf;
3852 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_deleted, buf, _countof(buf), langID);
3853 sDeleted = buf;
3854 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_modified, buf, _countof(buf), langID);
3855 sModified = buf;
3856 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_conflicted, buf, _countof(buf), langID);
3857 sConflicted = buf;
3858 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_unversioned, buf, _countof(buf), langID);
3859 sUnversioned = buf;
3860 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_replaced, buf, _countof(buf), langID);
3861 sRenamed = buf;
3862 CString sToolTip;
3863 if(simple)
3864 {
3865 sToolTip.Format(IDS_STATUSLIST_STATUSLINE1,
3866 this->m_nLineAdded,this->m_nLineDeleted,
3867 (LPCTSTR)sModified, m_nModified,
3868 (LPCTSTR)sAdded, m_nAdded,
3869 (LPCTSTR)sDeleted, m_nDeleted,
3870 (LPCTSTR)sRenamed, m_nRenamed
3871 );
3872 }
3873 else
3874 {
3875 sToolTip.Format(IDS_STATUSLIST_STATUSLINE2,
3876 this->m_nLineAdded,this->m_nLineDeleted,
3877 (LPCTSTR)sNormal, m_nNormal,
3878 (LPCTSTR)sUnversioned, m_nUnversioned,
3879 (LPCTSTR)sModified, m_nModified,
3880 (LPCTSTR)sAdded, m_nAdded,
3881 (LPCTSTR)sDeleted, m_nDeleted,
3882 (LPCTSTR)sConflicted, m_nConflicted
3883 );
3884 }
3885 CString sStats;
3886 sStats.Format(IDS_COMMITDLG_STATISTICSFORMAT, m_nSelected, GetItemCount());
3887 if (m_pStatLabel)
3888 {
3889 m_pStatLabel->SetWindowText(sStats);
3890 }
3891
3892 if (m_pSelectButton)
3893 {
3894 if (m_nSelected == 0)
3895 m_pSelectButton->SetCheck(BST_UNCHECKED);
3896 else if (m_nSelected != GetItemCount())
3897 m_pSelectButton->SetCheck(BST_INDETERMINATE);
3898 else
3899 m_pSelectButton->SetCheck(BST_CHECKED);
3900 }
3901
3902 if (m_pConfirmButton)
3903 {
3904 m_pConfirmButton->EnableWindow(m_nSelected>0);
3905 }
3906
3907 return sToolTip;
3908
3909
3910 }
3911
3912 CString CGitStatusListCtrl::GetCommonDirectory(bool bStrict)
3913 {
3914 if (!bStrict)
3915 {
3916 // not strict means that the selected folder has priority
3917 if (!m_StatusFileList.GetCommonDirectory().IsEmpty())
3918 return m_StatusFileList.GetCommonDirectory().GetWinPath();
3919 }
3920
3921 CTGitPath commonBaseDirectory;
3922 int nListItems = GetItemCount();
3923 for (int i=0; i<nListItems; ++i)
3924 {
3925 CTGitPath baseDirectory,*p= (CTGitPath*)this->GetItemData(i);
3926 ASSERT(p);
3927 if(p==NULL)
3928 continue;
3929 baseDirectory = p->GetDirectory();
3930
3931 if(commonBaseDirectory.IsEmpty())
3932 {
3933 commonBaseDirectory = baseDirectory;
3934 }
3935 else
3936 {
3937 if (commonBaseDirectory.GetWinPathString().GetLength() > baseDirectory.GetWinPathString().GetLength())
3938 {
3939 if (baseDirectory.IsAncestorOf(commonBaseDirectory))
3940 commonBaseDirectory = baseDirectory;
3941 }
3942 }
3943 }
3944 return g_Git.m_CurrentDir+CString(_T("\\"))+commonBaseDirectory.GetWinPath();
3945 }
3946
3947
3948 void CGitStatusListCtrl::SelectAll(bool bSelect, bool /*bIncludeNoCommits*/)
3949 {
3950 CWaitCursor waitCursor;
3951 // block here so the LVN_ITEMCHANGED messages
3952 // get ignored
3953 m_bBlock = TRUE;
3954 SetRedraw(FALSE);
3955
3956 int nListItems = GetItemCount();
3957 if (bSelect)
3958 m_nSelected = nListItems;
3959 else
3960 m_nSelected = 0;
3961
3962 for (int i=0; i<nListItems; ++i)
3963 {
3964 //FileEntry * entry = GetListEntry(i);
3965 //ASSERT(entry != NULL);
3966 CTGitPath *path = (CTGitPath *) GetItemData(i);
3967 if (path == NULL)
3968 continue;
3969 //if ((bIncludeNoCommits)||(entry->GetChangeList().Compare(SVNSLC_IGNORECHANGELIST)))
3970 SetEntryCheck(path,i,bSelect);
3971 }
3972
3973 // unblock before redrawing
3974 m_bBlock = FALSE;
3975 SetRedraw(TRUE);
3976 GetStatisticsString();
3977 NotifyCheck();
3978 }
3979
3980 void CGitStatusListCtrl::Check(DWORD dwCheck, bool uncheckNonMatches)
3981 {
3982 CWaitCursor waitCursor;
3983 // block here so the LVN_ITEMCHANGED messages
3984 // get ignored
3985 m_bBlock = TRUE;
3986 SetRedraw(FALSE);
3987
3988 int nListItems = GetItemCount();
3989 m_nSelected = 0;
3990
3991 for (int i = 0; i < nListItems; ++i)
3992 {
3993 CTGitPath *entry = (CTGitPath *) GetItemData(i);
3994 if (entry == NULL)
3995 continue;
3996
3997 DWORD showFlags = entry->m_Action;
3998 if (entry->IsDirectory())
3999 showFlags |= GITSLC_SHOWSUBMODULES;
4000 else
4001 showFlags |= GITSLC_SHOWFILES;
4002
4003 if (showFlags & dwCheck && !(entry->IsDirectory() && m_bDoNotAutoselectSubmodules && !(dwCheck & GITSLC_SHOWSUBMODULES)))
4004 {
4005 SetEntryCheck(entry, i, true);
4006 m_nSelected++;
4007 }
4008 else if (uncheckNonMatches)
4009 SetEntryCheck(entry, i, false);
4010 }
4011 // unblock before redrawing
4012 m_bBlock = FALSE;
4013 SetRedraw(TRUE);
4014 GetStatisticsString();
4015 NotifyCheck();
4016 }
4017
4018 void CGitStatusListCtrl::OnLvnGetInfoTip(NMHDR *pNMHDR, LRESULT *pResult)
4019 {
4020 LPNMLVGETINFOTIP pGetInfoTip = reinterpret_cast<LPNMLVGETINFOTIP>(pNMHDR);
4021 *pResult = 0;
4022 if (m_bBlock)
4023 return;
4024
4025 CTGitPath *entry=(CTGitPath *)GetItemData(pGetInfoTip->iItem);
4026
4027 if (entry)
4028 if (pGetInfoTip->cchTextMax > entry->GetGitPathString().GetLength() + g_Git.m_CurrentDir.GetLength())
4029 {
4030 CString str;
4031 str += g_Git.m_CurrentDir;
4032 str += _T("\\");
4033 str += entry->GetWinPathString();
4034
4035 _tcsncpy_s(pGetInfoTip->pszText, pGetInfoTip->cchTextMax, str.GetBuffer(), str.GetLength());
4036 }
4037 }
4038
4039 void CGitStatusListCtrl::OnNMCustomdraw(NMHDR *pNMHDR, LRESULT *pResult)
4040 {
4041 NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
4042
4043 // Take the default processing unless we set this to something else below.
4044 *pResult = CDRF_DODEFAULT;
4045
4046 // First thing - check the draw stage. If it's the control's prepaint
4047 // stage, then tell Windows we want messages for every item.
4048
4049 switch (pLVCD->nmcd.dwDrawStage)
4050 {
4051 case CDDS_PREPAINT:
4052 *pResult = CDRF_NOTIFYITEMDRAW;
4053 break;
4054 case CDDS_ITEMPREPAINT:
4055 {
4056 // This is the prepaint stage for an item. Here's where we set the
4057 // item's text color. Our return value will tell Windows to draw the
4058 // item itself, but it will use the new color we set here.
4059
4060 // Tell Windows to paint the control itself.
4061 *pResult = CDRF_DODEFAULT;
4062 if (m_bBlock)
4063 return;
4064
4065 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
4066
4067 if (m_arStatusArray.size() > (DWORD_PTR)pLVCD->nmcd.dwItemSpec)
4068 {
4069
4070 //FileEntry * entry = GetListEntry((int)pLVCD->nmcd.dwItemSpec);
4071 CTGitPath *entry=(CTGitPath *)GetItemData((int)pLVCD->nmcd.dwItemSpec);
4072 if (entry == NULL)
4073 return;
4074
4075 // coloring
4076 // ========
4077 // black : unversioned, normal
4078 // purple : added
4079 // blue : modified
4080 // brown : missing, deleted, replaced
4081 // green : merged (or potential merges)
4082 // red : conflicts or sure conflicts
4083 if(entry->m_Action & CTGitPath::LOGACTIONS_GRAY)
4084 {
4085 crText = RGB(128,128,128);
4086
4087 }
4088 else if(entry->m_Action & CTGitPath::LOGACTIONS_UNMERGED)
4089 {
4090 crText = m_Colors.GetColor(CColors::Conflict);
4091
4092 }
4093 else if(entry->m_Action & (CTGitPath::LOGACTIONS_MODIFIED))
4094 {
4095 crText = m_Colors.GetColor(CColors::Modified);
4096
4097 }
4098 else if(entry->m_Action & (CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_COPY))
4099 {
4100 crText = m_Colors.GetColor(CColors::Added);
4101 }
4102 else if(entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
4103 {
4104 crText = m_Colors.GetColor(CColors::DeletedNode);
4105 }
4106 else if(entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
4107 {
4108 crText = m_Colors.GetColor(CColors::RenamedNode);
4109 }
4110 else if(entry->m_Action & CTGitPath::LOGACTIONS_MERGED)
4111 {
4112 crText = m_Colors.GetColor(CColors::Merged);
4113 }
4114 else
4115 {
4116 crText = GetSysColor(COLOR_WINDOWTEXT);
4117 }
4118 // Store the color back in the NMLVCUSTOMDRAW struct.
4119 pLVCD->clrText = crText;
4120 }
4121 }
4122 break;
4123 }
4124 }
4125
4126 BOOL CGitStatusListCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
4127 {
4128 if (pWnd != this)
4129 return CListCtrl::OnSetCursor(pWnd, nHitTest, message);
4130 if (!m_bBlock)
4131 {
4132 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
4133 SetCursor(hCur);
4134 return CListCtrl::OnSetCursor(pWnd, nHitTest, message);
4135 }
4136 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));
4137 SetCursor(hCur);
4138 return TRUE;
4139 }
4140
4141 void CGitStatusListCtrl::RemoveListEntry(int index)
4142 {
4143
4144 Locker lock(m_critSec);
4145 DeleteItem(index);
4146
4147 m_arStatusArray.erase(m_arStatusArray.begin()+index);
4148
4149 #if 0
4150 delete m_arStatusArray[m_arListArray[index]];
4151 m_arStatusArray.erase(m_arStatusArray.begin()+m_arListArray[index]);
4152 m_arListArray.erase(m_arListArray.begin()+index);
4153 for (int i=index; i< (int)m_arListArray.size(); ++i)
4154 {
4155 m_arListArray[i]--;
4156 }
4157 #endif
4158 }
4159
4160 ///< Set a checkbox on an entry in the listbox
4161 // NEVER, EVER call SetCheck directly, because you'll end-up with the checkboxes and the 'checked' flag getting out of sync
4162 void CGitStatusListCtrl::SetEntryCheck(CTGitPath* pEntry, int listboxIndex, bool bCheck)
4163 {
4164 pEntry->m_Checked = bCheck;
4165 m_mapFilenameToChecked[pEntry->GetGitPathString()] = bCheck;
4166 SetCheck(listboxIndex, bCheck);
4167 }
4168
4169 #if 0
4170 void CGitStatusListCtrl::SetCheckOnAllDescendentsOf(const FileEntry* parentEntry, bool bCheck)
4171 {
4172
4173 int nListItems = GetItemCount();
4174 for (int j=0; j< nListItems ; ++j)
4175 {
4176 FileEntry * childEntry = GetListEntry(j);
4177 ASSERT(childEntry != NULL);
4178 if (childEntry == NULL || childEntry == parentEntry)
4179 continue;
4180 if (childEntry->checked != bCheck)
4181 {
4182 if (parentEntry->path.IsAncestorOf(childEntry->path))
4183 {
4184 SetEntryCheck(childEntry,j,bCheck);
4185 if(bCheck)
4186 {
4187 m_nSelected++;
4188 }
4189 else
4190 {
4191 m_nSelected--;
4192 }
4193 }
4194 }
4195 }
4196
4197 }
4198 #endif
4199
4200 void CGitStatusListCtrl::WriteCheckedNamesToPathList(CTGitPathList& pathList)
4201 {
4202
4203 pathList.Clear();
4204 int nListItems = GetItemCount();
4205 for (int i=0; i< nListItems; i++)
4206 {
4207 CTGitPath * entry = (CTGitPath*)GetItemData(i);
4208 ASSERT(entry != NULL);
4209 if (entry->m_Checked)
4210 {
4211 pathList.AddPath(*entry);
4212 }
4213 }
4214 pathList.SortByPathname();
4215
4216 }
4217
4218
4219 /// Build a path list of all the selected items in the list (NOTE - SELECTED, not CHECKED)
4220 void CGitStatusListCtrl::FillListOfSelectedItemPaths(CTGitPathList& pathList, bool /*bNoIgnored*/)
4221 {
4222 pathList.Clear();
4223
4224 POSITION pos = GetFirstSelectedItemPosition();
4225 int index;
4226 while ((index = GetNextSelectedItem(pos)) >= 0)
4227 {
4228 CTGitPath * entry = (CTGitPath*)GetItemData(index);
4229 //if ((bNoIgnored)&&(entry->status == git_wc_status_ignored))
4230 // continue;
4231 pathList.AddPath(*entry);
4232 }
4233 }
4234
4235 UINT CGitStatusListCtrl::OnGetDlgCode()
4236 {
4237 // we want to process the return key and not have that one
4238 // routed to the default pushbutton
4239 return CListCtrl::OnGetDlgCode() | DLGC_WANTALLKEYS;
4240 }
4241
4242 void CGitStatusListCtrl::OnNMReturn(NMHDR * /*pNMHDR*/, LRESULT *pResult)
4243 {
4244 *pResult = 0;
4245 if (m_bBlock)
4246 return;
4247 POSITION pos = GetFirstSelectedItemPosition();
4248 while ( pos )
4249 {
4250 int index = GetNextSelectedItem(pos);
4251 CTGitPath *file=(CTGitPath*)GetItemData(index);
4252 if (file->m_Action == CTGitPath::LOGACTIONS_UNVER)
4253 {
4254 OpenFile(file, OPEN);
4255 }
4256 else
4257 {
4258 StartDiff(index);
4259 }
4260 }
4261 }
4262
4263 void CGitStatusListCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
4264 {
4265 // Since we catch all keystrokes (to have the enter key processed here instead
4266 // of routed to the default pushbutton) we have to make sure that other
4267 // keys like Tab and Esc still do what they're supposed to do
4268 // Tab = change focus to next/previous control
4269 // Esc = quit the dialog
4270 switch (nChar)
4271 {
4272 case (VK_TAB):
4273 {
4274 ::PostMessage(GetParent()->GetSafeHwnd(), WM_NEXTDLGCTL, GetKeyState(VK_SHIFT)&0x8000, 0);
4275 return;
4276 }
4277 break;
4278 case (VK_ESCAPE):
4279 {
4280 ::SendMessage(GetParent()->GetSafeHwnd(), WM_CLOSE, 0, 0);
4281 }
4282 break;
4283 }
4284
4285 CListCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
4286 }
4287
4288 void CGitStatusListCtrl::PreSubclassWindow()
4289 {
4290 CListCtrl::PreSubclassWindow();
4291 EnableToolTips(TRUE);
4292 SetWindowTheme(GetSafeHwnd(), L"Explorer", NULL);
4293 }
4294
4295 INT_PTR CGitStatusListCtrl::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
4296 {
4297 int row, col;
4298 RECT cellrect;
4299 row = CellRectFromPoint(point, &cellrect, &col );
4300
4301 if (row == -1)
4302 return -1;
4303
4304
4305 pTI->hwnd = m_hWnd;
4306 pTI->uId = (UINT)((row<<10)+(col&0x3ff)+1);
4307 pTI->lpszText = LPSTR_TEXTCALLBACK;
4308
4309 pTI->rect = cellrect;
4310
4311 return pTI->uId;
4312 }
4313
4314 int CGitStatusListCtrl::CellRectFromPoint(CPoint& point, RECT *cellrect, int *col) const
4315 {
4316 int colnum;
4317
4318 // Make sure that the ListView is in LVS_REPORT
4319 if ((GetWindowLong(m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
4320 return -1;
4321
4322 // Get the top and bottom row visible
4323 int row = GetTopIndex();
4324 int bottom = row + GetCountPerPage();
4325 if (bottom > GetItemCount())
4326 bottom = GetItemCount();
4327
4328 // Get the number of columns
4329 CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
4330 int nColumnCount = pHeader->GetItemCount();
4331
4332 // Loop through the visible rows
4333 for ( ;row <=bottom;row++)
4334 {
4335 // Get bounding rect of item and check whether point falls in it.
4336 CRect rect;
4337 GetItemRect(row, &rect, LVIR_BOUNDS);
4338 if (rect.PtInRect(point))
4339 {
4340 // Now find the column
4341 for (colnum = 0; colnum < nColumnCount; colnum++)
4342 {
4343 int colwidth = GetColumnWidth(colnum);
4344 if (point.x >= rect.left && point.x <= (rect.left + colwidth))
4345 {
4346 RECT rectClient;
4347 GetClientRect(&rectClient);
4348 if (col)
4349 *col = colnum;
4350 rect.right = rect.left + colwidth;
4351
4352 // Make sure that the right extent does not exceed
4353 // the client area
4354 if (rect.right > rectClient.right)
4355 rect.right = rectClient.right;
4356 *cellrect = rect;
4357 return row;
4358 }
4359 rect.left += colwidth;
4360 }
4361 }
4362 }
4363 return -1;
4364 }
4365
4366 BOOL CGitStatusListCtrl::OnToolTipText(UINT /*id*/, NMHDR* /*pNMHDR*/, LRESULT* /*pResult*/)
4367 {
4368 #if 0
4369 TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
4370 CString strTipText;
4371 UINT_PTR nID = pNMHDR->idFrom;
4372
4373 if (nID == 0)
4374 return FALSE;
4375
4376 UINT_PTR row = ((nID-1) >> 10) & 0x3fffff;
4377 UINT_PTR col = (nID-1) & 0x3ff;
4378
4379 if (col == 0)
4380 return FALSE; // no custom tooltip for the path, we use the infotip there!
4381
4382 // get the internal column from the visible columns
4383 int internalcol = 0;
4384 UINT_PTR currentcol = 0;
4385 for (; (currentcol != col)
4386 && (internalcol < m_ColumnManager.GetColumnCount()-1)
4387 ; ++internalcol)
4388 {
4389 if (m_ColumnManager.IsVisible (internalcol))
4390 currentcol++;
4391 }
4392
4393 AFX_MODULE_THREAD_STATE* pModuleThreadState = AfxGetModuleThreadState();
4394 CToolTipCtrl* pToolTip = pModuleThreadState->m_pToolTip;
4395 pToolTip->SendMessage(TTM_SETMAXTIPWIDTH, 0, 300);
4396
4397 *pResult = 0;
4398 if ((internalcol == 2)||(internalcol == 4))
4399 {
4400 FileEntry *fentry = GetListEntry(row);
4401 if (fentry)
4402 {
4403 if (fentry->copied)
4404 {
4405 CString url;
4406 url.Format(IDS_STATUSLIST_COPYFROM, (LPCTSTR)CPathUtils::PathUnescape(fentry->copyfrom_url), (LONG)fentry->copyfrom_rev);
4407 lstrcpyn(pTTTW->szText, (LPCTSTR)url, 80);
4408 return TRUE;
4409 }
4410 if (fentry->switched)
4411 {
4412 CString url;
4413 url.Format(IDS_STATUSLIST_SWITCHEDTO, (LPCTSTR)CPathUtils::PathUnescape(fentry->url));
4414 lstrcpyn(pTTTW->szText, (LPCTSTR)url, 80);
4415 return TRUE;
4416 }
4417 if (fentry->keeplocal)
4418 {
4419 lstrcpyn(pTTTW->szText, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_KEEPLOCAL)), 80);
4420 return TRUE;
4421 }
4422 }
4423 }
4424 #endif
4425 return FALSE;
4426 }
4427
4428 void CGitStatusListCtrl::OnPaint()
4429 {
4430 Default();
4431 if ((m_bBusy)||(m_bEmpty))
4432 {
4433 CString str;
4434 if (m_bBusy)
4435 {
4436 if (m_sBusy.IsEmpty())
4437 str.LoadString(IDS_STATUSLIST_BUSYMSG);
4438 else
4439 str = m_sBusy;
4440 }
4441 else
4442 {
4443 if (m_sEmpty.IsEmpty())
4444 str.LoadString(IDS_STATUSLIST_EMPTYMSG);
4445 else
4446 str = m_sEmpty;
4447 }
4448 COLORREF clrText = ::GetSysColor(COLOR_WINDOWTEXT);
4449 COLORREF clrTextBk;
4450 if (IsWindowEnabled())
4451 clrTextBk = ::GetSysColor(COLOR_WINDOW);
4452 else
4453 clrTextBk = ::GetSysColor(COLOR_3DFACE);
4454
4455 CRect rc;
4456 GetClientRect(&rc);
4457 CHeaderCtrl* pHC;
4458 pHC = GetHeaderCtrl();
4459 if (pHC != NULL)
4460 {
4461 CRect rcH;
4462 pHC->GetItemRect(0, &rcH);
4463 rc.top += rcH.bottom;
4464 }
4465 CDC* pDC = GetDC();
4466 {
4467 CMyMemDC memDC(pDC, &rc);
4468
4469 memDC.SetTextColor(clrText);
4470 memDC.SetBkColor(clrTextBk);
4471 memDC.FillSolidRect(rc, clrTextBk);
4472 rc.top += 10;
4473 CGdiObject * oldfont = memDC.SelectStockObject(DEFAULT_GUI_FONT);
4474 memDC.DrawText(str, rc, DT_CENTER | DT_VCENTER |
4475 DT_WORDBREAK | DT_NOPREFIX | DT_NOCLIP);
4476 memDC.SelectObject(oldfont);
4477 }
4478 ReleaseDC(pDC);
4479 }
4480 }
4481
4482 // prevent users from extending our hidden (size 0) columns
4483 void CGitStatusListCtrl::OnHdnBegintrack(NMHDR *pNMHDR, LRESULT *pResult)
4484 {
4485 m_ColumnManager.OnHdnBegintrack(pNMHDR, pResult);
4486 }
4487
4488 // prevent any function from extending our hidden (size 0) columns
4489 void CGitStatusListCtrl::OnHdnItemchanging(NMHDR *pNMHDR, LRESULT *pResult)
4490 {
4491 if(!m_ColumnManager.OnHdnItemchanging(pNMHDR, pResult))
4492 Default();
4493 }
4494
4495 void CGitStatusListCtrl::OnDestroy()
4496 {
4497 SaveColumnWidths(true);
4498 CListCtrl::OnDestroy();
4499 }
4500
4501 void CGitStatusListCtrl::OnBeginDrag(NMHDR* /*pNMHDR*/, LRESULT* pResult)
4502 {
4503 #if 0
4504 Locker lock(m_critSec);
4505 CDropFiles dropFiles; // class for creating DROPFILES struct
4506
4507 int index;
4508 POSITION pos = GetFirstSelectedItemPosition();
4509 while ( (index = GetNextSelectedItem(pos)) >= 0 )
4510 {
4511 FileEntry * fentry = m_arStatusArray[m_arListArray[index]];
4512 CTGitPath path = fentry->GetPath();
4513 dropFiles.AddFile( path.GetWinPathString() );
4514 }
4515
4516 if ( dropFiles.GetCount()>0 )
4517 {
4518 m_bOwnDrag = true;
4519 dropFiles.CreateStructure();
4520 m_bOwnDrag = false;
4521 }
4522 #endif
4523 *pResult = 0;
4524 }
4525
4526 void CGitStatusListCtrl::SaveColumnWidths(bool bSaveToRegistry /* = false */)
4527 {
4528 int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;
4529 for (int col = 0; col <= maxcol; col++)
4530 if (m_ColumnManager.IsVisible (col))
4531 m_ColumnManager.ColumnResized (col);
4532
4533 if (bSaveToRegistry)
4534 m_ColumnManager.WriteSettings();
4535 }
4536
4537 bool CGitStatusListCtrl::EnableFileDrop()
4538 {
4539 m_bFileDropsEnabled = true;
4540 return true;
4541 }
4542
4543 bool CGitStatusListCtrl::HasPath(const CTGitPath& path)
4544 {
4545 for (size_t i=0; i < m_arStatusArray.size(); i++)
4546 {
4547 if (m_arStatusArray[i]->IsEquivalentTo(path))
4548 return true;
4549 }
4550
4551 return false;
4552 }
4553
4554 BOOL CGitStatusListCtrl::PreTranslateMessage(MSG* pMsg)
4555 {
4556 if (pMsg->message == WM_KEYDOWN)
4557 {
4558 switch (pMsg->wParam)
4559 {
4560 case 'A':
4561 {
4562 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
4563 {
4564 // select all entries
4565 for (int i=0; i<GetItemCount(); ++i)
4566 {
4567 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
4568 }
4569 return TRUE;
4570 }
4571 }
4572 break;
4573 case 'C':
4574 case VK_INSERT:
4575 {
4576 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
4577 {
4578 // copy all selected paths to the clipboard
4579 if (GetAsyncKeyState(VK_SHIFT)&0x8000)
4580 CopySelectedEntriesToClipboard(GITSLC_COLSTATUS);
4581 else
4582 CopySelectedEntriesToClipboard(0);
4583 return TRUE;
4584 }
4585 }
4586 break;
4587 }
4588 }
4589
4590 return CListCtrl::PreTranslateMessage(pMsg);
4591 }
4592
4593 bool CGitStatusListCtrl::CopySelectedEntriesToClipboard(DWORD dwCols)
4594 {
4595
4596 static HINSTANCE hResourceHandle(AfxGetResourceHandle());
4597 // WORD langID = (WORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
4598
4599 CString sClipboard;
4600 CString temp;
4601 //TCHAR buf[100];
4602 if (GetSelectedCount() == 0)
4603 return false;
4604
4605 // first add the column titles as the first line
4606 // We needn't head when only path copy
4607 //temp.LoadString(IDS_STATUSLIST_COLFILE);
4608 //sClipboard = temp;
4609
4610 DWORD selection = 0;
4611 for (int i = 0, count = m_ColumnManager.GetColumnCount(); i < count; ++i)
4612 if ( ((dwCols == -1) && m_ColumnManager.IsVisible (i))
4613 || ((dwCols != 1) && (i < 32) && ((dwCols & (1 << i)) != 0)))
4614 {
4615 sClipboard += _T("\t") + m_ColumnManager.GetName(i);
4616
4617 if (i < 32)
4618 selection += 1 << i;
4619 }
4620
4621 if(dwCols)
4622 sClipboard += _T("\r\n");
4623
4624 POSITION pos = GetFirstSelectedItemPosition();
4625 int index;
4626 while ((index = GetNextSelectedItem(pos)) >= 0)
4627 {
4628 CTGitPath * entry = (CTGitPath*)GetItemData(index);
4629 if(entry == NULL)
4630 continue;
4631
4632 sClipboard += entry->GetWinPathString();
4633 if (selection & GITSLC_COLFILENAME)
4634 {
4635 sClipboard += _T("\t")+entry->GetFileOrDirectoryName();
4636 }
4637 if (selection & GITSLC_COLEXT)
4638 {
4639 sClipboard += _T("\t")+entry->GetFileExtension();
4640 }
4641
4642 if (selection & GITSLC_COLSTATUS)
4643 {
4644 #if 0
4645 if (entry->isNested)
4646 {
4647 temp.LoadString(IDS_STATUSLIST_NESTED);
4648 }
4649 else
4650 {
4651 GitStatus::GetStatusString(hResourceHandle, entry->status, buf, _countof(buf), (WORD)langID);
4652 if ((entry->copied)&&(_tcslen(buf)>1))
4653 _tcscat_s(buf, 100, _T(" (+)"));
4654 if ((entry->switched)&&(_tcslen(buf)>1))
4655 _tcscat_s(buf, 100, _T(" (s)"));
4656 temp = buf;
4657 }
4658 #endif
4659 sClipboard += _T("\t")+entry->GetActionName();
4660 }
4661 #if 0
4662 if (selection & SVNSLC_COLTEXTSTATUS)
4663 {
4664
4665 if (entry->isNested)
4666 {
4667 temp.LoadString(IDS_STATUSLIST_NESTED);
4668 }
4669 else
4670 {
4671 GitStatus::GetStatusString(hResourceHandle, entry->textstatus, buf, _countof(buf), (WORD)langID);
4672 if ((entry->copied)&&(_tcslen(buf)>1))
4673 _tcscat_s(buf, 100, _T(" (+)"));
4674 if ((entry->switched)&&(_tcslen(buf)>1))
4675 _tcscat_s(buf, 100, _T(" (s)"));
4676 temp = buf;
4677 }
4678 sClipboard += _T("\t")+temp;
4679 }
4680 #endif
4681 #if 0
4682 if (selection & SVNSLC_COLREMOTESTATUS)
4683 {
4684 if (entry->isNested)
4685 {
4686 temp.LoadString(IDS_STATUSLIST_NESTED);
4687 }
4688 else
4689 {
4690 GitStatus::GetStatusString(hResourceHandle, entry->remotestatus, buf, _countof(buf), (WORD)langID);
4691 if ((entry->copied)&&(_tcslen(buf)>1))
4692 _tcscat_s(buf, 100, _T(" (+)"));
4693 if ((entry->switched)&&(_tcslen(buf)>1))
4694 _tcscat_s(buf, 100, _T(" (s)"));
4695 temp = buf;
4696 }
4697 sClipboard += _T("\t")+temp;
4698 }
4699 if (selection & GitSLC_COLPROPSTATUS)
4700 {
4701 if (entry->isNested)
4702 {
4703 temp.Empty();
4704 }
4705 else
4706 {
4707 GitStatus::GetStatusString(hResourceHandle, entry->propstatus, buf, _countof(buf), (WORD)langID);
4708 if ((entry->copied)&&(_tcslen(buf)>1))
4709 _tcscat_s(buf, 100, _T(" (+)"));
4710 if ((entry->switched)&&(_tcslen(buf)>1))
4711 _tcscat_s(buf, 100, _T(" (s)"));
4712 temp = buf;
4713 }
4714 sClipboard += _T("\t")+temp;
4715 }
4716 if (selection & SVNSLC_COLREMOTETEXT)
4717 {
4718 if (entry->isNested)
4719 {
4720 temp.Empty();
4721 }
4722 else
4723 {
4724 GitStatus::GetStatusString(hResourceHandle, entry->remotetextstatus, buf, _countof(buf), (WORD)langID);
4725 temp = buf;
4726 }
4727 sClipboard += _T("\t")+temp;
4728 }
4729 if (selection & SVNSLC_COLREMOTEPROP)
4730 {
4731 // SVNSLC_COLREMOTEPROP
4732 if (entry->isNested)
4733 {
4734 temp.Empty();
4735 }
4736 else
4737 {
4738 GitStatus::GetStatusString(hResourceHandle, entry->remotepropstatus, buf, _countof(buf), (WORD)langID);
4739 temp = buf;
4740 }
4741 sClipboard += _T("\t")+temp;
4742 }
4743 if (selection & SVNSLC_COLURL)
4744 sClipboard += _T("\t")+entry->url;
4745 if (selection & SVNSLC_COLLOCK)
4746 {
4747 if (!m_HeadRev.IsHead())
4748 {
4749 // we have contacted the repository
4750
4751 // decision-matrix
4752 // wc repository text
4753 // "" "" ""
4754 // "" UID1 owner
4755 // UID1 UID1 owner
4756 // UID1 "" lock has been broken
4757 // UID1 UID2 lock has been stolen
4758 if (entry->lock_token.IsEmpty() || (entry->lock_token.Compare(entry->lock_remotetoken)==0))
4759 {
4760 if (entry->lock_owner.IsEmpty())
4761 temp = entry->lock_remoteowner;
4762 else
4763 temp = entry->lock_owner;
4764 }
4765 else if (entry->lock_remotetoken.IsEmpty())
4766 {
4767 // broken lock
4768 temp.LoadString(IDS_STATUSLIST_LOCKBROKEN);
4769 }
4770 else
4771 {
4772 // stolen lock
4773 temp.Format(IDS_STATUSLIST_LOCKSTOLEN, (LPCTSTR)entry->lock_remoteowner);
4774 }
4775 }
4776 else
4777 temp = entry->lock_owner;
4778 sClipboard += _T("\t")+temp;
4779 }
4780 if (selection & SVNSLC_COLLOCKCOMMENT)
4781 sClipboard += _T("\t")+entry->lock_comment;
4782 if (selection & SVNSLC_COLAUTHOR)
4783 sClipboard += _T("\t")+entry->last_commit_author;
4784 if (selection & SVNSLC_COLREVISION)
4785 {
4786 temp.Format(_T("%ld"), entry->last_commit_rev);
4787 if (entry->last_commit_rev == 0)
4788 temp.Empty();
4789 sClipboard += _T("\t")+temp;
4790 }
4791 if (selection & SVNSLC_COLREMOTEREVISION)
4792 {
4793 temp.Format(_T("%ld"), entry->remoterev);
4794 if (entry->remoterev == 0)
4795 temp.Empty();
4796 sClipboard += _T("\t")+temp;
4797 }
4798
4799 if (selection & SVNSLC_COLDATE)
4800 {
4801 TCHAR datebuf[SVN_DATE_BUFFER];
4802 apr_time_t date = entry->last_commit_date;
4803 SVN::formatDate(datebuf, date, true);
4804 if (date)
4805 temp = datebuf;
4806 else
4807 temp.Empty();
4808 sClipboard += _T("\t")+temp;
4809 }
4810 if (selection & SVNSLC_COLCOPYFROM)
4811 {
4812 if (m_sURL.Compare(entry->copyfrom_url.Left(m_sURL.GetLength()))==0)
4813 temp = entry->copyfrom_url.Mid(m_sURL.GetLength());
4814 else
4815 temp = entry->copyfrom_url;
4816 sClipboard += _T("\t")+temp;
4817 }
4818
4819 for ( int i = SVNSLC_NUMCOLUMNS, count = m_ColumnManager.GetColumnCount()
4820 ; i < count
4821 ; ++i)
4822 {
4823 if ((dwCols == -1) && m_ColumnManager.IsVisible (i))
4824 {
4825 CString value
4826 = entry->present_props[m_ColumnManager.GetName(i)];
4827 sClipboard += _T("\t") + value;
4828 }
4829 }
4830 #endif
4831 if (selection & GITSLC_COLADD)
4832 {
4833 sClipboard += _T("\t")+entry->m_StatAdd;
4834 }
4835 if (selection & GITSLC_COLDEL)
4836 {
4837 sClipboard += _T("\t")+entry->m_StatDel;
4838 }
4839
4840 sClipboard += _T("\r\n");
4841 }
4842
4843 return CStringUtils::WriteAsciiStringToClipboard(sClipboard);
4844
4845 return TRUE;
4846
4847 }
4848
4849 size_t CGitStatusListCtrl::GetNumberOfChangelistsInSelection()
4850 {
4851 #if 0
4852 std::set<CString> changelists;
4853 POSITION pos = GetFirstSelectedItemPosition();
4854 int index;
4855 while ((index = GetNextSelectedItem(pos)) >= 0)
4856 {
4857 FileEntry * entry = GetListEntry(index);
4858 if (!entry->changelist.IsEmpty())
4859 changelists.insert(entry->changelist);
4860 }
4861 return changelists.size();
4862 #endif
4863 return 0;
4864 }
4865
4866 bool CGitStatusListCtrl::PrepareGroups(bool bForce /* = false */)
4867 {
4868
4869 bool bHasGroups=false;
4870 int max =0;
4871
4872 for(int i=0;i< this->m_arStatusArray.size(); i++)
4873 {
4874 int ParentNo = m_arStatusArray[i]->m_ParentNo&PARENT_MASK;
4875 if( ParentNo > max)
4876 max=m_arStatusArray[i]->m_ParentNo&PARENT_MASK;
4877 }
4878
4879 if ( this->m_UnRevFileList.GetCount()>0 ||
4880 this->m_IgnoreFileList.GetCount()>0 ||
4881 max>0 || bForce)
4882 {
4883 bHasGroups = true;
4884 }
4885
4886 RemoveAllGroups();
4887 EnableGroupView(bHasGroups);
4888
4889 TCHAR groupname[1024];
4890 int groupindex = 0;
4891
4892 if(bHasGroups)
4893 {
4894 LVGROUP grp = {0};
4895 grp.cbSize = sizeof(LVGROUP);
4896 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
4897 groupindex=0;
4898
4899 //if(m_UnRevFileList.GetCount()>0)
4900 if(max >0)
4901 {
4902 _tcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_MERGEDFILES)), 1023);
4903 grp.pszHeader = groupname;
4904 grp.iGroupId = MERGE_MASK;
4905 grp.uAlign = LVGA_HEADER_LEFT;
4906 InsertGroup(0, &grp);
4907
4908 for(int i=0;i<=max;i++)
4909 {
4910 CString str;
4911 str.Format(IDS_STATUSLIST_GROUP_DIFFWITHPARENT, i+1);
4912 grp.pszHeader = str.GetBuffer();
4913 str.ReleaseBuffer();
4914 grp.iGroupId = i;
4915 grp.uAlign = LVGA_HEADER_LEFT;
4916 InsertGroup(i+1, &grp);
4917 }
4918 }
4919 else
4920 {
4921 _tcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_MODIFIEDFILES)), 1023);
4922 grp.pszHeader = groupname;
4923 grp.iGroupId = groupindex;
4924 grp.uAlign = LVGA_HEADER_LEFT;
4925 InsertGroup(groupindex++, &grp);
4926
4927
4928 {
4929 _tcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_NOTVERSIONEDFILES)), 1023);
4930 grp.pszHeader = groupname;
4931 grp.iGroupId = groupindex;
4932 grp.uAlign = LVGA_HEADER_LEFT;
4933 InsertGroup(groupindex++, &grp);
4934 }
4935
4936 //if(m_IgnoreFileList.GetCount()>0)
4937 {
4938 _tcsncpy_s(groupname, 1024, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_GROUP_IGNOREDFILES)), 1023);
4939 grp.pszHeader = groupname;
4940 grp.iGroupId = groupindex;
4941 grp.uAlign = LVGA_HEADER_LEFT;
4942 InsertGroup(groupindex++, &grp);
4943 }
4944 }
4945 }
4946
4947 #if 0
4948 m_bHasIgnoreGroup = false;
4949
4950 // now add the items which don't belong to a group
4951 LVGROUP grp = {0};
4952 grp.cbSize = sizeof(LVGROUP);
4953 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
4954 CString sUnassignedName(MAKEINTRESOURCE(IDS_STATUSLIST_UNASSIGNED_CHANGESET));
4955 _tcsncpy_s(groupname, 1024, (LPCTSTR)sUnassignedName, 1023);
4956 grp.pszHeader = groupname;
4957 grp.iGroupId = groupindex;
4958 grp.uAlign = LVGA_HEADER_LEFT;
4959 InsertGroup(groupindex++, &grp);
4960
4961 for (std::map<CString,int>::iterator it = m_changelists.begin(); it != m_changelists.end(); ++it)
4962 {
4963 if (it->first.Compare(SVNSLC_IGNORECHANGELIST)!=0)
4964 {
4965 LVGROUP grp = {0};
4966 grp.cbSize = sizeof(LVGROUP);
4967 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
4968 _tcsncpy_s(groupname, 1024, it->first, 1023);
4969 grp.pszHeader = groupname;
4970 grp.iGroupId = groupindex;
4971 grp.uAlign = LVGA_HEADER_LEFT;
4972 it->second = InsertGroup(groupindex++, &grp);
4973 }
4974 else
4975 m_bHasIgnoreGroup = true;
4976 }
4977
4978 if (m_bHasIgnoreGroup)
4979 {
4980 // and now add the group 'ignore-on-commit'
4981 std::map<CString,int>::iterator it = m_changelists.find(SVNSLC_IGNORECHANGELIST);
4982 if (it != m_changelists.end())
4983 {
4984 grp.cbSize = sizeof(LVGROUP);
4985 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
4986 _tcsncpy_s(groupname, 1024, SVNSLC_IGNORECHANGELIST, 1023);
4987 grp.pszHeader = groupname;
4988 grp.iGroupId = groupindex;
4989 grp.uAlign = LVGA_HEADER_LEFT;
4990 it->second = InsertGroup(groupindex, &grp);
4991 }
4992 }
4993 #endif
4994 return bHasGroups;
4995 }
4996
4997 void CGitStatusListCtrl::NotifyCheck()
4998 {
4999 CWnd* pParent = GetParent();
5000 if (NULL != pParent && NULL != pParent->GetSafeHwnd())
5001 {
5002 pParent->SendMessage(GITSLNM_CHECKCHANGED, m_nSelected);
5003 }
5004 }
5005
5006 int CGitStatusListCtrl::UpdateFileList(git_revnum_t hash,CTGitPathList *list)
5007 {
5008 BYTE_VECTOR out;
5009 this->m_bBusy=TRUE;
5010 m_CurrentVersion=hash;
5011
5012 int count = 0;
5013 if(list == NULL)
5014 count = 1;
5015 else
5016 count = list->GetCount();
5017
5018 CString head = _T("HEAD");
5019 if(m_amend)
5020 head = _T("HEAD~1");
5021
5022 if(hash == GIT_REV_ZERO)
5023 {
5024 for(int i=0;i<count;i++)
5025 {
5026 BYTE_VECTOR cmdout;
5027 cmdout.clear();
5028 CString cmd;
5029 if(!g_Git.IsInitRepos())
5030 {
5031 // also list staged files which will be in the commit
5032 cmd=(_T("git.exe diff-index --cached --raw ") + head + _T(" --numstat -C -M -z"));
5033 g_Git.Run(cmd, &cmdout);
5034
5035 if(list == NULL)
5036 cmd=(_T("git.exe diff-index --raw ") + head + _T(" --numstat -C -M -z"));
5037 else
5038 cmd.Format(_T("git.exe diff-index --raw ") + head + _T(" --numstat -C -M -z -- \"%s\""),(*list)[i].GetGitPathString());
5039
5040 BYTE_VECTOR cmdErr;
5041 if(g_Git.Run(cmd, &cmdout, &cmdErr))
5042 {
5043 int last = cmdErr.RevertFind(0,-1);
5044 CString str;
5045 g_Git.StringAppend(&str, &cmdErr[last + 1], CP_UTF8, cmdErr.size() - last -1);
5046 CMessageBox::Show(NULL, str, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
5047 }
5048
5049 out.append(cmdout, 0);
5050 }
5051 else // Init Repository
5052 {
5053 //We will list all added file for init repository because commit will comit these
5054 //if(list == NULL)
5055 cmd=_T("git.exe ls-files -s -t -z");
5056 //else
5057 // cmd.Format(_T("git.exe ls-files -s -t -z -- \"%s\""),(*list)[i].GetGitPathString());
5058
5059 g_Git.Run(cmd, &cmdout);
5060 //out+=cmdout;
5061 out.append(cmdout,0);
5062 }
5063 }
5064
5065 if(g_Git.IsInitRepos())
5066 {
5067 m_StatusFileList.ParserFromLsFile(out);
5068 for(int i=0;i<m_StatusFileList.GetCount();i++)
5069 ((CTGitPath&)(m_StatusFileList[i])).m_Action=CTGitPath::LOGACTIONS_ADDED;
5070 }
5071 else
5072 this->m_StatusFileList.ParserFromLog(out);
5073
5074 //handle delete conflict case, when remote : modified, local : deleted.
5075 for(int i=0;i<count;i++)
5076 {
5077 BYTE_VECTOR cmdout;
5078 CString cmd;
5079
5080 if(list == NULL)
5081 cmd=_T("git.exe ls-files -u -t -z");
5082 else
5083 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),(*list)[i].GetGitPathString());
5084
5085 g_Git.Run(cmd, &cmdout);
5086
5087 CTGitPathList conflictlist;
5088 conflictlist.ParserFromLog(cmdout);
5089 for(int i=0;i<conflictlist.GetCount();i++)
5090 {
5091 CTGitPath *p=m_StatusFileList.LookForGitPath(conflictlist[i].GetGitPathString());
5092 if(p)
5093 p->m_Action|=CTGitPath::LOGACTIONS_UNMERGED;
5094 else
5095 m_StatusFileList.AddPath(conflictlist[i]);
5096 }
5097 }
5098
5099 // handle source files of file renames/moves (issue #860)
5100 // if a file gets renamed and the new file "git add"ed, diff-index doesn't list the source file anymore
5101 for(int i = 0; i < count; i++)
5102 {
5103 BYTE_VECTOR cmdout;
5104 CString cmd;
5105
5106 if(list == NULL)
5107 cmd = _T("git.exe ls-files -d -z");
5108 else
5109 cmd.Format(_T("git.exe ls-files -d -z -- \"%s\""),(*list)[i].GetGitPathString());
5110
5111 g_Git.Run(cmd, &cmdout);
5112
5113 CTGitPathList deletelist;
5114 deletelist.ParserFromLog(cmdout, true);
5115 for(int i = 0; i < deletelist.GetCount(); i++)
5116 {
5117 CTGitPath *p = m_StatusFileList.LookForGitPath(deletelist[i].GetGitPathString());
5118 if(!p)
5119 m_StatusFileList.AddPath(deletelist[i]);
5120 else if ((p->m_Action == CTGitPath::LOGACTIONS_ADDED || p->m_Action == CTGitPath::LOGACTIONS_REPLACED) && !p->Exists())
5121 {
5122 if (CMessageBox::Show(m_hWnd, _T("TortoiseGit detected that the file \"") + p->GetWinPathString() +_T("\" does not exist, but is staged as \"Added\".\nThe commit dialog cannot handle this.\n\nDo you want to remove it from the index?"), _T("TortoiseGit"), 1, IDI_EXCLAMATION, _T("&Remove file from index"), _T("&Ignore")) == 1)
5123 {
5124 g_Git.Run(_T("git.exe rm -f --cache -- \"") + p->GetWinPathString() + _T("\""), &cmdout);
5125 m_StatusFileList.RemoveItem(*p);
5126 }
5127 }
5128 }
5129 }
5130 }
5131 else
5132 {
5133 int count = 0;
5134 if(list == NULL)
5135 count = 1;
5136 else
5137 count = list->GetCount();
5138
5139 for(int i=0;i<count;i++)
5140 {
5141 BYTE_VECTOR cmdout;
5142 CString cmd;
5143 if(list == NULL)
5144 cmd.Format(_T("git.exe diff-tree --raw --numstat -C -M -z %s"),hash);
5145 else
5146 cmd.Format(_T("git.exe diff-tree --raw --numstat -C -M %s -z -- \"%s\""),hash,(*list)[i].GetGitPathString());
5147
5148 g_Git.Run(cmd, &cmdout, NULL);
5149
5150 out.append(cmdout);
5151 }
5152 this->m_StatusFileList.ParserFromLog(out);
5153
5154 }
5155
5156 for(int i=0;i<m_StatusFileList.GetCount();i++)
5157 {
5158 CTGitPath * gitpatch=(CTGitPath*)&m_StatusFileList[i];
5159 gitpatch->m_Checked = TRUE;
5160 m_arStatusArray.push_back((CTGitPath*)&m_StatusFileList[i]);
5161 }
5162
5163 this->m_bBusy=FALSE;
5164 return 0;
5165 }
5166
5167 int CGitStatusListCtrl::UpdateWithGitPathList(CTGitPathList &list)
5168 {
5169 m_arStatusArray.clear();
5170 for(int i=0;i<list.GetCount();i++)
5171 {
5172 CTGitPath * gitpath=(CTGitPath*)&list[i];
5173
5174 if(gitpath ->m_Action & CTGitPath::LOGACTIONS_HIDE)
5175 continue;
5176
5177 gitpath->m_Checked = TRUE;
5178 m_arStatusArray.push_back((CTGitPath*)&list[i]);
5179 }
5180 return 0;
5181 }
5182
5183 int CGitStatusListCtrl::UpdateUnRevFileList(CTGitPathList *List)
5184 {
5185 this->m_UnRevFileList.FillUnRev(CTGitPath::LOGACTIONS_UNVER,List);
5186 for(int i=0;i<m_UnRevFileList.GetCount();i++)
5187 {
5188 CTGitPath * gitpatch=(CTGitPath*)&m_UnRevFileList[i];
5189 gitpatch->m_Checked = FALSE;
5190 m_arStatusArray.push_back((CTGitPath*)&m_UnRevFileList[i]);
5191 }
5192 return 0;
5193 }
5194
5195 int CGitStatusListCtrl::UpdateIgnoreFileList(CTGitPathList *List)
5196 {
5197 this->m_IgnoreFileList.FillUnRev(CTGitPath::LOGACTIONS_UNVER|CTGitPath::LOGACTIONS_IGNORE,List);
5198 for(int i=0;i<m_IgnoreFileList.GetCount();i++)
5199 {
5200 CTGitPath * gitpatch=(CTGitPath*)&m_IgnoreFileList[i];
5201 gitpatch->m_Checked = FALSE;
5202 m_arStatusArray.push_back((CTGitPath*)&m_IgnoreFileList[i]);
5203 }
5204 return 0;
5205 }
5206 int CGitStatusListCtrl::UpdateFileList(int mask,bool once,CTGitPathList *List)
5207 {
5208 if(mask&CGitStatusListCtrl::FILELIST_MODIFY)
5209 {
5210 if(once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_MODIFY)))
5211 {
5212 UpdateFileList(git_revnum_t(GIT_REV_ZERO),List);
5213 m_FileLoaded|=CGitStatusListCtrl::FILELIST_MODIFY;
5214 }
5215 }
5216 if(mask&CGitStatusListCtrl::FILELIST_UNVER)
5217 {
5218 if(once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_UNVER)))
5219 {
5220 UpdateUnRevFileList(List);
5221 m_FileLoaded|=CGitStatusListCtrl::FILELIST_UNVER;
5222 }
5223 if(mask&CGitStatusListCtrl::FILELIST_IGNORE && (once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_IGNORE))))
5224 {
5225 UpdateIgnoreFileList(List);
5226 m_FileLoaded|=CGitStatusListCtrl::FILELIST_UNVER;
5227 }
5228 }
5229 return 0;
5230 }
5231
5232 void CGitStatusListCtrl::Clear()
5233 {
5234 m_FileLoaded=0;
5235 this->DeleteAllItems();
5236 this->m_arListArray.clear();
5237 this->m_arStatusArray.clear();
5238 this->m_changelists.clear();
5239 }
5240 //////////////////////////////////////////////////////////////////////////
5241 #if 0
5242 bool CGitStatusListCtrlDropTarget::OnDrop(FORMATETC* pFmtEtc, STGMEDIUM& medium, DWORD * /*pdwEffect*/, POINTL pt)
5243 {
5244 if(pFmtEtc->cfFormat == CF_HDROP && medium.tymed == TYMED_HGLOBAL)
5245 {
5246 HDROP hDrop = (HDROP)GlobalLock(medium.hGlobal);
5247 if(hDrop != NULL)
5248 {
5249 TCHAR szFileName[MAX_PATH];
5250
5251 UINT cFiles = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
5252
5253 POINT clientpoint;
5254 clientpoint.x = pt.x;
5255 clientpoint.y = pt.y;
5256 ScreenToClient(m_hTargetWnd, &clientpoint);
5257 if ((m_pSVNStatusListCtrl->IsGroupViewEnabled())&&(m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint) >= 0))
5258 {
5259 CTSVNPathList changelistItems;
5260 for(UINT i = 0; i < cFiles; ++i)
5261 {
5262 DragQueryFile(hDrop, i, szFileName, sizeof(szFileName));
5263 changelistItems.AddPath(CTSVNPath(szFileName));
5264 }
5265 // find the changelist name
5266 CString sChangelist;
5267 LONG_PTR nGroup = m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint);
5268 for (std::map<CString, int>::iterator it = m_pSVNStatusListCtrl->m_changelists.begin(); it != m_pSVNStatusListCtrl->m_changelists.end(); ++it)
5269 if (it->second == nGroup)
5270 sChangelist = it->first;
5271 if (!sChangelist.IsEmpty())
5272 {
5273 SVN git;
5274 if (git.AddToChangeList(changelistItems, sChangelist, git_depth_empty))
5275 {
5276 for (int l=0; l<changelistItems.GetCount(); ++l)
5277 {
5278 int index = m_pSVNStatusListCtrl->GetIndex(changelistItems[l]);
5279 if (index >= 0)
5280 {
5281 CSVNStatusListCtrl::FileEntry * e = m_pSVNStatusListCtrl->GetListEntry(index);
5282 if (e)
5283 {
5284 e->changelist = sChangelist;
5285 if (!e->IsFolder())
5286 {
5287 if (m_pSVNStatusListCtrl->m_changelists.find(e->changelist)!=m_pSVNStatusListCtrl->m_changelists.end())
5288 m_pSVNStatusListCtrl->SetItemGroup(index, m_pSVNStatusListCtrl->m_changelists[e->changelist]);
5289 else
5290 m_pSVNStatusListCtrl->SetItemGroup(index, 0);
5291 }
5292 }
5293 }
5294 else
5295 {
5296 HWND hParentWnd = GetParent(m_hTargetWnd);
5297 if (hParentWnd != NULL)
5298 ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)changelistItems[l].GetWinPath());
5299 }
5300 }
5301 }
5302 else
5303 {
5304 CMessageBox::Show(m_pSVNStatusListCtrl->m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
5305 }
5306 }
5307 else
5308 {
5309 SVN git;
5310 if (git.RemoveFromChangeList(changelistItems, CStringArray(), git_depth_empty))
5311 {
5312 for (int l=0; l<changelistItems.GetCount(); ++l)
5313 {
5314 int index = m_pSVNStatusListCtrl->GetIndex(changelistItems[l]);
5315 if (index >= 0)
5316 {
5317 CSVNStatusListCtrl::FileEntry * e = m_pSVNStatusListCtrl->GetListEntry(index);
5318 if (e)
5319 {
5320 e->changelist = sChangelist;
5321 m_pSVNStatusListCtrl->SetItemGroup(index, 0);
5322 }
5323 }
5324 else
5325 {
5326 HWND hParentWnd = GetParent(m_hTargetWnd);
5327 if (hParentWnd != NULL)
5328 ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)changelistItems[l].GetWinPath());
5329 }
5330 }
5331 }
5332 else
5333 {
5334 CMessageBox::Show(m_pSVNStatusListCtrl->m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
5335 }
5336 }
5337 }
5338 else
5339 {
5340 for(UINT i = 0; i < cFiles; ++i)
5341 {
5342 DragQueryFile(hDrop, i, szFileName, sizeof(szFileName));
5343 HWND hParentWnd = GetParent(m_hTargetWnd);
5344 if (hParentWnd != NULL)
5345 ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)szFileName);
5346 }
5347 }
5348 }
5349 GlobalUnlock(medium.hGlobal);
5350 }
5351 return true; //let base free the medium
5352 }
5353 HRESULT STDMETHODCALLTYPE CSVNStatusListCtrlDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD __RPC_FAR *pdwEffect)
5354 {
5355 CIDropTarget::DragOver(grfKeyState, pt, pdwEffect);
5356 *pdwEffect = DROPEFFECT_COPY;
5357 if (m_pSVNStatusListCtrl)
5358 {
5359 POINT clientpoint;
5360 clientpoint.x = pt.x;
5361 clientpoint.y = pt.y;
5362 ScreenToClient(m_hTargetWnd, &clientpoint);
5363 if ((m_pSVNStatusListCtrl->IsGroupViewEnabled())&&(m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint) >= 0))
5364 {
5365 *pdwEffect = DROPEFFECT_MOVE;
5366 }
5367 else if ((!m_pSVNStatusListCtrl->m_bFileDropsEnabled)||(m_pSVNStatusListCtrl->m_bOwnDrag))
5368 {
5369 *pdwEffect = DROPEFFECT_NONE;
5370 }
5371 }
5372 return S_OK;
5373 }f
5374
5375 #endif
5376
5377 void CGitStatusListCtrl::FileSaveAs(CTGitPath *path)
5378 {
5379 CString filename;
5380 filename.Format(_T("%s-%s%s"), path->GetBaseFilename(), this->m_CurrentVersion.Left(g_Git.GetShortHASHLength()), path->GetFileExtension());
5381 CFileDialog dlg(FALSE,NULL,
5382 filename,
5383 OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
5384 NULL);
5385 CString currentpath;
5386 currentpath=g_Git.m_CurrentDir+_T("\\");
5387 currentpath+=path->GetWinPathString();
5388
5389 dlg.m_ofn.lpstrInitialDir=currentpath.GetBuffer();
5390
5391 CString cmd,out;
5392 if(dlg.DoModal()==IDOK)
5393 {
5394 filename = dlg.GetPathName();
5395 if(m_CurrentVersion == GIT_REV_ZERO)
5396 {
5397 if(!CopyFile(g_Git.m_CurrentDir +_T("\\") + path->GetWinPath(),filename,false))
5398 {
5399 MessageBox(CFormatMessageWrapper(), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
5400 return;
5401 }
5402
5403 }
5404 else
5405 {
5406 if(g_Git.GetOneFile(m_CurrentVersion,*path,filename))
5407 {
5408 out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, path->GetGitPathString(), m_CurrentVersion, filename);
5409 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
5410 return;
5411 }
5412 }
5413 }
5414
5415 }
5416
5417 int CGitStatusListCtrl::RevertSelectedItemToVersion()
5418 {
5419 if(this->m_CurrentVersion.IsEmpty())
5420 return 0;
5421 if(this->m_CurrentVersion == GIT_REV_ZERO)
5422 return 0;
5423
5424 POSITION pos = GetFirstSelectedItemPosition();
5425 int index;
5426 CString cmd,out;
5427 int count =0;
5428 while ((index = GetNextSelectedItem(pos)) >= 0)
5429 {
5430 CTGitPath *fentry=(CTGitPath*)GetItemData(index);
5431 cmd.Format(_T("git.exe checkout %s -- \"%s\""),m_CurrentVersion,fentry->GetGitPathString());
5432 out.Empty();
5433 if (g_Git.Run(cmd, &out, CP_UTF8))
5434 {
5435 if (MessageBox(out, _T("TortoiseGit"), MB_ICONEXCLAMATION | MB_OKCANCEL) == IDCANCEL)
5436 break;
5437 }
5438 else
5439 count++;
5440 }
5441
5442 out.Format(IDS_STATUSLIST_FILESREVERTED, count, m_CurrentVersion);
5443 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
5444 return 0;
5445 }
5446
5447 void CGitStatusListCtrl::OpenFile(CTGitPath*filepath,int mode)
5448 {
5449 CString file;
5450 if(this->m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)
5451 {
5452 file= filepath->GetWinPath();
5453 }
5454 else
5455 {
5456 CString temppath;
5457 GetTempPath(temppath);
5458 file.Format(_T("%s%s_%s%s"),
5459 temppath,
5460 filepath->GetBaseFilename(),
5461 m_CurrentVersion.Left(g_Git.GetShortHASHLength()),
5462 filepath->GetFileExtension());
5463 CString cmd,out;
5464 if(g_Git.GetOneFile(m_CurrentVersion, *filepath, file))
5465 {
5466 out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, filepath->GetGitPathString(), m_CurrentVersion, file);
5467 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
5468 return;
5469 }
5470
5471 }
5472 if(mode == ALTERNATIVEEDITOR)
5473 {
5474 CAppUtils::LaunchAlternativeEditor(file);
5475 return;
5476 }
5477 int ret = HINSTANCE_ERROR;
5478
5479 if(mode == OPEN )
5480 {
5481 ret = (int)ShellExecute(this->m_hWnd, NULL,file, NULL, NULL, SW_SHOW);
5482
5483 if (ret > HINSTANCE_ERROR)
5484 {
5485 return;
5486 }
5487 }
5488
5489 {
5490 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");
5491 cmd += file;
5492 CAppUtils::LaunchApplication(cmd, NULL, false);
5493 }
5494
5495 }
Windows Explorer Extension to Operate Git