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