public override object Visit(FileNode fileNode, object data)
{
if (FileUtility.IsEqualFileName(oldName, fileNode.FileName)) {
fileNode.FileName = newName;
} else if (FileUtility.IsBaseDirectory(oldName, fileNode.FileName)) {
fileNode.FileName = FileUtility.RenameBaseDirectory(fileNode.FileName, oldName, newName);
}
fileNode.AcceptChildren(this, data);
return data;
}
public override object Visit(FileNode fileNode, object data)
{
if (FileUtility.IsBaseDirectory(fileName, fileNode.FileName)) {
ExtTreeNode parent = fileNode.Parent as ExtTreeNode;
fileNode.Remove();
if (parent != null) {
parent.Refresh();
}
} else {
fileNode.AcceptChildren(this, data);
}
return data;
}
/// <summary>
/// Add files to the current project at the project node.
/// </summary>
/// <param name="fileNames">list of files that have to be added.</param>
internal static void AddFiles(string []fileNames)
{
IProject project=ProjectService.CurrentProject;
Debug.Assert(project!=null);
foreach(var file in fileNames){
string relFileName=FileUtility.GetRelativePath(project.Directory,file);
FileProjectItem fileProjectItem=new FileProjectItem(project,project.GetDefaultItemType(file),relFileName);
FileNode fileNode=new FileNode(file,FileNodeStatus.InProject);
fileNode.ProjectItem=fileProjectItem;
ProjectService.AddProjectItem(project,fileProjectItem);
}
project.Save();
ProjectBrowserPad.RefreshViewAsync();
}
bool FileNodeMatchesNewFileAdded(FileNode fileNode)
{
return FileUtility.IsEqualFileName(fileNode.FileName, newFileAddedToProject.FileName);
}
void AddFileNodeTo(TreeNode node, FileNodeStatus status = FileNodeStatus.InProject)
{
var fileNode = new FileNode(newFileAddedToProject.FileName, status);
fileNode.InsertSorted(node);
}
protected override void Initialize()
{
Dictionary<string, FileNode> fileNodeDictionary = new Dictionary<string, FileNode>((IEqualityComparer<string>) StringComparer.InvariantCultureIgnoreCase);
Dictionary<string, DirectoryNode> directoryNodeList = new Dictionary<string, DirectoryNode>((IEqualityComparer<string>) StringComparer.InvariantCultureIgnoreCase);
string relativeDirectoryPath = (this.RelativePath.Length <= 0) ? string.Empty : (this.RelativePath.Replace('\\', '/') + "/");
foreach (FileProjectItem item in this.Project.Items.OfType<FileProjectItem>()) {
string virtualName = item.VirtualName.Replace('\\', '/');
if (virtualName.EndsWith("/", StringComparison.Ordinal))
virtualName = virtualName.Substring(0, virtualName.Length - 1);
string fileName = Path.GetFileName(virtualName);
if (!string.Equals(virtualName, relativeDirectoryPath + fileName, StringComparison.InvariantCultureIgnoreCase)) {
this.AddParentFolder(virtualName, relativeDirectoryPath, directoryNodeList);
// continue;
}
if (item.ItemType == ItemType.Folder || item.ItemType == ItemType.WebReferences) {
DirectoryNode newDirectoryNode = DirectoryNodeFactory.CreateDirectoryNode(this, this.Project, fileName);
if (!System.IO.Directory.Exists(item.FileName)) {
newDirectoryNode.FileNodeStatus = FileNodeStatus.Missing;
}
newDirectoryNode.ProjectItem = item;
newDirectoryNode.AddTo(this);
directoryNodeList[fileName] = newDirectoryNode;
} else {
FileNode fileNode = new FileNode(item.FileName);
if (!File.Exists(item.FileName)) {
fileNode.FileNodeStatus = FileNodeStatus.Missing;
}
fileNode.ProjectItem = item;
fileNodeDictionary[fileName] = fileNode;
fileNode.AddTo(this);
}
}
// Add files found in file system
if (System.IO.Directory.Exists(this.Directory)) {
foreach (string subDirectory in System.IO.Directory.GetDirectories(this.Directory)) {
string filename = Path.GetFileName(subDirectory);
if (filename != ".svn") {
DirectoryNode node;
if (directoryNodeList.TryGetValue(filename, out node)) {
if (node.FileNodeStatus == FileNodeStatus.None)
node.FileNodeStatus = FileNodeStatus.InProject;
} else {
node = DirectoryNodeFactory.CreateDirectoryNode(this, this.Project, subDirectory);
node.AddTo(this);
}
}
}
foreach (string fullpath in System.IO.Directory.GetFiles(this.Directory)) {
string file = Path.GetFileName(fullpath);
FileNode node;
if (fileNodeDictionary.TryGetValue(file, out node)) {
if (node.FileNodeStatus == FileNodeStatus.None)
node.FileNodeStatus = FileNodeStatus.InProject;
} else {
node = new FileNode(file);
node.AddTo(this);
}
}
}
}
/// <summary>
/// Copies or moves a file node (and the corresponding file, if applicable) to this directory,
/// discarding its DependentUpon value.
/// </summary>
/// <param name="fileNode">The file node to copy or move.</param>
/// <param name="performMove">true to move the file node, false to copy it.</param>
public void CopyFileHere(FileNode node, bool performMove)
{
if (node.FileNodeStatus == FileNodeStatus.None) {
AddExistingItemsToProject.CopyFile(node.FileName, this, false);
if (performMove) {
FileService.RemoveFile(node.FileName, false);
}
} else if (node.IsLink) {
string relFileName = FileUtility.GetRelativePath(Project.Directory, node.FileName);
FileNode fileNode = new FileNode(node.FileName, FileNodeStatus.InProject);
FileProjectItem fileProjectItem = new FileProjectItem(Project, Project.GetDefaultItemType(node.FileName));
fileProjectItem.Include = relFileName;
fileProjectItem.SetEvaluatedMetadata("Link", Path.Combine(RelativePath, Path.GetFileName(node.FileName)));
fileNode.ProjectItem = fileProjectItem;
fileNode.InsertSorted(this);
ProjectService.AddProjectItem(Project, fileProjectItem);
if (performMove) {
ProjectService.RemoveProjectItem(node.Project, node.ProjectItem);
node.Remove();
}
} else {
CopyFileHere(node.FileName, performMove);
}
}
/// <summary>
/// Create's a new FileProjectItem in this DirectoryNode.
/// </summary>
/// <param name="fileName">The name of the file that will be added to the project.</param>
public FileProjectItem AddNewFile(string fileName)
{
//TODO: this can probably be moved to AbstractProjectBrowserTreeNode or even lower in the chain.
this.Expanding();
FileNode fileNode = new FileNode(fileName, FileNodeStatus.InProject);
fileNode.InsertSorted(this);
fileNode.EnsureVisible();
return IncludeFileInProject.IncludeFileNode(fileNode);
}
protected override void Initialize()
{
if (removeMe != null)
{
Nodes.Remove(removeMe);
removeMe = null;
}
LoggingService.Info("Initialize DirectoryNode " + Directory);
Dictionary <string, FileNode> fileNodeDictionary
= new Dictionary <string, FileNode>(StringComparer.InvariantCultureIgnoreCase);
Dictionary <FileNode, string> dependendFileDictionary = new Dictionary <FileNode, string>();
Dictionary <string, DirectoryNode> directoryNodeList = new Dictionary <string, DirectoryNode>(StringComparer.InvariantCultureIgnoreCase);
// Add files found in file system
if (System.IO.Directory.Exists(Directory))
{
foreach (string subDirectory in System.IO.Directory.GetDirectories(Directory))
{
if (Path.GetFileName(subDirectory) != ".svn")
{
DirectoryNode newDirectoryNode = DirectoryNodeFactory.CreateDirectoryNode(this, Project, subDirectory);
newDirectoryNode.AddTo(this);
directoryNodeList[Path.GetFileName(subDirectory)] = newDirectoryNode;
}
}
foreach (string file in System.IO.Directory.GetFiles(Directory))
{
FileNode fileNode = new FileNode(file);
fileNodeDictionary[Path.GetFileName(file)] = fileNode;
fileNode.AddTo(this);
}
}
if (Nodes.Count == 0)
{
SetClosedImage();
}
string relativeDirectoryPath = this.RelativePath;
if (relativeDirectoryPath.Length > 0)
{
relativeDirectoryPath = relativeDirectoryPath.Replace('\\', '/') + '/';
}
// Add project items
foreach (ProjectItem item in Project.Items)
{
if (item.ItemType == ItemType.WebReferenceUrl)
{
DirectoryNode node;
if (directoryNodeList.TryGetValue(Path.GetFileName(item.FileName), out node))
{
if (node.FileNodeStatus == FileNodeStatus.None)
{
node.FileNodeStatus = FileNodeStatus.InProject;
}
node.ProjectItem = item;
}
continue;
}
FileProjectItem fileItem = item as FileProjectItem;
if (fileItem == null)
{
continue;
}
string virtualName = fileItem.VirtualName.Replace('\\', '/');
if (virtualName.EndsWith("/"))
{
virtualName = virtualName.Substring(0, virtualName.Length - 1);
}
string fileName = Path.GetFileName(virtualName);
if (!string.Equals(virtualName, relativeDirectoryPath + fileName, StringComparison.InvariantCultureIgnoreCase))
{
AddParentFolder(virtualName, relativeDirectoryPath, directoryNodeList);
continue;
}
if (item.ItemType == ItemType.Folder || item.ItemType == ItemType.WebReferences)
{
DirectoryNode node;
if (directoryNodeList.TryGetValue(fileName, out node))
{
if (node.FileNodeStatus == FileNodeStatus.None)
{
node.FileNodeStatus = FileNodeStatus.InProject;
}
node.ProjectItem = item;
}
else
{
node = DirectoryNodeFactory.CreateDirectoryNode(item, FileNodeStatus.Missing);
node.AddTo(this);
directoryNodeList[fileName] = node;
}
}
else
{
FileNode node;
if (fileItem.IsLink)
{
node = new FileNode(fileItem.FileName, FileNodeStatus.InProject);
node.AddTo(this);
fileNodeDictionary[fileName] = node;
}
else
{
if (fileNodeDictionary.TryGetValue(fileName, out node))
{
if (node.FileNodeStatus == FileNodeStatus.None)
{
node.FileNodeStatus = FileNodeStatus.InProject;
}
}
else
{
node = new FileNode(fileItem.FileName, FileNodeStatus.Missing);
node.AddTo(this);
fileNodeDictionary[fileName] = node;
}
}
node.ProjectItem = fileItem;
if (fileItem != null && fileItem.DependentUpon != null && fileItem.DependentUpon.Length > 0)
{
dependendFileDictionary[node] = fileItem.DependentUpon;
}
}
}
// Insert 'code behind files'
foreach (KeyValuePair <FileNode, string> pair in dependendFileDictionary)
{
string fileName = Path.GetFileName(pair.Value);
if (!fileNodeDictionary.ContainsKey(fileName))
{
continue;
}
AbstractProjectBrowserTreeNode parentNode = fileNodeDictionary[fileName];
pair.Key.Parent.Nodes.Remove(pair.Key);
if (NodeIsParent(parentNode, pair.Key))
{
// is pair.Key a parent of parentNode?
// if yes, we have a parent cycle - break it by adding one node to the directory
pair.Key.AddTo(this);
}
else
{
pair.Key.AddTo(parentNode);
if (pair.Key.FileNodeStatus != FileNodeStatus.Missing)
{
pair.Key.FileNodeStatus = FileNodeStatus.BehindFile;
}
}
}
base.Initialize();
}
public virtual object Visit(FileNode fileNode, object data)
{
fileNode.AcceptChildren(this, data);
return data;
}
public void Save()
{
if (resources != null) {
foreach (KeyValuePair<string, ResourceStorage> entry in resources) {
string cultureName = entry.Key;
string resourceFileName = CalcResourceFileName(FormFileName, cultureName);
FileUtility.ObservedSave(new NamedFileOperationDelegate(entry.Value.Save), resourceFileName, FileErrorPolicy.Inform);
IProject project = GetProject(FormFileName);
// Add this resource file to the project
if (entry.Value.ContainsData && project != null && !project.IsFileInProject(resourceFileName)) {
FileProjectItem newFileProjectItem = new FileProjectItem(project, ItemType.EmbeddedResource);
newFileProjectItem.DependentUpon = Path.GetFileName(FormFileName);
newFileProjectItem.Include = FileUtility.GetRelativePath(project.Directory, resourceFileName);
ProjectService.AddProjectItem(project, newFileProjectItem);
PadDescriptor pd = WorkbenchSingleton.Workbench.GetPad(typeof(ProjectBrowserPad));
FileNode formFileNode = ((ProjectBrowserPad)pd.PadContent).ProjectBrowserControl.FindFileNode(FormFileName);
if (formFileNode != null) {
LoggingService.Info("FormFileNode found, adding subitem");
FileNode fileNode = new FileNode(resourceFileName, FileNodeStatus.BehindFile);
fileNode.AddTo(formFileNode);
fileNode.ProjectItem = newFileProjectItem;
}
project.Save();
}
}
}
}
public virtual object Visit(FileNode fileNode, object data)
{
fileNode.AcceptChildren(this, data);
return(data);
}
public static IDataObject CreateDataObject(FileNode node, bool performMove)
{
return(new DataObject(typeof(FileNode).ToString(), new FileOperationClipboardObject(node.FileName, performMove)));
}
public override object Visit(FileNode fileNode, object data)
{
if (IsNewFileIsDependentUponAnotherFile()) {
if (IsImmediateParentForNewFile(fileNode)) {
AddFileNodeTo(fileNode, FileNodeStatus.BehindFile);
return null;
}
}
return base.Visit(fileNode, data);
}
protected override void Initialize()
{
if (removeMe != null) {
Nodes.Remove(removeMe);
removeMe = null;
}
LoggingService.Info("Initialize DirectoryNode " + Directory);
Dictionary<string, FileNode> fileNodeDictionary
= new Dictionary<string, FileNode>(StringComparer.OrdinalIgnoreCase);
Dictionary<FileNode, string> dependendFileDictionary = new Dictionary<FileNode, string>();
Dictionary<string, DirectoryNode> directoryNodeList = new Dictionary<string, DirectoryNode>(StringComparer.OrdinalIgnoreCase);
// Add files found in file system
if (System.IO.Directory.Exists(Directory)) {
foreach (string subDirectory in System.IO.Directory.GetDirectories(Directory)) {
if (Path.GetFileName(subDirectory) != ".svn") {
DirectoryNode newDirectoryNode = DirectoryNodeFactory.CreateDirectoryNode(this, Project, subDirectory);
newDirectoryNode.InsertSorted(this);
directoryNodeList[Path.GetFileName(subDirectory)] = newDirectoryNode;
}
}
foreach (string file in System.IO.Directory.GetFiles(Directory)) {
FileNode fileNode = new FileNode(file);
fileNodeDictionary[Path.GetFileName(file)] = fileNode;
fileNode.InsertSorted(this);
}
}
if (Nodes.Count == 0) {
SetClosedImage();
}
string relativeDirectoryPath = this.RelativePath;
if (relativeDirectoryPath.Length > 0)
relativeDirectoryPath = relativeDirectoryPath.Replace('\\', '/') + '/';
// Add project items
foreach (ProjectItem item in Project.Items) {
if (item.ItemType == ItemType.WebReferenceUrl) {
DirectoryNode node;
if (directoryNodeList.TryGetValue(Path.GetFileName(item.FileName), out node)) {
if (node.FileNodeStatus == FileNodeStatus.None) {
node.FileNodeStatus = FileNodeStatus.InProject;
}
node.ProjectItem = item;
}
continue;
}
FileProjectItem fileItem = item as FileProjectItem;
if (fileItem == null)
continue;
string virtualName = fileItem.VirtualName.Replace('\\', '/');
if (virtualName.EndsWith("/"))
virtualName = virtualName.Substring(0, virtualName.Length - 1);
string fileName = Path.GetFileName(virtualName);
if (!string.Equals(virtualName, relativeDirectoryPath + fileName, StringComparison.OrdinalIgnoreCase)) {
AddParentFolder(virtualName, relativeDirectoryPath, directoryNodeList);
continue;
}
if (item.ItemType == ItemType.Folder || item.ItemType == ItemType.WebReferences) {
DirectoryNode node;
if (directoryNodeList.TryGetValue(fileName, out node)) {
if (node.FileNodeStatus == FileNodeStatus.None) {
node.FileNodeStatus = FileNodeStatus.InProject;
}
node.ProjectItem = item;
} else {
node = DirectoryNodeFactory.CreateDirectoryNode(item, FileNodeStatus.Missing);
node.InsertSorted(this);
directoryNodeList[fileName] = node;
}
} else {
FileNode node;
if (fileItem.IsLink) {
node = new FileNode(fileItem.FileName, FileNodeStatus.InProject);
node.InsertSorted(this);
fileNodeDictionary[fileName] = node;
} else {
if (fileNodeDictionary.TryGetValue(fileName, out node)) {
if (node.FileNodeStatus == FileNodeStatus.None) {
node.FileNodeStatus = FileNodeStatus.InProject;
}
} else {
node = new FileNode(fileItem.FileName, FileNodeStatus.Missing);
node.InsertSorted(this);
fileNodeDictionary[fileName] = node;
}
}
node.ProjectItem = fileItem;
if (fileItem != null && fileItem.DependentUpon != null && fileItem.DependentUpon.Length > 0) {
dependendFileDictionary[node] = fileItem.DependentUpon;
}
}
}
// Insert 'code behind files'
foreach (KeyValuePair<FileNode, string> pair in dependendFileDictionary) {
string fileName = Path.GetFileName(pair.Value);
if (!fileNodeDictionary.ContainsKey(fileName)) {
continue;
}
AbstractProjectBrowserTreeNode parentNode = fileNodeDictionary[fileName];
pair.Key.Parent.Nodes.Remove(pair.Key);
if (NodeIsParent(parentNode, pair.Key)) {
// is pair.Key a parent of parentNode?
// if yes, we have a parent cycle - break it by adding one node to the directory
pair.Key.InsertSorted(this);
} else {
pair.Key.InsertSorted(parentNode);
if (pair.Key.FileNodeStatus != FileNodeStatus.Missing) {
pair.Key.FileNodeStatus = FileNodeStatus.BehindFile;
}
}
}
base.Initialize();
}
bool IsImmediateParentForNewFile(FileNode fileNode)
{
return FileProjectItemExtensions.IsDependentUponFileName(newFileAddedToProject, fileNode.FileName);
}
public static IDataObject CreateDataObject(FileNode node, bool performMove)
{
return new DataObject(typeof(FileNode).ToString(), new FileOperationClipboardObject(node.FileName, performMove));
}
void AddFileToProject(ResourceStorage storage)
{
string resourceFileName = storage.OpenedFile.FileName;
string formFileName = viewContent.PrimaryFileName;
IProject project = GetProject(formFileName);
// Add this resource file to the project
if (project != null && !project.IsFileInProject(resourceFileName)) {
FileProjectItem newFileProjectItem = new FileProjectItem(project, ItemType.EmbeddedResource);
newFileProjectItem.DependentUpon = Path.GetFileName(formFileName);
newFileProjectItem.Include = FileUtility.GetRelativePath(project.Directory, resourceFileName);
ProjectService.AddProjectItem(project, newFileProjectItem);
FileService.FireFileCreated(resourceFileName, false);
PadDescriptor pd = WorkbenchSingleton.Workbench.GetPad(typeof(ProjectBrowserPad));
FileNode formFileNode = ((ProjectBrowserPad)pd.PadContent).ProjectBrowserControl.FindFileNode(formFileName);
if (formFileNode != null) {
LoggingService.Info("FormFileNode found, adding subitem");
FileNode fileNode = new FileNode(resourceFileName, FileNodeStatus.BehindFile);
fileNode.AddTo(formFileNode);
fileNode.ProjectItem = newFileProjectItem;
}
project.Save();
}
}
public override void DoDragDrop(IDataObject dataObject, DragDropEffects effect)
{
PerformInitialization();
Expand();
try {
if (dataObject.GetDataPresent(typeof(FileNode)))
{
FileNode fileNode = (FileNode)dataObject.GetData(typeof(FileNode));
LoggingService.Debug("ProjectBrowser: Dragging file '" + fileNode.FileName + "' onto directory '" + this.Directory + "'");
if (!FileUtility.IsEqualFileName(Directory, fileNode.FileName) && !FileUtility.IsEqualFileName(Directory, Path.GetDirectoryName(fileNode.FileName)) &&
!(fileNode.ProjectItem is FileProjectItem && FileUtility.IsEqualFileName(Directory, Path.GetDirectoryName(GetFullVirtualName((FileProjectItem)fileNode.ProjectItem)))))
{
LoggingService.Debug("-> Not in same directory, performing " + effect.ToString());
CopyFileHere(fileNode, effect == DragDropEffects.Move);
}
else
{
// Dragging a dependent file onto its parent directory
// removes the dependency.
LoggingService.Debug("-> In same directory, removing dependency");
((FileProjectItem)fileNode.ProjectItem).DependentUpon = String.Empty;
fileNode.Remove();
if (!File.Exists(fileNode.FileName))
{
fileNode.FileNodeStatus = FileNodeStatus.Missing;
}
else
{
fileNode.FileNodeStatus = FileNodeStatus.InProject;
}
fileNode.InsertSorted(this);
}
}
else if (dataObject.GetDataPresent(typeof(DirectoryNode)))
{
DirectoryNode directoryNode = (DirectoryNode)dataObject.GetData(typeof(DirectoryNode));
CopyDirectoryHere(directoryNode, effect == DragDropEffects.Move);
}
else if (dataObject.GetDataPresent(DataFormats.FileDrop))
{
string[] files = (string[])dataObject.GetData(DataFormats.FileDrop);
foreach (string fileName in files)
{
if (System.IO.Directory.Exists(fileName))
{
if (!FileUtility.IsBaseDirectory(fileName, Directory))
{
CopyDirectoryHere(fileName, false);
}
}
else
{
CopyFileHere(fileName, false);
}
}
}
ProjectService.SaveSolution();
} catch (Exception e) {
MessageService.ShowError(e);
}
}
