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