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-2011 - 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(int 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,
  80                                                                                          CString *from=NULL,CString *to=NULL);
  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  ParserFromRefLog(CString ref);
  86
  87         int FetchFullInfo(int i);
  88 //      void AddFullInfo(
  89
  90         Lanes m_Lns;
  91         int      m_FirstFreeLane;
  92         MAP_HASH_REV m_HashMap;
  93         void updateLanes(GitRev& c, Lanes& lns, CGitHash &sha) ;
  94         void setLane(CGitHash& sha) ;
  95
  96         BYTE_VECTOR              m_RawlogData;
  97         std::vector<int> m_RawLogStart;
  98
  99 #if 0
 100         /// Ascending date sorting.
 101         struct AscDateSort
 102         {
 103                 bool operator()(GitRev& pStart, GitRev& pEnd)
 104                 {
 105                         return pStart->tmDate < pEnd->tmDate;
 106                 }
 107         };
 108         /// Descending date sorting.
 109         struct DescDateSort
 110         {
 111                 bool operator()(GitRev& pStart, GitRev& pEnd)
 112                 {
 113                         return pStart->tmDate > pEnd->tmDate;
 114                 }
 115         };
 116         /// Ascending revision sorting.
 117         struct AscRevSort
 118         {
 119                 bool operator()(GitRev& pStart, GitRev& pEnd)
 120                 {
 121                         return pStart->Rev < pEnd->Rev;
 122                 }
 123         };
 124         /// Descending revision sorting.
 125         struct DescRevSort
 126         {
 127                 bool operator()(GitRev& pStart, GitRev& pEnd)
 128                 {
 129                         return pStart->Rev > pEnd->Rev;
 130                 }
 131         };
 132         /// Ascending author sorting.
 133         struct AscAuthorSort
 134         {
 135                 bool operator()(GitRev& pStart, GitRev& pEnd)
 136                 {
 137                         int ret = pStart->sAuthor.CompareNoCase(pEnd->sAuthor);
 138                         if (ret == 0)
 139                                 return pStart->Rev < pEnd->Rev;
 140                         return ret<0;
 141                 }
 142         };
 143         /// Descending author sorting.
 144         struct DescAuthorSort
 145         {
 146                 bool operator()(GitRev& pStart, GitRev& pEnd)
 147                 {
 148                         int ret = pStart->sAuthor.CompareNoCase(pEnd->sAuthor);
 149                         if (ret == 0)
 150                                 return pStart->Rev > pEnd->Rev;
 151                         return ret>0;
 152                 }
 153         };
 154         /// Ascending bugID sorting.
 155         struct AscBugIDSort
 156         {
 157                 bool operator()(GitRev& pStart, GitRev& pEnd)
 158                 {
 159                         int ret = pStart->sBugIDs.CompareNoCase(pEnd->sBugIDs);
 160                         if (ret == 0)
 161                                 return pStart->Rev < pEnd->Rev;
 162                         return ret<0;
 163                 }
 164         };
 165         /// Descending bugID sorting.
 166         struct DescBugIDSort
 167         {
 168                 bool operator()(GitRev& pStart, GitRev& pEnd)
 169                 {
 170                         int ret = pStart->sBugIDs.CompareNoCase(pEnd->sBugIDs);
 171                         if (ret == 0)
 172                                 return pStart->Rev > pEnd->Rev;
 173                         return ret>0;
 174                 }
 175         };
 176         /// Ascending message sorting.
 177         struct AscMessageSort
 178         {
 179                 bool operator()(GitRev& pStart, GitRev& pEnd)
 180                 {
 181                         return pStart->sShortMessage.CompareNoCase(pEnd->sShortMessage)<0;
 182                 }
 183         };
 184         /// Descending message sorting.
 185         struct DescMessageSort
 186         {
 187                 bool operator()(GitRev& pStart, GitRev& pEnd)
 188                 {
 189                         return pStart->sShortMessage.CompareNoCase(pEnd->sShortMessage)>0;
 190                 }
 191         };
 192         /// Ascending action sorting
 193         struct AscActionSort
 194         {
 195                 bool operator() (GitRev& pStart, GitRev& pEnd)
 196                 {
 197                         if (pStart->actions == pEnd->actions)
 198                                 return pStart->Rev < pEnd->Rev;
 199                         return pStart->actions < pEnd->actions;
 200                 }
 201         };
 202         /// Descending action sorting
 203         struct DescActionSort
 204         {
 205                 bool operator() (GitRev& pStart, GitRev& pEnd)
 206                 {
 207                         if (pStart->actions == pEnd->actions)
 208                                 return pStart->Rev > pEnd->Rev;
 209                         return pStart->actions > pEnd->actions;
 210                 }
 211         };
 212 #endif
 213 };