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