CString CTreeConflictEditorDlg::GetShowLogCmd(const CTSVNPath &logPath, const CString &sFile)
{
CString sFilter;
if (!sFile.IsEmpty())
sFilter.Format(L"/findstring:\"%s\" /findtype:2 /findtext", (LPCTSTR)sFile);
CString sCmd;
sCmd.Format(L"/command:log /path:\"%s\" /pegrev:%ld %s",
(LPCTSTR)logPath.GetSVNPathString(),
(svn_revnum_t)src_left_version_rev,
(LPCTSTR)sFilter);
return sCmd;
}
bool SVNDiff::ShowCompare( const CTSVNPath& url1, const SVNRev& rev1, const CTSVNPath& url2, const SVNRev& rev2, SVNRev peg, bool ignoreprops, const CString& options, bool ignoreancestry /*= false*/, bool blame /*= false*/, svn_node_kind_t nodekind /*= svn_node_unknown*/ )
{
CTSVNPath tempfile;
CString mimetype;
CProgressDlg progDlg;
progDlg.SetTitle(IDS_APPNAME);
progDlg.SetTime(false);
m_pSVN->SetAndClearProgressInfo(&progDlg);
CAppUtils::DiffFlags diffFlags;
diffFlags.ReadOnly().AlternativeTool(m_bAlternativeTool);
if ((m_pSVN->PathIsURL(url1))||(!rev1.IsWorking())||(!url1.IsEquivalentTo(url2)))
{
// no working copy path!
progDlg.ShowModeless(GetHWND());
tempfile = CTempFiles::Instance().GetTempFilePath(false, url1);
// first find out if the url points to a file or dir
CString sRepoRoot;
if ((nodekind != svn_node_dir)&&(nodekind != svn_node_file))
{
progDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROGRESS_INFO)));
SVNInfo info;
const SVNInfoData * data = info.GetFirstFileInfo(url1, (peg.IsValid() ? peg : m_headPeg), rev1, svn_depth_empty);
if (data == NULL)
{
data = info.GetFirstFileInfo(url1, (peg.IsValid() ? peg : rev1), rev1, svn_depth_empty);
if (data == NULL)
{
data = info.GetFirstFileInfo(url1, (peg.IsValid() ? peg : rev2), rev1, svn_depth_empty);
if (data == NULL)
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
info.ShowErrorDialog(GetHWND());
return false;
}
else
{
sRepoRoot = data->reposRoot;
nodekind = data->kind;
peg = peg.IsValid() ? peg : rev2;
}
}
else
{
sRepoRoot = data->reposRoot;
nodekind = data->kind;
peg = peg.IsValid() ? peg : rev1;
}
}
else
{
sRepoRoot = data->reposRoot;
nodekind = data->kind;
peg = peg.IsValid() ? peg : m_headPeg;
}
}
else
{
sRepoRoot = m_pSVN->GetRepositoryRoot(url1);
peg = peg.IsValid() ? peg : m_headPeg;
}
if (nodekind == svn_node_dir)
{
if (rev1.IsWorking())
{
if (UnifiedDiff(tempfile, url1, rev1, url2, rev2, (peg.IsValid() ? peg : SVNRev::REV_WC), options))
{
CString sWC;
sWC.LoadString(IDS_DIFF_WORKINGCOPY);
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
return !!CAppUtils::StartExtPatch(tempfile, url1.GetDirectory(), sWC, url2.GetSVNPathString(), TRUE);
}
}
else
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
CFileDiffDlg fdlg;
fdlg.DoBlame(blame);
if (url1.IsEquivalentTo(url2))
{
fdlg.SetDiff(url1, (peg.IsValid() ? peg : m_headPeg), rev1, rev2, svn_depth_infinity, ignoreancestry);
fdlg.DoModal();
}
else
{
fdlg.SetDiff(url1, rev1, url2, rev2, svn_depth_infinity, ignoreancestry);
fdlg.DoModal();
}
}
}
else
{
if (url1.IsEquivalentTo(url2) && !ignoreprops)
{
svn_revnum_t baseRev = 0;
DiffProps(url1, rev2, rev1, baseRev);
}
// diffing two revs of a file, so export two files
CTSVNPath tempfile1 = CTempFiles::Instance().GetTempFilePath(m_bRemoveTempFiles, blame ? CTSVNPath() : url1, rev1);
CTSVNPath tempfile2 = CTempFiles::Instance().GetTempFilePath(m_bRemoveTempFiles, blame ? CTSVNPath() : url2, rev2);
m_pSVN->SetAndClearProgressInfo(&progDlg, true); // activate progress bar
progDlg.FormatPathLine(1, IDS_PROGRESSGETFILEREVISION, (LPCTSTR)url1.GetUIFileOrDirectoryName(), (LPCTSTR)rev1.ToString());
CAppUtils::GetMimeType(url1, mimetype, rev1);
CBlame blamer;
blamer.SetAndClearProgressInfo(&progDlg, true);
if (blame)
{
if (!blamer.BlameToFile(url1, 1, rev1, peg.IsValid() ? peg : rev1, tempfile1, options, TRUE, TRUE))
{
if ((peg.IsValid())&&(blamer.GetSVNError()->apr_err != SVN_ERR_CLIENT_IS_BINARY_FILE))
{
if (!blamer.BlameToFile(url1, 1, rev1, rev1, tempfile1, options, TRUE, TRUE))
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
blamer.ShowErrorDialog(GetHWND());
return false;
}
}
else
{
if (blamer.GetSVNError()->apr_err != SVN_ERR_CLIENT_IS_BINARY_FILE)
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
}
blamer.ShowErrorDialog(GetHWND());
if (blamer.GetSVNError()->apr_err == SVN_ERR_CLIENT_IS_BINARY_FILE)
blame = false;
else
return false;
}
}
}
if (!blame)
{
bool tryWorking = (!m_pSVN->PathIsURL(url1) && rev1.IsWorking() && PathFileExists(url1.GetWinPath()));
if (!m_pSVN->Export(url1, tempfile1, peg.IsValid() && !tryWorking ? peg : rev1, rev1))
{
if (peg.IsValid())
{
if (!m_pSVN->Export(url1, tempfile1, rev1, rev1))
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
else
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
}
SetFileAttributes(tempfile1.GetWinPath(), FILE_ATTRIBUTE_READONLY);
progDlg.FormatPathLine(1, IDS_PROGRESSGETFILEREVISION, (LPCTSTR)url2.GetUIFileOrDirectoryName(), (LPCTSTR)rev2.ToString());
progDlg.SetProgress(50,100);
if (blame)
{
if (!blamer.BlameToFile(url2, 1, rev2, peg.IsValid() ? peg : rev2, tempfile2, options, TRUE, TRUE))
{
if (peg.IsValid())
{
if (!blamer.BlameToFile(url2, 1, rev2, rev2, tempfile2, options, TRUE, TRUE))
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
else
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
}
else
{
if (!m_pSVN->Export(url2, tempfile2, peg.IsValid() ? peg : rev2, rev2))
{
if (peg.IsValid())
{
if (!m_pSVN->Export(url2, tempfile2, rev2, rev2))
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
else
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
}
SetFileAttributes(tempfile2.GetWinPath(), FILE_ATTRIBUTE_READONLY);
progDlg.SetProgress(100,100);
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
CString revname1, revname2;
if (url1.IsEquivalentTo(url2))
{
revname1.Format(L"%s Revision %s", (LPCTSTR)url1.GetUIFileOrDirectoryName(), (LPCTSTR)rev1.ToString());
revname2.Format(L"%s Revision %s", (LPCTSTR)url2.GetUIFileOrDirectoryName(), (LPCTSTR)rev2.ToString());
}
else
{
if (sRepoRoot.IsEmpty())
{
revname1.Format(L"%s Revision %s", (LPCTSTR)url1.GetSVNPathString(), (LPCTSTR)rev1.ToString());
revname2.Format(L"%s Revision %s", (LPCTSTR)url2.GetSVNPathString(), (LPCTSTR)rev2.ToString());
}
else
{
if (url1.IsUrl())
revname1.Format(L"%s Revision %s", (LPCTSTR)url1.GetSVNPathString().Mid(sRepoRoot.GetLength()), (LPCTSTR)rev1.ToString());
else
revname1.Format(L"%s Revision %s", (LPCTSTR)url1.GetSVNPathString(), (LPCTSTR)rev1.ToString());
if (url2.IsUrl() && (url2.GetSVNPathString().Left(sRepoRoot.GetLength()).Compare(sRepoRoot) == 0))
revname2.Format(L"%s Revision %s", (LPCTSTR)url2.GetSVNPathString().Mid(sRepoRoot.GetLength()), (LPCTSTR)rev2.ToString());
else
revname2.Format(L"%s Revision %s", (LPCTSTR)url2.GetSVNPathString(), (LPCTSTR)rev2.ToString());
}
}
return CAppUtils::StartExtDiff(tempfile1, tempfile2, revname1, revname2, url1, url2, rev1, rev2, peg, diffFlags.Blame(blame), m_JumpLine, L"", mimetype);
}
}
else
{
// compare with working copy
if (PathIsDirectory(url1.GetWinPath()))
{
if (UnifiedDiff(tempfile, url1, rev1, url1, rev2, (peg.IsValid() ? peg : SVNRev::REV_WC), options))
{
CString sWC, sRev;
sWC.LoadString(IDS_DIFF_WORKINGCOPY);
sRev.Format(IDS_DIFF_REVISIONPATCHED, (LONG)rev2);
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
return !!CAppUtils::StartExtPatch(tempfile, url1.GetDirectory(), sWC, sRev, TRUE);
}
}
else
{
ASSERT(rev1.IsWorking());
if (url1.IsEquivalentTo(url2) && !ignoreprops)
{
svn_revnum_t baseRev = 0;
DiffProps(url1, rev1, rev2, baseRev);
}
m_pSVN->SetAndClearProgressInfo(&progDlg, true); // activate progress bar
progDlg.ShowModeless(GetHWND());
progDlg.FormatPathLine(1, IDS_PROGRESSGETFILEREVISION, (LPCTSTR)url1.GetUIFileOrDirectoryName(), (LPCTSTR)rev2.ToString());
tempfile = CTempFiles::Instance().GetTempFilePath(m_bRemoveTempFiles, url1, rev2);
if (blame)
{
CBlame blamer;
if (!blamer.BlameToFile(url1, 1, rev2, (peg.IsValid() ? peg : SVNRev::REV_WC), tempfile, options, TRUE, TRUE))
{
if (peg.IsValid())
{
if (!blamer.BlameToFile(url1, 1, rev2, SVNRev::REV_WC, tempfile, options, TRUE, TRUE))
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
else
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
SetFileAttributes(tempfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);
CTSVNPath tempfile2 = CTempFiles::Instance().GetTempFilePath(false, url1);
if (!blamer.BlameToFile(url1, 1, SVNRev::REV_WC, SVNRev::REV_WC, tempfile2, options, TRUE, TRUE))
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
CString revname, wcname;
revname.Format(L"%s Revision %ld", (LPCTSTR)url1.GetFilename(), (LONG)rev2);
wcname.Format(IDS_DIFF_WCNAME, (LPCTSTR)url1.GetFilename());
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
return CAppUtils::StartExtDiff(tempfile, tempfile2, revname, wcname, url1, url2, rev1, rev2, peg, diffFlags, m_JumpLine, url1.GetFileOrDirectoryName(), L"");
}
else
{
if (!m_pSVN->Export(url1, tempfile, (peg.IsValid() ? peg : SVNRev::REV_WC), rev2))
{
if (peg.IsValid())
{
if (!m_pSVN->Export(url1, tempfile, SVNRev::REV_WC, rev2))
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
else
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
}
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
SetFileAttributes(tempfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);
CString revname, wcname;
revname.Format(L"%s Revision %s", (LPCTSTR)url1.GetFilename(), (LPCTSTR)rev2.ToString());
wcname.Format(IDS_DIFF_WCNAME, (LPCTSTR)url1.GetFilename());
return CAppUtils::StartExtDiff(tempfile, url1, revname, wcname, url1, url1, rev2, rev1, peg, diffFlags, m_JumpLine, url1.GetFileOrDirectoryName(), L"");
}
}
}
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
return false;
}
bool CFullHistory::FetchRevisionData ( CString path
, SVNRev pegRev
, bool showWCRev
, bool showWCModification
, CProgressDlg* progress
, ITaskbarList3 * pTaskBarList
, HWND hWnd)
{
// clear any previously existing SVN error info
svn_error_clear(Err);
Err = NULL;
// remove internal data from previous runs
CFuture<bool> clearJob (this, &CFullHistory::ClearCopyInfo, &cpuLoadScheduler);
// set some text on the progress dialog, before we wait
// for the log operation to start
this->progress = progress;
this->taskbarlist = pTaskBarList;
this->hwnd = hWnd;
CString temp;
temp.LoadString (IDS_REVGRAPH_PROGGETREVS);
progress->SetLine(1, temp);
temp.LoadString (IDS_REVGRAPH_PROGPREPARING);
progress->SetLine(2, temp);
progress->SetProgress(0, 1);
progress->ShowModeless (hWnd);
if (taskbarlist)
{
taskbarlist->SetProgressState(hwnd, TBPF_INDETERMINATE);
}
// prepare the path for Subversion
CTSVNPath svnPath (path);
CStringA url = CPathUtils::PathEscape
(CUnicodeUtils::GetUTF8
(svn.GetURLFromPath (svnPath)));
// we have to get the log from the repository root
CTSVNPath rootPath;
svn_revnum_t head;
if (FALSE == svn.GetRootAndHead (svnPath, rootPath, head))
{
Err = svn_error_dup(const_cast<svn_error_t*>(svn.GetSVNError()));
return false;
}
if (pegRev.IsHead())
pegRev = head;
headRevision = head;
CString escapedRepoRoot = rootPath.GetSVNPathString();
relPath = CPathUtils::PathUnescape (url.Mid (escapedRepoRoot.GetLength()));
repoRoot = CPathUtils::PathUnescape (escapedRepoRoot);
// fix issue #360: use WC revision as peg revision
pegRevision = pegRev;
if (pegRevision == NO_REVISION)
{
if (!svnPath.IsUrl())
{
SVNInfo info;
const SVNInfoData * baseInfo
= info.GetFirstFileInfo (svnPath, SVNRev(), SVNRev());
if (baseInfo != NULL)
pegRevision = baseInfo->rev;
}
}
// fetch missing data from the repository
try
{
// select / construct query object and optimize revision range to fetch
svnQuery.reset (new CSVNLogQuery (ctx, pool));
bool cacheIsComplete = false;
if (svn.GetLogCachePool()->IsEnabled())
{
CLogCachePool* pool = svn.GetLogCachePool();
query.reset (new CCacheLogQuery (pool, svnQuery.get()));
// get the cache and the lowest missing revision
// (in off-line mode, the query may not find the cache as
// it cannot contact the server to get the UUID)
uuid = pool->GetRepositoryInfo().GetRepositoryUUID (rootPath);
cache = pool->GetCache (uuid, escapedRepoRoot);
firstRevision = cache != NULL
? cache->GetRevisions().GetFirstMissingRevision(1)
: 0;
// if the cache is already complete, the firstRevision here is
// HEAD+1 - that revision does not exist and would throw an error later
if (firstRevision > headRevision)
{
cacheIsComplete = true;
firstRevision = headRevision;
}
}
else
{
query.reset (new CCacheLogQuery (svn, svnQuery.get()));
cache = NULL;
firstRevision = 0;
}
// Find the revision the working copy is on, we mark that revision
// later in the graph (handle option changes properly!).
// For performance reasons, we only don't do it if we want to display it.
wcInfo = SWCInfo (pegRev);
if (showWCRev || showWCModification)
{
new CAsyncCall ( this
, &CFullHistory::QueryWCRevision
, true
, path
, &diskIOScheduler);
new CAsyncCall ( this
, &CFullHistory::QueryWCRevision
, false
, path
, &diskIOScheduler);
}
// actually fetch the data
if (!cacheIsComplete)
query->Log ( CTSVNPathList (rootPath)
, headRevision
, headRevision
, firstRevision
, 0
, false // strictNodeHistory
, this
, false // includeChanges (log cache fetches them automatically)
, false // includeMerges
, true // includeStandardRevProps
, false // includeUserRevProps
, TRevPropNames());
// Store updated cache data
if (cache == NULL)
{
cache = query->GetCache();
// This should never happen:
if (cache == NULL)
return false;
}
else
{
if (cache->IsModified())
new CAsyncCall ( cache
, &LogCache::CCachedLogInfo::Save
, &cpuLoadScheduler);
}
// store WC path
const CPathDictionary* paths = &cache->GetLogInfo().GetPaths();
wcPath.reset (new CDictionaryBasedTempPath (paths, (const char*)relPath));
// wait for the cleanup jobs to finish before starting new ones
// that depend of them
clearJob.GetResult();
// analyse the data
new CAsyncCall ( this
, &CFullHistory::AnalyzeRevisionData
, &cpuLoadScheduler);
// pre-process log data (invert copy-relationship)
new CAsyncCall ( this
, &CFullHistory::BuildForwardCopies
, &cpuLoadScheduler);
// Wait for the jobs to finish
if (showWCRev || showWCModification)
{
temp.LoadString (IDS_REVGRAPH_PROGREADINGWC);
progress->SetLine(2, temp);
}
cpuLoadScheduler.WaitForEmptyQueue();
diskIOScheduler.WaitForEmptyQueue();
}
catch (SVNError& e)
{
Err = svn_error_create (e.GetCode(), NULL, e.GetMessage());
return false;
}
return true;
}
