CString CGit::GetUserName(void)\r
{\r
CString UserName;\r
- Run(_T("git.cmd config user.name"),&UserName);\r
+ Run(_T("git.exe config user.name"),&UserName);\r
return UserName;\r
}\r
CString CGit::GetUserEmail(void)\r
{\r
CString UserName;\r
- Run(_T("git.cmd config user.email"),&UserName);\r
+ Run(_T("git.exe config user.email"),&UserName);\r
return UserName;\r
}\r
\r
CString CGit::GetCurrentBranch(void)\r
{\r
CString branch;\r
- Run(_T("git.cmd branch"),&branch);\r
+ Run(_T("git.exe branch"),&branch);\r
if(branch.GetLength()>0)\r
{\r
branch.Replace(_T('*'),_T(' '));\r
return CString("");\r
}\r
\r
-int CGit::GetLog(CString& logOut)\r
+int CGit::BuildOutputFormat(CString &format,bool IsFull)\r
{\r
-\r
- CString cmd;\r
CString log;\r
- cmd=("git.cmd log -C --numstat --raw --pretty=format:\"");\r
log.Format(_T("#<%c>%%n"),LOG_REV_ITEM_BEGIN);\r
- cmd += log;\r
- log.Format(_T("#<%c>%%an%%n"),LOG_REV_AUTHOR_NAME);\r
- cmd += log;\r
- log.Format(_T("#<%c>%%ae%%n"),LOG_REV_AUTHOR_EMAIL);\r
- cmd += log;\r
- log.Format(_T("#<%c>%%ai%%n"),LOG_REV_AUTHOR_DATE);\r
- cmd += log;\r
- log.Format(_T("#<%c>%%cn%%n"),LOG_REV_COMMIT_NAME);\r
- cmd += log;\r
- log.Format(_T("#<%c>%%ce%%n"),LOG_REV_COMMIT_EMAIL);\r
- cmd += log;\r
- log.Format(_T("#<%c>%%ci%%n"),LOG_REV_COMMIT_DATE);\r
- cmd += log;\r
- log.Format(_T("#<%c>%%s%%n"),LOG_REV_COMMIT_SUBJECT);\r
- cmd += log;\r
- log.Format(_T("#<%c>%%b%%n"),LOG_REV_COMMIT_BODY);\r
- cmd += log;\r
+ format += log;\r
+ if(IsFull)\r
+ {\r
+ log.Format(_T("#<%c>%%an%%n"),LOG_REV_AUTHOR_NAME);\r
+ format += log;\r
+ log.Format(_T("#<%c>%%ae%%n"),LOG_REV_AUTHOR_EMAIL);\r
+ format += log;\r
+ log.Format(_T("#<%c>%%ai%%n"),LOG_REV_AUTHOR_DATE);\r
+ format += log;\r
+ log.Format(_T("#<%c>%%cn%%n"),LOG_REV_COMMIT_NAME);\r
+ format += log;\r
+ log.Format(_T("#<%c>%%ce%%n"),LOG_REV_COMMIT_EMAIL);\r
+ format += log;\r
+ log.Format(_T("#<%c>%%ci%%n"),LOG_REV_COMMIT_DATE);\r
+ format += log;\r
+ log.Format(_T("#<%c>%%s%%n"),LOG_REV_COMMIT_SUBJECT);\r
+ format += log;\r
+ log.Format(_T("#<%c>%%b%%n"),LOG_REV_COMMIT_BODY);\r
+ format += log;\r
+ }\r
log.Format(_T("#<%c>%%H%%n"),LOG_REV_COMMIT_HASH);\r
- cmd += log;\r
+ format += log;\r
log.Format(_T("#<%c>%%P%%n"),LOG_REV_COMMIT_PARENT);\r
+ format += log;\r
+\r
+ if(IsFull)\r
+ {\r
+ log.Format(_T("#<%c>%%n"),LOG_REV_COMMIT_FILE);\r
+ format += log;\r
+ }\r
+ return 0;\r
+}\r
+\r
+int CGit::GetLog(CString& logOut, CString &hash, int count)\r
+{\r
+\r
+ CString cmd;\r
+ CString log;\r
+ CString num;\r
+ CString since;\r
+ if(count>0)\r
+ num.Format(_T("-n%d"),count);\r
+\r
+ cmd.Format(_T("git.exe log %s -C --numstat --raw --pretty=format:\""),\r
+ num);\r
+ BuildOutputFormat(log);\r
cmd += log;\r
- log.Format(_T("#<%c>%%n"),LOG_REV_COMMIT_FILE);\r
+ cmd += CString(_T("\" "))+hash;\r
+ return Run(cmd,&logOut);\r
+}\r
+\r
+\r
+int CGit::GetShortLog(CString &logOut)\r
+{\r
+ CString cmd;\r
+ CString log;\r
+ cmd=("git.exe log --topo-order -n100 --pretty=format:\"");\r
+ BuildOutputFormat(log,false);\r
cmd += log;\r
cmd += CString(_T("\" HEAD~40..HEAD"));\r
- Run(cmd,&logOut);\r
- return 0;\r
+ return Run(cmd,&logOut);\r
}\r
\r
#define BUFSIZE 512\r
{\r
CString cmd;\r
CString out;\r
- cmd.Format(_T("git.cmd rev-parse %s" ),friendname);\r
+ cmd.Format(_T("git.exe rev-parse %s" ),friendname);\r
Run(cmd,&out);\r
int pos=out.ReverseFind(_T('\n'));\r
if(pos>0)\r
int GetTagList(CStringList &list);\r
int GetMapHashToFriendName(MAP_HASH_NAME &map);\r
\r
- int GetLog(CString& logOut);\r
+ //hash is empty means all. -1 means all\r
+ int GetLog(CString& logOut,CString &hash, int count=-1);\r
+\r
git_revnum_t GetHash(CString &friendname);\r
+\r
+ int BuildOutputFormat(CString &format,bool IsFull=TRUE);\r
+ int GetShortLog(CString &log);\r
+ \r
\r
};\r
extern void GetTempPath(CString &path);\r
RelativePath=".\TGitPath.cpp"\r
>\r
</File>\r
+ <File\r
+ RelativePath=".\TGitPath.h"\r
+ >\r
+ </File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
RelativePath=".\targetver.h"\r
>\r
</File>\r
- <File\r
- RelativePath=".\TGitPath.h"\r
- >\r
- </File>\r
</Filter>\r
<Filter\r
Name="Resource Files"\r
#include "StdAfx.h"\r
#include "GitRev.h"\r
-\r
+#include "Git.h"\r
\r
GitRev::GitRev(void)\r
{\r
m_Action=0;\r
+ m_IsFull = 0;\r
+ m_IsUpdateing = 0;\r
}\r
\r
GitRev::~GitRev(void)\r
m_CommitHash.Empty();\r
\r
}\r
+int GitRev::CopyFrom(GitRev &rev)\r
+{\r
+ m_AuthorName =rev.m_AuthorName ;\r
+ m_AuthorEmail =rev.m_AuthorEmail ;\r
+ m_AuthorDate =rev.m_AuthorDate ;\r
+ m_CommitterName =rev.m_CommitterName ;\r
+ m_CommitterEmail=rev.m_CommitterEmail;\r
+ m_CommitterDate =rev.m_CommitterDate ;\r
+ m_Subject =rev.m_Subject ;\r
+ m_Body =rev.m_Body ;\r
+ m_CommitHash =rev.m_CommitHash ;\r
+ m_ParentHash =rev.m_ParentHash ;\r
+ m_Files =rev.m_Files ; \r
+ m_Action =rev.m_Action ;\r
+ return 0;\r
+}\r
int GitRev::ParserFromLog(CString &log)\r
{\r
int pos=0;\r
_wtoi(input.Mid(20,4)));\r
return tm;\r
}\r
+\r
+int GitRev::SafeFetchFullInfo(CGit *git)\r
+{\r
+ if(InterlockedExchange(&m_IsUpdateing,TRUE) == FALSE)
+ {
+ //GitRev rev;
+ CString onelog;
+ git->GetLog(onelog,m_CommitHash,1);
+ CString oldhash=m_CommitHash;
+ ParserFromLog(onelog);
+
+ ASSERT(oldhash==m_CommitHash);
+
+ InterlockedExchange(&m_IsUpdateing,FALSE);
+ InterlockedExchange(&m_IsFull,TRUE);
+ return 0;
+ }
+ return -1;\r
+}
\ No newline at end of file
#define LOG_REV_ITEM_BEGIN _T('B')\r
#define LOG_REV_ITEM_END _T('C')\r
\r
-\r
+class CGit;\r
\r
class GitRev\r
{\r
// GitRev(GitRev &rev);\r
// GitRev &operator=(GitRev &rev);\r
~GitRev(void);\r
+ \r
enum\r
{\r
REV_HEAD = -1, ///< head revision\r
REV_WC = -3, ///< revision of the working copy\r
REV_UNSPECIFIED = -4, ///< unspecified revision\r
};\r
+ \r
+ int CopyFrom(GitRev &rev);\r
+\r
static CString GetHead(){return CString(_T("HEAD"));};\r
static CString GetWorkingCopy(){return CString(GIT_REV_ZERO);};\r
+ \r
CString m_AuthorName;\r
CString m_AuthorEmail;\r
CTime m_AuthorDate;\r
git_revnum_t m_CommitHash;\r
GIT_REV_LIST m_ParentHash;\r
CTGitPathList m_Files;\r
- void Clear();\r
int m_Action;\r
+ \r
+ void Clear();\r
int ParserFromLog(CString &log);\r
CTime ConverFromString(CString input);\r
inline int ParentsCount(){return m_ParentHash.size();}\r
\r
//Show version tree Graphic\r
std::vector<int> m_Lanes;\r
+\r
+ volatile LONG m_IsFull;\r
+ volatile LONG m_IsUpdateing;\r
+ \r
+ int SafeFetchFullInfo(CGit *git);\r
};\r
{\r
CTGitPath * path=(CTGitPath*)GetItemData(index);\r
CString cmd;\r
- cmd.Format(_T("git.cmd add %s"),path->GetGitPathString());\r
+ cmd.Format(_T("git.exe add %s"),path->GetGitPathString());\r
CString output;\r
g_Git.Run(cmd,&output);\r
path->m_Action = CTGitPath::LOGACTIONS_ADDED;\r
CString cmdout;\r
CString cmd;\r
if(list == NULL)\r
- cmd=(_T("git.cmd diff-index --raw HEAD --numstat -C -M"));\r
+ cmd=(_T("git.exe diff-index --raw HEAD --numstat -C -M"));\r
else\r
- cmd.Format(_T("git.cmd diff-index --raw HEAD --numstat -C -M -- \"%s\""),(*list)[i].GetGitPathString());\r
+ cmd.Format(_T("git.exe diff-index --raw HEAD --numstat -C -M -- \"%s\""),(*list)[i].GetGitPathString());\r
\r
g_Git.Run(cmd,&cmdout);\r
\r
\r
if(list==NULL)\r
{\r
- cmd=_T("git.cmd ls-files --exclude-standard --full-name --others");\r
+ cmd=_T("git.exe ls-files --exclude-standard --full-name --others");\r
cmd+=ignored;\r
\r
}\r
else\r
- { cmd.Format(_T("git.cmd ls-files --exclude-standard --full-name --others %s-- \"%s\""),\r
+ { cmd.Format(_T("git.exe ls-files --exclude-standard --full-name --others %s-- \"%s\""),\r
ignored,\r
(*list)[i].GetWinPathString());\r
}\r
CString cmd;\r
if(rev1 == GitRev::GetWorkingCopy())\r
{\r
- cmd.Format(_T("git.cmd diff --stat -p %s"),rev2);\r
+ cmd.Format(_T("git.exe diff --stat -p %s"),rev2);\r
}else\r
{ \r
- cmd.Format(_T("git.cmd diff-tree -r -p --stat %s %s"),rev1,rev2);\r
+ cmd.Format(_T("git.exe diff-tree -r -p --stat %s %s"),rev1,rev2);\r
}\r
g_Git.RunLogFile(cmd,tempfile);\r
CAppUtils::StartUnifiedDiffViewer(tempfile,rev1.Left(6)+_T(":")+rev2.Left(6));\r
git.m_CurrentDir=cmdLinePath.GetWinPath();\r
CString output;\r
\r
- if (git.Run(_T("git.cmd init-db"),&output))\r
+ if (git.Run(_T("git.exe init-db"),&output))\r
{\r
CMessageBox::Show(hwndExplorer, IDS_PROC_REPOCREATEERR, IDS_APPNAME, MB_ICONERROR);\r
return false;\r
\r
CString cmd;\r
CString output;\r
- cmd.Format(_T("git.cmd mv \"%s\" \"%s\""),\r
+ cmd.Format(_T("git.exe mv \"%s\" \"%s\""),\r
cmdLinePath.GetGitPathString(),\r
sNewName);\r
\r
CString out;\r
for(int i=0;i< dlg.m_pathList.GetCount() ;i++)\r
{\r
- cmd.Format(_T("git.cmd reset --hard -- \"%s\""),dlg.m_pathList[i].GetGitPathString());\r
+ cmd.Format(_T("git.exe reset --hard -- \"%s\""),dlg.m_pathList[i].GetGitPathString());\r
g_Git.Run(cmd,&out);\r
}\r
#if 0\r
CString out;\r
if(uncheckedfiles.GetLength()>0)\r
{\r
- cmd.Format(_T("git.cmd reset -- %s"),uncheckedfiles);\r
+ cmd.Format(_T("git.exe reset -- %s"),uncheckedfiles);\r
g_Git.Run(cmd,&out);\r
}\r
\r
if(checkedfiles.GetLength()>0)\r
{\r
- cmd.Format(_T("git.cmd update-index -- %s"),checkedfiles);\r
+ cmd.Format(_T("git.exe update-index -- %s"),checkedfiles);\r
g_Git.Run(cmd,&out);\r
\r
CString tempfile=::GetTempFile();\r
file.Close();\r
\r
out =_T("");\r
- cmd.Format(_T("git.cmd commit -F \"%s\""), tempfile);\r
+ cmd.Format(_T("git.exe commit -F \"%s\""), tempfile);\r
g_Git.Run(cmd,&out);\r
\r
CFile::Remove(tempfile);\r
pPath->GetBaseFilename(),\r
rev1.Left(6),\r
pPath->GetFileExtension());\r
- cmd.Format(_T("git.cmd cat-file -p %s:%s"),rev1,pPath->GetGitPathString());\r
+ cmd.Format(_T("git.exe cat-file -p %s:%s"),rev1,pPath->GetGitPathString());\r
g_Git.RunLogFile(cmd,file1);\r
}else\r
{\r
pPath->GetBaseFilename(),\r
rev2.Left(6),\r
pPath->GetFileExtension());\r
- cmd.Format(_T("git.cmd cat-file -p %s:%s"),rev2,pPath->GetGitPathString());\r
+ cmd.Format(_T("git.exe cat-file -p %s:%s"),rev2,pPath->GetGitPathString());\r
g_Git.RunLogFile(cmd,file2);\r
}else\r
{\r
{
cx = LOGLIST_MESSAGE_MAX;
}
+ if (cx < LOGLIST_MESSAGE_MIN)
+ {
+ cx = LOGLIST_MESSAGE_MIN;
+ }
}
// keep the bug id column small
if (m_bNoDispUpdates)
return;
+
+
switch (pLVCD->nmcd.dwDrawStage)
{
case CDDS_PREPAINT:
if (m_arShownList.GetCount() > (INT_PTR)pLVCD->nmcd.dwItemSpec)
{
GitRev* data = (GitRev*)m_arShownList.GetAt(pLVCD->nmcd.dwItemSpec);
+ if(!data->m_IsFull)
+ {
+ if(data->SafeFetchFullInfo(&g_Git))
+ this->Invalidate();
+ TRACE(_T("Update ... %d\r\n"),pLVCD->nmcd.dwItemSpec);
+ }
+
if(m_HashMap[data->m_CommitHash].size()!=0)
{
CRect rect;
+
GetSubItemRect(pLVCD->nmcd.dwItemSpec, pLVCD->iSubItem, LVIR_BOUNDS, rect);
FillBackGround(pLVCD->nmcd.hdc, (INT_PTR)pLVCD->nmcd.dwItemSpec,rect);
GitRev * pLogEntry = NULL;
if (itemid < m_arShownList.GetCount())
pLogEntry = reinterpret_cast<GitRev*>(m_arShownList.GetAt(pItem->iItem));
-
+
+
// Which column?
switch (pItem->iSubItem)
{
CString tempfile=GetTempFile();
CString cmd;
GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
- cmd.Format(_T("git.cmd diff-tree -r -p --stat %s"),r1->m_CommitHash);
+ cmd.Format(_T("git.exe diff-tree -r -p --stat %s"),r1->m_CommitHash);
g_Git.RunLogFile(cmd,tempfile);
CAppUtils::StartUnifiedDiffViewer(tempfile,r1->m_CommitHash.Left(6)+_T(":")+r1->m_Subject);
}
CString cmd;
GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
GitRev * r2 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(LastSelect));
- cmd.Format(_T("git.cmd diff-tree -r -p --stat %s %s"),r1->m_CommitHash,r2->m_CommitHash);
+ cmd.Format(_T("git.exe diff-tree -r -p --stat %s %s"),r1->m_CommitHash,r2->m_CommitHash);
g_Git.RunLogFile(cmd,tempfile);
CAppUtils::StartUnifiedDiffViewer(tempfile,r1->m_CommitHash.Left(6)+_T(":")+r2->m_CommitHash.Left(6));
*pResult = -1;
}
-int CGitLogList::FillGitLog()
+int CGitLogList::FillGitShortLog()
{
ClearText();
this->m_logEntries.ClearAll();
- this->m_logEntries.ParserFromLog();
+ this->m_logEntries.ParserShortLog();
+
+ //this->m_logEntries.ParserFromLog();
SetItemCountEx(this->m_logEntries.size());
this->m_arShownList.RemoveAll();
temp.LoadString(IDS_PROGRESSWAIT);
ShowText(temp, true);
-// git_revnum_t r = -1;
-
- // get the repository root url, because the changed-files-list has the
- // paths shown there relative to the repository root.
-// CTGitPath rootpath;
-// BOOL succeeded = GetRootAndHead(m_path, rootpath, r);
-
-// m_sRepositoryRoot = rootpath.GetGitPathString();
-// m_sURL = m_path.GetGitPathString();
-
- // we need the UUID to unambigously identify the log cache
-// if (logCachePool.IsEnabled())
-// m_sUUID = logCachePool.GetRepositoryInfo().GetRepositoryUUID (rootpath);
-
- // if the log dialog is started from a working copy, we need to turn that
- // local path into an url here
-// if (succeeded)
-// {
-// if (!m_path.IsUrl())
-// {
-// m_sURL = GetURLFromPath(m_path);
-
- // The URL is escaped because Git::logReceiver
- // returns the path in a native format
-// m_sURL = CPathUtils::PathUnescape(m_sURL);
- // }
-// m_sRelativeRoot = m_sURL.Mid(CPathUtils::PathUnescape(m_sRepositoryRoot).GetLength());
-// m_sSelfRelativeURL = m_sRelativeRoot;
- // }
-#if 0
- if (succeeded && !m_mergePath.IsEmpty() && m_mergedRevs.empty())
- {
- // in case we got a merge path set, retrieve the merge info
- // of that path and check whether one of the merge URLs
- // match the URL we show the log for.
- GitPool localpool(pool);
- git_error_clear(Err);
- apr_hash_t * mergeinfo = NULL;
- if (git_client_mergeinfo_get_merged (&mergeinfo, m_mergePath.GetGitApiPath(localpool), GitRev(GitRev::REV_WC), m_pctx, localpool) == NULL)
- {
- // now check the relative paths
- apr_hash_index_t *hi;
- const void *key;
- void *val;
-
- if (mergeinfo)
- {
- for (hi = apr_hash_first(localpool, mergeinfo); hi; hi = apr_hash_next(hi))
- {
- apr_hash_this(hi, &key, NULL, &val);
- if (m_sURL.Compare(CUnicodeUtils::GetUnicode((char*)key)) == 0)
- {
- apr_array_header_t * arr = (apr_array_header_t*)val;
- if (val)
- {
- for (long i=0; i<arr->nelts; ++i)
- {
- git_merge_range_t * pRange = APR_ARRAY_IDX(arr, i, git_merge_range_t*);
- if (pRange)
- {
- for (git_revnum_t r=pRange->start+1; r<=pRange->end; ++r)
- {
- m_mergedRevs.insert(r);
- }
- }
- }
- }
- break;
- }
- }
- }
- }
- }
-
- m_LogProgress.SetPos(1);
- if (m_startrev == GitRev::REV_HEAD)
- {
- m_startrev = r;
- }
- if (m_endrev == GitRev::REV_HEAD)
- {
- m_endrev = r;
- }
-
- if (m_limit != 0)
- {
- m_limitcounter = m_limit;
- m_LogProgress.SetRange32(0, m_limit);
- }
- else
- m_LogProgress.SetRange32(m_endrev, m_startrev);
-
- if (!m_pegrev.IsValid())
- m_pegrev = m_startrev;
- size_t startcount = m_logEntries.size();
- m_lowestRev = -1;
- m_bStrictStopped = false;
-
- if (succeeded)
- {
- succeeded = ReceiveLog (CTGitPathList(m_path), m_pegrev, m_startrev, m_endrev, m_limit, m_bStrict, m_bIncludeMerges, refresh);
- if ((!succeeded)&&(!m_path.IsUrl()))
- {
- // try again with REV_WC as the start revision, just in case the path doesn't
- // exist anymore in HEAD
- succeeded = ReceiveLog(CTGitPathList(m_path), GitRev(), GitRev::REV_WC, m_endrev, m_limit, m_bStrict, m_bIncludeMerges, refresh);
- }
- }
- m_LogList.ClearText();
- if (!succeeded)
- {
- m_LogList.ShowText(GetLastErrorMessage(), true);
- }
- else
- {
- if (!m_wcRev.IsValid())
- {
- // fetch the revision the wc path is on so we can mark it
- CTGitPath revWCPath = m_ProjectProperties.GetPropsPath();
- if (!m_path.IsUrl())
- revWCPath = m_path;
- if (DWORD(CRegDWORD(_T("Software\\TortoiseGit\\RecursiveLogRev"), FALSE)))
- {
- git_revnum_t minrev, maxrev;
- bool switched, modified, sparse;
- GetWCRevisionStatus(revWCPath, true, minrev, maxrev, switched, modified, sparse);
- if (maxrev)
- m_wcRev = maxrev;
- }
- else
- {
- CTGitPath dummypath;
- GitStatus status;
- git_wc_status2_t * stat = status.GetFirstFileStatus(revWCPath, dummypath, false, git_depth_empty);
- if (stat && stat->entry && stat->entry->cmt_rev)
- m_wcRev = stat->entry->cmt_rev;
- if (stat && stat->entry && (stat->entry->kind == git_node_dir))
- m_wcRev = stat->entry->revision;
- }
- }
- }
- if (m_bStrict && (m_lowestRev>1) && ((m_limit>0) ? ((startcount + m_limit)>m_logEntries.size()) : (m_endrev<m_lowestRev)))
- m_bStrictStopped = true;
- m_LogList.SetItemCountEx(ShownCountWithStopped());
-
- m_timFrom = (__time64_t(m_tFrom));
- m_timTo = (__time64_t(m_tTo));
- m_DateFrom.SetRange(&m_timFrom, &m_timTo);
- m_DateTo.SetRange(&m_timFrom, &m_timTo);
- m_DateFrom.SetTime(&m_timFrom);
- m_DateTo.SetTime(&m_timTo);
-#endif
- //DialogEnableWindow(IDC_GETALL, TRUE);
- FillGitLog();
+ FillGitShortLog();
InterlockedExchange(&m_bThreadRunning, FALSE);
SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
}
}
+ InterlockedExchange(&m_bNoDispUpdates, FALSE);
+
+ int index=0;
+ int updated=0;
+ int percent=0;
+ while(1)
+ {
+ for(int i=0;i<m_logEntries.size();i++)
+ {
+ if(!m_logEntries.FetchFullInfo(i))
+ {
+ updated++;
+ }
+
+ percent=updated*98/m_logEntries.size() + GITLOG_START+1;
+ if(percent == GITLOG_END)
+ percent == GITLOG_END -1;
+
+ if(m_ProcCallBack)
+ m_ProcCallBack(m_ProcData,percent);
+ }
+ if(updated==m_logEntries.size())
+ break;
+ }
//RefreshCursor();
// make sure the filter is applied (if any) now, after we refreshed/fetched
// the log messages
- InterlockedExchange(&m_bNoDispUpdates, FALSE);
+
if(m_ProcCallBack)
m_ProcCallBack(m_ProcData,GITLOG_END);
#define ICONITEMBORDER 5\r
\r
#define GITLOG_START 0\r
+#define GITLOG_START_ALL 1\r
#define GITLOG_END 100\r
\r
typedef void CALLBACK_PROCESS(void * data, int progress);\r
LOGLIST_AUTHOR,\r
LOGLIST_DATE,\r
LOGLIST_BUG,\r
- LOGLIST_MESSAGE_MAX=250\r
+ LOGLIST_MESSAGE_MAX=300,\r
+ LOGLIST_MESSAGE_MIN=200\r
};\r
\r
enum \r
void CopySelectionToClipBoard(bool hashonly=FALSE);\r
void DiffSelectedRevWithPrevious();\r
bool IsSelectionContinuous();\r
- int FillGitLog();\r
+ int FillGitShortLog();\r
inline int ShownCountWithStopped() const { return (int)m_arShownList.GetCount() + (m_bStrictStopped ? 1 : 0); }\r
int FetchLogAsync(CALLBACK_PROCESS *proc=NULL, void * data=NULL);\r
CPtrArray m_arShownList;\r
//#include "EditPropertiesDlg.h"
#include "FileDiffDlg.h"
+int CLogDataVector::ParserShortLog()
+{
+ CString log;
+ GitRev rev;
+
+ CString begin;
+ begin.Format(_T("#<%c>"),LOG_REV_ITEM_BEGIN);
+
+ g_Git.GetShortLog(log);
+ if(log.GetLength()==0)
+ return 0;
+
+ int start=4;
+ int length;
+ int next =1;
+ while( next>0 )
+ {
+ next=log.Find(begin,start);
+ if(next >0 )
+ length = next - start+4;
+ else
+ length = log.GetLength()-start+4;
+
+ CString onelog =log;
+ onelog=log.Mid(start -4,length);
+ rev.ParserFromLog(onelog);
+ rev.m_Subject=_T("Load .................................");
+ this->push_back(rev);
+ m_HashMap[rev.m_CommitHash]=size()-1;
+ start = next +4;
+ }
+
+ return 0;
+ return 0;
+
+}
+int CLogDataVector::FetchFullInfo(int i)
+{
+ return at(i).SafeFetchFullInfo(&g_Git);
+}
//CLogDataVector Class
int CLogDataVector::ParserFromLog()
{
CString log;
GitRev rev;
- g_Git.GetLog(log);
+ CString emptyhash;
+ g_Git.GetLog(log,emptyhash);
CString begin;
begin.Format(_T("#<%c>"),LOG_REV_ITEM_BEGIN);
}\r
\r
// We use a progress bar while getting the logs \r
- //m_LogProgress.SetRange32(0, 100);\r
- //m_LogProgress.SetPos(0);\r
+ m_LogProgress.SetRange32(0, 100);\r
+ m_LogProgress.SetPos(0);\r
\r
GetDlgItem(IDC_PROGRESS)->ShowWindow(TRUE);\r
\r
PostMessage(WM_TIMER, LOGFILTER_TIMER);\r
\r
}\r
+\r
+ m_LogProgress.SetPos(cur);\r
}\r
void CLogDlg::SetDlgTitle(bool bOffline)\r
{\r
\r
CString cmd;\r
\r
- cmd.Format(_T("git.cmd cat-file -p %s:%s"),rev1->m_CommitHash,(*m_currentChangedArray)[selIndex].GetGitPathString());\r
+ cmd.Format(_T("git.exe cat-file -p %s:%s"),rev1->m_CommitHash,(*m_currentChangedArray)[selIndex].GetGitPathString());\r
g_Git.RunLogFile(cmd,file1);\r
- cmd.Format(_T("git.cmd cat-file -p %s:%s"),rev2->m_CommitHash,(*m_currentChangedArray)[selIndex].GetGitPathString());\r
+ cmd.Format(_T("git.exe cat-file -p %s:%s"),rev2->m_CommitHash,(*m_currentChangedArray)[selIndex].GetGitPathString());\r
g_Git.RunLogFile(cmd,file2);\r
\r
CAppUtils::DiffFlags flags;\r
}\r
void ClearAll();\r
int ParserFromLog();\r
+ int ParserShortLog();\r
+ int FetchFullInfo(int i);\r
+\r
Lanes m_Lanes;\r
int m_FirstFreeLane;\r
MAP_HASH_REV m_HashMap;\r
void updateLanes(GitRev& c, Lanes& lns, CString &sha) ;\r
void setLane(CString& sha) ;\r
+ \r
+ \r
\r
\r
#if 0\r
OSDN Git Service
