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