void CRevisionRangeDlg::OnOK()
{
if (!UpdateData(TRUE))
return; // don't dismiss dialog (error message already shown by MFC framework)
m_StartRev = SVNRev(m_sStartRevision);
if (GetCheckedRadioButton(IDC_NEWEST, IDC_REVISION_N) == IDC_NEWEST)
{
m_StartRev = SVNRev(_T("HEAD"));
m_sStartRevision = _T("HEAD");
}
if ((!m_StartRev.IsValid())||((!m_bAllowWCRevs)&&(m_StartRev.IsPrev() || m_StartRev.IsCommitted() || m_StartRev.IsBase())))
{
ShowBalloon(IDC_REVNUM, m_bAllowWCRevs ? IDS_ERR_INVALIDREV : IDS_ERR_INVALIDREVNOWC);
return;
}
m_EndRev = SVNRev(m_sEndRevision);
if (GetCheckedRadioButton(IDC_NEWEST2, IDC_REVISION_N2) == IDC_NEWEST2)
{
m_EndRev = SVNRev(_T("HEAD"));
m_sEndRevision = _T("HEAD");
}
if ((!m_EndRev.IsValid())||((!m_bAllowWCRevs)&&(m_EndRev.IsPrev() || m_EndRev.IsCommitted() || m_EndRev.IsBase())))
{
ShowBalloon(IDC_REVNUM2, m_bAllowWCRevs ? IDS_ERR_INVALIDREV : IDS_ERR_INVALIDREVNOWC);
return;
}
UpdateData(FALSE);
CStandAloneDialog::OnOK();
}
void CUpdateDlg::OnOK()
{
if (!UpdateData(TRUE))
return; // don't dismiss dialog (error message already shown by MFC framework)
if (::IsWindow(m_pLogDlg->GetSafeHwnd())&&(m_pLogDlg->IsWindowVisible()))
{
m_pLogDlg->SendMessage(WM_CLOSE);
return;
}
Revision = SVNRev(m_sRevision);
if (GetCheckedRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N) == IDC_REVISION_HEAD)
{
Revision = SVNRev(_T("HEAD"));
}
if (!Revision.IsValid())
{
ShowEditBalloon(IDC_REVNUM, IDS_ERR_INVALIDREV, IDS_ERR_ERROR, TTI_ERROR);
return;
}
switch (m_depthCombo.GetCurSel())
{
case 0:
m_depth = svn_depth_unknown;
m_checkoutDepths.clear();
break;
case 1:
m_depth = svn_depth_infinity;
m_checkoutDepths.clear();
break;
case 2:
m_depth = svn_depth_immediates;
m_checkoutDepths.clear();
break;
case 3:
m_depth = svn_depth_files;
m_checkoutDepths.clear();
break;
case 4:
m_depth = svn_depth_empty;
m_checkoutDepths.clear();
break;
case 5:
m_depth = svn_depth_exclude;
m_checkoutDepths.clear();
break;
default:
m_depth = svn_depth_empty;
break;
}
UpdateData(FALSE);
CStandAloneDialog::OnOK();
}
bool LogCommand::Execute()
{
//the log command line looks like this:
//command:log path:<path_to_file_or_directory_to_show_the_log_messages> [startrev:<startrevision>] [endrev:<endrevision>]
CString val = parser.GetVal(_T("startrev"));
if ( val.IsEmpty() )
{
// support deprecated parameter prior 1.5.0
val = parser.GetVal(_T("revstart"));
}
GitRev revstart ;
val = parser.GetVal(_T("endrev"));
if ( val.IsEmpty() )
{
// support deprecated parameter prior 1.5.0
val = parser.GetVal(_T("revend"));
}
GitRev revend ;
val = parser.GetVal(_T("limit"));
int limit = _tstoi(val);
val = parser.GetVal(_T("pegrev"));
if ( val.IsEmpty() )
{
// support deprecated parameter prior 1.5.0
val = parser.GetVal(_T("revpeg"));
}
GitRev pegrev;
#if 0
SVNRev pegrev = val.IsEmpty() ? SVNRev() : SVNRev(val);
if (!revstart.IsValid())
revstart = SVNRev::REV_HEAD;
if (!revend.IsValid())
revend = 0;
#endif
if (limit == 0)
{
CRegDWORD reg = CRegDWORD(_T("Software\\TortoiseGit\\NumberOfLogs"), 100);
limit = (int)(LONG)reg;
}
CLogDlg dlg;
theApp.m_pMainWnd = &dlg;
//dlg.SetParams(cmdLinePath);
dlg.SetParams(cmdLinePath, pegrev, revstart, revend, limit);
// dlg.SetIncludeMerge(!!parser.HasKey(_T("merge")));
// val = parser.GetVal(_T("propspath"));
// if (!val.IsEmpty())
// dlg.SetProjectPropertiesPath(CTSVNPath(val));
dlg.DoModal();
return true;
}
void CEditPropExternalsValue::OnOK()
{
UpdateData();
m_sWCPath.Trim(L"\"'");
if (!CTSVNPath(m_sWCPath).IsValidOnWindows())
{
ShowEditBalloon(IDC_CHECKOUTDIRECTORY, IDS_ERR_NOVALIDPATH, IDS_ERR_ERROR, TTI_ERROR);
return;
}
if (::IsWindow(m_pLogDlg->GetSafeHwnd())&&(m_pLogDlg->IsWindowVisible()))
{
m_pLogDlg->SendMessage(WM_CLOSE);
return;
}
if (GetCheckedRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N) == IDC_REVISION_HEAD)
{
m_External.revision.kind = svn_opt_revision_head;
m_sPegRev.Empty();
}
else
{
SVNRev rev = m_sRevision;
if (!rev.IsValid())
{
ShowEditBalloon(IDC_REVISION_N, IDS_ERR_INVALIDREV, IDS_ERR_ERROR, TTI_ERROR);
return;
}
m_External.revision = *rev;
}
m_URLCombo.SaveHistory();
m_URL = CTSVNPath(m_URLCombo.GetString());
m_External.url = CUnicodeUtils::GetUnicode(CPathUtils::PathEscape(CUnicodeUtils::GetUTF8(m_URL.GetSVNPathString())));
if (m_URL.GetSVNPathString().GetLength() && (m_URL.GetSVNPathString()[0] == '^'))
{
// the ^ char must not be escaped
m_External.url = CUnicodeUtils::GetUnicode(CPathUtils::PathEscape(CUnicodeUtils::GetUTF8(m_URL.GetSVNPathString().Mid(1))));
m_External.url = '^' + m_External.url;
}
if (m_sPegRev.IsEmpty())
m_External.pegrevision = *SVNRev(L"HEAD");
else
m_External.pegrevision = *SVNRev(m_sPegRev);
m_External.targetDir = m_sWCPath;
CResizableStandAloneDialog::OnOK();
}
BOOL CMergeWizardTree::CheckData(bool bShowErrors /* = true */)
{
if (!UpdateData(TRUE))
return FALSE;
StartRev = SVNRev(m_sStartRev);
EndRev = SVNRev(m_sEndRev);
if (GetCheckedRadioButton(IDC_REVISION_HEAD1, IDC_REVISION_N1) == IDC_REVISION_HEAD1)
{
StartRev = SVNRev(_T("HEAD"));
}
if (!StartRev.IsValid())
{
if (bShowErrors)
CBalloon::ShowBalloon(this, CBalloon::GetCtrlCentre(this, IDC_REVISION_START), IDS_ERR_INVALIDREV, TRUE, IDI_EXCLAMATION);
return FALSE;
}
// if head revision, set revision as -1
if (GetCheckedRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N) == IDC_REVISION_HEAD)
{
EndRev = SVNRev(_T("HEAD"));
}
if (!EndRev.IsValid())
{
if (bShowErrors)
CBalloon::ShowBalloon(this, CBalloon::GetCtrlCentre(this, IDC_REVISION_END), IDS_ERR_INVALIDREV, TRUE, IDI_EXCLAMATION);
return FALSE;
}
m_URLCombo.SaveHistory();
m_URLFrom = m_URLCombo.GetString();
m_URLCombo2.SaveHistory();
m_URLTo = m_URLCombo2.GetString();
((CMergeWizard*)GetParent())->URL1 = m_URLFrom;
((CMergeWizard*)GetParent())->URL2 = m_URLTo;
((CMergeWizard*)GetParent())->startRev = StartRev;
((CMergeWizard*)GetParent())->endRev = EndRev;
UpdateData(FALSE);
return TRUE;
}
bool DiffCommand::Execute()
{
bool bRet = false;
CString path2 = CPathUtils::GetLongPathname(parser.GetVal(_T("path2")));
bool bAlternativeTool = !!parser.HasKey(_T("alternative"));
bool bBlame = !!parser.HasKey(_T("blame"));
if (path2.IsEmpty())
{
SVNDiff diff(NULL, hwndExplorer);
diff.SetAlternativeTool(bAlternativeTool);
diff.SetJumpLine(parser.GetLongVal(_T("line")));
if ( parser.HasKey(_T("startrev")) && parser.HasKey(_T("endrev")) )
{
SVNRev StartRevision = SVNRev(parser.GetLongVal(_T("startrev")));
SVNRev EndRevision = SVNRev(parser.GetLongVal(_T("endrev")));
bRet = diff.ShowCompare(cmdLinePath, StartRevision, cmdLinePath, EndRevision, SVNRev(), false, bBlame);
}
else
{
svn_revnum_t baseRev = 0;
if (cmdLinePath.IsDirectory())
{
bRet = diff.DiffProps(cmdLinePath, SVNRev::REV_WC, SVNRev::REV_BASE, baseRev);
if (bRet == false)
{
CChangedDlg dlg;
dlg.m_pathList = CTSVNPathList(cmdLinePath);
dlg.DoModal();
bRet = true;
}
}
else
{
bRet = diff.DiffFileAgainstBase(cmdLinePath, baseRev);
}
}
}
else
bRet = CAppUtils::StartExtDiff(
CTSVNPath(path2), cmdLinePath, CString(), CString(),
CAppUtils::DiffFlags().AlternativeTool(bAlternativeTool), parser.GetLongVal(_T("line")));
return bRet;
}
void CSwitchDlg::OnBnClickedBrowse()
{
UpdateData();
SVNRev rev;
if (GetCheckedRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N) == IDC_REVISION_HEAD)
{
rev = SVNRev::REV_HEAD;
}
else
rev = SVNRev(m_rev);
if (!rev.IsValid())
rev = SVNRev::REV_HEAD;
CAppUtils::BrowseRepository(m_repoRoot, m_URLCombo, this, rev);
SetRevision(rev);
}
void CSwitchDlg::OnOK()
{
if (!UpdateData(TRUE))
return; // don't dismiss dialog (error message already shown by MFC framework)
// if head revision, set revision as HEAD
if (GetCheckedRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N) == IDC_REVISION_HEAD)
{
m_rev = _T("HEAD");
}
Revision = SVNRev(m_rev);
if (!Revision.IsValid())
{
ShowBalloon(IDC_REVISION_NUM, IDS_ERR_INVALIDREV);
return;
}
m_URLCombo.SaveHistory();
m_URL = CPathUtils::CombineUrls(m_repoRoot, m_URLCombo.GetString());
switch (m_depthCombo.GetCurSel())
{
case 0:
m_depth = svn_depth_unknown;
break;
case 1:
m_depth = svn_depth_infinity;
break;
case 2:
m_depth = svn_depth_immediates;
break;
case 3:
m_depth = svn_depth_files;
break;
case 4:
m_depth = svn_depth_empty;
break;
case 5:
m_depth = svn_depth_exclude;
break;
default:
m_depth = svn_depth_empty;
break;
}
UpdateData(FALSE);
CResizableStandAloneDialog::OnOK();
}
void CExportDlg::OnBnClickedBrowse()
{
m_tooltips.Pop(); // hide the tooltips
SVNRev rev;
UpdateData();
if (GetCheckedRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N) == IDC_REVISION_HEAD)
{
rev = SVNRev::REV_HEAD;
}
else
rev = SVNRev(m_sRevision);
if (!rev.IsValid())
rev = SVNRev::REV_HEAD;
CAppUtils::BrowseRepository(m_URLCombo, this, rev);
SetRevision(rev);
DialogEnableWindow(IDOK, !m_strExportDirectory.IsEmpty());
}
bool SVNDiff::DiffWCFile(const CTSVNPath& filePath,
bool ignoreprops,
svn_wc_status_kind status, /* = svn_wc_status_none */
svn_wc_status_kind text_status /* = svn_wc_status_none */,
svn_wc_status_kind prop_status /* = svn_wc_status_none */,
svn_wc_status_kind remotetext_status /* = svn_wc_status_none */,
svn_wc_status_kind remoteprop_status /* = svn_wc_status_none */)
{
CTSVNPath basePath;
CTSVNPath remotePath;
SVNRev remoteRev;
svn_revnum_t baseRev = 0;
// first diff the remote properties against the wc props
// TODO: should we attempt to do a three way diff with the properties too
// if they're modified locally and remotely?
if (!ignoreprops && (remoteprop_status > svn_wc_status_normal))
{
DiffProps(filePath, SVNRev::REV_HEAD, SVNRev::REV_WC, baseRev);
}
if (!ignoreprops && (prop_status > svn_wc_status_normal)&&(filePath.IsDirectory()))
{
DiffProps(filePath, SVNRev::REV_WC, SVNRev::REV_BASE, baseRev);
}
if (filePath.IsDirectory())
return true;
if ((status > svn_wc_status_normal) || (text_status > svn_wc_status_normal))
{
basePath = SVN::GetPristinePath(filePath);
if (baseRev == 0)
{
SVNStatus stat;
CTSVNPath dummy;
svn_client_status_t * s = stat.GetFirstFileStatus(filePath, dummy);
if (s)
baseRev = s->revision >= 0 ? s->revision : s->changed_rev;
}
// If necessary, convert the line-endings on the file before diffing
if ((DWORD)CRegDWORD(L"Software\\TortoiseSVN\\ConvertBase", TRUE))
{
CTSVNPath temporaryFile = CTempFiles::Instance().GetTempFilePath(m_bRemoveTempFiles, filePath, SVNRev::REV_BASE);
if (!m_pSVN->Export(filePath, temporaryFile, SVNRev(SVNRev::REV_BASE), SVNRev(SVNRev::REV_BASE)))
{
temporaryFile.Reset();
}
else
{
basePath = temporaryFile;
SetFileAttributes(basePath.GetWinPath(), FILE_ATTRIBUTE_READONLY);
}
}
}
if (remotetext_status > svn_wc_status_normal)
{
remotePath = CTempFiles::Instance().GetTempFilePath(false, filePath, SVNRev::REV_HEAD);
CProgressDlg progDlg;
progDlg.SetTitle(IDS_APPNAME);
progDlg.SetTime(false);
m_pSVN->SetAndClearProgressInfo(&progDlg, true); // activate progress bar
progDlg.ShowModeless(GetHWND());
progDlg.FormatPathLine(1, IDS_PROGRESSGETFILE, (LPCTSTR)filePath.GetUIFileOrDirectoryName());
remoteRev = SVNRev::REV_HEAD;
if (!m_pSVN->Export(filePath, remotePath, remoteRev, remoteRev))
{
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
m_pSVN->ShowErrorDialog(GetHWND());
return false;
}
progDlg.Stop();
m_pSVN->SetAndClearProgressInfo((HWND)NULL);
SetFileAttributes(remotePath.GetWinPath(), FILE_ATTRIBUTE_READONLY);
}
CString name = filePath.GetUIFileOrDirectoryName();
CString n1, n2, n3;
n1.Format(IDS_DIFF_WCNAME, (LPCTSTR)name);
if (baseRev)
n2.FormatMessage(IDS_DIFF_BASENAMEREV, (LPCTSTR)name, baseRev);
else
n2.Format(IDS_DIFF_BASENAME, (LPCTSTR)name);
n3.Format(IDS_DIFF_REMOTENAME, (LPCTSTR)name);
if ((text_status <= svn_wc_status_normal)&&(prop_status <= svn_wc_status_normal)&&(status <= svn_wc_status_normal))
{
// Hasn't changed locally - diff remote against WC
return CAppUtils::StartExtDiff(
filePath, remotePath, n1, n3, filePath, filePath, SVNRev::REV_WC, remoteRev, remoteRev, CAppUtils::DiffFlags().AlternativeTool(m_bAlternativeTool),
m_JumpLine, filePath.GetFileOrDirectoryName(), L"");
}
else if (remotePath.IsEmpty())
{
return DiffFileAgainstBase(filePath, baseRev, ignoreprops, status, text_status, prop_status);
}
else
{
// Three-way diff
CAppUtils::MergeFlags flags;
flags.bAlternativeTool = m_bAlternativeTool;
flags.bReadOnly = true;
return !!CAppUtils::StartExtMerge(flags,
basePath, remotePath, filePath, CTSVNPath(), false, n2, n3, n1, CString(), filePath.GetFileOrDirectoryName());
}
}
bool SVNDiff::DiffFileAgainstBase( const CTSVNPath& filePath, svn_revnum_t & baseRev, bool ignoreprops, svn_wc_status_kind status /*= svn_wc_status_none*/, svn_wc_status_kind text_status /*= svn_wc_status_none*/, svn_wc_status_kind prop_status /*= svn_wc_status_none*/ )
{
bool retvalue = false;
bool fileexternal = false;
if ((text_status == svn_wc_status_none)||(prop_status == svn_wc_status_none))
{
SVNStatus stat;
stat.GetStatus(filePath);
if (stat.status == NULL)
return false;
text_status = stat.status->text_status;
prop_status = stat.status->prop_status;
fileexternal = stat.status->file_external != 0;
}
if (!ignoreprops && (prop_status > svn_wc_status_normal))
{
DiffProps(filePath, SVNRev::REV_WC, SVNRev::REV_BASE, baseRev);
}
if (filePath.IsDirectory())
return true;
if ((status >= svn_wc_status_normal) || (text_status >= svn_wc_status_normal))
{
CTSVNPath basePath(SVN::GetPristinePath(filePath));
if (baseRev == 0)
{
SVNInfo info;
const SVNInfoData * infodata = info.GetFirstFileInfo(filePath, SVNRev(), SVNRev());
if (infodata)
{
if (infodata->copyfromurl && infodata->copyfromurl[0])
baseRev = infodata->copyfromrev;
else
baseRev = infodata->lastchangedrev;
}
}
// If necessary, convert the line-endings on the file before diffing
// note: file externals can not be exported
if (((DWORD)CRegDWORD(L"Software\\TortoiseSVN\\ConvertBase", TRUE)) && (!fileexternal))
{
CTSVNPath temporaryFile = CTempFiles::Instance().GetTempFilePath(m_bRemoveTempFiles, filePath, SVNRev::REV_BASE);
if (!m_pSVN->Export(filePath, temporaryFile, SVNRev(SVNRev::REV_BASE), SVNRev(SVNRev::REV_BASE)))
{
temporaryFile.Reset();
}
else
{
basePath = temporaryFile;
SetFileAttributes(basePath.GetWinPath(), FILE_ATTRIBUTE_READONLY);
}
}
// for added/deleted files, we don't have a BASE file.
// create an empty temp file to be used.
if (!basePath.Exists())
{
basePath = CTempFiles::Instance().GetTempFilePath(m_bRemoveTempFiles, filePath, SVNRev::REV_BASE);
SetFileAttributes(basePath.GetWinPath(), FILE_ATTRIBUTE_READONLY);
}
CString name = filePath.GetFilename();
CTSVNPath wcFilePath = filePath;
if (!wcFilePath.Exists())
{
wcFilePath = CTempFiles::Instance().GetTempFilePath(m_bRemoveTempFiles, filePath, SVNRev::REV_BASE);
SetFileAttributes(wcFilePath.GetWinPath(), FILE_ATTRIBUTE_READONLY);
}
CString n1, n2;
n1.Format(IDS_DIFF_WCNAME, (LPCTSTR)name);
if (baseRev)
n2.FormatMessage(IDS_DIFF_BASENAMEREV, (LPCTSTR)name, baseRev);
else
n2.Format(IDS_DIFF_BASENAME, (LPCTSTR)name);
retvalue = CAppUtils::StartExtDiff(
basePath, wcFilePath, n2, n1,
filePath, filePath, SVNRev::REV_BASE, SVNRev::REV_WC, SVNRev::REV_BASE,
CAppUtils::DiffFlags().Wait().AlternativeTool(m_bAlternativeTool), m_JumpLine, name, L"");
}
return retvalue;
}
void CExportDlg::OnOK()
{
if (!UpdateData(TRUE))
return; // don't dismiss dialog (error message already shown by MFC framework)
if (::IsWindow(m_pLogDlg->GetSafeHwnd())&&(m_pLogDlg->IsWindowVisible()))
{
m_pLogDlg->SendMessage(WM_CLOSE);
return;
}
// check it the export path is a valid windows path
CTSVNPath ExportDirectory;
if (::PathIsRelative(m_strExportDirectory))
{
ExportDirectory = CTSVNPath(sOrigCWD);
ExportDirectory.AppendPathString(L"\\" + m_strExportDirectory);
m_strExportDirectory = ExportDirectory.GetWinPathString();
}
else
ExportDirectory = CTSVNPath(m_strExportDirectory);
if (!ExportDirectory.IsValidOnWindows())
{
ShowEditBalloon(IDC_CHECKOUTDIRECTORY, IDS_ERR_NOVALIDPATH, IDS_ERR_ERROR, TTI_ERROR);
return;
}
// check if the specified revision is valid
if (GetCheckedRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N) == IDC_REVISION_HEAD)
{
Revision = SVNRev(L"HEAD");
}
else
Revision = SVNRev(m_sRevision);
if (!Revision.IsValid())
{
ShowEditBalloon(IDC_REVISION_NUM, IDS_ERR_INVALIDREV, IDS_ERR_ERROR, TTI_ERROR);
return;
}
bool bAutoCreateTargetName = m_bAutoCreateTargetName;
m_bAutoCreateTargetName = false;
m_URLCombo.SaveHistory();
m_URL = m_URLCombo.GetString();
// we need an url to export from - local paths won't work
if (!SVN::PathIsURL(CTSVNPath(m_URL)))
{
m_tooltips.ShowBalloon(IDC_URLCOMBO, IDS_ERR_MUSTBEURL, IDS_ERR_ERROR, TTI_ERROR);
m_bAutoCreateTargetName = bAutoCreateTargetName;
return;
}
if (m_strExportDirectory.IsEmpty())
{
m_bAutoCreateTargetName = bAutoCreateTargetName;
return;
}
// if the export directory does not exist, where should we export to?
// We ask if the directory should be created...
if (!PathFileExists(m_strExportDirectory))
{
CPathUtils::MakeSureDirectoryPathExists(m_strExportDirectory);
}
// if the directory we should export to is not empty, show a warning:
// maybe the user doesn't want to overwrite the existing files.
if (!PathIsDirectoryEmpty(m_strExportDirectory))
{
CString message;
message.Format(CString(MAKEINTRESOURCE(IDS_WARN_FOLDERNOTEMPTY)),(LPCTSTR)m_strExportDirectory);
CTaskDialog taskdlg(message,
CString(MAKEINTRESOURCE(IDS_WARN_FOLDERNOTEMPTY_TASK2)),
L"TortoiseSVN",
0,
TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_WARN_FOLDERNOTEMPTY_TASK3_1)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_WARN_FOLDERNOTEMPTY_TASK4)));
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetDefaultCommandControl(2);
taskdlg.SetMainIcon(TD_WARNING_ICON);
bool doIt = (taskdlg.DoModal(GetExplorerHWND()) == 1);
if (!doIt)
{
m_bAutoCreateTargetName = bAutoCreateTargetName;
return; //don't dismiss the dialog
}
}
m_eolCombo.GetWindowText(m_eolStyle);
if (m_eolStyle.Compare(L"default")==0)
m_eolStyle.Empty();
switch (m_depthCombo.GetCurSel())
{
case 0:
m_depth = svn_depth_infinity;
break;
case 1:
m_depth = svn_depth_immediates;
break;
case 2:
m_depth = svn_depth_files;
break;
case 3:
m_depth = svn_depth_empty;
break;
default:
m_depth = svn_depth_empty;
break;
}
UpdateData(FALSE);
CRegDWORD regNoExt(L"Software\\TortoiseSVN\\noext");
regNoExt = m_bNoExternals;
CResizableStandAloneDialog::OnOK();
}
bool PasteCopyCommand::Execute()
{
CString sDroppath = parser.GetVal(_T("droptarget"));
CTSVNPath dropPath(sDroppath);
ProjectProperties props;
props.ReadProps(dropPath);
if (dropPath.IsAdminDir())
return FALSE;
SVN svn;
SVNStatus status;
unsigned long count = 0;
CString sNewName;
pathList.RemoveAdminPaths();
CProgressDlg progress;
progress.SetTitle(IDS_PROC_COPYING);
progress.SetAnimation(IDR_MOVEANI);
progress.SetTime(true);
progress.ShowModeless(CWnd::FromHandle(hwndExplorer));
for(int nPath = 0; nPath < pathList.GetCount(); nPath++)
{
const CTSVNPath& sourcePath = pathList[nPath];
CTSVNPath fullDropPath = dropPath;
if (sNewName.IsEmpty())
fullDropPath.AppendPathString(sourcePath.GetFileOrDirectoryName());
else
fullDropPath.AppendPathString(sNewName);
// Check for a drop-on-to-ourselves
if (sourcePath.IsEquivalentTo(fullDropPath))
{
// Offer a rename
progress.Stop();
CRenameDlg dlg;
dlg.m_windowtitle.Format(IDS_PROC_NEWNAMECOPY, (LPCTSTR)sourcePath.GetUIFileOrDirectoryName());
if (dlg.DoModal() != IDOK)
{
return FALSE;
}
// rebuild the progress dialog
progress.EnsureValid();
progress.SetTitle(IDS_PROC_COPYING);
progress.SetAnimation(IDR_MOVEANI);
progress.SetTime(true);
progress.SetProgress(count, pathList.GetCount());
progress.ShowModeless(CWnd::FromHandle(hwndExplorer));
// Rebuild the destination path, with the new name
fullDropPath.SetFromUnknown(sDroppath);
fullDropPath.AppendPathString(dlg.m_name);
}
svn_wc_status_kind s = status.GetAllStatus(sourcePath);
if ((s == svn_wc_status_none)||(s == svn_wc_status_unversioned)||(s == svn_wc_status_ignored))
{
// source file is unversioned: move the file to the target, then add it
CopyFile(sourcePath.GetWinPath(), fullDropPath.GetWinPath(), FALSE);
if (!svn.Add(CTSVNPathList(fullDropPath), &props, svn_depth_infinity, true, false, true))
{
TRACE(_T("%s\n"), (LPCTSTR)svn.GetLastErrorMessage());
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);
return FALSE; //get out of here
}
else
CShellUpdater::Instance().AddPathForUpdate(fullDropPath);
}
else
{
if (!svn.Copy(CTSVNPathList(sourcePath), fullDropPath, SVNRev::REV_WC, SVNRev()))
{
TRACE(_T("%s\n"), (LPCTSTR)svn.GetLastErrorMessage());
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);
return FALSE; //get out of here
}
else
CShellUpdater::Instance().AddPathForUpdate(fullDropPath);
}
count++;
if (progress.IsValid())
{
progress.FormatPathLine(1, IDS_PROC_COPYINGPROG, sourcePath.GetWinPath());
progress.FormatPathLine(2, IDS_PROC_CPYMVPROG2, fullDropPath.GetWinPath());
progress.SetProgress(count, pathList.GetCount());
}
if ((progress.IsValid())&&(progress.HasUserCancelled()))
{
CMessageBox::Show(hwndExplorer, IDS_SVN_USERCANCELLED, IDS_APPNAME, MB_ICONINFORMATION);
return false;
}
}
return true;
}
bool DiffCommand::Execute()
{
bool bRet = false;
CString path2 = CPathUtils::GetLongPathname(parser.GetVal(L"path2"));
bool bAlternativeTool = !!parser.HasKey(L"alternative");
bool bBlame = !!parser.HasKey(L"blame");
bool ignoreprops = !!parser.HasKey(L"ignoreprops");
if (path2.IsEmpty())
{
SVNDiff diff(NULL, GetExplorerHWND());
diff.SetAlternativeTool(bAlternativeTool);
diff.SetJumpLine(parser.GetLongVal(L"line"));
if ( parser.HasKey(L"startrev") && parser.HasKey(L"endrev") )
{
SVNRev StartRevision = SVNRev(parser.GetVal(L"startrev"));
SVNRev EndRevision = SVNRev(parser.GetVal(L"endrev"));
SVNRev pegRevision;
if (parser.HasVal(L"pegrevision"))
pegRevision = SVNRev(parser.GetVal(L"pegrevision"));
CString diffoptions;
if (parser.HasVal(L"diffoptions"))
diffoptions = parser.GetVal(L"diffoptions");
bRet = diff.ShowCompare(cmdLinePath, StartRevision, cmdLinePath, EndRevision, pegRevision, ignoreprops, diffoptions, false, bBlame);
}
else
{
svn_revnum_t baseRev = 0;
if (parser.HasKey(L"unified"))
{
SVNRev pegRevision;
if (parser.HasVal(L"pegrevision"))
pegRevision = SVNRev(parser.GetVal(L"pegrevision"));
CString diffoptions;
if (parser.HasVal(L"diffoptions"))
diffoptions = parser.GetVal(L"diffoptions");
diff.ShowUnifiedDiff(cmdLinePath, SVNRev::REV_BASE, cmdLinePath, SVNRev::REV_WC, pegRevision, diffoptions, false, bBlame, false);
}
else
{
if (cmdLinePath.IsDirectory())
{
if (!ignoreprops)
bRet = diff.DiffProps(cmdLinePath, SVNRev::REV_WC, SVNRev::REV_BASE, baseRev);
if (bRet == false)
{
CChangedDlg dlg;
dlg.m_pathList = CTSVNPathList(cmdLinePath);
dlg.DoModal();
bRet = true;
}
}
else
{
bRet = diff.DiffFileAgainstBase(cmdLinePath, baseRev, ignoreprops);
}
}
}
}
else
bRet = CAppUtils::StartExtDiff(
CTSVNPath(path2), cmdLinePath, CString(), CString(),
CAppUtils::DiffFlags().AlternativeTool(bAlternativeTool), parser.GetLongVal(L"line"), L"");
return bRet;
}
void CRevisionRangeDlg::OnOK()
{
if (!UpdateData(TRUE))
return; // don't dismiss dialog (error message already shown by MFC framework)
m_StartRev = SVNRev(m_sStartRevision);
if (GetCheckedRadioButton(IDC_REVRANGE_HEAD, IDC_REVRANGE_DATE) == IDC_REVRANGE_HEAD)
{
m_StartRev = SVNRev(L"HEAD");
m_sStartRevision = L"HEAD";
}
if (GetCheckedRadioButton(IDC_REVRANGE_HEAD, IDC_REVRANGE_DATE) == IDC_REVRANGE_DATE)
{
CTime _time;
m_DateFrom.GetTime(_time);
try
{
CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 0, 0, 0);
m_sStartRevision = time.FormatGmt(L"{%Y-%m-%d}");
m_StartRev = SVNRev(m_sStartRevision);
}
catch (CAtlException)
{
}
}
if ((!m_StartRev.IsValid())||((!m_bAllowWCRevs)&&(m_StartRev.IsPrev() || m_StartRev.IsCommitted() || m_StartRev.IsBase())))
{
ShowEditBalloon(IDC_REVNUM, m_bAllowWCRevs ? IDS_ERR_INVALIDREV : IDS_ERR_INVALIDREVNOWC, IDS_ERR_ERROR, TTI_ERROR);
return;
}
m_EndRev = SVNRev(m_sEndRevision);
if (GetCheckedRadioButton(IDC_REVRANGE_HEAD2, IDC_REVRANGE_DATE2) == IDC_REVRANGE_HEAD2)
{
m_EndRev = SVNRev(L"HEAD");
m_sEndRevision = L"HEAD";
}
if (GetCheckedRadioButton(IDC_REVRANGE_HEAD2, IDC_REVRANGE_DATE2) == IDC_REVRANGE_DATE2)
{
CTime _time;
m_DateTo.GetTime(_time);
try
{
CTime time(_time.GetYear(), _time.GetMonth(), _time.GetDay(), 23, 59, 59);
m_sEndRevision = time.FormatGmt(L"{%Y-%m-%d}");
m_EndRev = SVNRev(m_sEndRevision);
}
catch (CAtlException)
{
}
}
if ((!m_EndRev.IsValid())||((!m_bAllowWCRevs)&&(m_EndRev.IsPrev() || m_EndRev.IsCommitted() || m_EndRev.IsBase())))
{
ShowEditBalloon(IDC_REVNUM2, m_bAllowWCRevs ? IDS_ERR_INVALIDREV : IDS_ERR_INVALIDREVNOWC, IDS_ERR_ERROR, TTI_ERROR);
return;
}
UpdateData(FALSE);
CStandAloneDialog::OnOK();
}
bool CheckoutCommand::Execute()
{
bool bRet = false;
// Get the directory supplied in the command line. If there isn't
// one then we should use first the default checkout path
// specified in the settings dialog, and fall back to the current
// working directory instead if no such path was specified.
CTSVNPath checkoutDirectory;
CRegString regDefCheckoutPath(_T("Software\\TortoiseSVN\\DefaultCheckoutPath"));
if (cmdLinePath.IsEmpty())
{
if (CString(regDefCheckoutPath).IsEmpty())
{
checkoutDirectory.SetFromWin(sOrigCWD, true);
DWORD len = ::GetTempPath(0, NULL);
std::unique_ptr<TCHAR[]> tszPath(new TCHAR[len]);
::GetTempPath(len, tszPath.get());
if (_tcsncicmp(checkoutDirectory.GetWinPath(), tszPath.get(), len-2 /* \\ and \0 */) == 0)
{
// if the current directory is set to a temp directory,
// we don't use that but leave it empty instead.
checkoutDirectory.Reset();
}
}
else
{
checkoutDirectory.SetFromWin(CString(regDefCheckoutPath));
}
}
else
{
checkoutDirectory = cmdLinePath;
}
CCheckoutDlg dlg;
dlg.m_URLs.LoadFromAsteriskSeparatedString (parser.GetVal(_T("url")));
if (dlg.m_URLs.GetCount()==0)
{
SVN svn;
if (svn.IsRepository(cmdLinePath))
{
CString url;
// The path points to a local repository.
// Add 'file:///' so the repository browser recognizes
// it as an URL to the local repository.
if (cmdLinePath.GetWinPathString().GetAt(0) == '\\') // starts with '\' means an UNC path
{
CString p = cmdLinePath.GetWinPathString();
p.TrimLeft('\\');
url = _T("file://")+p;
}
else
url = _T("file:///")+cmdLinePath.GetWinPathString();
url.Replace('\\', '/');
dlg.m_URLs.AddPath(CTSVNPath(url));
checkoutDirectory.AppendRawString(L"wc");
}
}
dlg.m_strCheckoutDirectory = checkoutDirectory.GetWinPathString();
// if there is no url specified on the command line, check if there's one
// specified in the settings dialog to use as the default and use that
CRegString regDefCheckoutUrl(_T("Software\\TortoiseSVN\\DefaultCheckoutUrl"));
if (!CString(regDefCheckoutUrl).IsEmpty())
{
// if the URL specified is a child of the default URL, we also
// adjust the default checkout path
// e.g.
// Url specified on command line: http://server.com/repos/project/trunk/folder
// Url specified as default : http://server.com/repos/project/trunk
// checkout path specified : c:\work\project
// -->
// checkout path adjusted : c:\work\project\folder
CTSVNPath clurl = dlg.m_URLs.GetCommonDirectory();
CTSVNPath defurl = CTSVNPath(CString(regDefCheckoutUrl));
if (defurl.IsAncestorOf(clurl))
{
// the default url is the parent of the specified url
if (CTSVNPath::CheckChild(CTSVNPath(CString(regDefCheckoutPath)), CTSVNPath(dlg.m_strCheckoutDirectory)))
{
dlg.m_strCheckoutDirectory = CString(regDefCheckoutPath) + clurl.GetWinPathString().Mid(defurl.GetWinPathString().GetLength());
dlg.m_strCheckoutDirectory.Replace(_T("\\\\"), _T("\\"));
}
}
if (dlg.m_URLs.GetCount() == 0)
dlg.m_URLs.AddPath (defurl);
}
for (int i = 0; i < dlg.m_URLs.GetCount(); ++i)
{
CString pathString = dlg.m_URLs[i].GetWinPathString();
if (pathString.Left(5).Compare(_T("tsvn:"))==0)
{
pathString = pathString.Mid(5);
if (pathString.Find('?') >= 0)
{
dlg.Revision = SVNRev(pathString.Mid(pathString.Find('?')+1));
pathString = pathString.Left(pathString.Find('?'));
}
}
dlg.m_URLs[i].SetFromWin (pathString);
}
if (parser.HasKey(_T("revision")))
{
SVNRev Rev = SVNRev(parser.GetVal(_T("revision")));
dlg.Revision = Rev;
}
dlg.m_blockPathAdjustments = parser.HasKey(L"blockpathadjustments");
if (dlg.DoModal() == IDOK)
{
checkoutDirectory.SetFromWin(dlg.m_strCheckoutDirectory, true);
CSVNProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
bool useStandardCheckout
= dlg.m_standardCheckout
|| ((dlg.m_URLs.GetCount() > 1) && dlg.m_bIndependentWCs);
progDlg.SetCommand
(useStandardCheckout
? dlg.m_checkoutDepths.size()
? CSVNProgressDlg::SVNProgress_SparseCheckout
: CSVNProgressDlg::SVNProgress_Checkout
: dlg.m_parentExists && (dlg.m_URLs.GetCount() == 1)
? CSVNProgressDlg::SVNProgress_Update
: CSVNProgressDlg::SVNProgress_SingleFileCheckout);
if (dlg.m_checkoutDepths.size())
progDlg.SetPathDepths(dlg.m_checkoutDepths);
progDlg.SetAutoClose (parser);
progDlg.SetOptions(dlg.m_bNoExternals ? ProgOptIgnoreExternals : ProgOptNone);
progDlg.SetPathList(CTSVNPathList(checkoutDirectory));
progDlg.SetUrl(dlg.m_URLs.CreateAsteriskSeparatedString());
progDlg.SetRevision(dlg.Revision);
progDlg.SetDepth(dlg.m_depth);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
return bRet;
}
BOOL CMergeWizardTree::CheckData(bool bShowErrors /* = true */)
{
if (!UpdateData(TRUE))
return FALSE;
StartRev = SVNRev(m_sStartRev);
EndRev = SVNRev(m_sEndRev);
if (GetCheckedRadioButton(IDC_REVISION_HEAD1, IDC_REVISION_N1) == IDC_REVISION_HEAD1)
{
StartRev = SVNRev(L"HEAD");
}
if (!StartRev.IsValid())
{
if (bShowErrors)
ShowEditBalloon(IDC_REVISION_START, IDS_ERR_INVALIDREV, IDS_ERR_ERROR, TTI_ERROR);
return FALSE;
}
// if head revision, set revision as -1
if (GetCheckedRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N) == IDC_REVISION_HEAD)
{
EndRev = SVNRev(L"HEAD");
}
if (!EndRev.IsValid())
{
if (bShowErrors)
ShowEditBalloon(IDC_REVISION_END, IDS_ERR_INVALIDREV, IDS_ERR_ERROR, TTI_ERROR);
return FALSE;
}
CString sUrl;
m_URLCombo.GetWindowText(sUrl);
CTSVNPath url(sUrl);
if (!url.IsUrl())
{
ShowComboBalloon(&m_URLCombo, IDS_ERR_MUSTBEURL, IDS_ERR_ERROR, TTI_ERROR);
return FALSE;
}
m_URLCombo2.GetWindowText(sUrl);
CTSVNPath url2(sUrl);
if (!url2.IsUrl())
{
ShowComboBalloon(&m_URLCombo2, IDS_ERR_MUSTBEURL, IDS_ERR_ERROR, TTI_ERROR);
return FALSE;
}
m_URLCombo.SaveHistory();
m_URLFrom = m_URLCombo.GetString();
m_URLCombo2.SaveHistory();
m_URLTo = m_URLCombo2.GetString();
CString sRegKeyFrom = L"Software\\TortoiseSVN\\History\\repoURLS\\MergeURLForFrom" + ((CMergeWizard*)GetParent())->wcPath.GetSVNPathString();
CRegString regMergeUrlForWCFrom(sRegKeyFrom);
regMergeUrlForWCFrom = m_URLFrom;
CString sRegKeyTo = L"Software\\TortoiseSVN\\History\\repoURLS\\MergeURLForTo" + ((CMergeWizard*)GetParent())->wcPath.GetSVNPathString();
CRegString regMergeUrlForWCTo(sRegKeyTo);
regMergeUrlForWCTo = m_URLTo;
((CMergeWizard*)GetParent())->URL1 = m_URLFrom;
((CMergeWizard*)GetParent())->URL2 = m_URLTo;
((CMergeWizard*)GetParent())->startRev = StartRev;
((CMergeWizard*)GetParent())->endRev = EndRev;
UpdateData(FALSE);
return TRUE;
}
bool ConflictEditorCommand::Execute()
{
CTSVNPath merge = cmdLinePath;
CTSVNPath directory = merge.GetDirectory();
bool bRet = false;
bool bAlternativeTool = !!parser.HasKey(_T("alternative"));
// we have the conflicted file (%merged)
// now look for the other required files
SVNStatus stat;
stat.GetStatus(merge);
if (stat.status == NULL)
return false;
if (stat.status->text_status == svn_wc_status_conflicted)
{
// we have a text conflict, use our merge tool to resolve the conflict
CTSVNPath theirs(directory);
CTSVNPath mine(directory);
CTSVNPath base(directory);
bool bConflictData = false;
if ((stat.status->entry)&&(stat.status->entry->conflict_new))
{
theirs.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_new));
bConflictData = true;
}
if ((stat.status->entry)&&(stat.status->entry->conflict_old))
{
base.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_old));
bConflictData = true;
}
if ((stat.status->entry)&&(stat.status->entry->conflict_wrk))
{
mine.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_wrk));
bConflictData = true;
}
else
{
mine = merge;
}
if (bConflictData)
bRet = !!CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
base, theirs, mine, merge);
}
if (stat.status->prop_status == svn_wc_status_conflicted)
{
// we have a property conflict
CTSVNPath prej(directory);
if ((stat.status->entry)&&(stat.status->entry->prejfile))
{
prej.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->prejfile));
// there's a problem: the prej file contains a _description_ of the conflict, and
// that description string might be translated. That means we have no way of parsing
// the file to find out the conflicting values.
// The only thing we can do: show a dialog with the conflict description, then
// let the user either accept the existing property or open the property edit dialog
// to manually change the properties and values. And a button to mark the conflict as
// resolved.
CEditPropConflictDlg dlg;
dlg.SetPrejFile(prej);
dlg.SetConflictedItem(merge);
bRet = (dlg.DoModal() != IDCANCEL);
}
}
if (stat.status->tree_conflict)
{
// we have a tree conflict
SVNInfo info;
const SVNInfoData * pInfoData = info.GetFirstFileInfo(merge, SVNRev(), SVNRev());
if (pInfoData)
{
if (pInfoData->treeconflict_kind == svn_wc_conflict_kind_text)
{
CTSVNPath theirs(directory);
CTSVNPath mine(directory);
CTSVNPath base(directory);
bool bConflictData = false;
if (pInfoData->treeconflict_theirfile)
{
theirs.AppendPathString(pInfoData->treeconflict_theirfile);
bConflictData = true;
}
if (pInfoData->treeconflict_basefile)
{
base.AppendPathString(pInfoData->treeconflict_basefile);
bConflictData = true;
}
if (pInfoData->treeconflict_myfile)
{
mine.AppendPathString(pInfoData->treeconflict_myfile);
bConflictData = true;
}
else
{
mine = merge;
}
if (bConflictData)
bRet = !!CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
base, theirs, mine, merge);
}
else if (pInfoData->treeconflict_kind == svn_wc_conflict_kind_tree)
{
CString sConflictAction;
CString sConflictReason;
CString sResolveTheirs;
CString sResolveMine;
CTSVNPath treeConflictPath = CTSVNPath(pInfoData->treeconflict_path);
CString sItemName = treeConflictPath.GetUIFileOrDirectoryName();
if (pInfoData->treeconflict_nodekind == svn_node_file)
{
switch (pInfoData->treeconflict_operation)
{
default:
case svn_wc_operation_none:
case svn_wc_operation_update:
switch (pInfoData->treeconflict_action)
{
default:
case svn_wc_conflict_action_edit:
sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEEDIT, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
break;
case svn_wc_conflict_action_add:
sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEADD, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
break;
case svn_wc_conflict_action_delete:
sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEDELETE, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
break;
}
break;
case svn_wc_operation_switch:
switch (pInfoData->treeconflict_action)
{
default:
case svn_wc_conflict_action_edit:
sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHEDIT, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
break;
case svn_wc_conflict_action_add:
sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHADD, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
break;
case svn_wc_conflict_action_delete:
sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHDELETE, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
break;
}
break;
case svn_wc_operation_merge:
switch (pInfoData->treeconflict_action)
{
default:
case svn_wc_conflict_action_edit:
sConflictAction.Format(IDS_TREECONFLICT_FILEMERGEEDIT, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
break;
case svn_wc_conflict_action_add:
sConflictAction.Format(IDS_TREECONFLICT_FILEMERGEADD, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
break;
case svn_wc_conflict_action_delete:
sConflictAction.Format(IDS_TREECONFLICT_FILEMERGEDELETE, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
break;
}
break;
}
}
else //if (pInfoData->treeconflict_nodekind == svn_node_dir)
{
switch (pInfoData->treeconflict_operation)
{
default:
case svn_wc_operation_none:
case svn_wc_operation_update:
switch (pInfoData->treeconflict_action)
{
default:
case svn_wc_conflict_action_edit:
sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEEDIT, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
break;
case svn_wc_conflict_action_add:
sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEADD, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
break;
case svn_wc_conflict_action_delete:
sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEDELETE, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
break;
}
break;
case svn_wc_operation_switch:
switch (pInfoData->treeconflict_action)
{
default:
case svn_wc_conflict_action_edit:
sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHEDIT, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
break;
case svn_wc_conflict_action_add:
sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHADD, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
break;
case svn_wc_conflict_action_delete:
sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHDELETE, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
break;
}
break;
case svn_wc_operation_merge:
switch (pInfoData->treeconflict_action)
{
default:
case svn_wc_conflict_action_edit:
sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEEDIT, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
break;
case svn_wc_conflict_action_add:
sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEADD, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
break;
case svn_wc_conflict_action_delete:
sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEDELETE, (LPCTSTR)sItemName);
sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
break;
}
break;
}
}
UINT uReasonID = 0;
switch (pInfoData->treeconflict_reason)
{
case svn_wc_conflict_reason_edited:
uReasonID = IDS_TREECONFLICT_REASON_EDITED;
sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
break;
case svn_wc_conflict_reason_obstructed:
uReasonID = IDS_TREECONFLICT_REASON_OBSTRUCTED;
sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
break;
case svn_wc_conflict_reason_deleted:
uReasonID = IDS_TREECONFLICT_REASON_DELETED;
sResolveMine.LoadString(IDS_TREECONFLICT_RESOLVE_MARKASRESOLVED);
break;
case svn_wc_conflict_reason_added:
uReasonID = IDS_TREECONFLICT_REASON_ADDED;
sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
break;
case svn_wc_conflict_reason_missing:
uReasonID = IDS_TREECONFLICT_REASON_MISSING;
sResolveMine.LoadString(IDS_TREECONFLICT_RESOLVE_MARKASRESOLVED);
break;
case svn_wc_conflict_reason_unversioned:
uReasonID = IDS_TREECONFLICT_REASON_UNVERSIONED;
sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
break;
}
sConflictReason.Format(uReasonID, (LPCTSTR)sConflictAction);
CTreeConflictEditorDlg dlg;
dlg.SetConflictInfoText(sConflictReason);
dlg.SetResolveTexts(sResolveTheirs, sResolveMine);
dlg.SetPath(treeConflictPath);
dlg.SetConflictSources(stat.status->tree_conflict->src_left_version, stat.status->tree_conflict->src_right_version);
dlg.SetConflictReason(pInfoData->treeconflict_reason);
dlg.SetConflictAction(pInfoData->treeconflict_action);
INT_PTR dlgRet = dlg.DoModal();
bRet = (dlgRet != IDCANCEL);
}
}
}
return bRet;
}
bool DropCopyCommand::Execute()
{
CString sDroppath = parser.GetVal(L"droptarget");
if (CTSVNPath(sDroppath).IsAdminDir())
return FALSE;
SVN svn;
unsigned long count = 0;
CString sNewName;
pathList.RemoveAdminPaths();
if ((parser.HasKey(L"rename"))&&(pathList.GetCount()==1))
{
// ask for a new name of the source item
CRenameDlg renDlg;
renDlg.SetInputValidator(this);
renDlg.SetFileSystemAutoComplete();
renDlg.m_windowtitle.LoadString(IDS_PROC_COPYRENAME);
renDlg.m_name = pathList[0].GetFileOrDirectoryName();
if (renDlg.DoModal() != IDOK)
{
return FALSE;
}
sNewName = renDlg.m_name;
}
CProgressDlg progress;
progress.SetTitle(IDS_PROC_COPYING);
progress.SetTime(true);
progress.ShowModeless(CWnd::FromHandle(GetExplorerHWND()));
UINT msgRet = IDNO;
INT_PTR msgRetNonversioned = 0;
for (int nPath = 0; nPath < pathList.GetCount(); nPath++)
{
const CTSVNPath& sourcePath = pathList[nPath];
CTSVNPath fullDropPath(sDroppath);
if (sNewName.IsEmpty())
fullDropPath.AppendPathString(sourcePath.GetFileOrDirectoryName());
else
fullDropPath.AppendPathString(sNewName);
// Check for a drop-on-to-ourselves
if (sourcePath.IsEquivalentTo(fullDropPath))
{
// Offer a rename
progress.Stop();
CRenameDlg dlg;
dlg.SetFileSystemAutoComplete();
dlg.m_windowtitle.Format(IDS_PROC_NEWNAMECOPY, (LPCTSTR)sourcePath.GetUIFileOrDirectoryName());
if (dlg.DoModal() != IDOK)
{
return FALSE;
}
// rebuild the progress dialog
progress.EnsureValid();
progress.SetTitle(IDS_PROC_COPYING);
progress.SetTime(true);
progress.SetProgress(count, pathList.GetCount());
progress.ShowModeless(CWnd::FromHandle(GetExplorerHWND()));
// Rebuild the destination path, with the new name
fullDropPath.SetFromUnknown(sDroppath);
fullDropPath.AppendPathString(dlg.m_name);
}
if (!svn.Copy(CTSVNPathList(sourcePath), fullDropPath, SVNRev::REV_WC, SVNRev()))
{
if ((svn.GetSVNError() && svn.GetSVNError()->apr_err == SVN_ERR_ENTRY_EXISTS) && (fullDropPath.Exists()))
{
if ((msgRet != IDYESTOALL) && (msgRet != IDNOTOALL))
{
// target file already exists. Ask user if he wants to replace the file
CString sReplace;
sReplace.Format(IDS_PROC_REPLACEEXISTING, fullDropPath.GetWinPath());
CTaskDialog taskdlg(sReplace,
CString(MAKEINTRESOURCE(IDS_PROC_REPLACEEXISTING_TASK2)),
L"TortoiseSVN",
0,
TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_PROC_REPLACEEXISTING_TASK3)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_PROC_REPLACEEXISTING_TASK4)));
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetVerificationCheckboxText(CString(MAKEINTRESOURCE(IDS_PROC_REPLACEEXISTING_TASK5)));
taskdlg.SetVerificationCheckbox(false);
taskdlg.SetDefaultCommandControl(2);
taskdlg.SetMainIcon(TD_WARNING_ICON);
INT_PTR ret = taskdlg.DoModal(GetExplorerHWND());
if (ret == 1) // replace
msgRet = taskdlg.GetVerificationCheckboxState() ? IDYES : IDYESTOALL;
else
msgRet = taskdlg.GetVerificationCheckboxState() ? IDNO : IDNOTOALL;
}
if ((msgRet == IDYES) || (msgRet == IDYESTOALL))
{
if (!svn.Remove(CTSVNPathList(fullDropPath), true, false))
{
fullDropPath.Delete(true);
}
if (!svn.Copy(CTSVNPathList(pathList[nPath]), fullDropPath, SVNRev::REV_WC, SVNRev()))
{
svn.ShowErrorDialog(GetExplorerHWND(), pathList[nPath]);
return FALSE; //get out of here
}
}
}
else
{
svn.ShowErrorDialog(GetExplorerHWND(), sourcePath);
return FALSE; //get out of here
}
}
else if (svn.GetSVNError() && svn.GetSVNError()->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
INT_PTR ret = 0;
if (msgRetNonversioned == 0)
{
CString sReplace;
sReplace.Format(IDS_PROC_MOVEUNVERSIONED_TASK1, fullDropPath.GetWinPath());
CTaskDialog taskdlg(sReplace,
CString(MAKEINTRESOURCE(IDS_PROC_MOVEUNVERSIONED_TASK2)),
L"TortoiseSVN",
TDCBF_CANCEL_BUTTON,
TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
taskdlg.AddCommandControl(101, CString(MAKEINTRESOURCE(IDS_PROC_COPYUNVERSIONED_TASK3)));
taskdlg.AddCommandControl(102, CString(MAKEINTRESOURCE(IDS_PROC_COPYUNVERSIONED_TASK4)));
taskdlg.AddCommandControl(103, CString(MAKEINTRESOURCE(IDS_PROC_MOVEUNVERSIONED_TASK5)));
taskdlg.SetVerificationCheckboxText(CString(MAKEINTRESOURCE(IDS_PROC_MOVEUNVERSIONED_TASK6)));
taskdlg.SetVerificationCheckbox(false);
taskdlg.SetDefaultCommandControl(103);
taskdlg.SetMainIcon(TD_WARNING_ICON);
ret = taskdlg.DoModal(GetExplorerHWND());
if (taskdlg.GetVerificationCheckboxState())
msgRetNonversioned = ret;
}
else
{
ret = msgRetNonversioned;
}
switch (ret)
{
case 101: // copy
CopyFile(pathList[nPath].GetWinPath(), fullDropPath.GetWinPath(), FALSE);
break;
case 102: // copy and add
CopyFile(pathList[nPath].GetWinPath(), fullDropPath.GetWinPath(), FALSE);
if (!svn.Add(CTSVNPathList(fullDropPath), NULL, svn_depth_infinity, true, false, false, false))
{
svn.ShowErrorDialog(GetExplorerHWND(), fullDropPath);
return FALSE; //get out of here
}
break;
case 103: // skip
default:
break;
}
}
else
CShellUpdater::Instance().AddPathForUpdate(fullDropPath);
count++;
if (progress.IsValid())
{
progress.FormatPathLine(1, IDS_PROC_COPYINGPROG, sourcePath.GetWinPath());
progress.FormatPathLine(2, IDS_PROC_CPYMVPROG2, fullDropPath.GetWinPath());
progress.SetProgress(count, pathList.GetCount());
}
if ((progress.IsValid())&&(progress.HasUserCancelled()))
{
TaskDialog(GetExplorerHWND(), AfxGetResourceHandle(), MAKEINTRESOURCE(IDS_APPNAME), MAKEINTRESOURCE(IDS_SVN_USERCANCELLED), NULL, TDCBF_OK_BUTTON, TD_INFORMATION_ICON, NULL);
return false;
}
}
return true;
}
void CCopyDlg::OnOK()
{
if (::IsWindow(m_pLogDlg->GetSafeHwnd())&&(m_pLogDlg->IsWindowVisible()))
{
m_pLogDlg->SendMessage(WM_CLOSE);
return;
}
m_bCancelled = true;
// check if the status thread has already finished
if ((m_pThread)&&(m_bThreadRunning))
{
WaitForSingleObject(m_pThread->m_hThread, 1000);
if (m_bThreadRunning)
{
// we gave the thread a chance to quit. Since the thread didn't
// listen to us we have to kill it.
TerminateThread(m_pThread->m_hThread, (DWORD)-1);
InterlockedExchange(&m_bThreadRunning, FALSE);
}
}
CString id;
GetDlgItemText(IDC_BUGID, id);
CString sRevText;
GetDlgItemText(IDC_COPYREVTEXT, sRevText);
if (!m_ProjectProperties.CheckBugID(id))
{
ShowEditBalloon(IDC_BUGID, IDS_COMMITDLG_ONLYNUMBERS, IDS_ERR_ERROR, TTI_ERROR);
return;
}
m_sLogMessage = m_cLogMessage.GetText();
if ((m_ProjectProperties.bWarnIfNoIssue) && (id.IsEmpty() && !m_ProjectProperties.HasBugID(m_sLogMessage)))
{
CTaskDialog taskdlg(CString(MAKEINTRESOURCE(IDS_COMMITDLG_WARNNOISSUE_TASK1)),
CString(MAKEINTRESOURCE(IDS_COMMITDLG_WARNNOISSUE_TASK2)),
L"TortoiseSVN",
0,
TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_COMMITDLG_WARNNOISSUE_TASK3)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_COMMITDLG_WARNNOISSUE_TASK4)));
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetDefaultCommandControl(2);
taskdlg.SetMainIcon(TD_WARNING_ICON);
if (taskdlg.DoModal(m_hWnd) != 1)
return;
}
UpdateData(TRUE);
if (GetCheckedRadioButton(IDC_COPYHEAD, IDC_COPYREV) == IDC_COPYHEAD)
m_CopyRev = SVNRev(SVNRev::REV_HEAD);
else if (GetCheckedRadioButton(IDC_COPYHEAD, IDC_COPYREV) == IDC_COPYWC)
m_CopyRev = SVNRev(SVNRev::REV_WC);
else
m_CopyRev = SVNRev(sRevText);
if (!m_CopyRev.IsValid())
{
ShowEditBalloon(IDC_COPYREVTEXT, IDS_ERR_INVALIDREV, IDS_ERR_ERROR, TTI_ERROR);
return;
}
CString combourl = m_URLCombo.GetWindowString();
if (combourl.IsEmpty())
combourl = m_URLCombo.GetString();
if ((m_wcURL.CompareNoCase(combourl)==0)&&(m_CopyRev.IsHead()))
{
CString temp;
temp.FormatMessage(IDS_ERR_COPYITSELF, (LPCTSTR)m_wcURL, (LPCTSTR)m_URLCombo.GetString());
::MessageBox(this->m_hWnd, temp, L"TortoiseSVN", MB_ICONERROR);
return;
}
m_URLCombo.SaveHistory();
m_URL = CPathUtils::CombineUrls(m_repoRoot, m_URLCombo.GetString());
if (!CTSVNPath(m_URL).IsValidOnWindows())
{
CString sInfo;
sInfo.Format(IDS_WARN_NOVALIDPATH_TASK1, (LPCTSTR)m_URL);
CTaskDialog taskdlg(sInfo,
CString(MAKEINTRESOURCE(IDS_WARN_NOVALIDPATH_TASK2)),
L"TortoiseSVN",
0,
TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_WARN_NOVALIDPATH_TASK3)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_WARN_NOVALIDPATH_TASK4)));
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetExpansionArea(CString(MAKEINTRESOURCE(IDS_WARN_NOVALIDPATH_TASK5)));
taskdlg.SetDefaultCommandControl(2);
taskdlg.SetMainIcon(TD_WARNING_ICON);
if (taskdlg.DoModal(m_hWnd) != 1)
return;
}
CStringUtils::WriteAsciiStringToClipboard(m_URL);
// now let the bugtraq plugin check the commit message
CComPtr<IBugTraqProvider2> pProvider2 = NULL;
if (m_BugTraqProvider)
{
HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
if (SUCCEEDED(hr))
{
ATL::CComBSTR temp;
ATL::CComBSTR sourceURL;
sourceURL.Attach(m_wcURL.AllocSysString());
ATL::CComBSTR parameters;
parameters.Attach(m_bugtraq_association.GetParameters().AllocSysString());
ATL::CComBSTR targetURL;
targetURL.Attach(m_URL.AllocSysString());
ATL::CComBSTR commitMessage;
commitMessage.Attach(m_sLogMessage.AllocSysString());
CBstrSafeVector pathList(1);
pathList.PutElement(0, m_path.GetSVNPathString());
hr = pProvider2->CheckCommit(GetSafeHwnd(), parameters, sourceURL, targetURL, pathList, commitMessage, &temp);
if (FAILED(hr))
{
OnComError(hr);
}
else
{
CString sError = temp == 0 ? L"" : temp;
if (!sError.IsEmpty())
{
CAppUtils::ReportFailedHook(m_hWnd, sError);
return;
}
}
}
}
CTSVNPathList checkedItems;
checkedItems.AddPath(m_path);
DWORD exitcode = 0;
CString error;
CHooks::Instance().SetProjectProperties(m_path, m_ProjectProperties);
if (CHooks::Instance().CheckCommit(m_hWnd, checkedItems, m_sLogMessage, exitcode, error))
{
if (exitcode)
{
CString sErrorMsg;
sErrorMsg.Format(IDS_HOOK_ERRORMSG, (LPCWSTR)error);
CTaskDialog taskdlg(sErrorMsg,
CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK2)),
L"TortoiseSVN",
0,
TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK3)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK4)));
taskdlg.SetDefaultCommandControl(1);
taskdlg.SetMainIcon(TD_ERROR_ICON);
bool retry = (taskdlg.DoModal(GetSafeHwnd()) == 1);
if (retry)
return;
}
}
if (!m_sLogMessage.IsEmpty())
{
m_History.AddEntry(m_sLogMessage);
m_History.Save();
}
m_sBugID.Trim();
if (!m_sBugID.IsEmpty())
{
m_sBugID.Replace(L", ", L",");
m_sBugID.Replace(L" ,", L",");
CString sBugID = m_ProjectProperties.sMessage;
sBugID.Replace(L"%BUGID%", m_sBugID);
if (m_ProjectProperties.bAppend)
m_sLogMessage += L"\n" + sBugID + L"\n";
else
m_sLogMessage = sBugID + L"\n" + m_sLogMessage;
UpdateData(FALSE);
}
CResizableStandAloneDialog::OnOK();
}
void CMergeWizardRevRange::OnBnClickedShowlog()
{
if (::IsWindow(m_pLogDlg->GetSafeHwnd())&&(m_pLogDlg->IsWindowVisible()))
return;
CString sUrl;
m_URLCombo.GetWindowText(sUrl);
SVNRev rev(SVNRev::REV_HEAD);
// check if the url has a revision appended to it
auto atposurl = sUrl.ReverseFind('@');
if (atposurl >= 0)
{
CString sRev = sUrl.Mid(atposurl+1);
rev = SVNRev(sRev);
if (rev.IsValid())
{
sUrl = sUrl.Left(atposurl);
}
else
rev = SVNRev::REV_HEAD;
}
CTSVNPath url(sUrl);
if (!url.IsEmpty() && url.IsUrl())
{
StopWCCheckThread();
CTSVNPath wcPath = ((CMergeWizard*)GetParent())->wcPath;
if (m_pLogDlg)
m_pLogDlg->DestroyWindow();
delete m_pLogDlg;
m_pLogDlg = new CLogDlg();
m_pLogDlg->SetDialogTitle(CString(MAKEINTRESOURCE(IDS_MERGE_SELECTRANGE)));
m_pLogDlg->SetSelect(true);
m_pLogDlg->m_pNotifyWindow = this;
m_pLogDlg->SetParams(url, rev, rev, 1, TRUE, FALSE);
m_pLogDlg->SetProjectPropertiesPath(wcPath);
m_pLogDlg->SetMergePath(wcPath);
UpdateData(TRUE);
if (!m_sRevRange.IsEmpty() && (m_sRevRange.Find(L"HEAD") < 0))
{
CString sRevRange = m_sRevRange;
int atpos = -1;
if ((atpos = sRevRange.ReverseFind('@')) >= 0)
{
sRevRange = sRevRange.Left(atpos);
}
if (((CMergeWizard*)GetParent())->revRangeArray.FromListString(sRevRange))
{
m_pLogDlg->SetSelectedRevRanges(((CMergeWizard*)GetParent())->revRangeArray);
}
}
m_pLogDlg->Create(IDD_LOGMESSAGE, this);
m_pLogDlg->ShowWindow(SW_SHOW);
}
}
bool CheckoutCommand::Execute()
{
bool bRet = false;
// Get the directory supplied in the command line. If there isn't
// one then we should use first the default checkout path
// specified in the settings dialog, and fall back to the current
// working directory instead if no such path was specified.
CTSVNPath checkoutDirectory;
CRegString regDefCheckoutPath(_T("Software\\TortoiseGit\\DefaultCheckoutPath"));
if (cmdLinePath.IsEmpty())
{
if (CString(regDefCheckoutPath).IsEmpty())
{
checkoutDirectory.SetFromWin(sOrigCWD, true);
DWORD len = ::GetTempPath(0, NULL);
TCHAR * tszPath = new TCHAR[len];
::GetTempPath(len, tszPath);
if (_tcsncicmp(checkoutDirectory.GetWinPath(), tszPath, len-2 /* \\ and \0 */) == 0)
{
// if the current directory is set to a temp directory,
// we don't use that but leave it empty instead.
checkoutDirectory.Reset();
}
delete [] tszPath;
}
else
{
checkoutDirectory.SetFromWin(CString(regDefCheckoutPath));
}
}
else
{
checkoutDirectory = cmdLinePath;
}
CCheckoutDlg dlg;
dlg.m_strCheckoutDirectory = checkoutDirectory.GetWinPathString();
dlg.m_URL = parser.GetVal(_T("url"));
// if there is no url specified on the command line, check if there's one
// specified in the settings dialog to use as the default and use that
CRegString regDefCheckoutUrl(_T("Software\\TortoiseGit\\DefaultCheckoutUrl"));
if (!CString(regDefCheckoutUrl).IsEmpty())
{
// if the URL specified is a child of the default URL, we also
// adjust the default checkout path
// e.g.
// Url specified on command line: http://server.com/repos/project/trunk/folder
// Url specified as default : http://server.com/repos/project/trunk
// checkout path specified : c:\work\project
// -->
// checkout path adjusted : c:\work\project\folder
CTSVNPath clurl = CTSVNPath(dlg.m_URL);
CTSVNPath defurl = CTSVNPath(CString(regDefCheckoutUrl));
if (defurl.IsAncestorOf(clurl))
{
// the default url is the parent of the specified url
if (CTSVNPath::CheckChild(CTSVNPath(CString(regDefCheckoutPath)), CTSVNPath(dlg.m_strCheckoutDirectory)))
{
dlg.m_strCheckoutDirectory = CString(regDefCheckoutPath) + clurl.GetWinPathString().Mid(defurl.GetWinPathString().GetLength());
dlg.m_strCheckoutDirectory.Replace(_T("\\\\"), _T("\\"));
}
}
if (dlg.m_URL.IsEmpty())
dlg.m_URL = regDefCheckoutUrl;
}
if (dlg.m_URL.Left(5).Compare(_T("tsvn:"))==0)
{
dlg.m_URL = dlg.m_URL.Mid(5);
if (dlg.m_URL.Find('?') >= 0)
{
dlg.Revision = SVNRev(dlg.m_URL.Mid(dlg.m_URL.Find('?')+1));
dlg.m_URL = dlg.m_URL.Left(dlg.m_URL.Find('?'));
}
}
if (parser.HasKey(_T("revision")))
{
SVNRev Rev = SVNRev(parser.GetVal(_T("revision")));
dlg.Revision = Rev;
}
if (dlg.m_URL.Find('*')>=0)
{
// multiple URL's specified
// ask where to check them out to
CBrowseFolder foldbrowse;
foldbrowse.SetInfo(CString(MAKEINTRESOURCE(IDS_PROC_CHECKOUTTO)));
foldbrowse.SetCheckBoxText(CString(MAKEINTRESOURCE(IDS_PROC_CHECKOUTTOPONLY)));
foldbrowse.SetCheckBoxText2(CString(MAKEINTRESOURCE(IDS_PROC_CHECKOUTNOEXTERNALS)));
foldbrowse.m_style = BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS | BIF_USENEWUI | BIF_VALIDATE;
TCHAR checkoutpath[MAX_PATH];
if (foldbrowse.Show(hwndExplorer, checkoutpath, MAX_PATH, CString(regDefCheckoutPath))==CBrowseFolder::OK)
{
CSVNProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
if (parser.HasVal(_T("closeonend")))
progDlg.SetAutoClose(parser.GetLongVal(_T("closeonend")));
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Checkout);
progDlg.SetOptions(foldbrowse.m_bCheck2 ? ProgOptIgnoreExternals : ProgOptNone);
progDlg.SetPathList(CTSVNPathList(CTSVNPath(CString(checkoutpath))));
progDlg.SetUrl(dlg.m_URL);
progDlg.SetRevision(dlg.Revision);
progDlg.SetDepth(foldbrowse.m_bCheck ? svn_depth_empty : svn_depth_infinity);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
}
else if (dlg.DoModal() == IDOK)
{
checkoutDirectory.SetFromWin(dlg.m_strCheckoutDirectory, true);
CSVNProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Checkout);
if (parser.HasVal(_T("closeonend")))
progDlg.SetAutoClose(parser.GetLongVal(_T("closeonend")));
progDlg.SetOptions(dlg.m_bNoExternals ? ProgOptIgnoreExternals : ProgOptNone);
progDlg.SetPathList(CTSVNPathList(checkoutDirectory));
progDlg.SetUrl(dlg.m_URL);
progDlg.SetRevision(dlg.Revision);
progDlg.SetDepth(dlg.m_depth);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
return bRet;
}
bool ExportCommand::Execute()
{
bool bRet = false;
// When the user clicked on a working copy, we know that the export should
// be done from that. We then have to ask where the export should go to.
// If however the user clicked on an unversioned folder, we assume that
// this is where the export should go to and have to ask from where
// the export should be done from.
bool bURL = !!SVN::PathIsURL(cmdLinePath);
svn_wc_status_kind s = SVNStatus::GetAllStatus(cmdLinePath);
if ((bURL)||(s == svn_wc_status_unversioned)||(s == svn_wc_status_none))
{
// ask from where the export has to be done
CExportDlg dlg;
if (bURL)
dlg.m_URL = cmdLinePath.GetSVNPathString();
else
dlg.m_strExportDirectory = cmdLinePath.GetWinPathString();
if (parser.HasKey(_T("revision")))
{
SVNRev Rev = SVNRev(parser.GetVal(_T("revision")));
dlg.Revision = Rev;
}
dlg.m_blockPathAdjustments = parser.HasKey(L"blockpathadjustments");
if (dlg.DoModal() == IDOK)
{
CTSVNPath exportPath(dlg.m_strExportDirectory);
CSVNProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Export);
progDlg.SetAutoClose (parser);
DWORD options = dlg.m_bNoExternals ? ProgOptIgnoreExternals : ProgOptNone;
options |= dlg.m_bNoKeywords ? ProgOptIgnoreKeywords : ProgOptNone;
if (dlg.m_eolStyle.CompareNoCase(_T("CRLF"))==0)
options |= ProgOptEolCRLF;
if (dlg.m_eolStyle.CompareNoCase(_T("CR"))==0)
options |= ProgOptEolCR;
if (dlg.m_eolStyle.CompareNoCase(_T("LF"))==0)
options |= ProgOptEolLF;
progDlg.SetOptions(options);
progDlg.SetPathList(CTSVNPathList(exportPath));
progDlg.SetUrl(dlg.m_URL);
progDlg.SetRevision(dlg.Revision);
progDlg.SetDepth(dlg.m_depth);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
}
else
{
// ask where the export should go to.
CBrowseFolder folderBrowser;
CString strTemp;
strTemp.LoadString(IDS_PROC_EXPORT_1);
folderBrowser.SetInfo(strTemp);
folderBrowser.m_style = BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS | BIF_VALIDATE | BIF_EDITBOX;
strTemp.LoadString(IDS_PROC_EXPORT_2);
folderBrowser.SetCheckBoxText(strTemp);
strTemp.LoadString(IDS_PROC_OMMITEXTERNALS);
folderBrowser.SetCheckBoxText2(strTemp);
folderBrowser.DisableCheckBox2WhenCheckbox1IsEnabled(true);
CRegDWORD regExtended = CRegDWORD(_T("Software\\TortoiseSVN\\ExportExtended"), FALSE);
CBrowseFolder::m_bCheck = regExtended;
TCHAR saveto[MAX_PATH];
if (folderBrowser.Show(GetExplorerHWND(), saveto, _countof(saveto))==CBrowseFolder::OK)
{
CString saveplace = CString(saveto);
if (cmdLinePath.IsEquivalentTo(CTSVNPath(saveplace)))
{
// exporting to itself:
// remove all svn admin dirs, effectively unversion the 'exported' folder.
CString msg;
msg.Format(IDS_PROC_EXPORTUNVERSION, (LPCTSTR)saveplace);
bool bUnversion = false;
if (CTaskDialog::IsSupported())
{
CTaskDialog taskdlg(msg,
CString(MAKEINTRESOURCE(IDS_PROC_EXPORTUNVERSION_TASK2)),
L"TortoiseSVN",
0,
TDF_ENABLE_HYPERLINKS|TDF_USE_COMMAND_LINKS|TDF_ALLOW_DIALOG_CANCELLATION|TDF_POSITION_RELATIVE_TO_WINDOW);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_PROC_EXPORTUNVERSION_TASK3)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_PROC_EXPORTUNVERSION_TASK4)));
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetDefaultCommandControl(1);
taskdlg.SetMainIcon(TD_WARNING_ICON);
bUnversion = (taskdlg.DoModal(GetExplorerHWND()) == 1);
}
else
{
bUnversion = (MessageBox(GetExplorerHWND(), msg, _T("TortoiseSVN"), MB_ICONQUESTION|MB_YESNO) == IDYES);
}
if (bUnversion)
{
CProgressDlg progress;
progress.SetTitle(IDS_PROC_UNVERSION);
progress.SetAnimation(IDR_MOVEANI);
progress.FormatNonPathLine(1, IDS_SVNPROGRESS_EXPORTINGWAIT);
progress.SetTime(true);
progress.ShowModeless(GetExplorerHWND());
std::vector<CTSVNPath> removeVector;
CDirFileEnum lister(saveplace);
CString srcFile;
bool bFolder = false;
while (lister.NextFile(srcFile, &bFolder))
{
CTSVNPath item(srcFile);
if ((bFolder)&&(g_SVNAdminDir.IsAdminDirName(item.GetFileOrDirectoryName())))
{
removeVector.push_back(item);
}
}
DWORD count = 0;
for (std::vector<CTSVNPath>::iterator it = removeVector.begin(); (it != removeVector.end()) && (!progress.HasUserCancelled()); ++it)
{
progress.FormatPathLine(1, IDS_SVNPROGRESS_UNVERSION, (LPCTSTR)it->GetWinPath());
progress.SetProgress64(count, removeVector.size());
count++;
it->Delete(false);
}
progress.Stop();
bRet = true;
}
else
return false;
}
else
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": export %s to %s\n"), (LPCTSTR)cmdLinePath.GetUIPathString(), (LPCTSTR)saveto);
SVN svn;
if (!svn.Export(cmdLinePath, CTSVNPath(saveplace), SVNRev::REV_WC,
SVNRev::REV_WC, false, !!folderBrowser.m_bCheck2, false, svn_depth_infinity,
GetExplorerHWND(), folderBrowser.m_bCheck ? SVN::SVNExportIncludeUnversioned : SVN::SVNExportNormal))
{
svn.ShowErrorDialog(GetExplorerHWND(), cmdLinePath);
bRet = false;
}
else
bRet = true;
regExtended = CBrowseFolder::m_bCheck;
}
}
}
return bRet;
}
LRESULT CMergeWizardRevRange::OnWizardNext()
{
StopWCCheckThread();
UpdateData();
if (::IsWindow(m_pLogDlg->GetSafeHwnd())&&(m_pLogDlg->IsWindowVisible()))
{
m_pLogDlg->SendMessage(WM_CLOSE);
return -1;
}
if (::IsWindow(m_pLogDlg2->GetSafeHwnd())&&(m_pLogDlg2->IsWindowVisible()))
{
m_pLogDlg2->SendMessage(WM_CLOSE);
return -1;
}
CString sUrl;
m_URLCombo.GetWindowText(sUrl);
// check if the url has a revision appended to it and remove it if there is one
auto atposurl = sUrl.ReverseFind('@');
if (atposurl >= 0)
{
CString sRev = sUrl.Mid(atposurl+1);
SVNRev rev(sRev);
if (rev.IsValid())
{
((CMergeWizard*)GetParent())->pegRev = rev;
sUrl = sUrl.Left(atposurl);
}
}
CTSVNPath url(sUrl);
if (!url.IsUrl())
{
ShowComboBalloon(&m_URLCombo, IDS_ERR_MUSTBEURL, IDS_ERR_ERROR, TTI_ERROR);
return -1;
}
m_URLCombo.SaveHistory();
CString sRegKey = L"Software\\TortoiseSVN\\History\\repoURLS\\MergeURLFor" + ((CMergeWizard*)GetParent())->wcPath.GetSVNPathString();
CRegString regMergeUrlForWC(sRegKey);
regMergeUrlForWC = sUrl;
((CMergeWizard*)GetParent())->URL1 = sUrl;
((CMergeWizard*)GetParent())->URL2 = sUrl;
if (GetCheckedRadioButton(IDC_MERGERADIO_ALL, IDC_MERGERADIO_SPECIFIC)==IDC_MERGERADIO_ALL)
m_sRevRange.Empty();
// if the revision range has HEAD as a revision specified, we have to
// ask the server what the HEAD revision is: the SVNRevList can only deal
// with numerical revisions because we have to sort the list to get the
// ranges correctly
if (m_sRevRange.Find(L"HEAD") >= 0)
{
if (!m_HEAD.IsValid())
{
SVN svn;
m_HEAD = svn.GetHEADRevision(CTSVNPath(((CMergeWizard*)GetParent())->URL1));
}
m_sRevRange.Replace(L"HEAD", m_HEAD.ToString());
}
int atpos = -1;
if ((atpos = m_sRevRange.ReverseFind('@')) >= 0)
{
((CMergeWizard*)GetParent())->pegRev = SVNRev(m_sRevRange.Mid(atpos+1));
m_sRevRange = m_sRevRange.Left(atpos);
}
if (!((CMergeWizard*)GetParent())->revRangeArray.FromListString(m_sRevRange))
{
ShowEditBalloon(IDC_REVISION_RANGE, IDS_ERR_INVALIDREVRANGE, IDS_ERR_ERROR, TTI_ERROR);
return -1;
}
return IDD_MERGEWIZARD_OPTIONS;
}
bool DropExternalCommand::Execute()
{
bool bSuccess = false;
CString droppath = parser.GetVal(L"droptarget");
CTSVNPath droptsvnpath = CTSVNPath(droppath);
if (droptsvnpath.IsAdminDir())
droptsvnpath = droptsvnpath.GetDirectory();
if (!droptsvnpath.IsDirectory())
droptsvnpath = droptsvnpath.GetDirectory();
// first get the svn:externals property from the target folder
SVNProperties props(droptsvnpath, SVNRev::REV_WC, false, false);
std::string sExternalsValue;
for (int i = 0; i < props.GetCount(); ++i)
{
if (props.GetItemName(i).compare(SVN_PROP_EXTERNALS) == 0)
{
sExternalsValue = props.GetItemValue(i);
break;
}
}
// we don't add admin dirs as externals
pathList.RemoveAdminPaths();
if (pathList.GetCount() == 0)
return bSuccess;
SVNStatus status;
status.GetStatus(droptsvnpath);
CString sTargetRepoRootUrl;
if (status.status && status.status->repos_root_url)
{
sTargetRepoRootUrl = CUnicodeUtils::GetUnicode(status.status->repos_root_url);
}
if (sTargetRepoRootUrl.IsEmpty())
{
// failed to get the status and/or the repo root url
CString messageString;
messageString.Format(IDS_ERR_NOURLOFFILE, droptsvnpath.GetWinPath());
::MessageBox(GetExplorerHWND(), messageString, L"TortoiseSVN", MB_ICONERROR);
}
SVN svn;
for (auto i = 0; i < pathList.GetCount(); ++i)
{
CTSVNPath destPath = droptsvnpath;
destPath.AppendPathString(pathList[i].GetFileOrDirectoryName());
bool bExists = !!PathFileExists(destPath.GetWinPath());
if (!bExists &&
(PathIsDirectory(pathList[i].GetWinPath()) || CopyFile(pathList[i].GetWinPath(), destPath.GetWinPath(), TRUE)))
{
SVNStatus sourceStatus;
sourceStatus.GetStatus(pathList[i]);
if (sourceStatus.status && sourceStatus.status->repos_root_url)
{
CString sExternalRootUrl = CUnicodeUtils::GetUnicode(sourceStatus.status->repos_root_url);
CString sExternalUrl = svn.GetURLFromPath(pathList[i]);
CString sExtValue = sExternalUrl + L" " + pathList[i].GetFileOrDirectoryName();
// check if the url is from the same repo as the target, and if it is
// use a relative external url instead of a full url
if (sTargetRepoRootUrl.Compare(sExternalRootUrl) == 0)
{
sExtValue = L"^" + sExternalUrl.Mid(sTargetRepoRootUrl.GetLength()) + L" " + pathList[i].GetFileOrDirectoryName();
}
if (!sExternalsValue.empty())
{
if (sExternalsValue[sExternalsValue.size() - 1] != '\n')
sExternalsValue += "\n";
}
sExternalsValue += CUnicodeUtils::StdGetUTF8((LPCWSTR)sExtValue);
bSuccess = true;
}
}
else
{
// the file already exists, there can't be an external with the
// same name.
CString messageString;
messageString.Format(IDS_DROPEXT_FILEEXISTS, (LPCWSTR)pathList[i].GetFileOrDirectoryName());
::MessageBox(GetExplorerHWND(), messageString, L"TortoiseSVN", MB_ICONERROR);
bSuccess = false;
}
}
if (bSuccess)
{
bSuccess = !!props.Add(SVN_PROP_EXTERNALS, sExternalsValue, true);
if (bSuccess)
{
CString sInfo;
sInfo.Format(IDS_DROPEXT_UPDATE_TASK1, (LPCTSTR)droptsvnpath.GetFileOrDirectoryName());
CTaskDialog taskdlg(sInfo,
CString(MAKEINTRESOURCE(IDS_DROPEXT_UPDATE_TASK2)),
L"TortoiseSVN",
0,
TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_DROPEXT_UPDATE_TASK3)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_DROPEXT_UPDATE_TASK4)));
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetDefaultCommandControl(2);
taskdlg.SetMainIcon(TD_WARNING_ICON);
bool doUpdate = (taskdlg.DoModal(GetExplorerHWND()) == 1);
if (doUpdate)
{
DWORD exitcode = 0;
CString error;
ProjectProperties pprops;
pprops.ReadPropsPathList(pathList);
CHooks::Instance().SetProjectProperties(droptsvnpath, pprops);
if (CHooks::Instance().StartUpdate(GetExplorerHWND(), pathList, exitcode, error))
{
if (exitcode)
{
CString temp;
temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
::MessageBox(GetExplorerHWND(), temp, L"TortoiseSVN", MB_ICONERROR);
return FALSE;
}
}
CSVNProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Update);
progDlg.SetAutoClose(parser);
progDlg.SetOptions(ProgOptSkipPreChecks);
progDlg.SetPathList(CTSVNPathList(droptsvnpath));
progDlg.SetRevision(SVNRev(L"HEAD"));
progDlg.SetProjectProperties(pprops);
progDlg.SetDepth(svn_depth_unknown);
progDlg.DoModal();
return !progDlg.DidErrorsOccur();
}
}
else
{
// adding the svn:externals property failed, remove all the copied files
props.ShowErrorDialog(GetExplorerHWND());
}
}
return bSuccess != false;
}
bool ConflictEditorCommand::Execute()
{
CTSVNPath merge = cmdLinePath;
CTSVNPath directory = merge.GetDirectory();
bool bRet = false;
bool bAlternativeTool = !!parser.HasKey(L"alternative");
// Use Subversion 1.10 API to resolve possible tree conlifcts.
SVNConflictInfo conflict;
if (!conflict.Get(merge))
{
conflict.ShowErrorDialog(GetExplorerHWND());
return false;
}
// Resolve tree conflicts first.
if (conflict.HasTreeConflict())
{
CProgressDlg progressDlg;
progressDlg.SetTitle(IDS_PROC_EDIT_TREE_CONFLICTS);
CString sProgressLine;
sProgressLine.LoadString(IDS_PROGRS_FETCHING_TREE_CONFLICT_INFO);
progressDlg.SetLine(1, sProgressLine);
progressDlg.SetShowProgressBar(false);
progressDlg.ShowModal(GetExplorerHWND(), FALSE);
conflict.SetProgressDlg(&progressDlg);
if (!conflict.FetchTreeDetails())
{
// Ignore errors while fetching additional tree conflict information.
// Use still may want to resolve it manually.
conflict.ClearSVNError();
}
progressDlg.Stop();
conflict.SetProgressDlg(NULL);
CNewTreeConflictEditorDlg dlg;
dlg.SetConflictInfo(&conflict);
dlg.DoModal(GetExplorerHWND());
if (dlg.IsCancelled())
return false;
if (dlg.GetResult() == svn_client_conflict_option_postpone)
return false;
// Send notififcation that status may be changed. We cannot use
// '/resolvemsghwnd' here because satus of multiple files may be changed
// during tree conflict resolution.
if (parser.HasVal(L"refreshmsghwnd"))
{
HWND refreshMsgWnd = (HWND)parser.GetLongLongVal(L"refreshmsghwnd");
UINT WM_REFRESH_STATUS_MSG = RegisterWindowMessage(L"TORTOISESVN_REFRESH_STATUS_MSG");
::PostMessage(refreshMsgWnd, WM_REFRESH_STATUS_MSG, 0, 0);
}
}
// we have the conflicted file (%merged)
// now look for the other required files
SVNInfo info;
const SVNInfoData * pInfoData = info.GetFirstFileInfo(merge, SVNRev(), SVNRev());
if (pInfoData == NULL)
return false;
for (auto conflIt = pInfoData->conflicts.cbegin(); conflIt != pInfoData->conflicts.cend(); ++conflIt)
{
switch (conflIt->kind)
{
case svn_wc_conflict_kind_text:
{
// we have a text conflict, use our merge tool to resolve the conflict
CTSVNPath theirs = CTSVNPath(conflIt->conflict_new);
CTSVNPath mine = CTSVNPath(conflIt->conflict_wrk);
CTSVNPath base = CTSVNPath(conflIt->conflict_old);
if (mine.IsEmpty())
mine = merge;
bRet = !!CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
base, theirs, mine, merge, true, CString(), CString(), CString(), CString(), merge.GetFileOrDirectoryName());
}
break;
case svn_wc_conflict_kind_property:
{
// we have a property conflict
CTSVNPath prej(conflIt->prejfile);
CEditPropConflictDlg dlg;
dlg.SetPrejFile(prej);
dlg.SetConflictedItem(merge);
dlg.SetPropertyName(conflIt->propname);
dlg.SetPropValues(conflIt->propvalue_base, conflIt->propvalue_working, conflIt->propvalue_incoming_old, conflIt->propvalue_incoming_new);
bRet = (dlg.DoModal() != IDCANCEL);
}
break;
case svn_wc_conflict_kind_tree:
{
CTSVNPath treeConflictPath = CTSVNPath(conflIt->treeconflict_path);
CTreeConflictEditorDlg dlg;
dlg.SetPath(treeConflictPath);
dlg.SetConflictLeftSources(conflIt->src_left_version_url, conflIt->src_left_version_path, conflIt->src_left_version_rev, conflIt->src_left_version_kind);
dlg.SetConflictRightSources(conflIt->src_right_version_url, conflIt->src_right_version_path, conflIt->src_right_version_rev, conflIt->src_right_version_kind);
dlg.SetConflictReason(conflIt->treeconflict_reason);
dlg.SetConflictAction(conflIt->treeconflict_action);
dlg.SetConflictOperation(conflIt->treeconflict_operation);
dlg.SetKind(conflIt->treeconflict_nodekind);
INT_PTR dlgRet = dlg.DoModal();
bRet = (dlgRet != IDCANCEL);
}
break;
}
}
return bRet;
}
BOOL CEditPropExternalsValue::OnInitDialog()
{
CResizableStandAloneDialog::OnInitDialog();
CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
BlockResize(DIALOG_BLOCKVERTICAL);
ExtendFrameIntoClientArea(IDC_GROUPBOTTOM);
m_aeroControls.SubclassOkCancelHelp(this);
m_sWCPath = m_External.targetDir;
SVNRev rev = m_External.revision;
SVNRev pegRev = SVNRev(m_External.pegrevision);
if ((pegRev.IsValid() && !pegRev.IsHead()) || (rev.IsValid() && !rev.IsHead()))
{
CheckRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N, IDC_REVISION_N);
if (m_External.revision.value.number == m_External.pegrevision.value.number)
{
m_sPegRev = pegRev.ToString();
}
else
{
m_sRevision = rev.ToString();
m_sPegRev = pegRev.ToString();
}
}
else
{
CheckRadioButton(IDC_REVISION_HEAD, IDC_REVISION_N, IDC_REVISION_HEAD);
}
m_URLCombo.LoadHistory(L"Software\\TortoiseSVN\\History\\repoURLS", L"url");
m_URLCombo.SetURLHistory(true, false);
m_URLCombo.SetWindowText(CPathUtils::PathUnescape(m_External.url));
UpdateData(false);
CString sWindowTitle;
GetWindowText(sWindowTitle);
CAppUtils::SetWindowTitle(m_hWnd, m_pathList.GetCommonRoot().GetUIPathString(), sWindowTitle);
AddAnchor(IDC_WCLABEL, TOP_LEFT);
AddAnchor(IDC_WCPATH, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_URLLABEL, TOP_LEFT);
AddAnchor(IDC_URLCOMBO, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_BROWSE, TOP_RIGHT);
AddAnchor(IDC_PEGLABEL, TOP_LEFT);
AddAnchor(IDC_OPERATIVELABEL, TOP_LEFT);
AddAnchor(IDC_PEGREV, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_GROUPBOTTOM, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_REVISION_HEAD, TOP_LEFT);
AddAnchor(IDC_REVISION_N, TOP_LEFT);
AddAnchor(IDC_REVISION_NUM, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_SHOW_LOG, TOP_RIGHT);
AddAnchor(IDOK, BOTTOM_RIGHT);
AddAnchor(IDCANCEL, BOTTOM_RIGHT);
AddAnchor(IDHELP, BOTTOM_RIGHT);
EnableSaveRestore(L"EditPropExternalsValue");
return TRUE;
}
bool UrlDiffCommand::Execute()
{
bool bRet = false;
CUrlDiffDlg dlg;
dlg.m_path = cmdLinePath.GetWinPathString();
if (dlg.DoModal() == IDOK)
{
SVNDiff diff(NULL, GetExplorerHWND());
diff.SetJumpLine(parser.GetLongVal(_T("line")));
bool ignoreprops = !!parser.HasKey(_T("ignoreprops"));
bRet = diff.ShowCompare(cmdLinePath, SVNRev::REV_WC, CTSVNPath(dlg.m_URL), dlg.Revision, SVNRev(), ignoreprops, L"");
}
return bRet;
}
