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