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