public static VCFile AddRelativeFile(this VCFilter root, string relativepath, string fullpath) { VCFilter cur = root; var dirs = relativepath.Split(new char[] { '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList(); if (dirs.Count > 1) { for (int i = 0; i < dirs.Count - 1; i++) { string idir = dirs[i]; if (cur != null) { VCFilter next = null; IVCCollection subs = cur.Filters; foreach (VCFilter sub in subs) { if (sub.Name == idir) { next = sub; break; } } if (next != null) { next = cur.AddFilter(idir); cur = next; } } } } return(cur.AddFile(fullpath)); }
public void LoadCpps() { this.Cpps = new Dictionary <string, Cpp>(); string config = Connect.GetActiveConfigString(this.Project); VCFilter unityfilter = this.Filter.GetVCFilter(); foreach (VCFile file in this.VCProject.Files as IVCCollection) { if (file.Extension.ToLower() == ".cpp" && file.Parent != unityfilter) { VCFileConfiguration cfg = Connect.GetFileConfiguration(file, config); VCCLCompilerTool vctool = cfg.Tool as VCCLCompilerTool; if (vctool != null) { if (vctool.UsePrecompiledHeader == Microsoft.VisualStudio.VCProjectEngine.pchOption.pchCreateUsingSpecific) { continue; } } Cpp cpp = this.GetCppInUnity(file.RelativePath); if (cpp == null) { cpp = new Cpp(file); } this.Cpps.Add(cpp.Name, cpp); } } }
private void Project_EnableUnity(VCProject project, bool excluded) { if (project == null) { return; } string config = Connect.GetActiveConfigString(project.Object as Project); UnityManager um = new UnityManager(project); um.LoadUnities(); VCFilter unityfilter = um.Filter.GetVCFilter(); if (unityfilter == null || um.Unities.Count == 0) { return; } foreach (VCFile file in project.Files as IVCCollection) { if (file.Extension.ToLower() == ".cpp") { if (file.Parent == unityfilter) { Connect.SetExcludedFromBuild(file, config, !excluded); } else { Connect.SetExcludedFromBuild(file, config, excluded && (um.GetCppInUnity(file.RelativePath) != null)); } } } }
/// <summary> /// Add Folder to Specified Project /// </summary> /// <param name="path"></param> private VCFilter AddFolderToProject(Project proj, string dirInfo, string newDir, VCFilter filter) { VCFilter localFilter = filter; try { DirectoryInfo directoryInfo1 = new DirectoryInfo(dirInfo); directoryInfo1.CreateSubdirectory(newDir); if (localFilter == null) { localFilter = (proj.Object as VCProject).AddFilter(newDir); } else { localFilter = localFilter.AddFilter(newDir); } AddSummaryString("Folder Added: " + newDir); } catch (Exception e) { string error = e.Message; } return(localFilter); }
public static void RunlUpdate(EnvDTE.Project project) { QtProject qtPro = QtProject.Create(project); if (qtPro == null) { return; } FakeFilter ts = Filters.TranslationFiles(); VCFilter tsFilter = qtPro.FindFilterFromGuid(ts.UniqueIdentifier); if (tsFilter == null) { return; } IVCCollection files = tsFilter.Files as IVCCollection; foreach (VCFile file in files) { VCFile vcFile = file as VCFile; if (HelperFunctions.IsTranslationFile(vcFile)) { if (!RunlUpdate(vcFile, project)) { return; } } } }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private void Execute(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); object item = ProjectUtils.GetSelectedItem(); ProjectItem selectedItem = item as ProjectItem; VCFilter selectedFilter = item as VCFilter; try { // It's a source file if (selectedItem.ProjectItems.Item(1) == null) { // Just remove the source file string targetPath = selectedItem.Properties.Item("FullPath").Value as string; string dir = Path.GetDirectoryName(targetPath); if (Directory.GetFiles(dir, "*", SearchOption.AllDirectories).Length <= 1) { // If this is the last source file in the dir, remove everything Directory.Delete(dir, true); ProjectItem parent = selectedItem.Properties.Parent as ProjectItem; parent = parent.Properties.Parent as ProjectItem; if (parent == null) { parent = selectedItem.Properties.Parent as ProjectItem; } //selectedItem.Remove(); string parentName = parent.Name; string parParentName = (parent.Properties.Parent as ProjectItem).Name; //string collName = selectedItem.Collection.; parent.Remove(); parent.ContainingProject.Save(); } else { // Remove physical file from the disk File.Delete(targetPath); // Remove file from the project selectedItem.Remove(); selectedItem.ContainingProject.Save(); } } else { RemoveDir(selectedItem); } } catch (Exception exc) { // It's a filter (folder) } }
public VCFilter FindOrCreateFilter(VCFilter parent, string name) { foreach (VCFilter f in parent.Filters) { if (f.Name.Equals(name)) { return(f); } } return(parent.AddFilter(name)); }
/// <summary> /// Add File to specified project /// </summary> /// <param name="path"></param> private void AddFileToProject(Project proj, string source, string destination, VCFilter filter) { VCFilter localFilter = filter; try { FileInfo fileInfo1 = new FileInfo(source); if (!File.Exists(System.IO.Path.Combine(destination, fileInfo1.Name))) { File.Copy(source, System.IO.Path.Combine(destination, fileInfo1.Name)); } if ((fileInfo1.Name != ".cproject") && (fileInfo1.Name != ".project")) { if (localFilter == null) { if (proj.ProjectItems.Item(fileInfo1.Name) == null) { proj.ProjectItems.AddFromFileCopy(System.IO.Path.Combine(destination, fileInfo1.Name)); AddSummaryString("Project File Added: " + System.IO.Path.Combine(destination, fileInfo1.Name)); } else { AddSummaryString("Duplicate File: " + System.IO.Path.Combine(destination, fileInfo1.Name)); } } else { IVCCollection tmpCollection; tmpCollection = localFilter.Files; if (tmpCollection.Item(fileInfo1.Name) == null) { localFilter.AddFile(System.IO.Path.Combine(destination, fileInfo1.Name)); AddSummaryString("Project File Added: " + System.IO.Path.Combine(destination, fileInfo1.Name)); } else { AddSummaryString("Duplicate File: " + System.IO.Path.Combine(destination, fileInfo1.Name)); } } } else { AddSummaryString("File Skipped: " + System.IO.Path.Combine(destination, fileInfo1.Name)); } } catch (Exception e) { } }
void SolutionEvents_ProjectAdded(Project project) { if (HelperFunctions.IsQMakeProject(project)) { RegisterVCProjectEngineEvents(project); var vcpro = project.Object as VCProject; VCFilter filter = null; foreach (VCFilter f in vcpro.Filters as IVCCollection) { if (f.Name == Filters.HeaderFiles().Name) { filter = f; break; } } if (filter != null) { foreach (VCFile file in filter.Files as IVCCollection) { foreach (VCFileConfiguration config in file.FileConfigurations as IVCCollection) { var tool = HelperFunctions.GetCustomBuildTool(config); if (tool == null) { continue; } var commandLine = tool.CommandLine; if (!string.IsNullOrEmpty(commandLine) && commandLine.Contains("moc.exe")) { var matches = Regex.Matches(commandLine, "[^ ^\n]+moc\\.(exe\"|exe)"); string qtDir; if (matches.Count != 1) { var vm = QtVersionManager.The(); qtDir = vm.GetInstallPath(vm.GetDefaultVersion()); } else { qtDir = matches[0].ToString().Trim('"'); qtDir = qtDir.Remove(qtDir.LastIndexOf('\\')); qtDir = qtDir.Remove(qtDir.LastIndexOf('\\')); } qtDir = qtDir.Replace("_(QTDIR)", "$(QTDIR)"); HelperFunctions.SetDebuggingEnvironment(project, "PATH=" + Path.Combine(qtDir, "bin") + ";$(PATH)", false); } } } } } }
public void AddGeneratedFiles(EnvDTE.Project dteProject, EnvDTE.Configuration config, string filterName, List <string> paths, bool generatedFilesPerConfiguration) { VCProject project = dteProject.Object as VCProject; VCFilter filter = FindOrCreateFilter(project, filterName); if (generatedFilesPerConfiguration) { filter = FindOrCreateFilter(filter, config.PlatformName); filter = FindOrCreateFilter(filter, config.ConfigurationName); } string configurationName = config.ConfigurationName; string platformName = config.PlatformName; foreach (string path in paths) { if (!File.Exists(path)) { File.Create(path).Dispose(); } VCFile file = filter.AddFile(path); try { // // Remove the file otherwise it will be considered up to date. // File.Delete(path); } catch (Exception) { } // // Exclude the file from all other configurations // if (generatedFilesPerConfiguration) { foreach (VCFileConfiguration c in file.FileConfigurations) { if (!c.ProjectConfiguration.ConfigurationName.Equals(configurationName) || !c.ProjectConfiguration.Platform.Name.Equals(platformName)) { c.ExcludedFromBuild = true; } } } } }
public void AddGeneratedFile(IVsProject project, VCFilter filter, string path, EnvDTE.Configuration config) { int found; uint id; VSDOCUMENTPRIORITY[] priority = new VSDOCUMENTPRIORITY[1]; project.IsDocumentInProject(path, out found, priority, out id); if (found == 0) { if (!Directory.Exists(Path.GetDirectoryName(path))) { Directory.CreateDirectory(Path.GetDirectoryName(path)); } if (!File.Exists(path)) { File.Create(path).Dispose(); } VCFile file = null; if (config == null) { file = filter.AddFile(path); } else { filter = FindOrCreateFilter(filter, config.PlatformName); filter = FindOrCreateFilter(filter, config.ConfigurationName); file = filter.AddFile(path); foreach (VCFileConfiguration c in file.FileConfigurations) { if (!c.ProjectConfiguration.ConfigurationName.Equals(config.ConfigurationName) || !c.ProjectConfiguration.Platform.Name.Equals(config.PlatformName)) { c.ExcludedFromBuild = true; } } } try { // // Remove the file otherwise it will be considered up to date. // File.Delete(path); } catch (Exception) { } } }
private void QueueFilter(List <QueueEntry> queue, VCFilter src) { foreach (var item in src.Items) { var vcfile = item as VCFile; if (vcfile != null && vcfile.Parent as VCFilter != null) { queue.Add(new QueueEntry() { _vcfile = vcfile, _vcfilter = vcfile.Parent as VCFilter }); } } }
private VCFilter GetOrCreateTestFilter() { VCProject vcproj = (VCProject)project.GetExtObjectAs <Project>().Object; IVCCollection filters = (IVCCollection)vcproj.Filters; VCFilter filter = (VCFilter)filters.Item("Test Suites"); if (filter == null) { filter = (VCFilter)vcproj.AddFilter("Test Suites"); } return(filter); }
public static void SetExcludedFromBuild(VCFilter filter, string config, bool excluded) { foreach (VCFile file in filter.Files as IVCCollection) { if (file.Extension.ToLower() == ".cpp") { Connect.SetExcludedFromBuild(file, config, excluded); } } foreach (VCFilter subfilter in filter.Filters as IVCCollection) { Connect.SetExcludedFromBuild(subfilter, config, excluded); } }
public void SaveUnities() { try { VCFilter unityfilter = this.Filter.GetVCFilter(); if (unityfilter == null) { unityfilter = this.VCProject.AddFilter(this.Filter.Name) as VCFilter; } List <VCFile> oldfiles = new List <VCFile>(); foreach (VCFile file in unityfilter.Files as IVCCollection) { oldfiles.Add(file); } foreach (VCFile file in oldfiles) { file.Remove(); } IVCCollection tools = this.VCConfig.Tools as IVCCollection; VCCLCompilerTool vctool = tools.Item("VCCLCompilerTool") as VCCLCompilerTool; string pch = Connect.GetPCH(this.VCProject, this.VCConfig); foreach (Unity unity in this.Unities.Values) { unity.Save(this.VCProject.ProjectDirectory, this.Filter.Path, pch); VCFile file = unityfilter.AddFile(unity.FileName) as VCFile; foreach (VCFileConfiguration fileconfig in file.FileConfigurations as IVCCollection) { vctool = fileconfig.Tool as VCCLCompilerTool; if (vctool != null) { vctool.AdditionalIncludeDirectories = "\"$(ProjectDir)/\""; } } } } catch (System.Exception ex) { Utils.ShowError("SaveUnities failed: " + ex.Message); } }
public void Generate() { string projectDir = project.ProjectDirectory; string headerName = suiteName + ".h"; string suitePath = Path.Combine(projectDir, headerName); StreamWriter writer = File.CreateText(suitePath); WriteHeaderFileContent(writer, suitePath); writer.Close(); VCFilter testFilter = GetOrCreateTestFilter(); VCProjectItem item = (VCProjectItem)testFilter.AddFile(suitePath); suiteFile = project.GetChildWithName(item.ItemName); }
public static string GetVirtualPath(VCFile file) { try { string path = file.Name; VCFilter filter = file.Parent as VCFilter; if (filter != null) { path = filter.CanonicalName + "\\" + path; } return(path); } catch { } return(""); }
void SolutionEvents_ProjectAdded(Project project) { if (HelperFunctions.IsQMakeProject(project)) { RegisterVCProjectEngineEvents(project); VCProject vcpro = project.Object as VCProject; VCFilter filter = null; foreach (VCFilter f in vcpro.Filters as IVCCollection) { if (f.Name == Filters.HeaderFiles().Name) { filter = f; break; } } if (filter != null) { foreach (VCFile file in filter.Files as IVCCollection) { foreach (VCFileConfiguration config in file.FileConfigurations as IVCCollection) { VCCustomBuildTool tool = HelperFunctions.GetCustomBuildTool(config); if (tool != null && tool.CommandLine != null && tool.CommandLine.Contains("moc.exe")) { Regex reg = new Regex("[^ ^\n]+moc\\.exe"); MatchCollection matches = reg.Matches(tool.CommandLine); string qtDir = null; if (matches.Count != 1) { QtVersionManager vm = QtVersionManager.The(); qtDir = vm.GetInstallPath(vm.GetDefaultVersion()); } else { qtDir = matches[0].ToString(); qtDir = qtDir.Remove(qtDir.LastIndexOf("\\")); qtDir = qtDir.Remove(qtDir.LastIndexOf("\\")); } qtDir = qtDir.Replace("_(QTDIR)", "$(QTDIR)"); HelperFunctions.SetDebuggingEnvironment(project, "PATH=" + qtDir + "\\bin;$(PATH)", false); } } } } } }
public void LoadUnities() { this.Unities = new Dictionary <string, Unity>(); VCFilter unityfilter = this.Filter.GetVCFilter(); if (unityfilter != null) { foreach (VCFile file in unityfilter.Files as IVCCollection) { if (file.Extension.ToLower() == ".cpp") { Unity unity = new Unity(Path.GetFileNameWithoutExtension(file.Name)); unity.Load(file); this.Unities.Add(unity.Name, unity); } } } }
private void addNewFilterRecursive(VCFilter vcFilter, string dirName, string dir) { string filterName = dirName.Substring(dir.Length + 1); VCFilter newFilter = vcFilter.AddFilter(filterName); // add files string[] fileEntries = Directory.GetFiles(dirName); foreach (string file in fileEntries) { newFilter.AddFile(file); } // add directories as filter string[] dirEntries = Directory.GetDirectories(dirName); foreach (string d in dirEntries) { addNewFilterRecursive(newFilter, d, dirName); } }
// Helper private static bool isVcFileBelongToFilters(VCFile vcFile, List <string> filters) { Object obj = vcFile.Parent; while (obj != null) { VCFilter vcFilter = obj as VCFilter; if (vcFilter == null) { break; } if (filters.Contains(vcFilter.Name)) { return(true); } obj = vcFilter.Parent; } return(false); }
public static IEnumerable <VCFile> GetAllVCFiles(this VCFilter col) { IVCCollection files = col.Files; foreach (VCFile vcfile in files) { yield return(vcfile); } IVCCollection filters = col.Filters; foreach (VCFilter vcfilter in filters) { var sfiles = vcfilter.GetAllVCFiles(); foreach (VCFile svcfile in sfiles) { yield return(svcfile); } } yield break; }
public bool toVCFilter(VCFilter parent) { bool hasFiles = files.Count > 0; if (files.Count > 0 || folders.Count > 0) { VCFilter filter = parent.AddFilter(name); foreach (var file in files) { filter.AddFile(Path.Combine(path, file)); } foreach (var folder in folders) { hasFiles |= folder.toVCFilter(filter); } if (!hasFiles) { parent.RemoveFilter(filter); } } return hasFiles; }
/// <summary> /// Recursive filter expand and print sources /// </summary> /// <param name="filter"></param> private void iPrintRecursiveGroupsAndSources(VCFilter filter) { IVCCollection filterCollection = (IVCCollection)filter.Filters; if (0 == filterCollection.Count) { //print the sources files groups string group = filter.Name.Replace(" ", "_"); group = group.ToUpper(); m_MakFWriter.WriteLine("{0}= \\", group); m_SRCGroups += "$(" + group + ") "; IVCCollection filesCollection = (IVCCollection)filter.Files; int fileCntr = 0; foreach (VCFile vcFile in filesCollection) { string fileName = vcFile.RelativePath.Replace("\\", "/"); if (fileCntr < filesCollection.Count - 1) { m_MakFWriter.WriteLine("\t{0} \\", fileName);//print slash as in macro } else { m_MakFWriter.WriteLine("\t{0}", fileName);//in case of last file in group no slash needed } fileCntr++; } m_MakFWriter.WriteLine(""); } else { foreach (VCFilter f in filterCollection) { iPrintRecursiveGroupsAndSources(f); } } }
public bool toVCFilter(VCFilter parent) { bool hasFiles = files.Count > 0; if (files.Count > 0 || folders.Count > 0) { VCFilter filter = parent.AddFilter(name); foreach (var file in files) { filter.AddFile(Path.Combine(path, file)); } foreach (var folder in folders) { hasFiles |= folder.toVCFilter(filter); } if (!hasFiles) { parent.RemoveFilter(filter); } } return(hasFiles); }
/// <summary> /// Delete all parent, grand parent, etc. of this file if they are empty, after deleting this file. /// </summary> private static void DeleteAllParentFilters(object filter) { VCFilter currentFilter = filter as VCFilter; while (currentFilter != null) { var remainingFiles = currentFilter.Files as IEnumerable; var remainingFilters = currentFilter.Filters as IEnumerable; // if the current filter is empty, delete it if (!remainingFiles.GetEnumerator().MoveNext() && !remainingFilters.GetEnumerator().MoveNext()) { var parent = currentFilter.Parent; currentFilter.Remove(); currentFilter = parent as VCFilter; } else { break; } } }
/// <summary> /// </summary> protected VCFilter AddFilter(string path) { VCFilter filter = null; var name = string.Empty; var dirs = path.Split(new[] { Path.DirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries); foreach (var dir in dirs) { name = Path.Combine(name, dir); var item = ((IVCCollection)Project.Filters).Item(name); if (item != null) { filter = item; continue; } filter = filter == null?Project.AddFilter(dir) : filter.AddFilter(dir); } return(filter); }
public static void addAddons(VCProject vcproject, String ofRoot, IEnumerable <String> addons) { VCFilter addonsFolder = null; try { addonsFolder = vcproject.AddFilter("addons"); }catch (Exception e) { IVCCollection filters = vcproject.Filters; foreach (var filter in filters) { if (filter is VCFilter) { if (((VCFilter)filter).Name == "addons") { addonsFolder = ((VCFilter)filter); break; } } } } if (addonsFolder != null) { foreach (var addon in addons) { VCFilter addonFolder = addonsFolder.AddFilter(addon); var addonObj = new Addon(ofRoot, addon, vcproject.ProjectDirectory); addonObj.addFilesToVCFilter(addonFolder); addonObj.addIncludePathsToVCProject(vcproject); addonObj.addLibsToVCProject(vcproject); } vcproject.Save(); } else { throw new Exception("Couldn't create or find addonsFolder"); } }
public bool SetupSliceFilter(EnvDTE.Project dteProject) { VCProject project = dteProject.Object as VCProject; foreach (VCFilter f in project.Filters) { if (f.Name.Equals("Slice Files")) { if (string.IsNullOrEmpty(f.Filter) || !f.Filter.Equals("ice")) { f.Filter = "ice"; return(true); } return(false); } } VCFilter filter = project.AddFilter("Slice Files"); filter.Filter = "ice"; return(true); }
private void Project_ExportUnity(VCProject project, XmlElement xParent) { if (project == null) { return; } UnityManager um = new UnityManager(project); um.LoadUnities(); VCFilter unityfilter = um.Filter.GetVCFilter(); if (unityfilter == null || um.Unities.Count == 0) { return; } XmlElement xProject = Utils.AddXmlElement(xParent, "Project"); Utils.AddXmlAttribute(xProject, "Name", project.Name); Utils.AddXmlAttribute(xProject, "Path", project.ProjectFile); Utils.AddXmlAttribute(xProject, "UnityFilterName", um.Filter.Name); Utils.AddXmlAttribute(xProject, "UnityFilterPath", um.Filter.Path); foreach (Unity unity in um.Unities.Values) { XmlElement xUnity = Utils.AddXmlElement(xProject, "Unity"); Utils.AddXmlAttribute(xUnity, "Name", unity.Name); foreach (Cpp cpp in unity.Cpps.Values) { XmlElement xCpp = Utils.AddXmlElement(xUnity, "Cpp"); Utils.AddXmlAttribute(xCpp, "Name", cpp.Name); Utils.AddXmlAttribute(xCpp, "Condition", cpp.Condition); } } }
/// <summary> /// Get the filter that is represented by the specified path /// </summary> private static VCFilter GetFilter(VCProject vcProject, string folderPath, bool createIfNotExists) { Debug.Assert(!String.IsNullOrEmpty(folderPath)); string[] paths = folderPath.Split(Path.DirectorySeparatorChar); // recursively walks the folder path to get the last folder dynamic parent = vcProject; foreach (string path in paths) { VCFilter childFilter = null; foreach (VCFilter child in parent.Filters) { if (child.Name.Equals(path, StringComparison.OrdinalIgnoreCase)) { childFilter = child; break; } } if (childFilter == null) { if (createIfNotExists) { // if a child folder doesn't already exist, create it childFilter = parent.AddFilter(path); } else { return(null); } } parent = childFilter; } return((VCFilter)parent); }
/// <summary> /// Add Folder to Specified Project /// </summary> /// <param name="path"></param> private VCFilter AddFolderToProject(Project proj, string dirInfo, string newDir, VCFilter filter) { VCFilter localFilter = filter; try { DirectoryInfo directoryInfo1 = new DirectoryInfo(dirInfo); directoryInfo1.CreateSubdirectory(newDir); if (localFilter == null) { localFilter = (proj.Object as VCProject).AddFilter(newDir); } else { localFilter = localFilter.AddFilter(newDir); } AddSummaryString("Folder Added: " + newDir); } catch (Exception e) { string error = e.Message; } return localFilter; }
/// <summary> /// Recursive Function to walk a specified directory tree and add the files into a Visual Studio C project. /// </summary> /// <param name="proj">Destination Project</param> /// <param name="sourceDir">Source Directory to begin walking</param> /// <param name="destinationDir">Destination Directory of new project to copy files to</param> /// <param name="filter">VCFilter object to add files to</param> /// <returns></returns> public bool WalkDirectoryTree(Project proj, DirectoryInfo sourceDir, DirectoryInfo destinationDir, VCFilter filter) { VCFilter localFilter = filter; System.IO.FileInfo[] files = null; System.IO.DirectoryInfo[] subDirs = null; // First, process all the files directly under this folder try { files = sourceDir.GetFiles("*.*"); foreach (FileInfo file in files) { if (file.Name.Contains("vcxproj")) { AddSummaryString("Selected project already converted."); return false; } } } catch (UnauthorizedAccessException e) { return false; } if (files != null) { // Now find all the subdirectories under this directory. subDirs = sourceDir.GetDirectories(); if (localFilter == null) { foreach (System.IO.DirectoryInfo dirInfo in subDirs) { if (dirInfo.Name == "src") { IVCCollection tmpCollection; VCFilter tmpFilter; tmpCollection = (proj.Object as VCProject).Filters; tmpFilter = tmpCollection.Item("Source Files"); (proj.Object as VCProject).RemoveFilter(tmpFilter); } if (dirInfo.Name == "res") { IVCCollection tmpCollection; VCFilter tmpFilter; tmpCollection = (proj.Object as VCProject).Filters; tmpFilter = tmpCollection.Item("Resource Files"); (proj.Object as VCProject).RemoveFilter(tmpFilter); } } } foreach (System.IO.FileInfo fi in files) { AddFileToProject(proj, fi.FullName, destinationDir.FullName, localFilter); } foreach (System.IO.DirectoryInfo dirInfo in subDirs) { VCFilter newFilter = AddFolderToProject(proj, destinationDir.FullName, dirInfo.Name, localFilter); // Resursive call for each subdirectory. DirectoryInfo source = new DirectoryInfo(dirInfo.FullName); DirectoryInfo destination = new DirectoryInfo(Path.Combine(destinationDir.FullName, dirInfo.Name)); if (!WalkDirectoryTree(proj, source, destination, newFilter)) return false; } } return true; }
public static Project GetProject(VCFilter filter) { return (filter.project as VCProject).Object as Project; }
private static void CollectFilters(VCFilter filter, string path, ref Hashtable filterPathTable, ref Hashtable pathFilterTable) { string newPath = "."; if (path != null) newPath = path + "\\" + filter.Name; newPath = newPath.ToLower().Trim(); newPath = Regex.Replace(newPath, @"\\+\.?\\+", "\\"); newPath = Regex.Replace(newPath, @"\\\.?$", ""); if (newPath.StartsWith(".\\")) newPath = newPath.Substring(2); filterPathTable.Add(filter, newPath); pathFilterTable.Add(newPath, filter); foreach (VCFilter f in (IVCCollection)filter.Filters) { CollectFilters(f, newPath, ref filterPathTable, ref pathFilterTable); } }
public VcppFilter(VCFilter vcProjectFilter, string physicalDirectoryPath) { VcProjectFilter = vcProjectFilter; PhysicalDirectoryPath = physicalDirectoryPath; }
public void addFilesToVCFilter(VCFilter parent) { srcFolder.toVCFilter(parent); libsFolder.toVCFilter(parent); }
private void QueueFiltersRecursive(List<QueueEntry> queue, VCFilter src) { foreach (var item in src.Items) { var vcfilter = item as VCFilter; if (vcfilter != null) { QueueFiltersRecursive(queue, vcfilter); } var vcfile = item as VCFile; if (vcfile != null && vcfile.Parent as VCFilter != null) { queue.Add(new QueueEntry() { _vcfile = vcfile, _vcfilter = vcfile.Parent as VCFilter }); } } }
private bool DeleteFilesFromFilter(VCFilter filter) { bool error = false; foreach (VCFile f in filter.Files as IVCCollection) { try { FileInfo fi = new FileInfo(f.FullPath); if (fi.Exists) fi.Delete(); HelperFunctions.DeleteEmptyParentDirs(fi.Directory.ToString()); } catch { error = true; } } foreach (VCFilter filt in filter.Filters as IVCCollection) if (DeleteFilesFromFilter(filt)) error = true; return error; }
private void CleanupFilter(VCFilter filter) { IVCCollection subFilters = filter.Filters as IVCCollection; if (subFilters == null) return; for (int i = subFilters.Count; i > 0; i--) { VCFilter subFilter = subFilters.Item(i)as VCFilter; IVCCollection subFilterFilters = subFilter.Filters as IVCCollection; if (subFilterFilters == null) continue; CleanupFilter(subFilter); bool filterOrFileFound = false; foreach (object itemObject in subFilter.Items as IVCCollection) { if (itemObject is VCFilter || itemObject is VCFile) { filterOrFileFound = true; break; } } if (!filterOrFileFound) { filter.RemoveFilter(subFilter); } } }
/// <summary> /// Removes a file from the filter. /// This file will be deleted! /// </summary> /// <param name="project">project</param> /// <param name="file">file</param> public void RemoveFileFromFilter(VCFile file, VCFilter filter) { try { filter.RemoveFile(file); FileInfo fi = new FileInfo(file.FullPath); if (fi.Exists) fi.Delete(); } catch { } IVCCollection subfilters = (IVCCollection)filter.Filters; for (int i = subfilters.Count; i > 0; i--) { try { VCFilter subfilter = (VCFilter)subfilters.Item(i); RemoveFileFromFilter(file, subfilter); } catch { } } }
public System.Collections.Generic.List<VCFile> GetAllFilesFromFilter(VCFilter filter) { System.Collections.Generic.List<VCFile> tmpList = new System.Collections.Generic.List<VCFile>(); foreach (VCFile f in (IVCCollection)filter.Files) { tmpList.Add(f); } foreach (VCFilter subfilter in (IVCCollection)filter.Filters) foreach (VCFile file in GetAllFilesFromFilter(subfilter)) tmpList.Add(file); return tmpList; }
public VCFile GetFileFromFilter(VCFilter filter, string fileName) { try { FileInfo fi = null; if (Path.IsPathRooted(fileName)) fi = new FileInfo(fileName); else fi = new FileInfo(ProjectDir + "\\" + fileName); if (fi == null) { return null; } foreach (VCFile file in (IVCCollection)filter.Files) { if (file.MatchName(fi.FullName, true)) return file; } } catch { } return null; }