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

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