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