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