自学教程：C++ CTGitPath函数代码示例

CTGitPath CTGitPathList::GetCommonRoot() const{	if (IsEmpty())		return CTGitPath();	if (GetCount() == 1)		return m_paths[0];	// first entry is common root for itself	// (add trailing '//' to detect partial matches of the last path element)	CString root = m_paths[0].GetWinPathString() + _T('//');	int rootLength = root.GetLength();	// determine common path string prefix	for (PathVector::const_iterator it = m_paths.begin() + 1; it != m_paths.end(); ++it)	{		CString path = it->GetWinPathString() + _T('//');		int newLength = CStringUtils::GetMatchingLength(root, path);		if (newLength != rootLength)		{			root.Delete(newLength, rootLength);			rootLength = newLength;		}	}	// remove the last (partial) path element	if (rootLength > 0)		root.Delete(root.ReverseFind(_T('//')), rootLength);	// done	return CTGitPath(root);}

CTGitPath CDirectoryWatcher::CloseInfoMap(HANDLE hDir){	AutoLocker lock(m_critSec);	TInfoMap::const_iterator d = watchInfoMap.find(hDir);	if (d != watchInfoMap.end())	{		CTGitPath root = CTGitPath(CTGitPath(d->second->m_DirPath).GetRootPathString());		RemovePathAndChildren(root);		BlockPath(root);	}	CloseWatchHandles();	CTGitPath path;	if (watchInfoMap.empty())		return path;	for (TInfoMap::iterator I = watchInfoMap.begin(); I != watchInfoMap.end(); ++I)	{		CDirectoryWatcher::CDirWatchInfo * info = I->second;		ScheduleForDeletion (info);	}	watchInfoMap.clear();	return path;}

CTGitPath CTempFiles::CreateTempPath (bool bRemoveAtEnd, const CTGitPath& path, bool directory){	bool succeeded = false;	for (int retryCount = 0; retryCount < MAX_RETRIES; ++retryCount)	{		CTGitPath tempfile = ConstructTempPath (path);		// now create the temp file / directory, so that subsequent calls to GetTempFile() return		// different filenames.		// Handle races, i.e. name collisions.		if (directory)		{			DeleteFile(tempfile.GetWinPath());			if (CreateDirectory(tempfile.GetWinPath(), nullptr) == FALSE)			{				if (GetLastError() != ERROR_ALREADY_EXISTS)					return CTGitPath();			}			else				succeeded = true;		}		else		{			CAutoFile hFile = CreateFile(tempfile.GetWinPath(), GENERIC_READ, FILE_SHARE_READ, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, nullptr);			if (!hFile)			{				if (GetLastError() != ERROR_ALREADY_EXISTS)					return CTGitPath();			}			else			{				succeeded = true;			}		}		// done?		if (succeeded)		{			if (bRemoveAtEnd)				m_TempFileList.AddPath(tempfile);			return tempfile;		}	}	// give up	return CTGitPath();}

void CRequestPullDlg::OnBnClickedButtonLocalBranch(){	// use the git log to allow selection of a version	CLogDlg dlg;	CString revision;	m_cStartRevision.GetWindowText(revision);	dlg.SetParams(CTGitPath(), CTGitPath(), revision, revision, 0);	// tell the dialog to use mode for selecting revisions	dlg.SetSelect(true);	// only one revision must be selected however	dlg.SingleSelection(true);	if ( dlg.DoModal() == IDOK )		m_cStartRevision.SetWindowText(dlg.GetSelectedHash().at(0).ToString());}

void CSetHooks::OnBnClickedEditbutton(){	if (m_cHookList.GetSelectedCount() > 1)		return;	POSITION pos = m_cHookList.GetFirstSelectedItemPosition();	if (pos)	{		CSetHooksAdv dlg;		int index = m_cHookList.GetNextSelectedItem(pos);		dlg.key.htype = CHooks::GetHookType((LPCTSTR)m_cHookList.GetItemText(index, 0));		dlg.key.path = CTGitPath(m_cHookList.GetItemText(index, 1));		dlg.cmd.commandline = m_cHookList.GetItemText(index, 2);		dlg.cmd.bWait = (m_cHookList.GetItemText(index, 3).Compare(_T("true"))==0);		dlg.cmd.bShow = (m_cHookList.GetItemText(index, 4).Compare(_T("show"))==0);		hookkey key = dlg.key;		if (dlg.DoModal() == IDOK)		{			CHooks::Instance().Remove(key);			CHooks::Instance().Add(dlg.key.htype, dlg.key.path, dlg.cmd.commandline, dlg.cmd.bWait, dlg.cmd.bShow);			RebuildHookList();			SetModified();		}	}}

bool CLogFile::Open(){	if (m_maxlines == 0)		return false;	CTGitPath logfile = CTGitPath(CPathUtils::GetLocalAppDataDirectory() + _T("logfile.txt"));	return Open(logfile);}

int CSendMailPatch::SendAsCombinedMail(CTGitPathList &list, CGitProgressList * instance){	ASSERT(instance);	CStringArray attachments;	CString body;	for (int i = 0; i < list.GetCount(); ++i)	{		CPatch patch;		if (patch.Parse((CString &)list[i].GetWinPathString()))		{			instance->ReportError(_T("Could not open/parse ") + list[i].GetWinPathString());			return -2;		}		if (m_bAttachment)		{			attachments.Add(list[i].GetWinPathString());			body += patch.m_Subject;			body += _T("/r/n");		}		else		{			try			{				g_Git.StringAppend(&body, (BYTE*)patch.m_Body.GetBuffer(), CP_UTF8, patch.m_Body.GetLength());			}			catch (CMemoryException *)			{				instance->ReportError(_T("Out of memory. Could not parse ") + list[i].GetWinPathString());				return -2;			}		}	}	return SendMail(CTGitPath(), instance, m_sSenderName, m_sSenderMail, m_sTo, m_sCC, m_sSubject, body, attachments);}

/** * Returns the .git-path (if .git is a file, read the repository path and return it) * adminDir always ends with "/" */bool GitAdminDir::GetAdminDirPath(const CString &projectTopDir, CString& adminDir){	if (IsBareRepo(projectTopDir))	{		adminDir = projectTopDir;		adminDir.TrimRight('//');		adminDir.Append(_T("//"));		return true;	}	CString sDotGitPath = projectTopDir + _T("//") + GetAdminDirName();	if (CTGitPath(sDotGitPath).IsDirectory())	{		sDotGitPath.TrimRight('//');		sDotGitPath.Append(_T("//"));		adminDir = sDotGitPath;		return true;	}	else	{		CString result = ReadGitLink(projectTopDir, sDotGitPath);		if (result.IsEmpty())			return false;		adminDir = result + _T("//");		return true;	}}

int CSendMailCombineable::SendAsCombinedMail(const CTGitPathList &list, CGitProgressList* instance){	ASSERT(instance);	CStringArray attachments;	CString body;	for (int i = 0; i < list.GetCount(); ++i)	{		if (m_bAttachment)		{			attachments.Add(list[i].GetWinPathString());		}		else		{			CString filename(list[i].GetWinPathString());			body += filename + _T(":/n");			if (GetFileContents(filename, body))			{				instance->ReportError(_T("Could not open ") + filename);				return -2;			}			body += _T("/n");		}	}	return SendMail(CTGitPath(), instance, m_sSenderName, m_sSenderMail, m_sTo, m_sCC, m_sSubject, body, attachments);}

BOOL CSubmoduleUpdateDlg::OnInitDialog(){    CStandAloneDialog::OnInitDialog();    CAppUtils::MarkWindowAsUnpinnable(m_hWnd);    CString sWindowTitle;    GetWindowText(sWindowTitle);    CString dir = g_Git.m_CurrentDir;    if (m_PathFilterList.size() > 0)        dir += (g_Git.m_CurrentDir.Right(1) == _T('//') ? _T("") : _T("//")) + CTGitPath(m_PathFilterList[0]).GetWinPathString();    if (m_PathFilterList.size() > 1)        dir += _T(", ...");    CAppUtils::SetWindowTitle(m_hWnd, dir, sWindowTitle);    AdjustControlSize(IDC_CHECK_SUBMODULE_INIT);    AdjustControlSize(IDC_CHECK_SUBMODULE_RECURSIVE);    AdjustControlSize(IDC_CHECK_SUBMODULE_NOFETCH);    AdjustControlSize(IDC_CHECK_SUBMODULE_MERGE);    AdjustControlSize(IDC_CHECK_SUBMODULE_REBASE);    Refresh();    UpdateData(FALSE);    return TRUE;}

void CSetHooksAdv::OnOK(){	UpdateData();	int cursel = m_cHookTypeCombo.GetCurSel();	key.htype = unknown_hook;	if (cursel != CB_ERR)	{		key.htype = (hooktype)m_cHookTypeCombo.GetItemData(cursel);		key.path = CTGitPath(m_sPath);		cmd.commandline = m_sCommandLine;		cmd.bWait = !!m_bWait;		cmd.bShow = !m_bHide;	}	if (key.htype == unknown_hook)	{		m_tooltips.ShowBalloon(IDC_HOOKTYPECOMBO, IDS_ERR_NOHOOKTYPESPECIFIED, IDS_ERR_ERROR, TTI_ERROR);		return;	}	if (key.path.IsEmpty())	{		ShowEditBalloon(IDC_HOOKPATH, IDS_ERR_NOHOOKPATHSPECIFIED, IDS_ERR_ERROR, TTI_ERROR);		return;	}	if (cmd.commandline.IsEmpty())	{		ShowEditBalloon(IDC_HOOKCOMMANDLINE, IDS_ERR_NOHOOKCOMMANDPECIFIED, IDS_ERR_ERROR, TTI_ERROR);		return;	}	CResizableStandAloneDialog::OnOK();}

const_hookiterator CHooks::FindItem(hooktype t, const CString& workingTree) const{	hookkey key;	CTGitPath path = workingTree;	do	{		key.htype = t;		key.path = path;		auto it = find(key);		if (it != end())		{			return it;		}		path = path.GetContainingDirectory();	} while(!path.IsEmpty());	// look for a script with a path as '*'	key.htype = t;	key.path = CTGitPath(_T("*"));	auto it = find(key);	if (it != end())	{		return it;	}	return end();}

void CRepositoryBrowser::OnBnClickedButtonRevision(){		// use the git log to allow selection of a version		CLogDlg dlg;		dlg.SetParams(CTGitPath(), CTGitPath(), m_sRevision, m_sRevision, 0);		// tell the dialog to use mode for selecting revisions		dlg.SetSelect(true);		// only one revision must be selected however		dlg.SingleSelection(true);		if (dlg.DoModal() == IDOK)		{			// get selected hash if any			m_sRevision = dlg.GetSelectedHash();			Refresh();		}}

hookiterator CHooks::FindItem(hooktype t, const CTGitPathList& pathList){	hookkey key;	for (int i=0; i<pathList.GetCount(); ++i)	{		CTGitPath path = pathList[i];		do 		{			key.htype = t;			key.path = path;			hookiterator it = find(key);			if (it != end())			{				return it;			}			path = path.GetContainingDirectory();		} while(!path.IsEmpty());	}	// look for a script with a path as '*'	key.htype = t;	key.path = CTGitPath(_T("*"));	hookiterator it = find(key);	if (it != end())	{		return it;	}	return end();}

void CSyncDlg::RunPostAction(){	if (m_bWantToExit)		return;	FillNewRefMap();	if (this->m_CurrentCmd == GIT_COMMAND_PUSH)	{		if (!m_GitCmdStatus)		{			CTGitPathList list;			list.AddPath(CTGitPath(g_Git.m_CurrentDir));			DWORD exitcode;			CString error;			if (CHooks::Instance().PostPush(list,exitcode, error))			{				if (exitcode)				{					CString temp;					temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);					//ReportError(temp);					CMessageBox::Show(NULL,temp,_T("TortoiseGit"),MB_OK|MB_ICONERROR);					return;				}			}		}		EnableControlButton(true);		SwitchToInput();		this->FetchOutList(true);	}	else if (this->m_CurrentCmd == GIT_COMMAND_PULL)	{		PullComplete();	}	else if (this->m_CurrentCmd == GIT_COMMAND_FETCH || this->m_CurrentCmd == GIT_COMMAND_FETCHANDREBASE)	{		FetchComplete();	}	else if (this->m_CurrentCmd == GIT_COMMAND_SUBMODULE)	{		//this->m_ctrlCmdOut.SetSel(-1,-1);		//this->m_ctrlCmdOut.ReplaceSel(_T("Done/r/n"));		//this->m_ctrlCmdOut.SetSel(-1,-1);		EnableControlButton(true);		SwitchToInput();	}	else if (this->m_CurrentCmd == GIT_COMMAND_STASH)	{		StashComplete();	}	else if (this->m_CurrentCmd == GIT_COMMAND_REMOTE)	{		this->FetchOutList(true);		EnableControlButton(true);		SwitchToInput();		ShowTab(IDC_REFLIST);	}}

void CGitBlameLogList::GetPaths(const CGitHash& hash, std::vector<CTGitPath>& paths){	CTortoiseGitBlameView *pView = DYNAMIC_DOWNCAST(CTortoiseGitBlameView,((CMainFrame*)::AfxGetApp()->GetMainWnd())->GetActiveView());	if (pView)	{		{			std::set<CString> filenames;			int numberOfLines = pView->m_data.GetNumberOfLines();			for (int i = 0; i < numberOfLines; ++i)			{				if (pView->m_data.GetHash(i) == hash)				{					filenames.insert(pView->m_data.GetFilename(i));				}			}			for (auto it = filenames.cbegin(); it != filenames.cend(); ++it)			{				paths.push_back(CTGitPath(*it));			}		}		if (paths.empty())		{			// in case the hash does not exist in the blame output but it exists in the log follow only the file			paths.push_back(pView->GetDocument()->m_GitPath);		}	}}

const FileStatusCacheEntry * GitFolderStatus::GetCachedItem(const CTGitPath& filepath){	sCacheKey.assign(filepath.GetWinPath());	FileStatusMap::const_iterator iter;	const FileStatusCacheEntry *retVal;	if(m_mostRecentPath.IsEquivalentTo(CTGitPath(sCacheKey.c_str())))	{		// We've hit the same result as we were asked for last time		CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": fast cache hit for %s/n"), filepath.GetWinPath());		retVal = m_mostRecentStatus;	}	else if ((iter = m_cache.find(sCacheKey)) != m_cache.end())	{		CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": cache found for %s/n"), filepath.GetWinPath());		retVal = &iter->second;		m_mostRecentStatus = retVal;		m_mostRecentPath = CTGitPath(sCacheKey.c_str());	}	else	{		retVal = NULL;	}	if(retVal != NULL)	{		// We found something in a cache - check that the cache is not timed-out or force-invalidated		DWORD now = GetTickCount();		if ((now >= m_TimeStamp)&&((now - m_TimeStamp) > GetTimeoutValue()))		{			// Cache is timed-out			CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Cache timed-out/n");			ClearCache();			retVal = NULL;		}		else if(WaitForSingleObject(m_hInvalidationEvent, 0) == WAIT_OBJECT_0)		{			// TortoiseGitProc has just done something which has invalidated the cache			CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Cache invalidated/n");			ClearCache();			retVal = NULL;		}		return retVal;	}	return NULL;}

void CFormatPatchDlg::OnBnClickedButtonTo(){	CLogDlg dlg;	CString revision;	m_cTo.GetWindowText(revision);	dlg.SetParams(CTGitPath(), CTGitPath(), revision, revision, 0);	// tell the dialog to use mode for selecting revisions	dlg.SetSelect(true);	// only one revision must be selected however	dlg.SingleSelection(true);	if (dlg.DoModal() == IDOK && !dlg.GetSelectedHash().empty())	{		m_cTo.AddString(dlg.GetSelectedHash().at(0).ToString());		CheckRadioButton(IDC_RADIO_SINCE, IDC_RADIO_RANGE, IDC_RADIO_RANGE);		OnBnClickedRadio();	}}

CGitStatusCache::CGitStatusCache(void){#define forever DWORD(-1)    AutoLocker lock(m_NoWatchPathCritSec);    TCHAR path[MAX_PATH];    SHGetFolderPath(NULL, CSIDL_COOKIES, NULL, 0, path);    m_NoWatchPaths[CTGitPath(CString(path))] = forever;    SHGetFolderPath(NULL, CSIDL_HISTORY, NULL, 0, path);    m_NoWatchPaths[CTGitPath(CString(path))] = forever;    SHGetFolderPath(NULL, CSIDL_INTERNET_CACHE, NULL, 0, path);    m_NoWatchPaths[CTGitPath(CString(path))] = forever;    SHGetFolderPath(NULL, CSIDL_SYSTEM, NULL, 0, path);    m_NoWatchPaths[CTGitPath(CString(path))] = forever;    SHGetFolderPath(NULL, CSIDL_WINDOWS, NULL, 0, path);    m_NoWatchPaths[CTGitPath(CString(path))] = forever;    m_bClearMemory = false;    m_mostRecentExpiresAt = 0;}

git_error_t* GitFolderStatus::findfolderstatus(void * baton, const char * path, git_wc_status2_t * status, apr_pool_t * /*pool*/){    GitFolderStatus * Stat = (GitFolderStatus *)baton;    if ((Stat)&&(Stat->folderpath.IsEquivalentTo(CTGitPath(CString(path)))))    {        Stat->dirstatus = status;    }    return GIT_NO_ERROR;}

void CRequestPullDlg::OnBnClickedButtonLocalBranch(){	// use the git log to allow selection of a version	CLogDlg dlg;	CString revision;	m_cStartRevision.GetWindowText(revision);	dlg.SetParams(CTGitPath(), CTGitPath(), revision, revision, 0);	// tell the dialog to use mode for selecting revisions	dlg.SetSelect(true);	// only one revision must be selected however	dlg.SingleSelection(true);	if ( dlg.DoModal() == IDOK )	{		// get selected hash if any		CString selectedHash = dlg.GetSelectedHash();		// load into window, do this even if empty so that it is clear that nothing has been selected		m_cStartRevision.SetWindowText( selectedHash );	}}

void CSubmoduleUpdateDlg::SetDlgTitle(){	if (m_sTitle.IsEmpty())		GetWindowText(m_sTitle);	CString dir = g_Git.m_CurrentDir;	if (!m_bWholeProject)	{		if (!m_PathFilterList.empty())			dir += (CStringUtils::EndsWith(g_Git.m_CurrentDir, L'//') ? L"" : L"//") + CTGitPath(m_PathFilterList[0]).GetWinPathString();		if (m_PathFilterList.size() > 1)			dir += L", ...";	}	CAppUtils::SetWindowTitle(m_hWnd, dir, m_sTitle);}

/** * Returns the .git-path (if .git is a file, read the repository path and return it) * adminDir always ends with "/" */bool GitAdminDir::GetAdminDirPath(const CString &projectTopDir, CString &adminDir) const{	if (IsBareRepo(projectTopDir))	{		adminDir = projectTopDir;		adminDir.TrimRight('//');		adminDir.Append(_T("//"));		return true;	}	CString sDotGitPath = projectTopDir + _T("//") + g_GitAdminDir.GetAdminDirName();	if (CTGitPath(sDotGitPath).IsDirectory())	{		sDotGitPath.TrimRight('//');		sDotGitPath.Append(_T("//"));		adminDir = sDotGitPath;		return true;	}	else	{		FILE *pFile;		_tfopen_s(&pFile, sDotGitPath, _T("r"));		if (!pFile)			return false;		int size = 65536;		std::unique_ptr<char[]> buffer(new char[size]);		SecureZeroMemory(buffer.get(), size);		fread(buffer.get(), sizeof(char), size, pFile);		fclose(pFile);		CStringA gitPathA(buffer.get());		if (gitPathA.Left(8) != "gitdir: ")			return false;		CString gitPath = CUnicodeUtils::GetUnicode(gitPathA.Trim().Mid(8)); // 8 = len("gitdir: ")		gitPath.Replace('/', '//');		gitPath.TrimRight('//');		gitPath.Append(_T("//"));		if (gitPath.GetLength() > 0 && gitPath[0] == _T('.'))		{			gitPath = projectTopDir + _T("//") + gitPath;			PathCanonicalize(adminDir.GetBuffer(MAX_PATH), gitPath.GetBuffer());			adminDir.ReleaseBuffer();			gitPath.ReleaseBuffer();			return true;		}		adminDir = gitPath;		return true;	}}

void CTGitPathList::LoadFromAsteriskSeparatedString(const CString& sPathString){	int pos = 0;	CString temp;	for(;;)	{		temp = sPathString.Tokenize(_T("*"),pos);		if(temp.IsEmpty())		{			break;		}		AddPath(CTGitPath(CPathUtils::GetLongPathname(temp)));	}}

void CSubmoduleUpdateDlg::SetDlgTitle(){	if (m_sTitle.IsEmpty())		GetWindowText(m_sTitle);	CString dir = g_Git.m_CurrentDir;	if (!m_bWholeProject)	{		if (!m_PathFilterList.empty())			dir += (g_Git.m_CurrentDir.Right(1) == _T('//') ? _T("") : _T("//")) + CTGitPath(m_PathFilterList[0]).GetWinPathString();		if (m_PathFilterList.size() > 1)			dir += _T(", ...");	}	CAppUtils::SetWindowTitle(m_hWnd, dir, m_sTitle);}

void CSetBugTraq::OnBnClickedRemovebutton(){	// traversing from the end to the beginning so that the indices are not skipped	int index = m_cBugTraqList.GetItemCount()-1;	while (index >= 0)	{		if (m_cBugTraqList.GetItemState(index, LVIS_SELECTED) & LVIS_SELECTED)		{			CTGitPath path = CTGitPath(m_cBugTraqList.GetItemText(index, 0));			m_cBugTraqList.DeleteItem(index);			m_associations.RemoveByPath(path);			SetModified();		}		index--;	}}

//this is the thread function which calls the subversion functionUINT CCacheDlg::TestThread(){	CDirFileEnum direnum(m_sRootPath);	m_filelist.RemoveAll();	CString filepath;	bool bIsDir = false;	while (direnum.NextFile(filepath, &bIsDir))		if (filepath.Find(L".git") < 0)			m_filelist.Add(filepath);	CTime starttime = CTime::GetCurrentTime();	GetDlgItem(IDC_STARTTIME)->SetWindowText(starttime.Format(L"%H:%M:%S"));	ULONGLONG startticks = GetTickCount64();	CString sNumber;	std::random_device rd;	std::mt19937 mt(rd());	std::uniform_int_distribution<INT_PTR> dist(0, max(0, m_filelist.GetCount() - 1));	std::uniform_int_distribution<INT_PTR> dist2(0, 9);	for (int i=0; i < 1; ++i)	{		CString filepath2;		//do {			filepath2 = m_filelist.GetAt(dist(mt));		//}while(filepath.Find(L".git") >= 0);		GetDlgItem(IDC_FILEPATH)->SetWindowText(filepath2);		GetStatusFromRemoteCache(CTGitPath(filepath2), true);		sNumber.Format(L"%d", i);		GetDlgItem(IDC_DONE)->SetWindowText(sNumber);		if ((GetTickCount64()%10)==1)			Sleep(10);		if (dist2(mt) == 3)			RemoveFromCache(filepath2);	}	CTime endtime = CTime::GetCurrentTime();	CString sEnd = endtime.Format(L"%H:%M:%S");	ULONGLONG endticks = GetTickCount64();	CString sEndText;	sEndText.Format(L"%s  - %I64u ms", (LPCTSTR)sEnd, endticks - startticks);	GetDlgItem(IDC_ENDTIME)->SetWindowText(sEndText);	return 0;}

//this is the thread function which calls the subversion functionUINT CCacheDlg::TestThread(){	CDirFileEnum direnum(m_sRootPath);	m_filelist.RemoveAll();	CString filepath;	bool bIsDir = false;	while (direnum.NextFile(filepath, &bIsDir))		if(filepath.Find(_T(".git"))<0)			m_filelist.Add(filepath);	CTime starttime = CTime::GetCurrentTime();	GetDlgItem(IDC_STARTTIME)->SetWindowText(starttime.Format(_T("%H:%M:%S")));	int filecounter = 0;	DWORD startticks = GetTickCount();	CString sNumber;	srand(GetTickCount());	for (int i=0; i < 1; ++i)	{		CString filepath;		//do {			filepath = m_filelist.GetAt(rand() % m_filelist.GetCount());		//}while(filepath.Find(_T(".git"))>=0);		GetDlgItem(IDC_FILEPATH)->SetWindowText(filepath);		GetStatusFromRemoteCache(CTGitPath(filepath), true);		sNumber.Format(_T("%d"), i);		GetDlgItem(IDC_DONE)->SetWindowText(sNumber);		if ((GetTickCount()%10)==1)			Sleep(10);		if ((rand()%10)==3)			RemoveFromCache(filepath);	}	CTime endtime = CTime::GetCurrentTime();	CString sEnd = endtime.Format(_T("%H:%M:%S"));	DWORD endticks = GetTickCount();	CString sEndText;	sEndText.Format(_T("%s  - %d ms"), sEnd, endticks-startticks);	GetDlgItem(IDC_ENDTIME)->SetWindowText(sEndText);	return 0;}