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