public NewItemDialogViewModel(IProjectFolder folder) : base("New Item")
{
var shell = IoC.Get <IShell>();
var templateManager = IoC.Get <TemplateManager>();
templates = new ObservableCollection <TemplateViewModel>(templateManager.ListItemTemplates("").Select(t => new TemplateViewModel(t)).ToList());
SelectedTemplate = templates.FirstOrDefault();
this.folder = folder;
OKCommand = ReactiveCommand.Create(async() =>
{
await templateManager.CreateTemplate(
SelectedTemplate.Template,
folder.LocationDirectory,
SelectedTemplate.Parameters
.Where(p => !string.IsNullOrEmpty(p.Value.Trim()))
.Select(p => (p.Name.ToLower(), p.Value))
.ToArray());
Close();
});
UpdateTemplatesCommand = ReactiveCommand.Create(() =>
{
Task.Run(() =>
{
templateManager.UpdateDefaultTemplates();
});
});
}
public static Task<ISourceFile> Create(IProjectFolder parent, string name, string text = "")
{
if(parent.Project == null)
{
throw new ArgumentNullException("parent.Project");
}
var filePath = Path.Combine(parent.LocationDirectory, name);
TaskCompletionSource<ISourceFile> fileAddedCompletionSource = new TaskCompletionSource<ISourceFile>();
EventHandler fileAddedHandler = (sender, e) =>
{
var newFile = parent.Project.FindFile(filePath);
if(newFile != null)
{
fileAddedCompletionSource.SetResult(newFile);
}
};
parent.Project.FileAdded += fileAddedHandler;
var file = System.IO.File.CreateText(filePath);
file.Write(text);
file.Close();
fileAddedCompletionSource.Task.ContinueWith((f) =>
{
parent.Project.FileAdded -= fileAddedHandler;
});
return fileAddedCompletionSource.Task;
}
private static bool TryGetOrCreateProjectFolder(
RelativePath relativeFilePath,
IProject project,
IProjectModelTransactionCookie transaction,
out IProjectFolder projectFolder)
{
RelativePath subFolderRelativePath =
SolutionFilePathHelpers.GetProjectSubFolderRelativePath(relativeFilePath, project);
if (!SolutionFilePathHelpers.TryGetProjectFolder(subFolderRelativePath, project, out projectFolder))
{
string message =
$"There is not folder '{subFolderRelativePath}' in project '{project.Name}'.{Environment.NewLine}" +
"Do you want to create it?";
if (!MessageBox.ShowYesNo(message))
{
return(false);
}
FileSystemPath fileSystemPath = subFolderRelativePath.MakeAbsoluteBasedOn(project.Location);
projectFolder = project.GetOrCreateProjectFolder(fileSystemPath, transaction);
}
return(true);
}
private async Task <IProjectFolder> GetSubFoldersAsync(IProjectFolder parent, string path)
{
var result = new FileSystemFolder(path);
try
{
var folders = Directory.GetDirectories(path);
if (folders.Count() > 0)
{
foreach (var folder in folders.Where(f => !IsExcluded(f)))
{
result.Items.InsertSorted(await GetSubFoldersAsync(result, folder));
}
}
await PopulateFilesAsync(result);
Folders.InsertSorted(result);
result.Parent = parent;
result.Project = this;
}
catch (Exception)
{
}
return(result);
}
public override bool IsAvailableCore()
{
this.TableName = Helpers.GetTableName(this.Class);
if (this.TableName == null)
{
return(false);
}
IProjectFolder migrationsFolder =
this.DataProvider.Project.GetSubFolders().FirstOrDefault(x => x.Name == "Migrations");
if (migrationsFolder == null)
{
return(false);
}
IList <IProjectFile> migrationFiles = migrationsFolder.GetSubFiles();
foreach (IProjectFile migrationFile in migrationFiles)
{
if (int.TryParse(migrationFile.Name.SubstringAfter("M").SubstringBefore("_"), out int migrationNumber))
{
this.MigrationNumber = Math.Max(this.MigrationNumber, migrationNumber + 1);
}
}
return(true);
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var projectFile = (IProjectFile)_highlight.OffendingProjectItem;
using (var cookie = solution.CreateTransactionCookie(DefaultAction.Rollback, this.GetType().Name, progress))
{
IProjectFolder newFolder = (IProjectFolder)_highlight.TargetProject.FindProjectItemByLocation(_highlight.TargetFolder)
?? _highlight.TargetProject.GetOrCreateProjectFolder(_highlight.TargetFolder, cookie);
var workflow = new MoveToFolderWorkflow(solution, "ManualMoveToFolderQuickFix");
IProjectFolder targetFolder = newFolder ?? _highlight.TargetProject;
var dataProvider = new MoveToFolderDataProvider(true, false, targetFolder, new List <string>(), new List <string>());
workflow.SetDataProvider(dataProvider);
Lifetimes.Using(
(lifetime => WorkflowExecuter.ExecuteWithCustomHost(
Shell.Instance.GetComponent <IActionManager>()
.DataContexts.CreateWithoutDataRules(lifetime
, DataRules.AddRule(DataRules.AddRule("ManualMoveToFolderQuickFix"
, JetBrains.ProjectModel.DataContext.ProjectModelDataConstants.PROJECT_MODEL_ELEMENTS, new IProjectModelElement[] { projectFile })
, "ManualMoveToFolderQuickFix"
, JetBrains.ProjectModel.DataContext.ProjectModelDataConstants.SOLUTION, solution))
, workflow, new SimpleWorkflowHost())));
cookie.Commit(progress);
}
return(null);
}
public void RemoveFolder(IProjectFolder folder)
{
folder.Parent.Items.Remove(folder);
RemoveFiles(this, folder);
Folders.Remove(folder);
}
public static Task <ISourceFile> Create(IProjectFolder parent, string name, string text = "")
{
if (parent.Project == null)
{
throw new ArgumentNullException("parent.Project");
}
var filePath = Path.Combine(parent.LocationDirectory, name);
TaskCompletionSource <ISourceFile> fileAddedCompletionSource = new TaskCompletionSource <ISourceFile>();
EventHandler fileAddedHandler = (sender, e) =>
{
var newFile = parent.Project.FindFile(filePath);
if (newFile != null)
{
fileAddedCompletionSource.SetResult(newFile);
}
};
parent.Project.FileAdded += fileAddedHandler;
using (var file = System.IO.File.CreateText(filePath))
{
file.Write(text);
}
fileAddedCompletionSource.Task.ContinueWith((f) =>
{
parent.Project.FileAdded -= fileAddedHandler;
});
return(fileAddedCompletionSource.Task);
}
private void RecurseReadFolders(XmlTextReader reader, ref IProjectFolder folder)
{
if (reader.IsEmptyElement)
{
return;
}
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
return;
}
if (reader.Name == "Folder")
{
IProjectFolder subFolder = new ProjectFolder(this, reader.GetAttribute("Name"));
folder.AddFolder(subFolder);
RecurseReadFolders(reader, ref subFolder);
}
else if (reader.Name == "File")
{
IProjectFile file = new ProjectFile(this, reader.GetAttribute("Path"));
folder.AddFile(file);
}
else
{
return;
}
}
}
public IProjectFolder AddFolder(string dirName, IProjectFolder parentFolder)
{
IProjectFolder folder = new ProjectFolder(this, dirName);
parentFolder.AddFolder(folder);
return(folder);
}
public static IProjectFolder GetSubFolders(FileSystemProject project, IProjectFolder parent, string path)
{
var result = new StandardProjectFolder(path);
try
{
var folders = Directory.GetDirectories(path);
if (folders.Count() > 0)
{
foreach (var folder in folders.Where(f => !IsExcluded(project.ExcludedFiles, project.CurrentDirectory.MakeRelativePath(f).ToAvalonPath())))
{
result.Items.InsertSorted(GetSubFolders(project, result, folder));
}
}
PopulateFiles(project, result);
project.Folders.InsertSorted(result);
result.Parent = parent;
result.Project = project;
}
catch (Exception)
{
}
return(result);
}
public IProjectFile AddFile(IProjectFolder parentFolder, string fullPath)
{
IProjectFile file = new ProjectFile(this, fullPath);
parentFolder.AddFile(file);
return(file);
}
private void ExcludePackageRootFolderFromNamespace(ISettingsStorageMountPoint mountPoint,
IProjectFolder folder, string path)
{
ExcludeFolderFromNamespace(mountPoint, path);
// Is it a package folder? Exclude Scripts, Runtime, Scripts/Runtime and Runtime/Scripts
if (folder.Location.Combine("package.json").ExistsFile)
{
// The folder will be linked if the project's files belong to a package that is external to the solution
// folder. With a linked folder, the namespace provider must be the actual path, relative to the parent
// folder, rather than the visible path in the Solution Explorer
//
// NOTE: KEEP UP TO DATE WITH ExternalPackageCustomNamespaceProvider!
if (folder.IsLinked && folder.ParentFolder != null)
{
path = folder.Location.ConvertToRelativePath(folder.ParentFolder.Location).FullPath;
}
ExcludeFolderFromNamespace(mountPoint, path + @"\Runtime");
ExcludeFolderFromNamespace(mountPoint, path + @"\Scripts");
ExcludeFolderFromNamespace(mountPoint, path + @"\Runtime\Scripts");
ExcludeFolderFromNamespace(mountPoint, path + @"\Scripts\Runtime");
return;
}
// Recurse until we hit the package root
ExcludePackageSubFoldersFromNamespace(mountPoint, folder, path);
}
public void CreateScript(ProjectItem folder)
{
string name = m_project.GetUniqueName(m_localization.GetString("ID_RTScripting_ScriptsManager_Script", "Script"), Ext, folder, true);
string nl = Environment.NewLine;
RuntimeTextAsset csFile = ScriptableObject.CreateInstance <RuntimeTextAsset>();
csFile.name = name;
csFile.Ext = Ext;
csFile.Text =
"using System.Collections;" + nl +
"using System.Collections.Generic;" + nl +
"using UnityEngine;" + nl + nl +
"public class " + name + " : MonoBehaviour" + nl +
"{" + nl +
" // Start is called before the first frame update" + nl +
" void Start()" + nl +
" {" + nl +
" }" + nl + nl +
" // Update is called once per frame" + nl +
" void Update()" + nl +
" {" + nl +
" }" + nl +
"}";
IProjectFolder projectFolder = IOC.Resolve <IProjectFolder>();
projectFolder.CreateAsset(csFile, folder);
}
public void CreateFileWithinProject([NotNull] TestCopProjectItem projectItem, [NotNull] string targetFile)
{
var desiredTemplateName = LookupTemplateName(projectItem.Project);
var boundSettingsStore = _settingsStore.BindToContextTransient(ContextRange.ApplicationWide);
var context = _dataContexts.CreateOnActiveControl(_lifetime);
var applicableFileTemplateScopes = _scopeManager.EnumerateRealScopePoints(new TemplateAcceptanceContext(new ProjectFolderWithLocation(projectItem.Project)));
applicableFileTemplateScopes = applicableFileTemplateScopes.Distinct().Where(s => s is InLanguageSpecificProject).ToList();
var classTemplate = _storedTemplatesProvider.EnumerateTemplates(boundSettingsStore, TemplateApplicability.File)
.Where(x => x.Description == desiredTemplateName &&
TemplateScopeManager.TemplateIsAvailable(x, applicableFileTemplateScopes))
.Select(x => x)
.FirstOrDefault();
if (classTemplate == null)
{
ResharperHelper.AppendLineToOutputWindow(string.Format("File Template for '{0}' not found with default to 'Class'", desiredTemplateName));
classTemplate = LoadTemplateFromQuickList(context, "Class");
}
IProjectFolder folder = (IProjectFolder)projectItem.Project.FindProjectItemByLocation(projectItem.SubNamespaceFolder)
?? GetOrCreateProjectFolder(projectItem);
if (folder == null)
{
ResharperHelper.AppendLineToOutputWindow("Error failed to create/location project folder" + projectItem.SubNamespaceFolder);
return;
}
string extension = Enumerable.First(_fileExtensions.GetExtensions(projectItem.Project.ProjectProperties.DefaultLanguage.DefaultProjectFileType));
FileTemplatesManager.Instance.CreateFileFromTemplate(targetFile + extension, new ProjectFolderWithLocation(folder), classTemplate);
}
private void Unsubscribe()
{
if (m_wm != null)
{
m_wm.WindowCreated -= OnWindowCreated;
m_wm.WindowDestroyed -= OnWindowDestroyed;
m_wm = null;
}
if (m_scriptManager != null)
{
m_scriptManager.Loading -= OnScriptManagerLoading;
m_scriptManager.Loaded -= OnScriptManagerLoaded;
m_scriptManager.Compiling -= OnScriptManagerCompiling;
m_scriptManager.Complied -= OnScriptManagerCompiled;
}
if (m_projectFolder != null)
{
m_projectFolder.ItemOpen -= OnProjectFolderItemOpen;
m_projectFolder.ValidateContextMenuOpenCommand -= OnProjectFolderValidateContextMenuOpenCommand;
m_projectFolder.ContextMenu -= OnProjectFolderContextMenu;
m_projectFolder = null;
}
}
private void Init()
{
IProjectFolder projectFolder = IOC.Resolve <IProjectFolder>();
IProjectTree projectTree = IOC.Resolve <IProjectTree>();
if (m_projectFolder != projectFolder)
{
m_projectFolder = projectFolder;
if (m_projectFolder != null)
{
m_projectFolder.ItemsDeleting += OnItemsDeleting;
m_projectFolder.ItemDataBinding += OnItemDataBinding;
m_projectFolder.Destroyed += OnDestroyed;
}
}
if (m_projectTree != projectTree)
{
m_projectTree = projectTree;
if (m_projectTree != null)
{
m_projectTree.ItemsDeleting += OnItemsDeleting;
m_projectTree.ItemDataBinding += OnItemDataBinding;
m_projectTree.Destroyed += OnDestroyed;
}
}
}
public NewItemDialogViewModel(IProjectFolder folder) : base("New Item")
{
var shell = IoC.Get<IShell>();
templates = new ObservableCollection<ICodeTemplate>();
var compatibleTemplates = shell.CodeTemplates.Where(t => t.IsCompatible(folder.Project));
foreach (var template in compatibleTemplates)
{
templates.Add(template);
}
SelectedTemplate = templates.FirstOrDefault();
this.folder = folder;
OKCommand = ReactiveCommand.Create();
OKCommand.Subscribe(_ =>
{
if (SelectedTemplate != null)
{
}
Close();
});
}
public ProjectFile(string path, IProjectFolder parentFolder)
{
Name = System.IO.Path.GetFileName(path);
Extension = System.IO.Path.GetExtension(path);
Path = path;
ParentFolder = parentFolder;
}
public NewItemDialogViewModel(IProjectFolder folder) : base("New Item")
{
var shell = IoC.Get <IShell>();
templates = new ObservableCollection <ICodeTemplate>();
var compatibleTemplates = shell.CodeTemplates.Where(t => t.IsCompatible(folder.Project));
foreach (var template in compatibleTemplates)
{
templates.Add(template);
}
SelectedTemplate = templates.FirstOrDefault();
this.folder = folder;
OKCommand = ReactiveCommand.Create(() =>
{
if (SelectedTemplate != null)
{
}
Close();
});
}
private static IEnumerable <IProjectFile> GetNetCoreJsonConfigFiles(IProjectFolder project)
{
var additionalConfigurationFiles = project.GetSolution().GetAdditionalConfigurationFiles();
return(project.GetAllProjectFiles(
file => file.LanguageType.Is <JsonProjectFileType>() &&
(file.Name.Equals(FileNames.NetCoreAppSettingsJson, StringComparison.OrdinalIgnoreCase) ||
additionalConfigurationFiles.Contains(file.GetPersistentID()))));
}
private void ExcludePackageSubFoldersFromNamespace(ISettingsStorageMountPoint mountPoint,
IProjectFolder thisFolder, string thisPath)
{
foreach (var subFolder in thisFolder.GetSubFolders())
{
var path = thisPath + @"\" + subFolder.Name;
ExcludePackageRootFolderFromNamespace(mountPoint, subFolder, path);
}
}
public override void ExcludeFolder(IProjectFolder folder)
{
folder.Parent.Items.Remove(folder);
ExcludedFiles.Add(folder.Project.CurrentDirectory.MakeRelativePath(folder.Location).ToAvalonPath());
RemoveFiles(this, folder);
Save();
}
private static IProjectFile FindTestFileInProject(IProjectFolder testProject, string fileName)
{
if (fileName.Contains('.'))
{
fileName = fileName.Split('.').First();
}
var projectFiles = testProject.GetAllProjectFiles();
return(projectFiles.FirstOrDefault(file => file.Name.Contains(fileName)));
}
public override bool Equals(object obj)
{
IProjectFolder folder = obj as IProjectFolder;
if (folder == null)
{
return(base.Equals(obj));
}
return(Name.Equals(folder.Name));
}
public void SetUp()
{
_temporaryDirectory = new TemporaryDirectory();
var projectName = Path.GetRandomFileName();
var projectLocation = _temporaryDirectory.Path;
var project = Project.Create(projectName, projectLocation);
_folder = project.AddFolder("FolderUnderTest");
}
private void RecurseAddFiles(ref IList <IProjectFile> files, IProjectFolder folder)
{
foreach (IProjectFolder subFolder in folder.Folders)
{
RecurseAddFiles(ref files, subFolder);
}
foreach (IProjectFile file in folder.Files)
{
files.Add(file);
}
}
public static void PopulateFiles(FileSystemProject project, IProjectFolder folder)
{
var files = Directory.EnumerateFiles(folder.Location);
files = files.Where(f =>!IsExcluded(project.ExcludedFiles, project.CurrentDirectory.MakeRelativePath(f).ToAvalonPath()) && f != project.Location);
foreach (var file in files)
{
var sourceFile = File.FromPath(project, folder, file.ToPlatformPath());
project.SourceFiles.InsertSorted(sourceFile);
folder.Items.InsertSorted(sourceFile);
}
}
public FolderViewModel(IProjectFolder folder, IProjectExplorerItemViewModelFactory factory,
IAddContextMenuItemFactory addContextMenuItemFactory) : base(folder.FolderName)
{
_folder = folder;
_factory = factory;
UpdateItems(_factory.Create(_folder.Folders, _folder.Files));
ContextMenuItems.Add(addContextMenuItemFactory.Create(folder));
folder.FolderAdded += OnFolderItemsChanged;
folder.FileAdded += OnFolderItemsChanged;
}
public void BuildProjTree()
{
projViewer.Items.Clear();
//projViewer.TreeViewNodeSorter = new NodeSorter();
IProjectFolder folder = projectService.CurrentProject.MainFolder;
RecurseAddNodes(folder, null);
if (projViewer.Items.Count > 0)
{
(projViewer.Items[0] as TreeViewItem).ExpandSubtree();
}
//projViewer.Sort();
}
private void RecurseAddNodes(IProjectFolder folder, TreeViewItem parentNode)
{
var nodeAdded = AddFolder(folder, parentNode);
foreach (IProjectFolder subFolder in folder.Folders)
{
RecurseAddNodes(subFolder, nodeAdded);
}
foreach (IProjectFile file in folder.Files)
{
AddFile(file, nodeAdded);
}
}
public static void PopulateFiles(FileSystemProject project, IProjectFolder folder)
{
var files = Directory.EnumerateFiles(folder.Location);
files = files.Where(f => !IsExcluded(project.ExcludedFiles, project.CurrentDirectory.MakeRelativePath(f).ToAvalonPath()) && f != project.Location);
foreach (var file in files)
{
var sourceFile = File.FromPath(project, folder, file.ToPlatformPath().NormalizePath());
project.SourceFiles.InsertSorted(sourceFile);
folder.Items.InsertSorted(sourceFile);
}
}
private static string CalculateNamespaceForProjectFromRootFolder(
[CanBeNull] IProject project, IProjectFolder rootFolder, LanguageService languageService)
{
if (project == null || !rootFolder.IsLinked || rootFolder.Path == null)
{
return(null);
}
var calculatedNamespace = project.GetData(ourCalculatedDefaultNamespaceKey);
if (calculatedNamespace != null)
{
return(calculatedNamespace);
}
var location = rootFolder.Path.ReferencedFolderPath;
var packageJsonDirectory = FileSystemUtil.TryGetDirectoryNameOfFileAbove(location, "package.json");
if (packageJsonDirectory != null)
{
var path = location.MakeRelativeTo(packageJsonDirectory);
// MAKE SURE TO KEEP UP TO DATE WITH THE RULES IN NamespaceProviderProjectSettingsProvider
if (path.StartsWith("Runtime/Scripts"))
{
path = path.RemovePrefix("Runtime/Scripts");
}
else if (path.StartsWith("Scripts/Runtime"))
{
path = path.RemovePrefix("Scripts/Runtime");
}
else if (path.StartsWith("Runtime"))
{
path = path.RemovePrefix("Runtime");
}
else if (path.StartsWith("Scripts"))
{
path = path.RemovePrefix("Scripts");
}
foreach (var pathComponent in path.Components)
{
var name = NamespaceFolderUtil.MakeValidQualifiedName(pathComponent.ToString(), languageService);
calculatedNamespace = calculatedNamespace.IsNullOrEmpty() ? name : $"{calculatedNamespace}.{name}";
}
}
project.PutData(ourCalculatedDefaultNamespaceKey, calculatedNamespace);
return(calculatedNamespace);
}
protected IFile GetFile(string testSrc, IProjectFolder project)
{
var item = (IProjectFile) project.GetSubItem(testSrc);
Assert.NotNull(item);
IPsiSourceFile sourceFile = item.ToSourceFile();
Assert.IsNotNull(sourceFile);
Assert.True(sourceFile.IsValid());
IFile file = sourceFile.EnumeratePsiFiles().First();
return file;
}
public async Task Generate(IProjectFolder folder)
{
await Task.Factory.StartNew(async () =>
{
var name = _settings.ClassName;
var sourceTemplate = new CPlusPlusClassTemplate(name, _settings.GenerateHeader);
var headerTemplate = new CPlusPlusClassHeaderTemplate(name);
if (_settings.GenerateHeader)
{
await SourceFile.Create(folder, $"{(name.Contains('.') ? name : name + ".h")}", headerTemplate.TransformText());
}
if (_settings.GenerateClass)
{
await SourceFile.Create(folder, $"{name}.cpp", sourceTemplate.TransformText());
}
});
}
public static IProjectFolder GetSubFolders(FileSystemProject project, IProjectFolder parent, string path)
{
var result = new StandardProjectFolder(path);
var folders = Directory.GetDirectories(path);
if (folders.Count() > 0)
{
foreach (var folder in folders.Where(f => !IsExcluded(project.ExcludedFiles, project.CurrentDirectory.MakeRelativePath(f).ToAvalonPath())))
{
result.Items.InsertSorted(GetSubFolders(project, result, folder));
}
}
PopulateFiles(project, result);
project.Folders.InsertSorted(result);
result.Parent = parent;
result.Project = project;
return result;
}
public abstract int CompareTo(IProjectFolder other);
public abstract void ExcludeFolder(IProjectFolder folder);
public static File FromPath(IProject project, IProjectFolder parent, string filePath)
{
return new File { Project = project, Parent = parent, FilePath = filePath.ToPlatformPath() };
}
public static string TryGetSymbolFromOperand(IProjectFolder folder, string operand)
{
var programFolder = folder.Parent as S7ProgrammFolder;
if(programFolder == null) return null;
if (programFolder.SymbolTable == null) return null;
var ste = programFolder.SymbolTable.GetEntryFromOperand(operand);
return ste == null ? null : ste.Symbol;
}
public override void ExcludeFolder(IProjectFolder folder)
{
throw new NotImplementedException();
}
public override int CompareTo(IProjectFolder other)
{
return Location.CompareFilePath(other.Location);
}
public void ExcludeFolder(IProjectFolder folder)
{
Project.ExcludeFolder(folder);
}
public static string TryGetOperandFromSymbol(IProjectFolder folder, string symbol)
{
var programFolder = folder.Parent as S7ProgrammFolder;
if (programFolder == null) return null;
if (programFolder.SymbolTable == null) return null;
var o = symbol.Replace("\"", "");
var ste = programFolder.SymbolTable.GetEntryFromSymbol(o);
return ste == null ? null : ste.Operand;
}
private void RemoveFiles(CPlusPlusProject project, IProjectFolder folder)
{
foreach (var item in folder.Items)
{
if (item is IProjectFolder)
{
RemoveFiles(project, item as IProjectFolder);
project.Folders.Remove(item as IProjectFolder);
}
if (item is ISourceFile)
{
project.SourceFiles.Remove(item as ISourceFile);
}
}
}
public override void ExcludeFolder(IProjectFolder folder)
{
folder.Parent.Items.Remove(folder);
ExcludedFiles.Add(folder.Project.CurrentDirectory.MakeRelativePath(folder.Location).ToAvalonPath());
RemoveFiles(this, folder);
Save();
}
/// <summary>
/// 移动项到文件夹
/// </summary>
public static bool MoveItem(IProjectItem item, IProjectFolder directory)
{
string newName = Path.Combine(directory.FileName, item.Name);
if (FileService.RenameFile(item.FileName, newName, item is IProjectFolder))
{
return true;
}
return false;
}
public void RemoveFolder(IProjectFolder folder)
{
folder.Parent.Items.Remove(folder);
RemoveFiles(this, folder);
Folders.Remove(folder);
}
