src/TortoiseProc/GitLogListBase.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2014 - 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 "HintListCtrl.h"
  24 #include "Git.h"
  25 #include "ProjectProperties.h"
  26 #include "TGitPath.h"
  27 #include "registry.h"
  28 #include "SplitterControl.h"
  29 #include "Colors.h"
  30 #include "MenuButton.h"
  31 #include "LogDlgHelper.h"
  32 #include "FilterEdit.h"
  33 #include "GitRev.h"
  34 #include "Tooltip.h"
  35 #include "lanes.h"
  36 #include "GitLogCache.h"
  37 #include <regex>
  38 #include "GitStatusListCtrl.h"
  39 #include "FindDlg.h"
  40
  41 // CGitLogList
  42 #define ICONITEMBORDER 5
  43
  44 #define GITLOG_START 0
  45 #define GITLOG_START_ALL 1
  46 #define GITLOG_END   100
  47
  48 #define LOGFILTER_ALL                   0xFFFF
  49 #define LOGFILTER_TOGGLE                0x8000
  50 #define LOGFILTER_MESSAGES              0x0001
  51 #define LOGFILTER_PATHS                 0x0002
  52 #define LOGFILTER_AUTHORS               0x0004
  53 #define LOGFILTER_REVS                  0x0008
  54 #define LOGFILTER_REGEX                 0x0010
  55 #define LOGFILTER_BUGID                 0x0020
  56 #define LOGFILTER_SUBJECT               0x0040
  57 #define LOGFILTER_REFNAME               0x0080
  58 #define LOGFILTER_EMAILS                0x0100
  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 CThreadSafePtrArray: public CPtrArray
  75 {
  76         CComCriticalSection *m_critSec;
  77 public:
  78         CThreadSafePtrArray(CComCriticalSection *section){ m_critSec = section ;}
  79         void * SafeGetAt(INT_PTR i)
  80         {
  81                 if(m_critSec)
  82                         m_critSec->Lock();
  83
  84                 if( i<0 || i>=GetCount())
  85                 {
  86                         if(m_critSec)
  87                                 m_critSec->Unlock();
  88
  89                         return NULL;
  90                 }
  91
  92                 if(m_critSec)
  93                         m_critSec->Unlock();
  94
  95                 return GetAt(i);
  96         }
  97         INT_PTR SafeAdd(void *newElement)
  98         {
  99                 INT_PTR ret;
 100                 if(m_critSec)
 101                         m_critSec->Lock();
 102                 ret = Add(newElement);
 103                 if(m_critSec)
 104                         m_critSec->Unlock();
 105                 return ret;
 106         }
 107
 108         void  SafeRemoveAll()
 109         {
 110                 if(m_critSec)
 111                         m_critSec->Lock();
 112                 RemoveAll();
 113                 if(m_critSec)
 114                         m_critSec->Unlock();
 115         }
 116
 117 };
 118
 119 class CGitLogListBase : public CHintListCtrl
 120 {
 121         DECLARE_DYNAMIC(CGitLogListBase)
 122
 123 public:
 124         CGitLogListBase();
 125         virtual ~CGitLogListBase();
 126         ProjectProperties       m_ProjectProperties;
 127
 128         CFilterData m_Filter;
 129
 130         void UpdateProjectProperties()
 131         {
 132                 m_ProjectProperties.ReadProps();
 133
 134                 if ((!m_ProjectProperties.sUrl.IsEmpty())||(!m_ProjectProperties.sCheckRe.IsEmpty()))
 135                         m_bShowBugtraqColumn = true;
 136                 else
 137                         m_bShowBugtraqColumn = false;
 138         }
 139
 140         void ResetWcRev(bool refresh = false)
 141         {
 142                 m_wcRev.Clear();
 143                 m_wcRev.GetSubject() = CString(MAKEINTRESOURCE(IDS_LOG_WORKINGDIRCHANGES));
 144                 m_wcRev.m_Mark = _T('-');
 145                 m_wcRev.GetBody() = CString(MAKEINTRESOURCE(IDS_LOG_FETCHINGSTATUS));
 146                 m_wcRev.m_CallDiffAsync = DiffAsync;
 147                 InterlockedExchange(&m_wcRev.m_IsDiffFiles, FALSE);
 148                 if (refresh && m_bShowWC)
 149                         m_arShownList[0] = &m_wcRev;
 150         }
 151
 152         volatile LONG           m_bNoDispUpdates;
 153         BOOL m_IsIDReplaceAction;
 154         BOOL m_IsOldFirst;
 155         void hideFromContextMenu(unsigned __int64 hideMask, bool exclusivelyShow);
 156         BOOL m_IsRebaseReplaceGraph;
 157         BOOL m_bNoHightlightHead;
 158
 159         void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);
 160
 161         BOOL m_bStrictStopped;
 162         BOOL m_bShowBugtraqColumn;
 163         BOOL m_bSearchIndex;
 164         BOOL m_bCancelled;
 165         unsigned __int64 m_ContextMenuMask;
 166
 167         bool                            m_hasWC;
 168         bool                            m_bShowWC;
 169         GitRev                          m_wcRev;
 170         volatile LONG           m_bThreadRunning;
 171         CLogCache                       m_LogCache;
 172
 173         CString m_sRange;
 174         // don't forget to bump BLAME_COLUMN_VERSION in GitStatusListCtrlHelpers.cpp if you change columns
 175         enum
 176         {
 177                 LOGLIST_GRAPH,
 178                 LOGLIST_REBASE,
 179                 LOGLIST_ID,
 180                 LOGLIST_HASH,
 181                 LOGLIST_ACTION,
 182                 LOGLIST_MESSAGE,
 183                 LOGLIST_AUTHOR,
 184                 LOGLIST_DATE,
 185                 LOGLIST_EMAIL,
 186                 LOGLIST_COMMIT_NAME,
 187                 LOGLIST_COMMIT_EMAIL,
 188                 LOGLIST_COMMIT_DATE,
 189                 LOGLIST_BUG,
 190                 LOGLIST_MESSAGE_MAX=300,
 191                 LOGLIST_MESSAGE_MIN=200,
 192
 193                 GIT_LOG_GRAPH   =               1<< LOGLIST_GRAPH,
 194                 GIT_LOG_REBASE  =               1<< LOGLIST_REBASE,
 195                 GIT_LOG_ID              =               1<< LOGLIST_ID,
 196                 GIT_LOG_HASH    =               1<< LOGLIST_HASH,
 197                 GIT_LOG_ACTIONS =               1<< LOGLIST_ACTION,
 198                 GIT_LOG_MESSAGE =               1<< LOGLIST_MESSAGE,
 199                 GIT_LOG_AUTHOR  =               1<< LOGLIST_AUTHOR,
 200                 GIT_LOG_DATE    =               1<< LOGLIST_DATE,
 201                 GIT_LOG_EMAIL   =               1<< LOGLIST_EMAIL,
 202                 GIT_LOG_COMMIT_NAME     =       1<< LOGLIST_COMMIT_NAME,
 203                 GIT_LOG_COMMIT_EMAIL=   1<< LOGLIST_COMMIT_EMAIL,
 204                 GIT_LOG_COMMIT_DATE     =       1<< LOGLIST_COMMIT_DATE,
 205                 GIT_LOGLIST_BUG         =       1<< LOGLIST_BUG,
 206         };
 207
 208         enum
 209         {
 210         // needs to start with 1, since 0 is the return value if *nothing* is clicked on in the context menu
 211         ID_COMPARE = 1, // compare revision with WC
 212         ID_SAVEAS,
 213         ID_COMPARETWO, // compare two revisions
 214         ID_COPY,
 215         ID_REVERTREV,
 216         ID_MERGEREV,
 217         ID_GNUDIFF1, // compare with WC, unified
 218         ID_GNUDIFF2, // compare two revisions, unified
 219         ID_FINDENTRY,
 220         ID_OPEN,
 221         ID_BLAME,
 222         ID_REPOBROWSE,
 223         ID_LOG,
 224         ID_EDITNOTE,
 225         ID_DIFF,
 226         ID_OPENWITH,
 227         ID_COPYCLIPBOARD,
 228         ID_COPYHASH,
 229         ID_REVERTTOREV,
 230         ID_BLAMECOMPARE,
 231         ID_BLAMEDIFF,
 232         ID_VIEWREV,
 233         ID_VIEWPATHREV,
 234         ID_EXPORT,
 235         ID_COMPAREWITHPREVIOUS,
 236         ID_BLAMEPREVIOUS,
 237         ID_CHERRY_PICK,
 238         ID_CREATE_BRANCH,
 239         ID_CREATE_TAG,
 240         ID_SWITCHTOREV,
 241         ID_SWITCHBRANCH,
 242         ID_RESET,
 243         ID_REBASE_PICK,
 244         ID_REBASE_EDIT,
 245         ID_REBASE_SQUASH,
 246         ID_REBASE_SKIP,
 247         ID_COMBINE_COMMIT,
 248         ID_STASH_SAVE,
 249         ID_STASH_LIST,
 250         ID_STASH_POP,
 251         ID_REFLOG_STASH_APPLY,
 252         ID_REFLOG_DEL,
 253         ID_REBASE_TO_VERSION,
 254         ID_CREATE_PATCH,
 255         ID_DELETE,
 256         ID_COMMIT,
 257         ID_PUSH,
 258         ID_PULL,
 259         ID_FETCH,
 260         ID_SHOWBRANCHES,
 261         ID_COPYCLIPBOARDMESSAGES,
 262         ID_BISECTSTART,
 263         ID_LOG_VIEWRANGE,
 264         ID_LOG_VIEWRANGE_REACHABLEFROMONLYONE,
 265         ID_MERGE_ABORT,
 266         };
 267         enum
 268         {
 269         ID_COPY_ALL,
 270         ID_COPY_MESSAGE,
 271         ID_COPY_SUBJECT,
 272         ID_COPY_HASH,
 273         };
 274         enum FilterShow
 275         {
 276                 FILTERSHOW_REFS = 1,
 277                 FILTERSHOW_MERGEPOINTS = 2,
 278                 FILTERSHOW_ANYCOMMIT = 4,
 279                 FILTERSHOW_ALL = FILTERSHOW_ANYCOMMIT | FILTERSHOW_REFS | FILTERSHOW_MERGEPOINTS
 280         };
 281         enum : unsigned int
 282         {
 283                 // For Rebase only
 284                 LOGACTIONS_REBASE_CURRENT       = 0x08000000,
 285                 LOGACTIONS_REBASE_PICK          = 0x04000000,
 286                 LOGACTIONS_REBASE_SQUASH        = 0x02000000,
 287                 LOGACTIONS_REBASE_EDIT          = 0x01000000,
 288                 LOGACTIONS_REBASE_DONE          = 0x00800000,
 289                 LOGACTIONS_REBASE_SKIP          = 0x00400000,
 290                 LOGACTIONS_REBASE_MASK          = 0x0FC00000,
 291                 LOGACTIONS_REBASE_MODE_MASK     = 0x07C00000,
 292         };
 293         inline unsigned __int64 GetContextMenuBit(int i){ return ((unsigned __int64 )0x1)<<i ;}
 294         static CString GetRebaseActionName(int action);
 295         void InsertGitColumn();
 296         void ResizeAllListCtrlCols();
 297         void CopySelectionToClipBoard(int toCopy = ID_COPY_ALL);
 298         void DiffSelectedRevWithPrevious();
 299         bool IsSelectionContinuous();
 300         int  BeginFetchLog();
 301         int  FillGitLog(CTGitPath *path, CString *range = NULL, int infomask = CGit::LOG_INFO_STAT| CGit::LOG_INFO_FILESTATE | CGit::LOG_INFO_SHOW_MERGEDFILE);
 302         int  FillGitLog(std::set<CGitHash>& hashes);
 303         BOOL IsMatchFilter(bool bRegex, GitRev *pRev, std::tr1::wregex &pat);
 304         bool ShouldShowFilter(GitRev *pRev, const std::map<CGitHash, std::set<CGitHash>> &commitChildren);
 305         void ShowGraphColumn(bool bShow);
 306
 307         CFindDlg *m_pFindDialog;
 308         static const UINT       m_FindDialogMessage;
 309         void OnFind();
 310
 311         static const UINT       m_ScrollToMessage;
 312         static const UINT       m_RebaseActionMessage;
 313
 314         inline int ShownCountWithStopped() const { return (int)m_arShownList.GetCount() + (m_bStrictStopped ? 1 : 0); }
 315         int FetchLogAsync(void * data=NULL);
 316         CThreadSafePtrArray                     m_arShownList;
 317         void Refresh(BOOL IsCleanFilter=TRUE);
 318         void RecalculateShownList(CThreadSafePtrArray * pShownlist);
 319         void Clear();
 320
 321         DWORD                           m_SelectedFilters;
 322         FilterShow                      m_ShowFilter;
 323         bool                            m_bFilterWithRegex;
 324         CLogDataVector          m_logEntries;
 325         void RemoveFilter();
 326         void StartFilter();
 327         bool ValidateRegexp(LPCTSTR regexp_str, std::tr1::wregex& pat, bool bMatchCase = false );
 328         CString                         m_sFilterText;
 329
 330         __time64_t                      m_From;
 331         __time64_t                      m_To;
 332
 333         CTGitPath                       m_Path;
 334         int                                     m_ShowMask;
 335         CGitHash                        m_lastSelectedHash;
 336         int                                     m_ShowRefMask;
 337
 338         void                            GetTimeRange(CTime &oldest,CTime &latest);
 339         virtual void GetParentHashes(GitRev *pRev, GIT_REV_LIST &parentHash);
 340         virtual void ContextMenuAction(int cmd,int FirstSelect, int LastSelect, CMenu * menu)=0;
 341         void ReloadHashMap()
 342         {
 343                 m_HashMap.clear();
 344
 345                 if (g_Git.GetMapHashToFriendName(m_HashMap))
 346                         MessageBox(g_Git.GetGitLastErr(_T("Could not get all refs.")), _T("TortoiseGit"), MB_ICONERROR);
 347
 348                 m_CurrentBranch=g_Git.GetCurrentBranch();
 349
 350                 if (g_Git.GetHash(m_HeadHash, _T("HEAD")))
 351                 {
 352                         MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash. Quitting...")), _T("TortoiseGit"), MB_ICONERROR);
 353                         ExitProcess(1);
 354                 }
 355
 356                 m_wcRev.m_ParentHash.clear();
 357                 m_wcRev.m_ParentHash.push_back(m_HeadHash);
 358
 359                 FetchRemoteList();
 360                 FetchTrackingBranchList();
 361         }
 362         void SafeTerminateThread()
 363         {
 364                 if (m_LoadingThread!=NULL && InterlockedExchange(&m_bExitThread, TRUE) == FALSE)
 365                 {
 366                         DWORD ret = WAIT_TIMEOUT;
 367                         for (int i = 0; i < 200 && m_bThreadRunning; ++i)
 368                                 ret =::WaitForSingleObject(m_LoadingThread->m_hThread, 100);
 369                         if (ret == WAIT_TIMEOUT && m_bThreadRunning)
 370                                 ::TerminateThread(m_LoadingThread, 0);
 371                         m_LoadingThread = NULL;
 372                 }
 373         };
 374
 375         bool IsInWorkingThread()
 376         {
 377                 return (AfxGetThread() == m_LoadingThread);
 378         }
 379
 380         void SetRange(const CString& range)
 381         {
 382                 m_sRange = range;
 383         }
 384
 385         CString GetRange() const { return m_sRange; }
 386
 387         bool HasFilterText() const { return !m_sFilterText.IsEmpty() && m_sFilterText != _T("!"); }
 388
 389         int                                     m_nSearchIndex;
 390
 391         volatile LONG           m_bExitThread;
 392         CWinThread*                     m_LoadingThread;
 393         MAP_HASH_NAME           m_HashMap;
 394         std::map<CString, std::pair<CString, CString>>  m_TrackingMap;
 395
 396 public:
 397         CString                         m_ColumnRegKey;
 398         CComCriticalSection     m_critSec_AsyncDiff;
 399
 400 protected:
 401         typedef struct {
 402                 CString name;
 403                 COLORREF color;
 404                 CString simplifiedName;
 405                 bool singleRemote;
 406                 bool hasTracking;
 407                 bool sameName;
 408                 bool annotatedTag;
 409         } REFLABEL;
 410
 411         DECLARE_MESSAGE_MAP()
 412         afx_msg void OnDestroy();
 413         virtual afx_msg void OnNMCustomdrawLoglist(NMHDR *pNMHDR, LRESULT *pResult);
 414         virtual afx_msg void OnLvnGetdispinfoLoglist(NMHDR *pNMHDR, LRESULT *pResult);
 415         afx_msg LRESULT OnFindDialogMessage(WPARAM wParam, LPARAM lParam);
 416         afx_msg LRESULT OnScrollToMessage(WPARAM wParam, LPARAM lParam);
 417         afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 418         afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
 419         afx_msg LRESULT OnLoad(WPARAM wParam, LPARAM lParam);
 420         afx_msg void OnHdnBegintrack(NMHDR *pNMHDR, LRESULT *pResult);
 421         afx_msg void OnHdnItemchanging(NMHDR *pNMHDR, LRESULT *pResult);
 422         afx_msg void OnColumnResized(NMHDR *pNMHDR, LRESULT *pResult);
 423         afx_msg void OnColumnMoved(NMHDR *pNMHDR, LRESULT *pResult);
 424         void OnNMDblclkLoglist(NMHDR * /*pNMHDR*/, LRESULT *pResult);
 425         afx_msg void OnLvnOdfinditemLoglist(NMHDR *pNMHDR, LRESULT *pResult);
 426         void PreSubclassWindow();
 427         virtual BOOL PreTranslateMessage(MSG* pMsg);
 428         static UINT LogThreadEntry(LPVOID pVoid);
 429         UINT LogThread();
 430         bool IsOnStash(int index);
 431         bool IsStash(const GitRev * pSelLogEntry);
 432         void FetchRemoteList();
 433         void FetchTrackingBranchList();
 434         void FetchLastLogInfo();
 435         void FetchFullLogInfo(CString &from, CString &to);
 436         void FillBackGround(HDC hdc, DWORD_PTR Index, CRect &rect);
 437         void DrawTagBranchMessage(HDC hdc, CRect &rect, INT_PTR index, std::vector<REFLABEL> &refList);
 438         void DrawTagBranch(HDC hdc, CDC &W_Dc, HTHEME hTheme, CRect &rect, CRect &rt, LVITEM &rItem, GitRev* data, std::vector<REFLABEL> &refList);
 439         void DrawGraph(HDC,CRect &rect,INT_PTR index);
 440
 441         void paintGraphLane(HDC hdc,int laneHeight, int type, int x1, int x2,
 442                                                                           const COLORREF& col,const COLORREF& activeColor, int top) ;
 443         void DrawLine(HDC hdc, int x1, int y1, int x2, int y2){::MoveToEx(hdc,x1,y1,NULL);::LineTo(hdc,x2,y2);}
 444         /**
 445         * Save column widths to the registry
 446         */
 447         void SaveColumnWidths();        // save col widths to the registry
 448
 449         BOOL IsEntryInDateRange(int i);
 450
 451         int GetHeadIndex();
 452
 453         std::vector<GitRev*> m_AsynDiffList;
 454         CComCriticalSection m_AsynDiffListLock;
 455         HANDLE  m_AsyncDiffEvent;
 456         volatile LONG m_AsyncThreadExit;
 457         CWinThread*                     m_DiffingThread;
 458
 459         static int DiffAsync(GitRev *rev, void *data)
 460         {
 461                 ULONGLONG offset=((CGitLogListBase*)data)->m_LogCache.GetOffset(rev->m_CommitHash);
 462                 if(!offset)
 463                 {
 464                         ((CGitLogListBase*)data)->m_AsynDiffListLock.Lock();
 465                         ((CGitLogListBase*)data)->m_AsynDiffList.push_back(rev);
 466                         ((CGitLogListBase*)data)->m_AsynDiffListLock.Unlock();
 467                         ::SetEvent(((CGitLogListBase*)data)->m_AsyncDiffEvent);
 468                 }
 469                 else
 470                 {
 471                         if(((CGitLogListBase*)data)->m_LogCache.LoadOneItem(*rev,offset))
 472                         {
 473                                 ((CGitLogListBase*)data)->m_AsynDiffListLock.Lock();
 474                                 ((CGitLogListBase*)data)->m_AsynDiffList.push_back(rev);
 475                                 ((CGitLogListBase*)data)->m_AsynDiffListLock.Unlock();
 476                                 ::SetEvent(((CGitLogListBase*)data)->m_AsyncDiffEvent);
 477                         }
 478                         InterlockedExchange(&rev->m_IsDiffFiles, TRUE);
 479                         if(rev->m_IsDiffFiles && rev->m_IsCommitParsed)
 480                                 InterlockedExchange(&rev->m_IsFull, TRUE);
 481                 }
 482                 return 0;
 483         }
 484
 485         static UINT AsyncThread(LPVOID data)
 486         {
 487                 return ((CGitLogListBase*)data)->AsyncDiffThread();
 488         }
 489
 490         int AsyncDiffThread();
 491         bool m_AsyncThreadExited;
 492
 493         int SafeGetAction(GitRev *rev, int **ptr = nullptr)
 494         {
 495                 try
 496                 {
 497                         int *p = &rev->GetAction(this);
 498                         if (ptr)
 499                                 *ptr = p;
 500                         return *p;
 501                 }
 502                 catch (const char* msg)
 503                 {
 504                         MessageBox(_T("Could not get action of commit ") + rev->m_CommitHash.ToString() + _T(".\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
 505                         return 0;
 506                 }
 507         }
 508
 509 public:
 510         void SafeTerminateAsyncDiffThread()
 511         {
 512                 if(m_DiffingThread!=NULL && m_AsyncThreadExit != TRUE)
 513                 {
 514                         m_AsyncThreadExit = TRUE;
 515                         ::SetEvent(m_AsyncDiffEvent);
 516                         DWORD ret = WAIT_TIMEOUT;
 517                         // do not block here, but process messages and ask until the thread ends
 518                         while (ret == WAIT_TIMEOUT && !m_AsyncThreadExited)
 519                         {
 520                                 MSG msg;
 521                                 if (::PeekMessage(&msg, NULL, 0,0, PM_NOREMOVE))
 522                                         AfxGetThread()->PumpMessage(); // process messages, so that GetTopIndex and so on in the thread work
 523                                 ret = ::WaitForSingleObject(m_DiffingThread->m_hThread, 100);
 524                         }
 525                         m_DiffingThread = NULL;
 526                 }
 527         };
 528
 529 protected:
 530         CComCriticalSection     m_critSec;
 531
 532         HICON                           m_hModifiedIcon;
 533         HICON                           m_hReplacedIcon;
 534         HICON                           m_hAddedIcon;
 535         HICON                           m_hDeletedIcon;
 536         HICON                           m_hFetchIcon;
 537
 538         HFONT                           m_boldFont;
 539
 540         CRegDWORD                       m_regMaxBugIDColWidth;
 541
 542         void                            *m_ProcData;
 543         CStoreSelection*        m_pStoreSelection;
 544
 545         CColors                         m_Colors;
 546
 547         CString                         m_CurrentBranch;
 548         CGitHash                        m_HeadHash;
 549
 550         COLORREF                        m_LineColors[Lanes::COLORS_NUM];
 551         DWORD                           m_LineWidth;
 552         DWORD                           m_NodeSize;
 553         DWORD                           m_DateFormat;   // DATE_SHORTDATE or DATE_LONGDATE
 554         bool                            m_bRelativeTimes;       // Show relative times
 555         GIT_LOG                         m_DllGitLog;
 556         CString                         m_SingleRemote;
 557         bool                            m_bTagsBranchesOnRightSide;
 558         bool                            m_bSymbolizeRefNames;
 559         bool                            m_bIncludeBoundaryCommits;
 560
 561         ColumnManager           m_ColumnManager;
 562         DWORD                           m_dwDefaultColumns;
 563 };
 564
 565