?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed issue #1557: Submodule Diff Dialog should launch diff with working copy if...
[TortoiseGit.git] / src / TortoiseProc / GitLogListBase.cpp
bloba477bbc0a5b3800f2df8c0cb3d02396b1230832b
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2012 - TortoiseGit
4 // Copyright (C) 2005-2007 Marco Costalba
5 // Copyright (C) 2011-2012 - Sven Strickroth <email@cs-ware.de>
6
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License
9 // as published by the Free Software Foundation; either version 2
10 // of the License, or (at your option) any later version.
11
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software Foundation,
19 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 //
21 // GitLogList.cpp : implementation file
22 //
23 #include "stdafx.h"
24 #include "resource.h"
25 #include "GitLogListBase.h"
26 #include "GitRev.h"
27 //#include "VssStyle.h"
28 #include "IconMenu.h"
29 // CGitLogListBase
30 #include "cursor.h"
31 #include "InputDlg.h"
32 #include "GITProgressDlg.h"
33 #include "ProgressDlg.h"
34 //#include "RepositoryBrowser.h"
35 //#include "CopyDlg.h"
36 //#include "StatGraphDlg.h"
37 #include "Logdlg.h"
38 #include "MessageBox.h"
39 #include "Registry.h"
40 #include "LoglistUtils.h"
41 #include "PathUtils.h"
42 #include "StringUtils.h"
43 #include "UnicodeUtils.h"
44 #include "TempFile.h"
45 //#include "GitInfo.h"
46 //#include "GitDiff.h"
47 #include "IconMenu.h"
48 //#include "RevisionRangeDlg.h"
49 //#include "BrowseFolder.h"
50 //#include "BlameDlg.h"
51 //#include "Blame.h"
52 //#include "GitHelpers.h"
53 #include "GitStatus.h"
54 //#include "LogDlgHelper.h"
55 //#include "CachedLogInfo.h"
56 //#include "RepositoryInfo.h"
57 //#include "EditPropertiesDlg.h"
58 #include "FileDiffDlg.h"
59 #include "..\\TortoiseShell\\Resource.h"
60 #include "FindDlg.h"
61 #include "SysInfo.h"
62
63 const UINT CGitLogListBase::m_FindDialogMessage = RegisterWindowMessage(FINDMSGSTRING);
64 const UINT CGitLogListBase::m_ScrollToMessage = RegisterWindowMessage(_T("TORTOISEGIT_LOG_SCROLLTO"));
65
66 IMPLEMENT_DYNAMIC(CGitLogListBase, CHintListCtrl)
67
68 CGitLogListBase::CGitLogListBase():CHintListCtrl()
69 ,m_regMaxBugIDColWidth(_T("Software\\TortoiseGit\\MaxBugIDColWidth"), 200)
70 ,m_nSearchIndex(0)
71 ,m_bNoDispUpdates(FALSE)
72 , m_bThreadRunning(FALSE)
73 , m_bStrictStopped(false)
74 , m_pStoreSelection(NULL)
75 , m_SelectedFilters(LOGFILTER_ALL)
76 , m_bShowWC(false)
77 , m_logEntries(&m_LogCache)
78 , m_pFindDialog(NULL)
79 , m_ColumnManager(this)
80 , m_dwDefaultColumns(0)
81 , m_arShownList(&m_critSec)
82 , m_hasWC(true)
83 , m_bNoHightlightHead(FALSE)
84 {
85 // use the default GUI font, create a copy of it and
86 // change the copy to BOLD (leave the rest of the font
87 // the same)
88 HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
89 LOGFONT lf = {0};
90 GetObject(hFont, sizeof(LOGFONT), &lf);
91 lf.lfWeight = FW_BOLD;
92 m_boldFont = CreateFontIndirect(&lf);
93
94 m_bShowBugtraqColumn=false;
95
96 m_IsIDReplaceAction=FALSE;
97
98 this->m_critSec.Init();
99 m_wcRev.m_CommitHash.Empty();
100 m_wcRev.GetSubject() = CString(MAKEINTRESOURCE(IDS_LOG_WORKINGDIRCHANGES));
101 m_wcRev.m_ParentHash.clear();
102 m_wcRev.m_Mark=_T('-');
103 m_wcRev.m_IsUpdateing=FALSE;
104 m_wcRev.m_IsFull = TRUE;
105
106 m_hModifiedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONMODIFIED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
107 m_hReplacedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONREPLACED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
108 m_hAddedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONADDED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
109 m_hDeletedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONDELETED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
110 m_hFetchIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONFETCHING), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
111
112 m_bFilterWithRegex = !!CRegDWORD(_T("Software\\TortoiseGit\\UseRegexFilter"), TRUE);
113
114 g_Git.GetMapHashToFriendName(m_HashMap);
115 if (CTGitPath(g_Git.m_CurrentDir).HasAdminDir())
116 {
117 m_CurrentBranch=g_Git.GetCurrentBranch();
118 try {
119 m_HeadHash=g_Git.GetHash(_T("HEAD"));
120 }
121 catch (char* msg)
122 {
123 CString err(msg);
124 MessageBox(_T("Could not get HEAD hash. Quitting...\nlibgit reports:\n") + err, _T("TortoiseGit"), MB_ICONERROR);
125 ExitProcess(1);
126 }
127 }
128
129 m_From = -1;
130 m_To = -1;
131
132 m_ShowMask = 0;
133 m_LoadingThread = NULL;
134
135 InterlockedExchange(&m_bExitThread,FALSE);
136 m_IsOldFirst = FALSE;
137 m_IsRebaseReplaceGraph = FALSE;
138
139
140 for(int i=0;i<Lanes::COLORS_NUM;i++)
141 {
142 m_LineColors[i] = m_Colors.GetColor((CColors::Colors)(CColors::BranchLine1+i));
143 }
144 // get short/long datetime setting from registry
145 DWORD RegUseShortDateFormat = CRegDWORD(_T("Software\\TortoiseGit\\LogDateFormat"), TRUE);
146 if ( RegUseShortDateFormat )
147 {
148 m_DateFormat = DATE_SHORTDATE;
149 }
150 else
151 {
152 m_DateFormat = DATE_LONGDATE;
153 }
154 // get relative time display setting from registry
155 DWORD regRelativeTimes = CRegDWORD(_T("Software\\TortoiseGit\\RelativeTimes"), FALSE);
156 m_bRelativeTimes = (regRelativeTimes != 0);
157 m_ContextMenuMask = 0xFFFFFFFFFFFFFFFF;
158
159 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_PICK);
160 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_SQUASH);
161 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_EDIT);
162 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_SKIP);
163 m_ContextMenuMask &= ~GetContextMenuBit(ID_LOG);
164 m_ContextMenuMask &= ~GetContextMenuBit(ID_BLAME);
165
166 m_ColumnRegKey=_T("log");
167
168 m_AsyncThreadExit = FALSE;
169 m_AsyncDiffEvent = ::CreateEvent(NULL,FALSE,TRUE,NULL);
170 m_AsynDiffListLock.Init();
171
172 m_DiffingThread = AfxBeginThread(AsyncThread, this, THREAD_PRIORITY_BELOW_NORMAL);
173 if (m_DiffingThread ==NULL)
174 {
175 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
176 return;
177 }
178
179 }
180
181 int CGitLogListBase::AsyncDiffThread()
182 {
183 m_AsyncThreadExited = false;
184 while(!m_AsyncThreadExit)
185 {
186 ::WaitForSingleObject(m_AsyncDiffEvent, INFINITE);
187
188 GitRev *pRev = NULL;
189 while(!m_AsyncThreadExit && !m_AsynDiffList.empty())
190 {
191 m_AsynDiffListLock.Lock();
192 pRev = m_AsynDiffList.back();
193 m_AsynDiffList.pop_back();
194 m_AsynDiffListLock.Unlock();
195
196 if( pRev->m_CommitHash.IsEmpty() )
197 {
198 if(pRev->m_IsDiffFiles)
199 continue;
200
201 pRev->GetFiles(this).Clear();
202 pRev->m_ParentHash.clear();
203 pRev->m_ParentHash.push_back(m_HeadHash);
204 if(g_Git.IsInitRepos())
205 {
206 g_Git.GetInitAddList(pRev->GetFiles(this));
207
208 }
209 else
210 {
211 g_Git.GetCommitDiffList(pRev->m_CommitHash.ToString(),this->m_HeadHash.ToString(), pRev->GetFiles(this));
212 }
213 pRev->GetAction(this) = 0;
214
215 for(int j=0;j< pRev->GetFiles(this).GetCount();j++)
216 pRev->GetAction(this) |= pRev->GetFiles(this)[j].m_Action;
217
218 pRev->GetUnRevFiles().FillUnRev(CTGitPath::LOGACTIONS_UNVER);
219
220 InterlockedExchange(&pRev->m_IsDiffFiles, TRUE);
221 InterlockedExchange(&pRev->m_IsFull, TRUE);
222
223 pRev->GetBody().Format(IDS_FILESCHANGES, pRev->GetFiles(this).GetCount());
224 ::PostMessage(m_hWnd,MSG_LOADED,(WPARAM)0,0);
225 this->GetParent()->PostMessage(WM_COMMAND, MSG_FETCHED_DIFF, 0);
226 }
227
228 if(!pRev->CheckAndDiff())
229 { // fetch change file list
230 for(int i=GetTopIndex(); !m_AsyncThreadExit && i <= GetTopIndex()+GetCountPerPage(); i++)
231 {
232 if(i < m_arShownList.GetCount())
233 {
234 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(i);
235 if(data->m_CommitHash == pRev->m_CommitHash)
236 {
237 ::PostMessage(m_hWnd,MSG_LOADED,(WPARAM)i,0);
238 break;
239 }
240 }
241 }
242
243 if(!m_AsyncThreadExit && GetSelectedCount() == 1)
244 {
245 POSITION pos = GetFirstSelectedItemPosition();
246 int nItem = GetNextSelectedItem(pos);
247
248 if(nItem>=0)
249 {
250 GitRev* data = (GitRev*)m_arShownList[nItem];
251 if(data)
252 if(data->m_CommitHash == pRev->m_CommitHash)
253 {
254 this->GetParent()->PostMessage(WM_COMMAND, MSG_FETCHED_DIFF, 0);
255 }
256 }
257 }
258 }
259 }
260 }
261 m_AsyncThreadExited = true;
262 return 0;
263 }
264 void CGitLogListBase::hideFromContextMenu(unsigned __int64 hideMask, bool exclusivelyShow)
265 {
266 if (exclusivelyShow)
267 {
268 m_ContextMenuMask &= hideMask;
269 }
270 else
271 {
272 m_ContextMenuMask &= ~hideMask;
273 }
274 }
275
276 CGitLogListBase::~CGitLogListBase()
277 {
278 InterlockedExchange(&m_bNoDispUpdates, TRUE);
279 this->m_arShownList.SafeRemoveAll();
280
281 DestroyIcon(m_hModifiedIcon);
282 DestroyIcon(m_hReplacedIcon);
283 DestroyIcon(m_hAddedIcon);
284 DestroyIcon(m_hDeletedIcon);
285 m_logEntries.ClearAll();
286
287 if (m_boldFont)
288 DeleteObject(m_boldFont);
289
290 if ( m_pStoreSelection )
291 {
292 delete m_pStoreSelection;
293 m_pStoreSelection = NULL;
294 }
295
296 SafeTerminateThread();
297 SafeTerminateAsyncDiffThread();
298
299 if(m_AsyncDiffEvent)
300 CloseHandle(m_AsyncDiffEvent);
301 }
302
303
304 BEGIN_MESSAGE_MAP(CGitLogListBase, CHintListCtrl)
305 ON_REGISTERED_MESSAGE(m_FindDialogMessage, OnFindDialogMessage)
306 ON_REGISTERED_MESSAGE(m_ScrollToMessage, OnScrollToMessage)
307 ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnNMCustomdrawLoglist)
308 ON_NOTIFY_REFLECT(LVN_GETDISPINFO, OnLvnGetdispinfoLoglist)
309 ON_WM_CONTEXTMENU()
310 ON_NOTIFY_REFLECT(NM_DBLCLK, OnNMDblclkLoglist)
311 ON_NOTIFY_REFLECT(LVN_ODFINDITEM,OnLvnOdfinditemLoglist)
312 ON_WM_CREATE()
313 ON_WM_DESTROY()
314 ON_MESSAGE(MSG_LOADED,OnLoad)
315 ON_WM_MEASUREITEM()
316 ON_WM_MEASUREITEM_REFLECT()
317 ON_NOTIFY(HDN_BEGINTRACKA, 0, OnHdnBegintrack)
318 ON_NOTIFY(HDN_BEGINTRACKW, 0, OnHdnBegintrack)
319 ON_NOTIFY(HDN_ITEMCHANGINGA, 0, OnHdnItemchanging)
320 ON_NOTIFY(HDN_ITEMCHANGINGW, 0, OnHdnItemchanging)
321 ON_NOTIFY(HDN_ENDTRACK, 0, OnColumnResized)
322 ON_NOTIFY(HDN_ENDDRAG, 0, OnColumnMoved)
323 END_MESSAGE_MAP()
324
325 void CGitLogListBase::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
326 {
327 //if (m_nRowHeight>0)
328 {
329 lpMeasureItemStruct->itemHeight = 50;
330 }
331 }
332
333 int CGitLogListBase:: OnCreate(LPCREATESTRUCT lpCreateStruct)
334 {
335 PreSubclassWindow();
336 return CHintListCtrl::OnCreate(lpCreateStruct);
337 }
338
339 void CGitLogListBase::PreSubclassWindow()
340 {
341 SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_SUBITEMIMAGES);
342 // load the icons for the action columns
343 // m_Theme.Open(m_hWnd, L"ListView");
344 SetWindowTheme(m_hWnd, L"Explorer", NULL);
345 CHintListCtrl::PreSubclassWindow();
346 }
347
348 void CGitLogListBase::InsertGitColumn()
349 {
350 CString temp;
351
352 CRegDWORD regFullRowSelect(_T("Software\\TortoiseGit\\FullRowSelect"), TRUE);
353 DWORD exStyle = LVS_EX_HEADERDRAGDROP | LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP | LVS_EX_SUBITEMIMAGES;
354 if (DWORD(regFullRowSelect))
355 exStyle |= LVS_EX_FULLROWSELECT;
356 SetExtendedStyle(exStyle);
357
358 UpdateProjectProperties();
359
360 static UINT normal[] =
361 {
362 IDS_LOG_GRAPH,
363 IDS_LOG_REBASE,
364 IDS_LOG_ID,
365 IDS_LOG_HASH,
366 IDS_LOG_ACTIONS,
367 IDS_LOG_MESSAGE,
368 IDS_LOG_AUTHOR,
369 IDS_LOG_DATE,
370 IDS_LOG_EMAIL,
371 IDS_LOG_COMMIT_NAME,
372 IDS_LOG_COMMIT_EMAIL,
373 IDS_LOG_COMMIT_DATE,
374 IDS_LOG_BUGIDS,
375 };
376
377 static int with[] =
378 {
379 ICONITEMBORDER+16*4,
380 ICONITEMBORDER+16*4,
381 ICONITEMBORDER+16*4,
382 ICONITEMBORDER+16*4,
383 ICONITEMBORDER+16*4,
384 LOGLIST_MESSAGE_MIN,
385 ICONITEMBORDER+16*4,
386 ICONITEMBORDER+16*4,
387 ICONITEMBORDER+16*4,
388 ICONITEMBORDER+16*4,
389 ICONITEMBORDER+16*4,
390 ICONITEMBORDER+16*4,
391 ICONITEMBORDER+16*4,
392 };
393 m_dwDefaultColumns = GIT_LOG_GRAPH|GIT_LOG_ACTIONS|GIT_LOG_MESSAGE|GIT_LOG_AUTHOR|GIT_LOG_DATE;
394
395 DWORD hideColumns = 0;
396 if(this->m_IsRebaseReplaceGraph)
397 {
398 hideColumns |= GIT_LOG_GRAPH;
399 m_dwDefaultColumns |= GIT_LOG_REBASE;
400 }
401 else
402 {
403 hideColumns |= GIT_LOG_REBASE;
404 }
405
406 if(this->m_IsIDReplaceAction)
407 {
408 hideColumns |= GIT_LOG_ACTIONS;
409 m_dwDefaultColumns |= GIT_LOG_ID;
410 m_dwDefaultColumns |= GIT_LOG_HASH;
411 }
412 else
413 {
414 hideColumns |= GIT_LOG_ID;
415 }
416 if(this->m_bShowBugtraqColumn)
417 {
418 m_dwDefaultColumns |= GIT_LOGLIST_BUG;
419 }
420 else
421 {
422 hideColumns |= GIT_LOGLIST_BUG;
423 }
424 SetRedraw(false);
425
426 m_ColumnManager.SetNames(normal, _countof(normal));
427 m_ColumnManager.ReadSettings(m_dwDefaultColumns, hideColumns, m_ColumnRegKey+_T("loglist"), _countof(normal), with);
428
429 SetRedraw(true);
430
431 }
432
433 /**
434 * Resizes all columns in a list control to values in registry.
435 */
436 void CGitLogListBase::ResizeAllListCtrlCols()
437 {
438 // column max and min widths to allow
439 static const int nMinimumWidth = 10;
440 static const int nMaximumWidth = 1000;
441 CHeaderCtrl* pHdrCtrl = (CHeaderCtrl*)(GetDlgItem(0));
442 if (pHdrCtrl)
443 {
444 int numcols = pHdrCtrl->GetItemCount();
445 for (int col = 0; col < numcols; col++)
446 {
447 // get width for this col last time from registry
448 CString regentry;
449 regentry.Format( _T("Software\\TortoiseGit\\%s\\ColWidth%d"),m_ColumnRegKey, col);
450 CRegDWORD regwidth(regentry, 0);
451 int cx = regwidth;
452 if ( cx == 0 )
453 {
454 // no saved value, setup sensible defaults
455 if (col == this->LOGLIST_MESSAGE)
456 {
457 cx = LOGLIST_MESSAGE_MIN;
458 }
459 else
460 {
461 cx = ICONITEMBORDER+16*4;
462 }
463 }
464 if (cx < nMinimumWidth)
465 {
466 cx = nMinimumWidth;
467 }
468 else if (cx > nMaximumWidth)
469 {
470 cx = nMaximumWidth;
471 }
472
473 SetColumnWidth(col, cx);
474 }
475 }
476
477 }
478
479
480 BOOL CGitLogListBase::GetShortName(CString ref, CString &shortname,CString prefix)
481 {
482 //TRACE(_T("%s %s\r\n"),ref,prefix);
483 if(ref.Left(prefix.GetLength()) == prefix)
484 {
485 shortname = ref.Right(ref.GetLength()-prefix.GetLength());
486 if(shortname.Right(3)==_T("^{}"))
487 shortname=shortname.Left(shortname.GetLength()-3);
488 return TRUE;
489 }
490 return FALSE;
491 }
492
493 void CGitLogListBase::FillBackGround(HDC hdc, DWORD_PTR Index, CRect &rect)
494 {
495 LVITEM rItem;
496 SecureZeroMemory(&rItem, sizeof(LVITEM));
497 rItem.mask = LVIF_STATE;
498 rItem.iItem = (int)Index;
499 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
500 GetItem(&rItem);
501
502 GitRev* pLogEntry = (GitRev*)m_arShownList.SafeGetAt(Index);
503 HBRUSH brush = NULL;
504
505 if (!(rItem.state & LVIS_SELECTED))
506 {
507 if(pLogEntry->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_SQUASH)
508 brush = ::CreateSolidBrush(RGB(156,156,156));
509 else if(pLogEntry->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_EDIT)
510 brush = ::CreateSolidBrush(RGB(200,200,128));
511 }
512 else if (!(IsAppThemed() && SysInfo::Instance().IsVistaOrLater()))
513 {
514 if (rItem.state & LVIS_SELECTED)
515 {
516 if (::GetFocus() == m_hWnd)
517 brush = ::CreateSolidBrush(::GetSysColor(COLOR_HIGHLIGHT));
518 else
519 brush = ::CreateSolidBrush(::GetSysColor(COLOR_BTNFACE));
520 }
521 }
522
523 if (brush != NULL)
524 {
525 ::FillRect(hdc, &rect, brush);
526 ::DeleteObject(brush);
527 }
528 }
529
530 void CGitLogListBase::DrawTagBranch(HDC hdc,CRect &rect,INT_PTR index)
531 {
532 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(index);
533 CRect rt=rect;
534 LVITEM rItem;
535 SecureZeroMemory(&rItem, sizeof(LVITEM));
536 rItem.mask = LVIF_STATE;
537 rItem.iItem = (int)index;
538 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
539 GetItem(&rItem);
540
541 CDC W_Dc;
542 W_Dc.Attach(hdc);
543
544 HTHEME hTheme = NULL;
545 if (IsAppThemed() && SysInfo::Instance().IsVistaOrLater())
546 hTheme = OpenThemeData(m_hWnd, L"Explorer::ListView;ListView");
547
548 for(unsigned int i=0;i<m_HashMap[data->m_CommitHash].size();i++)
549 {
550 CString str;
551 str=m_HashMap[data->m_CommitHash][i];
552
553 CString shortname;
554 HBRUSH brush = 0;
555 shortname = _T("");
556 COLORREF colRef = 0;
557
558 //Determine label color
559 if(GetShortName(str,shortname,_T("refs/heads/")))
560 {
561 if( shortname == m_CurrentBranch )
562 colRef = m_Colors.GetColor(CColors::CurrentBranch);
563 else
564 colRef = m_Colors.GetColor(CColors::LocalBranch);
565
566 }
567 else if(GetShortName(str,shortname,_T("refs/remotes/")))
568 {
569 colRef = m_Colors.GetColor(CColors::RemoteBranch);
570 }
571 else if(GetShortName(str,shortname,_T("refs/tags/")))
572 {
573 colRef = m_Colors.GetColor(CColors::Tag);
574 }
575 else if(GetShortName(str,shortname,_T("refs/stash")))
576 {
577 colRef = m_Colors.GetColor(CColors::Stash);
578 shortname=_T("stash");
579 }
580 else if(GetShortName(str,shortname,_T("refs/bisect/")))
581 {
582 if(shortname.Find(_T("good")) == 0)
583 {
584 colRef = m_Colors.GetColor(CColors::BisectGood);
585 shortname = _T("good");
586 }
587
588 if(shortname.Find(_T("bad")) == 0)
589 {
590 colRef = m_Colors.GetColor(CColors::BisectBad);
591 shortname = _T("bad");
592 }
593 }
594
595 //When row selected, ajust label color
596 if (!(IsAppThemed() && SysInfo::Instance().IsVistaOrLater()))
597 if (rItem.state & LVIS_SELECTED)
598 colRef = CColors::MixColors(colRef, ::GetSysColor(COLOR_HIGHLIGHT), 150);
599
600 brush = ::CreateSolidBrush(colRef);
601
602 if(!shortname.IsEmpty() && (rt.left<rect.right) )
603 {
604 SIZE size;
605 memset(&size,0,sizeof(SIZE));
606 GetTextExtentPoint32(hdc, shortname,shortname.GetLength(),&size);
607
608 rt.SetRect(rt.left,rt.top,rt.left+size.cx,rt.bottom);
609 rt.right+=8;
610
611 int textpos = DT_CENTER;
612
613 if(rt.right > rect.right)
614 {
615 rt.right = rect.right;
616 textpos =0;
617 }
618
619 //Fill interior of ref label
620 ::FillRect(hdc, &rt, brush);
621
622 //Draw edge of label
623
624 CRect rectEdge = rt;
625
626 W_Dc.Draw3dRect(rectEdge, m_Colors.Lighten(colRef,100), m_Colors.Darken(colRef,100));
627 rectEdge.DeflateRect(1,1);
628 W_Dc.Draw3dRect(rectEdge, m_Colors.Lighten(colRef,50), m_Colors.Darken(colRef,50));
629
630 //Draw text inside label
631 if (IsAppThemed() && SysInfo::Instance().IsVistaOrLater())
632 {
633 int txtState = LISS_NORMAL;
634 if (rItem.state & LVIS_SELECTED)
635 txtState = LISS_SELECTED;
636
637 DrawThemeText(hTheme,hdc, LVP_LISTITEM, txtState, shortname, -1, textpos | DT_SINGLELINE | DT_VCENTER, 0, &rt);
638 }
639 else
640 {
641 W_Dc.SetBkMode(TRANSPARENT);
642 if (rItem.state & LVIS_SELECTED)
643 {
644 COLORREF clrNew = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
645 COLORREF clrOld = ::SetTextColor(hdc,clrNew);
646 ::DrawText(hdc,shortname,shortname.GetLength(),&rt,textpos | DT_SINGLELINE | DT_VCENTER);
647 ::SetTextColor(hdc,clrOld);
648 }
649 else
650 {
651 ::DrawText(hdc,shortname,shortname.GetLength(),&rt,textpos | DT_SINGLELINE | DT_VCENTER);
652 }
653 }
654
655 //::MoveToEx(hdc,rt.left,rt.top,NULL);
656 //::LineTo(hdc,rt.right,rt.top);
657 //::LineTo(hdc,rt.right,rt.bottom);
658 //::LineTo(hdc,rt.left,rt.bottom);
659 //::LineTo(hdc,rt.left,rt.top);
660
661 rt.left=rt.right+1;
662 }
663 if(brush)
664 ::DeleteObject(brush);
665 }
666 rt.right=rect.right;
667
668 if (IsAppThemed() && SysInfo::Instance().IsVistaOrLater())
669 {
670 int txtState = LISS_NORMAL;
671 if (rItem.state & LVIS_SELECTED)
672 txtState = LISS_SELECTED;
673
674 DrawThemeText(hTheme,hdc, LVP_LISTITEM, txtState, data->GetSubject(), -1, DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS, 0, &rt);
675 }
676 else
677 {
678 if (rItem.state & LVIS_SELECTED)
679 {
680 COLORREF clrOld = ::SetTextColor(hdc,::GetSysColor(COLOR_HIGHLIGHTTEXT));
681 ::DrawText(hdc,data->GetSubject(),data->GetSubject().GetLength(),&rt,DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS);
682 ::SetTextColor(hdc,clrOld);
683 }
684 else
685 {
686 ::DrawText(hdc,data->GetSubject(),data->GetSubject().GetLength(),&rt,DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS);
687 }
688 }
689
690 if (hTheme)
691 CloseThemeData(hTheme);
692
693 W_Dc.Detach();
694 }
695
696 static COLORREF blend(const COLORREF& col1, const COLORREF& col2, int amount = 128) {
697
698 // Returns ((256 - amount)*col1 + amount*col2) / 256;
699 return RGB(((256 - amount)*GetRValue(col1) + amount*GetRValue(col2) ) / 256,
700 ((256 - amount)*GetGValue(col1) + amount*GetGValue(col2) ) / 256,
701 ((256 - amount)*GetBValue(col1) + amount*GetBValue(col2) ) / 256);
702 }
703
704 Gdiplus::Color GetGdiColor(COLORREF col)
705 {
706 return Gdiplus::Color(GetRValue(col),GetGValue(col),GetBValue(col));
707 }
708 void CGitLogListBase::paintGraphLane(HDC hdc, int laneHeight,int type, int x1, int x2,
709 const COLORREF& col,const COLORREF& activeColor, int top
710 )
711 {
712 int h = laneHeight / 2;
713 int m = (x1 + x2) / 2;
714 int r = (x2 - x1) / 3;
715 int d = 2 * r;
716
717 #define P_CENTER m , h+top
718 #define P_0 x2, h+top
719 #define P_90 m , 0+top-1
720 #define P_180 x1, h+top
721 #define P_270 m , 2 * h+top +1
722 #define R_CENTER m - r, h - r+top, d, d
723
724
725 #define DELTA_UR_B 2*(x1 - m), 2*h +top
726 #define DELTA_UR_E 0*16, 90*16 +top // -,
727
728 #define DELTA_DR_B 2*(x1 - m), 2*-h +top
729 #define DELTA_DR_E 270*16, 90*16 +top // -'
730
731 #define DELTA_UL_B 2*(x2 - m), 2*h +top
732 #define DELTA_UL_E 90*16, 90*16 +top // ,-
733
734 #define DELTA_DL_B 2*(x2 - m),2*-h +top
735 #define DELTA_DL_E 180*16, 90*16 // '-
736
737 #define CENTER_UR x1, 2*h, 225
738 #define CENTER_DR x1, 0 , 135
739 #define CENTER_UL x2, 2*h, 315
740 #define CENTER_DL x2, 0 , 45
741
742
743 Gdiplus::Graphics graphics( hdc );
744
745 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
746
747 // arc
748 switch (type) {
749 case Lanes::JOIN:
750 case Lanes::JOIN_R:
751 case Lanes::HEAD:
752 case Lanes::HEAD_R:
753 {
754 Gdiplus::LinearGradientBrush gradient(
755 Gdiplus::Point(x1-2, h+top-2),
756 Gdiplus::Point(P_270),
757 GetGdiColor(activeColor),GetGdiColor(col));
758
759
760 Gdiplus::Pen mypen(&gradient,2);
761 //Gdiplus::Pen mypen(Gdiplus::Color(0,0,0),2);
762
763 //graphics.DrawRectangle(&mypen,x1-(x2-x1)/2,top+h, x2-x1,laneHeight);
764 graphics.DrawArc(&mypen,x1-(x2-x1)/2-1,top+h-1, x2-x1,laneHeight,270,90);
765 //graphics.DrawLine(&mypen,x1-1,h+top,P_270);
766
767 break;
768 }
769 case Lanes::JOIN_L:
770 {
771
772 Gdiplus::LinearGradientBrush gradient(
773 Gdiplus::Point(P_270),
774 Gdiplus::Point(x2+1, h+top-1),
775 GetGdiColor(col),GetGdiColor(activeColor));
776
777
778 Gdiplus::Pen mypen(&gradient,2);
779 //Gdiplus::Pen mypen(Gdiplus::Color(0,0,0),2);
780
781 //graphics.DrawRectangle(&mypen,x1-(x2-x1)/2,top+h, x2-x1,laneHeight);
782 graphics.DrawArc(&mypen,x1+(x2-x1)/2,top+h-1, x2-x1,laneHeight,180,90);
783 //graphics.DrawLine(&mypen,x1-1,h+top,P_270);
784
785
786 break;
787 }
788 case Lanes::TAIL:
789 case Lanes::TAIL_R:
790 {
791
792 Gdiplus::LinearGradientBrush gradient(
793 Gdiplus::Point(x1-2, h+top-2),
794 Gdiplus::Point(P_90),
795 GetGdiColor(activeColor),GetGdiColor(col));
796
797 Gdiplus::Pen mypen(&gradient,2);
798
799 graphics.DrawArc(&mypen,x1-(x2-x1)/2-1,top-h-1, x2-x1,laneHeight,0,90);
800
801 #if 0
802 QConicalGradient gradient(CENTER_DR);
803 gradient.setColorAt(0.375, activeCol);
804 gradient.setColorAt(0.625, col);
805 myPen.setBrush(gradient);
806 p->setPen(myPen);
807 p->drawArc(P_CENTER, DELTA_DR);
808 #endif
809 break;
810 }
811 default:
812 break;
813 }
814
815
816 //static QPen myPen(Qt::black, 2); // fast path here
817 CPen pen;
818 pen.CreatePen(PS_SOLID,2,col);
819 //myPen.setColor(col);
820 HPEN oldpen=(HPEN)::SelectObject(hdc,(HPEN)pen);
821
822 Gdiplus::Pen myPen(GetGdiColor(col),2);
823
824 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
825
826 //p->setPen(myPen);
827
828 // vertical line
829 switch (type) {
830 case Lanes::ACTIVE:
831 case Lanes::NOT_ACTIVE:
832 case Lanes::MERGE_FORK:
833 case Lanes::MERGE_FORK_R:
834 case Lanes::MERGE_FORK_L:
835 case Lanes::JOIN:
836 case Lanes::JOIN_R:
837 case Lanes::JOIN_L:
838 case Lanes::CROSS:
839 //DrawLine(hdc,P_90,P_270);
840 graphics.DrawLine(&myPen,P_90,P_270);
841 //p->drawLine(P_90, P_270);
842 break;
843 case Lanes::HEAD_L:
844 case Lanes::BRANCH:
845 //DrawLine(hdc,P_CENTER,P_270);
846 graphics.DrawLine(&myPen,P_CENTER,P_270);
847 //p->drawLine(P_CENTER, P_270);
848 break;
849 case Lanes::TAIL_L:
850 case Lanes::INITIAL:
851 case Lanes::BOUNDARY:
852 case Lanes::BOUNDARY_C:
853 case Lanes::BOUNDARY_R:
854 case Lanes::BOUNDARY_L:
855 //DrawLine(hdc,P_90, P_CENTER);
856 graphics.DrawLine(&myPen,P_90,P_CENTER);
857 //p->drawLine(P_90, P_CENTER);
858 break;
859 default:
860 break;
861 }
862
863 myPen.SetColor(GetGdiColor(activeColor));
864
865 // horizontal line
866 switch (type) {
867 case Lanes::MERGE_FORK:
868 case Lanes::JOIN:
869 case Lanes::HEAD:
870 case Lanes::TAIL:
871 case Lanes::CROSS:
872 case Lanes::CROSS_EMPTY:
873 case Lanes::BOUNDARY_C:
874 //DrawLine(hdc,P_180,P_0);
875 graphics.DrawLine(&myPen,P_180,P_0);
876 //p->drawLine(P_180, P_0);
877 break;
878 case Lanes::MERGE_FORK_R:
879 case Lanes::BOUNDARY_R:
880 //DrawLine(hdc,P_180,P_CENTER);
881 graphics.DrawLine(&myPen,P_180,P_CENTER);
882 //p->drawLine(P_180, P_CENTER);
883 break;
884 case Lanes::MERGE_FORK_L:
885 case Lanes::HEAD_L:
886 case Lanes::TAIL_L:
887 case Lanes::BOUNDARY_L:
888 //DrawLine(hdc,P_CENTER,P_0);
889 graphics.DrawLine(&myPen,P_CENTER,P_0);
890 //p->drawLine(P_CENTER, P_0);
891 break;
892 default:
893 break;
894 }
895
896 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
897
898 CBrush brush;
899 brush.CreateSolidBrush(col);
900 HBRUSH oldbrush=(HBRUSH)::SelectObject(hdc,(HBRUSH)brush);
901
902 Gdiplus::SolidBrush myBrush(GetGdiColor(col));
903 // center symbol, e.g. rect or ellipse
904 switch (type) {
905 case Lanes::ACTIVE:
906 case Lanes::INITIAL:
907 case Lanes::BRANCH:
908
909 //p->setPen(Qt::NoPen);
910 //p->setBrush(col);
911 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
912 graphics.FillEllipse(&myBrush, R_CENTER);
913 //p->drawEllipse(R_CENTER);
914 break;
915 case Lanes::MERGE_FORK:
916 case Lanes::MERGE_FORK_R:
917 case Lanes::MERGE_FORK_L:
918 //p->setPen(Qt::NoPen);
919 //p->setBrush(col);
920 //p->drawRect(R_CENTER);
921 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
922 graphics.FillRectangle(&myBrush, R_CENTER);
923 break;
924 case Lanes::UNAPPLIED:
925 // Red minus sign
926 //p->setPen(Qt::NoPen);
927 //p->setBrush(Qt::red);
928 //p->drawRect(m - r, h - 1, d, 2);
929 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
930 graphics.FillRectangle(&myBrush,m-r,h-1,d,2);
931 break;
932 case Lanes::APPLIED:
933 // Green plus sign
934 //p->setPen(Qt::NoPen);
935 //p->setBrush(DARK_GREEN);
936 //p->drawRect(m - r, h - 1, d, 2);
937 //p->drawRect(m - 1, h - r, 2, d);
938 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
939 graphics.FillRectangle(&myBrush,m-r,h-1,d,2);
940 graphics.FillRectangle(&myBrush,m-1,h-r,2,d);
941 break;
942 case Lanes::BOUNDARY:
943 //p->setBrush(back);
944 //p->drawEllipse(R_CENTER);
945 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
946 graphics.DrawEllipse(&myPen, R_CENTER);
947 break;
948 case Lanes::BOUNDARY_C:
949 case Lanes::BOUNDARY_R:
950 case Lanes::BOUNDARY_L:
951 //p->setBrush(back);
952 //p->drawRect(R_CENTER);
953 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
954 graphics.FillRectangle(&myBrush,R_CENTER);
955 break;
956 default:
957 break;
958 }
959
960 ::SelectObject(hdc,oldpen);
961 ::SelectObject(hdc,oldbrush);
962 #undef P_CENTER
963 #undef P_0
964 #undef P_90
965 #undef P_180
966 #undef P_270
967 #undef R_CENTER
968 }
969
970 void CGitLogListBase::DrawGraph(HDC hdc,CRect &rect,INT_PTR index)
971 {
972 // TODO: unfinished
973 // return;
974 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(index);
975 if(data->m_CommitHash.IsEmpty())
976 return;
977
978 CRect rt=rect;
979 LVITEM rItem;
980 SecureZeroMemory(&rItem, sizeof(LVITEM));
981 rItem.mask = LVIF_STATE;
982 rItem.iItem = (int)index;
983 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
984 GetItem(&rItem);
985
986 // p->translate(QPoint(opt.rect.left(), opt.rect.top()));
987
988 if (data->m_Lanes.empty())
989 m_logEntries.setLane(data->m_CommitHash);
990
991 std::vector<int>& lanes=data->m_Lanes;
992 size_t laneNum = lanes.size();
993 UINT activeLane = 0;
994 for (UINT i = 0; i < laneNum; i++)
995 if (Lanes::isMerge(lanes[i])) {
996 activeLane = i;
997 break;
998 }
999
1000 int x1 = 0, x2 = 0;
1001 int maxWidth = rect.Width();
1002 int lw = 3 * rect.Height() / 4; //laneWidth()
1003
1004 COLORREF activeColor = m_LineColors[activeLane % Lanes::COLORS_NUM];
1005 //if (opt.state & QStyle::State_Selected)
1006 // activeColor = blend(activeColor, opt.palette.highlightedText().color(), 208);
1007
1008 for (unsigned int i = 0; i < laneNum && x2 < maxWidth; i++)
1009 {
1010
1011 x1 = x2;
1012 x2 += lw;
1013
1014 int ln = lanes[i];
1015 if (ln == Lanes::EMPTY)
1016 continue;
1017
1018 COLORREF color = i == activeLane ? activeColor : m_LineColors[i % Lanes::COLORS_NUM];
1019 paintGraphLane(hdc, rect.Height(),ln, x1+rect.left, x2+rect.left, color,activeColor, rect.top);
1020 }
1021
1022 #if 0
1023 for (UINT i = 0; i < laneNum && x2 < maxWidth; i++) {
1024
1025 x1 = x2;
1026 x2 += lw;
1027
1028 int ln = lanes[i];
1029 if (ln == Lanes::EMPTY)
1030 continue;
1031
1032 UINT col = ( Lanes:: isHead(ln) ||Lanes:: isTail(ln) || Lanes::isJoin(ln)
1033 || ln ==Lanes:: CROSS_EMPTY) ? activeLane : i;
1034
1035 if (ln == Lanes::CROSS)
1036 {
1037 paintGraphLane(hdc, rect.Height(),Lanes::NOT_ACTIVE, x1, x2, m_LineColors[col % Lanes::COLORS_NUM],rect.top);
1038 paintGraphLane(hdc, rect.Height(),Lanes::CROSS, x1, x2, m_LineColors[activeLane % Lanes::COLORS_NUM],rect.top);
1039 }
1040 else
1041 paintGraphLane(hdc, rect.Height(),ln, x1, x2, m_LineColors[col % Lanes::COLORS_NUM],rect.top);
1042 }
1043 #endif
1044
1045 }
1046
1047 void CGitLogListBase::OnNMCustomdrawLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1048 {
1049
1050 NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
1051 // Take the default processing unless we set this to something else below.
1052 *pResult = CDRF_DODEFAULT;
1053
1054 if (m_bNoDispUpdates)
1055 return;
1056
1057 switch (pLVCD->nmcd.dwDrawStage)
1058 {
1059 case CDDS_PREPAINT:
1060 {
1061 *pResult = CDRF_NOTIFYITEMDRAW;
1062 return;
1063 }
1064 break;
1065 case CDDS_ITEMPREPAINT:
1066 {
1067 // This is the prepaint stage for an item. Here's where we set the
1068 // item's text color.
1069
1070 // Tell Windows to send draw notifications for each subitem.
1071 *pResult = CDRF_NOTIFYSUBITEMDRAW;
1072
1073 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
1074
1075 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)
1076 {
1077 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1078 if (data)
1079 {
1080 if (data->GetAction(this)& (CTGitPath::LOGACTIONS_REBASE_DONE| CTGitPath::LOGACTIONS_REBASE_SKIP) )
1081 crText = RGB(128,128,128);
1082
1083 if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_SQUASH)
1084 pLVCD->clrTextBk = RGB(156,156,156);
1085 else if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_EDIT)
1086 pLVCD->clrTextBk = RGB(200,200,128);
1087 else
1088 pLVCD->clrTextBk = ::GetSysColor(COLOR_WINDOW);
1089
1090 if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_CURRENT)
1091 {
1092 SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1093 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1094 }
1095
1096 if (data->m_CommitHash == m_HeadHash && m_bNoHightlightHead == FALSE)
1097 {
1098 SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1099 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1100 }
1101
1102 // if ((data->childStackDepth)||(m_mergedRevs.find(data->Rev) != m_mergedRevs.end()))
1103 // crText = GetSysColor(COLOR_GRAYTEXT);
1104
1105 if (data->m_CommitHash.IsEmpty())
1106 {
1107 //crText = GetSysColor(RGB(200,200,0));
1108 //SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1109 // We changed the font, so we're returning CDRF_NEWFONT. This
1110 // tells the control to recalculate the extent of the text.
1111 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1112 }
1113 }
1114 }
1115 if (m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec)
1116 {
1117 if (m_bStrictStopped)
1118 crText = GetSysColor(COLOR_GRAYTEXT);
1119 }
1120 // Store the color back in the NMLVCUSTOMDRAW struct.
1121 pLVCD->clrText = crText;
1122 return;
1123 }
1124 break;
1125 case CDDS_ITEMPREPAINT|CDDS_ITEM|CDDS_SUBITEM:
1126 {
1127 if ((m_bStrictStopped)&&(m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec))
1128 {
1129 pLVCD->nmcd.uItemState &= ~(CDIS_SELECTED|CDIS_FOCUS);
1130 }
1131
1132 if (pLVCD->iSubItem == LOGLIST_GRAPH && m_sFilterText.IsEmpty())
1133 {
1134 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec && (!this->m_IsRebaseReplaceGraph) )
1135 {
1136 CRect rect;
1137 GetSubItemRect((int)pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_LABEL, rect);
1138
1139 //TRACE(_T("A Graphic left %d right %d\r\n"),rect.left,rect.right);
1140 FillBackGround(pLVCD->nmcd.hdc, pLVCD->nmcd.dwItemSpec,rect);
1141
1142 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1143 if( !data ->m_CommitHash.IsEmpty())
1144 DrawGraph(pLVCD->nmcd.hdc,rect,pLVCD->nmcd.dwItemSpec);
1145
1146 *pResult = CDRF_SKIPDEFAULT;
1147 return;
1148 }
1149 }
1150
1151 if (pLVCD->iSubItem == LOGLIST_MESSAGE)
1152 {
1153 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)
1154 {
1155 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1156 //if(!data->m_IsFull)
1157 //{
1158 //if(data->SafeFetchFullInfo(&g_Git))
1159 // this->Invalidate();
1160 //TRACE(_T("Update ... %d\r\n"),pLVCD->nmcd.dwItemSpec);
1161 //}
1162
1163 if (!m_HashMap[data->m_CommitHash].empty())
1164 {
1165 CRect rect;
1166
1167 GetSubItemRect((int)pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
1168
1169 FillBackGround(pLVCD->nmcd.hdc, pLVCD->nmcd.dwItemSpec,rect);
1170 DrawTagBranch(pLVCD->nmcd.hdc,rect,pLVCD->nmcd.dwItemSpec);
1171
1172 *pResult = CDRF_SKIPDEFAULT;
1173 return;
1174
1175 }
1176
1177 }
1178 }
1179
1180 if (pLVCD->iSubItem == LOGLIST_ACTION)
1181 {
1182 if(this->m_IsIDReplaceAction)
1183 {
1184 *pResult = CDRF_DODEFAULT;
1185 return;
1186 }
1187 *pResult = CDRF_DODEFAULT;
1188
1189 if (m_arShownList.GetCount() <= (INT_PTR)pLVCD->nmcd.dwItemSpec)
1190 return;
1191
1192 int nIcons = 0;
1193 int iconwidth = ::GetSystemMetrics(SM_CXSMICON);
1194 int iconheight = ::GetSystemMetrics(SM_CYSMICON);
1195
1196 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec));
1197 CRect rect;
1198 GetSubItemRect((int)pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
1199 //TRACE(_T("Action left %d right %d\r\n"),rect.left,rect.right);
1200 // Get the selected state of the
1201 // item being drawn.
1202
1203 // Fill the background if necessary
1204 FillBackGround(pLVCD->nmcd.hdc, pLVCD->nmcd.dwItemSpec, rect);
1205
1206 // Draw the icon(s) into the compatible DC
1207 pLogEntry->GetAction(this);
1208
1209 if (!pLogEntry->m_IsDiffFiles)
1210 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left + ICONITEMBORDER, rect.top, m_hFetchIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1211
1212 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_MODIFIED)
1213 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left + ICONITEMBORDER, rect.top, m_hModifiedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1214 nIcons++;
1215
1216 if (pLogEntry->GetAction(this) & (CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_COPY) )
1217 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hAddedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1218 nIcons++;
1219
1220 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_DELETED)
1221 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hDeletedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1222 nIcons++;
1223
1224 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_REPLACED)
1225 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hReplacedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1226 nIcons++;
1227 *pResult = CDRF_SKIPDEFAULT;
1228 return;
1229 }
1230 }
1231 break;
1232 }
1233 *pResult = CDRF_DODEFAULT;
1234 }
1235
1236 // CGitLogListBase message handlers
1237
1238 void CGitLogListBase::OnLvnGetdispinfoLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1239 {
1240 NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
1241
1242 // Create a pointer to the item
1243 LV_ITEM* pItem = &(pDispInfo)->item;
1244
1245 // Do the list need text information?
1246 if (!(pItem->mask & LVIF_TEXT))
1247 return;
1248
1249 // By default, clear text buffer.
1250 lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);
1251
1252 bool bOutOfRange = pItem->iItem >= ShownCountWithStopped();
1253
1254 *pResult = 0;
1255 if (m_bNoDispUpdates || bOutOfRange)
1256 return;
1257
1258 // Which item number?
1259 int itemid = pItem->iItem;
1260 GitRev * pLogEntry = NULL;
1261 if (itemid < m_arShownList.GetCount())
1262 pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(pItem->iItem));
1263
1264 CString temp;
1265 if(m_IsOldFirst)
1266 {
1267 temp.Format(_T("%d"),pItem->iItem+1);
1268
1269 }
1270 else
1271 {
1272 temp.Format(_T("%d"),m_arShownList.GetCount()-pItem->iItem);
1273 }
1274
1275 // Which column?
1276 switch (pItem->iSubItem)
1277 {
1278 case this->LOGLIST_GRAPH: //Graphic
1279 break;
1280 case this->LOGLIST_REBASE:
1281 {
1282 if(this->m_IsRebaseReplaceGraph)
1283 {
1284 CTGitPath path;
1285 path.m_Action=pLogEntry->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_MODE_MASK;
1286 lstrcpyn(pItem->pszText,path.GetActionName(), pItem->cchTextMax);
1287 }
1288 }
1289 break;
1290 case this->LOGLIST_ACTION: //action -- no text in the column
1291 break;
1292 case this->LOGLIST_HASH:
1293 if(pLogEntry)
1294 lstrcpyn(pItem->pszText, pLogEntry->m_CommitHash.ToString(), pItem->cchTextMax);
1295 break;
1296 case this->LOGLIST_ID:
1297 if(this->m_IsIDReplaceAction)
1298 lstrcpyn(pItem->pszText, temp, pItem->cchTextMax);
1299 break;
1300 case this->LOGLIST_MESSAGE: //Message
1301 if (pLogEntry)
1302 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetSubject(), pItem->cchTextMax);
1303 break;
1304 case this->LOGLIST_AUTHOR: //Author
1305 if (pLogEntry)
1306 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetAuthorName(), pItem->cchTextMax);
1307 break;
1308 case this->LOGLIST_DATE: //Date
1309 if ( pLogEntry && (!pLogEntry->m_CommitHash.IsEmpty()) )
1310 lstrcpyn(pItem->pszText,
1311 CLoglistUtils::FormatDateAndTime(pLogEntry->GetAuthorDate(), m_DateFormat, true, m_bRelativeTimes),
1312 pItem->cchTextMax);
1313 break;
1314
1315 case this->LOGLIST_EMAIL:
1316 if (pLogEntry)
1317 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetAuthorEmail(), pItem->cchTextMax);
1318 break;
1319
1320 case this->LOGLIST_COMMIT_NAME: //Commit
1321 if (pLogEntry)
1322 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetCommitterName(), pItem->cchTextMax);
1323 break;
1324
1325 case this->LOGLIST_COMMIT_EMAIL: //Commit Email
1326 if (pLogEntry)
1327 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetCommitterEmail(), pItem->cchTextMax);
1328 break;
1329
1330 case this->LOGLIST_COMMIT_DATE: //Commit Date
1331 if (pLogEntry && (!pLogEntry->m_CommitHash.IsEmpty()))
1332 lstrcpyn(pItem->pszText,
1333 CLoglistUtils::FormatDateAndTime(pLogEntry->GetCommitterDate(), m_DateFormat, true, m_bRelativeTimes),
1334 pItem->cchTextMax);
1335 break;
1336 case this->LOGLIST_BUG: //Bug ID
1337 if(pLogEntry)
1338 lstrcpyn(pItem->pszText, (LPCTSTR)this->m_ProjectProperties.FindBugID(pLogEntry->GetSubject() + _T("\r\n\r\n") + pLogEntry->GetBody()), pItem->cchTextMax);
1339 break;
1340
1341 default:
1342 ASSERT(false);
1343 }
1344 }
1345
1346 void CGitLogListBase::OnContextMenu(CWnd* pWnd, CPoint point)
1347 {
1348
1349 if (pWnd == GetHeaderCtrl())
1350 {
1351 return m_ColumnManager.OnContextMenuHeader(pWnd,point,!!IsGroupViewEnabled());
1352 }
1353
1354 int selIndex = GetSelectionMark();
1355 if (selIndex < 0)
1356 return; // nothing selected, nothing to do with a context menu
1357
1358 // if the user selected the info text telling about not all revisions shown due to
1359 // the "stop on copy/rename" option, we also don't show the context menu
1360 if ((m_bStrictStopped)&&(selIndex == m_arShownList.GetCount()))
1361 return;
1362
1363 // if the context menu is invoked through the keyboard, we have to use
1364 // a calculated position on where to anchor the menu on
1365 if ((point.x == -1) && (point.y == -1))
1366 {
1367 CRect rect;
1368 GetItemRect(selIndex, &rect, LVIR_LABEL);
1369 ClientToScreen(&rect);
1370 point = rect.CenterPoint();
1371 }
1372 m_nSearchIndex = selIndex;
1373 m_bCancelled = FALSE;
1374
1375 // calculate some information the context menu commands can use
1376 // CString pathURL = GetURLFromPath(m_path);
1377
1378 POSITION pos = GetFirstSelectedItemPosition();
1379 int indexNext = GetNextSelectedItem(pos);
1380 if (indexNext < 0)
1381 return;
1382
1383 GitRev* pSelLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(indexNext));
1384 #if 0
1385 GitRev revSelected = pSelLogEntry->Rev;
1386 GitRev revPrevious = git_revnum_t(revSelected)-1;
1387 if ((pSelLogEntry->pArChangedPaths)&&(pSelLogEntry->pArChangedPaths->GetCount() <= 2))
1388 {
1389 for (int i=0; i<pSelLogEntry->pArChangedPaths->GetCount(); ++i)
1390 {
1391 LogChangedPath * changedpath = (LogChangedPath *)pSelLogEntry->pArChangedPaths->SafeGetAt(i);
1392 if (changedpath->lCopyFromRev)
1393 revPrevious = changedpath->lCopyFromRev;
1394 }
1395 }
1396 GitRev revSelected2;
1397 if (pos)
1398 {
1399 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1400 revSelected2 = pLogEntry->Rev;
1401 }
1402 bool bAllFromTheSameAuthor = true;
1403 CString firstAuthor;
1404 CLogDataVector selEntries;
1405 GitRev revLowest, revHighest;
1406 GitRevRangeArray revisionRanges;
1407 {
1408 POSITION pos = GetFirstSelectedItemPosition();
1409 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1410 revisionRanges.AddRevision(pLogEntry->Rev);
1411 selEntries.push_back(pLogEntry);
1412 firstAuthor = pLogEntry->sAuthor;
1413 revLowest = pLogEntry->Rev;
1414 revHighest = pLogEntry->Rev;
1415 while (pos)
1416 {
1417 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1418 revisionRanges.AddRevision(pLogEntry->Rev);
1419 selEntries.push_back(pLogEntry);
1420 if (firstAuthor.Compare(pLogEntry->sAuthor))
1421 bAllFromTheSameAuthor = false;
1422 revLowest = (git_revnum_t(pLogEntry->Rev) > git_revnum_t(revLowest) ? revLowest : pLogEntry->Rev);
1423 revHighest = (git_revnum_t(pLogEntry->Rev) < git_revnum_t(revHighest) ? revHighest : pLogEntry->Rev);
1424 }
1425 }
1426
1427 #endif
1428
1429 int FirstSelect=-1, LastSelect=-1;
1430 pos = GetFirstSelectedItemPosition();
1431 FirstSelect = GetNextSelectedItem(pos);
1432 while(pos)
1433 {
1434 LastSelect = GetNextSelectedItem(pos);
1435 }
1436 //entry is selected, now show the popup menu
1437 CIconMenu popup;
1438 CIconMenu subbranchmenu, submenu, gnudiffmenu, diffmenu, revertmenu;
1439
1440 if (popup.CreatePopupMenu())
1441 {
1442 bool isHeadCommit = (pSelLogEntry->m_CommitHash == m_HeadHash);
1443 CString currentBranch = _T("refs/heads/") + g_Git.GetCurrentBranch();
1444
1445 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_PICK))
1446 popup.AppendMenuIcon(ID_REBASE_PICK, IDS_REBASE_PICK, IDI_PICK);
1447
1448 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_SQUASH))
1449 popup.AppendMenuIcon(ID_REBASE_SQUASH, IDS_REBASE_SQUASH, IDI_SQUASH);
1450
1451 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_EDIT))
1452 popup.AppendMenuIcon(ID_REBASE_EDIT, IDS_REBASE_EDIT, IDI_EDIT);
1453
1454 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_SKIP))
1455 popup.AppendMenuIcon(ID_REBASE_SKIP, IDS_REBASE_SKIP, IDI_SKIP);
1456
1457 if(m_ContextMenuMask&(GetContextMenuBit(ID_REBASE_SKIP)|GetContextMenuBit(ID_REBASE_EDIT)|
1458 GetContextMenuBit(ID_REBASE_SQUASH)|GetContextMenuBit(ID_REBASE_PICK)))
1459 popup.AppendMenu(MF_SEPARATOR, NULL);
1460
1461 if (GetSelectedCount() == 1)
1462 {
1463
1464 {
1465 if( !pSelLogEntry->m_CommitHash.IsEmpty())
1466 {
1467 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPARE) && m_hasWC) // compare revision with WC
1468 popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARE, IDI_DIFF);
1469 }
1470 else
1471 {
1472 if(m_ContextMenuMask&GetContextMenuBit(ID_COMMIT))
1473 popup.AppendMenuIcon(ID_COMMIT, IDS_LOG_POPUP_COMMIT, IDI_COMMIT);
1474 }
1475 if(m_ContextMenuMask&GetContextMenuBit(ID_GNUDIFF1) && m_hasWC) // compare with WC, unified
1476 {
1477 GitRev *pRev=pSelLogEntry;
1478 if (pSelLogEntry->m_ParentHash.empty())
1479 {
1480 pRev->GetParentFromHash(pRev->m_CommitHash);
1481 }
1482 if(pRev->m_ParentHash.size()<=1)
1483 {
1484 popup.AppendMenuIcon(ID_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF_CH, IDI_DIFF);
1485
1486 }
1487 else
1488 {
1489 gnudiffmenu.CreatePopupMenu();
1490 popup.AppendMenuIcon(ID_GNUDIFF1,IDS_LOG_POPUP_GNUDIFF_PARENT, IDI_DIFF, gnudiffmenu.m_hMenu);
1491
1492 gnudiffmenu.AppendMenuIcon((UINT_PTR)(ID_GNUDIFF1 + (0xFFFF << 16)), CString(MAKEINTRESOURCE(IDS_ALLPARENTS)));
1493 gnudiffmenu.AppendMenuIcon((UINT_PTR)(ID_GNUDIFF1 + (0xFFFE << 16)), CString(MAKEINTRESOURCE(IDS_ONLYMERGEDFILES)));
1494
1495 for(int i=0;i<pRev->m_ParentHash.size();i++)
1496 {
1497 CString str;
1498 str.Format(IDS_PARENT, i + 1);
1499 gnudiffmenu.AppendMenuIcon(ID_GNUDIFF1+((i+1)<<16),str);
1500 }
1501 }
1502 }
1503
1504 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPAREWITHPREVIOUS))
1505 {
1506
1507 GitRev *pRev=pSelLogEntry;
1508 if (pSelLogEntry->m_ParentHash.empty())
1509 {
1510 pRev->GetParentFromHash(pRev->m_CommitHash);
1511 }
1512 if(pRev->m_ParentHash.size()<=1)
1513 {
1514 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF);
1515 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1516 popup.SetDefaultItem(ID_COMPAREWITHPREVIOUS, FALSE);
1517 }
1518 else
1519 {
1520 diffmenu.CreatePopupMenu();
1521 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF, diffmenu.m_hMenu);
1522 for(int i=0;i<pRev->m_ParentHash.size();i++)
1523 {
1524 CString str;
1525 str.Format(IDS_PARENT, i + 1);
1526 diffmenu.AppendMenuIcon(ID_COMPAREWITHPREVIOUS +((i+1)<<16),str);
1527 if (i == 0 && CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1528 {
1529 popup.SetDefaultItem(ID_COMPAREWITHPREVIOUS, FALSE);
1530 diffmenu.SetDefaultItem(ID_COMPAREWITHPREVIOUS +((i+1)<<16), FALSE);
1531 }
1532 }
1533 }
1534 }
1535
1536 if(m_ContextMenuMask&GetContextMenuBit(ID_BLAME))
1537 popup.AppendMenuIcon(ID_BLAME, IDS_LOG_POPUP_BLAME, IDI_BLAME);
1538
1539 //popup.AppendMenuIcon(ID_BLAMEWITHPREVIOUS, IDS_LOG_POPUP_BLAMEWITHPREVIOUS, IDI_BLAME);
1540 popup.AppendMenu(MF_SEPARATOR, NULL);
1541
1542 if (pSelLogEntry->m_CommitHash.IsEmpty())
1543 {
1544 if(m_ContextMenuMask&GetContextMenuBit(ID_STASH_SAVE))
1545 popup.AppendMenuIcon(ID_STASH_SAVE, IDS_MENUSTASHSAVE, IDI_COMMIT);
1546 }
1547
1548 bool isStash = false;
1549 for (int i = 0; i < m_HashMap[pSelLogEntry->m_CommitHash].size(); i++)
1550 {
1551 if (m_HashMap[pSelLogEntry->m_CommitHash][i] == _T("refs/stash"))
1552 {
1553 isStash = true;
1554 break;
1555 }
1556 }
1557
1558 if (CTGitPath(g_Git.m_CurrentDir).HasStashDir() && (pSelLogEntry->m_CommitHash.IsEmpty() || isStash))
1559 {
1560 if (m_ContextMenuMask&GetContextMenuBit(ID_STASH_POP))
1561 popup.AppendMenuIcon(ID_STASH_POP, IDS_MENUSTASHPOP, IDI_RELOCATE);
1562
1563 if (m_ContextMenuMask&GetContextMenuBit(ID_STASH_LIST))
1564 popup.AppendMenuIcon(ID_STASH_LIST, IDS_MENUSTASHLIST, IDI_LOG);
1565
1566 popup.AppendMenu(MF_SEPARATOR, NULL);
1567 }
1568
1569 if (pSelLogEntry->m_CommitHash.IsEmpty())
1570 {
1571 if(m_ContextMenuMask&GetContextMenuBit(ID_FETCH))
1572 popup.AppendMenuIcon(ID_FETCH, IDS_MENUFETCH, IDI_PULL);
1573
1574 popup.AppendMenu(MF_SEPARATOR, NULL);
1575 }
1576 }
1577
1578 // if (!m_ProjectProperties.sWebViewerRev.IsEmpty())
1579 // {
1580 // popup.AppendMenuIcon(ID_VIEWREV, IDS_LOG_POPUP_VIEWREV);
1581 // }
1582 // if (!m_ProjectProperties.sWebViewerPathRev.IsEmpty())
1583 // {
1584 // popup.AppendMenuIcon(ID_VIEWPATHREV, IDS_LOG_POPUP_VIEWPATHREV);
1585 // }
1586 // if ((!m_ProjectProperties.sWebViewerPathRev.IsEmpty())||
1587 // (!m_ProjectProperties.sWebViewerRev.IsEmpty()))
1588 // {
1589 // popup.AppendMenu(MF_SEPARATOR, NULL);
1590 // }
1591
1592 CString str,format;
1593 //if (m_hasWC)
1594 // popup.AppendMenuIcon(ID_REVERTTOREV, IDS_LOG_POPUP_REVERTTOREV, IDI_REVERT);
1595
1596 if(!pSelLogEntry->m_CommitHash.IsEmpty())
1597 {
1598 if((m_ContextMenuMask&GetContextMenuBit(ID_LOG)) &&
1599 GetSelectedCount() == 1)
1600 popup.AppendMenuIcon(ID_LOG, IDS_LOG_POPUP_LOG, IDI_LOG);
1601
1602 if (m_ContextMenuMask&GetContextMenuBit(ID_REPOBROWSE))
1603 popup.AppendMenuIcon(ID_REPOBROWSE, IDS_LOG_BROWSEREPO, IDI_REPOBROWSE);
1604
1605 format.LoadString(IDS_LOG_POPUP_MERGEREV);
1606 str.Format(format,g_Git.GetCurrentBranch());
1607
1608 if (m_ContextMenuMask&GetContextMenuBit(ID_MERGEREV) && !isHeadCommit && m_hasWC)
1609 popup.AppendMenuIcon(ID_MERGEREV, str, IDI_MERGE);
1610
1611 format.LoadString(IDS_RESET_TO_THIS_FORMAT);
1612 str.Format(format,g_Git.GetCurrentBranch());
1613
1614 if(m_ContextMenuMask&GetContextMenuBit(ID_RESET) && m_hasWC)
1615 popup.AppendMenuIcon(ID_RESET,str,IDI_REVERT);
1616
1617
1618 // Add Switch Branch express Menu
1619 if( this->m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.end()
1620 && (m_ContextMenuMask&GetContextMenuBit(ID_SWITCHBRANCH) && m_hasWC)
1621 )
1622 {
1623 std::vector<CString *> branchs;
1624 for(int i=0;i<m_HashMap[pSelLogEntry->m_CommitHash].size();i++)
1625 {
1626 CString ref = m_HashMap[pSelLogEntry->m_CommitHash][i];
1627 if(ref.Find(_T("refs/heads/")) == 0 && ref != currentBranch)
1628 {
1629 branchs.push_back(&m_HashMap[pSelLogEntry->m_CommitHash][i]);
1630 }
1631 }
1632
1633 CString str;
1634 str.LoadString(IDS_SWITCH_BRANCH);
1635
1636 if(branchs.size() == 1)
1637 {
1638 str+=_T(" ");
1639 str+= _T('"') + branchs[0]->Mid(11) + _T('"');
1640 popup.AppendMenuIcon(ID_SWITCHBRANCH,str,IDI_SWITCH);
1641
1642 popup.SetMenuItemData(ID_SWITCHBRANCH,(ULONG_PTR)branchs[0]);
1643
1644 }
1645 else if(branchs.size() > 1)
1646 {
1647 subbranchmenu.CreatePopupMenu();
1648 for(int i=0;i<branchs.size();i++)
1649 {
1650 if (*branchs[i] != currentBranch)
1651 {
1652 subbranchmenu.AppendMenuIcon(ID_SWITCHBRANCH+(i<<16), branchs[i]->Mid(11));
1653 subbranchmenu.SetMenuItemData(ID_SWITCHBRANCH+(i<<16), (ULONG_PTR) branchs[i]);
1654 }
1655 }
1656
1657 popup.AppendMenuIcon(ID_SWITCHBRANCH, str, IDI_SWITCH, subbranchmenu.m_hMenu);
1658 }
1659 }
1660
1661 if(m_ContextMenuMask&GetContextMenuBit(ID_SWITCHTOREV) && !isHeadCommit && m_hasWC)
1662 popup.AppendMenuIcon(ID_SWITCHTOREV, IDS_SWITCH_TO_THIS , IDI_SWITCH);
1663
1664 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_BRANCH))
1665 popup.AppendMenuIcon(ID_CREATE_BRANCH, IDS_CREATE_BRANCH_AT_THIS , IDI_COPY);
1666
1667 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_TAG))
1668 popup.AppendMenuIcon(ID_CREATE_TAG,IDS_CREATE_TAG_AT_THIS , IDI_TAG);
1669
1670 format.LoadString(IDS_REBASE_THIS_FORMAT);
1671 str.Format(format,g_Git.GetCurrentBranch());
1672
1673 if(pSelLogEntry->m_CommitHash != m_HeadHash && m_hasWC)
1674 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_TO_VERSION))
1675 popup.AppendMenuIcon(ID_REBASE_TO_VERSION, str , IDI_REBASE);
1676
1677 if(m_ContextMenuMask&GetContextMenuBit(ID_EXPORT))
1678 popup.AppendMenuIcon(ID_EXPORT,IDS_EXPORT_TO_THIS, IDI_EXPORT);
1679
1680 if (m_ContextMenuMask&GetContextMenuBit(ID_REVERTREV) && m_hasWC)
1681 {
1682 GitRev *pRev = pSelLogEntry;
1683 if (pSelLogEntry->m_ParentHash.empty())
1684 {
1685 pRev->GetParentFromHash(pRev->m_CommitHash);
1686 }
1687 if (pRev->m_ParentHash.size() == 1)
1688 {
1689 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREV, IDI_REVERT);
1690 }
1691 else
1692 {
1693 revertmenu.CreatePopupMenu();
1694 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREV, IDI_REVERT, revertmenu.m_hMenu);
1695
1696 for (int i = 0; i < pRev->m_ParentHash.size(); i++)
1697 {
1698 CString str;
1699 str.Format(IDS_PARENT, i + 1);
1700 revertmenu.AppendMenuIcon(ID_REVERTREV + ((i + 1) << 16), str);
1701 }
1702 }
1703 }
1704
1705 if (m_ContextMenuMask&GetContextMenuBit(ID_EDITNOTE))
1706 popup.AppendMenuIcon(ID_EDITNOTE, IDS_EDIT_NOTES, IDI_EDIT);
1707
1708 popup.AppendMenu(MF_SEPARATOR, NULL);
1709 }
1710
1711 }
1712
1713 if(!pSelLogEntry->m_Ref.IsEmpty())
1714 {
1715 popup.AppendMenuIcon(ID_REFLOG_DEL, IDS_REFLOG_DEL, IDI_DELETE);
1716 if (GetSelectedCount() == 1 && pSelLogEntry->m_Ref.Find(_T("refs/stash")) == 0)
1717 popup.AppendMenuIcon(ID_REFLOG_STASH_APPLY, IDS_MENUSTASHAPPLY, IDI_RELOCATE);
1718 popup.AppendMenu(MF_SEPARATOR, NULL);
1719 }
1720
1721 if (GetSelectedCount() >= 2)
1722 {
1723 bool bAddSeparator = false;
1724 if (IsSelectionContinuous() || (GetSelectedCount() == 2))
1725 {
1726 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPARETWO)) // compare two revisions
1727 popup.AppendMenuIcon(ID_COMPARETWO, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);
1728 }
1729
1730 if (GetSelectedCount() == 2)
1731 {
1732 if(m_ContextMenuMask&GetContextMenuBit(ID_GNUDIFF2) && m_hasWC) // compare two revisions, unified
1733 popup.AppendMenuIcon(ID_GNUDIFF2, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
1734 bAddSeparator = true;
1735 }
1736
1737 if (m_hasWC)
1738 {
1739 bAddSeparator = true;
1740 }
1741
1742 if (m_ContextMenuMask&GetContextMenuBit(ID_REVERTREV) && m_hasWC)
1743 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREVS, IDI_REVERT);
1744
1745 if (bAddSeparator)
1746 popup.AppendMenu(MF_SEPARATOR, NULL);
1747 }
1748
1749 if ( GetSelectedCount() >0 && (!pSelLogEntry->m_CommitHash.IsEmpty()))
1750 {
1751 bool bAddSeparator = false;
1752 if ( IsSelectionContinuous() && GetSelectedCount() >= 2 )
1753 {
1754 if(m_ContextMenuMask&GetContextMenuBit(ID_COMBINE_COMMIT) && m_hasWC)
1755 {
1756 CString head;
1757 int headindex;
1758 headindex = this->GetHeadIndex();
1759 if(headindex>=0)
1760 {
1761 head.Format(_T("HEAD~%d"),LastSelect-headindex);
1762 CGitHash hash=g_Git.GetHash(head);
1763 GitRev* pLastEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(LastSelect));
1764 if(pLastEntry->m_CommitHash == hash) {
1765 popup.AppendMenuIcon(ID_COMBINE_COMMIT,IDS_COMBINE_TO_ONE,IDI_COMBINE);
1766 bAddSeparator = true;
1767 }
1768 }
1769 }
1770 }
1771 if(m_ContextMenuMask&GetContextMenuBit(ID_CHERRY_PICK) && !isHeadCommit && m_hasWC) {
1772 if (GetSelectedCount() >= 2)
1773 popup.AppendMenuIcon(ID_CHERRY_PICK, IDS_CHERRY_PICK_VERSIONS, IDI_EXPORT);
1774 else
1775 popup.AppendMenuIcon(ID_CHERRY_PICK, IDS_CHERRY_PICK_VERSION, IDI_EXPORT);
1776 bAddSeparator = true;
1777 }
1778
1779 if(GetSelectedCount()<=2 || (IsSelectionContinuous() && GetSelectedCount() > 0))
1780 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_PATCH)) {
1781 popup.AppendMenuIcon(ID_CREATE_PATCH, IDS_CREATE_PATCH, IDI_PATCH);
1782 bAddSeparator = true;
1783 }
1784
1785 if (bAddSeparator)
1786 popup.AppendMenu(MF_SEPARATOR, NULL);
1787 }
1788
1789 if (m_hasWC && (m_ContextMenuMask & GetContextMenuBit(ID_BISECTSTART)) && GetSelectedCount() == 2 && !reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(FirstSelect))->m_CommitHash.IsEmpty() && !CTGitPath(g_Git.m_CurrentDir).IsBisectActive())
1790 {
1791 popup.AppendMenuIcon(ID_BISECTSTART, IDS_MENUBISECTSTART);
1792 popup.AppendMenu(MF_SEPARATOR, NULL);
1793 }
1794
1795 if (GetSelectedCount() == 1)
1796 {
1797 bool bAddSeparator = false;
1798 if(m_ContextMenuMask&GetContextMenuBit(ID_PUSH) && !m_HashMap[pSelLogEntry->m_CommitHash].empty())
1799 {
1800 // show the push-option only if the log entry has an associated local branch
1801 bool isLocal = false;
1802 for(int i=0; isLocal == false && i < m_HashMap[pSelLogEntry->m_CommitHash].size(); i++)
1803 {
1804 if (m_HashMap[pSelLogEntry->m_CommitHash][i].Find(_T("refs/heads/")) == 0)
1805 isLocal = true;
1806 }
1807 if (isLocal)
1808 {
1809 popup.AppendMenuIcon(ID_PUSH, IDS_LOG_PUSH, IDI_PUSH);
1810 bAddSeparator = true;
1811 }
1812 }
1813
1814 if(m_ContextMenuMask &GetContextMenuBit(ID_DELETE))
1815 {
1816 if( this->m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.end() )
1817 {
1818 std::vector<CString *> branchs;
1819 for (int i = 0; i < m_HashMap[pSelLogEntry->m_CommitHash].size(); i++)
1820 {
1821 if(m_HashMap[pSelLogEntry->m_CommitHash][i] != currentBranch)
1822 branchs.push_back(&m_HashMap[pSelLogEntry->m_CommitHash][i]);
1823 }
1824 CString str;
1825 if (branchs.size() == 1)
1826 {
1827 str.LoadString(IDS_DELETE_BRANCHTAG_SHORT);
1828 str+=_T(" ");
1829 str += *branchs[0];
1830 popup.AppendMenuIcon(ID_DELETE, str, IDI_DELETE);
1831 popup.SetMenuItemData(ID_DELETE, (ULONG_PTR)branchs[0]);
1832 bAddSeparator = true;
1833 }
1834 else if (branchs.size() > 1)
1835 {
1836 str.LoadString(IDS_DELETE_BRANCHTAG);
1837 submenu.CreatePopupMenu();
1838 for (int i = 0; i < branchs.size(); i++)
1839 {
1840 submenu.AppendMenuIcon(ID_DELETE + (i << 16), *branchs[i]);
1841 submenu.SetMenuItemData(ID_DELETE + (i << 16), (ULONG_PTR)branchs[i]);
1842 }
1843
1844 popup.AppendMenuIcon(ID_DELETE,str, IDI_DELETE, submenu.m_hMenu);
1845 bAddSeparator = true;
1846 }
1847 }
1848 } // m_ContextMenuMask &GetContextMenuBit(ID_DELETE)
1849 if (bAddSeparator)
1850 popup.AppendMenu(MF_SEPARATOR, NULL);
1851 } // GetSelectedCount() == 1
1852
1853 if (GetSelectedCount() != 0)
1854 {
1855 if(m_ContextMenuMask&GetContextMenuBit(ID_COPYHASH))
1856 popup.AppendMenuIcon(ID_COPYHASH, IDS_COPY_COMMIT_HASH, IDI_COPYCLIP);
1857 if(m_ContextMenuMask&GetContextMenuBit(ID_COPYCLIPBOARD))
1858 popup.AppendMenuIcon(ID_COPYCLIPBOARD, IDS_LOG_POPUP_COPYTOCLIPBOARD, IDI_COPYCLIP);
1859 if(m_ContextMenuMask&GetContextMenuBit(ID_COPYCLIPBOARDMESSAGES))
1860 popup.AppendMenuIcon(ID_COPYCLIPBOARDMESSAGES, IDS_LOG_POPUP_COPYTOCLIPBOARDMESSAGES, IDI_COPYCLIP);
1861 }
1862
1863 if(m_ContextMenuMask&GetContextMenuBit(ID_FINDENTRY))
1864 popup.AppendMenuIcon(ID_FINDENTRY, IDS_LOG_POPUP_FIND, IDI_FILTEREDIT);
1865
1866 if (GetSelectedCount() == 1 && m_ContextMenuMask & GetContextMenuBit(ID_SHOWBRANCHES) && !pSelLogEntry->m_CommitHash.IsEmpty())
1867 popup.AppendMenuIcon(ID_SHOWBRANCHES, IDS_LOG_POPUP_SHOWBRANCHES, IDI_SHOWBRANCHES);
1868
1869 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1870 // DialogEnableWindow(IDOK, FALSE);
1871 // SetPromptApp(&theApp);
1872
1873 this->ContextMenuAction(cmd, FirstSelect, LastSelect, &popup);
1874
1875 // EnableOKButton();
1876 } // if (popup.CreatePopupMenu())
1877
1878 }
1879
1880 bool CGitLogListBase::IsSelectionContinuous()
1881 {
1882 if ( GetSelectedCount()==1 )
1883 {
1884 // if only one revision is selected, the selection is of course
1885 // continuous
1886 return true;
1887 }
1888
1889 POSITION pos = GetFirstSelectedItemPosition();
1890 bool bContinuous = (m_arShownList.GetCount() == (INT_PTR)m_logEntries.size());
1891 if (bContinuous)
1892 {
1893 int itemindex = GetNextSelectedItem(pos);
1894 while (pos)
1895 {
1896 int nextindex = GetNextSelectedItem(pos);
1897 if (nextindex - itemindex > 1)
1898 {
1899 bContinuous = false;
1900 break;
1901 }
1902 itemindex = nextindex;
1903 }
1904 }
1905 return bContinuous;
1906 }
1907
1908 void CGitLogListBase::CopySelectionToClipBoard(int toCopy)
1909 {
1910
1911 CString sClipdata;
1912 POSITION pos = GetFirstSelectedItemPosition();
1913 if (pos != NULL)
1914 {
1915 CString sRev;
1916 sRev.LoadString(IDS_LOG_REVISION);
1917 CString sAuthor;
1918 sAuthor.LoadString(IDS_LOG_AUTHOR);
1919 CString sDate;
1920 sDate.LoadString(IDS_LOG_DATE);
1921 CString sMessage;
1922 sMessage.LoadString(IDS_LOG_MESSAGE);
1923 bool first = true;
1924 while (pos)
1925 {
1926 CString sLogCopyText;
1927 CString sPaths;
1928 GitRev * pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1929
1930 if (toCopy == ID_COPY_ALL)
1931 {
1932 //pLogEntry->GetFiles(this)
1933 //LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;
1934
1935 CString from(MAKEINTRESOURCE(IDS_STATUSLIST_FROM));
1936 for (int cpPathIndex = 0; cpPathIndex<pLogEntry->GetFiles(this).GetCount(); ++cpPathIndex)
1937 {
1938 sPaths += ((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).GetActionName() + _T(": ") + pLogEntry->GetFiles(this)[cpPathIndex].GetGitPathString();
1939 if (((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).m_Action & (CTGitPath::LOGACTIONS_REPLACED|CTGitPath::LOGACTIONS_COPY) && !((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).GetGitOldPathString().IsEmpty())
1940 {
1941 CString rename;
1942 rename.Format(from, ((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).GetGitOldPathString());
1943 sPaths += _T(" ") + rename;
1944 }
1945 sPaths += _T("\r\n");
1946 }
1947 sPaths.Trim();
1948 CString body = pLogEntry->GetBody();
1949 body.Replace(_T("\n"), _T("\r\n"));
1950 sLogCopyText.Format(_T("%s: %s\r\n%s: %s <%s>\r\n%s: %s\r\n%s:\r\n%s\r\n----\r\n%s\r\n\r\n"),
1951 (LPCTSTR)sRev, pLogEntry->m_CommitHash.ToString(),
1952 (LPCTSTR)sAuthor, (LPCTSTR)pLogEntry->GetAuthorName(), (LPCTSTR)pLogEntry->GetAuthorEmail(),
1953 (LPCTSTR)sDate,
1954 (LPCTSTR)CLoglistUtils::FormatDateAndTime(pLogEntry->GetAuthorDate(), m_DateFormat, true, m_bRelativeTimes),
1955 (LPCTSTR)sMessage, (pLogEntry->GetSubject().Trim() + _T("\r\n\r\n") + body.Trim()).Trim(),
1956 (LPCTSTR)sPaths);
1957 sClipdata += sLogCopyText;
1958 }
1959 else if (toCopy == ID_COPY_MESSAGE)
1960 {
1961 CString body = pLogEntry->GetBody();
1962 body.Replace(_T("\n"), _T("\r\n"));
1963 sClipdata += _T("* ") + (pLogEntry->GetSubject().Trim() + _T("\r\n\r\n") + body.Trim()).Trim() + _T("\r\n\r\n");
1964 }
1965 else if (toCopy == ID_COPY_SUBJECT)
1966 {
1967 sClipdata += _T("* ") + pLogEntry->GetSubject().Trim() + _T("\r\n\r\n");
1968 }
1969 else
1970 {
1971 if (!first)
1972 sClipdata += _T("\r\n");
1973 sClipdata += pLogEntry->m_CommitHash;
1974 }
1975
1976 first = false;
1977 }
1978 CStringUtils::WriteAsciiStringToClipboard(sClipdata, GetSafeHwnd());
1979 }
1980
1981 }
1982
1983 void CGitLogListBase::DiffSelectedRevWithPrevious()
1984 {
1985 if (m_bThreadRunning)
1986 return;
1987
1988 int FirstSelect=-1, LastSelect=-1;
1989 POSITION pos = GetFirstSelectedItemPosition();
1990 FirstSelect = GetNextSelectedItem(pos);
1991 while(pos)
1992 {
1993 LastSelect = GetNextSelectedItem(pos);
1994 }
1995
1996 ContextMenuAction(ID_COMPAREWITHPREVIOUS,FirstSelect,LastSelect, NULL);
1997
1998 #if 0
1999 UpdateLogInfoLabel();
2000 int selIndex = m_LogList.GetSelectionMark();
2001 if (selIndex < 0)
2002 return;
2003 int selCount = m_LogList.GetSelectedCount();
2004 if (selCount != 1)
2005 return;
2006
2007 // Find selected entry in the log list
2008 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2009 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
2010 long rev1 = pLogEntry->Rev;
2011 long rev2 = rev1-1;
2012 CTGitPath path = m_path;
2013
2014 // See how many files under the relative root were changed in selected revision
2015 int nChanged = 0;
2016 LogChangedPath * changed = NULL;
2017 for (INT_PTR c = 0; c < pLogEntry->pArChangedPaths->GetCount(); ++c)
2018 {
2019 LogChangedPath * cpath = pLogEntry->pArChangedPaths->SafeGetAt(c);
2020 if (cpath && cpath -> sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)
2021 {
2022 ++nChanged;
2023 changed = cpath;
2024 }
2025 }
2026
2027 if (m_path.IsDirectory() && nChanged == 1)
2028 {
2029 // We're looking at the log for a directory and only one file under dir was changed in the revision
2030 // Do diff on that file instead of whole directory
2031 path.AppendPathString(changed->sPath.Mid(m_sRelativeRoot.GetLength()));
2032 }
2033
2034 m_bCancelled = FALSE;
2035 DialogEnableWindow(IDOK, FALSE);
2036 SetPromptApp(&theApp);
2037 theApp.DoWaitCursor(1);
2038
2039 if (PromptShown())
2040 {
2041 GitDiff diff(this, m_hWnd, true);
2042 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2043 diff.SetHEADPeg(m_LogRevision);
2044 diff.ShowCompare(path, rev2, path, rev1);
2045 }
2046 else
2047 {
2048 CAppUtils::StartShowCompare(m_hWnd, path, rev2, path, rev1, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
2049 }
2050
2051 theApp.DoWaitCursor(-1);
2052 EnableOKButton();
2053 #endif
2054 }
2055
2056 void CGitLogListBase::OnLvnOdfinditemLoglist(NMHDR *pNMHDR, LRESULT *pResult)
2057 {
2058 LPNMLVFINDITEM pFindInfo = reinterpret_cast<LPNMLVFINDITEM>(pNMHDR);
2059 *pResult = -1;
2060
2061 if (pFindInfo->lvfi.flags & LVFI_PARAM)
2062 return;
2063 if ((pFindInfo->iStart < 0)||(pFindInfo->iStart >= m_arShownList.GetCount()))
2064 return;
2065 if (pFindInfo->lvfi.psz == 0)
2066 return;
2067 #if 0
2068 CString sCmp = pFindInfo->lvfi.psz;
2069 CString sRev;
2070 for (int i=pFindInfo->iStart; i<m_arShownList.GetCount(); ++i)
2071 {
2072 GitRev * pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(i));
2073 sRev.Format(_T("%ld"), pLogEntry->Rev);
2074 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)
2075 {
2076 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)
2077 {
2078 *pResult = i;
2079 return;
2080 }
2081 }
2082 else
2083 {
2084 if (sCmp.Compare(sRev)==0)
2085 {
2086 *pResult = i;
2087 return;
2088 }
2089 }
2090 }
2091 if (pFindInfo->lvfi.flags & LVFI_WRAP)
2092 {
2093 for (int i=0; i<pFindInfo->iStart; ++i)
2094 {
2095 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(i));
2096 sRev.Format(_T("%ld"), pLogEntry->Rev);
2097 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)
2098 {
2099 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)
2100 {
2101 *pResult = i;
2102 return;
2103 }
2104 }
2105 else
2106 {
2107 if (sCmp.Compare(sRev)==0)
2108 {
2109 *pResult = i;
2110 return;
2111 }
2112 }
2113 }
2114 }
2115 #endif
2116 *pResult = -1;
2117 }
2118
2119 int CGitLogListBase::FillGitLog(CTGitPath *path,int info,CString *from,CString *to)
2120 {
2121 ClearText();
2122
2123 this->m_arShownList.SafeRemoveAll();
2124
2125 this->m_logEntries.ClearAll();
2126 if (this->m_logEntries.ParserFromLog(path,-1,info,from,to))
2127 return -1;
2128
2129 //this->m_logEntries.ParserFromLog();
2130 SetItemCountEx((int)m_logEntries.size());
2131
2132 for(unsigned int i=0;i<m_logEntries.size();i++)
2133 {
2134 if(m_IsOldFirst)
2135 {
2136 m_logEntries.GetGitRevAt(m_logEntries.size()-i-1).m_IsFull=TRUE;
2137 this->m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size()-i-1));
2138
2139 }
2140 else
2141 {
2142 m_logEntries.GetGitRevAt(i).m_IsFull=TRUE;
2143 this->m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
2144 }
2145 }
2146
2147 ReloadHashMap();
2148
2149 if(path)
2150 m_Path=*path;
2151 return 0;
2152
2153 }
2154
2155 int CGitLogListBase::BeginFetchLog()
2156 {
2157 ClearText();
2158
2159 this->m_arShownList.SafeRemoveAll();
2160
2161 this->m_logEntries.ClearAll();
2162
2163 this->m_LogCache.ClearAllParent();
2164
2165 m_LogCache.FetchCacheIndex(g_Git.m_CurrentDir);
2166
2167 CTGitPath *path;
2168 if(this->m_Path.IsEmpty())
2169 path=NULL;
2170 else
2171 path=&this->m_Path;
2172
2173 CString hash;
2174 int mask;
2175 mask = CGit::LOG_INFO_ONLY_HASH | CGit::LOG_INFO_BOUNDARY;
2176 // if(this->m_bAllBranch)
2177 mask |= m_ShowMask ;
2178
2179 if(m_bShowWC)
2180 {
2181 this->m_logEntries.insert(m_logEntries.begin(),this->m_wcRev.m_CommitHash);
2182 ResetWcRev();
2183 this->m_LogCache.m_HashMap[m_wcRev.m_CommitHash]=m_wcRev;
2184 }
2185
2186 CString *pFrom, *pTo;
2187 pFrom = pTo = NULL;
2188 CString head(_T("HEAD"));
2189 if(!this->m_startrev.IsEmpty())
2190 {
2191 pFrom = &this->m_startrev;
2192 if(!this->m_endrev.IsEmpty())
2193 pTo = &this->m_endrev;
2194 else
2195 pTo = &head;
2196 }
2197
2198 CFilterData data;
2199 data.m_From = m_From;
2200 data.m_To =m_To;
2201
2202 #if 0 /* use tortoiegit filter */
2203 if(this->m_nSelectedFilter == LOGFILTER_ALL || m_nSelectedFilter == LOGFILTER_AUTHORS)
2204 data.m_Author = this->m_sFilterText;
2205
2206 if(this->m_nSelectedFilter == LOGFILTER_ALL || m_nSelectedFilter == LOGFILTER_MESSAGES)
2207 data.m_MessageFilter = this->m_sFilterText;
2208
2209 data.m_IsRegex = m_bFilterWithRegex;
2210 #endif
2211
2212 // follow does not work for directories
2213 if (!path || path->IsDirectory())
2214 mask &= ~CGit::LOG_INFO_FOLLOW;
2215 // follow does not work with all branches 8at least in TGit)
2216 if (mask & CGit::LOG_INFO_FOLLOW)
2217 mask &= ~CGit::LOG_INFO_ALL_BRANCH;
2218
2219 CString cmd=g_Git.GetLogCmd(m_StartRef,path,-1,mask,pFrom,pTo,true,&data);
2220
2221 //this->m_logEntries.ParserFromLog();
2222 if(IsInWorkingThread())
2223 {
2224 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL);
2225 }
2226 else
2227 {
2228 SetItemCountEx((int)m_logEntries.size());
2229 }
2230
2231 try
2232 {
2233 git_init();
2234 }
2235 catch (char* msg)
2236 {
2237 CString err(msg);
2238 MessageBox(_T("Could not initialize libgit.\nlibgit reports:\n") + err, _T("TortoiseGit"), MB_ICONERROR);
2239 return -1;
2240 }
2241
2242 if (g_Git.IsOrphanBranch(m_StartRef))
2243 {
2244 if (!(mask & CGit::LOG_INFO_ALL_BRANCH))
2245 return 0;
2246
2247 // if show all branches, pick any ref as dummy entry ref
2248 STRING_VECTOR list;
2249 g_Git.GetRefList(list);
2250 if (list.size() == 0)
2251 return 0;
2252
2253 cmd = g_Git.GetLogCmd(list[0], path, -1, mask, pFrom, pTo, true, &data);
2254 }
2255
2256 try {
2257 if (git_open_log(&m_DllGitLog, CUnicodeUtils::GetMulti(cmd, CP_UTF8).GetBuffer()))
2258 {
2259 return -1;
2260 }
2261 }
2262 catch (char* msg)
2263 {
2264 CString err(msg);
2265 MessageBox(_T("Could not open log.\nlibgit reports:\n") + err, _T("TortoiseGit"), MB_ICONERROR);
2266 return -1;
2267 }
2268
2269 return 0;
2270 }
2271
2272 BOOL CGitLogListBase::PreTranslateMessage(MSG* pMsg)
2273 {
2274 if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')
2275 {
2276 //if (GetFocus()==GetDlgItem(IDC_LOGLIST))
2277 {
2278 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
2279 {
2280 DiffSelectedRevWithPrevious();
2281 return TRUE;
2282 }
2283 }
2284 #if 0
2285 if (GetFocus()==GetDlgItem(IDC_LOGMSG))
2286 {
2287 DiffSelectedFile();
2288 return TRUE;
2289 }
2290 #endif
2291 }
2292 else if (pMsg->message == WM_KEYDOWN && pMsg->wParam == 'A' && GetAsyncKeyState(VK_CONTROL)&0x8000)
2293 {
2294 // select all entries
2295 for (int i=0; i<GetItemCount(); ++i)
2296 {
2297 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2298 }
2299 return TRUE;
2300 }
2301
2302 #if 0
2303 if (m_hAccel && !bSkipAccelerator)
2304 {
2305 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
2306 if (ret)
2307 return TRUE;
2308 }
2309
2310 #endif
2311 //m_tooltips.RelayEvent(pMsg);
2312 return __super::PreTranslateMessage(pMsg);
2313 }
2314
2315 void CGitLogListBase::OnNMDblclkLoglist(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2316 {
2317 // a double click on an entry in the revision list has happened
2318 *pResult = 0;
2319
2320 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
2321 DiffSelectedRevWithPrevious();
2322 }
2323
2324 int CGitLogListBase::FetchLogAsync(void * data)
2325 {
2326 m_ProcData=data;
2327 m_bExitThread=FALSE;
2328 InterlockedExchange(&m_bThreadRunning, TRUE);
2329 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2330 m_LoadingThread = AfxBeginThread(LogThreadEntry, this, THREAD_PRIORITY_LOWEST);
2331 if (m_LoadingThread ==NULL)
2332 {
2333 InterlockedExchange(&m_bThreadRunning, FALSE);
2334 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2335 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
2336 return -1;
2337 }
2338 return 0;
2339 }
2340
2341 //this is the thread function which calls the subversion function
2342 UINT CGitLogListBase::LogThreadEntry(LPVOID pVoid)
2343 {
2344 return ((CGitLogListBase*)pVoid)->LogThread();
2345 }
2346
2347 void CGitLogListBase::GetTimeRange(CTime &oldest, CTime &latest)
2348 {
2349 //CTime time;
2350 oldest=CTime::GetCurrentTime();
2351 latest=CTime(1971,1,2,0,0,0);
2352 for(unsigned int i=0;i<m_logEntries.size();i++)
2353 {
2354 if(m_logEntries[i].IsEmpty())
2355 continue;
2356
2357 if(m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime() < oldest.GetTime())
2358 oldest = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
2359
2360 if(m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime() > latest.GetTime())
2361 latest = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
2362
2363 }
2364
2365 if(latest<oldest)
2366 latest=oldest;
2367 }
2368
2369 UINT CGitLogListBase::LogThread()
2370 {
2371 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) GITLOG_START,0);
2372
2373 InterlockedExchange(&m_bThreadRunning, TRUE);
2374 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2375
2376 ULONGLONG t1,t2;
2377
2378 if(BeginFetchLog())
2379 {
2380 InterlockedExchange(&m_bThreadRunning, FALSE);
2381 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2382
2383 return 1;
2384 }
2385
2386 tr1::wregex pat;//(_T("Remove"), tr1::regex_constants::icase);
2387 bool bRegex = false;
2388 if (m_bFilterWithRegex)
2389 bRegex = ValidateRegexp(m_sFilterText, pat, false);
2390
2391 TRACE(_T("\n===Begin===\n"));
2392 //Update work copy item;
2393
2394 if (!m_logEntries.empty())
2395 {
2396 GitRev *pRev = &m_logEntries.GetGitRevAt(0);
2397
2398 m_arShownList.SafeAdd(pRev);
2399 }
2400
2401
2402 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2403
2404 // store commit number of the last selected commit/line before the refresh or -1
2405 int lastSelectedHashNItem = -1;
2406 int ret = 0;
2407
2408 bool shouldWalk = true;
2409 if (g_Git.IsOrphanBranch(m_StartRef))
2410 {
2411 // walk revisions if show all branches and there exists any ref
2412 if (!(m_ShowMask & CGit::LOG_INFO_ALL_BRANCH))
2413 shouldWalk = false;
2414 else
2415 {
2416 STRING_VECTOR list;
2417 g_Git.GetRefList(list);
2418 if (list.size() == 0)
2419 shouldWalk = false;
2420 }
2421 }
2422
2423 if (shouldWalk)
2424 {
2425 g_Git.m_critGitDllSec.Lock();
2426 int total = 0;
2427 try
2428 {
2429 git_get_log_firstcommit(m_DllGitLog);
2430 total = git_get_log_estimate_commit_count(m_DllGitLog);
2431 }
2432 catch (char* msg)
2433 {
2434 CString err(msg);
2435 MessageBox(_T("Could not get first commit.\nlibgit reports:\n") + err, _T("TortoiseGit"), MB_ICONERROR);
2436 ret = -1;
2437 }
2438 g_Git.m_critGitDllSec.Unlock();
2439
2440 GIT_COMMIT commit;
2441 t2=t1=GetTickCount();
2442 int oldprecentage = 0;
2443 size_t oldsize = m_logEntries.size();
2444 while (ret== 0 && !m_bExitThread)
2445 {
2446 g_Git.m_critGitDllSec.Lock();
2447 try
2448 {
2449 ret = git_get_log_nextcommit(this->m_DllGitLog, &commit, m_ShowMask & CGit::LOG_INFO_FOLLOW);
2450 }
2451 catch (char* msg)
2452 {
2453 g_Git.m_critGitDllSec.Unlock();
2454 CString err(msg);
2455 MessageBox(_T("Could not get next commit.\nlibgit reports:\n") + err, _T("TortoiseGit"), MB_ICONERROR);
2456 break;
2457 }
2458 g_Git.m_critGitDllSec.Unlock();
2459
2460 if(ret)
2461 break;
2462
2463 if (commit.m_ignore == 1)
2464 {
2465 git_free_commit(&commit);
2466 continue;
2467 }
2468
2469 //printf("%s\r\n",commit.GetSubject());
2470 if(m_bExitThread)
2471 break;
2472
2473 CGitHash hash = (char*)commit.m_hash ;
2474
2475 GitRev *pRev = m_LogCache.GetCacheData(hash);
2476 pRev->m_GitCommit = commit;
2477 InterlockedExchange(&pRev->m_IsCommitParsed, FALSE);
2478
2479 char *note=NULL;
2480 g_Git.m_critGitDllSec.Lock();
2481 git_get_notes(commit.m_hash,&note);
2482 g_Git.m_critGitDllSec.Unlock();
2483
2484 if(note)
2485 {
2486 pRev->m_Notes.Empty();
2487 g_Git.StringAppend(&pRev->m_Notes,(BYTE*)note);
2488 }
2489
2490 if(!pRev->m_IsDiffFiles)
2491 {
2492 pRev->m_CallDiffAsync = DiffAsync;
2493 }
2494
2495 pRev->ParserParentFromCommit(&commit);
2496
2497 #ifdef DEBUG
2498 pRev->DbgPrint();
2499 TRACE(_T("\n"));
2500 #endif
2501
2502 if(!m_sFilterText.IsEmpty())
2503 {
2504 if(!IsMatchFilter(bRegex,pRev,pat))
2505 continue;
2506 }
2507 this->m_critSec.Lock();
2508 m_logEntries.push_back(hash);
2509 m_arShownList.SafeAdd(pRev);
2510 this->m_critSec.Unlock();
2511
2512 if (lastSelectedHashNItem == -1 && hash == m_lastSelectedHash)
2513 lastSelectedHashNItem = (int)m_arShownList.GetCount() - 1;
2514
2515 t2=GetTickCount();
2516
2517 if(t2-t1>500 || (m_logEntries.size()-oldsize >100))
2518 {
2519 //update UI
2520 int percent = (int)m_logEntries.size() * 100 / total + GITLOG_START + 1;
2521 if(percent > 99)
2522 percent =99;
2523 if(percent < GITLOG_START)
2524 percent = GITLOG_START +1;
2525
2526 oldsize = m_logEntries.size();
2527 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL|LVSICF_NOSCROLL);
2528
2529 //if( percent > oldprecentage )
2530 {
2531 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) percent,0);
2532 oldprecentage = percent;
2533 }
2534 t1 = t2;
2535 }
2536 }
2537 g_Git.m_critGitDllSec.Lock();
2538 git_close_log(m_DllGitLog);
2539 g_Git.m_critGitDllSec.Unlock();
2540
2541 }
2542
2543 if (m_bExitThread)
2544 {
2545 InterlockedExchange(&m_bThreadRunning, FALSE);
2546 return 0;
2547 }
2548
2549 //Update UI;
2550 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL|LVSICF_NOSCROLL);
2551
2552 if (lastSelectedHashNItem >= 0)
2553 PostMessage(m_ScrollToMessage, lastSelectedHashNItem);
2554
2555 if (this->m_hWnd)
2556 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) GITLOG_END,0);
2557
2558 InterlockedExchange(&m_bThreadRunning, FALSE);
2559
2560 return 0;
2561 }
2562
2563 void CGitLogListBase::Refresh(BOOL IsCleanFilter)
2564 {
2565 SafeTerminateThread();
2566
2567 this->SetItemCountEx(0);
2568 this->Clear();
2569
2570 ResetWcRev();
2571
2572 // HACK to hide graph column
2573 if (m_ShowMask & CGit::LOG_INFO_FOLLOW)
2574 SetColumnWidth(0, 0);
2575 else
2576 SetColumnWidth(0, m_ColumnManager.GetWidth(0, false));
2577
2578 //Update branch and Tag info
2579 ReloadHashMap();
2580 //Assume Thread have exited
2581 //if(!m_bThreadRunning)
2582 {
2583 m_logEntries.clear();
2584
2585 if(IsCleanFilter)
2586 {
2587 m_sFilterText.Empty();
2588 m_From=-1;
2589 m_To=-1;
2590 }
2591
2592 InterlockedExchange(&m_bExitThread,FALSE);
2593
2594 InterlockedExchange(&m_bThreadRunning, TRUE);
2595 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2596 if ( (m_LoadingThread=AfxBeginThread(LogThreadEntry, this)) ==NULL)
2597 {
2598 InterlockedExchange(&m_bThreadRunning, FALSE);
2599 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2600 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
2601 }
2602 }
2603 }
2604 bool CGitLogListBase::ValidateRegexp(LPCTSTR regexp_str, tr1::wregex& pat, bool bMatchCase /* = false */)
2605 {
2606 try
2607 {
2608 tr1::regex_constants::syntax_option_type type = tr1::regex_constants::ECMAScript;
2609 if (!bMatchCase)
2610 type |= tr1::regex_constants::icase;
2611 pat = tr1::wregex(regexp_str, type);
2612 return true;
2613 }
2614 catch (exception) {}
2615 return false;
2616 }
2617 BOOL CGitLogListBase::IsMatchFilter(bool bRegex, GitRev *pRev, tr1::wregex &pat)
2618 {
2619
2620 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_any;
2621 CString sRev;
2622
2623 if ((bRegex)&&(m_bFilterWithRegex))
2624 {
2625 if (m_SelectedFilters & LOGFILTER_BUGID)
2626 {
2627 if(this->m_bShowBugtraqColumn)
2628 {
2629 CString sBugIds = m_ProjectProperties.FindBugID(pRev->GetSubject() + _T("\r\n\r\n") + pRev->GetBody());
2630
2631 ATLTRACE(_T("bugID = \"%s\"\n"), sBugIds);
2632 if (regex_search(wstring(sBugIds), pat, flags))
2633 {
2634 return TRUE;
2635 }
2636 }
2637 }
2638
2639 if ((m_SelectedFilters & LOGFILTER_SUBJECT) || (m_SelectedFilters & LOGFILTER_MESSAGES))
2640 {
2641 ATLTRACE(_T("messge = \"%s\"\n"), pRev->GetSubject());
2642 if (regex_search(wstring((LPCTSTR)pRev->GetSubject()), pat, flags))
2643 {
2644 return TRUE;
2645 }
2646 }
2647
2648 if (m_SelectedFilters & LOGFILTER_MESSAGES)
2649 {
2650 ATLTRACE(_T("messge = \"%s\"\n"),pRev->GetBody());
2651 if (regex_search(wstring((LPCTSTR)pRev->GetBody()), pat, flags))
2652 {
2653 return TRUE;
2654 }
2655 }
2656
2657 if (m_SelectedFilters & LOGFILTER_AUTHORS)
2658 {
2659 if (regex_search(wstring(pRev->GetAuthorName()), pat, flags))
2660 {
2661 return TRUE;
2662 }
2663
2664 if (regex_search(wstring(pRev->GetCommitterName()), pat, flags))
2665 {
2666 return TRUE;
2667 }
2668 }
2669
2670 if (m_SelectedFilters & LOGFILTER_REVS)
2671 {
2672 sRev.Format(_T("%s"), pRev->m_CommitHash.ToString());
2673 if (regex_search(wstring((LPCTSTR)sRev), pat, flags))
2674 {
2675 return TRUE;
2676 }
2677 }
2678
2679 if (m_SelectedFilters & LOGFILTER_PATHS)
2680 {
2681 CTGitPathList *pathList=NULL;
2682 if( pRev->m_IsDiffFiles)
2683 pathList = &pRev->GetFiles(this);
2684 else
2685 {
2686 if(!pRev->m_IsSimpleListReady)
2687 pRev->SafeGetSimpleList(&g_Git);
2688 }
2689
2690 if(pathList)
2691 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList->GetCount(); ++cpPathIndex)
2692 {
2693 if (regex_search(wstring((LPCTSTR)pathList->m_paths.at(cpPathIndex).GetGitOldPathString()), pat, flags))
2694 {
2695 return true;
2696 }
2697 if (regex_search(wstring((LPCTSTR)pathList->m_paths.at(cpPathIndex).GetGitPathString()), pat, flags))
2698 {
2699 return true;
2700 }
2701 }
2702
2703 for(size_t i = 0; i < pRev->m_SimpleFileList.size(); i++)
2704 {
2705 if (regex_search(wstring((LPCTSTR)pRev->m_SimpleFileList[i]), pat, flags))
2706 {
2707 return true;
2708 }
2709 }
2710 }
2711 }
2712 else
2713 {
2714 CString find = m_sFilterText;
2715 find.MakeLower();
2716
2717 if (m_SelectedFilters & LOGFILTER_BUGID)
2718 {
2719 if(this->m_bShowBugtraqColumn)
2720 {
2721 CString sBugIds = m_ProjectProperties.FindBugID(pRev->GetSubject() + _T("\r\n\r\n") + pRev->GetBody());
2722
2723 sBugIds.MakeLower();
2724 if ((sBugIds.Find(find) >= 0))
2725 {
2726 return TRUE;
2727 }
2728 }
2729 }
2730
2731 if ((m_SelectedFilters & LOGFILTER_SUBJECT) || (m_SelectedFilters & LOGFILTER_MESSAGES))
2732 {
2733 CString msg = pRev->GetSubject();
2734
2735 msg = msg.MakeLower();
2736 if ((msg.Find(find) >= 0))
2737 {
2738 return TRUE;
2739 }
2740 }
2741
2742 if (m_SelectedFilters & LOGFILTER_MESSAGES)
2743 {
2744 CString msg = pRev->GetBody();
2745
2746 msg = msg.MakeLower();
2747 if ((msg.Find(find) >= 0))
2748 {
2749 return TRUE;
2750 }
2751 }
2752
2753 if (m_SelectedFilters & LOGFILTER_AUTHORS)
2754 {
2755 CString msg = pRev->GetAuthorName();
2756 msg = msg.MakeLower();
2757 if ((msg.Find(find) >= 0))
2758 {
2759 return TRUE;
2760 }
2761 }
2762
2763 if (m_SelectedFilters & LOGFILTER_REVS)
2764 {
2765 sRev.Format(_T("%s"), pRev->m_CommitHash.ToString());
2766 if ((sRev.Find(find) >= 0))
2767 {
2768 return TRUE;
2769 }
2770 }
2771
2772 if (m_SelectedFilters & LOGFILTER_PATHS)
2773 {
2774 CTGitPathList *pathList=NULL;
2775 if( pRev->m_IsDiffFiles)
2776 pathList = &pRev->GetFiles(this);
2777 else
2778 {
2779 if(!pRev->m_IsSimpleListReady)
2780 pRev->SafeGetSimpleList(&g_Git);
2781 }
2782 if(pathList)
2783 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList->GetCount() ; ++cpPathIndex)
2784 {
2785 CTGitPath *cpath = &pathList->m_paths.at(cpPathIndex);
2786 CString path = cpath->GetGitOldPathString();
2787 path.MakeLower();
2788 if ((path.Find(find)>=0))
2789 {
2790 return true;
2791 }
2792 path = cpath->GetGitPathString();
2793 path.MakeLower();
2794 if ((path.Find(find)>=0))
2795 {
2796 return true;
2797 }
2798 }
2799
2800 for (size_t i = 0; i < pRev->m_SimpleFileList.size(); i++)
2801 {
2802 CString path = pRev->m_SimpleFileList[i];
2803 path.MakeLower();
2804 if ((path.Find(find)>=0))
2805 {
2806 return true;
2807 }
2808 }
2809 }
2810 } // else (from if (bRegex))
2811 return FALSE;
2812 }
2813
2814
2815 void CGitLogListBase::RecalculateShownList(CThreadSafePtrArray * pShownlist)
2816 {
2817
2818 pShownlist->SafeRemoveAll();
2819
2820 tr1::wregex pat;//(_T("Remove"), tr1::regex_constants::icase);
2821 bool bRegex = false;
2822 if (m_bFilterWithRegex)
2823 bRegex = ValidateRegexp(m_sFilterText, pat, false);
2824
2825 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_any;
2826 CString sRev;
2827 for (DWORD i=0; i<m_logEntries.size(); ++i)
2828 {
2829 if ((bRegex)&&(m_bFilterWithRegex))
2830 {
2831 #if 0
2832 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2833 {
2834 ATLTRACE(_T("bugID = \"%s\"\n"), (LPCTSTR)m_logEntries[i]->sBugIDs);
2835 if (regex_search(wstring((LPCTSTR)m_logEntries[i]->sBugIDs), pat, flags)&&IsEntryInDateRange(i))
2836 {
2837 pShownlist->SafeAdd(m_logEntries[i]);
2838 continue;
2839 }
2840 }
2841 #endif
2842 if ((m_SelectedFilters & LOGFILTER_SUBJECT) || (m_SelectedFilters & LOGFILTER_MESSAGES))
2843 {
2844 ATLTRACE(_T("messge = \"%s\"\n"),m_logEntries.GetGitRevAt(i).GetSubject());
2845 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetSubject()), pat, flags)&&IsEntryInDateRange(i))
2846 {
2847 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2848 continue;
2849 }
2850 }
2851 if (m_SelectedFilters & LOGFILTER_MESSAGES)
2852 {
2853 ATLTRACE(_T("messge = \"%s\"\n"),m_logEntries.GetGitRevAt(i).GetBody());
2854 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetBody()), pat, flags)&&IsEntryInDateRange(i))
2855 {
2856 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2857 continue;
2858 }
2859 }
2860 if (m_SelectedFilters & LOGFILTER_PATHS)
2861 {
2862 CTGitPathList pathList = m_logEntries.GetGitRevAt(i).GetFiles(this);
2863
2864 bool bGoing = true;
2865 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList.GetCount() && bGoing; ++cpPathIndex)
2866 {
2867 CTGitPath cpath = pathList[cpPathIndex];
2868 if (regex_search(wstring((LPCTSTR)cpath.GetGitOldPathString()), pat, flags)&&IsEntryInDateRange(i))
2869 {
2870 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2871 bGoing = false;
2872 continue;
2873 }
2874 if (regex_search(wstring((LPCTSTR)cpath.GetGitPathString()), pat, flags)&&IsEntryInDateRange(i))
2875 {
2876 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2877 bGoing = false;
2878 continue;
2879 }
2880 if (regex_search(wstring((LPCTSTR)cpath.GetActionName()), pat, flags)&&IsEntryInDateRange(i))
2881 {
2882 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2883 bGoing = false;
2884 continue;
2885 }
2886 }
2887 }
2888 if (m_SelectedFilters & LOGFILTER_AUTHORS)
2889 {
2890 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetAuthorName()), pat, flags)&&IsEntryInDateRange(i))
2891 {
2892 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2893 continue;
2894 }
2895 }
2896 if (m_SelectedFilters & LOGFILTER_REVS)
2897 {
2898 sRev.Format(_T("%s"), m_logEntries.GetGitRevAt(i).m_CommitHash.ToString());
2899 if (regex_search(wstring((LPCTSTR)sRev), pat, flags)&&IsEntryInDateRange(i))
2900 {
2901 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2902 continue;
2903 }
2904 }
2905 } // if (bRegex)
2906 else
2907 {
2908 CString find = m_sFilterText;
2909 find.MakeLower();
2910 #if 0
2911 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2912 {
2913 CString sBugIDs = m_logEntries[i]->sBugIDs;
2914
2915 sBugIDs = sBugIDs.MakeLower();
2916 if ((sBugIDs.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2917 {
2918 pShownlist->SafeAdd(m_logEntries[i]);
2919 continue;
2920 }
2921 }
2922 #endif
2923 if ((m_SelectedFilters & LOGFILTER_SUBJECT) || (m_SelectedFilters & LOGFILTER_MESSAGES))
2924 {
2925 CString msg = m_logEntries.GetGitRevAt(i).GetSubject();
2926
2927 msg = msg.MakeLower();
2928 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2929 {
2930 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2931 continue;
2932 }
2933 }
2934 if (m_SelectedFilters & LOGFILTER_MESSAGES)
2935 {
2936 CString msg = m_logEntries.GetGitRevAt(i).GetBody();
2937
2938 msg = msg.MakeLower();
2939 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2940 {
2941 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2942 continue;
2943 }
2944 }
2945 if (m_SelectedFilters & LOGFILTER_PATHS)
2946 {
2947 CTGitPathList pathList = m_logEntries.GetGitRevAt(i).GetFiles(this);
2948
2949 bool bGoing = true;
2950 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList.GetCount() && bGoing; ++cpPathIndex)
2951 {
2952 CTGitPath cpath = pathList[cpPathIndex];
2953 CString path = cpath.GetGitOldPathString();
2954 path.MakeLower();
2955 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2956 {
2957 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2958 bGoing = false;
2959 continue;
2960 }
2961 path = cpath.GetGitPathString();
2962 path.MakeLower();
2963 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2964 {
2965 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2966 bGoing = false;
2967 continue;
2968 }
2969 path = cpath.GetActionName();
2970 path.MakeLower();
2971 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2972 {
2973 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2974 bGoing = false;
2975 continue;
2976 }
2977 }
2978 }
2979 if (m_SelectedFilters & LOGFILTER_AUTHORS)
2980 {
2981 CString msg = m_logEntries.GetGitRevAt(i).GetAuthorName();
2982 msg = msg.MakeLower();
2983 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2984 {
2985 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2986 continue;
2987 }
2988 }
2989 if (m_SelectedFilters & LOGFILTER_REVS)
2990 {
2991 sRev.Format(_T("%s"), m_logEntries.GetGitRevAt(i).m_CommitHash.ToString());
2992 if ((sRev.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2993 {
2994 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2995 continue;
2996 }
2997 }
2998 } // else (from if (bRegex))
2999 } // for (DWORD i=0; i<m_logEntries.size(); ++i)
3000
3001 }
3002
3003 BOOL CGitLogListBase::IsEntryInDateRange(int /*i*/)
3004 {
3005 /*
3006 __time64_t time = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
3007
3008 if(m_From == -1)
3009 if(m_To == -1)
3010 return true;
3011 else
3012 return time <= m_To;
3013 else
3014 if(m_To == -1)
3015 return time >= m_From;
3016 else
3017 return ((time >= m_From)&&(time <= m_To));
3018 */
3019 return TRUE; /* git dll will filter time range */
3020
3021 // return TRUE;
3022 }
3023 void CGitLogListBase::StartFilter()
3024 {
3025 InterlockedExchange(&m_bNoDispUpdates, TRUE);
3026 RecalculateShownList(&m_arShownList);
3027 InterlockedExchange(&m_bNoDispUpdates, FALSE);
3028
3029
3030 DeleteAllItems();
3031 SetItemCountEx(ShownCountWithStopped());
3032 RedrawItems(0, ShownCountWithStopped());
3033 Invalidate();
3034
3035 }
3036 void CGitLogListBase::RemoveFilter()
3037 {
3038
3039 InterlockedExchange(&m_bNoDispUpdates, TRUE);
3040
3041 m_arShownList.SafeRemoveAll();
3042
3043 // reset the time filter too
3044 #if 0
3045 m_timFrom = (__time64_t(m_tFrom));
3046 m_timTo = (__time64_t(m_tTo));
3047 m_DateFrom.SetTime(&m_timFrom);
3048 m_DateTo.SetTime(&m_timTo);
3049 m_DateFrom.SetRange(&m_timFrom, &m_timTo);
3050 m_DateTo.SetRange(&m_timFrom, &m_timTo);
3051 #endif
3052
3053 for (DWORD i=0; i<m_logEntries.size(); ++i)
3054 {
3055 if(this->m_IsOldFirst)
3056 {
3057 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size()-i-1));
3058 }
3059 else
3060 {
3061 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
3062 }
3063 }
3064 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
3065 DeleteAllItems();
3066 SetItemCountEx(ShownCountWithStopped());
3067 RedrawItems(0, ShownCountWithStopped());
3068
3069 InterlockedExchange(&m_bNoDispUpdates, FALSE);
3070 }
3071
3072 void CGitLogListBase::Clear()
3073 {
3074 m_arShownList.SafeRemoveAll();
3075 DeleteAllItems();
3076
3077 m_logEntries.ClearAll();
3078
3079 }
3080
3081 void CGitLogListBase::OnDestroy()
3082 {
3083 // save the column widths to the registry
3084 SaveColumnWidths();
3085
3086 SafeTerminateThread();
3087 SafeTerminateAsyncDiffThread();
3088
3089 int retry = 0;
3090 while(m_LogCache.SaveCache())
3091 {
3092 if(retry > 5)
3093 break;
3094 Sleep(1000);
3095
3096 retry++;
3097
3098 //if(CMessageBox::Show(NULL,_T("Cannot Save Log Cache to Disk. To retry click yes. To give up click no."),_T("TortoiseGit"),
3099 // MB_YESNO) == IDNO)
3100 // break;
3101 }
3102
3103 CHintListCtrl::OnDestroy();
3104 }
3105
3106 LRESULT CGitLogListBase::OnLoad(WPARAM wParam,LPARAM lParam)
3107 {
3108 UNREFERENCED_PARAMETER(lParam);
3109 CRect rect;
3110 int i=(int)wParam;
3111 this->GetItemRect(i,&rect,LVIR_BOUNDS);
3112 this->InvalidateRect(rect);
3113
3114 return 0;
3115 }
3116
3117 /**
3118 * Save column widths to the registry
3119 */
3120 void CGitLogListBase::SaveColumnWidths()
3121 {
3122 int maxcol = m_ColumnManager.GetColumnCount();
3123
3124 // HACK that graph column is always shown
3125 SetColumnWidth(0, m_ColumnManager.GetWidth(0, false));
3126
3127 for (int col = 0; col < maxcol; col++)
3128 if (m_ColumnManager.IsVisible (col))
3129 m_ColumnManager.ColumnResized (col);
3130
3131 m_ColumnManager.WriteSettings();
3132 }
3133
3134 int CGitLogListBase::GetHeadIndex()
3135 {
3136 if(m_HeadHash.IsEmpty())
3137 return -1;
3138
3139 for(int i=0;i<m_arShownList.GetCount();i++)
3140 {
3141 GitRev *pRev = (GitRev*)m_arShownList[i];
3142 if(pRev)
3143 {
3144 if(pRev->m_CommitHash.ToString() == m_HeadHash )
3145 return i;
3146 }
3147 }
3148 return -1;
3149 }
3150 void CGitLogListBase::OnFind()
3151 {
3152 if (!m_pFindDialog)
3153 {
3154 m_pFindDialog = new CFindDlg(this);
3155 m_pFindDialog->Create(this);
3156 }
3157 }
3158 void CGitLogListBase::OnHdnBegintrack(NMHDR *pNMHDR, LRESULT *pResult)
3159 {
3160 m_ColumnManager.OnHdnBegintrack(pNMHDR, pResult);
3161 }
3162 void CGitLogListBase::OnHdnItemchanging(NMHDR *pNMHDR, LRESULT *pResult)
3163 {
3164 if(!m_ColumnManager.OnHdnItemchanging(pNMHDR, pResult))
3165 Default();
3166 }
3167 LRESULT CGitLogListBase::OnScrollToMessage(WPARAM itemToSelect, LPARAM /*lParam*/)
3168 {
3169 SetItemState((int)itemToSelect, LVIS_SELECTED, LVIS_SELECTED);
3170 EnsureVisible((int)itemToSelect, FALSE);
3171 return 0;
3172 }
3173 LRESULT CGitLogListBase::OnFindDialogMessage(WPARAM /*wParam*/, LPARAM /*lParam*/)
3174 {
3175
3176 ASSERT(m_pFindDialog != NULL);
3177 bool bFound = false;
3178 int i=0;
3179
3180 if (m_pFindDialog->IsTerminating())
3181 {
3182 // invalidate the handle identifying the dialog box.
3183 m_pFindDialog = NULL;
3184 return 0;
3185 }
3186
3187 if(m_pFindDialog->IsRef())
3188 {
3189 CString str;
3190 str=m_pFindDialog->GetFindString();
3191
3192 CGitHash hash;
3193
3194 if(!str.IsEmpty())
3195 hash = g_Git.GetHash(str + _T("^{}")); // add ^{} in order to get the correct SHA-1 (especially for signed tags)
3196
3197 if(!hash.IsEmpty())
3198 {
3199 for (i = 0; i<m_arShownList.GetCount(); i++)
3200 {
3201 GitRev* pLogEntry = (GitRev*)m_arShownList.SafeGetAt(i);
3202 if(pLogEntry && pLogEntry->m_CommitHash == hash)
3203 {
3204 bFound = true;
3205 break;
3206 }
3207 }
3208 }
3209
3210 }
3211
3212 if(m_pFindDialog->FindNext())
3213 {
3214 //read data from dialog
3215 CString FindText = m_pFindDialog->GetFindString();
3216 bool bMatchCase = (m_pFindDialog->MatchCase() == TRUE);
3217
3218 tr1::wregex pat;
3219 bool bRegex = ValidateRegexp(FindText, pat, bMatchCase);
3220
3221 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_not_null;
3222
3223
3224 for (i = this->m_nSearchIndex; i<m_arShownList.GetCount()&&!bFound; i++)
3225 {
3226 GitRev* pLogEntry = (GitRev*)m_arShownList.SafeGetAt(i);
3227
3228 CString str;
3229 str+=pLogEntry->m_CommitHash.ToString();
3230 str+=_T("\n");
3231
3232 for(int j=0;j<this->m_HashMap[pLogEntry->m_CommitHash].size();j++)
3233 {
3234 str+=m_HashMap[pLogEntry->m_CommitHash][j];
3235 str+=_T("\n");
3236 }
3237
3238 str+=pLogEntry->GetAuthorEmail();
3239 str+=_T("\n");
3240 str+=pLogEntry->GetAuthorName();
3241 str+=_T("\n");
3242 str+=pLogEntry->GetBody();
3243 str+=_T("\n");
3244 str+=pLogEntry->GetCommitterEmail();
3245 str+=_T("\n");
3246 str+=pLogEntry->GetCommitterName();
3247 str+=_T("\n");
3248 str+=pLogEntry->GetSubject();
3249 str+=_T("\n");
3250
3251
3252 /*Because changed files list is loaded on demand when gui show,
3253 files will empty when files have not fetched.
3254
3255 we can add it back by using one-way diff(with outnumber changed and rename detect.
3256 here just need changed filename list. one-way is much quicker.
3257 */
3258 if(pLogEntry->m_IsFull)
3259 {
3260 for(int i=0;i<pLogEntry->GetFiles(this).GetCount();i++)
3261 {
3262 str+=pLogEntry->GetFiles(this)[i].GetWinPath();
3263 str+=_T("\n");
3264 str+=pLogEntry->GetFiles(this)[i].GetGitOldPathString();
3265 str+=_T("\n");
3266 }
3267 }
3268 else
3269 {
3270 if(!pLogEntry->m_IsSimpleListReady)
3271 pLogEntry->SafeGetSimpleList(&g_Git);
3272
3273 for(int i=0;i<pLogEntry->m_SimpleFileList.size();i++)
3274 {
3275 str+=pLogEntry->m_SimpleFileList[i];
3276 str+=_T("\n");
3277 }
3278
3279 }
3280
3281
3282 if (bRegex)
3283 {
3284 if (regex_search(wstring(str), pat, flags))
3285 {
3286 bFound = true;
3287 break;
3288 }
3289 }
3290 else
3291 {
3292 if (bMatchCase)
3293 {
3294 if (str.Find(FindText) >= 0)
3295 {
3296 bFound = true;
3297 break;
3298 }
3299
3300 }
3301 else
3302 {
3303 CString msg = str;
3304 msg = msg.MakeLower();
3305 CString find = FindText.MakeLower();
3306 if (msg.Find(find) >= 0)
3307 {
3308 bFound = TRUE;
3309 break;
3310 }
3311 }
3312 }
3313 } // for (i = this->m_nSearchIndex; i<m_arShownList.GetItemCount()&&!bFound; i++)
3314
3315 } // if(m_pFindDialog->FindNext())
3316 //UpdateLogInfoLabel();
3317
3318 if (bFound)
3319 {
3320 this->m_nSearchIndex = i;
3321 EnsureVisible(i, FALSE);
3322 SetItemState(GetSelectionMark(), 0, LVIS_SELECTED);
3323 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
3324 SetSelectionMark(i);
3325 //FillLogMessageCtrl();
3326 UpdateData(FALSE);
3327 m_nSearchIndex++;
3328 if (m_nSearchIndex >= m_arShownList.GetCount())
3329 m_nSearchIndex = (int)m_arShownList.GetCount()-1;
3330 }
3331
3332 return 0;
3333 }
3334
3335 void CGitLogListBase::OnColumnResized(NMHDR *pNMHDR, LRESULT *pResult)
3336 {
3337 m_ColumnManager.OnColumnResized(pNMHDR,pResult);
3338
3339 *pResult = FALSE;
3340 }
3341
3342 void CGitLogListBase::OnColumnMoved(NMHDR *pNMHDR, LRESULT *pResult)
3343 {
3344 m_ColumnManager.OnColumnMoved(pNMHDR, pResult);
3345
3346 Invalidate(FALSE);
3347 }
Windows Explorer Extension to Operate Git