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