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