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