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