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