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