?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid UNREFERENCED_PARAMETER(...)
[TortoiseGit.git] / src / TortoiseProc / LogDlg.cpp
blob981f4ce427ec89fb434fa0a0b973c5dd80e3e330
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 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
235
236 m_hAccel = LoadAccelerators(AfxGetResourceHandle(),MAKEINTRESOURCE(IDR_ACC_LOGDLG));
237
238 // use the state of the "stop on copy/rename" option from the last time
239 UpdateData(FALSE);
240
241 // set the font to use in the log message view, configured in the settings dialog
242 CAppUtils::CreateFontForLogs(m_logFont);
243 GetDlgItem(IDC_MSGVIEW)->SetFont(&m_logFont);
244 // automatically detect URLs in the log message and turn them into links
245 GetDlgItem(IDC_MSGVIEW)->SendMessage(EM_AUTOURLDETECT, TRUE, NULL);
246 // make the log message rich edit control send a message when the mouse pointer is over a link
247 GetDlgItem(IDC_MSGVIEW)->SendMessage(EM_SETEVENTMASK, NULL, ENM_LINK);
248 //m_LogList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER | LVS_EX_SUBITEMIMAGES);
249
250 // the "hide unrelated paths" checkbox should be indeterminate
251 m_cHidePaths.SetCheck(BST_INDETERMINATE);
252
253
254 //SetWindowTheme(m_LogList.GetSafeHwnd(), L"Explorer", NULL);
255 //SetWindowTheme(m_ChangedFileListCtrl.GetSafeHwnd(), L"Explorer", NULL);
256
257 // set up the columns
258 m_LogList.DeleteAllItems();
259
260 m_LogList.m_Path=m_path;
261 m_LogList.m_hasWC = m_LogList.m_bShowWC = !g_GitAdminDir.IsBareRepo(g_Git.m_CurrentDir);
262 m_LogList.InsertGitColumn();
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_HIDEPATHS);
281 AdjustControlSize(IDC_LOG_FIRSTPARENT);
282 AdjustControlSize(IDC_LOG_ALLBRANCH);
283 AdjustControlSize(IDC_SHOWWHOLEPROJECT);
284 AdjustControlSize(IDC_LOG_FOLLOWRENAMES);
285 AdjustControlSize(IDC_LOG_SHOWTAGS);
286
287 GetClientRect(m_DlgOrigRect);
288 m_LogList.GetClientRect(m_LogListOrigRect);
289 GetDlgItem(IDC_MSGVIEW)->GetClientRect(m_MsgViewOrigRect);
290 m_ChangedFileListCtrl.GetClientRect(m_ChgOrigRect);
291
292 m_DateFrom.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);
293 m_DateTo.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);
294
295 m_staticRef.SetURL(CString());
296
297 // resizable stuff
298 AddAnchor(IDC_STATIC_REF, TOP_LEFT);
299 //AddAnchor(IDC_BUTTON_BROWSE_REF, TOP_LEFT);
300 AddAnchor(IDC_FROMLABEL, TOP_LEFT);
301 AddAnchor(IDC_DATEFROM, TOP_LEFT);
302 AddAnchor(IDC_TOLABEL, TOP_LEFT);
303 AddAnchor(IDC_DATETO, TOP_LEFT);
304
305 SetFilterCueText();
306 AddAnchor(IDC_SEARCHEDIT, TOP_LEFT, TOP_RIGHT);
307 AddAnchor(IDC_LOG_JUMPTYPE, TOP_RIGHT);
308 AddAnchor(IDC_LOG_JUMPUP, TOP_RIGHT);
309 AddAnchor(IDC_LOG_JUMPDOWN, TOP_RIGHT);
310
311 AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);
312 AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);
313 AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);
314 AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);
315 AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);
316
317 AddAnchor(IDC_LOGINFO, BOTTOM_LEFT, BOTTOM_RIGHT);
318 AddAnchor(IDC_HIDEPATHS, BOTTOM_LEFT);
319 AddAnchor(IDC_LOG_ALLBRANCH,BOTTOM_LEFT);
320 AddAnchor(IDC_LOG_FOLLOWRENAMES, BOTTOM_LEFT);
321 AddAnchor(IDC_LOG_FIRSTPARENT, BOTTOM_LEFT);
322 AddAnchor(IDC_SHOWWHOLEPROJECT, BOTTOM_LEFT);
323 AddAnchor(IDC_LOG_SHOWTAGS, BOTTOM_LEFT);
324 AddAnchor(IDC_REFRESH, BOTTOM_LEFT);
325 AddAnchor(IDC_STATBUTTON, BOTTOM_RIGHT);
326 AddAnchor(IDC_PROGRESS, BOTTOM_LEFT, BOTTOM_RIGHT);
327 AddAnchor(IDOK, BOTTOM_RIGHT);
328 AddAnchor(IDCANCEL, BOTTOM_RIGHT);
329 AddAnchor(IDHELP, BOTTOM_RIGHT);
330
331 if(this->m_bAllBranch)
332 m_LogList.m_ShowMask|=CGit::LOG_INFO_ALL_BRANCH;
333 else
334 m_LogList.m_ShowMask&=~CGit::LOG_INFO_ALL_BRANCH;
335
336 if (m_bShowTags)
337 m_LogList.m_ShowRefMask |= LOGLIST_SHOWTAGS;
338 else
339 m_LogList.m_ShowRefMask &= ~LOGLIST_SHOWTAGS;
340
341 // SetPromptParentWindow(m_hWnd);
342 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_AUTHOREMAIL)));
343 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_COMMITTEREMAIL)));
344 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_MERGEPOINT)));
345 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_PARENT1)));
346 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_PARENT2)));
347 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_TAG)));
348 m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_TAG_FF)));
349 m_JumpType.SetCurSel(0);
350 m_JumpUp.SetIcon((HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_JUMPUP), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR));
351 m_JumpDown.SetIcon((HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_JUMPDOWN), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR));
352
353 if (hWndExplorer)
354 CenterWindow(CWnd::FromHandle(hWndExplorer));
355 EnableSaveRestore(_T("LogDlg"));
356
357 DWORD yPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));
358 DWORD yPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));
359 RECT rcDlg, rcLogList, rcChgMsg;
360 GetClientRect(&rcDlg);
361 m_LogList.GetWindowRect(&rcLogList);
362 ScreenToClient(&rcLogList);
363 m_ChangedFileListCtrl.GetWindowRect(&rcChgMsg);
364 ScreenToClient(&rcChgMsg);
365 if (yPos1)
366 {
367 RECT rectSplitter;
368 m_wndSplitter1.GetWindowRect(&rectSplitter);
369 ScreenToClient(&rectSplitter);
370 int delta = yPos1 - rectSplitter.top;
371
372 if ((rcLogList.bottom + delta > rcLogList.top)&&(rcLogList.bottom + delta < rcChgMsg.bottom - 30))
373 {
374 m_wndSplitter1.SetWindowPos(NULL, rectSplitter.left, yPos1, 0, 0, SWP_NOSIZE);
375 DoSizeV1(delta);
376 }
377 }
378 if (yPos2)
379 {
380 RECT rectSplitter;
381 m_wndSplitter2.GetWindowRect(&rectSplitter);
382 ScreenToClient(&rectSplitter);
383 int delta = yPos2 - rectSplitter.top;
384
385 if ((rcChgMsg.top + delta < rcChgMsg.bottom)&&(rcChgMsg.top + delta > rcLogList.top + 30))
386 {
387 m_wndSplitter2.SetWindowPos(NULL, rectSplitter.left, yPos2, 0, 0, SWP_NOSIZE);
388 DoSizeV2(delta);
389 }
390 }
391
392 SetSplitterRange();
393
394 if (m_bSelect)
395 {
396 // the dialog is used to select revisions
397 // enable the OK button if appropriate
398 EnableOKButton();
399 }
400 else
401 {
402 // the dialog is used to just view log messages
403 // hide the OK button and set text on Cancel button to OK
404 GetDlgItemText(IDOK, temp);
405 SetDlgItemText(IDCANCEL, temp);
406 GetDlgItem(IDOK)->ShowWindow(SW_HIDE);
407 }
408
409 // first start a thread to obtain the log messages without
410 // blocking the dialog
411 //m_tTo = 0;
412 //m_tFrom = (DWORD)-1;
413
414 // scroll to user selected or current revision
415 if (!m_hightlightRevision.IsEmpty() && m_hightlightRevision.GetLength() >= GIT_HASH_SIZE)
416 m_LogList.m_lastSelectedHash = m_hightlightRevision;
417 else if (!m_LogList.m_endrev.IsEmpty() && m_LogList.m_endrev.GetLength() >= GIT_HASH_SIZE)
418 m_LogList.m_lastSelectedHash = m_hightlightRevision;
419 else
420 {
421 if (g_Git.GetHash(m_LogList.m_lastSelectedHash, _T("HEAD")))
422 MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash.")), _T("TortoiseGit"), MB_ICONERROR);
423 }
424
425 if (m_path.IsEmpty() || m_path.IsDirectory())
426 DialogEnableWindow(IDC_LOG_FOLLOWRENAMES, FALSE);
427
428 m_LogList.FetchLogAsync(this);
429
430 GetDlgItem(IDC_LOGLIST)->SetFocus();
431
432 ShowStartRef();
433 return FALSE;
434 }
435
436 LRESULT CLogDlg::OnLogListLoading(WPARAM wParam, LPARAM /*lParam*/)
437 {
438 int cur=(int)wParam;
439
440 if( cur == GITLOG_START )
441 {
442 CString temp;
443 temp.LoadString(IDS_PROGRESSWAIT);
444
445 this->m_LogList.ShowText(temp, true);
446
447 // We use a progress bar while getting the logs
448 m_LogProgress.SetRange32(0, 100);
449 m_LogProgress.SetPos(0);
450 if (m_pTaskbarList)
451 {
452 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
453 m_pTaskbarList->SetProgressValue(m_hWnd, 0, 100);
454 }
455
456 GetDlgItem(IDC_PROGRESS)->ShowWindow(TRUE);
457
458 //DialogEnableWindow(IDC_SHOWWHOLEPROJECT, FALSE);
459 //DialogEnableWindow(IDC_LOG_FIRSTPARENT, FALSE);
460 DialogEnableWindow(IDC_STATBUTTON, FALSE);
461 //DialogEnableWindow(IDC_REFRESH, FALSE);
462 DialogEnableWindow(IDC_HIDEPATHS,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);
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_HIDEPATHS,TRUE);
481
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(int 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 void CLogDlg::FillLogMessageCtrl(bool bShow /* = true*/)
593 {
594 // we fill here the log message rich edit control,
595 // and also populate the changed files list control
596 // according to the selected revision(s).
597
598 CRichEditCtrl * pMsgView = (CRichEditCtrl*)GetDlgItem(IDC_MSGVIEW);
599 // empty the log message view
600 pMsgView->SetWindowText(_T(" "));
601 // empty the changed files list
602 m_ChangedFileListCtrl.SetRedraw(FALSE);
603 // InterlockedExchange(&m_bNoDispUpdates, TRUE);
604 m_currentChangedArray = NULL;
605 //m_ChangedFileListCtrl.SetExtendedStyle ( LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER );
606 m_ChangedFileListCtrl.DeleteAllItems();
607
608 // if we're not here to really show a selected revision, just
609 // get out of here after clearing the views, which is what is intended
610 // if that flag is not set.
611 if (!bShow)
612 {
613 // force a redraw
614 m_ChangedFileListCtrl.Invalidate();
615 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
616 m_ChangedFileListCtrl.SetRedraw(TRUE);
617 return;
618 }
619
620 // depending on how many revisions are selected, we have to do different
621 // tasks.
622 int selCount = m_LogList.GetSelectedCount();
623 if (selCount == 0)
624 {
625 // if nothing is selected, we have nothing more to do
626 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
627 m_ChangedFileListCtrl.SetRedraw(TRUE);
628 return;
629 }
630 else if (selCount == 1)
631 {
632 // if one revision is selected, we have to fill the log message view
633 // with the corresponding log message, and also fill the changed files
634 // list fully.
635 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
636 int selIndex = m_LogList.GetNextSelectedItem(pos);
637 if (selIndex >= m_LogList.m_arShownList.GetCount())
638 {
639 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
640 m_ChangedFileListCtrl.SetRedraw(TRUE);
641 return;
642 }
643 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(selIndex));
644
645 {
646 // set the log message text
647 pMsgView->SetWindowText(CString(MAKEINTRESOURCE(IDS_HASH)) + _T(": ") + pLogEntry->m_CommitHash.ToString() + _T("\r\n\r\n"));
648 // turn bug ID's into links if the bugtraq: properties have been set
649 // and we can find a match of those in the log message
650
651 pMsgView->SetSel(-1,-1);
652 CHARFORMAT2 format;
653 SecureZeroMemory(&format, sizeof(CHARFORMAT2));
654 format.cbSize = sizeof(CHARFORMAT2);
655 format.dwMask = CFM_BOLD;
656 format.dwEffects = CFE_BOLD;
657 pMsgView->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
658
659 CString msg=_T("* ");
660 msg+=pLogEntry->GetSubject();
661 pMsgView->ReplaceSel(msg);
662
663 pMsgView->SetSel(-1,-1);
664 format.dwEffects = 0;
665 pMsgView->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
666
667 msg=_T("\n");
668 msg+=pLogEntry->GetBody();
669
670 if(!pLogEntry->m_Notes.IsEmpty())
671 {
672 msg+= _T("\n*") + CString(MAKEINTRESOURCE(IDS_NOTES)) + _T("* ");
673 msg+= pLogEntry->m_Notes;
674 msg+= _T("\n\n");
675 }
676
677 msg+=GetTagInfo(pLogEntry);
678
679 pMsgView->ReplaceSel(msg);
680
681 CString text;
682 pMsgView->GetWindowText(text);
683 // the rich edit control doesn't count the CR char!
684 // to be exact: CRLF is treated as one char.
685 text.Remove('\r');
686
687 m_LogList.m_ProjectProperties.FindBugID(text, pMsgView);
688 if (((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\StyleCommitMessages"), TRUE)) == TRUE)
689 CAppUtils::FormatTextInRichEditControl(pMsgView);
690
691 int HidePaths=m_cHidePaths.GetState() & 0x0003;
692 CString matchpath=this->m_path.GetGitPathString();
693
694 int count = pLogEntry->GetFiles(&m_LogList).GetCount();
695 for(int i=0;i<count && (!matchpath.IsEmpty());i++)
696 {
697 if( m_bWholeProject )
698 break;
699
700 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action &= ~(CTGitPath::LOGACTIONS_HIDE|CTGitPath::LOGACTIONS_GRAY);
701
702 if(pLogEntry->GetFiles(&m_LogList)[i].GetGitPathString().Left(matchpath.GetLength()) != matchpath && pLogEntry->GetFiles(&m_LogList)[i].GetGitOldPathString().Left(matchpath.GetLength()) != matchpath)
703 {
704 if(HidePaths==BST_CHECKED)
705 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action |= CTGitPath::LOGACTIONS_HIDE;
706 if(HidePaths==BST_INDETERMINATE)
707 ((CTGitPath&)pLogEntry->GetFiles(&m_LogList)[i]).m_Action |= CTGitPath::LOGACTIONS_GRAY;
708 }
709 }
710
711 m_ChangedFileListCtrl.UpdateWithGitPathList(pLogEntry->GetFiles(&m_LogList));
712 m_ChangedFileListCtrl.m_CurrentVersion=pLogEntry->m_CommitHash;
713 if (pLogEntry->m_CommitHash.IsEmpty() && m_bShowUnversioned)
714 {
715 m_ChangedFileListCtrl.UpdateUnRevFileList(pLogEntry->GetUnRevFiles());
716 m_ChangedFileListCtrl.Show(GITSLC_SHOWVERSIONED | GITSLC_SHOWUNVERSIONED);
717 }
718 else
719 m_ChangedFileListCtrl.Show(GITSLC_SHOWVERSIONED);
720
721 m_ChangedFileListCtrl.SetBusyString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_FETCHINGFILES)));
722
723 if(!pLogEntry->m_IsDiffFiles)
724 m_ChangedFileListCtrl.SetBusy(TRUE);
725 else
726 m_ChangedFileListCtrl.SetBusy(FALSE);
727
728 m_ChangedFileListCtrl.SetRedraw(TRUE);
729 return;
730 }
731
732 }
733 else
734 {
735 // more than one revision is selected:
736 // the log message view must be emptied
737 // the changed files list contains all the changed paths from all
738 // selected revisions, with 'doubles' removed
739 m_currentChangedPathList = GetChangedPathsFromSelectedRevisions(true);
740 }
741
742 // redraw the views
743 // InterlockedExchange(&m_bNoDispUpdates, FALSE);
744 #if 0
745 if (m_currentChangedArray)
746 {
747 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedArray->GetCount());
748 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedArray->GetCount());
749 }
750 else if (m_currentChangedPathList.GetCount())
751 {
752 m_ChangedFileListCtrl.SetItemCountEx(m_currentChangedPathList.GetCount());
753 m_ChangedFileListCtrl.RedrawItems(0, m_currentChangedPathList.GetCount());
754 }
755 else
756 {
757 m_ChangedFileListCtrl.SetItemCountEx(0);
758 m_ChangedFileListCtrl.Invalidate();
759 }
760 #endif
761 // sort according to the settings
762 if (m_nSortColumnPathList > 0)
763 SetSortArrow(&m_ChangedFileListCtrl, m_nSortColumnPathList, m_bAscendingPathList);
764 else
765 SetSortArrow(&m_ChangedFileListCtrl, -1, false);
766 m_ChangedFileListCtrl.SetRedraw(TRUE);
767
768 }
769
770 void CLogDlg::OnBnClickedRefresh()
771 {
772 Refresh (true);
773 }
774
775 void CLogDlg::Refresh (bool clearfilter /*autoGoOnline*/)
776 {
777 m_limit = 0;
778 m_LogList.Refresh(clearfilter);
779 ShowStartRef();
780 FillLogMessageCtrl(false);
781 }
782
783
784
785 BOOL CLogDlg::Cancel()
786 {
787 return m_bCancelled;
788 }
789
790 void CLogDlg::SaveSplitterPos()
791 {
792 if (!IsIconic())
793 {
794 CRegDWORD regPos1 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1"));
795 CRegDWORD regPos2 = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2"));
796 RECT rectSplitter;
797 m_wndSplitter1.GetWindowRect(&rectSplitter);
798 ScreenToClient(&rectSplitter);
799 regPos1 = rectSplitter.top;
800 m_wndSplitter2.GetWindowRect(&rectSplitter);
801 ScreenToClient(&rectSplitter);
802 regPos2 = rectSplitter.top;
803 }
804 }
805
806 void CLogDlg::OnCancel()
807 {
808 this->ShowWindow(SW_HIDE);
809
810 // canceling means stopping the working thread if it's still running.
811 m_LogList.SafeTerminateAsyncDiffThread();
812 if (this->IsThreadRunning())
813 {
814 m_LogList.SafeTerminateThread();
815 }
816 UpdateData();
817
818 SaveSplitterPos();
819 __super::OnCancel();
820 }
821
822 void CLogDlg::CopyChangedSelectionToClipBoard()
823 {
824
825 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
826 if (pos == NULL)
827 return; // nothing is selected, get out of here
828
829 CString sPaths;
830
831 // CGitRev* pLogEntry = reinterpret_cast<CGitRev* >(m_LogList.m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
832 // if (pos)
833 {
834 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
835 while (pos)
836 {
837 int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
838 CTGitPath *path = (CTGitPath*)m_ChangedFileListCtrl.GetItemData(nItem);
839 if(path)
840 sPaths += path->GetGitPathString();
841 sPaths += _T("\r\n");
842 }
843 }
844 #if 0
845 else
846 {
847 // only one revision is selected in the log dialog top pane
848 // but multiple items could be selected in the changed items list
849 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
850 while (pos)
851 {
852 int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
853 LogChangedPath * changedlogpath = pLogEntry->pArChangedPaths->SafeGetAt(nItem);
854
855 if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)
856 {
857 // some items are hidden! So find out which item the user really selected
858 INT_PTR selRealIndex = -1;
859 for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)
860 {
861 if (pLogEntry->pArChangedPaths->SafeGetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)
862 selRealIndex++;
863 if (selRealIndex == nItem)
864 {
865 changedlogpath = pLogEntry->pArChangedPaths->SafeGetAt(hiddenindex);
866 break;
867 }
868 }
869 }
870 if (changedlogpath)
871 {
872 sPaths += changedlogpath->sPath;
873 sPaths += _T("\r\n");
874 }
875 }
876 }
877 #endif
878 sPaths.Trim();
879 CStringUtils::WriteAsciiStringToClipboard(sPaths, GetSafeHwnd());
880
881 }
882
883 void CLogDlg::OnContextMenu(CWnd* pWnd, CPoint point)
884 {
885 // we have two separate context menus:
886 // one shown on the log message list control,
887 // the other shown in the changed-files list control
888 int selCount = m_LogList.GetSelectedCount();
889 if ((selCount == 1)&&(pWnd == GetDlgItem(IDC_MSGVIEW)))
890 {
891 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
892 int selIndex = -1;
893 if (pos)
894 selIndex = m_LogList.GetNextSelectedItem(pos);
895
896 GitRev *pRev = ((GitRev*)m_LogList.m_arShownList[selIndex]);
897
898 if ((point.x == -1) && (point.y == -1))
899 {
900 CRect rect;
901 GetDlgItem(IDC_MSGVIEW)->GetClientRect(&rect);
902 ClientToScreen(&rect);
903 point = rect.CenterPoint();
904 }
905 CString sMenuItemText;
906 CIconMenu popup;
907 if (popup.CreatePopupMenu())
908 {
909 // add the 'default' entries
910 sMenuItemText.LoadString(IDS_SCIEDIT_COPY);
911 popup.AppendMenu(MF_STRING | MF_ENABLED, WM_COPY, sMenuItemText);
912 sMenuItemText.LoadString(IDS_SCIEDIT_SELECTALL);
913 popup.AppendMenu(MF_STRING | MF_ENABLED, EM_SETSEL, sMenuItemText);
914 sMenuItemText.LoadString(IDS_EDIT_NOTES);
915 popup.AppendMenuIcon( CGitLogList::ID_EDITNOTE, sMenuItemText, IDI_EDIT);
916
917 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
918 switch (cmd)
919 {
920 case 0:
921 break; // no command selected
922 case EM_SETSEL:
923 case WM_COPY:
924 ::SendMessage(GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), cmd, 0, -1);
925 break;
926 case CGitLogList::ID_EDITNOTE:
927 CAppUtils::EditNote(pRev);
928 this->FillLogMessageCtrl(true);
929 break;
930 }
931 }
932 }
933 }
934
935 void CLogDlg::OnOK()
936 {
937 // since the log dialog is also used to select revisions for other
938 // dialogs, we have to do some work before closing this dialog
939 if (GetFocus() != GetDlgItem(IDOK))
940 return; // if the "OK" button doesn't have the focus, do nothing: this prevents closing the dialog when pressing enter
941
942 m_LogList.SafeTerminateAsyncDiffThread();
943 if (this->IsThreadRunning())
944 {
945 m_LogList.SafeTerminateThread();
946 }
947 UpdateData();
948 // check that one and only one row is selected
949 if (m_LogList.GetSelectedCount() == 1)
950 {
951 // get the selected row
952 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
953 int selIndex = m_LogList.GetNextSelectedItem(pos);
954 if (selIndex < m_LogList.m_arShownList.GetCount())
955 {
956 // all ok, pick up the revision
957 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(selIndex));
958 // extract the hash
959 m_sSelectedHash = pLogEntry->m_CommitHash;
960 }
961 }
962 UpdateData(FALSE);
963 SaveSplitterPos();
964 __super::OnOK();
965
966 #if 0
967 if (!GetDlgItem(IDOK)->IsWindowVisible() && GetFocus() != GetDlgItem(IDCANCEL))
968 return; // the Cancel button works as the OK button. But if the cancel button has not the focus, do nothing.
969
970 CString temp;
971 CString buttontext;
972 GetDlgItemText(IDOK, buttontext);
973 temp.LoadString(IDS_MSGBOX_CANCEL);
974 if (temp.Compare(buttontext) != 0)
975 __super::OnOK(); // only exit if the button text matches, and that will match only if the thread isn't running anymore
976 m_bCancelled = TRUE;
977 m_selectedRevs.Clear();
978 m_selectedRevsOneRange.Clear();
979 if (m_pNotifyWindow)
980 {
981 int selIndex = m_LogList.GetSelectionMark();
982 if (selIndex >= 0)
983 {
984 PLOGENTRYDATA pLogEntry = NULL;
985 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
986 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
987 m_selectedRevs.AddRevision(pLogEntry->Rev);
988 git_revnum_t lowerRev = pLogEntry->Rev;
989 git_revnum_t higherRev = lowerRev;
990 while (pos)
991 {
992 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
993 git_revnum_t rev = pLogEntry->Rev;
994 m_selectedRevs.AddRevision(pLogEntry->Rev);
995 if (lowerRev > rev)
996 lowerRev = rev;
997 if (higherRev < rev)
998 higherRev = rev;
999 }
1000 if (m_sFilterText.IsEmpty() && m_nSortColumn == 0 && IsSelectionContinuous())
1001 {
1002 m_selectedRevsOneRange.AddRevRange(lowerRev, higherRev);
1003 }
1004 BOOL bSentMessage = FALSE;
1005 if (m_LogList.GetSelectedCount() == 1)
1006 {
1007 // if only one revision is selected, check if the path/url with which the dialog was started
1008 // was directly affected in that revision. If it was, then check if our path was copied from somewhere.
1009 // if it was copied, use the copy from revision as lowerRev
1010 if ((pLogEntry)&&(pLogEntry->pArChangedPaths)&&(lowerRev == higherRev))
1011 {
1012 CString sUrl = m_path.GetGitPathString();
1013 if (!m_path.IsUrl())
1014 {
1015 sUrl = GetURLFromPath(m_path);
1016 }
1017 sUrl = sUrl.Mid(m_sRepositoryRoot.GetLength());
1018 for (int cp = 0; cp < pLogEntry->pArChangedPaths->GetCount(); ++cp)
1019 {
1020 LogChangedPath * pData = pLogEntry->pArChangedPaths->SafeGetAt(cp);
1021 if (pData)
1022 {
1023 if (sUrl.Compare(pData->sPath) == 0)
1024 {
1025 if (!pData->sCopyFromPath.IsEmpty())
1026 {
1027 lowerRev = pData->lCopyFromRev;
1028 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART), lowerRev);
1029 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND), higherRev);
1030 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);
1031 bSentMessage = TRUE;
1032 }
1033 }
1034 }
1035 }
1036 }
1037 }
1038 if ( !bSentMessage )
1039 {
1040 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART | MERGE_REVSELECTMINUSONE), lowerRev);
1041 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND | MERGE_REVSELECTMINUSONE), higherRev);
1042 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);
1043 if (m_selectedRevsOneRange.GetCount())
1044 m_pNotifyWindow->SendMessage(WM_REVLISTONERANGE, 0, (LPARAM)&m_selectedRevsOneRange);
1045 }
1046 }
1047 }
1048 UpdateData();
1049 CRegDWORD reg = CRegDWORD(_T("Software\\TortoiseGit\\ShowAllEntry"));
1050 SaveSplitterPos();
1051 #endif
1052 }
1053
1054 void CLogDlg::DoDiffFromLog(INT_PTR selIndex, GitRev* rev1, GitRev* rev2, bool /*blame*/, bool /*unified*/)
1055 {
1056 DialogEnableWindow(IDOK, FALSE);
1057 // SetPromptApp(&theApp);
1058 theApp.DoWaitCursor(1);
1059
1060 CString temppath;
1061 GetTempPath(temppath);
1062
1063 CString file1;
1064 file1.Format(_T("%s%s_%s%s"),
1065 temppath,
1066 (*m_currentChangedArray)[selIndex].GetBaseFilename(),
1067 rev1->m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()),
1068 (*m_currentChangedArray)[selIndex].GetFileExtension());
1069
1070 CString file2;
1071 file2.Format(_T("%s\\%s_%s%s"),
1072 temppath,
1073 (*m_currentChangedArray)[selIndex].GetBaseFilename(),
1074 rev2->m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()),
1075 (*m_currentChangedArray)[selIndex].GetFileExtension());
1076
1077 CString cmd;
1078 CTGitPath &path = (CTGitPath &)(*m_currentChangedArray)[selIndex];
1079
1080 g_Git.GetOneFile(rev1->m_CommitHash.ToString(), path, file1);
1081 g_Git.GetOneFile(rev2->m_CommitHash.ToString(), path, file2);
1082
1083 CAppUtils::DiffFlags flags;
1084 CAppUtils::StartExtDiff(file1,file2,_T("A"),_T("B"),
1085 g_Git.m_CurrentDir + _T("\\") + path.GetWinPathString(), g_Git.m_CurrentDir + _T("\\") + path.GetWinPathString(),
1086 rev1->m_CommitHash.ToString(), rev2->m_CommitHash.ToString(),
1087 flags);
1088
1089 theApp.DoWaitCursor(-1);
1090 EnableOKButton();
1091 }
1092
1093 BOOL CLogDlg::PreTranslateMessage(MSG* pMsg)
1094 {
1095 // Skip Ctrl-C when copying text out of the log message or search filter
1096 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);
1097 if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')
1098 {
1099 if (GetFocus()==GetDlgItem(IDC_LOGLIST))
1100 {
1101 if (CRegDWORD(_T("Software\\TortoiseGit\\DiffByDoubleClickInLog"), FALSE))
1102 {
1103 m_LogList.DiffSelectedRevWithPrevious();
1104 return TRUE;
1105 }
1106 }
1107 }
1108 if (m_hAccel && !bSkipAccelerator)
1109 {
1110 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
1111 if (ret)
1112 return TRUE;
1113 }
1114
1115 if(::IsWindow(m_tooltips.m_hWnd))
1116 m_tooltips.RelayEvent(pMsg);
1117 return __super::PreTranslateMessage(pMsg);
1118 }
1119
1120
1121 BOOL CLogDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
1122 {
1123 //if (this->IsThreadRunning())
1124 if(m_LogList.m_bNoDispUpdates)
1125 {
1126 // only show the wait cursor over the list control
1127 if ((pWnd)&&
1128 ((pWnd == GetDlgItem(IDC_LOGLIST))||
1129 (pWnd == GetDlgItem(IDC_MSGVIEW))||
1130 (pWnd == GetDlgItem(IDC_LOGMSG))))
1131 {
1132 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));
1133 SetCursor(hCur);
1134 return TRUE;
1135 }
1136 }
1137 if ((pWnd) && (pWnd == GetDlgItem(IDC_MSGVIEW)))
1138 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1139
1140 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
1141 SetCursor(hCur);
1142 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1143 }
1144
1145 void CLogDlg::OnBnClickedHelp()
1146 {
1147 OnHelp();
1148 }
1149
1150 void CLogDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1151 {
1152 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1153 *pResult = 0;
1154 //if (this->IsThreadRunning())
1155 if(m_LogList.m_bNoDispUpdates)
1156 return;
1157 if (pNMLV->iItem >= 0)
1158 {
1159 this->m_LogList.m_nSearchIndex = pNMLV->iItem;
1160 GitRev* pLogEntry = reinterpret_cast<GitRev *>(m_LogList.m_arShownList.SafeGetAt(pNMLV->iItem));
1161 m_LogList.m_lastSelectedHash = pLogEntry->m_CommitHash;
1162 if (pNMLV->iSubItem != 0)
1163 return;
1164 if ((pNMLV->iItem == m_LogList.m_arShownList.GetCount()))
1165 {
1166 // remove the selected state
1167 if (pNMLV->uChanged & LVIF_STATE)
1168 {
1169 m_LogList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
1170 FillLogMessageCtrl();
1171 UpdateData(FALSE);
1172 UpdateLogInfoLabel();
1173 }
1174 return;
1175 }
1176 if (pNMLV->uChanged & LVIF_STATE)
1177 {
1178 FillLogMessageCtrl();
1179 UpdateData(FALSE);
1180 }
1181 }
1182 else
1183 {
1184 m_LogList.m_lastSelectedHash.Empty();
1185 FillLogMessageCtrl();
1186 UpdateData(FALSE);
1187 }
1188 EnableOKButton();
1189 UpdateLogInfoLabel();
1190 }
1191
1192 void CLogDlg::OnEnLinkMsgview(NMHDR *pNMHDR, LRESULT *pResult)
1193 {
1194 ENLINK *pEnLink = reinterpret_cast<ENLINK *>(pNMHDR);
1195 if (pEnLink->msg == WM_LBUTTONUP)
1196 {
1197 CString url, msg;
1198 GetDlgItemText(IDC_MSGVIEW, msg);
1199 msg.Replace(_T("\r\n"), _T("\n"));
1200 url = msg.Mid(pEnLink->chrg.cpMin, pEnLink->chrg.cpMax-pEnLink->chrg.cpMin);
1201 if (!::PathIsURL(url))
1202 {
1203 url = m_LogList.m_ProjectProperties.GetBugIDUrl(url);
1204 url = GetAbsoluteUrlFromRelativeUrl(url);
1205 }
1206 if (!url.IsEmpty())
1207 ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);
1208 }
1209 *pResult = 0;
1210 }
1211
1212 class CDateSorter
1213 {
1214 public:
1215 class CCommitPointer
1216 {
1217 public:
1218 CCommitPointer():m_cont(NULL){}
1219 CCommitPointer(const CCommitPointer& P_Right)
1220 : m_cont(NULL)
1221 {
1222 *this = P_Right;
1223 }
1224
1225 CCommitPointer& operator = (const CCommitPointer& P_Right)
1226 {
1227 if(IsPointer())
1228 {
1229 (*m_cont->m_parDates)[m_place] = P_Right.GetDate();
1230 (*m_cont->m_parFileChanges)[m_place] = P_Right.GetChanges();
1231 (*m_cont->m_parAuthors)[m_place] = P_Right.GetAuthor();
1232 }
1233 else
1234 {
1235 m_Date = P_Right.GetDate();
1236 m_Changes = P_Right.GetChanges();
1237 m_csAuthor = P_Right.GetAuthor();
1238 }
1239 return *this;
1240 }
1241
1242 void Clone(const CCommitPointer& P_Right)
1243 {
1244 m_cont = P_Right.m_cont;
1245 m_place = P_Right.m_place;
1246 m_Date = P_Right.m_Date;
1247 m_Changes = P_Right.m_Changes;
1248 m_csAuthor = P_Right.m_csAuthor;
1249 }
1250
1251 DWORD GetDate() const {return IsPointer() ? (*m_cont->m_parDates)[m_place] : m_Date;}
1252 DWORD GetChanges() const {return IsPointer() ? (*m_cont->m_parFileChanges)[m_place] : m_Changes;}
1253 CString GetAuthor() const {return IsPointer() ? (*m_cont->m_parAuthors)[m_place] : m_csAuthor;}
1254
1255 bool IsPointer() const {return m_cont != NULL;}
1256 //When pointer
1257 CDateSorter* m_cont;
1258 int m_place;
1259
1260 //When element
1261 DWORD m_Date;
1262 DWORD m_Changes;
1263 CString m_csAuthor;
1264
1265 };
1266 class iterator : public std::iterator<std::random_access_iterator_tag, CCommitPointer>
1267 {
1268 public:
1269 CCommitPointer m_ptr;
1270
1271 iterator(){}
1272 iterator(const iterator& P_Right){*this = P_Right;}
1273 iterator& operator=(const iterator& P_Right)
1274 {
1275 m_ptr.Clone(P_Right.m_ptr);
1276 return *this;
1277 }
1278
1279 CCommitPointer& operator*(){return m_ptr;}
1280 CCommitPointer* operator->(){return &m_ptr;}
1281 const CCommitPointer& operator*()const{return m_ptr;}
1282 const CCommitPointer* operator->()const{return &m_ptr;}
1283
1284 iterator& operator+=(size_t P_iOffset){m_ptr.m_place += (int)P_iOffset;return *this;}
1285 iterator& operator-=(size_t P_iOffset){m_ptr.m_place -= (int)P_iOffset;return *this;}
1286 iterator operator+(size_t P_iOffset)const{iterator it(*this); it += P_iOffset;return it;}
1287 iterator operator-(size_t P_iOffset)const{iterator it(*this); it -= P_iOffset;return it;}
1288
1289 iterator& operator++(){++m_ptr.m_place;return *this;}
1290 iterator& operator--(){--m_ptr.m_place;return *this;}
1291 iterator operator++(int){iterator it(*this);++*this;return it;}
1292 iterator operator--(int){iterator it(*this);--*this;return it;}
1293
1294 size_t operator-(const iterator& P_itRight)const{return m_ptr.m_place - P_itRight->m_place;}
1295
1296 bool operator<(const iterator& P_itRight)const{return m_ptr.m_place < P_itRight->m_place;}
1297 bool operator!=(const iterator& P_itRight)const{return m_ptr.m_place != P_itRight->m_place;}
1298 bool operator==(const iterator& P_itRight)const{return m_ptr.m_place == P_itRight->m_place;}
1299 bool operator>(const iterator& P_itRight)const{return m_ptr.m_place > P_itRight->m_place;}
1300 };
1301 iterator begin()
1302 {
1303 iterator it;
1304 it->m_place = 0;
1305 it->m_cont = this;
1306 return it;
1307 }
1308 iterator end()
1309 {
1310 iterator it;
1311 it->m_place = (int)m_parDates->GetCount();
1312 it->m_cont = this;
1313 return it;
1314 }
1315
1316 CDWordArray * m_parDates;
1317 CDWordArray * m_parFileChanges;
1318 CStringArray * m_parAuthors;
1319 };
1320
1321 class CDateSorterLess
1322 {
1323 public:
1324 bool operator () (const CDateSorter::CCommitPointer& P_Left, const CDateSorter::CCommitPointer& P_Right) const
1325 {
1326 return P_Left.GetDate() > P_Right.GetDate(); //Last date first
1327 }
1328
1329 };
1330
1331 void CLogDlg::OnBnClickedStatbutton()
1332 {
1333 if (this->IsThreadRunning())
1334 return;
1335 if (m_LogList.m_arShownList.IsEmpty() || m_LogList.m_arShownList.GetCount() == 1 && m_LogList.m_bShowWC)
1336 return; // nothing or just the working copy changes are shown, so no statistics.
1337 // the statistics dialog expects the log entries to be sorted by date
1338 SortByColumn(3, false);
1339 CThreadSafePtrArray shownlist(NULL);
1340 m_LogList.RecalculateShownList(&shownlist);
1341 // create arrays which are aware of the current filter
1342 CStringArray m_arAuthorsFiltered;
1343 CDWordArray m_arDatesFiltered;
1344 CDWordArray m_arFileChangesFiltered;
1345 for (INT_PTR i=0; i<shownlist.GetCount(); ++i)
1346 {
1347 GitRev* pLogEntry = reinterpret_cast<GitRev*>(shownlist.SafeGetAt(i));
1348
1349 // do not take working dir changes into statistics
1350 if (pLogEntry->m_CommitHash.IsEmpty()) {
1351 continue;
1352 }
1353
1354 CString strAuthor = pLogEntry->GetAuthorName();
1355 if ( strAuthor.IsEmpty() )
1356 {
1357 strAuthor.LoadString(IDS_STATGRAPH_EMPTYAUTHOR);
1358 }
1359 m_arAuthorsFiltered.Add(strAuthor);
1360 m_arDatesFiltered.Add(pLogEntry->GetCommitterDate().GetTime());
1361 m_arFileChangesFiltered.Add(pLogEntry->GetFiles(&m_LogList).GetCount());
1362 }
1363
1364 CDateSorter W_Sorter;
1365 W_Sorter.m_parAuthors = &m_arAuthorsFiltered;
1366 W_Sorter.m_parDates = &m_arDatesFiltered;
1367 W_Sorter.m_parFileChanges = &m_arFileChangesFiltered;
1368 std::sort(W_Sorter.begin(), W_Sorter.end(), CDateSorterLess());
1369
1370 CStatGraphDlg dlg;
1371 dlg.m_parAuthors = &m_arAuthorsFiltered;
1372 dlg.m_parDates = &m_arDatesFiltered;
1373 dlg.m_parFileChanges = &m_arFileChangesFiltered;
1374 dlg.m_path = m_orgPath;
1375 dlg.DoModal();
1376 // restore the previous sorting
1377 SortByColumn(m_nSortColumn, m_bAscending);
1378 OnTimer(LOGFILTER_TIMER);
1379 }
1380
1381 void CLogDlg::DoSizeV1(int delta)
1382 {
1383
1384 RemoveAnchor(IDC_LOGLIST);
1385 RemoveAnchor(IDC_SPLITTERTOP);
1386 RemoveAnchor(IDC_MSGVIEW);
1387 RemoveAnchor(IDC_SPLITTERBOTTOM);
1388 RemoveAnchor(IDC_LOGMSG);
1389 CSplitterControl::ChangeHeight(&m_LogList, delta, CW_TOPALIGN);
1390 CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), -delta, CW_BOTTOMALIGN);
1391 AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);
1392 AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);
1393 AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);
1394 AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);
1395 AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);
1396 ArrangeLayout();
1397 AdjustMinSize();
1398 SetSplitterRange();
1399 m_LogList.Invalidate();
1400 GetDlgItem(IDC_MSGVIEW)->Invalidate();
1401
1402 }
1403
1404 void CLogDlg::DoSizeV2(int delta)
1405 {
1406
1407 RemoveAnchor(IDC_LOGLIST);
1408 RemoveAnchor(IDC_SPLITTERTOP);
1409 RemoveAnchor(IDC_MSGVIEW);
1410 RemoveAnchor(IDC_SPLITTERBOTTOM);
1411 RemoveAnchor(IDC_LOGMSG);
1412 CSplitterControl::ChangeHeight(GetDlgItem(IDC_MSGVIEW), delta, CW_TOPALIGN);
1413 CSplitterControl::ChangeHeight(&m_ChangedFileListCtrl, -delta, CW_BOTTOMALIGN);
1414 AddAnchor(IDC_LOGLIST, TOP_LEFT, TOP_RIGHT);
1415 AddAnchor(IDC_SPLITTERTOP, TOP_LEFT, TOP_RIGHT);
1416 AddAnchor(IDC_MSGVIEW, TOP_LEFT, BOTTOM_RIGHT);
1417 AddAnchor(IDC_SPLITTERBOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT);
1418 AddAnchor(IDC_LOGMSG, BOTTOM_LEFT, BOTTOM_RIGHT);
1419 ArrangeLayout();
1420 AdjustMinSize();
1421 SetSplitterRange();
1422 GetDlgItem(IDC_MSGVIEW)->Invalidate();
1423 m_ChangedFileListCtrl.Invalidate();
1424
1425 }
1426
1427 void CLogDlg::AdjustMinSize()
1428 {
1429 // adjust the minimum size of the dialog to prevent the resizing from
1430 // moving the list control too far down.
1431 CRect rcChgListView;
1432 m_ChangedFileListCtrl.GetClientRect(rcChgListView);
1433 CRect rcLogList;
1434 m_LogList.GetClientRect(rcLogList);
1435
1436 SetMinTrackSize(CSize(m_DlgOrigRect.Width(),
1437 m_DlgOrigRect.Height()-m_ChgOrigRect.Height()-m_LogListOrigRect.Height()-m_MsgViewOrigRect.Height()
1438 +rcChgListView.Height()+rcLogList.Height()+60));
1439 }
1440
1441 LRESULT CLogDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
1442 {
1443 switch (message) {
1444 case WM_NOTIFY:
1445 if (wParam == IDC_SPLITTERTOP)
1446 {
1447 SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
1448 DoSizeV1(pHdr->delta);
1449 }
1450 else if (wParam == IDC_SPLITTERBOTTOM)
1451 {
1452 SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
1453 DoSizeV2(pHdr->delta);
1454 }
1455 break;
1456 }
1457
1458 return CResizableDialog::DefWindowProc(message, wParam, lParam);
1459 }
1460
1461 void CLogDlg::SetSplitterRange()
1462 {
1463 if ((m_LogList)&&(m_ChangedFileListCtrl))
1464 {
1465 CRect rcTop;
1466 m_LogList.GetWindowRect(rcTop);
1467 ScreenToClient(rcTop);
1468 CRect rcMiddle;
1469 GetDlgItem(IDC_MSGVIEW)->GetWindowRect(rcMiddle);
1470 ScreenToClient(rcMiddle);
1471 m_wndSplitter1.SetRange(rcTop.top+30, rcMiddle.bottom-20);
1472 CRect rcBottom;
1473 m_ChangedFileListCtrl.GetWindowRect(rcBottom);
1474 ScreenToClient(rcBottom);
1475 m_wndSplitter2.SetRange(rcMiddle.top+30, rcBottom.bottom-20);
1476 }
1477 }
1478
1479 LRESULT CLogDlg::OnClickedInfoIcon(WPARAM /*wParam*/, LPARAM lParam)
1480 {
1481 // FIXME: x64 version would get this function called with unexpected parameters.
1482 if (!lParam)
1483 return 0;
1484
1485 RECT * rect = (LPRECT)lParam;
1486 CPoint point;
1487 CString temp;
1488 point = CPoint(rect->left, rect->bottom);
1489 #define LOGMENUFLAGS(x) (MF_STRING | MF_ENABLED | (m_LogList.m_SelectedFilters & x ? MF_CHECKED : MF_UNCHECKED))
1490 CMenu popup;
1491 if (popup.CreatePopupMenu())
1492 {
1493 temp.LoadString(IDS_LOG_FILTER_SUBJECT);
1494 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_SUBJECT), LOGFILTER_SUBJECT, temp);
1495
1496 temp.LoadString(IDS_LOG_FILTER_MESSAGES);
1497 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_MESSAGES), LOGFILTER_MESSAGES, temp);
1498
1499 temp.LoadString(IDS_LOG_FILTER_PATHS);
1500 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_PATHS), LOGFILTER_PATHS, temp);
1501
1502 temp.LoadString(IDS_LOG_FILTER_AUTHORS);
1503 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_AUTHORS), LOGFILTER_AUTHORS, temp);
1504
1505 temp.LoadString(IDS_LOG_FILTER_REVS);
1506 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_REVS), LOGFILTER_REVS, temp);
1507
1508 if (m_LogList.m_bShowBugtraqColumn == TRUE) {
1509 temp.LoadString(IDS_LOG_FILTER_BUGIDS);
1510 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_BUGID), LOGFILTER_BUGID, temp);
1511 }
1512
1513 popup.AppendMenu(MF_SEPARATOR, NULL);
1514
1515 temp.LoadString(IDS_LOG_FILTER_REGEX);
1516 popup.AppendMenu(MF_STRING | MF_ENABLED | (m_bFilterWithRegex ? MF_CHECKED : MF_UNCHECKED), LOGFILTER_REGEX, temp);
1517
1518 m_tooltips.Pop();
1519 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1520 if (selection != 0)
1521 {
1522
1523 if (selection == LOGFILTER_REGEX)
1524 {
1525 m_bFilterWithRegex = !m_bFilterWithRegex;
1526 CRegDWORD b = CRegDWORD(_T("Software\\TortoiseGit\\UseRegexFilter"), TRUE);
1527 b = m_bFilterWithRegex;
1528 m_LogList.m_bFilterWithRegex = m_bFilterWithRegex;
1529 SetFilterCueText();
1530 CheckRegexpTooltip();
1531 }
1532 else
1533 {
1534 m_LogList.m_SelectedFilters ^= selection;
1535 SetFilterCueText();
1536 }
1537 SetTimer(LOGFILTER_TIMER, 1000, NULL);
1538 }
1539 }
1540 return 0L;
1541 }
1542
1543 LRESULT CLogDlg::OnClickedCancelFilter(WPARAM /*wParam*/, LPARAM /*lParam*/)
1544 {
1545
1546 KillTimer(LOGFILTER_TIMER);
1547
1548 m_LogList.m_sFilterText.Empty();
1549 UpdateData(FALSE);
1550 theApp.DoWaitCursor(1);
1551 CStoreSelection storeselection(this);
1552 FillLogMessageCtrl(false);
1553
1554 m_LogList.RemoveFilter();
1555
1556 Refresh();
1557
1558 CTime begin,end;
1559 m_LogList.GetTimeRange(begin,end);
1560 m_DateFrom.SetTime(&begin);
1561 m_DateTo.SetTime(&end);
1562
1563 theApp.DoWaitCursor(-1);
1564 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
1565 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
1566 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
1567 UpdateLogInfoLabel();
1568
1569 return 0L;
1570 }
1571
1572
1573 void CLogDlg::SetFilterCueText()
1574 {
1575 CString temp(MAKEINTRESOURCE(IDS_LOG_FILTER_BY));
1576 temp += _T(" ");
1577
1578 if (m_LogList.m_SelectedFilters & LOGFILTER_SUBJECT)
1579 {
1580 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_SUBJECT));
1581 }
1582
1583 if (m_LogList.m_SelectedFilters & LOGFILTER_MESSAGES)
1584 {
1585 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1586 temp += _T(", ");
1587 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_MESSAGES));
1588 }
1589
1590 if (m_LogList.m_SelectedFilters & LOGFILTER_PATHS)
1591 {
1592 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1593 temp += _T(", ");
1594 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_PATHS));
1595 }
1596
1597 if (m_LogList.m_SelectedFilters & LOGFILTER_AUTHORS)
1598 {
1599 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1600 temp += _T(", ");
1601 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_AUTHORS));
1602 }
1603
1604 if (m_LogList.m_SelectedFilters & LOGFILTER_REVS)
1605 {
1606 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1607 temp += _T(", ");
1608 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_REVS));
1609 }
1610
1611 if (m_LogList.m_SelectedFilters & LOGFILTER_BUGID)
1612 {
1613 if (temp.ReverseFind(_T(' ')) != temp.GetLength() - 1)
1614 temp += _T(", ");
1615 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_BUGIDS));
1616 }
1617
1618 // to make the cue banner text appear more to the right of the edit control
1619 temp = _T(" ")+temp;
1620 m_cFilter.SetCueBanner(temp.TrimRight());
1621 }
1622
1623 bool CLogDlg::Validate(LPCTSTR string)
1624 {
1625 if (!m_bFilterWithRegex)
1626 return true;
1627 tr1::wregex pat;
1628 return m_LogList.ValidateRegexp(string, pat, false);
1629 }
1630
1631
1632 void CLogDlg::OnTimer(UINT_PTR nIDEvent)
1633 {
1634 if (nIDEvent == LOGFTIME_TIMER)
1635 {
1636 KillTimer(LOGFTIME_TIMER);
1637 m_limit = 0;
1638 m_LogList.Refresh(FALSE);
1639 FillLogMessageCtrl(false);
1640 }
1641
1642 if (nIDEvent == LOGFILTER_TIMER)
1643 {
1644 KillTimer(LOGFILTER_TIMER);
1645 m_limit = 0;
1646 m_LogList.Refresh(FALSE);
1647 FillLogMessageCtrl(false);
1648
1649 #if 0
1650 /* we will use git built-in grep to filter log */
1651 if (this->IsThreadRunning())
1652 {
1653 // thread still running! So just restart the timer.
1654 SetTimer(LOGFILTER_TIMER, 1000, NULL);
1655 return;
1656 }
1657 CWnd * focusWnd = GetFocus();
1658 bool bSetFocusToFilterControl = ((focusWnd != GetDlgItem(IDC_DATEFROM))&&(focusWnd != GetDlgItem(IDC_DATETO))
1659 && (focusWnd != GetDlgItem(IDC_LOGLIST)));
1660 if (m_LogList.m_sFilterText.IsEmpty())
1661 {
1662 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty()))));
1663 // do not return here!
1664 // we also need to run the filter if the filter text is empty:
1665 // 1. to clear an existing filter
1666 // 2. to rebuild the m_arShownList after sorting
1667 }
1668 theApp.DoWaitCursor(1);
1669 CStoreSelection storeselection(this);
1670 KillTimer(LOGFILTER_TIMER);
1671 FillLogMessageCtrl(false);
1672
1673 // now start filter the log list
1674 m_LogList.StartFilter();
1675
1676 if ( m_LogList.GetItemCount()==1 )
1677 {
1678 m_LogList.SetSelectionMark(0);
1679 m_LogList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
1680 }
1681 theApp.DoWaitCursor(-1);
1682 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
1683 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
1684 if (bSetFocusToFilterControl)
1685 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
1686 UpdateLogInfoLabel();
1687 #endif
1688 } // if (nIDEvent == LOGFILTER_TIMER)
1689 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty() || m_LogList.m_arShownList.GetCount() == 1 && m_LogList.m_bShowWC))));
1690 __super::OnTimer(nIDEvent);
1691 }
1692
1693 void CLogDlg::OnDtnDatetimechangeDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)
1694 {
1695 try
1696 {
1697 CTime _time;
1698 m_DateTo.GetTime(_time);
1699
1700 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 23, 59, 59);
1701 if (time.GetTime() != m_LogList.m_To)
1702 {
1703 m_LogList.m_To = (DWORD)time.GetTime();
1704 SetTimer(LOGFTIME_TIMER, 10, NULL);
1705 }
1706 }
1707 catch (...)
1708 {
1709 CMessageBox::Show(NULL,_T("Invalidate Parameter"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1710 }
1711
1712 *pResult = 0;
1713 }
1714
1715 void CLogDlg::OnDtnDatetimechangeDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)
1716 {
1717
1718 try
1719 {
1720 CTime _time;
1721 m_DateFrom.GetTime(_time);
1722
1723 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 0, 0, 0);
1724 if (time.GetTime() != m_LogList.m_From)
1725 {
1726 m_LogList.m_From = (DWORD)time.GetTime();
1727 SetTimer(LOGFTIME_TIMER, 10, NULL);
1728 }
1729 }
1730 catch (...)
1731 {
1732 CMessageBox::Show(NULL,_T("Invalidate Parameter"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1733 }
1734
1735 *pResult = 0;
1736 }
1737
1738 void CLogDlg::OnCbnSelchangeJumpType()
1739 {
1740 // reserved for future use
1741 }
1742
1743 void CLogDlg::OnBnClickedJumpUp()
1744 {
1745 int sel = m_JumpType.GetCurSel();
1746 if (sel < 0) return;
1747 JumpType jumpType = (JumpType)sel;
1748
1749 CString strValue;
1750 CGitHash hashValue;
1751 int index = -1;
1752 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1753 if (pos)
1754 {
1755 index = m_LogList.GetNextSelectedItem(pos);
1756 if (index == 0) return;
1757
1758 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(index);
1759 if (jumpType == JumpType_AuthorEmail)
1760 strValue = data->GetAuthorEmail();
1761 else if (jumpType == JumpType_CommitterEmail)
1762 strValue = data->GetCommitterEmail();
1763 else if (jumpType == JumpType_Parent1)
1764 hashValue = data->m_CommitHash;
1765 else if (jumpType == JumpType_Parent2)
1766 hashValue = data->m_CommitHash;
1767 else if (jumpType == JumpType_TagFF)
1768 hashValue = data->m_CommitHash;
1769
1770 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1771 }
1772 else
1773 return;
1774
1775 while (pos)
1776 {
1777 index = m_LogList.GetNextSelectedItem(pos);
1778 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1779 }
1780 m_LogList.SetSelectionMark(-1);
1781
1782 for (int i = index - 1; i >= 0; i--)
1783 {
1784 bool found = false;
1785 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(i);
1786 if (jumpType == JumpType_AuthorEmail)
1787 found = strValue == data->GetAuthorEmail();
1788 else if (jumpType == JumpType_CommitterEmail)
1789 found = strValue == data->GetCommitterEmail();
1790 else if (jumpType == JumpType_MergePoint)
1791 found = data->ParentsCount() > 1;
1792 else if (jumpType == JumpType_Parent1)
1793 {
1794 if (data->m_ParentHash.size() > 0)
1795 found = data->m_ParentHash[0] == hashValue;
1796 }
1797 else if (jumpType == JumpType_Parent2)
1798 {
1799 if (data->m_ParentHash.size() > 1)
1800 found = data->m_ParentHash[1] == hashValue;
1801 }
1802 else if (jumpType == JumpType_Tag || jumpType == JumpType_TagFF)
1803 {
1804 STRING_VECTOR refList = m_LogList.m_HashMap[data->m_CommitHash];
1805 for (int j = 0; j < refList.size(); j++)
1806 {
1807 if (refList[j].Left(10) == _T("refs/tags/"))
1808 {
1809 found = true;
1810 break;
1811 }
1812 }
1813
1814 if (found && jumpType == JumpType_TagFF)
1815 found = g_Git.IsFastForward(hashValue, data->m_CommitHash);
1816 }
1817
1818 if (found)
1819 {
1820 m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
1821 m_LogList.EnsureVisible(i, FALSE);
1822 m_LogList.SetSelectionMark(i);
1823 return;
1824 }
1825 }
1826
1827 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, _T("NoJumpNotFoundWarning"), IDS_MSGBOX_DONOTSHOWAGAIN);
1828 }
1829
1830 void CLogDlg::OnBnClickedJumpDown()
1831 {
1832 int jumpType = m_JumpType.GetCurSel();
1833 if (jumpType < 0) return;
1834
1835 CString strValue;
1836 CGitHash hashValue;
1837 int index = -1;
1838 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1839 if (pos)
1840 {
1841 index = m_LogList.GetNextSelectedItem(pos);
1842 if (index == 0) return;
1843
1844 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(index);
1845 if (jumpType == JumpType_AuthorEmail)
1846 strValue = data->GetAuthorEmail();
1847 else if (jumpType == JumpType_CommitterEmail)
1848 strValue = data->GetCommitterEmail();
1849 else if (jumpType == JumpType_Parent1)
1850 {
1851 if (data->m_ParentHash.size() > 0)
1852 hashValue = data->m_ParentHash.at(0);
1853 else
1854 return;
1855 }
1856 else if (jumpType == JumpType_Parent2)
1857 {
1858 if (data->m_ParentHash.size() > 1)
1859 hashValue = data->m_ParentHash.at(1);
1860 else
1861 return;
1862 }
1863 else if (jumpType == JumpType_TagFF)
1864 hashValue = data->m_CommitHash;
1865
1866 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1867 }
1868 else
1869 return;
1870
1871 while (pos)
1872 {
1873 index = m_LogList.GetNextSelectedItem(pos);
1874 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1875 }
1876 m_LogList.SetSelectionMark(-1);
1877
1878 for (int i = index + 1; i < m_LogList.GetItemCount(); i++)
1879 {
1880 bool found = false;
1881 GitRev* data = (GitRev*)m_LogList.m_arShownList.SafeGetAt(i);
1882 if (jumpType == JumpType_AuthorEmail)
1883 found = strValue == data->GetAuthorEmail();
1884 else if (jumpType == JumpType_CommitterEmail)
1885 found = strValue == data->GetCommitterEmail();
1886 else if (jumpType == JumpType_MergePoint)
1887 found = data->ParentsCount() > 1;
1888 else if (jumpType == JumpType_Parent1)
1889 found = data->m_CommitHash == hashValue;
1890 else if (jumpType == JumpType_Parent2)
1891 found = data->m_CommitHash == hashValue;
1892 else if (jumpType == JumpType_Tag || jumpType == JumpType_TagFF)
1893 {
1894 STRING_VECTOR refList = m_LogList.m_HashMap[data->m_CommitHash];
1895 for (int j = 0; j < refList.size(); j++)
1896 {
1897 if (refList[j].Left(10) == _T("refs/tags/"))
1898 {
1899 found = true;
1900 break;
1901 }
1902 }
1903
1904 if (found && jumpType == JumpType_TagFF)
1905 found = g_Git.IsFastForward(data->m_CommitHash, hashValue);
1906 }
1907
1908 if (found)
1909 {
1910 m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
1911 m_LogList.EnsureVisible(i, FALSE);
1912 m_LogList.SetSelectionMark(i);
1913 return;
1914 }
1915 }
1916
1917 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, _T("NoJumpNotFoundWarning"), IDS_MSGBOX_DONOTSHOWAGAIN);
1918 }
1919
1920 CTGitPathList CLogDlg::GetChangedPathsFromSelectedRevisions(bool /*bRelativePaths*/ /* = false */, bool /*bUseFilter*/ /* = true */)
1921 {
1922 CTGitPathList pathList;
1923 #if 0
1924
1925 if (m_sRepositoryRoot.IsEmpty() && (bRelativePaths == false))
1926 {
1927 m_sRepositoryRoot = GetRepositoryRoot(m_path);
1928 }
1929 if (m_sRepositoryRoot.IsEmpty() && (bRelativePaths == false))
1930 return pathList;
1931
1932 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1933 if (pos != NULL)
1934 {
1935 while (pos)
1936 {
1937 int nextpos = m_LogList.GetNextSelectedItem(pos);
1938 if (nextpos >= m_arShownList.GetCount())
1939 continue;
1940 PLOGENTRYDATA pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(nextpos));
1941 LogChangedPathArray * cpatharray = pLogEntry->pArChangedPaths;
1942 for (INT_PTR cpPathIndex = 0; cpPathIndex<cpatharray->GetCount(); ++cpPathIndex)
1943 {
1944 LogChangedPath * cpath = cpatharray->SafeGetAt(cpPathIndex);
1945 if (cpath == NULL)
1946 continue;
1947 CTGitPath path;
1948 if (!bRelativePaths)
1949 path.SetFromGit(m_sRepositoryRoot);
1950 path.AppendPathString(cpath->sPath);
1951 if ((!bUseFilter)||
1952 ((m_cHidePaths.GetState() & 0x0003)!=BST_CHECKED)||
1953 (cpath->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0))
1954 pathList.AddPath(path);
1955
1956 }
1957 }
1958 }
1959 pathList.RemoveDuplicates();
1960 #endif
1961 return pathList;
1962 }
1963
1964 void CLogDlg::SortByColumn(int /*nSortColumn*/, bool /*bAscending*/)
1965 {
1966 #if 0
1967 switch(nSortColumn)
1968 {
1969 case 0: // Revision
1970 {
1971 if(bAscending)
1972 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscRevSort());
1973 else
1974 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescRevSort());
1975 }
1976 break;
1977 case 1: // action
1978 {
1979 if(bAscending)
1980 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscActionSort());
1981 else
1982 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescActionSort());
1983 }
1984 break;
1985 case 2: // Author
1986 {
1987 if(bAscending)
1988 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscAuthorSort());
1989 else
1990 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescAuthorSort());
1991 }
1992 break;
1993 case 3: // Date
1994 {
1995 if(bAscending)
1996 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscDateSort());
1997 else
1998 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescDateSort());
1999 }
2000 break;
2001 case 4: // Message or bug id
2002 if (m_bShowBugtraqColumn)
2003 {
2004 if(bAscending)
2005 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscBugIDSort());
2006 else
2007 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescBugIDSort());
2008 break;
2009 }
2010 // fall through here
2011 case 5: // Message
2012 {
2013 if(bAscending)
2014 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscMessageSort());
2015 else
2016 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescMessageSort());
2017 }
2018 break;
2019 default:
2020 ATLASSERT(0);
2021 break;
2022 }
2023 #endif
2024 }
2025
2026 void CLogDlg::OnLvnColumnclick(NMHDR *pNMHDR, LRESULT *pResult)
2027 {
2028 if (this->IsThreadRunning())
2029 return; //no sorting while the arrays are filled
2030 #if 0
2031 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
2032 const int nColumn = pNMLV->iSubItem;
2033 m_bAscending = nColumn == m_nSortColumn ? !m_bAscending : TRUE;
2034 m_nSortColumn = nColumn;
2035 SortByColumn(m_nSortColumn, m_bAscending);
2036 SetSortArrow(&m_LogList, m_nSortColumn, !!m_bAscending);
2037 SortShownListArray();
2038 m_LogList.Invalidate();
2039 UpdateLogInfoLabel();
2040 #else
2041 UNREFERENCED_PARAMETER(pNMHDR);
2042 #endif
2043 *pResult = 0;
2044 }
2045
2046 void CLogDlg::SortShownListArray()
2047 {
2048 // make sure the shown list still matches the filter after sorting.
2049 OnTimer(LOGFILTER_TIMER);
2050 // clear the selection states
2051 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2052 while (pos)
2053 {
2054 m_LogList.SetItemState(m_LogList.GetNextSelectedItem(pos), 0, LVIS_SELECTED);
2055 }
2056 m_LogList.SetSelectionMark(-1);
2057 }
2058
2059 void CLogDlg::SetSortArrow(CListCtrl * control, int nColumn, bool bAscending)
2060 {
2061 if (control == NULL)
2062 return;
2063 // set the sort arrow
2064 CHeaderCtrl * pHeader = control->GetHeaderCtrl();
2065 HDITEM HeaderItem = {0};
2066 HeaderItem.mask = HDI_FORMAT;
2067 for (int i=0; i<pHeader->GetItemCount(); ++i)
2068 {
2069 pHeader->GetItem(i, &HeaderItem);
2070 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
2071 pHeader->SetItem(i, &HeaderItem);
2072 }
2073 if (nColumn >= 0)
2074 {
2075 pHeader->GetItem(nColumn, &HeaderItem);
2076 HeaderItem.fmt |= (bAscending ? HDF_SORTUP : HDF_SORTDOWN);
2077 pHeader->SetItem(nColumn, &HeaderItem);
2078 }
2079 }
2080
2081 int CLogDlg::m_nSortColumnPathList = 0;
2082 bool CLogDlg::m_bAscendingPathList = false;
2083
2084 void CLogDlg::OnBnClickedHidepaths()
2085 {
2086 FillLogMessageCtrl();
2087 m_ChangedFileListCtrl.Invalidate();
2088 }
2089
2090 void CLogDlg::UpdateLogInfoLabel()
2091 {
2092
2093 CGitHash rev1 ;
2094 CGitHash rev2 ;
2095 long selectedrevs = 0;
2096 int count = (int)m_LogList.m_arShownList.GetCount();
2097 int start = 0;
2098 if (count)
2099 {
2100 rev1 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(0)))->m_CommitHash;
2101 if(this->m_LogList.m_bShowWC && rev1.IsEmpty()&&(count>1))
2102 start = 1;
2103 rev1 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(start)))->m_CommitHash;
2104 //pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_arShownList.GetCount()-1));
2105 rev2 = (reinterpret_cast<GitRev*>(m_LogList.m_arShownList.SafeGetAt(count-1)))->m_CommitHash;
2106 selectedrevs = m_LogList.GetSelectedCount();
2107 }
2108 CString sTemp;
2109 sTemp.Format(IDS_PROC_LOG_STATS,
2110 count - start,
2111 rev2.ToString().Left(g_Git.GetShortHASHLength()), rev1.ToString().Left(g_Git.GetShortHASHLength()), selectedrevs);
2112
2113 if(selectedrevs == 1)
2114 {
2115 CString str=m_ChangedFileListCtrl.GetStatisticsString(true);
2116 str.Replace(_T('\n'), _T(' '));
2117 sTemp += _T("\r\n") + str;
2118 }
2119 m_sLogInfo = sTemp;
2120
2121 UpdateData(FALSE);
2122 }
2123
2124 void CLogDlg::OnDtnDropdownDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2125 {
2126 // the date control should not show the "today" button
2127 CMonthCalCtrl * pCtrl = m_DateFrom.GetMonthCalCtrl();
2128 if (pCtrl)
2129 SetWindowLongPtr(pCtrl->GetSafeHwnd(), GWL_STYLE, LONG_PTR(pCtrl->GetStyle() | MCS_NOTODAY));
2130 *pResult = 0;
2131 }
2132
2133 void CLogDlg::OnDtnDropdownDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2134 {
2135 // the date control should not show the "today" button
2136 CMonthCalCtrl * pCtrl = m_DateTo.GetMonthCalCtrl();
2137 if (pCtrl)
2138 SetWindowLongPtr(pCtrl->GetSafeHwnd(), GWL_STYLE, LONG_PTR(pCtrl->GetStyle() | MCS_NOTODAY));
2139 *pResult = 0;
2140 }
2141
2142 void CLogDlg::OnSize(UINT nType, int cx, int cy)
2143 {
2144 __super::OnSize(nType, cx, cy);
2145 //set range
2146 SetSplitterRange();
2147 }
2148
2149 void CLogDlg::OnRefresh()
2150 {
2151 {
2152 m_limit = 0;
2153 this->m_LogProgress.SetPos(0);
2154
2155 Refresh (false);
2156 }
2157 }
2158
2159 void CLogDlg::OnFocusFilter()
2160 {
2161 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2162 }
2163
2164 void CLogDlg::OnEditCopy()
2165 {
2166 if (GetFocus() == &m_ChangedFileListCtrl)
2167 CopyChangedSelectionToClipBoard();
2168 else
2169 m_LogList.CopySelectionToClipBoard();
2170 }
2171
2172 CString CLogDlg::GetAbsoluteUrlFromRelativeUrl(const CString& url)
2173 {
2174 // is the URL a relative one?
2175 if (url.Left(2).Compare(_T("^/")) == 0)
2176 {
2177 // URL is relative to the repository root
2178 CString url1 = m_sRepositoryRoot + url.Mid(1);
2179 TCHAR buf[INTERNET_MAX_URL_LENGTH];
2180 DWORD len = url.GetLength();
2181 if (UrlCanonicalize((LPCTSTR)url1, buf, &len, 0) == S_OK)
2182 return CString(buf, len);
2183 return url1;
2184 }
2185 else if (url[0] == '/')
2186 {
2187 // URL is relative to the server's hostname
2188 CString sHost;
2189 // find the server's hostname
2190 int schemepos = m_sRepositoryRoot.Find(_T("//"));
2191 if (schemepos >= 0)
2192 {
2193 sHost = m_sRepositoryRoot.Left(m_sRepositoryRoot.Find('/', schemepos+3));
2194 CString url1 = sHost + url;
2195 TCHAR buf[INTERNET_MAX_URL_LENGTH];
2196 DWORD len = url.GetLength();
2197 if (UrlCanonicalize((LPCTSTR)url, buf, &len, 0) == S_OK)
2198 return CString(buf, len);
2199 return url1;
2200 }
2201 }
2202 return url;
2203 }
2204
2205
2206 void CLogDlg::OnEnChangeSearchedit()
2207 {
2208 UpdateData();
2209 if (m_LogList.m_sFilterText.IsEmpty())
2210 {
2211 CStoreSelection storeselection(this);
2212 // clear the filter, i.e. make all entries appear
2213 theApp.DoWaitCursor(1);
2214 KillTimer(LOGFILTER_TIMER);
2215 FillLogMessageCtrl(false);
2216
2217 Refresh();
2218 //m_LogList.StartFilter();
2219 #if 0
2220 InterlockedExchange(&m_bNoDispUpdates, TRUE);
2221 m_arShownList.RemoveAll();
2222 for (DWORD i=0; i<m_logEntries.size(); ++i)
2223 {
2224 if (IsEntryInDateRange(i))
2225 m_arShownList.Add(m_logEntries[i]);
2226 }
2227 InterlockedExchange(&m_bNoDispUpdates, FALSE);
2228 m_LogList.DeleteAllItems();
2229 m_LogList.SetItemCountEx(ShownCountWithStopped());
2230 m_LogList.RedrawItems(0, ShownCountWithStopped());
2231 m_LogList.SetRedraw(false);
2232 ResizeAllListCtrlCols();
2233 m_LogList.SetRedraw(true);
2234 #endif
2235 theApp.DoWaitCursor(-1);
2236 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
2237 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
2238 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2239 DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty()))));
2240 return;
2241 }
2242 if (Validate(m_LogList.m_sFilterText))
2243 SetTimer(LOGFILTER_TIMER, 1000, NULL);
2244 else
2245 KillTimer(LOGFILTER_TIMER);
2246
2247 }
2248
2249 void CLogDlg::OnBnClickedAllBranch()
2250 {
2251 this->UpdateData();
2252
2253 if(this->m_bAllBranch)
2254 m_LogList.m_ShowMask|=CGit::LOG_INFO_ALL_BRANCH;
2255 else
2256 m_LogList.m_ShowMask&=~CGit::LOG_INFO_ALL_BRANCH;
2257
2258 OnRefresh();
2259
2260 FillLogMessageCtrl(false);
2261 }
2262
2263 void CLogDlg::OnBnClickedFollowRenames()
2264 {
2265 this->UpdateData();
2266
2267 if(m_bFollowRenames)
2268 {
2269 m_LogList.m_ShowMask |= CGit::LOG_INFO_FOLLOW;
2270 if (m_bAllBranch)
2271 {
2272
2273 m_bAllBranch = FALSE;
2274 m_LogList.m_ShowMask &=~ CGit::LOG_INFO_ALL_BRANCH;
2275 }
2276
2277 }
2278 else
2279 m_LogList.m_ShowMask &= ~CGit::LOG_INFO_FOLLOW;
2280
2281 DialogEnableWindow(IDC_LOG_ALLBRANCH, !m_bFollowRenames);
2282 DialogEnableWindow(IDC_SHOWWHOLEPROJECT, !m_bFollowRenames);
2283
2284 OnRefresh();
2285
2286 FillLogMessageCtrl(false);
2287 }
2288
2289 void CLogDlg::OnBnClickedShowTags()
2290 {
2291 this->UpdateData();
2292
2293 if (m_bShowTags)
2294 m_LogList.m_ShowRefMask |= LOGLIST_SHOWTAGS;
2295 else
2296 m_LogList.m_ShowRefMask &= ~LOGLIST_SHOWTAGS;
2297
2298 m_LogList.Invalidate();
2299 }
2300
2301 void CLogDlg::OnBnClickedBrowseRef()
2302 {
2303 CString newRef = CBrowseRefsDlg::PickRef(false,m_LogList.GetStartRef());
2304 if(newRef.IsEmpty())
2305 return;
2306
2307 SetStartRef(newRef);
2308 ((CButton*)GetDlgItem(IDC_LOG_ALLBRANCH))->SetCheck(0);
2309
2310 OnBnClickedAllBranch();
2311 }
2312
2313 void CLogDlg::ShowStartRef()
2314 {
2315 //Show ref name on top
2316 if(!::IsWindow(m_hWnd))
2317 return;
2318 if(m_bAllBranch)
2319 {
2320 m_staticRef.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_LOG_ALLBRANCHES)));
2321 m_staticRef.Invalidate(TRUE);
2322 return;
2323 }
2324
2325 CString showStartRef = m_LogList.GetStartRef();
2326 if(showStartRef.IsEmpty())
2327 {
2328 //Ref name is HEAD
2329 if (g_Git.Run(L"git symbolic-ref HEAD", &showStartRef, NULL, CP_UTF8))
2330 showStartRef = CString(MAKEINTRESOURCE(IDS_PROC_LOG_NOBRANCH));
2331 showStartRef.Trim(L"\r\n\t ");
2332 }
2333
2334
2335 if(wcsncmp(showStartRef,L"refs/",5) == 0)
2336 showStartRef = showStartRef.Mid(5);
2337 if(wcsncmp(showStartRef,L"heads/",6) == 0)
2338 showStartRef = showStartRef.Mid(6);
2339
2340 m_staticRef.SetWindowText(showStartRef);
2341 m_staticRef.Invalidate(TRUE);
2342 }
2343
2344 void CLogDlg::SetStartRef(const CString& StartRef)
2345 {
2346 m_LogList.SetStartRef(StartRef);
2347
2348 if (m_hightlightRevision.IsEmpty())
2349 {
2350 if (g_Git.GetHash(m_LogList.m_lastSelectedHash, StartRef))
2351 {
2352 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + StartRef + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
2353 }
2354 m_hightlightRevision = m_LogList.m_lastSelectedHash;
2355 }
2356
2357 ShowStartRef();
2358 }
2359
2360
2361 void CLogDlg::OnBnClickedFirstParent()
2362 {
2363 this->UpdateData();
2364
2365 if(this->m_bFirstParent)
2366 m_LogList.m_ShowMask|=CGit::LOG_INFO_FIRST_PARENT;
2367 else
2368 m_LogList.m_ShowMask&=~CGit::LOG_INFO_FIRST_PARENT;
2369
2370 OnRefresh();
2371
2372 FillLogMessageCtrl(false);
2373
2374 }
2375
2376 void CLogDlg::OnBnClickShowWholeProject()
2377 {
2378 this->UpdateData();
2379
2380 if(this->m_bWholeProject)
2381 {
2382 m_LogList.m_Path.Reset();
2383 SetDlgTitle();
2384 DialogEnableWindow(IDC_LOG_FOLLOWRENAMES, FALSE);
2385 }
2386 else
2387 {
2388 m_LogList.m_Path=m_path;
2389 DialogEnableWindow(IDC_LOG_FOLLOWRENAMES, !(m_path.IsEmpty() || m_path.IsDirectory()));
2390 }
2391
2392 SetDlgTitle();
2393
2394 OnRefresh();
2395
2396 FillLogMessageCtrl(false);
2397
2398 }
2399
2400 LRESULT CLogDlg::OnRefLogChanged(WPARAM /*wParam*/, LPARAM /*lParam*/)
2401 {
2402 ShowStartRef();
2403 return 0;
2404 }
2405
2406 LRESULT CLogDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
2407 {
2408 m_pTaskbarList.Release();
2409 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
2410 return 0;
2411 }
Windows Explorer Extension to Operate Git