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