HRESULT CNewTreeConflictEditorDlg::OnButtonClicked(HWND hWnd, int id)
{
for (SVNConflictOptions::const_iterator it = m_options.begin(); it != m_options.end(); ++it)
{
svn_client_conflict_option_id_t optionId = (*it)->GetId();
if (optionId + 100 == id)
{
if (m_svn)
{
if (!m_svn->ResolveTreeConflict(*m_conflictInfo, *it->get()))
{
m_svn->ShowErrorDialog(hWnd);
return S_FALSE;
}
}
else
{
SVN svn;
if (!svn.ResolveTreeConflict(*m_conflictInfo, *it->get()))
{
svn.ShowErrorDialog(hWnd);
return S_FALSE;
}
}
m_choice = optionId;
return S_OK;
}
}
return S_OK;
}
void CUpdateDlg::OnBnClickedSparse()
{
UpdateData();
CString strURLs;
CTSVNPathList paths;
paths.LoadFromAsteriskSeparatedString (strURLs);
SVN svn;
CString strUrl = svn.GetURLFromPath(m_wcPath);
CRepositoryBrowser browser(strUrl, SVNRev::REV_HEAD, this);
browser.SetSparseCheckoutMode(m_wcPath);
if (browser.DoModal() == IDOK)
{
m_checkoutDepths = browser.GetUpdateDepths();
CString sCustomDepth = CString(MAKEINTRESOURCE(IDS_SVN_DEPTH_CUSTOM));
int customIndex = m_depthCombo.FindStringExact(-1, sCustomDepth);
if (customIndex == CB_ERR)
{
customIndex = m_depthCombo.AddString(sCustomDepth);
}
m_depthCombo.SetCurSel(customIndex);
}
}
int main ( int argc, const char* argv[] )
{
Configuration config ( "svnbot.conf" );
if ( config.isOk () )
{
struct SVNData
{
SVN svn;
int lastRev;
};
SkypeConnector connector ( config.getSkypeName().c_str() );
// Load the repositories from the config and get the initial revision
puts ( "Fetching initial revisions...");
std::map<std::string, SVNData> repos;
for ( auto& repo : config.getRepos() )
{
printf ( "\t[%s] ", repo.first.c_str() );
fflush ( stdout );
SVN svn ( repo.second );
int lastRev = svn.getRevision ();
printf ( "%d\n", lastRev );
repos[repo.first] = {svn, lastRev};
}
// Poll
while ( true )
{
puts ( "Polling...");
for ( auto& repo : repos )
{
printf ( "\t[%s] %d -> ", repo.first.c_str(), repo.second.lastRev );
fflush ( stdout );
auto& data = repo.second;
int rev = data.svn.getRevision ();
printf ( "%d\n", rev );
while ( rev > data.lastRev )
{
data.lastRev++;
std::string log;
data.svn.getLog ( data.lastRev, &log );
if ( log.length() > 0 )
connector.send ( "CHATMESSAGE %s [%s]\n%s", config.getSkypeChannel().c_str(), repo.first.c_str(), log.c_str() );
}
}
sleep ( config.getPollInterval() );
}
}
return EXIT_SUCCESS;
}
HRESULT CTextConflictEditorDlg::OnButtonClicked(HWND hWnd, int id)
{
if (id == 1000)
{
// Edit conflicts
CTSVNPath theirs, mine, base;
m_merged = m_conflictInfo->GetPath();
m_conflictInfo->GetTextContentFiles(base, theirs, mine);
m_mergedCreationTime = m_merged.GetLastWriteTime();
::SendMessage(hWnd, TDM_ENABLE_BUTTON, 100 + svn_client_conflict_option_merged_text, 0);
CString filename, n1, n2, n3, n4;
filename = m_merged.GetUIFileOrDirectoryName();
n1.Format(IDS_DIFF_WCNAME, (LPCTSTR)filename);
n2.Format(IDS_DIFF_BASENAME, (LPCTSTR)filename);
n3.Format(IDS_DIFF_REMOTENAME, (LPCTSTR)filename);
n4.Format(IDS_DIFF_MERGEDNAME, (LPCTSTR)filename);
CAppUtils::MergeFlags flags;
flags.AlternativeTool((GetKeyState(VK_SHIFT) & 0x8000) != 0);
flags.PreventSVNResolve(true);
CAppUtils::StartExtMerge(flags,
base, theirs, mine, m_merged, true, n1, n1, n3, n4, filename);
return S_FALSE;
}
for (SVNConflictOptions::const_iterator it = m_options.begin(); it != m_options.end(); ++it)
{
svn_client_conflict_option_id_t optionId = (*it)->GetId();
int buttonID = 100 + optionId;
if (buttonID == id)
{
if (m_svn)
{
if (!m_svn->ResolveTextConflict(*m_conflictInfo, *it->get()))
{
m_svn->ShowErrorDialog(hWnd);
return S_FALSE;
}
}
else
{
SVN svn;
if (!svn.ResolveTextConflict(*m_conflictInfo, *it->get()))
{
svn.ShowErrorDialog(hWnd);
return S_FALSE;
}
}
m_choice = optionId;
return S_OK;
}
}
return S_OK;
}
bool RenameCommand::RenameWithReplace(HWND hWnd, const CTSVNPathList &srcPathList,
const CTSVNPath &destPath,
const CString &message /* = L"" */,
bool move_as_child /* = false */,
bool make_parents /* = false */) const
{
SVN svn;
UINT idret = IDYES;
bool bRet = true;
if (destPath.Exists() && !destPath.IsDirectory() && !destPath.IsEquivalentToWithoutCase(srcPathList[0]))
{
CString sReplace;
sReplace.Format(IDS_PROC_REPLACEEXISTING, destPath.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);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_PROC_REPLACEEXISTING_TASK3)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_PROC_REPLACEEXISTING_TASK4)));
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetDefaultCommandControl(2);
taskdlg.SetMainIcon(TD_WARNING_ICON);
INT_PTR ret = taskdlg.DoModal(hWnd);
if (ret == 1) // replace
idret = IDYES;
else
idret = IDNO;
if (idret == IDYES)
{
if (!svn.Remove(CTSVNPathList(destPath), true, false))
{
destPath.Delete(true);
}
}
}
if ((idret != IDNO)&&(!svn.Move(srcPathList, destPath, message, move_as_child, make_parents)))
{
auto apr_err = svn.GetSVNError()->apr_err;
if ((apr_err == SVN_ERR_ENTRY_NOT_FOUND) || (apr_err == SVN_ERR_WC_PATH_NOT_FOUND))
{
bRet = !!MoveFile(srcPathList[0].GetWinPath(), destPath.GetWinPath());
}
else
{
svn.ShowErrorDialog(hWnd, srcPathList.GetCommonDirectory());
bRet = false;
}
}
if (idret == IDNO)
bRet = false;
return bRet;
}
void CRevisionGraphDlg::UpdateFullHistory()
{
m_Graph.SetDlgTitle (false);
SVN svn;
LogCache::CRepositoryInfo& cachedProperties
= svn.GetLogCachePool()->GetRepositoryInfo();
CString root = m_Graph.m_state.GetRepositoryRoot();
CString uuid = m_Graph.m_state.GetRepositoryUUID();
cachedProperties.ResetHeadRevision (uuid, root);
m_bFetchLogs = true;
StartWorkerThread();
}
bool CRevisionGraphWnd::FetchRevisionData
( const CString& path
, SVNRev pegRevision
, CProgressDlg* progress
, ITaskbarList3 * pTaskbarList
, HWND hWnd)
{
// (re-)fetch the data
SVN svn;
if (svn.GetRepositoryRoot(CTSVNPath(path)) == svn.GetURLFromPath(CTSVNPath(path)))
{
m_state.SetLastErrorMessage(CString(MAKEINTRESOURCE(IDS_REVGRAPH_ERR_NOGRAPHFORROOT)));
return false;
}
std::unique_ptr<CFullHistory> newFullHistory (new CFullHistory());
bool showWCRev
= m_state.GetOptions()->GetOption<CShowWC>()->IsSelected();
bool showWCModification
= m_state.GetOptions()->GetOption<CShowWCModification>()->IsSelected();
bool result = newFullHistory->FetchRevisionData ( path
, pegRevision
, showWCRev
, showWCModification
, progress
, pTaskbarList
, hWnd);
m_state.SetLastErrorMessage (newFullHistory->GetLastErrorMessage());
if (result)
{
std::unique_ptr<CFullGraph> newFullGraph (new CFullGraph());
CFullGraphBuilder builder (*newFullHistory, *newFullGraph);
builder.Run();
CFullGraphFinalizer finalizer (*newFullHistory, *newFullGraph);
finalizer.Run();
m_state.SetQueryResult ( newFullHistory
, newFullGraph
, showWCRev || showWCModification);
}
return result;
}
void CSettingsLogCaches::OnBnClickedExport()
{
TRepo repo = GetSelectedRepo();
if (!repo.first.IsEmpty())
{
CString path;
if (CAppUtils::FileOpenSave(path, NULL, IDS_SETTINGS_LOGCACHE_EXPORT, IDS_LOGCACHE_EXPORTFILTER, false, CString(), GetSafeHwnd()))
{
SVN svn;
CCachedLogInfo* cache
= svn.GetLogCachePool()->GetCache (repo.second, repo.first);
CCSVWriter writer;
writer.Write(*cache, (LPCTSTR)path);
}
}
}
void CEditPropExternals::OnBnClickedFindhead()
{
CProgressDlg progDlg;
progDlg.ShowModal(m_hWnd, TRUE);
progDlg.SetTitle(IDS_EDITPROPS_PROG_FINDHEADTITLE);
progDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_EDITPROPS_PROG_FINDHEADROOTS)));
DWORD count = 0;
DWORD total = (DWORD)m_externals.size()*4;
SVN svn;
svn.SetPromptParentWindow(m_hWnd);
SVNInfo svnInfo;
svnInfo.SetPromptParentWindow(m_hWnd);
for (auto it = m_externals.begin(); it != m_externals.end(); ++it)
{
progDlg.SetProgress(count++, total);
if (progDlg.HasUserCancelled())
break;
if (it->root.IsEmpty())
{
CTSVNPath p = it->path;
p.AppendPathString(it->targetDir);
it->root = svn.GetRepositoryRoot(p);
}
}
progDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_EDITPROPS_PROG_FINDHEADREVS)));
SVNLogHelper logHelper;
for (auto it = m_externals.begin(); it != m_externals.end(); ++it)
{
progDlg.SetProgress(count, total);
progDlg.SetLine(2, it->url, true);
if (progDlg.HasUserCancelled())
break;
count += 4;
if (!it->root.IsEmpty())
{
auto youngestRev = logHelper.GetYoungestRev(CTSVNPath(it->fullurl));
if (!youngestRev.IsValid())
it->headrev = svn.GetHEADRevision(CTSVNPath(it->fullurl), true);
else
it->headrev = youngestRev;
}
}
progDlg.Stop();
m_ExtList.Invalidate();
}
bool ShelveCommand::Shelve(const CString& shelveName, const CTSVNPathList& paths)
{
CProgressDlg progDlg;
progDlg.SetTitle(IDS_PROC_PATCHTITLE);
progDlg.SetShowProgressBar(false);
progDlg.ShowModeless(CWnd::FromHandle(GetExplorerHWND()));
CTSVNPath sDir = paths.GetCommonRoot();
SVN svn;
if (!svn.Shelve(shelveName, paths, svn_depth_infinity /*, changelists*/))
{
progDlg.Stop();
svn.ShowErrorDialog(GetExplorerHWND(), sDir);
return FALSE;
}
progDlg.Stop();
return TRUE;
}
void CTreeConflictEditorDlg::OnBnClickedResolveusingtheirs()
{
int retVal = IDOK;
if (m_bInteractive)
{
m_choice = svn_wc_conflict_choose_merged;
EndDialog(retVal);
}
else
{
SVN svn;
if (!svn.Resolve(m_path, svn_wc_conflict_choose_merged, false, true, svn_wc_conflict_kind_tree))
{
svn.ShowErrorDialog(m_hWnd, m_path);
retVal = IDCANCEL;
}
else
m_choice = svn_wc_conflict_choose_merged;
EndDialog(retVal);
}
}
BOOL CMergeWizard::OnInitDialog()
{
BOOL bResult = CResizableSheetEx::OnInitDialog();
CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
SVN svn;
url = svn.GetURLFromPath(wcPath);
sUUID = svn.GetUUIDFromPath(wcPath);
MARGINS margs;
margs.cxLeftWidth = 0;
margs.cyTopHeight = 0;
margs.cxRightWidth = 0;
margs.cyBottomHeight = BOTTOMMARG;
if ((DWORD)CRegDWORD(L"Software\\TortoiseSVN\\EnableDWMFrame", TRUE))
{
HIGHCONTRAST hc = { sizeof(HIGHCONTRAST) };
SystemParametersInfo(SPI_GETHIGHCONTRAST, sizeof(HIGHCONTRAST), &hc, FALSE);
BOOL bEnabled = FALSE;
if (((hc.dwFlags & HCF_HIGHCONTRASTON) == 0) && SUCCEEDED(DwmIsCompositionEnabled(&bEnabled)) && bEnabled)
{
DwmExtendFrameIntoClientArea(m_hWnd, &margs);
ShowGrip(false);
}
m_aeroControls.SubclassOkCancelHelp(this);
m_aeroControls.SubclassControl(this, ID_WIZFINISH);
m_aeroControls.SubclassControl(this, ID_WIZBACK);
m_aeroControls.SubclassControl(this, ID_WIZNEXT);
}
if ((m_pParentWnd == NULL) && (GetExplorerHWND()))
CenterWindow(CWnd::FromHandle(GetExplorerHWND()));
EnableSaveRestore(L"MergeWizard");
return bResult;
}
void CSettingsLogCaches::FillRepositoryList()
{
int count = m_cRepositoryList.GetItemCount();
while (count > 0)
m_cRepositoryList.DeleteItem (--count);
SVN svn;
CLogCachePool* caches = svn.GetLogCachePool();
repos = caches->GetRepositoryURLs();
for (IT iter = repos.begin(), end = repos.end(); iter != end; ++iter, ++count)
{
CString url = iter->first;
m_cRepositoryList.InsertItem (count, url);
size_t fileSize = caches->FileSize (iter->second, url) / 1024;
CString sizeText;
sizeText.Format(L"%Iu", fileSize);
m_cRepositoryList.SetItemText (count, 1, sizeText);
}
}
void CCreatePatch::OnOK()
{
if (m_bThreadRunning)
return;
int nListItems = m_PatchList.GetItemCount();
m_filesToRevert.Clear();
for (int j=0; j<nListItems; j++)
{
const CSVNStatusListCtrl::FileEntry * entry = m_PatchList.GetConstListEntry(j);
if (entry->IsChecked())
{
// Unversioned files are not included in the resulting patch file!
// We add those files to a list which will be used to add those files
// before creating the patch.
if ((entry->status == svn_wc_status_none)||(entry->status == svn_wc_status_unversioned))
{
m_filesToRevert.AddPath(entry->GetPath());
}
}
}
if (m_filesToRevert.GetCount())
{
// add all unversioned files to version control
// so they're included in the resulting patch
// NOTE: these files must be reverted after the patch
// has been created! Since this dialog doesn't create the patch
// itself, the calling function is responsible to revert these files!
SVN svn;
svn.Add(m_filesToRevert, NULL, svn_depth_empty, false, false, false, true);
}
//save only the files the user has selected into the path list
m_PatchList.WriteCheckedNamesToPathList(m_pathList);
CResizableStandAloneDialog::OnOK();
}
void CRepoCreationFinished::OnBnClickedCreatefolders()
{
// create the default folder structure in a temp folder
CTSVNPath tempDir = CTempFiles::Instance().GetTempDirPath(true);
if (tempDir.IsEmpty())
{
::MessageBox(m_hWnd, CString(MAKEINTRESOURCE(IDS_ERR_CREATETEMPDIR)), CString(MAKEINTRESOURCE(IDS_APPNAME)), MB_ICONERROR);
return;
}
CTSVNPath tempDirSub = tempDir;
tempDirSub.AppendPathString(L"trunk");
CreateDirectory(tempDirSub.GetWinPath(), NULL);
tempDirSub = tempDir;
tempDirSub.AppendPathString(L"branches");
CreateDirectory(tempDirSub.GetWinPath(), NULL);
tempDirSub = tempDir;
tempDirSub.AppendPathString(L"tags");
CreateDirectory(tempDirSub.GetWinPath(), NULL);
CString url;
if (m_RepoPath.GetWinPathString().GetAt(0) == '\\') // starts with '\' means an UNC path
{
CString p = m_RepoPath.GetWinPathString();
p.TrimLeft('\\');
url = L"file://"+p;
}
else
url = L"file:///"+m_RepoPath.GetWinPathString();
// import the folder structure into the new repository
SVN svn;
if (!svn.Import(tempDir, CTSVNPath(url), CString(MAKEINTRESOURCE(IDS_MSG_IMPORTEDSTRUCTURE)), NULL, svn_depth_infinity, true, true, false))
{
svn.ShowErrorDialog(m_hWnd);
return;
}
MessageBox(CString(MAKEINTRESOURCE(IDS_MSG_IMPORTEDSTRUCTUREFINISHED)), L"TortoiseSVN", MB_ICONINFORMATION);
DialogEnableWindow(IDC_CREATEFOLDERS, FALSE);
}
bool CHooks::PreConnect(const CTSVNPathList& pathList)
{
if ((m_lastPreConnectTicks == 0) || ((GetTickCount64() - m_lastPreConnectTicks) > 5*60*1000))
{
hookiterator it = FindItem(pre_connect_hook, pathList);
if (it == end())
{
if (!m_PathsConvertedToUrls && pathList.GetCount() && pathList[0].IsUrl())
{
SVN svn;
for (hookiterator ith = begin(); ith != end(); ++ith)
{
if (ith->first.htype == pre_connect_hook)
{
CString sUrl = svn.GetURLFromPath(ith->first.path);
hookkey hk;
hk.htype = pre_connect_hook;
hk.path = CTSVNPath(sUrl);
insert(std::pair<hookkey, hookcmd>(hk, ith->second));
}
}
m_PathsConvertedToUrls = true;
it = FindItem(pre_connect_hook, pathList);
if (it == end())
return false;
}
else
return false;
}
CString sCmd = it->second.commandline;
CString error;
RunScript(sCmd, pathList, error, it->second.bWait, it->second.bShow);
m_lastPreConnectTicks = GetTickCount64();
return true;
}
return false;
}
bool PasteMoveCommand::Execute()
{
CString sDroppath = parser.GetVal(L"droptarget");
CTSVNPath dropPath(sDroppath);
ProjectProperties props;
props.ReadProps(dropPath);
if (dropPath.IsAdminDir())
return FALSE;
SVN svn;
SVNStatus status;
unsigned long count = 0;
pathList.RemoveAdminPaths();
CString sNewName;
CProgressDlg progress;
progress.SetTitle(IDS_PROC_MOVING);
progress.SetTime(true);
progress.ShowModeless(CWnd::FromHandle(GetExplorerHWND()));
for(int nPath = 0; nPath < pathList.GetCount(); nPath++)
{
CTSVNPath destPath;
if (sNewName.IsEmpty())
destPath = CTSVNPath(sDroppath+L"\\"+pathList[nPath].GetFileOrDirectoryName());
else
destPath = CTSVNPath(sDroppath+L"\\"+sNewName);
if (destPath.Exists())
{
CString name = pathList[nPath].GetFileOrDirectoryName();
if (!sNewName.IsEmpty())
name = sNewName;
progress.Stop();
CRenameDlg dlg;
dlg.SetFileSystemAutoComplete();
dlg.m_name = name;
dlg.SetInputValidator(this);
m_renPath = pathList[nPath];
dlg.m_windowtitle.Format(IDS_PROC_NEWNAMEMOVE, (LPCTSTR)name);
if (dlg.DoModal() != IDOK)
{
return FALSE;
}
destPath.SetFromWin(sDroppath+L"\\"+dlg.m_name);
}
svn_wc_status_kind s = status.GetAllStatus(pathList[nPath]);
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
MoveFile(pathList[nPath].GetWinPath(), destPath.GetWinPath());
if (!svn.Add(CTSVNPathList(destPath), &props, svn_depth_infinity, true, true, false, true))
{
svn.ShowErrorDialog(GetExplorerHWND());
return FALSE; //get out of here
}
CShellUpdater::Instance().AddPathForUpdate(destPath);
}
else
{
if (!svn.Move(CTSVNPathList(pathList[nPath]), destPath))
{
svn.ShowErrorDialog(GetExplorerHWND());
return FALSE; //get out of here
}
else
CShellUpdater::Instance().AddPathForUpdate(destPath);
}
count++;
if (progress.IsValid())
{
progress.FormatPathLine(1, IDS_PROC_MOVINGPROG, pathList[nPath].GetWinPath());
progress.FormatPathLine(2, IDS_PROC_CPYMVPROG2, destPath.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;
}
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 RepositoryBrowserCommand::Execute()
{
CString url;
SVN svn;
if (!cmdLinePath.IsEmpty())
{
if (cmdLinePath.GetSVNPathString().Left(4).CompareNoCase(_T("svn:"))==0)
{
// If the path starts with "svn:" and there is another protocol
// found in the path (a "://" found after the "svn:") then
// remove "svn:" from the beginning of the path.
if (cmdLinePath.GetSVNPathString().Find(_T("://"), 4)>=0)
cmdLinePath.SetFromSVN(cmdLinePath.GetSVNPathString().Mid(4));
}
url = svn.GetURLFromPath(cmdLinePath);
if (url.IsEmpty())
{
if (SVN::PathIsURL(cmdLinePath))
url = cmdLinePath.GetSVNPathString();
else if (svn.IsRepository(cmdLinePath))
{
// 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('\\', '/');
}
}
}
if (cmdLinePath.GetUIPathString().Left(7).CompareNoCase(_T("file://"))==0)
{
cmdLinePath.SetFromUnknown(cmdLinePath.GetUIPathString().Mid(7));
}
if (url.IsEmpty())
{
CURLDlg urldlg;
if (urldlg.DoModal() != IDOK)
{
return false;
}
url = urldlg.m_url;
cmdLinePath = CTSVNPath(url);
}
CString val = parser.GetVal(_T("rev"));
SVNRev rev(val);
CRepositoryBrowser dlg(url, rev);
if (!cmdLinePath.IsUrl())
dlg.m_ProjectProperties.ReadProps(cmdLinePath);
else
{
if (parser.HasVal(_T("projectpropertiespath")))
{
dlg.m_ProjectProperties.ReadProps(CTSVNPath(parser.GetVal(_T("projectpropertiespath"))));
}
}
if (parser.HasKey(L"sparse"))
{
if (SVN::PathIsURL(cmdLinePath))
dlg.SetSparseCheckoutMode(CTSVNPath());
else
dlg.SetSparseCheckoutMode(cmdLinePath);
}
dlg.m_path = cmdLinePath;
dlg.DoModal();
if (parser.HasVal(L"outfile"))
{
CString sText = dlg.GetPath();
sText += L"\n";
sText += dlg.GetRevision().ToString();
CStringUtils::WriteStringToTextFile(parser.GetVal(L"outfile"), (LPCTSTR)sText, true);
}
return true;
}
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 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 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 CleanupCommand::Execute()
{
bool bRet = false;
CCleanTypeDlg dlg;
if( dlg.DoModal() == IDOK)
{
bool quotepath = g_Git.GetConfigValueBool(_T("core.quotepath"));
CString cmd;
cmd.Format(_T("git.exe clean"));
if (dlg.m_bDryRun || !dlg.m_bNoRecycleBin)
cmd += _T(" -n ");
if(dlg.m_bDir)
cmd += _T(" -d ");
switch(dlg.m_CleanType)
{
case 0:
cmd += _T(" -fx");
break;
case 1:
cmd += _T(" -f");
break;
case 2:
cmd += _T(" -fX");
break;
}
STRING_VECTOR submoduleList;
SubmodulePayload payload(submoduleList);
if (dlg.m_bSubmodules)
{
payload.basePath = CTGitPath(g_Git.m_CurrentDir).GetGitPathString();
if (pathList.GetCount() != 1 || pathList.GetCount() == 1 && !pathList[0].IsEmpty())
{
for (int i = 0; i < pathList.GetCount(); ++i)
{
CString path;
if (pathList[i].IsDirectory())
payload.prefixList.push_back(pathList[i].GetGitPathString());
else
payload.prefixList.push_back(pathList[i].GetContainingDirectory().GetGitPathString());
}
}
if (!GetSubmodulePathList(payload))
return FALSE;
std::sort(submoduleList.begin(), submoduleList.end());
}
if (dlg.m_bDryRun || dlg.m_bNoRecycleBin)
{
while (true)
{
CProgressDlg progress;
for (int i = 0; i < this->pathList.GetCount(); ++i)
{
CString path;
if (this->pathList[i].IsDirectory())
path = pathList[i].GetGitPathString();
else
path = pathList[i].GetContainingDirectory().GetGitPathString();
progress.m_GitDirList.push_back(g_Git.m_CurrentDir);
progress.m_GitCmdList.push_back(cmd + _T(" \"") + path + _T("\""));
}
if (dlg.m_bSubmodules)
{
for (CString dir : submoduleList)
{
progress.m_GitDirList.push_back(CTGitPath(dir).GetWinPathString());
progress.m_GitCmdList.push_back(cmd);
}
}
INT_PTR idRetry = -1;
if (!dlg.m_bDryRun)
idRetry = progress.m_PostFailCmdList.Add(CString(MAKEINTRESOURCE(IDS_MSGBOX_RETRY)));
INT_PTR result = progress.DoModal();
if (result == IDOK)
return TRUE;
if (progress.m_GitStatus && result == IDC_PROGRESS_BUTTON1 + idRetry)
continue;
break;
}
}
else
{
CSysProgressDlg sysProgressDlg;
sysProgressDlg.SetAnimation(IDR_CLEANUPANI);
sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_CLEANUP_INFO1)));
sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
sysProgressDlg.SetShowProgressBar(false);
sysProgressDlg.ShowModeless((HWND)NULL, true);
CTGitPathList delList;
for (size_t i = 0; i <= submoduleList.size(); ++i)
{
CGit git;
CGit *pGit;
if (i == 0)
pGit = &g_Git;
else
{
git.m_CurrentDir = submoduleList[i - 1];
pGit = &git;
}
CString cmdout, cmdouterr;
if (pGit->Run(cmd, &cmdout, &cmdouterr, CP_UTF8))
{
MessageBox(nullptr, cmdouterr, _T("TortoiseGit"), MB_ICONERROR);
return FALSE;
}
if (sysProgressDlg.HasUserCancelled())
{
CMessageBox::Show(nullptr, IDS_SVN_USERCANCELLED, IDS_APPNAME, MB_OK);
return FALSE;
}
int pos = 0;
CString token = cmdout.Tokenize(_T("\n"), pos);
while (!token.IsEmpty())
{
if (token.Mid(0, 13) == _T("Would remove "))
{
CString tempPath = token.Mid(13).TrimRight();
if (quotepath)
{
tempPath = UnescapeQuotePath(tempPath.Trim(_T('"')));
}
if (i == 0)
delList.AddPath(CTGitPath(tempPath));
else
delList.AddPath(CTGitPath(submoduleList[i - 1] + "/" + tempPath));
}
token = cmdout.Tokenize(_T("\n"), pos);
}
if (sysProgressDlg.HasUserCancelled())
{
CMessageBox::Show(nullptr, IDS_SVN_USERCANCELLED, IDS_APPNAME, MB_OK);
return FALSE;
}
}
delList.DeleteAllFiles(true, false);
sysProgressDlg.Stop();
}
}
#if 0
CProgressDlg progress;
progress.SetTitle(IDS_PROC_CLEANUP);
progress.SetAnimation(IDR_CLEANUPANI);
progress.SetShowProgressBar(false);
progress.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_CLEANUP_INFO1)));
progress.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROC_CLEANUP_INFO2)));
progress.ShowModeless(hwndExplorer);
CString strSuccessfullPaths, strFailedPaths;
for (int i=0; i<pathList.GetCount(); ++i)
{
SVN svn;
if (!svn.CleanUp(pathList[i]))
{
strFailedPaths += _T("- ") + pathList[i].GetWinPathString() + _T("\n");
strFailedPaths += svn.GetLastErrorMessage() + _T("\n\n");
}
else
{
strSuccessfullPaths += _T("- ") + pathList[i].GetWinPathString() + _T("\n");
// after the cleanup has finished, crawl the path downwards and send a change
// notification for every directory to the shell. This will update the
// overlays in the left tree view of the explorer.
CDirFileEnum crawler(pathList[i].GetWinPathString());
CString sPath;
bool bDir = false;
CTSVNPathList updateList;
while (crawler.NextFile(sPath, &bDir))
{
if ((bDir) && (!g_SVNAdminDir.IsAdminDirPath(sPath)))
{
updateList.AddPath(CTSVNPath(sPath));
}
}
updateList.AddPath(pathList[i]);
CShellUpdater::Instance().AddPathsForUpdate(updateList);
CShellUpdater::Instance().Flush();
updateList.SortByPathname(true);
for (INT_PTR i=0; i<updateList.GetCount(); ++i)
{
SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH, updateList[i].GetWinPath(), NULL);
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": notify change for path %s\n"), updateList[i].GetWinPath());
}
}
}
progress.Stop();
CString strMessage;
if ( !strSuccessfullPaths.IsEmpty() )
{
CString tmp;
tmp.Format(IDS_PROC_CLEANUPFINISHED, (LPCTSTR)strSuccessfullPaths);
strMessage += tmp;
bRet = true;
}
if ( !strFailedPaths.IsEmpty() )
{
if (!strMessage.IsEmpty())
strMessage += _T("\n");
CString tmp;
tmp.Format(IDS_PROC_CLEANUPFINISHED_FAILED, (LPCTSTR)strFailedPaths);
strMessage += tmp;
bRet = false;
}
CMessageBox::Show(hwndExplorer, strMessage, _T("TortoiseGit"), MB_OK | (strFailedPaths.IsEmpty()?MB_ICONINFORMATION:MB_ICONERROR));
#endif
CShellUpdater::Instance().Flush();
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;
}
BOOL CCopyDlg::OnInitDialog()
{
CResizableStandAloneDialog::OnInitDialog();
CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
ExtendFrameIntoClientArea(IDC_EXTGROUP);
m_aeroControls.SubclassControl(this, IDC_DOSWITCH);
m_aeroControls.SubclassControl(this, IDC_MAKEPARENTS);
m_aeroControls.SubclassOkCancelHelp(this);
m_bCancelled = false;
DWORD exStyle = LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER | LVS_EX_CHECKBOXES;
m_ExtList.SetExtendedStyle(exStyle);
SetWindowTheme(m_ExtList.GetSafeHwnd(), L"Explorer", NULL);
m_ExtList.ShowText(CString(MAKEINTRESOURCE(IDS_COPY_WAITFOREXTERNALS)));
AdjustControlSize(IDC_COPYHEAD);
AdjustControlSize(IDC_COPYREV);
AdjustControlSize(IDC_COPYWC);
AdjustControlSize(IDC_DOSWITCH);
AdjustControlSize(IDC_MAKEPARENTS);
CTSVNPath path(m_path);
CString sWindowTitle;
GetWindowText(sWindowTitle);
CAppUtils::SetWindowTitle(m_hWnd, path.GetUIPathString(), sWindowTitle);
m_History.SetMaxHistoryItems((LONG)CRegDWORD(L"Software\\TortoiseSVN\\MaxHistoryItems", 25));
SetRevision(m_CopyRev);
m_tooltips.AddTool(IDC_HISTORY, IDS_COMMITDLG_HISTORY_TT);
if (SVN::PathIsURL(path))
{
DialogEnableWindow(IDC_COPYWC, FALSE);
DialogEnableWindow(IDC_DOSWITCH, FALSE);
SetDlgItemText(IDC_COPYSTARTLABEL, CString(MAKEINTRESOURCE(IDS_COPYDLG_FROMURL)));
}
SVN svn;
CString sUUID;
m_repoRoot = svn.GetRepositoryRootAndUUID(path, true, sUUID);
m_repoRoot.TrimRight('/');
m_wcURL = svn.GetURLFromPath(path);
if (m_wcURL.IsEmpty() || (!path.IsUrl() && !path.Exists()))
{
CString Wrong_URL=path.GetSVNPathString();
CString temp;
temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)Wrong_URL);
::MessageBox(this->m_hWnd, temp, L"TortoiseSVN", MB_ICONERROR);
this->EndDialog(IDCANCEL); //exit
}
m_URLCombo.LoadHistory(L"Software\\TortoiseSVN\\History\\repoPaths\\"+sUUID, L"url");
m_URLCombo.SetCurSel(0);
CString relPath = m_wcURL.Mid(m_repoRoot.GetLength());
if (!m_URL.IsEmpty())
{
// allow the use of urls relative to the repo root
if (m_URL[0] != '^')
relPath = m_URL.Mid(m_repoRoot.GetLength());
else
relPath = m_URL.Mid(1);
}
CTSVNPath r = CTSVNPath(relPath);
relPath = r.GetUIPathString();
relPath.Replace('\\', '/');
m_URLCombo.AddString(relPath, 0);
m_URLCombo.SelectString(-1, relPath);
m_URL = m_wcURL;
SetDlgItemText(IDC_DESTURL, CPathUtils::CombineUrls(m_repoRoot, relPath));
SetDlgItemText(IDC_FROMURL, m_wcURL);
CString reg;
reg.Format(L"Software\\TortoiseSVN\\History\\commit%s", (LPCTSTR)sUUID);
m_History.Load(reg, L"logmsgs");
m_ProjectProperties.ReadProps(m_path);
if (CRegDWORD(L"Software\\TortoiseSVN\\AlwaysWarnIfNoIssue", FALSE))
m_ProjectProperties.bWarnIfNoIssue = TRUE;
m_cLogMessage.Init(m_ProjectProperties);
m_cLogMessage.SetFont((CString)CRegString(L"Software\\TortoiseSVN\\LogFontName", L"Courier New"), (DWORD)CRegDWORD(L"Software\\TortoiseSVN\\LogFontSize", 8));
GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);
GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);
CBugTraqAssociations bugtraq_associations;
bugtraq_associations.Load(m_ProjectProperties.GetProviderUUID(), m_ProjectProperties.sProviderParams);
if (bugtraq_associations.FindProvider(CTSVNPathList(m_path), &m_bugtraq_association))
{
CComPtr<IBugTraqProvider> pProvider;
HRESULT hr = pProvider.CoCreateInstance(m_bugtraq_association.GetProviderClass());
if (SUCCEEDED(hr))
{
m_BugTraqProvider = pProvider;
ATL::CComBSTR temp;
ATL::CComBSTR parameters;
parameters.Attach(m_bugtraq_association.GetParameters().AllocSysString());
hr = pProvider->GetLinkText(GetSafeHwnd(), parameters, &temp);
if (SUCCEEDED(hr))
{
SetDlgItemText(IDC_BUGTRAQBUTTON, temp == 0 ? L"" : temp);
GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(TRUE);
GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_SHOW);
}
}
GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
}
if (m_ProjectProperties.sMessage.IsEmpty())
{
GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);
GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);
GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
}
else
{
GetDlgItem(IDC_BUGID)->ShowWindow(SW_SHOW);
GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_SHOW);
if (!m_ProjectProperties.sLabel.IsEmpty())
SetDlgItemText(IDC_BUGIDLABEL, m_ProjectProperties.sLabel);
GetDlgItem(IDC_BUGID)->SetFocus();
}
if (!m_sLogMessage.IsEmpty())
m_cLogMessage.SetText(m_sLogMessage);
else
m_cLogMessage.SetText(m_ProjectProperties.GetLogMsgTemplate(PROJECTPROPNAME_LOGTEMPLATEBRANCH));
OnEnChangeLogmessage();
m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKALL);
m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKNONE);
// line up all controls and adjust their sizes.
#define LINKSPACING 9
RECT rc = AdjustControlSize(IDC_SELECTLABEL);
rc.right -= 15; // AdjustControlSize() adds 20 pixels for the checkbox/radio button bitmap, but this is a label...
rc = AdjustStaticSize(IDC_CHECKALL, rc, LINKSPACING);
rc = AdjustStaticSize(IDC_CHECKNONE, rc, LINKSPACING);
CAppUtils::SetAccProperty(m_cLogMessage.GetSafeHwnd(), PROPID_ACC_ROLE, ROLE_SYSTEM_TEXT);
CAppUtils::SetAccProperty(m_cLogMessage.GetSafeHwnd(), PROPID_ACC_HELP, CString(MAKEINTRESOURCE(IDS_INPUT_ENTERLOG)));
CAppUtils::SetAccProperty(m_cLogMessage.GetSafeHwnd(), PROPID_ACC_KEYBOARDSHORTCUT, L"Alt+"+CString(CAppUtils::FindAcceleratorKey(this, IDC_INVISIBLE)));
CAppUtils::SetAccProperty(GetDlgItem(IDC_CHECKALL)->GetSafeHwnd(), PROPID_ACC_ROLE, ROLE_SYSTEM_LINK);
CAppUtils::SetAccProperty(GetDlgItem(IDC_CHECKNONE)->GetSafeHwnd(), PROPID_ACC_ROLE, ROLE_SYSTEM_LINK);
CAppUtils::SetAccProperty(m_URLCombo.GetSafeHwnd(), PROPID_ACC_KEYBOARDSHORTCUT, L"Alt+"+CString(CAppUtils::FindAcceleratorKey(this, IDC_TOURLLABEL)));
CAppUtils::SetAccProperty(GetDlgItem(IDC_FROMURL)->GetSafeHwnd(), PROPID_ACC_KEYBOARDSHORTCUT, L"Alt+"+CString(CAppUtils::FindAcceleratorKey(this, IDC_COPYSTARTLABEL)));
CAppUtils::SetAccProperty(GetDlgItem(IDC_DESTURL)->GetSafeHwnd(), PROPID_ACC_KEYBOARDSHORTCUT, L"Alt+"+CString(CAppUtils::FindAcceleratorKey(this, IDC_DESTLABEL)));
AddAnchor(IDC_REPOGROUP, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_COPYSTARTLABEL, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_FROMURL, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_TOURLLABEL, TOP_LEFT);
AddAnchor(IDC_URLCOMBO, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_BROWSE, TOP_RIGHT);
AddAnchor(IDC_DESTLABEL, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_DESTURL, TOP_LEFT, TOP_RIGHT);
AddAnchor(IDC_MSGGROUP, TOP_LEFT, MIDDLE_RIGHT);
AddAnchor(IDC_HISTORY, TOP_LEFT);
AddAnchor(IDC_BUGTRAQBUTTON, TOP_LEFT);
AddAnchor(IDC_BUGIDLABEL, TOP_RIGHT);
AddAnchor(IDC_BUGID, TOP_RIGHT);
AddAnchor(IDC_INVISIBLE, TOP_RIGHT);
AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, MIDDLE_RIGHT);
AddAnchor(IDC_FROMGROUP, MIDDLE_LEFT, MIDDLE_RIGHT);
AddAnchor(IDC_COPYHEAD, MIDDLE_LEFT);
AddAnchor(IDC_COPYREV, MIDDLE_LEFT);
AddAnchor(IDC_COPYREVTEXT, MIDDLE_RIGHT);
AddAnchor(IDC_BROWSEFROM, MIDDLE_RIGHT);
AddAnchor(IDC_COPYWC, MIDDLE_LEFT);
AddAnchor(IDC_EXTGROUP, MIDDLE_LEFT, BOTTOM_RIGHT);
AddAnchor(IDC_SELECTLABEL, MIDDLE_LEFT);
AddAnchor(IDC_CHECKALL, MIDDLE_LEFT);
AddAnchor(IDC_CHECKNONE, MIDDLE_LEFT);
AddAnchor(IDC_EXTERNALSLIST, MIDDLE_LEFT, BOTTOM_RIGHT);
AddAnchor(IDC_DOSWITCH, BOTTOM_LEFT);
AddAnchor(IDC_MAKEPARENTS, BOTTOM_LEFT);
AddAnchor(IDOK, BOTTOM_RIGHT);
AddAnchor(IDCANCEL, BOTTOM_RIGHT);
AddAnchor(IDHELP, BOTTOM_RIGHT);
if ((m_pParentWnd==NULL)&&(GetExplorerHWND()))
CenterWindow(CWnd::FromHandle(GetExplorerHWND()));
EnableSaveRestore(L"CopyDlg");
m_bSettingChanged = false;
if (!m_path.IsUrl())
{
// start a thread to obtain the highest revision number of the working copy
// without blocking the dialog
if ((m_pThread = AfxBeginThread(FindRevThreadEntry, this))==NULL)
{
OnCantStartThread();
}
}
return TRUE;
}
bool AddCommand::Execute()
{
bool bRet = false;
if (parser.HasKey(_T("noui")))
{
#if 0
SVN svn;
ProjectProperties props;
props.ReadPropsPathList(pathList);
bRet = !!svn.Add(pathList, &props, svn_depth_empty, FALSE, FALSE, TRUE);
CShellUpdater::Instance().AddPathsForUpdate(pathList);
#endif
}
else
{
#if 0
if (pathList.AreAllPathsFiles())
{
SVN svn;
ProjectProperties props;
props.ReadPropsPathList(pathList);
bRet = !!svn.Add(pathList, &props, svn_depth_empty, FALSE, FALSE, TRUE);
CShellUpdater::Instance().AddPathsForUpdate(pathList);
}
else
{
#endif
CAddDlg dlg;
dlg.m_pathList = pathList;
if (dlg.DoModal() == IDOK)
{
#if 0
CString cmd,out;
int success=0;
for(int i=0;i<dlg.m_pathList.GetCount();i++)
{
cmd.Format(_T("git.exe add -- \"%s\""),dlg.m_pathList[i].GetGitPathString());
if(g_Git.Run(cmd,&out,CP_ACP))
{
CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
}
success++;
}
CString message;
message.Format(_T("%d file added"),success);
CMessageBox::Show(NULL,message,_T("TortoiseGit"),MB_OK);
return TRUE;
#endif
if (dlg.m_pathList.GetCount() == 0)
return FALSE;
CGitProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
progDlg.SetCommand(CGitProgressDlg::GitProgress_Add);
if (parser.HasVal(_T("closeonend")))
progDlg.SetAutoClose(parser.GetLongVal(_T("closeonend")));
progDlg.SetPathList(dlg.m_pathList);
//ProjectProperties props;
//props.ReadPropsPathList(dlg.m_pathList);
//progDlg.SetProjectProperties(props);
progDlg.SetItemCount(dlg.m_pathList.GetCount());
progDlg.DoModal();
CShellUpdater::Instance().AddPathsForUpdate(dlg.m_pathList);
bRet = !progDlg.DidErrorsOccur();
}
// }
}
CShellUpdater::Instance().Flush();
return bRet;
}
bool DropMoveCommand::Execute()
{
CString droppath = parser.GetVal(_T("droptarget"));
if (CTSVNPath(droppath).IsAdminDir())
return FALSE;
SVN svn;
unsigned long count = 0;
pathList.RemoveAdminPaths();
CString sNewName;
if ((parser.HasKey(_T("rename")))&&(pathList.GetCount()==1))
{
// ask for a new name of the source item
CRenameDlg renDlg;
renDlg.SetInputValidator(this);
renDlg.m_windowtitle.LoadString(IDS_PROC_MOVERENAME);
renDlg.m_name = pathList[0].GetFileOrDirectoryName();
if (renDlg.DoModal() != IDOK)
{
return FALSE;
}
sNewName = renDlg.m_name;
}
CProgressDlg progress;
if (progress.IsValid())
{
progress.SetTitle(IDS_PROC_MOVING);
progress.SetAnimation(IDR_MOVEANI);
progress.SetTime(true);
progress.ShowModeless(CWnd::FromHandle(GetExplorerHWND()));
}
UINT msgRet = IDNO;
for(int nPath = 0; nPath < pathList.GetCount(); nPath++)
{
CTSVNPath destPath;
if (sNewName.IsEmpty())
destPath = CTSVNPath(droppath+_T("\\")+pathList[nPath].GetFileOrDirectoryName());
else
destPath = CTSVNPath(droppath+_T("\\")+sNewName);
// path the same but case-changed is ok: results in a case-rename
if (!(pathList[nPath].IsEquivalentToWithoutCase(destPath) && !pathList[nPath].IsEquivalentTo(destPath)))
{
if (destPath.Exists())
{
CString name = pathList[nPath].GetFileOrDirectoryName();
if (!sNewName.IsEmpty())
name = sNewName;
progress.Stop();
CRenameDlg dlg;
dlg.SetInputValidator(this);
dlg.m_name = name;
dlg.m_windowtitle.Format(IDS_PROC_NEWNAMEMOVE, (LPCTSTR)name);
if (dlg.DoModal() != IDOK)
{
return FALSE;
}
destPath.SetFromWin(droppath+_T("\\")+dlg.m_name);
}
}
if (!svn.Move(CTSVNPathList(pathList[nPath]), destPath))
{
if ((svn.GetSVNError() && svn.GetSVNError()->apr_err == SVN_ERR_ENTRY_EXISTS) && (destPath.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, destPath.GetWinPath());
if (CTaskDialog::IsSupported())
{
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);
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;
}
else
{
msgRet = TSVNMessageBox(GetExplorerHWND(), sReplace, _T("TortoiseSVN"), MB_ICONQUESTION|MB_YESNO|MB_YESTOALL|MB_NOTOALL);
}
}
if ((msgRet == IDYES) || (msgRet == IDYESTOALL))
{
if (!svn.Remove(CTSVNPathList(destPath), true, false))
{
destPath.Delete(true);
}
if (!svn.Move(CTSVNPathList(pathList[nPath]), destPath))
{
svn.ShowErrorDialog(GetExplorerHWND(), pathList[nPath]);
return FALSE; //get out of here
}
CShellUpdater::Instance().AddPathForUpdate(destPath);
}
}
else
{
svn.ShowErrorDialog(GetExplorerHWND(), pathList[nPath]);
return FALSE; //get out of here
}
}
else
CShellUpdater::Instance().AddPathForUpdate(destPath);
count++;
if (progress.IsValid())
{
progress.FormatPathLine(1, IDS_PROC_MOVINGPROG, pathList[nPath].GetWinPath());
progress.FormatPathLine(2, IDS_PROC_CPYMVPROG2, destPath.GetWinPath());
progress.SetProgress(count, pathList.GetCount());
}
if ((progress.IsValid())&&(progress.HasUserCancelled()))
{
TSVNMessageBox(GetExplorerHWND(), IDS_SVN_USERCANCELLED, IDS_APPNAME, MB_ICONINFORMATION);
return FALSE;
}
}
return true;
}
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 RemoveCommand::Execute()
{
bool bRet = false;
// removing items from a working copy is done item-by-item so we
// have a chance to show a progress bar
//
// removing items from an URL in the repository requires that we
// ask the user for a log message.
#if 0
BOOL bForce = FALSE;
SVN svn;
if ((!pathList.IsEmpty())&&(SVN::PathIsURL(pathList[0])))
{
// Delete using URL's, not wc paths
svn.SetPromptApp(&theApp);
CInputLogDlg dlg;
CString sUUID;
svn.GetRepositoryRootAndUUID(pathList[0], sUUID);
dlg.SetUUID(sUUID);
CString sHint;
if (pathList.GetCount() == 1)
sHint.Format(IDS_INPUT_REMOVEONE, (LPCTSTR)pathList[0].GetSVNPathString());
else
sHint.Format(IDS_INPUT_REMOVEMORE, pathList.GetCount());
dlg.SetActionText(sHint);
if (dlg.DoModal()==IDOK)
{
if (!svn.Remove(pathList, TRUE, parser.HasKey(_T("keep")), dlg.GetLogMessage()))
{
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
return FALSE;
}
return true;
}
return FALSE;
}
else
{
for (int nPath = 0; nPath < pathList.GetCount(); ++nPath)
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": remove file %s\n"), (LPCTSTR)pathList[nPath].GetUIPathString());
// even though SVN::Remove takes a list of paths to delete at once
// we delete each item individually so we can prompt the user
// if something goes wrong or unversioned/modified items are
// to be deleted
CTSVNPathList removePathList(pathList[nPath]);
if (bForce)
{
CTSVNPath delPath = removePathList[0];
delPath.Delete(true);
}
if (!svn.Remove(removePathList, bForce, parser.HasKey(_T("keep"))))
{
if ((svn.Err->apr_err == SVN_ERR_UNVERSIONED_RESOURCE) ||
(svn.Err->apr_err == SVN_ERR_CLIENT_MODIFIED))
{
CString msg, yes, no, yestoall;
if (pathList[nPath].IsDirectory())
{
msg.Format(IDS_PROC_REMOVEFORCEFOLDER, pathList[nPath].GetWinPath());
}
else
{
msg.Format(IDS_PROC_REMOVEFORCE, (LPCTSTR)svn.GetLastErrorMessage());
}
yes.LoadString(IDS_MSGBOX_YES);
no.LoadString(IDS_MSGBOX_NO);
yestoall.LoadString(IDS_PROC_YESTOALL);
UINT ret = CMessageBox::Show(hwndExplorer, msg, _T("TortoiseGit"), 2, IDI_ERROR, yes, no, yestoall);
if (ret == 3)
bForce = TRUE;
if ((ret == 1)||(ret==3))
{
CTSVNPath delPath = removePathList[0];
delPath.Delete(true);
if (!svn.Remove(removePathList, TRUE, parser.HasKey(_T("keep"))))
{
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
}
else
bRet = true;
}
}
else
CMessageBox::Show(hwndExplorer, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
}
}
}
if (bRet)
CShellUpdater::Instance().AddPathsForUpdate(pathList);
#endif
//we don't ask user about if keep local copy.
//because there are command "Delete(keep local copy)" at explore context menu
//int key=CMessageBox::Show(hwndExplorer, _T("File will removed from version control\r\n Do you want to keep local copy"), _T("TortoiseGit"), MB_ICONINFORMATION|MB_YESNOCANCEL);
//if(key == IDCANCEL)
CString format;
BOOL keepLocal = parser.HasKey(_T("keep"));
if (pathList.GetCount() > 1)
format.Format(keepLocal ? IDS_WARN_DELETE_MANY_FROM_INDEX : IDS_WARN_DELETE_MANY, pathList.GetCount());
else
format.Format(keepLocal ? IDS_WARN_DELETE_ONE_FROM_INDEX : IDS_WARN_REMOVE, pathList[0].GetGitPathString());
if (CMessageBox::Show(hwndExplorer, format, _T("TortoiseGit"), 2, IDI_QUESTION, CString(MAKEINTRESOURCE(IDS_REMOVEBUTTON)), CString(MAKEINTRESOURCE(IDS_MSGBOX_ABORT))) == 2)
return false;
if (keepLocal)
{
format= _T("git.exe rm -r -f --cached -- \"%s\"");
}
else
{
format=_T("git.exe rm -r -f -- \"%s\"");
}
CString output;
CString cmd;
int nPath;
for (nPath = 0; nPath < pathList.GetCount(); ++nPath)
{
cmd.Format(format, (LPCTSTR)pathList[nPath].GetGitPathString());
if (g_Git.Run(cmd, &output, CP_UTF8))
{
if (CMessageBox::Show(hwndExplorer, output, _T("TortoiseGit"), 2, IDI_ERROR, CString(MAKEINTRESOURCE(IDS_IGNOREBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 2)
return FALSE;
}
}
output.Format(IDS_PROC_FILESREMOVED, nPath);
CShellUpdater::Instance().AddPathsForUpdate(pathList);
CMessageBox::Show(hwndExplorer, output, _T("TortoiseGit"), MB_ICONINFORMATION|MB_OK);
CShellUpdater::Instance().Flush();
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;
}