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