?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add note for new users that a merge conflict requires a commit
[TortoiseGit.git] / src / TortoiseProc / GitLogListBase.cpp
blob64e735c8d2714f01e0e962928bad2959613754fc
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2018 - TortoiseGit
4 // Copyright (C) 2005-2007 Marco Costalba
5
6 // This program is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU General Public License
8 // as published by the Free Software Foundation; either version 2
9 // of the License, or (at your option) any later version.
10
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software Foundation,
18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 //
20 // GitLogList.cpp : implementation file
21 //
22 #include "stdafx.h"
23 #include "resource.h"
24 #include "GitLogListBase.h"
25 #include "IconMenu.h"
26 #include "GitProgressDlg.h"
27 #include "ProgressDlg.h"
28 #include "MessageBox.h"
29 #include "LoglistUtils.h"
30 #include "StringUtils.h"
31 #include "UnicodeUtils.h"
32 #include "IconMenu.h"
33 #include "../TortoiseShell/Resource.h"
34
35 const UINT CGitLogListBase::m_FindDialogMessage = RegisterWindowMessage(FINDMSGSTRING);
36 const UINT CGitLogListBase::m_ScrollToMessage = RegisterWindowMessage(L"TORTOISEGIT_LOG_SCROLLTO");
37 const UINT CGitLogListBase::m_ScrollToRef = RegisterWindowMessage(L"TORTOISEGIT_LOG_SCROLLTOREF");
38 const UINT CGitLogListBase::m_RebaseActionMessage = RegisterWindowMessage(L"TORTOISEGIT_LOG_REBASEACTION");
39 const UINT CGitLogListBase::LOGLIST_RESET_WCREV = RegisterWindowMessage(L"TORTOISEGIT_LOG_RESET_WCREV");
40
41 IMPLEMENT_DYNAMIC(CGitLogListBase, CHintCtrl<CResizableColumnsListCtrl<CListCtrl>>)
42
43 CGitLogListBase::CGitLogListBase() : CHintCtrl<CResizableColumnsListCtrl<CListCtrl>>()
44 ,m_regMaxBugIDColWidth(L"Software\\TortoiseGit\\MaxBugIDColWidth", 200)
45 ,m_nSearchIndex(0)
46 ,m_bNoDispUpdates(FALSE)
47 , m_bThreadRunning(FALSE)
48 , m_bStrictStopped(false)
49 , m_SelectedFilters(LOGFILTER_ALL)
50 , m_ShowFilter(FILTERSHOW_ALL)
51 , m_bShowWC(false)
52 , m_logEntries(&m_LogCache)
53 , m_pFindDialog(nullptr)
54 , m_dwDefaultColumns(0)
55 , m_arShownList(&m_critSec)
56 , m_hasWC(true)
57 , m_bNoHightlightHead(FALSE)
58 , m_ShowRefMask(LOGLIST_SHOWALLREFS)
59 , m_bFullCommitMessageOnLogLine(false)
60 , m_OldTopIndex(-1)
61 , m_AsyncThreadRunning(FALSE)
62 , m_AsyncThreadExit(FALSE)
63 , m_bIsCherryPick(false)
64 , m_pMailmap(nullptr)
65 , m_bShowBugtraqColumn(false)
66 , m_IsIDReplaceAction(FALSE)
67 , m_ShowMask(0)
68 , m_LoadingThread(nullptr)
69 , m_bExitThread(FALSE)
70 , m_IsOldFirst(FALSE)
71 , m_IsRebaseReplaceGraph(FALSE)
72 , m_ContextMenuMask(0xFFFFFFFFFFFFFFFF)
73 , m_bDragndropEnabled(false)
74 , m_bDragging(FALSE)
75 , m_nDropIndex(-1)
76 , m_nDropMarkerLast(-1)
77 , m_nDropMarkerLastHot(-1)
78 {
79 // use the default GUI font, create a copy of it and
80 // change the copy to BOLD (leave the rest of the font
81 // the same)
82 HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
83 LOGFONT lf = {0};
84 GetObject(hFont, sizeof(LOGFONT), &lf);
85 lf.lfWeight = FW_BOLD;
86 m_boldFont.CreateFontIndirect(&lf);
87 lf.lfWeight = FW_DONTCARE;
88 lf.lfItalic = TRUE;
89 m_FontItalics.CreateFontIndirect(&lf);
90 lf.lfWeight = FW_BOLD;
91 m_boldItalicsFont.CreateFontIndirect(&lf);
92
93 this->m_critSec.Init();
94 ResetWcRev(false);
95
96 int cx = GetSystemMetrics(SM_CXSMICON);
97 int cy = GetSystemMetrics(SM_CYSMICON);
98 m_hModifiedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONMODIFIED), IMAGE_ICON, cx, cy, 0);
99 m_hReplacedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONREPLACED), IMAGE_ICON, cx, cy, 0);
100 m_hConflictedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONCONFLICTED), IMAGE_ICON, cx, cy, 0);
101 m_hAddedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONADDED), IMAGE_ICON, cx, cy, 0);
102 m_hDeletedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONDELETED), IMAGE_ICON, cx, cy, 0);
103 m_hFetchIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONFETCHING), IMAGE_ICON, cx, cy, 0);
104
105 m_bFilterWithRegex = !!CRegDWORD(L"Software\\TortoiseGit\\UseRegexFilter", FALSE);
106 m_bFilterCaseSensitively = !!CRegDWORD(L"Software\\TortoiseGit\\FilterCaseSensitively", FALSE);
107
108 m_Filter.m_NumberOfLogsScale = (DWORD)CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\NumberOfLogsScale", CFilterData::SHOW_NO_LIMIT);
109 if (m_Filter.m_NumberOfLogsScale == CFilterData::SHOW_LAST_SEL_DATE)
110 {
111 CString key;
112 key.Format(L"Software\\TortoiseGit\\History\\LogDlg_Limits\\%s\\FromDate", (LPCTSTR)g_Git.m_CurrentDir);
113 key.Replace(L':', L'_');
114 CString lastSelFromDate = CRegString(key);
115 if (lastSelFromDate.GetLength() == 10)
116 {
117 CTime time = CTime(_wtoi((LPCTSTR)lastSelFromDate.Mid(0, 4)), _wtoi((LPCTSTR)lastSelFromDate.Mid(5, 2)), _wtoi((LPCTSTR)lastSelFromDate.Mid(8, 2)), 0, 0, 0);
118 m_Filter.m_From = (DWORD)time.GetTime();
119 }
120 }
121 m_Filter.m_NumberOfLogs = (DWORD)CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\NumberOfLogs", 1);
122
123 for (int i = 0; i < Lanes::COLORS_NUM; ++i)
124 {
125 m_LineColors[i] = m_Colors.GetColor((CColors::Colors)(CColors::BranchLine1+i));
126 }
127 // get short/long datetime setting from registry
128 DWORD RegUseShortDateFormat = CRegDWORD(L"Software\\TortoiseGit\\LogDateFormat", TRUE);
129 if ( RegUseShortDateFormat )
130 {
131 m_DateFormat = DATE_SHORTDATE;
132 }
133 else
134 {
135 m_DateFormat = DATE_LONGDATE;
136 }
137 // get relative time display setting from registry
138 DWORD regRelativeTimes = CRegDWORD(L"Software\\TortoiseGit\\RelativeTimes", FALSE);
139 m_bRelativeTimes = (regRelativeTimes != 0);
140
141 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_PICK);
142 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_SQUASH);
143 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_EDIT);
144 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_SKIP);
145 m_ContextMenuMask &= ~GetContextMenuBit(ID_LOG);
146 m_ContextMenuMask &= ~GetContextMenuBit(ID_BLAME);
147 m_ContextMenuMask &= ~GetContextMenuBit(ID_BLAMEPREVIOUS);
148
149 m_ColumnRegKey = L"log";
150
151 m_bTagsBranchesOnRightSide = !!CRegDWORD(L"Software\\TortoiseGit\\DrawTagsBranchesOnRightSide", FALSE);
152 m_bSymbolizeRefNames = !!CRegDWORD(L"Software\\TortoiseGit\\SymbolizeRefNames", FALSE);
153 m_bIncludeBoundaryCommits = !!CRegDWORD(L"Software\\TortoiseGit\\LogIncludeBoundaryCommits", FALSE);
154 m_bFullCommitMessageOnLogLine = !!CRegDWORD(L"Software\\TortoiseGit\\FullCommitMessageOnLogLine", FALSE);
155
156 m_LineWidth = max(1, CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\Graph\\LogLineWidth", 2));
157 m_NodeSize = max(1, CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\Graph\\LogNodeSize", 10));
158
159 if (CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\UseMailmap", FALSE) == TRUE)
160 git_read_mailmap(&m_pMailmap);
161
162 m_AsyncDiffEvent = ::CreateEvent(nullptr, FALSE, TRUE, nullptr);
163 m_AsynDiffListLock.Init();
164 StartAsyncDiffThread();
165 }
166
167 int CGitLogListBase::AsyncDiffThread()
168 {
169 while(!m_AsyncThreadExit)
170 {
171 ::WaitForSingleObject(m_AsyncDiffEvent, INFINITE);
172
173 GitRevLoglist* pRev = nullptr;
174 while(!m_AsyncThreadExit && !m_AsynDiffList.empty())
175 {
176 m_AsynDiffListLock.Lock();
177 pRev = m_AsynDiffList.back();
178 m_AsynDiffList.pop_back();
179 m_AsynDiffListLock.Unlock();
180
181 if( pRev->m_CommitHash.IsEmpty() )
182 {
183 if(pRev->m_IsDiffFiles)
184 continue;
185
186 CTGitPathList& files = pRev->GetFiles(this);
187 files.Clear();
188 pRev->m_ParentHash.clear();
189 pRev->m_ParentHash.push_back(m_HeadHash);
190 g_Git.RefreshGitIndex();
191 g_Git.GetWorkingTreeChanges(files);
192 auto& action = pRev->GetAction(this);
193 action = 0;
194 for (int j = 0; j < files.GetCount(); ++j)
195 action |= files[j].m_Action;
196
197 CString err;
198 if (pRev->GetUnRevFiles().FillUnRev(CTGitPath::LOGACTIONS_UNVER, nullptr, &err))
199 {
200 MessageBox(L"Failed to get UnRev file list\n" + err, L"TortoiseGit", MB_OK | MB_ICONERROR);
201 InterlockedExchange(&m_AsyncThreadRunning, FALSE);
202 return -1;
203 }
204
205 InterlockedExchange(&pRev->m_IsDiffFiles, TRUE);
206 InterlockedExchange(&pRev->m_IsFull, TRUE);
207
208 CString body = L"\n";
209 body.AppendFormat(IDS_FILESCHANGES, files.GetCount());
210 pRev->GetBody() = body;
211 ::PostMessage(m_hWnd,MSG_LOADED,(WPARAM)0,0);
212 this->GetParent()->PostMessage(WM_COMMAND, MSG_FETCHED_DIFF, 0);
213 }
214
215 if (!pRev->CheckAndDiff())
216 { // fetch change file list
217 for (int i = GetTopIndex(); !m_AsyncThreadExit && i <= GetTopIndex() + GetCountPerPage(); ++i)
218 {
219 if (i < (int)m_arShownList.size())
220 {
221 GitRevLoglist* data = m_arShownList.SafeGetAt(i);
222 if(data->m_CommitHash == pRev->m_CommitHash)
223 {
224 ::PostMessage(m_hWnd,MSG_LOADED,(WPARAM)i,0);
225 break;
226 }
227 }
228 }
229
230 if(!m_AsyncThreadExit && GetSelectedCount() == 1)
231 {
232 POSITION pos = GetFirstSelectedItemPosition();
233 int nItem = GetNextSelectedItem(pos);
234
235 if(nItem>=0)
236 {
237 GitRevLoglist* data = m_arShownList.SafeGetAt(nItem);
238 if(data)
239 if(data->m_CommitHash == pRev->m_CommitHash)
240 this->GetParent()->PostMessage(WM_COMMAND, MSG_FETCHED_DIFF, 0);
241 }
242 }
243 }
244 }
245 }
246 InterlockedExchange(&m_AsyncThreadRunning, FALSE);
247 return 0;
248 }
249 void CGitLogListBase::hideFromContextMenu(unsigned __int64 hideMask, bool exclusivelyShow)
250 {
251 if (exclusivelyShow)
252 m_ContextMenuMask &= hideMask;
253 else
254 m_ContextMenuMask &= ~hideMask;
255 }
256
257 CGitLogListBase::~CGitLogListBase()
258 {
259 InterlockedExchange(&m_bNoDispUpdates, TRUE);
260 this->m_arShownList.SafeRemoveAll();
261
262 DestroyIcon(m_hModifiedIcon);
263 DestroyIcon(m_hReplacedIcon);
264 DestroyIcon(m_hConflictedIcon);
265 DestroyIcon(m_hAddedIcon);
266 DestroyIcon(m_hDeletedIcon);
267 m_logEntries.ClearAll();
268
269 git_free_mailmap(m_pMailmap);
270
271 SafeTerminateThread();
272 SafeTerminateAsyncDiffThread();
273
274 if(m_AsyncDiffEvent)
275 CloseHandle(m_AsyncDiffEvent);
276 }
277
278
279 BEGIN_MESSAGE_MAP(CGitLogListBase, CHintCtrl<CResizableColumnsListCtrl<CListCtrl>>)
280 ON_REGISTERED_MESSAGE(m_FindDialogMessage, OnFindDialogMessage)
281 ON_REGISTERED_MESSAGE(m_ScrollToMessage, OnScrollToMessage)
282 ON_REGISTERED_MESSAGE(m_ScrollToRef, OnScrollToRef)
283 ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnNMCustomdrawLoglist)
284 ON_NOTIFY_REFLECT(LVN_GETDISPINFO, OnLvnGetdispinfoLoglist)
285 ON_WM_CONTEXTMENU()
286 ON_NOTIFY_REFLECT(NM_DBLCLK, OnNMDblclkLoglist)
287 ON_NOTIFY_REFLECT(LVN_ODFINDITEM,OnLvnOdfinditemLoglist)
288 ON_WM_CREATE()
289 ON_WM_DESTROY()
290 ON_MESSAGE(MSG_LOADED,OnLoad)
291 ON_WM_MEASUREITEM()
292 ON_WM_MEASUREITEM_REFLECT()
293 ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, &OnToolTipText)
294 ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, &OnToolTipText)
295 ON_WM_MOUSEMOVE()
296 ON_WM_LBUTTONUP()
297 ON_NOTIFY_REFLECT(LVN_BEGINDRAG, OnBeginDrag)
298 END_MESSAGE_MAP()
299
300 void CGitLogListBase::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
301 {
302 //if (m_nRowHeight>0)
303 lpMeasureItemStruct->itemHeight = 50;
304 }
305
306 int CGitLogListBase:: OnCreate(LPCREATESTRUCT lpCreateStruct)
307 {
308 PreSubclassWindow();
309 return __super::OnCreate(lpCreateStruct);
310 }
311
312 void CGitLogListBase::SetStyle()
313 {
314 SetExtendedStyle(LVS_EX_INFOTIP | LVS_EX_DOUBLEBUFFER | LVS_EX_SUBITEMIMAGES | LVS_EX_FULLROWSELECT);
315 }
316
317 void CGitLogListBase::PreSubclassWindow()
318 {
319 SetStyle();
320 // load the icons for the action columns
321 // m_Theme.Open(m_hWnd, L"ListView");
322 SetWindowTheme(m_hWnd, L"Explorer", nullptr);
323 __super::PreSubclassWindow();
324 }
325
326 CString CGitLogListBase::GetRebaseActionName(int action)
327 {
328 if (action & LOGACTIONS_REBASE_EDIT)
329 return MAKEINTRESOURCE(IDS_PATHACTIONS_EDIT);
330 if (action & LOGACTIONS_REBASE_SQUASH)
331 return MAKEINTRESOURCE(IDS_PATHACTIONS_SQUASH);
332 if (action & LOGACTIONS_REBASE_PICK)
333 return MAKEINTRESOURCE(IDS_PATHACTIONS_PICK);
334 if (action & LOGACTIONS_REBASE_SKIP)
335 return MAKEINTRESOURCE(IDS_PATHACTIONS_SKIP);
336
337 return MAKEINTRESOURCE(IDS_PATHACTIONS_UNKNOWN);
338 }
339
340 void CGitLogListBase::InsertGitColumn()
341 {
342 CString temp;
343
344 Init();
345
346 // only load properties if we have a repository
347 if (GitAdminDir::IsWorkingTreeOrBareRepo(g_Git.m_CurrentDir))
348 UpdateProjectProperties();
349
350 static UINT normal[] =
351 {
352 IDS_LOG_GRAPH,
353 IDS_LOG_REBASE,
354 IDS_LOG_ID,
355 IDS_LOG_HASH,
356 IDS_LOG_ACTIONS,
357 IDS_LOG_MESSAGE,
358 IDS_LOG_AUTHOR,
359 IDS_LOG_DATE,
360 IDS_LOG_EMAIL,
361 IDS_LOG_COMMIT_NAME,
362 IDS_LOG_COMMIT_EMAIL,
363 IDS_LOG_COMMIT_DATE,
364 IDS_LOG_BUGIDS,
365 IDS_LOG_SVNREV,
366 };
367
368 static int with[] =
369 {
370 ICONITEMBORDER+16*4,
371 ICONITEMBORDER+16*4,
372 ICONITEMBORDER+16*4,
373 ICONITEMBORDER+16*4,
374 2 * ICONITEMBORDER + GetSystemMetrics(SM_CXSMICON) * 5,
375 LOGLIST_MESSAGE_MIN,
376 ICONITEMBORDER+16*4,
377 ICONITEMBORDER+16*4,
378 ICONITEMBORDER+16*4,
379 ICONITEMBORDER+16*4,
380 ICONITEMBORDER+16*4,
381 ICONITEMBORDER+16*4,
382 ICONITEMBORDER+16*4,
383 ICONITEMBORDER+16*4,
384 };
385 m_dwDefaultColumns = GIT_LOG_GRAPH|GIT_LOG_ACTIONS|GIT_LOG_MESSAGE|GIT_LOG_AUTHOR|GIT_LOG_DATE;
386
387 DWORD hideColumns = 0;
388 if(this->m_IsRebaseReplaceGraph)
389 {
390 hideColumns |= GIT_LOG_GRAPH;
391 m_dwDefaultColumns |= GIT_LOG_REBASE;
392 }
393 else
394 hideColumns |= GIT_LOG_REBASE;
395
396 if(this->m_IsIDReplaceAction)
397 {
398 hideColumns |= GIT_LOG_ACTIONS;
399 m_dwDefaultColumns |= GIT_LOG_ID;
400 m_dwDefaultColumns |= GIT_LOG_HASH;
401 }
402 else
403 hideColumns |= GIT_LOG_ID;
404 if(this->m_bShowBugtraqColumn)
405 m_dwDefaultColumns |= GIT_LOGLIST_BUG;
406 else
407 hideColumns |= GIT_LOGLIST_BUG;
408 if (CTGitPath(g_Git.m_CurrentDir).HasGitSVNDir())
409 m_dwDefaultColumns |= GIT_LOGLIST_SVNREV;
410 else
411 hideColumns |= GIT_LOGLIST_SVNREV;
412 SetRedraw(false);
413
414 m_ColumnManager.SetNames(normal, _countof(normal));
415 m_ColumnManager.ReadSettings(m_dwDefaultColumns, hideColumns, m_ColumnRegKey + L"loglist", _countof(normal), with);
416 m_ColumnManager.SetRightAlign(LOGLIST_ID);
417
418 if (!(hideColumns & GIT_LOG_ACTIONS))
419 {
420 // Configure fake a imagelist for LogList with 1px width and height = GetSystemMetrics(SM_CYSMICON)
421 // to set the minimum item height: we draw icons in the actions column, but on High-DPI the
422 // display's font height may be less than small icon height.
423 ASSERT((GetStyle() & LVS_SHAREIMAGELISTS) == 0);
424 HIMAGELIST hImageList = ImageList_Create(1, GetSystemMetrics(SM_CYSMICON), 0, 1, 0);
425 ListView_SetImageList(GetSafeHwnd(), hImageList, LVSIL_SMALL);
426 }
427
428 SetRedraw(true);
429 }
430
431 void CGitLogListBase::FillBackGround(HDC hdc, DWORD_PTR Index, CRect &rect)
432 {
433 LVITEM rItem = { 0 };
434 rItem.mask = LVIF_STATE;
435 rItem.iItem = (int)Index;
436 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
437 GetItem(&rItem);
438
439 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(Index);
440 HBRUSH brush = nullptr;
441
442 if (!(rItem.state & LVIS_SELECTED))
443 {
444 int action = pLogEntry->GetRebaseAction();
445 if (action & LOGACTIONS_REBASE_SQUASH)
446 brush = ::CreateSolidBrush(RGB(156,156,156));
447 else if (action & LOGACTIONS_REBASE_EDIT)
448 brush = ::CreateSolidBrush(RGB(200,200,128));
449 }
450 else if (!IsAppThemed())
451 {
452 if (rItem.state & LVIS_SELECTED)
453 {
454 if (::GetFocus() == m_hWnd)
455 brush = ::CreateSolidBrush(::GetSysColor(COLOR_HIGHLIGHT));
456 else
457 brush = ::CreateSolidBrush(::GetSysColor(COLOR_BTNFACE));
458 }
459 }
460 if (brush)
461 {
462 ::FillRect(hdc, &rect, brush);
463 ::DeleteObject(brush);
464 }
465 }
466
467 void DrawTrackingRoundRect(HDC hdc, CRect rect, HBRUSH brush, COLORREF darkColor)
468 {
469 POINT point = { 4, 4 };
470 CRect rt2 = rect;
471 rt2.DeflateRect(1, 1);
472 rt2.OffsetRect(2, 2);
473
474 HPEN nullPen = ::CreatePen(PS_NULL, 0, 0);
475 HPEN oldpen = (HPEN)::SelectObject(hdc, nullPen);
476 HBRUSH darkBrush = (HBRUSH)::CreateSolidBrush(darkColor);
477 HBRUSH oldbrush = (HBRUSH)::SelectObject(hdc, darkBrush);
478 ::RoundRect(hdc, rt2.left, rt2.top, rt2.right, rt2.bottom, point.x, point.y);
479
480 ::SelectObject(hdc, brush);
481 rt2.OffsetRect(-2, -2);
482 ::RoundRect(hdc, rt2.left, rt2.top, rt2.right, rt2.bottom, point.x, point.y);
483 ::SelectObject(hdc, oldbrush);
484 ::SelectObject(hdc, oldpen);
485 ::DeleteObject(nullPen);
486 ::DeleteObject(darkBrush);
487 }
488
489 void DrawUpstream(HDC hdc, CRect rect, COLORREF color, int bold)
490 {
491 HPEN pen = ::CreatePen(PS_SOLID, bold, color);
492 HPEN oldpen = (HPEN)::SelectObject(hdc, pen);
493 ::MoveToEx(hdc, rect.left + 2 + bold, rect.top + 2 - bold, nullptr);
494 ::LineTo(hdc, rect.left + 2 + bold, rect.bottom + 1 - bold);
495 ::MoveToEx(hdc, rect.left + 3, rect.top + 1, nullptr);
496 ::LineTo(hdc, rect.left, rect.top + 4);
497 ::MoveToEx(hdc, rect.left + 2 + bold, rect.top + 1, nullptr);
498 ::LineTo(hdc, rect.right + 1 + bold, rect.top + 4);
499 ::MoveToEx(hdc, rect.left + 1, rect.top + 2 + bold, nullptr);
500 ::LineTo(hdc, rect.right + 1 + bold, rect.top + 2 + bold);
501 ::SelectObject(hdc, oldpen);
502 ::DeleteObject(pen);
503 }
504
505 void CGitLogListBase::DrawTagBranchMessage(HDC hdc, CRect &rect, INT_PTR index, std::vector<REFLABEL> &refList)
506 {
507 GitRevLoglist* data = m_arShownList.SafeGetAt(index);
508 CRect rt=rect;
509 LVITEM rItem = { 0 };
510 rItem.mask = LVIF_STATE;
511 rItem.iItem = (int)index;
512 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
513 GetItem(&rItem);
514
515 CDC W_Dc;
516 W_Dc.Attach(hdc);
517
518 HTHEME hTheme = nullptr;
519 if (IsAppThemed())
520 hTheme = OpenThemeData(m_hWnd, L"Explorer::ListView;ListView");
521
522 SIZE oneSpaceSize;
523 if (m_bTagsBranchesOnRightSide)
524 {
525 HFONT oldFont = (HFONT)SelectObject(hdc, (HFONT)GetStockObject(DEFAULT_GUI_FONT));
526 GetTextExtentPoint32(hdc, L" ", 1, &oneSpaceSize);
527 SelectObject(hdc, oldFont);
528 rt.left += oneSpaceSize.cx * 2;
529 }
530 else
531 {
532 GetTextExtentPoint32(hdc, L" ", 1, &oneSpaceSize);
533 DrawTagBranch(hdc, W_Dc, hTheme, rect, rt, rItem, data, refList);
534 rt.left += oneSpaceSize.cx;
535 }
536
537 CString msg = MessageDisplayStr(data);
538 int action = data->GetRebaseAction();
539 bool skip = !!(action & (LOGACTIONS_REBASE_DONE | LOGACTIONS_REBASE_SKIP));
540 if (IsAppThemed())
541 {
542 int txtState = LISS_NORMAL;
543 if (rItem.state & LVIS_SELECTED)
544 txtState = LISS_SELECTED;
545
546 DTTOPTS opts = { 0 };
547 opts.dwSize = sizeof(opts);
548 opts.crText = skip ? RGB(128,128,128) : ::GetSysColor(COLOR_WINDOWTEXT);
549 opts.dwFlags = DTT_TEXTCOLOR;
550 DrawThemeTextEx(hTheme, hdc, LVP_LISTITEM, txtState, msg, -1, DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS, &rt, &opts);
551 }
552 else
553 {
554 if ((rItem.state & LVIS_SELECTED) && (::GetFocus() == m_hWnd))
555 {
556 COLORREF clrOld = ::SetTextColor(hdc, skip ? RGB(128,128,128) : ::GetSysColor(COLOR_HIGHLIGHTTEXT));
557 ::DrawText(hdc,msg, msg.GetLength(), &rt, DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS);
558 ::SetTextColor(hdc, clrOld);
559 }
560 else
561 {
562 COLORREF clrOld = ::SetTextColor(hdc, skip ? RGB(128,128,128) : ::GetSysColor(COLOR_WINDOWTEXT));
563 ::DrawText(hdc, msg, msg.GetLength(), &rt, DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS);
564 ::SetTextColor(hdc, clrOld);
565 }
566 }
567
568 if (m_bTagsBranchesOnRightSide)
569 {
570 SIZE size;
571 GetTextExtentPoint32(hdc, msg, msg.GetLength(), &size);
572
573 rt.left += oneSpaceSize.cx + size.cx;
574
575 DrawTagBranch(hdc, W_Dc, hTheme, rect, rt, rItem, data, refList);
576 }
577
578 if (hTheme)
579 CloseThemeData(hTheme);
580
581 W_Dc.Detach();
582 }
583
584 void CGitLogListBase::DrawTagBranch(HDC hdc, CDC& W_Dc, HTHEME hTheme, CRect& rect, CRect& rt, LVITEM& rItem, GitRevLoglist* data, std::vector<REFLABEL>& refList)
585 {
586 for (unsigned int i = 0; i < refList.size(); ++i)
587 {
588 CString shortname = !refList[i].simplifiedName.IsEmpty() ? refList[i].simplifiedName : refList[i].name;
589 HBRUSH brush = 0;
590 COLORREF colRef = refList[i].color;
591 bool singleRemote = refList[i].singleRemote;
592 bool hasTracking = refList[i].hasTracking;
593 CGit::REF_TYPE refType = refList[i].refType;
594
595 //When row selected, ajust label color
596 if (!IsAppThemed())
597 {
598 if (rItem.state & LVIS_SELECTED)
599 colRef = CColors::MixColors(colRef, ::GetSysColor(COLOR_HIGHLIGHT), 150);
600 }
601
602 brush = ::CreateSolidBrush(colRef);
603
604 if (!shortname.IsEmpty() && (rt.left < rect.right))
605 {
606 SIZE size = { 0 };
607 GetTextExtentPoint32(hdc, shortname, shortname.GetLength(), &size);
608
609 rt.SetRect(rt.left, rt.top, rt.left + size.cx, rt.bottom);
610 rt.right += 8;
611
612 int textpos = DT_CENTER;
613
614 if (rt.right > rect.right)
615 {
616 rt.right = rect.right;
617 textpos = 0;
618 }
619
620 CRect textRect = rt;
621
622 if (singleRemote)
623 {
624 rt.right += 5;
625 textRect.OffsetRect(5, 0);
626 }
627
628 if (hasTracking)
629 DrawTrackingRoundRect(hdc, rt, brush, m_Colors.Darken(colRef, 100));
630 else
631 {
632 //Fill interior of ref label
633 ::FillRect(hdc, &rt, brush);
634 }
635
636 //Draw edge of label
637 CRect rectEdge = rt;
638
639 if (!hasTracking)
640 {
641 W_Dc.Draw3dRect(rectEdge, m_Colors.Lighten(colRef, 100), m_Colors.Darken(colRef, 100));
642 rectEdge.DeflateRect(1, 1);
643 W_Dc.Draw3dRect(rectEdge, m_Colors.Lighten(colRef, 50), m_Colors.Darken(colRef, 50));
644 }
645
646 if (refType == CGit::REF_TYPE::ANNOTATED_TAG)
647 {
648 rt.right += 8;
649 POINT trianglept[3] = { { rt.right - 8, rt.top }, { rt.right, (rt.top + rt.bottom) / 2 }, { rt.right - 8, rt.bottom } };
650 HRGN hrgn = ::CreatePolygonRgn(trianglept, 3, ALTERNATE);
651 ::FillRgn(hdc, hrgn, brush);
652 ::DeleteObject(hrgn);
653 ::MoveToEx(hdc, trianglept[0].x - 1, trianglept[0].y, nullptr);
654 HPEN pen;
655 HPEN oldpen = (HPEN)SelectObject(hdc, pen = ::CreatePen(PS_SOLID, 2, m_Colors.Lighten(colRef, 50)));
656 ::LineTo(hdc, trianglept[1].x - 1, trianglept[1].y - 1);
657 ::DeleteObject(pen);
658 SelectObject(hdc, pen = ::CreatePen(PS_SOLID, 2, m_Colors.Darken(colRef, 50)));
659 ::LineTo(hdc, trianglept[2].x - 1, trianglept[2].y - 1);
660 ::DeleteObject(pen);
661 SelectObject(hdc, pen = ::CreatePen(PS_SOLID, 2, colRef));
662 ::MoveToEx(hdc, trianglept[0].x - 1, trianglept[2].y - 3, nullptr);
663 ::LineTo(hdc, trianglept[0].x - 1, trianglept[0].y);
664 ::DeleteObject(pen);
665 SelectObject(hdc, oldpen);
666 }
667
668 //Draw text inside label
669 bool customColor = (colRef & 0xff) * 30 + ((colRef >> 8) & 0xff) * 59 + ((colRef >> 16) & 0xff) * 11 <= 12800; // check if dark background
670 if (!customColor && IsAppThemed())
671 {
672 int txtState = LISS_NORMAL;
673 if (rItem.state & LVIS_SELECTED)
674 txtState = LISS_SELECTED;
675
676 DTTOPTS opts = { 0 };
677 opts.dwSize = sizeof(opts);
678 opts.crText = ::GetSysColor(COLOR_WINDOWTEXT);
679 opts.dwFlags = DTT_TEXTCOLOR;
680 DrawThemeTextEx(hTheme, hdc, LVP_LISTITEM, txtState, shortname, -1, textpos | DT_SINGLELINE | DT_VCENTER, &textRect, &opts);
681 }
682 else
683 {
684 W_Dc.SetBkMode(TRANSPARENT);
685 if (customColor || (rItem.state & LVIS_SELECTED))
686 {
687 COLORREF clrNew = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
688 COLORREF clrOld = ::SetTextColor(hdc,clrNew);
689 ::DrawText(hdc, shortname, shortname.GetLength(), &textRect, textpos | DT_SINGLELINE | DT_VCENTER);
690 ::SetTextColor(hdc,clrOld);
691 }
692 else
693 {
694 COLORREF clrOld = ::SetTextColor(hdc, ::GetSysColor(COLOR_WINDOWTEXT));
695 ::DrawText(hdc, shortname, shortname.GetLength(), &textRect, textpos | DT_SINGLELINE | DT_VCENTER);
696 ::SetTextColor(hdc, clrOld);
697 }
698 }
699
700 if (singleRemote)
701 {
702 COLORREF color = ::GetSysColor(customColor ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT);
703 int bold = data->m_CommitHash == m_HeadHash ? 2 : 1;
704 CRect newRect;
705 newRect.SetRect(rt.left + 2, rt.top + 4, rt.left + 6, rt.bottom - 4);
706 DrawUpstream(hdc, newRect, color, bold);
707 }
708
709 if (!refList[i].fullName.IsEmpty())
710 m_RefLabelPosMap[refList[i].fullName] = rt;
711
712 rt.left = rt.right + 1;
713 }
714 if (brush)
715 ::DeleteObject(brush);
716 }
717 rt.right = rect.right;
718 }
719
720 static COLORREF blend(const COLORREF& col1, const COLORREF& col2, int amount = 128) {
721 // Returns ((256 - amount)*col1 + amount*col2) / 256;
722 return RGB(((256 - amount)*GetRValue(col1) + amount*GetRValue(col2) ) / 256,
723 ((256 - amount)*GetGValue(col1) + amount*GetGValue(col2) ) / 256,
724 ((256 - amount)*GetBValue(col1) + amount*GetBValue(col2) ) / 256);
725 }
726
727 Gdiplus::Color GetGdiColor(COLORREF col)
728 {
729 return Gdiplus::Color(GetRValue(col),GetGValue(col),GetBValue(col));
730 }
731 void CGitLogListBase::paintGraphLane(HDC hdc, int laneHeight,int type, int x1, int x2,
732 const COLORREF& col,const COLORREF& activeColor, int top
733 )
734 {
735 int h = laneHeight / 2;
736 int m = (x1 + x2) / 2;
737 int r = (x2 - x1) * m_NodeSize / 30;
738 int d = 2 * r;
739
740 #define P_CENTER m , h+top
741 #define P_0 x2, h+top
742 #define P_90 m , 0+top-1
743 #define P_180 x1, h+top
744 #define P_270 m , 2 * h+top +1
745 #define R_CENTER m - r, h - r+top, d, d
746
747
748 #define DELTA_UR_B 2*(x1 - m), 2*h +top
749 #define DELTA_UR_E 0*16, 90*16 +top // -,
750
751 #define DELTA_DR_B 2*(x1 - m), 2*-h +top
752 #define DELTA_DR_E 270*16, 90*16 +top // -'
753
754 #define DELTA_UL_B 2*(x2 - m), 2*h +top
755 #define DELTA_UL_E 90*16, 90*16 +top // ,-
756
757 #define DELTA_DL_B 2*(x2 - m),2*-h +top
758 #define DELTA_DL_E 180*16, 90*16 // '-
759
760 #define CENTER_UR x1, 2*h, 225
761 #define CENTER_DR x1, 0 , 135
762 #define CENTER_UL x2, 2*h, 315
763 #define CENTER_DL x2, 0 , 45
764
765
766 Gdiplus::Graphics graphics( hdc );
767
768 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
769
770 // arc
771 switch (type) {
772 case Lanes::JOIN:
773 case Lanes::JOIN_R:
774 case Lanes::HEAD:
775 case Lanes::HEAD_R:
776 {
777 Gdiplus::LinearGradientBrush gradient(
778 Gdiplus::Point(x1-2, h+top-2),
779 Gdiplus::Point(P_270),
780 GetGdiColor(activeColor),GetGdiColor(col));
781
782
783 Gdiplus::Pen mypen(&gradient, (Gdiplus::REAL)m_LineWidth);
784 //Gdiplus::Pen mypen(Gdiplus::Color(0,0,0),2);
785
786 //graphics.DrawRectangle(&mypen,x1-(x2-x1)/2,top+h, x2-x1,laneHeight);
787 graphics.DrawArc(&mypen,x1-(x2-x1)/2-1,top+h-1, x2-x1,laneHeight,270,90);
788 //graphics.DrawLine(&mypen,x1-1,h+top,P_270);
789
790 break;
791 }
792 case Lanes::JOIN_L:
793 {
794 Gdiplus::LinearGradientBrush gradient(
795 Gdiplus::Point(P_270),
796 Gdiplus::Point(x2+1, h+top-1),
797 GetGdiColor(col),GetGdiColor(activeColor));
798
799
800 Gdiplus::Pen mypen(&gradient, (Gdiplus::REAL)m_LineWidth);
801 //Gdiplus::Pen mypen(Gdiplus::Color(0,0,0),2);
802
803 //graphics.DrawRectangle(&mypen,x1-(x2-x1)/2,top+h, x2-x1,laneHeight);
804 graphics.DrawArc(&mypen,x1+(x2-x1)/2,top+h-1, x2-x1,laneHeight,180,90);
805 //graphics.DrawLine(&mypen,x1-1,h+top,P_270);
806
807
808 break;
809 }
810 case Lanes::TAIL:
811 case Lanes::TAIL_R:
812 {
813 Gdiplus::LinearGradientBrush gradient(
814 Gdiplus::Point(x1-2, h+top-2),
815 Gdiplus::Point(P_90),
816 GetGdiColor(activeColor),GetGdiColor(col));
817
818 Gdiplus::Pen mypen(&gradient, (Gdiplus::REAL)m_LineWidth);
819
820 graphics.DrawArc(&mypen,x1-(x2-x1)/2-1,top-h-1, x2-x1,laneHeight,0,90);
821
822 #if 0
823 QConicalGradient gradient(CENTER_DR);
824 gradient.setColorAt(0.375, activeCol);
825 gradient.setColorAt(0.625, col);
826 myPen.setBrush(gradient);
827 p->setPen(myPen);
828 p->drawArc(P_CENTER, DELTA_DR);
829 #endif
830 break;
831 }
832 default:
833 break;
834 }
835
836
837 //static QPen myPen(Qt::black, 2); // fast path here
838 CPen pen;
839 pen.CreatePen(PS_SOLID,2,col);
840 //myPen.setColor(col);
841 HPEN oldpen=(HPEN)::SelectObject(hdc,(HPEN)pen);
842
843 Gdiplus::Pen myPen(GetGdiColor(col), (Gdiplus::REAL)m_LineWidth);
844
845 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
846
847 //p->setPen(myPen);
848
849 // vertical line
850 switch (type) {
851 case Lanes::ACTIVE:
852 case Lanes::NOT_ACTIVE:
853 case Lanes::MERGE_FORK:
854 case Lanes::MERGE_FORK_R:
855 case Lanes::MERGE_FORK_L:
856 case Lanes::JOIN:
857 case Lanes::JOIN_R:
858 case Lanes::JOIN_L:
859 case Lanes::CROSS:
860 //DrawLine(hdc,P_90,P_270);
861 graphics.DrawLine(&myPen,P_90,P_270);
862 //p->drawLine(P_90, P_270);
863 break;
864 case Lanes::HEAD_L:
865 case Lanes::BRANCH:
866 //DrawLine(hdc,P_CENTER,P_270);
867 graphics.DrawLine(&myPen,P_CENTER,P_270);
868 //p->drawLine(P_CENTER, P_270);
869 break;
870 case Lanes::TAIL_L:
871 case Lanes::INITIAL:
872 case Lanes::MERGE_FORK_L_INITIAL:
873 case Lanes::BOUNDARY:
874 case Lanes::BOUNDARY_C:
875 case Lanes::BOUNDARY_R:
876 case Lanes::BOUNDARY_L:
877 //DrawLine(hdc,P_90, P_CENTER);
878 graphics.DrawLine(&myPen,P_90,P_CENTER);
879 //p->drawLine(P_90, P_CENTER);
880 break;
881 default:
882 break;
883 }
884
885 myPen.SetColor(GetGdiColor(activeColor));
886
887 // horizontal line
888 switch (type) {
889 case Lanes::MERGE_FORK:
890 case Lanes::JOIN:
891 case Lanes::HEAD:
892 case Lanes::TAIL:
893 case Lanes::CROSS:
894 case Lanes::CROSS_EMPTY:
895 case Lanes::BOUNDARY_C:
896 //DrawLine(hdc,P_180,P_0);
897 graphics.DrawLine(&myPen,P_180,P_0);
898 //p->drawLine(P_180, P_0);
899 break;
900 case Lanes::MERGE_FORK_R:
901 case Lanes::BOUNDARY_R:
902 //DrawLine(hdc,P_180,P_CENTER);
903 graphics.DrawLine(&myPen,P_180,P_CENTER);
904 //p->drawLine(P_180, P_CENTER);
905 break;
906 case Lanes::MERGE_FORK_L:
907 case Lanes::MERGE_FORK_L_INITIAL:
908 case Lanes::HEAD_L:
909 case Lanes::TAIL_L:
910 case Lanes::BOUNDARY_L:
911 //DrawLine(hdc,P_CENTER,P_0);
912 graphics.DrawLine(&myPen,P_CENTER,P_0);
913 //p->drawLine(P_CENTER, P_0);
914 break;
915 default:
916 break;
917 }
918
919 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
920
921 CBrush brush;
922 brush.CreateSolidBrush(col);
923 HBRUSH oldbrush=(HBRUSH)::SelectObject(hdc,(HBRUSH)brush);
924
925 Gdiplus::SolidBrush myBrush(GetGdiColor(col));
926 // center symbol, e.g. rect or ellipse
927 switch (type) {
928 case Lanes::ACTIVE:
929 case Lanes::INITIAL:
930 case Lanes::BRANCH:
931
932 //p->setPen(Qt::NoPen);
933 //p->setBrush(col);
934 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
935 graphics.FillEllipse(&myBrush, R_CENTER);
936 //p->drawEllipse(R_CENTER);
937 break;
938 case Lanes::MERGE_FORK:
939 case Lanes::MERGE_FORK_R:
940 case Lanes::MERGE_FORK_L:
941 case Lanes::MERGE_FORK_L_INITIAL:
942 //p->setPen(Qt::NoPen);
943 //p->setBrush(col);
944 //p->drawRect(R_CENTER);
945 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
946 graphics.FillRectangle(&myBrush, R_CENTER);
947 break;
948 case Lanes::UNAPPLIED:
949 // Red minus sign
950 //p->setPen(Qt::NoPen);
951 //p->setBrush(Qt::red);
952 //p->drawRect(m - r, h - 1, d, 2);
953 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
954 graphics.FillRectangle(&myBrush,m-r,h-1,d,2);
955 break;
956 case Lanes::APPLIED:
957 // Green plus sign
958 //p->setPen(Qt::NoPen);
959 //p->setBrush(DARK_GREEN);
960 //p->drawRect(m - r, h - 1, d, 2);
961 //p->drawRect(m - 1, h - r, 2, d);
962 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
963 graphics.FillRectangle(&myBrush,m-r,h-1,d,2);
964 graphics.FillRectangle(&myBrush,m-1,h-r,2,d);
965 break;
966 case Lanes::BOUNDARY:
967 //p->setBrush(back);
968 //p->drawEllipse(R_CENTER);
969 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
970 graphics.DrawEllipse(&myPen, R_CENTER);
971 break;
972 case Lanes::BOUNDARY_C:
973 case Lanes::BOUNDARY_R:
974 case Lanes::BOUNDARY_L:
975 //p->setBrush(back);
976 //p->drawRect(R_CENTER);
977 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
978 graphics.FillRectangle(&myBrush,R_CENTER);
979 break;
980 default:
981 break;
982 }
983
984 ::SelectObject(hdc,oldpen);
985 ::SelectObject(hdc,oldbrush);
986 #undef P_CENTER
987 #undef P_0
988 #undef P_90
989 #undef P_180
990 #undef P_270
991 #undef R_CENTER
992 }
993
994 void CGitLogListBase::DrawGraph(HDC hdc,CRect &rect,INT_PTR index)
995 {
996 // TODO: unfinished
997 // return;
998 GitRevLoglist* data = m_arShownList.SafeGetAt(index);
999 if(data->m_CommitHash.IsEmpty())
1000 return;
1001
1002 CRect rt=rect;
1003 LVITEM rItem = { 0 };
1004 rItem.mask = LVIF_STATE;
1005 rItem.iItem = (int)index;
1006 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
1007 GetItem(&rItem);
1008
1009 // p->translate(QPoint(opt.rect.left(), opt.rect.top()));
1010
1011 if (data->m_Lanes.empty())
1012 m_logEntries.setLane(data->m_CommitHash);
1013
1014 std::vector<int>& lanes=data->m_Lanes;
1015 size_t laneNum = lanes.size();
1016 UINT activeLane = 0;
1017 for (UINT i = 0; i < laneNum; ++i)
1018 if (Lanes::isMerge(lanes[i])) {
1019 activeLane = i;
1020 break;
1021 }
1022
1023 int x2 = 0;
1024 int maxWidth = rect.Width();
1025 int lw = 3 * rect.Height() / 4; //laneWidth()
1026
1027 COLORREF activeColor = m_LineColors[activeLane % Lanes::COLORS_NUM];
1028 //if (opt.state & QStyle::State_Selected)
1029 // activeColor = blend(activeColor, opt.palette.highlightedText().color(), 208);
1030
1031 for (unsigned int i = 0; i < laneNum && x2 < maxWidth; ++i)
1032 {
1033 int x1 = x2;
1034 x2 += lw;
1035
1036 int ln = lanes[i];
1037 if (ln == Lanes::EMPTY)
1038 continue;
1039
1040 COLORREF color = i == activeLane ? activeColor : m_LineColors[i % Lanes::COLORS_NUM];
1041 paintGraphLane(hdc, rect.Height(),ln, x1+rect.left, x2+rect.left, color,activeColor, rect.top);
1042 }
1043
1044 #if 0
1045 for (UINT i = 0; i < laneNum && x2 < maxWidth; ++i) {
1046 int x1 = x2;
1047 x2 += lw;
1048
1049 int ln = lanes[i];
1050 if (ln == Lanes::EMPTY)
1051 continue;
1052
1053 UINT col = ( Lanes:: isHead(ln) ||Lanes:: isTail(ln) || Lanes::isJoin(ln)
1054 || ln ==Lanes:: CROSS_EMPTY) ? activeLane : i;
1055
1056 if (ln == Lanes::CROSS)
1057 {
1058 paintGraphLane(hdc, rect.Height(),Lanes::NOT_ACTIVE, x1, x2, m_LineColors[col % Lanes::COLORS_NUM],rect.top);
1059 paintGraphLane(hdc, rect.Height(),Lanes::CROSS, x1, x2, m_LineColors[activeLane % Lanes::COLORS_NUM],rect.top);
1060 }
1061 else
1062 paintGraphLane(hdc, rect.Height(),ln, x1, x2, m_LineColors[col % Lanes::COLORS_NUM],rect.top);
1063 }
1064 #endif
1065 }
1066
1067 void CGitLogListBase::OnNMCustomdrawLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1068 {
1069 NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
1070 // Take the default processing unless we set this to something else below.
1071 *pResult = CDRF_DODEFAULT;
1072
1073 if (m_bNoDispUpdates)
1074 return;
1075
1076 switch (pLVCD->nmcd.dwDrawStage)
1077 {
1078 case CDDS_PREPAINT:
1079 {
1080 *pResult = CDRF_NOTIFYITEMDRAW;
1081 return;
1082 }
1083 break;
1084 case CDDS_ITEMPREPAINT:
1085 {
1086 // This is the prepaint stage for an item. Here's where we set the
1087 // item's text color.
1088
1089 // Tell Windows to send draw notifications for each subitem.
1090 *pResult = CDRF_NOTIFYSUBITEMDRAW;
1091
1092 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
1093
1094 if (m_arShownList.size() > pLVCD->nmcd.dwItemSpec)
1095 {
1096 GitRevLoglist* data = m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1097 if (data)
1098 {
1099 HGDIOBJ hGdiObj = nullptr;
1100 int action = data->GetRebaseAction();
1101 if (action & (LOGACTIONS_REBASE_DONE | LOGACTIONS_REBASE_SKIP))
1102 crText = RGB(128,128,128);
1103
1104 if (action & LOGACTIONS_REBASE_SQUASH)
1105 pLVCD->clrTextBk = RGB(156,156,156);
1106 else if (action & LOGACTIONS_REBASE_EDIT)
1107 pLVCD->clrTextBk = RGB(200,200,128);
1108 else
1109 pLVCD->clrTextBk = ::GetSysColor(COLOR_WINDOW);
1110
1111 if (action & LOGACTIONS_REBASE_CURRENT)
1112 hGdiObj = m_boldFont.GetSafeHandle();
1113
1114 BOOL isHeadHash = data->m_CommitHash == m_HeadHash && m_bNoHightlightHead == FALSE;
1115 BOOL isHighlight = data->m_CommitHash == m_highlight && !m_highlight.IsEmpty();
1116 if (isHeadHash && isHighlight)
1117 hGdiObj = m_boldItalicsFont.GetSafeHandle();
1118 else if (isHeadHash)
1119 hGdiObj = m_boldFont.GetSafeHandle();
1120 else if (isHighlight)
1121 hGdiObj = m_FontItalics.GetSafeHandle();
1122
1123 if (hGdiObj)
1124 {
1125 SelectObject(pLVCD->nmcd.hdc, hGdiObj);
1126 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1127 }
1128
1129 // if ((data->childStackDepth)||(m_mergedRevs.find(data->Rev) != m_mergedRevs.end()))
1130 // crText = GetSysColor(COLOR_GRAYTEXT);
1131
1132 if (data->m_CommitHash.IsEmpty())
1133 {
1134 //crText = GetSysColor(RGB(200,200,0));
1135 //SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1136 // We changed the font, so we're returning CDRF_NEWFONT. This
1137 // tells the control to recalculate the extent of the text.
1138 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1139 }
1140 }
1141 }
1142 if (m_arShownList.size() == pLVCD->nmcd.dwItemSpec)
1143 {
1144 if (m_bStrictStopped)
1145 crText = GetSysColor(COLOR_GRAYTEXT);
1146 }
1147 // Store the color back in the NMLVCUSTOMDRAW struct.
1148 pLVCD->clrText = crText;
1149 return;
1150 }
1151 break;
1152 case CDDS_ITEMPREPAINT|CDDS_ITEM|CDDS_SUBITEM:
1153 {
1154 if (m_bStrictStopped && m_arShownList.size() == pLVCD->nmcd.dwItemSpec)
1155 {
1156 pLVCD->nmcd.uItemState &= ~(CDIS_SELECTED|CDIS_FOCUS);
1157 }
1158
1159 if (pLVCD->iSubItem == LOGLIST_GRAPH && !HasFilterText() && (m_ShowFilter & FILTERSHOW_MERGEPOINTS))
1160 {
1161 if (m_arShownList.size() > pLVCD->nmcd.dwItemSpec && !this->m_IsRebaseReplaceGraph)
1162 {
1163 CRect rect;
1164 GetSubItemRect((int)pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_LABEL, rect);
1165
1166 //TRACE(L"A Graphic left %d right %d\r\n", rect.left, rect.right);
1167 FillBackGround(pLVCD->nmcd.hdc, pLVCD->nmcd.dwItemSpec,rect);
1168
1169 GitRevLoglist* data = m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1170 if( !data ->m_CommitHash.IsEmpty())
1171 DrawGraph(pLVCD->nmcd.hdc,rect,pLVCD->nmcd.dwItemSpec);
1172
1173 *pResult = CDRF_SKIPDEFAULT;
1174 return;
1175 }
1176 }
1177
1178 if (pLVCD->iSubItem == LOGLIST_MESSAGE)
1179 {
1180 // If the top index of list is changed, the position map of reference label is outdated.
1181 if (m_OldTopIndex != GetTopIndex())
1182 {
1183 m_OldTopIndex = GetTopIndex();
1184 m_RefLabelPosMap.clear();
1185 }
1186
1187 if (m_arShownList.size() > pLVCD->nmcd.dwItemSpec)
1188 {
1189 GitRevLoglist* data = m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1190
1191 if ((m_HashMap.find(data->m_CommitHash) != m_HashMap.cend() || (!m_superProjectHash.IsEmpty() && data->m_CommitHash == m_superProjectHash)) && !(data->GetRebaseAction() & LOGACTIONS_REBASE_DONE))
1192 {
1193 CRect rect;
1194 GetSubItemRect((int)pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
1195
1196 // BEGIN: extended redraw, HACK for issue #1618 and #2014
1197 // not in FillBackGround method, because this only affected the message subitem
1198 if (0 != pLVCD->iStateId) // don't know why, but this helps against loosing the focus rect
1199 return;
1200
1201 int index = (int)pLVCD->nmcd.dwItemSpec;
1202 int state = GetItemState(index, LVIS_SELECTED);
1203 int txtState = LISS_NORMAL;
1204 if (IsAppThemed() && GetHotItem() == (int)index)
1205 {
1206 if (state & LVIS_SELECTED)
1207 txtState = LISS_HOTSELECTED;
1208 else
1209 txtState = LISS_HOT;
1210 }
1211 else if (state & LVIS_SELECTED)
1212 {
1213 if (::GetFocus() == m_hWnd)
1214 txtState = LISS_SELECTED;
1215 else
1216 txtState = LISS_SELECTEDNOTFOCUS;
1217 }
1218
1219 HTHEME hTheme = nullptr;
1220 if (IsAppThemed())
1221 hTheme = OpenThemeData(m_hWnd, L"Explorer::ListView;ListView");
1222
1223 if (hTheme && IsThemeBackgroundPartiallyTransparent(hTheme, LVP_LISTDETAIL, txtState))
1224 DrawThemeParentBackground(m_hWnd, pLVCD->nmcd.hdc, &rect);
1225 else
1226 {
1227 HBRUSH brush = ::CreateSolidBrush(pLVCD->clrTextBk);
1228 ::FillRect(pLVCD->nmcd.hdc, rect, brush);
1229 ::DeleteObject(brush);
1230 }
1231 if (hTheme && txtState != LISS_NORMAL)
1232 {
1233 CRect rt;
1234 // get rect of whole line
1235 GetItemRect(index, rt, LVIR_BOUNDS);
1236 CRect rect2 = rect;
1237
1238 // calculate background for rect of whole line, but limit redrawing to SubItem rect
1239 DrawThemeBackground(hTheme, pLVCD->nmcd.hdc, LVP_LISTITEM, txtState, rt, rect2);
1240
1241 CloseThemeData(hTheme);
1242 }
1243 // END: extended redraw
1244
1245 FillBackGround(pLVCD->nmcd.hdc, pLVCD->nmcd.dwItemSpec,rect);
1246
1247 std::vector<REFLABEL> refsToShow;
1248 STRING_VECTOR remoteTrackingList;
1249 const STRING_VECTOR& refList = m_HashMap[data->m_CommitHash];
1250 for (unsigned int i = 0; i < refList.size(); ++i)
1251 {
1252 CString str = refList[i];
1253
1254 REFLABEL refLabel;
1255 refLabel.color = RGB(255, 255, 255);
1256 refLabel.singleRemote = false;
1257 refLabel.hasTracking = false;
1258 refLabel.sameName = false;
1259 refLabel.name = CGit::GetShortName(str, &refLabel.refType);
1260 refLabel.fullName = str;
1261
1262 switch (refLabel.refType)
1263 {
1264 case CGit::REF_TYPE::LOCAL_BRANCH:
1265 {
1266 if (!(m_ShowRefMask & LOGLIST_SHOWLOCALBRANCHES))
1267 continue;
1268 if (refLabel.name == m_CurrentBranch)
1269 refLabel.color = m_Colors.GetColor(CColors::CurrentBranch);
1270 else
1271 refLabel.color = m_Colors.GetColor(CColors::LocalBranch);
1272
1273 std::pair<CString, CString> trackingEntry = m_TrackingMap[refLabel.name];
1274 CString pullRemote = trackingEntry.first;
1275 CString pullBranch = trackingEntry.second;
1276 if (!pullRemote.IsEmpty() && !pullBranch.IsEmpty())
1277 {
1278 CString defaultUpstream;
1279 defaultUpstream.Format(L"refs/remotes/%s/%s", (LPCTSTR)pullRemote, (LPCTSTR)pullBranch);
1280 refLabel.hasTracking = true;
1281 if (m_ShowRefMask & LOGLIST_SHOWREMOTEBRANCHES)
1282 {
1283 bool found = false;
1284 for (size_t j = i + 1; j < refList.size(); ++j)
1285 {
1286 if (refList[j] == defaultUpstream)
1287 {
1288 found = true;
1289 break;
1290 }
1291 }
1292
1293 if (found)
1294 {
1295 bool sameName = pullBranch == refLabel.name;
1296 refsToShow.push_back(refLabel);
1297 CGit::GetShortName(defaultUpstream, refLabel.name, L"refs/remotes/");
1298 refLabel.color = m_Colors.GetColor(CColors::RemoteBranch);
1299 if (m_bSymbolizeRefNames)
1300 {
1301 if (!m_SingleRemote.IsEmpty() && m_SingleRemote == pullRemote)
1302 {
1303 refLabel.simplifiedName = L'/';
1304 if (sameName)
1305 refLabel.simplifiedName += L'≡';
1306 else
1307 refLabel.simplifiedName += pullBranch;
1308 refLabel.singleRemote = true;
1309 }
1310 else if (sameName)
1311 refLabel.simplifiedName = pullRemote + L"/≡";
1312 refLabel.sameName = sameName;
1313 }
1314 refLabel.fullName = defaultUpstream;
1315 refsToShow.push_back(refLabel);
1316 remoteTrackingList.push_back(defaultUpstream);
1317 continue;
1318 }
1319 }
1320 }
1321 break;
1322 }
1323 case CGit::REF_TYPE::REMOTE_BRANCH:
1324 {
1325 if (!(m_ShowRefMask & LOGLIST_SHOWREMOTEBRANCHES))
1326 continue;
1327 bool found = false;
1328 for (size_t j = 0; j < remoteTrackingList.size(); ++j)
1329 {
1330 if (remoteTrackingList[j] == str)
1331 {
1332 found = true;
1333 break;
1334 }
1335 }
1336 if (found)
1337 continue;
1338
1339 refLabel.color = m_Colors.GetColor(CColors::RemoteBranch);
1340 if (m_bSymbolizeRefNames)
1341 {
1342 if (!m_SingleRemote.IsEmpty() && CStringUtils::StartsWith(refLabel.name, m_SingleRemote + L"/"))
1343 {
1344 refLabel.simplifiedName = L'/' + refLabel.name.Mid(m_SingleRemote.GetLength() + 1);
1345 refLabel.singleRemote = true;
1346 }
1347 }
1348 break;
1349 }
1350 case CGit::REF_TYPE::ANNOTATED_TAG:
1351 case CGit::REF_TYPE::TAG:
1352 if (!(m_ShowRefMask & LOGLIST_SHOWTAGS))
1353 continue;
1354 refLabel.color = m_Colors.GetColor(CColors::Tag);
1355 break;
1356 case CGit::REF_TYPE::STASH:
1357 if (!(m_ShowRefMask & LOGLIST_SHOWSTASH))
1358 continue;
1359 refLabel.color = m_Colors.GetColor(CColors::Stash);
1360 break;
1361 case CGit::REF_TYPE::BISECT_GOOD:
1362 case CGit::REF_TYPE::BISECT_BAD:
1363 case CGit::REF_TYPE::BISECT_SKIP:
1364 if (!(m_ShowRefMask & LOGLIST_SHOWBISECT))
1365 continue;
1366 refLabel.color = (refLabel.refType == CGit::REF_TYPE::BISECT_GOOD) ? m_Colors.GetColor(CColors::BisectGood) : ((refLabel.refType == CGit::REF_TYPE::BISECT_SKIP) ? m_Colors.GetColor(CColors::BisectSkip) : m_Colors.GetColor(CColors::BisectBad));
1367 break;
1368 case CGit::REF_TYPE::NOTES:
1369 if (!(m_ShowRefMask & LOGLIST_SHOWOTHERREFS))
1370 continue;
1371 refLabel.color = m_Colors.GetColor(CColors::NoteNode);
1372 break;
1373 default:
1374 if (!(m_ShowRefMask & LOGLIST_SHOWOTHERREFS))
1375 continue;
1376 refLabel.color = m_Colors.GetColor(CColors::OtherRef);
1377 break;
1378 }
1379 refsToShow.push_back(refLabel);
1380 }
1381 if (!m_superProjectHash.IsEmpty() && data->m_CommitHash == m_superProjectHash)
1382 {
1383 REFLABEL refLabel;
1384 refLabel.color = RGB(246, 153, 253);
1385 refLabel.singleRemote = false;
1386 refLabel.hasTracking = false;
1387 refLabel.sameName = false;
1388 refLabel.name = L"super-project-pointer";
1389 refLabel.fullName = "";
1390 refsToShow.push_back(refLabel);
1391 }
1392
1393 if (refsToShow.empty())
1394 {
1395 *pResult = CDRF_DODEFAULT;
1396 return;
1397 }
1398
1399 DrawTagBranchMessage(pLVCD->nmcd.hdc, rect, pLVCD->nmcd.dwItemSpec, refsToShow);
1400
1401 *pResult = CDRF_SKIPDEFAULT;
1402 return;
1403
1404 }
1405
1406 }
1407 }
1408
1409 if (pLVCD->iSubItem == LOGLIST_ACTION)
1410 {
1411 if (m_IsIDReplaceAction || !m_ColumnManager.IsVisible(LOGLIST_ACTION))
1412 {
1413 *pResult = CDRF_DODEFAULT;
1414 return;
1415 }
1416 *pResult = CDRF_DODEFAULT;
1417
1418 if (m_arShownList.size() <= pLVCD->nmcd.dwItemSpec)
1419 return;
1420
1421 int nIcons = 0;
1422 int iconwidth = ::GetSystemMetrics(SM_CXSMICON);
1423 int iconheight = ::GetSystemMetrics(SM_CYSMICON);
1424
1425 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1426 CRect rect;
1427 GetSubItemRect((int)pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
1428 //TRACE(L"Action left %d right %d\r\n", rect.left, rect.right);
1429 // Get the selected state of the
1430 // item being drawn.
1431
1432 CMemDC myDC(*CDC::FromHandle(pLVCD->nmcd.hdc), rect);
1433 BitBlt(myDC.GetDC(), rect.left, rect.top, rect.Width(), rect.Height(), pLVCD->nmcd.hdc, rect.left, rect.top, SRCCOPY);
1434
1435 // Fill the background if necessary
1436 FillBackGround(myDC.GetDC(), pLVCD->nmcd.dwItemSpec, rect);
1437
1438 // Draw the icon(s) into the compatible DC
1439 int action = pLogEntry->GetAction(this);
1440 if (!pLogEntry->m_IsDiffFiles)
1441 {
1442 ::DrawIconEx(myDC.GetDC(), rect.left + ICONITEMBORDER, rect.top, m_hFetchIcon, iconwidth, iconheight, 0, nullptr, DI_NORMAL);
1443 *pResult = CDRF_SKIPDEFAULT;
1444 return;
1445 }
1446
1447 if (action & CTGitPath::LOGACTIONS_MODIFIED)
1448 ::DrawIconEx(myDC.GetDC(), rect.left + ICONITEMBORDER, rect.top, m_hModifiedIcon, iconwidth, iconheight, 0, nullptr, DI_NORMAL);
1449 ++nIcons;
1450
1451 if (action & (CTGitPath::LOGACTIONS_ADDED | CTGitPath::LOGACTIONS_COPY))
1452 ::DrawIconEx(myDC.GetDC(), rect.left + nIcons * iconwidth + ICONITEMBORDER, rect.top, m_hAddedIcon, iconwidth, iconheight, 0, nullptr, DI_NORMAL);
1453 ++nIcons;
1454
1455 if (action & CTGitPath::LOGACTIONS_DELETED)
1456 ::DrawIconEx(myDC.GetDC(), rect.left + nIcons * iconwidth + ICONITEMBORDER, rect.top, m_hDeletedIcon, iconwidth, iconheight, 0, nullptr, DI_NORMAL);
1457 ++nIcons;
1458
1459 if (action & CTGitPath::LOGACTIONS_REPLACED)
1460 ::DrawIconEx(myDC.GetDC(), rect.left + nIcons * iconwidth + ICONITEMBORDER, rect.top, m_hReplacedIcon, iconwidth, iconheight, 0, nullptr, DI_NORMAL);
1461 ++nIcons;
1462
1463 if (action & CTGitPath::LOGACTIONS_UNMERGED)
1464 ::DrawIconEx(myDC.GetDC(), rect.left + nIcons * iconwidth + ICONITEMBORDER, rect.top, m_hConflictedIcon, iconwidth, iconheight, 0, nullptr, DI_NORMAL);
1465 ++nIcons;
1466
1467 *pResult = CDRF_SKIPDEFAULT;
1468 return;
1469 }
1470 }
1471 break;
1472 }
1473 *pResult = CDRF_DODEFAULT;
1474 }
1475
1476 CString FindSVNRev(const CString& msg)
1477 {
1478 try
1479 {
1480 const std::wsregex_iterator end;
1481 std::wstring s = msg;
1482 std::wregex regex1(L"^\\s*git-svn-id:\\s+(.*)\\@(\\d+)\\s([a-f\\d\\-]+)$");
1483 for (std::wsregex_iterator it(s.cbegin(), s.cend(), regex1); it != end; ++it)
1484 {
1485 const std::wsmatch match = *it;
1486 if (match.size() == 4)
1487 {
1488 ATLTRACE(L"matched rev: %s\n", std::wstring(match[2]).c_str());
1489 return std::wstring(match[2]).c_str();
1490 }
1491 }
1492 std::wregex regex2(L"^\\s*git-svn-id:\\s(\\d+)\\@([a-f\\d\\-]+)$");
1493 for (std::wsregex_iterator it(s.cbegin(), s.cend(), regex2); it != end; ++it)
1494 {
1495 const std::wsmatch match = *it;
1496 if (match.size() == 3)
1497 {
1498 ATLTRACE(L"matched rev: %s\n", std::wstring(match[1]).c_str());
1499 return std::wstring(match[1]).c_str();
1500 }
1501 }
1502 }
1503 catch (std::exception&) {}
1504
1505 return L"";
1506 }
1507
1508 CString CGitLogListBase::MessageDisplayStr(GitRev* pLogEntry)
1509 {
1510 if (!m_bFullCommitMessageOnLogLine || pLogEntry->GetBody().IsEmpty())
1511 return pLogEntry->GetSubject();
1512
1513 CString txt(pLogEntry->GetSubject());
1514 txt += L' ';
1515 txt += pLogEntry->GetBody();
1516
1517 // Deal with CRLF
1518 txt.Replace(L'\n', L' ');
1519 txt.Replace(L'\r', L' ');
1520
1521 return txt;
1522 }
1523
1524 // CGitLogListBase message handlers
1525
1526 static const char* GetMailmapMapping(GIT_MAILMAP mailmap, const CString& email, const CString& name, bool returnEmail)
1527 {
1528 struct payload_struct { const CString* name; const char* authorName; };
1529 payload_struct payload = { &name, nullptr };
1530 const char* author1 = nullptr;
1531 const char* email1 = nullptr;
1532 git_lookup_mailmap(mailmap, &email1, &author1, CUnicodeUtils::GetUTF8(email), &payload,
1533 [](void* payload) -> const char* { return reinterpret_cast<payload_struct*>(payload)->authorName = _strdup(CUnicodeUtils::GetUTF8(*reinterpret_cast<payload_struct*>(payload)->name)); });
1534 free((void *)payload.authorName);
1535 if (returnEmail)
1536 return email1;
1537 return author1;
1538 }
1539
1540 static void CopyMailmapProcessedData(GIT_MAILMAP mailmap, LV_ITEM* pItem, const CString& email, const CString& name, bool returnEmail)
1541 {
1542 if (mailmap)
1543 {
1544 const char* translated = GetMailmapMapping(mailmap, email, name, returnEmail);
1545 if (translated)
1546 {
1547 lstrcpyn(pItem->pszText, CUnicodeUtils::GetUnicode(translated), pItem->cchTextMax - 1);
1548 return;
1549 }
1550 }
1551 if (returnEmail)
1552 lstrcpyn(pItem->pszText, (LPCTSTR)email, pItem->cchTextMax - 1);
1553 else
1554 lstrcpyn(pItem->pszText, (LPCTSTR)name, pItem->cchTextMax - 1);
1555 }
1556
1557 void CGitLogListBase::OnLvnGetdispinfoLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1558 {
1559 NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
1560
1561 // Create a pointer to the item
1562 LV_ITEM* pItem = &(pDispInfo)->item;
1563
1564 // Do the list need text information?
1565 if (!(pItem->mask & LVIF_TEXT))
1566 return;
1567
1568 // By default, clear text buffer.
1569 lstrcpyn(pItem->pszText, L"", pItem->cchTextMax - 1);
1570
1571 bool bOutOfRange = pItem->iItem >= ShownCountWithStopped();
1572
1573 *pResult = 0;
1574 if (m_bNoDispUpdates || bOutOfRange)
1575 return;
1576
1577 // Which item number?
1578 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(pItem->iItem);
1579
1580 CString temp;
1581 if(m_IsOldFirst)
1582 temp.Format(L"%d", pItem->iItem + 1);
1583 else
1584 temp.Format(L"%zu", m_arShownList.size() - pItem->iItem);
1585
1586 if (!pLogEntry)
1587 return;
1588
1589 // Which column?
1590 switch (pItem->iSubItem)
1591 {
1592 case LOGLIST_GRAPH: //Graphic
1593 break;
1594 case LOGLIST_REBASE:
1595 if (m_IsRebaseReplaceGraph)
1596 lstrcpyn(pItem->pszText, GetRebaseActionName(pLogEntry->GetRebaseAction() & LOGACTIONS_REBASE_MODE_MASK), pItem->cchTextMax - 1);
1597 break;
1598 case LOGLIST_ACTION: //action -- no text in the column
1599 break;
1600 case LOGLIST_HASH:
1601 lstrcpyn(pItem->pszText, pLogEntry->m_CommitHash.ToString(), pItem->cchTextMax - 1);
1602 break;
1603 case LOGLIST_ID:
1604 if (this->m_IsIDReplaceAction)
1605 lstrcpyn(pItem->pszText, temp, pItem->cchTextMax - 1);
1606 break;
1607 case LOGLIST_MESSAGE: //Message
1608 lstrcpyn(pItem->pszText, (LPCTSTR)MessageDisplayStr(pLogEntry), pItem->cchTextMax - 1);
1609 break;
1610 case LOGLIST_AUTHOR: //Author
1611 CopyMailmapProcessedData(m_pMailmap, pItem, pLogEntry->GetAuthorEmail(), pLogEntry->GetAuthorName(), false);
1612 break;
1613 case LOGLIST_DATE: //Date
1614 if (!pLogEntry->m_CommitHash.IsEmpty())
1615 lstrcpyn(pItem->pszText,
1616 CLoglistUtils::FormatDateAndTime(pLogEntry->GetAuthorDate(), m_DateFormat, true, m_bRelativeTimes),
1617 pItem->cchTextMax - 1);
1618 break;
1619
1620 case LOGLIST_EMAIL:
1621 CopyMailmapProcessedData(m_pMailmap, pItem, pLogEntry->GetAuthorEmail(), pLogEntry->GetAuthorName(), true);
1622 break;
1623
1624 case LOGLIST_COMMIT_NAME: //Commit
1625 CopyMailmapProcessedData(m_pMailmap, pItem, pLogEntry->GetCommitterEmail(), pLogEntry->GetCommitterName(), false);
1626 break;
1627
1628 case LOGLIST_COMMIT_EMAIL: //Commit Email
1629 CopyMailmapProcessedData(m_pMailmap, pItem, pLogEntry->GetCommitterEmail(), pLogEntry->GetCommitterName(), true);
1630 break;
1631
1632 case LOGLIST_COMMIT_DATE: //Commit Date
1633 if (!pLogEntry->m_CommitHash.IsEmpty())
1634 lstrcpyn(pItem->pszText,
1635 CLoglistUtils::FormatDateAndTime(pLogEntry->GetCommitterDate(), m_DateFormat, true, m_bRelativeTimes),
1636 pItem->cchTextMax - 1);
1637 break;
1638 case LOGLIST_BUG: //Bug ID
1639 lstrcpyn(pItem->pszText, (LPCTSTR)this->m_ProjectProperties.FindBugID(pLogEntry->GetSubjectBody()), pItem->cchTextMax - 1);
1640 break;
1641 case LOGLIST_SVNREV: //SVN revision
1642 lstrcpyn(pItem->pszText, (LPCTSTR)FindSVNRev(pLogEntry->GetSubjectBody()), pItem->cchTextMax - 1);
1643 break;
1644
1645 default:
1646 ASSERT(false);
1647 }
1648 }
1649
1650 bool CGitLogListBase::IsOnStash(int index)
1651 {
1652 GitRevLoglist* rev = m_arShownList.SafeGetAt(index);
1653 if (IsStash(rev))
1654 return true;
1655 if (index > 0)
1656 {
1657 GitRevLoglist* preRev = m_arShownList.SafeGetAt(index - 1);
1658 if (IsStash(preRev))
1659 return preRev->m_ParentHash.size() == 2 && preRev->m_ParentHash[1] == rev->m_CommitHash;
1660 }
1661 return false;
1662 }
1663
1664 bool CGitLogListBase::IsStash(const GitRev * pSelLogEntry)
1665 {
1666 auto refList = m_HashMap.find(pSelLogEntry->m_CommitHash);
1667 if (refList == m_HashMap.cend())
1668 return false;
1669 return find_if((*refList).second, [](const auto& ref) { return ref == L"refs/stash"; }) != (*refList).second.cend();
1670 }
1671
1672 bool CGitLogListBase::IsBisect(const GitRev * pSelLogEntry)
1673 {
1674 auto refList = m_HashMap.find(pSelLogEntry->m_CommitHash);
1675 if (refList == m_HashMap.cend())
1676 return false;
1677 return find_if((*refList).second, [](const auto& ref) { return CStringUtils::StartsWith(ref, L"refs/bisect/"); }) != (*refList).second.cend();
1678 }
1679
1680 void CGitLogListBase::GetParentHashes(GitRev *pRev, GIT_REV_LIST &parentHash)
1681 {
1682 if (pRev->m_ParentHash.empty())
1683 {
1684 if (pRev->GetParentFromHash(pRev->m_CommitHash))
1685 MessageBox(pRev->GetLastErr(), L"TortoiseGit", MB_ICONERROR);
1686 }
1687 parentHash = pRev->m_ParentHash;
1688 }
1689
1690 void CGitLogListBase::OnContextMenu(CWnd* pWnd, CPoint point)
1691 {
1692 __super::OnContextMenu(pWnd, point);
1693
1694 if (pWnd != this)
1695 return;
1696
1697 int selIndex = GetSelectionMark();
1698 if (selIndex < 0)
1699 return; // nothing selected, nothing to do with a context menu
1700
1701 // if the user selected the info text telling about not all revisions shown due to
1702 // the "stop on copy/rename" option, we also don't show the context menu
1703 if (m_bStrictStopped && selIndex == (int)m_arShownList.size())
1704 return;
1705
1706 // if the context menu is invoked through the keyboard, we have to use
1707 // a calculated position on where to anchor the menu on
1708 if ((point.x == -1) && (point.y == -1))
1709 {
1710 CRect rect;
1711 GetItemRect(selIndex, &rect, LVIR_LABEL);
1712 ClientToScreen(&rect);
1713 point = rect.CenterPoint();
1714 }
1715 m_nSearchIndex = selIndex;
1716
1717 bool showExtendedMenu = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
1718
1719 POSITION pos = GetFirstSelectedItemPosition();
1720 int FirstSelect = GetNextSelectedItem(pos);
1721 if (FirstSelect < 0)
1722 return;
1723
1724 GitRevLoglist* pSelLogEntry = m_arShownList.SafeGetAt(FirstSelect);
1725 if (pSelLogEntry == nullptr)
1726 return;
1727
1728 int LastSelect = -1;
1729 UINT selectedCount = 1;
1730 while (pos)
1731 {
1732 LastSelect = GetNextSelectedItem(pos);
1733 ++selectedCount;
1734 }
1735
1736 ASSERT(GetSelectedCount() == selectedCount);
1737
1738 #if 0
1739 GitRev revSelected = pSelLogEntry->Rev;
1740 GitRev revPrevious = git_revnum_t(revSelected)-1;
1741 if ((pSelLogEntry->pArChangedPaths)&&(pSelLogEntry->pArChangedPaths->GetCount() <= 2))
1742 {
1743 for (int i=0; i<pSelLogEntry->pArChangedPaths->GetCount(); ++i)
1744 {
1745 LogChangedPath * changedpath = (LogChangedPath *)pSelLogEntry->pArChangedPaths->SafeGetAt(i);
1746 if (changedpath->lCopyFromRev)
1747 revPrevious = changedpath->lCopyFromRev;
1748 }
1749 }
1750 GitRev revSelected2;
1751 if (pos)
1752 {
1753 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1754 revSelected2 = pLogEntry->Rev;
1755 }
1756 bool bAllFromTheSameAuthor = true;
1757 CString firstAuthor;
1758 CLogDataVector selEntries;
1759 GitRev revLowest, revHighest;
1760 GitRevRangeArray revisionRanges;
1761 {
1762 POSITION pos = GetFirstSelectedItemPosition();
1763 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1764 revisionRanges.AddRevision(pLogEntry->Rev);
1765 selEntries.push_back(pLogEntry);
1766 firstAuthor = pLogEntry->sAuthor;
1767 revLowest = pLogEntry->Rev;
1768 revHighest = pLogEntry->Rev;
1769 while (pos)
1770 {
1771 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1772 revisionRanges.AddRevision(pLogEntry->Rev);
1773 selEntries.push_back(pLogEntry);
1774 if (firstAuthor.Compare(pLogEntry->sAuthor))
1775 bAllFromTheSameAuthor = false;
1776 revLowest = (git_revnum_t(pLogEntry->Rev) > git_revnum_t(revLowest) ? revLowest : pLogEntry->Rev);
1777 revHighest = (git_revnum_t(pLogEntry->Rev) < git_revnum_t(revHighest) ? revHighest : pLogEntry->Rev);
1778 }
1779 }
1780
1781 #endif
1782
1783 //entry is selected, now show the popup menu
1784 CIconMenu popup;
1785 CIconMenu subbranchmenu, submenu, gnudiffmenu, diffmenu, blamemenu, revertmenu;
1786
1787 if (popup.CreatePopupMenu())
1788 {
1789 bool isHeadCommit = (pSelLogEntry->m_CommitHash == m_HeadHash);
1790 CString currentBranch = L"refs/heads/" + g_Git.GetCurrentBranch();
1791 CTGitPath workingTree(g_Git.m_CurrentDir);
1792 bool isMergeActive = workingTree.IsMergeActive();
1793 bool isBisectActive = workingTree.IsBisectActive();
1794 bool isStash = IsOnStash(FirstSelect);
1795 GIT_REV_LIST parentHash;
1796 GetParentHashes(pSelLogEntry, parentHash);
1797
1798 if (m_ContextMenuMask & GetContextMenuBit(ID_REBASE_PICK) && !(pSelLogEntry->GetRebaseAction() & (LOGACTIONS_REBASE_CURRENT | LOGACTIONS_REBASE_DONE)))
1799 popup.AppendMenuIcon(ID_REBASE_PICK, IDS_REBASE_PICK, IDI_PICK);
1800
1801 if (m_ContextMenuMask & GetContextMenuBit(ID_REBASE_SQUASH) && !(pSelLogEntry->GetRebaseAction() & (LOGACTIONS_REBASE_CURRENT | LOGACTIONS_REBASE_DONE)) && FirstSelect != GetItemCount() - 1 && LastSelect != GetItemCount() - 1 && (m_bIsCherryPick || pSelLogEntry->ParentsCount() == 1))
1802 popup.AppendMenuIcon(ID_REBASE_SQUASH, IDS_REBASE_SQUASH, IDI_SQUASH);
1803
1804 if (m_ContextMenuMask & GetContextMenuBit(ID_REBASE_EDIT) && !(pSelLogEntry->GetRebaseAction() & (LOGACTIONS_REBASE_CURRENT | LOGACTIONS_REBASE_DONE)))
1805 popup.AppendMenuIcon(ID_REBASE_EDIT, IDS_REBASE_EDIT, IDI_EDIT);
1806
1807 if (m_ContextMenuMask & GetContextMenuBit(ID_REBASE_SKIP) && !(pSelLogEntry->GetRebaseAction() & (LOGACTIONS_REBASE_CURRENT | LOGACTIONS_REBASE_DONE)))
1808 popup.AppendMenuIcon(ID_REBASE_SKIP, IDS_REBASE_SKIP, IDI_SKIP);
1809
1810 if (m_ContextMenuMask & (GetContextMenuBit(ID_REBASE_SKIP) | GetContextMenuBit(ID_REBASE_EDIT) | GetContextMenuBit(ID_REBASE_SQUASH) | GetContextMenuBit(ID_REBASE_PICK)) && !(pSelLogEntry->GetRebaseAction() & (LOGACTIONS_REBASE_CURRENT | LOGACTIONS_REBASE_DONE)))
1811 popup.AppendMenu(MF_SEPARATOR, NULL);
1812
1813 if (selectedCount == 1)
1814 {
1815 {
1816 bool requiresSeparator = false;
1817 if( !pSelLogEntry->m_CommitHash.IsEmpty())
1818 {
1819 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPARE) && m_hasWC) // compare revision with WC
1820 {
1821 popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARE, IDI_DIFF);
1822 requiresSeparator = true;
1823 }
1824 }
1825 else
1826 {
1827 if(m_ContextMenuMask&GetContextMenuBit(ID_COMMIT))
1828 {
1829 popup.AppendMenuIcon(ID_COMMIT, IDS_LOG_POPUP_COMMIT, IDI_COMMIT);
1830 requiresSeparator = true;
1831 }
1832 if (isMergeActive && (m_ContextMenuMask & GetContextMenuBit(ID_MERGE_ABORT)))
1833 {
1834 popup.AppendMenuIcon(ID_MERGE_ABORT, IDS_MENUMERGEABORT, IDI_MERGEABORT);
1835 requiresSeparator = true;
1836 }
1837 }
1838
1839 if (m_ContextMenuMask & GetContextMenuBit(ID_BLAMEPREVIOUS))
1840 {
1841 if (parentHash.size() == 1)
1842 {
1843 popup.AppendMenuIcon(ID_BLAMEPREVIOUS, IDS_LOG_POPUP_BLAMEPREVIOUS, IDI_BLAME);
1844 requiresSeparator = true;
1845 }
1846 else if (parentHash.size() > 1)
1847 {
1848 blamemenu.CreatePopupMenu();
1849 popup.AppendMenuIcon(ID_BLAMEPREVIOUS, IDS_LOG_POPUP_BLAMEPREVIOUS, IDI_BLAME, blamemenu.m_hMenu);
1850 for (size_t i = 0; i < parentHash.size(); ++i)
1851 {
1852 CString str;
1853 str.Format(IDS_PARENT, i + 1);
1854 blamemenu.AppendMenuIcon(ID_BLAMEPREVIOUS +((i + 1) << 16), str);
1855 }
1856 requiresSeparator = true;
1857 }
1858 }
1859
1860 if(m_ContextMenuMask&GetContextMenuBit(ID_GNUDIFF1) && m_hasWC) // compare with WC, unified
1861 {
1862 if (parentHash.size() == 1)
1863 {
1864 popup.AppendMenuIcon(ID_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF_CH, IDI_DIFF);
1865 requiresSeparator = true;
1866 }
1867 else if (parentHash.size() > 1)
1868 {
1869 gnudiffmenu.CreatePopupMenu();
1870 popup.AppendMenuIcon(ID_GNUDIFF1,IDS_LOG_POPUP_GNUDIFF_PARENT, IDI_DIFF, gnudiffmenu.m_hMenu);
1871
1872 gnudiffmenu.AppendMenuIcon((UINT_PTR)(ID_GNUDIFF1 + (0xFFFF << 16)), CString(MAKEINTRESOURCE(IDS_ALLPARENTS)));
1873 gnudiffmenu.AppendMenuIcon((UINT_PTR)(ID_GNUDIFF1 + (0xFFFE << 16)), CString(MAKEINTRESOURCE(IDS_ONLYMERGEDFILES)));
1874 gnudiffmenu.AppendMenuIcon((UINT_PTR)(ID_GNUDIFF1 + (0xFFFD << 16)), CString(MAKEINTRESOURCE(IDS_DIFFWITHMERGE)));
1875
1876 for (size_t i = 0; i < parentHash.size(); ++i)
1877 {
1878 CString str;
1879 str.Format(IDS_PARENT, i + 1);
1880 gnudiffmenu.AppendMenuIcon(ID_GNUDIFF1+((i+1)<<16),str);
1881 }
1882 requiresSeparator = true;
1883 }
1884 }
1885
1886 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPAREWITHPREVIOUS))
1887 {
1888 if (parentHash.size() == 1)
1889 {
1890 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF);
1891 if (CRegDWORD(L"Software\\TortoiseGit\\DiffByDoubleClickInLog", FALSE))
1892 popup.SetDefaultItem(ID_COMPAREWITHPREVIOUS, FALSE);
1893 requiresSeparator = true;
1894 }
1895 else if (parentHash.size() > 1)
1896 {
1897 diffmenu.CreatePopupMenu();
1898 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF, diffmenu.m_hMenu);
1899 for (size_t i = 0; i < parentHash.size(); ++i)
1900 {
1901 CString str;
1902 str.Format(IDS_PARENT, i + 1);
1903 diffmenu.AppendMenuIcon(ID_COMPAREWITHPREVIOUS +((i+1)<<16),str);
1904 if (i == 0 && CRegDWORD(L"Software\\TortoiseGit\\DiffByDoubleClickInLog", FALSE))
1905 {
1906 popup.SetDefaultItem(ID_COMPAREWITHPREVIOUS, FALSE);
1907 diffmenu.SetDefaultItem((UINT)(ID_COMPAREWITHPREVIOUS + ((i + 1) << 16)), FALSE);
1908 }
1909 }
1910 requiresSeparator = true;
1911 }
1912 }
1913
1914 if(m_ContextMenuMask&GetContextMenuBit(ID_BLAME))
1915 {
1916 popup.AppendMenuIcon(ID_BLAME, IDS_LOG_POPUP_BLAME, IDI_BLAME);
1917 requiresSeparator = true;
1918 }
1919
1920 if (requiresSeparator)
1921 {
1922 popup.AppendMenu(MF_SEPARATOR, NULL);
1923 requiresSeparator = false;
1924 }
1925
1926 if (pSelLogEntry->m_CommitHash.IsEmpty() && !isMergeActive)
1927 {
1928 if(m_ContextMenuMask&GetContextMenuBit(ID_STASH_SAVE))
1929 {
1930 popup.AppendMenuIcon(ID_STASH_SAVE, IDS_MENUSTASHSAVE, IDI_COMMIT);
1931 requiresSeparator = true;
1932 }
1933 }
1934
1935 if ((pSelLogEntry->m_CommitHash.IsEmpty() || isStash) && workingTree.HasStashDir())
1936 {
1937 if (m_ContextMenuMask&GetContextMenuBit(ID_STASH_POP))
1938 {
1939 popup.AppendMenuIcon(ID_STASH_POP, IDS_MENUSTASHPOP, IDI_RELOCATE);
1940 requiresSeparator = true;
1941 }
1942
1943 if (m_ContextMenuMask&GetContextMenuBit(ID_STASH_LIST))
1944 {
1945 popup.AppendMenuIcon(ID_STASH_LIST, IDS_MENUSTASHLIST, IDI_LOG);
1946 requiresSeparator = true;
1947 }
1948 }
1949
1950 if (requiresSeparator)
1951 {
1952 popup.AppendMenu(MF_SEPARATOR, NULL);
1953 requiresSeparator = false;
1954 }
1955
1956 if (isBisectActive)
1957 {
1958 GitRevLoglist* pFirstEntry = m_arShownList.SafeGetAt(FirstSelect);
1959 if (m_ContextMenuMask&GetContextMenuBit(ID_BISECTGOOD) && !IsBisect(pFirstEntry))
1960 {
1961 popup.AppendMenuIcon(ID_BISECTGOOD, IDS_MENUBISECTGOOD, IDI_THUMB_UP);
1962 requiresSeparator = true;
1963 }
1964
1965 if (m_ContextMenuMask&GetContextMenuBit(ID_BISECTBAD) && !IsBisect(pFirstEntry))
1966 {
1967 popup.AppendMenuIcon(ID_BISECTBAD, IDS_MENUBISECTBAD, IDI_THUMB_DOWN);
1968 requiresSeparator = true;
1969 }
1970 if (m_ContextMenuMask&GetContextMenuBit(ID_BISECTSKIP) && !IsBisect(pFirstEntry))
1971 {
1972 popup.AppendMenuIcon(ID_BISECTSKIP, IDS_MENUBISECTSKIP, IDI_BISECT);
1973 requiresSeparator = true;
1974 }
1975 }
1976
1977 if (pSelLogEntry->m_CommitHash.IsEmpty() && isBisectActive)
1978 {
1979 if (m_ContextMenuMask&GetContextMenuBit(ID_BISECTRESET))
1980 {
1981 popup.AppendMenuIcon(ID_BISECTRESET, IDS_MENUBISECTRESET, IDI_BISECT_RESET);
1982 requiresSeparator = true;
1983 }
1984 }
1985
1986 if (requiresSeparator)
1987 {
1988 popup.AppendMenu(MF_SEPARATOR, NULL);
1989 requiresSeparator = false;
1990 }
1991
1992 if (pSelLogEntry->m_CommitHash.IsEmpty())
1993 {
1994 if (m_ContextMenuMask & GetContextMenuBit(ID_PULL) && !isMergeActive)
1995 popup.AppendMenuIcon(ID_PULL, IDS_MENUPULL, IDI_PULL);
1996
1997 if(m_ContextMenuMask&GetContextMenuBit(ID_FETCH))
1998 popup.AppendMenuIcon(ID_FETCH, IDS_MENUFETCH, IDI_PULL);
1999
2000 if ((m_ContextMenuMask & GetContextMenuBit(ID_SUBMODULE_UPDATE)) && workingTree.HasSubmodules())
2001 popup.AppendMenuIcon(ID_SUBMODULE_UPDATE, IDS_PROC_SYNC_SUBKODULEUPDATE, IDI_UPDATE);
2002
2003 popup.AppendMenu(MF_SEPARATOR, NULL);
2004
2005 if (m_ContextMenuMask & GetContextMenuBit(ID_CLEANUP))
2006 popup.AppendMenuIcon(ID_CLEANUP, IDS_MENUCLEANUP, IDI_CLEANUP);
2007
2008 popup.AppendMenu(MF_SEPARATOR, NULL);
2009 }
2010 }
2011
2012 // if (!m_ProjectProperties.sWebViewerRev.IsEmpty())
2013 // {
2014 // popup.AppendMenuIcon(ID_VIEWREV, IDS_LOG_POPUP_VIEWREV);
2015 // }
2016 // if (!m_ProjectProperties.sWebViewerPathRev.IsEmpty())
2017 // {
2018 // popup.AppendMenuIcon(ID_VIEWPATHREV, IDS_LOG_POPUP_VIEWPATHREV);
2019 // }
2020 // if ((!m_ProjectProperties.sWebViewerPathRev.IsEmpty())||
2021 // (!m_ProjectProperties.sWebViewerRev.IsEmpty()))
2022 // {
2023 // popup.AppendMenu(MF_SEPARATOR, NULL);
2024 // }
2025
2026 CString str;
2027 //if (m_hasWC)
2028 // popup.AppendMenuIcon(ID_REVERTTOREV, IDS_LOG_POPUP_REVERTTOREV, IDI_REVERT);
2029
2030 if(!pSelLogEntry->m_CommitHash.IsEmpty())
2031 {
2032 if ((m_ContextMenuMask & GetContextMenuBit(ID_LOG)) && selectedCount == 1)
2033 popup.AppendMenuIcon(ID_LOG, IDS_LOG_POPUP_LOG, IDI_LOG);
2034
2035 if (m_ContextMenuMask&GetContextMenuBit(ID_REPOBROWSE))
2036 popup.AppendMenuIcon(ID_REPOBROWSE, IDS_LOG_BROWSEREPO, IDI_REPOBROWSE);
2037
2038 str.Format(IDS_LOG_POPUP_MERGEREV, (LPCTSTR)g_Git.GetCurrentBranch());
2039
2040 if (m_ContextMenuMask&GetContextMenuBit(ID_MERGEREV) && !isHeadCommit && m_hasWC && !isMergeActive && !isStash)
2041 {
2042 popup.AppendMenuIcon(ID_MERGEREV, str, IDI_MERGE);
2043
2044 size_t index = (size_t)-1;
2045 CGit::REF_TYPE type = CGit::REF_TYPE::UNKNOWN;
2046 if (IsMouseOnRefLabelFromPopupMenu(pSelLogEntry, point, type, nullptr, &index))
2047 popup.SetMenuItemData(ID_MERGEREV, (ULONG_PTR)&m_HashMap[pSelLogEntry->m_CommitHash][index]);
2048 }
2049
2050 str.Format(IDS_RESET_TO_THIS_FORMAT, (LPCTSTR)g_Git.GetCurrentBranch());
2051
2052 if (m_ContextMenuMask&GetContextMenuBit(ID_RESET) && m_hasWC && !isStash)
2053 popup.AppendMenuIcon(ID_RESET,str,IDI_REVERT);
2054
2055
2056 // Add Switch Branch express Menu
2057 if( this->m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.end()
2058 && (m_ContextMenuMask&GetContextMenuBit(ID_SWITCHBRANCH) && m_hasWC && !isStash)
2059 )
2060 {
2061 std::vector<const CString*> branchs;
2062 auto addCheck = [&](const CString& ref)
2063 {
2064 if (!CStringUtils::StartsWith(ref, L"refs/heads/") || ref == currentBranch)
2065 return;
2066 branchs.push_back(&ref);
2067 };
2068 size_t index = (size_t)-1;
2069 CGit::REF_TYPE type = CGit::REF_TYPE::UNKNOWN;
2070 if (IsMouseOnRefLabelFromPopupMenu(pSelLogEntry, point, type, nullptr, &index))
2071 addCheck(m_HashMap[pSelLogEntry->m_CommitHash][index]);
2072 else
2073 for_each(m_HashMap[pSelLogEntry->m_CommitHash], addCheck);
2074
2075 CString str2;
2076 str2.LoadString(IDS_SWITCH_BRANCH);
2077
2078 if(branchs.size() == 1)
2079 {
2080 str2 += L' ';
2081 str2 += L'"' + branchs[0]->Mid((int)wcslen(L"refs/heads/")) + L'"';
2082 popup.AppendMenuIcon(ID_SWITCHBRANCH, str2, IDI_SWITCH);
2083
2084 popup.SetMenuItemData(ID_SWITCHBRANCH,(ULONG_PTR)branchs[0]);
2085
2086 }
2087 else if(branchs.size() > 1)
2088 {
2089 subbranchmenu.CreatePopupMenu();
2090 for (size_t i = 0 ; i < branchs.size(); ++i)
2091 {
2092 if (*branchs[i] != currentBranch)
2093 {
2094 subbranchmenu.AppendMenuIcon(ID_SWITCHBRANCH+(i<<16), branchs[i]->Mid(11));
2095 subbranchmenu.SetMenuItemData(ID_SWITCHBRANCH+(i<<16), (ULONG_PTR) branchs[i]);
2096 }
2097 }
2098
2099 popup.AppendMenuIcon(ID_SWITCHBRANCH, str2, IDI_SWITCH, subbranchmenu.m_hMenu);
2100 }
2101 }
2102
2103 if (m_ContextMenuMask&GetContextMenuBit(ID_SWITCHTOREV) && !isHeadCommit && m_hasWC && !isStash)
2104 {
2105 popup.AppendMenuIcon(ID_SWITCHTOREV, IDS_SWITCH_TO_THIS, IDI_SWITCH);
2106 size_t index = (size_t)-1;
2107 CGit::REF_TYPE type = CGit::REF_TYPE::UNKNOWN;
2108 if (IsMouseOnRefLabelFromPopupMenu(pSelLogEntry, point, type, nullptr, &index))
2109 popup.SetMenuItemData(ID_SWITCHTOREV, (ULONG_PTR)&m_HashMap[pSelLogEntry->m_CommitHash][index]);
2110 }
2111
2112 if (m_ContextMenuMask&GetContextMenuBit(ID_CREATE_BRANCH) && !isStash)
2113 {
2114 popup.AppendMenuIcon(ID_CREATE_BRANCH, IDS_CREATE_BRANCH_AT_THIS, IDI_COPY);
2115
2116 size_t index = (size_t)-1;
2117 CGit::REF_TYPE type = CGit::REF_TYPE::REMOTE_BRANCH;
2118 if (IsMouseOnRefLabelFromPopupMenu(pSelLogEntry, point, type, nullptr, &index))
2119 popup.SetMenuItemData(ID_CREATE_BRANCH, (ULONG_PTR)&m_HashMap[pSelLogEntry->m_CommitHash][index]);
2120 }
2121
2122 if (m_ContextMenuMask&GetContextMenuBit(ID_CREATE_TAG) && !isStash)
2123 popup.AppendMenuIcon(ID_CREATE_TAG,IDS_CREATE_TAG_AT_THIS , IDI_TAG);
2124
2125 str.Format(IDS_REBASE_THIS_FORMAT, (LPCTSTR)g_Git.GetCurrentBranch());
2126
2127 if (pSelLogEntry->m_CommitHash != m_HeadHash && m_hasWC && !isMergeActive && !isStash)
2128 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_TO_VERSION))
2129 popup.AppendMenuIcon(ID_REBASE_TO_VERSION, str , IDI_REBASE);
2130
2131 if(m_ContextMenuMask&GetContextMenuBit(ID_EXPORT))
2132 popup.AppendMenuIcon(ID_EXPORT,IDS_EXPORT_TO_THIS, IDI_EXPORT);
2133
2134 if (m_ContextMenuMask&GetContextMenuBit(ID_REVERTREV) && m_hasWC && !isMergeActive && !isStash)
2135 {
2136 if (parentHash.size() == 1)
2137 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREV, IDI_REVERT);
2138 else if (parentHash.size() > 1)
2139 {
2140 revertmenu.CreatePopupMenu();
2141 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREV, IDI_REVERT, revertmenu.m_hMenu);
2142
2143 for (size_t i = 0; i < parentHash.size(); ++i)
2144 {
2145 CString str2;
2146 str2.Format(IDS_PARENT, i + 1);
2147 revertmenu.AppendMenuIcon(ID_REVERTREV + ((i + 1) << 16), str2);
2148 }
2149 }
2150 }
2151
2152 if (m_ContextMenuMask&GetContextMenuBit(ID_EDITNOTE) && !isStash)
2153 popup.AppendMenuIcon(ID_EDITNOTE, IDS_EDIT_NOTES, IDI_EDIT);
2154
2155 popup.AppendMenu(MF_SEPARATOR, NULL);
2156 }
2157 }
2158
2159 if(!pSelLogEntry->m_Ref.IsEmpty())
2160 {
2161 popup.AppendMenuIcon(ID_REFLOG_DEL, IDS_REFLOG_DEL, IDI_DELETE);
2162 if (selectedCount == 1 && CStringUtils::StartsWith(pSelLogEntry->m_Ref, L"refs/stash"))
2163 popup.AppendMenuIcon(ID_REFLOG_STASH_APPLY, IDS_MENUSTASHAPPLY, IDI_RELOCATE);
2164 if (selectedCount <= 2)
2165 popup.AppendMenu(MF_SEPARATOR, NULL);
2166 }
2167
2168 if (selectedCount >= 2)
2169 {
2170 bool bAddSeparator = false;
2171 if ((selectedCount == 2) || IsSelectionContinuous())
2172 {
2173 if (m_ContextMenuMask&GetContextMenuBit(ID_COMPARETWO)) // compare two revisions
2174 {
2175 popup.AppendMenuIcon(ID_COMPARETWO, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);
2176 bAddSeparator = true;
2177 }
2178 }
2179
2180 if (selectedCount == 2)
2181 {
2182 if (m_ContextMenuMask&GetContextMenuBit(ID_GNUDIFF2) && m_hasWC) // compare two revisions, unified
2183 {
2184 popup.AppendMenuIcon(ID_GNUDIFF2, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
2185 bAddSeparator = true;
2186 }
2187
2188 if (!pSelLogEntry->m_CommitHash.IsEmpty())
2189 {
2190 CString firstSelHash = pSelLogEntry->m_CommitHash.ToString().Left(g_Git.GetShortHASHLength());
2191 GitRevLoglist* pLastEntry = m_arShownList.SafeGetAt(LastSelect);
2192 CString lastSelHash = pLastEntry->m_CommitHash.ToString().Left(g_Git.GetShortHASHLength());
2193 CString menu;
2194 menu.Format(IDS_SHOWLOG_OF, (LPCTSTR)(lastSelHash + L".." + firstSelHash));
2195 popup.AppendMenuIcon(ID_LOG_VIEWRANGE, menu, IDI_LOG);
2196 menu.Format(IDS_SHOWLOG_OF, (LPCTSTR)(lastSelHash + L"..." + firstSelHash));
2197 popup.AppendMenuIcon(ID_LOG_VIEWRANGE_REACHABLEFROMONLYONE, menu, IDI_LOG);
2198 bAddSeparator = true;
2199 }
2200 }
2201
2202 if ((m_ContextMenuMask & GetContextMenuBit(ID_COMPARETWOCOMMITCHANGES)) && selectedCount == 2 && !IsSelectionContinuous())
2203 {
2204 bAddSeparator = true;
2205 popup.AppendMenuIcon(ID_COMPARETWOCOMMITCHANGES, IDS_LOG_POPUP_COMPARECHANGESET, IDI_DIFF);
2206 }
2207
2208 if (bAddSeparator)
2209 {
2210 popup.AppendMenu(MF_SEPARATOR, NULL);
2211 bAddSeparator = false;
2212 }
2213
2214 if (m_ContextMenuMask&GetContextMenuBit(ID_REVERTREV) && m_hasWC && !isMergeActive)
2215 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREVS, IDI_REVERT);
2216
2217 if (bAddSeparator)
2218 popup.AppendMenu(MF_SEPARATOR, NULL);
2219 }
2220
2221 if (selectedCount > 1 && isBisectActive && (m_ContextMenuMask & GetContextMenuBit(ID_BISECTSKIP)) && !IsBisect(pSelLogEntry))
2222 {
2223 popup.AppendMenuIcon(ID_BISECTSKIP, IDS_MENUBISECTSKIP, IDI_BISECT);
2224 popup.AppendMenu(MF_SEPARATOR, NULL);
2225 }
2226
2227 if (!pSelLogEntry->m_CommitHash.IsEmpty())
2228 {
2229 bool bAddSeparator = false;
2230 if (selectedCount >= 2 && IsSelectionContinuous())
2231 {
2232 if (m_ContextMenuMask&GetContextMenuBit(ID_COMBINE_COMMIT) && m_hasWC && !isMergeActive)
2233 {
2234 CString head;
2235 int headindex;
2236 headindex = this->GetHeadIndex();
2237 if(headindex>=0 && LastSelect >= headindex && FirstSelect >= headindex)
2238 {
2239 head.Format(L"HEAD~%d", FirstSelect - headindex);
2240 CGitHash hashFirst;
2241 int ret = g_Git.GetHash(hashFirst, head);
2242 head.Format(L"HEAD~%d",LastSelect-headindex);
2243 CGitHash hash;
2244 ret = ret || g_Git.GetHash(hash, head);
2245 GitRevLoglist* pFirstEntry = m_arShownList.SafeGetAt(FirstSelect);
2246 GitRevLoglist* pLastEntry = m_arShownList.SafeGetAt(LastSelect);
2247 if (!ret && pFirstEntry->m_CommitHash == hashFirst && pLastEntry->m_CommitHash == hash)
2248 {
2249 popup.AppendMenuIcon(ID_COMBINE_COMMIT,IDS_COMBINE_TO_ONE,IDI_COMBINE);
2250 bAddSeparator = true;
2251 }
2252 }
2253 }
2254 }
2255 if (m_ContextMenuMask&GetContextMenuBit(ID_CHERRY_PICK) && !isHeadCommit && m_hasWC && !isMergeActive) {
2256 if (selectedCount >= 2)
2257 popup.AppendMenuIcon(ID_CHERRY_PICK, IDS_CHERRY_PICK_VERSIONS, IDI_EXPORT);
2258 else
2259 popup.AppendMenuIcon(ID_CHERRY_PICK, IDS_CHERRY_PICK_VERSION, IDI_EXPORT);
2260 bAddSeparator = true;
2261 }
2262
2263 if (selectedCount <= 2 || (IsSelectionContinuous() && !isStash))
2264 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_PATCH)) {
2265 popup.AppendMenuIcon(ID_CREATE_PATCH, IDS_CREATE_PATCH, IDI_PATCH);
2266 bAddSeparator = true;
2267 }
2268
2269 if (bAddSeparator)
2270 popup.AppendMenu(MF_SEPARATOR, NULL);
2271 }
2272
2273 if (m_hasWC && !isMergeActive && !isStash && (m_ContextMenuMask & GetContextMenuBit(ID_BISECTSTART)) && selectedCount == 2 && !m_arShownList.SafeGetAt(FirstSelect)->m_CommitHash.IsEmpty() && !isBisectActive)
2274 {
2275 popup.AppendMenuIcon(ID_BISECTSTART, IDS_MENUBISECTSTART, IDI_BISECT);
2276 popup.AppendMenu(MF_SEPARATOR, NULL);
2277 }
2278
2279 if (selectedCount == 1)
2280 {
2281 bool bAddSeparator = false;
2282 if ((m_ContextMenuMask & GetContextMenuBit(ID_PUSH)) && ((!isStash && m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.cend()) || showExtendedMenu))
2283 {
2284 // show the push-option only if the log entry has an associated local branch
2285 bool isLocal = find_if(m_HashMap[pSelLogEntry->m_CommitHash], [](const CString& ref) { return CStringUtils::StartsWith(ref, L"refs/heads/") || CStringUtils::StartsWith(ref, L"refs/tags/"); }) != m_HashMap[pSelLogEntry->m_CommitHash].cend();
2286 if (isLocal || showExtendedMenu)
2287 {
2288 CString str;
2289 str.LoadString(IDS_MENUPUSH);
2290
2291 CString branch;
2292 size_t index = (size_t)-1;
2293 CGit::REF_TYPE type = CGit::REF_TYPE::UNKNOWN;
2294 if (IsMouseOnRefLabelFromPopupMenu(pSelLogEntry, point, type, &branch, &index))
2295 if (type == CGit::REF_TYPE::LOCAL_BRANCH || type == CGit::REF_TYPE::ANNOTATED_TAG || type == CGit::REF_TYPE::TAG)
2296 str.Insert(str.Find(L'.'), L" \"" + branch + L'"');
2297
2298 popup.AppendMenuIcon(ID_PUSH, str, IDI_PUSH);
2299
2300 if (index != (size_t)-1 && index < m_HashMap[pSelLogEntry->m_CommitHash].size())
2301 popup.SetMenuItemData(ID_PUSH, (ULONG_PTR)&m_HashMap[pSelLogEntry->m_CommitHash][index]);
2302
2303 if (m_ContextMenuMask & GetContextMenuBit(ID_SVNDCOMMIT) && workingTree.HasGitSVNDir())
2304 popup.AppendMenuIcon(ID_SVNDCOMMIT, IDS_MENUSVNDCOMMIT, IDI_COMMIT);
2305
2306 bAddSeparator = true;
2307 }
2308 }
2309 if (m_ContextMenuMask & GetContextMenuBit(ID_PULL) && isHeadCommit && !isMergeActive && m_hasWC)
2310 {
2311 popup.AppendMenuIcon(ID_PULL, IDS_MENUPULL, IDI_PULL);
2312 bAddSeparator = true;
2313 }
2314
2315
2316 if(m_ContextMenuMask &GetContextMenuBit(ID_DELETE))
2317 {
2318 if( this->m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.end() )
2319 {
2320 std::vector<const CString*> branchs;
2321 auto addCheck = [&](const CString& ref)
2322 {
2323 if (ref == currentBranch)
2324 return;
2325 branchs.push_back(&ref);
2326 };
2327 size_t index = (size_t)-1;
2328 CGit::REF_TYPE type = CGit::REF_TYPE::UNKNOWN;
2329 if (IsMouseOnRefLabelFromPopupMenu(pSelLogEntry, point, type, nullptr, &index))
2330 addCheck(m_HashMap[pSelLogEntry->m_CommitHash][index]);
2331 else
2332 for_each(m_HashMap[pSelLogEntry->m_CommitHash], addCheck);
2333
2334 CString str;
2335 if (branchs.size() == 1)
2336 {
2337 str.LoadString(IDS_DELETE_BRANCHTAG_SHORT);
2338 str += L' ';
2339 str += *branchs[0];
2340 popup.AppendMenuIcon(ID_DELETE, str, IDI_DELETE);
2341 popup.SetMenuItemData(ID_DELETE, (ULONG_PTR)branchs[0]);
2342 bAddSeparator = true;
2343 }
2344 else if (branchs.size() > 1)
2345 {
2346 str.LoadString(IDS_DELETE_BRANCHTAG);
2347 submenu.CreatePopupMenu();
2348 for (size_t i = 0; i < branchs.size(); ++i)
2349 {
2350 submenu.AppendMenuIcon(ID_DELETE + (i << 16), *branchs[i]);
2351 submenu.SetMenuItemData(ID_DELETE + (i << 16), (ULONG_PTR)branchs[i]);
2352 }
2353 submenu.AppendMenuIcon(ID_DELETE + (branchs.size() << 16), IDS_ALL);
2354 submenu.SetMenuItemData(ID_DELETE + (branchs.size() << 16), (ULONG_PTR)MAKEINTRESOURCE(IDS_ALL));
2355
2356 popup.AppendMenuIcon(ID_DELETE,str, IDI_DELETE, submenu.m_hMenu);
2357 bAddSeparator = true;
2358 }
2359 }
2360 } // m_ContextMenuMask &GetContextMenuBit(ID_DELETE)
2361 if (bAddSeparator)
2362 popup.AppendMenu(MF_SEPARATOR, NULL);
2363 } // selectedCount == 1
2364
2365 CIconMenu clipSubMenu;
2366 if (!clipSubMenu.CreatePopupMenu())
2367 return;
2368 if (m_ContextMenuMask & GetContextMenuBit(ID_COPYCLIPBOARD))
2369 {
2370 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDFULL, IDS_LOG_POPUP_CLIPBOARD_FULL, IDI_COPYCLIP);
2371 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDFULLNOPATHS, IDS_LOG_POPUP_CLIPBOARD_FULLNOPATHS, IDI_COPYCLIP);
2372 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDHASH, IDS_LOG_HASH, IDI_COPYCLIP);
2373 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDAUTHORSFULL, IDS_LOG_POPUP_CLIPBOARD_AUTHORSFULL, IDI_COPYCLIP);
2374 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDAUTHORSNAME, IDS_LOG_POPUP_CLIPBOARD_AUTHORSNAME, IDI_COPYCLIP);
2375 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDAUTHORSEMAIL, IDS_LOG_POPUP_CLIPBOARD_AUTHORSEMAIL, IDI_COPYCLIP);
2376 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDSUBJECTS, IDS_LOG_POPUP_CLIPBOARD_SUBJECTS, IDI_COPYCLIP);
2377 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDMESSAGES, IDS_LOG_POPUP_CLIPBOARD_MSGS, IDI_COPYCLIP);
2378 if (m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.cend() && selectedCount == 1)
2379 {
2380 clipSubMenu.AppendMenuIcon(ID_COPYCLIPBOARDBRANCHTAG, IDS_LOG_POPUP_CLIPBOARD_TAGBRANCHES, IDI_COPYCLIP);
2381 size_t index = (size_t)-1;
2382 CGit::REF_TYPE type = CGit::REF_TYPE::UNKNOWN;
2383 if (IsMouseOnRefLabelFromPopupMenu(pSelLogEntry, point, type, nullptr, &index))
2384 clipSubMenu.SetMenuItemData(ID_COPYCLIPBOARDBRANCHTAG, (ULONG_PTR)&m_HashMap[pSelLogEntry->m_CommitHash][index]);
2385 }
2386
2387 CString temp;
2388 temp.LoadString(IDS_LOG_POPUP_COPYTOCLIPBOARD);
2389 popup.InsertMenu((UINT)-1, MF_BYPOSITION | MF_POPUP, (UINT_PTR)clipSubMenu.m_hMenu, temp);
2390 }
2391
2392 if(m_ContextMenuMask&GetContextMenuBit(ID_FINDENTRY))
2393 popup.AppendMenuIcon(ID_FINDENTRY, IDS_LOG_POPUP_FIND, IDI_FILTEREDIT);
2394
2395 if (selectedCount == 1 && (m_ContextMenuMask & GetContextMenuBit(ID_SHOWBRANCHES)) && !pSelLogEntry->m_CommitHash.IsEmpty())
2396 popup.AppendMenuIcon(ID_SHOWBRANCHES, IDS_LOG_POPUP_SHOWBRANCHES, IDI_SHOWBRANCHES);
2397
2398 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
2399 // DialogEnableWindow(IDOK, FALSE);
2400 // SetPromptApp(&theApp);
2401
2402 this->ContextMenuAction(cmd, FirstSelect, LastSelect, &popup);
2403
2404 // EnableOKButton();
2405 } // if (popup.CreatePopupMenu())
2406 }
2407
2408 bool CGitLogListBase::IsSelectionContinuous()
2409 {
2410 if ( GetSelectedCount()==1 )
2411 {
2412 // if only one revision is selected, the selection is of course
2413 // continuous
2414 return true;
2415 }
2416
2417 POSITION pos = GetFirstSelectedItemPosition();
2418 bool bContinuous = (m_arShownList.size() == m_logEntries.size());
2419 if (bContinuous)
2420 {
2421 int itemindex = GetNextSelectedItem(pos);
2422 while (pos)
2423 {
2424 int nextindex = GetNextSelectedItem(pos);
2425 if (nextindex - itemindex > 1)
2426 {
2427 bContinuous = false;
2428 break;
2429 }
2430 itemindex = nextindex;
2431 }
2432 }
2433 return bContinuous;
2434 }
2435
2436 void CGitLogListBase::CopySelectionToClipBoard(int toCopy)
2437 {
2438 CString sClipdata;
2439 POSITION pos = GetFirstSelectedItemPosition();
2440 if (pos)
2441 {
2442 CString sRev;
2443 sRev.LoadString(IDS_LOG_REVISION);
2444 CString sAuthor;
2445 sAuthor.LoadString(IDS_LOG_AUTHOR);
2446 CString sDate;
2447 sDate.LoadString(IDS_LOG_DATE);
2448 CString sMessage;
2449 sMessage.LoadString(IDS_LOG_MESSAGE);
2450 CString from(MAKEINTRESOURCE(IDS_STATUSLIST_FROM));
2451 bool first = true;
2452 while (pos)
2453 {
2454 CString sLogCopyText;
2455 CString sPaths;
2456 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(GetNextSelectedItem(pos));
2457
2458 if (toCopy == ID_COPYCLIPBOARDFULL)
2459 {
2460 sPaths = L"----\r\n";
2461 for (int cpPathIndex = 0; cpPathIndex<pLogEntry->GetFiles(this).GetCount(); ++cpPathIndex)
2462 {
2463 sPaths += ((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).GetActionName() + L": " + pLogEntry->GetFiles(this)[cpPathIndex].GetGitPathString();
2464 if (((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).m_Action & (CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_COPY) && !((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).GetGitOldPathString().IsEmpty())
2465 {
2466 sPaths += L' ';
2467 sPaths.AppendFormat(from, (LPCTSTR)((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).GetGitOldPathString());
2468 }
2469 sPaths += L"\r\n";
2470 }
2471 sPaths.Trim();
2472 sPaths += L"\r\n";
2473 }
2474
2475 if (toCopy == ID_COPYCLIPBOARDFULL || toCopy == ID_COPYCLIPBOARDFULLNOPATHS)
2476 {
2477 CString sNotesTags;
2478 if (!pLogEntry->m_Notes.IsEmpty())
2479 {
2480 sNotesTags = L"----\n" + CString(MAKEINTRESOURCE(IDS_NOTES));
2481 sNotesTags += L":\n";
2482 sNotesTags += pLogEntry->m_Notes;
2483 sNotesTags.Replace(L"\n", L"\r\n");
2484 }
2485 CString tagInfo = GetTagInfo(pLogEntry);
2486 if (!tagInfo.IsEmpty())
2487 {
2488 sNotesTags += L"----\r\n" + CString(MAKEINTRESOURCE(IDS_PROC_LOG_TAGINFO)) + L":\r\n";
2489 tagInfo.Replace(L"\n", L"\r\n");
2490 sNotesTags += tagInfo;
2491 }
2492
2493 sLogCopyText.Format(L"%s: %s\r\n%s: %s <%s>\r\n%s: %s\r\n%s:\r\n%s\r\n%s%s\r\n",
2494 (LPCTSTR)sRev, (LPCTSTR)pLogEntry->m_CommitHash.ToString(),
2495 (LPCTSTR)sAuthor, (LPCTSTR)pLogEntry->GetAuthorName(), (LPCTSTR)pLogEntry->GetAuthorEmail(),
2496 (LPCTSTR)sDate,
2497 (LPCTSTR)CLoglistUtils::FormatDateAndTime(pLogEntry->GetAuthorDate(), m_DateFormat, true, m_bRelativeTimes),
2498 (LPCTSTR)sMessage, (LPCTSTR)pLogEntry->GetSubjectBody(true),
2499 (LPCTSTR)sNotesTags,
2500 (LPCTSTR)sPaths);
2501 sClipdata += sLogCopyText;
2502 }
2503 else if (toCopy == ID_COPYCLIPBOARDAUTHORSFULL)
2504 {
2505 if (!first)
2506 sClipdata += L"\r\n";
2507 sClipdata += pLogEntry->GetAuthorName();
2508 sClipdata += L" <";
2509 sClipdata += pLogEntry->GetAuthorEmail();
2510 sClipdata += L">";
2511 }
2512 else if (toCopy == ID_COPYCLIPBOARDAUTHORSNAME)
2513 {
2514 if (!first)
2515 sClipdata += L"\r\n";
2516 sClipdata += pLogEntry->GetAuthorName();
2517 }
2518 else if (toCopy == ID_COPYCLIPBOARDAUTHORSEMAIL)
2519 {
2520 if (!first)
2521 sClipdata += L"\r\n";
2522 sClipdata += pLogEntry->GetAuthorEmail();
2523 }
2524
2525 else if (toCopy == ID_COPYCLIPBOARDMESSAGES)
2526 {
2527 sClipdata += L"* ";
2528 sClipdata += pLogEntry->GetSubjectBody(true);
2529 sClipdata += L"\r\n\r\n";
2530 }
2531 else if (toCopy == ID_COPYCLIPBOARDSUBJECTS)
2532 {
2533 sClipdata += L"* ";
2534 sClipdata += pLogEntry->GetSubject().Trim();
2535 sClipdata += L"\r\n\r\n";
2536 }
2537 else
2538 {
2539 if (!first)
2540 sClipdata += L"\r\n";
2541 sClipdata += pLogEntry->m_CommitHash;
2542 }
2543
2544 first = false;
2545 }
2546 CStringUtils::WriteAsciiStringToClipboard(sClipdata, GetSafeHwnd());
2547 }
2548 }
2549
2550 void CGitLogListBase::DiffSelectedRevWithPrevious()
2551 {
2552 if (m_bThreadRunning)
2553 return;
2554
2555 int FirstSelect=-1, LastSelect=-1;
2556 POSITION pos = GetFirstSelectedItemPosition();
2557 FirstSelect = GetNextSelectedItem(pos);
2558 while(pos)
2559 LastSelect = GetNextSelectedItem(pos);
2560
2561 ContextMenuAction(ID_COMPAREWITHPREVIOUS, FirstSelect, LastSelect, nullptr);
2562 }
2563
2564 void CGitLogListBase::OnLvnOdfinditemLoglist(NMHDR *pNMHDR, LRESULT *pResult)
2565 {
2566 LPNMLVFINDITEM pFindInfo = reinterpret_cast<LPNMLVFINDITEM>(pNMHDR);
2567 *pResult = -1;
2568
2569 if (pFindInfo->lvfi.flags & LVFI_PARAM)
2570 return;
2571 if (pFindInfo->iStart < 0 || pFindInfo->iStart >= (int)m_arShownList.size())
2572 return;
2573 if (!pFindInfo->lvfi.psz)
2574 return;
2575 #if 0
2576 CString sCmp = pFindInfo->lvfi.psz;
2577 CString sRev;
2578 for (int i=pFindInfo->iStart; i<m_arShownList.GetCount(); ++i)
2579 {
2580 GitRev * pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(i));
2581 sRev.Format(L"%ld", pLogEntry->Rev);
2582 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)
2583 {
2584 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)
2585 {
2586 *pResult = i;
2587 return;
2588 }
2589 }
2590 else
2591 {
2592 if (sCmp.Compare(sRev)==0)
2593 {
2594 *pResult = i;
2595 return;
2596 }
2597 }
2598 }
2599 if (pFindInfo->lvfi.flags & LVFI_WRAP)
2600 {
2601 for (int i=0; i<pFindInfo->iStart; ++i)
2602 {
2603 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(i));
2604 sRev.Format(L"%ld", pLogEntry->Rev);
2605 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)
2606 {
2607 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)
2608 {
2609 *pResult = i;
2610 return;
2611 }
2612 }
2613 else
2614 {
2615 if (sCmp.Compare(sRev)==0)
2616 {
2617 *pResult = i;
2618 return;
2619 }
2620 }
2621 }
2622 }
2623 #endif
2624 *pResult = -1;
2625 }
2626
2627 int CGitLogListBase::FillGitLog(CTGitPath *path, CString *range, int info)
2628 {
2629 ClearText();
2630
2631 this->m_arShownList.SafeRemoveAll();
2632
2633 this->m_logEntries.ClearAll();
2634 if (this->m_logEntries.ParserFromLog(path, 0, info, range))
2635 return -1;
2636
2637 SetItemCountEx((int)m_logEntries.size());
2638
2639 for (unsigned int i = 0; i < m_logEntries.size(); ++i)
2640 {
2641 if(m_IsOldFirst)
2642 {
2643 m_logEntries.GetGitRevAt(m_logEntries.size()-i-1).m_IsFull=TRUE;
2644 this->m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size()-i-1));
2645 }
2646 else
2647 {
2648 m_logEntries.GetGitRevAt(i).m_IsFull=TRUE;
2649 this->m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
2650 }
2651 }
2652
2653 ReloadHashMap();
2654
2655 if(path)
2656 m_Path=*path;
2657 return 0;
2658 }
2659
2660 int CGitLogListBase::FillGitLog(std::unordered_set<CGitHash>& hashes)
2661 {
2662 ClearText();
2663
2664 m_arShownList.SafeRemoveAll();
2665
2666 m_logEntries.ClearAll();
2667 if (m_logEntries.Fill(hashes))
2668 return -1;
2669
2670 SetItemCountEx((int)m_logEntries.size());
2671
2672 for (unsigned int i = 0; i < m_logEntries.size(); ++i)
2673 {
2674 if (m_IsOldFirst)
2675 {
2676 m_logEntries.GetGitRevAt(m_logEntries.size() - i - 1).m_IsFull = TRUE;
2677 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size() - i - 1));
2678 }
2679 else
2680 {
2681 m_logEntries.GetGitRevAt(i).m_IsFull = TRUE;
2682 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
2683 }
2684 }
2685
2686 ReloadHashMap();
2687
2688 return 0;
2689 }
2690
2691 int CGitLogListBase::BeginFetchLog()
2692 {
2693 ClearText();
2694
2695 this->m_arShownList.SafeRemoveAll();
2696
2697 this->m_logEntries.ClearAll();
2698
2699 this->m_LogCache.ClearAllParent();
2700
2701 m_LogCache.FetchCacheIndex(g_Git.m_CurrentDir);
2702
2703 CTGitPath *path;
2704 if(this->m_Path.IsEmpty())
2705 path = nullptr;
2706 else
2707 path=&this->m_Path;
2708
2709 int mask;
2710 mask = CGit::LOG_INFO_ONLY_HASH;
2711 if (m_bIncludeBoundaryCommits)
2712 mask |= CGit::LOG_INFO_BOUNDARY;
2713 // if(this->m_bAllBranch)
2714 mask |= m_ShowMask ;
2715
2716 if(m_bShowWC)
2717 {
2718 this->m_logEntries.insert(m_logEntries.cbegin(), m_wcRev.m_CommitHash);
2719 ResetWcRev();
2720 this->m_LogCache.m_HashMap[m_wcRev.m_CommitHash]=m_wcRev;
2721 }
2722
2723 if (m_sRange.IsEmpty())
2724 m_sRange = L"HEAD";
2725
2726 #if 0 /* use tortoiegit filter */
2727 if (this->m_nSelectedFilter == LOGFILTER_ALL || m_nSelectedFilter == LOGFILTER_AUTHORS)
2728 data.m_Author = this->m_sFilterText;
2729
2730 if(this->m_nSelectedFilter == LOGFILTER_ALL || m_nSelectedFilter == LOGFILTER_MESSAGES)
2731 data.m_MessageFilter = this->m_sFilterText;
2732
2733 data.m_IsRegex = m_bFilterWithRegex;
2734 #endif
2735
2736 // follow does not work for directories
2737 if (!path || path->IsDirectory())
2738 mask &= ~CGit::LOG_INFO_FOLLOW;
2739 // follow does not work with all branches 8at least in TGit)
2740 if (mask & CGit::LOG_INFO_FOLLOW)
2741 mask &= ~(CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_BASIC_REFS | CGit::LOG_INFO_LOCAL_BRANCHES);
2742
2743 CString cmd = g_Git.GetLogCmd(m_sRange, path, mask, &m_Filter, CRegDWORD(L"Software\\TortoiseGit\\LogOrderBy", CGit::LOG_ORDER_TOPOORDER));
2744
2745 //this->m_logEntries.ParserFromLog();
2746 if(IsInWorkingThread())
2747 {
2748 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL);
2749 }
2750 else
2751 {
2752 SetItemCountEx((int)m_logEntries.size());
2753 }
2754
2755 try
2756 {
2757 [] { git_init(); } ();
2758 }
2759 catch (char* msg)
2760 {
2761 CString err(msg);
2762 MessageBox(L"Could not initialize libgit.\nlibgit reports:\n" + err, L"TortoiseGit", MB_ICONERROR);
2763 return -1;
2764 }
2765
2766 if (!g_Git.CanParseRev(m_sRange))
2767 {
2768 if (!(mask & CGit::LOG_INFO_ALL_BRANCH) && !(mask & CGit::LOG_INFO_BASIC_REFS) && !(mask & CGit::LOG_INFO_LOCAL_BRANCHES))
2769 return 0;
2770
2771 // if show all branches, pick any ref as dummy entry ref
2772 STRING_VECTOR list;
2773 if (g_Git.GetRefList(list))
2774 MessageBox(g_Git.GetGitLastErr(L"Could not get all refs."), L"TortoiseGit", MB_ICONERROR);
2775 if (list.empty())
2776 return 0;
2777
2778 cmd = g_Git.GetLogCmd(list[0], path, mask, &m_Filter, CRegDWORD(L"Software\\TortoiseGit\\LogOrderBy", CGit::LOG_ORDER_TOPOORDER));
2779 }
2780
2781 g_Git.m_critGitDllSec.Lock();
2782 try {
2783 if (git_open_log(&m_DllGitLog, CUnicodeUtils::GetMulti(cmd, CP_UTF8).GetBuffer()))
2784 {
2785 g_Git.m_critGitDllSec.Unlock();
2786 return -1;
2787 }
2788 }
2789 catch (char* msg)
2790 {
2791 g_Git.m_critGitDllSec.Unlock();
2792 CString err(msg);
2793 MessageBox(L"Could not open log.\nlibgit reports:\n" + err, L"TortoiseGit", MB_ICONERROR);
2794 return -1;
2795 }
2796 g_Git.m_critGitDllSec.Unlock();
2797
2798 return 0;
2799 }
2800
2801 BOOL CGitLogListBase::PreTranslateMessage(MSG* pMsg)
2802 {
2803 if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')
2804 {
2805 //if (GetFocus()==GetDlgItem(IDC_LOGLIST))
2806 {
2807 if (CRegDWORD(L"Software\\TortoiseGit\\DiffByDoubleClickInLog", FALSE))
2808 {
2809 DiffSelectedRevWithPrevious();
2810 return TRUE;
2811 }
2812 }
2813 #if 0
2814 if (GetFocus()==GetDlgItem(IDC_LOGMSG))
2815 {
2816 DiffSelectedFile();
2817 return TRUE;
2818 }
2819 #endif
2820 }
2821 else if (pMsg->message == WM_KEYDOWN && pMsg->wParam == 'A' && GetAsyncKeyState(VK_CONTROL)&0x8000)
2822 {
2823 // select all entries
2824 for (int i=0; i<GetItemCount(); ++i)
2825 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2826 return TRUE;
2827 }
2828
2829 #if 0
2830 if (m_hAccel && !bSkipAccelerator)
2831 {
2832 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
2833 if (ret)
2834 return TRUE;
2835 }
2836
2837 #endif
2838 //m_tooltips.RelayEvent(pMsg);
2839 return __super::PreTranslateMessage(pMsg);
2840 }
2841
2842 void CGitLogListBase::OnNMDblclkLoglist(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2843 {
2844 // a double click on an entry in the revision list has happened
2845 *pResult = 0;
2846
2847 if (CRegDWORD(L"Software\\TortoiseGit\\DiffByDoubleClickInLog", FALSE))
2848 DiffSelectedRevWithPrevious();
2849 }
2850
2851 void CGitLogListBase::FetchLogAsync(void* data)
2852 {
2853 ReloadHashMap();
2854 m_ProcData=data;
2855 StartLoadingThread();
2856 }
2857
2858 UINT CGitLogListBase::LogThreadEntry(LPVOID pVoid)
2859 {
2860 return ((CGitLogListBase*)pVoid)->LogThread();
2861 }
2862
2863 void CGitLogListBase::GetTimeRange(CTime &oldest, CTime &latest)
2864 {
2865 //CTime time;
2866 oldest=CTime::GetCurrentTime();
2867 latest=CTime(1971,1,2,0,0,0);
2868 for (unsigned int i = 0; i < m_logEntries.size(); ++i)
2869 {
2870 if(m_logEntries[i].IsEmpty())
2871 continue;
2872
2873 if (m_logEntries.GetGitRevAt(i).GetCommitterDate().GetTime() < oldest.GetTime())
2874 oldest = m_logEntries.GetGitRevAt(i).GetCommitterDate().GetTime();
2875
2876 if (m_logEntries.GetGitRevAt(i).GetCommitterDate().GetTime() > latest.GetTime())
2877 latest = m_logEntries.GetGitRevAt(i).GetCommitterDate().GetTime();
2878
2879 }
2880
2881 if(latest<oldest)
2882 latest=oldest;
2883 }
2884
2885 UINT CGitLogListBase::LogThread()
2886 {
2887 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) GITLOG_START,0);
2888
2889 ULONGLONG t1,t2;
2890
2891 if(BeginFetchLog())
2892 {
2893 InterlockedExchange(&m_bThreadRunning, FALSE);
2894 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2895
2896 return 1;
2897 }
2898
2899 std::wregex pat;//(L"Remove", regex_constants::icase);
2900 bool bRegex = false;
2901 if (m_bFilterWithRegex)
2902 bRegex = ValidateRegexp(m_sFilterText, pat, false);
2903
2904 TRACE(L"\n===Begin===\n");
2905 //Update work copy item;
2906
2907 if (!m_logEntries.empty())
2908 {
2909 GitRevLoglist* pRev = &m_logEntries.GetGitRevAt(0);
2910
2911 m_arShownList.SafeAdd(pRev);
2912 }
2913
2914
2915 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2916
2917 // store commit number of the last selected commit/line before the refresh or -1
2918 int lastSelectedHashNItem = -1;
2919 if (m_lastSelectedHash.IsEmpty())
2920 lastSelectedHashNItem = 0;
2921
2922 int ret = 0;
2923
2924 bool shouldWalk = true;
2925 if (!g_Git.CanParseRev(m_sRange))
2926 {
2927 // walk revisions if show all branches and there exists any ref
2928 if (!(m_ShowMask & CGit::LOG_INFO_ALL_BRANCH) && !(m_ShowMask & CGit::LOG_INFO_BASIC_REFS) && !(m_ShowMask & CGit::LOG_INFO_LOCAL_BRANCHES))
2929 shouldWalk = false;
2930 else
2931 {
2932 STRING_VECTOR list;
2933 if (g_Git.GetRefList(list))
2934 MessageBox(g_Git.GetGitLastErr(L"Could not get all refs."), L"TortoiseGit", MB_ICONERROR);
2935 if (list.empty())
2936 shouldWalk = false;
2937 }
2938 }
2939
2940 if (shouldWalk)
2941 {
2942 g_Git.m_critGitDllSec.Lock();
2943 if (!m_DllGitLog)
2944 {
2945 MessageBox(L"Opening log failed.", L"TortoiseGit", MB_ICONERROR);
2946 g_Git.m_critGitDllSec.Unlock();
2947 InterlockedExchange(&m_bThreadRunning, FALSE);
2948 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2949 return 1;
2950 }
2951 int total = 0;
2952 try
2953 {
2954 [&] {git_get_log_firstcommit(m_DllGitLog);}();
2955 total = git_get_log_estimate_commit_count(m_DllGitLog);
2956 }
2957 catch (char* msg)
2958 {
2959 CString err(msg);
2960 MessageBox(L"Could not get first commit.\nlibgit reports:\n" + err, L"TortoiseGit", MB_ICONERROR);
2961 ret = -1;
2962 }
2963 g_Git.m_critGitDllSec.Unlock();
2964
2965 GIT_COMMIT commit;
2966 t2 = t1 = GetTickCount64();
2967 int oldprecentage = 0;
2968 size_t oldsize = m_logEntries.size();
2969 std::unordered_map<CGitHash, std::unordered_set<CGitHash>> commitChildren;
2970 while (ret== 0 && !m_bExitThread)
2971 {
2972 g_Git.m_critGitDllSec.Lock();
2973 try
2974 {
2975 [&] { ret = git_get_log_nextcommit(this->m_DllGitLog, &commit, m_ShowMask & CGit::LOG_INFO_FOLLOW); } ();
2976 }
2977 catch (char* msg)
2978 {
2979 g_Git.m_critGitDllSec.Unlock();
2980 CString err(msg);
2981 MessageBox(L"Could not get next commit.\nlibgit reports:\n" + err, L"TortoiseGit", MB_ICONERROR);
2982 break;
2983 }
2984 g_Git.m_critGitDllSec.Unlock();
2985
2986 if(ret)
2987 {
2988 if (ret != -2) // other than end of revision walking
2989 MessageBox((L"Could not get next commit.\nlibgit returns:" + std::to_wstring(ret)).c_str(), L"TortoiseGit", MB_ICONERROR);
2990 break;
2991 }
2992
2993 if (commit.m_ignore == 1)
2994 {
2995 git_free_commit(&commit);
2996 continue;
2997 }
2998
2999 //printf("%s\r\n",commit.GetSubject());
3000 if(m_bExitThread)
3001 break;
3002
3003 CGitHash hash(commit.m_hash);
3004
3005 GitRevLoglist* pRev = m_LogCache.GetCacheData(hash);
3006 pRev->m_GitCommit = commit;
3007 InterlockedExchange(&pRev->m_IsCommitParsed, FALSE);
3008
3009 char* note = nullptr;
3010 g_Git.m_critGitDllSec.Lock();
3011 try
3012 {
3013 git_get_notes(commit.m_hash, &note);
3014 }
3015 catch (char* msg)
3016 {
3017 g_Git.m_critGitDllSec.Unlock();
3018 CString err(msg);
3019 MessageBox(L"Could not get commit notes.\nlibgit reports:\n" + err, L"TortoiseGit", MB_ICONERROR);
3020 break;
3021 }
3022 g_Git.m_critGitDllSec.Unlock();
3023
3024 if(note)
3025 {
3026 pRev->m_Notes = CUnicodeUtils::GetUnicode(note);
3027 free(note);
3028 note = nullptr;
3029 }
3030
3031 if(!pRev->m_IsDiffFiles)
3032 {
3033 pRev->m_CallDiffAsync = DiffAsync;
3034 }
3035
3036 pRev->ParserParentFromCommit(&commit);
3037 if (m_ShowFilter & FILTERSHOW_MERGEPOINTS) // See also ShouldShowFilter()
3038 {
3039 for (size_t i = 0; i < pRev->m_ParentHash.size(); ++i)
3040 {
3041 const CGitHash &parentHash = pRev->m_ParentHash[i];
3042 auto it = commitChildren.find(parentHash);
3043 if (it == commitChildren.end())
3044 it = commitChildren.insert(make_pair(parentHash, std::unordered_set<CGitHash>())).first;
3045 it->second.insert(pRev->m_CommitHash);
3046 }
3047 }
3048
3049 #ifdef DEBUG
3050 pRev->DbgPrint();
3051 TRACE(L"\n");
3052 #endif
3053
3054 bool visible = true;
3055 if (HasFilterText())
3056 {
3057 if(!IsMatchFilter(bRegex,pRev,pat))
3058 visible = false;
3059 }
3060 if (visible && !ShouldShowFilter(pRev, commitChildren))
3061 visible = false;
3062 this->m_critSec.Lock();
3063 m_logEntries.append(hash, visible);
3064 if (visible)
3065 m_arShownList.SafeAdd(pRev);
3066 this->m_critSec.Unlock();
3067
3068 if (!visible)
3069 continue;
3070
3071 if (lastSelectedHashNItem == -1 && hash == m_lastSelectedHash)
3072 lastSelectedHashNItem = (int)m_arShownList.size() - 1;
3073
3074 t2 = GetTickCount64();
3075
3076 if (t2 - t1 > 500UL || (m_logEntries.size() - oldsize > 100))
3077 {
3078 //update UI
3079 int percent = (int)m_logEntries.size() * 100 / total + GITLOG_START + 1;
3080 if(percent > 99)
3081 percent =99;
3082 if(percent < GITLOG_START)
3083 percent = GITLOG_START +1;
3084
3085 oldsize = m_logEntries.size();
3086 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL|LVSICF_NOSCROLL);
3087
3088 //if( percent > oldprecentage )
3089 {
3090 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) percent,0);
3091 oldprecentage = percent;
3092 }
3093
3094 if (lastSelectedHashNItem >= 0)
3095 PostMessage(m_ScrollToMessage, lastSelectedHashNItem);
3096
3097 t1 = t2;
3098 }
3099 }
3100 g_Git.m_critGitDllSec.Lock();
3101 git_close_log(m_DllGitLog);
3102 g_Git.m_critGitDllSec.Unlock();
3103
3104 }
3105
3106 if (m_bExitThread)
3107 {
3108 InterlockedExchange(&m_bThreadRunning, FALSE);
3109 return 0;
3110 }
3111
3112 //Update UI;
3113 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL|LVSICF_NOSCROLL);
3114
3115 if (lastSelectedHashNItem >= 0)
3116 PostMessage(m_ScrollToMessage, lastSelectedHashNItem);
3117
3118 if (this->m_hWnd)
3119 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) GITLOG_END,0);
3120
3121 InterlockedExchange(&m_bThreadRunning, FALSE);
3122
3123 return 0;
3124 }
3125
3126 void CGitLogListBase::FetchRemoteList()
3127 {
3128 STRING_VECTOR remoteList;
3129 m_SingleRemote.Empty();
3130 if (!g_Git.GetRemoteList(remoteList) && remoteList.size() == 1)
3131 m_SingleRemote = remoteList[0];
3132 }
3133
3134 void CGitLogListBase::FetchTrackingBranchList()
3135 {
3136 m_TrackingMap.clear();
3137 for (auto it = m_HashMap.cbegin(); it != m_HashMap.cend(); ++it)
3138 {
3139 for (const auto& ref : it->second)
3140 {
3141 CString branchName;
3142 if (CGit::GetShortName(ref, branchName, L"refs/heads/"))
3143 {
3144 CString pullRemote, pullBranch;
3145 g_Git.GetRemoteTrackedBranch(branchName, pullRemote, pullBranch);
3146 if (!pullRemote.IsEmpty() && !pullBranch.IsEmpty())
3147 m_TrackingMap[branchName] = std::make_pair(pullRemote, pullBranch);
3148 }
3149 }
3150 }
3151 }
3152
3153 void CGitLogListBase::Refresh(BOOL IsCleanFilter)
3154 {
3155 SafeTerminateThread();
3156
3157 this->SetItemCountEx(0);
3158 this->Clear();
3159
3160 ResetWcRev();
3161
3162 ShowGraphColumn((m_ShowMask & CGit::LOG_INFO_FOLLOW) ? false : true);
3163
3164 if (m_pMailmap)
3165 {
3166 git_free_mailmap(m_pMailmap);
3167 git_read_mailmap(&m_pMailmap);
3168 }
3169
3170 //Update branch and Tag info
3171 ReloadHashMap();
3172 if (m_pFindDialog)
3173 m_pFindDialog->RefreshList();
3174 //Assume Thread have exited
3175 //if(!m_bThreadRunning)
3176 {
3177 m_logEntries.clear();
3178
3179 if(IsCleanFilter)
3180 {
3181 m_sFilterText.Empty();
3182 }
3183
3184 SafeTerminateAsyncDiffThread();
3185 m_AsynDiffListLock.Lock();
3186 m_AsynDiffList.clear();
3187 m_AsynDiffListLock.Unlock();
3188 StartAsyncDiffThread();
3189
3190 StartLoadingThread();
3191 }
3192 }
3193
3194 void CGitLogListBase::StartAsyncDiffThread()
3195 {
3196 if (m_AsyncThreadExit)
3197 return;
3198 if (InterlockedExchange(&m_AsyncThreadRunning, TRUE) != FALSE)
3199 return;
3200 m_DiffingThread = AfxBeginThread(AsyncThread, this, THREAD_PRIORITY_BELOW_NORMAL);
3201 if (!m_DiffingThread)
3202 {
3203 InterlockedExchange(&m_AsyncThreadRunning, FALSE);
3204 CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
3205 }
3206 }
3207
3208 void CGitLogListBase::StartLoadingThread()
3209 {
3210 if (InterlockedExchange(&m_bThreadRunning, TRUE) != FALSE)
3211 return;
3212 InterlockedExchange(&m_bNoDispUpdates, TRUE);
3213 InterlockedExchange(&m_bExitThread, FALSE);
3214 m_LoadingThread = AfxBeginThread(LogThreadEntry, this, THREAD_PRIORITY_LOWEST);
3215 if (!m_LoadingThread)
3216 {
3217 InterlockedExchange(&m_bThreadRunning, FALSE);
3218 InterlockedExchange(&m_bNoDispUpdates, FALSE);
3219 CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
3220 }
3221 }
3222
3223 bool CGitLogListBase::ValidateRegexp(LPCTSTR regexp_str, std::wregex& pat, bool bMatchCase /* = false */)
3224 {
3225 try
3226 {
3227 std::regex_constants::syntax_option_type type = std::regex_constants::ECMAScript;
3228 if (!bMatchCase)
3229 type |= std::regex_constants::icase;
3230 pat = std::wregex(regexp_str, type);
3231 return true;
3232 }
3233 catch (std::exception&) {}
3234 return false;
3235 }
3236 BOOL CGitLogListBase::IsMatchFilter(bool bRegex, GitRevLoglist* pRev, std::wregex& pat)
3237 {
3238 BOOL result = TRUE;
3239 std::regex_constants::match_flag_type flags = std::regex_constants::match_any;
3240 CString sRev;
3241
3242 if ((bRegex)&&(m_bFilterWithRegex))
3243 {
3244 if (m_SelectedFilters & LOGFILTER_BUGID)
3245 {
3246 if(this->m_bShowBugtraqColumn)
3247 {
3248 CString sBugIds = m_ProjectProperties.FindBugID(pRev->GetSubjectBody());
3249
3250 ATLTRACE(L"bugID = \"%s\"\n", (LPCTSTR)sBugIds);
3251 if (std::regex_search(std::wstring(sBugIds), pat, flags))
3252 return TRUE;
3253 }
3254 }
3255
3256 if ((m_SelectedFilters & LOGFILTER_SUBJECT) || (m_SelectedFilters & LOGFILTER_MESSAGES))
3257 {
3258 ATLTRACE(L"messge = \"%s\"\n", (LPCTSTR)pRev->GetSubject());
3259 if (std::regex_search(std::wstring((LPCTSTR)pRev->GetSubject()), pat, flags))
3260 return TRUE;
3261 }
3262
3263 if (m_SelectedFilters & LOGFILTER_MESSAGES)
3264 {
3265 ATLTRACE(L"messge = \"%s\"\n", (LPCTSTR)pRev->GetBody());
3266 if (std::regex_search(std::wstring((LPCTSTR)pRev->GetBody()), pat, flags))
3267 return TRUE;
3268 }
3269
3270 if (m_SelectedFilters & LOGFILTER_AUTHORS)
3271 {
3272 if (std::regex_search(std::wstring(pRev->GetAuthorName()), pat, flags))
3273 return TRUE;
3274
3275 if (std::regex_search(std::wstring(pRev->GetCommitterName()), pat, flags))
3276 return TRUE;
3277 }
3278
3279 if (m_SelectedFilters & LOGFILTER_EMAILS)
3280 {
3281 if (std::regex_search(std::wstring(pRev->GetAuthorEmail()), pat, flags))
3282 return TRUE;
3283
3284 if (std::regex_search(std::wstring(pRev->GetCommitterEmail()), pat, flags))
3285 return TRUE;
3286 }
3287
3288 if (m_SelectedFilters & LOGFILTER_REVS)
3289 {
3290 sRev = pRev->m_CommitHash.ToString();
3291 if (std::regex_search(std::wstring((LPCTSTR)sRev), pat, flags))
3292 {
3293 return TRUE;
3294 }
3295 }
3296
3297 if (m_SelectedFilters & LOGFILTER_NOTES)
3298 {
3299 if (std::regex_search(std::wstring(pRev->m_Notes), pat, flags))
3300 return TRUE;
3301 }
3302
3303 if ((m_SelectedFilters & LOGFILTER_REFNAME) && m_HashMap.find(pRev->m_CommitHash) != m_HashMap.cend())
3304 {
3305 const STRING_VECTOR& refs = m_HashMap[pRev->m_CommitHash];
3306 for (const auto& ref : refs)
3307 {
3308 if (std::regex_search(std::wstring(ref), pat, flags))
3309 return TRUE;
3310 }
3311 }
3312
3313 if (m_SelectedFilters & LOGFILTER_ANNOTATEDTAG)
3314 {
3315 if (std::regex_search(std::wstring(GetTagInfo(pRev)), pat, flags))
3316 return TRUE;
3317 }
3318
3319 if (m_SelectedFilters & LOGFILTER_PATHS)
3320 {
3321 CTGitPathList* pathList = nullptr;
3322 if( pRev->m_IsDiffFiles)
3323 pathList = &pRev->GetFiles(this);
3324 else
3325 {
3326 if(!pRev->m_IsSimpleListReady)
3327 pRev->SafeGetSimpleList(&g_Git);
3328 }
3329
3330 if(pathList)
3331 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList->GetCount(); ++cpPathIndex)
3332 {
3333 if (std::regex_search(std::wstring((LPCTSTR)pathList->m_paths[cpPathIndex].GetGitOldPathString()), pat, flags))
3334 return true;
3335 if (std::regex_search(std::wstring((LPCTSTR)pathList->m_paths[cpPathIndex].GetGitPathString()), pat, flags))
3336 return true;
3337 }
3338
3339 for (size_t i = 0; i < pRev->m_SimpleFileList.size(); ++i)
3340 {
3341 if (std::regex_search(std::wstring((LPCTSTR)pRev->m_SimpleFileList[i]), pat, flags))
3342 return true;
3343 }
3344 }
3345 }
3346 else
3347 {
3348 CString find = m_sFilterText;
3349 if (!m_bFilterCaseSensitively)
3350 find.MakeLower();
3351 result = find[0] == '!' ? FALSE : TRUE;
3352 if (!result)
3353 find = find.Mid(1);
3354
3355 if (m_SelectedFilters & LOGFILTER_BUGID)
3356 {
3357 if(this->m_bShowBugtraqColumn)
3358 {
3359 CString sBugIds = m_ProjectProperties.FindBugID(pRev->GetSubjectBody());
3360
3361 if (!m_bFilterCaseSensitively)
3362 sBugIds.MakeLower();
3363 if ((sBugIds.Find(find) >= 0))
3364 return result;
3365 }
3366 }
3367
3368 if ((m_SelectedFilters & LOGFILTER_SUBJECT) || (m_SelectedFilters & LOGFILTER_MESSAGES))
3369 {
3370 CString msg = pRev->GetSubject();
3371
3372 if (!m_bFilterCaseSensitively)
3373 msg = msg.MakeLower();
3374 if ((msg.Find(find) >= 0))
3375 return result;
3376 }
3377
3378 if (m_SelectedFilters & LOGFILTER_MESSAGES)
3379 {
3380 CString msg = pRev->GetBody();
3381
3382 if (!m_bFilterCaseSensitively)
3383 msg = msg.MakeLower();
3384 if ((msg.Find(find) >= 0))
3385 return result;
3386 }
3387
3388 if (m_SelectedFilters & LOGFILTER_AUTHORS)
3389 {
3390 CString msg = pRev->GetAuthorName();
3391 if (!m_bFilterCaseSensitively)
3392 msg = msg.MakeLower();
3393 if ((msg.Find(find) >= 0))
3394 return result;
3395 }
3396
3397 if (m_SelectedFilters & LOGFILTER_EMAILS)
3398 {
3399 CString msg = pRev->GetAuthorEmail();
3400 if (!m_bFilterCaseSensitively)
3401 msg = msg.MakeLower();
3402 if ((msg.Find(find) >= 0))
3403 return result;
3404 }
3405
3406 if (m_SelectedFilters & LOGFILTER_NOTES)
3407 {
3408 CString msg = pRev->m_Notes;
3409 if (!m_bFilterCaseSensitively)
3410 msg = msg.MakeLower();
3411 if ((msg.Find(find) >= 0))
3412 return result;
3413 }
3414
3415 if (m_SelectedFilters & LOGFILTER_REVS)
3416 {
3417 sRev = pRev->m_CommitHash.ToString();
3418 if ((sRev.Find(find) >= 0))
3419 return result;
3420 }
3421
3422 if (m_SelectedFilters & LOGFILTER_ANNOTATEDTAG)
3423 {
3424 CString msg = GetTagInfo(pRev);
3425 if (!m_bFilterCaseSensitively)
3426 msg = msg.MakeLower();
3427 if ((msg.Find(find) >= 0))
3428 return result;
3429 }
3430
3431 if ((m_SelectedFilters & LOGFILTER_REFNAME) && m_HashMap.find(pRev->m_CommitHash) != m_HashMap.cend())
3432 {
3433 const STRING_VECTOR& refs = m_HashMap[pRev->m_CommitHash];
3434 for (auto it = refs.cbegin(); it != refs.cend(); ++it)
3435 {
3436 if (it->Find(find) >= 0)
3437 return result;
3438 }
3439 }
3440
3441 if (m_SelectedFilters & LOGFILTER_PATHS)
3442 {
3443 CTGitPathList* pathList = nullptr;
3444 if( pRev->m_IsDiffFiles)
3445 pathList = &pRev->GetFiles(this);
3446 else
3447 {
3448 if(!pRev->m_IsSimpleListReady)
3449 pRev->SafeGetSimpleList(&g_Git);
3450 }
3451 if(pathList)
3452 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList->GetCount() ; ++cpPathIndex)
3453 {
3454 CTGitPath* cpath = &pathList->m_paths[cpPathIndex];
3455 CString path = cpath->GetGitOldPathString();
3456 if (!m_bFilterCaseSensitively)
3457 path.MakeLower();
3458 if ((path.Find(find)>=0))
3459 return result;
3460 path = cpath->GetGitPathString();
3461 if (!m_bFilterCaseSensitively)
3462 path.MakeLower();
3463 if ((path.Find(find)>=0))
3464 return result;
3465 }
3466
3467 for (size_t i = 0; i < pRev->m_SimpleFileList.size(); ++i)
3468 {
3469 CString path = pRev->m_SimpleFileList[i];
3470 if (!m_bFilterCaseSensitively)
3471 path.MakeLower();
3472 if ((path.Find(find)>=0))
3473 return result;
3474 }
3475 }
3476 } // else (from if (bRegex))
3477 return !result;
3478 }
3479
3480 static bool CStringStartsWith(const CString &str, const CString &prefix)
3481 {
3482 return str.Left(prefix.GetLength()) == prefix;
3483 }
3484 bool CGitLogListBase::ShouldShowFilter(GitRevLoglist* pRev, const std::unordered_map<CGitHash, std::unordered_set<CGitHash>>& commitChildren)
3485 {
3486 if (m_ShowFilter & FILTERSHOW_ANYCOMMIT)
3487 return true;
3488
3489 if ((m_ShowFilter & FILTERSHOW_REFS) && m_HashMap.find(pRev->m_CommitHash) != m_HashMap.cend())
3490 {
3491 // Keep all refs.
3492 const STRING_VECTOR &refList = m_HashMap[pRev->m_CommitHash];
3493 for (size_t i = 0; i < refList.size(); ++i)
3494 {
3495 const CString &str = refList[i];
3496 if (CStringStartsWith(str, L"refs/heads/"))
3497 {
3498 if (m_ShowRefMask & LOGLIST_SHOWLOCALBRANCHES)
3499 return true;
3500 }
3501 else if (CStringStartsWith(str, L"refs/remotes/"))
3502 {
3503 if (m_ShowRefMask & LOGLIST_SHOWREMOTEBRANCHES)
3504 return true;
3505 }
3506 else if (CStringStartsWith(str, L"refs/tags/"))
3507 {
3508 if (m_ShowRefMask & LOGLIST_SHOWTAGS)
3509 return true;
3510 }
3511 else if (CStringStartsWith(str, L"refs/stash"))
3512 {
3513 if (m_ShowRefMask & LOGLIST_SHOWSTASH)
3514 return true;
3515 }
3516 else if (CStringStartsWith(str, L"refs/bisect/"))
3517 {
3518 if (m_ShowRefMask & LOGLIST_SHOWBISECT)
3519 return true;
3520 }
3521 }
3522 // Keep the head too.
3523 if (pRev->m_CommitHash == m_HeadHash)
3524 return true;
3525 }
3526
3527 if (m_ShowFilter & FILTERSHOW_MERGEPOINTS)
3528 {
3529 if (pRev->ParentsCount() > 1)
3530 return true;
3531 auto childrenIt = commitChildren.find(pRev->m_CommitHash);
3532 if (childrenIt != commitChildren.end())
3533 {
3534 const std::unordered_set<CGitHash> &children = childrenIt->second;
3535 if (children.size() > 1)
3536 return true;
3537 }
3538 }
3539 return false;
3540 }
3541
3542 void CGitLogListBase::ShowGraphColumn(bool bShow)
3543 {
3544 // HACK to hide graph column
3545 if (bShow)
3546 SetColumnWidth(0, m_ColumnManager.GetWidth(0, false));
3547 else
3548 SetColumnWidth(0, 0);
3549 }
3550
3551 CString CGitLogListBase::GetTagInfo(GitRev* pLogEntry)
3552 {
3553 if (m_HashMap.find(pLogEntry->m_CommitHash) == m_HashMap.end())
3554 return L"";
3555
3556 CString tagInfo;
3557 const STRING_VECTOR& vector = m_HashMap[pLogEntry->m_CommitHash];
3558 for (auto it = vector.cbegin(); it != vector.cend(); ++it)
3559 {
3560 if (!CStringUtils::StartsWith((*it), L"refs/tags/"))
3561 continue;
3562 if (!CStringUtils::EndsWith((*it), L"^{}"))
3563 continue;
3564
3565 CString cmd;
3566 cmd.Format(L"git.exe cat-file tag %s", (LPCTSTR)(*it).Left((*it).GetLength() - (int)wcslen(L"^{}")));
3567 CString output;
3568 if (g_Git.Run(cmd, &output, nullptr, CP_UTF8) != 0)
3569 continue;
3570
3571 // parse tag date
3572 do
3573 {
3574 // this assumes that in the header of the tag there is no ">" before the "tagger " header entry
3575 int pos1 = output.Find(L'>');
3576 if (pos1 < 0)
3577 break;
3578 ++pos1;
3579 if (output[pos1] == L' ')
3580 ++pos1;
3581 int pos2 = output.Find(L'\n', pos1);
3582 if (pos2 < 0)
3583 break;
3584
3585 CString str = output.Mid(pos1, pos2 - pos1);
3586 wchar_t* pEnd = nullptr;
3587 errno = 0;
3588 auto number = wcstoumax(str.GetBuffer(), &pEnd, 10);
3589 if (str.GetBuffer() == pEnd)
3590 break;
3591 if (errno == ERANGE)
3592 break;
3593
3594 output.Delete(pos1, pos2 - pos1);
3595 output.Insert(pos1, (LPCWSTR)CLoglistUtils::FormatDateAndTime(CTime(number), m_DateFormat, true, m_bRelativeTimes));
3596 } while (0);
3597 output.Trim().AppendChar(L'\n');
3598 tagInfo += output;
3599 }
3600 return tagInfo;
3601 }
3602
3603 void CGitLogListBase::RecalculateShownList(CThreadSafePtrArray * pShownlist)
3604 {
3605 pShownlist->SafeRemoveAll();
3606
3607 std::wregex pat;//(L"Remove", regex_constants::icase);
3608 bool bRegex = false;
3609 if (m_bFilterWithRegex)
3610 bRegex = ValidateRegexp(m_sFilterText, pat, false);
3611
3612 std::regex_constants::match_flag_type flags = std::regex_constants::match_any;
3613 CString sRev;
3614 for (DWORD i=0; i<m_logEntries.size(); ++i)
3615 {
3616 if ((bRegex)&&(m_bFilterWithRegex))
3617 {
3618 #if 0
3619 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
3620 {
3621 ATLTRACE(L"bugID = \"%s\"\n", (LPCTSTR)m_logEntries[i]->sBugIDs);
3622 if (std::regex_search(std::wstring((LPCTSTR)m_logEntries[i]->sBugIDs), pat, flags)&&IsEntryInDateRange(i))
3623 {
3624 pShownlist->SafeAdd(m_logEntries[i]);
3625 continue;
3626 }
3627 }
3628 #endif
3629 if ((m_SelectedFilters & LOGFILTER_SUBJECT) || (m_SelectedFilters & LOGFILTER_MESSAGES))
3630 {
3631 ATLTRACE(L"messge = \"%s\"\n", (LPCTSTR)m_logEntries.GetGitRevAt(i).GetSubject());
3632 if (std::regex_search(std::wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetSubject()), pat, flags)&&IsEntryInDateRange(i))
3633 {
3634 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3635 continue;
3636 }
3637 }
3638 if (m_SelectedFilters & LOGFILTER_MESSAGES)
3639 {
3640 ATLTRACE("messge = \"%s\"\n", (LPCTSTR)m_logEntries.GetGitRevAt(i).GetBody());
3641 if (std::regex_search(std::wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetBody()), pat, flags)&&IsEntryInDateRange(i))
3642 {
3643 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3644 continue;
3645 }
3646 }
3647 if (m_SelectedFilters & LOGFILTER_PATHS)
3648 {
3649 CTGitPathList pathList = m_logEntries.GetGitRevAt(i).GetFiles(this);
3650
3651 bool bGoing = true;
3652 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList.GetCount() && bGoing; ++cpPathIndex)
3653 {
3654 CTGitPath cpath = pathList[cpPathIndex];
3655 if (std::regex_search(std::wstring((LPCTSTR)cpath.GetGitOldPathString()), pat, flags)&&IsEntryInDateRange(i))
3656 {
3657 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3658 bGoing = false;
3659 continue;
3660 }
3661 if (std::regex_search(std::wstring((LPCTSTR)cpath.GetGitPathString()), pat, flags)&&IsEntryInDateRange(i))
3662 {
3663 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3664 bGoing = false;
3665 continue;
3666 }
3667 if (std::regex_search(std::wstring((LPCTSTR)cpath.GetActionName()), pat, flags)&&IsEntryInDateRange(i))
3668 {
3669 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3670 bGoing = false;
3671 continue;
3672 }
3673 }
3674 }
3675 if (m_SelectedFilters & LOGFILTER_AUTHORS)
3676 {
3677 if (std::regex_search(std::wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetAuthorName()), pat, flags)&&IsEntryInDateRange(i))
3678 {
3679 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3680 continue;
3681 }
3682 }
3683 if (m_SelectedFilters & LOGFILTER_EMAILS)
3684 {
3685 if (std::regex_search(std::wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetAuthorEmail()), pat, flags) && IsEntryInDateRange(i))
3686 {
3687 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3688 continue;
3689 }
3690 }
3691 if (m_SelectedFilters & LOGFILTER_REVS)
3692 {
3693 sRev = m_logEntries.GetGitRevAt(i).m_CommitHash.ToString();
3694 if (std::regex_search(std::wstring((LPCTSTR)sRev), pat, flags)&&IsEntryInDateRange(i))
3695 {
3696 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3697 continue;
3698 }
3699 }
3700 if ((m_SelectedFilters & LOGFILTER_REFNAME) && m_HashMap.find(m_logEntries.GetGitRevAt(i).m_CommitHash) != m_HashMap.cend())
3701 {
3702 const STRING_VECTOR& refs = m_HashMap[m_logEntries.GetGitRevAt(i).m_CommitHash];
3703 for (auto it = refs.cbegin(); it != refs.cend(); ++it)
3704 {
3705 if (std::regex_search(std::wstring((LPCTSTR)*it), pat, flags) && IsEntryInDateRange(i))
3706 {
3707 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3708 continue;
3709 }
3710 }
3711 }
3712 } // if (bRegex)
3713 else
3714 {
3715 CString find = m_sFilterText;
3716 if (!m_bFilterCaseSensitively)
3717 find.MakeLower();
3718 #if 0
3719 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
3720 {
3721 CString sBugIDs = m_logEntries[i]->sBugIDs;
3722
3723 if (!m_bFilterCaseSensitively)
3724 sBugIDs = sBugIDs.MakeLower();
3725 if ((sBugIDs.Find(find) >= 0)&&(IsEntryInDateRange(i)))
3726 {
3727 pShownlist->SafeAdd(m_logEntries[i]);
3728 continue;
3729 }
3730 }
3731 #endif
3732 if ((m_SelectedFilters & LOGFILTER_SUBJECT) || (m_SelectedFilters & LOGFILTER_MESSAGES))
3733 {
3734 CString msg = m_logEntries.GetGitRevAt(i).GetSubject();
3735
3736 if (!m_bFilterCaseSensitively)
3737 msg = msg.MakeLower();
3738 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
3739 {
3740 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3741 continue;
3742 }
3743 }
3744 if (m_SelectedFilters & LOGFILTER_MESSAGES)
3745 {
3746 CString msg = m_logEntries.GetGitRevAt(i).GetBody();
3747
3748 if (!m_bFilterCaseSensitively)
3749 msg = msg.MakeLower();
3750 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
3751 {
3752 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3753 continue;
3754 }
3755 }
3756 if (m_SelectedFilters & LOGFILTER_PATHS)
3757 {
3758 CTGitPathList pathList = m_logEntries.GetGitRevAt(i).GetFiles(this);
3759
3760 bool bGoing = true;
3761 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList.GetCount() && bGoing; ++cpPathIndex)
3762 {
3763 CTGitPath cpath = pathList[cpPathIndex];
3764 CString path = cpath.GetGitOldPathString();
3765 if (!m_bFilterCaseSensitively)
3766 path.MakeLower();
3767 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
3768 {
3769 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3770 bGoing = false;
3771 continue;
3772 }
3773 path = cpath.GetGitPathString();
3774 if (!m_bFilterCaseSensitively)
3775 path.MakeLower();
3776 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
3777 {
3778 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3779 bGoing = false;
3780 continue;
3781 }
3782 path = cpath.GetActionName();
3783 if (!m_bFilterCaseSensitively)
3784 path.MakeLower();
3785 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
3786 {
3787 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3788 bGoing = false;
3789 continue;
3790 }
3791 }
3792 }
3793 if (m_SelectedFilters & LOGFILTER_AUTHORS)
3794 {
3795 CString msg = m_logEntries.GetGitRevAt(i).GetAuthorName();
3796 if (!m_bFilterCaseSensitively)
3797 msg = msg.MakeLower();
3798 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
3799 {
3800 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3801 continue;
3802 }
3803 }
3804 if (m_SelectedFilters & LOGFILTER_EMAILS)
3805 {
3806 CString msg = m_logEntries.GetGitRevAt(i).GetAuthorEmail();
3807 if (!m_bFilterCaseSensitively)
3808 msg = msg.MakeLower();
3809 if ((msg.Find(find) >= 0) && (IsEntryInDateRange(i)))
3810 {
3811 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3812 continue;
3813 }
3814 }
3815 if (m_SelectedFilters & LOGFILTER_REVS)
3816 {
3817 sRev = m_logEntries.GetGitRevAt(i).m_CommitHash.ToString();
3818 if ((sRev.Find(find) >= 0)&&(IsEntryInDateRange(i)))
3819 {
3820 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3821 continue;
3822 }
3823 }
3824 if ((m_SelectedFilters & LOGFILTER_REFNAME) && m_HashMap.find(m_logEntries.GetGitRevAt(i).m_CommitHash) != m_HashMap.cend())
3825 {
3826 const STRING_VECTOR& refs = m_HashMap[m_logEntries.GetGitRevAt(i).m_CommitHash];
3827 for (auto it = refs.cbegin(); it != refs.cend(); ++it)
3828 {
3829 if (it->Find(find) >= 0 && IsEntryInDateRange(i))
3830 {
3831 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
3832 continue;
3833 }
3834 }
3835 }
3836 } // else (from if (bRegex))
3837 } // for (DWORD i=0; i<m_logEntries.size(); ++i)
3838 }
3839
3840 BOOL CGitLogListBase::IsEntryInDateRange(int /*i*/)
3841 {
3842 /*
3843 __time64_t time = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
3844
3845 if(m_From == -1)
3846 if(m_To == -1)
3847 return true;
3848 else
3849 return time <= m_To;
3850 else
3851 if(m_To == -1)
3852 return time >= m_From;
3853 else
3854 return ((time >= m_From)&&(time <= m_To));
3855 */
3856 return TRUE; /* git dll will filter time range */
3857
3858 // return TRUE;
3859 }
3860
3861 void CGitLogListBase::StartFilter()
3862 {
3863 InterlockedExchange(&m_bNoDispUpdates, TRUE);
3864 RecalculateShownList(&m_arShownList);
3865 InterlockedExchange(&m_bNoDispUpdates, FALSE);
3866
3867
3868 DeleteAllItems();
3869 SetItemCountEx(ShownCountWithStopped());
3870 RedrawItems(0, ShownCountWithStopped());
3871 Invalidate();
3872 }
3873
3874 void CGitLogListBase::RemoveFilter()
3875 {
3876 InterlockedExchange(&m_bNoDispUpdates, TRUE);
3877
3878 m_arShownList.SafeRemoveAll();
3879
3880 // reset the time filter too
3881 #if 0
3882 m_timFrom = (__time64_t(m_tFrom));
3883 m_timTo = (__time64_t(m_tTo));
3884 m_DateFrom.SetTime(&m_timFrom);
3885 m_DateTo.SetTime(&m_timTo);
3886 m_DateFrom.SetRange(&m_timFrom, &m_timTo);
3887 m_DateTo.SetRange(&m_timFrom, &m_timTo);
3888 #endif
3889
3890 for (DWORD i=0; i<m_logEntries.size(); ++i)
3891 {
3892 if(this->m_IsOldFirst)
3893 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size()-i-1));
3894 else
3895 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
3896 }
3897 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
3898 DeleteAllItems();
3899 SetItemCountEx(ShownCountWithStopped());
3900 RedrawItems(0, ShownCountWithStopped());
3901
3902 InterlockedExchange(&m_bNoDispUpdates, FALSE);
3903 }
3904
3905 void CGitLogListBase::Clear()
3906 {
3907 m_arShownList.SafeRemoveAll();
3908 DeleteAllItems();
3909
3910 m_logEntries.ClearAll();
3911 }
3912
3913 void CGitLogListBase::OnDestroy()
3914 {
3915 SafeTerminateThread();
3916 SafeTerminateAsyncDiffThread();
3917
3918 int retry = 0;
3919 while(m_LogCache.SaveCache())
3920 {
3921 if(retry > 5)
3922 break;
3923 Sleep(1000);
3924
3925 ++retry;
3926
3927 //if(CMessageBox::Show(nullptr, L"Cannot Save Log Cache to Disk. To retry click yes. To give up click no.", L"TortoiseGit",
3928 // MB_YESNO) == IDNO)
3929 // break;
3930 }
3931
3932 __super::OnDestroy();
3933 }
3934
3935 LRESULT CGitLogListBase::OnLoad(WPARAM wParam,LPARAM /*lParam*/)
3936 {
3937 CRect rect;
3938 int i=(int)wParam;
3939 this->GetItemRect(i,&rect,LVIR_BOUNDS);
3940 this->InvalidateRect(rect);
3941
3942 return 0;
3943 }
3944
3945 /**
3946 * Save column widths to the registry
3947 */
3948 void CGitLogListBase::SaveColumnWidths()
3949 {
3950 // HACK that graph column is always shown
3951 SetColumnWidth(0, m_ColumnManager.GetWidth(0, false));
3952
3953 __super::SaveColumnWidths();
3954 }
3955
3956 int CGitLogListBase::GetHeadIndex()
3957 {
3958 if(m_HeadHash.IsEmpty())
3959 return -1;
3960
3961 for (size_t i = 0; i < m_arShownList.size(); ++i)
3962 {
3963 GitRev* pRev = m_arShownList.SafeGetAt(i);
3964 if(pRev)
3965 {
3966 if(pRev->m_CommitHash.ToString() == m_HeadHash )
3967 return (int)i;
3968 }
3969 }
3970 return -1;
3971 }
3972 void CGitLogListBase::OnFind()
3973 {
3974 if (!m_pFindDialog)
3975 {
3976 m_pFindDialog = new CFindDlg(this);
3977 m_pFindDialog->Create(this);
3978 }
3979 }
3980
3981 LRESULT CGitLogListBase::OnScrollToMessage(WPARAM itemToSelect, LPARAM /*lParam*/)
3982 {
3983 if (GetSelectedCount() != 0)
3984 return 0;
3985
3986 CGitHash theSelectedHash = m_lastSelectedHash;
3987 SetItemState((int)itemToSelect, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
3988 m_lastSelectedHash = theSelectedHash;
3989
3990 int countPerPage = GetCountPerPage();
3991 EnsureVisible(max(0, (int)itemToSelect-countPerPage/2), FALSE);
3992 EnsureVisible(min(GetItemCount(), (int)itemToSelect+countPerPage/2), FALSE);
3993 EnsureVisible((int)itemToSelect, FALSE);
3994 return 0;
3995 }
3996
3997 LRESULT CGitLogListBase::OnScrollToRef(WPARAM wParam, LPARAM /*lParam*/)
3998 {
3999 CString* ref = reinterpret_cast<CString*>(wParam);
4000 if (!ref || ref->IsEmpty())
4001 return 1;
4002
4003 bool bShift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
4004
4005 CGitHash hash;
4006 if (g_Git.GetHash(hash, *ref + L"^{}")) // add ^{} in order to get the correct SHA-1 (especially for signed tags)
4007 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of ref \"" + *ref + L"^{}\"."), L"TortoiseGit", MB_ICONERROR);
4008
4009 if (hash.IsEmpty())
4010 return 1;
4011
4012 bool bFound = false;
4013 int cnt = (int)m_arShownList.size();
4014 int i;
4015 for (i = 0; i < cnt; ++i)
4016 {
4017 GitRev* pLogEntry = m_arShownList.SafeGetAt(i);
4018 if (pLogEntry && pLogEntry->m_CommitHash == hash)
4019 {
4020 bFound = true;
4021 break;
4022 }
4023 }
4024 if (!bFound)
4025 return 1;
4026
4027 EnsureVisible(i, FALSE);
4028 if (!bShift)
4029 {
4030 SetItemState(GetSelectionMark(), 0, LVIS_SELECTED);
4031 SetItemState(i, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
4032 SetSelectionMark(i);
4033 }
4034 else
4035 {
4036 GitRev* pLogEntry = m_arShownList.SafeGetAt(i);
4037 if (pLogEntry)
4038 m_highlight = pLogEntry->m_CommitHash;
4039 }
4040 Invalidate();
4041 UpdateData(FALSE);
4042
4043 return 0;
4044 }
4045
4046 LRESULT CGitLogListBase::OnFindDialogMessage(WPARAM /*wParam*/, LPARAM /*lParam*/)
4047 {
4048 ASSERT(m_pFindDialog);
4049 bool bFound = false;
4050 int i=0;
4051
4052 if (m_pFindDialog->IsTerminating())
4053 {
4054 // invalidate the handle identifying the dialog box.
4055 m_pFindDialog = nullptr;
4056 return 0;
4057 }
4058
4059 int cnt = (int)m_arShownList.size();
4060 bool bShift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
4061
4062 if(m_pFindDialog->IsRef())
4063 {
4064 CString str;
4065 str=m_pFindDialog->GetFindString();
4066
4067 CGitHash hash;
4068
4069 if(!str.IsEmpty())
4070 {
4071 if (g_Git.GetHash(hash, str + L"^{}")) // add ^{} in order to get the correct SHA-1 (especially for signed tags)
4072 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of ref \"" + str + L"^{}\"."), L"TortoiseGit", MB_ICONERROR);
4073 }
4074
4075 if(!hash.IsEmpty())
4076 {
4077 for (i = 0; i < cnt; ++i)
4078 {
4079 GitRev* pLogEntry = m_arShownList.SafeGetAt(i);
4080 if(pLogEntry && pLogEntry->m_CommitHash == hash)
4081 {
4082 bFound = true;
4083 break;
4084 }
4085 }
4086 }
4087 if (!bFound)
4088 {
4089 m_pFindDialog->FlashWindowEx(FLASHW_ALL, 2, 100);
4090 return 0;
4091 }
4092 }
4093
4094 if (m_pFindDialog->FindNext() && !bFound)
4095 {
4096 //read data from dialog
4097 CString findText = m_pFindDialog->GetFindString();
4098 bool bMatchCase = (m_pFindDialog->MatchCase() == TRUE);
4099
4100 std::wregex pat;
4101 bool bRegex = false;
4102 if (m_pFindDialog->Regex())
4103 bRegex = ValidateRegexp(findText, pat, bMatchCase);
4104
4105 std::regex_constants::match_flag_type flags = std::regex_constants::match_not_null;
4106
4107 for (i = m_nSearchIndex + 1; ; ++i)
4108 {
4109 if (i >= cnt)
4110 {
4111 i = 0;
4112 m_pFindDialog->FlashWindowEx(FLASHW_ALL, 2, 100);
4113 }
4114 if (m_nSearchIndex >= 0)
4115 {
4116 if (i == m_nSearchIndex)
4117 {
4118 ::MessageBeep(0xFFFFFFFF);
4119 m_pFindDialog->FlashWindowEx(FLASHW_ALL, 3, 100);
4120 break;
4121 }
4122 }
4123
4124 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(i);
4125
4126 CString str;
4127 str+=pLogEntry->m_CommitHash.ToString();
4128 str += L'\n';
4129
4130 auto refList = m_HashMap.find(pLogEntry->m_CommitHash);
4131 if (refList != m_HashMap.cend())
4132 {
4133 for (const auto& ref : (*refList).second)
4134 {
4135 str += ref;
4136 str += L'\n';
4137 }
4138 }
4139
4140 str+=pLogEntry->GetAuthorEmail();
4141 str += L'\n';
4142 str+=pLogEntry->GetAuthorName();
4143 str += L'\n';
4144 str+=pLogEntry->GetBody();
4145 str += L'\n';
4146 str+=pLogEntry->GetCommitterEmail();
4147 str += L'\n';
4148 str+=pLogEntry->GetCommitterName();
4149 str += L'\n';
4150 str+=pLogEntry->GetSubject();
4151 str += L'\n';
4152 str+=pLogEntry->m_Notes;
4153 str += L'\n';
4154 str+=GetTagInfo(pLogEntry);
4155 str += L'\n';
4156
4157
4158 /*Because changed files list is loaded on demand when gui show,
4159 files will empty when files have not fetched.
4160
4161 we can add it back by using one-way diff(with outnumber changed and rename detect.
4162 here just need changed filename list. one-way is much quicker.
4163 */
4164 if(pLogEntry->m_IsFull)
4165 {
4166 for (int j = 0; j < pLogEntry->GetFiles(this).GetCount(); ++j)
4167 {
4168 str += pLogEntry->GetFiles(this)[j].GetWinPath();
4169 str += L'\n';
4170 str += pLogEntry->GetFiles(this)[j].GetGitOldPathString();
4171 str += L'\n';
4172 }
4173 }
4174 else
4175 {
4176 if(!pLogEntry->m_IsSimpleListReady)
4177 pLogEntry->SafeGetSimpleList(&g_Git);
4178
4179 for (size_t j = 0; j < pLogEntry->m_SimpleFileList.size(); ++j)
4180 {
4181 str += pLogEntry->m_SimpleFileList[j];
4182 str += L'\n';
4183 }
4184 }
4185
4186 if (bRegex)
4187 {
4188 if (std::regex_search(std::wstring(str), pat, flags))
4189 {
4190 bFound = true;
4191 break;
4192 }
4193 }
4194 else
4195 {
4196 if (bMatchCase)
4197 {
4198 if (str.Find(findText) >= 0)
4199 {
4200 bFound = true;
4201 break;
4202 }
4203 }
4204 else
4205 {
4206 CString msg = str;
4207 msg = msg.MakeLower();
4208 CString find = findText.MakeLower();
4209 if (msg.Find(find) >= 0)
4210 {
4211 bFound = TRUE;
4212 break;
4213 }
4214 }
4215 }
4216 } // for (i = this->m_nSearchIndex; i<m_arShownList.GetItemCount()&&!bFound; ++i)
4217
4218 } // if(m_pFindDialog->FindNext())
4219 //UpdateLogInfoLabel();
4220
4221 if (bFound)
4222 {
4223 m_nSearchIndex = i;
4224 EnsureVisible(i, FALSE);
4225 if (!bShift)
4226 {
4227 SetItemState(GetSelectionMark(), 0, LVIS_SELECTED);
4228 SetItemState(i, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
4229 SetSelectionMark(i);
4230 }
4231 else
4232 {
4233 GitRev* pLogEntry = m_arShownList.SafeGetAt(i);
4234 if (pLogEntry)
4235 m_highlight = pLogEntry->m_CommitHash;
4236 }
4237 Invalidate();
4238 //FillLogMessageCtrl();
4239 UpdateData(FALSE);
4240 }
4241
4242 return 0;
4243 }
4244
4245 INT_PTR CGitLogListBase::OnToolHitTest(CPoint point, TOOLINFO * pTI) const
4246 {
4247 LVHITTESTINFO lvhitTestInfo;
4248
4249 lvhitTestInfo.pt = point;
4250
4251 int nItem = ListView_SubItemHitTest(m_hWnd, &lvhitTestInfo);
4252 int nSubItem = lvhitTestInfo.iSubItem;
4253
4254 UINT nFlags = lvhitTestInfo.flags;
4255
4256 // nFlags is 0 if the SubItemHitTest fails
4257 // Therefore, 0 & <anything> will equal false
4258 if (nFlags & LVHT_ONITEM)
4259 {
4260 // Get the client area occupied by this control
4261 RECT rcClient;
4262 GetClientRect(&rcClient);
4263
4264 // Fill in the TOOLINFO structure
4265 pTI->hwnd = m_hWnd;
4266 pTI->uId = (UINT)((nItem<<10)+(nSubItem&0x3ff)+1);
4267 pTI->lpszText = LPSTR_TEXTCALLBACK;
4268 pTI->rect = rcClient;
4269
4270 return pTI->uId; // By returning a unique value per listItem,
4271 // we ensure that when the mouse moves over another list item,
4272 // the tooltip will change
4273 }
4274 else
4275 {
4276 // Otherwise, we aren't interested, so let the message propagate
4277 return -1;
4278 }
4279 }
4280
4281 BOOL CGitLogListBase::OnToolTipText(UINT /*id*/, NMHDR* pNMHDR, LRESULT* pResult)
4282 {
4283 TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
4284 TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
4285
4286 *pResult = 0;
4287
4288 // Ignore messages from the built in tooltip, we are processing them internally
4289 if ((pNMHDR->idFrom == (UINT_PTR)m_hWnd) &&
4290 (((pNMHDR->code == TTN_NEEDTEXTA) && (pTTTA->uFlags & TTF_IDISHWND)) ||
4291 ((pNMHDR->code == TTN_NEEDTEXTW) && (pTTTW->uFlags & TTF_IDISHWND))))
4292 return FALSE;
4293
4294 // Get the mouse position
4295 const MSG* pMessage = GetCurrentMessage();
4296
4297 CPoint pt;
4298 pt = pMessage->pt;
4299 ScreenToClient(&pt);
4300
4301 // Check if the point falls onto a list item
4302 LVHITTESTINFO lvhitTestInfo;
4303 lvhitTestInfo.pt = pt;
4304
4305 int nItem = SubItemHitTest(&lvhitTestInfo);
4306
4307 if (lvhitTestInfo.flags & LVHT_ONITEM)
4308 {
4309 // Get branch description first
4310 CString strTipText;
4311 if (lvhitTestInfo.iSubItem == LOGLIST_MESSAGE)
4312 {
4313 CString branch;
4314 CGit::REF_TYPE type = CGit::REF_TYPE::LOCAL_BRANCH;
4315 if (IsMouseOnRefLabel(m_arShownList.SafeGetAt(nItem), lvhitTestInfo.pt, type, &branch))
4316 {
4317 MAP_STRING_STRING descriptions;
4318 g_Git.GetBranchDescriptions(descriptions);
4319 if (descriptions.find(branch) != descriptions.cend())
4320 {
4321 strTipText.LoadString(IDS_DESCRIPTION);
4322 strTipText += L":\n";
4323 strTipText += descriptions[branch];
4324 }
4325 }
4326 }
4327
4328 bool followMousePos = false;
4329 if (!strTipText.IsEmpty())
4330 followMousePos = true;
4331 else
4332 strTipText = GetToolTipText(nItem, lvhitTestInfo.iSubItem);
4333 if (strTipText.IsEmpty())
4334 return FALSE;
4335
4336 // we want multiline tooltips
4337 ::SendMessage(pNMHDR->hwndFrom, TTM_SETMAXTIPWIDTH, 0, SHRT_MAX);
4338
4339 wcscpy_s(m_wszTip, strTipText);
4340 // handle Unicode as well as non-Unicode requests
4341 if (pNMHDR->code == TTN_NEEDTEXTA)
4342 {
4343 pTTTA->hinst = nullptr;
4344 pTTTA->lpszText = m_szTip;
4345 ::WideCharToMultiByte(CP_ACP, 0, m_wszTip, -1, m_szTip, 8192, nullptr, nullptr);
4346 }
4347 else
4348 {
4349 pTTTW->hinst = nullptr;
4350 pTTTW->lpszText = m_wszTip;
4351 }
4352
4353 CRect rect;
4354 GetSubItemRect(nItem, lvhitTestInfo.iSubItem, LVIR_LABEL, rect);
4355 if (followMousePos)
4356 rect.MoveToXY(pt.x, pt.y + 18); // 18: to act like a normal tooltip
4357 ClientToScreen(rect);
4358 ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, rect.left, rect.top, 0, 0, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOOWNERZORDER);
4359
4360 return TRUE; // We found a tool tip,
4361 // tell the framework this message has been handled
4362 }
4363
4364 return FALSE; // We didn't handle the message,
4365 // let the framework continue propagating the message
4366 }
4367
4368 CString CGitLogListBase::GetToolTipText(int nItem, int nSubItem)
4369 {
4370 if (nSubItem == LOGLIST_MESSAGE && !m_bTagsBranchesOnRightSide)
4371 {
4372 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(nItem);
4373 if (pLogEntry == nullptr)
4374 return CString();
4375 if (m_HashMap.find(pLogEntry->m_CommitHash) == m_HashMap.cend() && (m_superProjectHash.IsEmpty() || pLogEntry->m_CommitHash != m_superProjectHash))
4376 return CString();
4377 return pLogEntry->GetSubject();
4378 }
4379 else if (nSubItem == LOGLIST_DATE && m_bRelativeTimes)
4380 {
4381 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(nItem);
4382 if (pLogEntry == nullptr)
4383 return CString();
4384 return CLoglistUtils::FormatDateAndTime(pLogEntry->GetAuthorDate(), m_DateFormat, true, false);
4385 }
4386 else if (nSubItem == LOGLIST_COMMIT_DATE && m_bRelativeTimes)
4387 {
4388 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(nItem);
4389 if (pLogEntry == nullptr)
4390 return CString();
4391 return CLoglistUtils::FormatDateAndTime(pLogEntry->GetCommitterDate(), m_DateFormat, true, false);
4392 }
4393 else if (nSubItem == LOGLIST_ACTION)
4394 {
4395 GitRevLoglist* pLogEntry = m_arShownList.SafeGetAt(nItem);
4396 if (pLogEntry == nullptr)
4397 return CString();
4398
4399 if (!pLogEntry->m_IsDiffFiles)
4400 return CString(MAKEINTRESOURCE(IDS_PROC_LOG_FETCHINGFILES));
4401
4402 int actions = pLogEntry->GetAction(this);
4403 CString sToolTipText;
4404
4405 CString actionText;
4406 if (actions & CTGitPath::LOGACTIONS_MODIFIED)
4407 actionText += CTGitPath::GetActionName(CTGitPath::LOGACTIONS_MODIFIED);
4408
4409 if (actions & CTGitPath::LOGACTIONS_ADDED)
4410 {
4411 if (!actionText.IsEmpty())
4412 actionText += L"\r\n";
4413 actionText += CTGitPath::GetActionName(CTGitPath::LOGACTIONS_ADDED);
4414 }
4415
4416 if (actions & CTGitPath::LOGACTIONS_DELETED)
4417 {
4418 if (!actionText.IsEmpty())
4419 actionText += L"\r\n";
4420 actionText += CTGitPath::GetActionName(CTGitPath::LOGACTIONS_DELETED);
4421 }
4422
4423 if (actions & CTGitPath::LOGACTIONS_REPLACED)
4424 {
4425 if (!actionText.IsEmpty())
4426 actionText += L"\r\n";
4427 actionText += CTGitPath::GetActionName(CTGitPath::LOGACTIONS_REPLACED);
4428 }
4429
4430 if (actions & CTGitPath::LOGACTIONS_UNMERGED)
4431 {
4432 if (!actionText.IsEmpty())
4433 actionText += L"\r\n";
4434 actionText += CTGitPath::GetActionName(CTGitPath::LOGACTIONS_UNMERGED);
4435 }
4436
4437 if (!actionText.IsEmpty())
4438 {
4439 CString sTitle(MAKEINTRESOURCE(IDS_LOG_ACTIONS));
4440 sToolTipText = sTitle + L":\r\n" + actionText;
4441 }
4442 return sToolTipText;
4443 }
4444 return CString();
4445 }
4446
4447 bool CGitLogListBase::IsMouseOnRefLabelFromPopupMenu(const GitRevLoglist* pLogEntry, const CPoint& point, CGit::REF_TYPE& type, CString* pShortname /*nullptr*/, size_t* pIndex /*nullptr*/)
4448 {
4449 POINT pt = point;
4450 ScreenToClient(&pt);
4451 return IsMouseOnRefLabel(pLogEntry, pt, type, pShortname, pIndex);
4452 }
4453
4454 bool CGitLogListBase::IsMouseOnRefLabel(const GitRevLoglist* pLogEntry, const POINT& pt, CGit::REF_TYPE& type, CString* pShortname /*nullptr*/, size_t* pIndex /*nullptr*/)
4455 {
4456 if (!pLogEntry)
4457 return false;
4458
4459 auto refList = m_HashMap.find(pLogEntry->m_CommitHash);
4460 if (refList == m_HashMap.cend())
4461 return false;
4462
4463 for (size_t i = 0; i < m_HashMap[pLogEntry->m_CommitHash].size(); ++i)
4464 {
4465 const auto labelpos = m_RefLabelPosMap.find(m_HashMap[pLogEntry->m_CommitHash][i]);
4466 if (labelpos == m_RefLabelPosMap.cend() || !labelpos->second.PtInRect(pt))
4467 continue;
4468
4469 CGit::REF_TYPE foundType;
4470 if (pShortname)
4471 *pShortname = CGit::GetShortName(m_HashMap[pLogEntry->m_CommitHash][i], &foundType);
4472 else
4473 CGit::GetShortName(m_HashMap[pLogEntry->m_CommitHash][i], &foundType);
4474 if (foundType != type && type != CGit::REF_TYPE::UNKNOWN)
4475 return false;
4476
4477 type = foundType;
4478 if (pIndex)
4479 *pIndex = i;
4480 return true;
4481 }
4482 return false;
4483 }
4484
4485 void CGitLogListBase::OnBeginDrag(NMHDR* /*pnmhdr*/, LRESULT* pResult)
4486 {
4487 *pResult = 0;
4488
4489 if (!m_bDragndropEnabled || GetSelectedCount() == 0 || !IsSelectionContinuous())
4490 return;
4491
4492 m_bDragging = TRUE;
4493 m_nDropIndex = -1;
4494 m_nDropMarkerLast = -1;
4495 m_nDropMarkerLastHot = GetHotItem();
4496 SetCapture();
4497 }
4498
4499 void CGitLogListBase::OnMouseMove(UINT nFlags, CPoint point)
4500 {
4501 __super::OnMouseMove(nFlags, point);
4502
4503 if (!m_bDragging)
4504 return;
4505
4506 CPoint dropPoint = point;
4507 ClientToScreen(&dropPoint);
4508
4509 if (WindowFromPoint(dropPoint) != this)
4510 {
4511 SetCursor(LoadCursor(nullptr, IDC_NO));
4512 m_nDropIndex = -1;
4513 DrawDropInsertMarker(m_nDropIndex);
4514 return;
4515 }
4516
4517 SetCursor(LoadCursor(nullptr, IDC_ARROW));
4518 ScreenToClient(&dropPoint);
4519
4520 dropPoint.y += 10;
4521 m_nDropIndex = HitTest(dropPoint);
4522
4523 if (m_nDropIndex == -1) // might be last item, allow to move past last item
4524 {
4525 dropPoint.y -= 10;
4526 m_nDropIndex = HitTest(dropPoint);
4527 if (m_nDropIndex != -1)
4528 m_nDropIndex = GetItemCount();
4529 }
4530
4531 POSITION pos = GetFirstSelectedItemPosition();
4532 int first = GetNextSelectedItem(pos);
4533 int last = first;
4534 while (pos)
4535 last = GetNextSelectedItem(pos);
4536 if (m_nDropIndex == -1 || (m_nDropIndex >= first && m_nDropIndex - 1 <= last))
4537 {
4538 SetCursor(LoadCursor(nullptr, IDC_NO));
4539 m_nDropIndex = -1;
4540 }
4541
4542 // handle auto scrolling
4543 int hotItem = GetHotItem();
4544 int topindex = GetTopIndex();
4545 if (hotItem == topindex && hotItem != 0)
4546 EnsureVisible(hotItem - 1, FALSE);
4547 else if (hotItem >= topindex + GetCountPerPage() - 1 && hotItem + 1 < GetItemCount())
4548 EnsureVisible(hotItem + 1, FALSE);
4549
4550 DrawDropInsertMarker(m_nDropIndex);
4551 }
4552
4553 void CGitLogListBase::OnLButtonUp(UINT nFlags, CPoint point)
4554 {
4555 if (m_bDragging)
4556 {
4557 ::ReleaseCapture();
4558 SetCursor(LoadCursor(nullptr, IDC_HAND));
4559 m_bDragging = FALSE;
4560
4561 CRect rect;
4562 GetItemRect(m_nDropMarkerLast, &rect, 0);
4563 rect.bottom = rect.top + 2;
4564 rect.top -= 2;
4565 InvalidateRect(&rect, 0);
4566
4567 CPoint pt(point);
4568 ClientToScreen(&pt);
4569 if (WindowFromPoint(pt) == this && m_nDropIndex != -1)
4570 GetParent()->PostMessage(MSG_COMMITS_REORDERED, m_nDropIndex, 0);
4571 }
4572
4573 __super::OnLButtonUp(nFlags, point);
4574 }
4575
4576 void CGitLogListBase::DrawDropInsertMarker(int nIndex)
4577 {
4578 if (m_nDropMarkerLast != nIndex)
4579 {
4580 CRect rect;
4581 if (GetItemRect(m_nDropMarkerLast, &rect, 0))
4582 {
4583 rect.bottom = rect.top + 2;
4584 rect.top -= 2;
4585 InvalidateRect(&rect, 0);
4586 }
4587 else if (m_nDropMarkerLast == GetItemCount())
4588 DrawDropInsertMarkerLine(m_nDropMarkerLast); // double painting = removal
4589 m_nDropMarkerLast = nIndex;
4590
4591 if (nIndex < 0)
4592 return;
4593
4594 DrawDropInsertMarkerLine(m_nDropMarkerLast);
4595 }
4596 else if (m_nDropMarkerLastHot != GetHotItem())
4597 {
4598 m_nDropMarkerLastHot = GetHotItem();
4599 m_nDropMarkerLast = -1;
4600 }
4601 }
4602
4603 void CGitLogListBase::DrawDropInsertMarkerLine(int nIndex)
4604 {
4605 CBrush* pBrush = CDC::GetHalftoneBrush();
4606 CDC* pDC = GetDC();
4607
4608 CRect rect;
4609 if (nIndex < GetItemCount())
4610 {
4611 GetItemRect(nIndex, &rect, 0);
4612 rect.bottom = rect.top + 2;
4613 rect.top -= 2;
4614 }
4615 else
4616 {
4617 GetItemRect(nIndex - 1, &rect, 0);
4618 rect.top = rect.bottom - 2;
4619 rect.bottom += 2;
4620 }
4621
4622 CBrush* pBrushOld = pDC->SelectObject(pBrush);
4623 pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
4624 pDC->SelectObject(pBrushOld);
4625
4626 ReleaseDC(pDC);
4627 }
4628
4629 ULONG CGitLogListBase::GetGestureStatus(CPoint /*ptTouch*/)
4630 {
4631 return 0;
4632 }
Windows Explorer Extension to Operate Git