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;
}
bool FormatPatchCommand::Execute()
{
CFormatPatchDlg dlg;
// dlg.m_bIsTag=TRUE;
CString startval = parser.GetVal(L"startrev");
CString endval = parser.GetVal(L"endrev");
if( endval.IsEmpty() && (!startval.IsEmpty()))
{
dlg.m_Since=startval;
dlg.m_Radio = IDC_RADIO_SINCE;
}
else if( (!endval.IsEmpty()) && (!startval.IsEmpty()))
{
dlg.m_From=startval;
dlg.m_To=endval;
dlg.m_Radio = IDC_RADIO_RANGE;
}
if(dlg.DoModal()==IDOK)
{
CString cmd;
CString range;
switch(dlg.m_Radio)
{
case IDC_RADIO_SINCE:
range=g_Git.FixBranchName(dlg.m_Since);
break;
case IDC_RADIO_NUM:
range.Format(L"-%d", dlg.m_Num);
break;
case IDC_RADIO_RANGE:
range.Format(L"%s..%s", (LPCTSTR)dlg.m_From, (LPCTSTR)dlg.m_To);
break;
}
dlg.m_Dir.Replace(L'\\', L'/');
cmd.Format(L"git.exe format-patch%s -o \"%s\" %s",
dlg.m_bNoPrefix ? L" --no-prefix" : L"",
(LPCTSTR)dlg.m_Dir,
(LPCTSTR)range
);
CProgressDlg progress;
progress.m_GitCmd=cmd;
progress.DoModal();
CShellUpdater::Instance().AddPathForUpdate(CTGitPath(dlg.m_Dir));
CShellUpdater::Instance().Flush();
if(!progress.m_GitStatus)
{
if(dlg.m_bSendMail)
CAppUtils::SendPatchMail(cmd, progress.m_LogText, true);
}
return !progress.m_GitStatus;
}
return FALSE;
}
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 );
}
}
// ICopyHook member
UINT __stdcall CShellExt::CopyCallback(HWND /*hWnd*/, UINT wFunc, UINT /*wFlags*/, LPCTSTR pszSrcFile, DWORD /*dwSrcAttribs*/, LPCTSTR /*pszDestFile*/, DWORD /*dwDestAttribs*/)
{
if (wFunc == FO_COPY)
return IDYES; // copying is not a problem for us
m_remoteCacheLink.ReleaseLockForPath(CTGitPath(pszSrcFile));
// we could now wait a little bit to give the cache time to release the handles.
// but the explorer/shell already retries any action for about two seconds
// if it first fails. So if the cache hasn't released the handle yet, the explorer
// will retry anyway, so we just leave here immediately.
return IDYES;
}
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 function
UINT 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 function
UINT 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;
}
