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