public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { if (tree != null) { if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(ProjectIconProvider.ProjectNodeImage.ToProjectSystemType()); } else if (tree.Capabilities.Contains(ProjectTreeCapabilities.FileOnDisk)) { string ext = Path.GetExtension(tree.FilePath).ToLowerInvariant(); if (ext == ".r") { tree = tree.SetIcon(ProjectIconProvider.RFileNodeImage.ToProjectSystemType()); } else if (ext == ".rdata" || ext == ".rhistory") { tree = tree.SetIcon(ProjectIconProvider.RDataFileNodeImage.ToProjectSystemType()); } else if (ext == ".md" || ext == ".rmd") { tree = tree.SetIcon(KnownMonikers.MarkdownFile.ToProjectSystemType()); } else if (tree.FilePath.EndsWithIgnoreCase(SProcFileExtensions.QueryFileExtension)) { tree = tree.SetIcon(KnownMonikers.DatabaseColumn.ToProjectSystemType()); } else if (tree.FilePath.EndsWithIgnoreCase(SProcFileExtensions.SProcFileExtension)) { tree = tree.SetIcon(KnownMonikers.DatabaseStoredProcedures.ToProjectSystemType()); } } } return(tree); }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { if (tree != null) { if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(ProjectIconProvider.ProjectNodeImage.ToProjectSystemType()); } else if (tree.Capabilities.Contains(ProjectTreeCapabilities.FileOnDisk)) { string name = Path.GetFileName(tree.FilePath).ToLowerInvariant(); if (name == "cargo.toml") { tree = tree.SetIcon(ProjectIconProvider.CargoManifestNodeImage.ToProjectSystemType()); } else { string ext = Path.GetExtension(tree.FilePath).ToLowerInvariant(); if (ext == ".rs") { tree = tree.SetIcon(ProjectIconProvider.RustFileNodeImage.ToProjectSystemType()); } else if (ext == ".md") { tree = tree.SetIcon(KnownMonikers.MarkdownFile.ToProjectSystemType()); } } } } return(tree); }
public static IPhysicalProjectTree Create(IProjectTreeProvider provider = null) { var mock = new Mock <IPhysicalProjectTree>(); mock.Setup(t => t.TreeProvider).Returns(provider ?? IProjectTreeProviderFactory.Create()); return(mock.Object); }
private async Task <IProjectTree?> GetAppDesignerFolderAsync(IProjectTreeProvider provider, IProjectTree root) { string?appDesignerPath = await GetAppDesignerFolderPathAsync(); if (appDesignerPath == null) { return(null); } return(provider.FindByPath(root, appDesignerPath)); }
private async Task <IProjectTree?> FindAppDesignerFolderCandidateAsync(IProjectTreeProvider provider, IProjectTree root) { string?path = await GetDefaultFileAsync(provider, root); if (path == null) { return(null); } return(provider.FindByPath(root, path)); }
protected override async Task <IProjectTree?> FindFileAsync(IProjectTreeProvider provider, IProjectTree root) { string?path = await GetAppManifestPathFromPropertiesAsync(); if (path == null) { return(await base.FindFileAsync(provider, root)); } return(provider.FindByPath(root, path)); }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { #if Dev12 if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) tree = tree.SetIcon(Resources.NuProj); #else if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) tree = tree.SetIcon(KnownMonikers.NuGet.ToProjectSystemType()); #endif return tree; }
private async Task <string?> CreateDefaultFileAsync(IProjectTreeProvider provider, IProjectTree root, SpecialFileFlags flags) { string?path = await GetDefaultFileAsync(provider, root); if (path != null && flags.HasFlag(SpecialFileFlags.CreateIfNotExist)) { await CreateFileAsync(path); } // We always return the default path, regardless of whether we created it or it exists, as per contract return(path); }
protected override Task <string?> GetDefaultFileAsync(IProjectTreeProvider provider, IProjectTree root) { string?projectPath = provider.GetRootedAddNewItemDirectory(root); if (projectPath == null) // Root has DisableAddItem { return(Task.FromResult <string?>(null)); } string path = Path.Combine(projectPath, _fileName); return(Task.FromResult <string?>(path)); }
protected override async Task <string?> GetDefaultFileAsync(IProjectTreeProvider provider, IProjectTree root) { // AppDesigner folder first if it exists string?appDesignerPath = await GetAppDesignerFolderPathAsync(); if (appDesignerPath != null) { return(GetDefaultFileAsync(appDesignerPath)); } // Then fallback to project root return(await base.GetDefaultFileAsync(provider, root)); }
protected override async Task <IProjectTree?> FindFileAsync(IProjectTreeProvider provider, IProjectTree root) { // First look for the actual AppDesigner folder IProjectTree?folder = FindAppDesignerFolder(root); if (folder == null) { // Otherwise, find a location that is a candidate folder = await FindAppDesignerFolderCandidateAsync(provider, root); } return(folder); }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(EpochImagesMonikers.ProjectIconImageMoniker.ToProjectSystemType()); } else if (tree.Capabilities.Contains(ProjectTreeCapabilities.FileOnDisk) && tree.FilePath.EndsWith(".epoch", StringComparison.CurrentCultureIgnoreCase)) { tree = tree.SetIcon(EpochImagesMonikers.DocumentIconImageMoniker.ToProjectSystemType()); } return(tree); }
protected override async Task <IProjectTree?> FindFileAsync(IProjectTreeProvider provider, IProjectTree root) { // First look for the actual App.xaml first IProjectTree?node = FindAppXamlFile(root); if (node == null) { // Otherwise, find a candidate that we might be able to add to the project node = await base.FindFileAsync(provider, root); } return(node); }
public ProjectAssetFileWatcher( [Import(ContractNames.ProjectTreeProviders.FileSystemDirectoryTree)] IProjectTreeProvider fileSystemTreeProvider, IUnconfiguredProjectCommonServices projectServices, IUnconfiguredProjectTasksService projectTasksService, IActiveConfiguredProjectSubscriptionService activeConfiguredProjectSubscriptionService) : this( AsyncServiceProvider.GlobalProvider, fileSystemTreeProvider, projectServices, projectTasksService, activeConfiguredProjectSubscriptionService) { }
public ProjectAssetFileWatcher( IVsService <SVsFileChangeEx, IVsAsyncFileChangeEx> fileChangeService, [Import(ContractNames.ProjectTreeProviders.FileSystemDirectoryTree)] IProjectTreeProvider fileSystemTreeProvider, IUnconfiguredProjectCommonServices projectServices, IUnconfiguredProjectTasksService projectTasksService, IActiveConfiguredProjectSubscriptionService activeConfiguredProjectSubscriptionService) : base(projectServices.ThreadingService.JoinableTaskContext) { _fileChangeService = fileChangeService; _fileSystemTreeProvider = fileSystemTreeProvider; _projectServices = projectServices; _projectTasksService = projectTasksService; _activeConfiguredProjectSubscriptionService = activeConfiguredProjectSubscriptionService; }
public static IPhysicalProjectTree Create(IProjectTreeProvider provider = null, IProjectTree currentTree = null, IProjectTreeService service = null) { var mock = new Mock <IPhysicalProjectTree>(); mock.Setup(t => t.TreeProvider) .Returns(provider ?? IProjectTreeProviderFactory.Create()); mock.Setup(t => t.CurrentTree) .Returns(currentTree ?? ProjectTreeParser.Parse("Project")); mock.Setup(t => t.TreeService) .Returns(service ?? IProjectTreeServiceFactory.Create()); return(mock.Object); }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { // Only set the icon for the root project node. We could choose to set different icons for nodes based // on various criteria, not just Capabilities, if we wished. if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(AndroidMonikers.ProjectIconImageMoniker.ToProjectSystemType()); } else if (tree.Capabilities.Contains(ProjectTreeCapabilities.SourceFile) && tree.FilePath.EndsWith(".smali")) { tree = tree.SetIcon(SmaliMonikers.ProjectIconImageMoniker.ToProjectSystemType()); } return(tree); }
public ProjectLockFileWatcher([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider, [Import(ContractNames.ProjectTreeProviders.FileSystemDirectoryTree)] IProjectTreeProvider fileSystemTreeProvider, IUnconfiguredProjectCommonServices projectServices, IProjectLockService projectLockService) { Requires.NotNull(serviceProvider, nameof(serviceProvider)); Requires.NotNull(fileSystemTreeProvider, nameof(fileSystemTreeProvider)); Requires.NotNull(projectServices, nameof(projectServices)); Requires.NotNull(projectLockService, nameof(projectLockService)); _serviceProvider = serviceProvider; _fileSystemTreeProvider = fileSystemTreeProvider; _projectServices = projectServices; _projectLockService = projectLockService; }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { // Only set the icon for the root project node. We could choose to set different icons for nodes based // on various criteria, not just Capabilities, if we wished. if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(XSharpImagesMonikers.ProjectIconImageMoniker.ToProjectSystemType()); } if (tree.BrowseObjectProperties?.ItemType?.ToLower() == "compile") //if (tree.Capabilities.Contains(ProjectTreeCapabilities.SourceFile)) { tree = tree.SetIcon(XSharpImagesMonikers.ItemIconImageMoniker.ToProjectSystemType()); } return(tree); }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { // Only set the icon for the root project node. We could choose to set different icons for nodes based // on various criteria, not just Capabilities, if we wished. if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(XSharpImagesMonikers.ProjectIconImageMoniker.ToProjectSystemType()); } if (tree.BrowseObjectProperties?.ItemType?.ToLower() == "compile") //if (tree.Capabilities.Contains(ProjectTreeCapabilities.SourceFile)) { tree = tree.SetIcon(XSharpImagesMonikers.ItemIconImageMoniker.ToProjectSystemType()); } return tree; }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { #if Dev12 if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(Resources.NuProj); } #else if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(KnownMonikers.NuGet.ToProjectSystemType()); } #endif return(tree); }
public static IProjectTreeService Create(IProjectTree tree, IProjectTreeProvider treeProvider = null) { var mock = new Mock <IProjectTreeService>(); var treeState = IProjectTreeServiceStateFactory.ImplementTree(() => tree, () => treeProvider ?? IProjectTreeProviderFactory.Create()); mock.Setup(s => s.PublishAnyNonLoadingTreeAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(treeState); mock.Setup(s => s.PublishAnyNonNullTreeAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(treeState); mock.SetupGet(s => s.CurrentTree) .Returns(treeState); return(mock.Object); }
protected override async Task <string?> GetDefaultFileAsync(IProjectTreeProvider provider, IProjectTree root) { string?projectPath = provider.GetRootedAddNewItemDirectory(root); if (projectPath == null) // Root has DisableAddItem { return(null); } string?folderName = await GetDefaultAppDesignerFolderNameAsync(); if (string.IsNullOrEmpty(folderName)) { return(null); // Developer has set the AppDesigner path to empty } return(Path.Combine(projectPath, folderName)); }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { if (tree != null) { if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(ProjectIconProvider.ProjectNodeImage.ToProjectSystemType()); } else if (tree.Capabilities.Contains(ProjectTreeCapabilities.FileOnDisk)) { string ext = Path.GetExtension(tree.FilePath).ToLowerInvariant(); if (ext == ".r") { tree = tree.SetIcon(ProjectIconProvider.RFileNodeImage.ToProjectSystemType()); } else if (ext == ".rdata" || ext == ".rhistory") { tree = tree.SetIcon(ProjectIconProvider.RDataFileNodeImage.ToProjectSystemType()); } if (ext == ".md" || ext == ".rmd") { tree = tree.SetIcon(KnownMonikers.MarkdownFile.ToProjectSystemType()); } } } return tree; }
/// <summary> /// Returns a rooted directory that new files should added to the project under when the user /// initiates an Add New Item operation on a particular node in the tree. /// </summary> /// <param name="provider"> /// The <see cref="IProjectTreeProvider"/> that provides the directory. /// </param> /// <param name="target"> /// The <see cref="IProjectTree"/> in the tree that is the receiver of the Add New Item operation. /// </param> /// <returns> /// A <see cref="string"/> containing the path path under which to save the new items, or <see langword="null"/> /// if <paramref name="target"/> does not support adding new items. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="provider"/> is <see langword="null"/>. /// <para> /// -or- /// </para> /// <paramref name="target"/> is <see langword="null"/>. /// </exception> public static string GetRootedAddNewItemDirectory(this IProjectTreeProvider provider, IProjectTree target) { Requires.NotNull(provider, nameof(provider)); Requires.NotNull(target, nameof(target)); string relativePath = provider.GetAddNewItemDirectory(target); if (relativePath == null) { return(null); } string projectFilePath = provider.GetPath(target.Root); string rootPath = Path.GetDirectoryName(projectFilePath); return(Path.Combine(rootPath, relativePath)); }
protected override async Task <IProjectTree?> FindFileAsync(IProjectTreeProvider provider, IProjectTree root) { // Search AppDesigner folder first if it exists IProjectTree?appDesignerFolder = await GetAppDesignerFolderAsync(provider, root); if (appDesignerFolder != null) { IProjectTree?node = await base.FindFileAsync(provider, appDesignerFolder); if (node != null) { return(node); } } // Then fallback to project root return(await base.FindFileAsync(provider, root)); }
private async Task <string?> FindFileAsync(IProjectTreeProvider provider, IProjectTree root, SpecialFileFlags flags) { IProjectTree?node = await FindFileAsync(provider, root); if (node == null) { return(null); } string?path = GetFilePath(provider, node); if (path != null && flags.HasFlag(SpecialFileFlags.CreateIfNotExist)) { // Similar to legacy, we only verify state if we've been asked to create it await VerifyStateAsync(node, path); } return(path); }
public ProjectAssetFileWatcher( IAsyncServiceProvider asyncServiceProvider, IProjectTreeProvider fileSystemTreeProvider, IUnconfiguredProjectCommonServices projectServices, IUnconfiguredProjectTasksService projectTasksService, IActiveConfiguredProjectSubscriptionService activeConfiguredProjectSubscriptionService) : base(projectServices.ThreadingService.JoinableTaskContext) { Requires.NotNull(asyncServiceProvider, nameof(asyncServiceProvider)); Requires.NotNull(fileSystemTreeProvider, nameof(fileSystemTreeProvider)); Requires.NotNull(projectServices, nameof(projectServices)); Requires.NotNull(projectTasksService, nameof(projectTasksService)); Requires.NotNull(activeConfiguredProjectSubscriptionService, nameof(activeConfiguredProjectSubscriptionService)); _asyncServiceProvider = asyncServiceProvider; _fileSystemTreeProvider = fileSystemTreeProvider; _projectServices = projectServices; _projectTasksService = projectTasksService; _activeConfiguredProjectSubscriptionService = activeConfiguredProjectSubscriptionService; }
public IProjectTree ApplyModifications(IProjectTree tree, IProjectTreeProvider projectTreeProvider) { if (tree != null) { if (tree.Capabilities.Contains(ProjectTreeCapabilities.ProjectRoot)) { tree = tree.SetIcon(ProjectTreeIcons.GetProjectIcon()); } else if (tree.Capabilities.Contains(ProjectTreeCapabilities.FileOnDisk)) { string name = Path.GetFileName(tree.FilePath).ToLowerInvariant(); ProjectImageMoniker icon = ProjectTreeIcons.GetChildIcon(name); if (icon != null) { tree.SetIcon(icon); } } } return(tree); }
public Task <IEnumerable <ICopyPasteItem> > ProcessDataObjectAsync(object dataObject, IProjectTree dropTarget, IProjectTreeProvider currentProvider, DropEffects effect) { _dropTarget = dropTarget; return(PasteProcessor.ProcessDataObjectAsync(dataObject, dropTarget, currentProvider, effect)); }
public bool CanHandleDataObject(object dataObject, IProjectTree dropTarget, IProjectTreeProvider currentProvider) { return(PasteProcessor.CanHandleDataObject(dataObject, dropTarget, currentProvider)); }
internal AbstractAddClassProjectCommand CreateInstance(IPhysicalProjectTree projectTree = null, IUnconfiguredProjectVsServices projectVsServices = null, Shell.SVsServiceProvider serviceProvider = null, IProjectTreeProvider provider = null, IVsAddProjectItemDlg dlg = null) { projectTree = projectTree ?? IPhysicalProjectTreeFactory.Create(provider); projectVsServices = projectVsServices ?? IUnconfiguredProjectVsServicesFactory.Implement(threadingServiceCreator: () => IProjectThreadingServiceFactory.Create()); serviceProvider = serviceProvider ?? SVsServiceProviderFactory.Create(dlg); return(CreateInstance(projectTree, projectVsServices, serviceProvider)); }
public async Task <IEnumerable <Tuple <int, IntPtr> > > GetPointerToDataAsync(IReadOnlyCollection <int> types, IEnumerable <IProjectTree> selectedNodes, IProjectTreeProvider currentProvider) { var paths = new StringBuilder(); var data = new List <Tuple <int, IntPtr> >(); foreach (IProjectTree node in selectedNodes) { string?path = await DependencyServices.GetBrowsePathAsync(_project, node); if (path == null) { continue; } // Note we leave trailing slashes to mimic what happens with normal folders if (node.Flags.Contains(DependencyTreeFlags.SupportsFolderBrowse)) { path = PathHelper.EnsureTrailingSlash(path); } if (paths.Length > 0) { paths.AppendLine(); } paths.Append(path); } if (types.Contains(ClipboardFormat.CF_TEXT)) { data.Add(new Tuple <int, IntPtr>(ClipboardFormat.CF_TEXT, Marshal.StringToHGlobalAnsi(paths.ToString()))); } if (types.Contains(ClipboardFormat.CF_UNICODETEXT)) { data.Add(new Tuple <int, IntPtr>(ClipboardFormat.CF_UNICODETEXT, Marshal.StringToHGlobalUni(paths.ToString()))); } return(data); }