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