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