?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cleanup
[TortoiseGit.git] / src / TortoiseProc / GitLogListBase.cpp
blobbd243c98a3c306de5578912bf09fc9641eba5eac
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2012 - TortoiseGit
4 // Copyright (C) 2005-2007 Marco Costalba
5 // Copyright (C) 2011-2012 - Sven Strickroth <email@cs-ware.de>
6
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License
9 // as published by the Free Software Foundation; either version 2
10 // of the License, or (at your option) any later version.
11
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software Foundation,
19 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 //
21 // GitLogList.cpp : implementation file
22 //
23 #include "stdafx.h"
24 #include "resource.h"
25 #include "GitLogListBase.h"
26 #include "GitRev.h"
27 //#include "VssStyle.h"
28 #include "IconMenu.h"
29 // CGitLogListBase
30 #include "cursor.h"
31 #include "InputDlg.h"
32 #include "GITProgressDlg.h"
33 #include "ProgressDlg.h"
34 //#include "RepositoryBrowser.h"
35 //#include "CopyDlg.h"
36 //#include "StatGraphDlg.h"
37 #include "Logdlg.h"
38 #include "MessageBox.h"
39 #include "Registry.h"
40 #include "AppUtils.h"
41 #include "PathUtils.h"
42 #include "StringUtils.h"
43 #include "UnicodeUtils.h"
44 #include "TempFile.h"
45 //#include "GitInfo.h"
46 //#include "GitDiff.h"
47 #include "IconMenu.h"
48 //#include "RevisionRangeDlg.h"
49 //#include "BrowseFolder.h"
50 //#include "BlameDlg.h"
51 //#include "Blame.h"
52 //#include "GitHelpers.h"
53 #include "GitStatus.h"
54 //#include "LogDlgHelper.h"
55 //#include "CachedLogInfo.h"
56 //#include "RepositoryInfo.h"
57 //#include "EditPropertiesDlg.h"
58 #include "FileDiffDlg.h"
59 #include "..\\TortoiseShell\\Resource.h"
60 #include "FindDlg.h"
61 #include "SysInfo.h"
62
63 const UINT CGitLogListBase::m_FindDialogMessage = RegisterWindowMessage(FINDMSGSTRING);
64
65 IMPLEMENT_DYNAMIC(CGitLogListBase, CHintListCtrl)
66
67 CGitLogListBase::CGitLogListBase():CHintListCtrl()
68 ,m_regMaxBugIDColWidth(_T("Software\\TortoiseGit\\MaxBugIDColWidth"), 200)
69 ,m_nSearchIndex(0)
70 ,m_bNoDispUpdates(FALSE)
71 , m_bThreadRunning(FALSE)
72 , m_bStrictStopped(false)
73 , m_pStoreSelection(NULL)
74 , m_nSelectedFilter(LOGFILTER_ALL)
75 , m_bShowWC(false)
76 , m_logEntries(&m_LogCache)
77 , m_pFindDialog(NULL)
78 , m_ColumnManager(this)
79 , m_dwDefaultColumns(0)
80 , m_arShownList(&m_critSec)
81 , m_hasWC(true)
82 {
83 // use the default GUI font, create a copy of it and
84 // change the copy to BOLD (leave the rest of the font
85 // the same)
86 HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
87 LOGFONT lf = {0};
88 GetObject(hFont, sizeof(LOGFONT), &lf);
89 lf.lfWeight = FW_BOLD;
90 m_boldFont = CreateFontIndirect(&lf);
91
92 m_bShowBugtraqColumn=false;
93
94 m_IsIDReplaceAction=FALSE;
95
96 this->m_critSec.Init();
97 m_wcRev.m_CommitHash.Empty();
98 m_wcRev.GetSubject()=_T("Working dir changes");
99 m_wcRev.m_ParentHash.clear();
100 m_wcRev.m_Mark=_T('-');
101 m_wcRev.m_IsUpdateing=FALSE;
102 m_wcRev.m_IsFull = TRUE;
103
104 m_hModifiedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONMODIFIED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
105 m_hReplacedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONREPLACED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
106 m_hAddedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONADDED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
107 m_hDeletedIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONDELETED), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
108 m_hFetchIcon = (HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ACTIONFETCHING), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
109
110 m_bFilterWithRegex = !!CRegDWORD(_T("Software\\TortoiseGit\\UseRegexFilter"), TRUE);
111
112 g_Git.GetMapHashToFriendName(m_HashMap);
113 m_CurrentBranch=g_Git.GetCurrentBranch();
114 this->m_HeadHash=g_Git.GetHash(_T("HEAD"));
115
116 m_From=-1;;
117 m_To=-1;
118
119 m_ShowMask = 0;
120 m_LoadingThread = NULL;
121
122 InterlockedExchange(&m_bExitThread,FALSE);
123 m_IsOldFirst = FALSE;
124 m_IsRebaseReplaceGraph = FALSE;
125
126
127 for(int i=0;i<Lanes::COLORS_NUM;i++)
128 {
129 m_LineColors[i] = m_Colors.GetColor((CColors::Colors)(CColors::BranchLine1+i));
130 }
131 // get short/long datetime setting from registry
132 DWORD RegUseShortDateFormat = CRegDWORD(_T("Software\\TortoiseGit\\LogDateFormat"), TRUE);
133 if ( RegUseShortDateFormat )
134 {
135 m_DateFormat = DATE_SHORTDATE;
136 }
137 else
138 {
139 m_DateFormat = DATE_LONGDATE;
140 }
141 // get relative time display setting from registry
142 DWORD regRelativeTimes = CRegDWORD(_T("Software\\TortoiseGit\\RelativeTimes"), FALSE);
143 m_bRelativeTimes = (regRelativeTimes != 0);
144 m_ContextMenuMask = 0xFFFFFFFFFFFFFFFF;
145
146 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_PICK);
147 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_SQUASH);
148 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_EDIT);
149 m_ContextMenuMask &= ~GetContextMenuBit(ID_REBASE_SKIP);
150 m_ContextMenuMask &= ~GetContextMenuBit(ID_LOG);
151 m_ContextMenuMask &= ~GetContextMenuBit(ID_BLAME);
152
153 m_ColumnRegKey=_T("log");
154
155 m_AsyncThreadExit = FALSE;
156 m_AsyncDiffEvent = ::CreateEvent(NULL,FALSE,TRUE,NULL);
157 m_AsynDiffListLock.Init();
158
159 m_DiffingThread = AfxBeginThread(AsyncThread, this, THREAD_PRIORITY_BELOW_NORMAL);
160 if (m_DiffingThread ==NULL)
161 {
162 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
163 return;
164 }
165
166 }
167
168 int CGitLogListBase::AsyncDiffThread()
169 {
170 m_AsyncThreadExited = false;
171 while(!m_AsyncThreadExit)
172 {
173 ::WaitForSingleObject(m_AsyncDiffEvent, INFINITE);
174
175 GitRev *pRev = NULL;
176 while(!m_AsyncThreadExit && m_AsynDiffList.size() > 0)
177 {
178 m_AsynDiffListLock.Lock();
179 pRev = m_AsynDiffList.back();
180 m_AsynDiffList.pop_back();
181 m_AsynDiffListLock.Unlock();
182
183 if( pRev->m_CommitHash.IsEmpty() )
184 {
185 if(pRev->m_IsDiffFiles)
186 continue;
187
188 pRev->GetFiles(this).Clear();
189 pRev->m_ParentHash.clear();
190 pRev->m_ParentHash.push_back(m_HeadHash);
191 if(g_Git.IsInitRepos())
192 {
193 g_Git.GetInitAddList(pRev->GetFiles(this));
194
195 }
196 else
197 {
198 g_Git.GetCommitDiffList(pRev->m_CommitHash.ToString(),this->m_HeadHash.ToString(), pRev->GetFiles(this));
199 }
200 pRev->GetAction(this) = 0;
201
202 for(int j=0;j< pRev->GetFiles(this).GetCount();j++)
203 pRev->GetAction(this) |= pRev->GetFiles(this)[j].m_Action;
204
205 InterlockedExchange(&pRev->m_IsDiffFiles, TRUE);
206 InterlockedExchange(&pRev->m_IsFull, TRUE);
207
208 pRev->GetBody().Format(_T("%d files changed"),pRev->GetFiles(this).GetCount());
209 ::PostMessage(m_hWnd,MSG_LOADED,(WPARAM)0,0);
210 this->GetParent()->PostMessage(WM_COMMAND, MSG_FETCHED_DIFF, 0);
211 }
212
213 if(!pRev->CheckAndDiff())
214 { // fetch change file list
215 for(int i=GetTopIndex(); !m_AsyncThreadExit && i <= GetTopIndex()+GetCountPerPage(); i++)
216 {
217 if(i < m_arShownList.GetCount())
218 {
219 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(i);
220 if(data->m_CommitHash == pRev->m_CommitHash)
221 {
222 ::PostMessage(m_hWnd,MSG_LOADED,(WPARAM)i,0);
223 break;
224 }
225 }
226 }
227
228 if(!m_AsyncThreadExit && GetSelectedCount() == 1)
229 {
230 POSITION pos = GetFirstSelectedItemPosition();
231 int nItem = GetNextSelectedItem(pos);
232
233 if(nItem>=0)
234 {
235 GitRev* data = (GitRev*)m_arShownList[nItem];
236 if(data)
237 if(data->m_CommitHash == pRev->m_CommitHash)
238 {
239 this->GetParent()->PostMessage(WM_COMMAND, MSG_FETCHED_DIFF, 0);
240 }
241 }
242 }
243 }
244 }
245 }
246 m_AsyncThreadExited = true;
247 return 0;
248 }
249 void CGitLogListBase::hideFromContextMenu(unsigned __int64 hideMask, bool exclusivelyShow)
250 {
251 if (exclusivelyShow)
252 {
253 m_ContextMenuMask &= hideMask;
254 }
255 else
256 {
257 m_ContextMenuMask &= ~hideMask;
258 }
259 }
260
261 CGitLogListBase::~CGitLogListBase()
262 {
263 InterlockedExchange(&m_bNoDispUpdates, TRUE);
264 this->m_arShownList.SafeRemoveAll();
265
266 DestroyIcon(m_hModifiedIcon);
267 DestroyIcon(m_hReplacedIcon);
268 DestroyIcon(m_hAddedIcon);
269 DestroyIcon(m_hDeletedIcon);
270 m_logEntries.ClearAll();
271
272 if (m_boldFont)
273 DeleteObject(m_boldFont);
274
275 if ( m_pStoreSelection )
276 {
277 delete m_pStoreSelection;
278 m_pStoreSelection = NULL;
279 }
280
281 SafeTerminateThread();
282 SafeTerminateAsyncDiffThread();
283
284 if(m_AsyncDiffEvent)
285 CloseHandle(m_AsyncDiffEvent);
286 }
287
288
289 BEGIN_MESSAGE_MAP(CGitLogListBase, CHintListCtrl)
290 ON_REGISTERED_MESSAGE(m_FindDialogMessage, OnFindDialogMessage)
291 ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnNMCustomdrawLoglist)
292 ON_NOTIFY_REFLECT(LVN_GETDISPINFO, OnLvnGetdispinfoLoglist)
293 ON_WM_CONTEXTMENU()
294 ON_NOTIFY_REFLECT(NM_DBLCLK, OnNMDblclkLoglist)
295 ON_NOTIFY_REFLECT(LVN_ODFINDITEM,OnLvnOdfinditemLoglist)
296 ON_WM_CREATE()
297 ON_WM_DESTROY()
298 ON_MESSAGE(MSG_LOADED,OnLoad)
299 ON_WM_MEASUREITEM()
300 ON_WM_MEASUREITEM_REFLECT()
301 ON_NOTIFY(HDN_BEGINTRACKA, 0, OnHdnBegintrack)
302 ON_NOTIFY(HDN_BEGINTRACKW, 0, OnHdnBegintrack)
303 ON_NOTIFY(HDN_ITEMCHANGINGA, 0, OnHdnItemchanging)
304 ON_NOTIFY(HDN_ITEMCHANGINGW, 0, OnHdnItemchanging)
305 ON_NOTIFY(HDN_ENDTRACK, 0, OnColumnResized)
306 ON_NOTIFY(HDN_ENDDRAG, 0, OnColumnMoved)
307 END_MESSAGE_MAP()
308
309 void CGitLogListBase::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
310 {
311 //if (m_nRowHeight>0)
312 {
313 lpMeasureItemStruct->itemHeight = 50;
314 }
315 }
316
317 int CGitLogListBase:: OnCreate(LPCREATESTRUCT lpCreateStruct)
318 {
319 PreSubclassWindow();
320 return CHintListCtrl::OnCreate(lpCreateStruct);
321 }
322
323 void CGitLogListBase::PreSubclassWindow()
324 {
325 SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_SUBITEMIMAGES);
326 // load the icons for the action columns
327 // m_Theme.Open(m_hWnd, L"ListView");
328 SetWindowTheme(m_hWnd, L"Explorer", NULL);
329 CHintListCtrl::PreSubclassWindow();
330 }
331
332 void CGitLogListBase::InsertGitColumn()
333 {
334 CString temp;
335
336 CRegDWORD regFullRowSelect(_T("Software\\TortoiseGit\\FullRowSelect"), TRUE);
337 DWORD exStyle = LVS_EX_HEADERDRAGDROP | LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP | LVS_EX_SUBITEMIMAGES;
338 if (DWORD(regFullRowSelect))
339 exStyle |= LVS_EX_FULLROWSELECT;
340 SetExtendedStyle(exStyle);
341
342 UpdateProjectProperties();
343
344 static UINT normal[] =
345 {
346 IDS_LOG_GRAPH,
347 IDS_LOG_REBASE,
348 IDS_LOG_ID,
349 IDS_LOG_HASH,
350 IDS_LOG_ACTIONS,
351 IDS_LOG_MESSAGE,
352 IDS_LOG_AUTHOR,
353 IDS_LOG_DATE,
354 IDS_LOG_EMAIL,
355 IDS_LOG_COMMIT_NAME,
356 IDS_LOG_COMMIT_EMAIL,
357 IDS_LOG_COMMIT_DATE,
358 IDS_LOG_BUGIDS,
359 };
360
361 static int with[] =
362 {
363 ICONITEMBORDER+16*4,
364 ICONITEMBORDER+16*4,
365 ICONITEMBORDER+16*4,
366 ICONITEMBORDER+16*4,
367 ICONITEMBORDER+16*4,
368 LOGLIST_MESSAGE_MIN,
369 ICONITEMBORDER+16*4,
370 ICONITEMBORDER+16*4,
371 ICONITEMBORDER+16*4,
372 ICONITEMBORDER+16*4,
373 ICONITEMBORDER+16*4,
374 ICONITEMBORDER+16*4,
375 ICONITEMBORDER+16*4,
376 };
377 m_dwDefaultColumns = GIT_LOG_GRAPH|GIT_LOG_ACTIONS|GIT_LOG_MESSAGE|GIT_LOG_AUTHOR|GIT_LOG_DATE;
378
379 DWORD hideColumns = 0;
380 if(this->m_IsRebaseReplaceGraph)
381 {
382 hideColumns |= GIT_LOG_GRAPH;
383 m_dwDefaultColumns |= GIT_LOG_REBASE;
384 }
385 else
386 {
387 hideColumns |= GIT_LOG_REBASE;
388 }
389
390 if(this->m_IsIDReplaceAction)
391 {
392 hideColumns |= GIT_LOG_ACTIONS;
393 m_dwDefaultColumns |= GIT_LOG_ID;
394 m_dwDefaultColumns |= GIT_LOG_HASH;
395 }
396 else
397 {
398 hideColumns |= GIT_LOG_ID;
399 }
400 if(this->m_bShowBugtraqColumn)
401 {
402 m_dwDefaultColumns |= GIT_LOGLIST_BUG;
403 }
404 else
405 {
406 hideColumns |= GIT_LOGLIST_BUG;
407 }
408 SetRedraw(false);
409
410 m_ColumnManager.SetNames(normal, _countof(normal));
411 m_ColumnManager.ReadSettings(m_dwDefaultColumns, hideColumns, m_ColumnRegKey+_T("loglist"), _countof(normal), with);
412
413 SetRedraw(true);
414
415 }
416
417 /**
418 * Resizes all columns in a list control to values in registry.
419 */
420 void CGitLogListBase::ResizeAllListCtrlCols()
421 {
422 // column max and min widths to allow
423 static const int nMinimumWidth = 10;
424 static const int nMaximumWidth = 1000;
425 CHeaderCtrl* pHdrCtrl = (CHeaderCtrl*)(GetDlgItem(0));
426 if (pHdrCtrl)
427 {
428 int numcols = pHdrCtrl->GetItemCount();
429 for (int col = 0; col < numcols; col++)
430 {
431 // get width for this col last time from registry
432 CString regentry;
433 regentry.Format( _T("Software\\TortoiseGit\\%s\\ColWidth%d"),m_ColumnRegKey, col);
434 CRegDWORD regwidth(regentry, 0);
435 int cx = regwidth;
436 if ( cx == 0 )
437 {
438 // no saved value, setup sensible defaults
439 if (col == this->LOGLIST_MESSAGE)
440 {
441 cx = LOGLIST_MESSAGE_MIN;
442 }
443 else
444 {
445 cx = ICONITEMBORDER+16*4;
446 }
447 }
448 if (cx < nMinimumWidth)
449 {
450 cx = nMinimumWidth;
451 }
452 else if (cx > nMaximumWidth)
453 {
454 cx = nMaximumWidth;
455 }
456
457 SetColumnWidth(col, cx);
458 }
459 }
460
461 }
462
463
464 BOOL CGitLogListBase::GetShortName(CString ref, CString &shortname,CString prefix)
465 {
466 //TRACE(_T("%s %s\r\n"),ref,prefix);
467 if(ref.Left(prefix.GetLength()) == prefix)
468 {
469 shortname = ref.Right(ref.GetLength()-prefix.GetLength());
470 if(shortname.Right(3)==_T("^{}"))
471 shortname=shortname.Left(shortname.GetLength()-3);
472 return TRUE;
473 }
474 return FALSE;
475 }
476
477 void CGitLogListBase::FillBackGround(HDC hdc, int Index,CRect &rect)
478 {
479 LVITEM rItem;
480 SecureZeroMemory(&rItem, sizeof(LVITEM));
481 rItem.mask = LVIF_STATE;
482 rItem.iItem = Index;
483 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
484 GetItem(&rItem);
485
486 GitRev* pLogEntry = (GitRev*)m_arShownList.SafeGetAt(Index);
487 HBRUSH brush = NULL;
488
489 if (!(rItem.state & LVIS_SELECTED))
490 {
491 if(pLogEntry->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_SQUASH)
492 brush = ::CreateSolidBrush(RGB(156,156,156));
493 else if(pLogEntry->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_EDIT)
494 brush = ::CreateSolidBrush(RGB(200,200,128));
495 }
496 else if (!(IsAppThemed() && SysInfo::Instance().IsVistaOrLater()))
497 {
498 if (rItem.state & LVIS_SELECTED)
499 {
500 if (::GetFocus() == m_hWnd)
501 brush = ::CreateSolidBrush(::GetSysColor(COLOR_HIGHLIGHT));
502 else
503 brush = ::CreateSolidBrush(::GetSysColor(COLOR_BTNFACE));
504 }
505 }
506
507 if (brush != NULL)
508 {
509 ::FillRect(hdc, &rect, brush);
510 ::DeleteObject(brush);
511 }
512 }
513
514 void CGitLogListBase::DrawTagBranch(HDC hdc,CRect &rect,INT_PTR index)
515 {
516 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(index);
517 CRect rt=rect;
518 LVITEM rItem;
519 SecureZeroMemory(&rItem, sizeof(LVITEM));
520 rItem.mask = LVIF_STATE;
521 rItem.iItem = index;
522 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
523 GetItem(&rItem);
524
525 CDC W_Dc;
526 W_Dc.Attach(hdc);
527
528 HTHEME hTheme = NULL;
529 if (IsAppThemed() && SysInfo::Instance().IsVistaOrLater())
530 hTheme = OpenThemeData(m_hWnd, L"Explorer::ListView;ListView");
531
532 for(unsigned int i=0;i<m_HashMap[data->m_CommitHash].size();i++)
533 {
534 CString str;
535 str=m_HashMap[data->m_CommitHash][i];
536
537 CString shortname;
538 HBRUSH brush = 0;
539 shortname = _T("");
540 COLORREF colRef = 0;
541
542 //Determine label color
543 if(GetShortName(str,shortname,_T("refs/heads/")))
544 {
545 if( shortname == m_CurrentBranch )
546 colRef = m_Colors.GetColor(CColors::CurrentBranch);
547 else
548 colRef = m_Colors.GetColor(CColors::LocalBranch);
549
550 }
551 else if(GetShortName(str,shortname,_T("refs/remotes/")))
552 {
553 colRef = m_Colors.GetColor(CColors::RemoteBranch);
554 }
555 else if(GetShortName(str,shortname,_T("refs/tags/")))
556 {
557 colRef = m_Colors.GetColor(CColors::Tag);
558 }
559 else if(GetShortName(str,shortname,_T("refs/stash")))
560 {
561 colRef = m_Colors.GetColor(CColors::Stash);
562 shortname=_T("stash");
563 }
564 else if(GetShortName(str,shortname,_T("refs/bisect/")))
565 {
566 if(shortname.Find(_T("good")) == 0)
567 {
568 colRef = m_Colors.GetColor(CColors::BisectGood);
569 shortname = _T("good");
570 }
571
572 if(shortname.Find(_T("bad")) == 0)
573 {
574 colRef = m_Colors.GetColor(CColors::BisectBad);
575 shortname = _T("bad");
576 }
577 }
578
579 //When row selected, ajust label color
580 if (!(IsAppThemed() && SysInfo::Instance().IsVistaOrLater()))
581 if (rItem.state & LVIS_SELECTED)
582 colRef = CColors::MixColors(colRef, ::GetSysColor(COLOR_HIGHLIGHT), 150);
583
584 brush = ::CreateSolidBrush(colRef);
585
586 if(!shortname.IsEmpty() && (rt.left<rect.right) )
587 {
588 SIZE size;
589 memset(&size,0,sizeof(SIZE));
590 GetTextExtentPoint32(hdc, shortname,shortname.GetLength(),&size);
591
592 rt.SetRect(rt.left,rt.top,rt.left+size.cx,rt.bottom);
593 rt.right+=8;
594
595 int textpos = DT_CENTER;
596
597 if(rt.right > rect.right)
598 {
599 rt.right = rect.right;
600 textpos =0;
601 }
602
603 //Fill interior of ref label
604 ::FillRect(hdc, &rt, brush);
605
606 //Draw edge of label
607
608 CRect rectEdge = rt;
609
610 W_Dc.Draw3dRect(rectEdge, m_Colors.Lighten(colRef,100), m_Colors.Darken(colRef,100));
611 rectEdge.DeflateRect(1,1);
612 W_Dc.Draw3dRect(rectEdge, m_Colors.Lighten(colRef,50), m_Colors.Darken(colRef,50));
613
614 //Draw text inside label
615 if (IsAppThemed() && SysInfo::Instance().IsVistaOrLater())
616 {
617 int txtState = LISS_NORMAL;
618 if (rItem.state & LVIS_SELECTED)
619 txtState = LISS_SELECTED;
620
621 DrawThemeText(hTheme,hdc, LVP_LISTITEM, txtState, shortname, -1, textpos | DT_SINGLELINE | DT_VCENTER, 0, &rt);
622 }
623 else
624 {
625 W_Dc.SetBkMode(TRANSPARENT);
626 if (rItem.state & LVIS_SELECTED)
627 {
628 COLORREF clrNew = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
629 COLORREF clrOld = ::SetTextColor(hdc,clrNew);
630 ::DrawText(hdc,shortname,shortname.GetLength(),&rt,textpos | DT_SINGLELINE | DT_VCENTER);
631 ::SetTextColor(hdc,clrOld);
632 }
633 else
634 {
635 ::DrawText(hdc,shortname,shortname.GetLength(),&rt,textpos | DT_SINGLELINE | DT_VCENTER);
636 }
637 }
638
639 //::MoveToEx(hdc,rt.left,rt.top,NULL);
640 //::LineTo(hdc,rt.right,rt.top);
641 //::LineTo(hdc,rt.right,rt.bottom);
642 //::LineTo(hdc,rt.left,rt.bottom);
643 //::LineTo(hdc,rt.left,rt.top);
644
645 rt.left=rt.right+1;
646 }
647 if(brush)
648 ::DeleteObject(brush);
649 }
650 rt.right=rect.right;
651
652 if (IsAppThemed() && SysInfo::Instance().IsVistaOrLater())
653 {
654 int txtState = LISS_NORMAL;
655 if (rItem.state & LVIS_SELECTED)
656 txtState = LISS_SELECTED;
657
658 DrawThemeText(hTheme,hdc, LVP_LISTITEM, txtState, data->GetSubject(), -1, DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER, 0, &rt);
659 }
660 else
661 {
662 if (rItem.state & LVIS_SELECTED)
663 {
664 COLORREF clrOld = ::SetTextColor(hdc,::GetSysColor(COLOR_HIGHLIGHTTEXT));
665 ::DrawText(hdc,data->GetSubject(),data->GetSubject().GetLength(),&rt,DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER);
666 ::SetTextColor(hdc,clrOld);
667 }
668 else
669 {
670 ::DrawText(hdc,data->GetSubject(),data->GetSubject().GetLength(),&rt,DT_NOPREFIX | DT_LEFT | DT_SINGLELINE | DT_VCENTER);
671 }
672 }
673
674 if (hTheme)
675 CloseThemeData(hTheme);
676
677 W_Dc.Detach();
678 }
679
680 static COLORREF blend(const COLORREF& col1, const COLORREF& col2, int amount = 128) {
681
682 // Returns ((256 - amount)*col1 + amount*col2) / 256;
683 return RGB(((256 - amount)*GetRValue(col1) + amount*GetRValue(col2) ) / 256,
684 ((256 - amount)*GetGValue(col1) + amount*GetGValue(col2) ) / 256,
685 ((256 - amount)*GetBValue(col1) + amount*GetBValue(col2) ) / 256);
686 }
687
688 Gdiplus::Color GetGdiColor(COLORREF col)
689 {
690 return Gdiplus::Color(GetRValue(col),GetGValue(col),GetBValue(col));
691 }
692 void CGitLogListBase::paintGraphLane(HDC hdc, int laneHeight,int type, int x1, int x2,
693 const COLORREF& col,const COLORREF& activeColor, int top
694 )
695 {
696 int h = laneHeight / 2;
697 int m = (x1 + x2) / 2;
698 int r = (x2 - x1) / 3;
699 int d = 2 * r;
700
701 #define P_CENTER m , h+top
702 #define P_0 x2, h+top
703 #define P_90 m , 0+top-1
704 #define P_180 x1, h+top
705 #define P_270 m , 2 * h+top +1
706 #define R_CENTER m - r, h - r+top, d, d
707
708
709 #define DELTA_UR_B 2*(x1 - m), 2*h +top
710 #define DELTA_UR_E 0*16, 90*16 +top // -,
711
712 #define DELTA_DR_B 2*(x1 - m), 2*-h +top
713 #define DELTA_DR_E 270*16, 90*16 +top // -'
714
715 #define DELTA_UL_B 2*(x2 - m), 2*h +top
716 #define DELTA_UL_E 90*16, 90*16 +top // ,-
717
718 #define DELTA_DL_B 2*(x2 - m),2*-h +top
719 #define DELTA_DL_E 180*16, 90*16 // '-
720
721 #define CENTER_UR x1, 2*h, 225
722 #define CENTER_DR x1, 0 , 135
723 #define CENTER_UL x2, 2*h, 315
724 #define CENTER_DL x2, 0 , 45
725
726
727 Gdiplus::Graphics graphics( hdc );
728
729 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
730
731 // arc
732 switch (type) {
733 case Lanes::JOIN:
734 case Lanes::JOIN_R:
735 case Lanes::HEAD:
736 case Lanes::HEAD_R:
737 {
738 Gdiplus::LinearGradientBrush gradient(
739 Gdiplus::Point(x1-2, h+top-2),
740 Gdiplus::Point(P_270),
741 GetGdiColor(activeColor),GetGdiColor(col));
742
743
744 Gdiplus::Pen mypen(&gradient,2);
745 //Gdiplus::Pen mypen(Gdiplus::Color(0,0,0),2);
746
747 //graphics.DrawRectangle(&mypen,x1-(x2-x1)/2,top+h, x2-x1,laneHeight);
748 graphics.DrawArc(&mypen,x1-(x2-x1)/2-1,top+h-1, x2-x1,laneHeight,270,90);
749 //graphics.DrawLine(&mypen,x1-1,h+top,P_270);
750
751 break;
752 }
753 case Lanes::JOIN_L:
754 {
755
756 Gdiplus::LinearGradientBrush gradient(
757 Gdiplus::Point(P_270),
758 Gdiplus::Point(x2+1, h+top-1),
759 GetGdiColor(col),GetGdiColor(activeColor));
760
761
762 Gdiplus::Pen mypen(&gradient,2);
763 //Gdiplus::Pen mypen(Gdiplus::Color(0,0,0),2);
764
765 //graphics.DrawRectangle(&mypen,x1-(x2-x1)/2,top+h, x2-x1,laneHeight);
766 graphics.DrawArc(&mypen,x1+(x2-x1)/2,top+h-1, x2-x1,laneHeight,180,90);
767 //graphics.DrawLine(&mypen,x1-1,h+top,P_270);
768
769
770 break;
771 }
772 case Lanes::TAIL:
773 case Lanes::TAIL_R:
774 {
775
776 Gdiplus::LinearGradientBrush gradient(
777 Gdiplus::Point(x1-2, h+top-2),
778 Gdiplus::Point(P_90),
779 GetGdiColor(activeColor),GetGdiColor(col));
780
781 Gdiplus::Pen mypen(&gradient,2);
782
783 graphics.DrawArc(&mypen,x1-(x2-x1)/2-1,top-h-1, x2-x1,laneHeight,0,90);
784
785 #if 0
786 QConicalGradient gradient(CENTER_DR);
787 gradient.setColorAt(0.375, activeCol);
788 gradient.setColorAt(0.625, col);
789 myPen.setBrush(gradient);
790 p->setPen(myPen);
791 p->drawArc(P_CENTER, DELTA_DR);
792 #endif
793 break;
794 }
795 default:
796 break;
797 }
798
799
800 //static QPen myPen(Qt::black, 2); // fast path here
801 CPen pen;
802 pen.CreatePen(PS_SOLID,2,col);
803 //myPen.setColor(col);
804 HPEN oldpen=(HPEN)::SelectObject(hdc,(HPEN)pen);
805
806 Gdiplus::Pen myPen(GetGdiColor(col),2);
807
808 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
809
810 //p->setPen(myPen);
811
812 // vertical line
813 switch (type) {
814 case Lanes::ACTIVE:
815 case Lanes::NOT_ACTIVE:
816 case Lanes::MERGE_FORK:
817 case Lanes::MERGE_FORK_R:
818 case Lanes::MERGE_FORK_L:
819 case Lanes::JOIN:
820 case Lanes::JOIN_R:
821 case Lanes::JOIN_L:
822 case Lanes::CROSS:
823 //DrawLine(hdc,P_90,P_270);
824 graphics.DrawLine(&myPen,P_90,P_270);
825 //p->drawLine(P_90, P_270);
826 break;
827 case Lanes::HEAD_L:
828 case Lanes::BRANCH:
829 //DrawLine(hdc,P_CENTER,P_270);
830 graphics.DrawLine(&myPen,P_CENTER,P_270);
831 //p->drawLine(P_CENTER, P_270);
832 break;
833 case Lanes::TAIL_L:
834 case Lanes::INITIAL:
835 case Lanes::BOUNDARY:
836 case Lanes::BOUNDARY_C:
837 case Lanes::BOUNDARY_R:
838 case Lanes::BOUNDARY_L:
839 //DrawLine(hdc,P_90, P_CENTER);
840 graphics.DrawLine(&myPen,P_90,P_CENTER);
841 //p->drawLine(P_90, P_CENTER);
842 break;
843 default:
844 break;
845 }
846
847 myPen.SetColor(GetGdiColor(activeColor));
848
849 // horizontal line
850 switch (type) {
851 case Lanes::MERGE_FORK:
852 case Lanes::JOIN:
853 case Lanes::HEAD:
854 case Lanes::TAIL:
855 case Lanes::CROSS:
856 case Lanes::CROSS_EMPTY:
857 case Lanes::BOUNDARY_C:
858 //DrawLine(hdc,P_180,P_0);
859 graphics.DrawLine(&myPen,P_180,P_0);
860 //p->drawLine(P_180, P_0);
861 break;
862 case Lanes::MERGE_FORK_R:
863 case Lanes::BOUNDARY_R:
864 //DrawLine(hdc,P_180,P_CENTER);
865 graphics.DrawLine(&myPen,P_180,P_CENTER);
866 //p->drawLine(P_180, P_CENTER);
867 break;
868 case Lanes::MERGE_FORK_L:
869 case Lanes::HEAD_L:
870 case Lanes::TAIL_L:
871 case Lanes::BOUNDARY_L:
872 //DrawLine(hdc,P_CENTER,P_0);
873 graphics.DrawLine(&myPen,P_CENTER,P_0);
874 //p->drawLine(P_CENTER, P_0);
875 break;
876 default:
877 break;
878 }
879
880 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
881
882 CBrush brush;
883 brush.CreateSolidBrush(col);
884 HBRUSH oldbrush=(HBRUSH)::SelectObject(hdc,(HBRUSH)brush);
885
886 Gdiplus::SolidBrush myBrush(GetGdiColor(col));
887 // center symbol, e.g. rect or ellipse
888 switch (type) {
889 case Lanes::ACTIVE:
890 case Lanes::INITIAL:
891 case Lanes::BRANCH:
892
893 //p->setPen(Qt::NoPen);
894 //p->setBrush(col);
895 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
896 graphics.FillEllipse(&myBrush, R_CENTER);
897 //p->drawEllipse(R_CENTER);
898 break;
899 case Lanes::MERGE_FORK:
900 case Lanes::MERGE_FORK_R:
901 case Lanes::MERGE_FORK_L:
902 //p->setPen(Qt::NoPen);
903 //p->setBrush(col);
904 //p->drawRect(R_CENTER);
905 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
906 graphics.FillRectangle(&myBrush, R_CENTER);
907 break;
908 case Lanes::UNAPPLIED:
909 // Red minus sign
910 //p->setPen(Qt::NoPen);
911 //p->setBrush(Qt::red);
912 //p->drawRect(m - r, h - 1, d, 2);
913 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
914 graphics.FillRectangle(&myBrush,m-r,h-1,d,2);
915 break;
916 case Lanes::APPLIED:
917 // Green plus sign
918 //p->setPen(Qt::NoPen);
919 //p->setBrush(DARK_GREEN);
920 //p->drawRect(m - r, h - 1, d, 2);
921 //p->drawRect(m - 1, h - r, 2, d);
922 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
923 graphics.FillRectangle(&myBrush,m-r,h-1,d,2);
924 graphics.FillRectangle(&myBrush,m-1,h-r,2,d);
925 break;
926 case Lanes::BOUNDARY:
927 //p->setBrush(back);
928 //p->drawEllipse(R_CENTER);
929 graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
930 graphics.DrawEllipse(&myPen, R_CENTER);
931 break;
932 case Lanes::BOUNDARY_C:
933 case Lanes::BOUNDARY_R:
934 case Lanes::BOUNDARY_L:
935 //p->setBrush(back);
936 //p->drawRect(R_CENTER);
937 graphics.SetSmoothingMode(Gdiplus::SmoothingModeNone);
938 graphics.FillRectangle(&myBrush,R_CENTER);
939 break;
940 default:
941 break;
942 }
943
944 ::SelectObject(hdc,oldpen);
945 ::SelectObject(hdc,oldbrush);
946 #undef P_CENTER
947 #undef P_0
948 #undef P_90
949 #undef P_180
950 #undef P_270
951 #undef R_CENTER
952 }
953
954 void CGitLogListBase::DrawGraph(HDC hdc,CRect &rect,INT_PTR index)
955 {
956 // TODO: unfinished
957 // return;
958 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(index);
959 if(data->m_CommitHash.IsEmpty())
960 return;
961
962 CRect rt=rect;
963 LVITEM rItem;
964 SecureZeroMemory(&rItem, sizeof(LVITEM));
965 rItem.mask = LVIF_STATE;
966 rItem.iItem = index;
967 rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
968 GetItem(&rItem);
969
970 // p->translate(QPoint(opt.rect.left(), opt.rect.top()));
971
972 if (data->m_Lanes.size() == 0)
973 m_logEntries.setLane(data->m_CommitHash);
974
975 std::vector<int>& lanes=data->m_Lanes;
976 UINT laneNum = lanes.size();
977 UINT activeLane = 0;
978 for (UINT i = 0; i < laneNum; i++)
979 if (Lanes::isMerge(lanes[i])) {
980 activeLane = i;
981 break;
982 }
983
984 int x1 = 0, x2 = 0;
985 int maxWidth = rect.Width();
986 int lw = 3 * rect.Height() / 4; //laneWidth()
987
988 COLORREF activeColor = m_LineColors[activeLane % Lanes::COLORS_NUM];
989 //if (opt.state & QStyle::State_Selected)
990 // activeColor = blend(activeColor, opt.palette.highlightedText().color(), 208);
991
992 for (unsigned int i = 0; i < laneNum && x2 < maxWidth; i++)
993 {
994
995 x1 = x2;
996 x2 += lw;
997
998 int ln = lanes[i];
999 if (ln == Lanes::EMPTY)
1000 continue;
1001
1002 COLORREF color = i == activeLane ? activeColor : m_LineColors[i % Lanes::COLORS_NUM];
1003 paintGraphLane(hdc, rect.Height(),ln, x1+rect.left, x2+rect.left, color,activeColor, rect.top);
1004 }
1005
1006 #if 0
1007 for (UINT i = 0; i < laneNum && x2 < maxWidth; i++) {
1008
1009 x1 = x2;
1010 x2 += lw;
1011
1012 int ln = lanes[i];
1013 if (ln == Lanes::EMPTY)
1014 continue;
1015
1016 UINT col = ( Lanes:: isHead(ln) ||Lanes:: isTail(ln) || Lanes::isJoin(ln)
1017 || ln ==Lanes:: CROSS_EMPTY) ? activeLane : i;
1018
1019 if (ln == Lanes::CROSS)
1020 {
1021 paintGraphLane(hdc, rect.Height(),Lanes::NOT_ACTIVE, x1, x2, m_LineColors[col % Lanes::COLORS_NUM],rect.top);
1022 paintGraphLane(hdc, rect.Height(),Lanes::CROSS, x1, x2, m_LineColors[activeLane % Lanes::COLORS_NUM],rect.top);
1023 }
1024 else
1025 paintGraphLane(hdc, rect.Height(),ln, x1, x2, m_LineColors[col % Lanes::COLORS_NUM],rect.top);
1026 }
1027 #endif
1028
1029 }
1030
1031 void CGitLogListBase::OnNMCustomdrawLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1032 {
1033
1034 NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
1035 // Take the default processing unless we set this to something else below.
1036 *pResult = CDRF_DODEFAULT;
1037
1038 if (m_bNoDispUpdates)
1039 return;
1040
1041 switch (pLVCD->nmcd.dwDrawStage)
1042 {
1043 case CDDS_PREPAINT:
1044 {
1045 *pResult = CDRF_NOTIFYITEMDRAW;
1046 return;
1047 }
1048 break;
1049 case CDDS_ITEMPREPAINT:
1050 {
1051 // This is the prepaint stage for an item. Here's where we set the
1052 // item's text color.
1053
1054 // Tell Windows to send draw notifications for each subitem.
1055 *pResult = CDRF_NOTIFYSUBITEMDRAW;
1056
1057 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
1058
1059 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)
1060 {
1061 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1062 if (data)
1063 {
1064 if (data->GetAction(this)& (CTGitPath::LOGACTIONS_REBASE_DONE| CTGitPath::LOGACTIONS_REBASE_SKIP) )
1065 crText = RGB(128,128,128);
1066
1067 if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_SQUASH)
1068 pLVCD->clrTextBk = RGB(156,156,156);
1069 else if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_EDIT)
1070 pLVCD->clrTextBk = RGB(200,200,128);
1071 else
1072 pLVCD->clrTextBk = ::GetSysColor(COLOR_WINDOW);
1073
1074 if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_CURRENT)
1075 {
1076 SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1077 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1078 }
1079
1080 if(data->m_CommitHash.ToString() == m_HeadHash)
1081 {
1082 SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1083 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1084 }
1085
1086 // if ((data->childStackDepth)||(m_mergedRevs.find(data->Rev) != m_mergedRevs.end()))
1087 // crText = GetSysColor(COLOR_GRAYTEXT);
1088
1089 if (data->m_CommitHash.IsEmpty())
1090 {
1091 //crText = GetSysColor(RGB(200,200,0));
1092 //SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1093 // We changed the font, so we're returning CDRF_NEWFONT. This
1094 // tells the control to recalculate the extent of the text.
1095 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1096 }
1097 }
1098 }
1099 if (m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec)
1100 {
1101 if (m_bStrictStopped)
1102 crText = GetSysColor(COLOR_GRAYTEXT);
1103 }
1104 // Store the color back in the NMLVCUSTOMDRAW struct.
1105 pLVCD->clrText = crText;
1106 return;
1107 }
1108 break;
1109 case CDDS_ITEMPREPAINT|CDDS_ITEM|CDDS_SUBITEM:
1110 {
1111 if ((m_bStrictStopped)&&(m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec))
1112 {
1113 pLVCD->nmcd.uItemState &= ~(CDIS_SELECTED|CDIS_FOCUS);
1114 }
1115
1116 if (pLVCD->iSubItem == LOGLIST_GRAPH && m_sFilterText.IsEmpty())
1117 {
1118 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec && (!this->m_IsRebaseReplaceGraph) )
1119 {
1120 CRect rect;
1121 GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_LABEL, rect);
1122
1123 //TRACE(_T("A Graphic left %d right %d\r\n"),rect.left,rect.right);
1124 FillBackGround(pLVCD->nmcd.hdc, (INT_PTR)pLVCD->nmcd.dwItemSpec,rect);
1125
1126 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1127 if( !data ->m_CommitHash.IsEmpty())
1128 DrawGraph(pLVCD->nmcd.hdc,rect,pLVCD->nmcd.dwItemSpec);
1129
1130 *pResult = CDRF_SKIPDEFAULT;
1131 return;
1132 }
1133 }
1134
1135 if (pLVCD->iSubItem == LOGLIST_MESSAGE)
1136 {
1137 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)
1138 {
1139 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1140 //if(!data->m_IsFull)
1141 //{
1142 //if(data->SafeFetchFullInfo(&g_Git))
1143 // this->Invalidate();
1144 //TRACE(_T("Update ... %d\r\n"),pLVCD->nmcd.dwItemSpec);
1145 //}
1146
1147 if(m_HashMap[data->m_CommitHash].size()!=0)
1148 {
1149 CRect rect;
1150
1151 GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
1152
1153 FillBackGround(pLVCD->nmcd.hdc, (INT_PTR)pLVCD->nmcd.dwItemSpec,rect);
1154 DrawTagBranch(pLVCD->nmcd.hdc,rect,pLVCD->nmcd.dwItemSpec);
1155
1156 *pResult = CDRF_SKIPDEFAULT;
1157 return;
1158
1159 }
1160
1161 }
1162 }
1163
1164 if (pLVCD->iSubItem == LOGLIST_ACTION)
1165 {
1166 if(this->m_IsIDReplaceAction)
1167 {
1168 *pResult = CDRF_DODEFAULT;
1169 return;
1170 }
1171 *pResult = CDRF_DODEFAULT;
1172
1173 if (m_arShownList.GetCount() <= (INT_PTR)pLVCD->nmcd.dwItemSpec)
1174 return;
1175
1176 int nIcons = 0;
1177 int iconwidth = ::GetSystemMetrics(SM_CXSMICON);
1178 int iconheight = ::GetSystemMetrics(SM_CYSMICON);
1179
1180 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec));
1181 CRect rect;
1182 GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
1183 //TRACE(_T("Action left %d right %d\r\n"),rect.left,rect.right);
1184 // Get the selected state of the
1185 // item being drawn.
1186
1187 // Fill the background if necessary
1188 FillBackGround(pLVCD->nmcd.hdc, (INT_PTR)pLVCD->nmcd.dwItemSpec,rect);
1189
1190 // Draw the icon(s) into the compatible DC
1191 pLogEntry->GetAction(this);
1192
1193 if (!pLogEntry->m_IsDiffFiles)
1194 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left + ICONITEMBORDER, rect.top, m_hFetchIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1195
1196 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_MODIFIED)
1197 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left + ICONITEMBORDER, rect.top, m_hModifiedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1198 nIcons++;
1199
1200 if (pLogEntry->GetAction(this) & (CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_COPY) )
1201 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hAddedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1202 nIcons++;
1203
1204 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_DELETED)
1205 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hDeletedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1206 nIcons++;
1207
1208 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_REPLACED)
1209 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hReplacedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1210 nIcons++;
1211 *pResult = CDRF_SKIPDEFAULT;
1212 return;
1213 }
1214 }
1215 break;
1216 }
1217 *pResult = CDRF_DODEFAULT;
1218 }
1219
1220 // CGitLogListBase message handlers
1221
1222 void CGitLogListBase::OnLvnGetdispinfoLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1223 {
1224 NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
1225
1226 // Create a pointer to the item
1227 LV_ITEM* pItem = &(pDispInfo)->item;
1228
1229 // Do the list need text information?
1230 if (!(pItem->mask & LVIF_TEXT))
1231 return;
1232
1233 // By default, clear text buffer.
1234 lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);
1235
1236 bool bOutOfRange = pItem->iItem >= ShownCountWithStopped();
1237
1238 *pResult = 0;
1239 if (m_bNoDispUpdates || bOutOfRange)
1240 return;
1241
1242 // Which item number?
1243 int itemid = pItem->iItem;
1244 GitRev * pLogEntry = NULL;
1245 if (itemid < m_arShownList.GetCount())
1246 pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(pItem->iItem));
1247
1248 CString temp;
1249 if(m_IsOldFirst)
1250 {
1251 temp.Format(_T("%d"),pItem->iItem+1);
1252
1253 }
1254 else
1255 {
1256 temp.Format(_T("%d"),m_arShownList.GetCount()-pItem->iItem);
1257 }
1258
1259 // Which column?
1260 switch (pItem->iSubItem)
1261 {
1262 case this->LOGLIST_GRAPH: //Graphic
1263 break;
1264 case this->LOGLIST_REBASE:
1265 {
1266 if(this->m_IsRebaseReplaceGraph)
1267 {
1268 CTGitPath path;
1269 path.m_Action=pLogEntry->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_MODE_MASK;
1270 lstrcpyn(pItem->pszText,path.GetActionName(), pItem->cchTextMax);
1271 }
1272 }
1273 break;
1274 case this->LOGLIST_ACTION: //action -- no text in the column
1275 break;
1276 case this->LOGLIST_HASH:
1277 if(pLogEntry)
1278 lstrcpyn(pItem->pszText, pLogEntry->m_CommitHash.ToString(), pItem->cchTextMax);
1279 break;
1280 case this->LOGLIST_ID:
1281 if(this->m_IsIDReplaceAction)
1282 lstrcpyn(pItem->pszText, temp, pItem->cchTextMax);
1283 break;
1284 case this->LOGLIST_MESSAGE: //Message
1285 if (pLogEntry)
1286 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetSubject(), pItem->cchTextMax);
1287 break;
1288 case this->LOGLIST_AUTHOR: //Author
1289 if (pLogEntry)
1290 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetAuthorName(), pItem->cchTextMax);
1291 break;
1292 case this->LOGLIST_DATE: //Date
1293 if ( pLogEntry && (!pLogEntry->m_CommitHash.IsEmpty()) )
1294 lstrcpyn(pItem->pszText,
1295 CAppUtils::FormatDateAndTime( pLogEntry->GetAuthorDate(), m_DateFormat, true, m_bRelativeTimes ),
1296 pItem->cchTextMax);
1297 break;
1298
1299 case this->LOGLIST_EMAIL:
1300 if (pLogEntry)
1301 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetAuthorEmail(), pItem->cchTextMax);
1302 break;
1303
1304 case this->LOGLIST_COMMIT_NAME: //Commit
1305 if (pLogEntry)
1306 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetCommitterName(), pItem->cchTextMax);
1307 break;
1308
1309 case this->LOGLIST_COMMIT_EMAIL: //Commit Email
1310 if (pLogEntry)
1311 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetCommitterEmail(), pItem->cchTextMax);
1312 break;
1313
1314 case this->LOGLIST_COMMIT_DATE: //Commit Date
1315 if (pLogEntry)
1316 lstrcpyn(pItem->pszText,
1317 CAppUtils::FormatDateAndTime( pLogEntry->GetCommitterDate(), m_DateFormat, true, m_bRelativeTimes ),
1318 pItem->cchTextMax);
1319 break;
1320 case this->LOGLIST_BUG: //Bug ID
1321 if(pLogEntry)
1322 lstrcpyn(pItem->pszText, (LPCTSTR)this->m_ProjectProperties.FindBugID(pLogEntry->GetSubject()), pItem->cchTextMax);
1323 break;
1324
1325 default:
1326 ASSERT(false);
1327 }
1328 }
1329
1330 void CGitLogListBase::OnContextMenu(CWnd* pWnd, CPoint point)
1331 {
1332
1333 if (pWnd == GetHeaderCtrl())
1334 {
1335 return m_ColumnManager.OnContextMenuHeader(pWnd,point,!!IsGroupViewEnabled());
1336 }
1337
1338 int selIndex = GetSelectionMark();
1339 if (selIndex < 0)
1340 return; // nothing selected, nothing to do with a context menu
1341
1342 // if the user selected the info text telling about not all revisions shown due to
1343 // the "stop on copy/rename" option, we also don't show the context menu
1344 if ((m_bStrictStopped)&&(selIndex == m_arShownList.GetCount()))
1345 return;
1346
1347 // if the context menu is invoked through the keyboard, we have to use
1348 // a calculated position on where to anchor the menu on
1349 if ((point.x == -1) && (point.y == -1))
1350 {
1351 CRect rect;
1352 GetItemRect(selIndex, &rect, LVIR_LABEL);
1353 ClientToScreen(&rect);
1354 point = rect.CenterPoint();
1355 }
1356 m_nSearchIndex = selIndex;
1357 m_bCancelled = FALSE;
1358
1359 // calculate some information the context menu commands can use
1360 // CString pathURL = GetURLFromPath(m_path);
1361
1362 POSITION pos = GetFirstSelectedItemPosition();
1363 int indexNext = GetNextSelectedItem(pos);
1364 if (indexNext < 0)
1365 return;
1366
1367 GitRev* pSelLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(indexNext));
1368 #if 0
1369 GitRev revSelected = pSelLogEntry->Rev;
1370 GitRev revPrevious = git_revnum_t(revSelected)-1;
1371 if ((pSelLogEntry->pArChangedPaths)&&(pSelLogEntry->pArChangedPaths->GetCount() <= 2))
1372 {
1373 for (int i=0; i<pSelLogEntry->pArChangedPaths->GetCount(); ++i)
1374 {
1375 LogChangedPath * changedpath = (LogChangedPath *)pSelLogEntry->pArChangedPaths->SafeGetAt(i);
1376 if (changedpath->lCopyFromRev)
1377 revPrevious = changedpath->lCopyFromRev;
1378 }
1379 }
1380 GitRev revSelected2;
1381 if (pos)
1382 {
1383 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1384 revSelected2 = pLogEntry->Rev;
1385 }
1386 bool bAllFromTheSameAuthor = true;
1387 CString firstAuthor;
1388 CLogDataVector selEntries;
1389 GitRev revLowest, revHighest;
1390 GitRevRangeArray revisionRanges;
1391 {
1392 POSITION pos = GetFirstSelectedItemPosition();
1393 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1394 revisionRanges.AddRevision(pLogEntry->Rev);
1395 selEntries.push_back(pLogEntry);
1396 firstAuthor = pLogEntry->sAuthor;
1397 revLowest = pLogEntry->Rev;
1398 revHighest = pLogEntry->Rev;
1399 while (pos)
1400 {
1401 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1402 revisionRanges.AddRevision(pLogEntry->Rev);
1403 selEntries.push_back(pLogEntry);
1404 if (firstAuthor.Compare(pLogEntry->sAuthor))
1405 bAllFromTheSameAuthor = false;
1406 revLowest = (git_revnum_t(pLogEntry->Rev) > git_revnum_t(revLowest) ? revLowest : pLogEntry->Rev);
1407 revHighest = (git_revnum_t(pLogEntry->Rev) < git_revnum_t(revHighest) ? revHighest : pLogEntry->Rev);
1408 }
1409 }
1410
1411 #endif
1412
1413 int FirstSelect=-1, LastSelect=-1;
1414 pos = GetFirstSelectedItemPosition();
1415 FirstSelect = GetNextSelectedItem(pos);
1416 while(pos)
1417 {
1418 LastSelect = GetNextSelectedItem(pos);
1419 }
1420 //entry is selected, now show the popup menu
1421 CIconMenu popup;
1422 CIconMenu subbranchmenu, submenu, gnudiffmenu,diffmenu;
1423
1424 if (popup.CreatePopupMenu())
1425 {
1426 bool isHeadCommit = (pSelLogEntry->m_CommitHash == m_HeadHash);
1427 CString currentBranch = _T("refs/heads/") + g_Git.GetCurrentBranch();
1428
1429 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_PICK))
1430 popup.AppendMenuIcon(ID_REBASE_PICK, IDS_REBASE_PICK, IDI_PICK);
1431
1432 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_SQUASH))
1433 popup.AppendMenuIcon(ID_REBASE_SQUASH, IDS_REBASE_SQUASH, IDI_SQUASH);
1434
1435 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_EDIT))
1436 popup.AppendMenuIcon(ID_REBASE_EDIT, IDS_REBASE_EDIT, IDI_EDIT);
1437
1438 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_SKIP))
1439 popup.AppendMenuIcon(ID_REBASE_SKIP, IDS_REBASE_SKIP, IDI_SKIP);
1440
1441 if(m_ContextMenuMask&(GetContextMenuBit(ID_REBASE_SKIP)|GetContextMenuBit(ID_REBASE_EDIT)|
1442 GetContextMenuBit(ID_REBASE_SQUASH)|GetContextMenuBit(ID_REBASE_PICK)))
1443 popup.AppendMenu(MF_SEPARATOR, NULL);
1444
1445 if (GetSelectedCount() == 1)
1446 {
1447
1448 {
1449 if( !pSelLogEntry->m_CommitHash.IsEmpty())
1450 {
1451 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPARE) && m_hasWC) // compare revision with WC
1452 popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARE, IDI_DIFF);
1453 // TODO:
1454 // TortoiseMerge could be improved to take a /blame switch
1455 // and then not 'cat' the files from a unified diff but
1456 // blame then.
1457 // But until that's implemented, the context menu entry for
1458 // this feature is commented out.
1459 //popup.AppendMenu(ID_BLAMECOMPARE, IDS_LOG_POPUP_BLAMECOMPARE, IDI_BLAME);
1460 }
1461 else
1462 {
1463 if(m_ContextMenuMask&GetContextMenuBit(ID_COMMIT))
1464 popup.AppendMenuIcon(ID_COMMIT, IDS_LOG_POPUP_COMMIT, IDI_COMMIT);
1465 }
1466 if(m_ContextMenuMask&GetContextMenuBit(ID_GNUDIFF1) && m_hasWC) // compare with WC, unified
1467 {
1468 GitRev *pRev=pSelLogEntry;
1469 if(pSelLogEntry->m_ParentHash.size()==0)
1470 {
1471 pRev->GetParentFromHash(pRev->m_CommitHash);
1472 }
1473 if(pRev->m_ParentHash.size()<=1)
1474 {
1475 popup.AppendMenuIcon(ID_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF_CH, IDI_DIFF);
1476
1477 }
1478 else
1479 {
1480 gnudiffmenu.CreatePopupMenu();
1481 popup.AppendMenuIcon(ID_GNUDIFF1,IDS_LOG_POPUP_GNUDIFF_PARENT, IDI_DIFF, gnudiffmenu.m_hMenu);
1482
1483 gnudiffmenu.AppendMenuIcon(ID_GNUDIFF1+(0xFFFF<<16),_T("All Parents"));
1484 gnudiffmenu.AppendMenuIcon(ID_GNUDIFF1+(0xFFFE<<16),_T("Only Merged Files"));
1485
1486 for(int i=0;i<pRev->m_ParentHash.size();i++)
1487 {
1488 CString str;
1489 str.Format(_T("Parent %d"), i+1);
1490 gnudiffmenu.AppendMenuIcon(ID_GNUDIFF1+((i+1)<<16),str);
1491 }
1492 }
1493 }
1494
1495 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPAREWITHPREVIOUS))
1496 {
1497
1498 GitRev *pRev=pSelLogEntry;
1499 if(pSelLogEntry->m_ParentHash.size()==0)
1500 {
1501 pRev->GetParentFromHash(pRev->m_CommitHash);
1502 }
1503 if(pRev->m_ParentHash.size()<=1)
1504 {
1505 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF);
1506 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1507 popup.SetDefaultItem(ID_COMPAREWITHPREVIOUS, FALSE);
1508 }
1509 else
1510 {
1511 diffmenu.CreatePopupMenu();
1512 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF, diffmenu.m_hMenu);
1513 for(int i=0;i<pRev->m_ParentHash.size();i++)
1514 {
1515 CString str;
1516 str.Format(_T("Parent %d"), i+1);
1517 diffmenu.AppendMenuIcon(ID_COMPAREWITHPREVIOUS +((i+1)<<16),str);
1518 if (i == 0 && CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1519 {
1520 popup.SetDefaultItem(ID_COMPAREWITHPREVIOUS, FALSE);
1521 diffmenu.SetDefaultItem(ID_COMPAREWITHPREVIOUS +((i+1)<<16), FALSE);
1522 }
1523 }
1524 }
1525 }
1526
1527 if(m_ContextMenuMask&GetContextMenuBit(ID_BLAME))
1528 popup.AppendMenuIcon(ID_BLAME, IDS_LOG_POPUP_BLAME, IDI_BLAME);
1529
1530 //popup.AppendMenuIcon(ID_BLAMEWITHPREVIOUS, IDS_LOG_POPUP_BLAMEWITHPREVIOUS, IDI_BLAME);
1531 popup.AppendMenu(MF_SEPARATOR, NULL);
1532 }
1533
1534 // if (!m_ProjectProperties.sWebViewerRev.IsEmpty())
1535 // {
1536 // popup.AppendMenuIcon(ID_VIEWREV, IDS_LOG_POPUP_VIEWREV);
1537 // }
1538 // if (!m_ProjectProperties.sWebViewerPathRev.IsEmpty())
1539 // {
1540 // popup.AppendMenuIcon(ID_VIEWPATHREV, IDS_LOG_POPUP_VIEWPATHREV);
1541 // }
1542 // if ((!m_ProjectProperties.sWebViewerPathRev.IsEmpty())||
1543 // (!m_ProjectProperties.sWebViewerRev.IsEmpty()))
1544 // {
1545 // popup.AppendMenu(MF_SEPARATOR, NULL);
1546 // }
1547
1548 CString str,format;
1549 //if (m_hasWC)
1550 // popup.AppendMenuIcon(ID_REVERTTOREV, IDS_LOG_POPUP_REVERTTOREV, IDI_REVERT);
1551
1552 if(!pSelLogEntry->m_CommitHash.IsEmpty())
1553 {
1554 if((m_ContextMenuMask&GetContextMenuBit(ID_LOG)) &&
1555 GetSelectedCount() == 1)
1556 popup.AppendMenuIcon(ID_LOG, IDS_LOG_POPUP_LOG, IDI_LOG);
1557
1558 format.LoadString(IDS_LOG_POPUP_MERGEREV);
1559 str.Format(format,g_Git.GetCurrentBranch());
1560
1561 if (m_ContextMenuMask&GetContextMenuBit(ID_MERGEREV) && !isHeadCommit && m_hasWC)
1562 popup.AppendMenuIcon(ID_MERGEREV, str, IDI_MERGE);
1563
1564 format.LoadString(IDS_RESET_TO_THIS_FORMAT);
1565 str.Format(format,g_Git.GetCurrentBranch());
1566
1567 if(m_ContextMenuMask&GetContextMenuBit(ID_RESET) && m_hasWC)
1568 popup.AppendMenuIcon(ID_RESET,str,IDI_REVERT);
1569
1570
1571 // Add Switch Branch express Menu
1572 if( this->m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.end()
1573 && (m_ContextMenuMask&GetContextMenuBit(ID_SWITCHBRANCH) && m_hasWC)
1574 )
1575 {
1576 std::vector<CString *> branchs;
1577 for(int i=0;i<m_HashMap[pSelLogEntry->m_CommitHash].size();i++)
1578 {
1579 CString ref = m_HashMap[pSelLogEntry->m_CommitHash][i];
1580 if(ref.Find(_T("refs/heads/")) == 0 && ref != currentBranch)
1581 {
1582 branchs.push_back(&m_HashMap[pSelLogEntry->m_CommitHash][i]);
1583 }
1584 }
1585
1586 CString str;
1587 str.LoadString(IDS_SWITCH_BRANCH);
1588
1589 if(branchs.size() == 1)
1590 {
1591 str+=_T(" ");
1592 str+= _T('"') + branchs[0]->Mid(11) + _T('"');
1593 popup.AppendMenuIcon(ID_SWITCHBRANCH,str,IDI_SWITCH);
1594
1595 popup.SetMenuItemData(ID_SWITCHBRANCH,(ULONG_PTR)branchs[0]);
1596
1597 }
1598 else if(branchs.size() > 1)
1599 {
1600 subbranchmenu.CreatePopupMenu();
1601 for(int i=0;i<branchs.size();i++)
1602 {
1603 if (*branchs[i] != currentBranch)
1604 {
1605 subbranchmenu.AppendMenuIcon(ID_SWITCHBRANCH+(i<<16), branchs[i]->Mid(11));
1606 subbranchmenu.SetMenuItemData(ID_SWITCHBRANCH+(i<<16), (ULONG_PTR) branchs[i]);
1607 }
1608 }
1609
1610 popup.AppendMenuIcon(ID_SWITCHBRANCH, str, IDI_SWITCH, subbranchmenu.m_hMenu);
1611 }
1612 }
1613
1614 if(m_ContextMenuMask&GetContextMenuBit(ID_SWITCHTOREV) && !isHeadCommit && m_hasWC)
1615 popup.AppendMenuIcon(ID_SWITCHTOREV, IDS_SWITCH_TO_THIS , IDI_SWITCH);
1616
1617 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_BRANCH))
1618 popup.AppendMenuIcon(ID_CREATE_BRANCH, IDS_CREATE_BRANCH_AT_THIS , IDI_COPY);
1619
1620 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_TAG))
1621 popup.AppendMenuIcon(ID_CREATE_TAG,IDS_CREATE_TAG_AT_THIS , IDI_TAG);
1622
1623 format.LoadString(IDS_REBASE_THIS_FORMAT);
1624 str.Format(format,g_Git.GetCurrentBranch());
1625
1626 if(pSelLogEntry->m_CommitHash != m_HeadHash && m_hasWC)
1627 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_TO_VERSION))
1628 popup.AppendMenuIcon(ID_REBASE_TO_VERSION, str , IDI_REBASE);
1629
1630 if(m_ContextMenuMask&GetContextMenuBit(ID_EXPORT))
1631 popup.AppendMenuIcon(ID_EXPORT,IDS_EXPORT_TO_THIS, IDI_EXPORT);
1632
1633 if (m_ContextMenuMask&GetContextMenuBit(ID_REVERTREV) && m_hasWC)
1634 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREV, IDI_REVERT);
1635
1636 if (m_ContextMenuMask&GetContextMenuBit(ID_EDITNOTE))
1637 popup.AppendMenuIcon(ID_EDITNOTE, IDS_EDIT_NOTES, IDI_EDIT);
1638
1639 popup.AppendMenu(MF_SEPARATOR, NULL);
1640 }
1641
1642 }
1643
1644 if(!pSelLogEntry->m_Ref.IsEmpty() && GetSelectedCount() == 1)
1645 {
1646 popup.AppendMenuIcon(ID_REFLOG_DEL, IDS_REFLOG_DEL, IDI_DELETE);
1647 if (pSelLogEntry->m_Ref.Find(_T("refs/stash")) == 0)
1648 popup.AppendMenuIcon(ID_STASH_APPLY, IDS_MENUSTASHAPPLY, IDI_RELOCATE);
1649 popup.AppendMenu(MF_SEPARATOR, NULL);
1650 }
1651
1652 if (GetSelectedCount() >= 2)
1653 {
1654 bool bAddSeparator = false;
1655 if (IsSelectionContinuous() || (GetSelectedCount() == 2))
1656 {
1657 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPARETWO)) // compare two revisions
1658 popup.AppendMenuIcon(ID_COMPARETWO, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);
1659 }
1660
1661 if (GetSelectedCount() == 2)
1662 {
1663 //popup.AppendMenuIcon(ID_BLAMETWO, IDS_LOG_POPUP_BLAMEREVS, IDI_BLAME);
1664 if(m_ContextMenuMask&GetContextMenuBit(ID_GNUDIFF2) && m_hasWC) // compare two revisions, unified
1665 popup.AppendMenuIcon(ID_GNUDIFF2, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
1666 bAddSeparator = true;
1667 }
1668
1669 if (m_hasWC)
1670 {
1671 //popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREVS, IDI_REVERT);
1672 // if (m_hasWC)
1673 // popup.AppendMenuIcon(ID_MERGEREV, IDS_LOG_POPUP_MERGEREVS, IDI_MERGE);
1674 bAddSeparator = true;
1675 }
1676
1677 if (m_ContextMenuMask&GetContextMenuBit(ID_REVERTREV) && m_hasWC)
1678 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREVS, IDI_REVERT);
1679
1680 if (bAddSeparator)
1681 popup.AppendMenu(MF_SEPARATOR, NULL);
1682 }
1683
1684 if ( GetSelectedCount() >0 && (!pSelLogEntry->m_CommitHash.IsEmpty()))
1685 {
1686 bool bAddSeparator = false;
1687 if ( IsSelectionContinuous() && GetSelectedCount() >= 2 )
1688 {
1689 if(m_ContextMenuMask&GetContextMenuBit(ID_COMBINE_COMMIT) && m_hasWC)
1690 {
1691 CString head;
1692 int headindex;
1693 headindex = this->GetHeadIndex();
1694 if(headindex>=0)
1695 {
1696 head.Format(_T("HEAD~%d"),LastSelect-headindex);
1697 CGitHash hash=g_Git.GetHash(head);
1698 GitRev* pLastEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(LastSelect));
1699 if(pLastEntry->m_CommitHash == hash) {
1700 popup.AppendMenuIcon(ID_COMBINE_COMMIT,IDS_COMBINE_TO_ONE,IDI_COMBINE);
1701 bAddSeparator = true;
1702 }
1703 }
1704 }
1705 }
1706 if(m_ContextMenuMask&GetContextMenuBit(ID_CHERRY_PICK) && !isHeadCommit && m_hasWC) {
1707 if (GetSelectedCount() >= 2)
1708 popup.AppendMenuIcon(ID_CHERRY_PICK, IDS_CHERRY_PICK_VERSIONS, IDI_EXPORT);
1709 else
1710 popup.AppendMenuIcon(ID_CHERRY_PICK, IDS_CHERRY_PICK_VERSION, IDI_EXPORT);
1711 bAddSeparator = true;
1712 }
1713
1714 if(GetSelectedCount()<=2 || (IsSelectionContinuous() && GetSelectedCount() > 0))
1715 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_PATCH)) {
1716 popup.AppendMenuIcon(ID_CREATE_PATCH, IDS_CREATE_PATCH, IDI_PATCH);
1717 bAddSeparator = true;
1718 }
1719
1720 if (bAddSeparator)
1721 popup.AppendMenu(MF_SEPARATOR, NULL);
1722 }
1723
1724 #if 0
1725 // if ((selEntries.size() > 0)&&(bAllFromTheSameAuthor))
1726 // {
1727 // popup.AppendMenuIcon(ID_EDITAUTHOR, IDS_LOG_POPUP_EDITAUTHOR);
1728 // }
1729 // if (GetSelectedCount() == 1)
1730 // {
1731 // popup.AppendMenuIcon(ID_EDITLOG, IDS_LOG_POPUP_EDITLOG);
1732 // popup.AppendMenuIcon(ID_REVPROPS, IDS_REPOBROWSE_SHOWREVPROP, IDI_PROPERTIES); // "Show Revision Properties"
1733 // popup.AppendMenu(MF_SEPARATOR, NULL);
1734 // }
1735 #endif
1736
1737 if (GetSelectedCount() == 1)
1738 {
1739 bool bAddSeparator = false;
1740 if(m_ContextMenuMask&GetContextMenuBit(ID_PUSH) && m_HashMap[pSelLogEntry->m_CommitHash].size() >= 1)
1741 {
1742 // show the push-option only if the log entry has an associated local branch
1743 bool isLocal = false;
1744 for(int i=0; isLocal == false && i < m_HashMap[pSelLogEntry->m_CommitHash].size(); i++)
1745 {
1746 if (m_HashMap[pSelLogEntry->m_CommitHash][i].Find(_T("refs/heads/")) == 0)
1747 isLocal = true;
1748 }
1749 if (isLocal)
1750 {
1751 popup.AppendMenuIcon(ID_PUSH, IDS_LOG_PUSH, IDI_PUSH);
1752 bAddSeparator = true;
1753 }
1754 }
1755
1756 if(m_ContextMenuMask &GetContextMenuBit(ID_DELETE))
1757 {
1758 if( this->m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.end() )
1759 {
1760 std::vector<CString *> branchs;
1761 for (int i = 0; i < m_HashMap[pSelLogEntry->m_CommitHash].size(); i++)
1762 {
1763 if(m_HashMap[pSelLogEntry->m_CommitHash][i] != currentBranch)
1764 branchs.push_back(&m_HashMap[pSelLogEntry->m_CommitHash][i]);
1765 }
1766 CString str;
1767 if (branchs.size() == 1)
1768 {
1769 str.LoadString(IDS_DELETE_BRANCHTAG_SHORT);
1770 str+=_T(" ");
1771 str += *branchs[0];
1772 popup.AppendMenuIcon(ID_DELETE, str, IDI_DELETE);
1773 popup.SetMenuItemData(ID_DELETE, (ULONG_PTR)branchs[0]);
1774 bAddSeparator = true;
1775 }
1776 else if (branchs.size() > 1)
1777 {
1778 str.LoadString(IDS_DELETE_BRANCHTAG);
1779 submenu.CreatePopupMenu();
1780 for (int i = 0; i < branchs.size(); i++)
1781 {
1782 submenu.AppendMenuIcon(ID_DELETE + (i << 16), *branchs[i]);
1783 submenu.SetMenuItemData(ID_DELETE + (i << 16), (ULONG_PTR)branchs[i]);
1784 }
1785
1786 popup.AppendMenuIcon(ID_DELETE,str, IDI_DELETE, submenu.m_hMenu);
1787 bAddSeparator = true;
1788 }
1789 }
1790 } // m_ContextMenuMask &GetContextMenuBit(ID_DELETE)
1791 if (bAddSeparator)
1792 popup.AppendMenu(MF_SEPARATOR, NULL);
1793 } // GetSelectedCount() == 1
1794
1795 if (GetSelectedCount() == 1)
1796 {
1797 if(m_ContextMenuMask&GetContextMenuBit(ID_COPYHASH))
1798 popup.AppendMenuIcon(ID_COPYHASH, IDS_COPY_COMMIT_HASH, IDI_COPYCLIP);
1799 }
1800 if (GetSelectedCount() != 0)
1801 {
1802 if(m_ContextMenuMask&GetContextMenuBit(ID_COPYCLIPBOARD))
1803 popup.AppendMenuIcon(ID_COPYCLIPBOARD, IDS_LOG_POPUP_COPYTOCLIPBOARD, IDI_COPYCLIP);
1804 }
1805
1806 if(m_ContextMenuMask&GetContextMenuBit(ID_FINDENTRY))
1807 popup.AppendMenuIcon(ID_FINDENTRY, IDS_LOG_POPUP_FIND, IDI_FILTEREDIT);
1808
1809 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1810 // DialogEnableWindow(IDOK, FALSE);
1811 // SetPromptApp(&theApp);
1812
1813 this->ContextMenuAction(cmd, FirstSelect, LastSelect, &popup);
1814
1815 // EnableOKButton();
1816 } // if (popup.CreatePopupMenu())
1817
1818 }
1819
1820 bool CGitLogListBase::IsSelectionContinuous()
1821 {
1822 if ( GetSelectedCount()==1 )
1823 {
1824 // if only one revision is selected, the selection is of course
1825 // continuous
1826 return true;
1827 }
1828
1829 POSITION pos = GetFirstSelectedItemPosition();
1830 bool bContinuous = (m_arShownList.GetCount() == (INT_PTR)m_logEntries.size());
1831 if (bContinuous)
1832 {
1833 int itemindex = GetNextSelectedItem(pos);
1834 while (pos)
1835 {
1836 int nextindex = GetNextSelectedItem(pos);
1837 if (nextindex - itemindex > 1)
1838 {
1839 bContinuous = false;
1840 break;
1841 }
1842 itemindex = nextindex;
1843 }
1844 }
1845 return bContinuous;
1846 }
1847
1848 void CGitLogListBase::CopySelectionToClipBoard(bool HashOnly)
1849 {
1850
1851 CString sClipdata;
1852 POSITION pos = GetFirstSelectedItemPosition();
1853 if (pos != NULL)
1854 {
1855 CString sRev;
1856 sRev.LoadString(IDS_LOG_REVISION);
1857 CString sAuthor;
1858 sAuthor.LoadString(IDS_LOG_AUTHOR);
1859 CString sDate;
1860 sDate.LoadString(IDS_LOG_DATE);
1861 CString sMessage;
1862 sMessage.LoadString(IDS_LOG_MESSAGE);
1863 while (pos)
1864 {
1865 CString sLogCopyText;
1866 CString sPaths;
1867 GitRev * pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1868
1869 if(!HashOnly)
1870 {
1871 //pLogEntry->GetFiles(this)
1872 //LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;
1873
1874 for (int cpPathIndex = 0; cpPathIndex<pLogEntry->GetFiles(this).GetCount(); ++cpPathIndex)
1875 {
1876 sPaths += ((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).GetActionName() + _T(" : ") + pLogEntry->GetFiles(this)[cpPathIndex].GetGitPathString();
1877 sPaths += _T("\r\n");
1878 }
1879 sPaths.Trim();
1880 CString body = pLogEntry->GetBody();
1881 body.Replace(_T("\n"), _T("\r\n"));
1882 sLogCopyText.Format(_T("%s: %s\r\n%s: %s\r\n%s: %s\r\n%s:\r\n%s\r\n----\r\n%s\r\n\r\n"),
1883 (LPCTSTR)sRev, pLogEntry->m_CommitHash.ToString(),
1884 (LPCTSTR)sAuthor, (LPCTSTR)pLogEntry->GetAuthorName(),
1885 (LPCTSTR)sDate,
1886 (LPCTSTR)CAppUtils::FormatDateAndTime( pLogEntry->GetAuthorDate(), m_DateFormat, true, m_bRelativeTimes ),
1887 (LPCTSTR)sMessage, pLogEntry->GetSubject().Trim() + _T("\r\n\r\n") + body.Trim(),
1888 (LPCTSTR)sPaths);
1889 sClipdata += sLogCopyText;
1890 }
1891 else
1892 {
1893 sClipdata += pLogEntry->m_CommitHash;
1894 break;
1895 }
1896
1897 }
1898 CStringUtils::WriteAsciiStringToClipboard(sClipdata, GetSafeHwnd());
1899 }
1900
1901 }
1902
1903 void CGitLogListBase::DiffSelectedRevWithPrevious()
1904 {
1905 if (m_bThreadRunning)
1906 return;
1907
1908 int FirstSelect=-1, LastSelect=-1;
1909 POSITION pos = GetFirstSelectedItemPosition();
1910 FirstSelect = GetNextSelectedItem(pos);
1911 while(pos)
1912 {
1913 LastSelect = GetNextSelectedItem(pos);
1914 }
1915
1916 ContextMenuAction(ID_COMPAREWITHPREVIOUS,FirstSelect,LastSelect, NULL);
1917
1918 #if 0
1919 UpdateLogInfoLabel();
1920 int selIndex = m_LogList.GetSelectionMark();
1921 if (selIndex < 0)
1922 return;
1923 int selCount = m_LogList.GetSelectedCount();
1924 if (selCount != 1)
1925 return;
1926
1927 // Find selected entry in the log list
1928 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1929 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
1930 long rev1 = pLogEntry->Rev;
1931 long rev2 = rev1-1;
1932 CTGitPath path = m_path;
1933
1934 // See how many files under the relative root were changed in selected revision
1935 int nChanged = 0;
1936 LogChangedPath * changed = NULL;
1937 for (INT_PTR c = 0; c < pLogEntry->pArChangedPaths->GetCount(); ++c)
1938 {
1939 LogChangedPath * cpath = pLogEntry->pArChangedPaths->SafeGetAt(c);
1940 if (cpath && cpath -> sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)
1941 {
1942 ++nChanged;
1943 changed = cpath;
1944 }
1945 }
1946
1947 if (m_path.IsDirectory() && nChanged == 1)
1948 {
1949 // We're looking at the log for a directory and only one file under dir was changed in the revision
1950 // Do diff on that file instead of whole directory
1951 path.AppendPathString(changed->sPath.Mid(m_sRelativeRoot.GetLength()));
1952 }
1953
1954 m_bCancelled = FALSE;
1955 DialogEnableWindow(IDOK, FALSE);
1956 SetPromptApp(&theApp);
1957 theApp.DoWaitCursor(1);
1958
1959 if (PromptShown())
1960 {
1961 GitDiff diff(this, m_hWnd, true);
1962 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
1963 diff.SetHEADPeg(m_LogRevision);
1964 diff.ShowCompare(path, rev2, path, rev1);
1965 }
1966 else
1967 {
1968 CAppUtils::StartShowCompare(m_hWnd, path, rev2, path, rev1, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
1969 }
1970
1971 theApp.DoWaitCursor(-1);
1972 EnableOKButton();
1973 #endif
1974 }
1975
1976 void CGitLogListBase::OnLvnOdfinditemLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1977 {
1978 LPNMLVFINDITEM pFindInfo = reinterpret_cast<LPNMLVFINDITEM>(pNMHDR);
1979 *pResult = -1;
1980
1981 if (pFindInfo->lvfi.flags & LVFI_PARAM)
1982 return;
1983 if ((pFindInfo->iStart < 0)||(pFindInfo->iStart >= m_arShownList.GetCount()))
1984 return;
1985 if (pFindInfo->lvfi.psz == 0)
1986 return;
1987 #if 0
1988 CString sCmp = pFindInfo->lvfi.psz;
1989 CString sRev;
1990 for (int i=pFindInfo->iStart; i<m_arShownList.GetCount(); ++i)
1991 {
1992 GitRev * pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(i));
1993 sRev.Format(_T("%ld"), pLogEntry->Rev);
1994 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)
1995 {
1996 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)
1997 {
1998 *pResult = i;
1999 return;
2000 }
2001 }
2002 else
2003 {
2004 if (sCmp.Compare(sRev)==0)
2005 {
2006 *pResult = i;
2007 return;
2008 }
2009 }
2010 }
2011 if (pFindInfo->lvfi.flags & LVFI_WRAP)
2012 {
2013 for (int i=0; i<pFindInfo->iStart; ++i)
2014 {
2015 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(i));
2016 sRev.Format(_T("%ld"), pLogEntry->Rev);
2017 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)
2018 {
2019 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)
2020 {
2021 *pResult = i;
2022 return;
2023 }
2024 }
2025 else
2026 {
2027 if (sCmp.Compare(sRev)==0)
2028 {
2029 *pResult = i;
2030 return;
2031 }
2032 }
2033 }
2034 }
2035 #endif
2036 *pResult = -1;
2037 }
2038
2039 int CGitLogListBase::FillGitLog(CTGitPath *path,int info,CString *from,CString *to)
2040 {
2041 ClearText();
2042
2043
2044 this->m_arShownList.SafeRemoveAll();
2045
2046 this->m_logEntries.ClearAll();
2047 this->m_logEntries.ParserFromLog(path,-1,info,from,to);
2048
2049 //this->m_logEntries.ParserFromLog();
2050 SetItemCountEx(this->m_logEntries.size());
2051
2052 for(unsigned int i=0;i<m_logEntries.size();i++)
2053 {
2054 if(m_IsOldFirst)
2055 {
2056 m_logEntries.GetGitRevAt(m_logEntries.size()-i-1).m_IsFull=TRUE;
2057 this->m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size()-i-1));
2058
2059 }
2060 else
2061 {
2062 m_logEntries.GetGitRevAt(i).m_IsFull=TRUE;
2063 this->m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
2064 }
2065 }
2066
2067 if(path)
2068 m_Path=*path;
2069 return 0;
2070
2071 }
2072
2073 int CGitLogListBase::BeginFetchLog()
2074 {
2075 ClearText();
2076
2077 this->m_arShownList.SafeRemoveAll();
2078
2079 this->m_logEntries.ClearAll();
2080 git_init();
2081
2082 this->m_LogCache.ClearAllParent();
2083
2084 m_LogCache.FetchCacheIndex(g_Git.m_CurrentDir);
2085
2086 CTGitPath *path;
2087 if(this->m_Path.IsEmpty())
2088 path=NULL;
2089 else
2090 path=&this->m_Path;
2091
2092 CString hash;
2093 int mask;
2094 mask = CGit::LOG_INFO_ONLY_HASH | CGit::LOG_INFO_BOUNDARY;
2095 // if(this->m_bAllBranch)
2096 mask |= m_ShowMask ;
2097
2098 if(m_bShowWC)
2099 {
2100 this->m_logEntries.insert(m_logEntries.begin(),this->m_wcRev.m_CommitHash);
2101 ResetWcRev();
2102 this->m_LogCache.m_HashMap[m_wcRev.m_CommitHash]=m_wcRev;
2103 }
2104
2105 CString *pFrom, *pTo;
2106 pFrom = pTo = NULL;
2107 CString head(_T("HEAD"));
2108 if(!this->m_startrev.IsEmpty())
2109 {
2110 pFrom = &this->m_startrev;
2111 if(!this->m_endrev.IsEmpty())
2112 pTo = &this->m_endrev;
2113 else
2114 pTo = &head;
2115 }
2116
2117 CFilterData data;
2118 data.m_From = m_From;
2119 data.m_To =m_To;
2120
2121 #if 0 /* use tortoiegit filter */
2122 if(this->m_nSelectedFilter == LOGFILTER_ALL || m_nSelectedFilter == LOGFILTER_AUTHORS)
2123 data.m_Author = this->m_sFilterText;
2124
2125 if(this->m_nSelectedFilter == LOGFILTER_ALL || m_nSelectedFilter == LOGFILTER_MESSAGES)
2126 data.m_MessageFilter = this->m_sFilterText;
2127
2128 data.m_IsRegex = m_bFilterWithRegex;
2129 #endif
2130
2131 CString cmd=g_Git.GetLogCmd(m_StartRef,path,-1,mask,pFrom,pTo,true,&data);
2132
2133 //this->m_logEntries.ParserFromLog();
2134 if(IsInWorkingThread())
2135 {
2136 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL);
2137 }
2138 else
2139 {
2140 SetItemCountEx(this->m_logEntries.size());
2141 }
2142
2143 git_init();
2144
2145 if(g_Git.IsInitRepos())
2146 return 0;
2147
2148 if(git_open_log(&m_DllGitLog,CUnicodeUtils::GetMulti(cmd,CP_ACP).GetBuffer()))
2149 {
2150 return -1;
2151 }
2152
2153 return 0;
2154 }
2155
2156 BOOL CGitLogListBase::PreTranslateMessage(MSG* pMsg)
2157 {
2158 if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')
2159 {
2160 //if (GetFocus()==GetDlgItem(IDC_LOGLIST))
2161 {
2162 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
2163 {
2164 DiffSelectedRevWithPrevious();
2165 return TRUE;
2166 }
2167 }
2168 #if 0
2169 if (GetFocus()==GetDlgItem(IDC_LOGMSG))
2170 {
2171 DiffSelectedFile();
2172 return TRUE;
2173 }
2174 #endif
2175 }
2176 else if (pMsg->message == WM_KEYDOWN && pMsg->wParam == 'A' && GetAsyncKeyState(VK_CONTROL)&0x8000)
2177 {
2178 // select all entries
2179 for (int i=0; i<GetItemCount(); ++i)
2180 {
2181 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2182 }
2183 return TRUE;
2184 }
2185
2186 #if 0
2187 if (m_hAccel && !bSkipAccelerator)
2188 {
2189 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
2190 if (ret)
2191 return TRUE;
2192 }
2193
2194 #endif
2195 //m_tooltips.RelayEvent(pMsg);
2196 return __super::PreTranslateMessage(pMsg);
2197 }
2198
2199 void CGitLogListBase::OnNMDblclkLoglist(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2200 {
2201 // a double click on an entry in the revision list has happened
2202 *pResult = 0;
2203
2204 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
2205 DiffSelectedRevWithPrevious();
2206 }
2207
2208 int CGitLogListBase::FetchLogAsync(void * data)
2209 {
2210 m_ProcData=data;
2211 m_bExitThread=FALSE;
2212 InterlockedExchange(&m_bThreadRunning, TRUE);
2213 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2214 m_LoadingThread = AfxBeginThread(LogThreadEntry, this, THREAD_PRIORITY_LOWEST);
2215 if (m_LoadingThread ==NULL)
2216 {
2217 InterlockedExchange(&m_bThreadRunning, FALSE);
2218 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2219 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
2220 return -1;
2221 }
2222 return 0;
2223 }
2224
2225 //this is the thread function which calls the subversion function
2226 UINT CGitLogListBase::LogThreadEntry(LPVOID pVoid)
2227 {
2228 return ((CGitLogListBase*)pVoid)->LogThread();
2229 }
2230
2231 void CGitLogListBase::GetTimeRange(CTime &oldest, CTime &latest)
2232 {
2233 //CTime time;
2234 oldest=CTime::GetCurrentTime();
2235 latest=CTime(1971,1,2,0,0,0);
2236 for(unsigned int i=0;i<m_logEntries.size();i++)
2237 {
2238 if(m_logEntries[i].IsEmpty())
2239 continue;
2240
2241 if(m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime() < oldest.GetTime())
2242 oldest = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
2243
2244 if(m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime() > latest.GetTime())
2245 latest = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
2246
2247 }
2248
2249 if(latest<oldest)
2250 latest=oldest;
2251 }
2252
2253 UINT CGitLogListBase::LogThread()
2254 {
2255 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) GITLOG_START,0);
2256
2257 InterlockedExchange(&m_bThreadRunning, TRUE);
2258 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2259
2260 ULONGLONG t1,t2;
2261
2262 if(BeginFetchLog())
2263 {
2264 InterlockedExchange(&m_bThreadRunning, FALSE);
2265 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2266
2267 return -1;
2268 }
2269
2270 tr1::wregex pat;//(_T("Remove"), tr1::regex_constants::icase);
2271 bool bRegex = false;
2272 if (m_bFilterWithRegex)
2273 bRegex = ValidateRegexp(m_sFilterText, pat, false);
2274
2275 TRACE(_T("\n===Begin===\n"));
2276 //Update work copy item;
2277
2278 if( m_logEntries.size() > 0)
2279 {
2280 GitRev *pRev = &m_logEntries.GetGitRevAt(0);
2281
2282 m_arShownList.SafeAdd(pRev);
2283 }
2284
2285
2286 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2287
2288 // store commit number of the last selected commit/line before the refresh or -1
2289 int lastSelectedHashNItem = -1;
2290
2291 if(!g_Git.IsInitRepos())
2292 {
2293 g_Git.m_critGitDllSec.Lock();
2294 git_get_log_firstcommit(m_DllGitLog);
2295 int total = git_get_log_estimate_commit_count(m_DllGitLog);
2296 g_Git.m_critGitDllSec.Unlock();
2297
2298 GIT_COMMIT commit;
2299 t2=t1=GetTickCount();
2300 int oldprecentage = 0;
2301 int oldsize=m_logEntries.size();
2302 int ret=0;
2303 while( ret== 0)
2304 {
2305 g_Git.m_critGitDllSec.Lock();
2306 ret = git_get_log_nextcommit(this->m_DllGitLog, &commit, 0);
2307 g_Git.m_critGitDllSec.Unlock();
2308
2309 if(ret)
2310 break;
2311
2312 //printf("%s\r\n",commit.GetSubject());
2313 if(m_bExitThread)
2314 break;
2315
2316 CGitHash hash = (char*)commit.m_hash ;
2317
2318 GitRev *pRev = m_LogCache.GetCacheData(hash);
2319 pRev->m_GitCommit = commit;
2320 InterlockedExchange(&pRev->m_IsCommitParsed, FALSE);
2321
2322 char *note=NULL;
2323 g_Git.m_critGitDllSec.Lock();
2324 git_get_notes(commit.m_hash,&note);
2325 g_Git.m_critGitDllSec.Unlock();
2326
2327 if(note)
2328 {
2329 pRev->m_Notes.Empty();
2330 g_Git.StringAppend(&pRev->m_Notes,(BYTE*)note);
2331 }
2332
2333 if(!pRev->m_IsDiffFiles)
2334 {
2335 pRev->m_CallDiffAsync = DiffAsync;
2336 }
2337
2338 pRev->ParserParentFromCommit(&commit);
2339
2340 #ifdef DEBUG
2341 pRev->DbgPrint();
2342 TRACE(_T("\n"));
2343 #endif
2344
2345 if(!m_sFilterText.IsEmpty())
2346 {
2347 if(!IsMatchFilter(bRegex,pRev,pat))
2348 continue;
2349 }
2350 this->m_critSec.Lock();
2351 m_logEntries.push_back(hash);
2352 m_arShownList.SafeAdd(pRev);
2353 this->m_critSec.Unlock();
2354
2355 if (lastSelectedHashNItem == -1 && hash == m_lastSelectedHash)
2356 lastSelectedHashNItem = m_arShownList.GetCount() - 1;
2357
2358 t2=GetTickCount();
2359
2360 if(t2-t1>500 || (m_logEntries.size()-oldsize >100))
2361 {
2362 //update UI
2363 int percent=m_logEntries.size()*100/total + GITLOG_START+1;
2364 if(percent > 99)
2365 percent =99;
2366 if(percent < GITLOG_START)
2367 percent = GITLOG_START +1;
2368
2369 oldsize = m_logEntries.size();
2370 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL|LVSICF_NOSCROLL);
2371
2372 //if( percent > oldprecentage )
2373 {
2374 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) percent,0);
2375 oldprecentage = percent;
2376 }
2377 t1 = t2;
2378 }
2379 }
2380 g_Git.m_critGitDllSec.Lock();
2381 git_close_log(m_DllGitLog);
2382 g_Git.m_critGitDllSec.Unlock();
2383
2384 }
2385
2386 // restore last selected item
2387 if (lastSelectedHashNItem >= 0)
2388 {
2389 SetItemState(lastSelectedHashNItem, LVIS_SELECTED, LVIS_SELECTED);
2390 EnsureVisible(lastSelectedHashNItem, FALSE);
2391 }
2392
2393 //Update UI;
2394 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL|LVSICF_NOSCROLL);
2395 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) GITLOG_END,0);
2396
2397 InterlockedExchange(&m_bThreadRunning, FALSE);
2398
2399 return 0;
2400 }
2401
2402 void CGitLogListBase::Refresh(BOOL IsCleanFilter)
2403 {
2404 SafeTerminateThread();
2405
2406 this->SetItemCountEx(0);
2407 this->Clear();
2408
2409 ResetWcRev();
2410
2411 //Update branch and Tag info
2412 ReloadHashMap();
2413 //Assume Thread have exited
2414 //if(!m_bThreadRunning)
2415 {
2416 m_logEntries.clear();
2417
2418 if(IsCleanFilter)
2419 {
2420 m_sFilterText.Empty();
2421 m_From=-1;
2422 m_To=-1;
2423 }
2424
2425 InterlockedExchange(&m_bExitThread,FALSE);
2426
2427 InterlockedExchange(&m_bThreadRunning, TRUE);
2428 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2429 if ( (m_LoadingThread=AfxBeginThread(LogThreadEntry, this)) ==NULL)
2430 {
2431 InterlockedExchange(&m_bThreadRunning, FALSE);
2432 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2433 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
2434 }
2435 }
2436 }
2437 bool CGitLogListBase::ValidateRegexp(LPCTSTR regexp_str, tr1::wregex& pat, bool bMatchCase /* = false */)
2438 {
2439 try
2440 {
2441 tr1::regex_constants::syntax_option_type type = tr1::regex_constants::ECMAScript;
2442 if (!bMatchCase)
2443 type |= tr1::regex_constants::icase;
2444 pat = tr1::wregex(regexp_str, type);
2445 return true;
2446 }
2447 catch (exception) {}
2448 return false;
2449 }
2450 BOOL CGitLogListBase::IsMatchFilter(bool bRegex, GitRev *pRev, tr1::wregex &pat)
2451 {
2452
2453 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_any;
2454 CString sRev;
2455
2456 if ((bRegex)&&(m_bFilterWithRegex))
2457 {
2458 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2459 {
2460 if(this->m_bShowBugtraqColumn)
2461 {
2462 CString sBugIds = m_ProjectProperties.FindBugID(pRev->GetSubject());
2463
2464 ATLTRACE(_T("bugID = \"%s\"\n"), sBugIds);
2465 if (regex_search(wstring(sBugIds), pat, flags))
2466 {
2467 return TRUE;
2468 }
2469 }
2470 }
2471
2472 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_SUBJECT)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2473 {
2474 ATLTRACE(_T("messge = \"%s\"\n"), pRev->GetSubject());
2475 if (regex_search(wstring((LPCTSTR)pRev->GetSubject()), pat, flags))
2476 {
2477 return TRUE;
2478 }
2479 }
2480
2481 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2482 {
2483 ATLTRACE(_T("messge = \"%s\"\n"),pRev->GetBody());
2484 if (regex_search(wstring((LPCTSTR)pRev->GetBody()), pat, flags))
2485 {
2486 return TRUE;
2487 }
2488 }
2489
2490 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))
2491 {
2492 if (regex_search(wstring(pRev->GetAuthorName()), pat, flags))
2493 {
2494 return TRUE;
2495 }
2496
2497 if (regex_search(wstring(pRev->GetCommitterName()), pat, flags))
2498 {
2499 return TRUE;
2500 }
2501 }
2502
2503 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))
2504 {
2505 sRev.Format(_T("%s"), pRev->m_CommitHash.ToString());
2506 if (regex_search(wstring((LPCTSTR)sRev), pat, flags))
2507 {
2508 return TRUE;
2509 }
2510 }
2511
2512 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))
2513 {
2514 CTGitPathList *pathList=NULL;
2515 if( pRev->m_IsDiffFiles)
2516 pathList = &pRev->GetFiles(this);
2517 else
2518 {
2519 if(!pRev->m_IsSimpleListReady)
2520 pRev->SafeGetSimpleList(&g_Git);
2521 }
2522
2523 if(pathList)
2524 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList->GetCount(); ++cpPathIndex)
2525 {
2526 if (regex_search(wstring((LPCTSTR)pathList->m_paths.at(cpPathIndex).GetGitOldPathString()), pat, flags))
2527 {
2528 return true;
2529 }
2530 if (regex_search(wstring((LPCTSTR)pathList->m_paths.at(cpPathIndex).GetGitPathString()), pat, flags))
2531 {
2532 return true;
2533 }
2534 }
2535
2536 for(INT_PTR i=0;i<pRev->m_SimpleFileList.size();i++)
2537 {
2538 if (regex_search(wstring((LPCTSTR)pRev->m_SimpleFileList[i]), pat, flags))
2539 {
2540 return true;
2541 }
2542 }
2543 }
2544 }
2545 else
2546 {
2547 CString find = m_sFilterText;
2548 find.MakeLower();
2549
2550 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2551 {
2552 if(this->m_bShowBugtraqColumn)
2553 {
2554 CString sBugIds = m_ProjectProperties.FindBugID(pRev->GetSubject());
2555
2556 sBugIds.MakeLower();
2557 if ((sBugIds.Find(find) >= 0))
2558 {
2559 return TRUE;
2560 }
2561 }
2562 }
2563
2564 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_SUBJECT)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2565 {
2566 CString msg = pRev->GetSubject();
2567
2568 msg = msg.MakeLower();
2569 if ((msg.Find(find) >= 0))
2570 {
2571 return TRUE;
2572 }
2573 }
2574
2575 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2576 {
2577 CString msg = pRev->GetBody();
2578
2579 msg = msg.MakeLower();
2580 if ((msg.Find(find) >= 0))
2581 {
2582 return TRUE;
2583 }
2584 }
2585
2586 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))
2587 {
2588 CString msg = pRev->GetAuthorName();
2589 msg = msg.MakeLower();
2590 if ((msg.Find(find) >= 0))
2591 {
2592 return TRUE;
2593 }
2594 }
2595
2596 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))
2597 {
2598 sRev.Format(_T("%s"), pRev->m_CommitHash.ToString());
2599 if ((sRev.Find(find) >= 0))
2600 {
2601 return TRUE;
2602 }
2603 }
2604
2605 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))
2606 {
2607 CTGitPathList *pathList=NULL;
2608 if( pRev->m_IsDiffFiles)
2609 pathList = &pRev->GetFiles(this);
2610 else
2611 {
2612 if(!pRev->m_IsSimpleListReady)
2613 pRev->SafeGetSimpleList(&g_Git);
2614 }
2615 if(pathList)
2616 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList->GetCount() ; ++cpPathIndex)
2617 {
2618 CTGitPath *cpath = &pathList->m_paths.at(cpPathIndex);
2619 CString path = cpath->GetGitOldPathString();
2620 path.MakeLower();
2621 if ((path.Find(find)>=0))
2622 {
2623 return true;
2624 }
2625 path = cpath->GetGitPathString();
2626 path.MakeLower();
2627 if ((path.Find(find)>=0))
2628 {
2629 return true;
2630 }
2631 }
2632
2633 for (INT_PTR i=0;i<pRev->m_SimpleFileList.size();i++)
2634 {
2635 CString path = pRev->m_SimpleFileList[i];
2636 path.MakeLower();
2637 if ((path.Find(find)>=0))
2638 {
2639 return true;
2640 }
2641 }
2642 }
2643 } // else (from if (bRegex))
2644 return FALSE;
2645 }
2646
2647
2648 void CGitLogListBase::RecalculateShownList(CThreadSafePtrArray * pShownlist)
2649 {
2650
2651 pShownlist->SafeRemoveAll();
2652
2653 tr1::wregex pat;//(_T("Remove"), tr1::regex_constants::icase);
2654 bool bRegex = false;
2655 if (m_bFilterWithRegex)
2656 bRegex = ValidateRegexp(m_sFilterText, pat, false);
2657
2658 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_any;
2659 CString sRev;
2660 for (DWORD i=0; i<m_logEntries.size(); ++i)
2661 {
2662 if ((bRegex)&&(m_bFilterWithRegex))
2663 {
2664 #if 0
2665 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2666 {
2667 ATLTRACE(_T("bugID = \"%s\"\n"), (LPCTSTR)m_logEntries[i]->sBugIDs);
2668 if (regex_search(wstring((LPCTSTR)m_logEntries[i]->sBugIDs), pat, flags)&&IsEntryInDateRange(i))
2669 {
2670 pShownlist->SafeAdd(m_logEntries[i]);
2671 continue;
2672 }
2673 }
2674 #endif
2675 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_SUBJECT)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2676 {
2677 ATLTRACE(_T("messge = \"%s\"\n"),m_logEntries.GetGitRevAt(i).GetSubject());
2678 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetSubject()), pat, flags)&&IsEntryInDateRange(i))
2679 {
2680 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2681 continue;
2682 }
2683 }
2684 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2685 {
2686 ATLTRACE(_T("messge = \"%s\"\n"),m_logEntries.GetGitRevAt(i).GetBody());
2687 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetBody()), pat, flags)&&IsEntryInDateRange(i))
2688 {
2689 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2690 continue;
2691 }
2692 }
2693 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))
2694 {
2695 CTGitPathList pathList = m_logEntries.GetGitRevAt(i).GetFiles(this);
2696
2697 bool bGoing = true;
2698 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList.GetCount() && bGoing; ++cpPathIndex)
2699 {
2700 CTGitPath cpath = pathList[cpPathIndex];
2701 if (regex_search(wstring((LPCTSTR)cpath.GetGitOldPathString()), pat, flags)&&IsEntryInDateRange(i))
2702 {
2703 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2704 bGoing = false;
2705 continue;
2706 }
2707 if (regex_search(wstring((LPCTSTR)cpath.GetGitPathString()), pat, flags)&&IsEntryInDateRange(i))
2708 {
2709 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2710 bGoing = false;
2711 continue;
2712 }
2713 if (regex_search(wstring((LPCTSTR)cpath.GetActionName()), pat, flags)&&IsEntryInDateRange(i))
2714 {
2715 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2716 bGoing = false;
2717 continue;
2718 }
2719 }
2720 }
2721 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))
2722 {
2723 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetAuthorName()), pat, flags)&&IsEntryInDateRange(i))
2724 {
2725 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2726 continue;
2727 }
2728 }
2729 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))
2730 {
2731 sRev.Format(_T("%s"), m_logEntries.GetGitRevAt(i).m_CommitHash.ToString());
2732 if (regex_search(wstring((LPCTSTR)sRev), pat, flags)&&IsEntryInDateRange(i))
2733 {
2734 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2735 continue;
2736 }
2737 }
2738 } // if (bRegex)
2739 else
2740 {
2741 CString find = m_sFilterText;
2742 find.MakeLower();
2743 #if 0
2744 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2745 {
2746 CString sBugIDs = m_logEntries[i]->sBugIDs;
2747
2748 sBugIDs = sBugIDs.MakeLower();
2749 if ((sBugIDs.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2750 {
2751 pShownlist->SafeAdd(m_logEntries[i]);
2752 continue;
2753 }
2754 }
2755 #endif
2756 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_SUBJECT)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2757 {
2758 CString msg = m_logEntries.GetGitRevAt(i).GetSubject();
2759
2760 msg = msg.MakeLower();
2761 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2762 {
2763 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2764 continue;
2765 }
2766 }
2767 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2768 {
2769 CString msg = m_logEntries.GetGitRevAt(i).GetBody();
2770
2771 msg = msg.MakeLower();
2772 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2773 {
2774 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2775 continue;
2776 }
2777 }
2778 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))
2779 {
2780 CTGitPathList pathList = m_logEntries.GetGitRevAt(i).GetFiles(this);
2781
2782 bool bGoing = true;
2783 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList.GetCount() && bGoing; ++cpPathIndex)
2784 {
2785 CTGitPath cpath = pathList[cpPathIndex];
2786 CString path = cpath.GetGitOldPathString();
2787 path.MakeLower();
2788 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2789 {
2790 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2791 bGoing = false;
2792 continue;
2793 }
2794 path = cpath.GetGitPathString();
2795 path.MakeLower();
2796 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2797 {
2798 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2799 bGoing = false;
2800 continue;
2801 }
2802 path = cpath.GetActionName();
2803 path.MakeLower();
2804 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2805 {
2806 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2807 bGoing = false;
2808 continue;
2809 }
2810 }
2811 }
2812 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))
2813 {
2814 CString msg = m_logEntries.GetGitRevAt(i).GetAuthorName();
2815 msg = msg.MakeLower();
2816 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2817 {
2818 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2819 continue;
2820 }
2821 }
2822 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))
2823 {
2824 sRev.Format(_T("%s"), m_logEntries.GetGitRevAt(i).m_CommitHash.ToString());
2825 if ((sRev.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2826 {
2827 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2828 continue;
2829 }
2830 }
2831 } // else (from if (bRegex))
2832 } // for (DWORD i=0; i<m_logEntries.size(); ++i)
2833
2834 }
2835
2836 BOOL CGitLogListBase::IsEntryInDateRange(int /*i*/)
2837 {
2838 /*
2839 __time64_t time = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
2840
2841 if(m_From == -1)
2842 if(m_To == -1)
2843 return true;
2844 else
2845 return time <= m_To;
2846 else
2847 if(m_To == -1)
2848 return time >= m_From;
2849 else
2850 return ((time >= m_From)&&(time <= m_To));
2851 */
2852 return TRUE; /* git dll will filter time range */
2853
2854 // return TRUE;
2855 }
2856 void CGitLogListBase::StartFilter()
2857 {
2858 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2859 RecalculateShownList(&m_arShownList);
2860 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2861
2862
2863 DeleteAllItems();
2864 SetItemCountEx(ShownCountWithStopped());
2865 RedrawItems(0, ShownCountWithStopped());
2866 Invalidate();
2867
2868 }
2869 void CGitLogListBase::RemoveFilter()
2870 {
2871
2872 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2873
2874 m_arShownList.SafeRemoveAll();
2875
2876 // reset the time filter too
2877 #if 0
2878 m_timFrom = (__time64_t(m_tFrom));
2879 m_timTo = (__time64_t(m_tTo));
2880 m_DateFrom.SetTime(&m_timFrom);
2881 m_DateTo.SetTime(&m_timTo);
2882 m_DateFrom.SetRange(&m_timFrom, &m_timTo);
2883 m_DateTo.SetRange(&m_timFrom, &m_timTo);
2884 #endif
2885
2886 for (DWORD i=0; i<m_logEntries.size(); ++i)
2887 {
2888 if(this->m_IsOldFirst)
2889 {
2890 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size()-i-1));
2891 }
2892 else
2893 {
2894 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
2895 }
2896 }
2897 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
2898 DeleteAllItems();
2899 SetItemCountEx(ShownCountWithStopped());
2900 RedrawItems(0, ShownCountWithStopped());
2901
2902 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2903 }
2904
2905 void CGitLogListBase::Clear()
2906 {
2907 m_arShownList.SafeRemoveAll();
2908 DeleteAllItems();
2909
2910 m_logEntries.ClearAll();
2911
2912 }
2913
2914 void CGitLogListBase::OnDestroy()
2915 {
2916 // save the column widths to the registry
2917 SaveColumnWidths();
2918
2919 SafeTerminateThread();
2920 SafeTerminateAsyncDiffThread();
2921
2922 int retry = 0;
2923 while(m_LogCache.SaveCache())
2924 {
2925 if(retry > 5)
2926 break;
2927 Sleep(1000);
2928
2929 retry++;
2930
2931 //if(CMessageBox::Show(NULL,_T("Cannot Save Log Cache to Disk. To retry click yes. To give up click no."),_T("TortoiseGit"),
2932 // MB_YESNO) == IDNO)
2933 // break;
2934 }
2935
2936 CHintListCtrl::OnDestroy();
2937 }
2938
2939 LRESULT CGitLogListBase::OnLoad(WPARAM wParam,LPARAM lParam)
2940 {
2941 UNREFERENCED_PARAMETER(lParam);
2942 CRect rect;
2943 int i=(int)wParam;
2944 this->GetItemRect(i,&rect,LVIR_BOUNDS);
2945 this->InvalidateRect(rect);
2946
2947 return 0;
2948 }
2949
2950 /**
2951 * Save column widths to the registry
2952 */
2953 void CGitLogListBase::SaveColumnWidths()
2954 {
2955 int maxcol = m_ColumnManager.GetColumnCount();
2956
2957 for (int col = 0; col < maxcol; col++)
2958 if (m_ColumnManager.IsVisible (col))
2959 m_ColumnManager.ColumnResized (col);
2960
2961 m_ColumnManager.WriteSettings();
2962 }
2963
2964 int CGitLogListBase::GetHeadIndex()
2965 {
2966 if(m_HeadHash.IsEmpty())
2967 return -1;
2968
2969 for(int i=0;i<m_arShownList.GetCount();i++)
2970 {
2971 GitRev *pRev = (GitRev*)m_arShownList[i];
2972 if(pRev)
2973 {
2974 if(pRev->m_CommitHash.ToString() == m_HeadHash )
2975 return i;
2976 }
2977 }
2978 return -1;
2979 }
2980 void CGitLogListBase::OnFind()
2981 {
2982 if (!m_pFindDialog)
2983 {
2984 m_pFindDialog = new CFindDlg(this);
2985 m_pFindDialog->Create(this);
2986 }
2987 }
2988 void CGitLogListBase::OnHdnBegintrack(NMHDR *pNMHDR, LRESULT *pResult)
2989 {
2990 m_ColumnManager.OnHdnBegintrack(pNMHDR, pResult);
2991 }
2992 void CGitLogListBase::OnHdnItemchanging(NMHDR *pNMHDR, LRESULT *pResult)
2993 {
2994 if(!m_ColumnManager.OnHdnItemchanging(pNMHDR, pResult))
2995 Default();
2996 }
2997 LRESULT CGitLogListBase::OnFindDialogMessage(WPARAM /*wParam*/, LPARAM /*lParam*/)
2998 {
2999
3000 ASSERT(m_pFindDialog != NULL);
3001 bool bFound = false;
3002 int i=0;
3003
3004 if (m_pFindDialog->IsTerminating())
3005 {
3006 // invalidate the handle identifying the dialog box.
3007 m_pFindDialog = NULL;
3008 return 0;
3009 }
3010
3011 if(m_pFindDialog->IsRef())
3012 {
3013 CString str;
3014 str=m_pFindDialog->GetFindString();
3015
3016 CGitHash hash;
3017
3018 if(!str.IsEmpty())
3019 hash = g_Git.GetHash(str);
3020
3021 if(!hash.IsEmpty())
3022 {
3023 for (i = 0; i<m_arShownList.GetCount(); i++)
3024 {
3025 GitRev* pLogEntry = (GitRev*)m_arShownList.SafeGetAt(i);
3026 if(pLogEntry && pLogEntry->m_CommitHash == hash)
3027 {
3028 bFound = true;
3029 break;
3030 }
3031 }
3032 }
3033
3034 }
3035
3036 if(m_pFindDialog->FindNext())
3037 {
3038 //read data from dialog
3039 CString FindText = m_pFindDialog->GetFindString();
3040 bool bMatchCase = (m_pFindDialog->MatchCase() == TRUE);
3041
3042 tr1::wregex pat;
3043 bool bRegex = ValidateRegexp(FindText, pat, bMatchCase);
3044
3045 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_not_null;
3046
3047
3048 for (i = this->m_nSearchIndex; i<m_arShownList.GetCount()&&!bFound; i++)
3049 {
3050 GitRev* pLogEntry = (GitRev*)m_arShownList.SafeGetAt(i);
3051
3052 CString str;
3053 str+=pLogEntry->m_CommitHash.ToString();
3054 str+=_T("\n");
3055
3056 for(int j=0;j<this->m_HashMap[pLogEntry->m_CommitHash].size();j++)
3057 {
3058 str+=m_HashMap[pLogEntry->m_CommitHash][j];
3059 str+=_T("\n");
3060 }
3061
3062 str+=pLogEntry->GetAuthorEmail();
3063 str+=_T("\n");
3064 str+=pLogEntry->GetAuthorName();
3065 str+=_T("\n");
3066 str+=pLogEntry->GetBody();
3067 str+=_T("\n");
3068 str+=pLogEntry->GetCommitterEmail();
3069 str+=_T("\n");
3070 str+=pLogEntry->GetCommitterName();
3071 str+=_T("\n");
3072 str+=pLogEntry->GetSubject();
3073 str+=_T("\n");
3074
3075
3076 /*Because changed files list is loaded on demand when gui show,
3077 files will empty when files have not fetched.
3078
3079 we can add it back by using one-way diff(with outnumber changed and rename detect.
3080 here just need changed filename list. one-way is much quicker.
3081 */
3082 if(pLogEntry->m_IsFull)
3083 {
3084 for(int i=0;i<pLogEntry->GetFiles(this).GetCount();i++)
3085 {
3086 str+=pLogEntry->GetFiles(this)[i].GetWinPath();
3087 str+=_T("\n");
3088 str+=pLogEntry->GetFiles(this)[i].GetGitOldPathString();
3089 str+=_T("\n");
3090 }
3091 }
3092 else
3093 {
3094 if(!pLogEntry->m_IsSimpleListReady)
3095 pLogEntry->SafeGetSimpleList(&g_Git);
3096
3097 for(int i=0;i<pLogEntry->m_SimpleFileList.size();i++)
3098 {
3099 str+=pLogEntry->m_SimpleFileList[i];
3100 str+=_T("\n");
3101 }
3102
3103 }
3104
3105
3106 if (bRegex)
3107 {
3108 if (regex_search(wstring(str), pat, flags))
3109 {
3110 bFound = true;
3111 break;
3112 }
3113 }
3114 else
3115 {
3116 if (bMatchCase)
3117 {
3118 if (str.Find(FindText) >= 0)
3119 {
3120 bFound = true;
3121 break;
3122 }
3123
3124 }
3125 else
3126 {
3127 CString msg = str;
3128 msg = msg.MakeLower();
3129 CString find = FindText.MakeLower();
3130 if (msg.Find(find) >= 0)
3131 {
3132 bFound = TRUE;
3133 break;
3134 }
3135 }
3136 }
3137 } // for (i = this->m_nSearchIndex; i<m_arShownList.GetItemCount()&&!bFound; i++)
3138
3139 } // if(m_pFindDialog->FindNext())
3140 //UpdateLogInfoLabel();
3141
3142 if (bFound)
3143 {
3144 this->m_nSearchIndex = i;
3145 EnsureVisible(i, FALSE);
3146 SetItemState(GetSelectionMark(), 0, LVIS_SELECTED);
3147 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
3148 SetSelectionMark(i);
3149 //FillLogMessageCtrl();
3150 UpdateData(FALSE);
3151 m_nSearchIndex++;
3152 if (m_nSearchIndex >= m_arShownList.GetCount())
3153 m_nSearchIndex = (int)m_arShownList.GetCount()-1;
3154 }
3155
3156 return 0;
3157 }
3158
3159 void CGitLogListBase::OnColumnResized(NMHDR *pNMHDR, LRESULT *pResult)
3160 {
3161 m_ColumnManager.OnColumnResized(pNMHDR,pResult);
3162
3163 *pResult = FALSE;
3164 }
3165
3166 void CGitLogListBase::OnColumnMoved(NMHDR *pNMHDR, LRESULT *pResult)
3167 {
3168 m_ColumnManager.OnColumnMoved(pNMHDR, pResult);
3169
3170 Invalidate(FALSE);
3171 }
Windows Explorer Extension to Operate Git