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