?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make sure buffer is large enough for the nul terminator
[TortoiseGit.git] / src / TortoiseProc / LogDlg.cpp
blob10031ea98fee347d8262eb015626d0593b39aa55
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2003-2009, 2015 - TortoiseSVN
4 // Copyright (C) 2008-2015 - TortoiseGit
5
6 // This program is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU General Public License
8 // as published by the Free Software Foundation; either version 2
9 // of the License, or (at your option) any later version.
10
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software Foundation,
18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19
20 #include "stdafx.h"
21 #include "TortoiseProc.h"
22 #include "cursor.h"
23 #include "StatGraphDlg.h"
24 #include "LogDlg.h"
25 #include "MessageBox.h"
26 #include "registry.h"
27 #include "AppUtils.h"
28 #include "StringUtils.h"
29 #include "UnicodeUtils.h"
30 #include "TempFile.h"
31 #include "IconMenu.h"
32 #include "BrowseRefsDlg.h"
33 #include "SmartHandle.h"
34 #include "LogOrdering.h"
35
36 #define WM_TGIT_REFRESH_SELECTION (WM_APP + 1)
37
38 IMPLEMENT_DYNAMIC(CLogDlg, CResizableStandAloneDialog)
39 CLogDlg::CLogDlg(CWnd* pParent /*=NULL*/)
40 : CResizableStandAloneDialog(CLogDlg::IDD, pParent)
41 , m_wParam(0)
42 , m_currentChangedArray(NULL)
43 , m_nSortColumn(0)
44 , m_bFollowRenames(false)
45 , m_bSelect(false)
46 , m_bSelectionMustBeSingle(true)
47 , m_bShowTags(true)
48 , m_bShowLocalBranches(true)
49 , m_bShowRemoteBranches(true)
50 , m_bNoMerges(false)
51 , m_iHidePaths(0)
52 , m_bWalkBehavior(FALSE)
53 , m_bFirstParent(false)
54 , m_bWholeProject(FALSE)
55 , m_iCompressedGraph(0)
56
57 , m_bSelectionMustBeContinuous(false)
58
59 , m_sLogInfo(_T(""))
60
61 , m_bCancelled(FALSE)
62 , m_pNotifyWindow(NULL)
63
64 , m_bAscending(FALSE)
65
66 , m_limit(0)
67 , m_hAccel(NULL)
68 , m_bNavigatingWithSelect(false)
69 {
70 m_bFilterWithRegex = !!CRegDWORD(_T("Software\\TortoiseGit\\UseRegexFilter"), FALSE);
71 m_bFilterCaseSensitively = !!CRegDWORD(L"Software\\TortoiseGit\\FilterCaseSensitively", FALSE);
72 m_bAsteriskLogPrefix = !!CRegDWORD(L"Software\\TortoiseGit\\AsteriskLogPrefix", TRUE);
73 m_LogList.m_SelectedFilters = CRegDWORD(_T("Software\\TortoiseGit\\SelectedLogFilters"), LOGFILTER_ALL);
74
75 CString str;
76 str=g_Git.m_CurrentDir;
77 str.Replace(_T(":"),_T("_"));
78 str=CString(_T("Software\\TortoiseGit\\LogDialog\\AllBranch\\"))+str;
79
80 m_regbAllBranch=CRegDWORD(str,FALSE);
81
82 m_bAllBranch=m_regbAllBranch;
83
84 str = g_Git.m_CurrentDir;
85 str.Replace(_T(":"),_T("_"));
86 m_regShowWholeProject = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ShowWholeProject\\") + str, FALSE);
87 m_bWholeProject = m_regShowWholeProject;
88 m_regbShowTags = CRegDWORD(_T("Software\\TortoiseGit\\LogDialog\\ShowTags\\") + str, TRUE);
89 m_bShowTags = !!m_regbShowTags;
90 m_regbShowLocalBranches = CRegDWORD(_T("Software\\TortoiseGit\\LogDialog\\ShowLocalBranches\\") + str, TRUE);
91 m_bShowLocalBranches = !!m_regbShowLocalBranches;
92 m_regbShowRemoteBranches = CRegDWORD(_T("Software\\TortoiseGit\\LogDialog\\ShowRemoteBranches\\") + str, TRUE);
93 m_bShowRemoteBranches = !!m_regbShowRemoteBranches;
94
95 m_bShowUnversioned = CRegDWORD(_T("Software\\TortoiseGit\\AddBeforeCommit"), TRUE);
96
97 m_bShowGravatar = !!CRegDWORD(_T("Software\\TortoiseGit\\EnableGravatar"), FALSE);
98 m_regbShowGravatar = CRegDWORD(_T("Software\\TortoiseGit\\LogDialog\\ShowGravatar\\") + str, m_bShowGravatar);
99 m_bShowGravatar = !!m_regbShowGravatar;
100 m_bShowDescribe = !!CRegDWORD(_T("Software\\TortoiseGit\\ShowDescribe"));
101 }
102
103 CLogDlg::~CLogDlg()
104 {
105
106 m_regbAllBranch = m_bAllBranch;
107 m_regbShowTags = m_bShowTags;
108 m_regbShowLocalBranches = m_bShowLocalBranches;
109 m_regbShowRemoteBranches = m_bShowRemoteBranches;
110 m_regbShowGravatar = m_bShowGravatar;
111
112 m_CurrentFilteredChangedArray.RemoveAll();
113
114 }
115
116 void CLogDlg::DoDataExchange(CDataExchange* pDX)
117 {
118 CResizableStandAloneDialog::DoDataExchange(pDX);
119 DDX_Control(pDX, IDC_LOGLIST, m_LogList);
120 DDX_Control(pDX, IDC_LOGMSG, m_ChangedFileListCtrl);
121 DDX_Control(pDX, IDC_PROGRESS, m_LogProgress);
122 DDX_Control(pDX, IDC_SPLITTERTOP, m_wndSplitter1);
123 DDX_Control(pDX, IDC_SPLITTERBOTTOM, m_wndSplitter2);
124 DDX_Text(pDX, IDC_SEARCHEDIT, m_LogList.m_sFilterText);
125 DDX_Control(pDX, IDC_DATEFROM, m_DateFrom);
126 DDX_Control(pDX, IDC_DATETO, m_DateTo);
127 DDX_Control(pDX, IDC_LOG_JUMPTYPE, m_JumpType);
128 DDX_Control(pDX, IDC_LOG_JUMPUP, m_JumpUp);
129 DDX_Control(pDX, IDC_LOG_JUMPDOWN, m_JumpDown);
130 DDX_Text(pDX, IDC_LOGINFO, m_sLogInfo);
131 DDX_Check(pDX, IDC_LOG_ALLBRANCH,m_bAllBranch);
132 DDX_Check(pDX, IDC_WHOLE_PROJECT, m_bWholeProject);
133 DDX_Check(pDX, IDC_WALKBEHAVIOUR, m_bWalkBehavior);
134 DDX_Control(pDX, IDC_SEARCHEDIT, m_cFilter);
135 DDX_Control(pDX, IDC_STATIC_REF, m_staticRef);
136 DDX_Control(pDX, IDC_PIC_AUTHOR, m_gravatar);
137 DDX_Control(pDX, IDC_FILTER, m_cFileFilter);
138 }
139
140 BEGIN_MESSAGE_MAP(CLogDlg, CResizableStandAloneDialog)
141 ON_WM_CONTEXTMENU()
142 ON_WM_SETCURSOR()
143 ON_NOTIFY(LVN_ITEMCHANGED, IDC_LOGLIST, OnLvnItemchangedLoglist)
144 ON_NOTIFY(LVN_ITEMCHANGED, IDC_LOGMSG, OnLvnItemchangedLogmsg)
145 ON_NOTIFY(EN_LINK, IDC_MSGVIEW, OnEnLinkMsgview)
146 ON_EN_VSCROLL(IDC_MSGVIEW, OnEnscrollMsgview)
147 ON_EN_HSCROLL(IDC_MSGVIEW, OnEnscrollMsgview)
148 ON_BN_CLICKED(IDC_STATBUTTON, OnBnClickedStatbutton)
149
150 ON_MESSAGE(WM_TGIT_REFRESH_SELECTION, OnRefreshSelection)
151 ON_MESSAGE(WM_FILTEREDIT_INFOCLICKED, OnClickedInfoIcon)
152 ON_MESSAGE(WM_FILTEREDIT_CANCELCLICKED, OnClickedCancelFilter)
153
154 ON_MESSAGE(MSG_LOAD_PERCENTAGE,OnLogListLoading)
155
156 ON_EN_CHANGE(IDC_SEARCHEDIT, OnEnChangeSearchedit)
157 ON_WM_TIMER()
158 ON_NOTIFY(DTN_DATETIMECHANGE, IDC_DATETO, OnDtnDatetimechangeDateto)
159 ON_NOTIFY(DTN_DATETIMECHANGE, IDC_DATEFROM, OnDtnDatetimechangeDatefrom)
160 ON_CBN_SELCHANGE(IDC_LOG_JUMPTYPE, &CLogDlg::OnCbnSelchangeJumpType)
161 ON_COMMAND(IDC_LOG_JUMPUP, &CLogDlg::OnBnClickedJumpUp)
162 ON_COMMAND(IDC_LOG_JUMPDOWN, &CLogDlg::OnBnClickedJumpDown)
163 ON_COMMAND(ID_GO_UP, &CLogDlg::OnBnClickedJumpUp)
164 ON_COMMAND(ID_GO_DOWN, &CLogDlg::OnBnClickedJumpDown)
165 ON_BN_CLICKED(IDC_WALKBEHAVIOUR, OnBnClickedWalkBehaviour)
166 ON_BN_CLICKED(IDC_VIEW, OnBnClickedView)
167 ON_BN_CLICKED(IDC_WHOLE_PROJECT, OnBnClickShowWholeProject)
168 ON_NOTIFY(LVN_COLUMNCLICK,IDC_LOGLIST, OnLvnColumnclick)
169 ON_COMMAND(MSG_FETCHED_DIFF, OnBnClickedHidepaths)
170 ON_BN_CLICKED(IDC_LOG_ALLBRANCH, OnBnClickedAllBranch)
171 ON_EN_CHANGE(IDC_FILTER, OnEnChangeFileFilter)
172
173 ON_NOTIFY(DTN_DROPDOWN, IDC_DATEFROM, &CLogDlg::OnDtnDropdownDatefrom)
174 ON_NOTIFY(DTN_DROPDOWN, IDC_DATETO, &CLogDlg::OnDtnDropdownDateto)
175 ON_WM_SIZE()
176 ON_BN_CLICKED(IDC_REFRESH, &CLogDlg::OnBnClickedRefresh)
177 ON_STN_CLICKED(IDC_STATIC_REF, &CLogDlg::OnBnClickedBrowseRef)
178 ON_COMMAND(ID_LOGDLG_REFRESH, &CLogDlg::OnBnClickedRefresh)
179 ON_COMMAND(ID_GO_BACKWARD_SELECT, &CLogDlg::GoBackAndSelect)
180 ON_COMMAND(ID_GO_FORWARD_SELECT, &CLogDlg::GoForwardAndSelect)
181 ON_COMMAND(ID_GO_BACKWARD, &CLogDlg::GoBack)
182 ON_COMMAND(ID_GO_FORWARD, &CLogDlg::GoForward)
183 ON_COMMAND(ID_SELECT_SEARCHFIELD, &CLogDlg::OnSelectSearchField)
184 ON_COMMAND(ID_LOGDLG_FIND, &CLogDlg::OnFind)
185 ON_COMMAND(ID_LOGDLG_FOCUSFILTER, &CLogDlg::OnFocusFilter)
186 ON_COMMAND(ID_EDIT_COPY, &CLogDlg::OnEditCopy)
187 ON_MESSAGE(MSG_REFLOG_CHANGED, OnRefLogChanged)
188 ON_REGISTERED_MESSAGE(WM_TASKBARBTNCREATED, OnTaskbarBtnCreated)
189
190 ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ITEMCHANGED, &CLogDlg::OnFileListCtrlItemChanged)
191 ON_WM_MOVE()
192 ON_WM_MOVING()
193 ON_WM_SIZING()
194 END_MESSAGE_MAP()
195
196 enum JumpType
197 {
198 JumpType_AuthorEmail,
199 JumpType_CommitterEmail,
200 JumpType_MergePoint,
201 JumpType_Parent1,
202 JumpType_Parent2,
203 JumpType_Tag,
204 JumpType_TagFF,
205 JumpType_Branch,
206 JumpType_BranchFF,
207 JumpType_History,
208 };
209
210 void CLogDlg::SetParams(const CTGitPath& orgPath, const CTGitPath& path, CString hightlightRevision, CString range, int limit)
211 {
212 m_orgPath = orgPath;
213 m_path = path;
214 m_hightlightRevision = hightlightRevision;
215
216 if (range == GIT_REV_ZERO)
217 range = _T("HEAD");
218
219 if (!(range.IsEmpty() || range == _T("HEAD")))
220 m_bAllBranch = BST_UNCHECKED;
221
222 SetRange(range);
223
224 m_limit = limit;
225 if (::IsWindow(m_hWnd))
226 UpdateData(FALSE);
227 }
228
229 void CLogDlg::SetFilter(const CString& findstr, LONG findtype, bool findregex)
230 {
231 m_LogList.m_sFilterText = findstr;
232 if (findtype)
233 m_LogList.m_SelectedFilters = findtype;
234 m_LogList.m_bFilterWithRegex = m_bFilterWithRegex = findregex;
235 }
236
237 BOOL CLogDlg::OnInitDialog()
238 {
239 CString temp;
240 CResizableStandAloneDialog::OnInitDialog();
241 CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
242
243 // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
244 // do this, Explorer would be unable to send that message to our window if we
245 // were running elevated. It's OK to make the call all the time, since if we're
246 // not elevated, this is a no-op.
247 CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
248 typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
249 CAutoLibrary hUser = AtlLoadSystemLibraryUsingFullPath(_T("user32.dll"));
250 if (hUser)
251 {
252 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
253 if (pfnChangeWindowMessageFilterEx)
254 {
255 pfnChangeWindowMessageFilterEx(m_hWnd, WM_TASKBARBTNCREATED, MSGFLT_ALLOW, &cfs);
256 }
257 }
258 m_pTaskbarList.Release();
259 if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
260 m_pTaskbarList = nullptr;
261
262 m_hAccel = LoadAccelerators(AfxGetResourceHandle(),MAKEINTRESOURCE(IDR_ACC_LOGDLG));
263
264 // use the state of the "stop on copy/rename" option from the last time
265 UpdateData(FALSE);
266
267 // set the font to use in the log message view, configured in the settings dialog
268 CAppUtils::CreateFontForLogs(m_logFont);
269 GetDlgItem(IDC_MSGVIEW)->SetFont(&m_logFont);
270 // make the log message rich edit control send a message when the mouse pointer is over a link
271 GetDlgItem(IDC_MSGVIEW)->SendMessage(EM_SETEVENTMASK, NULL, ENM_LINK | ENM_SCROLL);
272
273 // "unrelated paths" should be in gray color
274 m_iHidePaths = 2;
275
276 // set up the columns
277 m_LogList.DeleteAllItems();
278
279 m_LogList.m_Path=m_path;
280 m_LogList.m_hasWC = m_LogList.m_bShowWC = !GitAdminDir::IsBareRepo(g_Git.m_CurrentDir);
281 m_LogList.InsertGitColumn();
282
283 if (m_bWholeProject)
284 m_LogList.m_Path.Reset();
285
286 m_ChangedFileListCtrl.Init(GITSLC_COLEXT | GITSLC_COLSTATUS |GITSLC_COLADD|GITSLC_COLDEL, _T("LogDlg"), (GITSLC_POPALL ^ (GITSLC_POPIGNORE|GITSLC_POPRESTORE)), false, m_LogList.m_hasWC, GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD| GITSLC_COLDEL);
287
288 GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);
289
290 SetDlgTitle();
291
292 CheckRegexpTooltip();
293
294 SetSplitterRange();
295
296 // the filter control has a 'cancel' button (the red 'X'), we need to load its bitmap
297 m_cFilter.SetCancelBitmaps(IDI_CANCELNORMAL, IDI_CANCELPRESSED);
298 m_cFilter.SetInfoIcon(IDI_LOGFILTER);
299 m_cFilter.SetValidator(this);
300
301 AdjustControlSize(IDC_LOG_ALLBRANCH);
302 AdjustControlSize(IDC_WHOLE_PROJECT);
303
304 GetClientRect(m_DlgOrigRect);
305 m_LogList.GetClientRect(m_LogListOrigRect);
306 GetDlgItem(IDC_MSGVIEW)->GetClientRect(m_MsgViewOrigRect);
307 m_ChangedFileListCtrl.GetClientRect(m_ChgOrigRect);
308
309 m_DateFrom.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);
310 m_DateTo.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);
311
312 m_staticRef.SetURL(CString());
313
314 AddMainAnchors();
315 SetFilterCueText();
316
317 m_LogList.m_ShowMask &= ~CGit::LOG_INFO_LOCAL_BRANCHES;
318 if (m_bAllBranch == BST_CHECKED)
319 m_LogList.m_ShowMask|=CGit::LOG_INFO_ALL_BRANCH;
320 else if (m_bAllBranch == BST_INDETERMINATE)
321 m_LogList.m_ShowMask |= CGit::LOG_INFO_LOCAL_BRANCHES;
322 else
323 m_LogList.m_ShowMask&=~CGit::LOG_INFO_ALL_BRANCH;
324
325 HandleShowLabels(m_bShowTags, LOGLIST_SHOWTAGS);
326 HandleShowLabels(m_bShowLocalBranches, LOGLIST_SHOWLOCALBRANCHES);
327 HandleShowLabels(m_bShowRemoteBranches, LOGLIST_SHOWREMOTEBRANCHES);
328
329 // SetPromptParentWindow(m_hWnd);
330 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_AUTHOREMAIL)));
331 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_COMMITTEREMAIL)));
332 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_MERGEPOINT)));
333 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_PARENT1)));
334 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_PARENT2)));
335 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_TAG)));
336 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_TAG_FF)));
337 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_BRANCH)));
338 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_BRANCH_FF)));
339 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_SELECTION_HISTORY)));
340 m_JumpType.SetCurSel(0);
341 m_JumpUp.SetIcon((HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_JUMPUP), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR));
342 m_JumpDown.SetIcon((HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_JUMPDOWN), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR));
343
344 if (hWndExplorer)
345 CenterWindow(CWnd::FromHandle(hWndExplorer));
346 EnableSaveRestore(_T("LogDlg"));
347
348 DWORD yPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));
349 DWORD yPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));
350 RECT rcDlg, rcLogList, rcChgMsg;
351 GetClientRect(&rcDlg);
352 m_LogList.GetWindowRect(&rcLogList);
353 ScreenToClient(&rcLogList);
354 m_ChangedFileListCtrl.GetWindowRect(&rcChgMsg);
355 ScreenToClient(&rcChgMsg);
356 if (yPos1 && ((LONG)yPos1 < rcDlg.bottom - 185))
357 {
358 RECT rectSplitter;
359 m_wndSplitter1.GetWindowRect(&rectSplitter);
360 ScreenToClient(&rectSplitter);
361 int delta = yPos1 - rectSplitter.top;
362
363 if ((rcLogList.bottom + delta > rcLogList.top)&&(rcLogList.bottom + delta < rcChgMsg.bottom - 30))
364 {
365 m_wndSplitter1.SetWindowPos(NULL, rectSplitter.left, yPos1, 0, 0, SWP_NOSIZE);
366 DoSizeV1(delta);
367 }
368 }
369 if (yPos2 && ((LONG)yPos2 < rcDlg.bottom - 153))
370 {
371 RECT rectSplitter;
372 m_wndSplitter2.GetWindowRect(&rectSplitter);
373 ScreenToClient(&rectSplitter);
374 int delta = yPos2 - rectSplitter.top;
375
376 if ((rcChgMsg.top + delta < rcChgMsg.bottom)&&(rcChgMsg.top + delta > rcLogList.top + 30))
377 {
378 m_wndSplitter2.SetWindowPos(NULL, rectSplitter.left, yPos2, 0, 0, SWP_NOSIZE);
379 DoSizeV2(delta);
380 }
381 }
382
383 SetSplitterRange();
384
385 if (m_bSelect)
386 {
387 // the dialog is used to select revisions
388 // enable the OK button if appropriate
389 EnableOKButton();
390 }
391 else
392 {
393 // the dialog is used to just view log messages
394 // hide the OK button and set text on Cancel button to OK
395 GetDlgItemText(IDOK, temp);
396 SetDlgItemText(IDCANCEL, temp);
397 GetDlgItem(IDOK)->ShowWindow(SW_HIDE);
398 }
399
400 // first start a thread to obtain the log messages without
401 // blocking the dialog
402 //m_tTo = 0;
403 //m_tFrom = (DWORD)-1;
404
405 // scroll to user selected or current revision
406 if (m_hightlightRevision.IsEmpty() || g_Git.GetHash(m_LogList.m_lastSelectedHash, m_hightlightRevision))
407 {
408 if (g_Git.GetHash(m_LogList.m_lastSelectedHash, _T("HEAD")))
409 MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash.")), _T("TortoiseGit"), MB_ICONERROR);
410 }
411
412 if (g_Git.GetConfigValueBool(_T("tgit.logshowpatch")))
413 TogglePatchView();
414
415 m_LogList.FetchLogAsync(this);
416 ShowGravatar();
417 m_gravatar.Init();
418
419 m_cFileFilter.SetCancelBitmaps(IDI_CANCELNORMAL, IDI_CANCELPRESSED);
420 m_cFileFilter.SetInfoIcon(IDI_FILTEREDIT);
421 temp.LoadString(IDS_FILEDIFF_FILTERCUE);
422 temp = _T(" ") + temp;
423 m_cFileFilter.SetCueBanner(temp);
424
425 GetDlgItem(IDC_LOGLIST)->SetFocus();
426
427 m_History.SetMaxHistoryItems((LONG)CRegDWORD(_T("Software\\TortoiseGit\\MaxRefHistoryItems"), 5));
428 CString reg;
429 reg.Format(_T("Software\\TortoiseGit\\History\\log-refs\\%s"), g_Git.m_CurrentDir);
430 reg.Replace(_T(':'),_T('_'));
431 m_History.Load(reg, _T("ref"));
432
433 ShowStartRef();
434 return FALSE;
435 }
436
437 LRESULT CLogDlg::OnLogListLoading(WPARAM wParam, LPARAM /*lParam*/)
438 {
439 int cur=(int)wParam;
440
441 if( cur == GITLOG_START )
442 {
443 CString temp;
444 temp.LoadString(IDS_PROGRESSWAIT);
445
446 this->m_LogList.ShowText(temp, true);
447
448 // We use a progress bar while getting the logs
449 m_LogProgress.SetRange32(0, 100);
450 m_LogProgress.SetPos(0);
451 if (m_pTaskbarList)
452 {
453 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
454 m_pTaskbarList->SetProgressValue(m_hWnd, 0, 100);
455 }
456
457 GetDlgItem(IDC_WALKBEHAVIOUR)->ShowWindow(SW_HIDE);
458 GetDlgItem(IDC_VIEW)->ShowWindow(SW_HIDE);
459 GetDlgItem(IDC_STATBUTTON)->ShowWindow(SW_HIDE);
460 GetDlgItem(IDC_PROGRESS)->ShowWindow(TRUE);
461
462 DialogEnableWindow(IDC_WALKBEHAVIOUR, FALSE);
463 DialogEnableWindow(IDC_STATBUTTON, FALSE);
464 //DialogEnableWindow(IDC_REFRESH, FALSE);
465 DialogEnableWindow(IDC_VIEW, FALSE);
466
467 }
468 else if( cur == GITLOG_END)
469 {
470 if(this->m_LogList.HasText())
471 {
472 this->m_LogList.ClearText();
473 }
474 UpdateLogInfoLabel();
475
476 if (m_pTaskbarList)
477 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
478
479 DialogEnableWindow(IDC_WHOLE_PROJECT, !m_bFollowRenames && !m_path.IsEmpty());
480
481 DialogEnableWindow(IDC_STATBUTTON, !(m_LogList.m_arShownList.IsEmpty() || m_LogList.m_arShownList.GetCount() == 1 && m_LogList.m_bShowWC));
482 DialogEnableWindow(IDC_REFRESH, TRUE);
483 DialogEnableWindow(IDC_VIEW, TRUE);
484 DialogEnableWindow(IDC_WALKBEHAVIOUR, TRUE);
485 // PostMessage(WM_TIMER, LOGFILTER_TIMER);
486 GetDlgItem(IDC_WALKBEHAVIOUR)->ShowWindow(SW_SHOW);
487 GetDlgItem(IDC_VIEW)->ShowWindow(SW_SHOW);
488 GetDlgItem(IDC_STATBUTTON)->ShowWindow(SW_SHOW);
489 GetDlgItem(IDC_PROGRESS)->ShowWindow(FALSE);
490 //CTime time=m_LogList.GetOldestTime();
491 CTime begin,end;
492 m_LogList.GetTimeRange(begin,end);
493
494 if(m_LogList.m_From == -1)
495 m_DateFrom.SetTime(&begin);
496
497 if(m_LogList.m_To == -1)
498 m_DateTo.SetTime(&end);
499
500
501 }
502 else
503 {
504 if(this->m_LogList.HasText())
505 {
506 this->m_LogList.ClearText();
507 this->m_LogList.Invalidate();
508 }
509 UpdateLogInfoLabel();
510 m_LogProgress.SetPos(cur);
511 if (m_pTaskbarList)
512 {
513 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
514 m_pTaskbarList->SetProgressValue(m_hWnd, cur, 100);
515 }
516 }
517 return 0;
518 }
519 void CLogDlg::SetDlgTitle()
520 {
521 if (m_sTitle.IsEmpty())
522 GetWindowText(m_sTitle);
523
524 if (m_LogList.m_Path.IsEmpty() || m_orgPath.GetWinPathString().IsEmpty())
525 {
526 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, m_sTitle);
527 }
528 else
529 CAppUtils::SetWindowTitle(m_hWnd, m_orgPath.GetWinPathString(), m_sTitle);
530 }
531
532 void CLogDlg::CheckRegexpTooltip()
533 {
534 CWnd *pWnd = GetDlgItem(IDC_SEARCHEDIT);
535 // Since tooltip describes regexp features, show it only if regexps are enabled.
536 if (m_bFilterWithRegex)
537 {
538 m_tooltips.AddTool(pWnd, IDS_LOG_FILTER_REGEX_TT);
539 }
540 else
541 m_tooltips.DelTool(pWnd);
542 }
543
544 void CLogDlg::EnableOKButton()
545 {
546 if (m_bSelect)
547 {
548 // the dialog is used to select revisions
549 if (m_bSelectionMustBeSingle)
550 {
551 // enable OK button if only a single revision is selected
552 DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()==1));
553 }
554 else if (m_bSelectionMustBeContinuous)
555 DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()!=0)&&(m_LogList.IsSelectionContinuous()));
556 else
557 DialogEnableWindow(IDOK, m_LogList.GetSelectedCount()!=0);
558 }
559 else
560 DialogEnableWindow(IDOK, TRUE);
561 }
562
563 bool LookLikeGitHash(const CString& msg, int &pos)
564 {
565 int c = 0;
566 for (; pos < msg.GetLength(); ++pos)
567 {
568 if (msg[pos] >= '0' && msg[pos] <= '9' || msg[pos] >= 'a' && msg[pos] <= 'f')
569 {
570 c++;
571 }
572 else
573 {
574 return c >= g_Git.GetShortHASHLength() && c <= GIT_HASH_SIZE * 2;
575 }
576 }
577 return c >= g_Git.GetShortHASHLength() && c <= GIT_HASH_SIZE * 2;
578 }
579
580 std::vector<CHARRANGE> FindGitHashPositions(const CString& msg, int offset)
581 {
582 std::vector<CHARRANGE> result;
583 offset = offset < 0 ? 0 : offset;
584 int old = offset;
585 while (offset < msg.GetLength())
586 {
587 old = offset;
588 TCHAR e = msg[offset];
589 if (e == '\n')
590 {
591 ++offset;
592 if (msg.Mid(offset, 11) == _T("git-svn-id:")
593 || msg.Mid(offset, 14) == _T("Signed-off-by:")
594 || msg.Mid(offset, 10) == _T("Change-Id:")
595 )
596 {
597 offset += 10;
598 while (offset < msg.GetLength())
599 {
600 if (msg[offset++] == '\n')
601 break;
602 }
603 continue;
604 }
605 }
606 else if (e >= 'A' && e <= 'Z' || e >= 'h' && e <= 'z')
607 {
608 do
609 {
610 e = msg[++offset];
611 } while (offset < msg.GetLength() && (e >= 'A' && e <= 'Z' || e >= 'a' && e <= 'z' || e >= '0' && e <= '9'));
612 }
613 else if (e >= 'a' && e <= 'g' || e >= '0' && e <= '9')
614 {
615 if (e == 'g')
616 {
617 ++old;
618 ++offset;
619 }
620 if (LookLikeGitHash(msg, offset))
621 {
622 TCHAR d = offset < msg.GetLength() ? msg[offset] : '\0';
623 if (!((d >= 'A' && d <= 'Z') || (d >= 'a' && d <= 'z') || (d >= '0' && d <= '9')))
624 {
625 CHARRANGE range = { old, offset };
626 result.push_back(range);
627 }
628 }
629 ++offset;
630 }
631 else
632 {
633 ++offset;
634 }
635 }
636
637 return result;
638 }
639
640 BOOL FindGitHash(const CString& msg, int offset, CWnd *pWnd)
641 {
642 std::vector<CHARRANGE> positions = FindGitHashPositions(msg, offset);
643 CAppUtils::SetCharFormat(pWnd, CFM_LINK, CFE_LINK, positions);
644
645 return positions.empty() ? FALSE : TRUE;
646 }
647
648 static int DescribeCommit(CGitHash& hash, CString& result)
649 {
650 CAutoRepository repo(g_Git.GetGitRepository());
651 if (!repo)
652 return -1;
653 CAutoObject commit;
654 if (git_object_lookup(commit.GetPointer(), repo, (const git_oid *)hash.m_hash, GIT_OBJ_COMMIT))
655 return -1;
656
657 CAutoDescribeResult describe;
658 git_describe_options describe_options = GIT_DESCRIBE_OPTIONS_INIT;
659 describe_options.describe_strategy = CRegDWORD(_T("Software\\TortoiseGit\\DescribeStrategy"), GIT_DESCRIBE_DEFAULT);
660 if (git_describe_commit(describe.GetPointer(), (git_object *)commit, &describe_options))
661 return -1;
662
663 CAutoBuf describe_buf;
664 git_describe_format_options format_options = GIT_DESCRIBE_FORMAT_OPTIONS_INIT;
665 format_options.abbreviated_size = CRegDWORD(_T("Software\\TortoiseGit\\DescribeAbbreviatedSize"), GIT_DESCRIBE_DEFAULT_ABBREVIATED_SIZE);
666 format_options.always_use_long_format = CRegDWORD(_T("Software\\TortoiseGit\\DescribeAlwaysLong"));
667 if (git_describe_format(describe_buf, describe, &format_options))
668 return -1;
669
670 result = CUnicodeUtils::GetUnicode(describe_buf->ptr);
671 return 0;
672 }
673
674 void CLogDlg::FillLogMessageCtrl(bool bShow /* = true*/)
675 {
676 // we fill here the log message rich edit control,
677 // and also populate the changed files list control
678 // according to the selected revision(s).
679
680 CRichEditCtrl * pMsgView = (CRichEditCtrl*)GetDlgItem(IDC_MSGVIEW);
681 // empty the log message view
682 pMsgView->SetWindowText(_T(" "));
683 FillPatchView(true);
684 // empty the changed files list
685 m_ChangedFileListCtrl.SetRedraw(FALSE);
686 // InterlockedExchange(&m_bNoDispUpdates, TRUE);
687 m_currentChangedArray = NULL;
688 m_ChangedFileListCtrl.DeleteAllItems();
689
690 // if we're not here to really show a selected revision, just
691 // get out of here after clearing the views, which is what is intended
692 // if that flag is not set.
693 if (!bShow)
694 {
695 // force a redraw
696 m_ChangedFileListCtrl.Invalidate();
697 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
698 m_ChangedFileListCtrl.SetRedraw(TRUE);
699 m_gravatar.LoadGravatar();
700 return;
701 }
702
703 // depending on how many revisions are selected, we have to do different
704 // tasks.
705 int selCount = m_LogList.GetSelectedCount();
706 if (selCount == 0)
707 {
708 // if nothing is selected, we have nothing more to do
709 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
710 m_ChangedFileListCtrl.SetRedraw(TRUE);
711 m_gravatar.LoadGravatar();
712 return;
713 }
714 else if (selCount == 1)
715 {
716 // if one revision is selected, we have to fill the log message view
717 // with the corresponding log message, and also fill the changed files
718 // list fully.
719 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
720 int selIndex = m_LogList.GetNextSelectedItem(pos);
721 if (selIndex >= m_LogList.m_arShownList.GetCount())
722 {
723 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
724 m_ChangedFileListCtrl.SetRedraw(TRUE);
725 return;
726 }
727 Locker lock(m_LogList.m_critSec_AsyncDiff);
728 GitRevLoglist* pLogEntry = reinterpret_cast<GitRevLoglist*>(m_LogList.m_arShownList.SafeGetAt(selIndex));
729
730 {
731 CString out_describe;
732 if (m_bShowDescribe)
733 {
734 CString result;
735 if (!DescribeCommit(pLogEntry->m_CommitHash, result))
736 out_describe = _T("Describe: ") + result + _T("\r\n");
737 }
738
739 // set the log message text
740 pMsgView->SetWindowText(CString(MAKEINTRESOURCE(IDS_HASH)) + _T(": ") + pLogEntry->m_CommitHash.ToString() + _T("\r\n") + out_describe + _T("\r\n"));
741 // turn bug ID's into links if the bugtraq: properties have been set
742 // and we can find a match of those in the log message
743
744 pMsgView->SetSel(-1,-1);
745 CAppUtils::SetCharFormat(pMsgView, CFM_BOLD, CFE_BOLD);
746
747 CString msg = m_bAsteriskLogPrefix ? _T("* ") : _T("");
748 msg+=pLogEntry->GetSubject();
749 pMsgView->ReplaceSel(msg);
750
751 pMsgView->SetSel(-1,-1);
752 CAppUtils::SetCharFormat(pMsgView, CFM_BOLD, 0);
753
754 msg=_T("\n");
755 msg+=pLogEntry->GetBody();
756
757 if(!pLogEntry->m_Notes.IsEmpty())
758 {
759 msg+= _T("\n*") + CString(MAKEINTRESOURCE(IDS_NOTES)) + _T("* ");
760 msg+= pLogEntry->m_Notes;
761 msg+= _T("\n\n");
762 }
763
764 CString tagInfo = m_LogList.GetTagInfo(pLogEntry);
765 if(!tagInfo.IsEmpty())
766 tagInfo = _T("\n*") + CString(MAKEINTRESOURCE(IDS_PROC_LOG_TAGINFO)) + _T("*\n\n") + tagInfo;
767 msg += tagInfo;
768
769 pMsgView->ReplaceSel(msg);
770
771 CString text;
772 pMsgView->GetWindowText(text);
773 // the rich edit control doesn't count the CR char!
774 // to be exact: CRLF is treated as one char.
775 text.Remove('\r');
776
777 int findHashStart = text.Find('\n');
778 if (!out_describe.IsEmpty())
779 findHashStart = text.Find('\n', findHashStart + 1);
780 FindGitHash(text, findHashStart, pMsgView);
781 m_LogList.m_ProjectProperties.FindBugID(text, pMsgView);
782 CAppUtils::StyleURLs(text, pMsgView);
783 if (((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\StyleCommitMessages"), TRUE)) == TRUE)
784 CAppUtils::FormatTextInRichEditControl(pMsgView);
785
786 CHARRANGE range;
787 range.cpMin = 0;
788 range.cpMax = 0;
789 pMsgView->SendMessage(EM_EXSETSEL, NULL, (LPARAM)&range);
790
791 CString matchpath=this->m_path.GetGitPathString();
792
793 bool mightNeedReset = true;
794
795 int count = pLogEntry->GetFiles(&m_LogList).GetCount();
796 for (int i = 0 ; i < count && (!matchpath.IsEmpty()); ++i)
797 {
798 if( m_bWholeProject )
799 break;
800
801 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action &= ~(CTGitPath::LOGACTIONS_HIDE|CTGitPath::LOGACTIONS_GRAY);
802 mightNeedReset = false;
803
804 if(pLogEntry->GetFiles(&m_LogList)[i].GetGitPathString().Left(matchpath.GetLength()) != matchpath && pLogEntry->GetFiles(&m_LogList)[i].GetGitOldPathString().Left(matchpath.GetLength()) != matchpath)
805 {
806 if (m_iHidePaths == 1)
807 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action |= CTGitPath::LOGACTIONS_HIDE;
808 else if (m_iHidePaths == 2)
809 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action |= CTGitPath::LOGACTIONS_GRAY;
810 }
811 }
812
813 if (mightNeedReset)
814 {
815 for (int i = 0 ; i < count; ++i)
816 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action &= ~CTGitPath::LOGACTIONS_HIDE;
817 }
818
819 CString fileFilter;
820 m_cFileFilter.GetWindowText(fileFilter);
821 fileFilter.MakeLower();
822 for (int i = 0; i < count && (!fileFilter.IsEmpty()); ++i)
823 {
824 CString sPath = pLogEntry->GetFiles(&m_LogList)[i].GetGitPathString();
825 sPath.MakeLower();
826 if (sPath.Find(fileFilter) < 0)
827 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action |= CTGitPath::LOGACTIONS_HIDE;
828 }
829
830 m_ChangedFileListCtrl.UpdateWithGitPathList(pLogEntry->GetFiles(&m_LogList));
831 m_ChangedFileListCtrl.m_CurrentVersion=pLogEntry->m_CommitHash;
832 if (pLogEntry->m_CommitHash.IsEmpty() && m_bShowUnversioned)
833 {
834 m_ChangedFileListCtrl.UpdateUnRevFileList(pLogEntry->GetUnRevFiles());
835 m_ChangedFileListCtrl.Show(GITSLC_SHOWVERSIONED | GITSLC_SHOWUNVERSIONED);
836 }
837 else
838 m_ChangedFileListCtrl.Show(GITSLC_SHOWVERSIONED);
839
840 m_ChangedFileListCtrl.SetBusyString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_FETCHINGFILES)));
841
842 if(!pLogEntry->m_IsDiffFiles)
843 m_ChangedFileListCtrl.SetBusy(TRUE);
844 else
845 m_ChangedFileListCtrl.SetBusy(FALSE);
846
847 m_ChangedFileListCtrl.SetRedraw(TRUE);
848 m_gravatar.LoadGravatar(pLogEntry->GetAuthorEmail());
849 return;
850 }
851
852 }
853 else
854 {
855 // more than one revision is selected:
856 // the log message view must be emptied
857 // the changed files list contains all the changed paths from all
858 // selected revisions, with 'doubles' removed
859 m_currentChangedPathList = GetChangedPathsFromSelectedRevisions(true);
860 m_gravatar.LoadGravatar();
861 }
862
863 // redraw the views
864 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
865 #if 0
866 if (m_currentChangedArray)
867 {
868 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedArray->GetCount());
869 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedArray->GetCount());
870 }
871 else if (m_currentChangedPathList.GetCount())
872 {
873 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedPathList.GetCount());
874 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedPathList.GetCount());
875 }
876 else
877 {
878 m_ChangedFileListCtrl.SetItemCountEx(0);
879 m_ChangedFileListCtrl.Invalidate();
880 }
881 #endif
882 // sort according to the settings
883 if (m_nSortColumnPathList > 0)
884 SetSortArrow(&m_ChangedFileListCtrl, m_nSortColumnPathList, m_bAscendingPathList);
885 else
886 SetSortArrow(&m_ChangedFileListCtrl, -1, false);
887 m_ChangedFileListCtrl.SetRedraw(TRUE);
888
889 }
890
891 void CLogDlg::FillPatchView(bool onlySetTimer)
892 {
893 if (!::IsWindow(this->m_patchViewdlg.m_hWnd))
894 return;
895
896 KillTimer(LOG_FILLPATCHVTIMER);
897 if (onlySetTimer)
898 {
899 SetTimer(LOG_FILLPATCHVTIMER, 100, nullptr);
900 return;
901 }
902
903 POSITION posLogList = m_LogList.GetFirstSelectedItemPosition();
904 if (posLogList == nullptr)
905 {
906 m_patchViewdlg.ClearView();
907 return; // nothing is selected, get out of here
908 }
909
910 GitRev * pLogEntry = reinterpret_cast<GitRev* >(m_LogList.m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(posLogList)));
911 if (pLogEntry == nullptr || m_LogList.GetNextSelectedItem(posLogList) != -1)
912 {
913 m_patchViewdlg.ClearView();
914 return;
915 }
916
917 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
918 CString out;
919
920 if (pos == nullptr)
921 {
922 int diffContext = 0;
923 if (CAppUtils::GetMsysgitVersion() > 0x01080100)
924 diffContext = g_Git.GetConfigValueInt32(_T("diff.context"), -1);
925 CStringA outA;
926 CString rev1 = pLogEntry->m_CommitHash.IsEmpty() ? _T("HEAD") : (pLogEntry->m_CommitHash.ToString() + _T("~1"));
927 CString rev2 = pLogEntry->m_CommitHash.IsEmpty() ? GIT_REV_ZERO : pLogEntry->m_CommitHash.ToString();
928 g_Git.GetUnifiedDiff(CTGitPath(), rev1, rev2, &outA, false, false, diffContext);
929 out = CUnicodeUtils::GetUnicode(outA);
930 }
931 else
932 {
933 while (pos)
934 {
935 int nSelect = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
936 CTGitPath * p = (CTGitPath*)m_ChangedFileListCtrl.GetItemData(nSelect);
937 if (p && !(p->m_Action&CTGitPath::LOGACTIONS_UNVER))
938 {
939 CString cmd;
940 if (pLogEntry->m_CommitHash.IsEmpty())
941 cmd.Format(_T("git.exe diff HEAD -- \"%s\""), p->GetGitPathString());
942 else
943 cmd.Format(_T("git.exe diff %s^%d..%s -- \"%s\""), pLogEntry->m_CommitHash.ToString(), p->m_ParentNo + 1, pLogEntry->m_CommitHash.ToString(), p->GetGitPathString());
944 g_Git.Run(cmd, &out, CP_UTF8);
945 }
946 }
947 }
948
949 m_patchViewdlg.SetText(out);
950 }
951
952 void CLogDlg::TogglePatchView()
953 {
954 m_patchViewdlg.m_ParentDlg = this;
955 if (!IsWindow(m_patchViewdlg.m_hWnd))
956 {
957 BOOL viewPatchEnabled = FALSE;
958 viewPatchEnabled = g_Git.GetConfigValueBool(_T("tgit.logshowpatch"));
959 if (viewPatchEnabled == FALSE)
960 g_Git.SetConfigValue(_T("tgit.logshowpatch"), _T("true"));
961 m_patchViewdlg.Create(IDD_PATCH_VIEW, this);
962 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETSCROLLWIDTHTRACKING, TRUE);
963 CRect rect;
964 this->GetWindowRect(&rect);
965
966 m_patchViewdlg.ShowWindow(SW_SHOW);
967 m_patchViewdlg.SetWindowPos(nullptr, rect.right, rect.top, rect.Width(), rect.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
968
969 FillPatchView();
970 }
971 else
972 {
973 g_Git.SetConfigValue(_T("tgit.logshowpatch"), _T("false"));
974 m_patchViewdlg.ShowWindow(SW_HIDE);
975 m_patchViewdlg.DestroyWindow();
976 }
977 }
978
979 LRESULT CLogDlg::OnFileListCtrlItemChanged(WPARAM /*wparam*/, LPARAM /*lparam*/)
980 {
981 FillPatchView(true);
982 return 0;
983 }
984
985 void CLogDlg::OnMoving(UINT fwSide, LPRECT pRect)
986 {
987 __super::OnMoving(fwSide, pRect);
988
989 if (!::IsWindow(m_patchViewdlg.m_hWnd))
990 return;
991
992 RECT patchrect;
993 m_patchViewdlg.GetWindowRect(&patchrect);
994 if (!::IsWindow(m_hWnd))
995 return;
996
997 RECT thisrect;
998 GetWindowRect(&thisrect);
999 if (patchrect.left == thisrect.right)
1000 {
1001 m_patchViewdlg.SetWindowPos(nullptr, patchrect.left - (thisrect.left - pRect->left), patchrect.top - (thisrect.top - pRect->top), 0, 0, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);
1002 }
1003 }
1004
1005 void CLogDlg::OnSizing(UINT fwSide, LPRECT pRect)
1006 {
1007 __super::OnSizing(fwSide, pRect);
1008
1009 if (!::IsWindow(this->m_patchViewdlg.m_hWnd))
1010 return;
1011
1012 CRect thisrect, patchrect;
1013 this->GetWindowRect(thisrect);
1014 this->m_patchViewdlg.GetWindowRect(patchrect);
1015 if (thisrect.right != patchrect.left)
1016 return;
1017
1018 patchrect.left -= (thisrect.right - pRect->right);
1019 patchrect.right -= (thisrect.right - pRect->right);
1020
1021 if (patchrect.bottom == thisrect.bottom)
1022 patchrect.bottom -= (thisrect.bottom - pRect->bottom);
1023 if (patchrect.top == thisrect.top)
1024 patchrect.top -= thisrect.top - pRect->top;
1025 m_patchViewdlg.MoveWindow(patchrect);
1026 }
1027
1028 void CLogDlg::OnSelectSearchField()
1029 {
1030 m_cFilter.SetSel(0, -1, FALSE);
1031 m_cFilter.SetFocus();
1032 }
1033
1034 void CLogDlg::GoBack()
1035 {
1036 GoBackForward(false, false);
1037 }
1038
1039 void CLogDlg::GoForward()
1040 {
1041 GoBackForward(false, true);
1042 }
1043
1044 void CLogDlg::GoBackAndSelect()
1045 {
1046 GoBackForward(true, false);
1047 }
1048
1049 void CLogDlg::GoForwardAndSelect()
1050 {
1051 GoBackForward(true, true);
1052 }
1053
1054 void CLogDlg::GoBackForward(bool select, bool bForward)
1055 {
1056 m_LogList.m_highlight.Empty();
1057 CGitHash gotoHash;
1058 if (bForward ? m_LogList.m_selectionHistory.GoForward(gotoHash) : m_LogList.m_selectionHistory.GoBack(gotoHash))
1059 {
1060 int i;
1061 for (i = 0; i < m_LogList.m_arShownList.GetCount(); ++i)
1062 {
1063 GitRev *rev = (GitRev *)m_LogList.m_arShownList.SafeGetAt(i);
1064 if (!rev) continue;
1065 if (rev->m_CommitHash == gotoHash)
1066 {
1067 m_LogList.EnsureVisible(i, FALSE);
1068 if (select)
1069 {
1070 m_LogList.m_highlight.Empty();
1071 m_LogList.SetItemState(m_LogList.GetSelectionMark(), 0, LVIS_SELECTED);
1072 m_bNavigatingWithSelect = true;
1073 m_LogList.SetItemState(i, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
1074 m_LogList.SetSelectionMark(i);
1075 m_bNavigatingWithSelect = false;
1076 }
1077 else
1078 m_LogList.m_highlight = gotoHash;
1079 m_LogList.Invalidate();
1080 return;
1081 }
1082 }
1083 if (i == m_LogList.m_arShownList.GetCount())
1084 {
1085 CString msg;
1086 msg.Format(IDS_LOG_NOT_VISIBLE, gotoHash.ToString());
1087 MessageBox(msg, _T("TortoiseGit"), MB_OK | MB_ICONINFORMATION);
1088 return;
1089 }
1090 }
1091 PlaySound((LPCTSTR)SND_ALIAS_SYSTEMASTERISK, nullptr, SND_ASYNC | SND_ALIAS_ID);
1092 }
1093
1094 void CLogDlg::OnBnClickedRefresh()
1095 {
1096 Refresh (true);
1097 }
1098
1099 void CLogDlg::Refresh (bool clearfilter /*autoGoOnline*/)
1100 {
1101 m_limit = 0;
1102 m_LogList.Refresh(clearfilter);
1103 EnableOKButton();
1104 ShowStartRef();
1105 FillLogMessageCtrl(false);
1106 }
1107
1108
1109
1110 BOOL CLogDlg::Cancel()
1111 {
1112 return m_bCancelled;
1113 }
1114
1115 void CLogDlg::SaveSplitterPos()
1116 {
1117 if (!IsIconic())
1118 {
1119 CRegDWORD regPos1(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));
1120 CRegDWORD regPos2(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));
1121 RECT rectSplitter;
1122 m_wndSplitter1.GetWindowRect(&rectSplitter);
1123 ScreenToClient(&rectSplitter);
1124 regPos1 = rectSplitter.top;
1125 m_wndSplitter2.GetWindowRect(&rectSplitter);
1126 ScreenToClient(&rectSplitter);
1127 regPos2 = rectSplitter.top;
1128 }
1129 }
1130
1131 void CLogDlg::OnCancel()
1132 {
1133 this->ShowWindow(SW_HIDE);
1134
1135 // canceling means stopping the working thread if it's still running.
1136 m_LogList.SafeTerminateAsyncDiffThread();
1137 if (this->IsThreadRunning())
1138 {
1139 m_LogList.SafeTerminateThread();
1140 }
1141 UpdateData();
1142
1143 SaveSplitterPos();
1144 __super::OnCancel();
1145 }
1146
1147 void CLogDlg::CopyChangedSelectionToClipBoard()
1148 {
1149
1150 POSITION posLogList = m_LogList.GetFirstSelectedItemPosition();
1151 if (posLogList == nullptr)
1152 return; // nothing is selected, get out of here
1153
1154 CString sPaths;
1155
1156 // CGitRev* pLogEntry = reinterpret_cast<CGitRev* >(m_LogList.m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
1157 // if (posLogList)
1158 {
1159 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
1160 while (pos)
1161 {
1162 int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
1163 CTGitPath *path = (CTGitPath*)m_ChangedFileListCtrl.GetItemData(nItem);
1164 if(path)
1165 sPaths += path->GetGitPathString();
1166 sPaths += _T("\r\n");
1167 }
1168 }
1169 #if 0
1170 else
1171 {
1172 // only one revision is selected in the log dialog top pane
1173 // but multiple items could be selected in the changed items list
1174 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
1175 while (pos)
1176 {
1177 int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
1178 LogChangedPath * changedlogpath = pLogEntry->pArChangedPaths->SafeGetAt(nItem);
1179
1180 if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)
1181 {
1182 // some items are hidden! So find out which item the user really selected
1183 INT_PTR selRealIndex = -1;
1184 for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)
1185 {
1186 if (pLogEntry->pArChangedPaths->SafeGetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)
1187 ++selRealIndex;
1188 if (selRealIndex == nItem)
1189 {
1190 changedlogpath = pLogEntry->pArChangedPaths->SafeGetAt(hiddenindex);
1191 break;
1192 }
1193 }
1194 }
1195 if (changedlogpath)
1196 {
1197 sPaths += changedlogpath->sPath;
1198 sPaths += _T("\r\n");
1199 }
1200 }
1201 }
1202 #endif
1203 sPaths.Trim();
1204 CStringUtils::WriteAsciiStringToClipboard(sPaths, GetSafeHwnd());
1205
1206 }
1207
1208 void CLogDlg::OnContextMenu(CWnd* pWnd, CPoint point)
1209 {
1210 // we have three separate context menus:
1211 // one for the branch label in the upper left
1212 // one shown on the log message list control,
1213 // one shown in the changed-files list control
1214 if (pWnd == GetDlgItem(IDC_STATIC_REF))
1215 {
1216 CIconMenu popup;
1217 if (!popup.CreatePopupMenu())
1218 return;
1219
1220 int cnt = 0;
1221 popup.AppendMenuIcon(++cnt, IDS_MENUREFBROWSE);
1222 popup.SetDefaultItem(cnt);
1223 popup.AppendMenuIcon(++cnt, _T("HEAD"));
1224 CGitHash fetchHead;
1225 g_Git.GetHash(fetchHead, g_Git.FixBranchName(_T("FETCH_HEAD")));
1226 popup.AppendMenuIcon(++cnt, _T("FETCH_HEAD"));
1227 popup.EnableMenuItem(cnt, fetchHead.IsEmpty());
1228 popup.AppendMenuIcon(++cnt, IDS_ALL);
1229 popup.EnableMenuItem(cnt, m_bFollowRenames);
1230 popup.AppendMenuIcon(++cnt, IDS_PROC_LOG_SELECT_LOCAL_BRANCHES);
1231 popup.EnableMenuItem(cnt, m_bFollowRenames);
1232 int offset = ++cnt;
1233 if (m_History.GetCount() > 0)
1234 {
1235 popup.AppendMenu(MF_SEPARATOR, 0);
1236 for (size_t i = 0; i < m_History.GetCount(); ++i)
1237 {
1238 CString entry = m_History.GetEntry(i);
1239 if (entry.GetLength() > 150)
1240 entry = entry.Left(150) + _T("...");
1241 popup.AppendMenuIcon(cnt++, entry);
1242 }
1243 }
1244
1245 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1246 if (cmd == 0)
1247 return;
1248 else if (cmd == 1)
1249 {
1250 OnBnClickedBrowseRef();
1251 return;
1252 }
1253
1254 m_LogList.m_ShowMask &= ~(CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_LOCAL_BRANCHES);
1255 m_bAllBranch = BST_UNCHECKED;
1256 if (cmd == 2)
1257 {
1258 SetRange(g_Git.GetCurrentBranch(true));
1259 }
1260 else if (cmd == 3)
1261 {
1262 SetRange(fetchHead.ToString());
1263 }
1264 else if (cmd == 4)
1265 {
1266 m_bAllBranch = BST_CHECKED;
1267 m_LogList.m_ShowMask |= CGit::LOG_INFO_ALL_BRANCH;
1268 }
1269 else if (cmd == 5)
1270 {
1271 m_bAllBranch = BST_INDETERMINATE;
1272 m_LogList.m_ShowMask |= CGit::LOG_INFO_LOCAL_BRANCHES;
1273 }
1274 else if (cmd >= offset)
1275 {
1276 SetRange(m_History.GetEntry(cmd - offset));
1277 m_History.AddEntry(m_LogList.m_sRange);
1278 m_History.Save();
1279 }
1280
1281 UpdateData(FALSE);
1282
1283 OnRefresh();
1284 FillLogMessageCtrl(false);
1285
1286 return;
1287 }
1288 int selCount = m_LogList.GetSelectedCount();
1289 if ((selCount == 1)&&(pWnd == GetDlgItem(IDC_MSGVIEW)))
1290 {
1291 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1292 int selIndex = -1;
1293 if (pos)
1294 selIndex = m_LogList.GetNextSelectedItem(pos);
1295
1296 GitRevLoglist* pRev = ((GitRevLoglist*)m_LogList.m_arShownList[selIndex]);
1297
1298 if ((point.x == -1) && (point.y == -1))
1299 {
1300 CRect rect;
1301 GetDlgItem(IDC_MSGVIEW)->GetClientRect(&rect);
1302 ClientToScreen(&rect);
1303 point = rect.CenterPoint();
1304 }
1305 CString sMenuItemText;
1306 CIconMenu popup;
1307 if (popup.CreatePopupMenu())
1308 {
1309 long start = -1, end = -1;
1310 auto pEdit = (CRichEditCtrl *)GetDlgItem(IDC_MSGVIEW);
1311 pEdit->GetSel(start, end);
1312 // add the 'default' entries
1313 popup.AppendMenuIcon(WM_COPY, IDS_SCIEDIT_COPY, IDI_COPYCLIP);
1314 if (start >= end)
1315 popup.EnableMenuItem(WM_COPY, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
1316 popup.AppendMenu(MF_SEPARATOR);
1317 sMenuItemText.LoadString(IDS_STATUSLIST_CONTEXT_COPYEXT);
1318 popup.AppendMenuIcon(EM_SETSEL, sMenuItemText, IDI_COPYCLIP);
1319 popup.AppendMenu(MF_SEPARATOR, NULL);
1320 sMenuItemText.LoadString(IDS_EDIT_NOTES);
1321 popup.AppendMenuIcon( CGitLogList::ID_EDITNOTE, sMenuItemText, IDI_EDIT);
1322
1323 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1324 switch (cmd)
1325 {
1326 case 0:
1327 break; // no command selected
1328 case EM_SETSEL:
1329 {
1330 pEdit->SetRedraw(FALSE);
1331 int oldLine = pEdit->GetFirstVisibleLine();
1332 pEdit->SetSel(0, -1);
1333 pEdit->Copy();
1334 pEdit->SetSel(start, end);
1335 int newLine = pEdit->GetFirstVisibleLine();
1336 pEdit->LineScroll(oldLine - newLine);
1337 pEdit->SetRedraw(TRUE);
1338 pEdit->RedrawWindow();
1339 }
1340 break;
1341 case WM_COPY:
1342 ::SendMessage(GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), cmd, 0, -1);
1343 break;
1344 case CGitLogList::ID_EDITNOTE:
1345 CAppUtils::EditNote(pRev);
1346 this->FillLogMessageCtrl(true);
1347 break;
1348 }
1349 }
1350 }
1351 }
1352
1353 void CLogDlg::OnOK()
1354 {
1355 // since the log dialog is also used to select revisions for other
1356 // dialogs, we have to do some work before closing this dialog
1357 if (GetFocus() != GetDlgItem(IDOK))
1358 return; // if the "OK" button doesn't have the focus, do nothing: this prevents closing the dialog when pressing enter
1359
1360 m_LogList.SafeTerminateAsyncDiffThread();
1361 if (this->IsThreadRunning())
1362 {
1363 m_LogList.SafeTerminateThread();
1364 }
1365 UpdateData();
1366 // check that one and only one row is selected
1367 if (m_LogList.GetSelectedCount() == 1)
1368 {
1369 // get the selected row
1370 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1371 int selIndex = m_LogList.GetNextSelectedItem(pos);
1372 if (selIndex < m_LogList.m_arShownList.GetCount())
1373 {
1374 // all ok, pick up the revision
1375 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(selIndex));
1376 // extract the hash
1377 m_sSelectedHash = pLogEntry->m_CommitHash;
1378 }
1379 }
1380 UpdateData(FALSE);
1381 SaveSplitterPos();
1382 __super::OnOK();
1383
1384 #if 0
1385 if (!GetDlgItem(IDOK)->IsWindowVisible() && GetFocus() != GetDlgItem(IDCANCEL))
1386 return; // the Cancel button works as the OK button. But if the cancel button has not the focus, do nothing.
1387
1388 CString temp;
1389 CString buttontext;
1390 GetDlgItemText(IDOK, buttontext);
1391 temp.LoadString(IDS_MSGBOX_CANCEL);
1392 if (temp.Compare(buttontext) != 0)
1393 __super::OnOK(); // only exit if the button text matches, and that will match only if the thread isn't running anymore
1394 m_bCancelled = TRUE;
1395 m_selectedRevs.Clear();
1396 m_selectedRevsOneRange.Clear();
1397 if (m_pNotifyWindow)
1398 {
1399 int selIndex = m_LogList.GetSelectionMark();
1400 if (selIndex >= 0)
1401 {
1402 PLOGENTRYDATA pLogEntry = NULL;
1403 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1404 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
1405 m_selectedRevs.AddRevision(pLogEntry->Rev);
1406 git_revnum_t lowerRev = pLogEntry->Rev;
1407 git_revnum_t higherRev = lowerRev;
1408 while (pos)
1409 {
1410 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
1411 git_revnum_t rev = pLogEntry->Rev;
1412 m_selectedRevs.AddRevision(pLogEntry->Rev);
1413 if (lowerRev > rev)
1414 lowerRev = rev;
1415 if (higherRev < rev)
1416 higherRev = rev;
1417 }
1418 if (m_sFilterText.IsEmpty() && m_nSortColumn == 0 && IsSelectionContinuous())
1419 {
1420 m_selectedRevsOneRange.AddRevRange(lowerRev, higherRev);
1421 }
1422 BOOL bSentMessage = FALSE;
1423 if (m_LogList.GetSelectedCount() == 1)
1424 {
1425 // if only one revision is selected, check if the path/url with which the dialog was started
1426 // was directly affected in that revision. If it was, then check if our path was copied from somewhere.
1427 // if it was copied, use the copy from revision as lowerRev
1428 if ((pLogEntry)&&(pLogEntry->pArChangedPaths)&&(lowerRev == higherRev))
1429 {
1430 CString sUrl = m_path.GetGitPathString();
1431 if (!m_path.IsUrl())
1432 {
1433 sUrl = GetURLFromPath(m_path);
1434 }
1435 sUrl = sUrl.Mid(m_sRepositoryRoot.GetLength());
1436 for (int cp = 0; cp < pLogEntry->pArChangedPaths->GetCount(); ++cp)
1437 {
1438 LogChangedPath * pData = pLogEntry->pArChangedPaths->SafeGetAt(cp);
1439 if (pData)
1440 {
1441 if (sUrl.Compare(pData->sPath) == 0)
1442 {
1443 if (!pData->sCopyFromPath.IsEmpty())
1444 {
1445 lowerRev = pData->lCopyFromRev;
1446 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART), lowerRev);
1447 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND), higherRev);
1448 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);
1449 bSentMessage = TRUE;
1450 }
1451 }
1452 }
1453 }
1454 }
1455 }
1456 if ( !bSentMessage )
1457 {
1458 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART | MERGE_REVSELECTMINUSONE), lowerRev);
1459 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND | MERGE_REVSELECTMINUSONE), higherRev);
1460 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);
1461 if (m_selectedRevsOneRange.GetCount())
1462 m_pNotifyWindow->SendMessage(WM_REVLISTONERANGE, 0, (LPARAM)&m_selectedRevsOneRange);
1463 }
1464 }
1465 }
1466 UpdateData();
1467 CRegDWORD reg(_T("Software\\TortoiseGit\\ShowAllEntry"));
1468 SaveSplitterPos();
1469 #endif
1470 }
1471
1472 void CLogDlg::DoDiffFromLog(INT_PTR selIndex, GitRev* rev1, GitRev* rev2, bool /*blame*/, bool /*unified*/)
1473 {
1474 DialogEnableWindow(IDOK, FALSE);
1475 // SetPromptApp(&theApp);
1476 theApp.DoWaitCursor(1);
1477
1478 CString temppath;
1479 GetTempPath(temppath);
1480
1481 CString file1;
1482 file1.Format(_T("%s%s_%s%s"),
1483 temppath,
1484 (*m_currentChangedArray)[selIndex].GetBaseFilename(),
1485 rev1->m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()),
1486 (*m_currentChangedArray)[selIndex].GetFileExtension());
1487
1488 CString file2;
1489 file2.Format(_T("%s\\%s_%s%s"),
1490 temppath,
1491 (*m_currentChangedArray)[selIndex].GetBaseFilename(),
1492 rev2->m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()),
1493 (*m_currentChangedArray)[selIndex].GetFileExtension());
1494
1495 CString cmd;
1496 CTGitPath &path = (CTGitPath &)(*m_currentChangedArray)[selIndex];
1497
1498 if (g_Git.GetOneFile(rev1->m_CommitHash.ToString(), path, file1))
1499 {
1500 CString out;
1501 out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, path.GetGitPathString(), rev1->m_CommitHash.ToString(), file1);
1502 CMessageBox::Show(nullptr, g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), _T("TortoiseGit"), MB_OK);
1503 theApp.DoWaitCursor(-1);
1504 EnableOKButton();
1505 return;
1506 }
1507 if (g_Git.GetOneFile(rev2->m_CommitHash.ToString(), path, file2))
1508 {
1509 CString out;
1510 out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, path.GetGitPathString(), rev2->m_CommitHash.ToString(), file2);
1511 CMessageBox::Show(nullptr, g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), _T("TortoiseGit"), MB_OK);
1512 theApp.DoWaitCursor(-1);
1513 EnableOKButton();
1514 return;
1515 }
1516
1517 CAppUtils::DiffFlags flags;
1518 CAppUtils::StartExtDiff(file1,file2,_T("A"),_T("B"),
1519 g_Git.CombinePath(path), g_Git.CombinePath(path),
1520 rev1->m_CommitHash.ToString(), rev2->m_CommitHash.ToString(),
1521 flags);
1522
1523 theApp.DoWaitCursor(-1);
1524 EnableOKButton();
1525 }
1526
1527 BOOL CLogDlg::PreTranslateMessage(MSG* pMsg)
1528 {
1529 // Skip Ctrl-C when copying text out of the log message or search filter
1530 bool bSkipAccelerator = (pMsg->message == WM_KEYDOWN && (pMsg->wParam == 'C' || pMsg->wParam == VK_INSERT) && (GetFocus() == GetDlgItem(IDC_MSGVIEW) || GetFocus() == GetDlgItem(IDC_SEARCHEDIT) || GetFocus() == GetDlgItem(IDC_FILTER)) && GetKeyState(VK_CONTROL) & 0x8000);
1531 if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')
1532 {
1533 if (GetFocus()==GetDlgItem(IDC_LOGLIST))
1534 {
1535 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1536 {
1537 m_LogList.DiffSelectedRevWithPrevious();
1538 return TRUE;
1539 }
1540 }
1541 if (GetFocus() == GetDlgItem(IDC_SEARCHEDIT))
1542 {
1543 KillTimer(LOGFILTER_TIMER);
1544 m_limit = 0;
1545 m_LogList.Refresh(FALSE);
1546 FillLogMessageCtrl(false);
1547 }
1548 if (GetFocus() == GetDlgItem(IDC_FILTER))
1549 {
1550 KillTimer(FILEFILTER_TIMER);
1551 FillLogMessageCtrl();
1552 return TRUE;
1553 }
1554 }
1555 else if (pMsg->message == WM_XBUTTONUP)
1556 {
1557 bool select = (pMsg->wParam & MK_SHIFT) == 0;
1558 if (HIWORD(pMsg->wParam) & XBUTTON1)
1559 GoBackForward(select, false);
1560 if (HIWORD(pMsg->wParam) & XBUTTON2)
1561 GoBackForward(select, true);
1562 if (HIWORD(pMsg->wParam) & (XBUTTON1 | XBUTTON2))
1563 return TRUE;
1564 }
1565 if (m_hAccel && !bSkipAccelerator)
1566 {
1567 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
1568 if (ret)
1569 return TRUE;
1570 }
1571
1572 return __super::PreTranslateMessage(pMsg);
1573 }
1574
1575
1576 BOOL CLogDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
1577 {
1578 //if (this->IsThreadRunning())
1579 if(m_LogList.m_bNoDispUpdates)
1580 {
1581 // only show the wait cursor over the list control
1582 if ((pWnd)&&
1583 ((pWnd == GetDlgItem(IDC_LOGLIST))||
1584 (pWnd == GetDlgItem(IDC_MSGVIEW))||
1585 (pWnd == GetDlgItem(IDC_LOGMSG))))
1586 {
1587 HCURSOR hCur = LoadCursor(NULL, IDC_WAIT);
1588 SetCursor(hCur);
1589 return TRUE;
1590 }
1591 }
1592 if ((pWnd) && (pWnd == GetDlgItem(IDC_MSGVIEW)))
1593 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1594
1595 HCURSOR hCur = LoadCursor(NULL, IDC_ARROW);
1596 SetCursor(hCur);
1597 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1598 }
1599
1600 void CLogDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1601 {
1602 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1603 *pResult = 0;
1604 //if (this->IsThreadRunning())
1605 if(m_LogList.m_bNoDispUpdates)
1606 return;
1607 if (pNMLV->iItem >= 0)
1608 {
1609 if (!m_LogList.m_highlight.IsEmpty())
1610 {
1611 m_LogList.m_highlight.Empty();
1612 m_LogList.Invalidate();
1613 }
1614 this->m_LogList.m_nSearchIndex = pNMLV->iItem;
1615 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(pNMLV->iItem));
1616 if (pLogEntry == nullptr)
1617 return;
1618 m_LogList.m_lastSelectedHash = pLogEntry->m_CommitHash;
1619 if (pNMLV->iSubItem != 0)
1620 return;
1621 if ((pNMLV->iItem == m_LogList.m_arShownList.GetCount()))
1622 {
1623 // remove the selected state
1624 if (pNMLV->uChanged & LVIF_STATE)
1625 {
1626 m_LogList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
1627 FillLogMessageCtrl();
1628 UpdateData(FALSE);
1629 UpdateLogInfoLabel();
1630 }
1631 return;
1632 }
1633 if (pNMLV->uChanged & LVIF_STATE)
1634 {
1635 if ((pNMLV->uNewState & LVIS_SELECTED) && !m_bNavigatingWithSelect)
1636 {
1637 m_LogList.m_selectionHistory.Add(m_LogList.m_lastSelectedHash);
1638 m_LogList.m_lastSelectedHash = pLogEntry->m_CommitHash;
1639 }
1640 FillLogMessageCtrl();
1641 UpdateData(FALSE);
1642 }
1643 }
1644 else
1645 {
1646 m_LogList.m_lastSelectedHash.Empty();
1647 FillLogMessageCtrl();
1648 UpdateData(FALSE);
1649 }
1650 EnableOKButton();
1651 UpdateLogInfoLabel();
1652 }
1653
1654 void CLogDlg::OnLvnItemchangedLogmsg(NMHDR * /*pNMHDR*/, LRESULT * /*pResult*/)
1655 {
1656 UpdateLogInfoLabel();
1657 }
1658
1659 void CLogDlg::OnEnLinkMsgview(NMHDR *pNMHDR, LRESULT *pResult)
1660 {
1661 ENLINK *pEnLink = reinterpret_cast<ENLINK *>(pNMHDR);
1662 if ((pEnLink->msg == WM_LBUTTONUP) || (pEnLink->msg == WM_SETCURSOR))
1663 {
1664 CString url, msg;
1665 GetDlgItemText(IDC_MSGVIEW, msg);
1666 msg.Replace(_T("\r\n"), _T("\n"));
1667 url = msg.Mid(pEnLink->chrg.cpMin, pEnLink->chrg.cpMax-pEnLink->chrg.cpMin);
1668 auto findResult = m_LogList.m_ProjectProperties.FindBugIDPositions(msg);
1669 if (std::find_if(findResult.begin(), findResult.end(),
1670 [=] (const CHARRANGE &cr) -> bool { return cr.cpMin == pEnLink->chrg.cpMin && cr.cpMax == pEnLink->chrg.cpMax; }
1671 ) != findResult.end())
1672 {
1673 url = m_LogList.m_ProjectProperties.GetBugIDUrl(url);
1674 url = GetAbsoluteUrlFromRelativeUrl(url);
1675 }
1676 if (::PathIsURL(url))
1677 {
1678 if (pEnLink->msg == WM_LBUTTONUP)
1679 ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);
1680 else
1681 {
1682 static RECT prevRect = { 0 };
1683 CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);
1684 if (pMsgView)
1685 {
1686 RECT rc;
1687 POINTL pt;
1688 pMsgView->SendMessage(EM_POSFROMCHAR, (WPARAM)&pt, pEnLink->chrg.cpMin);
1689 rc.left = pt.x;
1690 rc.top = pt.y;
1691 pMsgView->SendMessage(EM_POSFROMCHAR, (WPARAM)&pt, pEnLink->chrg.cpMax);
1692 rc.right = pt.x;
1693 rc.bottom = pt.y + 12;
1694 if ((prevRect.left != rc.left) || (prevRect.top != rc.top))
1695 {
1696 m_tooltips.DelTool(pMsgView, 1);
1697 m_tooltips.AddTool(pMsgView, url, &rc, 1);
1698 prevRect = rc;
1699 }
1700 }
1701 }
1702 }
1703 else if(pEnLink->msg == WM_LBUTTONUP)
1704 {
1705 int pos = 0;
1706 if (LookLikeGitHash(url, pos))
1707 {
1708 bool found = false;
1709 for (int i = 0; i < m_LogList.m_arShownList.GetCount(); ++i)
1710 {
1711 GitRev *rev = (GitRev *)m_LogList.m_arShownList.SafeGetAt(i);
1712 if (!rev) continue;
1713 if (rev->m_CommitHash.ToString().Left(url.GetLength()) == url)
1714 {
1715 POSITION pos2 = m_LogList.GetFirstSelectedItemPosition();
1716 if (pos2)
1717 {
1718 int index = m_LogList.GetNextSelectedItem(pos2);
1719 if (index >= 0)
1720 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1721 }
1722 m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
1723 m_LogList.EnsureVisible(i, FALSE);
1724 m_LogList.SetSelectionMark(i);
1725 found = true;
1726 PostMessage(WM_TGIT_REFRESH_SELECTION, 0, 0);
1727 break;
1728 }
1729 }
1730
1731 if (!found)
1732 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, _T("NoJumpNotFoundWarning"), IDS_MSGBOX_DONOTSHOWAGAIN);
1733 }
1734 }
1735 }
1736 *pResult = 0;
1737 }
1738
1739 void CLogDlg::OnBnClickedStatbutton()
1740 {
1741 if (this->IsThreadRunning())
1742 return;
1743 if (m_LogList.m_arShownList.IsEmpty() || m_LogList.m_arShownList.GetCount() == 1 && m_LogList.m_bShowWC)
1744 return; // nothing or just the working copy changes are shown, so no statistics.
1745 // the statistics dialog expects the log entries to be sorted by date
1746 SortByColumn(3, false);
1747
1748 CStatGraphDlg dlg;
1749 m_LogList.RecalculateShownList(&dlg.m_ShowList);
1750
1751 dlg.m_path = m_orgPath;
1752 dlg.DoModal();
1753 // restore the previous sorting
1754 SortByColumn(m_nSortColumn, m_bAscending);
1755 OnTimer(LOGFILTER_TIMER);
1756 }
1757
1758 void CLogDlg::MoveToSameTop(CWnd *pWndRef, CWnd *pWndTarget)
1759 {
1760 CRect rcWndPicAuthor, rcWndMsgView;
1761 pWndRef->GetWindowRect(rcWndMsgView);
1762 ScreenToClient(rcWndMsgView);
1763 pWndTarget->GetWindowRect(rcWndPicAuthor);
1764 ScreenToClient(rcWndPicAuthor);
1765 int diff = rcWndMsgView.top - rcWndPicAuthor.top;
1766 rcWndPicAuthor.top += diff;
1767 rcWndPicAuthor.bottom += diff;
1768 pWndTarget->MoveWindow(rcWndPicAuthor);
1769 }
1770
1771 void CLogDlg::DoSizeV1(int delta)
1772 {
1773 RemoveMainAnchors();
1774
1775 // first, reduce the middle section to a minimum.
1776 // if that is not sufficient, minimize the lower section
1777
1778 CRect changeListViewRect;
1779 m_ChangedFileListCtrl.GetClientRect(changeListViewRect);
1780 CRect messageViewRect;
1781 GetDlgItem(IDC_MSGVIEW)->GetClientRect(messageViewRect);
1782
1783 int messageViewDelta = max(-delta, 20 - messageViewRect.Height());
1784 int changeFileListDelta = -delta - messageViewDelta;
1785
1786 // set new sizes & positions
1787 CSplitterControl::ChangeHeight(&m_LogList, delta, CW_TOPALIGN);
1788 CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), messageViewDelta, CW_TOPALIGN);
1789 CSplitterControl::ChangePos(GetDlgItem(IDC_MSGVIEW), 0, delta);
1790 MoveToSameTop(GetDlgItem(IDC_MSGVIEW), GetDlgItem(IDC_PIC_AUTHOR));
1791 CSplitterControl::ChangePos(GetDlgItem(IDC_SPLITTERBOTTOM), 0, -changeFileListDelta);
1792 CSplitterControl::ChangeHeight(&m_ChangedFileListCtrl, changeFileListDelta, CW_BOTTOMALIGN);
1793
1794 AddMainAnchors();
1795 ArrangeLayout();
1796 AdjustMinSize();
1797 SetSplitterRange();
1798 m_LogList.Invalidate();
1799 m_ChangedFileListCtrl.Invalidate();
1800 GetDlgItem(IDC_MSGVIEW)->Invalidate();
1801 m_gravatar.Invalidate();
1802 }
1803
1804 void CLogDlg::DoSizeV2(int delta)
1805 {
1806 RemoveMainAnchors();
1807
1808 // first, reduce the middle section to a minimum.
1809 // if that is not sufficient, minimize the top section
1810
1811 CRect logViewRect;
1812 m_LogList.GetClientRect(logViewRect);
1813 CRect messageViewRect;
1814 GetDlgItem(IDC_MSGVIEW)->GetClientRect(messageViewRect);
1815
1816 int messageViewDelta = max(delta, 20 - messageViewRect.Height());
1817 int logListDelta = delta - messageViewDelta;
1818
1819 // set new sizes & positions
1820 CSplitterControl::ChangeHeight(&m_LogList, logListDelta, CW_TOPALIGN);
1821 CSplitterControl::ChangePos(GetDlgItem(IDC_SPLITTERTOP), 0, logListDelta);
1822
1823 CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), messageViewDelta, CW_TOPALIGN);
1824 CSplitterControl::ChangePos(GetDlgItem(IDC_MSGVIEW), 0, logListDelta);
1825 MoveToSameTop(GetDlgItem(IDC_MSGVIEW), GetDlgItem(IDC_PIC_AUTHOR));
1826
1827 CSplitterControl::ChangeHeight(&m_ChangedFileListCtrl, -delta, CW_BOTTOMALIGN);
1828
1829 AddMainAnchors();
1830 ArrangeLayout();
1831 AdjustMinSize();
1832 SetSplitterRange();
1833 GetDlgItem(IDC_MSGVIEW)->Invalidate();
1834 m_ChangedFileListCtrl.Invalidate();
1835 m_gravatar.Invalidate();
1836 }
1837
1838 void CLogDlg::AddMainAnchors()
1839 {
1840 AddAnchor(IDC_STATIC_REF, TOP_LEFT);
1841 AddAnchor(IDC_FROMLABEL, TOP_LEFT);
1842 AddAnchor(IDC_DATEFROM, TOP_LEFT);
1843 AddAnchor(IDC_TOLABEL, TOP_LEFT);
1844 AddAnchor(IDC_DATETO, TOP_LEFT);
1845
1846 AddAnchor(IDC_SEARCHEDIT, TOP_LEFT, TOP_RIGHT);
1847 AddAnchor(IDC_LOG_JUMPTYPE, TOP_RIGHT);
1848 AddAnchor(IDC_LOG_JUMPUP, TOP_RIGHT);
1849 AddAnchor(IDC_LOG_JUMPDOWN, TOP_RIGHT);
1850
1851 AddAnchor(IDC_LOGLIST, TOP_LEFT, MIDDLE_RIGHT);
1852 AddAnchor(IDC_SPLITTERTOP, MIDDLE_LEFT, MIDDLE_RIGHT);
1853 AddAnchor(IDC_MSGVIEW, MIDDLE_LEFT, MIDDLE_RIGHT); // keep in sync with ShowGravatar()
1854 AddAnchor(IDC_PIC_AUTHOR, MIDDLE_RIGHT);
1855 AddAnchor(IDC_SPLITTERBOTTOM, MIDDLE_LEFT, MIDDLE_RIGHT);
1856 AddAnchor(IDC_LOGMSG, MIDDLE_LEFT, BOTTOM_RIGHT);
1857
1858 AddAnchor(IDC_LOGINFO, BOTTOM_LEFT, BOTTOM_RIGHT);
1859 AddAnchor(IDC_WALKBEHAVIOUR, BOTTOM_LEFT);
1860 AddAnchor(IDC_VIEW, BOTTOM_LEFT);
1861 AddAnchor(IDC_LOG_ALLBRANCH, BOTTOM_LEFT);
1862 AddAnchor(IDC_FILTER, BOTTOM_LEFT, BOTTOM_RIGHT);
1863 AddAnchor(IDC_WHOLE_PROJECT, BOTTOM_LEFT);
1864 AddAnchor(IDC_REFRESH, BOTTOM_LEFT);
1865 AddAnchor(IDC_STATBUTTON, BOTTOM_LEFT);
1866 AddAnchor(IDC_PROGRESS, BOTTOM_LEFT, BOTTOM_RIGHT);
1867 AddAnchor(IDOK, BOTTOM_RIGHT);
1868 AddAnchor(IDCANCEL, BOTTOM_RIGHT);
1869 AddAnchor(IDHELP, BOTTOM_RIGHT);
1870 }
1871
1872 void CLogDlg::RemoveMainAnchors()
1873 {
1874 RemoveAnchor(IDC_STATIC_REF);
1875 RemoveAnchor(IDC_FROMLABEL);
1876 RemoveAnchor(IDC_DATEFROM);
1877 RemoveAnchor(IDC_TOLABEL);
1878 RemoveAnchor(IDC_DATETO);
1879
1880 RemoveAnchor(IDC_SEARCHEDIT);
1881 RemoveAnchor(IDC_LOG_JUMPTYPE);
1882 RemoveAnchor(IDC_LOG_JUMPUP);
1883 RemoveAnchor(IDC_LOG_JUMPDOWN);
1884
1885 RemoveAnchor(IDC_LOGLIST);
1886 RemoveAnchor(IDC_SPLITTERTOP);
1887 RemoveAnchor(IDC_MSGVIEW);
1888 RemoveAnchor(IDC_PIC_AUTHOR);
1889 RemoveAnchor(IDC_SPLITTERBOTTOM);
1890 RemoveAnchor(IDC_LOGMSG);
1891
1892 RemoveAnchor(IDC_LOGINFO);
1893 RemoveAnchor(IDC_WALKBEHAVIOUR);
1894 RemoveAnchor(IDC_VIEW);
1895 RemoveAnchor(IDC_LOG_ALLBRANCH);
1896 RemoveAnchor(IDC_FILTER);
1897 RemoveAnchor(IDC_WHOLE_PROJECT);
1898 RemoveAnchor(IDC_REFRESH);
1899 RemoveAnchor(IDC_STATBUTTON);
1900 RemoveAnchor(IDC_PROGRESS);
1901 RemoveAnchor(IDOK);
1902 RemoveAnchor(IDCANCEL);
1903 RemoveAnchor(IDHELP);
1904 }
1905
1906 void CLogDlg::AdjustMinSize()
1907 {
1908 // adjust the minimum size of the dialog to prevent the resizing from
1909 // moving the list control too far down.
1910 CRect rcChgListView;
1911 m_ChangedFileListCtrl.GetClientRect(rcChgListView);
1912 CRect rcLogList;
1913 m_LogList.GetClientRect(rcLogList);
1914 CRect rcLogMsg;
1915 GetDlgItem(IDC_MSGVIEW)->GetClientRect(rcLogMsg);
1916
1917 SetMinTrackSize(CSize(m_DlgOrigRect.Width(),
1918 m_DlgOrigRect.Height()-m_ChgOrigRect.Height()-m_LogListOrigRect.Height()-m_MsgViewOrigRect.Height()
1919 + rcLogMsg.Height() + abs(rcChgListView.Height() - rcLogList.Height()) + 60));
1920 }
1921
1922 LRESULT CLogDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
1923 {
1924 switch (message) {
1925 case WM_NOTIFY:
1926 if (wParam == IDC_SPLITTERTOP)
1927 {
1928 SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
1929 DoSizeV1(pHdr->delta);
1930 }
1931 else if (wParam == IDC_SPLITTERBOTTOM)
1932 {
1933 SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
1934 DoSizeV2(pHdr->delta);
1935 }
1936 break;
1937 }
1938
1939 return CResizableDialog::DefWindowProc(message, wParam, lParam);
1940 }
1941
1942 void CLogDlg::SetSplitterRange()
1943 {
1944 if ((m_LogList)&&(m_ChangedFileListCtrl))
1945 {
1946 CRect rcTop;
1947 m_LogList.GetWindowRect(rcTop);
1948 ScreenToClient(rcTop);
1949 CRect rcBottom;
1950 m_ChangedFileListCtrl.GetWindowRect(rcBottom);
1951 ScreenToClient(rcBottom);
1952 m_wndSplitter1.SetRange(rcTop.top + 20, rcBottom.bottom - 50);
1953 m_wndSplitter2.SetRange(rcTop.top + 50, rcBottom.bottom - 20);
1954 }
1955 }
1956
1957 void CLogDlg::OnEnscrollMsgview()
1958 {
1959 m_tooltips.DelTool(GetDlgItem(IDC_MSGVIEW), 1);
1960 }
1961
1962 LRESULT CLogDlg::OnClickedInfoIcon(WPARAM wParam, LPARAM lParam)
1963 {
1964 if ((HWND)wParam == m_cFileFilter.GetSafeHwnd())
1965 return 0;
1966
1967 // FIXME: x64 version would get this function called with unexpected parameters.
1968 if (!lParam)
1969 return 0;
1970
1971 RECT * rect = (LPRECT)lParam;
1972 CPoint point;
1973 CString temp;
1974 point = CPoint(rect->left, rect->bottom);
1975 #define LOGMENUFLAGS(x) (MF_STRING | MF_ENABLED | ((m_LogList.m_SelectedFilters & x) ? MF_CHECKED : MF_UNCHECKED))
1976 CMenu popup;
1977 if (popup.CreatePopupMenu())
1978 {
1979 temp.LoadString(IDS_LOG_FILTER_SUBJECT);
1980 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_SUBJECT), LOGFILTER_SUBJECT, temp);
1981
1982 temp.LoadString(IDS_LOG_FILTER_MESSAGES);
1983 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_MESSAGES), LOGFILTER_MESSAGES, temp);
1984
1985 temp.LoadString(IDS_LOG_FILTER_PATHS);
1986 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_PATHS), LOGFILTER_PATHS, temp);
1987
1988 temp.LoadString(IDS_LOG_FILTER_AUTHORS);
1989 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_AUTHORS), LOGFILTER_AUTHORS, temp);
1990
1991 temp.LoadString(IDS_LOG_FILTER_EMAILS);
1992 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_EMAILS), LOGFILTER_EMAILS, temp);
1993
1994 temp.LoadString(IDS_LOG_FILTER_REVS);
1995 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_REVS), LOGFILTER_REVS, temp);
1996
1997 temp.LoadString(IDS_LOG_FILTER_REFNAME);
1998 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_REFNAME), LOGFILTER_REFNAME, temp);
1999
2000 if (m_LogList.m_bShowBugtraqColumn == TRUE) {
2001 temp.LoadString(IDS_LOG_FILTER_BUGIDS);
2002 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_BUGID), LOGFILTER_BUGID, temp);
2003 }
2004
2005 popup.AppendMenu(MF_SEPARATOR, NULL);
2006
2007 temp.LoadString(IDS_LOG_FILTER_TOGGLE);
2008 popup.AppendMenu(MF_STRING | MF_ENABLED, LOGFILTER_TOGGLE, temp);
2009
2010 temp.LoadString(IDS_ALL);
2011 popup.AppendMenu(MF_STRING | MF_ENABLED, LOGFILTER_ALL, temp);
2012
2013 popup.AppendMenu(MF_SEPARATOR, NULL);
2014
2015 temp.LoadString(IDS_LOG_FILTER_REGEX);
2016 popup.AppendMenu(MF_STRING | MF_ENABLED | (m_bFilterWithRegex ? MF_CHECKED : MF_UNCHECKED), LOGFILTER_REGEX, temp);
2017
2018 temp.LoadString(IDS_LOG_FILTER_CASESENSITIVE);
2019 popup.AppendMenu(MF_STRING | MF_ENABLED | (m_bFilterCaseSensitively ? MF_CHECKED : MF_UNCHECKED), LOGFILTER_CASE, temp);
2020
2021 m_tooltips.Pop();
2022 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
2023 if (selection != 0)
2024 {
2025
2026 if (selection == LOGFILTER_REGEX)
2027 {
2028 m_bFilterWithRegex = !m_bFilterWithRegex;
2029 CRegDWORD b(_T("Software\\TortoiseGit\\UseRegexFilter"), FALSE);
2030 b = m_bFilterWithRegex;
2031 m_LogList.m_bFilterWithRegex = m_bFilterWithRegex;
2032 SetFilterCueText();
2033 CheckRegexpTooltip();
2034 }
2035 else if (selection == LOGFILTER_CASE)
2036 {
2037 m_bFilterCaseSensitively = !m_bFilterCaseSensitively;
2038 CRegDWORD b(_T("Software\\TortoiseGit\\FilterCaseSensitively"), FALSE);
2039 b = m_bFilterCaseSensitively;
2040 m_LogList.m_bFilterCaseSensitively = m_bFilterCaseSensitively;
2041 }
2042 else if (selection == LOGFILTER_TOGGLE)
2043 {
2044 m_LogList.m_SelectedFilters = (~m_LogList.m_SelectedFilters) & LOGFILTER_ALL;
2045 SetFilterCueText();
2046 }
2047 else if (selection == LOGFILTER_ALL)
2048 {
2049 m_LogList.m_SelectedFilters = selection;
2050 SetFilterCueText();
2051 }
2052 else
2053 {
2054 m_LogList.m_SelectedFilters ^= selection;
2055 SetFilterCueText();
2056 }
2057 CRegDWORD(_T("Software\\TortoiseGit\\SelectedLogFilters")) = m_LogList.m_SelectedFilters;
2058 // Reload only if a search text is entered
2059 if (m_LogList.HasFilterText())
2060 SetTimer(LOGFILTER_TIMER, 1000, NULL);
2061 }
2062 }
2063 return 0L;
2064 }
2065
2066 LRESULT CLogDlg::OnClickedCancelFilter(WPARAM wParam, LPARAM /*lParam*/)
2067 {
2068 if ((HWND)wParam == m_cFileFilter.GetSafeHwnd())
2069 {
2070 KillTimer(FILEFILTER_TIMER);
2071
2072 FillLogMessageCtrl();
2073 return 0L;
2074 }
2075
2076 KillTimer(LOGFILTER_TIMER);
2077
2078 m_LogList.m_sFilterText.Empty();
2079 UpdateData(FALSE);
2080 theApp.DoWaitCursor(1);
2081 CStoreSelection storeselection(this);
2082 FillLogMessageCtrl(false);
2083
2084 m_LogList.RemoveFilter();
2085
2086 Refresh();
2087
2088 CTime begin,end;
2089 m_LogList.GetTimeRange(begin,end);
2090 m_DateFrom.SetTime(&begin);
2091 m_DateTo.SetTime(&end);
2092
2093 theApp.DoWaitCursor(-1);
2094 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
2095 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
2096 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2097 UpdateLogInfoLabel();
2098
2099 return 0L;
2100 }
2101
2102
2103 void CLogDlg::SetFilterCueText()
2104 {
2105 CString temp(MAKEINTRESOURCE(IDS_LOG_FILTER_BY));
2106 temp += _T(" ");
2107
2108 if (m_LogList.m_SelectedFilters & LOGFILTER_SUBJECT)
2109 {
2110 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_SUBJECT));
2111 }
2112
2113 if (m_LogList.m_SelectedFilters & LOGFILTER_MESSAGES)
2114 {
2115 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
2116 temp += _T(", ");
2117 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_MESSAGES));
2118 }
2119
2120 if (m_LogList.m_SelectedFilters & LOGFILTER_PATHS)
2121 {
2122 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
2123 temp += _T(", ");
2124 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_PATHS));
2125 }
2126
2127 if (m_LogList.m_SelectedFilters & LOGFILTER_AUTHORS)
2128 {
2129 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
2130 temp += _T(", ");
2131 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_AUTHORS));
2132 }
2133
2134 if (m_LogList.m_SelectedFilters & LOGFILTER_EMAILS)
2135 {
2136 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
2137 temp += _T(", ");
2138 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_EMAILS));
2139 }
2140
2141 if (m_LogList.m_SelectedFilters & LOGFILTER_REVS)
2142 {
2143 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
2144 temp += _T(", ");
2145 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_REVS));
2146 }
2147
2148 if (m_LogList.m_SelectedFilters & LOGFILTER_REFNAME)
2149 {
2150 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
2151 temp += _T(", ");
2152 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_REFNAME));
2153 }
2154
2155 if (m_LogList.m_bShowBugtraqColumn && m_LogList.m_SelectedFilters & LOGFILTER_BUGID)
2156 {
2157 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
2158 temp += _T(", ");
2159 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_BUGIDS));
2160 }
2161
2162 // to make the cue banner text appear more to the right of the edit control
2163 temp = _T(" ")+temp;
2164 m_cFilter.SetCueBanner(temp.TrimRight());
2165 }
2166
2167 bool CLogDlg::Validate(LPCTSTR string)
2168 {
2169 if (!m_bFilterWithRegex)
2170 return true;
2171 std::tr1::wregex pat;
2172 return m_LogList.ValidateRegexp(string, pat, false);
2173 }
2174
2175 void CLogDlg::OnEnChangeFileFilter()
2176 {
2177 SetTimer(FILEFILTER_TIMER, 1000, NULL);
2178 }
2179
2180 void CLogDlg::OnTimer(UINT_PTR nIDEvent)
2181 {
2182 if (nIDEvent == LOGFTIME_TIMER)
2183 {
2184 KillTimer(LOGFTIME_TIMER);
2185 m_limit = 0;
2186 m_LogList.Refresh(FALSE);
2187 FillLogMessageCtrl(false);
2188 }
2189 else if (nIDEvent == LOG_FILLPATCHVTIMER)
2190 {
2191 FillPatchView();
2192 }
2193 else if (nIDEvent == LOGFILTER_TIMER)
2194 {
2195 KillTimer(LOGFILTER_TIMER);
2196 m_limit = 0;
2197 m_LogList.Refresh(FALSE);
2198 FillLogMessageCtrl(false);
2199
2200 #if 0
2201 /* we will use git built-in grep to filter log */
2202 if (this->IsThreadRunning())
2203 {
2204 // thread still running! So just restart the timer.
2205 SetTimer(LOGFILTER_TIMER, 1000, NULL);
2206 return;
2207 }
2208 CWnd * focusWnd = GetFocus();
2209 bool bSetFocusToFilterControl = ((focusWnd != GetDlgItem(IDC_DATEFROM))&&(focusWnd != GetDlgItem(IDC_DATETO))
2210 && (focusWnd != GetDlgItem(IDC_LOGLIST)));
2211 if (m_LogList.m_sFilterText.IsEmpty())
2212 {
2213 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty()))));
2214 // do not return here!
2215 // we also need to run the filter if the filter text is empty:
2216 // 1. to clear an existing filter
2217 // 2. to rebuild the m_arShownList after sorting
2218 }
2219 theApp.DoWaitCursor(1);
2220 CStoreSelection storeselection(this);
2221 KillTimer(LOGFILTER_TIMER);
2222 FillLogMessageCtrl(false);
2223
2224 // now start filter the log list
2225 m_LogList.StartFilter();
2226
2227 if ( m_LogList.GetItemCount()==1 )
2228 {
2229 m_LogList.SetSelectionMark(0);
2230 m_LogList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
2231 }
2232 theApp.DoWaitCursor(-1);
2233 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
2234 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
2235 if (bSetFocusToFilterControl)
2236 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2237 UpdateLogInfoLabel();
2238 #endif
2239 } // if (nIDEvent == LOGFILTER_TIMER)
2240 else if (nIDEvent == LOG_HEADER_ORDER_TIMER)
2241 {
2242 KillTimer(LOG_HEADER_ORDER_TIMER);
2243 CLogOrdering orderDlg;
2244 if (orderDlg.DoModal() == IDOK)
2245 Refresh();
2246 }
2247 else if (nIDEvent == FILEFILTER_TIMER)
2248 {
2249 KillTimer(FILEFILTER_TIMER);
2250 FillLogMessageCtrl();
2251 }
2252 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty() || m_LogList.m_arShownList.GetCount() == 1 && m_LogList.m_bShowWC))));
2253 __super::OnTimer(nIDEvent);
2254 }
2255
2256 void CLogDlg::OnDtnDatetimechangeDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2257 {
2258 try
2259 {
2260 CTime _time;
2261 m_DateTo.GetTime(_time);
2262
2263 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 23, 59, 59);
2264 if (time.GetTime() != m_LogList.m_To)
2265 {
2266 m_LogList.m_To = (DWORD)time.GetTime();
2267 SetTimer(LOGFTIME_TIMER, 10, NULL);
2268 }
2269 }
2270 catch (...)
2271 {
2272 CMessageBox::Show(NULL,_T("Invalidate Parameter"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
2273 }
2274
2275 *pResult = 0;
2276 }
2277
2278 void CLogDlg::OnDtnDatetimechangeDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2279 {
2280
2281 try
2282 {
2283 CTime _time;
2284 m_DateFrom.GetTime(_time);
2285
2286 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 0, 0, 0);
2287 if (time.GetTime() != m_LogList.m_From)
2288 {
2289 m_LogList.m_From = (DWORD)time.GetTime();
2290 SetTimer(LOGFTIME_TIMER, 10, NULL);
2291 }
2292 }
2293 catch (...)
2294 {
2295 CMessageBox::Show(NULL,_T("Invalidate Parameter"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
2296 }
2297
2298 *pResult = 0;
2299 }
2300
2301 void CLogDlg::OnCbnSelchangeJumpType()
2302 {
2303 // reserved for future use
2304 }
2305
2306 void CLogDlg::OnBnClickedJumpUp()
2307 {
2308 int sel = m_JumpType.GetCurSel();
2309 if (sel < 0) return;
2310 JumpType jumpType = (JumpType)sel;
2311
2312 if (jumpType == JumpType_History)
2313 {
2314 GoBack();
2315 return;
2316 }
2317
2318 CString strValue;
2319 CGitHash hashValue;
2320 int index = -1;
2321 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2322 if (pos)
2323 {
2324 index = m_LogList.GetNextSelectedItem(pos);
2325 if (index == 0) return;
2326
2327 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(index);
2328 if (jumpType == JumpType_AuthorEmail)
2329 strValue = data->GetAuthorEmail();
2330 else if (jumpType == JumpType_CommitterEmail)
2331 strValue = data->GetCommitterEmail();
2332 else if (jumpType == JumpType_Parent1)
2333 hashValue = data->m_CommitHash;
2334 else if (jumpType == JumpType_Parent2)
2335 hashValue = data->m_CommitHash;
2336 else if (jumpType == JumpType_TagFF)
2337 hashValue = data->m_CommitHash;
2338 else if (jumpType == JumpType_BranchFF)
2339 hashValue = data->m_CommitHash;
2340
2341 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
2342 }
2343 else
2344 return;
2345
2346 while (pos)
2347 {
2348 index = m_LogList.GetNextSelectedItem(pos);
2349 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
2350 }
2351 m_LogList.SetSelectionMark(-1);
2352
2353 for (int i = index - 1; i >= 0; i--)
2354 {
2355 bool found = false;
2356 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(i);
2357 if (jumpType == JumpType_AuthorEmail)
2358 found = strValue == data->GetAuthorEmail();
2359 else if (jumpType == JumpType_CommitterEmail)
2360 found = strValue == data->GetCommitterEmail();
2361 else if (jumpType == JumpType_MergePoint)
2362 found = data->ParentsCount() > 1;
2363 else if (jumpType == JumpType_Parent1)
2364 {
2365 if (data->m_ParentHash.size() > 0)
2366 found = data->m_ParentHash[0] == hashValue;
2367 }
2368 else if (jumpType == JumpType_Parent2)
2369 {
2370 if (data->m_ParentHash.size() > 1)
2371 found = data->m_ParentHash[1] == hashValue;
2372 }
2373 else if (jumpType == JumpType_Tag || jumpType == JumpType_TagFF)
2374 {
2375 STRING_VECTOR refList = m_LogList.m_HashMap[data->m_CommitHash];
2376 for (size_t j = 0; j < refList.size(); ++j)
2377 {
2378 if (refList[j].Left(10) == _T("refs/tags/"))
2379 {
2380 found = true;
2381 break;
2382 }
2383 }
2384
2385 if (found && jumpType == JumpType_TagFF)
2386 found = g_Git.IsFastForward(hashValue, data->m_CommitHash);
2387 }
2388 else if (jumpType == JumpType_Branch || jumpType == JumpType_BranchFF)
2389 {
2390 STRING_VECTOR refList = m_LogList.m_HashMap[data->m_CommitHash];
2391 for (size_t j = 0; j < refList.size(); ++j)
2392 {
2393 if (refList[j].Left(11) == _T("refs/heads/") || refList[j].Left(13) == _T("refs/remotes/"))
2394 {
2395 found = true;
2396 break;
2397 }
2398 }
2399
2400 if (found && jumpType == JumpType_BranchFF)
2401 found = g_Git.IsFastForward(hashValue, data->m_CommitHash);
2402 }
2403
2404 if (found)
2405 {
2406 m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2407 m_LogList.EnsureVisible(i, FALSE);
2408 m_LogList.SetSelectionMark(i);
2409 return;
2410 }
2411 }
2412
2413 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, _T("NoJumpNotFoundWarning"), IDS_MSGBOX_DONOTSHOWAGAIN);
2414 }
2415
2416 void CLogDlg::OnBnClickedJumpDown()
2417 {
2418 int jumpType = m_JumpType.GetCurSel();
2419 if (jumpType < 0) return;
2420
2421 if (jumpType == JumpType_History)
2422 {
2423 GoForward();
2424 return;
2425 }
2426
2427 CString strValue;
2428 CGitHash hashValue;
2429 int index = -1;
2430 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2431 if (pos)
2432 {
2433 index = m_LogList.GetNextSelectedItem(pos);
2434 if (index == 0) return;
2435
2436 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(index);
2437 if (jumpType == JumpType_AuthorEmail)
2438 strValue = data->GetAuthorEmail();
2439 else if (jumpType == JumpType_CommitterEmail)
2440 strValue = data->GetCommitterEmail();
2441 else if (jumpType == JumpType_Parent1)
2442 {
2443 if (data->m_ParentHash.size() > 0)
2444 hashValue = data->m_ParentHash.at(0);
2445 else
2446 return;
2447 }
2448 else if (jumpType == JumpType_Parent2)
2449 {
2450 if (data->m_ParentHash.size() > 1)
2451 hashValue = data->m_ParentHash.at(1);
2452 else
2453 return;
2454 }
2455 else if (jumpType == JumpType_TagFF)
2456 hashValue = data->m_CommitHash;
2457 else if (jumpType == JumpType_BranchFF)
2458 hashValue = data->m_CommitHash;
2459
2460 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
2461 }
2462 else
2463 return;
2464
2465 while (pos)
2466 {
2467 index = m_LogList.GetNextSelectedItem(pos);
2468 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
2469 }
2470 m_LogList.SetSelectionMark(-1);
2471
2472 for (int i = index + 1; i < m_LogList.GetItemCount(); ++i)
2473 {
2474 bool found = false;
2475 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(i);
2476 if (jumpType == JumpType_AuthorEmail)
2477 found = strValue == data->GetAuthorEmail();
2478 else if (jumpType == JumpType_CommitterEmail)
2479 found = strValue == data->GetCommitterEmail();
2480 else if (jumpType == JumpType_MergePoint)
2481 found = data->ParentsCount() > 1;
2482 else if (jumpType == JumpType_Parent1)
2483 found = data->m_CommitHash == hashValue;
2484 else if (jumpType == JumpType_Parent2)
2485 found = data->m_CommitHash == hashValue;
2486 else if (jumpType == JumpType_Tag || jumpType == JumpType_TagFF)
2487 {
2488 STRING_VECTOR refList = m_LogList.m_HashMap[data->m_CommitHash];
2489 for (size_t j = 0; j < refList.size(); ++j)
2490 {
2491 if (refList[j].Left(10) == _T("refs/tags/"))
2492 {
2493 found = true;
2494 break;
2495 }
2496 }
2497
2498 if (found && jumpType == JumpType_TagFF)
2499 found = g_Git.IsFastForward(data->m_CommitHash, hashValue);
2500 }
2501 else if (jumpType == JumpType_Branch || jumpType == JumpType_BranchFF)
2502 {
2503 STRING_VECTOR refList = m_LogList.m_HashMap[data->m_CommitHash];
2504 for (size_t j = 0; j < refList.size(); ++j)
2505 {
2506 if (refList[j].Left(11) == _T("refs/heads/") || refList[j].Left(13) == _T("refs/remotes/"))
2507 {
2508 found = true;
2509 break;
2510 }
2511 }
2512
2513 if (found && jumpType == JumpType_BranchFF)
2514 found = g_Git.IsFastForward(data->m_CommitHash, hashValue);
2515 }
2516
2517 if (found)
2518 {
2519 m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2520 m_LogList.EnsureVisible(i, FALSE);
2521 m_LogList.SetSelectionMark(i);
2522 return;
2523 }
2524 }
2525
2526 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, _T("NoJumpNotFoundWarning"), IDS_MSGBOX_DONOTSHOWAGAIN);
2527 }
2528
2529 CTGitPathList CLogDlg::GetChangedPathsFromSelectedRevisions(bool /*bRelativePaths*/ /* = false */, bool /*bUseFilter*/ /* = true */)
2530 {
2531 CTGitPathList pathList;
2532 #if 0
2533
2534 if (m_sRepositoryRoot.IsEmpty() && (bRelativePaths == false))
2535 {
2536 m_sRepositoryRoot = GetRepositoryRoot(m_path);
2537 }
2538 if (m_sRepositoryRoot.IsEmpty() && (bRelativePaths == false))
2539 return pathList;
2540
2541 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2542 if (pos != NULL)
2543 {
2544 while (pos)
2545 {
2546 int nextpos = m_LogList.GetNextSelectedItem(pos);
2547 if (nextpos >= m_arShownList.GetCount())
2548 continue;
2549 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(nextpos));
2550 LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;
2551 for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)
2552 {
2553 LogChangedPath * cpath = cpatharray->SafeGetAt(cpPathIndex);
2554 if (cpath == NULL)
2555 continue;
2556 CTGitPath path;
2557 if (!bRelativePaths)
2558 path.SetFromGit(m_sRepositoryRoot);
2559 path.AppendPathString(cpath->sPath);
2560 if ((!bUseFilter)||
2561 ((m_cHidePaths.GetState() & 0x0003)!=BST_CHECKED)||
2562 (cpath->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0))
2563 pathList.AddPath(path);
2564
2565 }
2566 }
2567 }
2568 pathList.RemoveDuplicates();
2569 #endif
2570 return pathList;
2571 }
2572
2573 void CLogDlg::SortByColumn(int /*nSortColumn*/, bool /*bAscending*/)
2574 {
2575 #if 0
2576 switch(nSortColumn)
2577 {
2578 case 0: // Revision
2579 {
2580 if(bAscending)
2581 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscRevSort());
2582 else
2583 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescRevSort());
2584 }
2585 break;
2586 case 1: // action
2587 {
2588 if(bAscending)
2589 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscActionSort());
2590 else
2591 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescActionSort());
2592 }
2593 break;
2594 case 2: // Author
2595 {
2596 if(bAscending)
2597 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscAuthorSort());
2598 else
2599 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescAuthorSort());
2600 }
2601 break;
2602 case 3: // Date
2603 {
2604 if(bAscending)
2605 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscDateSort());
2606 else
2607 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescDateSort());
2608 }
2609 break;
2610 case 4: // Message or bug id
2611 if (m_bShowBugtraqColumn)
2612 {
2613 if(bAscending)
2614 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscBugIDSort());
2615 else
2616 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescBugIDSort());
2617 break;
2618 }
2619 // fall through here
2620 case 5: // Message
2621 {
2622 if(bAscending)
2623 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscMessageSort());
2624 else
2625 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescMessageSort());
2626 }
2627 break;
2628 default:
2629 ATLASSERT(0);
2630 break;
2631 }
2632 #endif
2633 }
2634
2635 void CLogDlg::OnLvnColumnclick(NMHDR *pNMHDR, LRESULT *pResult)
2636 {
2637 if (this->IsThreadRunning())
2638 return; //no sorting while the arrays are filled
2639 #if 0
2640 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
2641 const int nColumn = pNMLV->iSubItem;
2642 m_bAscending = nColumn == m_nSortColumn ? !m_bAscending : TRUE;
2643 m_nSortColumn = nColumn;
2644 SortByColumn(m_nSortColumn, m_bAscending);
2645 SetSortArrow(&m_LogList, m_nSortColumn, !!m_bAscending);
2646 SortShownListArray();
2647 m_LogList.Invalidate();
2648 UpdateLogInfoLabel();
2649 #else
2650 UNREFERENCED_PARAMETER(pNMHDR);
2651 #endif
2652 *pResult = 0;
2653
2654 SetTimer(LOG_HEADER_ORDER_TIMER, 10, nullptr);
2655 }
2656
2657 void CLogDlg::SortShownListArray()
2658 {
2659 // make sure the shown list still matches the filter after sorting.
2660 OnTimer(LOGFILTER_TIMER);
2661 // clear the selection states
2662 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2663 while (pos)
2664 {
2665 m_LogList.SetItemState(m_LogList.GetNextSelectedItem(pos), 0, LVIS_SELECTED);
2666 }
2667 m_LogList.SetSelectionMark(-1);
2668 }
2669
2670 void CLogDlg::SetSortArrow(CListCtrl * control, int nColumn, bool bAscending)
2671 {
2672 if (control == NULL)
2673 return;
2674 // set the sort arrow
2675 CHeaderCtrl * pHeader = control->GetHeaderCtrl();
2676 HDITEM HeaderItem = {0};
2677 HeaderItem.mask = HDI_FORMAT;
2678 for (int i=0; i<pHeader->GetItemCount(); ++i)
2679 {
2680 pHeader->GetItem(i, &HeaderItem);
2681 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
2682 pHeader->SetItem(i, &HeaderItem);
2683 }
2684 if (nColumn >= 0)
2685 {
2686 pHeader->GetItem(nColumn, &HeaderItem);
2687 HeaderItem.fmt |= (bAscending ? HDF_SORTUP : HDF_SORTDOWN);
2688 pHeader->SetItem(nColumn, &HeaderItem);
2689 }
2690 }
2691
2692 int CLogDlg::m_nSortColumnPathList = 0;
2693 bool CLogDlg::m_bAscendingPathList = false;
2694
2695 void CLogDlg::OnBnClickedHidepaths()
2696 {
2697 FillLogMessageCtrl();
2698 m_ChangedFileListCtrl.Invalidate();
2699 }
2700
2701 void CLogDlg::UpdateLogInfoLabel()
2702 {
2703
2704 CGitHash rev1 ;
2705 CGitHash rev2 ;
2706 long selectedrevs = 0;
2707 long selectedfiles = 0;
2708 int count = (int)m_LogList.m_arShownList.GetCount();
2709 int start = 0;
2710 if (count)
2711 {
2712 rev1 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(0)))->m_CommitHash;
2713 if(this->m_LogList.m_bShowWC && rev1.IsEmpty()&&(count>1))
2714 start = 1;
2715 rev1 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(start)))->m_CommitHash;
2716 //pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_arShownList.GetCount()-1));
2717 rev2 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(count-1)))->m_CommitHash;
2718 selectedrevs = m_LogList.GetSelectedCount();
2719 if (selectedrevs)
2720 selectedfiles = m_ChangedFileListCtrl.GetSelectedCount();
2721 }
2722 CString sTemp;
2723 sTemp.Format(IDS_PROC_LOG_STATS,
2724 count - start,
2725 rev2.ToString().Left(g_Git.GetShortHASHLength()), rev1.ToString().Left(g_Git.GetShortHASHLength()), selectedrevs, selectedfiles);
2726
2727 if(selectedrevs == 1)
2728 {
2729 CString str=m_ChangedFileListCtrl.GetStatisticsString(true);
2730 str.Replace(_T('\n'), _T(' '));
2731 sTemp += _T("\r\n") + str;
2732 }
2733 m_sLogInfo = sTemp;
2734
2735 UpdateData(FALSE);
2736 }
2737
2738 void CLogDlg::OnDtnDropdownDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2739 {
2740 // the date control should not show the "today" button
2741 CMonthCalCtrl * pCtrl = m_DateFrom.GetMonthCalCtrl();
2742 if (pCtrl)
2743 SetWindowLongPtr(pCtrl->GetSafeHwnd(), GWL_STYLE, LONG_PTR(pCtrl->GetStyle() | MCS_NOTODAY));
2744 *pResult = 0;
2745 }
2746
2747 void CLogDlg::OnDtnDropdownDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2748 {
2749 // the date control should not show the "today" button
2750 CMonthCalCtrl * pCtrl = m_DateTo.GetMonthCalCtrl();
2751 if (pCtrl)
2752 SetWindowLongPtr(pCtrl->GetSafeHwnd(), GWL_STYLE, LONG_PTR(pCtrl->GetStyle() | MCS_NOTODAY));
2753 *pResult = 0;
2754 }
2755
2756 void CLogDlg::OnSize(UINT nType, int cx, int cy)
2757 {
2758 __super::OnSize(nType, cx, cy);
2759 //set range
2760 SetSplitterRange();
2761 }
2762
2763 void CLogDlg::OnRefresh()
2764 {
2765 {
2766 m_limit = 0;
2767 this->m_LogProgress.SetPos(0);
2768
2769 Refresh (false);
2770 }
2771 }
2772
2773 void CLogDlg::OnFocusFilter()
2774 {
2775 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2776 }
2777
2778 void CLogDlg::OnEditCopy()
2779 {
2780 if (GetFocus() == &m_ChangedFileListCtrl)
2781 CopyChangedSelectionToClipBoard();
2782 else
2783 m_LogList.CopySelectionToClipBoard();
2784 }
2785
2786 CString CLogDlg::GetAbsoluteUrlFromRelativeUrl(const CString& url)
2787 {
2788 // is the URL a relative one?
2789 if (url.Left(2).Compare(_T("^/")) == 0)
2790 {
2791 // URL is relative to the repository root
2792 CString url1 = m_sRepositoryRoot + url.Mid(1);
2793 TCHAR buf[INTERNET_MAX_URL_LENGTH] = { 0 };
2794 DWORD len = url.GetLength();
2795 if (UrlCanonicalize((LPCTSTR)url1, buf, &len, 0) == S_OK)
2796 return CString(buf, len);
2797 return url1;
2798 }
2799 else if (url[0] == '/')
2800 {
2801 // URL is relative to the server's hostname
2802 CString sHost;
2803 // find the server's hostname
2804 int schemepos = m_sRepositoryRoot.Find(_T("//"));
2805 if (schemepos >= 0)
2806 {
2807 sHost = m_sRepositoryRoot.Left(m_sRepositoryRoot.Find('/', schemepos+3));
2808 CString url1 = sHost + url;
2809 TCHAR buf[INTERNET_MAX_URL_LENGTH] = { 0 };
2810 DWORD len = url.GetLength();
2811 if (UrlCanonicalize((LPCTSTR)url, buf, &len, 0) == S_OK)
2812 return CString(buf, len);
2813 return url1;
2814 }
2815 }
2816 return url;
2817 }
2818
2819 void CLogDlg::ShowGravatar()
2820 {
2821 m_gravatar.EnableGravatar(m_bShowGravatar);
2822 RemoveAnchor(IDC_MSGVIEW);
2823 if (m_gravatar.IsGravatarEnabled())
2824 {
2825 RECT rect, rect2;
2826 GetDlgItem(IDC_MSGVIEW)->GetWindowRect(&rect);
2827 ScreenToClient(&rect);
2828 m_gravatar.GetWindowRect(&rect2);
2829 ScreenToClient(&rect2);
2830 rect.right = rect2.left;
2831 GetDlgItem(IDC_MSGVIEW)->MoveWindow(&rect);
2832 m_gravatar.ShowWindow(SW_SHOW);
2833 }
2834 else
2835 {
2836 RECT rect, rect2;
2837 GetDlgItem(IDC_MSGVIEW)->GetWindowRect(&rect);
2838 ScreenToClient(&rect);
2839 m_gravatar.GetWindowRect(&rect2);
2840 ScreenToClient(&rect2);
2841 rect.right = rect2.right;
2842 GetDlgItem(IDC_MSGVIEW)->MoveWindow(&rect);
2843 m_gravatar.ShowWindow(SW_HIDE);
2844 }
2845 AddAnchor(IDC_MSGVIEW, MIDDLE_LEFT, MIDDLE_RIGHT); // keep in sync with AddMainAnchors
2846 }
2847
2848
2849 void CLogDlg::OnEnChangeSearchedit()
2850 {
2851 UpdateData();
2852 if (!m_LogList.HasFilterText())
2853 {
2854 CStoreSelection storeselection(this);
2855 // clear the filter, i.e. make all entries appear
2856 theApp.DoWaitCursor(1);
2857 KillTimer(LOGFILTER_TIMER);
2858 FillLogMessageCtrl(false);
2859
2860 Refresh();
2861 //m_LogList.StartFilter();
2862 #if 0
2863 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2864 m_arShownList.RemoveAll();
2865 for (DWORD i=0; i<m_logEntries.size(); ++i)
2866 {
2867 if (IsEntryInDateRange(i))
2868 m_arShownList.Add(m_logEntries[i]);
2869 }
2870 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2871 m_LogList.DeleteAllItems();
2872 m_LogList.SetItemCountEx(ShownCountWithStopped());
2873 m_LogList.RedrawItems(0, ShownCountWithStopped());
2874 m_LogList.SetRedraw(false);
2875 ResizeAllListCtrlCols();
2876 m_LogList.SetRedraw(true);
2877 #endif
2878 theApp.DoWaitCursor(-1);
2879 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
2880 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
2881 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2882 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty()))));
2883 return;
2884 }
2885 if (Validate(m_LogList.m_sFilterText))
2886 SetTimer(LOGFILTER_TIMER, 1000, NULL);
2887 else
2888 KillTimer(LOGFILTER_TIMER);
2889
2890 }
2891
2892 void CLogDlg::OnBnClickedAllBranch()
2893 {
2894 // m_bAllBranch is not auto-toggled by MFC, we have to handle it manually (in order to prevent the indeterminate state)
2895
2896 m_LogList.m_ShowMask &=~ (CGit::LOG_INFO_LOCAL_BRANCHES | CGit::LOG_INFO_ALL_BRANCH);
2897
2898 if (m_bAllBranch)
2899 {
2900 m_bAllBranch = BST_UNCHECKED;
2901 m_ChangedFileListCtrl.m_sDisplayedBranch = m_LogList.GetRange();
2902 }
2903 else
2904 {
2905 m_bAllBranch = BST_CHECKED;
2906 m_LogList.m_ShowMask|=CGit::LOG_INFO_ALL_BRANCH;
2907 m_ChangedFileListCtrl.m_sDisplayedBranch.Empty();
2908 }
2909
2910 // need to save value here, so that log dialogs started from now on also have AllBranch activated
2911 m_regbAllBranch = m_bAllBranch;
2912
2913 UpdateData(FALSE);
2914
2915 OnRefresh();
2916
2917 FillLogMessageCtrl(false);
2918 }
2919
2920 void CLogDlg::OnBnClickedFollowRenames()
2921 {
2922 if(m_bFollowRenames)
2923 {
2924 m_LogList.m_ShowMask |= CGit::LOG_INFO_FOLLOW;
2925 m_LogList.m_ShowMask &=~ CGit::LOG_INFO_LOCAL_BRANCHES;
2926 if (m_bAllBranch)
2927 {
2928
2929 m_bAllBranch = FALSE;
2930 m_LogList.m_ShowMask &=~ CGit::LOG_INFO_ALL_BRANCH;
2931 }
2932
2933 }
2934 else
2935 m_LogList.m_ShowMask &= ~CGit::LOG_INFO_FOLLOW;
2936
2937 DialogEnableWindow(IDC_LOG_ALLBRANCH, !m_bFollowRenames);
2938 DialogEnableWindow(IDC_WHOLE_PROJECT, !m_bFollowRenames && !m_path.IsEmpty());
2939
2940 OnRefresh();
2941
2942 FillLogMessageCtrl(false);
2943 }
2944
2945 void CLogDlg::HandleShowLabels(bool var, int flag)
2946 {
2947 if (var)
2948 m_LogList.m_ShowRefMask |= flag;
2949 else
2950 m_LogList.m_ShowRefMask &= ~flag;
2951
2952 if ((m_LogList.m_ShowFilter & CGitLogListBase::FILTERSHOW_REFS) && !(m_LogList.m_ShowFilter & CGitLogListBase::FILTERSHOW_ANYCOMMIT))
2953 {
2954 // Remove commits where labels are not shown.
2955 OnRefresh();
2956 FillLogMessageCtrl(false);
2957 }
2958 else
2959 {
2960 // Just redraw
2961 m_LogList.Invalidate();
2962 }
2963 }
2964
2965 void CLogDlg::OnBnClickedCompressedGraph()
2966 {
2967 UpdateData();
2968
2969 if (m_iCompressedGraph == 2)
2970 m_LogList.m_ShowFilter = CGitLogListBase::FILTERSHOW_REFS;
2971 else if (m_iCompressedGraph == 1)
2972 m_LogList.m_ShowFilter = static_cast<CGitLogListBase::FilterShow>(CGitLogListBase::FILTERSHOW_REFS | CGitLogListBase::FILTERSHOW_MERGEPOINTS);
2973 else
2974 m_LogList.m_ShowFilter = CGitLogListBase::FILTERSHOW_ALL;
2975
2976 OnRefresh();
2977 FillLogMessageCtrl(false);
2978 }
2979
2980 void CLogDlg::OnBnClickedBrowseRef()
2981 {
2982 CString newRef = CBrowseRefsDlg::PickRef(false, m_LogList.GetRange(), gPickRef_All, true);
2983 if(newRef.IsEmpty())
2984 return;
2985
2986 m_History.AddEntry(newRef);
2987 m_History.Save();
2988
2989 SetRange(newRef);
2990
2991 m_LogList.m_ShowMask &= ~(CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_LOCAL_BRANCHES);
2992 m_bAllBranch = BST_UNCHECKED;
2993 UpdateData(FALSE);
2994
2995 OnRefresh();
2996 FillLogMessageCtrl(false);
2997 }
2998
2999 void CLogDlg::ShowStartRef()
3000 {
3001 //Show ref name on top
3002 if(!::IsWindow(m_hWnd))
3003 return;
3004 if (m_LogList.m_ShowMask & (CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_LOCAL_BRANCHES))
3005 {
3006 switch (m_LogList.m_ShowMask & (CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_LOCAL_BRANCHES))
3007 {
3008 case CGit::LOG_INFO_ALL_BRANCH:
3009 m_staticRef.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_LOG_ALLBRANCHES)));
3010 break;
3011
3012 case CGit::LOG_INFO_LOCAL_BRANCHES:
3013 m_staticRef.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_LOG_LOCAL_BRANCHES)));
3014 break;
3015 }
3016
3017 m_staticRef.Invalidate(TRUE);
3018 m_tooltips.DelTool(GetDlgItem(IDC_STATIC_REF));
3019 return;
3020 }
3021
3022 CString showStartRef = m_LogList.GetRange();
3023 if (showStartRef.IsEmpty() || showStartRef == _T("HEAD"))
3024 {
3025 showStartRef.Empty();
3026 //Ref name is HEAD
3027 if (g_Git.Run(L"git.exe symbolic-ref HEAD", &showStartRef, NULL, CP_UTF8))
3028 showStartRef = CString(MAKEINTRESOURCE(IDS_PROC_LOG_NOBRANCH));
3029 showStartRef.Trim(L"\r\n\t ");
3030 }
3031
3032
3033 showStartRef = g_Git.StripRefName(showStartRef);
3034
3035 m_staticRef.SetWindowText(showStartRef);
3036 CWnd *pWnd = GetDlgItem(IDC_STATIC_REF);
3037 m_tooltips.AddTool(pWnd, showStartRef);
3038 m_staticRef.Invalidate(TRUE);
3039 }
3040
3041 void CLogDlg::SetRange(const CString& range)
3042 {
3043 m_LogList.SetRange(range);
3044 m_ChangedFileListCtrl.m_sDisplayedBranch = range;
3045
3046 ShowStartRef();
3047 }
3048
3049 static void AppendMenuChecked(CMenu &menu, UINT nTextID, UINT_PTR nItemID, BOOL checked = FALSE, BOOL enabled = TRUE)
3050 {
3051 CString text;
3052 text.LoadString(nTextID);
3053 menu.AppendMenu(MF_STRING | (enabled ? MF_ENABLED : MF_DISABLED) | (checked ? MF_CHECKED : MF_UNCHECKED), nItemID, text);
3054 }
3055
3056 #define WALKBEHAVIOUR_FIRSTPARENT 1
3057 #define WALKBEHAVIOUR_FOLLOWRENAMES 2
3058 #define WALKBEHAVIOUR_COMPRESSEDGRAPH 3
3059 #define WALKBEHAVIOUR_LABELEDCOMMITS 4
3060 #define WALKBEHAVIOUR_NOMERGES 5
3061
3062 void CLogDlg::OnBnClickedWalkBehaviour()
3063 {
3064 CMenu popup;
3065 if (popup.CreatePopupMenu())
3066 {
3067 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_FIRSTPARENT, WALKBEHAVIOUR_FIRSTPARENT, m_bFirstParent);
3068 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_NOMERGES, WALKBEHAVIOUR_NOMERGES, m_bNoMerges);
3069 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_FOLLOWRENAMES, WALKBEHAVIOUR_FOLLOWRENAMES, m_bFollowRenames, !(m_path.IsEmpty() || m_path.IsDirectory()));
3070 popup.AppendMenu(MF_SEPARATOR, NULL);
3071 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_COMPRESSED, WALKBEHAVIOUR_COMPRESSEDGRAPH, m_iCompressedGraph == 1);
3072 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_LABELEDCOMMITS, WALKBEHAVIOUR_LABELEDCOMMITS, m_iCompressedGraph == 2);
3073
3074 m_tooltips.Pop();
3075 RECT rect;
3076 GetDlgItem(IDC_WALKBEHAVIOUR)->GetWindowRect(&rect);
3077 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, rect.left, rect.top, this, 0);
3078 switch (selection)
3079 {
3080 case WALKBEHAVIOUR_FIRSTPARENT:
3081 m_bFirstParent = !m_bFirstParent;
3082 OnBnClickedFirstParent();
3083 break;
3084 case WALKBEHAVIOUR_NOMERGES:
3085 m_bNoMerges = !m_bNoMerges;
3086 OnBnClickedFirstParent(); // OnBnClickedFirstParent handles both cases: m_bFirstParent and m_bNoMerges
3087 break;
3088 case WALKBEHAVIOUR_FOLLOWRENAMES:
3089 m_bFollowRenames = !m_bFollowRenames;
3090 OnBnClickedFollowRenames();
3091 break;
3092 case WALKBEHAVIOUR_COMPRESSEDGRAPH:
3093 m_iCompressedGraph = (m_iCompressedGraph == 1 ? 0 : 1);
3094 OnBnClickedCompressedGraph();
3095 break;
3096 case WALKBEHAVIOUR_LABELEDCOMMITS:
3097 m_iCompressedGraph = (m_iCompressedGraph == 2 ? 0 : 2);
3098 OnBnClickedCompressedGraph();
3099 break;
3100 default:
3101 break;
3102 }
3103 m_bWalkBehavior = (m_bFirstParent || m_bNoMerges || m_bFollowRenames || m_iCompressedGraph);
3104 UpdateData(FALSE);
3105 }
3106 }
3107
3108 #define VIEW_HIDEPATHS 1
3109 #define VIEW_GRAYPATHS 2
3110 #define VIEW_SHOWTAGS 3
3111 #define VIEW_SHOWLOCALBRANCHES 4
3112 #define VIEW_SHOWREMOTEBRANCHES 5
3113 #define VIEW_SHOWGRAVATAR 6
3114 #define VIEW_SHOWPATCH 7
3115
3116 void CLogDlg::OnBnClickedView()
3117 {
3118 CMenu popup;
3119 if (popup.CreatePopupMenu())
3120 {
3121 AppendMenuChecked(popup, IDS_SHOWFILES_HIDEPATHS, VIEW_HIDEPATHS, m_iHidePaths == 1);
3122 AppendMenuChecked(popup, IDS_SHOWFILES_GRAYPATHS, VIEW_GRAYPATHS, m_iHidePaths == 2);
3123 popup.AppendMenu(MF_SEPARATOR, NULL);
3124 CMenu showLabelsMenu;
3125 if (showLabelsMenu.CreatePopupMenu())
3126 {
3127 AppendMenuChecked(showLabelsMenu, IDS_VIEW_SHOWTAGLABELS, VIEW_SHOWTAGS, m_bShowTags);
3128 AppendMenuChecked(showLabelsMenu, IDS_VIEW_SHOWLOCALBRANCHLABELS, VIEW_SHOWLOCALBRANCHES, m_bShowLocalBranches);
3129 AppendMenuChecked(showLabelsMenu, IDS_VIEW_SHOWREMOTEBRANCHLABELS, VIEW_SHOWREMOTEBRANCHES, m_bShowRemoteBranches);
3130 popup.AppendMenu(MF_STRING | MF_POPUP, (UINT_PTR)showLabelsMenu.m_hMenu, (CString)MAKEINTRESOURCE(IDS_VIEW_LABELS));
3131 }
3132 popup.AppendMenu(MF_SEPARATOR, NULL);
3133 AppendMenuChecked(popup, IDS_VIEW_SHOWGRAVATAR, VIEW_SHOWGRAVATAR, m_bShowGravatar);
3134 AppendMenuChecked(popup, IDS_MENU_VIEWPATCH, VIEW_SHOWPATCH, IsWindow(this->m_patchViewdlg.m_hWnd));
3135
3136 m_tooltips.Pop();
3137 RECT rect;
3138 GetDlgItem(IDC_VIEW)->GetWindowRect(&rect);
3139 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, rect.left, rect.top, this, 0);
3140 switch (selection)
3141 {
3142 case VIEW_HIDEPATHS:
3143 if (m_iHidePaths == 1)
3144 m_iHidePaths = 0;
3145 else
3146 m_iHidePaths = 1;
3147 OnBnClickedHidepaths();
3148 break;
3149 case VIEW_GRAYPATHS:
3150 if (m_iHidePaths == 2)
3151 m_iHidePaths = 0;
3152 else
3153 m_iHidePaths = 2;
3154 OnBnClickedHidepaths();
3155 break;
3156 case VIEW_SHOWTAGS:
3157 m_bShowTags = !m_bShowTags;
3158 HandleShowLabels(m_bShowTags, LOGLIST_SHOWTAGS);
3159 break;
3160 case VIEW_SHOWLOCALBRANCHES:
3161 m_bShowLocalBranches = !m_bShowLocalBranches;
3162 HandleShowLabels(m_bShowLocalBranches, LOGLIST_SHOWLOCALBRANCHES);
3163 break;
3164 case VIEW_SHOWREMOTEBRANCHES:
3165 m_bShowRemoteBranches = !m_bShowRemoteBranches;
3166 HandleShowLabels(m_bShowRemoteBranches, LOGLIST_SHOWREMOTEBRANCHES);
3167 break;
3168 case VIEW_SHOWGRAVATAR:
3169 {
3170 m_bShowGravatar = !m_bShowGravatar;
3171 ShowGravatar();
3172 m_gravatar.Init();
3173 CString email;
3174 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
3175 if (pos)
3176 {
3177 int selIndex = m_LogList.GetNextSelectedItem(pos);
3178 int moreSel = m_LogList.GetNextSelectedItem(pos);
3179 if (moreSel < 0)
3180 {
3181 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(selIndex));
3182 if (pLogEntry)
3183 email = pLogEntry->GetAuthorEmail();
3184 }
3185 }
3186 m_gravatar.LoadGravatar(email);
3187 break;
3188 }
3189 case VIEW_SHOWPATCH:
3190 TogglePatchView();
3191 break;
3192 default:
3193 break;
3194 }
3195 }
3196 }
3197
3198 void CLogDlg::OnBnClickedFirstParent()
3199 {
3200 if(this->m_bFirstParent)
3201 m_LogList.m_ShowMask|=CGit::LOG_INFO_FIRST_PARENT;
3202 else
3203 m_LogList.m_ShowMask&=~CGit::LOG_INFO_FIRST_PARENT;
3204
3205 if (m_bNoMerges)
3206 m_LogList.m_ShowMask |= CGit::LOG_INFO_NO_MERGE;
3207 else
3208 m_LogList.m_ShowMask &= ~CGit::LOG_INFO_NO_MERGE;
3209
3210 OnRefresh();
3211
3212 FillLogMessageCtrl(false);
3213
3214 }
3215
3216 void CLogDlg::OnBnClickShowWholeProject()
3217 {
3218 this->UpdateData();
3219
3220 if(this->m_bWholeProject)
3221 {
3222 m_LogList.m_Path.Reset();
3223 SetDlgTitle();
3224 }
3225 else
3226 m_LogList.m_Path=m_path;
3227
3228 m_regShowWholeProject = m_bWholeProject;
3229
3230 SetDlgTitle();
3231
3232 OnRefresh();
3233
3234 FillLogMessageCtrl(false);
3235
3236 }
3237
3238 LRESULT CLogDlg::OnRefLogChanged(WPARAM /*wParam*/, LPARAM /*lParam*/)
3239 {
3240 ShowStartRef();
3241 return 0;
3242 }
3243
3244 LRESULT CLogDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
3245 {
3246 m_pTaskbarList.Release();
3247 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
3248 SetUUIDOverlayIcon(m_hWnd);
3249 return 0;
3250 }
3251
3252 LRESULT CLogDlg::OnRefreshSelection(WPARAM /*wParam*/, LPARAM /*lParam*/)
3253 {
3254 // it's enough to deselect, then select again one item of the whole selection
3255 int selMark = m_LogList.GetSelectionMark();
3256 if (selMark >= 0)
3257 {
3258 m_LogList.SetSelectionMark(selMark);
3259 m_LogList.SetItemState(selMark, 0, LVIS_SELECTED);
3260 m_LogList.SetItemState(selMark, LVIS_SELECTED, LVIS_SELECTED);
3261 }
3262 return 0;
3263 }
Windows Explorer Extension to Operate Git