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