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