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