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