bool ImportCommand::Execute()
{
bool bRet = false;
CString msg;
if (parser.HasKey(_T("logmsg")))
{
msg = parser.GetVal(_T("logmsg"));
}
if (parser.HasKey(_T("logmsgfile")))
{
CString logmsgfile = parser.GetVal(_T("logmsgfile"));
CStringUtils::ReadStringFromTextFile(logmsgfile, msg);
}
CImportDlg dlg;
dlg.m_path = cmdLinePath;
dlg.m_sMessage = msg;
if (parser.HasVal(_T("url")))
dlg.m_url = parser.GetVal(_T("url"));
if (dlg.DoModal() == IDOK)
{
CSVNProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Import);
progDlg.SetAutoClose (parser);
DWORD dwOpts = dlg.m_bIncludeIgnored ? ProgOptIncludeIgnored : ProgOptNone;
if (dlg.m_UseAutoprops)
dwOpts |= ProgOptUseAutoprops;
progDlg.SetOptions(dwOpts);
progDlg.SetPathList(pathList);
progDlg.SetUrl(dlg.m_url);
progDlg.SetCommitMessage(dlg.m_sMessage);
ProjectProperties props;
props.ReadPropsPathList(pathList);
progDlg.SetProjectProperties(props);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
return bRet;
}
bool RevertCommand::Execute()
{
CRevertDlg dlg;
dlg.m_pathList = pathList;
if (dlg.DoModal() == IDOK)
{
if (dlg.m_pathList.GetCount() == 0)
return FALSE;
CSVNProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Revert);
progDlg.SetAutoClose (parser);
progDlg.SetOptions(dlg.m_bRecursive ? ProgOptRecursive : ProgOptNonRecursive);
progDlg.SetPathList(dlg.m_pathList);
progDlg.SetItemCount(dlg.m_selectedPathList.GetCount());
progDlg.SetSelectedList(dlg.m_selectedPathList);
progDlg.DoModal();
return !progDlg.DidErrorsOccur();
}
return false;
}
bool UnLockCommand::Execute()
{
bool bRet = false;
CUnlockDlg unlockDlg;
unlockDlg.m_pathList = pathList;
if (unlockDlg.DoModal()==IDOK)
{
if (unlockDlg.m_pathList.GetCount() != 0)
{
CSVNProgressDlg progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Unlock);
progDlg.SetOptions(parser.HasKey(_T("force")) ? ProgOptForce : ProgOptNone);
progDlg.SetPathList(unlockDlg.m_pathList);
progDlg.SetAutoClose (parser);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
}
return bRet;
}
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 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;
}
bool RenameCommand::Execute()
{
bool bRet = false;
CString filename = cmdLinePath.GetFileOrDirectoryName();
CString basePath = cmdLinePath.GetContainingDirectory().GetGitPathString();
//::SetCurrentDirectory(basePath);
// show the rename dialog until the user either cancels or enters a new
// name (one that's different to the original name
CString sNewName;
do
{
CRenameDlg dlg;
dlg.m_name = filename;
if (dlg.DoModal() != IDOK)
return FALSE;
sNewName = dlg.m_name;
} while(PathIsRelative(sNewName) && !PathIsURL(sNewName) && (sNewName.IsEmpty() || (sNewName.Compare(filename)==0)));
if(!basePath.IsEmpty())
sNewName=basePath+"/"+sNewName;
CString cmd;
CString output;
cmd.Format(_T("git.exe mv -- \"%s\" \"%s\""),
cmdLinePath.GetGitPathString(),
sNewName);
if(g_Git.Run(cmd,&output,CP_ACP))
{
CMessageBox::Show(hwndExplorer, output, _T("TortoiseGit"), MB_OK);
}
CTGitPath newpath;
newpath.SetFromGit(sNewName);
CShellUpdater::Instance().AddPathForUpdate(newpath);
#if 0
TRACE(_T("rename file %s to %s\n"), (LPCTSTR)cmdLinePath.GetWinPathString(), (LPCTSTR)sNewName);
CTSVNPath destinationPath(basePath);
if (PathIsRelative(sNewName) && !PathIsURL(sNewName))
destinationPath.AppendPathString(sNewName);
else
destinationPath.SetFromWin(sNewName);
// check if a rename just with case is requested: that's not possible on windows file systems
// and we have to show an error.
if (cmdLinePath.GetWinPathString().CompareNoCase(destinationPath.GetWinPathString())==0)
{
//rename to the same file!
CString sHelpPath = theApp.m_pszHelpFilePath;
sHelpPath += _T("::/tsvn-dug-rename.html#tsvn-dug-renameincase");
CMessageBox::Show(hwndExplorer, IDS_PROC_CASERENAME, IDS_APPNAME, MB_OK|MB_HELP, sHelpPath);
}
else
{
CString sMsg;
if (SVN::PathIsURL(cmdLinePath))
{
// rename an URL.
// Ask for a commit message, then rename directly in
// the repository
CInputLogDlg input;
CString sUUID;
SVN svn;
svn.GetRepositoryRootAndUUID(cmdLinePath, sUUID);
input.SetUUID(sUUID);
CString sHint;
sHint.Format(IDS_INPUT_MOVE, (LPCTSTR)cmdLinePath.GetSVNPathString(), (LPCTSTR)destinationPath.GetSVNPathString());
input.SetActionText(sHint);
if (input.DoModal() == IDOK)
{
sMsg = input.GetLogMessage();
}
else
{
return FALSE;
}
}
if ((cmdLinePath.IsDirectory())||(pathList.GetCount() > 1))
{
// renaming a directory can take a while: use the
// progress dialog to show the progress of the renaming
// operation.
CSVNProgressDlg progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Rename);
if (parser.HasVal(_T("closeonend")))
progDlg.SetAutoClose(parser.GetLongVal(_T("closeonend")));
progDlg.SetPathList(pathList);
progDlg.SetUrl(destinationPath.GetWinPathString());
progDlg.SetCommitMessage(sMsg);
progDlg.SetRevision(SVNRev::REV_WC);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
else
{
SVN svn;
CString sFilemask = cmdLinePath.GetFilename();
if (sFilemask.ReverseFind('.')>=0)
{
sFilemask = sFilemask.Left(sFilemask.ReverseFind('.'));
}
else
sFilemask.Empty();
CString sNewMask = sNewName;
if (sNewMask.ReverseFind('.'>=0))
{
sNewMask = sNewMask.Left(sNewMask.ReverseFind('.'));
}
else
sNewMask.Empty();
if (((!sFilemask.IsEmpty()) && (parser.HasKey(_T("noquestion")))) ||
(cmdLinePath.GetFileExtension().Compare(destinationPath.GetFileExtension())!=0))
{
if (!svn.Move(CTSVNPathList(cmdLinePath), destinationPath, TRUE, sMsg))
{
TRACE(_T("%s\n"), (LPCTSTR)svn.GetLastErrorMessage());
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
}
else
bRet = true;
}
else
{
// when refactoring, multiple files have to be renamed
// at once because those files belong together.
// e.g. file.aspx, file.aspx.cs, file.aspx.resx
CTSVNPathList renlist;
CSimpleFileFind filefind(cmdLinePath.GetDirectory().GetWinPathString(), sFilemask+_T(".*"));
while (filefind.FindNextFileNoDots())
{
if (!filefind.IsDirectory())
renlist.AddPath(CTSVNPath(filefind.GetFilePath()));
}
if (renlist.GetCount()<=1)
{
// we couldn't find any other matching files
// just do the default...
if (!svn.Move(CTSVNPathList(cmdLinePath), destinationPath, TRUE, sMsg))
{
TRACE(_T("%s\n"), (LPCTSTR)svn.GetLastErrorMessage());
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
}
else
{
bRet = true;
CShellUpdater::Instance().AddPathForUpdate(destinationPath);
}
}
else
{
std::map<CString, CString> renmap;
CString sTemp;
CString sRenList;
for (int i=0; i<renlist.GetCount(); ++i)
{
CString sFilename = renlist[i].GetFilename();
CString sNewFilename = sNewMask + sFilename.Mid(sFilemask.GetLength());
sTemp.Format(_T("\n%s -> %s"), (LPCTSTR)sFilename, (LPCTSTR)sNewFilename);
if (!renlist[i].IsEquivalentTo(cmdLinePath))
sRenList += sTemp;
renmap[renlist[i].GetWinPathString()] = renlist[i].GetContainingDirectory().GetWinPathString()+_T("\\")+sNewFilename;
}
CString sRenameMultipleQuestion;
sRenameMultipleQuestion.Format(IDS_PROC_MULTIRENAME, (LPCTSTR)sRenList);
UINT idret = CMessageBox::Show(hwndExplorer, sRenameMultipleQuestion, _T("TortoiseGit"), MB_ICONQUESTION|MB_YESNOCANCEL);
if (idret == IDYES)
{
CProgressDlg progress;
progress.SetTitle(IDS_PROC_MOVING);
progress.SetAnimation(IDR_MOVEANI);
progress.SetTime(true);
progress.ShowModeless(CWnd::FromHandle(hwndExplorer));
DWORD count = 1;
for (std::map<CString, CString>::iterator it=renmap.begin(); it != renmap.end(); ++it)
{
progress.FormatPathLine(1, IDS_PROC_MOVINGPROG, (LPCTSTR)it->first);
progress.FormatPathLine(2, IDS_PROC_CPYMVPROG2, (LPCTSTR)it->second);
progress.SetProgress(count, renmap.size());
if (!svn.Move(CTSVNPathList(CTSVNPath(it->first)), CTSVNPath(it->second), TRUE, sMsg))
{
if (svn.Err->apr_err == SVN_ERR_ENTRY_NOT_FOUND)
{
bRet = !!MoveFile(it->first, it->second);
}
else
{
TRACE(_T("%s\n"), (LPCTSTR)svn.GetLastErrorMessage());
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
bRet = false;
}
}
else
{
bRet = true;
CShellUpdater::Instance().AddPathForUpdate(CTSVNPath(it->second));
}
}
progress.Stop();
}
else if (idret == IDNO)
{
// no, user wants to just rename the file he selected
if (!svn.Move(CTSVNPathList(cmdLinePath), destinationPath, TRUE, sMsg))
{
TRACE(_T("%s\n"), (LPCTSTR)svn.GetLastErrorMessage());
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
}
else
{
bRet = true;
CShellUpdater::Instance().AddPathForUpdate(destinationPath);
}
}
else if (idret == IDCANCEL)
{
// nothing
}
}
}
}
}
#endif
CShellUpdater::Instance().Flush();
return bRet;
}
bool CopyCommand::Execute()
{
bool bRet = false;
CString msg;
if (parser.HasKey(_T("logmsg")))
{
msg = parser.GetVal(_T("logmsg"));
}
if (parser.HasKey(_T("logmsgfile")))
{
CString logmsgfile = parser.GetVal(_T("logmsgfile"));
CStringUtils::ReadStringFromTextFile(logmsgfile, msg);
}
BOOL repeat = FALSE;
CCopyDlg dlg;
dlg.m_sLogMessage = msg;
dlg.m_path = cmdLinePath;
CString url = parser.GetVal(_T("url"));
CString logmessage;
SVNRev copyRev = SVNRev::REV_HEAD;
BOOL doSwitch = FALSE;
do
{
repeat = FALSE;
dlg.m_URL = url;
dlg.m_sLogMessage = logmessage;
dlg.m_CopyRev = copyRev;
dlg.m_bDoSwitch = doSwitch;
if (dlg.DoModal() == IDOK)
{
theApp.m_pMainWnd = NULL;
TRACE(_T("copy %s to %s\n"), (LPCTSTR)cmdLinePath.GetWinPathString(), (LPCTSTR)dlg.m_URL);
CSVNProgressDlg progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Copy);
if (parser.HasVal(_T("closeonend")))
progDlg.SetAutoClose(parser.GetLongVal(_T("closeonend")));
progDlg.SetOptions(dlg.m_bDoSwitch ? ProgOptSwitchAfterCopy : ProgOptNone);
progDlg.SetPathList(pathList);
progDlg.SetUrl(dlg.m_URL);
progDlg.SetCommitMessage(dlg.m_sLogMessage);
progDlg.SetRevision(dlg.m_CopyRev);
url = dlg.m_URL;
logmessage = dlg.m_sLogMessage;
copyRev = dlg.m_CopyRev;
doSwitch = dlg.m_bDoSwitch;
progDlg.DoModal();
CRegDWORD err = CRegDWORD(_T("Software\\TortoiseGit\\ErrorOccurred"), FALSE);
err = (DWORD)progDlg.DidErrorsOccur();
bRet = !progDlg.DidErrorsOccur();
repeat = progDlg.DidErrorsOccur();
CRegDWORD bFailRepeat = CRegDWORD(_T("Software\\TortoiseGit\\CommitReopen"), FALSE);
if (DWORD(bFailRepeat) == FALSE)
repeat = false; // do not repeat if the user chose not to in the settings.
}
} while(repeat);
return bRet;
}
void CMergeWizardOptions::OnBnClickedDryrun()
{
UpdateData();
CMergeWizard * pWizard = ((CMergeWizard*)GetParent());
CSVNProgressDlg progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Merge);
int options = ProgOptDryRun;
options |= pWizard->m_bIgnoreAncestry ? ProgOptIgnoreAncestry : 0;
options |= pWizard->m_bRecordOnly ? ProgOptRecordOnly : 0;
progDlg.SetOptions(options);
progDlg.SetPathList(CTSVNPathList(pWizard->wcPath));
progDlg.SetUrl(pWizard->URL1);
progDlg.SetSecondUrl(pWizard->URL2);
switch (pWizard->nRevRangeMerge)
{
case MERGEWIZARD_REVRANGE:
{
if (pWizard->revRangeArray.GetCount())
{
SVNRevRangeArray tempRevArray = pWizard->revRangeArray;
tempRevArray.AdjustForMerge(!!pWizard->bReverseMerge);
progDlg.SetRevisionRanges(tempRevArray);
}
else
{
SVNRevRangeArray tempRevArray;
tempRevArray.AddRevRange(1, SVNRev::REV_HEAD);
progDlg.SetRevisionRanges(tempRevArray);
}
}
break;
case MERGEWIZARD_TREE:
{
progDlg.SetRevision(pWizard->startRev);
progDlg.SetRevisionEnd(pWizard->endRev);
if (pWizard->URL1.Compare(pWizard->URL2) == 0)
{
SVNRevRangeArray tempRevArray;
tempRevArray.AdjustForMerge(!!pWizard->bReverseMerge);
tempRevArray.AddRevRange(pWizard->startRev, pWizard->endRev);
progDlg.SetRevisionRanges(tempRevArray);
}
}
break;
case MERGEWIZARD_REINTEGRATE:
{
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_MergeReintegrate);
}
break;
}
progDlg.SetDepth(pWizard->m_depth);
progDlg.SetDiffOptions(SVN::GetOptionsString(pWizard->m_bIgnoreEOL, pWizard->m_IgnoreSpaces));
progDlg.DoModal();
}
bool RenameCommand::Execute()
{
bool bRet = false;
CString filename = cmdLinePath.GetFileOrDirectoryName();
CString basePath = cmdLinePath.GetContainingDirectory().GetWinPathString();
::SetCurrentDirectory(basePath);
// show the rename dialog until the user either cancels or enters a new
// name (one that's different to the original name
CString sNewName;
do
{
CRenameDlg dlg;
dlg.m_name = filename;
if (!SVN::PathIsURL(cmdLinePath))
dlg.SetFileSystemAutoComplete();
if (dlg.DoModal() != IDOK)
return FALSE;
sNewName = dlg.m_name;
} while(PathIsRelative(sNewName) && !PathIsURL(sNewName) && (sNewName.IsEmpty() || (sNewName.Compare(filename)==0)));
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": rename file %s to %s\n", (LPCTSTR)cmdLinePath.GetWinPathString(), (LPCTSTR)sNewName);
CTSVNPath destinationPath(basePath);
if (PathIsRelative(sNewName) && !PathIsURL(sNewName))
destinationPath.AppendPathString(sNewName);
else
destinationPath.SetFromWin(sNewName);
CString sMsg;
if (SVN::PathIsURL(cmdLinePath))
{
// rename an URL.
// Ask for a commit message, then rename directly in
// the repository
CInputLogDlg input;
CString sUUID;
SVN svn;
svn.GetRepositoryRootAndUUID(cmdLinePath, true, sUUID);
input.SetUUID(sUUID);
CString sHint;
sHint.FormatMessage(IDS_INPUT_MOVE, (LPCTSTR)cmdLinePath.GetSVNPathString(), (LPCTSTR)destinationPath.GetSVNPathString());
input.SetActionText(sHint);
if (input.DoModal() == IDOK)
{
sMsg = input.GetLogMessage();
}
else
{
return FALSE;
}
}
if ((cmdLinePath.IsDirectory())||(pathList.GetCount() > 1))
{
// renaming a directory can take a while: use the
// progress dialog to show the progress of the renaming
// operation.
CSVNProgressDlg progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Rename);
progDlg.SetAutoClose (parser);
progDlg.SetPathList(pathList);
progDlg.SetUrl(destinationPath.GetWinPathString());
progDlg.SetCommitMessage(sMsg);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
else
{
CString sFilemask = cmdLinePath.GetFilename();
int slashpos = 0;
// find out up to which char sFilemask and sNewName are identical
int minlen = min(sFilemask.GetLength(), sNewName.GetLength());
for (; slashpos < minlen; ++slashpos)
{
if (sFilemask[slashpos] != sNewName[slashpos])
break;
}
if (sFilemask.ReverseFind('.') >= slashpos)
{
while (sFilemask.ReverseFind('.') >= slashpos)
sFilemask = sFilemask.Left(sFilemask.ReverseFind('.'));
}
else
sFilemask.Empty();
CString sNewMask = sNewName;
if (sNewMask.ReverseFind('.') >= slashpos)
{
while (sNewMask.ReverseFind('.') >= slashpos)
sNewMask = sNewMask.Left(sNewMask.ReverseFind('.'));
}
else
sNewMask.Empty();
CString sRightPartNew = sNewName.Mid(sNewMask.GetLength());
CString sRightPartOld = cmdLinePath.GetFilename().Mid(sFilemask.GetLength());
// if the file extension changed, or the old and new right parts are not the
// same then we can not correctly guess the new names of similar files, so
// just do the plain rename of the selected file and don't offer to rename similar ones.
if (((!sFilemask.IsEmpty()) && (parser.HasKey(L"noquestion"))) ||
(cmdLinePath.GetFileExtension().Compare(destinationPath.GetFileExtension())!=0) ||
(sRightPartOld.CompareNoCase(sRightPartNew)))
{
if (RenameWithReplace(GetExplorerHWND(), CTSVNPathList(cmdLinePath), destinationPath, sMsg))
bRet = true;
}
else
{
// when refactoring, multiple files have to be renamed
// at once because those files belong together.
// e.g. file.aspx, file.aspx.cs, file.aspx.resx
CTSVNPathList renlist;
CSimpleFileFind filefind(cmdLinePath.GetDirectory().GetWinPathString(), sFilemask+L".*");
while (filefind.FindNextFileNoDots())
{
if (!filefind.IsDirectory())
renlist.AddPath(CTSVNPath(filefind.GetFilePath()));
}
if ((renlist.GetCount() <= 1) ||
(renlist.GetCount() > 10)) // arbitrary value of ten
{
// Either no matching files to rename, or way too many of them:
// just do the default...
if (RenameWithReplace(GetExplorerHWND(), CTSVNPathList(cmdLinePath), destinationPath, sMsg))
{
bRet = true;
CShellUpdater::Instance().AddPathForUpdate(destinationPath);
}
}
else
{
std::map<CString, CString> renmap;
CString sTemp;
CString sRenList;
for (int i=0; i<renlist.GetCount(); ++i)
{
CString sFilename = renlist[i].GetFilename();
CString sNewFilename = sNewMask + sFilename.Mid(sFilemask.GetLength());
sTemp.Format(L"\n%s -> %s", (LPCTSTR)sFilename, (LPCTSTR)sNewFilename);
if (!renlist[i].IsEquivalentTo(cmdLinePath))
sRenList += sTemp;
renmap[renlist[i].GetWinPathString()] = renlist[i].GetContainingDirectory().GetWinPathString()+L"\\"+sNewFilename;
}
CString sRenameMultipleQuestion;
sRenameMultipleQuestion.Format(IDS_PROC_MULTIRENAME, (LPCTSTR)sRenList);
UINT idret = ::MessageBox(GetExplorerHWND(), sRenameMultipleQuestion, L"TortoiseSVN", MB_ICONQUESTION|MB_YESNOCANCEL);
if (idret == IDYES)
{
CProgressDlg progress;
progress.SetTitle(IDS_PROC_MOVING);
progress.SetTime(true);
progress.ShowModeless(CWnd::FromHandle(GetExplorerHWND()));
DWORD count = 1;
for (std::map<CString, CString>::iterator it=renmap.begin(); it != renmap.end(); ++it)
{
progress.FormatPathLine(1, IDS_PROC_MOVINGPROG, (LPCTSTR)it->first);
progress.FormatPathLine(2, IDS_PROC_CPYMVPROG2, (LPCTSTR)it->second);
progress.SetProgress64(count, renmap.size());
if (RenameWithReplace(GetExplorerHWND(), CTSVNPathList(CTSVNPath(it->first)), CTSVNPath(it->second), sMsg))
{
bRet = true;
CShellUpdater::Instance().AddPathForUpdate(CTSVNPath(it->second));
}
}
progress.Stop();
}
else if (idret == IDNO)
{
// no, user wants to just rename the file he selected
if (RenameWithReplace(GetExplorerHWND(), CTSVNPathList(cmdLinePath), destinationPath, sMsg))
{
bRet = true;
CShellUpdater::Instance().AddPathForUpdate(destinationPath);
}
}
else if (idret == IDCANCEL)
{
// nothing
}
}
}
}
return bRet;
}
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 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;
}
