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