private void GetProjectFiles([CanBeNull] string projectName, [ItemNotNull][CanBeNull] EnvDTE.ProjectItems projectItems, [NotNull] IDictionary <string, DteProjectFile> items) { Contract.Requires(items != null); if (projectItems == null) { return; } try { var index = 1; // Must use forach here! See https://connect.microsoft.com/VisualStudio/feedback/details/1093318/resource-files-falsely-enumerated-as-part-of-project foreach (var projectItem in projectItems.OfType <EnvDTE.ProjectItem>()) { try { GetProjectFiles(projectName, projectItem, items); } catch { _tracer.TraceError("Error loading project item #{0} in project {1}.", index, projectName); } index += 1; } } catch { _tracer.TraceError("Error loading a project item in project {0}.", projectName); } }
GetAllDataSetsInProjectItems(ArrayList list, EnvDTE.ProjectItems projectItems) { if (projectItems == null) { MessageBox.Show("Project.projectItems is null"); } foreach (Object obj in projectItems) { EnvDTE.ProjectItem projItem = obj as EnvDTE.ProjectItem; if (projItem != null && projItem.Name != null && projItem.Name.Length > 0) { // only add xsd files that use MSDataSetGenerator string extension = // get the file extension GetProperty(projItem.Properties, "Extension"); if (ToLower(extension) != ".xsd") { continue; } string customTool = GetProperty(projItem.Properties, "CustomTool"); if (ToLower(customTool) != "msdatasetgenerator") { continue; } list.Add(projItem); } } return(list); } // GetAllDataSetsInProject
protected override async Task AddFileToProjectAsync(string path) { if (ExcludeFile(path)) { return; } var folderPath = Path.GetDirectoryName(path); var fullPath = FileSystemUtility.GetFullPath(ProjectFullPath, path); await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); // Add the file to project or folder EnvDTEProjectItems container = await GetProjectItemsAsync(folderPath, createIfNotExists : true); if (container == null) { throw new ArgumentException( string.Format( CultureInfo.CurrentCulture, Strings.Error_FailedToCreateParentFolder, path, ProjectName)); } container.AddFromFileCopy(fullPath); NuGetProjectContext.Log(ProjectManagement.MessageLevel.Debug, Strings.Debug_AddedFileToProject, path, ProjectName); }
protected override void AddFileToProject(string path) { if (ExcludeFile(path)) { return; } string folderPath = Path.GetDirectoryName(path); string fullPath = FileSystemUtility.GetFullPath(EnvDTEProjectUtility.GetFullPath(EnvDTEProject), path); // Add the file to project or folder EnvDTEProjectItems container = EnvDTEProjectUtility.GetProjectItems(EnvDTEProject, folderPath, createIfNotExists: true); if (container == null) { throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Strings.Error_FailedToCreateParentFolder, path, ProjectName)); } AddFileToContainer(fullPath, folderPath, container); NuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_AddedFileToProject, path, ProjectName); }
protected override async Task AddFileToProjectAsync(string path) { Debug.Assert(ThreadHelper.CheckAccess()); if (ExcludeFile(path)) { return; } string folderPath = Path.GetDirectoryName(path); string fullPath = FileSystemUtility.GetFullPath(ProjectFullPath, path); // Add the file to project or folder EnvDTEProjectItems container = await EnvDTEProjectUtility.GetProjectItemsAsync(EnvDTEProject, folderPath, createIfNotExists : true); if (container == null) { throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Strings.Error_FailedToCreateParentFolder, path, ProjectName)); } AddFileToContainer(fullPath, folderPath, container); NuGetProjectContext.Log(ProjectManagement.MessageLevel.Debug, Strings.Debug_AddedFileToProject, path, ProjectName); }
private void GetSubProjects(string projectName, EnvDTE.ProjectItems projectItems, IList <EnvDTE.Project> items) { Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); if (projectItems == null) { return; } try { var index = 1; foreach (var projectItem in projectItems.OfType <EnvDTE.ProjectItem>()) { try { GetSubProjects(projectName, projectItem, items); } catch { _tracer.TraceError("Error loading project item #{0} in project {1}.", index, projectName ?? "unknown"); } index += 1; } } catch { _tracer.TraceError("Error loading a project item in project {0}.", projectName ?? "unknown"); } }
/// <summary> /// If we didn't find the project item at the top level, then we look one more level down. /// In VS files can have other nested files like foo.aspx and foo.aspx.cs or web.config and web.debug.config. /// These are actually top level files in the file system but are represented as nested project items in VS. /// </summary> private static bool TryGetNestedFile(EnvDTE.ProjectItems envDTEProjectItems, string name, out EnvDTE.ProjectItem envDTEProjectItem) { ThreadHelper.ThrowIfNotOnUIThread(); string parentFileName; if (!KnownNestedFiles.TryGetValue(name, out parentFileName)) { parentFileName = Path.GetFileNameWithoutExtension(name); } // If it's not one of the known nested files then we're going to look up prefixes backwards // i.e. if we're looking for foo.aspx.cs then we look for foo.aspx then foo.aspx.cs as a nested file var parentEnvDTEProjectItem = GetProjectItem(envDTEProjectItems, parentFileName, FileKinds); if (parentEnvDTEProjectItem != null) { // Now try to find the nested file envDTEProjectItem = GetProjectItem(parentEnvDTEProjectItem.ProjectItems, name, FileKinds); } else { envDTEProjectItem = null; } return(envDTEProjectItem != null); }
/// <summary> /// Helper function to recursively trigger the NUPlixLoader tool /// </summary> private static void RunCustomTool(EnvDTE.ProjectItems items, EnvDTE.ProjectItem ignoreItem, ProcessProjectItem itemProcessor) { #if VerifyUIThread Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); #endif foreach (EnvDTE.ProjectItem testItem in items) { if (!object.ReferenceEquals(testItem, ignoreItem)) { EnvDTE.Property prop = null; try { prop = testItem.Properties.Item("CustomTool"); } catch (ArgumentException) { // Swallow } if (prop != null && 0 == string.Compare((string)prop.Value, CustomToolName, true, CultureInfo.InvariantCulture)) { itemProcessor(testItem); } RunCustomTool(testItem.ProjectItems, ignoreItem, itemProcessor); } } }
private JObject AddProjectItems([ItemNotNull][CanBeNull] EnvDTE.ProjectItems projectItems, [NotNull] JObject jProject) { Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); if (projectItems == null) { return(jProject); } try { var index = 1; foreach (var projectItem in projectItems.OfType <EnvDTE.ProjectItem>().OrderBy(item => item.Name)) { try { AddProjectItems(projectItem, jProject); } catch { _tracer.TraceWarning("Can't load project item #{0}", index); } index += 1; } } catch { _tracer.TraceWarning("Can't load a project item."); } return(jProject); }
private void FormatSolutionRecursive(EnvDTE.ProjectItems projectItems) { if (projectItems != null && projectItems.Count > 0) { try { foreach (EnvDTE.ProjectItem item in projectItems) { if (item != null) { if (item.Kind == VSConstants.ItemTypeGuid.PhysicalFile_string && item.FileCodeModel != null) { FormatDocument(item); } var children = item.ProjectItems; if (children == null && item.SubProject != null) { // Required while testing in Visual Studio 2013 against a GIT-sourced solution. children = item.SubProject.ProjectItems; } FormatSolutionRecursive(children); } } } catch (Exception ex) { Debug.WriteLine("Failed to iterate items in project. Error: " + ex, packageTitle); } } }
private static void BuildStructure(EnvDTE.ProjectItems projectItems, string[] levels, int currentLevel) { if (currentLevel == levels.Length) { return; } var folderName = levels[currentLevel]; var toBeCreated = true; EnvDTE.ProjectItem newProjectItem = null; foreach (EnvDTE.ProjectItem pi in projectItems) { if (pi.Name == folderName && pi.Kind == KIND_FOLDER) { newProjectItem = pi; toBeCreated = false; break; } } if (toBeCreated) { newProjectItem = projectItems.AddFolder(folderName, KIND_FOLDER); } BuildStructure(newProjectItem.ProjectItems, levels, currentLevel + 1); }
private IEnumerable <string> CollectFileNamesRecursively(EnvDTE.ProjectItems items) { if (items != null) { foreach (EnvDTE.ProjectItem item in items) { //if (!(item is OAFileItem || item is OAFolderItem)) // continue; for (short i = 1; i <= item.FileCount; ++i) { var path = item.get_FileNames(i); if (!Path.GetExtension(path).Equals(".dll", StringComparison.OrdinalIgnoreCase) && File.Exists(path)) { yield return(item.get_FileNames(i)); } } //yield return fileItem..Name; foreach (var s in CollectFileNamesRecursively(item.ProjectItems)) { yield return(s); } } } }
/// <summary> /// Parses the project passed in. /// </summary> private void parseProject(EnvDTE.Project project) { // We get the project name... string projectName = Utils.call(() => (project.Name)); // We check if the project is loaded in the solution if (Utils.call(() => project.Object) == null && Utils.call(() => project.UniqueName) != "<MiscFiles>") { Log.log("Warning: " + projectName + " is currently unloaded in the solution! No conversion performed"); return; } // We check if this project is a kind we know how to convert... string strProjectType = Utils.call(() => (project.Kind)); ProjectType eProjectType = convertProjectTypeToEnum(strProjectType); switch (eProjectType) { // It's a C++ project... case ProjectType.CPP_PROJECT: { // We get the Visual Studio project, parse it and store the // parsed project in our collection of results... VCProject vcProject = Utils.call(() => (project.Object as VCProject)); ProjectParser_CPP parser = new ProjectParser_CPP(vcProject, m_parsedSolution.RootFolderAbsolute); ProjectParser_ForCUDA cudaparser = new ProjectParser_ForCUDA(project.FileName, project.Name); // Remove cuda file. foreach (var info in cudaparser.Project.CompileInfos) { parser.Project.removeFile(info.File); } m_parsedSolution.addProjectInfo(projectName, parser.Project); m_parsedSolution.addCudaProjectInfo(projectName, cudaparser.Project); } break; // Not support... #if false // It's a C# project... case ProjectType.CSHARP_PROJECT: { // We get the Visual Studio project, parse it and store the // parsed project in our collection of results... VSProject2 vsProject = Utils.call(() => (project.Object as VSProject2)); ProjectParser_CSharp parser = new ProjectParser_CSharp(vsProject, m_parsedSolution.RootFolderAbsolute); m_parsedSolution.addProjectInfo(projectName, parser.Project); } break; #endif } // We parse the project's items, to check whether there are any nested // projects... EnvDTE.ProjectItems projectItems = Utils.call(() => (project.ProjectItems)); parseProjectItems(projectItems); }
// 'parentItem' can be either a Project or ProjectItem private static EnvDTEProjectItem GetOrCreateFolder( EnvDTEProject envDTEProject, object parentItem, string fullPath, string folderRelativePath, string folderName, bool createIfNotExists) { if (parentItem == null) { return(null); } EnvDTEProjectItem subFolder; EnvDTEProjectItems envDTEProjectItems = GetProjectItems(parentItem); if (TryGetFolder(envDTEProjectItems, folderName, out subFolder)) { // Get the sub folder return(subFolder); } else if (createIfNotExists) { // The JS Metro project system has a bug whereby calling AddFolder() to an existing folder that // does not belong to the project will throw. To work around that, we have to manually include // it into our project. if (IsJavaScriptProject(envDTEProject) && Directory.Exists(fullPath)) { bool succeeded = IncludeExistingFolderToProject(envDTEProject, folderRelativePath); if (succeeded) { // IMPORTANT: after including the folder into project, we need to get // a new EnvDTEProjecItems snapshot from the parent item. Otherwise, reusing // the old snapshot from above won't have access to the added folder. envDTEProjectItems = GetProjectItems(parentItem); if (TryGetFolder(envDTEProjectItems, folderName, out subFolder)) { // Get the sub folder return(subFolder); } } return(null); } try { return(envDTEProjectItems.AddFromDirectory(fullPath)); } catch (NotImplementedException) { // This is the case for F#'s project system, we can't add from directory so we fall back // to this impl return(envDTEProjectItems.AddFolder(folderName)); } } return(null); }
private static bool TryGetFolder(EnvDTE.ProjectItems envDTEProjectItems, string name, out EnvDTE.ProjectItem envDTEProjectItem) { Debug.Assert(ThreadHelper.CheckAccess()); envDTEProjectItem = GetProjectItem(envDTEProjectItems, name, FolderKinds); return(envDTEProjectItem != null); }
private static bool TryGetFolder(EnvDTE.ProjectItems envDTEProjectItems, string name, out EnvDTE.ProjectItem envDTEProjectItem) { ThreadHelper.ThrowIfNotOnUIThread(); envDTEProjectItem = GetProjectItem(envDTEProjectItems, name, FolderKinds); return(envDTEProjectItem != null); }
public static IEnumerable <EnvDTE.ProjectItem> GetFiles(EnvDTE.ProjectItems source) { foreach (EnvDTE.ProjectItem item2 in source) { foreach (var item3 in GetFiles(item2)) { yield return(item3); } } }
static IEnumerable <EnvDTE.ProjectItem> TraverseProjectItems(EnvDTE.ProjectItems projectItems) { foreach (EnvDTE.ProjectItem projectItem in projectItems) { yield return(projectItem); foreach (EnvDTE.ProjectItem childProjectItem in TraverseProjectItems(projectItem.ProjectItems)) { yield return(childProjectItem); } } }
private EnvDTE.ProjectItem FindItemByName(EnvDTE.ProjectItems projectItems, string name) { foreach (EnvDTE.ProjectItem item in projectItems) { if (item.Name == name) { return(item); } } return(null); }
private string ResolveAppNameCollisionWithUser(EnvDTE.ProjectItems items, string name, out bool cancel) { while (true) { try { if (items.Item(name) == null) { break; } } catch (ArgumentException) { break; } var td = new TaskDialog(new ServiceProvider(GetSite())) { Title = Resources.ProductTitle, MainInstruction = string.Format(Resources.DjangoAppAlreadyExistsTitle, name), Content = string.Format(Resources.DjangoAppAlreadyExistsInstruction, name), AllowCancellation = true }; var cont = new TaskDialogButton( Resources.DjangoAppAlreadyExistsCreateAnyway, Resources.DjangoAppAlreadyExistsCreateAnywaySubtitle ); var retry = new TaskDialogButton(Resources.SelectAnotherName); td.Buttons.Add(cont); td.Buttons.Add(retry); td.Buttons.Add(TaskDialogButton.Cancel); var clicked = td.ShowModal(); if (clicked == cont) { break; } else if (clicked == retry) { name = GetNewAppNameFromUser(name); if (string.IsNullOrEmpty(name)) { cancel = true; return(null); } } else { cancel = true; return(null); } } cancel = false; return(name); }
static EnvDTE.ProjectItem FindProjectItemOrNull(string name, EnvDTE.ProjectItems parentCollection) { foreach (EnvDTE.ProjectItem projectItem in GetFilesIncludingSubFiles(parentCollection)) { string projectItemName = projectItem.Name; if (projectItemName.ToLower() == name.ToLower()) { return(projectItem); } } return(null); }
public static bool TryGetFile(EnvDTEProjectItems envDTEProjectItems, string name, out EnvDTEProjectItem envDTEProjectItem) { envDTEProjectItem = GetProjectItem(envDTEProjectItems, name, FileKinds); if (envDTEProjectItem == null) { // Try to get the nested project item return(TryGetNestedFile(envDTEProjectItems, name, out envDTEProjectItem)); } return(envDTEProjectItem != null); }
private IEnumerable <EnvDTE.ProjectItem> GetProjectItems(EnvDTE.ProjectItems projectItems) { List <EnvDTE.ProjectItem> result = new List <EnvDTE.ProjectItem>(); int itemCount = TryHelper.Run(() => projectItems.Count); for (int i = 0; i < itemCount; i++) { result.Add(TryHelper.Run(() => projectItems.Item(i + 1))); } return(result); }
private static bool TryGetFile(EnvDTE.ProjectItems envDTEProjectItems, string name, out EnvDTE.ProjectItem envDTEProjectItem) { ThreadHelper.ThrowIfNotOnUIThread(); envDTEProjectItem = GetProjectItem(envDTEProjectItems, name, FileKinds); if (envDTEProjectItem == null) { // Try to get the nested project item return(TryGetNestedFile(envDTEProjectItems, name, out envDTEProjectItem)); } return(envDTEProjectItem != null); }
/// <summary> /// This function returns the currently-active project object, provided that it is a valid /// project. Validity is defined as: /// - It's open /// - All items in the project are stored off of the root directory where the /// project itself is located /// </summary> private EnvDTE.Project GetValidProject(string strName) { EnvDTE.Project CurrentProj = null; if (strName == EnvDTE.Constants.vsMiscFilesProjectUniqueName) { // Copying the Misc Files project doesn't make any sense... return(null); } try { EnvDTE.Projects CurrentProjs = null; EnvDTE.ProjectItems Items = null; int nLastIndex; string strProjectRootPath; CurrentProjs = m_application.Solution.Projects; CurrentProj = CurrentProjs.Item(strName); if (CurrentProj == null) { return(null); } strProjectRootPath = CurrentProj.FileName; nLastIndex = strProjectRootPath.LastIndexOf('\\'); if (nLastIndex == -1) { nLastIndex = strProjectRootPath.LastIndexOf('/'); if (nLastIndex == -1) { return(null); } } strProjectRootPath = strProjectRootPath.Substring(0, nLastIndex + 1); // Just keep the 'path\' of 'path\name' strProjectRootPath = strProjectRootPath.ToUpper(); Items = CurrentProj.ProjectItems; if (!ValidProjectItems(Items, strProjectRootPath)) { return(null); } } catch (Exception /*e*/) { return(null); } return(CurrentProj); }
private static bool TryGetFile(EnvDTE.ProjectItems envDTEProjectItems, string name, out EnvDTE.ProjectItem envDTEProjectItem) { Debug.Assert(ThreadHelper.CheckAccess()); envDTEProjectItem = GetProjectItem(envDTEProjectItems, name, FileKinds); if (envDTEProjectItem == null) { // Try to get the nested project item return(TryGetNestedFile(envDTEProjectItems, name, out envDTEProjectItem)); } return(envDTEProjectItem != null); }
static string ListProjectItems(EnvDTE.ProjectItems projectItems, int level) { string result = ""; foreach (EnvDTE.ProjectItem projectItem in projectItems) { result += projectItem.Name + " {" + projectItem.Properties.Item("FullPath").Value.ToString() + "}" + " (" + level.ToString() + ")" + Environment.NewLine; if (projectItem.ProjectItems != null) { result += ListProjectItems(projectItem.ProjectItems, level + 1); } } return(result); }
GetGeneratedFiles(EnvDTE.ProjectItems items, ref Dictionary <String, List <String> > generated) { foreach (EnvDTE.ProjectItem item in items) { if (IsProjectItemFile(item) && IsSliceFileName(item.Name)) { generated[item.FileNames[1]] = GetGeneratedFiles(item.ContainingProject, item.FileNames[1]); } else if (IsProjectItemFolder(item) || IsProjectItemFilter(item)) { GetGeneratedFiles(item.ProjectItems, ref generated); } } }
static bool DeleteFileInProject(EnvDTE.Project project, string fileName) { EnvDTE.ProjectItems projectItems = project.ProjectItems; try { projectItems.Item(fileName).Delete(); return(true); } catch (Exception ex) { DisplayMessageBoxOnUIThread(string.Format("Unable to delete '{0}'.", fileName) + Environment.NewLine + Environment.NewLine + ex.ToString()); return(false); } }
private static void NavigateProjectItems(EnvDTE.ProjectItems nativeProjectItems, List <EnvDTE.Project> nativeProjects) { ThreadHelper.ThrowIfNotOnUIThread(); if (nativeProjectItems == null) { return; } foreach (EnvDTE.ProjectItem nativeProjectItem in nativeProjectItems) { if (nativeProjectItem.SubProject != null) { NavigateProject(nativeProjectItem.SubProject, nativeProjects); } } }