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