src/TortoiseProc/LogDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2009, 2015 - TortoiseSVN
   4 // Copyright (C) 2008-2019 - 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 "StatGraphDlg.h"
  23 #include "LogDlg.h"
  24 #include "MessageBox.h"
  25 #include "AppUtils.h"
  26 #include "StringUtils.h"
  27 #include "UnicodeUtils.h"
  28 #include "TempFile.h"
  29 #include "IconMenu.h"
  30 #include "BrowseRefsDlg.h"
  31 #include "SmartHandle.h"
  32 #include "LogOrdering.h"
  33 #include "ClipboardHelper.h"
  34 #include "DPIAware.h"
  35
  36 #define MIN_CTRL_HEIGHT (CDPIAware::Instance().ScaleY(20))
  37 #define MIN_SPLITTER_HEIGHT (CDPIAware::Instance().ScaleY(10))
  38
  39 #define WM_TGIT_REFRESH_SELECTION   (WM_APP + 1)
  40
  41 IMPLEMENT_DYNAMIC(CLogDlg, CResizableStandAloneDialog)
  42 CLogDlg::CLogDlg(CWnd* pParent /*=nullptr*/)
  43         : CResizableStandAloneDialog(CLogDlg::IDD, pParent)
  44         , m_wParam(0)
  45         , m_nSortColumn(0)
  46         , m_bFollowRenames(false)
  47         , m_bSelect(false)
  48         , m_bSelectionMustBeSingle(true)
  49         , m_bShowTags(true)
  50         , m_bShowLocalBranches(true)
  51         , m_bShowRemoteBranches(true)
  52         , m_bShowOtherRefs(true)
  53         , m_bNoMerges(false)
  54         , m_iHidePaths(0)
  55         , m_bFirstParent(false)
  56         , m_bWholeProject(FALSE)
  57         , m_iCompressedGraph(0)
  58         , m_bShowWC(true)
  59
  60         , m_bSelectionMustBeContinuous(false)
  61
  62         , m_pNotifyWindow(nullptr)
  63
  64         , m_bAscending(FALSE)
  65         , m_hAccel(nullptr)
  66         , m_bNavigatingWithSelect(false)
  67 {
  68         m_bFilterWithRegex = !!CRegDWORD(L"Software\\TortoiseGit\\UseRegexFilter", FALSE);
  69         m_bFilterCaseSensitively = !!CRegDWORD(L"Software\\TortoiseGit\\FilterCaseSensitively", FALSE);
  70         m_bAsteriskLogPrefix = !!CRegDWORD(L"Software\\TortoiseGit\\AsteriskLogPrefix", TRUE);
  71         m_SelectedFilters = CRegDWORD(L"Software\\TortoiseGit\\SelectedLogFilters", LOGFILTER_ALL);
  72
  73         CString str = g_Git.m_CurrentDir;
  74         str.Replace(L':', L'_');
  75
  76         m_regbAllBranch = CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\AllBranch\\" + str, FALSE);
  77         m_AllBranchType = (AllBranchType)(DWORD)m_regbAllBranch;
  78         switch (m_AllBranchType)
  79         {
  80         case AllBranchType::None:
  81                 m_bAllBranch = FALSE;
  82                 break;
  83         case AllBranchType::AllBranches:
  84                 m_bAllBranch = TRUE;
  85                 break;
  86         default:
  87                 m_bAllBranch = BST_INDETERMINATE;
  88         }
  89
  90         m_regShowWholeProject = CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\ShowWholeProject\\" + str, FALSE);
  91         m_bWholeProject = m_regShowWholeProject;
  92         m_regbShowTags = CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\ShowTags\\" + str, TRUE);
  93         m_bShowTags = !!m_regbShowTags;
  94         m_regbShowLocalBranches = CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\ShowLocalBranches\\" + str, TRUE);
  95         m_bShowLocalBranches = !!m_regbShowLocalBranches;
  96         m_regbShowRemoteBranches = CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\ShowRemoteBranches\\" + str, TRUE);
  97         m_bShowRemoteBranches = !!m_regbShowRemoteBranches;
  98         m_regbShowOtherRefs = CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\ShowOtherRefs\\" + str, TRUE);
  99         m_bShowOtherRefs = !!m_regbShowOtherRefs;
 100
 101
 102         m_regAddBeforeCommit = CRegDWORD(L"Software\\TortoiseGit\\AddBeforeCommit", TRUE);
 103         m_bShowUnversioned = !!m_regAddBeforeCommit;
 104
 105         m_bShowGravatar = !!CRegDWORD(L"Software\\TortoiseGit\\EnableGravatar", FALSE);
 106         m_regbShowGravatar = CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\ShowGravatar\\" + str, m_bShowGravatar);
 107         m_bShowGravatar = !!m_regbShowGravatar;
 108         m_bShowDescribe = !!CRegDWORD(L"Software\\TortoiseGit\\ShowDescribe");
 109         m_bShowBranchRevNo = !!CRegDWORD(L"Software\\TortoiseGit\\ShowBranchRevisionNumber", FALSE);
 110 }
 111
 112 CLogDlg::~CLogDlg()
 113 {
 114         m_regbAllBranch = (DWORD)m_AllBranchType;
 115         m_regbShowTags = m_bShowTags;
 116         m_regbShowLocalBranches = m_bShowLocalBranches;
 117         m_regbShowRemoteBranches = m_bShowRemoteBranches;
 118         m_regbShowOtherRefs = m_bShowOtherRefs;
 119         m_regbShowGravatar = m_bShowGravatar;
 120         m_regAddBeforeCommit = m_bShowUnversioned;
 121 }
 122
 123 void CLogDlg::DoDataExchange(CDataExchange* pDX)
 124 {
 125         CResizableStandAloneDialog::DoDataExchange(pDX);
 126         DDX_Control(pDX, IDC_LOGLIST, m_LogList);
 127         DDX_Control(pDX, IDC_LOGMSG, m_ChangedFileListCtrl);
 128         DDX_Control(pDX, IDC_PROGRESS, m_LogProgress);
 129         DDX_Control(pDX, IDC_SPLITTERTOP, m_wndSplitter1);
 130         DDX_Control(pDX, IDC_SPLITTERBOTTOM, m_wndSplitter2);
 131         DDX_Text(pDX, IDC_SEARCHEDIT, m_sFilterText);
 132         DDX_Control(pDX, IDC_DATEFROM, m_DateFrom);
 133         DDX_Control(pDX, IDC_DATETO, m_DateTo);
 134         DDX_Control(pDX, IDC_LOG_JUMPTYPE, m_JumpType);
 135         DDX_Control(pDX, IDC_LOG_JUMPUP, m_JumpUp);
 136         DDX_Control(pDX, IDC_LOG_JUMPDOWN, m_JumpDown);
 137         DDX_Text(pDX, IDC_LOGINFO, m_sLogInfo);
 138         DDX_Check(pDX, IDC_LOG_ALLBRANCH,m_bAllBranch);
 139         DDX_Check(pDX, IDC_WHOLE_PROJECT, m_bWholeProject);
 140         DDX_Control(pDX, IDC_WALKBEHAVIOUR, m_ctrlWalkBehavior);
 141         DDX_Control(pDX, IDC_VIEW, m_ctrlView);
 142         DDX_Control(pDX, IDC_SEARCHEDIT, m_cFilter);
 143         DDX_Control(pDX, IDC_STATIC_REF, m_staticRef);
 144         DDX_Control(pDX, IDC_PIC_AUTHOR, m_gravatar);
 145         DDX_Control(pDX, IDC_FILTER, m_cFileFilter);
 146 }
 147
 148 BEGIN_MESSAGE_MAP(CLogDlg, CResizableStandAloneDialog)
 149         ON_WM_CONTEXTMENU()
 150         ON_WM_SETCURSOR()
 151         ON_NOTIFY(LVN_ITEMCHANGED, IDC_LOGLIST, OnLvnItemchangedLoglist)
 152         ON_NOTIFY(LVN_ITEMCHANGED, IDC_LOGMSG, OnLvnItemchangedLogmsg)
 153         ON_NOTIFY(NM_CUSTOMDRAW, IDC_LOGMSG, OnNMCustomdrawChangedFileList)
 154         ON_NOTIFY(EN_LINK, IDC_MSGVIEW, OnEnLinkMsgview)
 155         ON_EN_VSCROLL(IDC_MSGVIEW, OnEnscrollMsgview)
 156         ON_EN_HSCROLL(IDC_MSGVIEW, OnEnscrollMsgview)
 157         ON_BN_CLICKED(IDC_STATBUTTON, OnBnClickedStatbutton)
 158
 159         ON_MESSAGE(WM_TGIT_REFRESH_SELECTION, OnRefreshSelection)
 160         ON_REGISTERED_MESSAGE(CFilterEdit::WM_FILTEREDIT_INFOCLICKED, OnClickedInfoIcon)
 161         ON_REGISTERED_MESSAGE(CFilterEdit::WM_FILTEREDIT_CANCELCLICKED, OnClickedCancelFilter)
 162
 163         ON_MESSAGE(MSG_LOAD_PERCENTAGE,OnLogListLoading)
 164
 165         ON_EN_CHANGE(IDC_SEARCHEDIT, OnEnChangeSearchedit)
 166         ON_WM_TIMER()
 167         ON_NOTIFY(DTN_DATETIMECHANGE, IDC_DATETO, OnDtnDatetimechangeDateto)
 168         ON_NOTIFY(DTN_DATETIMECHANGE, IDC_DATEFROM, OnDtnDatetimechangeDatefrom)
 169         ON_CBN_SELCHANGE(IDC_LOG_JUMPTYPE, &CLogDlg::OnCbnSelchangeJumpType)
 170         ON_COMMAND(IDC_LOG_JUMPUP, &CLogDlg::OnBnClickedJumpUp)
 171         ON_COMMAND(IDC_LOG_JUMPDOWN, &CLogDlg::OnBnClickedJumpDown)
 172         ON_COMMAND(ID_GO_UP, &CLogDlg::OnBnClickedJumpUp)
 173         ON_COMMAND(ID_GO_DOWN, &CLogDlg::OnBnClickedJumpDown)
 174         ON_COMMAND(ID_EXITCLEARFILTER, OnExitClearFilter)
 175         ON_BN_CLICKED(IDC_WALKBEHAVIOUR, OnBnClickedWalkBehaviour)
 176         ON_BN_CLICKED(IDC_VIEW, OnBnClickedView)
 177         ON_BN_CLICKED(IDC_WHOLE_PROJECT, OnBnClickShowWholeProject)
 178         ON_NOTIFY(LVN_COLUMNCLICK,IDC_LOGLIST, OnLvnColumnclick)
 179         ON_COMMAND(MSG_FETCHED_DIFF, OnBnClickedHidepaths)
 180         ON_BN_CLICKED(IDC_LOG_ALLBRANCH, OnBnClickedAllBranch)
 181         ON_EN_CHANGE(IDC_FILTER, OnEnChangeFileFilter)
 182
 183         ON_NOTIFY(DTN_DROPDOWN, IDC_DATEFROM, &CLogDlg::OnDtnDropdownDatefrom)
 184         ON_WM_SIZE()
 185         ON_BN_CLICKED(IDC_REFRESH, &CLogDlg::OnBnClickedRefresh)
 186         ON_STN_CLICKED(IDC_STATIC_REF, &CLogDlg::OnBnClickedBrowseRef)
 187         ON_COMMAND(ID_LOGDLG_REFRESH, &CLogDlg::OnBnClickedRefresh)
 188         ON_COMMAND(ID_GO_BACKWARD_SELECT, &CLogDlg::GoBackAndSelect)
 189         ON_COMMAND(ID_GO_FORWARD_SELECT, &CLogDlg::GoForwardAndSelect)
 190         ON_COMMAND(ID_GO_BACKWARD, &CLogDlg::GoBack)
 191         ON_COMMAND(ID_GO_FORWARD, &CLogDlg::GoForward)
 192         ON_COMMAND(ID_SELECT_SEARCHFIELD, &CLogDlg::OnSelectSearchField)
 193         ON_COMMAND(ID_LOGDLG_FIND, &CLogDlg::OnFind)
 194         ON_COMMAND(ID_LOGDLG_FOCUSFILTER, &CLogDlg::OnFocusFilter)
 195         ON_COMMAND(ID_EDIT_COPY, &CLogDlg::OnEditCopy)
 196         ON_MESSAGE(MSG_REFLOG_CHANGED, OnRefLogChanged)
 197         ON_REGISTERED_MESSAGE(TaskBarButtonCreated, OnTaskbarBtnCreated)
 198
 199         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ITEMCHANGED, &CLogDlg::OnFileListCtrlItemChanged)
 200         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_NEEDSREFRESH, OnGitStatusListCtrlNeedsRefresh)
 201         ON_REGISTERED_MESSAGE(CGitLogListBase::LOGLIST_RESET_WCREV, OnResetWcRev)
 202         ON_WM_MOVE()
 203         ON_WM_MOVING()
 204         ON_WM_SIZING()
 205         ON_WM_CTLCOLOR()
 206         ON_WM_PAINT()
 207 END_MESSAGE_MAP()
 208
 209 enum JumpType
 210 {
 211         JumpType_AuthorEmail,
 212         JumpType_CommitterEmail,
 213         JumpType_MergePoint,
 214         JumpType_Parent1,
 215         JumpType_Parent2,
 216         JumpType_Tag,
 217         JumpType_TagFF,
 218         JumpType_Branch,
 219         JumpType_BranchFF,
 220         JumpType_History,
 221 };
 222
 223 LRESULT CLogDlg::OnResetWcRev(WPARAM, LPARAM)
 224 {
 225         if (m_LogList.m_hasWC && m_ChangedFileListCtrl.m_CurrentVersion.IsEmpty())
 226                 m_ChangedFileListCtrl.Clear();
 227
 228         return 0;
 229 }
 230
 231 LRESULT CLogDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
 232 {
 233         if (m_LogList.m_hasWC && m_LogList.GetSelectedCount() == 1)
 234         {
 235                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
 236                 size_t selIndex = m_LogList.GetNextSelectedItem(pos);
 237                 GitRevLoglist* pLogEntry = m_LogList.m_arShownList.SafeGetAt(selIndex);
 238                 if (pLogEntry && pLogEntry->m_CommitHash.IsEmpty())
 239                         m_ChangedFileListCtrl.StoreScrollPos();
 240         }
 241         m_LogList.ResetWcRev(true);
 242         m_LogList.Invalidate();
 243         return 0;
 244 }
 245
 246 void CLogDlg::SetParams(const CTGitPath& orgPath, const CTGitPath& path, CString hightlightRevision, CString range, DWORD limit, int limitScale/*=-1*/)
 247 {
 248         m_orgPath = orgPath;
 249         m_path = path;
 250         m_hightlightRevision = hightlightRevision;
 251
 252         if (range == GIT_REV_ZERO)
 253                 range = L"HEAD";
 254
 255         if (!(range.IsEmpty() || range == L"HEAD"))
 256         {
 257                 m_bAllBranch = BST_UNCHECKED;
 258                 m_AllBranchType = AllBranchType::None;
 259         }
 260
 261         SetRange(range);
 262
 263         if (limitScale == CFilterData::SHOW_NO_LIMIT || (!range.IsEmpty() && m_LogList.m_Filter.m_NumberOfLogsScale != CFilterData::SHOW_LAST_N_COMMITS))
 264                 m_LogList.m_Filter.m_NumberOfLogsScale = CFilterData::SHOW_NO_LIMIT;
 265         if (limitScale >= CFilterData::SHOW_LAST_N_COMMITS && limit > 0)
 266         {
 267                 // limitation from command line argument, so override the filter.
 268                 m_LogList.m_Filter.m_NumberOfLogs = limit;
 269                 m_LogList.m_Filter.m_NumberOfLogsScale = limitScale;
 270         }
 271
 272         if (::IsWindow(m_hWnd))
 273                 UpdateData(FALSE);
 274 }
 275
 276 void CLogDlg::SetFilter(const CString& findstr, LONG findtype, bool findregex)
 277 {
 278         m_LogList.m_LogFilter = std::make_shared<CLogDlgFilter>(findstr, m_bFilterWithRegex, (DWORD)findtype, m_bFilterCaseSensitively);
 279         m_sFilterText = findstr;
 280         m_bFilterWithRegex = findregex;
 281 }
 282
 283 BOOL CLogDlg::OnInitDialog()
 284 {
 285         CString temp;
 286         CResizableStandAloneDialog::OnInitDialog();
 287         CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
 288
 289         // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
 290         // do this, Explorer would be unable to send that message to our window if we
 291         // were running elevated. It's OK to make the call all the time, since if we're
 292         // not elevated, this is a no-op.
 293         CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
 294         typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
 295         CAutoLibrary hUser = AtlLoadSystemLibraryUsingFullPath(L"user32.dll");
 296         if (hUser)
 297         {
 298                 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
 299                 if (pfnChangeWindowMessageFilterEx)
 300                 {
 301                         pfnChangeWindowMessageFilterEx(m_hWnd, TaskBarButtonCreated, MSGFLT_ALLOW, &cfs);
 302                 }
 303         }
 304         m_pTaskbarList.Release();
 305         if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
 306                 m_pTaskbarList = nullptr;
 307
 308         m_hAccel = LoadAccelerators(AfxGetResourceHandle(),MAKEINTRESOURCE(IDR_ACC_LOGDLG));
 309
 310         // use the state of the "stop on copy/rename" option from the last time
 311         UpdateData(FALSE);
 312
 313         // set the font to use in the log message view, configured in the settings dialog
 314         CAppUtils::CreateFontForLogs(m_logFont);
 315         GetDlgItem(IDC_MSGVIEW)->SetFont(&m_logFont);
 316         // make the log message rich edit control send a message when the mouse pointer is over a link
 317         GetDlgItem(IDC_MSGVIEW)->SendMessage(EM_SETEVENTMASK, NULL, ENM_LINK | ENM_SCROLL);
 318
 319         // "unrelated paths" should be in gray color
 320         m_iHidePaths = 2;
 321
 322         // set up the columns
 323         m_LogList.DeleteAllItems();
 324
 325         m_LogList.m_Path=m_path;
 326         m_LogList.m_hasWC = !GitAdminDir::IsBareRepo(g_Git.m_CurrentDir);
 327         m_LogList.m_bShowWC = m_LogList.m_hasWC && m_bShowWC;
 328         m_LogList.InsertGitColumn();
 329
 330         if (m_bWholeProject)
 331                 m_LogList.m_Path.Reset();
 332
 333         m_ChangedFileListCtrl.Init(GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD | GITSLC_COLDEL, L"LogDlg", (GITSLC_POPALL ^ (GITSLC_POPIGNORE | GITSLC_POPRESTORE)), false, m_LogList.m_hasWC, GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD| GITSLC_COLDEL);
 334
 335         GetDlgItem(IDC_LOGLIST)->UpdateData(FALSE);
 336
 337         SetDlgTitle();
 338
 339         CheckRegexpTooltip();
 340
 341         SetSplitterRange();
 342
 343         // the filter control has a 'cancel' button (the red 'X'), we need to load its bitmap
 344         m_cFilter.SetCancelBitmaps(IDI_CANCELNORMAL, IDI_CANCELPRESSED, 14, 14);
 345         m_cFilter.SetInfoIcon(IDI_LOGFILTER, 19, 19);
 346         m_cFilter.SetValidator(this);
 347
 348         AdjustControlSize(IDC_LOG_ALLBRANCH);
 349         AdjustControlSize(IDC_WHOLE_PROJECT);
 350
 351         GetClientRect(m_DlgOrigRect);
 352         m_LogList.GetClientRect(m_LogListOrigRect);
 353         GetDlgItem(IDC_MSGVIEW)->GetClientRect(m_MsgViewOrigRect);
 354         m_ChangedFileListCtrl.GetClientRect(m_ChgOrigRect);
 355
 356         m_Brush.CreateSolidBrush(RGB(174, 200, 255));
 357
 358         m_DateFrom.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS|MCS_NOTODAY|MCS_NOTRAILINGDATES|MCS_NOSELCHANGEONNAV);
 359         m_DateTo.SendMessage(DTM_SETMCSTYLE, 0, MCS_WEEKNUMBERS | MCS_NOTRAILINGDATES | MCS_NOSELCHANGEONNAV);
 360
 361         m_staticRef.SetURL(CString());
 362
 363         AddMainAnchors();
 364         SetFilterCueText();
 365
 366         m_LogList.m_ShowMask &= ~CGit::LOG_INFO_LOCAL_BRANCHES;
 367         if (m_AllBranchType == AllBranchType::AllBranches)
 368                 m_LogList.m_ShowMask|=CGit::LOG_INFO_ALL_BRANCH;
 369         else if (m_AllBranchType == AllBranchType::AllLocalBranches)
 370                 m_LogList.m_ShowMask |= CGit::LOG_INFO_LOCAL_BRANCHES;
 371         else if (m_AllBranchType == AllBranchType::AllBasicRefs)
 372                 m_LogList.m_ShowMask |= CGit::LOG_INFO_BASIC_REFS;
 373         else
 374                 m_LogList.m_ShowMask&=~CGit::LOG_INFO_ALL_BRANCH;
 375
 376         HandleShowLabels(m_bShowTags, LOGLIST_SHOWTAGS);
 377         HandleShowLabels(m_bShowLocalBranches, LOGLIST_SHOWLOCALBRANCHES);
 378         HandleShowLabels(m_bShowRemoteBranches, LOGLIST_SHOWREMOTEBRANCHES);
 379         HandleShowLabels(m_bShowOtherRefs, LOGLIST_SHOWOTHERREFS);
 380
 381 //      SetPromptParentWindow(m_hWnd);
 382         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_AUTHOREMAIL)));
 383         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_COMMITTEREMAIL)));
 384         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_MERGEPOINT)));
 385         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_PARENT1)));
 386         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_PARENT2)));
 387         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_TAG)));
 388         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_TAG_FF)));
 389         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_BRANCH)));
 390         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_BRANCH_FF)));
 391         m_JumpType.AddString(CString(MAKEINTRESOURCE(IDS_PROC_SELECTION_HISTORY)));
 392         m_JumpType.SetCurSel(0);
 393         int iconWidth = GetSystemMetrics(SM_CXSMICON);
 394         int iconHeight = GetSystemMetrics(SM_CYSMICON);
 395         m_JumpUp.SetIcon(CCommonAppUtils::LoadIconEx(IDI_JUMPUP, iconWidth, iconHeight));
 396         m_JumpDown.SetIcon(CCommonAppUtils::LoadIconEx(IDI_JUMPDOWN, iconWidth, iconHeight));
 397
 398         if (GetExplorerHWND())
 399                 CenterWindow(CWnd::FromHandle(GetExplorerHWND()));
 400         EnableSaveRestore(L"LogDlg");
 401
 402         DWORD yPos1 = CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1");
 403         DWORD yPos2 = CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2");
 404         RECT rcDlg, rcLogList, rcChgMsg;
 405         GetClientRect(&rcDlg);
 406         m_LogList.GetWindowRect(&rcLogList);
 407         ScreenToClient(&rcLogList);
 408         m_ChangedFileListCtrl.GetWindowRect(&rcChgMsg);
 409         ScreenToClient(&rcChgMsg);
 410         if (yPos1 && ((LONG)yPos1 < rcDlg.bottom - CDPIAware::Instance().ScaleY(185)))
 411         {
 412                 RECT rectSplitter;
 413                 m_wndSplitter1.GetWindowRect(&rectSplitter);
 414                 ScreenToClient(&rectSplitter);
 415                 int delta = yPos1 - rectSplitter.top;
 416
 417                 if ((rcLogList.bottom + delta > rcLogList.top) && (rcLogList.bottom + delta < rcChgMsg.bottom - CDPIAware::Instance().ScaleY(30)))
 418                 {
 419                         m_wndSplitter1.SetWindowPos(nullptr, rectSplitter.left, yPos1, 0, 0, SWP_NOSIZE);
 420                         DoSizeV1(delta);
 421                 }
 422         }
 423         if (yPos2 && ((LONG)yPos2 < rcDlg.bottom - CDPIAware::Instance().ScaleY(153)))
 424         {
 425                 RECT rectSplitter;
 426                 m_wndSplitter2.GetWindowRect(&rectSplitter);
 427                 ScreenToClient(&rectSplitter);
 428                 int delta = yPos2 - rectSplitter.top;
 429
 430                 if ((rcChgMsg.top + delta < rcChgMsg.bottom) && (rcChgMsg.top + delta > rcLogList.top + CDPIAware::Instance().ScaleY(30)))
 431                 {
 432                         m_wndSplitter2.SetWindowPos(nullptr, rectSplitter.left, yPos2, 0, 0, SWP_NOSIZE);
 433                         DoSizeV2(delta);
 434                 }
 435         }
 436
 437         SetSplitterRange();
 438         Invalidate();
 439
 440         if (m_bSelect)
 441         {
 442                 // the dialog is used to select revisions
 443                 // enable the OK button if appropriate
 444                 EnableOKButton();
 445         }
 446         else
 447         {
 448                 // the dialog is used to just view log messages
 449                 // hide the OK button and set text on Cancel button to OK
 450                 GetDlgItemText(IDOK, temp);
 451                 SetDlgItemText(IDCANCEL, temp);
 452                 GetDlgItem(IDOK)->ShowWindow(SW_HIDE);
 453         }
 454
 455         // first start a thread to obtain the log messages without
 456         // blocking the dialog
 457         //m_tTo = 0;
 458         //m_tFrom = (DWORD)-1;
 459
 460         // scroll to user selected or current revision
 461         if (m_hightlightRevision.IsEmpty() || g_Git.GetHash(m_LogList.m_lastSelectedHash, m_hightlightRevision))
 462         {
 463                 if (g_Git.GetHash(m_LogList.m_lastSelectedHash, L"HEAD"))
 464                         MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
 465         }
 466
 467         if (g_Git.GetConfigValueBool(L"tgit.logshowpatch"))
 468                 TogglePatchView();
 469
 470         m_LogList.FetchLogAsync(this);
 471         ShowGravatar();
 472         m_gravatar.Init();
 473
 474         m_cFilter.SetCancelBitmaps(IDI_CANCELNORMAL, IDI_CANCELPRESSED, 14, 14);
 475         m_cFilter.SetInfoIcon(IDI_LOGFILTER, 19, 19);
 476         temp.LoadString(IDS_FILEDIFF_FILTERCUE);
 477         temp = L"   " + temp;
 478         m_cFileFilter.SetCueBanner(temp);
 479
 480         GetDlgItem(IDC_LOGLIST)->SetFocus();
 481
 482         m_History.SetMaxHistoryItems((LONG)CRegDWORD(L"Software\\TortoiseGit\\MaxRefHistoryItems", 5));
 483         CString reg;
 484         reg.Format(L"Software\\TortoiseGit\\History\\log-refs\\%s", (LPCTSTR)g_Git.m_CurrentDir);
 485         reg.Replace(L':', L'_');
 486         m_History.Load(reg, L"ref");
 487
 488         reg.Format(L"Software\\TortoiseGit\\History\\LogDlg_Limits\\%s\\FromDate", (LPCTSTR)g_Git.m_CurrentDir);
 489         reg.Replace(L':', L'_');
 490         m_regLastSelectedFromDate = CRegString(reg);
 491
 492         m_ctrlWalkBehavior.m_bAlwaysShowArrow = true;
 493         m_ctrlView.m_bAlwaysShowArrow = true;
 494
 495         ShowStartRef();
 496         return FALSE;
 497 }
 498
 499 HBRUSH CLogDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
 500 {
 501         HBRUSH hbr = __super::OnCtlColor(pDC, pWnd, nCtlColor);
 502
 503         if ((m_LogList.m_Filter.m_NumberOfLogsScale >= CFilterData::SHOW_LAST_N_COMMITS || m_LogList.m_Filter.m_NumberOfLogsScale == CFilterData::SHOW_LAST_SEL_DATE && m_LogList.m_Filter.m_From != -1) && pWnd->GetDlgCtrlID() == IDC_FROMLABEL)
 504         {
 505                 pDC->SetBkMode(TRANSPARENT);
 506                 return m_Brush;
 507         }
 508
 509         return hbr;
 510 }
 511
 512 void CLogDlg::OnPaint()
 513 {
 514         CPaintDC dc(this);
 515
 516         if (!(m_LogList.m_Filter.m_NumberOfLogsScale >= CFilterData::SHOW_LAST_N_COMMITS || m_LogList.m_Filter.m_NumberOfLogsScale == CFilterData::SHOW_LAST_SEL_DATE && m_LogList.m_Filter.m_From != -1))
 517                 return;
 518
 519         CWnd* pWnd = GetDlgItem(IDC_FROMLABEL);
 520         if (!pWnd)
 521                 return;
 522
 523         CRect rect;
 524         pWnd->GetWindowRect(&rect);
 525         ScreenToClient(rect);
 526         rect.left -= 5;
 527         rect.top -= 3;
 528         rect.bottom += 3;
 529
 530         dc.FillRect(rect, &m_Brush);
 531 }
 532
 533 LRESULT CLogDlg::OnLogListLoading(WPARAM wParam, LPARAM /*lParam*/)
 534 {
 535         int cur=(int)wParam;
 536
 537         if( cur == GITLOG_START )
 538         {
 539                 CString temp;
 540                 temp.LoadString(IDS_PROGRESSWAIT);
 541
 542                 this->m_LogList.ShowText(temp, true);
 543
 544                 // We use a progress bar while getting the logs
 545                 m_LogProgress.SetRange32(0, 100);
 546                 m_LogProgress.SetPos(0);
 547                 if (m_pTaskbarList)
 548                 {
 549                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
 550                         m_pTaskbarList->SetProgressValue(m_hWnd, 0, 100);
 551                 }
 552
 553                 GetDlgItem(IDC_WALKBEHAVIOUR)->ShowWindow(SW_HIDE);
 554                 GetDlgItem(IDC_VIEW)->ShowWindow(SW_HIDE);
 555                 GetDlgItem(IDC_STATBUTTON)->ShowWindow(SW_HIDE);
 556                 GetDlgItem(IDC_PROGRESS)->ShowWindow(TRUE);
 557
 558                 DialogEnableWindow(IDC_WALKBEHAVIOUR, FALSE);
 559                 DialogEnableWindow(IDC_STATBUTTON, FALSE);
 560                 //DialogEnableWindow(IDC_REFRESH, FALSE);
 561                 DialogEnableWindow(IDC_VIEW, FALSE);
 562
 563         }
 564         else if( cur == GITLOG_END)
 565         {
 566                 if(this->m_LogList.HasText())
 567                 {
 568                         this->m_LogList.ClearText();
 569                 }
 570                 UpdateLogInfoLabel();
 571
 572                 if (m_pTaskbarList)
 573                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
 574
 575                 DialogEnableWindow(IDC_WHOLE_PROJECT, !m_bFollowRenames && !m_path.IsEmpty());
 576
 577                 DialogEnableWindow(IDC_STATBUTTON, !(m_LogList.m_arShownList.empty() || m_LogList.m_arShownList.size() == 1 && m_LogList.m_bShowWC));
 578                 DialogEnableWindow(IDC_REFRESH, TRUE);
 579                 DialogEnableWindow(IDC_VIEW, TRUE);
 580                 DialogEnableWindow(IDC_WALKBEHAVIOUR, TRUE);
 581 //              PostMessage(WM_TIMER, LOGFILTER_TIMER);
 582                 GetDlgItem(IDC_WALKBEHAVIOUR)->ShowWindow(SW_SHOW);
 583                 GetDlgItem(IDC_VIEW)->ShowWindow(SW_SHOW);
 584                 GetDlgItem(IDC_STATBUTTON)->ShowWindow(SW_SHOW);
 585                 GetDlgItem(IDC_PROGRESS)->ShowWindow(FALSE);
 586                 //CTime time=m_LogList.GetOldestTime();
 587                 CTime begin,end;
 588                 m_LogList.GetTimeRange(begin,end);
 589
 590                 if (m_LogList.m_Filter.m_From > 0 && m_LogList.m_Filter.m_NumberOfLogsScale >= CFilterData::SHOW_LAST_SEL_DATE)
 591                         begin = m_LogList.m_Filter.m_From;
 592                 m_DateFrom.SetTime(&begin);
 593                 if (m_LogList.m_Filter.m_To != -1)
 594                         end = m_LogList.m_Filter.m_To;
 595                 m_DateTo.SetTime(&end);
 596                 Invalidate();
 597         }
 598         else
 599         {
 600                 if(this->m_LogList.HasText())
 601                 {
 602                         this->m_LogList.ClearText();
 603                         this->m_LogList.Invalidate();
 604                 }
 605                 UpdateLogInfoLabel();
 606                 m_LogProgress.SetPos(cur);
 607                 if (m_pTaskbarList)
 608                 {
 609                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
 610                         m_pTaskbarList->SetProgressValue(m_hWnd, cur, 100);
 611                 }
 612         }
 613         return 0;
 614 }
 615 void CLogDlg::SetDlgTitle()
 616 {
 617         if (m_sTitle.IsEmpty())
 618                 GetWindowText(m_sTitle);
 619
 620         if (m_LogList.m_Path.IsEmpty() || m_orgPath.GetWinPathString().IsEmpty())
 621                 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, m_sTitle);
 622         else
 623                 CAppUtils::SetWindowTitle(m_hWnd, m_orgPath.GetWinPathString(), m_sTitle);
 624 }
 625
 626 void CLogDlg::CheckRegexpTooltip()
 627 {
 628         CWnd *pWnd = GetDlgItem(IDC_SEARCHEDIT);
 629         // Since tooltip describes regexp features, show it only if regexps are enabled.
 630         if (m_bFilterWithRegex)
 631                 m_tooltips.AddTool(pWnd, IDS_LOG_FILTER_REGEX_TT);
 632         else
 633                 m_tooltips.DelTool(pWnd);
 634 }
 635
 636 void CLogDlg::EnableOKButton()
 637 {
 638         if (m_bSelect)
 639         {
 640                 // the dialog is used to select revisions
 641                 if (m_bSelectionMustBeSingle)
 642                 {
 643                         // enable OK button if only a single revision is selected
 644                         DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()==1));
 645                 }
 646                 else if (m_bSelectionMustBeContinuous)
 647                         DialogEnableWindow(IDOK, (m_LogList.GetSelectedCount()!=0)&&(m_LogList.IsSelectionContinuous()));
 648                 else
 649                         DialogEnableWindow(IDOK, m_LogList.GetSelectedCount()!=0);
 650         }
 651         else
 652                 DialogEnableWindow(IDOK, TRUE);
 653 }
 654
 655 bool LookLikeGitHash(const CString& msg, int &pos)
 656 {
 657         int c = 0;
 658         for (; pos < msg.GetLength(); ++pos)
 659         {
 660                 if (msg[pos] >= '0' && msg[pos] <= '9' || msg[pos] >= 'a' && msg[pos] <= 'f')
 661                         c++;
 662                 else
 663                         return c >= g_Git.GetShortHASHLength() && c <= GIT_HASH_SIZE * 2 && msg[pos] != '@';
 664         }
 665         return c >= g_Git.GetShortHASHLength() && c <= GIT_HASH_SIZE * 2;
 666 }
 667
 668 std::vector<CHARRANGE> FindGitHashPositions(const CString& msg, int offset)
 669 {
 670         std::vector<CHARRANGE> result;
 671         offset = offset < 0 ? 0 : offset;
 672         int old = offset;
 673         while (offset < msg.GetLength())
 674         {
 675                 old = offset;
 676                 TCHAR e = msg[offset];
 677                 if (e == '\n')
 678                 {
 679                         ++offset;
 680                         if (msg.Mid(offset, 11) == L"git-svn-id:"
 681                                 || msg.Mid(offset, 14) == L"Signed-off-by:"
 682                                 || msg.Mid(offset, 10) == L"Change-Id:"
 683                         )
 684                         {
 685                                 offset += 10;
 686                                 while (offset < msg.GetLength())
 687                                 {
 688                                         if (msg[++offset] == '\n')
 689                                                 break;
 690                                 }
 691                                 continue;
 692                         }
 693                 }
 694                 else if (e >= 'A' && e <= 'Z' || e >= 'h' && e <= 'z')
 695                 {
 696                         do
 697                         {
 698                                 e = msg[++offset];
 699                         } while (offset < msg.GetLength() && (e >= 'A' && e <= 'Z' || e >= 'a' && e <= 'z' || e >= '0' && e <= '9'));
 700                 }
 701                 else if (e >= 'a' && e <= 'g' || e >= '0' && e <= '9')
 702                 {
 703                         if (e == 'g')
 704                         {
 705                                 ++old;
 706                                 ++offset;
 707                         }
 708                         if (LookLikeGitHash(msg, offset))
 709                         {
 710                                 TCHAR d = offset < msg.GetLength() ? msg[offset] : '\0';
 711                                 if (!((d >= 'A' && d <= 'Z') || (d >= 'a' && d <= 'z') || (d >= '0' && d <= '9')))
 712                                 {
 713                                         CHARRANGE range = { old, offset };
 714                                         result.push_back(range);
 715                                 }
 716                         }
 717                         ++offset;
 718                 }
 719                 else
 720                         ++offset;
 721         }
 722
 723         return result;
 724 }
 725
 726 BOOL FindGitHash(const CString& msg, int offset, CWnd *pWnd)
 727 {
 728         std::vector<CHARRANGE> positions = FindGitHashPositions(msg, offset);
 729         CAppUtils::SetCharFormat(pWnd, CFM_LINK, CFE_LINK, positions);
 730
 731         return positions.empty() ? FALSE : TRUE;
 732 }
 733
 734 static int DescribeCommit(CGitHash& hash, CString& result)
 735 {
 736         CAutoRepository repo(g_Git.GetGitRepository());
 737         if (!repo)
 738                 return -1;
 739         CAutoObject commit;
 740         if (git_object_lookup(commit.GetPointer(), repo, hash, GIT_OBJECT_COMMIT))
 741                 return -1;
 742
 743         CAutoDescribeResult describe;
 744         git_describe_options describe_options = GIT_DESCRIBE_OPTIONS_INIT;
 745         describe_options.describe_strategy = CRegDWORD(L"Software\\TortoiseGit\\DescribeStrategy", GIT_DESCRIBE_DEFAULT);
 746         describe_options.only_follow_first_parent = CRegDWORD(L"Software\\TortoiseGit\\DescribeOnlyFollowFirstParent", 0);
 747         if (git_describe_commit(describe.GetPointer(), (git_object *)commit, &describe_options))
 748                 return -1;
 749
 750         CAutoBuf describe_buf;
 751         git_describe_format_options format_options = GIT_DESCRIBE_FORMAT_OPTIONS_INIT;
 752         format_options.abbreviated_size = CRegDWORD(L"Software\\TortoiseGit\\DescribeAbbreviatedSize", GIT_DESCRIBE_DEFAULT_ABBREVIATED_SIZE);
 753         format_options.always_use_long_format = CRegDWORD(L"Software\\TortoiseGit\\DescribeAlwaysLong");
 754         if (git_describe_format(describe_buf, describe, &format_options))
 755                 return -1;
 756
 757         result = CUnicodeUtils::GetUnicode(describe_buf->ptr);
 758         return 0;
 759 }
 760
 761 namespace
 762 {
 763 bool IsAllWhitespace(const CString& text, long first, long last)
 764 {
 765         for (; first < last; ++first)
 766         {
 767                 wchar_t c = text[first];
 768                 if (c > L' ')
 769                         return false;
 770
 771                 if (c != L' ' && c != L'\t' && c != L'\r' && c != L'\n')
 772                         return false;
 773         }
 774
 775         return true;
 776 }
 777
 778 void ReduceRanges(std::vector<CHARRANGE>& ranges, const CString& text)
 779 {
 780         if (ranges.size() < 2)
 781                 return;
 782
 783         auto begin = ranges.begin();
 784         auto end = ranges.end();
 785
 786         auto target = begin;
 787         for (auto source = begin + 1; source != end; ++source)
 788                 if (IsAllWhitespace(text, target->cpMax, source->cpMin))
 789                         target->cpMax = source->cpMax;
 790                 else
 791                         *(++target) = *source;
 792
 793         ranges.erase(++target, end);
 794 }
 795 } // namespace
 796
 797 void CLogDlg::FillLogMessageCtrl(bool bShow /* = true*/)
 798 {
 799         // we fill here the log message rich edit control,
 800         // and also populate the changed files list control
 801         // according to the selected revision(s).
 802
 803         CRichEditCtrl * pMsgView = (CRichEditCtrl*)GetDlgItem(IDC_MSGVIEW);
 804         // empty the log message view
 805         pMsgView->SetWindowText(L" ");
 806         FillPatchView(true);
 807         // empty the changed files list
 808         m_ChangedFileListCtrl.SetRedraw(FALSE);
 809 //      InterlockedExchange(&m_bNoDispUpdates, TRUE);
 810         m_ChangedFileListCtrl.Clear();
 811
 812         // if we're not here to really show a selected revision, just
 813         // get out of here after clearing the views, which is what is intended
 814         // if that flag is not set.
 815         if (!bShow)
 816         {
 817                 // force a redraw
 818                 m_ChangedFileListCtrl.Invalidate();
 819 //              InterlockedExchange(&m_bNoDispUpdates, FALSE);
 820                 m_ChangedFileListCtrl.SetRedraw(TRUE);
 821                 m_gravatar.LoadGravatar();
 822                 return;
 823         }
 824
 825         // depending on how many revisions are selected, we have to do different
 826         // tasks.
 827         int selCount = m_LogList.GetSelectedCount();
 828         if (selCount == 0)
 829         {
 830                 // if nothing is selected, we have nothing more to do
 831 //              InterlockedExchange(&m_bNoDispUpdates, FALSE);
 832                 m_ChangedFileListCtrl.SetRedraw(TRUE);
 833                 m_gravatar.LoadGravatar();
 834                 return;
 835         }
 836         else if (selCount == 1)
 837         {
 838                 // if one revision is selected, we have to fill the log message view
 839                 // with the corresponding log message, and also fill the changed files
 840                 // list fully.
 841                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
 842                 size_t selIndex = m_LogList.GetNextSelectedItem(pos);
 843                 if (selIndex >= m_LogList.m_arShownList.size())
 844                 {
 845 //                      InterlockedExchange(&m_bNoDispUpdates, FALSE);
 846                         m_ChangedFileListCtrl.SetRedraw(TRUE);
 847                         return;
 848                 }
 849                 GitRevLoglist* pLogEntry = m_LogList.m_arShownList.SafeGetAt(selIndex);
 850
 851                 {
 852                         m_gravatar.LoadGravatar(pLogEntry->GetAuthorEmail());
 853
 854                         CString out_describe;
 855                         if (m_bShowDescribe)
 856                         {
 857                                 CString result;
 858                                 if (!DescribeCommit(pLogEntry->m_CommitHash, result))
 859                                         out_describe = L"Describe: " + result + L"\n";
 860                         }
 861
 862                         CString out_counter;
 863                         if (m_bShowBranchRevNo && !pLogEntry->m_CommitHash.IsEmpty())
 864                         {
 865                                 bool isFirstParentCommit = !pLogEntry->m_Lanes.empty() && Lanes::isActive(pLogEntry->m_Lanes[0]);
 866
 867                                 if (isFirstParentCommit)
 868                                 {
 869                                         CString rev_counter, rev_err;
 870                                         if (g_Git.Run(L"git.exe rev-list --count --first-parent " + pLogEntry->m_CommitHash.ToString(), &rev_counter, &rev_err, CP_UTF8))
 871                                                 CMessageBox::Show(GetSafeHwnd(), L"Could not get rev count\n" + rev_counter + L'\n' + rev_err, L"TortoiseGit", MB_ICONERROR);
 872                                         else
 873                                                 out_counter = L", " + CString(MAKEINTRESOURCE(IDS_REV_COUNTER)) + L": " + rev_counter.Trim();
 874                                 }
 875                         }
 876
 877                         std::vector<CHARRANGE> hightlightRanges;
 878                         std::vector<CHARRANGE> boldRanges;
 879                         auto filter = m_LogList.m_LogFilter;
 880
 881                         // set the log message text
 882                         CString msg = CString(MAKEINTRESOURCE(IDS_HASH)) + L": ";
 883                         int offset = msg.GetLength();
 884                         msg += pLogEntry->m_CommitHash.ToString();
 885                         if ((m_SelectedFilters & LOGFILTER_REVS) && filter->IsFilterActive())
 886                                 filter->GetMatchRanges(hightlightRanges, msg.Mid(offset), offset);
 887                         msg += out_counter + L"\n" + out_describe + L"\n";
 888
 889                         if (m_bAsteriskLogPrefix)
 890                                 msg += L"* ";
 891                         offset = msg.GetLength();
 892                         msg += pLogEntry->GetSubject();
 893                         msg.Remove(L'\r');
 894                         boldRanges.push_back({ offset, msg.GetLength() });
 895                         if ((m_SelectedFilters & (LOGFILTER_SUBJECT | LOGFILTER_MESSAGES)) && filter->IsFilterActive())
 896                                 filter->GetMatchRanges(hightlightRanges, msg.Mid(offset), offset);
 897
 898                         msg += L'\n';
 899                         offset = msg.GetLength();
 900                         msg += pLogEntry->GetBody();
 901                         msg.Remove(L'\r');
 902                         if ((m_SelectedFilters & LOGFILTER_MESSAGES) && filter->IsFilterActive())
 903                                 filter->GetMatchRanges(hightlightRanges, msg.Mid(offset), offset);
 904
 905                         if (!pLogEntry->m_Notes.IsEmpty())
 906                         {
 907                                 msg += L'\n';
 908                                 if (m_bAsteriskLogPrefix)
 909                                         msg += L"* ";
 910                                 offset = msg.GetLength();
 911                                 msg += CString(MAKEINTRESOURCE(IDS_NOTES)) + L":\n";
 912                                 boldRanges.push_back({ offset, msg.GetLength() });
 913                                 msg += pLogEntry->m_Notes;
 914                                 msg.Remove(L'\r');
 915                                 if ((m_SelectedFilters & LOGFILTER_NOTES) && filter->IsFilterActive())
 916                                         filter->GetMatchRanges(hightlightRanges, msg.Mid(offset), offset);
 917                         }
 918
 919                         CString tagInfo = m_LogList.GetTagInfo(pLogEntry);
 920                         if (!tagInfo.IsEmpty())
 921                         {
 922                                 msg += L'\n';
 923                                 if (m_bAsteriskLogPrefix)
 924                                         msg += L"* ";
 925                                 offset = msg.GetLength();
 926                                 msg += CString(MAKEINTRESOURCE(IDS_PROC_LOG_TAGINFO)) + L":\n";
 927                                 boldRanges.push_back({ offset, msg.GetLength() });
 928                                 msg += tagInfo;
 929                                 msg.Remove(L'\r');
 930                                 if ((m_SelectedFilters & LOGFILTER_ANNOTATEDTAG) && filter->IsFilterActive())
 931                                         filter->GetMatchRanges(hightlightRanges, msg.Mid(offset), offset);
 932                         }
 933
 934                         pMsgView->SetWindowText(msg);
 935
 936                         CAppUtils::SetCharFormat(pMsgView, CFM_BOLD, CFE_BOLD, boldRanges);
 937                         if (!hightlightRanges.empty())
 938                         {
 939                                 ReduceRanges(hightlightRanges, msg);
 940                                 CAppUtils::SetCharFormat(pMsgView, CFM_COLOR, m_Colors.GetColor(CColors::FilterMatch), hightlightRanges);
 941                         }
 942
 943                         // turn bug ID's into links if the bugtraq: properties have been set
 944                         // and we can find a match of those in the log message
 945                         int findHashStart = msg.Find(L'\n');
 946                         if (!out_describe.IsEmpty())
 947                                 findHashStart = msg.Find(L'\n', findHashStart + 1);
 948                         FindGitHash(msg, findHashStart, pMsgView);
 949                         m_LogList.m_ProjectProperties.FindBugID(msg, pMsgView);
 950                         CAppUtils::StyleURLs(msg, pMsgView);
 951                         if (((DWORD)CRegStdDWORD(L"Software\\TortoiseGit\\StyleCommitMessages", TRUE)) == TRUE)
 952                                 CAppUtils::FormatTextInRichEditControl(pMsgView);
 953
 954                         if (!pLogEntry->m_IsDiffFiles)
 955                         {
 956                                 m_ChangedFileListCtrl.SetBusyString(CString(MAKEINTRESOURCE(IDS_PROC_LOG_FETCHINGFILES)));
 957                                 m_ChangedFileListCtrl.SetBusy(TRUE);
 958                                 m_ChangedFileListCtrl.SetRedraw(TRUE);
 959                                 // entry might not already been enqueued for updating, issue #3090
 960                                 pLogEntry->GetAction(&m_LogList);
 961                                 return;
 962                         }
 963
 964                         CString matchpath=this->m_path.GetGitPathString();
 965
 966                         CTGitPathList& files = pLogEntry->GetFiles(&m_LogList);
 967                         int count = files.GetCount();
 968                         if (!m_bWholeProject && !matchpath.IsEmpty() && m_iHidePaths)
 969                         {
 970                                 if (m_path.IsDirectory() && !CStringUtils::EndsWith(matchpath, L'/'))
 971                                         matchpath.AppendChar(L'/');
 972                                 int matchPathLen = matchpath.GetLength();
 973                                 bool somethingHidden = false;
 974                                 for (int i = 0; i < count; ++i)
 975                                 {
 976                                         ((CTGitPath&)files[i]).m_Action &= ~(CTGitPath::LOGACTIONS_HIDE | CTGitPath::LOGACTIONS_GRAY);
 977
 978                                         bool bothAreDirectory = m_path.IsDirectory() && files[i].IsDirectory() && files[i].GetGitPathString().GetLength() == matchPathLen - 1; // submodules don't end with slash, but we must also not match a submodule in a fodler with an equal prefix
 979                                         if ((bothAreDirectory && wcsncmp(files[i].GetGitPathString(), matchpath, matchPathLen - 1) || !bothAreDirectory && wcsncmp(files[i].GetGitPathString(), matchpath, matchPathLen)) && ((files[i].m_Action & (CTGitPath::LOGACTIONS_REPLACED | CTGitPath::LOGACTIONS_COPY)) == 0 || (bothAreDirectory && wcsncmp(files[i].GetGitOldPathString(), matchpath, matchPathLen - 1) || !bothAreDirectory && wcsncmp(files[i].GetGitOldPathString(), matchpath, matchPathLen))))
 980                                         {
 981                                                 somethingHidden = true;
 982                                                 if (m_iHidePaths == 1)
 983                                                         ((CTGitPath&)files[i]).m_Action |= CTGitPath::LOGACTIONS_HIDE;
 984                                                 else if (m_iHidePaths == 2)
 985                                                         ((CTGitPath&)files[i]).m_Action |= CTGitPath::LOGACTIONS_GRAY;
 986                                         }
 987                                 }
 988                                 if (somethingHidden)
 989                                         pLogEntry->GetAction(&m_LogList) |= CTGitPath::LOGACTIONS_HIDE;
 990                                 else
 991                                         pLogEntry->GetAction(&m_LogList) &= ~CTGitPath::LOGACTIONS_HIDE;
 992                         }
 993                         else if (pLogEntry->GetAction(&m_LogList) & CTGitPath::LOGACTIONS_HIDE)
 994                         {
 995                                 pLogEntry->GetAction(&m_LogList) &= ~CTGitPath::LOGACTIONS_HIDE;
 996                                 for (int i = 0 ; i < count; ++i)
 997                                         ((CTGitPath&)files[i]).m_Action &= ~(CTGitPath::LOGACTIONS_HIDE | CTGitPath::LOGACTIONS_GRAY);
 998                         }
 999
1000                         CString fileFilter;
1001                         m_cFileFilter.GetWindowText(fileFilter);
1002                         if (!fileFilter.IsEmpty())
1003                         {
1004                                 fileFilter.MakeLower();
1005                                 bool somethingHidden = false;
1006                                 for (int i = 0; i < count; ++i)
1007                                 {
1008                                         CString sPath(files[i].GetGitPathString());
1009                                         sPath.MakeLower();
1010                                         if (sPath.Find(fileFilter) < 0)
1011                                         {
1012                                                 ((CTGitPath&)files[i]).m_Action |= CTGitPath::LOGACTIONS_HIDE;
1013                                                 somethingHidden = true;
1014                                         }
1015                                 }
1016                                 if (somethingHidden)
1017                                         pLogEntry->GetAction(&m_LogList) |= CTGitPath::LOGACTIONS_HIDE;
1018                         }
1019
1020                         m_ChangedFileListCtrl.UpdateWithGitPathList(files);
1021                         m_ChangedFileListCtrl.m_CurrentVersion = pLogEntry->m_CommitHash.ToString();
1022                         if (pLogEntry->m_CommitHash.IsEmpty() && m_bShowUnversioned)
1023                         {
1024                                 m_ChangedFileListCtrl.UpdateUnRevFileList(pLogEntry->GetUnRevFiles());
1025                                 m_ChangedFileListCtrl.Show(GITSLC_SHOWVERSIONED | GITSLC_SHOWUNVERSIONED);
1026                         }
1027                         else
1028                                 m_ChangedFileListCtrl.Show(GITSLC_SHOWVERSIONED);
1029
1030                         m_ChangedFileListCtrl.SetBusy(FALSE);
1031
1032                         m_ChangedFileListCtrl.SetRedraw(TRUE);
1033                         return;
1034                 }
1035
1036         }
1037         else
1038         {
1039                 // more than one revision is selected:
1040                 // the log message view must be emptied
1041                 // the changed files list contains all the changed paths from all
1042                 // selected revisions, with 'doubles' removed
1043                 m_gravatar.LoadGravatar();
1044         }
1045
1046         // redraw the views
1047 //      InterlockedExchange(&m_bNoDispUpdates, FALSE);
1048
1049         // sort according to the settings
1050         if (m_nSortColumnPathList > 0)
1051                 SetSortArrow(&m_ChangedFileListCtrl, m_nSortColumnPathList, m_bAscendingPathList);
1052         else
1053                 SetSortArrow(&m_ChangedFileListCtrl, -1, false);
1054         m_ChangedFileListCtrl.SetRedraw(TRUE);
1055 }
1056
1057 void CLogDlg::FillPatchView(bool onlySetTimer)
1058 {
1059         if (!::IsWindow(this->m_patchViewdlg.m_hWnd))
1060                 return;
1061
1062         KillTimer(LOG_FILLPATCHVTIMER);
1063         if (onlySetTimer)
1064         {
1065                 SetTimer(LOG_FILLPATCHVTIMER, 100, nullptr);
1066                 return;
1067         }
1068
1069         POSITION posLogList = m_LogList.GetFirstSelectedItemPosition();
1070         if (posLogList == nullptr)
1071         {
1072                 m_patchViewdlg.ClearView();
1073                 return; // nothing is selected, get out of here
1074         }
1075
1076         GitRev* pLogEntry = m_LogList.m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(posLogList));
1077         if (pLogEntry == nullptr || m_LogList.GetNextSelectedItem(posLogList) != -1)
1078         {
1079                 m_patchViewdlg.ClearView();
1080                 return;
1081         }
1082
1083         auto locker(m_ChangedFileListCtrl.AcquireReadWeakLock(50));
1084         if (!locker.IsAcquired())
1085         {
1086                 SetTimer(LOG_FILLPATCHVTIMER, 100, nullptr);
1087                 return;
1088         }
1089         POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
1090         CString out;
1091
1092         if (pos == nullptr)
1093         {
1094                 int diffContext = g_Git.GetConfigValueInt32(L"diff.context", -1);
1095                 CStringA outA;
1096                 CString rev1 = pLogEntry->m_CommitHash.IsEmpty() ? L"HEAD" : (pLogEntry->m_CommitHash.ToString() + L"~1");
1097                 CString rev2 = pLogEntry->m_CommitHash.IsEmpty() ? GIT_REV_ZERO : pLogEntry->m_CommitHash.ToString();
1098                 g_Git.GetUnifiedDiff(CTGitPath(), rev1, rev2, &outA, false, false, diffContext);
1099                 out = CUnicodeUtils::GetUnicode(outA);
1100         }
1101         else
1102         {
1103                 while (pos)
1104                 {
1105                         int nSelect = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
1106                         auto p = m_ChangedFileListCtrl.GetListEntry(nSelect);
1107                         if (p && !(p->m_Action&CTGitPath::LOGACTIONS_UNVER))
1108                         {
1109                                 CString cmd;
1110                                 if (pLogEntry->m_CommitHash.IsEmpty())
1111                                         cmd.Format(L"git.exe diff HEAD -- \"%s\"", (LPCTSTR)p->GetGitPathString());
1112                                 else
1113                                         cmd.Format(L"git.exe diff %s^%d..%s -- \"%s\"", (LPCTSTR)pLogEntry->m_CommitHash.ToString(), p->m_ParentNo + 1, (LPCTSTR)pLogEntry->m_CommitHash.ToString(), (LPCTSTR)p->GetGitPathString());
1114                                 g_Git.Run(cmd, &out, CP_UTF8);
1115                         }
1116                 }
1117         }
1118
1119         m_patchViewdlg.SetText(out);
1120 }
1121
1122 void CLogDlg::TogglePatchView()
1123 {
1124         m_patchViewdlg.m_ParentDlg = this;
1125         if (!IsWindow(m_patchViewdlg.m_hWnd))
1126         {
1127                 if (g_Git.GetConfigValueBool(L"tgit.logshowpatch") == FALSE)
1128                         g_Git.SetConfigValue(L"tgit.logshowpatch", L"true");
1129                 m_patchViewdlg.Create(IDD_PATCH_VIEW, this);
1130                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETSCROLLWIDTHTRACKING, TRUE);
1131                 CRect rect;
1132                 this->GetWindowRect(&rect);
1133
1134                 m_patchViewdlg.ShowWindow(SW_SHOW);
1135                 m_patchViewdlg.SetWindowPos(nullptr, rect.right, rect.top, (DWORD)CRegStdDWORD(L"Software\\TortoiseGit\\TortoiseProc\\PatchDlgWidth", rect.Width()), rect.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
1136
1137                 FillPatchView();
1138         }
1139         else
1140         {
1141                 g_Git.SetConfigValue(L"tgit.logshowpatch", L"false");
1142                 m_patchViewdlg.ShowWindow(SW_HIDE);
1143                 m_patchViewdlg.DestroyWindow();
1144         }
1145 }
1146
1147 LRESULT CLogDlg::OnFileListCtrlItemChanged(WPARAM /*wparam*/, LPARAM /*lparam*/)
1148 {
1149         FillPatchView(true);
1150         return 0;
1151 }
1152
1153 void CLogDlg::OnMoving(UINT fwSide, LPRECT pRect)
1154 {
1155         __super::OnMoving(fwSide, pRect);
1156
1157         if (!::IsWindow(m_patchViewdlg.m_hWnd))
1158                 return;
1159
1160         RECT patchrect;
1161         m_patchViewdlg.GetWindowRect(&patchrect);
1162         if (!::IsWindow(m_hWnd))
1163                 return;
1164
1165         RECT thisrect;
1166         GetWindowRect(&thisrect);
1167         if (patchrect.left == thisrect.right)
1168         {
1169                 m_patchViewdlg.SetWindowPos(nullptr, patchrect.left - (thisrect.left - pRect->left), patchrect.top - (thisrect.top - pRect->top), 0, 0, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);
1170         }
1171 }
1172
1173 void CLogDlg::OnSizing(UINT fwSide, LPRECT pRect)
1174 {
1175         __super::OnSizing(fwSide, pRect);
1176
1177         if (!::IsWindow(this->m_patchViewdlg.m_hWnd))
1178                 return;
1179
1180         CRect thisrect, patchrect;
1181         this->GetWindowRect(thisrect);
1182         this->m_patchViewdlg.GetWindowRect(patchrect);
1183         if (thisrect.right != patchrect.left)
1184                 return;
1185
1186         patchrect.left -= (thisrect.right - pRect->right);
1187         patchrect.right -= (thisrect.right - pRect->right);
1188
1189         if (patchrect.bottom == thisrect.bottom)
1190                 patchrect.bottom -= (thisrect.bottom - pRect->bottom);
1191         if (patchrect.top == thisrect.top)
1192                 patchrect.top -= thisrect.top - pRect->top;
1193         m_patchViewdlg.MoveWindow(patchrect);
1194 }
1195
1196 void CLogDlg::OnSelectSearchField()
1197 {
1198         m_cFilter.SetSel(0, -1, FALSE);
1199         m_cFilter.SetFocus();
1200 }
1201
1202 void CLogDlg::GoBack()
1203 {
1204         GoBackForward(false, false);
1205 }
1206
1207 void CLogDlg::GoForward()
1208 {
1209         GoBackForward(false, true);
1210 }
1211
1212 void CLogDlg::GoBackAndSelect()
1213 {
1214         GoBackForward(true, false);
1215 }
1216
1217 void CLogDlg::GoForwardAndSelect()
1218 {
1219         GoBackForward(true, true);
1220 }
1221
1222 void CLogDlg::GoBackForward(bool select, bool bForward)
1223 {
1224         m_LogList.m_highlight.Empty();
1225         CGitHash gotoHash;
1226         if (bForward ? m_LogList.m_selectionHistory.GoForward(gotoHash) : m_LogList.m_selectionHistory.GoBack(gotoHash))
1227         {
1228                 int i;
1229                 for (i = 0; i < (int)m_LogList.m_arShownList.size(); ++i)
1230                 {
1231                         GitRev* rev = m_LogList.m_arShownList.SafeGetAt(i);
1232                         if (!rev) continue;
1233                         if (rev->m_CommitHash == gotoHash)
1234                         {
1235                                 m_LogList.EnsureVisible(i, FALSE);
1236                                 if (select)
1237                                 {
1238                                         m_LogList.m_highlight.Empty();
1239                                         m_LogList.SetItemState(m_LogList.GetSelectionMark(), 0, LVIS_SELECTED | LVIS_FOCUSED);
1240                                         POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1241                                         while (pos)
1242                                         {
1243                                                 int index = m_LogList.GetNextSelectedItem(pos);
1244                                                 if (index >= 0)
1245                                                         m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1246                                         }
1247                                         m_bNavigatingWithSelect = true;
1248                                         m_LogList.SetItemState(i, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
1249                                         m_LogList.SetSelectionMark(i);
1250                                         m_bNavigatingWithSelect = false;
1251                                 }
1252                                 else
1253                                         m_LogList.m_highlight = gotoHash;
1254                                 m_LogList.Invalidate();
1255                                 return;
1256                         }
1257                 }
1258                 if (i == (int)m_LogList.m_arShownList.size())
1259                 {
1260                         CString msg;
1261                         msg.Format(IDS_LOG_NOT_VISIBLE, (LPCTSTR)gotoHash.ToString());
1262                         MessageBox(msg, L"TortoiseGit", MB_OK | MB_ICONINFORMATION);
1263                         return;
1264                 }
1265         }
1266         PlaySound((LPCTSTR)SND_ALIAS_SYSTEMASTERISK, nullptr, SND_ASYNC | SND_ALIAS_ID);
1267 }
1268
1269 void CLogDlg::OnBnClickedRefresh()
1270 {
1271         Refresh (true);
1272 }
1273
1274 void CLogDlg::Refresh (bool clearfilter /*autoGoOnline*/)
1275 {
1276         if (m_bSelect)
1277                 DialogEnableWindow(IDOK, FALSE);
1278         m_LogList.m_LogFilter = std::make_shared<CLogDlgFilter>(m_sFilterText, m_bFilterWithRegex, (DWORD)m_SelectedFilters, m_bFilterCaseSensitively);
1279         m_LogList.Refresh(clearfilter);
1280         if (clearfilter)
1281                 m_sFilterText.Empty();
1282         EnableOKButton();
1283         ShowStartRef();
1284         FillLogMessageCtrl(false);
1285 }
1286
1287 void CLogDlg::SaveSplitterPos()
1288 {
1289         if (!IsIconic())
1290         {
1291                 CRegDWORD regPos1(L"Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer1");
1292                 CRegDWORD regPos2(L"Software\\TortoiseGit\\TortoiseProc\\ResizableState\\LogDlgSizer2");
1293                 RECT rectSplitter;
1294                 m_wndSplitter1.GetWindowRect(&rectSplitter);
1295                 ScreenToClient(&rectSplitter);
1296                 regPos1 = rectSplitter.top;
1297                 m_wndSplitter2.GetWindowRect(&rectSplitter);
1298                 ScreenToClient(&rectSplitter);
1299                 regPos2 = rectSplitter.top;
1300         }
1301 }
1302
1303 void CLogDlg::OnCancel()
1304 {
1305         this->ShowWindow(SW_HIDE);
1306
1307         // canceling means stopping the working thread if it's still running.
1308         m_LogList.SafeTerminateAsyncDiffThread();
1309         if (this->IsThreadRunning())
1310         {
1311                 m_LogList.SafeTerminateThread();
1312         }
1313         UpdateData();
1314
1315         SaveSplitterPos();
1316         __super::OnCancel();
1317 }
1318
1319 void CLogDlg::CopyChangedSelectionToClipBoard()
1320 {
1321         POSITION posLogList = m_LogList.GetFirstSelectedItemPosition();
1322         if (posLogList == nullptr)
1323                 return; // nothing is selected, get out of here
1324
1325         CString sPaths;
1326
1327 //      CGitRev* pLogEntry = reinterpret_cast<CGitRev* >(m_LogList.m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
1328 //      if (posLogList)
1329         {
1330                 auto locker(m_ChangedFileListCtrl.AcquireReadLock());
1331                 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
1332                 while (pos)
1333                 {
1334                         int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
1335                         auto path = m_ChangedFileListCtrl.GetListEntry(nItem);
1336                         if (!path)
1337                                 continue;
1338                         sPaths += path->GetGitPathString();
1339                         sPaths += L"\r\n";
1340                 }
1341         }
1342 #if 0
1343         else
1344         {
1345                 // only one revision is selected in the log dialog top pane
1346                 // but multiple items could be selected  in the changed items list
1347                 POSITION pos = m_ChangedFileListCtrl.GetFirstSelectedItemPosition();
1348                 while (pos)
1349                 {
1350                         int nItem = m_ChangedFileListCtrl.GetNextSelectedItem(pos);
1351                         LogChangedPath * changedlogpath = pLogEntry->pArChangedPaths->SafeGetAt(nItem);
1352
1353                         if ((m_cHidePaths.GetState() & 0x0003)==BST_CHECKED)
1354                         {
1355                                 // some items are hidden! So find out which item the user really selected
1356                                 INT_PTR selRealIndex = -1;
1357                                 for (INT_PTR hiddenindex=0; hiddenindex<pLogEntry->pArChangedPaths->GetCount(); ++hiddenindex)
1358                                 {
1359                                         if (pLogEntry->pArChangedPaths->SafeGetAt(hiddenindex)->sPath.Left(m_sRelativeRoot.GetLength()).Compare(m_sRelativeRoot)==0)
1360                                                 ++selRealIndex;
1361                                         if (selRealIndex == nItem)
1362                                         {
1363                                                 changedlogpath = pLogEntry->pArChangedPaths->SafeGetAt(hiddenindex);
1364                                                 break;
1365                                         }
1366                                 }
1367                         }
1368                         if (changedlogpath)
1369                         {
1370                                 sPaths += changedlogpath->sPath;
1371                                 sPaths += L"\r\n";
1372                         }
1373                 }
1374         }
1375 #endif
1376         sPaths.Trim();
1377         CStringUtils::WriteAsciiStringToClipboard(sPaths, GetSafeHwnd());
1378 }
1379
1380 void CLogDlg::OnContextMenu(CWnd* pWnd, CPoint point)
1381 {
1382         // we have 4 separate context menus:
1383         // one for the branch label in the upper left
1384         // one for FROM date control
1385         // one shown on the log message list control,
1386         // one shown in the changed-files list control
1387         if (pWnd == GetDlgItem(IDC_STATIC_REF))
1388         {
1389                 CIconMenu popup;
1390                 if (!popup.CreatePopupMenu())
1391                         return;
1392
1393                 int cnt = 0;
1394                 popup.AppendMenuIcon(++cnt, IDS_MENUREFBROWSE);
1395                 popup.SetDefaultItem(cnt);
1396                 CString head = L"HEAD";
1397                 CString curBranch = g_Git.GetCurrentBranch();
1398                 if (!curBranch.IsEmpty())
1399                         head.AppendFormat(L" -> \"%s\"", (LPCTSTR)curBranch);
1400                 popup.AppendMenuIcon(++cnt, head);
1401                 CGitHash fetchHead;
1402                 g_Git.GetHash(fetchHead, g_Git.FixBranchName(L"FETCH_HEAD"));
1403                 popup.AppendMenuIcon(++cnt, L"FETCH_HEAD");
1404                 popup.EnableMenuItem(cnt, fetchHead.IsEmpty());
1405                 popup.AppendMenuIcon(++cnt, IDS_ALL);
1406                 popup.EnableMenuItem(cnt, m_bFollowRenames);
1407                 popup.AppendMenuIcon(++cnt, IDS_PROC_LOG_SELECT_BASIC_REFS);
1408                 popup.EnableMenuItem(cnt, m_bFollowRenames);
1409                 popup.AppendMenuIcon(++cnt, IDS_PROC_LOG_SELECT_LOCAL_BRANCHES);
1410                 popup.EnableMenuItem(cnt, m_bFollowRenames);
1411                 int offset = ++cnt;
1412                 if (m_History.GetCount() > 0)
1413                 {
1414                         popup.AppendMenu(MF_SEPARATOR, 0);
1415                         for (size_t i = 0; i < m_History.GetCount(); ++i)
1416                         {
1417                                 CString entry = m_History.GetEntry(i);
1418                                 if (entry.GetLength() > 150)
1419                                         entry = entry.Left(150) + L"...";
1420                                 popup.AppendMenuIcon(cnt++, entry);
1421                         }
1422                 }
1423
1424                 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
1425                 if (cmd == 0)
1426                         return;
1427                 else if (cmd == 1)
1428                 {
1429                         OnBnClickedBrowseRef();
1430                         return;
1431                 }
1432
1433                 m_LogList.m_ShowMask &= ~(CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_BASIC_REFS | CGit::LOG_INFO_LOCAL_BRANCHES);
1434                 m_bAllBranch = BST_UNCHECKED;
1435                 m_AllBranchType = AllBranchType::None;
1436                 if (cmd == 2)
1437                 {
1438                         SetRange(g_Git.GetCurrentBranch(true));
1439                 }
1440                 else if (cmd == 3)
1441                 {
1442                         SetRange(fetchHead.ToString());
1443                 }
1444                 else if (cmd == 4)
1445                 {
1446                         m_bAllBranch = BST_CHECKED;
1447                         m_AllBranchType = AllBranchType::AllBranches;
1448                         m_LogList.m_ShowMask |= CGit::LOG_INFO_ALL_BRANCH;
1449                 }
1450                 else if (cmd == 5)
1451                 {
1452                         m_bAllBranch = BST_INDETERMINATE;
1453                         m_AllBranchType = AllBranchType::AllBasicRefs;
1454                         m_LogList.m_ShowMask |= CGit::LOG_INFO_BASIC_REFS;
1455                 }
1456                 else if (cmd == 6)
1457                 {
1458                         m_bAllBranch = BST_INDETERMINATE;
1459                         m_AllBranchType = AllBranchType::AllLocalBranches;
1460                         m_LogList.m_ShowMask |= CGit::LOG_INFO_LOCAL_BRANCHES;
1461                 }
1462                 else if (cmd >= offset)
1463                 {
1464                         SetRange(m_History.GetEntry(cmd - offset));
1465                         m_History.AddEntry(m_LogList.m_sRange);
1466                         m_History.Save();
1467                 }
1468
1469                 UpdateData(FALSE);
1470
1471                 OnRefresh();
1472                 FillLogMessageCtrl(false);
1473
1474                 return;
1475         }
1476
1477         if (pWnd == GetDlgItem(IDC_DATEFROM))
1478         {
1479                 CIconMenu popup;
1480                 if (!popup.CreatePopupMenu())
1481                         return;
1482
1483                 int cnt = 0;
1484
1485                 popup.AppendMenuIcon(++cnt, IDS_NO_LIMIT);
1486
1487                 DWORD scale = (DWORD)CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\NumberOfLogsScale", CFilterData::SHOW_NO_LIMIT);
1488                 CString strScale;
1489                 switch (scale)
1490                 {
1491                 case CFilterData::SHOW_LAST_N_COMMITS:
1492                         strScale.LoadString(IDS_LAST_N_COMMITS);
1493                         break;
1494                 case CFilterData::SHOW_LAST_N_YEARS:
1495                         strScale.LoadString(IDS_LAST_N_YEARS);
1496                         break;
1497                 case CFilterData::SHOW_LAST_N_MONTHS:
1498                         strScale.LoadString(IDS_LAST_N_MONTHS);
1499                         break;
1500                 case CFilterData::SHOW_LAST_N_WEEKS:
1501                         strScale.LoadString(IDS_LAST_N_WEEKS);
1502                         break;
1503                 }
1504                 if (!strScale.IsEmpty() && m_LogList.m_Filter.m_NumberOfLogs > 0)
1505                 {
1506                         popup.AppendMenu(MF_SEPARATOR, 0);
1507                         CString number;
1508                         number.Format(L"%ld", m_LogList.m_Filter.m_NumberOfLogs);
1509                         CString item;
1510                         item.Format(strScale, (LPCTSTR)number);
1511                         popup.AppendMenuIcon(++cnt, item);
1512                 }
1513
1514                 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
1515                 if (cmd <= 0)
1516                         return;
1517                 else if (cmd == 1)
1518                 {
1519                         m_LogList.m_Filter.m_NumberOfLogsScale = CFilterData::SHOW_NO_LIMIT;
1520                         // reset last selected date
1521                         m_regLastSelectedFromDate.removeValue();
1522                 }
1523                 else if (cmd == 2)
1524                         m_LogList.m_Filter.m_NumberOfLogsScale = scale;
1525
1526                 UpdateData(FALSE);
1527                 OnRefresh();
1528                 FillLogMessageCtrl(false);
1529
1530                 return;
1531         }
1532
1533         int selCount = m_LogList.GetSelectedCount();
1534         if ((selCount == 1)&&(pWnd == GetDlgItem(IDC_MSGVIEW)))
1535         {
1536                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1537                 int selIndex = -1;
1538                 if (pos)
1539                         selIndex = m_LogList.GetNextSelectedItem(pos);
1540
1541                 GitRevLoglist* pRev = nullptr;
1542                 if (selIndex >= 0)
1543                         pRev = m_LogList.m_arShownList.SafeGetAt(selIndex);
1544
1545                 if ((point.x == -1) && (point.y == -1))
1546                 {
1547                         CRect rect;
1548                         GetDlgItem(IDC_MSGVIEW)->GetClientRect(&rect);
1549                         ClientToScreen(&rect);
1550                         point = rect.CenterPoint();
1551                 }
1552                 CString sMenuItemText;
1553                 CIconMenu popup;
1554                 if (popup.CreatePopupMenu())
1555                 {
1556                         long start = -1, end = -1;
1557                         auto pEdit = (CRichEditCtrl *)GetDlgItem(IDC_MSGVIEW);
1558                         pEdit->GetSel(start, end);
1559                         // add the 'default' entries
1560                         popup.AppendMenuIcon(WM_COPY, IDS_SCIEDIT_COPY, IDI_COPYCLIP);
1561                         if (start >= end)
1562                                 popup.EnableMenuItem(WM_COPY, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
1563                         popup.AppendMenu(MF_SEPARATOR);
1564                         sMenuItemText.LoadString(IDS_STATUSLIST_CONTEXT_COPYEXT);
1565                         popup.AppendMenuIcon(EM_SETSEL, sMenuItemText, IDI_COPYCLIP);
1566                         if (pRev && !pRev->m_CommitHash.IsEmpty())
1567                         {
1568                                 popup.AppendMenu(MF_SEPARATOR, NULL);
1569                                 sMenuItemText.LoadString(IDS_EDIT_NOTES);
1570                                 popup.AppendMenuIcon(CGitLogList::ID_EDITNOTE, sMenuItemText, IDI_EDIT);
1571                         }
1572
1573                         int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
1574                         switch (cmd)
1575                         {
1576                         case 0:
1577                                 break;  // no command selected
1578                         case EM_SETSEL:
1579                                 {
1580                                         pEdit->SetRedraw(FALSE);
1581                                         int oldLine = pEdit->GetFirstVisibleLine();
1582                                         pEdit->SetSel(0, -1);
1583                                         pEdit->Copy();
1584                                         pEdit->SetSel(start, end);
1585                                         int newLine = pEdit->GetFirstVisibleLine();
1586                                         pEdit->LineScroll(oldLine - newLine);
1587                                         pEdit->SetRedraw(TRUE);
1588                                         pEdit->RedrawWindow();
1589                                 }
1590                                 break;
1591                         case WM_COPY:
1592                                 ::SendMessage(GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), cmd, 0, -1);
1593                                 break;
1594                         case CGitLogList::ID_EDITNOTE:
1595                                 CAppUtils::EditNote(GetSafeHwnd(), pRev, &m_LogList.m_ProjectProperties);
1596                                 this->FillLogMessageCtrl(true);
1597                                 break;
1598                         }
1599                 }
1600         }
1601 }
1602
1603 void CLogDlg::OnOK()
1604 {
1605         // since the log dialog is also used to select revisions for other
1606         // dialogs, we have to do some work before closing this dialog
1607         if (GetFocus() != GetDlgItem(IDOK))
1608                 return; // if the "OK" button doesn't have the focus, do nothing: this prevents closing the dialog when pressing enter
1609
1610         m_LogList.SafeTerminateAsyncDiffThread();
1611         if (this->IsThreadRunning())
1612         {
1613                 m_LogList.SafeTerminateThread();
1614         }
1615         UpdateData();
1616         // get the selected row(s)
1617         POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1618         while (pos)
1619         {
1620                 int selIndex = m_LogList.GetNextSelectedItem(pos);
1621                 GitRev* pLogEntry = m_LogList.m_arShownList.SafeGetAt(selIndex);
1622                 if (!pLogEntry)
1623                         continue;
1624                 m_sSelectedHash.push_back(pLogEntry->m_CommitHash);
1625         }
1626         UpdateData(FALSE);
1627         SaveSplitterPos();
1628         __super::OnOK();
1629
1630         #if 0
1631         if (!GetDlgItem(IDOK)->IsWindowVisible() && GetFocus() != GetDlgItem(IDCANCEL))
1632                 return; // the Cancel button works as the OK button. But if the cancel button has not the focus, do nothing.
1633
1634         CString temp;
1635         CString buttontext;
1636         GetDlgItemText(IDOK, buttontext);
1637         temp.LoadString(IDS_MSGBOX_CANCEL);
1638         if (temp.Compare(buttontext) != 0)
1639                 __super::OnOK();        // only exit if the button text matches, and that will match only if the thread isn't running anymore
1640         m_selectedRevs.Clear();
1641         m_selectedRevsOneRange.Clear();
1642         if (m_pNotifyWindow)
1643         {
1644                 int selIndex = m_LogList.GetSelectionMark();
1645                 if (selIndex >= 0)
1646                 {
1647                         PLOGENTRYDATA pLogEntry = nullptr;
1648                         POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1649                         pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
1650                         m_selectedRevs.AddRevision(pLogEntry->Rev);
1651                         git_revnum_t lowerRev = pLogEntry->Rev;
1652                         git_revnum_t higherRev = lowerRev;
1653                         while (pos)
1654                         {
1655                                 pLogEntry = reinterpret_cast<PLOGENTRYDATA>(m_arShownList.SafeGetAt(m_LogList.GetNextSelectedItem(pos)));
1656                                 git_revnum_t rev = pLogEntry->Rev;
1657                                 m_selectedRevs.AddRevision(pLogEntry->Rev);
1658                                 if (lowerRev > rev)
1659                                         lowerRev = rev;
1660                                 if (higherRev < rev)
1661                                         higherRev = rev;
1662                         }
1663                         if (m_sFilterText.IsEmpty() && m_nSortColumn == 0 && IsSelectionContinuous())
1664                         {
1665                                 m_selectedRevsOneRange.AddRevRange(lowerRev, higherRev);
1666                         }
1667                         BOOL bSentMessage = FALSE;
1668                         if (m_LogList.GetSelectedCount() == 1)
1669                         {
1670                                 // if only one revision is selected, check if the path/url with which the dialog was started
1671                                 // was directly affected in that revision. If it was, then check if our path was copied from somewhere.
1672                                 // if it was copied, use the copy from revision as lowerRev
1673                                 if ((pLogEntry)&&(pLogEntry->pArChangedPaths)&&(lowerRev == higherRev))
1674                                 {
1675                                         CString sUrl = m_path.GetGitPathString();
1676                                         if (!m_path.IsUrl())
1677                                         {
1678                                                 sUrl = GetURLFromPath(m_path);
1679                                         }
1680                                         sUrl = sUrl.Mid(m_sRepositoryRoot.GetLength());
1681                                         for (int cp = 0; cp < pLogEntry->pArChangedPaths->GetCount(); ++cp)
1682                                         {
1683                                                 LogChangedPath * pData = pLogEntry->pArChangedPaths->SafeGetAt(cp);
1684                                                 if (pData)
1685                                                 {
1686                                                         if (sUrl.Compare(pData->sPath) == 0)
1687                                                         {
1688                                                                 if (!pData->sCopyFromPath.IsEmpty())
1689                                                                 {
1690                                                                         lowerRev = pData->lCopyFromRev;
1691                                                                         m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART), lowerRev);
1692                                                                         m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND), higherRev);
1693                                                                         m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);
1694                                                                         bSentMessage = TRUE;
1695                                                                 }
1696                                                         }
1697                                                 }
1698                                         }
1699                                 }
1700                         }
1701                         if ( !bSentMessage )
1702                         {
1703                                 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTSTART | MERGE_REVSELECTMINUSONE), lowerRev);
1704                                 m_pNotifyWindow->SendMessage(WM_REVSELECTED, m_wParam & (MERGE_REVSELECTEND | MERGE_REVSELECTMINUSONE), higherRev);
1705                                 m_pNotifyWindow->SendMessage(WM_REVLIST, m_selectedRevs.GetCount(), (LPARAM)&m_selectedRevs);
1706                                 if (m_selectedRevsOneRange.GetCount())
1707                                         m_pNotifyWindow->SendMessage(WM_REVLISTONERANGE, 0, (LPARAM)&m_selectedRevsOneRange);
1708                         }
1709                 }
1710         }
1711         UpdateData();
1712         CRegDWORD reg(L"Software\\TortoiseGit\\ShowAllEntry");
1713         SaveSplitterPos();
1714 #endif
1715 }
1716
1717 void CLogDlg::OnPasteGitHash()
1718 {
1719         if (!IsClipboardFormatAvailable(CF_TEXT))
1720                 return;
1721
1722         CClipboardHelper clipboardHelper;
1723         if (!clipboardHelper.Open(GetSafeHwnd()))
1724                 return;
1725
1726         HGLOBAL hClipboardData = GetClipboardData(CF_TEXT);
1727         if (!hClipboardData)
1728                 return;
1729
1730         char* pStr = (char*)GlobalLock(hClipboardData);
1731         CString str(pStr);
1732         GlobalUnlock(hClipboardData);
1733         if (str.IsEmpty())
1734                 return;
1735
1736         int pos = 0;
1737         if (LookLikeGitHash(str, pos))
1738                 JumpToGitHash(str);
1739 }
1740
1741 void CLogDlg::JumpToGitHash(CString hash)
1742 {
1743         int prefixLen = hash.GetLength();
1744         while (hash.GetLength() < 2 * GIT_HASH_SIZE)
1745                 hash += L'0';
1746         CGitHash prefixHash(hash);
1747         // start searching downwards, because it's unlikely that a hash is a forward reference
1748         int currentPos = m_LogList.GetSelectionMark();
1749         int cnt = (int)m_LogList.m_arShownList.size();
1750         if (!cnt || currentPos < 0)
1751                 return;
1752         for (int i = currentPos + 1; i != currentPos; ++i)
1753         {
1754                 if (i >= cnt)
1755                         i = 0;
1756
1757                 GitRev* rev = m_LogList.m_arShownList.SafeGetAt(i);
1758                 if (!rev) continue;
1759                 if (!rev->m_CommitHash.MatchesPrefix(prefixHash, hash, prefixLen))
1760                         continue;
1761
1762                 m_LogList.SetItemState(m_LogList.GetSelectionMark(), 0, LVIS_SELECTED | LVIS_FOCUSED);
1763                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
1764                 while (pos)
1765                 {
1766                         int index = m_LogList.GetNextSelectedItem(pos);
1767                         if (index >= 0)
1768                                 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
1769                 }
1770                 m_LogList.EnsureVisible(i, FALSE);
1771                 m_LogList.SetSelectionMark(i);
1772                 m_LogList.SetItemState(i, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
1773                 // refresh of selection needs to be queued instead of done immediately, to ensure hyperlinks in target selection are created
1774                 PostMessage(WM_TGIT_REFRESH_SELECTION, 0, 0);
1775                 return;
1776         }
1777
1778         FlashWindowEx(FLASHW_ALL, 3, 100);
1779         CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, L"NoJumpNotFoundWarning", IDS_MSGBOX_DONOTSHOWAGAIN);
1780 }
1781
1782 BOOL CLogDlg::PreTranslateMessage(MSG* pMsg)
1783 {
1784         // Skip Ctrl-C when copying text out of the log message or search filter
1785         bool bSkipAccelerator = (pMsg->message == WM_KEYDOWN && (pMsg->wParam == 'C' || pMsg->wParam == VK_INSERT) && (GetFocus() == GetDlgItem(IDC_MSGVIEW) || GetFocus() == GetDlgItem(IDC_SEARCHEDIT) || GetFocus() == GetDlgItem(IDC_FILTER)) && GetKeyState(VK_CONTROL) & 0x8000);
1786         if (pMsg->message == WM_KEYDOWN && pMsg->wParam=='\r')
1787         {
1788                 if (GetFocus()==GetDlgItem(IDC_LOGLIST))
1789                 {
1790                         if (CRegDWORD(L"Software\\TortoiseGit\\DiffByDoubleClickInLog", FALSE))
1791                         {
1792                                 m_LogList.DiffSelectedRevWithPrevious();
1793                                 return TRUE;
1794                         }
1795                 }
1796                 if (GetFocus() == GetDlgItem(IDC_SEARCHEDIT))
1797                 {
1798                         KillTimer(LOGFILTER_TIMER);
1799                         Refresh(false);
1800                 }
1801                 if (GetFocus() == GetDlgItem(IDC_FILTER))
1802                 {
1803                         KillTimer(FILEFILTER_TIMER);
1804                         FillLogMessageCtrl();
1805                         return TRUE;
1806                 }
1807         }
1808         else if (pMsg->message == WM_KEYDOWN && ((pMsg->wParam == 'V' && GetKeyState(VK_CONTROL) < 0) || (pMsg->wParam == VK_INSERT && GetKeyState(VK_SHIFT) < 0 && GetKeyState(VK_CONTROL) >= 0)) && GetKeyState(VK_MENU) >= 0)
1809         {
1810                 if (GetFocus() != GetDlgItem(IDC_SEARCHEDIT) && GetFocus() != GetDlgItem(IDC_FILTER))
1811                 {
1812                         OnPasteGitHash();
1813                         return TRUE;
1814                 }
1815         }
1816         else if (pMsg->message == WM_KEYDOWN  && pMsg->wParam == VK_ESCAPE && GetFocus() == GetDlgItem(IDC_FILTER) && m_cFileFilter.GetWindowTextLength())
1817         {
1818                 m_cFileFilter.SetWindowText(L"");
1819                 KillTimer(FILEFILTER_TIMER);
1820                 FillLogMessageCtrl();
1821                 return TRUE;
1822         }
1823         else if (pMsg->message == WM_XBUTTONUP)
1824         {
1825                 bool select = (pMsg->wParam & MK_SHIFT) == 0;
1826                 if (HIWORD(pMsg->wParam) & XBUTTON1)
1827                         GoBackForward(select, false);
1828                 if (HIWORD(pMsg->wParam) & XBUTTON2)
1829                         GoBackForward(select, true);
1830                 if (HIWORD(pMsg->wParam) & (XBUTTON1 | XBUTTON2))
1831                         return TRUE;
1832         }
1833         if (m_hAccel && !bSkipAccelerator)
1834         {
1835                 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
1836                 if (ret)
1837                         return TRUE;
1838         }
1839
1840         return __super::PreTranslateMessage(pMsg);
1841 }
1842
1843
1844 BOOL CLogDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
1845 {
1846         //if (this->IsThreadRunning())
1847         if(m_LogList.m_bNoDispUpdates)
1848         {
1849                 // only show the wait cursor over the list control
1850                 if ((pWnd)&&
1851                         ((pWnd == GetDlgItem(IDC_LOGLIST))||
1852                         (pWnd == GetDlgItem(IDC_MSGVIEW))||
1853                         (pWnd == GetDlgItem(IDC_LOGMSG))))
1854                 {
1855                         HCURSOR hCur = LoadCursor(nullptr, IDC_WAIT);
1856                         SetCursor(hCur);
1857                         return TRUE;
1858                 }
1859         }
1860         if (pWnd && (pWnd == GetDlgItem(IDC_MSGVIEW) || pWnd == GetDlgItem(IDC_SEARCHEDIT) || pWnd == GetDlgItem(IDC_FILTER)))
1861                 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1862
1863         HCURSOR hCur = LoadCursor(nullptr, IDC_ARROW);
1864         SetCursor(hCur);
1865         return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1866 }
1867
1868 void CLogDlg::OnLvnItemchangedLoglist(NMHDR *pNMHDR, LRESULT *pResult)
1869 {
1870         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1871         *pResult = 0;
1872         //if (this->IsThreadRunning())
1873         if(m_LogList.m_bNoDispUpdates)
1874                 return;
1875         if (pNMLV->iItem >= 0)
1876         {
1877                 if (!m_LogList.m_highlight.IsEmpty())
1878                 {
1879                         m_LogList.m_highlight.Empty();
1880                         m_LogList.Invalidate();
1881                 }
1882                 this->m_LogList.m_nSearchIndex = pNMLV->iItem;
1883                 GitRev* pLogEntry = m_LogList.m_arShownList.SafeGetAt(pNMLV->iItem);
1884                 if (pLogEntry == nullptr)
1885                         return;
1886                 m_LogList.m_lastSelectedHash = pLogEntry->m_CommitHash;
1887                 if (pNMLV->iSubItem != 0)
1888                         return;
1889                 if (pNMLV->iItem == (int)m_LogList.m_arShownList.size())
1890                 {
1891                         // remove the selected state
1892                         if (pNMLV->uChanged & LVIF_STATE)
1893                         {
1894                                 m_LogList.SetItemState(pNMLV->iItem, 0, LVIS_SELECTED);
1895                                 FillLogMessageCtrl();
1896                                 UpdateData(FALSE);
1897                                 UpdateLogInfoLabel();
1898                         }
1899                         return;
1900                 }
1901                 if (pNMLV->uChanged & LVIF_STATE)
1902                 {
1903                         if ((pNMLV->uNewState & LVIS_SELECTED) && !m_bNavigatingWithSelect)
1904                         {
1905                                 m_LogList.m_selectionHistory.Add(m_LogList.m_lastSelectedHash);
1906                                 m_LogList.m_lastSelectedHash = pLogEntry->m_CommitHash;
1907                         }
1908                         FillLogMessageCtrl();
1909                         UpdateData(FALSE);
1910                 }
1911         }
1912         else
1913         {
1914                 m_LogList.m_lastSelectedHash.Empty();
1915                 FillLogMessageCtrl();
1916                 UpdateData(FALSE);
1917         }
1918         EnableOKButton();
1919         if (pNMLV->iItem < 0)
1920                 return;
1921         UpdateLogInfoLabel();
1922 }
1923
1924 void CLogDlg::OnLvnItemchangedLogmsg(NMHDR * /*pNMHDR*/, LRESULT * /*pResult*/)
1925 {
1926         if (m_ChangedFileListCtrl.IsBusy())
1927                 return;
1928         UpdateLogInfoLabel();
1929 }
1930
1931 void CLogDlg::OnEnLinkMsgview(NMHDR *pNMHDR, LRESULT *pResult)
1932 {
1933         // similar code in ProgressDlg.cpp and SyncDlg.cpp
1934         ENLINK *pEnLink = reinterpret_cast<ENLINK *>(pNMHDR);
1935         if ((pEnLink->msg == WM_LBUTTONUP) || (pEnLink->msg == WM_SETCURSOR))
1936         {
1937                 auto pEdit = reinterpret_cast<CRichEditCtrl*>(GetDlgItem(IDC_MSGVIEW));
1938                 CHARRANGE selRange;
1939                 pEdit->GetSel(selRange);
1940                 bool hasSelection = (selRange.cpMax != selRange.cpMin);
1941
1942                 CString url, msg;
1943                 GetDlgItemText(IDC_MSGVIEW, msg);
1944                 msg.Replace(L"\r\n", L"\n");
1945                 url = msg.Mid(pEnLink->chrg.cpMin, pEnLink->chrg.cpMax-pEnLink->chrg.cpMin);
1946                 auto findResult = m_LogList.m_ProjectProperties.FindBugIDPositions(msg);
1947                 if (std::find_if(findResult.cbegin(), findResult.cend(),
1948                         [=] (const CHARRANGE &cr) -> bool { return cr.cpMin == pEnLink->chrg.cpMin && cr.cpMax == pEnLink->chrg.cpMax; }
1949                 ) != findResult.cend())
1950                 {
1951                         url = m_LogList.m_ProjectProperties.GetBugIDUrl(url);
1952                         url = GetAbsoluteUrlFromRelativeUrl(url);
1953                 }
1954                 // check if it's an email address
1955                 auto atpos = url.Find(L'@');
1956                 if ((atpos > 0) && (url.ReverseFind(L'.') > atpos) && !::PathIsURL(url))
1957                         url = L"mailto:" + url;
1958                 if (::PathIsURL(url))
1959                 {
1960                         if (pEnLink->msg == WM_LBUTTONUP)
1961                         {
1962                                 if (!hasSelection)
1963                                         ShellExecute(GetSafeHwnd(), L"open", url, nullptr, nullptr, SW_SHOWDEFAULT);
1964                         }
1965                         else
1966                         {
1967                                 static RECT prevRect = { 0 };
1968                                 CWnd * pMsgView = GetDlgItem(IDC_MSGVIEW);
1969                                 if (pMsgView)
1970                                 {
1971                                         RECT rc;
1972                                         POINTL pt;
1973                                         pMsgView->SendMessage(EM_POSFROMCHAR, (WPARAM)&pt, pEnLink->chrg.cpMin);
1974                                         rc.left = pt.x;
1975                                         rc.top = pt.y;
1976                                         pMsgView->SendMessage(EM_POSFROMCHAR, (WPARAM)&pt, pEnLink->chrg.cpMax);
1977                                         rc.right = pt.x;
1978                                         rc.bottom = pt.y + 12;
1979                                         if ((prevRect.left != rc.left) || (prevRect.top != rc.top))
1980                                         {
1981                                                 m_tooltips.DelTool(pMsgView, 1);
1982                                                 m_tooltips.AddTool(pMsgView, url, &rc, 1);
1983                                                 prevRect = rc;
1984                                         }
1985                                 }
1986                         }
1987                 }
1988                 else if(pEnLink->msg == WM_LBUTTONUP && !hasSelection)
1989                 {
1990                         int pos = 0;
1991                         if (LookLikeGitHash(url, pos))
1992                                 JumpToGitHash(url);
1993                 }
1994         }
1995         *pResult = 0;
1996 }
1997
1998 void CLogDlg::OnBnClickedStatbutton()
1999 {
2000         if (this->IsThreadRunning())
2001                 return;
2002
2003         if (m_LogList.m_arShownList.empty() || m_LogList.m_arShownList.size() == 1 && m_LogList.m_bShowWC)
2004                 return;         // nothing or just the working copy changes are shown, so no statistics.
2005
2006         CStatGraphDlg dlg;
2007         dlg.m_ShowList.reserve(m_LogList.m_arShownList.size());
2008         for (size_t i = m_LogList.m_bShowWC ? 1 : 0; i < m_LogList.m_arShownList.size(); ++i)
2009                 dlg.m_ShowList.emplace_back(m_LogList.m_arShownList.SafeGetAt(i));
2010
2011         dlg.m_path = m_orgPath;
2012         dlg.DoModal();
2013 }
2014
2015 void CLogDlg::MoveToSameTop(CWnd *pWndRef, CWnd *pWndTarget)
2016 {
2017         CRect rcWndPicAuthor, rcWndMsgView;
2018         pWndRef->GetWindowRect(rcWndMsgView);
2019         ScreenToClient(rcWndMsgView);
2020         pWndTarget->GetWindowRect(rcWndPicAuthor);
2021         ScreenToClient(rcWndPicAuthor);
2022         int diff = rcWndMsgView.top - rcWndPicAuthor.top;
2023         rcWndPicAuthor.top += diff;
2024         rcWndPicAuthor.bottom += diff;
2025         pWndTarget->MoveWindow(rcWndPicAuthor);
2026 }
2027
2028 void CLogDlg::DoSizeV1(int delta)
2029 {
2030         RemoveMainAnchors();
2031
2032         // first, reduce the middle section to a minimum.
2033         // if that is not sufficient, minimize the lower section
2034
2035         CRect changeListViewRect;
2036         m_ChangedFileListCtrl.GetClientRect(changeListViewRect);
2037         CRect messageViewRect;
2038         GetDlgItem(IDC_MSGVIEW)->GetClientRect(messageViewRect);
2039
2040         int messageViewDelta = max(-delta, CDPIAware::Instance().ScaleY(20) - messageViewRect.Height());
2041         int changeFileListDelta = -delta - messageViewDelta;
2042
2043         // set new sizes & positions
2044         auto hdwp = BeginDeferWindowPos(5);
2045         hdwp = CSplitterControl::ChangeRect(hdwp, &m_LogList, 0, 0, 0, delta);
2046         hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_MSGVIEW), 0, delta, 0, delta + messageViewDelta);
2047         MoveToSameTop(GetDlgItem(IDC_MSGVIEW), GetDlgItem(IDC_PIC_AUTHOR));
2048         hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_SPLITTERBOTTOM), 0, -changeFileListDelta, 0, -changeFileListDelta);
2049         hdwp = CSplitterControl::ChangeRect(hdwp, &m_ChangedFileListCtrl, 0, -changeFileListDelta, 0, 0);
2050         EndDeferWindowPos(hdwp);
2051
2052         AddMainAnchors();
2053         ArrangeLayout();
2054         SetSplitterRange();
2055         m_LogList.Invalidate();
2056         m_ChangedFileListCtrl.Invalidate();
2057         GetDlgItem(IDC_MSGVIEW)->Invalidate();
2058         m_gravatar.Invalidate();
2059 }
2060
2061 void CLogDlg::DoSizeV2(int delta)
2062 {
2063         RemoveMainAnchors();
2064
2065         // first, reduce the middle section to a minimum.
2066         // if that is not sufficient, minimize the top section
2067
2068         CRect logViewRect;
2069         m_LogList.GetClientRect(logViewRect);
2070         CRect messageViewRect;
2071         GetDlgItem(IDC_MSGVIEW)->GetClientRect(messageViewRect);
2072
2073         int messageViewDelta = max(delta, CDPIAware::Instance().ScaleY(20) - messageViewRect.Height());
2074         int logListDelta = delta - messageViewDelta;
2075
2076         // set new sizes & positions
2077         auto hdwp = BeginDeferWindowPos(5);
2078         hdwp = CSplitterControl::ChangeRect(hdwp, &m_LogList, 0, 0, 0, logListDelta);
2079         hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_SPLITTERTOP), 0, logListDelta, 0, logListDelta);
2080         hdwp = CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_MSGVIEW), 0, logListDelta, 0, logListDelta + messageViewDelta);
2081         MoveToSameTop(GetDlgItem(IDC_MSGVIEW), GetDlgItem(IDC_PIC_AUTHOR));
2082         hdwp = CSplitterControl::ChangeRect(hdwp, &m_ChangedFileListCtrl, 0, delta, 0, 0);
2083         EndDeferWindowPos(hdwp);
2084
2085         AddMainAnchors();
2086         ArrangeLayout();
2087         SetSplitterRange();
2088         GetDlgItem(IDC_MSGVIEW)->Invalidate();
2089         m_ChangedFileListCtrl.Invalidate();
2090         m_gravatar.Invalidate();
2091 }
2092
2093 void CLogDlg::AddMainAnchors()
2094 {
2095         AddAnchor(IDC_STATIC_REF, TOP_LEFT);
2096         AddAnchor(IDC_FROMLABEL, TOP_LEFT);
2097         AddAnchor(IDC_DATEFROM, TOP_LEFT);
2098         AddAnchor(IDC_TOLABEL, TOP_LEFT);
2099         AddAnchor(IDC_DATETO, TOP_LEFT);
2100
2101         AddAnchor(IDC_SEARCHEDIT, TOP_LEFT, TOP_RIGHT);
2102         AddAnchor(IDC_LOG_JUMPTYPE, TOP_RIGHT);
2103         AddAnchor(IDC_LOG_JUMPUP, TOP_RIGHT);
2104         AddAnchor(IDC_LOG_JUMPDOWN, TOP_RIGHT);
2105
2106         AddAnchor(IDC_LOGLIST, TOP_LEFT, MIDDLE_RIGHT);
2107         AddAnchor(IDC_SPLITTERTOP, MIDDLE_LEFT, MIDDLE_RIGHT);
2108         AddAnchor(IDC_MSGVIEW, MIDDLE_LEFT, MIDDLE_RIGHT); // keep in sync with ShowGravatar()
2109         AddAnchor(IDC_PIC_AUTHOR, MIDDLE_RIGHT);
2110         AddAnchor(IDC_SPLITTERBOTTOM, MIDDLE_LEFT, MIDDLE_RIGHT);
2111         AddAnchor(IDC_LOGMSG, MIDDLE_LEFT, BOTTOM_RIGHT);
2112
2113         AddAnchor(IDC_LOGINFO, BOTTOM_LEFT, BOTTOM_RIGHT);
2114         AddAnchor(IDC_WALKBEHAVIOUR, BOTTOM_LEFT);
2115         AddAnchor(IDC_VIEW, BOTTOM_LEFT);
2116         AddAnchor(IDC_LOG_ALLBRANCH, BOTTOM_LEFT);
2117         AddAnchor(IDC_FILTER, BOTTOM_LEFT, BOTTOM_RIGHT);
2118         AddAnchor(IDC_WHOLE_PROJECT, BOTTOM_LEFT);
2119         AddAnchor(IDC_REFRESH, BOTTOM_LEFT);
2120         AddAnchor(IDC_STATBUTTON, BOTTOM_LEFT);
2121         AddAnchor(IDC_PROGRESS, BOTTOM_LEFT, BOTTOM_RIGHT);
2122         AddAnchor(IDOK, BOTTOM_RIGHT);
2123         AddAnchor(IDCANCEL, BOTTOM_RIGHT);
2124         AddAnchor(IDHELP, BOTTOM_RIGHT);
2125 }
2126
2127 void CLogDlg::RemoveMainAnchors()
2128 {
2129         RemoveAnchor(IDC_STATIC_REF);
2130         RemoveAnchor(IDC_FROMLABEL);
2131         RemoveAnchor(IDC_DATEFROM);
2132         RemoveAnchor(IDC_TOLABEL);
2133         RemoveAnchor(IDC_DATETO);
2134
2135         RemoveAnchor(IDC_SEARCHEDIT);
2136         RemoveAnchor(IDC_LOG_JUMPTYPE);
2137         RemoveAnchor(IDC_LOG_JUMPUP);
2138         RemoveAnchor(IDC_LOG_JUMPDOWN);
2139
2140         RemoveAnchor(IDC_LOGLIST);
2141         RemoveAnchor(IDC_SPLITTERTOP);
2142         RemoveAnchor(IDC_MSGVIEW);
2143         RemoveAnchor(IDC_PIC_AUTHOR);
2144         RemoveAnchor(IDC_SPLITTERBOTTOM);
2145         RemoveAnchor(IDC_LOGMSG);
2146
2147         RemoveAnchor(IDC_LOGINFO);
2148         RemoveAnchor(IDC_WALKBEHAVIOUR);
2149         RemoveAnchor(IDC_VIEW);
2150         RemoveAnchor(IDC_LOG_ALLBRANCH);
2151         RemoveAnchor(IDC_FILTER);
2152         RemoveAnchor(IDC_WHOLE_PROJECT);
2153         RemoveAnchor(IDC_REFRESH);
2154         RemoveAnchor(IDC_STATBUTTON);
2155         RemoveAnchor(IDC_PROGRESS);
2156         RemoveAnchor(IDOK);
2157         RemoveAnchor(IDCANCEL);
2158         RemoveAnchor(IDHELP);
2159 }
2160
2161 LRESULT CLogDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
2162 {
2163         switch (message) {
2164         case WM_NOTIFY:
2165                 if (wParam == IDC_SPLITTERTOP)
2166                 {
2167                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
2168                         DoSizeV1(pHdr->delta);
2169                 }
2170                 else if (wParam == IDC_SPLITTERBOTTOM)
2171                 {
2172                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
2173                         DoSizeV2(pHdr->delta);
2174                 }
2175                 break;
2176         }
2177
2178         return CResizableDialog::DefWindowProc(message, wParam, lParam);
2179 }
2180
2181 void CLogDlg::SetSplitterRange()
2182 {
2183         if ((m_LogList)&&(m_ChangedFileListCtrl))
2184         {
2185                 CRect rcTop;
2186                 m_LogList.GetWindowRect(rcTop);
2187                 ScreenToClient(rcTop);
2188
2189                 CRect rcBottom;
2190                 m_ChangedFileListCtrl.GetWindowRect(rcBottom);
2191                 ScreenToClient(rcBottom);
2192
2193                 m_wndSplitter1.SetRange(rcTop.top + MIN_CTRL_HEIGHT, rcBottom.bottom - (2 * MIN_CTRL_HEIGHT + MIN_SPLITTER_HEIGHT));
2194                 m_wndSplitter2.SetRange(rcTop.top + (2 * MIN_CTRL_HEIGHT + MIN_SPLITTER_HEIGHT), rcBottom.bottom - MIN_CTRL_HEIGHT);
2195         }
2196 }
2197
2198 void CLogDlg::OnEnscrollMsgview()
2199 {
2200         m_tooltips.DelTool(GetDlgItem(IDC_MSGVIEW), 1);
2201 }
2202
2203 LRESULT CLogDlg::OnClickedInfoIcon(WPARAM wParam, LPARAM lParam)
2204 {
2205         if ((HWND)wParam == m_cFileFilter.GetSafeHwnd())
2206                 return 0;
2207
2208         // FIXME: x64 version would get this function called with unexpected parameters.
2209         if (!lParam)
2210                 return 0;
2211
2212         RECT * rect = (LPRECT)lParam;
2213         CPoint point;
2214         CString temp;
2215         point = CPoint(rect->left, rect->bottom);
2216 #define LOGMENUFLAGS(x) (MF_STRING | MF_ENABLED | ((m_SelectedFilters & x) ? MF_CHECKED : MF_UNCHECKED))
2217         CMenu popup;
2218         if (popup.CreatePopupMenu())
2219         {
2220                 temp.LoadString(IDS_LOG_FILTER_SUBJECT);
2221                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_SUBJECT), LOGFILTER_SUBJECT, temp);
2222
2223                 temp.LoadString(IDS_LOG_FILTER_MESSAGES);
2224                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_MESSAGES), LOGFILTER_MESSAGES, temp);
2225
2226                 temp.LoadString(IDS_LOG_FILTER_PATHS);
2227                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_PATHS), LOGFILTER_PATHS, temp);
2228
2229                 temp.LoadString(IDS_LOG_FILTER_AUTHORS);
2230                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_AUTHORS), LOGFILTER_AUTHORS, temp);
2231
2232                 temp.LoadString(IDS_LOG_FILTER_EMAILS);
2233                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_EMAILS), LOGFILTER_EMAILS, temp);
2234
2235                 temp.LoadString(IDS_LOG_FILTER_REVS);
2236                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_REVS), LOGFILTER_REVS, temp);
2237
2238                 temp.LoadString(IDS_LOG_FILTER_REFNAME);
2239                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_REFNAME), LOGFILTER_REFNAME, temp);
2240
2241                 temp.LoadString(IDS_PROC_LOG_TAGINFO);
2242                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_ANNOTATEDTAG), LOGFILTER_ANNOTATEDTAG, temp);
2243
2244                 temp.LoadString(IDS_NOTES);
2245                 popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_NOTES), LOGFILTER_NOTES, temp);
2246
2247                 if (m_LogList.m_bShowBugtraqColumn == TRUE) {
2248                         temp.LoadString(IDS_LOG_FILTER_BUGIDS);
2249                         popup.AppendMenu(LOGMENUFLAGS(LOGFILTER_BUGID), LOGFILTER_BUGID, temp);
2250                 }
2251
2252                 popup.AppendMenu(MF_SEPARATOR, NULL);
2253
2254                 temp.LoadString(IDS_LOG_FILTER_TOGGLE);
2255                 popup.AppendMenu(MF_STRING | MF_ENABLED, LOGFILTER_TOGGLE, temp);
2256
2257                 temp.LoadString(IDS_ALL);
2258                 popup.AppendMenu(MF_STRING | MF_ENABLED, LOGFILTER_ALL, temp);
2259
2260                 popup.AppendMenu(MF_SEPARATOR, NULL);
2261
2262                 temp.LoadString(IDS_LOG_FILTER_REGEX);
2263                 popup.AppendMenu(MF_STRING | MF_ENABLED | (m_bFilterWithRegex ? MF_CHECKED : MF_UNCHECKED), LOGFILTER_REGEX, temp);
2264
2265                 temp.LoadString(IDS_LOG_FILTER_CASESENSITIVE);
2266                 popup.AppendMenu(MF_STRING | MF_ENABLED | (m_bFilterCaseSensitively ? MF_CHECKED : MF_UNCHECKED), LOGFILTER_CASE, temp);
2267
2268                 m_tooltips.Pop();
2269                 int selection = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this);
2270                 if (selection != 0)
2271                 {
2272                         if (selection == LOGFILTER_REGEX)
2273                         {
2274                                 m_bFilterWithRegex = !m_bFilterWithRegex;
2275                                 CRegDWORD b(L"Software\\TortoiseGit\\UseRegexFilter", FALSE);
2276                                 b = m_bFilterWithRegex;
2277                                 SetFilterCueText();
2278                                 CheckRegexpTooltip();
2279                                 m_cFilter.ValidateAndRedraw();
2280                         }
2281                         else if (selection == LOGFILTER_CASE)
2282                         {
2283                                 m_bFilterCaseSensitively = !m_bFilterCaseSensitively;
2284                                 CRegDWORD b(L"Software\\TortoiseGit\\FilterCaseSensitively", FALSE);
2285                                 b = m_bFilterCaseSensitively;
2286                         }
2287                         else if (selection == LOGFILTER_TOGGLE)
2288                         {
2289                                 m_SelectedFilters = (~m_SelectedFilters) & LOGFILTER_ALL;
2290                                 SetFilterCueText();
2291                         }
2292                         else if (selection == LOGFILTER_ALL)
2293                         {
2294                                 m_SelectedFilters = selection;
2295                                 SetFilterCueText();
2296                         }
2297                         else
2298                         {
2299                                 m_SelectedFilters ^= selection;
2300                                 SetFilterCueText();
2301                         }
2302                         CRegDWORD(L"Software\\TortoiseGit\\SelectedLogFilters") = m_SelectedFilters;
2303                         // Reload only if a search text is entered
2304                         if (m_LogList.m_LogFilter->IsFilterActive())
2305                                 SetTimer(LOGFILTER_TIMER, 1000, nullptr);
2306                 }
2307         }
2308         return 0L;
2309 }
2310
2311 LRESULT CLogDlg::OnClickedCancelFilter(WPARAM wParam, LPARAM /*lParam*/)
2312 {
2313         if ((HWND)wParam == m_cFileFilter.GetSafeHwnd())
2314         {
2315                 KillTimer(FILEFILTER_TIMER);
2316
2317                 FillLogMessageCtrl();
2318                 return 0L;
2319         }
2320
2321         KillTimer(LOGFILTER_TIMER);
2322
2323         m_sFilterText.Empty();
2324         UpdateData(FALSE);
2325         theApp.DoWaitCursor(1);
2326         FillLogMessageCtrl(false);
2327
2328         Refresh(true);
2329
2330         theApp.DoWaitCursor(-1);
2331         GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
2332         GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
2333         GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2334         UpdateLogInfoLabel();
2335
2336         return 0L;
2337 }
2338
2339
2340 void CLogDlg::SetFilterCueText()
2341 {
2342         CString temp(MAKEINTRESOURCE(IDS_LOG_FILTER_BY));
2343         temp += L' ';
2344
2345         if (m_SelectedFilters & LOGFILTER_SUBJECT)
2346         {
2347                 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_SUBJECT));
2348         }
2349
2350         if (m_SelectedFilters & LOGFILTER_MESSAGES)
2351         {
2352                 if (!CStringUtils::EndsWith(temp, L' '))
2353                         temp += L", ";
2354                 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_MESSAGES));
2355         }
2356
2357         if (m_SelectedFilters & LOGFILTER_PATHS)
2358         {
2359                 if (!CStringUtils::EndsWith(temp, L' '))
2360                         temp += L", ";
2361                 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_PATHS));
2362         }
2363
2364         if (m_SelectedFilters & LOGFILTER_AUTHORS)
2365         {
2366                 if (!CStringUtils::EndsWith(temp, L' '))
2367                         temp += L", ";
2368                 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_AUTHORS));
2369         }
2370
2371         if (m_SelectedFilters & LOGFILTER_EMAILS)
2372         {
2373                 if (!CStringUtils::EndsWith(temp, L' '))
2374                         temp += L", ";
2375                 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_EMAILS));
2376         }
2377
2378         if (m_SelectedFilters & LOGFILTER_REVS)
2379         {
2380                 if (!CStringUtils::EndsWith(temp, L' '))
2381                         temp += L", ";
2382                 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_REVS));
2383         }
2384
2385         if (m_SelectedFilters & LOGFILTER_REFNAME)
2386         {
2387                 if (!CStringUtils::EndsWith(temp, L' '))
2388                         temp += L", ";
2389                 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_REFNAME));
2390         }
2391
2392         if (m_SelectedFilters & LOGFILTER_NOTES)
2393         {
2394                 if (!CStringUtils::EndsWith(temp, L' '))
2395                         temp += L", ";
2396                 temp += CString(MAKEINTRESOURCE(IDS_NOTES));
2397         }
2398
2399         if (m_LogList.m_bShowBugtraqColumn && m_SelectedFilters & LOGFILTER_BUGID)
2400         {
2401                 if (!CStringUtils::EndsWith(temp, L' '))
2402                         temp += L", ";
2403                 temp += CString(MAKEINTRESOURCE(IDS_LOG_FILTER_BUGIDS));
2404         }
2405
2406         // to make the cue banner text appear more to the right of the edit control
2407         temp = L"   " + temp;
2408         m_cFilter.SetCueBanner(temp.TrimRight());
2409 }
2410
2411 bool CLogDlg::Validate(LPCTSTR string)
2412 {
2413         if (!m_bFilterWithRegex)
2414                 return true;
2415         std::vector<std::wregex> pats;
2416         return m_LogList.m_LogFilter->ValidateRegexp(string, pats);
2417 }
2418
2419 void CLogDlg::OnEnChangeFileFilter()
2420 {
2421         SetTimer(FILEFILTER_TIMER, 1000, nullptr);
2422 }
2423
2424 void CLogDlg::OnTimer(UINT_PTR nIDEvent)
2425 {
2426         if (nIDEvent == LOGFTIME_TIMER)
2427         {
2428                 KillTimer(LOGFTIME_TIMER);
2429                 Refresh(false);
2430         }
2431         else if (nIDEvent == LOG_FILLPATCHVTIMER)
2432                 FillPatchView();
2433         else if (nIDEvent == LOGFILTER_TIMER)
2434         {
2435                 KillTimer(LOGFILTER_TIMER);
2436                 Refresh(false);
2437
2438 #if 0
2439                 /* we will use git built-in grep to filter log */
2440                 if (this->IsThreadRunning())
2441                 {
2442                         // thread still running! So just restart the timer.
2443                         SetTimer(LOGFILTER_TIMER, 1000, nullptr);
2444                         return;
2445                 }
2446                 CWnd * focusWnd = GetFocus();
2447                 bool bSetFocusToFilterControl = ((focusWnd != GetDlgItem(IDC_DATEFROM))&&(focusWnd != GetDlgItem(IDC_DATETO))
2448                         && (focusWnd != GetDlgItem(IDC_LOGLIST)));
2449                 if (m_LogList.m_sFilterText.IsEmpty())
2450                 {
2451                         DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.IsEmpty()))));
2452                         // do not return here!
2453                         // we also need to run the filter if the filter text is empty:
2454                         // 1. to clear an existing filter
2455                         // 2. to rebuild the m_arShownList after sorting
2456                 }
2457                 theApp.DoWaitCursor(1);
2458                 CStoreSelection storeselection(this);
2459                 KillTimer(LOGFILTER_TIMER);
2460                 FillLogMessageCtrl(false);
2461
2462                 // now start filter the log list
2463                 m_LogList.StartFilter();
2464
2465                 if ( m_LogList.GetItemCount()==1 )
2466                 {
2467                         m_LogList.SetSelectionMark(0);
2468                         m_LogList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
2469                 }
2470                 theApp.DoWaitCursor(-1);
2471                 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
2472                 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
2473                 if (bSetFocusToFilterControl)
2474                         GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
2475                 UpdateLogInfoLabel();
2476 #endif
2477         } // if (nIDEvent == LOGFILTER_TIMER)
2478         else if (nIDEvent == LOG_HEADER_ORDER_TIMER)
2479         {
2480                 KillTimer(LOG_HEADER_ORDER_TIMER);
2481                 CLogOrdering orderDlg;
2482                 if (orderDlg.DoModal() == IDOK)
2483                         Refresh();
2484         }
2485         else if (nIDEvent == FILEFILTER_TIMER)
2486         {
2487                 KillTimer(FILEFILTER_TIMER);
2488                 FillLogMessageCtrl();
2489         }
2490         DialogEnableWindow(IDC_STATBUTTON, !(((this->IsThreadRunning())||(m_LogList.m_arShownList.empty() || m_LogList.m_arShownList.size() == 1 && m_LogList.m_bShowWC))));
2491         __super::OnTimer(nIDEvent);
2492 }
2493
2494 void CLogDlg::OnDtnDatetimechangeDateto(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2495 {
2496         try
2497         {
2498                 CTime _time;
2499                 m_DateTo.GetTime(_time);
2500
2501                 CTime fromTime;
2502                 m_DateFrom.GetTime(fromTime);
2503                 if (_time < fromTime)
2504                 {
2505                         _time = fromTime;
2506                         m_DateTo.SetTime(&_time);
2507                 }
2508
2509                 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 23, 59, 59);
2510                 if (time.GetTime() != m_LogList.m_Filter.m_To)
2511                 {
2512                         m_LogList.m_Filter.m_To = (DWORD)time.GetTime();
2513                         SetTimer(LOGFTIME_TIMER, 10, nullptr);
2514                 }
2515         }
2516         catch (...)
2517         {
2518                 CMessageBox::Show(GetSafeHwnd(), L"Invalidate Parameter", L"TortoiseGit", MB_OK | MB_ICONERROR);
2519         }
2520
2521         *pResult = 0;
2522 }
2523
2524 void CLogDlg::OnDtnDatetimechangeDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2525 {
2526         try
2527         {
2528                 CTime _time;
2529                 m_DateFrom.GetTime(_time);
2530
2531                 CTime toTime;
2532                 m_DateTo.GetTime(toTime);
2533                 if (_time > toTime)
2534                 {
2535                         _time = toTime;
2536                         m_DateFrom.SetTime(&_time);
2537                 }
2538
2539                 CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 0, 0, 0);
2540                 if (time.GetTime() != m_LogList.m_Filter.m_From)
2541                 {
2542                         m_LogList.m_Filter.m_From = (DWORD)time.GetTime();
2543                         m_LogList.m_Filter.m_NumberOfLogsScale = CFilterData::SHOW_LAST_SEL_DATE;
2544
2545                         if (CFilterData::SHOW_LAST_SEL_DATE == (DWORD)CRegDWORD(L"Software\\TortoiseGit\\LogDialog\\NumberOfLogsScale", CFilterData::SHOW_NO_LIMIT))
2546                                 m_regLastSelectedFromDate = time.Format(L"%Y-%m-%d");
2547
2548                         SetTimer(LOGFTIME_TIMER, 10, nullptr);
2549                 }
2550         }
2551         catch (...)
2552         {
2553                 CMessageBox::Show(GetSafeHwnd(), L"Invalidate Parameter", L"TortoiseGit", MB_OK | MB_ICONERROR);
2554         }
2555
2556         *pResult = 0;
2557 }
2558
2559 void CLogDlg::OnCbnSelchangeJumpType()
2560 {
2561         // reserved for future use
2562 }
2563
2564 void CLogDlg::OnBnClickedJumpUp()
2565 {
2566         int sel = m_JumpType.GetCurSel();
2567         if (sel < 0) return;
2568         JumpType jumpType = (JumpType)sel;
2569
2570         if (jumpType == JumpType_History)
2571         {
2572                 GoBack();
2573                 return;
2574         }
2575
2576         CString strValue;
2577         CGitHash hashValue;
2578         int index = -1;
2579         POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2580         if (pos)
2581         {
2582                 index = m_LogList.GetNextSelectedItem(pos);
2583                 if (index == 0) return;
2584
2585                 GitRev* data = m_LogList.m_arShownList.SafeGetAt(index);
2586                 if (jumpType == JumpType_AuthorEmail)
2587                         strValue = data->GetAuthorEmail();
2588                 else if (jumpType == JumpType_CommitterEmail)
2589                         strValue = data->GetCommitterEmail();
2590                 else if (jumpType == JumpType_Parent1)
2591                         hashValue = data->m_CommitHash;
2592                 else if (jumpType == JumpType_Parent2)
2593                         hashValue = data->m_CommitHash;
2594                 else if (jumpType == JumpType_TagFF)
2595                         hashValue = data->m_CommitHash;
2596                 else if (jumpType == JumpType_BranchFF)
2597                         hashValue = data->m_CommitHash;
2598
2599                 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
2600         }
2601         else
2602                 return;
2603
2604         while (pos)
2605         {
2606                 index = m_LogList.GetNextSelectedItem(pos);
2607                 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
2608         }
2609         m_LogList.SetSelectionMark(-1);
2610
2611         for (int i = index - 1; i >= 0; i--)
2612         {
2613                 bool found = false;
2614                 GitRev* data = m_LogList.m_arShownList.SafeGetAt(i);
2615                 if (jumpType == JumpType_AuthorEmail)
2616                         found = strValue == data->GetAuthorEmail();
2617                 else if (jumpType == JumpType_CommitterEmail)
2618                         found = strValue == data->GetCommitterEmail();
2619                 else if (jumpType == JumpType_MergePoint)
2620                         found = data->ParentsCount() > 1;
2621                 else if (jumpType == JumpType_Parent1)
2622                 {
2623                         if (!data->m_ParentHash.empty())
2624                                 found = data->m_ParentHash[0] == hashValue;
2625                 }
2626                 else if (jumpType == JumpType_Parent2)
2627                 {
2628                         if (data->m_ParentHash.size() > 1)
2629                                 found = data->m_ParentHash[1] == hashValue;
2630                 }
2631                 else if (jumpType == JumpType_Tag || jumpType == JumpType_TagFF)
2632                 {
2633                         auto refList = m_LogList.m_HashMap.find(data->m_CommitHash);
2634                         if (refList != m_LogList.m_HashMap.cend())
2635                                 found = find_if((*refList).second, [](const auto& ref) { return CStringUtils::StartsWith(ref, L"refs/tags/"); }) != (*refList).second.cend();
2636
2637                         if (found && jumpType == JumpType_TagFF)
2638                                 found = g_Git.IsFastForward(hashValue.ToString(), data->m_CommitHash.ToString());
2639                 }
2640                 else if (jumpType == JumpType_Branch || jumpType == JumpType_BranchFF)
2641                 {
2642                         auto refList = m_LogList.m_HashMap.find(data->m_CommitHash);
2643                         if (refList != m_LogList.m_HashMap.cend())
2644                                 found = find_if((*refList).second, [](const auto& ref) { return CStringUtils::StartsWith(ref, L"refs/heads/") || CStringUtils::StartsWith(ref, L"refs/remotes/"); }) != (*refList).second.cend();
2645
2646                         if (found && jumpType == JumpType_BranchFF)
2647                                 found = g_Git.IsFastForward(hashValue.ToString(), data->m_CommitHash.ToString());
2648                 }
2649
2650                 if (found)
2651                 {
2652                         m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2653                         m_LogList.EnsureVisible(i, FALSE);
2654                         m_LogList.SetSelectionMark(i);
2655                         return;
2656                 }
2657         }
2658
2659         CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, L"NoJumpNotFoundWarning", IDS_MSGBOX_DONOTSHOWAGAIN);
2660 }
2661
2662 void CLogDlg::OnBnClickedJumpDown()
2663 {
2664         int jumpType = m_JumpType.GetCurSel();
2665         if (jumpType < 0) return;
2666
2667         if (jumpType == JumpType_History)
2668         {
2669                 GoForward();
2670                 return;
2671         }
2672
2673         CString strValue;
2674         CGitHash hashValue;
2675         int index = -1;
2676         POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2677         if (pos)
2678         {
2679                 index = m_LogList.GetNextSelectedItem(pos);
2680                 if (index == 0) return;
2681
2682                 GitRev* data = m_LogList.m_arShownList.SafeGetAt(index);
2683                 if (jumpType == JumpType_AuthorEmail)
2684                         strValue = data->GetAuthorEmail();
2685                 else if (jumpType == JumpType_CommitterEmail)
2686                         strValue = data->GetCommitterEmail();
2687                 else if (jumpType == JumpType_Parent1)
2688                 {
2689                         if (!data->m_ParentHash.empty())
2690                                 hashValue = data->m_ParentHash.at(0);
2691                         else
2692                                 return;
2693                 }
2694                 else if (jumpType == JumpType_Parent2)
2695                 {
2696                         if (data->m_ParentHash.size() > 1)
2697                                 hashValue = data->m_ParentHash.at(1);
2698                         else
2699                                 return;
2700                 }
2701                 else if (jumpType == JumpType_TagFF)
2702                         hashValue = data->m_CommitHash;
2703                 else if (jumpType == JumpType_BranchFF)
2704                         hashValue = data->m_CommitHash;
2705
2706                 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
2707         }
2708         else
2709                 return;
2710
2711         while (pos)
2712         {
2713                 index = m_LogList.GetNextSelectedItem(pos);
2714                 m_LogList.SetItemState(index, 0, LVIS_SELECTED);
2715         }
2716         m_LogList.SetSelectionMark(-1);
2717
2718         for (int i = index + 1; i < m_LogList.GetItemCount(); ++i)
2719         {
2720                 bool found = false;
2721                 GitRev* data = m_LogList.m_arShownList.SafeGetAt(i);
2722                 if (jumpType == JumpType_AuthorEmail)
2723                         found = strValue == data->GetAuthorEmail();
2724                 else if (jumpType == JumpType_CommitterEmail)
2725                         found = strValue == data->GetCommitterEmail();
2726                 else if (jumpType == JumpType_MergePoint)
2727                         found = data->ParentsCount() > 1;
2728                 else if (jumpType == JumpType_Parent1)
2729                         found = data->m_CommitHash == hashValue;
2730                 else if (jumpType == JumpType_Parent2)
2731                         found = data->m_CommitHash == hashValue;
2732                 else if (jumpType == JumpType_Tag || jumpType == JumpType_TagFF)
2733                 {
2734                         auto refList = m_LogList.m_HashMap.find(data->m_CommitHash);
2735                         if (refList != m_LogList.m_HashMap.cend())
2736                                 found = find_if((*refList).second, [](const auto& ref) { return CStringUtils::StartsWith(ref, L"refs/tags/"); }) != (*refList).second.cend();
2737
2738                         if (found && jumpType == JumpType_TagFF)
2739                                 found = g_Git.IsFastForward(data->m_CommitHash.ToString(), hashValue.ToString());
2740                 }
2741                 else if (jumpType == JumpType_Branch || jumpType == JumpType_BranchFF)
2742                 {
2743                         auto refList = m_LogList.m_HashMap.find(data->m_CommitHash);
2744                         if (refList != m_LogList.m_HashMap.cend())
2745                                 found = find_if((*refList).second, [](const auto& ref) { return CStringUtils::StartsWith(ref, L"refs/heads/") || CStringUtils::StartsWith(ref, L"refs/remotes/"); }) != (*refList).second.cend();
2746
2747                         if (found && jumpType == JumpType_BranchFF)
2748                                 found = g_Git.IsFastForward(data->m_CommitHash.ToString(), hashValue.ToString());
2749                 }
2750
2751                 if (found)
2752                 {
2753                         m_LogList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
2754                         m_LogList.EnsureVisible(i, FALSE);
2755                         m_LogList.SetSelectionMark(i);
2756                         return;
2757                 }
2758         }
2759
2760         CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROC_LOG_JUMPNOTFOUND, IDS_APPNAME, 1, IDI_INFORMATION, IDS_OKBUTTON, 0, 0, L"NoJumpNotFoundWarning", IDS_MSGBOX_DONOTSHOWAGAIN);
2761 }
2762
2763 void CLogDlg::SortByColumn(int /*nSortColumn*/, bool /*bAscending*/)
2764 {
2765 #if 0
2766         switch(nSortColumn)
2767         {
2768         case 0: // Revision
2769                 {
2770                         if(bAscending)
2771                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscRevSort());
2772                         else
2773                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescRevSort());
2774                 }
2775                 break;
2776         case 1: // action
2777                 {
2778                         if(bAscending)
2779                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscActionSort());
2780                         else
2781                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescActionSort());
2782                 }
2783                 break;
2784         case 2: // Author
2785                 {
2786                         if(bAscending)
2787                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscAuthorSort());
2788                         else
2789                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescAuthorSort());
2790                 }
2791                 break;
2792         case 3: // Date
2793                 {
2794                         if(bAscending)
2795                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscDateSort());
2796                         else
2797                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescDateSort());
2798                 }
2799                 break;
2800         case 4: // Message or bug id
2801                 if (m_bShowBugtraqColumn)
2802                 {
2803                         if(bAscending)
2804                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscBugIDSort());
2805                         else
2806                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescBugIDSort());
2807                         break;
2808                 }
2809                 // fall through here
2810         case 5: // Message
2811                 {
2812                         if(bAscending)
2813                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::AscMessageSort());
2814                         else
2815                                 std::sort(m_logEntries.begin(), m_logEntries.end(), CLogDataVector::DescMessageSort());
2816                 }
2817                 break;
2818         default:
2819                 ATLASSERT(0);
2820                 break;
2821         }
2822 #endif
2823 }
2824
2825 void CLogDlg::OnLvnColumnclick(NMHDR *pNMHDR, LRESULT *pResult)
2826 {
2827         if (this->IsThreadRunning())
2828                 return;         //no sorting while the arrays are filled
2829 #if 0
2830         LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
2831         const int nColumn = pNMLV->iSubItem;
2832         m_bAscending = nColumn == m_nSortColumn ? !m_bAscending : TRUE;
2833         m_nSortColumn = nColumn;
2834         SortByColumn(m_nSortColumn, m_bAscending);
2835         SetSortArrow(&m_LogList, m_nSortColumn, !!m_bAscending);
2836         SortShownListArray();
2837         m_LogList.Invalidate();
2838         UpdateLogInfoLabel();
2839 #else
2840         UNREFERENCED_PARAMETER(pNMHDR);
2841 #endif
2842         *pResult = 0;
2843
2844         SetTimer(LOG_HEADER_ORDER_TIMER, 10, nullptr);
2845 }
2846
2847 void CLogDlg::SortShownListArray()
2848 {
2849         // make sure the shown list still matches the filter after sorting.
2850         OnTimer(LOGFILTER_TIMER);
2851         // clear the selection states
2852         POSITION pos = m_LogList.GetFirstSelectedItemPosition();
2853         while (pos)
2854         {
2855                 m_LogList.SetItemState(m_LogList.GetNextSelectedItem(pos), 0, LVIS_SELECTED);
2856         }
2857         m_LogList.SetSelectionMark(-1);
2858 }
2859
2860 void CLogDlg::SetSortArrow(CListCtrl * control, int nColumn, bool bAscending)
2861 {
2862         if (!control)
2863                 return;
2864         // set the sort arrow
2865         CHeaderCtrl * pHeader = control->GetHeaderCtrl();
2866         HDITEM HeaderItem = {0};
2867         HeaderItem.mask = HDI_FORMAT;
2868         for (int i=0; i<pHeader->GetItemCount(); ++i)
2869         {
2870                 pHeader->GetItem(i, &HeaderItem);
2871                 HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
2872                 pHeader->SetItem(i, &HeaderItem);
2873         }
2874         if (nColumn >= 0)
2875         {
2876                 pHeader->GetItem(nColumn, &HeaderItem);
2877                 HeaderItem.fmt |= (bAscending ? HDF_SORTUP : HDF_SORTDOWN);
2878                 pHeader->SetItem(nColumn, &HeaderItem);
2879         }
2880 }
2881
2882 int CLogDlg::m_nSortColumnPathList = 0;
2883 bool CLogDlg::m_bAscendingPathList = false;
2884
2885 void CLogDlg::OnBnClickedHidepaths()
2886 {
2887         FillLogMessageCtrl();
2888         m_ChangedFileListCtrl.Invalidate();
2889 }
2890
2891 void CLogDlg::UpdateLogInfoLabel()
2892 {
2893         CGitHash rev1 ;
2894         CGitHash rev2 ;
2895         long selectedrevs = 0;
2896         long selectedfiles = 0;
2897         int count = (int)m_LogList.m_arShownList.size();
2898         int start = 0;
2899         if (count >= 1)
2900         {
2901                 auto pRev = m_LogList.m_arShownList.SafeGetAt(0);
2902                 if (pRev)
2903                 {
2904                         rev1 = m_LogList.m_arShownList.SafeGetAt(0)->m_CommitHash;
2905                         if (m_LogList.m_bShowWC && rev1.IsEmpty() && count > 1)
2906                         {
2907                                 start = 1;
2908                                 pRev = m_LogList.m_arShownList.SafeGetAt(start);
2909                                 if (pRev)
2910                                         rev1 = pRev->m_CommitHash;
2911                         }
2912                 }
2913                 pRev = m_LogList.m_arShownList.SafeGetAt(count - 1);
2914                 if (pRev)
2915                         rev2 = pRev->m_CommitHash;
2916                 selectedrevs = m_LogList.GetSelectedCount();
2917                 if (selectedrevs)
2918                         selectedfiles = m_ChangedFileListCtrl.GetSelectedCount();
2919         }
2920         CString sTemp;
2921         sTemp.FormatMessage(IDS_PROC_LOG_STATS,
2922                 count - start,
2923                 (LPCTSTR)rev2.ToString().Left(g_Git.GetShortHASHLength()), (LPCTSTR)rev1.ToString().Left(g_Git.GetShortHASHLength()), selectedrevs, selectedfiles);
2924
2925         if(selectedrevs == 1)
2926         {
2927                 CString str=m_ChangedFileListCtrl.GetStatisticsString(true);
2928                 str.Replace(L'\n', L' ');
2929                 sTemp += L"; " + str;
2930         }
2931         m_sLogInfo = sTemp;
2932
2933         UpdateData(FALSE);
2934 }
2935
2936 void CLogDlg::OnDtnDropdownDatefrom(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2937 {
2938         // the date control should not show the "today" button
2939         CMonthCalCtrl * pCtrl = m_DateFrom.GetMonthCalCtrl();
2940         if (pCtrl)
2941                 pCtrl->ModifyStyle(0, MCS_NOTODAY);
2942         *pResult = 0;
2943 }
2944
2945 void CLogDlg::OnSize(UINT nType, int cx, int cy)
2946 {
2947         __super::OnSize(nType, cx, cy);
2948         if ((m_LogList) && (m_ChangedFileListCtrl) && (nType == 0) && (cx >0) && (cy > 0))
2949         {
2950                 // correct the splitter positions if they're out of bounds
2951                 CRect rcTop;
2952                 m_LogList.GetWindowRect(rcTop);
2953                 ScreenToClient(rcTop);
2954
2955                 CRect rcMiddle;
2956                 GetDlgItem(IDC_MSGVIEW)->GetWindowRect(rcMiddle);
2957                 ScreenToClient(rcMiddle);
2958
2959                 CRect rcBottom;
2960                 m_ChangedFileListCtrl.GetWindowRect(rcBottom);
2961                 ScreenToClient(rcBottom);
2962
2963                 CRect rcBottomLimit;
2964                 GetDlgItem(IDC_LOGINFO)->GetWindowRect(rcBottomLimit);
2965                 ScreenToClient(rcBottomLimit);
2966
2967                 auto minCtrlHeight = MIN_CTRL_HEIGHT;
2968
2969                 // the IDC_LOGINFO and the changed file list control
2970                 // have a space of 3 dlg units between them (check in the dlg resource editor)
2971                 CRect dlgUnitRect(0, 0, 3, 3);
2972                 MapDialogRect(&dlgUnitRect);
2973
2974                 if ((rcTop.Height() < minCtrlHeight) ||
2975                         (rcMiddle.Height() < minCtrlHeight) ||
2976                         (rcBottom.Height() < minCtrlHeight) ||
2977                         (rcBottom.bottom > rcBottomLimit.top - dlgUnitRect.bottom))
2978                 {
2979                         // controls sizes and splitters need adjusting
2980                         RemoveMainAnchors();
2981
2982                         auto hdwp = BeginDeferWindowPos(5);
2983                         auto hdwpflags = SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOREDRAW | SWP_NOZORDER;
2984                         auto splitterHeight = MIN_SPLITTER_HEIGHT;
2985
2986                         if ((rcBottom.bottom > rcBottomLimit.top - dlgUnitRect.bottom) || (rcBottom.Height() < minCtrlHeight))
2987                         {
2988                                 // the bottom of the changed files list control is
2989                                 // below the point it should get, so move it upwards.
2990                                 // or the control is too small and needs extending.
2991                                 rcBottom.bottom = rcBottomLimit.top + dlgUnitRect.bottom;
2992                                 rcBottom.top = min(rcBottom.top, rcBottom.bottom - minCtrlHeight);
2993                                 DeferWindowPos(hdwp, m_ChangedFileListCtrl.GetSafeHwnd(), nullptr, rcBottom.left, rcBottom.top, rcBottom.Width(), rcBottom.Height(), hdwpflags);
2994                                 if (rcBottom.top < rcMiddle.bottom + splitterHeight)
2995                                 {
2996                                         // we also need to move splitter2 and rcMiddle.bottom upwards
2997                                         CRect rcSplitter2;
2998                                         m_wndSplitter2.GetWindowRect(rcSplitter2);
2999                                         ScreenToClient(rcSplitter2);
3000                                         rcSplitter2.top = rcBottom.top - splitterHeight;
3001                                         rcSplitter2.bottom = rcBottom.top;
3002                                         DeferWindowPos(hdwp, m_wndSplitter2.GetSafeHwnd(), nullptr, rcSplitter2.left, rcSplitter2.top, rcSplitter2.Width(), rcSplitter2.Height(), hdwpflags);
3003                                         rcMiddle.bottom = rcSplitter2.top;
3004                                         if (rcMiddle.Height() < minCtrlHeight)
3005                                         {
3006                                                 // now the message view is too small, we have to
3007                                                 // move splitter1 upwards and resize the top view
3008                                                 CRect rcSplitter1;
3009                                                 m_wndSplitter1.GetWindowRect(rcSplitter1);
3010                                                 ScreenToClient(rcSplitter1);
3011                                                 rcMiddle.top = min(rcMiddle.top, rcMiddle.bottom - minCtrlHeight);
3012                                                 rcSplitter1.top = rcMiddle.top - splitterHeight;
3013                                                 rcSplitter1.bottom = rcMiddle.top;
3014                                                 DeferWindowPos(hdwp, m_wndSplitter1.GetSafeHwnd(), nullptr, rcSplitter1.left, rcSplitter1.top, rcSplitter1.Width(), rcSplitter1.Height(), hdwpflags);
3015                                                 rcTop.bottom = rcSplitter1.top;
3016                                                 DeferWindowPos(hdwp, m_LogList.GetSafeHwnd(), nullptr, rcTop.left, rcTop.top, rcTop.Width(), rcTop.Height(), hdwpflags);
3017                                         }
3018                                         rcMiddle.top = min(rcMiddle.top, rcMiddle.bottom - minCtrlHeight);
3019                                         DeferWindowPos(hdwp, GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), nullptr, rcMiddle.left, rcMiddle.top, rcMiddle.Width(), rcMiddle.Height(), hdwpflags);
3020                                 }
3021                         }
3022                         if (rcTop.Height() < minCtrlHeight)
3023                         {
3024                                 // the log list view is too small. Extend its height down and move splitter1 down.
3025                                 rcTop.bottom = rcTop.top + minCtrlHeight;
3026                                 DeferWindowPos(hdwp, m_LogList.GetSafeHwnd(), nullptr, rcTop.left, rcTop.top, rcTop.Width(), rcTop.Height(), hdwpflags);
3027                                 CRect rcSplitter1;
3028                                 m_wndSplitter1.GetWindowRect(rcSplitter1);
3029                                 ScreenToClient(rcSplitter1);
3030                                 rcSplitter1.top = rcTop.bottom;
3031                                 rcSplitter1.bottom = rcSplitter1.top + splitterHeight;
3032                                 DeferWindowPos(hdwp, m_wndSplitter1.GetSafeHwnd(), nullptr, rcSplitter1.left, rcSplitter1.top, rcSplitter1.Width(), rcSplitter1.Height(), hdwpflags);
3033                                 // since splitter1 moves down, also adjust the message view
3034                                 rcMiddle.top = rcSplitter1.bottom;
3035                                 DeferWindowPos(hdwp, GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), nullptr, rcMiddle.left, rcMiddle.top, rcMiddle.Width(), rcMiddle.Height(), hdwpflags);
3036                         }
3037                         if (rcMiddle.Height() < minCtrlHeight)
3038                         {
3039                                 // the message view is too small. Extend its height down and move splitter2 down;
3040                                 rcMiddle.bottom = rcMiddle.top + minCtrlHeight;
3041                                 DeferWindowPos(hdwp, GetDlgItem(IDC_MSGVIEW)->GetSafeHwnd(), nullptr, rcMiddle.left, rcMiddle.top, rcMiddle.Width(), rcMiddle.Height(), hdwpflags);
3042                                 CRect rcSplitter2;
3043                                 m_wndSplitter2.GetWindowRect(rcSplitter2);
3044                                 ScreenToClient(rcSplitter2);
3045                                 rcSplitter2.top = rcMiddle.bottom;
3046                                 rcSplitter2.bottom = rcSplitter2.top + splitterHeight;
3047                                 DeferWindowPos(hdwp, m_wndSplitter2.GetSafeHwnd(), nullptr, rcSplitter2.left, rcSplitter2.top, rcSplitter2.Width(), rcSplitter2.Height(), hdwpflags);
3048                                 // since splitter2 moves down, also adjust the changed files list control
3049                                 rcBottom.top = rcSplitter2.bottom;
3050                                 DeferWindowPos(hdwp, m_ChangedFileListCtrl.GetSafeHwnd(), nullptr, rcBottom.left, rcBottom.top, rcBottom.Width(), rcBottom.Height(), hdwpflags);
3051                         }
3052                         EndDeferWindowPos(hdwp);
3053
3054                         AddMainAnchors();
3055                         ArrangeLayout();
3056                 }
3057
3058                 m_wndSplitter1.SetRange(rcTop.top + MIN_CTRL_HEIGHT, rcBottom.bottom - (2 * MIN_CTRL_HEIGHT + MIN_SPLITTER_HEIGHT));
3059                 m_wndSplitter2.SetRange(rcTop.top + (2 * MIN_CTRL_HEIGHT + MIN_SPLITTER_HEIGHT), rcBottom.bottom - MIN_CTRL_HEIGHT);
3060
3061                 m_LogList.Invalidate();
3062                 m_ChangedFileListCtrl.Invalidate();
3063                 GetDlgItem(IDC_MSGVIEW)->Invalidate();
3064         }
3065 }
3066
3067 void CLogDlg::OnRefresh()
3068 {
3069         {
3070                 this->m_LogProgress.SetPos(0);
3071
3072                 Refresh (false);
3073         }
3074 }
3075
3076 void CLogDlg::OnFocusFilter()
3077 {
3078         GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
3079 }
3080
3081 void CLogDlg::OnEditCopy()
3082 {
3083         if (GetFocus() == &m_ChangedFileListCtrl)
3084                 CopyChangedSelectionToClipBoard();
3085         else
3086                 m_LogList.CopySelectionToClipBoard();
3087 }
3088
3089 CString CLogDlg::GetAbsoluteUrlFromRelativeUrl(const CString& url)
3090 {
3091         // is the URL a relative one?
3092         if (CStringUtils::StartsWith(url, L"^/"))
3093         {
3094                 // URL is relative to the repository root
3095                 CString url1 = m_sRepositoryRoot + url.Mid(1);
3096                 TCHAR buf[INTERNET_MAX_URL_LENGTH] = { 0 };
3097                 DWORD len = url.GetLength();
3098                 if (UrlCanonicalize((LPCTSTR)url1, buf, &len, 0) == S_OK)
3099                         return CString(buf, len);
3100                 return url1;
3101         }
3102         else if (url[0] == '/')
3103         {
3104                 // URL is relative to the server's hostname
3105                 CString sHost;
3106                 // find the server's hostname
3107                 int schemepos = m_sRepositoryRoot.Find(L"//");
3108                 if (schemepos >= 0)
3109                 {
3110                         sHost = m_sRepositoryRoot.Left(m_sRepositoryRoot.Find(L'/', schemepos + 3));
3111                         CString url1 = sHost + url;
3112                         TCHAR buf[INTERNET_MAX_URL_LENGTH] = { 0 };
3113                         DWORD len = url.GetLength();
3114                         if (UrlCanonicalize((LPCTSTR)url, buf, &len, 0) == S_OK)
3115                                 return CString(buf, len);
3116                         return url1;
3117                 }
3118         }
3119         return url;
3120 }
3121
3122 void CLogDlg::ShowGravatar()
3123 {
3124         m_gravatar.EnableGravatar(m_bShowGravatar);
3125         RemoveAnchor(IDC_MSGVIEW);
3126         if (m_gravatar.IsGravatarEnabled())
3127         {
3128                 RECT rect, rect2;
3129                 GetDlgItem(IDC_MSGVIEW)->GetWindowRect(&rect);
3130                 ScreenToClient(&rect);
3131                 m_gravatar.GetWindowRect(&rect2);
3132                 ScreenToClient(&rect2);
3133                 rect.right = rect2.left;
3134                 GetDlgItem(IDC_MSGVIEW)->MoveWindow(&rect);
3135                 m_gravatar.ShowWindow(SW_SHOW);
3136         }
3137         else
3138         {
3139                 RECT rect, rect2;
3140                 GetDlgItem(IDC_MSGVIEW)->GetWindowRect(&rect);
3141                 ScreenToClient(&rect);
3142                 m_gravatar.GetWindowRect(&rect2);
3143                 ScreenToClient(&rect2);
3144                 rect.right = rect2.right;
3145                 GetDlgItem(IDC_MSGVIEW)->MoveWindow(&rect);
3146                 m_gravatar.ShowWindow(SW_HIDE);
3147         }
3148         AddAnchor(IDC_MSGVIEW, MIDDLE_LEFT, MIDDLE_RIGHT); // keep in sync with AddMainAnchors
3149 }
3150
3151
3152 void CLogDlg::OnEnChangeSearchedit()
3153 {
3154         UpdateData();
3155         if (m_sFilterText.IsEmpty())
3156         {
3157                 // clear the filter, i.e. make all entries appear
3158                 theApp.DoWaitCursor(1);
3159                 KillTimer(LOGFILTER_TIMER);
3160                 FillLogMessageCtrl(false);
3161
3162                 Refresh(true);
3163
3164                 theApp.DoWaitCursor(-1);
3165                 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_HIDE);
3166                 GetDlgItem(IDC_SEARCHEDIT)->ShowWindow(SW_SHOW);
3167                 GetDlgItem(IDC_SEARCHEDIT)->SetFocus();
3168                 DialogEnableWindow(IDC_STATBUTTON, !(this->IsThreadRunning() || m_LogList.m_arShownList.empty()));
3169                 return;
3170         }
3171         if (Validate(m_sFilterText))
3172                 SetTimer(LOGFILTER_TIMER, 1000, nullptr);
3173         else
3174                 KillTimer(LOGFILTER_TIMER);
3175 }
3176
3177 void CLogDlg::OnBnClickedAllBranch()
3178 {
3179         // m_bAllBranch is not auto-toggled by MFC, we have to handle it manually (in order to prevent the indeterminate state)
3180
3181         m_LogList.m_ShowMask &=~ (CGit::LOG_INFO_LOCAL_BRANCHES | CGit::LOG_INFO_BASIC_REFS | CGit::LOG_INFO_ALL_BRANCH);
3182
3183         if (m_bAllBranch)
3184         {
3185                 m_bAllBranch = BST_UNCHECKED;
3186                 m_AllBranchType = AllBranchType::None;
3187                 m_ChangedFileListCtrl.m_sDisplayedBranch = m_LogList.GetRange();
3188         }
3189         else
3190         {
3191                 m_bAllBranch = BST_CHECKED;
3192                 m_AllBranchType = AllBranchType::AllBranches;
3193                 m_LogList.m_ShowMask|=CGit::LOG_INFO_ALL_BRANCH;
3194                 m_ChangedFileListCtrl.m_sDisplayedBranch.Empty();
3195         }
3196
3197         // need to save value here, so that log dialogs started from now on also have AllBranch activated
3198         m_regbAllBranch = (DWORD)m_AllBranchType;
3199
3200         UpdateData(FALSE);
3201
3202         OnRefresh();
3203
3204         FillLogMessageCtrl(false);
3205 }
3206
3207 void CLogDlg::OnBnClickedFollowRenames()
3208 {
3209         if(m_bFollowRenames)
3210         {
3211                 m_LogList.m_ShowMask |= CGit::LOG_INFO_FOLLOW;
3212                 m_LogList.m_ShowMask &=~ CGit::LOG_INFO_LOCAL_BRANCHES;
3213                 m_LogList.m_ShowMask &= ~CGit::LOG_INFO_BASIC_REFS;
3214                 if (m_bAllBranch)
3215                 {
3216                         m_bAllBranch = FALSE;
3217                         m_AllBranchType = AllBranchType::None;
3218                         m_LogList.m_ShowMask &=~ CGit::LOG_INFO_ALL_BRANCH;
3219                 }
3220         }
3221         else
3222                 m_LogList.m_ShowMask &= ~CGit::LOG_INFO_FOLLOW;
3223
3224         DialogEnableWindow(IDC_LOG_ALLBRANCH, !m_bFollowRenames);
3225         DialogEnableWindow(IDC_WHOLE_PROJECT, !m_bFollowRenames && !m_path.IsEmpty());
3226
3227         OnRefresh();
3228
3229         FillLogMessageCtrl(false);
3230 }
3231
3232 void CLogDlg::HandleShowLabels(bool var, int flag)
3233 {
3234         if (var)
3235                 m_LogList.m_ShowRefMask |= flag;
3236         else
3237                 m_LogList.m_ShowRefMask &= ~flag;
3238
3239         if ((m_LogList.m_ShowFilter & CGitLogListBase::FILTERSHOW_REFS) && !(m_LogList.m_ShowFilter & CGitLogListBase::FILTERSHOW_ANYCOMMIT))
3240         {
3241                 // Remove commits where labels are not shown.
3242                 OnRefresh();
3243                 FillLogMessageCtrl(false);
3244         }
3245         else
3246         {
3247                 // Just redraw
3248                 m_LogList.Invalidate();
3249         }
3250 }
3251
3252 void CLogDlg::OnBnClickedCompressedGraph()
3253 {
3254         UpdateData();
3255
3256         if (m_iCompressedGraph == 2)
3257                 m_LogList.m_ShowFilter = CGitLogListBase::FILTERSHOW_REFS;
3258         else if (m_iCompressedGraph == 1)
3259                 m_LogList.m_ShowFilter = static_cast<CGitLogListBase::FilterShow>(CGitLogListBase::FILTERSHOW_REFS | CGitLogListBase::FILTERSHOW_MERGEPOINTS);
3260         else
3261                 m_LogList.m_ShowFilter = CGitLogListBase::FILTERSHOW_ALL;
3262
3263         OnRefresh();
3264         FillLogMessageCtrl(false);
3265 }
3266
3267 void CLogDlg::OnBnClickedBrowseRef()
3268 {
3269         CString newRef = CBrowseRefsDlg::PickRef(false, m_LogList.GetRange(), gPickRef_All, true);
3270         if(newRef.IsEmpty())
3271                 return;
3272
3273         m_History.AddEntry(newRef);
3274         m_History.Save();
3275
3276         SetRange(newRef);
3277
3278         m_LogList.m_ShowMask &= ~(CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_BASIC_REFS | CGit::LOG_INFO_LOCAL_BRANCHES);
3279         m_bAllBranch = BST_UNCHECKED;
3280         m_AllBranchType = AllBranchType::None;
3281         UpdateData(FALSE);
3282
3283         OnRefresh();
3284         FillLogMessageCtrl(false);
3285 }
3286
3287 void CLogDlg::ShowStartRef()
3288 {
3289         //Show ref name on top
3290         if(!::IsWindow(m_hWnd))
3291                 return;
3292         if (m_LogList.m_ShowMask & (CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_BASIC_REFS | CGit::LOG_INFO_LOCAL_BRANCHES))
3293         {
3294                 switch (m_LogList.m_ShowMask & (CGit::LOG_INFO_ALL_BRANCH | CGit::LOG_INFO_BASIC_REFS | CGit::LOG_INFO_LOCAL_BRANCHES))
3295                 {
3296                 case CGit::LOG_INFO_ALL_BRANCH:
3297                         m_staticRef.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_LOG_ALLBRANCHES)));
3298                         break;
3299
3300                 case CGit::LOG_INFO_BASIC_REFS:
3301                         m_staticRef.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_LOG_BASIC_REFS)));
3302                         break;
3303
3304                 case CGit::LOG_INFO_LOCAL_BRANCHES:
3305                         m_staticRef.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_LOG_LOCAL_BRANCHES)));
3306                         break;
3307                 }
3308
3309                 m_staticRef.Invalidate(TRUE);
3310                 m_tooltips.DelTool(GetDlgItem(IDC_STATIC_REF));
3311                 return;
3312         }
3313
3314         CString showStartRef = m_LogList.GetRange();
3315         if (showStartRef.IsEmpty() || showStartRef == L"HEAD")
3316         {
3317                 showStartRef.Empty();
3318                 //Ref name is HEAD
3319                 if (g_Git.Run(L"git.exe symbolic-ref HEAD", &showStartRef, nullptr, CP_UTF8))
3320                         showStartRef.LoadString(IDS_PROC_LOG_NOBRANCH);
3321                 showStartRef.Trim(L"\r\n\t ");
3322         }
3323
3324
3325         showStartRef = g_Git.StripRefName(showStartRef);
3326
3327         m_staticRef.SetWindowText(showStartRef);
3328         CWnd *pWnd = GetDlgItem(IDC_STATIC_REF);
3329         m_tooltips.AddTool(pWnd, showStartRef);
3330         m_staticRef.Invalidate(TRUE);
3331 }
3332
3333 void CLogDlg::SetRange(const CString& range)
3334 {
3335         m_LogList.SetRange(range);
3336         m_ChangedFileListCtrl.m_sDisplayedBranch = range;
3337
3338         ShowStartRef();
3339 }
3340
3341 static void AppendMenuChecked(CMenu &menu, UINT nTextID, UINT_PTR nItemID, BOOL checked = FALSE, BOOL enabled = TRUE)
3342 {
3343         CString text;
3344         text.LoadString(nTextID);
3345         menu.AppendMenu(MF_STRING | (enabled ? MF_ENABLED : MF_DISABLED) | (checked ? MF_CHECKED : MF_UNCHECKED), nItemID, text);
3346 }
3347
3348 #define WALKBEHAVIOUR_FIRSTPARENT                       1
3349 #define WALKBEHAVIOUR_FOLLOWRENAMES                     2
3350 #define WALKBEHAVIOUR_COMPRESSEDGRAPH           3
3351 #define WALKBEHAVIOUR_LABELEDCOMMITS            4
3352 #define WALKBEHAVIOUR_NOMERGES                          5
3353
3354 void CLogDlg::OnBnClickedWalkBehaviour()
3355 {
3356         CMenu popup;
3357         if (popup.CreatePopupMenu())
3358         {
3359                 m_ctrlWalkBehavior.SetCheck(BST_CHECKED);
3360                 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_FIRSTPARENT, WALKBEHAVIOUR_FIRSTPARENT, m_bFirstParent);
3361                 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_NOMERGES, WALKBEHAVIOUR_NOMERGES, m_bNoMerges);
3362                 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_FOLLOWRENAMES, WALKBEHAVIOUR_FOLLOWRENAMES, m_bFollowRenames, !(m_path.IsEmpty() || m_path.IsDirectory()));
3363                 popup.AppendMenu(MF_SEPARATOR, NULL);
3364                 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_COMPRESSED, WALKBEHAVIOUR_COMPRESSEDGRAPH, m_iCompressedGraph == 1);
3365                 AppendMenuChecked(popup, IDS_WALKBEHAVIOUR_LABELEDCOMMITS, WALKBEHAVIOUR_LABELEDCOMMITS, m_iCompressedGraph == 2);
3366
3367                 m_tooltips.Pop();
3368                 RECT rect;
3369                 GetDlgItem(IDC_WALKBEHAVIOUR)->GetWindowRect(&rect);
3370                 TPMPARAMS params;
3371                 params.cbSize = sizeof(TPMPARAMS);
3372                 params.rcExclude = rect;
3373                 int selection = popup.TrackPopupMenuEx(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY | TPM_VERTICAL, rect.left, rect.top, this, &params);
3374                 switch (selection)
3375                 {
3376                 case WALKBEHAVIOUR_FIRSTPARENT:
3377                         m_bFirstParent = !m_bFirstParent;
3378                         OnBnClickedFirstParent();
3379                         break;
3380                 case WALKBEHAVIOUR_NOMERGES:
3381                         m_bNoMerges = !m_bNoMerges;
3382                         OnBnClickedFirstParent(); // OnBnClickedFirstParent handles both cases: m_bFirstParent and m_bNoMerges
3383                         break;
3384                 case WALKBEHAVIOUR_FOLLOWRENAMES:
3385                         m_bFollowRenames = !m_bFollowRenames;
3386                         OnBnClickedFollowRenames();
3387                         break;
3388                 case WALKBEHAVIOUR_COMPRESSEDGRAPH:
3389                         m_iCompressedGraph = (m_iCompressedGraph == 1 ? 0 : 1);
3390                         OnBnClickedCompressedGraph();
3391                         break;
3392                 case WALKBEHAVIOUR_LABELEDCOMMITS:
3393                         m_iCompressedGraph = (m_iCompressedGraph == 2 ? 0 : 2);
3394                         OnBnClickedCompressedGraph();
3395                         break;
3396                 default:
3397                         break;
3398                 }
3399                 m_ctrlWalkBehavior.SetCheck((m_bFirstParent || m_bNoMerges || m_bFollowRenames || m_iCompressedGraph) ? BST_CHECKED : BST_UNCHECKED);
3400         }
3401 }
3402
3403 #define VIEW_HIDEPATHS                          1
3404 #define VIEW_GRAYPATHS                          2
3405 #define VIEW_SHOWTAGS                           3
3406 #define VIEW_SHOWLOCALBRANCHES          4
3407 #define VIEW_SHOWREMOTEBRANCHES         5
3408 #define VIEW_SHOWGRAVATAR                       6
3409 #define VIEW_SHOWPATCH                          7
3410 #define VIEW_SHOWWCUNVERSIONED          8
3411 #define VIEW_SHOWOTHERREFS                      9
3412
3413 void CLogDlg::OnBnClickedView()
3414 {
3415         CMenu popup;
3416         if (popup.CreatePopupMenu())
3417         {
3418                 m_ctrlView.SetCheck(BST_CHECKED);
3419                 AppendMenuChecked(popup, IDS_SHOWFILES_HIDEPATHS, VIEW_HIDEPATHS, m_iHidePaths == 1);
3420                 AppendMenuChecked(popup, IDS_SHOWFILES_GRAYPATHS, VIEW_GRAYPATHS, m_iHidePaths == 2);
3421                 popup.AppendMenu(MF_SEPARATOR, NULL);
3422                 AppendMenuChecked(popup, IDS_PROC_LOG_SHOWUNVERSIONED, VIEW_SHOWWCUNVERSIONED, m_bShowUnversioned == BST_CHECKED);
3423                 popup.AppendMenu(MF_SEPARATOR, NULL);
3424                 CMenu showLabelsMenu;
3425                 if (showLabelsMenu.CreatePopupMenu())
3426                 {
3427                         AppendMenuChecked(showLabelsMenu, IDS_VIEW_SHOWTAGLABELS, VIEW_SHOWTAGS, m_bShowTags);
3428                         AppendMenuChecked(showLabelsMenu, IDS_VIEW_SHOWLOCALBRANCHLABELS, VIEW_SHOWLOCALBRANCHES, m_bShowLocalBranches);
3429                         AppendMenuChecked(showLabelsMenu, IDS_VIEW_SHOWREMOTEBRANCHLABELS, VIEW_SHOWREMOTEBRANCHES, m_bShowRemoteBranches);
3430                         AppendMenuChecked(showLabelsMenu, IDS_VIEW_SHOWROTHERLABELS, VIEW_SHOWOTHERREFS, m_bShowOtherRefs);
3431                         popup.AppendMenu(MF_STRING | MF_POPUP, (UINT_PTR)showLabelsMenu.m_hMenu, (CString)MAKEINTRESOURCE(IDS_VIEW_LABELS));
3432                 }
3433                 popup.AppendMenu(MF_SEPARATOR, NULL);
3434                 AppendMenuChecked(popup, IDS_VIEW_SHOWGRAVATAR, VIEW_SHOWGRAVATAR, m_bShowGravatar);
3435                 AppendMenuChecked(popup, IDS_MENU_VIEWPATCH, VIEW_SHOWPATCH, IsWindow(this->m_patchViewdlg.m_hWnd));
3436
3437                 m_tooltips.Pop();
3438                 RECT rect;
3439                 GetDlgItem(IDC_VIEW)->GetWindowRect(&rect);
3440                 TPMPARAMS params;
3441                 params.cbSize = sizeof(TPMPARAMS);
3442                 params.rcExclude = rect;
3443                 int selection = popup.TrackPopupMenuEx(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY | TPM_VERTICAL, rect.left, rect.top, this, &params);
3444                 switch (selection)
3445                 {
3446                 case VIEW_HIDEPATHS:
3447                         if (m_iHidePaths == 1)
3448                                 m_iHidePaths = 0;
3449                         else
3450                                 m_iHidePaths = 1;
3451                         OnBnClickedHidepaths();
3452                         break;
3453                 case VIEW_GRAYPATHS:
3454                         if (m_iHidePaths == 2)
3455                                 m_iHidePaths = 0;
3456                         else
3457                                 m_iHidePaths = 2;
3458                         OnBnClickedHidepaths();
3459                         break;
3460                 case VIEW_SHOWTAGS:
3461                         m_bShowTags = !m_bShowTags;
3462                         HandleShowLabels(m_bShowTags, LOGLIST_SHOWTAGS);
3463                         break;
3464                 case VIEW_SHOWLOCALBRANCHES:
3465                         m_bShowLocalBranches = !m_bShowLocalBranches;
3466                         HandleShowLabels(m_bShowLocalBranches, LOGLIST_SHOWLOCALBRANCHES);
3467                         break;
3468                 case VIEW_SHOWREMOTEBRANCHES:
3469                         m_bShowRemoteBranches = !m_bShowRemoteBranches;
3470                         HandleShowLabels(m_bShowRemoteBranches, LOGLIST_SHOWREMOTEBRANCHES);
3471                         break;
3472                 case VIEW_SHOWOTHERREFS:
3473                         m_bShowOtherRefs = !m_bShowOtherRefs;
3474                         HandleShowLabels(m_bShowOtherRefs, LOGLIST_SHOWOTHERREFS);
3475                         break;
3476                 case VIEW_SHOWGRAVATAR:
3477                         {
3478                                 m_bShowGravatar = !m_bShowGravatar;
3479                                 ShowGravatar();
3480                                 m_gravatar.Init();
3481                                 CString email;
3482                                 POSITION pos = m_LogList.GetFirstSelectedItemPosition();
3483                                 if (pos)
3484                                 {
3485                                         int selIndex = m_LogList.GetNextSelectedItem(pos);
3486                                         int moreSel = m_LogList.GetNextSelectedItem(pos);
3487                                         if (moreSel < 0)
3488                                         {
3489                                                 GitRev* pLogEntry = m_LogList.m_arShownList.SafeGetAt(selIndex);
3490                                                 if (pLogEntry)
3491                                                         email = pLogEntry->GetAuthorEmail();
3492                                         }
3493                                 }
3494                                 m_gravatar.LoadGravatar(email);
3495                                 break;
3496                         }
3497                 case VIEW_SHOWPATCH:
3498                         TogglePatchView();
3499                         break;
3500                 case VIEW_SHOWWCUNVERSIONED:
3501                         m_bShowUnversioned = !m_bShowUnversioned;
3502                         FillLogMessageCtrl();
3503                         m_ChangedFileListCtrl.Invalidate();
3504                         break;
3505                 default:
3506                         break;
3507                 }
3508                 m_ctrlView.SetCheck(BST_UNCHECKED);
3509         }
3510 }
3511
3512 void CLogDlg::OnBnClickedFirstParent()
3513 {
3514         if(this->m_bFirstParent)
3515                 m_LogList.m_ShowMask|=CGit::LOG_INFO_FIRST_PARENT;
3516         else
3517                 m_LogList.m_ShowMask&=~CGit::LOG_INFO_FIRST_PARENT;
3518
3519         if (m_bNoMerges)
3520                 m_LogList.m_ShowMask |= CGit::LOG_INFO_NO_MERGE;
3521         else
3522                 m_LogList.m_ShowMask &= ~CGit::LOG_INFO_NO_MERGE;
3523
3524         OnRefresh();
3525
3526         FillLogMessageCtrl(false);
3527 }
3528
3529 void CLogDlg::OnBnClickShowWholeProject()
3530 {
3531         this->UpdateData();
3532
3533         if(this->m_bWholeProject)
3534         {
3535                 m_LogList.m_Path.Reset();
3536                 SetDlgTitle();
3537         }
3538         else
3539                 m_LogList.m_Path=m_path;
3540
3541         m_regShowWholeProject = m_bWholeProject;
3542
3543         SetDlgTitle();
3544
3545         OnRefresh();
3546
3547         FillLogMessageCtrl(false);
3548 }
3549
3550 LRESULT CLogDlg::OnRefLogChanged(WPARAM /*wParam*/, LPARAM /*lParam*/)
3551 {
3552         ShowStartRef();
3553         return 0;
3554 }
3555
3556 LRESULT CLogDlg::OnTaskbarBtnCreated(WPARAM wParam, LPARAM lParam)
3557 {
3558         m_pTaskbarList.Release();
3559         m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
3560         return __super::OnTaskbarButtonCreated(wParam, lParam);
3561 }
3562
3563 LRESULT CLogDlg::OnRefreshSelection(WPARAM /*wParam*/, LPARAM /*lParam*/)
3564 {
3565         // it's enough to deselect, then select again one item of the whole selection
3566         int selMark = m_LogList.GetSelectionMark();
3567         if (selMark >= 0)
3568         {
3569                 m_LogList.SetSelectionMark(selMark);
3570                 m_LogList.SetItemState(selMark, 0, LVIS_SELECTED);
3571                 m_LogList.SetItemState(selMark, LVIS_SELECTED, LVIS_SELECTED);
3572         }
3573         return 0;
3574 }
3575
3576 void CLogDlg::OnExitClearFilter()
3577 {
3578         if (m_LogList.m_LogFilter->IsFilterActive())
3579         {
3580                 OnClickedCancelFilter(NULL, NULL);
3581                 return;
3582         }
3583         SendMessage(WM_CLOSE);
3584 }
3585
3586 void CLogDlg::OnNMCustomdrawChangedFileList(NMHDR* pNMHDR, LRESULT* pResult)
3587 {
3588         NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pNMHDR);
3589         if (pLVCD->nmcd.dwDrawStage != (CDDS_ITEMPREPAINT | CDDS_ITEM | CDDS_SUBITEM))
3590                 return;
3591
3592         if (pLVCD->iSubItem > 2)
3593                 return;
3594
3595         auto filter(m_LogList.m_LogFilter);
3596         if ((m_SelectedFilters & LOGFILTER_PATHS) && (filter->IsFilterActive()))
3597                 *pResult = m_LogList.DrawListItemWithMatches(filter.get(), m_ChangedFileListCtrl, pLVCD);
3598 }