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