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