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