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