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