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);
}
