?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
show "Stash Apply" in RefLog only if showing stash list
[TortoiseGit.git] / src / TortoiseProc / GitLogListBase.cpp
blobfc77bc21789727d99b03bcabcb8622f0f95dc00b
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2011 - TortoiseGit
4 // Copyright (C) 2005-2007 Marco Costalba
5 // Copyright (C) 2011 - 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
1042
1043 switch (pLVCD->nmcd.dwDrawStage)
1044 {
1045 case CDDS_PREPAINT:
1046 {
1047 *pResult = CDRF_NOTIFYITEMDRAW;
1048 return;
1049 }
1050 break;
1051 case CDDS_ITEMPREPAINT:
1052 {
1053 // This is the prepaint stage for an item. Here's where we set the
1054 // item's text color.
1055
1056 // Tell Windows to send draw notifications for each subitem.
1057 *pResult = CDRF_NOTIFYSUBITEMDRAW;
1058
1059 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
1060
1061 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)
1062 {
1063 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1064 if (data)
1065 {
1066 #if 0
1067 if (data->bCopiedSelf)
1068 {
1069 // only change the background color if the item is not 'hot' (on vista with m_Themes enabled)
1070 if (!IsAppThemed()) || !m_bVista || ((pLVCD->nmcd.uItemState & CDIS_HOT)==0))
1071 pLVCD->clrTextBk = GetSysColor(COLOR_MENU);
1072 }
1073
1074 if (data->bCopies)
1075 crText = m_Colors.GetColor(CColors::Modified);
1076 #endif
1077 if (data->GetAction(this)& (CTGitPath::LOGACTIONS_REBASE_DONE| CTGitPath::LOGACTIONS_REBASE_SKIP) )
1078 crText = RGB(128,128,128);
1079
1080 if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_SQUASH)
1081 pLVCD->clrTextBk = RGB(156,156,156);
1082 else if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_EDIT)
1083 pLVCD->clrTextBk = RGB(200,200,128);
1084 else
1085 pLVCD->clrTextBk = ::GetSysColor(COLOR_WINDOW);
1086
1087 if(data->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_CURRENT)
1088 {
1089 SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1090 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1091 }
1092
1093 if(data->m_CommitHash.ToString() == m_HeadHash)
1094 {
1095 SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1096 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1097 }
1098
1099 // if ((data->childStackDepth)||(m_mergedRevs.find(data->Rev) != m_mergedRevs.end()))
1100 // crText = GetSysColor(COLOR_GRAYTEXT);
1101
1102 if (data->m_CommitHash.IsEmpty())
1103 {
1104 //crText = GetSysColor(RGB(200,200,0));
1105 //SelectObject(pLVCD->nmcd.hdc, m_boldFont);
1106 // We changed the font, so we're returning CDRF_NEWFONT. This
1107 // tells the control to recalculate the extent of the text.
1108 *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NEWFONT;
1109 }
1110 }
1111 }
1112 if (m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec)
1113 {
1114 if (m_bStrictStopped)
1115 crText = GetSysColor(COLOR_GRAYTEXT);
1116 }
1117 // Store the color back in the NMLVCUSTOMDRAW struct.
1118 pLVCD->clrText = crText;
1119 return;
1120 }
1121 break;
1122 case CDDS_ITEMPREPAINT|CDDS_ITEM|CDDS_SUBITEM:
1123 {
1124 if ((m_bStrictStopped)&&(m_arShownList.GetCount() == (INT_PTR)pLVCD->nmcd.dwItemSpec))
1125 {
1126 pLVCD->nmcd.uItemState &= ~(CDIS_SELECTED|CDIS_FOCUS);
1127 }
1128
1129 if (pLVCD->iSubItem == LOGLIST_GRAPH)
1130 {
1131 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec && (!this->m_IsRebaseReplaceGraph) )
1132 {
1133 CRect rect;
1134 GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_LABEL, rect);
1135
1136 //TRACE(_T("A Graphic left %d right %d\r\n"),rect.left,rect.right);
1137 FillBackGround(pLVCD->nmcd.hdc, (INT_PTR)pLVCD->nmcd.dwItemSpec,rect);
1138
1139 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1140 if( !data ->m_CommitHash.IsEmpty())
1141 DrawGraph(pLVCD->nmcd.hdc,rect,pLVCD->nmcd.dwItemSpec);
1142
1143 *pResult = CDRF_SKIPDEFAULT;
1144 return;
1145 }
1146 }
1147
1148 if (pLVCD->iSubItem == LOGLIST_MESSAGE)
1149 {
1150 if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)
1151 {
1152 GitRev* data = (GitRev*)m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec);
1153 //if(!data->m_IsFull)
1154 //{
1155 //if(data->SafeFetchFullInfo(&g_Git))
1156 // this->Invalidate();
1157 //TRACE(_T("Update ... %d\r\n"),pLVCD->nmcd.dwItemSpec);
1158 //}
1159
1160 if(m_HashMap[data->m_CommitHash].size()!=0)
1161 {
1162 CRect rect;
1163
1164 GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
1165
1166 FillBackGround(pLVCD->nmcd.hdc, (INT_PTR)pLVCD->nmcd.dwItemSpec,rect);
1167 DrawTagBranch(pLVCD->nmcd.hdc,rect,pLVCD->nmcd.dwItemSpec);
1168
1169 *pResult = CDRF_SKIPDEFAULT;
1170 return;
1171
1172 }
1173
1174 }
1175 }
1176
1177 if (pLVCD->iSubItem == LOGLIST_ACTION)
1178 {
1179 if(this->m_IsIDReplaceAction)
1180 {
1181 *pResult = CDRF_DODEFAULT;
1182 return;
1183 }
1184 *pResult = CDRF_DODEFAULT;
1185
1186 if (m_arShownList.GetCount() <= (INT_PTR)pLVCD->nmcd.dwItemSpec)
1187 return;
1188
1189 int nIcons = 0;
1190 int iconwidth = ::GetSystemMetrics(SM_CXSMICON);
1191 int iconheight = ::GetSystemMetrics(SM_CYSMICON);
1192
1193 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.SafeGetAt(pLVCD->nmcd.dwItemSpec));
1194 CRect rect;
1195 GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
1196 //TRACE(_T("Action left %d right %d\r\n"),rect.left,rect.right);
1197 // Get the selected state of the
1198 // item being drawn.
1199
1200 // Fill the background if necessary
1201 FillBackGround(pLVCD->nmcd.hdc, (INT_PTR)pLVCD->nmcd.dwItemSpec,rect);
1202
1203 // Draw the icon(s) into the compatible DC
1204 pLogEntry->GetAction(this);
1205
1206 if (!pLogEntry->m_IsDiffFiles)
1207 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left + ICONITEMBORDER, rect.top, m_hFetchIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1208
1209 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_MODIFIED)
1210 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left + ICONITEMBORDER, rect.top, m_hModifiedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1211 nIcons++;
1212
1213 if (pLogEntry->GetAction(this) & (CTGitPath::LOGACTIONS_ADDED|CTGitPath::LOGACTIONS_COPY) )
1214 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hAddedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1215 nIcons++;
1216
1217 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_DELETED)
1218 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hDeletedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1219 nIcons++;
1220
1221 if (pLogEntry->GetAction(this) & CTGitPath::LOGACTIONS_REPLACED)
1222 ::DrawIconEx(pLVCD->nmcd.hdc, rect.left+nIcons*iconwidth + ICONITEMBORDER, rect.top, m_hReplacedIcon, iconwidth, iconheight, 0, NULL, DI_NORMAL);
1223 nIcons++;
1224 *pResult = CDRF_SKIPDEFAULT;
1225 return;
1226 }
1227 }
1228 break;
1229 }
1230 *pResult = CDRF_DODEFAULT;
1231 }
1232
1233 // CGitLogListBase message handlers
1234
1235 void CGitLogListBase::OnLvnGetdispinfoLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1236 {
1237 NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
1238
1239 // Create a pointer to the item
1240 LV_ITEM* pItem = &(pDispInfo)->item;
1241
1242 // Do the list need text information?
1243 if (!(pItem->mask & LVIF_TEXT))
1244 return;
1245
1246 // By default, clear text buffer.
1247 lstrcpyn(pItem->pszText, _T(""), pItem->cchTextMax);
1248
1249 bool bOutOfRange = pItem->iItem >= ShownCountWithStopped();
1250
1251 *pResult = 0;
1252 if (m_bNoDispUpdates || bOutOfRange)
1253 return;
1254
1255 // Which item number?
1256 int itemid = pItem->iItem;
1257 GitRev * pLogEntry = NULL;
1258 if (itemid < m_arShownList.GetCount())
1259 pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(pItem->iItem));
1260
1261 CString temp;
1262 if(m_IsOldFirst)
1263 {
1264 temp.Format(_T("%d"),pItem->iItem+1);
1265
1266 }
1267 else
1268 {
1269 temp.Format(_T("%d"),m_arShownList.GetCount()-pItem->iItem);
1270 }
1271
1272 // Which column?
1273 switch (pItem->iSubItem)
1274 {
1275 case this->LOGLIST_GRAPH: //Graphic
1276 break;
1277 case this->LOGLIST_REBASE:
1278 {
1279 if(this->m_IsRebaseReplaceGraph)
1280 {
1281 CTGitPath path;
1282 path.m_Action=pLogEntry->GetAction(this)&CTGitPath::LOGACTIONS_REBASE_MODE_MASK;
1283 lstrcpyn(pItem->pszText,path.GetActionName(), pItem->cchTextMax);
1284 }
1285 }
1286 break;
1287 case this->LOGLIST_ACTION: //action -- no text in the column
1288 break;
1289 case this->LOGLIST_HASH:
1290 if(pLogEntry)
1291 lstrcpyn(pItem->pszText, pLogEntry->m_CommitHash.ToString(), pItem->cchTextMax);
1292 break;
1293 case this->LOGLIST_ID:
1294 if(this->m_IsIDReplaceAction)
1295 lstrcpyn(pItem->pszText, temp, pItem->cchTextMax);
1296 break;
1297 case this->LOGLIST_MESSAGE: //Message
1298 if (pLogEntry)
1299 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetSubject(), pItem->cchTextMax);
1300 break;
1301 case this->LOGLIST_AUTHOR: //Author
1302 if (pLogEntry)
1303 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetAuthorName(), pItem->cchTextMax);
1304 break;
1305 case this->LOGLIST_DATE: //Date
1306 if ( pLogEntry && (!pLogEntry->m_CommitHash.IsEmpty()) )
1307 lstrcpyn(pItem->pszText,
1308 CAppUtils::FormatDateAndTime( pLogEntry->GetAuthorDate(), m_DateFormat, true, m_bRelativeTimes ),
1309 pItem->cchTextMax);
1310 break;
1311
1312 case this->LOGLIST_EMAIL:
1313 if (pLogEntry)
1314 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetAuthorEmail(), pItem->cchTextMax);
1315 break;
1316
1317 case this->LOGLIST_COMMIT_NAME: //Commit
1318 if (pLogEntry)
1319 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetCommitterName(), pItem->cchTextMax);
1320 break;
1321
1322 case this->LOGLIST_COMMIT_EMAIL: //Commit Email
1323 if (pLogEntry)
1324 lstrcpyn(pItem->pszText, (LPCTSTR)pLogEntry->GetCommitterEmail(), pItem->cchTextMax);
1325 break;
1326
1327 case this->LOGLIST_COMMIT_DATE: //Commit Date
1328 if (pLogEntry)
1329 lstrcpyn(pItem->pszText,
1330 CAppUtils::FormatDateAndTime( pLogEntry->GetCommitterDate(), m_DateFormat, true, m_bRelativeTimes ),
1331 pItem->cchTextMax);
1332 break;
1333 case this->LOGLIST_BUG: //Bug ID
1334 if(pLogEntry)
1335 lstrcpyn(pItem->pszText, (LPCTSTR)this->m_ProjectProperties.FindBugID(pLogEntry->GetSubject()), pItem->cchTextMax);
1336 break;
1337
1338 default:
1339 ASSERT(false);
1340 }
1341 }
1342
1343 void CGitLogListBase::OnContextMenu(CWnd* pWnd, CPoint point)
1344 {
1345
1346 if (pWnd == GetHeaderCtrl())
1347 {
1348 return m_ColumnManager.OnContextMenuHeader(pWnd,point,!!IsGroupViewEnabled());
1349 }
1350
1351 int selIndex = GetSelectionMark();
1352 if (selIndex < 0)
1353 return; // nothing selected, nothing to do with a context menu
1354
1355 // if the user selected the info text telling about not all revisions shown due to
1356 // the "stop on copy/rename" option, we also don't show the context menu
1357 if ((m_bStrictStopped)&&(selIndex == m_arShownList.GetCount()))
1358 return;
1359
1360 // if the context menu is invoked through the keyboard, we have to use
1361 // a calculated position on where to anchor the menu on
1362 if ((point.x == -1) && (point.y == -1))
1363 {
1364 CRect rect;
1365 GetItemRect(selIndex, &rect, LVIR_LABEL);
1366 ClientToScreen(&rect);
1367 point = rect.CenterPoint();
1368 }
1369 m_nSearchIndex = selIndex;
1370 m_bCancelled = FALSE;
1371
1372 // calculate some information the context menu commands can use
1373 // CString pathURL = GetURLFromPath(m_path);
1374
1375 POSITION pos = GetFirstSelectedItemPosition();
1376 int indexNext = GetNextSelectedItem(pos);
1377 if (indexNext < 0)
1378 return;
1379
1380 GitRev* pSelLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(indexNext));
1381 #if 0
1382 GitRev revSelected = pSelLogEntry->Rev;
1383 GitRev revPrevious = git_revnum_t(revSelected)-1;
1384 if ((pSelLogEntry->pArChangedPaths)&&(pSelLogEntry->pArChangedPaths->GetCount() <= 2))
1385 {
1386 for (int i=0; i<pSelLogEntry->pArChangedPaths->GetCount(); ++i)
1387 {
1388 LogChangedPath * changedpath = (LogChangedPath *)pSelLogEntry->pArChangedPaths->SafeGetAt(i);
1389 if (changedpath->lCopyFromRev)
1390 revPrevious = changedpath->lCopyFromRev;
1391 }
1392 }
1393 GitRev revSelected2;
1394 if (pos)
1395 {
1396 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1397 revSelected2 = pLogEntry->Rev;
1398 }
1399 bool bAllFromTheSameAuthor = true;
1400 CString firstAuthor;
1401 CLogDataVector selEntries;
1402 GitRev revLowest, revHighest;
1403 GitRevRangeArray revisionRanges;
1404 {
1405 POSITION pos = GetFirstSelectedItemPosition();
1406 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1407 revisionRanges.AddRevision(pLogEntry->Rev);
1408 selEntries.push_back(pLogEntry);
1409 firstAuthor = pLogEntry->sAuthor;
1410 revLowest = pLogEntry->Rev;
1411 revHighest = pLogEntry->Rev;
1412 while (pos)
1413 {
1414 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1415 revisionRanges.AddRevision(pLogEntry->Rev);
1416 selEntries.push_back(pLogEntry);
1417 if (firstAuthor.Compare(pLogEntry->sAuthor))
1418 bAllFromTheSameAuthor = false;
1419 revLowest = (git_revnum_t(pLogEntry->Rev) > git_revnum_t(revLowest) ? revLowest : pLogEntry->Rev);
1420 revHighest = (git_revnum_t(pLogEntry->Rev) < git_revnum_t(revHighest) ? revHighest : pLogEntry->Rev);
1421 }
1422 }
1423
1424 #endif
1425
1426 int FirstSelect=-1, LastSelect=-1;
1427 pos = GetFirstSelectedItemPosition();
1428 FirstSelect = GetNextSelectedItem(pos);
1429 while(pos)
1430 {
1431 LastSelect = GetNextSelectedItem(pos);
1432 }
1433 //entry is selected, now show the popup menu
1434 CIconMenu popup;
1435 CIconMenu subbranchmenu, submenu, gnudiffmenu,diffmenu;
1436
1437 if (popup.CreatePopupMenu())
1438 {
1439 bool isHeadCommit = (pSelLogEntry->m_CommitHash == m_HeadHash);
1440
1441 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_PICK))
1442 popup.AppendMenuIcon(ID_REBASE_PICK, IDS_REBASE_PICK, IDI_PICK);
1443
1444 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_SQUASH))
1445 popup.AppendMenuIcon(ID_REBASE_SQUASH, IDS_REBASE_SQUASH, IDI_SQUASH);
1446
1447 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_EDIT))
1448 popup.AppendMenuIcon(ID_REBASE_EDIT, IDS_REBASE_EDIT, IDI_EDIT);
1449
1450 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_SKIP))
1451 popup.AppendMenuIcon(ID_REBASE_SKIP, IDS_REBASE_SKIP, IDI_SKIP);
1452
1453 if(m_ContextMenuMask&(GetContextMenuBit(ID_REBASE_SKIP)|GetContextMenuBit(ID_REBASE_EDIT)|
1454 GetContextMenuBit(ID_REBASE_SQUASH)|GetContextMenuBit(ID_REBASE_PICK)))
1455 popup.AppendMenu(MF_SEPARATOR, NULL);
1456
1457 if (GetSelectedCount() == 1)
1458 {
1459
1460 {
1461 if( !pSelLogEntry->m_CommitHash.IsEmpty())
1462 {
1463 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPARE) && m_hasWC) // compare revision with WC
1464 popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARE, IDI_DIFF);
1465 // TODO:
1466 // TortoiseMerge could be improved to take a /blame switch
1467 // and then not 'cat' the files from a unified diff but
1468 // blame then.
1469 // But until that's implemented, the context menu entry for
1470 // this feature is commented out.
1471 //popup.AppendMenu(ID_BLAMECOMPARE, IDS_LOG_POPUP_BLAMECOMPARE, IDI_BLAME);
1472 }
1473 else
1474 {
1475 if(m_ContextMenuMask&GetContextMenuBit(ID_COMMIT))
1476 popup.AppendMenuIcon(ID_COMMIT, IDS_LOG_POPUP_COMMIT, IDI_COMMIT);
1477 }
1478 if(m_ContextMenuMask&GetContextMenuBit(ID_GNUDIFF1) && m_hasWC) // compare with WC, unified
1479 {
1480 GitRev *pRev=pSelLogEntry;
1481 if(pSelLogEntry->m_ParentHash.size()==0)
1482 {
1483 pRev->GetParentFromHash(pRev->m_CommitHash);
1484 }
1485 if(pRev->m_ParentHash.size()<=1)
1486 {
1487 popup.AppendMenuIcon(ID_GNUDIFF1, IDS_LOG_POPUP_GNUDIFF_CH, IDI_DIFF);
1488
1489 }
1490 else
1491 {
1492 gnudiffmenu.CreatePopupMenu();
1493 popup.AppendMenuIcon(ID_GNUDIFF1,IDS_LOG_POPUP_GNUDIFF_PARENT, IDI_DIFF, gnudiffmenu.m_hMenu);
1494
1495 gnudiffmenu.AppendMenuIcon(ID_GNUDIFF1+(0xFFFF<<16),_T("All Parents"));
1496 gnudiffmenu.AppendMenuIcon(ID_GNUDIFF1+(0xFFFE<<16),_T("Only Merged Files"));
1497
1498 for(int i=0;i<pRev->m_ParentHash.size();i++)
1499 {
1500 CString str;
1501 str.Format(_T("Parent %d"), i+1);
1502 gnudiffmenu.AppendMenuIcon(ID_GNUDIFF1+((i+1)<<16),str);
1503 }
1504 }
1505 }
1506
1507 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPAREWITHPREVIOUS))
1508 {
1509
1510 GitRev *pRev=pSelLogEntry;
1511 if(pSelLogEntry->m_ParentHash.size()==0)
1512 {
1513 pRev->GetParentFromHash(pRev->m_CommitHash);
1514 }
1515 if(pRev->m_ParentHash.size()<=1)
1516 {
1517 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF);
1518 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1519 popup.SetDefaultItem(ID_COMPAREWITHPREVIOUS, FALSE);
1520 }
1521 else
1522 {
1523 diffmenu.CreatePopupMenu();
1524 popup.AppendMenuIcon(ID_COMPAREWITHPREVIOUS, IDS_LOG_POPUP_COMPAREWITHPREVIOUS, IDI_DIFF, diffmenu.m_hMenu);
1525 for(int i=0;i<pRev->m_ParentHash.size();i++)
1526 {
1527 CString str;
1528 str.Format(_T("Parent %d"), i+1);
1529 diffmenu.AppendMenuIcon(ID_COMPAREWITHPREVIOUS +((i+1)<<16),str);
1530 if (i == 0 && CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1531 {
1532 popup.SetDefaultItem(ID_COMPAREWITHPREVIOUS, FALSE);
1533 diffmenu.SetDefaultItem(ID_COMPAREWITHPREVIOUS +((i+1)<<16), FALSE);
1534 }
1535 }
1536 }
1537 }
1538
1539 if(m_ContextMenuMask&GetContextMenuBit(ID_BLAME))
1540 popup.AppendMenuIcon(ID_BLAME, IDS_LOG_POPUP_BLAME, IDI_BLAME);
1541
1542 //popup.AppendMenuIcon(ID_BLAMEWITHPREVIOUS, IDS_LOG_POPUP_BLAMEWITHPREVIOUS, IDI_BLAME);
1543 popup.AppendMenu(MF_SEPARATOR, NULL);
1544 }
1545
1546 // if (!m_ProjectProperties.sWebViewerRev.IsEmpty())
1547 // {
1548 // popup.AppendMenuIcon(ID_VIEWREV, IDS_LOG_POPUP_VIEWREV);
1549 // }
1550 // if (!m_ProjectProperties.sWebViewerPathRev.IsEmpty())
1551 // {
1552 // popup.AppendMenuIcon(ID_VIEWPATHREV, IDS_LOG_POPUP_VIEWPATHREV);
1553 // }
1554 // if ((!m_ProjectProperties.sWebViewerPathRev.IsEmpty())||
1555 // (!m_ProjectProperties.sWebViewerRev.IsEmpty()))
1556 // {
1557 // popup.AppendMenu(MF_SEPARATOR, NULL);
1558 // }
1559
1560 CString str,format;
1561 //if (m_hasWC)
1562 // popup.AppendMenuIcon(ID_REVERTTOREV, IDS_LOG_POPUP_REVERTTOREV, IDI_REVERT);
1563
1564 if(!pSelLogEntry->m_CommitHash.IsEmpty())
1565 {
1566 if((m_ContextMenuMask&GetContextMenuBit(ID_LOG)) &&
1567 GetSelectedCount() == 1)
1568 popup.AppendMenuIcon(ID_LOG, IDS_LOG_POPUP_LOG, IDI_LOG);
1569
1570 format.LoadString(IDS_LOG_POPUP_MERGEREV);
1571 str.Format(format,g_Git.GetCurrentBranch());
1572
1573 bool thisbranch = false;
1574 CString currentBranch = _T("refs/heads/")+g_Git.GetCurrentBranch();
1575 for(int i=0; i < m_HashMap[pSelLogEntry->m_CommitHash].size(); i++)
1576 {
1577 if (m_HashMap[pSelLogEntry->m_CommitHash][i] == currentBranch)
1578 thisbranch = true;
1579 break;
1580 }
1581
1582 if (m_ContextMenuMask&GetContextMenuBit(ID_MERGEREV) && !isHeadCommit && m_hasWC)
1583 popup.AppendMenuIcon(ID_MERGEREV, str, IDI_MERGE);
1584
1585 format.LoadString(IDS_RESET_TO_THIS_FORMAT);
1586 str.Format(format,g_Git.GetCurrentBranch());
1587
1588 if(m_ContextMenuMask&GetContextMenuBit(ID_RESET) && m_hasWC)
1589 popup.AppendMenuIcon(ID_RESET,str,IDI_REVERT);
1590
1591
1592 // Add Switch Branch express Menu
1593 if( this->m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.end()
1594 && (m_ContextMenuMask&GetContextMenuBit(ID_SWITCHBRANCH) && m_hasWC)
1595 )
1596 {
1597 std::vector<CString *> branchs;
1598 CString ref;
1599
1600 for(int i=0;i<m_HashMap[pSelLogEntry->m_CommitHash].size();i++)
1601 {
1602 ref = m_HashMap[pSelLogEntry->m_CommitHash][i];
1603 if(ref.Find(_T("refs/heads/")) == 0 && ref != currentBranch)
1604 {
1605 branchs.push_back(&m_HashMap[pSelLogEntry->m_CommitHash][i]);
1606 }
1607 }
1608
1609 CString str;
1610 str.LoadString(IDS_SWITCH_BRANCH);
1611
1612 if(branchs.size() == 1)
1613 {
1614 str+=_T(" ");
1615 str+= _T('"') + branchs[0]->Mid(11) + _T('"');
1616 popup.AppendMenuIcon(ID_SWITCHBRANCH,str,IDI_SWITCH);
1617
1618 popup.SetMenuItemData(ID_SWITCHBRANCH,(ULONG_PTR)branchs[0]);
1619
1620 }
1621 else if(branchs.size() > 1)
1622 {
1623 subbranchmenu.CreatePopupMenu();
1624 for(int i=0;i<branchs.size();i++)
1625 {
1626 if (*branchs[i] != currentBranch)
1627 {
1628 subbranchmenu.AppendMenuIcon(ID_SWITCHBRANCH+(i<<16), branchs[i]->Mid(11));
1629 subbranchmenu.SetMenuItemData(ID_SWITCHBRANCH+(i<<16), (ULONG_PTR) branchs[i]);
1630 }
1631 }
1632
1633 popup.AppendMenuIcon(ID_SWITCHBRANCH, str, IDI_SWITCH, subbranchmenu.m_hMenu);
1634 }
1635 }
1636
1637 if(m_ContextMenuMask&GetContextMenuBit(ID_SWITCHTOREV) && !isHeadCommit && m_hasWC)
1638 popup.AppendMenuIcon(ID_SWITCHTOREV, IDS_SWITCH_TO_THIS , IDI_SWITCH);
1639
1640 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_BRANCH))
1641 popup.AppendMenuIcon(ID_CREATE_BRANCH, IDS_CREATE_BRANCH_AT_THIS , IDI_COPY);
1642
1643 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_TAG))
1644 popup.AppendMenuIcon(ID_CREATE_TAG,IDS_CREATE_TAG_AT_THIS , IDI_TAG);
1645
1646 format.LoadString(IDS_REBASE_THIS_FORMAT);
1647 str.Format(format,g_Git.GetCurrentBranch());
1648
1649 if(pSelLogEntry->m_CommitHash != m_HeadHash && m_hasWC)
1650 if(m_ContextMenuMask&GetContextMenuBit(ID_REBASE_TO_VERSION))
1651 popup.AppendMenuIcon(ID_REBASE_TO_VERSION, str , IDI_REBASE);
1652
1653 if(m_ContextMenuMask&GetContextMenuBit(ID_EXPORT))
1654 popup.AppendMenuIcon(ID_EXPORT,IDS_EXPORT_TO_THIS, IDI_EXPORT);
1655
1656 if (m_ContextMenuMask&GetContextMenuBit(ID_REVERTREV) && m_hasWC)
1657 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREV, IDI_REVERT);
1658
1659 if (m_ContextMenuMask&GetContextMenuBit(ID_EDITNOTE))
1660 popup.AppendMenuIcon(ID_EDITNOTE, IDS_EDIT_NOTES, IDI_EDIT);
1661
1662 popup.AppendMenu(MF_SEPARATOR, NULL);
1663 }
1664
1665 }
1666
1667 if(!pSelLogEntry->m_Ref.IsEmpty() && GetSelectedCount() == 1)
1668 {
1669 popup.AppendMenuIcon(ID_REFLOG_DEL, IDS_REFLOG_DEL, IDI_DELETE);
1670 if (pSelLogEntry->m_Ref.Find(_T("refs/stash")) == 0)
1671 popup.AppendMenuIcon(ID_STASH_APPLY, IDS_MENUSTASHAPPLY, IDI_RELOCATE);
1672 popup.AppendMenu(MF_SEPARATOR, NULL);
1673 }
1674
1675 if (GetSelectedCount() >= 2)
1676 {
1677 bool bAddSeparator = false;
1678 if (IsSelectionContinuous() || (GetSelectedCount() == 2))
1679 {
1680 if(m_ContextMenuMask&GetContextMenuBit(ID_COMPARETWO)) // compare two revisions
1681 popup.AppendMenuIcon(ID_COMPARETWO, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);
1682 }
1683
1684 if (GetSelectedCount() == 2)
1685 {
1686 //popup.AppendMenuIcon(ID_BLAMETWO, IDS_LOG_POPUP_BLAMEREVS, IDI_BLAME);
1687 if(m_ContextMenuMask&GetContextMenuBit(ID_GNUDIFF2) && m_hasWC) // compare two revisions, unified
1688 popup.AppendMenuIcon(ID_GNUDIFF2, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
1689 bAddSeparator = true;
1690 }
1691
1692 if (m_hasWC)
1693 {
1694 //popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREVS, IDI_REVERT);
1695 // if (m_hasWC)
1696 // popup.AppendMenuIcon(ID_MERGEREV, IDS_LOG_POPUP_MERGEREVS, IDI_MERGE);
1697 bAddSeparator = true;
1698 }
1699
1700 if (m_ContextMenuMask&GetContextMenuBit(ID_REVERTREV) && m_hasWC)
1701 popup.AppendMenuIcon(ID_REVERTREV, IDS_LOG_POPUP_REVERTREVS, IDI_REVERT);
1702
1703 if (bAddSeparator)
1704 popup.AppendMenu(MF_SEPARATOR, NULL);
1705 }
1706
1707 if ( GetSelectedCount() >0 && (!pSelLogEntry->m_CommitHash.IsEmpty()))
1708 {
1709 bool bAddSeparator = false;
1710 if ( IsSelectionContinuous() && GetSelectedCount() >= 2 )
1711 {
1712 if(m_ContextMenuMask&GetContextMenuBit(ID_COMBINE_COMMIT) && m_hasWC)
1713 {
1714 CString head;
1715 int headindex;
1716 headindex = this->GetHeadIndex();
1717 if(headindex>=0)
1718 {
1719 head.Format(_T("HEAD~%d"),LastSelect-headindex);
1720 CGitHash hash=g_Git.GetHash(head);
1721 GitRev* pLastEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(LastSelect));
1722 if(pLastEntry->m_CommitHash == hash) {
1723 popup.AppendMenuIcon(ID_COMBINE_COMMIT,IDS_COMBINE_TO_ONE,IDI_COMBINE);
1724 bAddSeparator = true;
1725 }
1726 }
1727 }
1728 }
1729 if(m_ContextMenuMask&GetContextMenuBit(ID_CHERRY_PICK) && !isHeadCommit && m_hasWC) {
1730 if (GetSelectedCount() >= 2)
1731 popup.AppendMenuIcon(ID_CHERRY_PICK, IDS_CHERRY_PICK_VERSIONS, IDI_EXPORT);
1732 else
1733 popup.AppendMenuIcon(ID_CHERRY_PICK, IDS_CHERRY_PICK_VERSION, IDI_EXPORT);
1734 bAddSeparator = true;
1735 }
1736
1737 if(GetSelectedCount()<=2 || (IsSelectionContinuous() && GetSelectedCount() > 0))
1738 if(m_ContextMenuMask&GetContextMenuBit(ID_CREATE_PATCH)) {
1739 popup.AppendMenuIcon(ID_CREATE_PATCH, IDS_CREATE_PATCH, IDI_PATCH);
1740 bAddSeparator = true;
1741 }
1742
1743 if (bAddSeparator)
1744 popup.AppendMenu(MF_SEPARATOR, NULL);
1745 }
1746
1747 #if 0
1748 // if ((selEntries.size() > 0)&&(bAllFromTheSameAuthor))
1749 // {
1750 // popup.AppendMenuIcon(ID_EDITAUTHOR, IDS_LOG_POPUP_EDITAUTHOR);
1751 // }
1752 // if (GetSelectedCount() == 1)
1753 // {
1754 // popup.AppendMenuIcon(ID_EDITLOG, IDS_LOG_POPUP_EDITLOG);
1755 // popup.AppendMenuIcon(ID_REVPROPS, IDS_REPOBROWSE_SHOWREVPROP, IDI_PROPERTIES); // "Show Revision Properties"
1756 // popup.AppendMenu(MF_SEPARATOR, NULL);
1757 // }
1758 #endif
1759
1760 if (GetSelectedCount() == 1)
1761 {
1762 bool bAddSeparator = false;
1763 if(m_ContextMenuMask&GetContextMenuBit(ID_PUSH) && m_HashMap[pSelLogEntry->m_CommitHash].size() >= 1)
1764 {
1765 // show the push-option only if the log entry has an associated local branch
1766 bool isLocal = false;
1767 for(int i=0; isLocal == false && i < m_HashMap[pSelLogEntry->m_CommitHash].size(); i++)
1768 {
1769 if (m_HashMap[pSelLogEntry->m_CommitHash][i].Find(_T("refs/heads/")) == 0)
1770 isLocal = true;
1771 }
1772 if (isLocal)
1773 {
1774 popup.AppendMenuIcon(ID_PUSH, IDS_LOG_PUSH, IDI_PUSH);
1775 bAddSeparator = true;
1776 }
1777 }
1778
1779 if(m_ContextMenuMask &GetContextMenuBit(ID_DELETE))
1780 {
1781 if( this->m_HashMap.find(pSelLogEntry->m_CommitHash) != m_HashMap.end() )
1782 {
1783 CString str;
1784 if( m_HashMap[pSelLogEntry->m_CommitHash].size() == 1 )
1785 {
1786 str.LoadString(IDS_DELETE_BRANCHTAG_SHORT);
1787 str+=_T(" ");
1788 str+=m_HashMap[pSelLogEntry->m_CommitHash].at(0);
1789 popup.AppendMenuIcon(ID_DELETE, str, IDI_DELETE);
1790 bAddSeparator = true;
1791 }
1792 else if( m_HashMap[pSelLogEntry->m_CommitHash].size() > 1 )
1793 {
1794 str.LoadString(IDS_DELETE_BRANCHTAG);
1795 submenu.CreatePopupMenu();
1796 for(int i=0;i<m_HashMap[pSelLogEntry->m_CommitHash].size();i++)
1797 {
1798 submenu.AppendMenuIcon(ID_DELETE+(i<<16),m_HashMap[pSelLogEntry->m_CommitHash][i]);
1799 }
1800
1801 popup.AppendMenuIcon(ID_DELETE,str, IDI_DELETE, submenu.m_hMenu);
1802 bAddSeparator = true;
1803 }
1804 }
1805 } // m_ContextMenuMask &GetContextMenuBit(ID_DELETE)
1806 if (bAddSeparator)
1807 popup.AppendMenu(MF_SEPARATOR, NULL);
1808 } // GetSelectedCount() == 1
1809
1810 if (GetSelectedCount() == 1)
1811 {
1812 if(m_ContextMenuMask&GetContextMenuBit(ID_COPYHASH))
1813 popup.AppendMenuIcon(ID_COPYHASH, IDS_COPY_COMMIT_HASH, IDI_COPYCLIP);
1814 }
1815 if (GetSelectedCount() != 0)
1816 {
1817 if(m_ContextMenuMask&GetContextMenuBit(ID_COPYCLIPBOARD))
1818 popup.AppendMenuIcon(ID_COPYCLIPBOARD, IDS_LOG_POPUP_COPYTOCLIPBOARD, IDI_COPYCLIP);
1819 }
1820
1821 if(m_ContextMenuMask&GetContextMenuBit(ID_FINDENTRY))
1822 popup.AppendMenuIcon(ID_FINDENTRY, IDS_LOG_POPUP_FIND, IDI_FILTEREDIT);
1823
1824 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1825 // DialogEnableWindow(IDOK, FALSE);
1826 // SetPromptApp(&theApp);
1827
1828 this->ContextMenuAction(cmd, FirstSelect, LastSelect, &popup);
1829
1830 // EnableOKButton();
1831 } // if (popup.CreatePopupMenu())
1832
1833 }
1834
1835 bool CGitLogListBase::IsSelectionContinuous()
1836 {
1837 if ( GetSelectedCount()==1 )
1838 {
1839 // if only one revision is selected, the selection is of course
1840 // continuous
1841 return true;
1842 }
1843
1844 POSITION pos = GetFirstSelectedItemPosition();
1845 bool bContinuous = (m_arShownList.GetCount() == (INT_PTR)m_logEntries.size());
1846 if (bContinuous)
1847 {
1848 int itemindex = GetNextSelectedItem(pos);
1849 while (pos)
1850 {
1851 int nextindex = GetNextSelectedItem(pos);
1852 if (nextindex - itemindex > 1)
1853 {
1854 bContinuous = false;
1855 break;
1856 }
1857 itemindex = nextindex;
1858 }
1859 }
1860 return bContinuous;
1861 }
1862
1863 void CGitLogListBase::CopySelectionToClipBoard(bool HashOnly)
1864 {
1865
1866 CString sClipdata;
1867 POSITION pos = GetFirstSelectedItemPosition();
1868 if (pos != NULL)
1869 {
1870 CString sRev;
1871 sRev.LoadString(IDS_LOG_REVISION);
1872 CString sAuthor;
1873 sAuthor.LoadString(IDS_LOG_AUTHOR);
1874 CString sDate;
1875 sDate.LoadString(IDS_LOG_DATE);
1876 CString sMessage;
1877 sMessage.LoadString(IDS_LOG_MESSAGE);
1878 while (pos)
1879 {
1880 CString sLogCopyText;
1881 CString sPaths;
1882 GitRev * pLogEntry = reinterpret_cast<GitRev *>(m_arShownList.SafeGetAt(GetNextSelectedItem(pos)));
1883
1884 if(!HashOnly)
1885 {
1886 //pLogEntry->GetFiles(this)
1887 //LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;
1888
1889 for (int cpPathIndex = 0; cpPathIndex<pLogEntry->GetFiles(this).GetCount(); ++cpPathIndex)
1890 {
1891 sPaths += ((CTGitPath&)pLogEntry->GetFiles(this)[cpPathIndex]).GetActionName() + _T(" : ") + pLogEntry->GetFiles(this)[cpPathIndex].GetGitPathString();
1892 sPaths += _T("\r\n");
1893 }
1894 sPaths.Trim();
1895 CString body = pLogEntry->GetBody();
1896 body.Replace(_T("\n"), _T("\r\n"));
1897 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"),
1898 (LPCTSTR)sRev, pLogEntry->m_CommitHash.ToString(),
1899 (LPCTSTR)sAuthor, (LPCTSTR)pLogEntry->GetAuthorName(),
1900 (LPCTSTR)sDate,
1901 (LPCTSTR)CAppUtils::FormatDateAndTime( pLogEntry->GetAuthorDate(), m_DateFormat, true, m_bRelativeTimes ),
1902 (LPCTSTR)sMessage, pLogEntry->GetSubject().Trim() + _T("\r\n\r\n") + body.Trim(),
1903 (LPCTSTR)sPaths);
1904 sClipdata += sLogCopyText;
1905 }
1906 else
1907 {
1908 sClipdata += pLogEntry->m_CommitHash;
1909 break;
1910 }
1911
1912 }
1913 CStringUtils::WriteAsciiStringToClipboard(sClipdata, GetSafeHwnd());
1914 }
1915
1916 }
1917
1918 void CGitLogListBase::DiffSelectedRevWithPrevious()
1919 {
1920 if (m_bThreadRunning)
1921 return;
1922
1923 int FirstSelect=-1, LastSelect=-1;
1924 POSITION pos = GetFirstSelectedItemPosition();
1925 FirstSelect = GetNextSelectedItem(pos);
1926 while(pos)
1927 {
1928 LastSelect = GetNextSelectedItem(pos);
1929 }
1930
1931 ContextMenuAction(ID_COMPAREWITHPREVIOUS,FirstSelect,LastSelect, NULL);
1932
1933 #if 0
1934 UpdateLogInfoLabel();
1935 int selIndex = m_LogList.GetSelectionMark();
1936 if (selIndex < 0)
1937 return;
1938 int selCount = m_LogList.GetSelectedCount();
1939 if (selCount != 1)
1940 return;
1941
1942 // Find selected entry in the log list
1943 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1944 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
1945 long rev1 = pLogEntry->Rev;
1946 long rev2 = rev1-1;
1947 CTGitPath path = m_path;
1948
1949 // See how many files under the relative root were changed in selected revision
1950 int nChanged = 0;
1951 LogChangedPath * changed = NULL;
1952 for (INT_PTR c = 0; c < pLogEntry->pArChangedPaths->GetCount(); ++c)
1953 {
1954 LogChangedPath * cpath = pLogEntry->pArChangedPaths->SafeGetAt(c);
1955 if (cpath && cpath -> sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)
1956 {
1957 ++nChanged;
1958 changed = cpath;
1959 }
1960 }
1961
1962 if (m_path.IsDirectory() && nChanged == 1)
1963 {
1964 // We're looking at the log for a directory and only one file under dir was changed in the revision
1965 // Do diff on that file instead of whole directory
1966 path.AppendPathString(changed->sPath.Mid(m_sRelativeRoot.GetLength()));
1967 }
1968
1969 m_bCancelled = FALSE;
1970 DialogEnableWindow(IDOK, FALSE);
1971 SetPromptApp(&theApp);
1972 theApp.DoWaitCursor(1);
1973
1974 if (PromptShown())
1975 {
1976 GitDiff diff(this, m_hWnd, true);
1977 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
1978 diff.SetHEADPeg(m_LogRevision);
1979 diff.ShowCompare(path, rev2, path, rev1);
1980 }
1981 else
1982 {
1983 CAppUtils::StartShowCompare(m_hWnd, path, rev2, path, rev1, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
1984 }
1985
1986 theApp.DoWaitCursor(-1);
1987 EnableOKButton();
1988 #endif
1989 }
1990
1991 void CGitLogListBase::OnLvnOdfinditemLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1992 {
1993 LPNMLVFINDITEM pFindInfo = reinterpret_cast<LPNMLVFINDITEM>(pNMHDR);
1994 *pResult = -1;
1995
1996 if (pFindInfo->lvfi.flags & LVFI_PARAM)
1997 return;
1998 if ((pFindInfo->iStart < 0)||(pFindInfo->iStart >= m_arShownList.GetCount()))
1999 return;
2000 if (pFindInfo->lvfi.psz == 0)
2001 return;
2002 #if 0
2003 CString sCmp = pFindInfo->lvfi.psz;
2004 CString sRev;
2005 for (int i=pFindInfo->iStart; i<m_arShownList.GetCount(); ++i)
2006 {
2007 GitRev * pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(i));
2008 sRev.Format(_T("%ld"), pLogEntry->Rev);
2009 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)
2010 {
2011 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)
2012 {
2013 *pResult = i;
2014 return;
2015 }
2016 }
2017 else
2018 {
2019 if (sCmp.Compare(sRev)==0)
2020 {
2021 *pResult = i;
2022 return;
2023 }
2024 }
2025 }
2026 if (pFindInfo->lvfi.flags & LVFI_WRAP)
2027 {
2028 for (int i=0; i<pFindInfo->iStart; ++i)
2029 {
2030 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(i));
2031 sRev.Format(_T("%ld"), pLogEntry->Rev);
2032 if (pFindInfo->lvfi.flags & LVFI_PARTIAL)
2033 {
2034 if (sCmp.Compare(sRev.Left(sCmp.GetLength()))==0)
2035 {
2036 *pResult = i;
2037 return;
2038 }
2039 }
2040 else
2041 {
2042 if (sCmp.Compare(sRev)==0)
2043 {
2044 *pResult = i;
2045 return;
2046 }
2047 }
2048 }
2049 }
2050 #endif
2051 *pResult = -1;
2052 }
2053
2054 int CGitLogListBase::FillGitLog(CTGitPath *path,int info,CString *from,CString *to)
2055 {
2056 ClearText();
2057
2058
2059 this->m_arShownList.SafeRemoveAll();
2060
2061 this->m_logEntries.ClearAll();
2062 this->m_logEntries.ParserFromLog(path,-1,info,from,to);
2063
2064 //this->m_logEntries.ParserFromLog();
2065 SetItemCountEx(this->m_logEntries.size());
2066
2067 for(unsigned int i=0;i<m_logEntries.size();i++)
2068 {
2069 if(m_IsOldFirst)
2070 {
2071 m_logEntries.GetGitRevAt(m_logEntries.size()-i-1).m_IsFull=TRUE;
2072 this->m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size()-i-1));
2073
2074 }
2075 else
2076 {
2077 m_logEntries.GetGitRevAt(i).m_IsFull=TRUE;
2078 this->m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
2079 }
2080 }
2081
2082 if(path)
2083 m_Path=*path;
2084 return 0;
2085
2086 }
2087
2088 int CGitLogListBase::BeginFetchLog()
2089 {
2090 ClearText();
2091
2092 this->m_arShownList.SafeRemoveAll();
2093
2094 this->m_logEntries.ClearAll();
2095 git_init();
2096
2097 this->m_LogCache.ClearAllParent();
2098
2099 m_LogCache.FetchCacheIndex(g_Git.m_CurrentDir);
2100
2101 CTGitPath *path;
2102 if(this->m_Path.IsEmpty())
2103 path=NULL;
2104 else
2105 path=&this->m_Path;
2106
2107 CString hash;
2108 int mask;
2109 mask = CGit::LOG_INFO_ONLY_HASH | CGit::LOG_INFO_BOUNDARY;
2110 // if(this->m_bAllBranch)
2111 mask |= m_ShowMask ;
2112
2113 if(m_bShowWC)
2114 {
2115 this->m_logEntries.insert(m_logEntries.begin(),this->m_wcRev.m_CommitHash);
2116 ResetWcRev();
2117 this->m_LogCache.m_HashMap[m_wcRev.m_CommitHash]=m_wcRev;
2118 }
2119
2120 CString *pFrom, *pTo;
2121 pFrom = pTo = NULL;
2122 CString head(_T("HEAD"));
2123 if(!this->m_startrev.IsEmpty())
2124 {
2125 pFrom = &this->m_startrev;
2126 if(!this->m_endrev.IsEmpty())
2127 pTo = &this->m_endrev;
2128 else
2129 pTo = &head;
2130 }
2131
2132 CFilterData data;
2133 data.m_From = m_From;
2134 data.m_To =m_To;
2135
2136 #if 0 /* use tortoiegit filter */
2137 if(this->m_nSelectedFilter == LOGFILTER_ALL || m_nSelectedFilter == LOGFILTER_AUTHORS)
2138 data.m_Author = this->m_sFilterText;
2139
2140 if(this->m_nSelectedFilter == LOGFILTER_ALL || m_nSelectedFilter == LOGFILTER_MESSAGES)
2141 data.m_MessageFilter = this->m_sFilterText;
2142
2143 data.m_IsRegex = m_bFilterWithRegex;
2144 #endif
2145
2146 CString cmd=g_Git.GetLogCmd(m_StartRef,path,-1,mask,pFrom,pTo,true,&data);
2147
2148 //this->m_logEntries.ParserFromLog();
2149 if(IsInWorkingThread())
2150 {
2151 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL);
2152 }
2153 else
2154 {
2155 SetItemCountEx(this->m_logEntries.size());
2156 }
2157
2158 git_init();
2159
2160 if(g_Git.IsInitRepos())
2161 return 0;
2162
2163 if(git_open_log(&m_DllGitLog,CUnicodeUtils::GetMulti(cmd,CP_ACP).GetBuffer()))
2164 {
2165 return -1;
2166 }
2167
2168 return 0;
2169 }
2170
2171 BOOL CGitLogListBase::PreTranslateMessage(MSG* pMsg)
2172 {
2173 if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')
2174 {
2175 //if (GetFocus()==GetDlgItem(IDC_LOGLIST))
2176 {
2177 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
2178 {
2179 DiffSelectedRevWithPrevious();
2180 return TRUE;
2181 }
2182 }
2183 #if 0
2184 if (GetFocus()==GetDlgItem(IDC_LOGMSG))
2185 {
2186 DiffSelectedFile();
2187 return TRUE;
2188 }
2189 #endif
2190 }
2191 else if (pMsg->message == WM_KEYDOWN && pMsg->wParam == 'A' && GetAsyncKeyState(VK_CONTROL)&0x8000)
2192 {
2193 // select all entries
2194 for (int i=0; i<GetItemCount(); ++i)
2195 {
2196 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2197 }
2198 return TRUE;
2199 }
2200
2201 #if 0
2202 if (m_hAccel && !bSkipAccelerator)
2203 {
2204 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
2205 if (ret)
2206 return TRUE;
2207 }
2208
2209 #endif
2210 //m_tooltips.RelayEvent(pMsg);
2211 return __super::PreTranslateMessage(pMsg);
2212 }
2213
2214 void CGitLogListBase::OnNMDblclkLoglist(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2215 {
2216 // a double click on an entry in the revision list has happened
2217 *pResult = 0;
2218
2219 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
2220 DiffSelectedRevWithPrevious();
2221 }
2222
2223 int CGitLogListBase::FetchLogAsync(void * data)
2224 {
2225 m_ProcData=data;
2226 m_bExitThread=FALSE;
2227 InterlockedExchange(&m_bThreadRunning, TRUE);
2228 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2229 m_LoadingThread = AfxBeginThread(LogThreadEntry, this, THREAD_PRIORITY_LOWEST);
2230 if (m_LoadingThread ==NULL)
2231 {
2232 InterlockedExchange(&m_bThreadRunning, FALSE);
2233 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2234 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
2235 return -1;
2236 }
2237 return 0;
2238 }
2239
2240 //this is the thread function which calls the subversion function
2241 UINT CGitLogListBase::LogThreadEntry(LPVOID pVoid)
2242 {
2243 return ((CGitLogListBase*)pVoid)->LogThread();
2244 }
2245
2246 void CGitLogListBase::GetTimeRange(CTime &oldest, CTime &latest)
2247 {
2248 //CTime time;
2249 oldest=CTime::GetCurrentTime();
2250 latest=CTime(1971,1,2,0,0,0);
2251 for(unsigned int i=0;i<m_logEntries.size();i++)
2252 {
2253 if(m_logEntries[i].IsEmpty())
2254 continue;
2255
2256 if(m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime() < oldest.GetTime())
2257 oldest = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
2258
2259 if(m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime() > latest.GetTime())
2260 latest = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
2261
2262 }
2263
2264 if(latest<oldest)
2265 latest=oldest;
2266 }
2267
2268 UINT CGitLogListBase::LogThread()
2269 {
2270 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) GITLOG_START,0);
2271
2272 InterlockedExchange(&m_bThreadRunning, TRUE);
2273 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2274
2275 ULONGLONG t1,t2;
2276
2277 if(BeginFetchLog())
2278 {
2279 InterlockedExchange(&m_bThreadRunning, FALSE);
2280 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2281
2282 return -1;
2283 }
2284
2285 tr1::wregex pat;//(_T("Remove"), tr1::regex_constants::icase);
2286 bool bRegex = false;
2287 if (m_bFilterWithRegex)
2288 bRegex = ValidateRegexp(m_sFilterText, pat, false);
2289
2290 TRACE(_T("\n===Begin===\n"));
2291 //Update work copy item;
2292
2293 if( m_logEntries.size() > 0)
2294 {
2295 GitRev *pRev = &m_logEntries.GetGitRevAt(0);
2296
2297 m_arShownList.SafeAdd(pRev);
2298 }
2299
2300
2301 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2302
2303 // store commit number of the last selected commit/line before the refresh or -1
2304 int lastSelectedHashNItem = -1;
2305
2306 if(!g_Git.IsInitRepos())
2307 {
2308 g_Git.m_critGitDllSec.Lock();
2309 git_get_log_firstcommit(m_DllGitLog);
2310 int total = git_get_log_estimate_commit_count(m_DllGitLog);
2311 g_Git.m_critGitDllSec.Unlock();
2312
2313 GIT_COMMIT commit;
2314 t2=t1=GetTickCount();
2315 int oldprecentage = 0;
2316 int oldsize=m_logEntries.size();
2317 int ret=0;
2318 while( ret== 0)
2319 {
2320 g_Git.m_critGitDllSec.Lock();
2321 ret = git_get_log_nextcommit(this->m_DllGitLog, &commit, 0);
2322 g_Git.m_critGitDllSec.Unlock();
2323
2324 if(ret)
2325 break;
2326
2327 //printf("%s\r\n",commit.GetSubject());
2328 if(m_bExitThread)
2329 break;
2330
2331 CGitHash hash = (char*)commit.m_hash ;
2332
2333 GitRev *pRev = m_LogCache.GetCacheData(hash);
2334 pRev->m_GitCommit = commit;
2335 InterlockedExchange(&pRev->m_IsCommitParsed, FALSE);
2336
2337 char *note=NULL;
2338 g_Git.m_critGitDllSec.Lock();
2339 git_get_notes(commit.m_hash,&note);
2340 g_Git.m_critGitDllSec.Unlock();
2341
2342 if(note)
2343 {
2344 pRev->m_Notes.Empty();
2345 g_Git.StringAppend(&pRev->m_Notes,(BYTE*)note);
2346 }
2347
2348 if(!pRev->m_IsDiffFiles)
2349 {
2350 pRev->m_CallDiffAsync = DiffAsync;
2351 }
2352
2353 pRev->ParserParentFromCommit(&commit);
2354
2355 #ifdef DEBUG
2356 pRev->DbgPrint();
2357 TRACE(_T("\n"));
2358 #endif
2359
2360 if(!m_sFilterText.IsEmpty())
2361 {
2362 if(!IsMatchFilter(bRegex,pRev,pat))
2363 continue;
2364 }
2365 this->m_critSec.Lock();
2366 m_logEntries.push_back(hash);
2367 m_arShownList.SafeAdd(pRev);
2368 this->m_critSec.Unlock();
2369
2370 if (lastSelectedHashNItem == -1 && hash == m_lastSelectedHash)
2371 lastSelectedHashNItem = m_arShownList.GetCount() - 1;
2372
2373 t2=GetTickCount();
2374
2375 if(t2-t1>500 || (m_logEntries.size()-oldsize >100))
2376 {
2377 //update UI
2378 int percent=m_logEntries.size()*100/total + GITLOG_START+1;
2379 if(percent > 99)
2380 percent =99;
2381 if(percent < GITLOG_START)
2382 percent = GITLOG_START +1;
2383
2384 oldsize = m_logEntries.size();
2385 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL|LVSICF_NOSCROLL);
2386
2387 //if( percent > oldprecentage )
2388 {
2389 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) percent,0);
2390 oldprecentage = percent;
2391 }
2392 t1 = t2;
2393 }
2394 }
2395 g_Git.m_critGitDllSec.Lock();
2396 git_close_log(m_DllGitLog);
2397 g_Git.m_critGitDllSec.Unlock();
2398
2399 }
2400
2401 // restore last selected item
2402 if (lastSelectedHashNItem >= 0)
2403 {
2404 SetItemState(lastSelectedHashNItem, LVIS_SELECTED, LVIS_SELECTED);
2405 EnsureVisible(lastSelectedHashNItem, FALSE);
2406 }
2407
2408 //Update UI;
2409 PostMessage(LVM_SETITEMCOUNT, (WPARAM) this->m_logEntries.size(),(LPARAM) LVSICF_NOINVALIDATEALL|LVSICF_NOSCROLL);
2410 ::PostMessage(this->GetParent()->m_hWnd,MSG_LOAD_PERCENTAGE,(WPARAM) GITLOG_END,0);
2411
2412 InterlockedExchange(&m_bThreadRunning, FALSE);
2413
2414 return 0;
2415 }
2416
2417 void CGitLogListBase::Refresh(BOOL IsCleanFilter)
2418 {
2419 SafeTerminateThread();
2420
2421 this->SetItemCountEx(0);
2422 this->Clear();
2423
2424 ResetWcRev();
2425
2426 //Update branch and Tag info
2427 ReloadHashMap();
2428 //Assume Thread have exited
2429 //if(!m_bThreadRunning)
2430 {
2431 m_logEntries.clear();
2432
2433 if(IsCleanFilter)
2434 {
2435 m_sFilterText.Empty();
2436 m_From=-1;
2437 m_To=-1;
2438 }
2439
2440 InterlockedExchange(&m_bExitThread,FALSE);
2441
2442 InterlockedExchange(&m_bThreadRunning, TRUE);
2443 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2444 if ( (m_LoadingThread=AfxBeginThread(LogThreadEntry, this)) ==NULL)
2445 {
2446 InterlockedExchange(&m_bThreadRunning, FALSE);
2447 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2448 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
2449 }
2450 }
2451 }
2452 bool CGitLogListBase::ValidateRegexp(LPCTSTR regexp_str, tr1::wregex& pat, bool bMatchCase /* = false */)
2453 {
2454 try
2455 {
2456 tr1::regex_constants::syntax_option_type type = tr1::regex_constants::ECMAScript;
2457 if (!bMatchCase)
2458 type |= tr1::regex_constants::icase;
2459 pat = tr1::wregex(regexp_str, type);
2460 return true;
2461 }
2462 catch (exception) {}
2463 return false;
2464 }
2465 BOOL CGitLogListBase::IsMatchFilter(bool bRegex, GitRev *pRev, tr1::wregex &pat)
2466 {
2467
2468 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_any;
2469 CString sRev;
2470
2471 if ((bRegex)&&(m_bFilterWithRegex))
2472 {
2473 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2474 {
2475 if(this->m_bShowBugtraqColumn)
2476 {
2477 CString sBugIds = m_ProjectProperties.FindBugID(pRev->GetSubject());
2478
2479 ATLTRACE(_T("bugID = \"%s\"\n"), sBugIds);
2480 if (regex_search(wstring(sBugIds), pat, flags))
2481 {
2482 return TRUE;
2483 }
2484 }
2485 }
2486
2487 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_SUBJECT)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2488 {
2489 ATLTRACE(_T("messge = \"%s\"\n"), pRev->GetSubject());
2490 if (regex_search(wstring((LPCTSTR)pRev->GetSubject()), pat, flags))
2491 {
2492 return TRUE;
2493 }
2494 }
2495
2496 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2497 {
2498 ATLTRACE(_T("messge = \"%s\"\n"),pRev->GetBody());
2499 if (regex_search(wstring((LPCTSTR)pRev->GetBody()), pat, flags))
2500 {
2501 return TRUE;
2502 }
2503 }
2504
2505 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))
2506 {
2507 if (regex_search(wstring(pRev->GetAuthorName()), pat, flags))
2508 {
2509 return TRUE;
2510 }
2511
2512 if (regex_search(wstring(pRev->GetCommitterName()), pat, flags))
2513 {
2514 return TRUE;
2515 }
2516 }
2517
2518 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))
2519 {
2520 sRev.Format(_T("%s"), pRev->m_CommitHash.ToString());
2521 if (regex_search(wstring((LPCTSTR)sRev), pat, flags))
2522 {
2523 return TRUE;
2524 }
2525 }
2526
2527 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))
2528 {
2529 CTGitPathList *pathList=NULL;
2530 if( pRev->m_IsDiffFiles)
2531 pathList = &pRev->GetFiles(this);
2532 else
2533 {
2534 if(!pRev->m_IsSimpleListReady)
2535 pRev->SafeGetSimpleList(&g_Git);
2536 }
2537
2538 if(pathList)
2539 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList->GetCount(); ++cpPathIndex)
2540 {
2541 if (regex_search(wstring((LPCTSTR)pathList->m_paths.at(cpPathIndex).GetGitOldPathString()), pat, flags))
2542 {
2543 return true;
2544 }
2545 if (regex_search(wstring((LPCTSTR)pathList->m_paths.at(cpPathIndex).GetGitPathString()), pat, flags))
2546 {
2547 return true;
2548 }
2549 }
2550
2551 for(INT_PTR i=0;i<pRev->m_SimpleFileList.size();i++)
2552 {
2553 if (regex_search(wstring((LPCTSTR)pRev->m_SimpleFileList[i]), pat, flags))
2554 {
2555 return true;
2556 }
2557 }
2558 }
2559 }
2560 else
2561 {
2562 CString find = m_sFilterText;
2563 find.MakeLower();
2564
2565 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2566 {
2567 if(this->m_bShowBugtraqColumn)
2568 {
2569 CString sBugIds = m_ProjectProperties.FindBugID(pRev->GetSubject());
2570
2571 sBugIds.MakeLower();
2572 if ((sBugIds.Find(find) >= 0))
2573 {
2574 return TRUE;
2575 }
2576 }
2577 }
2578
2579 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_SUBJECT)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2580 {
2581 CString msg = pRev->GetSubject();
2582
2583 msg = msg.MakeLower();
2584 if ((msg.Find(find) >= 0))
2585 {
2586 return TRUE;
2587 }
2588 }
2589
2590 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2591 {
2592 CString msg = pRev->GetBody();
2593
2594 msg = msg.MakeLower();
2595 if ((msg.Find(find) >= 0))
2596 {
2597 return TRUE;
2598 }
2599 }
2600
2601 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))
2602 {
2603 CString msg = pRev->GetAuthorName();
2604 msg = msg.MakeLower();
2605 if ((msg.Find(find) >= 0))
2606 {
2607 return TRUE;
2608 }
2609 }
2610
2611 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))
2612 {
2613 sRev.Format(_T("%s"), pRev->m_CommitHash.ToString());
2614 if ((sRev.Find(find) >= 0))
2615 {
2616 return TRUE;
2617 }
2618 }
2619
2620 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))
2621 {
2622 CTGitPathList *pathList=NULL;
2623 if( pRev->m_IsDiffFiles)
2624 pathList = &pRev->GetFiles(this);
2625 else
2626 {
2627 if(!pRev->m_IsSimpleListReady)
2628 pRev->SafeGetSimpleList(&g_Git);
2629 }
2630 if(pathList)
2631 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList->GetCount() ; ++cpPathIndex)
2632 {
2633 CTGitPath *cpath = &pathList->m_paths.at(cpPathIndex);
2634 CString path = cpath->GetGitOldPathString();
2635 path.MakeLower();
2636 if ((path.Find(find)>=0))
2637 {
2638 return true;
2639 }
2640 path = cpath->GetGitPathString();
2641 path.MakeLower();
2642 if ((path.Find(find)>=0))
2643 {
2644 return true;
2645 }
2646 }
2647
2648 for (INT_PTR i=0;i<pRev->m_SimpleFileList.size();i++)
2649 {
2650 CString path = pRev->m_SimpleFileList[i];
2651 path.MakeLower();
2652 if ((path.Find(find)>=0))
2653 {
2654 return true;
2655 }
2656 }
2657 }
2658 } // else (from if (bRegex))
2659 return FALSE;
2660 }
2661
2662
2663 void CGitLogListBase::RecalculateShownList(CThreadSafePtrArray * pShownlist)
2664 {
2665
2666 pShownlist->SafeRemoveAll();
2667
2668 tr1::wregex pat;//(_T("Remove"), tr1::regex_constants::icase);
2669 bool bRegex = false;
2670 if (m_bFilterWithRegex)
2671 bRegex = ValidateRegexp(m_sFilterText, pat, false);
2672
2673 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_any;
2674 CString sRev;
2675 for (DWORD i=0; i<m_logEntries.size(); ++i)
2676 {
2677 if ((bRegex)&&(m_bFilterWithRegex))
2678 {
2679 #if 0
2680 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2681 {
2682 ATLTRACE(_T("bugID = \"%s\"\n"), (LPCTSTR)m_logEntries[i]->sBugIDs);
2683 if (regex_search(wstring((LPCTSTR)m_logEntries[i]->sBugIDs), pat, flags)&&IsEntryInDateRange(i))
2684 {
2685 pShownlist->SafeAdd(m_logEntries[i]);
2686 continue;
2687 }
2688 }
2689 #endif
2690 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_SUBJECT)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2691 {
2692 ATLTRACE(_T("messge = \"%s\"\n"),m_logEntries.GetGitRevAt(i).GetSubject());
2693 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetSubject()), pat, flags)&&IsEntryInDateRange(i))
2694 {
2695 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2696 continue;
2697 }
2698 }
2699 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2700 {
2701 ATLTRACE(_T("messge = \"%s\"\n"),m_logEntries.GetGitRevAt(i).GetBody());
2702 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetBody()), pat, flags)&&IsEntryInDateRange(i))
2703 {
2704 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2705 continue;
2706 }
2707 }
2708 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))
2709 {
2710 CTGitPathList pathList = m_logEntries.GetGitRevAt(i).GetFiles(this);
2711
2712 bool bGoing = true;
2713 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList.GetCount() && bGoing; ++cpPathIndex)
2714 {
2715 CTGitPath cpath = pathList[cpPathIndex];
2716 if (regex_search(wstring((LPCTSTR)cpath.GetGitOldPathString()), pat, flags)&&IsEntryInDateRange(i))
2717 {
2718 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2719 bGoing = false;
2720 continue;
2721 }
2722 if (regex_search(wstring((LPCTSTR)cpath.GetGitPathString()), pat, flags)&&IsEntryInDateRange(i))
2723 {
2724 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2725 bGoing = false;
2726 continue;
2727 }
2728 if (regex_search(wstring((LPCTSTR)cpath.GetActionName()), pat, flags)&&IsEntryInDateRange(i))
2729 {
2730 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2731 bGoing = false;
2732 continue;
2733 }
2734 }
2735 }
2736 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))
2737 {
2738 if (regex_search(wstring((LPCTSTR)m_logEntries.GetGitRevAt(i).GetAuthorName()), pat, flags)&&IsEntryInDateRange(i))
2739 {
2740 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2741 continue;
2742 }
2743 }
2744 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))
2745 {
2746 sRev.Format(_T("%s"), m_logEntries.GetGitRevAt(i).m_CommitHash.ToString());
2747 if (regex_search(wstring((LPCTSTR)sRev), pat, flags)&&IsEntryInDateRange(i))
2748 {
2749 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2750 continue;
2751 }
2752 }
2753 } // if (bRegex)
2754 else
2755 {
2756 CString find = m_sFilterText;
2757 find.MakeLower();
2758 #if 0
2759 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_BUGID))
2760 {
2761 CString sBugIDs = m_logEntries[i]->sBugIDs;
2762
2763 sBugIDs = sBugIDs.MakeLower();
2764 if ((sBugIDs.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2765 {
2766 pShownlist->SafeAdd(m_logEntries[i]);
2767 continue;
2768 }
2769 }
2770 #endif
2771 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_SUBJECT)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2772 {
2773 CString msg = m_logEntries.GetGitRevAt(i).GetSubject();
2774
2775 msg = msg.MakeLower();
2776 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2777 {
2778 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2779 continue;
2780 }
2781 }
2782 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_MESSAGES))
2783 {
2784 CString msg = m_logEntries.GetGitRevAt(i).GetBody();
2785
2786 msg = msg.MakeLower();
2787 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2788 {
2789 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2790 continue;
2791 }
2792 }
2793 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_PATHS))
2794 {
2795 CTGitPathList pathList = m_logEntries.GetGitRevAt(i).GetFiles(this);
2796
2797 bool bGoing = true;
2798 for (INT_PTR cpPathIndex = 0; cpPathIndex < pathList.GetCount() && bGoing; ++cpPathIndex)
2799 {
2800 CTGitPath cpath = pathList[cpPathIndex];
2801 CString path = cpath.GetGitOldPathString();
2802 path.MakeLower();
2803 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2804 {
2805 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2806 bGoing = false;
2807 continue;
2808 }
2809 path = cpath.GetGitPathString();
2810 path.MakeLower();
2811 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2812 {
2813 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2814 bGoing = false;
2815 continue;
2816 }
2817 path = cpath.GetActionName();
2818 path.MakeLower();
2819 if ((path.Find(find)>=0)&&(IsEntryInDateRange(i)))
2820 {
2821 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2822 bGoing = false;
2823 continue;
2824 }
2825 }
2826 }
2827 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_AUTHORS))
2828 {
2829 CString msg = m_logEntries.GetGitRevAt(i).GetAuthorName();
2830 msg = msg.MakeLower();
2831 if ((msg.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2832 {
2833 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2834 continue;
2835 }
2836 }
2837 if ((m_nSelectedFilter == LOGFILTER_ALL)||(m_nSelectedFilter == LOGFILTER_REVS))
2838 {
2839 sRev.Format(_T("%s"), m_logEntries.GetGitRevAt(i).m_CommitHash.ToString());
2840 if ((sRev.Find(find) >= 0)&&(IsEntryInDateRange(i)))
2841 {
2842 pShownlist->SafeAdd(&m_logEntries.GetGitRevAt(i));
2843 continue;
2844 }
2845 }
2846 } // else (from if (bRegex))
2847 } // for (DWORD i=0; i<m_logEntries.size(); ++i)
2848
2849 }
2850
2851 BOOL CGitLogListBase::IsEntryInDateRange(int /*i*/)
2852 {
2853 /*
2854 __time64_t time = m_logEntries.GetGitRevAt(i).GetAuthorDate().GetTime();
2855
2856 if(m_From == -1)
2857 if(m_To == -1)
2858 return true;
2859 else
2860 return time <= m_To;
2861 else
2862 if(m_To == -1)
2863 return time >= m_From;
2864 else
2865 return ((time >= m_From)&&(time <= m_To));
2866 */
2867 return TRUE; /* git dll will filter time range */
2868
2869 // return TRUE;
2870 }
2871 void CGitLogListBase::StartFilter()
2872 {
2873 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2874 RecalculateShownList(&m_arShownList);
2875 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2876
2877
2878 DeleteAllItems();
2879 SetItemCountEx(ShownCountWithStopped());
2880 RedrawItems(0, ShownCountWithStopped());
2881 Invalidate();
2882
2883 }
2884 void CGitLogListBase::RemoveFilter()
2885 {
2886
2887 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2888
2889 m_arShownList.SafeRemoveAll();
2890
2891 // reset the time filter too
2892 #if 0
2893 m_timFrom = (__time64_t(m_tFrom));
2894 m_timTo = (__time64_t(m_tTo));
2895 m_DateFrom.SetTime(&m_timFrom);
2896 m_DateTo.SetTime(&m_timTo);
2897 m_DateFrom.SetRange(&m_timFrom, &m_timTo);
2898 m_DateTo.SetRange(&m_timFrom, &m_timTo);
2899 #endif
2900
2901 for (DWORD i=0; i<m_logEntries.size(); ++i)
2902 {
2903 if(this->m_IsOldFirst)
2904 {
2905 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(m_logEntries.size()-i-1));
2906 }
2907 else
2908 {
2909 m_arShownList.SafeAdd(&m_logEntries.GetGitRevAt(i));
2910 }
2911 }
2912 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
2913 DeleteAllItems();
2914 SetItemCountEx(ShownCountWithStopped());
2915 RedrawItems(0, ShownCountWithStopped());
2916
2917 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2918 }
2919
2920 void CGitLogListBase::Clear()
2921 {
2922 m_arShownList.SafeRemoveAll();
2923 DeleteAllItems();
2924
2925 m_logEntries.ClearAll();
2926
2927 }
2928
2929 void CGitLogListBase::OnDestroy()
2930 {
2931 // save the column widths to the registry
2932 SaveColumnWidths();
2933
2934 SafeTerminateThread();
2935 SafeTerminateAsyncDiffThread();
2936
2937 int retry = 0;
2938 while(m_LogCache.SaveCache())
2939 {
2940 if(retry > 5)
2941 break;
2942 Sleep(1000);
2943
2944 retry++;
2945
2946 //if(CMessageBox::Show(NULL,_T("Cannot Save Log Cache to Disk. To retry click yes. To give up click no."),_T("TortoiseGit"),
2947 // MB_YESNO) == IDNO)
2948 // break;
2949 }
2950
2951 CHintListCtrl::OnDestroy();
2952 }
2953
2954 LRESULT CGitLogListBase::OnLoad(WPARAM wParam,LPARAM lParam)
2955 {
2956 UNREFERENCED_PARAMETER(lParam);
2957 CRect rect;
2958 int i=(int)wParam;
2959 this->GetItemRect(i,&rect,LVIR_BOUNDS);
2960 this->InvalidateRect(rect);
2961
2962 return 0;
2963 }
2964
2965 /**
2966 * Save column widths to the registry
2967 */
2968 void CGitLogListBase::SaveColumnWidths()
2969 {
2970 int maxcol = m_ColumnManager.GetColumnCount();
2971
2972 for (int col = 0; col < maxcol; col++)
2973 if (m_ColumnManager.IsVisible (col))
2974 m_ColumnManager.ColumnResized (col);
2975
2976 m_ColumnManager.WriteSettings();
2977 }
2978
2979 int CGitLogListBase::GetHeadIndex()
2980 {
2981 if(m_HeadHash.IsEmpty())
2982 return -1;
2983
2984 for(int i=0;i<m_arShownList.GetCount();i++)
2985 {
2986 GitRev *pRev = (GitRev*)m_arShownList[i];
2987 if(pRev)
2988 {
2989 if(pRev->m_CommitHash.ToString() == m_HeadHash )
2990 return i;
2991 }
2992 }
2993 return -1;
2994 }
2995 void CGitLogListBase::OnFind()
2996 {
2997 if (!m_pFindDialog)
2998 {
2999 m_pFindDialog = new CFindDlg(this);
3000 m_pFindDialog->Create(this);
3001 }
3002 }
3003 void CGitLogListBase::OnHdnBegintrack(NMHDR *pNMHDR, LRESULT *pResult)
3004 {
3005 m_ColumnManager.OnHdnBegintrack(pNMHDR, pResult);
3006 }
3007 void CGitLogListBase::OnHdnItemchanging(NMHDR *pNMHDR, LRESULT *pResult)
3008 {
3009 if(!m_ColumnManager.OnHdnItemchanging(pNMHDR, pResult))
3010 Default();
3011 }
3012 LRESULT CGitLogListBase::OnFindDialogMessage(WPARAM /*wParam*/, LPARAM /*lParam*/)
3013 {
3014
3015 ASSERT(m_pFindDialog != NULL);
3016 bool bFound = false;
3017 int i=0;
3018
3019 if (m_pFindDialog->IsTerminating())
3020 {
3021 // invalidate the handle identifying the dialog box.
3022 m_pFindDialog = NULL;
3023 return 0;
3024 }
3025
3026 if(m_pFindDialog->IsRef())
3027 {
3028 CString str;
3029 str=m_pFindDialog->GetFindString();
3030
3031 CGitHash hash;
3032
3033 if(!str.IsEmpty())
3034 hash = g_Git.GetHash(str);
3035
3036 if(!hash.IsEmpty())
3037 {
3038 for (i = 0; i<m_arShownList.GetCount(); i++)
3039 {
3040 GitRev* pLogEntry = (GitRev*)m_arShownList.SafeGetAt(i);
3041 if(pLogEntry && pLogEntry->m_CommitHash == hash)
3042 {
3043 bFound = true;
3044 break;
3045 }
3046 }
3047 }
3048
3049 }
3050
3051 if(m_pFindDialog->FindNext())
3052 {
3053 //read data from dialog
3054 CString FindText = m_pFindDialog->GetFindString();
3055 bool bMatchCase = (m_pFindDialog->MatchCase() == TRUE);
3056
3057 tr1::wregex pat;
3058 bool bRegex = ValidateRegexp(FindText, pat, bMatchCase);
3059
3060 tr1::regex_constants::match_flag_type flags = tr1::regex_constants::match_not_null;
3061
3062
3063 for (i = this->m_nSearchIndex; i<m_arShownList.GetCount()&&!bFound; i++)
3064 {
3065 GitRev* pLogEntry = (GitRev*)m_arShownList.SafeGetAt(i);
3066
3067 CString str;
3068 str+=pLogEntry->m_CommitHash.ToString();
3069 str+=_T("\n");
3070
3071 for(int j=0;j<this->m_HashMap[pLogEntry->m_CommitHash].size();j++)
3072 {
3073 str+=m_HashMap[pLogEntry->m_CommitHash][j];
3074 str+=_T("\n");
3075 }
3076
3077 str+=pLogEntry->GetAuthorEmail();
3078 str+=_T("\n");
3079 str+=pLogEntry->GetAuthorName();
3080 str+=_T("\n");
3081 str+=pLogEntry->GetBody();
3082 str+=_T("\n");
3083 str+=pLogEntry->GetCommitterEmail();
3084 str+=_T("\n");
3085 str+=pLogEntry->GetCommitterName();
3086 str+=_T("\n");
3087 str+=pLogEntry->GetSubject();
3088 str+=_T("\n");
3089
3090
3091 /*Because changed files list is loaded on demand when gui show,
3092 files will empty when files have not fetched.
3093
3094 we can add it back by using one-way diff(with outnumber changed and rename detect.
3095 here just need changed filename list. one-way is much quicker.
3096 */
3097 if(pLogEntry->m_IsFull)
3098 {
3099 for(int i=0;i<pLogEntry->GetFiles(this).GetCount();i++)
3100 {
3101 str+=pLogEntry->GetFiles(this)[i].GetWinPath();
3102 str+=_T("\n");
3103 str+=pLogEntry->GetFiles(this)[i].GetGitOldPathString();
3104 str+=_T("\n");
3105 }
3106 }
3107 else
3108 {
3109 if(!pLogEntry->m_IsSimpleListReady)
3110 pLogEntry->SafeGetSimpleList(&g_Git);
3111
3112 for(int i=0;i<pLogEntry->m_SimpleFileList.size();i++)
3113 {
3114 str+=pLogEntry->m_SimpleFileList[i];
3115 str+=_T("\n");
3116 }
3117
3118 }
3119
3120
3121 if (bRegex)
3122 {
3123 if (regex_search(wstring(str), pat, flags))
3124 {
3125 bFound = true;
3126 break;
3127 }
3128 }
3129 else
3130 {
3131 if (bMatchCase)
3132 {
3133 if (str.Find(FindText) >= 0)
3134 {
3135 bFound = true;
3136 break;
3137 }
3138
3139 }
3140 else
3141 {
3142 CString msg = str;
3143 msg = msg.MakeLower();
3144 CString find = FindText.MakeLower();
3145 if (msg.Find(find) >= 0)
3146 {
3147 bFound = TRUE;
3148 break;
3149 }
3150 }
3151 }
3152 } // for (i = this->m_nSearchIndex; i<m_arShownList.GetItemCount()&&!bFound; i++)
3153
3154 } // if(m_pFindDialog->FindNext())
3155 //UpdateLogInfoLabel();
3156
3157 if (bFound)
3158 {
3159 this->m_nSearchIndex = i;
3160 EnsureVisible(i, FALSE);
3161 SetItemState(GetSelectionMark(), 0, LVIS_SELECTED);
3162 SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
3163 SetSelectionMark(i);
3164 //FillLogMessageCtrl();
3165 UpdateData(FALSE);
3166 m_nSearchIndex++;
3167 if (m_nSearchIndex >= m_arShownList.GetCount())
3168 m_nSearchIndex = (int)m_arShownList.GetCount()-1;
3169 }
3170
3171 return 0;
3172 }
3173
3174 void CGitLogListBase::OnColumnResized(NMHDR *pNMHDR, LRESULT *pResult)
3175 {
3176 m_ColumnManager.OnColumnResized(pNMHDR,pResult);
3177
3178 *pResult = FALSE;
3179 }
3180
3181 void CGitLogListBase::OnColumnMoved(NMHDR *pNMHDR, LRESULT *pResult)
3182 {
3183 m_ColumnManager.OnColumnMoved(pNMHDR, pResult);
3184
3185 Invalidate(FALSE);
3186 }
Windows Explorer Extension to Operate Git