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