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

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