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