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