src/TortoiseProc/LogDlg.cpp

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