src/TortoiseProc/GitLogListBase.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2016 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // GitLogList.cpp : implementation file
  20 //
  21 #pragma once
  22
  23 #include "HintCtrl.h"
  24 #include "ResizableColumnsListCtrl.h"
  25 #include "Git.h"
  26 #include "ProjectProperties.h"
  27 #include "TGitPath.h"
  28 #include "registry.h"
  29 #include "Colors.h"
  30 #include "LogDlgHelper.h"
  31 #include "GitRevLoglist.h"
  32 #include "lanes.h"
  33 #include "GitLogCache.h"
  34 #include <regex>
  35 #include "GitStatusListCtrl.h"
  36 #include "FindDlg.h"
  37
  38 // CGitLogList
  39 #define ICONITEMBORDER 5
  40
  41 #define GITLOG_START 0
  42 #define GITLOG_START_ALL 1
  43 #define GITLOG_END   100
  44
  45 #define LOGFILTER_ALL                   0xFFFF
  46 #define LOGFILTER_TOGGLE                0x8000
  47 #define LOGFILTER_MESSAGES              0x0001
  48 #define LOGFILTER_PATHS                 0x0002
  49 #define LOGFILTER_AUTHORS               0x0004
  50 #define LOGFILTER_REVS                  0x0008
  51 #define LOGFILTER_REGEX                 0x0010
  52 #define LOGFILTER_BUGID                 0x0020
  53 #define LOGFILTER_SUBJECT               0x0040
  54 #define LOGFILTER_REFNAME               0x0080
  55 #define LOGFILTER_EMAILS                0x0100
  56 #define LOGFILTER_NOTES                 0x0200
  57 #define LOGFILTER_ANNOTATEDTAG  0x0400
  58 #define LOGFILTER_CASE                  0x0800
  59
  60 #define LOGLIST_SHOWNOTHING                             0x0000
  61 #define LOGLIST_SHOWLOCALBRANCHES               0x0001
  62 #define LOGLIST_SHOWREMOTEBRANCHES              0x0002
  63 #define LOGLIST_SHOWTAGS                                0x0004
  64 #define LOGLIST_SHOWSTASH                               0x0008
  65 #define LOGLIST_SHOWBISECT                              0x0010
  66 #define LOGLIST_SHOWALLREFS                             0xFFFF
  67
  68 //typedef void CALLBACK_PROCESS(void * data, int progress);
  69 #define MSG_LOADED                              (WM_USER+110)
  70 #define MSG_LOAD_PERCENTAGE             (WM_USER+111)
  71 #define MSG_REFLOG_CHANGED              (WM_USER+112)
  72 #define MSG_FETCHED_DIFF                (WM_USER+113)
  73
  74 class SelectionHistory
  75 {
  76 #define HISTORYLENGTH 50
  77 public:
  78         SelectionHistory(void)
  79         : location(0)
  80         {
  81                 lastselected.reserve(HISTORYLENGTH);
  82         }
  83         void Add(CGitHash &hash)
  84         {
  85                 if (hash.IsEmpty())
  86                         return;
  87
  88                 size_t size = lastselected.size();
  89
  90                 // re-select last selected commit
  91                 if (size > 0 && hash == lastselected[size - 1])
  92                 {
  93                         // reset location
  94                         if (location != size - 1)
  95                                 location = size - 1;
  96                         return;
  97                 }
  98
  99                 // go back and some commit was highlight
 100                 if (size > 0 && location != size - 1)
 101                 {
 102                         // Re-select current one, it may be a forked point.
 103                         if (hash == lastselected[location])
 104                                 // Discard it later.
 105                                 // That is that discarding forward history when a forked entry is really coming.
 106                                 // And user has the chance to Go Forward again in this situation.
 107                                 // IOW, (hash != lastselected[location]) means user wants a forked history,
 108                                 // and this change saves one step from old behavior.
 109                                 return;
 110
 111                         // Discard forward history if any
 112                         while (lastselected.size() - 1 > location)
 113                                 lastselected.pop_back();
 114                 }
 115
 116                 if (lastselected.size() >= HISTORYLENGTH)
 117                         lastselected.erase(lastselected.cbegin());
 118
 119                 lastselected.push_back(hash);
 120                 location = lastselected.size() - 1;
 121         }
 122         BOOL GoBack(CGitHash& historyEntry)
 123         {
 124                 if (location < 1)
 125                         return FALSE;
 126
 127                 historyEntry = lastselected[--location];
 128
 129                 return TRUE;
 130         }
 131         BOOL GoForward(CGitHash& historyEntry)
 132         {
 133                 if (location >= lastselected.size() - 1)
 134                         return FALSE;
 135
 136                 historyEntry = lastselected[++location];
 137
 138                 return TRUE;
 139         }
 140 private:
 141         std::vector<CGitHash> lastselected;
 142         size_t location;
 143 };
 144
 145 class CThreadSafePtrArray : public std::vector<GitRevLoglist*>
 146 {
 147         CComCriticalSection *m_critSec;
 148 public:
 149         CThreadSafePtrArray(CComCriticalSection *section){ m_critSec = section ;}
 150         GitRevLoglist* SafeGetAt(size_t i)
 151         {
 152                 if(m_critSec)
 153                         m_critSec->Lock();
 154
 155                 SCOPE_EXIT
 156                 {
 157                         if (m_critSec)
 158                                 m_critSec->Unlock();
 159                 };
 160
 161                 if (i >= size())
 162                         return nullptr;
 163
 164                 return (*this)[i];
 165         }
 166
 167         void SafeAdd(GitRevLoglist* newElement)
 168         {
 169                 if(m_critSec)
 170                         m_critSec->Lock();
 171                 push_back(newElement);
 172                 if(m_critSec)
 173                         m_critSec->Unlock();
 174         }
 175
 176         void SafeRemoveAt(size_t i)
 177         {
 178                 if (m_critSec)
 179                         m_critSec->Lock();
 180
 181                 SCOPE_EXIT
 182                 {
 183                         if (m_critSec)
 184                         m_critSec->Unlock();
 185                 };
 186
 187                 if (i >= size())
 188                         return;
 189
 190                 erase(begin() + i);
 191         }
 192
 193         void  SafeRemoveAll()
 194         {
 195                 if(m_critSec)
 196                         m_critSec->Lock();
 197                 clear();
 198                 if(m_critSec)
 199                         m_critSec->Unlock();
 200         }
 201 };
 202
 203 class CGitLogListBase : public CHintCtrl<CResizableColumnsListCtrl<CListCtrl>>
 204 {
 205         DECLARE_DYNAMIC(CGitLogListBase)
 206
 207 public:
 208         CGitLogListBase();
 209         virtual ~CGitLogListBase();
 210         ProjectProperties       m_ProjectProperties;
 211
 212         void UpdateProjectProperties()
 213         {
 214                 m_ProjectProperties.ReadProps();
 215
 216                 if ((!m_ProjectProperties.sUrl.IsEmpty())||(!m_ProjectProperties.sCheckRe.IsEmpty()))
 217                         m_bShowBugtraqColumn = true;
 218                 else
 219                         m_bShowBugtraqColumn = false;
 220         }
 221
 222         void ResetWcRev(bool refresh = false)
 223         {
 224                 m_wcRev.Clear();
 225                 m_wcRev.GetSubject().LoadString(IDS_LOG_WORKINGDIRCHANGES);
 226                 m_wcRev.m_Mark = _T('-');
 227                 m_wcRev.GetBody().LoadString(IDS_LOG_FETCHINGSTATUS);
 228                 m_wcRev.m_CallDiffAsync = DiffAsync;
 229                 InterlockedExchange(&m_wcRev.m_IsDiffFiles, FALSE);
 230                 if (refresh && m_bShowWC)
 231                         m_arShownList[0] = &m_wcRev;
 232         }
 233
 234         volatile LONG           m_bNoDispUpdates;
 235         BOOL m_IsIDReplaceAction;
 236         BOOL m_IsOldFirst;
 237         void hideFromContextMenu(unsigned __int64 hideMask, bool exclusivelyShow);
 238         BOOL m_IsRebaseReplaceGraph;
 239         BOOL m_bNoHightlightHead;
 240
 241         void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);
 242
 243         BOOL m_bStrictStopped;
 244         BOOL m_bShowBugtraqColumn;
 245         BOOL m_bSearchIndex;
 246         BOOL m_bCancelled;
 247         bool m_bIsCherryPick;
 248         unsigned __int64 m_ContextMenuMask;
 249
 250         bool                            m_hasWC;
 251         bool                            m_bShowWC;
 252         GitRevLoglist           m_wcRev;
 253         volatile LONG           m_bThreadRunning;
 254         CLogCache                       m_LogCache;
 255
 256         CString m_sRange;
 257         // don't forget to bump BLAME_COLUMN_VERSION in GitStatusListCtrlHelpers.cpp if you change columns
 258         enum
 259         {
 260                 LOGLIST_GRAPH,
 261                 LOGLIST_REBASE,
 262                 LOGLIST_ID,
 263                 LOGLIST_HASH,
 264                 LOGLIST_ACTION,
 265                 LOGLIST_MESSAGE,
 266                 LOGLIST_AUTHOR,
 267                 LOGLIST_DATE,
 268                 LOGLIST_EMAIL,
 269                 LOGLIST_COMMIT_NAME,
 270                 LOGLIST_COMMIT_EMAIL,
 271                 LOGLIST_COMMIT_DATE,
 272                 LOGLIST_BUG,
 273                 LOGLIST_SVNREV,
 274                 LOGLIST_MESSAGE_MAX=300,
 275                 LOGLIST_MESSAGE_MIN=200,
 276
 277                 GIT_LOG_GRAPH   =               1<< LOGLIST_GRAPH,
 278                 GIT_LOG_REBASE  =               1<< LOGLIST_REBASE,
 279                 GIT_LOG_ID              =               1<< LOGLIST_ID,
 280                 GIT_LOG_HASH    =               1<< LOGLIST_HASH,
 281                 GIT_LOG_ACTIONS =               1<< LOGLIST_ACTION,
 282                 GIT_LOG_MESSAGE =               1<< LOGLIST_MESSAGE,
 283                 GIT_LOG_AUTHOR  =               1<< LOGLIST_AUTHOR,
 284                 GIT_LOG_DATE    =               1<< LOGLIST_DATE,
 285                 GIT_LOG_EMAIL   =               1<< LOGLIST_EMAIL,
 286                 GIT_LOG_COMMIT_NAME     =       1<< LOGLIST_COMMIT_NAME,
 287                 GIT_LOG_COMMIT_EMAIL=   1<< LOGLIST_COMMIT_EMAIL,
 288                 GIT_LOG_COMMIT_DATE     =       1<< LOGLIST_COMMIT_DATE,
 289                 GIT_LOGLIST_BUG         =       1<< LOGLIST_BUG,
 290                 GIT_LOGLIST_SVNREV      =       1<< LOGLIST_SVNREV,
 291         };
 292
 293         enum
 294         {
 295         // needs to start with 1, since 0 is the return value if *nothing* is clicked on in the context menu
 296         ID_COMPARE = 1, // compare revision with WC
 297         ID_SAVEAS,
 298         ID_COMPARETWO, // compare two revisions
 299         ID_COPY,
 300         ID_REVERTREV,
 301         ID_MERGEREV,
 302         ID_GNUDIFF1, // compare with WC, unified
 303         ID_GNUDIFF2, // compare two revisions, unified
 304         ID_FINDENTRY,
 305         ID_OPEN,
 306         ID_BLAME,
 307         ID_REPOBROWSE,
 308         ID_LOG,
 309         ID_EDITNOTE,
 310         ID_DIFF,
 311         ID_OPENWITH,
 312         ID_COPYCLIPBOARD,
 313         ID_COPYHASH,
 314         ID_REVERTTOREV,
 315         ID_BLAMECOMPARE,
 316         ID_BLAMEDIFF,
 317         ID_VIEWREV,
 318         ID_VIEWPATHREV,
 319         ID_EXPORT,
 320         ID_COMPAREWITHPREVIOUS,
 321         ID_BLAMEPREVIOUS,
 322         ID_CHERRY_PICK,
 323         ID_CREATE_BRANCH,
 324         ID_CREATE_TAG,
 325         ID_SWITCHTOREV,
 326         ID_SWITCHBRANCH,
 327         ID_RESET,
 328         ID_REBASE_PICK,
 329         ID_REBASE_EDIT,
 330         ID_REBASE_SQUASH,
 331         ID_REBASE_SKIP,
 332         ID_COMBINE_COMMIT,
 333         ID_STASH_SAVE,
 334         ID_STASH_LIST,
 335         ID_STASH_POP,
 336         ID_REFLOG_STASH_APPLY,
 337         ID_REFLOG_DEL,
 338         ID_REBASE_TO_VERSION,
 339         ID_CREATE_PATCH,
 340         ID_DELETE,
 341         ID_COMMIT,
 342         ID_PUSH,
 343         ID_PULL,
 344         ID_FETCH,
 345         ID_SHOWBRANCHES,
 346         ID_COPYCLIPBOARDMESSAGES,
 347         ID_BISECTSTART,
 348         ID_LOG_VIEWRANGE,
 349         ID_LOG_VIEWRANGE_REACHABLEFROMONLYONE,
 350         ID_MERGE_ABORT,
 351         ID_CLEANUP,
 352         ID_SUBMODULE_UPDATE,
 353         ID_BISECTGOOD,
 354         ID_BISECTBAD,
 355         ID_BISECTRESET,
 356         };
 357         enum
 358         {
 359         ID_COPY_ALL,
 360         ID_COPY_MESSAGE,
 361         ID_COPY_SUBJECT,
 362         ID_COPY_HASH,
 363         };
 364         enum FilterShow
 365         {
 366                 FILTERSHOW_REFS = 1,
 367                 FILTERSHOW_MERGEPOINTS = 2,
 368                 FILTERSHOW_ANYCOMMIT = 4,
 369                 FILTERSHOW_ALL = FILTERSHOW_ANYCOMMIT | FILTERSHOW_REFS | FILTERSHOW_MERGEPOINTS
 370         };
 371         enum : unsigned int
 372         {
 373                 // For Rebase only
 374                 LOGACTIONS_REBASE_CURRENT       = 0x08000000,
 375                 LOGACTIONS_REBASE_PICK          = 0x04000000,
 376                 LOGACTIONS_REBASE_SQUASH        = 0x02000000,
 377                 LOGACTIONS_REBASE_EDIT          = 0x01000000,
 378                 LOGACTIONS_REBASE_DONE          = 0x00800000,
 379                 LOGACTIONS_REBASE_SKIP          = 0x00400000,
 380                 LOGACTIONS_REBASE_MASK          = 0x0FC00000,
 381                 LOGACTIONS_REBASE_MODE_MASK     = 0x07C00000,
 382         };
 383         inline unsigned __int64 GetContextMenuBit(int i){ return ((unsigned __int64 )0x1)<<i ;}
 384         static CString GetRebaseActionName(int action);
 385         void InsertGitColumn();
 386         void CopySelectionToClipBoard(int toCopy = ID_COPY_ALL);
 387         void DiffSelectedRevWithPrevious();
 388         bool IsSelectionContinuous();
 389         int  BeginFetchLog();
 390         int  FillGitLog(CTGitPath* path, CString* range = nullptr, int infomask = CGit::LOG_INFO_STAT | CGit::LOG_INFO_FILESTATE | CGit::LOG_INFO_SHOW_MERGEDFILE);
 391         int  FillGitLog(std::set<CGitHash>& hashes);
 392         CString MessageDisplayStr(GitRev* pLogEntry);
 393         BOOL IsMatchFilter(bool bRegex, GitRevLoglist* pRev, std::tr1::wregex& pat);
 394         bool ShouldShowFilter(GitRevLoglist* pRev, const std::map<CGitHash, std::set<CGitHash>>& commitChildren);
 395         void ShowGraphColumn(bool bShow);
 396         CString GetTagInfo(GitRev* pLogEntry);
 397
 398         CFindDlg *m_pFindDialog;
 399         static const UINT       m_FindDialogMessage;
 400         void OnFind();
 401
 402         static const UINT       m_ScrollToMessage;
 403         static const UINT       m_RebaseActionMessage;
 404
 405         inline int ShownCountWithStopped() const { return (int)m_arShownList.size() + (m_bStrictStopped ? 1 : 0); }
 406         void FetchLogAsync(void* data = nullptr);
 407         CThreadSafePtrArray                     m_arShownList;
 408         void Refresh(BOOL IsCleanFilter=TRUE);
 409         void RecalculateShownList(CThreadSafePtrArray * pShownlist);
 410         void Clear();
 411
 412         DWORD                           m_SelectedFilters;
 413         FilterShow                      m_ShowFilter;
 414         bool                            m_bFilterWithRegex;
 415         bool                            m_bFilterCaseSensitively;
 416         CLogDataVector          m_logEntries;
 417         void RemoveFilter();
 418         void StartFilter();
 419         bool ValidateRegexp(LPCTSTR regexp_str, std::tr1::wregex& pat, bool bMatchCase = false );
 420         CString                         m_sFilterText;
 421
 422         CFilterData                     m_Filter;
 423
 424         CTGitPath                       m_Path;
 425         int                                     m_ShowMask;
 426         CGitHash                        m_lastSelectedHash;
 427         SelectionHistory        m_selectionHistory;
 428         CGitHash                        m_highlight;
 429         int                                     m_ShowRefMask;
 430
 431         void                            GetTimeRange(CTime &oldest,CTime &latest);
 432         virtual void GetParentHashes(GitRev* pRev, GIT_REV_LIST& parentHash);
 433         virtual void ContextMenuAction(int cmd,int FirstSelect, int LastSelect, CMenu * menu)=0;
 434         void ReloadHashMap()
 435         {
 436                 m_RefLabelPosMap.clear();
 437                 m_HashMap.clear();
 438
 439                 if (g_Git.GetMapHashToFriendName(m_HashMap))
 440                         MessageBox(g_Git.GetGitLastErr(_T("Could not get all refs.")), _T("TortoiseGit"), MB_ICONERROR);
 441
 442                 m_CurrentBranch=g_Git.GetCurrentBranch();
 443
 444                 if (g_Git.GetHash(m_HeadHash, _T("HEAD")))
 445                 {
 446                         MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash. Quitting...")), _T("TortoiseGit"), MB_ICONERROR);
 447                         ExitProcess(1);
 448                 }
 449
 450                 m_wcRev.m_ParentHash.clear();
 451                 m_wcRev.m_ParentHash.push_back(m_HeadHash);
 452
 453                 FetchRemoteList();
 454                 FetchTrackingBranchList();
 455         }
 456         void StartAsyncDiffThread();
 457         void StartLoadingThread();
 458         void SafeTerminateThread()
 459         {
 460                 if (m_LoadingThread && InterlockedExchange(&m_bExitThread, TRUE) == FALSE)
 461                 {
 462                         DWORD ret = WAIT_TIMEOUT;
 463                         for (int i = 0; i < 200 && m_bThreadRunning; ++i)
 464                                 ret =::WaitForSingleObject(m_LoadingThread->m_hThread, 100);
 465                         if (ret == WAIT_TIMEOUT && m_bThreadRunning)
 466                                 ::TerminateThread(m_LoadingThread, 0);
 467                         m_LoadingThread = nullptr;
 468                 }
 469         };
 470
 471         bool IsInWorkingThread()
 472         {
 473                 return (AfxGetThread() == m_LoadingThread);
 474         }
 475
 476         void SetRange(const CString& range)
 477         {
 478                 m_sRange = range;
 479         }
 480
 481         CString GetRange() const { return m_sRange; }
 482
 483         bool HasFilterText() const { return !m_sFilterText.IsEmpty() && m_sFilterText != _T("!"); }
 484
 485         int                                     m_nSearchIndex;
 486
 487         volatile LONG           m_bExitThread;
 488         CWinThread*                     m_LoadingThread;
 489         MAP_HASH_NAME           m_HashMap;
 490         std::map<CString, std::pair<CString, CString>>  m_TrackingMap;
 491
 492 public:
 493         CString                         m_ColumnRegKey;
 494
 495 protected:
 496         typedef struct {
 497                 CString name;
 498                 COLORREF color;
 499                 CString simplifiedName;
 500                 CString fullName;
 501                 bool singleRemote;
 502                 bool hasTracking;
 503                 bool sameName;
 504                 CGit::REF_TYPE refType;
 505         } REFLABEL;
 506
 507         DECLARE_MESSAGE_MAP()
 508         afx_msg void OnDestroy();
 509         virtual afx_msg void OnNMCustomdrawLoglist(NMHDR *pNMHDR, LRESULT *pResult);
 510         virtual afx_msg void OnLvnGetdispinfoLoglist(NMHDR *pNMHDR, LRESULT *pResult);
 511         afx_msg LRESULT OnFindDialogMessage(WPARAM wParam, LPARAM lParam);
 512         afx_msg LRESULT OnScrollToMessage(WPARAM wParam, LPARAM lParam);
 513         afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 514         afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
 515         afx_msg LRESULT OnLoad(WPARAM wParam, LPARAM lParam);
 516         void OnNMDblclkLoglist(NMHDR * /*pNMHDR*/, LRESULT *pResult);
 517         afx_msg void OnLvnOdfinditemLoglist(NMHDR *pNMHDR, LRESULT *pResult);
 518         void PreSubclassWindow();
 519         virtual BOOL PreTranslateMessage(MSG* pMsg);
 520         static UINT LogThreadEntry(LPVOID pVoid);
 521         UINT LogThread();
 522         bool IsOnStash(int index);
 523         bool IsStash(const GitRev * pSelLogEntry);
 524         bool IsBisect(const GitRev * pSelLogEntry);
 525         void FetchRemoteList();
 526         void FetchTrackingBranchList();
 527         void FetchLastLogInfo();
 528         void FetchFullLogInfo(CString &from, CString &to);
 529
 530         virtual afx_msg BOOL OnToolTipText(UINT id, NMHDR * pNMHDR, LRESULT * pResult);
 531         virtual INT_PTR OnToolHitTest(CPoint point, TOOLINFO * pTI) const;
 532         CString GetToolTipText(int nItem, int nSubItem);
 533
 534         /** Checks whether a referenfe label is under pt and returns the index/type
 535          * pLogEntry  IN: the entry of commit
 536          * pt         IN: the mouse position in client coordinate
 537          * type       IN: give the specific reference type, then check if it is the same reference type.
 538          *            OUT: give CGit::REF_TYPE::UNKNOWN for getting the real type it is.
 539          * pShortname OUT: the short name of that reference label
 540          * pIndex     OUT: the index value of label of that entry
 541          */
 542         bool IsMouseOnRefLabel(const GitRevLoglist* pLogEntry, const POINT& pt, CGit::REF_TYPE& type, CString* pShortname = nullptr, size_t* pIndex = nullptr);
 543         bool IsMouseOnRefLabelFromPopupMenu(const GitRevLoglist* pLogEntry, const CPoint& pt, CGit::REF_TYPE& type, CString* pShortname = nullptr, size_t* pIndex = nullptr);
 544
 545         void FillBackGround(HDC hdc, DWORD_PTR Index, CRect &rect);
 546         void DrawTagBranchMessage(HDC hdc, CRect &rect, INT_PTR index, std::vector<REFLABEL> &refList);
 547         void DrawTagBranch(HDC hdc, CDC& W_Dc, HTHEME hTheme, CRect& rect, CRect& rt, LVITEM& rItem, GitRevLoglist* data, std::vector<REFLABEL>& refList);
 548         void DrawGraph(HDC,CRect &rect,INT_PTR index);
 549
 550         void paintGraphLane(HDC hdc,int laneHeight, int type, int x1, int x2,
 551                                                                           const COLORREF& col,const COLORREF& activeColor, int top) ;
 552         void DrawLine(HDC hdc, int x1, int y1, int x2, int y2){ ::MoveToEx(hdc, x1, y1, nullptr); ::LineTo(hdc, x2, y2); }
 553         /**
 554         * Save column widths to the registry
 555         */
 556         void SaveColumnWidths();        // save col widths to the registry
 557
 558         BOOL IsEntryInDateRange(int i);
 559
 560         int GetHeadIndex();
 561
 562         std::vector<GitRevLoglist*> m_AsynDiffList;
 563         CComCriticalSection m_AsynDiffListLock;
 564         HANDLE  m_AsyncDiffEvent;
 565         volatile LONG m_AsyncThreadExit;
 566         CWinThread*                     m_DiffingThread;
 567         volatile LONG m_AsyncThreadRunning;
 568
 569         static int DiffAsync(GitRevLoglist* rev, void* data)
 570         {
 571                 ULONGLONG offset=((CGitLogListBase*)data)->m_LogCache.GetOffset(rev->m_CommitHash);
 572                 if (!offset || ((CGitLogListBase*)data)->m_LogCache.LoadOneItem(*rev, offset))
 573                 {
 574                         ((CGitLogListBase*)data)->m_AsynDiffListLock.Lock();
 575                         ((CGitLogListBase*)data)->m_AsynDiffList.push_back(rev);
 576                         ((CGitLogListBase*)data)->m_AsynDiffListLock.Unlock();
 577                         ::SetEvent(((CGitLogListBase*)data)->m_AsyncDiffEvent);
 578                         return 0;
 579                 }
 580
 581                 InterlockedExchange(&rev->m_IsDiffFiles, TRUE);
 582                 if (!rev->m_IsCommitParsed)
 583                         return 0;
 584                 InterlockedExchange(&rev->m_IsFull, TRUE);
 585                 // we might need to signal that the changed files are now available
 586                 if (((CGitLogListBase*)data)->GetSelectedCount() == 1)
 587                 {
 588                         POSITION pos = ((CGitLogListBase*)data)->GetFirstSelectedItemPosition();
 589                         int nItem = ((CGitLogListBase*)data)->GetNextSelectedItem(pos);
 590                         if (nItem >= 0)
 591                         {
 592                                 GitRevLoglist* data2 = (GitRevLoglist*)((CGitLogListBase*)data)->m_arShownList.SafeGetAt(nItem);
 593                                 if (data2 && data2->m_CommitHash == rev->m_CommitHash)
 594                                         ((CGitLogListBase*)data)->GetParent()->PostMessage(WM_COMMAND, MSG_FETCHED_DIFF, 0);
 595                         }
 596                 }
 597                 return 0;
 598         }
 599
 600         static UINT AsyncThread(LPVOID data)
 601         {
 602                 return ((CGitLogListBase*)data)->AsyncDiffThread();
 603         }
 604
 605         int AsyncDiffThread();
 606
 607 public:
 608         void SafeTerminateAsyncDiffThread()
 609         {
 610                 if (m_DiffingThread && InterlockedExchange(&m_AsyncThreadExit, TRUE) == FALSE)
 611                 {
 612                         ::SetEvent(m_AsyncDiffEvent);
 613                         DWORD ret = WAIT_TIMEOUT;
 614                         // do not block here, but process messages and ask until the thread ends
 615                         while (ret == WAIT_TIMEOUT && m_AsyncThreadRunning)
 616                         {
 617                                 MSG msg;
 618                                 if (::PeekMessage(&msg, nullptr, 0,0, PM_NOREMOVE))
 619                                         AfxGetThread()->PumpMessage(); // process messages, so that GetTopIndex and so on in the thread work
 620                                 ret = ::WaitForSingleObject(m_DiffingThread->m_hThread, 100);
 621                         }
 622                         m_DiffingThread = nullptr;
 623                         InterlockedExchange(&m_AsyncThreadExit, FALSE);
 624                 }
 625         };
 626
 627 protected:
 628         CComCriticalSection     m_critSec;
 629
 630         HICON                           m_hModifiedIcon;
 631         HICON                           m_hReplacedIcon;
 632         HICON                           m_hConflictedIcon;
 633         HICON                           m_hAddedIcon;
 634         HICON                           m_hDeletedIcon;
 635         HICON                           m_hFetchIcon;
 636
 637         CFont                           m_boldFont;
 638         CFont                           m_FontItalics;
 639         CFont                           m_boldItalicsFont;
 640
 641         CRegDWORD                       m_regMaxBugIDColWidth;
 642
 643         void                            *m_ProcData;
 644
 645         CColors                         m_Colors;
 646
 647         CString                         m_CurrentBranch;
 648         CGitHash                        m_HeadHash;
 649
 650         COLORREF                        m_LineColors[Lanes::COLORS_NUM];
 651         DWORD                           m_LineWidth;
 652         DWORD                           m_NodeSize;
 653         DWORD                           m_DateFormat;   // DATE_SHORTDATE or DATE_LONGDATE
 654         bool                            m_bRelativeTimes;       // Show relative times
 655         GIT_LOG                         m_DllGitLog;
 656         CString                         m_SingleRemote;
 657         bool                            m_bTagsBranchesOnRightSide;
 658         bool                            m_bFullCommitMessageOnLogLine;
 659         bool                            m_bSymbolizeRefNames;
 660         bool                            m_bIncludeBoundaryCommits;
 661
 662         DWORD                           m_dwDefaultColumns;
 663         TCHAR               m_wszTip[8192];
 664         char                m_szTip[8192];
 665         std::map<CString, CRect> m_RefLabelPosMap; // ref name vs. label position
 666         int                                     m_OldTopIndex;
 667 };