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