src/TortoiseProc/LogDlgHelper.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2007 - TortoiseSVN
   4 // Copyright (C) 2008-2016 - 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 #pragma once
  21 #include "lanes.h"
  22 #include "GitHash.h"
  23 #include "GitLogCache.h"
  24 class CLogDlg;
  25
  26 /**
  27  * \ingroup TortoiseProc
  28  * Instances of CStoreSelection save the selection of the CLogDlg. When the instance
  29  * is deleted the destructor restores the selection.
  30  */
  31 typedef std::map<CGitHash, int> MAP_HASH_REV;
  32
  33 /**
  34  * \ingroup TortoiseProc
  35  * Helper class for the log dialog, handles all the log entries, including
  36  * sorting.
  37  */
  38 class CLogDataVector :  public std::vector<CGitHash>
  39 {
  40 public:
  41         CLogCache *m_pLogCache;
  42         /// De-allocates log items.
  43         CLogDataVector(CLogCache *pLogCache)
  44         {
  45                 m_pLogCache=pLogCache;
  46                 m_FirstFreeLane=0;
  47                 // Default to value set in Registry
  48                 m_logOrderBy = CRegDWORD(L"Software\\TortoiseGit\\LogOrderBy", CGit::LOG_ORDER_TOPOORDER);
  49         }
  50         CLogDataVector()
  51         {
  52                 m_pLogCache = nullptr;
  53                 m_FirstFreeLane=0;
  54                 // Default to value set in Registry
  55                 m_logOrderBy = CRegDWORD(L"Software\\TortoiseGit\\LogOrderBy", CGit::LOG_ORDER_TOPOORDER);
  56         }
  57         void SetLogCache(CLogCache *pLogCache)
  58         {
  59                 m_pLogCache = pLogCache;
  60         }
  61         GitRevLoglist& GetGitRevAt(size_t i)
  62         {
  63                 ASSERT(i<size());
  64                 return  m_pLogCache->m_HashMap[(*this)[i]];
  65         }
  66         void ClearAll();
  67         int  ParserFromLog(CTGitPath* path = nullptr, DWORD count = 0, DWORD infomask = CGit::LOG_INFO_STAT | CGit::LOG_INFO_FILESTATE | CGit::LOG_INFO_SHOW_MERGEDFILE, CString* range = nullptr);
  68         int  Fill(std::set<CGitHash>& hashes);
  69
  70         int FetchFullInfo(int i);
  71
  72         Lanes m_Lns;
  73         int      m_FirstFreeLane;
  74         // Log order: LOG_ORDER_CHRONOLOGIALREVERSED, LOG_ORDER_TOPOORDER, LOG_ORDER_DATEORDER
  75         int m_logOrderBy;
  76         MAP_HASH_REV m_HashMap;
  77         void updateLanes(GitRevLoglist& c, Lanes& lns, CGitHash& sha);
  78         void setLane(CGitHash& sha) ;
  79         void append(CGitHash& sha, bool storeInVector);
  80
  81 #if 0
  82         /// Ascending date sorting.
  83         struct AscDateSort
  84         {
  85                 bool operator()(GitRev& pStart, GitRev& pEnd)
  86                 {
  87                         return pStart->tmDate < pEnd->tmDate;
  88                 }
  89         };
  90         /// Descending date sorting.
  91         struct DescDateSort
  92         {
  93                 bool operator()(GitRev& pStart, GitRev& pEnd)
  94                 {
  95                         return pStart->tmDate > pEnd->tmDate;
  96                 }
  97         };
  98         /// Ascending revision sorting.
  99         struct AscRevSort
 100         {
 101                 bool operator()(GitRev& pStart, GitRev& pEnd)
 102                 {
 103                         return pStart->Rev < pEnd->Rev;
 104                 }
 105         };
 106         /// Descending revision sorting.
 107         struct DescRevSort
 108         {
 109                 bool operator()(GitRev& pStart, GitRev& pEnd)
 110                 {
 111                         return pStart->Rev > pEnd->Rev;
 112                 }
 113         };
 114         /// Ascending author sorting.
 115         struct AscAuthorSort
 116         {
 117                 bool operator()(GitRev& pStart, GitRev& pEnd)
 118                 {
 119                         int ret = pStart->sAuthor.CompareNoCase(pEnd->sAuthor);
 120                         if (ret == 0)
 121                                 return pStart->Rev < pEnd->Rev;
 122                         return ret<0;
 123                 }
 124         };
 125         /// Descending author sorting.
 126         struct DescAuthorSort
 127         {
 128                 bool operator()(GitRev& pStart, GitRev& pEnd)
 129                 {
 130                         int ret = pStart->sAuthor.CompareNoCase(pEnd->sAuthor);
 131                         if (ret == 0)
 132                                 return pStart->Rev > pEnd->Rev;
 133                         return ret>0;
 134                 }
 135         };
 136         /// Ascending bugID sorting.
 137         struct AscBugIDSort
 138         {
 139                 bool operator()(GitRev& pStart, GitRev& pEnd)
 140                 {
 141                         int ret = pStart->sBugIDs.CompareNoCase(pEnd->sBugIDs);
 142                         if (ret == 0)
 143                                 return pStart->Rev < pEnd->Rev;
 144                         return ret<0;
 145                 }
 146         };
 147         /// Descending bugID sorting.
 148         struct DescBugIDSort
 149         {
 150                 bool operator()(GitRev& pStart, GitRev& pEnd)
 151                 {
 152                         int ret = pStart->sBugIDs.CompareNoCase(pEnd->sBugIDs);
 153                         if (ret == 0)
 154                                 return pStart->Rev > pEnd->Rev;
 155                         return ret>0;
 156                 }
 157         };
 158         /// Ascending message sorting.
 159         struct AscMessageSort
 160         {
 161                 bool operator()(GitRev& pStart, GitRev& pEnd)
 162                 {
 163                         return pStart->sShortMessage.CompareNoCase(pEnd->sShortMessage)<0;
 164                 }
 165         };
 166         /// Descending message sorting.
 167         struct DescMessageSort
 168         {
 169                 bool operator()(GitRev& pStart, GitRev& pEnd)
 170                 {
 171                         return pStart->sShortMessage.CompareNoCase(pEnd->sShortMessage)>0;
 172                 }
 173         };
 174         /// Ascending action sorting
 175         struct AscActionSort
 176         {
 177                 bool operator() (GitRev& pStart, GitRev& pEnd)
 178                 {
 179                         if (pStart->actions == pEnd->actions)
 180                                 return pStart->Rev < pEnd->Rev;
 181                         return pStart->actions < pEnd->actions;
 182                 }
 183         };
 184         /// Descending action sorting
 185         struct DescActionSort
 186         {
 187                 bool operator() (GitRev& pStart, GitRev& pEnd)
 188                 {
 189                         if (pStart->actions == pEnd->actions)
 190                                 return pStart->Rev > pEnd->Rev;
 191                         return pStart->actions > pEnd->actions;
 192                 }
 193         };
 194 #endif
 195 };