DirectoryNode ExpandChildDirectory(DirectoryNode parentNode, int index)
{
DirectoryNode directoryNode = GetDirectoryChildNodeAtIndex(parentNode, index);
directoryNode.Expanding();
return(directoryNode);
}
DirectoryNode ExpandFirstChildDirectory(ExtTreeNode parentNode)
{
DirectoryNode directoryNode = GetFirstDirectoryChildNode(parentNode);
directoryNode.Expanding();
return(directoryNode);
}
FileProjectItem CreateNewFile(DirectoryNode upper, string fileName)
{
upper.Expanding();
FileNode fileNode = new FileNode(fileName, FileNodeStatus.InProject);
fileNode.AddTo(upper);
fileNode.EnsureVisible();
return(IncludeFileInProject.IncludeFileNode(fileNode));
}
DirectoryNode CreateNewDirectory(DirectoryNode upper, string directoryName)
{
upper.Expanding();
Directory.CreateDirectory(directoryName);
DirectoryNode directoryNode = new DirectoryNode(directoryName, FileNodeStatus.InProject);
directoryNode.AddTo(upper);
IncludeFileInProject.IncludeDirectoryNode(directoryNode, false);
return(directoryNode);
}
DirectoryNode CreateExpandedProjectNodeWithFileInSubFolder(string projectFileName, string fileName)
{
CreateProjectBrowserControl();
projectNode = AddProjectToProjectBrowser(projectFileName);
AddFileToProject(fileName);
projectNode.Expanding();
DirectoryNode subfolderNode = GetFirstDirectoryChildNode(projectNode);
subfolderNode.Expanding();
CreateProjectBrowserUpdater(projectBrowser);
projectNode.Expanding();
return(subfolderNode);
}
DirectoryNode CreateNewDirectory(DirectoryNode upper, string directoryName)
{
upper.Expanding();
Directory.CreateDirectory(directoryName);
FileService.FireFileCreated(directoryName, true);
DirectoryNode directoryNode = new DirectoryNode(directoryName, FileNodeStatus.InProject);
directoryNode.InsertSorted(upper);
IncludeFileInProject.IncludeDirectoryNode(directoryNode, false);
return(directoryNode);
}
public override void Run()
{
ProjectBrowserPad.Instance.BringToFront();
DirectoryNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedDirectoryNode;
if (node == null)
{
return;
}
node.Expanding();
string newDirectoryName = GenerateValidDirectoryName(node.Directory);
DirectoryNode newDirectoryNode = CreateNewDirectory(node, newDirectoryName);
ProjectBrowserPad.Instance.StartLabelEdit(newDirectoryNode);
}
public void Constructor_ProjectHasFileInProjectAndInSubdirectoryAndNewFileAddedInSubdirectory_NewFileNotAddedAsChildToExistingFile()
{
CreateExpandedProjectNodeWithFiles(
@"d:\projects\MyProject\MyProject.csproj",
@"d:\projects\MyProject\a.cs",
@"d:\projects\MyProject\src\b.cs");
DirectoryNode srcDirectoryNode = GetFirstDirectoryChildNode(projectNode);
srcDirectoryNode.Expanding();
AddFileToProject(@"d:\projects\MyProject\src\c.cs");
FileNode firstFileNode = GetFirstFileChildNode(projectNode);
Assert.AreEqual(0, firstFileNode.Nodes.Count);
}
public void Constructor_DependentFileAddedWhenProjectHasTwoFilesWithSameParentNameButInDifferentFolders_DependentFileNotAddedToFileInDifferentDirectoryWithSameDependentName()
{
CreateExpandedProjectNodeWithFiles(
@"d:\projects\MyProject\MyProject.csproj",
@"d:\projects\MyProject\a.cs",
@"d:\projects\MyProject\src\a.cs",
@"d:\projects\MyProject\src\b.cs");
DirectoryNode srcDirectoryNode = GetFirstDirectoryChildNode(projectNode);
srcDirectoryNode.Expanding();
AddDependentFileToProject(@"d:\projects\MyProject\src\c.cs", "a.cs");
FileNode firstFileNode = GetFirstFileChildNode(projectNode);
Assert.AreEqual(0, firstFileNode.Nodes.Count);
}
public void Constructor_DependentFileAddedWhenProjectHasTwoFilesWithSameParentNameButInDifferentFoldersAndFolderCasingDifferent_DependentFileAddedToFileInSameDirectory()
{
CreateExpandedProjectNodeWithFiles(
@"d:\projects\MyProject\MyProject.csproj",
@"d:\projects\MyProject\a.cs",
@"d:\projects\MYPROJECT\SRC\a.cs",
@"d:\projects\MyProject\src\b.cs");
DirectoryNode srcDirectoryNode = GetFirstDirectoryChildNode(projectNode);
srcDirectoryNode.Expanding();
AddDependentFileToProject(@"d:\projects\MyProject\src\c.cs", "a.cs");
FileNode fileNode = GetFirstFileChildNode(srcDirectoryNode);
FileNode childNode = GetFirstFileChildNode(fileNode);
Assert.AreEqual(@"d:\projects\MyProject\src\c.cs", childNode.FileName);
}
public override void Run()
{
TreeNode selectedNode = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedNode;
DirectoryNode node = null;
while (selectedNode != null && node == null)
{
node = selectedNode as DirectoryNode;
selectedNode = selectedNode.Parent;
}
if (node == null)
{
return;
}
node.Expand();
node.Expanding();
using (NewFileDialog nfd = new NewFileDialog(node.Directory)) {
if (nfd.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainForm) == DialogResult.OK)
{
bool additionalProperties = false;
foreach (KeyValuePair <string, FileDescriptionTemplate> createdFile in nfd.CreatedFiles)
{
FileProjectItem item = CreateNewFile(node, createdFile.Key);
if (createdFile.Value.SetProjectItemProperties(item))
{
additionalProperties = true;
}
}
if (additionalProperties)
{
node.Project.Save();
node.RecreateSubNodes();
}
}
}
}
protected IEnumerable <FileProjectItem> AddNewItems()
{
DirectoryNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedDirectoryNode;
if (node == null)
{
return(null);
}
node.Expand();
node.Expanding();
FileTemplateResult result = SD.UIService.ShowNewFileDialog(node.Project, node.Directory);
if (result != null)
{
node.RecreateSubNodes();
return(result.NewFiles.Select(node.Project.FindFile).Where(f => f != null).ToArray());
}
else
{
return(null);
}
}
protected IEnumerable <FileProjectItem> AddNewItems()
{
DirectoryNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedDirectoryNode;
if (node == null)
{
return(null);
}
node.Expand();
node.Expanding();
List <FileProjectItem> addedItems = new List <FileProjectItem>();
using (NewFileDialog nfd = new NewFileDialog(node.Directory)) {
if (nfd.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainForm) == DialogResult.OK)
{
bool additionalProperties = false;
foreach (KeyValuePair <string, FileDescriptionTemplate> createdFile in nfd.CreatedFiles)
{
FileProjectItem item = node.AddNewFile(createdFile.Key);
addedItems.Add(item);
if (createdFile.Value.SetProjectItemProperties(item))
{
additionalProperties = true;
}
}
if (additionalProperties)
{
node.Project.Save();
node.RecreateSubNodes();
}
}
}
return(addedItems.AsReadOnly());
}
public static void CopyDirectory(string directoryName, DirectoryNode node, bool includeInProject)
{
directoryName = FileUtility.NormalizePath(directoryName);
string copiedFileName = Path.Combine(node.Directory, Path.GetFileName(directoryName));
LoggingService.Debug("Copy " + directoryName + " to " + copiedFileName);
if (!FileUtility.IsEqualFileName(directoryName, copiedFileName))
{
if (includeInProject && ProjectService.OpenSolution != null)
{
// get ProjectItems in source directory
foreach (IProject project in ProjectService.OpenSolution.Projects)
{
if (!FileUtility.IsBaseDirectory(project.Directory, directoryName))
{
continue;
}
LoggingService.Debug("Searching for child items in " + project.Name);
foreach (ProjectItem item in project.Items)
{
FileProjectItem fileItem = item as FileProjectItem;
if (fileItem == null)
{
continue;
}
string virtualFullName = Path.Combine(project.Directory, fileItem.VirtualName);
if (FileUtility.IsBaseDirectory(directoryName, virtualFullName))
{
if (item.ItemType == ItemType.Folder && FileUtility.IsEqualFileName(directoryName, virtualFullName))
{
continue;
}
LoggingService.Debug("Found file " + virtualFullName);
FileProjectItem newItem = new FileProjectItem(node.Project, fileItem.ItemType);
if (FileUtility.IsBaseDirectory(directoryName, fileItem.FileName))
{
newItem.FileName = FileUtility.RenameBaseDirectory(fileItem.FileName, directoryName, copiedFileName);
}
else
{
newItem.FileName = fileItem.FileName;
}
fileItem.CopyMetadataTo(newItem);
if (fileItem.IsLink)
{
string newVirtualFullName = FileUtility.RenameBaseDirectory(virtualFullName, directoryName, copiedFileName);
fileItem.SetEvaluatedMetadata("Link", FileUtility.GetRelativePath(node.Project.Directory, newVirtualFullName));
}
ProjectService.AddProjectItem(node.Project, newItem);
}
}
}
}
FileService.CopyFile(directoryName, copiedFileName, true, false);
DirectoryNode newNode = new DirectoryNode(copiedFileName);
newNode.InsertSorted(node);
if (includeInProject)
{
IncludeFileInProject.IncludeDirectoryNode(newNode, false);
}
newNode.Expanding();
}
else if (includeInProject)
{
foreach (TreeNode childNode in node.Nodes)
{
if (childNode is DirectoryNode)
{
DirectoryNode directoryNode = (DirectoryNode)childNode;
if (FileUtility.IsEqualFileName(directoryNode.Directory, copiedFileName))
{
IncludeFileInProject.IncludeDirectoryNode(directoryNode, true);
}
}
}
}
}
DirectoryNode CreateNewDirectory(DirectoryNode upper, string directoryName)
{
upper.Expanding();
Directory.CreateDirectory(directoryName);
FileService.FireFileCreated(directoryName, true);
DirectoryNode directoryNode = new DirectoryNode(directoryName, FileNodeStatus.InProject);
directoryNode.InsertSorted(upper);
IncludeFileInProject.IncludeDirectoryNode(directoryNode, false);
return directoryNode;
}
DirectoryNode CreateNewDirectory(DirectoryNode upper, string directoryName)
{
upper.Expanding();
Directory.CreateDirectory(directoryName);
DirectoryNode directoryNode = new DirectoryNode(directoryName, FileNodeStatus.InProject);
directoryNode.AddTo(upper);
IncludeFileInProject.IncludeDirectoryNode(directoryNode, false);
return directoryNode;
}
public override void Run()
{
ProjectBrowserPad.Instance.BringToFront();
DirectoryNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedDirectoryNode;
if (node == null)
{
return;
}
node.Expanding();
node.Expand();
using (FolderBrowserDialog dlg = new FolderBrowserDialog()) {
dlg.SelectedPath = node.Directory;
dlg.ShowNewFolderButton = false;
if (dlg.ShowDialog(WorkbenchSingleton.MainForm) == DialogResult.OK)
{
string folderName = dlg.SelectedPath;
string copiedFolderName = Path.Combine(node.Directory, Path.GetFileName(folderName));
if (!FileUtility.IsEqualFileName(folderName, copiedFolderName))
{
if (FileUtility.IsBaseDirectory(folderName, node.Directory))
{
MessageService.ShowError("Cannot copy " + folderName + " to " + copiedFolderName);
return;
}
if (Directory.Exists(copiedFolderName))
{
MessageService.ShowError("Cannot copy " + folderName + " to " + copiedFolderName + ": target already exists.");
return;
}
int res = MessageService.ShowCustomDialog(
"${res:ProjectComponent.ContextMenu.ExistingFolder}",
"${res:ProjectComponent.ContextMenu.ExistingFolder.CopyQuestion}",
0, 1,
"${res:ProjectComponent.ContextMenu.AddExistingFiles.Copy}",
"${res:Global.CancelButtonText}");
if (res != 0)
{
return;
}
if (!FileService.CopyFile(folderName, copiedFolderName, true, false))
{
return;
}
}
// ugly HACK to get IncludeDirectoryNode to work properly
AbstractProjectBrowserTreeNode.ShowAll = true;
try {
node.RecreateSubNodes();
DirectoryNode newNode = node.AllNodes.OfType <DirectoryNode>()
.FirstOrDefault(dir => FileUtility.IsEqualFileName(copiedFolderName, dir.Directory));
if (newNode != null)
{
newNode.Expanding();
IncludeFileInProject.IncludeDirectoryNode(newNode, true);
}
} finally {
AbstractProjectBrowserTreeNode.ShowAll = false;
}
node.RecreateSubNodes();
}
}
}
protected IEnumerable <FileProjectItem> AddExistingItems()
{
DirectoryNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedDirectoryNode;
if (node == null)
{
return(null);
}
node.Expanding();
node.Expand();
List <FileProjectItem> addedItems = new List <FileProjectItem>();
using (OpenFileDialog fdiag = new OpenFileDialog()) {
fdiag.AddExtension = true;
string[] fileFilters = (string[])(AddInTree.GetTreeNode("/SharpDevelop/Workbench/FileFilter").BuildChildItems(this)).ToArray(typeof(string));
fdiag.InitialDirectory = node.Directory;
fdiag.FilterIndex = GetFileFilterIndex(node.Project, fileFilters);
fdiag.Filter = String.Join("|", fileFilters);
fdiag.Multiselect = true;
fdiag.CheckFileExists = true;
fdiag.Title = StringParser.Parse("${res:ProjectComponent.ContextMenu.AddExistingFiles}");
if (fdiag.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainForm) == DialogResult.OK)
{
List <KeyValuePair <string, string> > fileNames = new List <KeyValuePair <string, string> >(fdiag.FileNames.Length);
foreach (string fileName in fdiag.FileNames)
{
fileNames.Add(new KeyValuePair <string, string>(fileName, ""));
}
bool addedDependentFiles = false;
foreach (string fileName in fdiag.FileNames)
{
foreach (string additionalFile in FindAdditionalFiles(fileName))
{
if (!fileNames.Exists(delegate(KeyValuePair <string, string> pair) {
return(FileUtility.IsEqualFileName(pair.Key, additionalFile));
}))
{
addedDependentFiles = true;
fileNames.Add(new KeyValuePair <string, string>(additionalFile, Path.GetFileName(fileName)));
}
}
}
string copiedFileName = Path.Combine(node.Directory, Path.GetFileName(fileNames[0].Key));
if (!FileUtility.IsEqualFileName(fileNames[0].Key, copiedFileName))
{
int res = MessageService.ShowCustomDialog(
fdiag.Title, "${res:ProjectComponent.ContextMenu.AddExistingFiles.Question}",
0, 2,
"${res:ProjectComponent.ContextMenu.AddExistingFiles.Copy}",
"${res:ProjectComponent.ContextMenu.AddExistingFiles.Link}",
"${res:Global.CancelButtonText}");
if (res == 1)
{
// Link
foreach (KeyValuePair <string, string> pair in fileNames)
{
string fileName = pair.Key;
string relFileName = FileUtility.GetRelativePath(node.Project.Directory, fileName);
FileNode fileNode = new FileNode(fileName, FileNodeStatus.InProject);
FileProjectItem fileProjectItem = new FileProjectItem(node.Project, node.Project.GetDefaultItemType(fileName), relFileName);
fileProjectItem.SetEvaluatedMetadata("Link", Path.Combine(node.RelativePath, Path.GetFileName(fileName)));
fileProjectItem.DependentUpon = pair.Value;
addedItems.Add(fileProjectItem);
fileNode.ProjectItem = fileProjectItem;
fileNode.InsertSorted(node);
ProjectService.AddProjectItem(node.Project, fileProjectItem);
}
node.Project.Save();
if (addedDependentFiles)
{
node.RecreateSubNodes();
}
return(addedItems.AsReadOnly());
}
if (res == 2)
{
// Cancel
return(addedItems.AsReadOnly());
}
// only continue for res==0 (Copy)
}
bool replaceAll = false;
foreach (KeyValuePair <string, string> pair in fileNames)
{
copiedFileName = Path.Combine(node.Directory, Path.GetFileName(pair.Key));
if (!replaceAll && File.Exists(copiedFileName) && !FileUtility.IsEqualFileName(pair.Key, copiedFileName))
{
ReplaceExistingFile res = ShowReplaceExistingFileDialog(fdiag.Title, Path.GetFileName(pair.Key), true);
if (res == ReplaceExistingFile.YesToAll)
{
replaceAll = true;
}
else if (res == ReplaceExistingFile.No)
{
continue;
}
else if (res == ReplaceExistingFile.Cancel)
{
break;
}
}
FileProjectItem item = CopyFile(pair.Key, node, true);
if (item != null)
{
addedItems.Add(item);
item.DependentUpon = pair.Value;
}
}
node.Project.Save();
if (addedDependentFiles)
{
node.RecreateSubNodes();
}
}
}
return(addedItems.AsReadOnly());
}
public static void CopyDirectory(string directoryName, DirectoryNode node, bool includeInProject)
{
directoryName = FileUtility.NormalizePath(directoryName);
string copiedFileName = Path.Combine(node.Directory, Path.GetFileName(directoryName));
LoggingService.Debug("Copy " + directoryName + " to " + copiedFileName);
if (!FileUtility.IsEqualFileName(directoryName, copiedFileName)) {
if (includeInProject && ProjectService.OpenSolution != null) {
// get ProjectItems in source directory
foreach (IProject project in ProjectService.OpenSolution.Projects) {
if (!FileUtility.IsBaseDirectory(project.Directory, directoryName))
continue;
LoggingService.Debug("Searching for child items in " + project.Name);
foreach (ProjectItem item in project.Items) {
FileProjectItem fileItem = item as FileProjectItem;
if (fileItem == null)
continue;
string virtualFullName = Path.Combine(project.Directory, fileItem.VirtualName);
if (FileUtility.IsBaseDirectory(directoryName, virtualFullName)) {
if (item.ItemType == ItemType.Folder && FileUtility.IsEqualFileName(directoryName, virtualFullName)) {
continue;
}
LoggingService.Debug("Found file " + virtualFullName);
FileProjectItem newItem = new FileProjectItem(node.Project, fileItem.ItemType);
if (FileUtility.IsBaseDirectory(directoryName, fileItem.FileName)) {
newItem.FileName = FileUtility.RenameBaseDirectory(fileItem.FileName, directoryName, copiedFileName);
} else {
newItem.FileName = fileItem.FileName;
}
fileItem.CopyMetadataTo(newItem);
if (fileItem.IsLink) {
string newVirtualFullName = FileUtility.RenameBaseDirectory(virtualFullName, directoryName, copiedFileName);
fileItem.SetEvaluatedMetadata("Link", FileUtility.GetRelativePath(node.Project.Directory, newVirtualFullName));
}
ProjectService.AddProjectItem(node.Project, newItem);
}
}
}
}
FileService.CopyFile(directoryName, copiedFileName, true, false);
DirectoryNode newNode = new DirectoryNode(copiedFileName);
newNode.InsertSorted(node);
if (includeInProject) {
IncludeFileInProject.IncludeDirectoryNode(newNode, false);
}
newNode.Expanding();
} else if (includeInProject) {
foreach (TreeNode childNode in node.Nodes) {
if (childNode is DirectoryNode) {
DirectoryNode directoryNode = (DirectoryNode)childNode;
if (FileUtility.IsEqualFileName(directoryNode.Directory, copiedFileName)) {
IncludeFileInProject.IncludeDirectoryNode(directoryNode, true);
}
}
}
}
}
FileProjectItem CreateNewFile(DirectoryNode upper, string fileName)
{
upper.Expanding();
FileNode fileNode = new FileNode(fileName, FileNodeStatus.InProject);
fileNode.AddTo(upper);
fileNode.EnsureVisible();
return IncludeFileInProject.IncludeFileNode(fileNode);
}
