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)
{
}
}
}
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));
}
/// <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)
{
}
}
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 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);
}
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);
}
}
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);
}
public void AddToFilter(EnvDTE.Project dteProject, String name, String path)
{
VCProject project = dteProject.Object as VCProject;
VCFilter filter = null;
foreach (VCFilter f in project.Filters)
{
if (f.Name.Equals(name))
{
filter = f;
break;
}
}
if (filter != null)
{
filter.AddFile(path);
}
else
{
project.AddFile(path);
}
}
public void Execute(object Application,
int hwndOwner,
ref object[] contextParams,
ref object[] customParams,
ref EnvDTE.wizardResult retval)
{
try
{
_applicationObject = Application as DTE2;
if (null == template_file_name_src)
{
RegistryKey vs2010 = Registry.CurrentUser.OpenSubKey("software\\jstructtool");
app_folder = vs2010.GetValue("AppFolder").ToString();
template_file_name_src = app_folder + "\\inc\\template.jst";
vs2010.Close();
}
foreach (SelectedItem si in _applicationObject.SelectedItems)
{
VCFilter filter = si.ProjectItem.Object as VCFilter;
VCProject proj = filter.project as VCProject;
template_file_name_dst = contextParams[4] as string;
template_file_name_dst += ".jst";
File.Copy(template_file_name_src, template_file_name_dst);
if (filter.CanAddFile(template_file_name_dst))
{
string text = null;
using (StreamReader sr = new StreamReader(template_file_name_dst))
{
text = sr.ReadToEnd();
text = text.Replace("%ns%", Path.GetFileNameWithoutExtension(template_file_name_dst));
}
using (StreamWriter sw = new StreamWriter(template_file_name_dst))
{
sw.Write(text);
}
filter.AddFile(template_file_name_dst);
if (null == add_output_file)
{
XmlDocument doc = new XmlDocument();
doc.Load(app_folder + "\\debugconf.xml");
XmlNode add_o_file = doc.SelectSingleNode("/debug/add_output_file");
add_output_file = add_o_file.InnerText;
}
if ("true" == add_output_file)
{
filter.AddFile(proj.ProjectDirectory + "\\mjst\\" + Path.GetFileNameWithoutExtension(template_file_name_dst) + ".h");
}
// open added file
_applicationObject.ItemOperations.OpenFile(template_file_name_dst);
}
}
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
}
public void ProjectFinishedGenerating(Project project)
{
// --- FILTERS --- //
VCProject vcproject = project as VCProject;
// Retrieve filters
_filterHeaderQuestion = null;
_filterHeaderRead = null;
_filterHeaderWrite = null;
_filterSourceQuestion = null;
_filterSourceRead = null;
_filterSourceWrite = null;
foreach (VCFilter filter in vcproject.Filters)
{
if (filter.Name == _filterStringHeaderQuestion)
{
_filterHeaderQuestion = filter;
}
else if (filter.Name == _filterStringHeaderRead)
{
_filterHeaderRead = filter;
}
else if (filter.Name == _filterStringHeaderWrite)
{
_filterHeaderWrite = filter;
}
else if (filter.Name == _filterStringSourceQuestion)
{
_filterSourceQuestion = filter;
}
else if (filter.Name == _filterStringSourceRead)
{
_filterSourceRead = filter;
}
else if (filter.Name == _filterStringSourceWrite)
{
_filterSourceWrite = filter;
}
}
// If any filters didn't already exist, make them!
if (_filterHeaderQuestion == null)
{
_filterHeaderQuestion = vcproject.AddFilter(_filterStringHeaderQuestion);
}
if (_filterHeaderRead == null)
{
_filterHeaderRead = vcproject.AddFilter(_filterStringHeaderRead);
}
if (_filterHeaderWrite == null)
{
_filterHeaderWrite = vcproject.AddFilter(_filterStringHeaderWrite);
}
if (_filterSourceQuestion == null)
{
_filterSourceQuestion = vcproject.AddFilter(_filterStringSourceQuestion);
}
if (_filterSourceRead == null)
{
_filterSourceRead = vcproject.AddFilter(_filterStringSourceRead);
}
if (_filterSourceWrite == null)
{
_filterSourceWrite = vcproject.AddFilter(_filterStringSourceWrite);
}
// Add files to filters
_filterHeaderQuestion.AddFile(_mainHeaderFilePath);
_filterHeaderRead.AddFile(_readHeaderFilePath);
_filterHeaderWrite.AddFile(_writeHeaderFilePath);
_filterSourceQuestion.AddFile(_mainSourceFilePath);
_filterSourceRead.AddFile(_readSourceFilePath);
_filterSourceWrite.AddFile(_writeSourceFilePath);
}
public void Execute(object Application,
int hwndOwner,
ref object[] contextParams,
ref object[] customParams,
ref EnvDTE.wizardResult retval)
{
try
{
_applicationObject = Application as DTE2;
if (null == template_file_name_src_jst || null == template_file_name_src_json)
{
RegistryKey vs2010 = Registry.CurrentUser.OpenSubKey("software\\jstructtool");
template_file_name_src_jst = vs2010.GetValue("AppFolder").ToString() + "\\inc\\template.jst";
template_file_name_src_json = vs2010.GetValue("AppFolder").ToString() + "\\inc\\template.json";
vs2010.Close();
}
foreach (SelectedItem si in _applicationObject.SelectedItems)
{
VCFilter filter = si.ProjectItem.Object as VCFilter;
VCProject proj = filter.project as VCProject;
template_file_name_dst = contextParams[4] as string;
if (!template_file_name_dst.EndsWith(".json"))
{
template_file_name_dst += ".jst";
File.Copy(template_file_name_src_jst, template_file_name_dst);
}
else
{
File.Copy(template_file_name_src_json, template_file_name_dst);
}
if (filter.CanAddFile(template_file_name_dst))
{
if (template_file_name_dst.EndsWith(".jst"))
{
string text = null;
using (StreamReader sr = new StreamReader(template_file_name_dst))
{
text = sr.ReadToEnd();
text = text.Replace("%struct_name%", Path.GetFileNameWithoutExtension(template_file_name_dst));
}
using (StreamWriter sw = new StreamWriter(template_file_name_dst))
{
sw.Write(text);
}
}
filter.AddFile(template_file_name_dst);
// open added file
_applicationObject.ItemOperations.OpenFile(template_file_name_dst);
if (template_file_name_dst.EndsWith(".json"))
{
template_file_name_dst = template_file_name_dst.Remove(template_file_name_dst.LastIndexOf(".json")) + ".jst";
filter.AddFile(template_file_name_dst);
}
}
}
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
}
