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