?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed issue #1105: Wrong status for missing files
[TortoiseGit.git] / src / Git / GitStatusListCtrl.cpp
blob798771eef06022623e8202d07bcbed7c43b35a1a
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 bothItemsAreExistingFiles = true;
1895 entry2 = (CTGitPath * )GetItemData(index);
1896 if (entry2)
1897 bothItemsAreExistingFiles = !entry2->IsDirectory() && entry2->Exists();
1898 index = GetNextSelectedItem(pos);
1899 if (index >= 0)
1900 {
1901 entry2 = (CTGitPath * )GetItemData(index);
1902 if (entry2)
1903 bothItemsAreExistingFiles = bothItemsAreExistingFiles && !entry2->IsDirectory() && entry2->Exists();
1904 if (bothItemsAreExistingFiles)
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 CMassiveGitTask 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 if (file1.m_ParentNo > 0)
3680 fromwhere.Format(_T("%s^%d"), m_CurrentVersion, file1.m_ParentNo + 1);
3681
3682 CGitDiff::DiffNull(&file1,fromwhere,false);
3683 }
3684 else
3685 {
3686 if( file1.m_ParentNo & MERGE_MASK)
3687 {
3688
3689 CTGitPath base,theirs, mine;
3690
3691 CTGitPath merge=file1;
3692 CTGitPath directory = merge.GetDirectory();
3693
3694 mine.SetFromGit(CAppUtils::GetMergeTempFile(_T("LOCAL"),merge));
3695 theirs.SetFromGit(CAppUtils::GetMergeTempFile(_T("REMOTE"),merge));
3696 base.SetFromGit(CAppUtils::GetMergeTempFile(_T("BASE"),merge));
3697
3698 CFile tempfile;
3699 //create a empty file, incase stage is not three
3700 tempfile.Open(mine.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
3701 tempfile.Close();
3702 tempfile.Open(theirs.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
3703 tempfile.Close();
3704 tempfile.Open(base.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
3705 tempfile.Close();
3706
3707 merge.SetFromGit(merge.GetGitPathString()+_T("Merged"));
3708
3709 int parent1=-1, parent2 =-1;
3710 for(int i=0;i<this->m_arStatusArray.size();i++)
3711 {
3712 if(m_arStatusArray[i]->GetGitPathString() == file1.GetGitPathString())
3713 {
3714 if(m_arStatusArray[i]->m_ParentNo & MERGE_MASK)
3715 {
3716 }
3717 else
3718 {
3719 if(parent1<0)
3720 {
3721 parent1 = m_arStatusArray[i]->m_ParentNo & PARENT_MASK;
3722 }
3723 else if (parent2 <0)
3724 {
3725 parent2 = m_arStatusArray[i]->m_ParentNo & PARENT_MASK;
3726 }
3727 }
3728 }
3729 }
3730
3731 if(g_Git.GetOneFile(m_CurrentVersion, file1, (CString&)merge.GetWinPathString()))
3732 {
3733 CMessageBox::Show(NULL, _T("Fail to get merge file"), _T("TortoiseGit"),MB_OK|MB_ICONERROR);
3734 }
3735
3736 if(parent1>=0)
3737 {
3738 CString str;
3739 str.Format(_T("%s^%d"),this->m_CurrentVersion, parent1+1);
3740
3741 if(g_Git.GetOneFile(str, file1, (CString&)mine.GetWinPathString()))
3742 {
3743 CMessageBox::Show(NULL, _T("Fail to get merge file"), _T("TortoiseGit"),MB_OK|MB_ICONERROR);
3744 }
3745 }
3746
3747 if(parent2>=0)
3748 {
3749 CString str;
3750 str.Format(_T("%s^%d"),this->m_CurrentVersion, parent2+1);
3751
3752 if(g_Git.GetOneFile(str, file1, (CString&)theirs.GetWinPathString()))
3753 {
3754 CMessageBox::Show(NULL, _T("Fail to get merge file"), _T("TortoiseGit"),MB_OK|MB_ICONERROR);
3755 }
3756 }
3757
3758 if(parent1>=0 && parent2>=0)
3759 {
3760 CString cmd, output;
3761 cmd.Format(_T("git.exe merge-base %s^%d %s^%d"), this->m_CurrentVersion, parent1+1,
3762 this->m_CurrentVersion,parent2+1);
3763
3764 if(g_Git.Run(cmd, &output, NULL, CP_ACP))
3765 {
3766 }
3767 else
3768 {
3769 if(g_Git.GetOneFile(output.Left(40), file1, (CString&)base.GetWinPathString()))
3770 {
3771 CMessageBox::Show(NULL, _T("Fail to get base file"), _T("TortoiseGit"),MB_OK|MB_ICONERROR);
3772 }
3773 }
3774 }
3775 CAppUtils::StartExtMerge(base, theirs, mine, merge,_T("BASE"),_T("REMOTE"),_T("LOCAL"));
3776
3777 }
3778 else
3779 {
3780 CString str;
3781 if( (file1.m_ParentNo&PARENT_MASK) == 0)
3782 {
3783 str = _T("~1");
3784 }
3785 else
3786 {
3787 str.Format(_T("^%d"), (file1.m_ParentNo&PARENT_MASK)+1);
3788 }
3789 CGitDiff::Diff(&file1,&file2,
3790 m_CurrentVersion,
3791 m_CurrentVersion+str);
3792 }
3793 }
3794 }
3795 #if 0
3796 if (fileindex < 0)
3797 return;
3798 FileEntry * entry = GetListEntry(fileindex);
3799 ASSERT(entry != NULL);
3800 if (entry == NULL)
3801 return;
3802 if (((entry->status == git_wc_status_normal)&&(entry->remotestatus <= git_wc_status_normal))||
3803 (entry->status == git_wc_status_unversioned)||(entry->status == git_wc_status_none))
3804 {
3805 int ret = (int)ShellExecute(this->m_hWnd, NULL, entry->path.GetWinPath(), NULL, NULL, SW_SHOW);
3806 if (ret <= HINSTANCE_ERROR)
3807 {
3808 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");
3809 cmd += entry->path.GetWinPathString();
3810 CAppUtils::LaunchApplication(cmd, NULL, false);
3811 }
3812 return;
3813 }
3814
3815 GitDiff diff(NULL, m_hWnd, true);
3816 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
3817 diff.DiffWCFile(
3818 entry->path, entry->textstatus, entry->propstatus,
3819 entry->remotetextstatus, entry->remotepropstatus);
3820 #endif
3821 }
3822
3823 CString CGitStatusListCtrl::GetStatisticsString(bool simple)
3824 {
3825
3826 CString sNormal, sAdded, sDeleted, sModified, sConflicted, sUnversioned, sRenamed;
3827 WORD langID = (WORD)(DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
3828 TCHAR buf[MAX_STATUS_STRING_LENGTH];
3829 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_normal, buf, _countof(buf), langID);
3830 sNormal = buf;
3831 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_added, buf, _countof(buf), langID);
3832 sAdded = buf;
3833 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_deleted, buf, _countof(buf), langID);
3834 sDeleted = buf;
3835 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_modified, buf, _countof(buf), langID);
3836 sModified = buf;
3837 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_conflicted, buf, _countof(buf), langID);
3838 sConflicted = buf;
3839 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_unversioned, buf, _countof(buf), langID);
3840 sUnversioned = buf;
3841 GitStatus::GetStatusString(AfxGetResourceHandle(), git_wc_status_replaced, buf, _countof(buf), langID);
3842 sRenamed = buf;
3843 CString sToolTip;
3844 if(simple)
3845 {
3846 sToolTip.Format(_T("line: %d(+) %d(-) files: %s = %d\n%s = %d\n%s = %d\n%s = %d"),
3847 this->m_nLineAdded,this->m_nLineDeleted,
3848 (LPCTSTR)sModified, m_nModified,
3849 (LPCTSTR)sAdded, m_nAdded,
3850 (LPCTSTR)sDeleted, m_nDeleted,
3851 (LPCTSTR)sRenamed, m_nRenamed
3852 );
3853 }
3854 else
3855 {
3856 sToolTip.Format(_T("line: %d(+) %d(-) files: %s = %d\n%s = %d\n%s = %d\n%s = %d\n%s = %d\n%s = %d"),
3857 this->m_nLineAdded,this->m_nLineDeleted,
3858 (LPCTSTR)sNormal, m_nNormal,
3859 (LPCTSTR)sUnversioned, m_nUnversioned,
3860 (LPCTSTR)sModified, m_nModified,
3861 (LPCTSTR)sAdded, m_nAdded,
3862 (LPCTSTR)sDeleted, m_nDeleted,
3863 (LPCTSTR)sConflicted, m_nConflicted
3864 );
3865 }
3866 CString sStats;
3867 sStats.Format(IDS_COMMITDLG_STATISTICSFORMAT, m_nSelected, GetItemCount());
3868 if (m_pStatLabel)
3869 {
3870 m_pStatLabel->SetWindowText(sStats);
3871 }
3872
3873 if (m_pSelectButton)
3874 {
3875 if (m_nSelected == 0)
3876 m_pSelectButton->SetCheck(BST_UNCHECKED);
3877 else if (m_nSelected != GetItemCount())
3878 m_pSelectButton->SetCheck(BST_INDETERMINATE);
3879 else
3880 m_pSelectButton->SetCheck(BST_CHECKED);
3881 }
3882
3883 if (m_pConfirmButton)
3884 {
3885 m_pConfirmButton->EnableWindow(m_nSelected>0);
3886 }
3887
3888 return sToolTip;
3889
3890
3891 }
3892
3893 CString CGitStatusListCtrl::GetCommonDirectory(bool bStrict)
3894 {
3895 if (!bStrict)
3896 {
3897 // not strict means that the selected folder has priority
3898 if (!m_StatusFileList.GetCommonDirectory().IsEmpty())
3899 return m_StatusFileList.GetCommonDirectory().GetWinPath();
3900 }
3901
3902 CTGitPath commonBaseDirectory;
3903 int nListItems = GetItemCount();
3904 for (int i=0; i<nListItems; ++i)
3905 {
3906 CTGitPath baseDirectory,*p= (CTGitPath*)this->GetItemData(i);
3907 ASSERT(p);
3908 if(p==NULL)
3909 continue;
3910 baseDirectory = p->GetDirectory();
3911
3912 if(commonBaseDirectory.IsEmpty())
3913 {
3914 commonBaseDirectory = baseDirectory;
3915 }
3916 else
3917 {
3918 if (commonBaseDirectory.GetWinPathString().GetLength() > baseDirectory.GetWinPathString().GetLength())
3919 {
3920 if (baseDirectory.IsAncestorOf(commonBaseDirectory))
3921 commonBaseDirectory = baseDirectory;
3922 }
3923 }
3924 }
3925 return g_Git.m_CurrentDir+CString(_T("\\"))+commonBaseDirectory.GetWinPath();
3926 }
3927
3928
3929 void CGitStatusListCtrl::SelectAll(bool bSelect, bool /*bIncludeNoCommits*/)
3930 {
3931 CWaitCursor waitCursor;
3932 // block here so the LVN_ITEMCHANGED messages
3933 // get ignored
3934 m_bBlock = TRUE;
3935 SetRedraw(FALSE);
3936
3937 int nListItems = GetItemCount();
3938 if (bSelect)
3939 m_nSelected = nListItems;
3940 else
3941 m_nSelected = 0;
3942
3943 for (int i=0; i<nListItems; ++i)
3944 {
3945 //FileEntry * entry = GetListEntry(i);
3946 //ASSERT(entry != NULL);
3947 CTGitPath *path = (CTGitPath *) GetItemData(i);
3948 if (path == NULL)
3949 continue;
3950 //if ((bIncludeNoCommits)||(entry->GetChangeList().Compare(SVNSLC_IGNORECHANGELIST)))
3951 SetEntryCheck(path,i,bSelect);
3952 }
3953
3954 // unblock before redrawing
3955 m_bBlock = FALSE;
3956 SetRedraw(TRUE);
3957 GetStatisticsString();
3958 NotifyCheck();
3959 }
3960
3961 void CGitStatusListCtrl::OnLvnGetInfoTip(NMHDR *pNMHDR, LRESULT *pResult)
3962 {
3963 LPNMLVGETINFOTIP pGetInfoTip = reinterpret_cast<LPNMLVGETINFOTIP>(pNMHDR);
3964 *pResult = 0;
3965 if (m_bBlock)
3966 return;
3967
3968 CTGitPath *entry=(CTGitPath *)GetItemData(pGetInfoTip->iItem);
3969
3970 if (entry)
3971 if (pGetInfoTip->cchTextMax > entry->GetGitPathString().GetLength() + g_Git.m_CurrentDir.GetLength())
3972 {
3973 CString str;
3974 str += g_Git.m_CurrentDir;
3975 str += _T("\\");
3976 str += entry->GetWinPathString();
3977
3978 _tcsncpy_s(pGetInfoTip->pszText, pGetInfoTip->cchTextMax, str.GetBuffer(), str.GetLength());
3979 }
3980 }
3981
3982 void CGitStatusListCtrl::OnNMCustomdraw(NMHDR *pNMHDR, LRESULT *pResult)
3983 {
3984 NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
3985
3986 // Take the default processing unless we set this to something else below.
3987 *pResult = CDRF_DODEFAULT;
3988
3989 // First thing - check the draw stage. If it's the control's prepaint
3990 // stage, then tell Windows we want messages for every item.
3991
3992 switch (pLVCD->nmcd.dwDrawStage)
3993 {
3994 case CDDS_PREPAINT:
3995 *pResult = CDRF_NOTIFYITEMDRAW;
3996 break;
3997 case CDDS_ITEMPREPAINT:
3998 {
3999 // This is the prepaint stage for an item. Here's where we set the
4000 // item's text color. Our return value will tell Windows to draw the
4001 // item itself, but it will use the new color we set here.
4002
4003 // Tell Windows to paint the control itself.
4004 *pResult = CDRF_DODEFAULT;
4005 if (m_bBlock)
4006 return;
4007
4008 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
4009
4010 if (m_arStatusArray.size() > (DWORD_PTR)pLVCD->nmcd.dwItemSpec)
4011 {
4012
4013 //FileEntry * entry = GetListEntry((int)pLVCD->nmcd.dwItemSpec);
4014 CTGitPath *entry=(CTGitPath *)GetItemData((int)pLVCD->nmcd.dwItemSpec);
4015 if (entry == NULL)
4016 return;
4017
4018 // coloring
4019 // ========
4020 // black : unversioned, normal
4021 // purple : added
4022 // blue : modified
4023 // brown : missing, deleted, replaced
4024 // green : merged (or potential merges)
4025 // red : conflicts or sure conflicts
4026 if(entry->m_Action & CTGitPath::LOGACTIONS_GRAY)
4027 {
4028 crText = RGB(128,128,128);
4029
4030 }
4031 else if(entry->m_Action & CTGitPath::LOGACTIONS_UNMERGED)
4032 {
4033 crText = m_Colors.GetColor(CColors::Conflict);
4034
4035 }
4036 else if(entry->m_Action & (CTGitPath::LOGACTIONS_MODIFIED))
4037 {
4038 crText = m_Colors.GetColor(CColors::Modified);
4039
4040 }
4041 else if(entry->m_Action & (CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_COPY))
4042 {
4043 crText = m_Colors.GetColor(CColors::Added);
4044 }
4045 else if(entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
4046 {
4047 crText = m_Colors.GetColor(CColors::DeletedNode);
4048 }
4049 else if(entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
4050 {
4051 crText = m_Colors.GetColor(CColors::RenamedNode);
4052 }
4053 else if(entry->m_Action & CTGitPath::LOGACTIONS_MERGED)
4054 {
4055 crText = m_Colors.GetColor(CColors::Merged);
4056 }
4057 else
4058 {
4059 crText = GetSysColor(COLOR_WINDOWTEXT);
4060 }
4061 // Store the color back in the NMLVCUSTOMDRAW struct.
4062 pLVCD->clrText = crText;
4063 }
4064 }
4065 break;
4066 }
4067 }
4068
4069 BOOL CGitStatusListCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
4070 {
4071 if (pWnd != this)
4072 return CListCtrl::OnSetCursor(pWnd, nHitTest, message);
4073 if (!m_bBlock)
4074 {
4075 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
4076 SetCursor(hCur);
4077 return CListCtrl::OnSetCursor(pWnd, nHitTest, message);
4078 }
4079 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));
4080 SetCursor(hCur);
4081 return TRUE;
4082 }
4083
4084 void CGitStatusListCtrl::RemoveListEntry(int index)
4085 {
4086
4087 Locker lock(m_critSec);
4088 DeleteItem(index);
4089
4090 m_arStatusArray.erase(m_arStatusArray.begin()+index);
4091
4092 #if 0
4093 delete m_arStatusArray[m_arListArray[index]];
4094 m_arStatusArray.erase(m_arStatusArray.begin()+m_arListArray[index]);
4095 m_arListArray.erase(m_arListArray.begin()+index);
4096 for (int i=index; i< (int)m_arListArray.size(); ++i)
4097 {
4098 m_arListArray[i]--;
4099 }
4100 #endif
4101 }
4102
4103 ///< Set a checkbox on an entry in the listbox
4104 // NEVER, EVER call SetCheck directly, because you'll end-up with the checkboxes and the 'checked' flag getting out of sync
4105 void CGitStatusListCtrl::SetEntryCheck(CTGitPath* pEntry, int listboxIndex, bool bCheck)
4106 {
4107 pEntry->m_Checked = bCheck;
4108 SetCheck(listboxIndex, bCheck);
4109 }
4110
4111 #if 0
4112 void CGitStatusListCtrl::SetCheckOnAllDescendentsOf(const FileEntry* parentEntry, bool bCheck)
4113 {
4114
4115 int nListItems = GetItemCount();
4116 for (int j=0; j< nListItems ; ++j)
4117 {
4118 FileEntry * childEntry = GetListEntry(j);
4119 ASSERT(childEntry != NULL);
4120 if (childEntry == NULL || childEntry == parentEntry)
4121 continue;
4122 if (childEntry->checked != bCheck)
4123 {
4124 if (parentEntry->path.IsAncestorOf(childEntry->path))
4125 {
4126 SetEntryCheck(childEntry,j,bCheck);
4127 if(bCheck)
4128 {
4129 m_nSelected++;
4130 }
4131 else
4132 {
4133 m_nSelected--;
4134 }
4135 }
4136 }
4137 }
4138
4139 }
4140 #endif
4141
4142 void CGitStatusListCtrl::WriteCheckedNamesToPathList(CTGitPathList& pathList)
4143 {
4144
4145 pathList.Clear();
4146 int nListItems = GetItemCount();
4147 for (int i=0; i< nListItems; i++)
4148 {
4149 CTGitPath * entry = (CTGitPath*)GetItemData(i);
4150 ASSERT(entry != NULL);
4151 if (entry->m_Checked)
4152 {
4153 pathList.AddPath(*entry);
4154 }
4155 }
4156 pathList.SortByPathname();
4157
4158 }
4159
4160
4161 /// Build a path list of all the selected items in the list (NOTE - SELECTED, not CHECKED)
4162 void CGitStatusListCtrl::FillListOfSelectedItemPaths(CTGitPathList& pathList, bool /*bNoIgnored*/)
4163 {
4164 pathList.Clear();
4165
4166 POSITION pos = GetFirstSelectedItemPosition();
4167 int index;
4168 while ((index = GetNextSelectedItem(pos)) >= 0)
4169 {
4170 CTGitPath * entry = (CTGitPath*)GetItemData(index);
4171 //if ((bNoIgnored)&&(entry->status == git_wc_status_ignored))
4172 // continue;
4173 pathList.AddPath(*entry);
4174 }
4175 }
4176
4177 UINT CGitStatusListCtrl::OnGetDlgCode()
4178 {
4179 // we want to process the return key and not have that one
4180 // routed to the default pushbutton
4181 return CListCtrl::OnGetDlgCode() | DLGC_WANTALLKEYS;
4182 }
4183
4184 void CGitStatusListCtrl::OnNMReturn(NMHDR * /*pNMHDR*/, LRESULT *pResult)
4185 {
4186 *pResult = 0;
4187 if (m_bBlock)
4188 return;
4189 POSITION pos = GetFirstSelectedItemPosition();
4190 while ( pos )
4191 {
4192 int index = GetNextSelectedItem(pos);
4193 CTGitPath *file=(CTGitPath*)GetItemData(index);
4194 if (file->m_Action == CTGitPath::LOGACTIONS_UNVER)
4195 {
4196 OpenFile(file, OPEN);
4197 }
4198 else
4199 {
4200 StartDiff(index);
4201 }
4202 }
4203 }
4204
4205 void CGitStatusListCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
4206 {
4207 // Since we catch all keystrokes (to have the enter key processed here instead
4208 // of routed to the default pushbutton) we have to make sure that other
4209 // keys like Tab and Esc still do what they're supposed to do
4210 // Tab = change focus to next/previous control
4211 // Esc = quit the dialog
4212 switch (nChar)
4213 {
4214 case (VK_TAB):
4215 {
4216 ::PostMessage(GetParent()->GetSafeHwnd(), WM_NEXTDLGCTL, GetKeyState(VK_SHIFT)&0x8000, 0);
4217 return;
4218 }
4219 break;
4220 case (VK_ESCAPE):
4221 {
4222 ::SendMessage(GetParent()->GetSafeHwnd(), WM_CLOSE, 0, 0);
4223 }
4224 break;
4225 }
4226
4227 CListCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
4228 }
4229
4230 void CGitStatusListCtrl::PreSubclassWindow()
4231 {
4232 CListCtrl::PreSubclassWindow();
4233 EnableToolTips(TRUE);
4234 SetWindowTheme(GetSafeHwnd(), L"Explorer", NULL);
4235 }
4236
4237 INT_PTR CGitStatusListCtrl::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
4238 {
4239 int row, col;
4240 RECT cellrect;
4241 row = CellRectFromPoint(point, &cellrect, &col );
4242
4243 if (row == -1)
4244 return -1;
4245
4246
4247 pTI->hwnd = m_hWnd;
4248 pTI->uId = (UINT)((row<<10)+(col&0x3ff)+1);
4249 pTI->lpszText = LPSTR_TEXTCALLBACK;
4250
4251 pTI->rect = cellrect;
4252
4253 return pTI->uId;
4254 }
4255
4256 int CGitStatusListCtrl::CellRectFromPoint(CPoint& point, RECT *cellrect, int *col) const
4257 {
4258 int colnum;
4259
4260 // Make sure that the ListView is in LVS_REPORT
4261 if ((GetWindowLong(m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
4262 return -1;
4263
4264 // Get the top and bottom row visible
4265 int row = GetTopIndex();
4266 int bottom = row + GetCountPerPage();
4267 if (bottom > GetItemCount())
4268 bottom = GetItemCount();
4269
4270 // Get the number of columns
4271 CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
4272 int nColumnCount = pHeader->GetItemCount();
4273
4274 // Loop through the visible rows
4275 for ( ;row <=bottom;row++)
4276 {
4277 // Get bounding rect of item and check whether point falls in it.
4278 CRect rect;
4279 GetItemRect(row, &rect, LVIR_BOUNDS);
4280 if (rect.PtInRect(point))
4281 {
4282 // Now find the column
4283 for (colnum = 0; colnum < nColumnCount; colnum++)
4284 {
4285 int colwidth = GetColumnWidth(colnum);
4286 if (point.x >= rect.left && point.x <= (rect.left + colwidth))
4287 {
4288 RECT rectClient;
4289 GetClientRect(&rectClient);
4290 if (col)
4291 *col = colnum;
4292 rect.right = rect.left + colwidth;
4293
4294 // Make sure that the right extent does not exceed
4295 // the client area
4296 if (rect.right > rectClient.right)
4297 rect.right = rectClient.right;
4298 *cellrect = rect;
4299 return row;
4300 }
4301 rect.left += colwidth;
4302 }
4303 }
4304 }
4305 return -1;
4306 }
4307
4308 BOOL CGitStatusListCtrl::OnToolTipText(UINT /*id*/, NMHDR* /*pNMHDR*/, LRESULT* /*pResult*/)
4309 {
4310 #if 0
4311 TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
4312 CString strTipText;
4313 UINT_PTR nID = pNMHDR->idFrom;
4314
4315 if (nID == 0)
4316 return FALSE;
4317
4318 UINT_PTR row = ((nID-1) >> 10) & 0x3fffff;
4319 UINT_PTR col = (nID-1) & 0x3ff;
4320
4321 if (col == 0)
4322 return FALSE; // no custom tooltip for the path, we use the infotip there!
4323
4324 // get the internal column from the visible columns
4325 int internalcol = 0;
4326 UINT_PTR currentcol = 0;
4327 for (; (currentcol != col)
4328 && (internalcol < m_ColumnManager.GetColumnCount()-1)
4329 ; ++internalcol)
4330 {
4331 if (m_ColumnManager.IsVisible (internalcol))
4332 currentcol++;
4333 }
4334
4335 AFX_MODULE_THREAD_STATE* pModuleThreadState = AfxGetModuleThreadState();
4336 CToolTipCtrl* pToolTip = pModuleThreadState->m_pToolTip;
4337 pToolTip->SendMessage(TTM_SETMAXTIPWIDTH, 0, 300);
4338
4339 *pResult = 0;
4340 if ((internalcol == 2)||(internalcol == 4))
4341 {
4342 FileEntry *fentry = GetListEntry(row);
4343 if (fentry)
4344 {
4345 if (fentry->copied)
4346 {
4347 CString url;
4348 url.Format(IDS_STATUSLIST_COPYFROM, (LPCTSTR)CPathUtils::PathUnescape(fentry->copyfrom_url), (LONG)fentry->copyfrom_rev);
4349 lstrcpyn(pTTTW->szText, (LPCTSTR)url, 80);
4350 return TRUE;
4351 }
4352 if (fentry->switched)
4353 {
4354 CString url;
4355 url.Format(IDS_STATUSLIST_SWITCHEDTO, (LPCTSTR)CPathUtils::PathUnescape(fentry->url));
4356 lstrcpyn(pTTTW->szText, (LPCTSTR)url, 80);
4357 return TRUE;
4358 }
4359 if (fentry->keeplocal)
4360 {
4361 lstrcpyn(pTTTW->szText, (LPCTSTR)CString(MAKEINTRESOURCE(IDS_STATUSLIST_KEEPLOCAL)), 80);
4362 return TRUE;
4363 }
4364 }
4365 }
4366 #endif
4367 return FALSE;
4368 }
4369
4370 void CGitStatusListCtrl::OnPaint()
4371 {
4372 Default();
4373 if ((m_bBusy)||(m_bEmpty))
4374 {
4375 CString str;
4376 if (m_bBusy)
4377 {
4378 if (m_sBusy.IsEmpty())
4379 str.LoadString(IDS_STATUSLIST_BUSYMSG);
4380 else
4381 str = m_sBusy;
4382 }
4383 else
4384 {
4385 if (m_sEmpty.IsEmpty())
4386 str.LoadString(IDS_STATUSLIST_EMPTYMSG);
4387 else
4388 str = m_sEmpty;
4389 }
4390 COLORREF clrText = ::GetSysColor(COLOR_WINDOWTEXT);
4391 COLORREF clrTextBk;
4392 if (IsWindowEnabled())
4393 clrTextBk = ::GetSysColor(COLOR_WINDOW);
4394 else
4395 clrTextBk = ::GetSysColor(COLOR_3DFACE);
4396
4397 CRect rc;
4398 GetClientRect(&rc);
4399 CHeaderCtrl* pHC;
4400 pHC = GetHeaderCtrl();
4401 if (pHC != NULL)
4402 {
4403 CRect rcH;
4404 pHC->GetItemRect(0, &rcH);
4405 rc.top += rcH.bottom;
4406 }
4407 CDC* pDC = GetDC();
4408 {
4409 CMyMemDC memDC(pDC, &rc);
4410
4411 memDC.SetTextColor(clrText);
4412 memDC.SetBkColor(clrTextBk);
4413 memDC.FillSolidRect(rc, clrTextBk);
4414 rc.top += 10;
4415 CGdiObject * oldfont = memDC.SelectStockObject(DEFAULT_GUI_FONT);
4416 memDC.DrawText(str, rc, DT_CENTER | DT_VCENTER |
4417 DT_WORDBREAK | DT_NOPREFIX | DT_NOCLIP);
4418 memDC.SelectObject(oldfont);
4419 }
4420 ReleaseDC(pDC);
4421 }
4422 }
4423
4424 // prevent users from extending our hidden (size 0) columns
4425 void CGitStatusListCtrl::OnHdnBegintrack(NMHDR *pNMHDR, LRESULT *pResult)
4426 {
4427 m_ColumnManager.OnHdnBegintrack(pNMHDR, pResult);
4428 }
4429
4430 // prevent any function from extending our hidden (size 0) columns
4431 void CGitStatusListCtrl::OnHdnItemchanging(NMHDR *pNMHDR, LRESULT *pResult)
4432 {
4433 if(!m_ColumnManager.OnHdnItemchanging(pNMHDR, pResult))
4434 Default();
4435 }
4436
4437 void CGitStatusListCtrl::OnDestroy()
4438 {
4439 SaveColumnWidths(true);
4440 CListCtrl::OnDestroy();
4441 }
4442
4443 void CGitStatusListCtrl::OnBeginDrag(NMHDR* /*pNMHDR*/, LRESULT* pResult)
4444 {
4445 #if 0
4446 Locker lock(m_critSec);
4447 CDropFiles dropFiles; // class for creating DROPFILES struct
4448
4449 int index;
4450 POSITION pos = GetFirstSelectedItemPosition();
4451 while ( (index = GetNextSelectedItem(pos)) >= 0 )
4452 {
4453 FileEntry * fentry = m_arStatusArray[m_arListArray[index]];
4454 CTGitPath path = fentry->GetPath();
4455 dropFiles.AddFile( path.GetWinPathString() );
4456 }
4457
4458 if ( dropFiles.GetCount()>0 )
4459 {
4460 m_bOwnDrag = true;
4461 dropFiles.CreateStructure();
4462 m_bOwnDrag = false;
4463 }
4464 #endif
4465 *pResult = 0;
4466 }
4467
4468 void CGitStatusListCtrl::SaveColumnWidths(bool bSaveToRegistry /* = false */)
4469 {
4470 int maxcol = ((CHeaderCtrl*)(GetDlgItem(0)))->GetItemCount()-1;
4471 for (int col = 0; col <= maxcol; col++)
4472 if (m_ColumnManager.IsVisible (col))
4473 m_ColumnManager.ColumnResized (col);
4474
4475 if (bSaveToRegistry)
4476 m_ColumnManager.WriteSettings();
4477 }
4478
4479 bool CGitStatusListCtrl::EnableFileDrop()
4480 {
4481 m_bFileDropsEnabled = true;
4482 return true;
4483 }
4484
4485 bool CGitStatusListCtrl::HasPath(const CTGitPath& path)
4486 {
4487 for (size_t i=0; i < m_arStatusArray.size(); i++)
4488 {
4489 if (m_arStatusArray[i]->IsEquivalentTo(path))
4490 return true;
4491 }
4492
4493 return false;
4494 }
4495
4496 BOOL CGitStatusListCtrl::PreTranslateMessage(MSG* pMsg)
4497 {
4498 if (pMsg->message == WM_KEYDOWN)
4499 {
4500 switch (pMsg->wParam)
4501 {
4502 case 'A':
4503 {
4504 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
4505 {
4506 // select all entries
4507 for (int i=0; i<GetItemCount(); ++i)
4508 {
4509 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
4510 }
4511 return TRUE;
4512 }
4513 }
4514 break;
4515 case 'C':
4516 case VK_INSERT:
4517 {
4518 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
4519 {
4520 // copy all selected paths to the clipboard
4521 if (GetAsyncKeyState(VK_SHIFT)&0x8000)
4522 CopySelectedEntriesToClipboard(GITSLC_COLSTATUS);
4523 else
4524 CopySelectedEntriesToClipboard(0);
4525 return TRUE;
4526 }
4527 }
4528 break;
4529 }
4530 }
4531
4532 return CListCtrl::PreTranslateMessage(pMsg);
4533 }
4534
4535 bool CGitStatusListCtrl::CopySelectedEntriesToClipboard(DWORD dwCols)
4536 {
4537
4538 static CString ponly(MAKEINTRESOURCE(IDS_STATUSLIST_PROPONLY));
4539 static HINSTANCE hResourceHandle(AfxGetResourceHandle());
4540 // WORD langID = (WORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
4541
4542 CString sClipboard;
4543 CString temp;
4544 //TCHAR buf[100];
4545 if (GetSelectedCount() == 0)
4546 return false;
4547
4548 // first add the column titles as the first line
4549 // We needn't head when only path copy
4550 //temp.LoadString(IDS_STATUSLIST_COLFILE);
4551 //sClipboard = temp;
4552
4553 DWORD selection = 0;
4554 for (int i = 0, count = m_ColumnManager.GetColumnCount(); i < count; ++i)
4555 if ( ((dwCols == -1) && m_ColumnManager.IsVisible (i))
4556 || ((dwCols != 1) && (i < 32) && ((dwCols & (1 << i)) != 0)))
4557 {
4558 sClipboard += _T("\t") + m_ColumnManager.GetName(i);
4559
4560 if (i < 32)
4561 selection += 1 << i;
4562 }
4563
4564 if(dwCols)
4565 sClipboard += _T("\r\n");
4566
4567 POSITION pos = GetFirstSelectedItemPosition();
4568 int index;
4569 while ((index = GetNextSelectedItem(pos)) >= 0)
4570 {
4571 CTGitPath * entry = (CTGitPath*)GetItemData(index);
4572 if(entry == NULL)
4573 continue;
4574
4575 sClipboard += entry->GetWinPathString();
4576 if (selection & GITSLC_COLFILENAME)
4577 {
4578 sClipboard += _T("\t")+entry->GetFileOrDirectoryName();
4579 }
4580 if (selection & GITSLC_COLEXT)
4581 {
4582 sClipboard += _T("\t")+entry->GetFileExtension();
4583 }
4584
4585 if (selection & GITSLC_COLSTATUS)
4586 {
4587 #if 0
4588 if (entry->isNested)
4589 {
4590 temp.LoadString(IDS_STATUSLIST_NESTED);
4591 }
4592 else
4593 {
4594 GitStatus::GetStatusString(hResourceHandle, entry->status, buf, _countof(buf), (WORD)langID);
4595 if ((entry->copied)&&(_tcslen(buf)>1))
4596 _tcscat_s(buf, 100, _T(" (+)"));
4597 if ((entry->switched)&&(_tcslen(buf)>1))
4598 _tcscat_s(buf, 100, _T(" (s)"));
4599 if ((entry->status == entry->propstatus)&&
4600 (entry->status != git_wc_status_normal)&&
4601 (entry->status != git_wc_status_unversioned)&&
4602 (!GitStatus::IsImportant(entry->textstatus)))
4603 _tcscat_s(buf, 100, ponly);
4604 temp = buf;
4605 }
4606 #endif
4607 sClipboard += _T("\t")+entry->GetActionName();
4608 }
4609 #if 0
4610 if (selection & SVNSLC_COLTEXTSTATUS)
4611 {
4612
4613 if (entry->isNested)
4614 {
4615 temp.LoadString(IDS_STATUSLIST_NESTED);
4616 }
4617 else
4618 {
4619 GitStatus::GetStatusString(hResourceHandle, entry->textstatus, buf, _countof(buf), (WORD)langID);
4620 if ((entry->copied)&&(_tcslen(buf)>1))
4621 _tcscat_s(buf, 100, _T(" (+)"));
4622 if ((entry->switched)&&(_tcslen(buf)>1))
4623 _tcscat_s(buf, 100, _T(" (s)"));
4624 temp = buf;
4625 }
4626 sClipboard += _T("\t")+temp;
4627 }
4628 #endif
4629 #if 0
4630 if (selection & SVNSLC_COLREMOTESTATUS)
4631 {
4632 if (entry->isNested)
4633 {
4634 temp.LoadString(IDS_STATUSLIST_NESTED);
4635 }
4636 else
4637 {
4638 GitStatus::GetStatusString(hResourceHandle, entry->remotestatus, buf, _countof(buf), (WORD)langID);
4639 if ((entry->copied)&&(_tcslen(buf)>1))
4640 _tcscat_s(buf, 100, _T(" (+)"));
4641 if ((entry->switched)&&(_tcslen(buf)>1))
4642 _tcscat_s(buf, 100, _T(" (s)"));
4643 if ((entry->remotestatus == entry->remotepropstatus)&&
4644 (entry->remotestatus != git_wc_status_none)&&
4645 (entry->remotestatus != git_wc_status_normal)&&
4646 (entry->remotestatus != git_wc_status_unversioned)&&
4647 (!SVNStatus::IsImportant(entry->remotetextstatus)))
4648 _tcscat_s(buf, 100, ponly);
4649 temp = buf;
4650 }
4651 sClipboard += _T("\t")+temp;
4652 }
4653 if (selection & GitSLC_COLPROPSTATUS)
4654 {
4655 if (entry->isNested)
4656 {
4657 temp.Empty();
4658 }
4659 else
4660 {
4661 GitStatus::GetStatusString(hResourceHandle, entry->propstatus, buf, _countof(buf), (WORD)langID);
4662 if ((entry->copied)&&(_tcslen(buf)>1))
4663 _tcscat_s(buf, 100, _T(" (+)"));
4664 if ((entry->switched)&&(_tcslen(buf)>1))
4665 _tcscat_s(buf, 100, _T(" (s)"));
4666 temp = buf;
4667 }
4668 sClipboard += _T("\t")+temp;
4669 }
4670 if (selection & SVNSLC_COLREMOTETEXT)
4671 {
4672 if (entry->isNested)
4673 {
4674 temp.Empty();
4675 }
4676 else
4677 {
4678 GitStatus::GetStatusString(hResourceHandle, entry->remotetextstatus, buf, _countof(buf), (WORD)langID);
4679 temp = buf;
4680 }
4681 sClipboard += _T("\t")+temp;
4682 }
4683 if (selection & SVNSLC_COLREMOTEPROP)
4684 {
4685 // SVNSLC_COLREMOTEPROP
4686 if (entry->isNested)
4687 {
4688 temp.Empty();
4689 }
4690 else
4691 {
4692 GitStatus::GetStatusString(hResourceHandle, entry->remotepropstatus, buf, _countof(buf), (WORD)langID);
4693 temp = buf;
4694 }
4695 sClipboard += _T("\t")+temp;
4696 }
4697 if (selection & SVNSLC_COLURL)
4698 sClipboard += _T("\t")+entry->url;
4699 if (selection & SVNSLC_COLLOCK)
4700 {
4701 if (!m_HeadRev.IsHead())
4702 {
4703 // we have contacted the repository
4704
4705 // decision-matrix
4706 // wc repository text
4707 // "" "" ""
4708 // "" UID1 owner
4709 // UID1 UID1 owner
4710 // UID1 "" lock has been broken
4711 // UID1 UID2 lock has been stolen
4712 if (entry->lock_token.IsEmpty() || (entry->lock_token.Compare(entry->lock_remotetoken)==0))
4713 {
4714 if (entry->lock_owner.IsEmpty())
4715 temp = entry->lock_remoteowner;
4716 else
4717 temp = entry->lock_owner;
4718 }
4719 else if (entry->lock_remotetoken.IsEmpty())
4720 {
4721 // broken lock
4722 temp.LoadString(IDS_STATUSLIST_LOCKBROKEN);
4723 }
4724 else
4725 {
4726 // stolen lock
4727 temp.Format(IDS_STATUSLIST_LOCKSTOLEN, (LPCTSTR)entry->lock_remoteowner);
4728 }
4729 }
4730 else
4731 temp = entry->lock_owner;
4732 sClipboard += _T("\t")+temp;
4733 }
4734 if (selection & SVNSLC_COLLOCKCOMMENT)
4735 sClipboard += _T("\t")+entry->lock_comment;
4736 if (selection & SVNSLC_COLAUTHOR)
4737 sClipboard += _T("\t")+entry->last_commit_author;
4738 if (selection & SVNSLC_COLREVISION)
4739 {
4740 temp.Format(_T("%ld"), entry->last_commit_rev);
4741 if (entry->last_commit_rev == 0)
4742 temp.Empty();
4743 sClipboard += _T("\t")+temp;
4744 }
4745 if (selection & SVNSLC_COLREMOTEREVISION)
4746 {
4747 temp.Format(_T("%ld"), entry->remoterev);
4748 if (entry->remoterev == 0)
4749 temp.Empty();
4750 sClipboard += _T("\t")+temp;
4751 }
4752
4753 if (selection & SVNSLC_COLDATE)
4754 {
4755 TCHAR datebuf[SVN_DATE_BUFFER];
4756 apr_time_t date = entry->last_commit_date;
4757 SVN::formatDate(datebuf, date, true);
4758 if (date)
4759 temp = datebuf;
4760 else
4761 temp.Empty();
4762 sClipboard += _T("\t")+temp;
4763 }
4764 if (selection & SVNSLC_COLCOPYFROM)
4765 {
4766 if (m_sURL.Compare(entry->copyfrom_url.Left(m_sURL.GetLength()))==0)
4767 temp = entry->copyfrom_url.Mid(m_sURL.GetLength());
4768 else
4769 temp = entry->copyfrom_url;
4770 sClipboard += _T("\t")+temp;
4771 }
4772
4773 for ( int i = SVNSLC_NUMCOLUMNS, count = m_ColumnManager.GetColumnCount()
4774 ; i < count
4775 ; ++i)
4776 {
4777 if ((dwCols == -1) && m_ColumnManager.IsVisible (i))
4778 {
4779 CString value
4780 = entry->present_props[m_ColumnManager.GetName(i)];
4781 sClipboard += _T("\t") + value;
4782 }
4783 }
4784 #endif
4785 if (selection & GITSLC_COLADD)
4786 {
4787 sClipboard += _T("\t")+entry->m_StatAdd;
4788 }
4789 if (selection & GITSLC_COLDEL)
4790 {
4791 sClipboard += _T("\t")+entry->m_StatDel;
4792 }
4793
4794 sClipboard += _T("\r\n");
4795 }
4796
4797 return CStringUtils::WriteAsciiStringToClipboard(sClipboard);
4798
4799 return TRUE;
4800
4801 }
4802
4803 size_t CGitStatusListCtrl::GetNumberOfChangelistsInSelection()
4804 {
4805 #if 0
4806 std::set<CString> changelists;
4807 POSITION pos = GetFirstSelectedItemPosition();
4808 int index;
4809 while ((index = GetNextSelectedItem(pos)) >= 0)
4810 {
4811 FileEntry * entry = GetListEntry(index);
4812 if (!entry->changelist.IsEmpty())
4813 changelists.insert(entry->changelist);
4814 }
4815 return changelists.size();
4816 #endif
4817 return 0;
4818 }
4819
4820 bool CGitStatusListCtrl::PrepareGroups(bool bForce /* = false */)
4821 {
4822
4823 bool bHasGroups=false;
4824 int max =0;
4825
4826 for(int i=0;i< this->m_arStatusArray.size(); i++)
4827 {
4828 int ParentNo = m_arStatusArray[i]->m_ParentNo&PARENT_MASK;
4829 if( ParentNo > max)
4830 max=m_arStatusArray[i]->m_ParentNo&PARENT_MASK;
4831 }
4832
4833 if ( this->m_UnRevFileList.GetCount()>0 ||
4834 this->m_IgnoreFileList.GetCount()>0 ||
4835 max>0 || bForce)
4836 {
4837 bHasGroups = true;
4838 }
4839
4840 RemoveAllGroups();
4841 EnableGroupView(bHasGroups);
4842
4843 TCHAR groupname[1024];
4844 int groupindex = 0;
4845
4846 if(bHasGroups)
4847 {
4848 LVGROUP grp = {0};
4849 grp.cbSize = sizeof(LVGROUP);
4850 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
4851 groupindex=0;
4852
4853 //if(m_UnRevFileList.GetCount()>0)
4854 if(max >0)
4855 {
4856 grp.pszHeader = _T("Merged Files");
4857 grp.iGroupId = MERGE_MASK;
4858 grp.uAlign = LVGA_HEADER_LEFT;
4859 InsertGroup(0, &grp);
4860
4861 for(int i=0;i<=max;i++)
4862 {
4863 CString str;
4864 str.Format(_T("Diff with parent %d"), i+1);
4865 //_tcsncpy_s(groupname, 1024, (LPCTSTR)_T("Not Versioned"), 1023);
4866 grp.pszHeader = str.GetBuffer();
4867 grp.iGroupId = i;
4868 grp.uAlign = LVGA_HEADER_LEFT;
4869 InsertGroup(i+1, &grp);
4870 }
4871 }
4872 else
4873 {
4874 CString sUnassignedName(_T("Modified File"));
4875 _tcsncpy_s(groupname, 1024, (LPCTSTR)sUnassignedName, 1023);
4876 grp.pszHeader = groupname;
4877 grp.iGroupId = groupindex;
4878 grp.uAlign = LVGA_HEADER_LEFT;
4879 InsertGroup(groupindex++, &grp);
4880
4881
4882 {
4883 _tcsncpy_s(groupname, 1024, (LPCTSTR)_T("Not Versioned"), 1023);
4884 grp.pszHeader = groupname;
4885 grp.iGroupId = groupindex;
4886 grp.uAlign = LVGA_HEADER_LEFT;
4887 InsertGroup(groupindex++, &grp);
4888 }
4889
4890 //if(m_IgnoreFileList.GetCount()>0)
4891 {
4892 _tcsncpy_s(groupname, 1024, (LPCTSTR)_T("Ignored"), 1023);
4893 grp.pszHeader = groupname;
4894 grp.iGroupId = groupindex;
4895 grp.uAlign = LVGA_HEADER_LEFT;
4896 InsertGroup(groupindex++, &grp);
4897 }
4898 }
4899 }
4900
4901 #if 0
4902 m_bHasIgnoreGroup = false;
4903
4904 // now add the items which don't belong to a group
4905 LVGROUP grp = {0};
4906 grp.cbSize = sizeof(LVGROUP);
4907 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
4908 CString sUnassignedName(MAKEINTRESOURCE(IDS_STATUSLIST_UNASSIGNED_CHANGESET));
4909 _tcsncpy_s(groupname, 1024, (LPCTSTR)sUnassignedName, 1023);
4910 grp.pszHeader = groupname;
4911 grp.iGroupId = groupindex;
4912 grp.uAlign = LVGA_HEADER_LEFT;
4913 InsertGroup(groupindex++, &grp);
4914
4915 for (std::map<CString,int>::iterator it = m_changelists.begin(); it != m_changelists.end(); ++it)
4916 {
4917 if (it->first.Compare(SVNSLC_IGNORECHANGELIST)!=0)
4918 {
4919 LVGROUP grp = {0};
4920 grp.cbSize = sizeof(LVGROUP);
4921 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
4922 _tcsncpy_s(groupname, 1024, it->first, 1023);
4923 grp.pszHeader = groupname;
4924 grp.iGroupId = groupindex;
4925 grp.uAlign = LVGA_HEADER_LEFT;
4926 it->second = InsertGroup(groupindex++, &grp);
4927 }
4928 else
4929 m_bHasIgnoreGroup = true;
4930 }
4931
4932 if (m_bHasIgnoreGroup)
4933 {
4934 // and now add the group 'ignore-on-commit'
4935 std::map<CString,int>::iterator it = m_changelists.find(SVNSLC_IGNORECHANGELIST);
4936 if (it != m_changelists.end())
4937 {
4938 grp.cbSize = sizeof(LVGROUP);
4939 grp.mask = LVGF_ALIGN | LVGF_GROUPID | LVGF_HEADER;
4940 _tcsncpy_s(groupname, 1024, SVNSLC_IGNORECHANGELIST, 1023);
4941 grp.pszHeader = groupname;
4942 grp.iGroupId = groupindex;
4943 grp.uAlign = LVGA_HEADER_LEFT;
4944 it->second = InsertGroup(groupindex, &grp);
4945 }
4946 }
4947 #endif
4948 return bHasGroups;
4949 }
4950
4951 void CGitStatusListCtrl::NotifyCheck()
4952 {
4953 CWnd* pParent = GetParent();
4954 if (NULL != pParent && NULL != pParent->GetSafeHwnd())
4955 {
4956 pParent->SendMessage(GITSLNM_CHECKCHANGED, m_nSelected);
4957 }
4958 }
4959
4960 int CGitStatusListCtrl::UpdateFileList(git_revnum_t hash,CTGitPathList *list)
4961 {
4962 BYTE_VECTOR out;
4963 this->m_bBusy=TRUE;
4964 m_CurrentVersion=hash;
4965
4966 int count = 0;
4967 if(list == NULL)
4968 count = 1;
4969 else
4970 count = list->GetCount();
4971
4972 CString head = _T("HEAD");
4973 if(m_amend)
4974 head = _T("HEAD~1");
4975
4976 if(hash == GIT_REV_ZERO)
4977 {
4978 for(int i=0;i<count;i++)
4979 {
4980 BYTE_VECTOR cmdout;
4981 cmdout.clear();
4982 CString cmd;
4983 if(!g_Git.IsInitRepos())
4984 {
4985 // also list staged files which will be in the commit
4986 cmd=(_T("git.exe diff-index --cached --raw ") + head + _T(" --numstat -C -M -z"));
4987 g_Git.Run(cmd, &cmdout);
4988
4989 if(list == NULL)
4990 cmd=(_T("git.exe diff-index --raw ") + head + _T(" --numstat -C -M -z"));
4991 else
4992 cmd.Format(_T("git.exe diff-index --raw ") + head + _T(" --numstat -C -M -z -- \"%s\""),(*list)[i].GetGitPathString());
4993
4994 BYTE_VECTOR cmdErr;
4995 if(g_Git.Run(cmd, &cmdout, &cmdErr))
4996 {
4997 int last = cmdErr.RevertFind(0,-1);
4998 CString str;
4999 g_Git.StringAppend(&str, &cmdErr[last + 1], CP_ACP, cmdErr.size() - last -1);
5000 CMessageBox::Show(NULL, str, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
5001 }
5002
5003 out.append(cmdout, 0);
5004 }
5005 else // Init Repository
5006 {
5007 //We will list all added file for init repository because commit will comit these
5008 //if(list == NULL)
5009 cmd=_T("git.exe ls-files -s -t -z");
5010 //else
5011 // cmd.Format(_T("git.exe ls-files -s -t -z -- \"%s\""),(*list)[i].GetGitPathString());
5012
5013 g_Git.Run(cmd, &cmdout);
5014 //out+=cmdout;
5015 out.append(cmdout,0);
5016 }
5017 }
5018
5019 if(g_Git.IsInitRepos())
5020 {
5021 m_StatusFileList.ParserFromLsFile(out);
5022 for(int i=0;i<m_StatusFileList.GetCount();i++)
5023 ((CTGitPath&)(m_StatusFileList[i])).m_Action=CTGitPath::LOGACTIONS_ADDED;
5024 }
5025 else
5026 this->m_StatusFileList.ParserFromLog(out);
5027
5028 //handle delete conflict case, when remote : modified, local : deleted.
5029 for(int i=0;i<count;i++)
5030 {
5031 BYTE_VECTOR cmdout;
5032 CString cmd;
5033
5034 if(list == NULL)
5035 cmd=_T("git.exe ls-files -u -t -z");
5036 else
5037 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),(*list)[i].GetGitPathString());
5038
5039 g_Git.Run(cmd, &cmdout);
5040
5041 CTGitPathList conflictlist;
5042 conflictlist.ParserFromLog(cmdout);
5043 for(int i=0;i<conflictlist.GetCount();i++)
5044 {
5045 CTGitPath *p=m_StatusFileList.LookForGitPath(conflictlist[i].GetGitPathString());
5046 if(p)
5047 p->m_Action|=CTGitPath::LOGACTIONS_UNMERGED;
5048 else
5049 m_StatusFileList.AddPath(conflictlist[i]);
5050 }
5051 }
5052
5053 // handle source files of file renames/moves (issue #860)
5054 // if a file gets renamed and the new file "git add"ed, diff-index doesn't list the source file anymore
5055 for(int i = 0; i < count; i++)
5056 {
5057 BYTE_VECTOR cmdout;
5058 CString cmd;
5059
5060 if(list == NULL)
5061 cmd = _T("git.exe ls-files -d -z");
5062 else
5063 cmd.Format(_T("git.exe ls-files -d -z -- \"%s\""),(*list)[i].GetGitPathString());
5064
5065 g_Git.Run(cmd, &cmdout);
5066
5067 CTGitPathList deletelist;
5068 deletelist.ParserFromLog(cmdout, true);
5069 for(int i = 0; i < deletelist.GetCount(); i++)
5070 {
5071 CTGitPath *p = m_StatusFileList.LookForGitPath(deletelist[i].GetGitPathString());
5072 if(!p)
5073 m_StatusFileList.AddPath(deletelist[i]);
5074 else if ((p->m_Action == CTGitPath::LOGACTIONS_ADDED || p->m_Action == CTGitPath::LOGACTIONS_REPLACED) && !p->Exists())
5075 {
5076 if (CMessageBox::Show(m_hWnd, _T("TortoiseGit detected that the file \"") + p->GetWinPathString() +_T("\" does not exist, but is staged as \"Added\".\nThe commit dialog cannot handle this.\n\nDo you want to remove it from the index?"), _T("TortoiseGit"), 1, IDI_EXCLAMATION, _T("&Remove file from index"), _T("&Ignore")) == 1)
5077 {
5078 g_Git.Run(_T("git.exe rm -f --cache -- \"") + p->GetWinPathString() + _T("\""), &cmdout);
5079 m_StatusFileList.RemoveItem(*p);
5080 }
5081 }
5082 }
5083 }
5084 }
5085 else
5086 {
5087 int count = 0;
5088 if(list == NULL)
5089 count = 1;
5090 else
5091 count = list->GetCount();
5092
5093 for(int i=0;i<count;i++)
5094 {
5095 BYTE_VECTOR cmdout;
5096 CString cmd;
5097 if(list == NULL)
5098 cmd.Format(_T("git.exe diff-tree --raw --numstat -C -M -z %s"),hash);
5099 else
5100 cmd.Format(_T("git.exe diff-tree --raw --numstat -C -M %s -z -- \"%s\""),hash,(*list)[i].GetGitPathString());
5101
5102 g_Git.Run(cmd, &cmdout, NULL);
5103
5104 out.append(cmdout);
5105 }
5106 this->m_StatusFileList.ParserFromLog(out);
5107
5108 }
5109
5110 for(int i=0;i<m_StatusFileList.GetCount();i++)
5111 {
5112 CTGitPath * gitpatch=(CTGitPath*)&m_StatusFileList[i];
5113 gitpatch->m_Checked = TRUE;
5114 m_arStatusArray.push_back((CTGitPath*)&m_StatusFileList[i]);
5115 }
5116
5117 this->m_bBusy=FALSE;
5118 return 0;
5119 }
5120
5121 int CGitStatusListCtrl::UpdateWithGitPathList(CTGitPathList &list)
5122 {
5123 m_arStatusArray.clear();
5124 for(int i=0;i<list.GetCount();i++)
5125 {
5126 CTGitPath * gitpath=(CTGitPath*)&list[i];
5127
5128 if(gitpath ->m_Action & CTGitPath::LOGACTIONS_HIDE)
5129 continue;
5130
5131 gitpath->m_Checked = TRUE;
5132 m_arStatusArray.push_back((CTGitPath*)&list[i]);
5133 }
5134 return 0;
5135 }
5136
5137 int CGitStatusListCtrl::UpdateUnRevFileList(CTGitPathList *List)
5138 {
5139 this->m_UnRevFileList.FillUnRev(CTGitPath::LOGACTIONS_UNVER,List);
5140 for(int i=0;i<m_UnRevFileList.GetCount();i++)
5141 {
5142 CTGitPath * gitpatch=(CTGitPath*)&m_UnRevFileList[i];
5143 gitpatch->m_Checked = FALSE;
5144 m_arStatusArray.push_back((CTGitPath*)&m_UnRevFileList[i]);
5145 }
5146 return 0;
5147 }
5148
5149 int CGitStatusListCtrl::UpdateIgnoreFileList(CTGitPathList *List)
5150 {
5151 this->m_IgnoreFileList.FillUnRev(CTGitPath::LOGACTIONS_UNVER|CTGitPath::LOGACTIONS_IGNORE,List);
5152 for(int i=0;i<m_IgnoreFileList.GetCount();i++)
5153 {
5154 CTGitPath * gitpatch=(CTGitPath*)&m_IgnoreFileList[i];
5155 gitpatch->m_Checked = FALSE;
5156 m_arStatusArray.push_back((CTGitPath*)&m_IgnoreFileList[i]);
5157 }
5158 return 0;
5159 }
5160 int CGitStatusListCtrl::UpdateFileList(int mask,bool once,CTGitPathList *List)
5161 {
5162 if(mask&CGitStatusListCtrl::FILELIST_MODIFY)
5163 {
5164 if(once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_MODIFY)))
5165 {
5166 UpdateFileList(git_revnum_t(GIT_REV_ZERO),List);
5167 m_FileLoaded|=CGitStatusListCtrl::FILELIST_MODIFY;
5168 }
5169 }
5170 if(mask&CGitStatusListCtrl::FILELIST_UNVER)
5171 {
5172 if(once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_UNVER)))
5173 {
5174 UpdateUnRevFileList(List);
5175 m_FileLoaded|=CGitStatusListCtrl::FILELIST_UNVER;
5176 }
5177 if(mask&CGitStatusListCtrl::FILELIST_IGNORE && (once || (!(m_FileLoaded&CGitStatusListCtrl::FILELIST_IGNORE))))
5178 {
5179 UpdateIgnoreFileList(List);
5180 m_FileLoaded|=CGitStatusListCtrl::FILELIST_UNVER;
5181 }
5182 }
5183 return 0;
5184 }
5185
5186 void CGitStatusListCtrl::Clear()
5187 {
5188 m_FileLoaded=0;
5189 this->DeleteAllItems();
5190 this->m_arListArray.clear();
5191 this->m_arStatusArray.clear();
5192 this->m_changelists.clear();
5193 }
5194 //////////////////////////////////////////////////////////////////////////
5195 #if 0
5196 bool CGitStatusListCtrlDropTarget::OnDrop(FORMATETC* pFmtEtc, STGMEDIUM& medium, DWORD * /*pdwEffect*/, POINTL pt)
5197 {
5198 if(pFmtEtc->cfFormat == CF_HDROP && medium.tymed == TYMED_HGLOBAL)
5199 {
5200 HDROP hDrop = (HDROP)GlobalLock(medium.hGlobal);
5201 if(hDrop != NULL)
5202 {
5203 TCHAR szFileName[MAX_PATH];
5204
5205 UINT cFiles = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
5206
5207 POINT clientpoint;
5208 clientpoint.x = pt.x;
5209 clientpoint.y = pt.y;
5210 ScreenToClient(m_hTargetWnd, &clientpoint);
5211 if ((m_pSVNStatusListCtrl->IsGroupViewEnabled())&&(m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint) >= 0))
5212 {
5213 CTSVNPathList changelistItems;
5214 for(UINT i = 0; i < cFiles; ++i)
5215 {
5216 DragQueryFile(hDrop, i, szFileName, sizeof(szFileName));
5217 changelistItems.AddPath(CTSVNPath(szFileName));
5218 }
5219 // find the changelist name
5220 CString sChangelist;
5221 LONG_PTR nGroup = m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint);
5222 for (std::map<CString, int>::iterator it = m_pSVNStatusListCtrl->m_changelists.begin(); it != m_pSVNStatusListCtrl->m_changelists.end(); ++it)
5223 if (it->second == nGroup)
5224 sChangelist = it->first;
5225 if (!sChangelist.IsEmpty())
5226 {
5227 SVN git;
5228 if (git.AddToChangeList(changelistItems, sChangelist, git_depth_empty))
5229 {
5230 for (int l=0; l<changelistItems.GetCount(); ++l)
5231 {
5232 int index = m_pSVNStatusListCtrl->GetIndex(changelistItems[l]);
5233 if (index >= 0)
5234 {
5235 CSVNStatusListCtrl::FileEntry * e = m_pSVNStatusListCtrl->GetListEntry(index);
5236 if (e)
5237 {
5238 e->changelist = sChangelist;
5239 if (!e->IsFolder())
5240 {
5241 if (m_pSVNStatusListCtrl->m_changelists.find(e->changelist)!=m_pSVNStatusListCtrl->m_changelists.end())
5242 m_pSVNStatusListCtrl->SetItemGroup(index, m_pSVNStatusListCtrl->m_changelists[e->changelist]);
5243 else
5244 m_pSVNStatusListCtrl->SetItemGroup(index, 0);
5245 }
5246 }
5247 }
5248 else
5249 {
5250 HWND hParentWnd = GetParent(m_hTargetWnd);
5251 if (hParentWnd != NULL)
5252 ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)changelistItems[l].GetWinPath());
5253 }
5254 }
5255 }
5256 else
5257 {
5258 CMessageBox::Show(m_pSVNStatusListCtrl->m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
5259 }
5260 }
5261 else
5262 {
5263 SVN git;
5264 if (git.RemoveFromChangeList(changelistItems, CStringArray(), git_depth_empty))
5265 {
5266 for (int l=0; l<changelistItems.GetCount(); ++l)
5267 {
5268 int index = m_pSVNStatusListCtrl->GetIndex(changelistItems[l]);
5269 if (index >= 0)
5270 {
5271 CSVNStatusListCtrl::FileEntry * e = m_pSVNStatusListCtrl->GetListEntry(index);
5272 if (e)
5273 {
5274 e->changelist = sChangelist;
5275 m_pSVNStatusListCtrl->SetItemGroup(index, 0);
5276 }
5277 }
5278 else
5279 {
5280 HWND hParentWnd = GetParent(m_hTargetWnd);
5281 if (hParentWnd != NULL)
5282 ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)changelistItems[l].GetWinPath());
5283 }
5284 }
5285 }
5286 else
5287 {
5288 CMessageBox::Show(m_pSVNStatusListCtrl->m_hWnd, git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
5289 }
5290 }
5291 }
5292 else
5293 {
5294 for(UINT i = 0; i < cFiles; ++i)
5295 {
5296 DragQueryFile(hDrop, i, szFileName, sizeof(szFileName));
5297 HWND hParentWnd = GetParent(m_hTargetWnd);
5298 if (hParentWnd != NULL)
5299 ::SendMessage(hParentWnd, CSVNStatusListCtrl::SVNSLNM_ADDFILE, 0, (LPARAM)szFileName);
5300 }
5301 }
5302 }
5303 GlobalUnlock(medium.hGlobal);
5304 }
5305 return true; //let base free the medium
5306 }
5307 HRESULT STDMETHODCALLTYPE CSVNStatusListCtrlDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD __RPC_FAR *pdwEffect)
5308 {
5309 CIDropTarget::DragOver(grfKeyState, pt, pdwEffect);
5310 *pdwEffect = DROPEFFECT_COPY;
5311 if (m_pSVNStatusListCtrl)
5312 {
5313 POINT clientpoint;
5314 clientpoint.x = pt.x;
5315 clientpoint.y = pt.y;
5316 ScreenToClient(m_hTargetWnd, &clientpoint);
5317 if ((m_pSVNStatusListCtrl->IsGroupViewEnabled())&&(m_pSVNStatusListCtrl->GetGroupFromPoint(&clientpoint) >= 0))
5318 {
5319 *pdwEffect = DROPEFFECT_MOVE;
5320 }
5321 else if ((!m_pSVNStatusListCtrl->m_bFileDropsEnabled)||(m_pSVNStatusListCtrl->m_bOwnDrag))
5322 {
5323 *pdwEffect = DROPEFFECT_NONE;
5324 }
5325 }
5326 return S_OK;
5327 }f
5328
5329 #endif
5330
5331 void CGitStatusListCtrl::FileSaveAs(CTGitPath *path)
5332 {
5333 CString filename;
5334 filename.Format(_T("%s-%s%s"),path->GetBaseFilename(),this->m_CurrentVersion.Left(6),path->GetFileExtension());
5335 CFileDialog dlg(FALSE,NULL,
5336 filename,
5337 OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
5338 NULL);
5339 CString currentpath;
5340 currentpath=g_Git.m_CurrentDir+_T("\\");
5341 currentpath+=path->GetWinPathString();
5342
5343 dlg.m_ofn.lpstrInitialDir=currentpath.GetBuffer();
5344
5345 CString cmd,out;
5346 if(dlg.DoModal()==IDOK)
5347 {
5348 filename = dlg.GetPathName();
5349 if(m_CurrentVersion == GIT_REV_ZERO)
5350 {
5351 if(!CopyFile(g_Git.m_CurrentDir +_T("\\") + path->GetWinPath(),filename,false))
5352 {
5353 MessageBox(CFormatMessageWrapper(), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
5354 return;
5355 }
5356
5357 }
5358 else
5359 {
5360 if(g_Git.GetOneFile(m_CurrentVersion,*path,filename))
5361 {
5362 out.Format(_T("Fail checkout one file %s;%s"),m_CurrentVersion, path->GetWinPath());
5363 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
5364 return;
5365 }
5366 }
5367 }
5368
5369 }
5370
5371 int CGitStatusListCtrl::RevertSelectedItemToVersion()
5372 {
5373 if(this->m_CurrentVersion.IsEmpty())
5374 return 0;
5375 if(this->m_CurrentVersion == GIT_REV_ZERO)
5376 return 0;
5377
5378 POSITION pos = GetFirstSelectedItemPosition();
5379 int index;
5380 CString cmd,out;
5381 int count =0;
5382 while ((index = GetNextSelectedItem(pos)) >= 0)
5383 {
5384 CTGitPath *fentry=(CTGitPath*)GetItemData(index);
5385 cmd.Format(_T("git.exe checkout %s -- \"%s\""),m_CurrentVersion,fentry->GetGitPathString());
5386 out.Empty();
5387 if(g_Git.Run(cmd,&out,CP_ACP))
5388 {
5389 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
5390 }
5391 count++;
5392 }
5393
5394 out.Format(_T("%d files revert to %s"),count,m_CurrentVersion.Left(6));
5395 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
5396 return 0;
5397 }
5398
5399 void CGitStatusListCtrl::OpenFile(CTGitPath*filepath,int mode)
5400 {
5401 CString file;
5402 if(this->m_CurrentVersion.IsEmpty() || m_CurrentVersion == GIT_REV_ZERO)
5403 {
5404 file= filepath->GetWinPath();
5405 }
5406 else
5407 {
5408 CString temppath;
5409 GetTempPath(temppath);
5410 file.Format(_T("%s%s_%s%s"),
5411 temppath,
5412 filepath->GetBaseFilename(),
5413 m_CurrentVersion.Left(6),
5414 filepath->GetFileExtension());
5415 CString cmd,out;
5416 if(g_Git.GetOneFile(m_CurrentVersion, *filepath, file))
5417 {
5418 out.Format(_T("Fail checkout file %s to %s\n"), filepath->GetGitPathString(), file);
5419 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
5420 return;
5421 }
5422
5423 }
5424 if(mode == ALTERNATIVEEDITOR)
5425 {
5426 CAppUtils::LaunchAlternativeEditor(file);
5427 return;
5428 }
5429 int ret = HINSTANCE_ERROR;
5430
5431 if(mode == OPEN )
5432 {
5433 ret = (int)ShellExecute(this->m_hWnd, NULL,file, NULL, NULL, SW_SHOW);
5434
5435 if (ret > HINSTANCE_ERROR)
5436 {
5437 return;
5438 }
5439 }
5440
5441 {
5442 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");
5443 cmd += file;
5444 CAppUtils::LaunchApplication(cmd, NULL, false);
5445 }
5446
5447 }
Windows Explorer Extension to Operate Git