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