?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

fdb2e782246894c5faffdda8cf737d48ec2ddc8d
[TortoiseGit.git] / src / TortoiseProc / LogDlg.cpp
blobfdb2e782246894c5faffdda8cf737d48ec2ddc8d
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2003-2008 - TortoiseSVN
4 // Copyright (C) 2008-2013 - 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 "InputDlg.h"
24 #include "GITProgressDlg.h"
25 #include "ProgressDlg.h"
26 //#include "CopyDlg.h"
27 #include "StatGraphDlg.h"
28 #include "Logdlg.h"
29 #include "MessageBox.h"
30 #include "registry.h"
31 #include "AppUtils.h"
32 #include "PathUtils.h"
33 #include "StringUtils.h"
34 #include "UnicodeUtils.h"
35 #include "TempFile.h"
36 //#include "GitInfo.h"
37 //#include "GitDiff.h"
38 #include "IconMenu.h"
39 //#include "BrowseFolder.h"
40 //#include "GitHelpers.h"
41 #include "GitStatus.h"
42 //#include "LogDlgHelper.h"
43 //#include "CachedLogInfo.h"
44 #include "FileDiffDlg.h"
45 #include "BrowseRefsDlg.h"
46 #include "SmartHandle.h"
47
48 IMPLEMENT_DYNAMIC(CLogDlg, CResizableStandAloneDialog)
49 CLogDlg::CLogDlg(CWnd* pParent /*=NULL*/)
50 : CResizableStandAloneDialog(CLogDlg::IDD, pParent)
51 , m_wParam(0)
52 , m_currentChangedArray(NULL)
53 , m_nSortColumn(0)
54 , m_bFollowRenames(FALSE)
55 , m_bSelect(false)
56 , m_bShowTags(TRUE)
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 str = CString(_T("Software\\TortoiseGit\\LogDialog\\ShowTags\\")) + str;
84 m_regbShowTags = CRegDWORD(str, TRUE);
85 m_bShowTags = m_regbShowTags;
86
87 m_bFirstParent=FALSE;
88 m_bWholeProject=FALSE;
89
90 m_bShowUnversioned = CRegDWORD(_T("Software\\TortoiseGit\\AddBeforeCommit"), TRUE);
91 }
92
93 CLogDlg::~CLogDlg()
94 {
95
96 m_regbAllBranch=m_bAllBranch;
97 m_regbShowTags = m_bShowTags;
98
99 m_CurrentFilteredChangedArray.RemoveAll();
100
101 }
102
103 void CLogDlg::DoDataExchange(CDataExchange* pDX)
104 {
105 CResizableStandAloneDialog::DoDataExchange(pDX);
106 DDX_Control(pDX, IDC_LOGLIST, m_LogList);
107 DDX_Control(pDX, IDC_LOGMSG, m_ChangedFileListCtrl);
108 DDX_Control(pDX, IDC_PROGRESS, m_LogProgress);
109 DDX_Control(pDX, IDC_SPLITTERTOP, m_wndSplitter1);
110 DDX_Control(pDX, IDC_SPLITTERBOTTOM, m_wndSplitter2);
111 DDX_Text(pDX, IDC_SEARCHEDIT, m_LogList.m_sFilterText);
112 DDX_Control(pDX, IDC_DATEFROM, m_DateFrom);
113 DDX_Control(pDX, IDC_DATETO, m_DateTo);
114 DDX_Control(pDX, IDC_LOG_JUMPTYPE, m_JumpType);
115 DDX_Control(pDX, IDC_LOG_JUMPUP, m_JumpUp);
116 DDX_Control(pDX, IDC_LOG_JUMPDOWN, m_JumpDown);
117 DDX_Control(pDX, IDC_HIDEPATHS, m_cHidePaths);
118 DDX_Text(pDX, IDC_LOGINFO, m_sLogInfo);
119 DDX_Check(pDX, IDC_LOG_FIRSTPARENT, m_bFirstParent);
120 DDX_Check(pDX, IDC_LOG_ALLBRANCH,m_bAllBranch);
121 DDX_Check(pDX, IDC_LOG_FOLLOWRENAMES, m_bFollowRenames);
122 DDX_Check(pDX, IDC_SHOWWHOLEPROJECT,m_bWholeProject);
123 DDX_Check(pDX, IDC_LOG_SHOWTAGS, m_bShowTags);
124 DDX_Control(pDX, IDC_SEARCHEDIT, m_cFilter);
125 DDX_Control(pDX, IDC_STATIC_REF, m_staticRef);
126 }
127
128 BEGIN_MESSAGE_MAP(CLogDlg, CResizableStandAloneDialog)
129 ON_WM_CONTEXTMENU()
130 ON_WM_SETCURSOR()
131 ON_BN_CLICKED(IDHELP, OnBnClickedHelp)
132 ON_NOTIFY(LVN_ITEMCHANGED, IDC_LOGLIST, OnLvnItemchangedLoglist)
133 ON_NOTIFY(EN_LINK, IDC_MSGVIEW, OnEnLinkMsgview)
134 ON_BN_CLICKED(IDC_STATBUTTON, OnBnClickedStatbutton)
135
136 ON_MESSAGE(WM_FILTEREDIT_INFOCLICKED, OnClickedInfoIcon)
137 ON_MESSAGE(WM_FILTEREDIT_CANCELCLICKED, OnClickedCancelFilter)
138
139 ON_MESSAGE(MSG_LOAD_PERCENTAGE,OnLogListLoading)
140
141 ON_EN_CHANGE(IDC_SEARCHEDIT, OnEnChangeSearchedit)
142 ON_WM_TIMER()
143 ON_NOTIFY(DTN_DATETIMECHANGE, IDC_DATETO, OnDtnDatetimechangeDateto)
144 ON_NOTIFY(DTN_DATETIMECHANGE, IDC_DATEFROM, OnDtnDatetimechangeDatefrom)
145 ON_CBN_SELCHANGE(IDC_LOG_JUMPTYPE, &CLogDlg::OnCbnSelchangeJumpType)
146 ON_COMMAND(IDC_LOG_JUMPUP, &CLogDlg::OnBnClickedJumpUp)
147 ON_COMMAND(IDC_LOG_JUMPDOWN, &CLogDlg::OnBnClickedJumpDown)
148 ON_BN_CLICKED(IDC_SHOWWHOLEPROJECT, OnBnClickShowWholeProject)
149 ON_NOTIFY(LVN_COLUMNCLICK,IDC_LOGLIST, OnLvnColumnclick)
150 ON_BN_CLICKED(IDC_HIDEPATHS, OnBnClickedHidepaths)
151 ON_COMMAND(MSG_FETCHED_DIFF, OnBnClickedHidepaths)
152 ON_BN_CLICKED(IDC_LOG_ALLBRANCH, OnBnClickedAllBranch)
153 ON_BN_CLICKED(IDC_LOG_FOLLOWRENAMES, OnBnClickedFollowRenames)
154 ON_BN_CLICKED(IDC_LOG_SHOWTAGS, OnBnClickedShowTags)
155
156 ON_NOTIFY(DTN_DROPDOWN, IDC_DATEFROM, &CLogDlg::OnDtnDropdownDatefrom)
157 ON_NOTIFY(DTN_DROPDOWN, IDC_DATETO, &CLogDlg::OnDtnDropdownDateto)
158 ON_WM_SIZE()
159 ON_BN_CLICKED(IDC_LOG_FIRSTPARENT, &CLogDlg::OnBnClickedFirstParent)
160 ON_BN_CLICKED(IDC_REFRESH, &CLogDlg::OnBnClickedRefresh)
161 ON_STN_CLICKED(IDC_STATIC_REF, &CLogDlg::OnBnClickedBrowseRef)
162 ON_COMMAND(ID_LOGDLG_REFRESH, &CLogDlg::OnBnClickedRefresh)
163 ON_COMMAND(ID_LOGDLG_FIND, &CLogDlg::OnFind)
164 ON_COMMAND(ID_LOGDLG_FOCUSFILTER, &CLogDlg::OnFocusFilter)
165 ON_COMMAND(ID_EDIT_COPY, &CLogDlg::OnEditCopy)
166 ON_MESSAGE(MSG_REFLOG_CHANGED, OnRefLogChanged)
167 ON_REGISTERED_MESSAGE(WM_TASKBARBTNCREATED, OnTaskbarBtnCreated)
168 END_MESSAGE_MAP()
169
170 enum JumpType
171 {
172 JumpType_AuthorEmail,
173 JumpType_CommitterEmail,
174 JumpType_MergePoint,
175 JumpType_Parent1,
176 JumpType_Parent2,
177 JumpType_Tag,
178 JumpType_TagFF
179 };
180
181 void CLogDlg::SetParams(const CTGitPath& orgPath, const CTGitPath& path, CString hightlightRevision, CString startrev, CString endrev, int limit /* = FALSE */)
182 {
183 m_orgPath = orgPath;
184 m_path = path;
185 m_hightlightRevision = hightlightRevision;
186
187 if (startrev == GIT_REV_ZERO)
188 startrev.Empty();
189 if (endrev == GIT_REV_ZERO)
190 endrev.Empty();
191
192 this->m_LogList.m_startrev = startrev;
193 m_LogRevision = startrev;
194 this->m_LogList.m_endrev = endrev;
195
196 if(!endrev.IsEmpty())
197 this->SetStartRef(endrev);
198
199 m_limit = limit;
200 if (::IsWindow(m_hWnd))
201 UpdateData(FALSE);
202 }
203
204 void CLogDlg::SetFilter(const CString& findstr, LONG findtype, bool findregex)
205 {
206 m_LogList.m_sFilterText = findstr;
207 if (findtype)
208 m_LogList.m_SelectedFilters = findtype;
209 m_LogList.m_bFilterWithRegex = m_bFilterWithRegex = findregex;
210 }
211
212 BOOL CLogDlg::OnInitDialog()
213 {
214 CString temp;
215 CResizableStandAloneDialog::OnInitDialog();
216 CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
217
218 // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
219 // do this, Explorer would be unable to send that message to our window if we
220 // were running elevated. It's OK to make the call all the time, since if we're
221 // not elevated, this is a no-op.
222 CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
223 typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
224 CAutoLibrary hUser = AtlLoadSystemLibraryUsingFullPath(_T("user32.dll"));
225 if (hUser)
226 {
227 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
228 if (pfnChangeWindowMessageFilterEx)
229 {
230 pfnChangeWindowMessageFilterEx(m_hWnd, WM_TASKBARBTNCREATED, MSGFLT_ALLOW, &cfs);
231 }
232 }
233 m_pTaskbarList.Release();
234 if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
235 m_pTaskbarList = nullptr;
236
237 m_hAccel = LoadAccelerators(AfxGetResourceHandle(),MAKEINTRESOURCE(IDR_ACC_LOGDLG));
238
239 // use the state of the "stop on copy/rename" option from the last time
240 UpdateData(FALSE);
241
242 // set the font to use in the log message view, configured in the settings dialog
243 CAppUtils::CreateFontForLogs(m_logFont);
244 GetDlgItem(IDC_MSGVIEW)->SetFont(&m_logFont);
245 // automatically detect URLs in the log message and turn them into links
246 GetDlgItem(IDC_MSGVIEW)->SendMessage(EM_AUTOURLDETECT, TRUE, NULL);
247 // make the log message rich edit control send a message when the mouse pointer is over a link
248 GetDlgItem(IDC_MSGVIEW)->SendMessage(EM_SETEVENTMASK, NULL, ENM_LINK);
249 //m_LogList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER | LVS_EX_SUBITEMIMAGES);
250
251 // the "hide unrelated paths" checkbox should be indeterminate
252 m_cHidePaths.SetCheck(BST_INDETERMINATE);
253
254
255 //SetWindowTheme(m_LogList.GetSafeHwnd(), L"Explorer", NULL);
256 //SetWindowTheme(m_ChangedFileListCtrl.GetSafeHwnd(), L"Explorer", NULL);
257
258 // set up the columns
259 m_LogList.DeleteAllItems();
260
261 m_LogList.m_Path=m_path;
262 m_LogList.m_hasWC = m_LogList.m_bShowWC = !g_GitAdminDir.IsBareRepo(g_Git.m_CurrentDir);
263 m_LogList.InsertGitColumn();
264
265 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);
266
267 GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);
268
269 SetDlgTitle();
270
271 m_tooltips.Create(this);
272 CheckRegexpTooltip();
273
274 SetSplitterRange();
275
276 // the filter control has a 'cancel' button (the red 'X'), we need to load its bitmap
277 m_cFilter.SetCancelBitmaps(IDI_CANCELNORMAL, IDI_CANCELPRESSED);
278 m_cFilter.SetInfoIcon(IDI_LOGFILTER);
279 m_cFilter.SetValidator(this);
280
281 AdjustControlSize(IDC_HIDEPATHS);
282 AdjustControlSize(IDC_LOG_FIRSTPARENT);
283 AdjustControlSize(IDC_LOG_ALLBRANCH);
284 AdjustControlSize(IDC_SHOWWHOLEPROJECT);
285 AdjustControlSize(IDC_LOG_FOLLOWRENAMES);
286 AdjustControlSize(IDC_LOG_SHOWTAGS);
287
288 GetClientRect(m_DlgOrigRect);
289 m_LogList.GetClientRect(m_LogListOrigRect);
290 GetDlgItem(IDC_MSGVIEW)->GetClientRect(m_MsgViewOrigRect);
291 m_ChangedFileListCtrl.GetClientRect(m_ChgOrigRect);
292
293 m_DateFrom.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);
294 m_DateTo.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);
295
296 m_staticRef.SetURL(CString());
297
298 // resizable stuff
299 AddAnchor(IDC_STATIC_REF, TOP_LEFT);
300 //AddAnchor(IDC_BUTTON_BROWSE_REF, TOP_LEFT);
301 AddAnchor(IDC_FROMLABEL, TOP_LEFT);
302 AddAnchor(IDC_DATEFROM, TOP_LEFT);
303 AddAnchor(IDC_TOLABEL, TOP_LEFT);
304 AddAnchor(IDC_DATETO, TOP_LEFT);
305
306 SetFilterCueText();
307 AddAnchor(IDC_SEARCHEDIT, TOP_LEFT, TOP_RIGHT);
308 AddAnchor(IDC_LOG_JUMPTYPE, TOP_RIGHT);
309 AddAnchor(IDC_LOG_JUMPUP, TOP_RIGHT);
310 AddAnchor(IDC_LOG_JUMPDOWN, TOP_RIGHT);
311
312 AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);
313 AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);
314 AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);
315 AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);
316 AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);
317
318 AddAnchor(IDC_LOGINFO, BOTTOM_LEFT, BOTTOM_RIGHT);
319 AddAnchor(IDC_HIDEPATHS, BOTTOM_LEFT);
320 AddAnchor(IDC_LOG_ALLBRANCH,BOTTOM_LEFT);
321 AddAnchor(IDC_LOG_FOLLOWRENAMES, BOTTOM_LEFT);
322 AddAnchor(IDC_LOG_FIRSTPARENT, BOTTOM_LEFT);
323 AddAnchor(IDC_SHOWWHOLEPROJECT, BOTTOM_LEFT);
324 AddAnchor(IDC_LOG_SHOWTAGS, BOTTOM_LEFT);
325 AddAnchor(IDC_REFRESH, BOTTOM_LEFT);
326 AddAnchor(IDC_STATBUTTON, BOTTOM_RIGHT);
327 AddAnchor(IDC_PROGRESS, BOTTOM_LEFT, BOTTOM_RIGHT);
328 AddAnchor(IDOK, BOTTOM_RIGHT);
329 AddAnchor(IDCANCEL, BOTTOM_RIGHT);
330 AddAnchor(IDHELP, BOTTOM_RIGHT);
331
332 if(this->m_bAllBranch)
333 m_LogList.m_ShowMask|=CGit::LOG_INFO_ALL_BRANCH;
334 else
335 m_LogList.m_ShowMask&=~CGit::LOG_INFO_ALL_BRANCH;
336
337 if (m_bShowTags)
338 m_LogList.m_ShowRefMask |= LOGLIST_SHOWTAGS;
339 else
340 m_LogList.m_ShowRefMask &= ~LOGLIST_SHOWTAGS;
341
342 // SetPromptParentWindow(m_hWnd);
343 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_AUTHOREMAIL)));
344 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_COMMITTEREMAIL)));
345 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_MERGEPOINT)));
346 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_PARENT1)));
347 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_PARENT2)));
348 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_TAG)));
349 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_TAG_FF)));
350 m_JumpType.SetCurSel(0);
351 m_JumpUp.SetIcon((HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_JUMPUP), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR));
352 m_JumpDown.SetIcon((HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_JUMPDOWN), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR));
353
354 if (hWndExplorer)
355 CenterWindow(CWnd::FromHandle(hWndExplorer));
356 EnableSaveRestore(_T("LogDlg"));
357
358 DWORD yPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));
359 DWORD yPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));
360 RECT rcDlg, rcLogList, rcChgMsg;
361 GetClientRect(&rcDlg);
362 m_LogList.GetWindowRect(&rcLogList);
363 ScreenToClient(&rcLogList);
364 m_ChangedFileListCtrl.GetWindowRect(&rcChgMsg);
365 ScreenToClient(&rcChgMsg);
366 if (yPos1)
367 {
368 RECT rectSplitter;
369 m_wndSplitter1.GetWindowRect(&rectSplitter);
370 ScreenToClient(&rectSplitter);
371 int delta = yPos1 - rectSplitter.top;
372
373 if ((rcLogList.bottom + delta > rcLogList.top)&&(rcLogList.bottom + delta < rcChgMsg.bottom - 30))
374 {
375 m_wndSplitter1.SetWindowPos(NULL, rectSplitter.left, yPos1, 0, 0, SWP_NOSIZE);
376 DoSizeV1(delta);
377 }
378 }
379 if (yPos2)
380 {
381 RECT rectSplitter;
382 m_wndSplitter2.GetWindowRect(&rectSplitter);
383 ScreenToClient(&rectSplitter);
384 int delta = yPos2 - rectSplitter.top;
385
386 if ((rcChgMsg.top + delta < rcChgMsg.bottom)&&(rcChgMsg.top + delta > rcLogList.top + 30))
387 {
388 m_wndSplitter2.SetWindowPos(NULL, rectSplitter.left, yPos2, 0, 0, SWP_NOSIZE);
389 DoSizeV2(delta);
390 }
391 }
392
393 SetSplitterRange();
394
395 if (m_bSelect)
396 {
397 // the dialog is used to select revisions
398 // enable the OK button if appropriate
399 EnableOKButton();
400 }
401 else
402 {
403 // the dialog is used to just view log messages
404 // hide the OK button and set text on Cancel button to OK
405 GetDlgItemText(IDOK, temp);
406 SetDlgItemText(IDCANCEL, temp);
407 GetDlgItem(IDOK)->ShowWindow(SW_HIDE);
408 }
409
410 // first start a thread to obtain the log messages without
411 // blocking the dialog
412 //m_tTo = 0;
413 //m_tFrom = (DWORD)-1;
414
415 // scroll to user selected or current revision
416 if (!m_hightlightRevision.IsEmpty() && m_hightlightRevision.GetLength() >= GIT_HASH_SIZE)
417 m_LogList.m_lastSelectedHash = m_hightlightRevision;
418 else if (!m_LogList.m_endrev.IsEmpty() && m_LogList.m_endrev.GetLength() >= GIT_HASH_SIZE)
419 m_LogList.m_lastSelectedHash = m_hightlightRevision;
420 else
421 {
422 if (g_Git.GetHash(m_LogList.m_lastSelectedHash, _T("HEAD")))
423 MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash.")), _T("TortoiseGit"), MB_ICONERROR);
424 }
425
426 if (m_path.IsEmpty() || m_path.IsDirectory())
427 DialogEnableWindow(IDC_LOG_FOLLOWRENAMES, FALSE);
428
429 m_LogList.FetchLogAsync(this);
430
431 GetDlgItem(IDC_LOGLIST)->SetFocus();
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_SHOWWHOLEPROJECT, FALSE);
460 //DialogEnableWindow(IDC_LOG_FIRSTPARENT, FALSE);
461 DialogEnableWindow(IDC_STATBUTTON, FALSE);
462 //DialogEnableWindow(IDC_REFRESH, FALSE);
463 DialogEnableWindow(IDC_HIDEPATHS,FALSE);
464
465 }
466 else if( cur == GITLOG_END)
467 {
468 if(this->m_LogList.HasText())
469 {
470 this->m_LogList.ClearText();
471 }
472 UpdateLogInfoLabel();
473
474 if (m_pTaskbarList)
475 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
476
477 DialogEnableWindow(IDC_SHOWWHOLEPROJECT, !m_bFollowRenames);
478
479 DialogEnableWindow(IDC_STATBUTTON, !(m_LogList.m_arShownList.IsEmpty() || m_LogList.m_arShownList.GetCount() == 1 && m_LogList.m_bShowWC));
480 DialogEnableWindow(IDC_REFRESH, TRUE);
481 DialogEnableWindow(IDC_HIDEPATHS,TRUE);
482
483 // PostMessage(WM_TIMER, LOGFILTER_TIMER);
484 GetDlgItem(IDC_PROGRESS)->ShowWindow(FALSE);
485 //CTime time=m_LogList.GetOldestTime();
486 CTime begin,end;
487 m_LogList.GetTimeRange(begin,end);
488
489 if(m_LogList.m_From == -1)
490 m_DateFrom.SetTime(&begin);
491
492 if(m_LogList.m_To == -1)
493 m_DateTo.SetTime(&end);
494
495
496 }
497 else
498 {
499 if(this->m_LogList.HasText())
500 {
501 this->m_LogList.ClearText();
502 this->m_LogList.Invalidate();
503 }
504 UpdateLogInfoLabel();
505 m_LogProgress.SetPos(cur);
506 if (m_pTaskbarList)
507 {
508 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
509 m_pTaskbarList->SetProgressValue(m_hWnd, cur, 100);
510 }
511 }
512 return 0;
513 }
514 void CLogDlg::SetDlgTitle()
515 {
516 if (m_sTitle.IsEmpty())
517 GetWindowText(m_sTitle);
518
519 if (m_LogList.m_Path.IsEmpty() || m_orgPath.GetWinPathString().IsEmpty())
520 {
521 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, m_sTitle);
522 }
523 else
524 CAppUtils::SetWindowTitle(m_hWnd, m_orgPath.GetWinPathString(), m_sTitle);
525 }
526
527 void CLogDlg::CheckRegexpTooltip()
528 {
529 CWnd *pWnd = GetDlgItem(IDC_SEARCHEDIT);
530 // Since tooltip describes regexp features, show it only if regexps are enabled.
531 if (m_bFilterWithRegex)
532 {
533 m_tooltips.AddTool(pWnd, IDS_LOG_FILTER_REGEX_TT);
534 }
535 else
536 m_tooltips.DelTool(pWnd);
537 }
538
539 void CLogDlg::EnableOKButton()
540 {
541 if (m_bSelect)
542 {
543 // the dialog is used to select revisions
544 if (m_bSelectionMustBeSingle)
545 {
546 // enable OK button if only a single revision is selected
547 DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()==1));
548 }
549 else if (m_bSelectionMustBeContinuous)
550 DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()!=0)&&(m_LogList.IsSelectionContinuous()));
551 else
552 DialogEnableWindow(IDOK, m_LogList.GetSelectedCount()!=0);
553 }
554 else
555 DialogEnableWindow(IDOK, TRUE);
556 }
557
558 CString CLogDlg::GetTagInfo(GitRev* pLogEntry)
559 {
560 CString cmd;
561 CString output;
562
563 if(m_LogList.m_HashMap.find(pLogEntry->m_CommitHash) != m_LogList.m_HashMap.end())
564 {
565 STRING_VECTOR &vector = m_LogList.m_HashMap[pLogEntry->m_CommitHash];
566 for(int i=0;i<vector.size();i++)
567 {
568 if(vector[i].Find(_T("refs/tags/")) == 0 )
569 {
570 CString tag= vector[i];
571 int start = vector[i].Find(_T("^{}"));
572 if(start>0)
573 tag=tag.Left(start);
574 else
575 continue;
576
577 cmd.Format(_T("git.exe cat-file tag %s"), tag);
578
579 if(g_Git.Run(cmd, &output, NULL, CP_UTF8) == 0 )
580 output+=_T("\n");
581 }
582 }
583 }
584
585 if(!output.IsEmpty())
586 {
587 output = _T("\n*") + CString(MAKEINTRESOURCE(IDS_PROC_LOG_TAGINFO)) + _T("*\n\n") + output;
588 }
589
590 return output;
591 }
592
593 void CLogDlg::FillLogMessageCtrl(bool bShow /* = true*/)
594 {
595 // we fill here the log message rich edit control,
596 // and also populate the changed files list control
597 // according to the selected revision(s).
598
599 CRichEditCtrl * pMsgView = (CRichEditCtrl*)GetDlgItem(IDC_MSGVIEW);
600 // empty the log message view
601 pMsgView->SetWindowText(_T(" "));
602 // empty the changed files list
603 m_ChangedFileListCtrl.SetRedraw(FALSE);
604 // InterlockedExchange(&m_bNoDispUpdates, TRUE);
605 m_currentChangedArray = NULL;
606 //m_ChangedFileListCtrl.SetExtendedStyle ( LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER );
607 m_ChangedFileListCtrl.DeleteAllItems();
608
609 // if we're not here to really show a selected revision, just
610 // get out of here after clearing the views, which is what is intended
611 // if that flag is not set.
612 if (!bShow)
613 {
614 // force a redraw
615 m_ChangedFileListCtrl.Invalidate();
616 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
617 m_ChangedFileListCtrl.SetRedraw(TRUE);
618 return;
619 }
620
621 // depending on how many revisions are selected, we have to do different
622 // tasks.
623 int selCount = m_LogList.GetSelectedCount();
624 if (selCount == 0)
625 {
626 // if nothing is selected, we have nothing more to do
627 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
628 m_ChangedFileListCtrl.SetRedraw(TRUE);
629 return;
630 }
631 else if (selCount == 1)
632 {
633 // if one revision is selected, we have to fill the log message view
634 // with the corresponding log message, and also fill the changed files
635 // list fully.
636 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
637 int selIndex = m_LogList.GetNextSelectedItem(pos);
638 if (selIndex >= m_LogList.m_arShownList.GetCount())
639 {
640 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
641 m_ChangedFileListCtrl.SetRedraw(TRUE);
642 return;
643 }
644 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(selIndex));
645
646 {
647 // set the log message text
648 pMsgView->SetWindowText(CString(MAKEINTRESOURCE(IDS_HASH)) + _T(": ") + pLogEntry->m_CommitHash.ToString() + _T("\r\n\r\n"));
649 // turn bug ID's into links if the bugtraq: properties have been set
650 // and we can find a match of those in the log message
651
652 pMsgView->SetSel(-1,-1);
653 CHARFORMAT2 format;
654 SecureZeroMemory(&format, sizeof(CHARFORMAT2));
655 format.cbSize = sizeof(CHARFORMAT2);
656 format.dwMask = CFM_BOLD;
657 format.dwEffects = CFE_BOLD;
658 pMsgView->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
659
660 CString msg=_T("* ");
661 msg+=pLogEntry->GetSubject();
662 pMsgView->ReplaceSel(msg);
663
664 pMsgView->SetSel(-1,-1);
665 format.dwEffects = 0;
666 pMsgView->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
667
668 msg=_T("\n");
669 msg+=pLogEntry->GetBody();
670
671 if(!pLogEntry->m_Notes.IsEmpty())
672 {
673 msg+= _T("\n*") + CString(MAKEINTRESOURCE(IDS_NOTES)) + _T("* ");
674 msg+= pLogEntry->m_Notes;
675 msg+= _T("\n\n");
676 }
677
678 msg+=GetTagInfo(pLogEntry);
679
680 pMsgView->ReplaceSel(msg);
681
682 CString text;
683 pMsgView->GetWindowText(text);
684 // the rich edit control doesn't count the CR char!
685 // to be exact: CRLF is treated as one char.
686 text.Remove('\r');
687
688 m_LogList.m_ProjectProperties.FindBugID(text, pMsgView);
689 if (((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\StyleCommitMessages"), TRUE)) == TRUE)
690 CAppUtils::FormatTextInRichEditControl(pMsgView);
691
692 int HidePaths=m_cHidePaths.GetState() & 0x0003;
693 CString matchpath=this->m_path.GetGitPathString();
694
695 int count = pLogEntry->GetFiles(&m_LogList).GetCount();
696 for(int i=0;i<count && (!matchpath.IsEmpty());i++)
697 {
698 if( m_bWholeProject )
699 break;
700
701 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action &= ~(CTGitPath::LOGACTIONS_HIDE|CTGitPath::LOGACTIONS_GRAY);
702
703 if(pLogEntry->GetFiles(&m_LogList)[i].GetGitPathString().Left(matchpath.GetLength()) != matchpath && pLogEntry->GetFiles(&m_LogList)[i].GetGitOldPathString().Left(matchpath.GetLength()) != matchpath)
704 {
705 if(HidePaths==BST_CHECKED)
706 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action |= CTGitPath::LOGACTIONS_HIDE;
707 if(HidePaths==BST_INDETERMINATE)
708 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action |= CTGitPath::LOGACTIONS_GRAY;
709 }
710 }
711
712 m_ChangedFileListCtrl.UpdateWithGitPathList(pLogEntry->GetFiles(&m_LogList));
713 m_ChangedFileListCtrl.m_CurrentVersion=pLogEntry->m_CommitHash;
714 if (pLogEntry->m_CommitHash.IsEmpty() && m_bShowUnversioned)
715 {
716 m_ChangedFileListCtrl.UpdateUnRevFileList(pLogEntry->GetUnRevFiles());
717 m_ChangedFileListCtrl.Show(GITSLC_SHOWVERSIONED | GITSLC_SHOWUNVERSIONED);
718 }
719 else
720 m_ChangedFileListCtrl.Show(GITSLC_SHOWVERSIONED);
721
722 m_ChangedFileListCtrl.SetBusyString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_FETCHINGFILES)));
723
724 if(!pLogEntry->m_IsDiffFiles)
725 m_ChangedFileListCtrl.SetBusy(TRUE);
726 else
727 m_ChangedFileListCtrl.SetBusy(FALSE);
728
729 m_ChangedFileListCtrl.SetRedraw(TRUE);
730 return;
731 }
732
733 }
734 else
735 {
736 // more than one revision is selected:
737 // the log message view must be emptied
738 // the changed files list contains all the changed paths from all
739 // selected revisions, with 'doubles' removed
740 m_currentChangedPathList = GetChangedPathsFromSelectedRevisions(true);
741 }
742
743 // redraw the views
744 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
745 #if 0
746 if (m_currentChangedArray)
747 {
748 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedArray->GetCount());
749 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedArray->GetCount());
750 }
751 else if (m_currentChangedPathList.GetCount())
752 {
753 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedPathList.GetCount());
754 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedPathList.GetCount());
755 }
756 else
757 {
758 m_ChangedFileListCtrl.SetItemCountEx(0);
759 m_ChangedFileListCtrl.Invalidate();
760 }
761 #endif
762 // sort according to the settings
763 if (m_nSortColumnPathList > 0)
764 SetSortArrow(&m_ChangedFileListCtrl, m_nSortColumnPathList, m_bAscendingPathList);
765 else
766 SetSortArrow(&m_ChangedFileListCtrl, -1, false);
767 m_ChangedFileListCtrl.SetRedraw(TRUE);
768
769 }
770
771 void CLogDlg::OnBnClickedRefresh()
772 {
773 Refresh (true);
774 }
775
776 void CLogDlg::Refresh (bool clearfilter /*autoGoOnline*/)
777 {
778 m_limit = 0;
779 m_LogList.Refresh(clearfilter);
780 ShowStartRef();
781 FillLogMessageCtrl(false);
782 }
783
784
785
786 BOOL CLogDlg::Cancel()
787 {
788 return m_bCancelled;
789 }
790
791 void CLogDlg::SaveSplitterPos()
792 {
793 if (!IsIconic())
794 {
795 CRegDWORD regPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));
796 CRegDWORD regPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));
797 RECT rectSplitter;
798 m_wndSplitter1.GetWindowRect(&rectSplitter);
799 ScreenToClient(&rectSplitter);
800 regPos1 = rectSplitter.top;
801 m_wndSplitter2.GetWindowRect(&rectSplitter);
802 ScreenToClient(&rectSplitter);
803 regPos2 = rectSplitter.top;
804 }
805 }
806
807 void CLogDlg::OnCancel()
808 {
809 this->ShowWindow(SW_HIDE);
810
811 // canceling means stopping the working thread if it's still running.
812 m_LogList.SafeTerminateAsyncDiffThread();
813 if (this->IsThreadRunning())
814 {
815 m_LogList.SafeTerminateThread();
816 }
817 UpdateData();
818
819 SaveSplitterPos();
820 __super::OnCancel();
821 }
822
823 void CLogDlg::CopyChangedSelectionToClipBoard()
824 {
825
826 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
827 if (pos == NULL)
828 return; // nothing is selected, get out of here
829
830 CString sPaths;
831
832 // CGitRev* pLogEntry = reinterpret_cast<CGitRev* >(m_LogList.m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
833 // if (pos)
834 {
835 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
836 while (pos)
837 {
838 int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
839 CTGitPath *path = (CTGitPath*)m_ChangedFileListCtrl.GetItemData(nItem);
840 if(path)
841 sPaths += path->GetGitPathString();
842 sPaths += _T("\r\n");
843 }
844 }
845 #if 0
846 else
847 {
848 // only one revision is selected in the log dialog top pane
849 // but multiple items could be selected in the changed items list
850 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
851 while (pos)
852 {
853 int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
854 LogChangedPath * changedlogpath = pLogEntry->pArChangedPaths->SafeGetAt(nItem);
855
856 if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)
857 {
858 // some items are hidden! So find out which item the user really selected
859 INT_PTR selRealIndex = -1;
860 for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)
861 {
862 if (pLogEntry->pArChangedPaths->SafeGetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)
863 selRealIndex++;
864 if (selRealIndex == nItem)
865 {
866 changedlogpath = pLogEntry->pArChangedPaths->SafeGetAt(hiddenindex);
867 break;
868 }
869 }
870 }
871 if (changedlogpath)
872 {
873 sPaths += changedlogpath->sPath;
874 sPaths += _T("\r\n");
875 }
876 }
877 }
878 #endif
879 sPaths.Trim();
880 CStringUtils::WriteAsciiStringToClipboard(sPaths, GetSafeHwnd());
881
882 }
883
884 void CLogDlg::OnContextMenu(CWnd* pWnd, CPoint point)
885 {
886 // we have two separate context menus:
887 // one shown on the log message list control,
888 // the other shown in the changed-files list control
889 int selCount = m_LogList.GetSelectedCount();
890 if ((selCount == 1)&&(pWnd == GetDlgItem(IDC_MSGVIEW)))
891 {
892 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
893 int selIndex = -1;
894 if (pos)
895 selIndex = m_LogList.GetNextSelectedItem(pos);
896
897 GitRev *pRev = ((GitRev*)m_LogList.m_arShownList[selIndex]);
898
899 if ((point.x == -1) && (point.y == -1))
900 {
901 CRect rect;
902 GetDlgItem(IDC_MSGVIEW)->GetClientRect(&rect);
903 ClientToScreen(&rect);
904 point = rect.CenterPoint();
905 }
906 CString sMenuItemText;
907 CIconMenu popup;
908 if (popup.CreatePopupMenu())
909 {
910 // add the 'default' entries
911 sMenuItemText.LoadString(IDS_SCIEDIT_COPY);
912 popup.AppendMenu(MF_STRING | MF_ENABLED, WM_COPY, sMenuItemText);
913 sMenuItemText.LoadString(IDS_SCIEDIT_SELECTALL);
914 popup.AppendMenu(MF_STRING | MF_ENABLED, EM_SETSEL, sMenuItemText);
915 sMenuItemText.LoadString(IDS_EDIT_NOTES);
916 popup.AppendMenuIcon( CGitLogList::ID_EDITNOTE, sMenuItemText, IDI_EDIT);
917
918 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
919 switch (cmd)
920 {
921 case 0:
922 break; // no command selected
923 case EM_SETSEL:
924 case WM_COPY:
925 ::SendMessage(GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), cmd, 0, -1);
926 break;
927 case CGitLogList::ID_EDITNOTE:
928 CAppUtils::EditNote(pRev);
929 this->FillLogMessageCtrl(true);
930 break;
931 }
932 }
933 }
934 }
935
936 void CLogDlg::OnOK()
937 {
938 // since the log dialog is also used to select revisions for other
939 // dialogs, we have to do some work before closing this dialog
940 if (GetFocus() != GetDlgItem(IDOK))
941 return; // if the "OK" button doesn't have the focus, do nothing: this prevents closing the dialog when pressing enter
942
943 m_LogList.SafeTerminateAsyncDiffThread();
944 if (this->IsThreadRunning())
945 {
946 m_LogList.SafeTerminateThread();
947 }
948 UpdateData();
949 // check that one and only one row is selected
950 if (m_LogList.GetSelectedCount() == 1)
951 {
952 // get the selected row
953 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
954 int selIndex = m_LogList.GetNextSelectedItem(pos);
955 if (selIndex < m_LogList.m_arShownList.GetCount())
956 {
957 // all ok, pick up the revision
958 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(selIndex));
959 // extract the hash
960 m_sSelectedHash = pLogEntry->m_CommitHash;
961 }
962 }
963 UpdateData(FALSE);
964 SaveSplitterPos();
965 __super::OnOK();
966
967 #if 0
968 if (!GetDlgItem(IDOK)->IsWindowVisible() && GetFocus() != GetDlgItem(IDCANCEL))
969 return; // the Cancel button works as the OK button. But if the cancel button has not the focus, do nothing.
970
971 CString temp;
972 CString buttontext;
973 GetDlgItemText(IDOK, buttontext);
974 temp.LoadString(IDS_MSGBOX_CANCEL);
975 if (temp.Compare(buttontext) != 0)
976 __super::OnOK(); // only exit if the button text matches, and that will match only if the thread isn't running anymore
977 m_bCancelled = TRUE;
978 m_selectedRevs.Clear();
979 m_selectedRevsOneRange.Clear();
980 if (m_pNotifyWindow)
981 {
982 int selIndex = m_LogList.GetSelectionMark();
983 if (selIndex >= 0)
984 {
985 PLOGENTRYDATA pLogEntry = NULL;
986 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
987 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
988 m_selectedRevs.AddRevision(pLogEntry->Rev);
989 git_revnum_t lowerRev = pLogEntry->Rev;
990 git_revnum_t higherRev = lowerRev;
991 while (pos)
992 {
993 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
994 git_revnum_t rev = pLogEntry->Rev;
995 m_selectedRevs.AddRevision(pLogEntry->Rev);
996 if (lowerRev > rev)
997 lowerRev = rev;
998 if (higherRev < rev)
999 higherRev = rev;
1000 }
1001 if (m_sFilterText.IsEmpty() && m_nSortColumn == 0 && IsSelectionContinuous())
1002 {
1003 m_selectedRevsOneRange.AddRevRange(lowerRev, higherRev);
1004 }
1005 BOOL bSentMessage = FALSE;
1006 if (m_LogList.GetSelectedCount() == 1)
1007 {
1008 // if only one revision is selected, check if the path/url with which the dialog was started
1009 // was directly affected in that revision. If it was, then check if our path was copied from somewhere.
1010 // if it was copied, use the copy from revision as lowerRev
1011 if ((pLogEntry)&&(pLogEntry->pArChangedPaths)&&(lowerRev == higherRev))
1012 {
1013 CString sUrl = m_path.GetGitPathString();
1014 if (!m_path.IsUrl())
1015 {
1016 sUrl = GetURLFromPath(m_path);
1017 }
1018 sUrl = sUrl.Mid(m_sRepositoryRoot.GetLength());
1019 for (int cp = 0; cp < pLogEntry->pArChangedPaths->GetCount(); ++cp)
1020 {
1021 LogChangedPath * pData = pLogEntry->pArChangedPaths->SafeGetAt(cp);
1022 if (pData)
1023 {
1024 if (sUrl.Compare(pData->sPath) == 0)
1025 {
1026 if (!pData->sCopyFromPath.IsEmpty())
1027 {
1028 lowerRev = pData->lCopyFromRev;
1029 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART), lowerRev);
1030 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND), higherRev);
1031 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);
1032 bSentMessage = TRUE;
1033 }
1034 }
1035 }
1036 }
1037 }
1038 }
1039 if ( !bSentMessage )
1040 {
1041 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART | MERGE_REVSELECTMINUSONE), lowerRev);
1042 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND | MERGE_REVSELECTMINUSONE), higherRev);
1043 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);
1044 if (m_selectedRevsOneRange.GetCount())
1045 m_pNotifyWindow->SendMessage(WM_REVLISTONERANGE, 0, (LPARAM)&m_selectedRevsOneRange);
1046 }
1047 }
1048 }
1049 UpdateData();
1050 CRegDWORD reg = CRegDWORD(_T("Software\\TortoiseGit\\ShowAllEntry"));
1051 SaveSplitterPos();
1052 #endif
1053 }
1054
1055 void CLogDlg::DoDiffFromLog(INT_PTR selIndex, GitRev* rev1, GitRev* rev2, bool /*blame*/, bool /*unified*/)
1056 {
1057 DialogEnableWindow(IDOK, FALSE);
1058 // SetPromptApp(&theApp);
1059 theApp.DoWaitCursor(1);
1060
1061 CString temppath;
1062 GetTempPath(temppath);
1063
1064 CString file1;
1065 file1.Format(_T("%s%s_%s%s"),
1066 temppath,
1067 (*m_currentChangedArray)[selIndex].GetBaseFilename(),
1068 rev1->m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()),
1069 (*m_currentChangedArray)[selIndex].GetFileExtension());
1070
1071 CString file2;
1072 file2.Format(_T("%s\\%s_%s%s"),
1073 temppath,
1074 (*m_currentChangedArray)[selIndex].GetBaseFilename(),
1075 rev2->m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()),
1076 (*m_currentChangedArray)[selIndex].GetFileExtension());
1077
1078 CString cmd;
1079 CTGitPath &path = (CTGitPath &)(*m_currentChangedArray)[selIndex];
1080
1081 g_Git.GetOneFile(rev1->m_CommitHash.ToString(), path, file1);
1082 g_Git.GetOneFile(rev2->m_CommitHash.ToString(), path, file2);
1083
1084 CAppUtils::DiffFlags flags;
1085 CAppUtils::StartExtDiff(file1,file2,_T("A"),_T("B"),
1086 g_Git.m_CurrentDir + _T("\\") + path.GetWinPathString(), g_Git.m_CurrentDir + _T("\\") + path.GetWinPathString(),
1087 rev1->m_CommitHash.ToString(), rev2->m_CommitHash.ToString(),
1088 flags);
1089
1090 theApp.DoWaitCursor(-1);
1091 EnableOKButton();
1092 }
1093
1094 BOOL CLogDlg::PreTranslateMessage(MSG* pMsg)
1095 {
1096 // Skip Ctrl-C when copying text out of the log message or search filter
1097 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);
1098 if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')
1099 {
1100 if (GetFocus()==GetDlgItem(IDC_LOGLIST))
1101 {
1102 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1103 {
1104 m_LogList.DiffSelectedRevWithPrevious();
1105 return TRUE;
1106 }
1107 }
1108 }
1109 if (m_hAccel && !bSkipAccelerator)
1110 {
1111 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
1112 if (ret)
1113 return TRUE;
1114 }
1115
1116 if(::IsWindow(m_tooltips.m_hWnd))
1117 m_tooltips.RelayEvent(pMsg);
1118 return __super::PreTranslateMessage(pMsg);
1119 }
1120
1121
1122 BOOL CLogDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
1123 {
1124 //if (this->IsThreadRunning())
1125 if(m_LogList.m_bNoDispUpdates)
1126 {
1127 // only show the wait cursor over the list control
1128 if ((pWnd)&&
1129 ((pWnd == GetDlgItem(IDC_LOGLIST))||
1130 (pWnd == GetDlgItem(IDC_MSGVIEW))||
1131 (pWnd == GetDlgItem(IDC_LOGMSG))))
1132 {
1133 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));
1134 SetCursor(hCur);
1135 return TRUE;
1136 }
1137 }
1138 if ((pWnd) && (pWnd == GetDlgItem(IDC_MSGVIEW)))
1139 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1140
1141 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
1142 SetCursor(hCur);
1143 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1144 }
1145
1146 void CLogDlg::OnBnClickedHelp()
1147 {
1148 OnHelp();
1149 }
1150
1151 void CLogDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1152 {
1153 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1154 *pResult = 0;
1155 //if (this->IsThreadRunning())
1156 if(m_LogList.m_bNoDispUpdates)
1157 return;
1158 if (pNMLV->iItem >= 0)
1159 {
1160 this->m_LogList.m_nSearchIndex = pNMLV->iItem;
1161 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(pNMLV->iItem));
1162 m_LogList.m_lastSelectedHash = pLogEntry->m_CommitHash;
1163 if (pNMLV->iSubItem != 0)
1164 return;
1165 if ((pNMLV->iItem == m_LogList.m_arShownList.GetCount()))
1166 {
1167 // remove the selected state
1168 if (pNMLV->uChanged & LVIF_STATE)
1169 {
1170 m_LogList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
1171 FillLogMessageCtrl();
1172 UpdateData(FALSE);
1173 UpdateLogInfoLabel();
1174 }
1175 return;
1176 }
1177 if (pNMLV->uChanged & LVIF_STATE)
1178 {
1179 FillLogMessageCtrl();
1180 UpdateData(FALSE);
1181 }
1182 }
1183 else
1184 {
1185 m_LogList.m_lastSelectedHash.Empty();
1186 FillLogMessageCtrl();
1187 UpdateData(FALSE);
1188 }
1189 EnableOKButton();
1190 UpdateLogInfoLabel();
1191 }
1192
1193 void CLogDlg::OnEnLinkMsgview(NMHDR *pNMHDR, LRESULT *pResult)
1194 {
1195 ENLINK *pEnLink = reinterpret_cast<ENLINK *>(pNMHDR);
1196 if (pEnLink->msg == WM_LBUTTONUP)
1197 {
1198 CString url, msg;
1199 GetDlgItemText(IDC_MSGVIEW, msg);
1200 msg.Replace(_T("\r\n"), _T("\n"));
1201 url = msg.Mid(pEnLink->chrg.cpMin, pEnLink->chrg.cpMax-pEnLink->chrg.cpMin);
1202 if (!::PathIsURL(url))
1203 {
1204 url = m_LogList.m_ProjectProperties.GetBugIDUrl(url);
1205 url = GetAbsoluteUrlFromRelativeUrl(url);
1206 }
1207 if (!url.IsEmpty())
1208 ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);
1209 }
1210 *pResult = 0;
1211 }
1212
1213 void CLogDlg::OnBnClickedStatbutton()
1214 {
1215 if (this->IsThreadRunning())
1216 return;
1217 if (m_LogList.m_arShownList.IsEmpty() || m_LogList.m_arShownList.GetCount() == 1 && m_LogList.m_bShowWC)
1218 return; // nothing or just the working copy changes are shown, so no statistics.
1219 // the statistics dialog expects the log entries to be sorted by date
1220 SortByColumn(3, false);
1221
1222 CStatGraphDlg dlg;
1223 m_LogList.RecalculateShownList(&dlg.m_ShowList);
1224
1225 dlg.m_path = m_orgPath;
1226 dlg.DoModal();
1227 // restore the previous sorting
1228 SortByColumn(m_nSortColumn, m_bAscending);
1229 OnTimer(LOGFILTER_TIMER);
1230 }
1231
1232 void CLogDlg::DoSizeV1(int delta)
1233 {
1234
1235 RemoveAnchor(IDC_LOGLIST);
1236 RemoveAnchor(IDC_SPLITTERTOP);
1237 RemoveAnchor(IDC_MSGVIEW);
1238 RemoveAnchor(IDC_SPLITTERBOTTOM);
1239 RemoveAnchor(IDC_LOGMSG);
1240 CSplitterControl::ChangeHeight(&m_LogList, delta, CW_TOPALIGN);
1241 CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), -delta, CW_BOTTOMALIGN);
1242 AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);
1243 AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);
1244 AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);
1245 AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);
1246 AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);
1247 ArrangeLayout();
1248 AdjustMinSize();
1249 SetSplitterRange();
1250 m_LogList.Invalidate();
1251 GetDlgItem(IDC_MSGVIEW)->Invalidate();
1252
1253 }
1254
1255 void CLogDlg::DoSizeV2(int delta)
1256 {
1257
1258 RemoveAnchor(IDC_LOGLIST);
1259 RemoveAnchor(IDC_SPLITTERTOP);
1260 RemoveAnchor(IDC_MSGVIEW);
1261 RemoveAnchor(IDC_SPLITTERBOTTOM);
1262 RemoveAnchor(IDC_LOGMSG);
1263 CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), delta, CW_TOPALIGN);
1264 CSplitterControl::ChangeHeight(&m_ChangedFileListCtrl, -delta, CW_BOTTOMALIGN);
1265 AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);
1266 AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);
1267 AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);
1268 AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);
1269 AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);
1270 ArrangeLayout();
1271 AdjustMinSize();
1272 SetSplitterRange();
1273 GetDlgItem(IDC_MSGVIEW)->Invalidate();
1274 m_ChangedFileListCtrl.Invalidate();
1275
1276 }
1277
1278 void CLogDlg::AdjustMinSize()
1279 {
1280 // adjust the minimum size of the dialog to prevent the resizing from
1281 // moving the list control too far down.
1282 CRect rcChgListView;
1283 m_ChangedFileListCtrl.GetClientRect(rcChgListView);
1284 CRect rcLogList;
1285 m_LogList.GetClientRect(rcLogList);
1286
1287 SetMinTrackSize(CSize(m_DlgOrigRect.Width(),
1288 m_DlgOrigRect.Height()-m_ChgOrigRect.Height()-m_LogListOrigRect.Height()-m_MsgViewOrigRect.Height()
1289 +rcChgListView.Height()+rcLogList.Height()+60));
1290 }
1291
1292 LRESULT CLogDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
1293 {
1294 switch (message) {
1295 case WM_NOTIFY:
1296 if (wParam == IDC_SPLITTERTOP)
1297 {
1298 SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
1299 DoSizeV1(pHdr->delta);
1300 }
1301 else if (wParam == IDC_SPLITTERBOTTOM)
1302 {
1303 SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
1304 DoSizeV2(pHdr->delta);
1305 }
1306 break;
1307 }
1308
1309 return CResizableDialog::DefWindowProc(message, wParam, lParam);
1310 }
1311
1312 void CLogDlg::SetSplitterRange()
1313 {
1314 if ((m_LogList)&&(m_ChangedFileListCtrl))
1315 {
1316 CRect rcTop;
1317 m_LogList.GetWindowRect(rcTop);
1318 ScreenToClient(rcTop);
1319 CRect rcMiddle;
1320 GetDlgItem(IDC_MSGVIEW)->GetWindowRect(rcMiddle);
1321 ScreenToClient(rcMiddle);
1322 m_wndSplitter1.SetRange(rcTop.top+30, rcMiddle.bottom-20);
1323 CRect rcBottom;
1324 m_ChangedFileListCtrl.GetWindowRect(rcBottom);
1325 ScreenToClient(rcBottom);
1326 m_wndSplitter2.SetRange(rcMiddle.top+30, rcBottom.bottom-20);
1327 }
1328 }
1329
1330 LRESULT CLogDlg::OnClickedInfoIcon(WPARAM /*wParam*/, LPARAM lParam)
1331 {
1332 // FIXME: x64 version would get this function called with unexpected parameters.
1333 if (!lParam)
1334 return 0;
1335
1336 RECT * rect = (LPRECT)lParam;
1337 CPoint point;
1338 CString temp;
1339 point = CPoint(rect->left, rect->bottom);
1340 #define LOGMENUFLAGS(x) (MF_STRING | MF_ENABLED | (m_LogList.m_SelectedFilters & x ? MF_CHECKED : MF_UNCHECKED))
1341 CMenu popup;
1342 if (popup.CreatePopupMenu())
1343 {
1344 temp.LoadString(IDS_LOG_FILTER_SUBJECT);
1345 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_SUBJECT), LOGFILTER_SUBJECT, temp);
1346
1347 temp.LoadString(IDS_LOG_FILTER_MESSAGES);
1348 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_MESSAGES), LOGFILTER_MESSAGES, temp);
1349
1350 temp.LoadString(IDS_LOG_FILTER_PATHS);
1351 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_PATHS), LOGFILTER_PATHS, temp);
1352
1353 temp.LoadString(IDS_LOG_FILTER_AUTHORS);
1354 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_AUTHORS), LOGFILTER_AUTHORS, temp);
1355
1356 temp.LoadString(IDS_LOG_FILTER_REVS);
1357 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_REVS), LOGFILTER_REVS, temp);
1358
1359 temp.LoadString(IDS_LOG_FILTER_REFNAME);
1360 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_REFNAME), LOGFILTER_REFNAME, temp);
1361
1362 if (m_LogList.m_bShowBugtraqColumn == TRUE) {
1363 temp.LoadString(IDS_LOG_FILTER_BUGIDS);
1364 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_BUGID), LOGFILTER_BUGID, temp);
1365 }
1366
1367 popup.AppendMenu(MF_SEPARATOR, NULL);
1368
1369 temp.LoadString(IDS_LOG_FILTER_REGEX);
1370 popup.AppendMenu(MF_STRING | MF_ENABLED | (m_bFilterWithRegex ? MF_CHECKED : MF_UNCHECKED), LOGFILTER_REGEX, temp);
1371
1372 m_tooltips.Pop();
1373 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1374 if (selection != 0)
1375 {
1376
1377 if (selection == LOGFILTER_REGEX)
1378 {
1379 m_bFilterWithRegex = !m_bFilterWithRegex;
1380 CRegDWORD b = CRegDWORD(_T("Software\\TortoiseGit\\UseRegexFilter"), TRUE);
1381 b = m_bFilterWithRegex;
1382 m_LogList.m_bFilterWithRegex = m_bFilterWithRegex;
1383 SetFilterCueText();
1384 CheckRegexpTooltip();
1385 }
1386 else
1387 {
1388 m_LogList.m_SelectedFilters ^= selection;
1389 SetFilterCueText();
1390 }
1391 // Reload only if a search text is entered
1392 if (!m_LogList.m_sFilterText.IsEmpty())
1393 SetTimer(LOGFILTER_TIMER, 1000, NULL);
1394 }
1395 }
1396 return 0L;
1397 }
1398
1399 LRESULT CLogDlg::OnClickedCancelFilter(WPARAM /*wParam*/, LPARAM /*lParam*/)
1400 {
1401
1402 KillTimer(LOGFILTER_TIMER);
1403
1404 m_LogList.m_sFilterText.Empty();
1405 UpdateData(FALSE);
1406 theApp.DoWaitCursor(1);
1407 CStoreSelection storeselection(this);
1408 FillLogMessageCtrl(false);
1409
1410 m_LogList.RemoveFilter();
1411
1412 Refresh();
1413
1414 CTime begin,end;
1415 m_LogList.GetTimeRange(begin,end);
1416 m_DateFrom.SetTime(&begin);
1417 m_DateTo.SetTime(&end);
1418
1419 theApp.DoWaitCursor(-1);
1420 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
1421 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
1422 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
1423 UpdateLogInfoLabel();
1424
1425 return 0L;
1426 }
1427
1428
1429 void CLogDlg::SetFilterCueText()
1430 {
1431 CString temp(MAKEINTRESOURCE(IDS_LOG_FILTER_BY));
1432 temp += _T(" ");
1433
1434 if (m_LogList.m_SelectedFilters & LOGFILTER_SUBJECT)
1435 {
1436 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_SUBJECT));
1437 }
1438
1439 if (m_LogList.m_SelectedFilters & LOGFILTER_MESSAGES)
1440 {
1441 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1442 temp += _T(", ");
1443 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_MESSAGES));
1444 }
1445
1446 if (m_LogList.m_SelectedFilters & LOGFILTER_PATHS)
1447 {
1448 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1449 temp += _T(", ");
1450 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_PATHS));
1451 }
1452
1453 if (m_LogList.m_SelectedFilters & LOGFILTER_AUTHORS)
1454 {
1455 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1456 temp += _T(", ");
1457 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_AUTHORS));
1458 }
1459
1460 if (m_LogList.m_SelectedFilters & LOGFILTER_REVS)
1461 {
1462 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1463 temp += _T(", ");
1464 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_REVS));
1465 }
1466
1467 if (m_LogList.m_SelectedFilters & LOGFILTER_BUGID)
1468 {
1469 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1470 temp += _T(", ");
1471 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_BUGIDS));
1472 }
1473
1474 // to make the cue banner text appear more to the right of the edit control
1475 temp = _T(" ")+temp;
1476 m_cFilter.SetCueBanner(temp.TrimRight());
1477 }
1478
1479 bool CLogDlg::Validate(LPCTSTR string)
1480 {
1481 if (!m_bFilterWithRegex)
1482 return true;
1483 tr1::wregex pat;
1484 return m_LogList.ValidateRegexp(string, pat, false);
1485 }
1486
1487
1488 void CLogDlg::OnTimer(UINT_PTR nIDEvent)
1489 {
1490 if (nIDEvent == LOGFTIME_TIMER)
1491 {
1492 KillTimer(LOGFTIME_TIMER);
1493 m_limit = 0;
1494 m_LogList.Refresh(FALSE);
1495 FillLogMessageCtrl(false);
1496 }
1497
1498 if (nIDEvent == LOGFILTER_TIMER)
1499 {
1500 KillTimer(LOGFILTER_TIMER);
1501 m_limit = 0;
1502 m_LogList.Refresh(FALSE);
1503 FillLogMessageCtrl(false);
1504
1505 #if 0
1506 /* we will use git built-in grep to filter log */
1507 if (this->IsThreadRunning())
1508 {
1509 // thread still running! So just restart the timer.
1510 SetTimer(LOGFILTER_TIMER, 1000, NULL);
1511 return;
1512 }
1513 CWnd * focusWnd = GetFocus();
1514 bool bSetFocusToFilterControl = ((focusWnd != GetDlgItem(IDC_DATEFROM))&&(focusWnd != GetDlgItem(IDC_DATETO))
1515 && (focusWnd != GetDlgItem(IDC_LOGLIST)));
1516 if (m_LogList.m_sFilterText.IsEmpty())
1517 {
1518 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty()))));
1519 // do not return here!
1520 // we also need to run the filter if the filter text is empty:
1521 // 1. to clear an existing filter
1522 // 2. to rebuild the m_arShownList after sorting
1523 }
1524 theApp.DoWaitCursor(1);
1525 CStoreSelection storeselection(this);
1526 KillTimer(LOGFILTER_TIMER);
1527 FillLogMessageCtrl(false);
1528
1529 // now start filter the log list
1530 m_LogList.StartFilter();
1531
1532 if ( m_LogList.GetItemCount()==1 )
1533 {
1534 m_LogList.SetSelectionMark(0);
1535 m_LogList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
1536 }
1537 theApp.DoWaitCursor(-1);
1538 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
1539 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
1540 if (bSetFocusToFilterControl)
1541 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
1542 UpdateLogInfoLabel();
1543 #endif
1544 } // if (nIDEvent == LOGFILTER_TIMER)
1545 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty() || m_LogList.m_arShownList.GetCount() == 1 && m_LogList.m_bShowWC))));
1546 __super::OnTimer(nIDEvent);
1547 }
1548
1549 void CLogDlg::OnDtnDatetimechangeDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)
1550 {
1551 try
1552 {
1553 CTime _time;
1554 m_DateTo.GetTime(_time);
1555
1556 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 23, 59, 59);
1557 if (time.GetTime() != m_LogList.m_To)
1558 {
1559 m_LogList.m_To = (DWORD)time.GetTime();
1560 SetTimer(LOGFTIME_TIMER, 10, NULL);
1561 }
1562 }
1563 catch (...)
1564 {
1565 CMessageBox::Show(NULL,_T("Invalidate Parameter"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1566 }
1567
1568 *pResult = 0;
1569 }
1570
1571 void CLogDlg::OnDtnDatetimechangeDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)
1572 {
1573
1574 try
1575 {
1576 CTime _time;
1577 m_DateFrom.GetTime(_time);
1578
1579 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 0, 0, 0);
1580 if (time.GetTime() != m_LogList.m_From)
1581 {
1582 m_LogList.m_From = (DWORD)time.GetTime();
1583 SetTimer(LOGFTIME_TIMER, 10, NULL);
1584 }
1585 }
1586 catch (...)
1587 {
1588 CMessageBox::Show(NULL,_T("Invalidate Parameter"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1589 }
1590
1591 *pResult = 0;
1592 }
1593
1594 void CLogDlg::OnCbnSelchangeJumpType()
1595 {
1596 // reserved for future use
1597 }
1598
1599 void CLogDlg::OnBnClickedJumpUp()
1600 {
1601 int sel = m_JumpType.GetCurSel();
1602 if (sel < 0) return;
1603 JumpType jumpType = (JumpType)sel;
1604
1605 CString strValue;
1606 CGitHash hashValue;
1607 int index = -1;
1608 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1609 if (pos)
1610 {
1611 index = m_LogList.GetNextSelectedItem(pos);
1612 if (index == 0) return;
1613
1614 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(index);
1615 if (jumpType == JumpType_AuthorEmail)
1616 strValue = data->GetAuthorEmail();
1617 else if (jumpType == JumpType_CommitterEmail)
1618 strValue = data->GetCommitterEmail();
1619 else if (jumpType == JumpType_Parent1)
1620 hashValue = data->m_CommitHash;
1621 else if (jumpType == JumpType_Parent2)
1622 hashValue = data->m_CommitHash;
1623 else if (jumpType == JumpType_TagFF)
1624 hashValue = data->m_CommitHash;
1625
1626 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1627 }
1628 else
1629 return;
1630
1631 while (pos)
1632 {
1633 index = m_LogList.GetNextSelectedItem(pos);
1634 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1635 }
1636 m_LogList.SetSelectionMark(-1);
1637
1638 for (int i = index - 1; i >= 0; i--)
1639 {
1640 bool found = false;
1641 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(i);
1642 if (jumpType == JumpType_AuthorEmail)
1643 found = strValue == data->GetAuthorEmail();
1644 else if (jumpType == JumpType_CommitterEmail)
1645 found = strValue == data->GetCommitterEmail();
1646 else if (jumpType == JumpType_MergePoint)
1647 found = data->ParentsCount() > 1;
1648 else if (jumpType == JumpType_Parent1)
1649 {
1650 if (data->m_ParentHash.size() > 0)
1651 found = data->m_ParentHash[0] == hashValue;
1652 }
1653 else if (jumpType == JumpType_Parent2)
1654 {
1655 if (data->m_ParentHash.size() > 1)
1656 found = data->m_ParentHash[1] == hashValue;
1657 }
1658 else if (jumpType == JumpType_Tag || jumpType == JumpType_TagFF)
1659 {
1660 STRING_VECTOR refList = m_LogList.m_HashMap[data->m_CommitHash];
1661 for (int j = 0; j < refList.size(); j++)
1662 {
1663 if (refList[j].Left(10) == _T("refs/tags/"))
1664 {
1665 found = true;
1666 break;
1667 }
1668 }
1669
1670 if (found && jumpType == JumpType_TagFF)
1671 found = g_Git.IsFastForward(hashValue, data->m_CommitHash);
1672 }
1673
1674 if (found)
1675 {
1676 m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
1677 m_LogList.EnsureVisible(i, FALSE);
1678 m_LogList.SetSelectionMark(i);
1679 return;
1680 }
1681 }
1682
1683 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, _T("NoJumpNotFoundWarning"), IDS_MSGBOX_DONOTSHOWAGAIN);
1684 }
1685
1686 void CLogDlg::OnBnClickedJumpDown()
1687 {
1688 int jumpType = m_JumpType.GetCurSel();
1689 if (jumpType < 0) return;
1690
1691 CString strValue;
1692 CGitHash hashValue;
1693 int index = -1;
1694 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1695 if (pos)
1696 {
1697 index = m_LogList.GetNextSelectedItem(pos);
1698 if (index == 0) return;
1699
1700 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(index);
1701 if (jumpType == JumpType_AuthorEmail)
1702 strValue = data->GetAuthorEmail();
1703 else if (jumpType == JumpType_CommitterEmail)
1704 strValue = data->GetCommitterEmail();
1705 else if (jumpType == JumpType_Parent1)
1706 {
1707 if (data->m_ParentHash.size() > 0)
1708 hashValue = data->m_ParentHash.at(0);
1709 else
1710 return;
1711 }
1712 else if (jumpType == JumpType_Parent2)
1713 {
1714 if (data->m_ParentHash.size() > 1)
1715 hashValue = data->m_ParentHash.at(1);
1716 else
1717 return;
1718 }
1719 else if (jumpType == JumpType_TagFF)
1720 hashValue = data->m_CommitHash;
1721
1722 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1723 }
1724 else
1725 return;
1726
1727 while (pos)
1728 {
1729 index = m_LogList.GetNextSelectedItem(pos);
1730 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1731 }
1732 m_LogList.SetSelectionMark(-1);
1733
1734 for (int i = index + 1; i < m_LogList.GetItemCount(); i++)
1735 {
1736 bool found = false;
1737 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(i);
1738 if (jumpType == JumpType_AuthorEmail)
1739 found = strValue == data->GetAuthorEmail();
1740 else if (jumpType == JumpType_CommitterEmail)
1741 found = strValue == data->GetCommitterEmail();
1742 else if (jumpType == JumpType_MergePoint)
1743 found = data->ParentsCount() > 1;
1744 else if (jumpType == JumpType_Parent1)
1745 found = data->m_CommitHash == hashValue;
1746 else if (jumpType == JumpType_Parent2)
1747 found = data->m_CommitHash == hashValue;
1748 else if (jumpType == JumpType_Tag || jumpType == JumpType_TagFF)
1749 {
1750 STRING_VECTOR refList = m_LogList.m_HashMap[data->m_CommitHash];
1751 for (int j = 0; j < refList.size(); j++)
1752 {
1753 if (refList[j].Left(10) == _T("refs/tags/"))
1754 {
1755 found = true;
1756 break;
1757 }
1758 }
1759
1760 if (found && jumpType == JumpType_TagFF)
1761 found = g_Git.IsFastForward(data->m_CommitHash, hashValue);
1762 }
1763
1764 if (found)
1765 {
1766 m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
1767 m_LogList.EnsureVisible(i, FALSE);
1768 m_LogList.SetSelectionMark(i);
1769 return;
1770 }
1771 }
1772
1773 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, _T("NoJumpNotFoundWarning"), IDS_MSGBOX_DONOTSHOWAGAIN);
1774 }
1775
1776 CTGitPathList CLogDlg::GetChangedPathsFromSelectedRevisions(bool /*bRelativePaths*/ /* = false */, bool /*bUseFilter*/ /* = true */)
1777 {
1778 CTGitPathList pathList;
1779 #if 0
1780
1781 if (m_sRepositoryRoot.IsEmpty() && (bRelativePaths == false))
1782 {
1783 m_sRepositoryRoot = GetRepositoryRoot(m_path);
1784 }
1785 if (m_sRepositoryRoot.IsEmpty() && (bRelativePaths == false))
1786 return pathList;
1787
1788 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1789 if (pos != NULL)
1790 {
1791 while (pos)
1792 {
1793 int nextpos = m_LogList.GetNextSelectedItem(pos);
1794 if (nextpos >= m_arShownList.GetCount())
1795 continue;
1796 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(nextpos));
1797 LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;
1798 for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)
1799 {
1800 LogChangedPath * cpath = cpatharray->SafeGetAt(cpPathIndex);
1801 if (cpath == NULL)
1802 continue;
1803 CTGitPath path;
1804 if (!bRelativePaths)
1805 path.SetFromGit(m_sRepositoryRoot);
1806 path.AppendPathString(cpath->sPath);
1807 if ((!bUseFilter)||
1808 ((m_cHidePaths.GetState() & 0x0003)!=BST_CHECKED)||
1809 (cpath->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0))
1810 pathList.AddPath(path);
1811
1812 }
1813 }
1814 }
1815 pathList.RemoveDuplicates();
1816 #endif
1817 return pathList;
1818 }
1819
1820 void CLogDlg::SortByColumn(int /*nSortColumn*/, bool /*bAscending*/)
1821 {
1822 #if 0
1823 switch(nSortColumn)
1824 {
1825 case 0: // Revision
1826 {
1827 if(bAscending)
1828 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscRevSort());
1829 else
1830 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescRevSort());
1831 }
1832 break;
1833 case 1: // action
1834 {
1835 if(bAscending)
1836 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscActionSort());
1837 else
1838 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescActionSort());
1839 }
1840 break;
1841 case 2: // Author
1842 {
1843 if(bAscending)
1844 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscAuthorSort());
1845 else
1846 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescAuthorSort());
1847 }
1848 break;
1849 case 3: // Date
1850 {
1851 if(bAscending)
1852 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscDateSort());
1853 else
1854 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescDateSort());
1855 }
1856 break;
1857 case 4: // Message or bug id
1858 if (m_bShowBugtraqColumn)
1859 {
1860 if(bAscending)
1861 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscBugIDSort());
1862 else
1863 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescBugIDSort());
1864 break;
1865 }
1866 // fall through here
1867 case 5: // Message
1868 {
1869 if(bAscending)
1870 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscMessageSort());
1871 else
1872 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescMessageSort());
1873 }
1874 break;
1875 default:
1876 ATLASSERT(0);
1877 break;
1878 }
1879 #endif
1880 }
1881
1882 void CLogDlg::OnLvnColumnclick(NMHDR *pNMHDR, LRESULT *pResult)
1883 {
1884 if (this->IsThreadRunning())
1885 return; //no sorting while the arrays are filled
1886 #if 0
1887 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1888 const int nColumn = pNMLV->iSubItem;
1889 m_bAscending = nColumn == m_nSortColumn ? !m_bAscending : TRUE;
1890 m_nSortColumn = nColumn;
1891 SortByColumn(m_nSortColumn, m_bAscending);
1892 SetSortArrow(&m_LogList, m_nSortColumn, !!m_bAscending);
1893 SortShownListArray();
1894 m_LogList.Invalidate();
1895 UpdateLogInfoLabel();
1896 #else
1897 UNREFERENCED_PARAMETER(pNMHDR);
1898 #endif
1899 *pResult = 0;
1900 }
1901
1902 void CLogDlg::SortShownListArray()
1903 {
1904 // make sure the shown list still matches the filter after sorting.
1905 OnTimer(LOGFILTER_TIMER);
1906 // clear the selection states
1907 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1908 while (pos)
1909 {
1910 m_LogList.SetItemState(m_LogList.GetNextSelectedItem(pos), 0, LVIS_SELECTED);
1911 }
1912 m_LogList.SetSelectionMark(-1);
1913 }
1914
1915 void CLogDlg::SetSortArrow(CListCtrl * control, int nColumn, bool bAscending)
1916 {
1917 if (control == NULL)
1918 return;
1919 // set the sort arrow
1920 CHeaderCtrl * pHeader = control->GetHeaderCtrl();
1921 HDITEM HeaderItem = {0};
1922 HeaderItem.mask = HDI_FORMAT;
1923 for (int i=0; i<pHeader->GetItemCount(); ++i)
1924 {
1925 pHeader->GetItem(i, &HeaderItem);
1926 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
1927 pHeader->SetItem(i, &HeaderItem);
1928 }
1929 if (nColumn >= 0)
1930 {
1931 pHeader->GetItem(nColumn, &HeaderItem);
1932 HeaderItem.fmt |= (bAscending ? HDF_SORTUP : HDF_SORTDOWN);
1933 pHeader->SetItem(nColumn, &HeaderItem);
1934 }
1935 }
1936
1937 int CLogDlg::m_nSortColumnPathList = 0;
1938 bool CLogDlg::m_bAscendingPathList = false;
1939
1940 void CLogDlg::OnBnClickedHidepaths()
1941 {
1942 FillLogMessageCtrl();
1943 m_ChangedFileListCtrl.Invalidate();
1944 }
1945
1946 void CLogDlg::UpdateLogInfoLabel()
1947 {
1948
1949 CGitHash rev1 ;
1950 CGitHash rev2 ;
1951 long selectedrevs = 0;
1952 int count = (int)m_LogList.m_arShownList.GetCount();
1953 int start = 0;
1954 if (count)
1955 {
1956 rev1 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(0)))->m_CommitHash;
1957 if(this->m_LogList.m_bShowWC && rev1.IsEmpty()&&(count>1))
1958 start = 1;
1959 rev1 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(start)))->m_CommitHash;
1960 //pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_arShownList.GetCount()-1));
1961 rev2 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(count-1)))->m_CommitHash;
1962 selectedrevs = m_LogList.GetSelectedCount();
1963 }
1964 CString sTemp;
1965 sTemp.Format(IDS_PROC_LOG_STATS,
1966 count - start,
1967 rev2.ToString().Left(g_Git.GetShortHASHLength()), rev1.ToString().Left(g_Git.GetShortHASHLength()), selectedrevs);
1968
1969 if(selectedrevs == 1)
1970 {
1971 CString str=m_ChangedFileListCtrl.GetStatisticsString(true);
1972 str.Replace(_T('\n'), _T(' '));
1973 sTemp += _T("\r\n") + str;
1974 }
1975 m_sLogInfo = sTemp;
1976
1977 UpdateData(FALSE);
1978 }
1979
1980 void CLogDlg::OnDtnDropdownDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)
1981 {
1982 // the date control should not show the "today" button
1983 CMonthCalCtrl * pCtrl = m_DateFrom.GetMonthCalCtrl();
1984 if (pCtrl)
1985 SetWindowLongPtr(pCtrl->GetSafeHwnd(), GWL_STYLE, LONG_PTR(pCtrl->GetStyle() | MCS_NOTODAY));
1986 *pResult = 0;
1987 }
1988
1989 void CLogDlg::OnDtnDropdownDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)
1990 {
1991 // the date control should not show the "today" button
1992 CMonthCalCtrl * pCtrl = m_DateTo.GetMonthCalCtrl();
1993 if (pCtrl)
1994 SetWindowLongPtr(pCtrl->GetSafeHwnd(), GWL_STYLE, LONG_PTR(pCtrl->GetStyle() | MCS_NOTODAY));
1995 *pResult = 0;
1996 }
1997
1998 void CLogDlg::OnSize(UINT nType, int cx, int cy)
1999 {
2000 __super::OnSize(nType, cx, cy);
2001 //set range
2002 SetSplitterRange();
2003 }
2004
2005 void CLogDlg::OnRefresh()
2006 {
2007 {
2008 m_limit = 0;
2009 this->m_LogProgress.SetPos(0);
2010
2011 Refresh (false);
2012 }
2013 }
2014
2015 void CLogDlg::OnFocusFilter()
2016 {
2017 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2018 }
2019
2020 void CLogDlg::OnEditCopy()
2021 {
2022 if (GetFocus() == &m_ChangedFileListCtrl)
2023 CopyChangedSelectionToClipBoard();
2024 else
2025 m_LogList.CopySelectionToClipBoard();
2026 }
2027
2028 CString CLogDlg::GetAbsoluteUrlFromRelativeUrl(const CString& url)
2029 {
2030 // is the URL a relative one?
2031 if (url.Left(2).Compare(_T("^/")) == 0)
2032 {
2033 // URL is relative to the repository root
2034 CString url1 = m_sRepositoryRoot + url.Mid(1);
2035 TCHAR buf[INTERNET_MAX_URL_LENGTH];
2036 DWORD len = url.GetLength();
2037 if (UrlCanonicalize((LPCTSTR)url1, buf, &len, 0) == S_OK)
2038 return CString(buf, len);
2039 return url1;
2040 }
2041 else if (url[0] == '/')
2042 {
2043 // URL is relative to the server's hostname
2044 CString sHost;
2045 // find the server's hostname
2046 int schemepos = m_sRepositoryRoot.Find(_T("//"));
2047 if (schemepos >= 0)
2048 {
2049 sHost = m_sRepositoryRoot.Left(m_sRepositoryRoot.Find('/', schemepos+3));
2050 CString url1 = sHost + url;
2051 TCHAR buf[INTERNET_MAX_URL_LENGTH];
2052 DWORD len = url.GetLength();
2053 if (UrlCanonicalize((LPCTSTR)url, buf, &len, 0) == S_OK)
2054 return CString(buf, len);
2055 return url1;
2056 }
2057 }
2058 return url;
2059 }
2060
2061
2062 void CLogDlg::OnEnChangeSearchedit()
2063 {
2064 UpdateData();
2065 if (m_LogList.m_sFilterText.IsEmpty())
2066 {
2067 CStoreSelection storeselection(this);
2068 // clear the filter, i.e. make all entries appear
2069 theApp.DoWaitCursor(1);
2070 KillTimer(LOGFILTER_TIMER);
2071 FillLogMessageCtrl(false);
2072
2073 Refresh();
2074 //m_LogList.StartFilter();
2075 #if 0
2076 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2077 m_arShownList.RemoveAll();
2078 for (DWORD i=0; i<m_logEntries.size(); ++i)
2079 {
2080 if (IsEntryInDateRange(i))
2081 m_arShownList.Add(m_logEntries[i]);
2082 }
2083 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2084 m_LogList.DeleteAllItems();
2085 m_LogList.SetItemCountEx(ShownCountWithStopped());
2086 m_LogList.RedrawItems(0, ShownCountWithStopped());
2087 m_LogList.SetRedraw(false);
2088 ResizeAllListCtrlCols();
2089 m_LogList.SetRedraw(true);
2090 #endif
2091 theApp.DoWaitCursor(-1);
2092 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
2093 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
2094 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2095 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty()))));
2096 return;
2097 }
2098 if (Validate(m_LogList.m_sFilterText))
2099 SetTimer(LOGFILTER_TIMER, 1000, NULL);
2100 else
2101 KillTimer(LOGFILTER_TIMER);
2102
2103 }
2104
2105 void CLogDlg::OnBnClickedAllBranch()
2106 {
2107 this->UpdateData();
2108
2109 if(this->m_bAllBranch)
2110 m_LogList.m_ShowMask|=CGit::LOG_INFO_ALL_BRANCH;
2111 else
2112 m_LogList.m_ShowMask&=~CGit::LOG_INFO_ALL_BRANCH;
2113
2114 OnRefresh();
2115
2116 FillLogMessageCtrl(false);
2117 }
2118
2119 void CLogDlg::OnBnClickedFollowRenames()
2120 {
2121 this->UpdateData();
2122
2123 if(m_bFollowRenames)
2124 {
2125 m_LogList.m_ShowMask |= CGit::LOG_INFO_FOLLOW;
2126 if (m_bAllBranch)
2127 {
2128
2129 m_bAllBranch = FALSE;
2130 m_LogList.m_ShowMask &=~ CGit::LOG_INFO_ALL_BRANCH;
2131 }
2132
2133 }
2134 else
2135 m_LogList.m_ShowMask &= ~CGit::LOG_INFO_FOLLOW;
2136
2137 DialogEnableWindow(IDC_LOG_ALLBRANCH, !m_bFollowRenames);
2138 DialogEnableWindow(IDC_SHOWWHOLEPROJECT, !m_bFollowRenames);
2139
2140 OnRefresh();
2141
2142 FillLogMessageCtrl(false);
2143 }
2144
2145 void CLogDlg::OnBnClickedShowTags()
2146 {
2147 this->UpdateData();
2148
2149 if (m_bShowTags)
2150 m_LogList.m_ShowRefMask |= LOGLIST_SHOWTAGS;
2151 else
2152 m_LogList.m_ShowRefMask &= ~LOGLIST_SHOWTAGS;
2153
2154 m_LogList.Invalidate();
2155 }
2156
2157 void CLogDlg::OnBnClickedBrowseRef()
2158 {
2159 CString newRef = CBrowseRefsDlg::PickRef(false,m_LogList.GetStartRef());
2160 if(newRef.IsEmpty())
2161 return;
2162
2163 SetStartRef(newRef);
2164 ((CButton*)GetDlgItem(IDC_LOG_ALLBRANCH))->SetCheck(0);
2165
2166 OnBnClickedAllBranch();
2167 }
2168
2169 void CLogDlg::ShowStartRef()
2170 {
2171 //Show ref name on top
2172 if(!::IsWindow(m_hWnd))
2173 return;
2174 if(m_bAllBranch)
2175 {
2176 m_staticRef.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_LOG_ALLBRANCHES)));
2177 m_staticRef.Invalidate(TRUE);
2178 return;
2179 }
2180
2181 CString showStartRef = m_LogList.GetStartRef();
2182 if(showStartRef.IsEmpty())
2183 {
2184 //Ref name is HEAD
2185 if (g_Git.Run(L"git symbolic-ref HEAD", &showStartRef, NULL, CP_UTF8))
2186 showStartRef = CString(MAKEINTRESOURCE(IDS_PROC_LOG_NOBRANCH));
2187 showStartRef.Trim(L"\r\n\t ");
2188 }
2189
2190
2191 if(wcsncmp(showStartRef,L"refs/",5) == 0)
2192 showStartRef = showStartRef.Mid(5);
2193 if(wcsncmp(showStartRef,L"heads/",6) == 0)
2194 showStartRef = showStartRef.Mid(6);
2195
2196 m_staticRef.SetWindowText(showStartRef);
2197 m_staticRef.Invalidate(TRUE);
2198 }
2199
2200 void CLogDlg::SetStartRef(const CString& StartRef)
2201 {
2202 m_LogList.SetStartRef(StartRef);
2203
2204 if (m_hightlightRevision.IsEmpty())
2205 {
2206 if (g_Git.GetHash(m_LogList.m_lastSelectedHash, StartRef))
2207 {
2208 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + StartRef + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
2209 }
2210 m_hightlightRevision = m_LogList.m_lastSelectedHash;
2211 }
2212
2213 ShowStartRef();
2214 }
2215
2216
2217 void CLogDlg::OnBnClickedFirstParent()
2218 {
2219 this->UpdateData();
2220
2221 if(this->m_bFirstParent)
2222 m_LogList.m_ShowMask|=CGit::LOG_INFO_FIRST_PARENT;
2223 else
2224 m_LogList.m_ShowMask&=~CGit::LOG_INFO_FIRST_PARENT;
2225
2226 OnRefresh();
2227
2228 FillLogMessageCtrl(false);
2229
2230 }
2231
2232 void CLogDlg::OnBnClickShowWholeProject()
2233 {
2234 this->UpdateData();
2235
2236 if(this->m_bWholeProject)
2237 {
2238 m_LogList.m_Path.Reset();
2239 SetDlgTitle();
2240 DialogEnableWindow(IDC_LOG_FOLLOWRENAMES, FALSE);
2241 }
2242 else
2243 {
2244 m_LogList.m_Path=m_path;
2245 DialogEnableWindow(IDC_LOG_FOLLOWRENAMES, !(m_path.IsEmpty() || m_path.IsDirectory()));
2246 }
2247
2248 SetDlgTitle();
2249
2250 OnRefresh();
2251
2252 FillLogMessageCtrl(false);
2253
2254 }
2255
2256 LRESULT CLogDlg::OnRefLogChanged(WPARAM /*wParam*/, LPARAM /*lParam*/)
2257 {
2258 ShowStartRef();
2259 return 0;
2260 }
2261
2262 LRESULT CLogDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
2263 {
2264 m_pTaskbarList.Release();
2265 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
2266 return 0;
2267 }
Windows Explorer Extension to Operate Git