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