bool DropExportCommand::Execute()
{
bool bRet = true;
#if 0
CString droppath = parser.GetVal(_T("droptarget"));
if (CTGitPath(droppath).IsAdminDir())
return false;
SVN svn;
if ((pathList.GetCount() == 1)&&
(pathList[0].IsEquivalentTo(CTSVNPath(droppath))))
{
// exporting to itself:
// remove all svn admin dirs, effectively unversion the 'exported' folder.
CString msg;
msg.Format(IDS_PROC_EXPORTUNVERSION, (LPCTSTR)droppath);
if (CMessageBox::Show(hwndExplorer, msg, _T("TortoiseSVN"), MB_ICONQUESTION|MB_YESNO) == IDYES)
{
CProgressDlg progress;
progress.SetTitle(IDS_PROC_UNVERSION);
progress.SetAnimation(IDR_MOVEANI);
progress.FormatNonPathLine(1, IDS_SVNPROGRESS_EXPORTINGWAIT);
progress.SetTime(true);
progress.ShowModeless(hwndExplorer);
std::vector<CTSVNPath> removeVector;
CDirFileEnum lister(droppath);
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.SetProgress(count, removeVector.size());
count++;
it->Delete(false);
}
progress.Stop();
}
else
return false;
}
else
{
for(int nPath = 0; nPath < pathList.GetCount(); nPath++)
{
CString dropper = droppath + _T("\\") + pathList[nPath].GetFileOrDirectoryName();
if (PathFileExists(dropper))
{
CString sMsg;
CString sBtn1(MAKEINTRESOURCE(IDS_PROC_OVERWRITEEXPORT_OVERWRITE));
CString sBtn2(MAKEINTRESOURCE(IDS_PROC_OVERWRITEEXPORT_RENAME));
CString sBtn3(MAKEINTRESOURCE(IDS_PROC_OVERWRITEEXPORT_CANCEL));
sMsg.Format(IDS_PROC_OVERWRITEEXPORT, (LPCTSTR)dropper);
UINT ret = CMessageBox::Show(hwndExplorer, sMsg, _T("TortoiseSVN"), MB_DEFBUTTON1, IDI_QUESTION, sBtn1, sBtn2, sBtn3);
if (ret==2)
{
dropper.Format(IDS_PROC_EXPORTFOLDERNAME, (LPCTSTR)droppath, (LPCTSTR)pathList[nPath].GetFileOrDirectoryName());
int exportcount = 1;
while (PathFileExists(dropper))
{
dropper.Format(IDS_PROC_EXPORTFOLDERNAME2, (LPCTSTR)droppath, exportcount++, (LPCTSTR)pathList[nPath].GetFileOrDirectoryName());
}
}
else if (ret == 3)
return false;
}
if (!svn.Export(pathList[nPath], CTSVNPath(dropper), SVNRev::REV_WC ,SVNRev::REV_WC, FALSE, FALSE, svn_depth_infinity, hwndExplorer, parser.HasKey(_T("extended"))))
{
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseSVN"), MB_OK | MB_ICONERROR);
bRet = false;
}
}
}
#endif
return bRet;
}
bool DropExportCommand::Execute()
{
bool bRet = true;
CString droppath = parser.GetVal(L"droptarget");
if (CTSVNPath(droppath).IsAdminDir())
return false;
SVN::SVNExportType exportType = SVN::SVNExportNormal;
if (parser.HasKey(L"extended"))
{
exportType = SVN::SVNExportIncludeUnversioned;
CString et = parser.GetVal(L"extended");
if (et == L"localchanges")
exportType = SVN::SVNExportOnlyLocalChanges;
if (et == L"unversioned")
exportType = SVN::SVNExportIncludeUnversioned;
}
SVN svn;
if ((pathList.GetCount() == 1)&&
(pathList[0].IsEquivalentTo(CTSVNPath(droppath))))
{
// exporting to itself:
// remove all svn admin dirs, effectively unversion the 'exported' folder.
CString msg;
msg.Format(IDS_PROC_EXPORTUNVERSION, (LPCTSTR)droppath);
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 | TDF_SIZE_TO_CONTENT);
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);
if (taskdlg.DoModal(GetExplorerHWND()) != 1)
return false;
CProgressDlg progress;
progress.SetTitle(IDS_PROC_UNVERSION);
progress.FormatNonPathLine(1, IDS_SVNPROGRESS_EXPORTINGWAIT);
progress.SetTime(true);
progress.ShowModeless(GetExplorerHWND());
std::vector<CTSVNPath> removeVector;
CDirFileEnum lister(droppath);
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();
}
else
{
bool bOverwrite = !!parser.HasKey(L"overwrite");
bool bAutorename = !!parser.HasKey(L"autorename");
UINT retDefault = bAutorename ? IDCUSTOM1 : 0;
for(int nPath = 0; nPath < pathList.GetCount(); nPath++)
{
CString dropper = droppath + L"\\" + pathList[nPath].GetFileOrDirectoryName();
if ((!bOverwrite)&&(PathFileExists(dropper)))
{
CString renameddropper;
renameddropper.FormatMessage(IDS_PROC_EXPORTFOLDERNAME, (LPCTSTR)droppath, (LPCTSTR)pathList[nPath].GetFileOrDirectoryName());
int exportcount = 1;
while (PathFileExists(renameddropper))
{
renameddropper.FormatMessage(IDS_PROC_EXPORTFOLDERNAME2, (LPCTSTR)droppath, (LPCTSTR)pathList[nPath].GetFileOrDirectoryName(), exportcount++);
}
UINT ret = retDefault;
if (ret == 0)
{
CString sMsg;
sMsg.Format(IDS_PROC_OVERWRITEEXPORT, (LPCTSTR)dropper);
CTaskDialog taskdlg(sMsg,
CString(MAKEINTRESOURCE(IDS_PROC_OVERWRITEEXPORT_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(IDCUSTOM1, CString(MAKEINTRESOURCE(IDS_PROC_OVERWRITEEXPORT_TASK3)));
CString task4;
task4.Format(IDS_PROC_OVERWRITEEXPORT_TASK4, (LPCTSTR)renameddropper);
taskdlg.AddCommandControl(IDCUSTOM2, task4);
taskdlg.AddCommandControl(IDCUSTOM3, CString(MAKEINTRESOURCE(IDS_PROC_OVERWRITEEXPORT_TASK5)));
taskdlg.SetDefaultCommandControl(IDCUSTOM2);
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetVerificationCheckboxText(CString(MAKEINTRESOURCE(IDS_PROC_OVERWRITEEXPORT_TASK6)));
taskdlg.SetMainIcon(TD_WARNING_ICON);
ret = (UINT)taskdlg.DoModal(GetExplorerHWND());
if (taskdlg.GetVerificationCheckboxState())
retDefault = ret;
}
if (ret == IDCUSTOM3)
return false;
if (ret==IDCUSTOM2)
{
dropper = renameddropper;
}
}
if (!svn.Export(pathList[nPath], CTSVNPath(dropper), SVNRev::REV_WC ,SVNRev::REV_WC, !!parser.HasKey(L"overwrite"), false, false, svn_depth_infinity, GetExplorerHWND(), exportType))
{
svn.ShowErrorDialog(GetExplorerHWND(), pathList[nPath]);
bRet = false;
}
}
}
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;
}
void CFileDiffDlg::DoDiff(int selIndex, bool blame)
{
CFileDiffDlg::FileDiff fd = m_arFilteredList[selIndex];
CTSVNPath url1 = CTSVNPath(m_path1.GetSVNPathString() + _T("/") + fd.path.GetSVNPathString());
CTSVNPath url2 = m_bDoPegDiff ? url1 : CTSVNPath(m_path2.GetSVNPathString() + _T("/") + fd.path.GetSVNPathString());
if (fd.kind == svn_client_diff_summarize_kind_deleted)
{
if (!PathIsURL(url1))
url1 = CTSVNPath(GetURLFromPath(m_path1) + _T("/") + fd.path.GetSVNPathString());
if (!PathIsURL(url2))
url2 = m_bDoPegDiff ? url1 : CTSVNPath(GetURLFromPath(m_path2) + _T("/") + fd.path.GetSVNPathString());
}
if (fd.propchanged)
{
DiffProps(selIndex);
}
if (fd.node == svn_node_dir)
return;
CTSVNPath tempfile = CTempFiles::Instance().GetTempFilePath(false, m_path1, m_rev1);
CString sTemp;
CProgressDlg progDlg;
progDlg.SetTitle(IDS_PROGRESSWAIT);
progDlg.SetAnimation(IDR_DOWNLOAD);
progDlg.ShowModeless(this);
progDlg.FormatPathLine(1, IDS_PROGRESSGETFILE, (LPCTSTR)m_path1.GetUIPathString());
progDlg.FormatNonPathLine(2, IDS_PROGRESSREVISIONTEXT, (LPCTSTR)m_rev1.ToString());
if ((fd.kind != svn_client_diff_summarize_kind_added)&&(!blame)&&(!Cat(url1, m_bDoPegDiff ? m_peg : m_rev1, m_rev1, tempfile)))
{
if ((!m_bDoPegDiff)||(!Cat(url1, m_rev1, m_rev1, tempfile)))
{
CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);
return;
}
}
else if ((fd.kind != svn_client_diff_summarize_kind_added)&&(blame)&&(!m_blamer.BlameToFile(url1, 1, m_rev1, m_bDoPegDiff ? m_peg : m_rev1, tempfile, _T(""), TRUE, TRUE)))
{
if ((!m_bDoPegDiff)||(!m_blamer.BlameToFile(url1, 1, m_rev1, m_rev1, tempfile, _T(""), TRUE, TRUE)))
{
CMessageBox::Show(this->m_hWnd, m_blamer.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);
return;
}
}
SetFileAttributes(tempfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);
progDlg.SetProgress(1, 2);
progDlg.FormatPathLine(1, IDS_PROGRESSGETFILE, (LPCTSTR)url2.GetUIPathString());
progDlg.FormatNonPathLine(2, IDS_PROGRESSREVISIONTEXT, (LPCTSTR)m_rev2.ToString());
CTSVNPath tempfile2 = CTempFiles::Instance().GetTempFilePath(false, url2, m_rev2);
if ((fd.kind != svn_client_diff_summarize_kind_deleted)&&(!blame)&&(!Cat(url2, m_bDoPegDiff ? m_peg : m_rev2, m_rev2, tempfile2)))
{
if ((!m_bDoPegDiff)||(!Cat(url2, m_rev2, m_rev2, tempfile2)))
{
CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);
return;
}
}
else if ((fd.kind != svn_client_diff_summarize_kind_deleted)&&(blame)&&(!m_blamer.BlameToFile(url2, 1, m_bDoPegDiff ? m_peg : m_rev2, m_rev2, tempfile2, _T(""), TRUE, TRUE)))
{
if ((!m_bDoPegDiff)||(!m_blamer.BlameToFile(url2, 1, m_rev2, m_rev2, tempfile2, _T(""), TRUE, TRUE)))
{
CMessageBox::Show(this->m_hWnd, m_blamer.GetLastErrorMessage(), _T("TortoiseSVN"), MB_ICONERROR);
return;
}
}
SetFileAttributes(tempfile2.GetWinPath(), FILE_ATTRIBUTE_READONLY);
progDlg.SetProgress(2,2);
progDlg.Stop();
CString rev1name, rev2name;
if (m_bDoPegDiff)
{
rev1name.Format(_T("%s Revision %ld"), (LPCTSTR)fd.path.GetSVNPathString(), (LONG)m_rev1);
rev2name.Format(_T("%s Revision %ld"), (LPCTSTR)fd.path.GetSVNPathString(), (LONG)m_rev2);
}
else
{
rev1name = m_path1.GetSVNPathString() + _T("/") + fd.path.GetSVNPathString();
rev2name = m_path2.GetSVNPathString() + _T("/") + fd.path.GetSVNPathString();
}
CAppUtils::DiffFlags flags;
flags.AlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
flags.Blame(blame);
CAppUtils::StartExtDiff(
tempfile, tempfile2, rev1name, rev2name, flags, 0);
}
