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