public void AddCoreTargets(ProjectRootElement el)
{
var skiaSharpTargets = Path.Combine(
Path.GetDirectoryName(GetType().Assembly.Location),
"..", "..", "..", "packages", "SkiaSharp.1.56.1", "build", "net45", "SkiaSharp.targets");
//var props = Path.Combine (
// Path.GetDirectoryName (GetType ().Assembly.Location),
// "..", "..", "..", "Resizetizer.BuildTasks", "bin", "Debug", "Resizetizer.props"
//);
//el.AddImport (props);
var targets = Path.Combine(
Path.GetDirectoryName(GetType().Assembly.Location),
"..", "..", "..", "Resizetizer.BuildTasks", "bin", "Debug", "Resizetizer.targets"
);
if (!File.Exists(targets))
{
targets = Path.Combine(
Path.GetDirectoryName(GetType().Assembly.Location),
"..", "..", "..", "Resizetizer.BuildTasks", "bin", "Release", "Resizetizer.targets"
);
}
el.AddProperty("ShouldIncludeNativeSkiaSharp", "True");
//< ShouldIncludeNativeSkiaSharp > True </ ShouldIncludeNativeSkiaSharp >
el.AddImport(targets);
el.AddImport(skiaSharpTargets);
}
public void DefaultTargetsOuterAndInner()
{
ProjectRootElement xml1 = ProjectRootElement.Create("p1");
xml1.AddImport("p2");
xml1.AddImport("p3");
xml1.DefaultTargets = "d1";
ProjectRootElement xml2 = ProjectRootElement.Create("p2");
xml2.DefaultTargets = "d2";
ProjectRootElement xml3 = ProjectRootElement.Create("p3");
xml3.DefaultTargets = "d3";
Project project = new Project(xml1);
StringWriter writer = new StringWriter();
project.SaveLogicalProject(writer);
string expected = ObjectModelHelpers.CleanupFileContents(
@"<?xml version=""1.0"" encoding=""utf-16""?>
<!--
============================================================================================================================================
" + CurrentDirectoryXmlCommentFriendly + Path.DirectorySeparatorChar + @"p1
============================================================================================================================================
-->
<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"" DefaultTargets=""d1"">
<!--
============================================================================================================================================
<Import Project=""p2"">
" + CurrentDirectoryXmlCommentFriendly + Path.DirectorySeparatorChar + @"p2
============================================================================================================================================
-->
<!--
============================================================================================================================================
</Import>
" + CurrentDirectoryXmlCommentFriendly + Path.DirectorySeparatorChar + @"p1
============================================================================================================================================
-->
<!--
============================================================================================================================================
<Import Project=""p3"">
" + CurrentDirectoryXmlCommentFriendly + Path.DirectorySeparatorChar + @"p3
============================================================================================================================================
-->
<!--
============================================================================================================================================
</Import>
" + CurrentDirectoryXmlCommentFriendly + Path.DirectorySeparatorChar + @"p1
============================================================================================================================================
-->
</Project>");
Helpers.VerifyAssertLineByLine(expected, writer.ToString());
}
/// <summary>
/// Creates and returns a minimal C# project file that can be built.
/// The project imports the C# targets and any other optional targets that are specified.
/// The project is NOT saved.
/// </summary>
/// <param name="preImportProperties">Any properties that need to be set before the C# targets are imported. Can be null.</param>
/// <param name="importsBeforeTargets">Any targets that should be imported before the C# targets are imported. Optional.</param>
public static ProjectRootElement CreateMinimalBuildableProject(IDictionary <string, string> preImportProperties, params string[] importsBeforeTargets)
{
ProjectRootElement root = ProjectRootElement.Create();
foreach (string importTarget in importsBeforeTargets)
{
Assert.IsTrue(File.Exists(importTarget), "Test error: the specified target file does not exist. Path: {0}", importTarget);
root.AddImport(importTarget);
}
if (preImportProperties != null)
{
foreach (KeyValuePair <string, string> kvp in preImportProperties)
{
root.AddProperty(kvp.Key, kvp.Value);
}
}
// Ensure the output path is set
if (preImportProperties == null || !preImportProperties.ContainsKey("OutputPath"))
{
root.AddProperty("OutputPath", @"bin\");
}
// Import the standard Microsoft targets
root.AddImport("$(MSBuildToolsPath)\\Microsoft.CSharp.targets");
root.AddProperty("OutputType", "library"); // build a library so we don't need a Main method
return(root);
}
private static void AddImports(ProjectRootElement root)
{
root.AddImport("$(MSBuildToolsPath)\\Microsoft.CSharp.targets");
ProjectImportElement import = root.AddImport("$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props");
import.Condition = "Exists('$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props')";
}
public void AddCoreTargets(ProjectRootElement el)
{
var props = Path.Combine(
Path.GetDirectoryName(GetType().Assembly.Location),
"..", "..", "..", "Xamarin.Build.Download", "bin", "Debug", "Xamarin.Build.Download.props"
);
el.AddImport(props);
var targets = Path.Combine(
Path.GetDirectoryName(GetType().Assembly.Location),
"..", "..", "..", "Xamarin.Build.Download", "bin", "Debug", "Xamarin.Build.Download.targets"
);
el.AddImport(targets);
}
private static void makeBuildProject()
{
projectRootElement = ProjectRootElement.Create(projectDirectory);
//stuff for importing XNA Framework
projectRootElement.AddImport("$(MSBuildExtensionsPath)\\Microsoft\\XNA Game Studio\\" +
"v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets");
if (buildProject == null)
{
buildProject = new Project(projectRootElement);
}
buildProject.SetProperty("XnaPlatform", "Windows");
buildProject.SetProperty("XnaProfile", "Reach");
buildProject.SetProperty("XnaFrameworkVersion", "v4.0");
buildProject.SetProperty("Configuration", "Release");
buildProject.SetProperty("OutputPath", outputDirectory);
//add references to required content importers
buildProject.AddItem("Reference", "Microsoft.Xna.Framework.Content.Pipeline.FBXImporter, Version=4.0.0.0, PublicKeyToken=842cf8be1de50553");
buildProject.AddItem("Reference", "Microsoft.Xna.Framework.Content.Pipeline.XImporter, Version=4.0.0.0, PublicKeyToken=842cf8be1de50553");
buildProject.AddItem("Reference", "Microsoft.Xna.Framework.Content.Pipeline.TextureImporter, Version=4.0.0.0, PublicKeyToken=842cf8be1de50553");
buildProject.AddItem("Reference", "Microsoft.Xna.Framework.Content.Pipeline.EffectImporter, Version=4.0.0.0, PublicKeyToken=842cf8be1de50553");
}
public void Add(string item)
{
if (!Contains(item))
{
_projectRoot.AddImport(item);
}
}
private static void ProcessImportsFrom22(ProjectRootElement projectXml, Action <__VSUL_ERRORLEVEL, string> log)
{
bool anyUpdated = false;
var propValue = PtvsTargets;
foreach (var p in projectXml.Properties.Where(IsPtvsTargetsFileProperty).ToArray())
{
propValue = p.Value;
p.Parent.RemoveChild(p);
anyUpdated = true;
}
// Replace:
// <Import Condition="Exists($(PtvsTargetsFile))" Project="$(PtvsTargetsFile)" />
// <Import Condition="!Exists($(PtvsTargetsFile))" Project="$(MSBuildToolsPath)\Microsoft.Common.targets" />
//
// With:
// <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets" />
foreach (var p in projectXml.Imports.Where(i => i.Condition.Contains("$(PtvsTargetsFile)")).ToArray())
{
p.Parent.RemoveChild(p);
}
projectXml.AddImport(PtvsTargets);
if (anyUpdated)
{
log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, Strings.UpgradedImportsFor30);
}
}
/// <summary>
/// Creates a temporary MSBuild content project in memory.
/// </summary>
private void CreateBuildProject()
{
string projectPath = Path.Combine(_buildDirectory, "content.contentproj");
string outputPath = Path.Combine(_buildDirectory, "bin");
// Create the build project.
_projectRootElement = ProjectRootElement.Create(projectPath);
// Include the standard targets file that defines how to build XNA Framework content.
_projectRootElement.AddImport("$(MSBuildExtensionsPath)\\Microsoft\\XNA Game Studio\\"
+ "v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets");
_buildProject = new Project(_projectRootElement);
_buildProject.SetProperty("XnaPlatform", "Windows");
IOptionsService optionsService = (IOptionsService)_serviceProvider.GetService(typeof(IOptionsService));
_buildProject.SetProperty("XnaProfile", optionsService.GetContentPreviewOptions().Profile.ToString());
_buildProject.SetProperty("XnaFrameworkVersion", XnaConstants.XnaFrameworkVersion);
_buildProject.SetProperty("Configuration", "Release");
_buildProject.SetProperty("OutputPath", outputPath);
// Hook up our custom error logger.
_errorLogger = new ErrorLogger();
_buildParameters = new BuildParameters(ProjectCollection.GlobalProjectCollection);
_buildParameters.Loggers = new ILogger[] { _errorLogger };
}
public void SetPropertyImported()
{
Assert.Throws <InvalidOperationException>(() =>
{
string file = null;
try
{
file = net.r_eg.IeXod.Shared.FileUtilities.GetTemporaryFile();
Project import = new Project();
import.SetProperty("p", "v0");
import.Save(file);
ProjectRootElement xml = ProjectRootElement.Create();
xml.AddImport(file);
Project project = new Project(xml);
ProjectProperty property = project.GetProperty("p");
property.UnevaluatedValue = "v1";
}
finally
{
File.Delete(file);
}
}
);
}
public override void Process(
string sourcePath,
ProjectRootElement project,
Dictionary <string, ProjectPropertyGroupElement> groups
)
{
ProjectPropertyGroupElement globals;
if (!groups.TryGetValue("Globals", out globals))
{
globals = project.AddPropertyGroup();
}
AddOrSetProperty(globals, "StartupFile", "manage.py");
AddOrSetProperty(globals, "ProjectTypeGuids", "{5F0BE9CA-D677-4A4D-8806-6076C0FAAD37};{349c5851-65df-11da-9384-00065b846f21};{888888a0-9f3d-457c-b088-3a5042f75d52}");
AddOrSetProperty(globals, "LaunchProvider", "Django launcher");
AddOrSetProperty(globals, "WebBrowserUrl", "http://localhost");
var settingsFilePath = PathUtils.FindFile(sourcePath, "settings.py", depthLimit: 1);
if (File.Exists(settingsFilePath))
{
var packageName = PathUtils.GetLastDirectoryName(settingsFilePath);
AddOrSetProperty(globals, "DjangoSettingsModule", "{0}.settings".FormatInvariant(packageName));
}
project.AddImport(@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.Django.targets");
GenericWebProjectCustomization.AddWebProjectExtensions(project);
}
public void FalseImport()
{
ProjectRootElement xml1 = ProjectRootElement.Create("p1");
xml1.AddProperty("p", "v1");
xml1.AddImport("p2").Condition = "false";
ProjectRootElement xml2 = ProjectRootElement.Create("p2");
xml2.AddProperty("p", "v2");
Project project = new Project(xml1);
StringWriter writer = new StringWriter();
project.SaveLogicalProject(writer);
string expected = ObjectModelHelpers.CleanupFileContents(
@"<?xml version=""1.0"" encoding=""utf-16""?>
<!--
============================================================================================================================================
" + CurrentDirectoryXmlCommentFriendly + Path.DirectorySeparatorChar + @"p1
============================================================================================================================================
-->
<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<PropertyGroup>
<p>v1</p>
</PropertyGroup>
<!--<Import Project=""p2"" Condition=""false"" />-->
</Project>");
Helpers.VerifyAssertLineByLine(expected, writer.ToString());
}
private void CreateBuildProject()
{
string projectPath = Path.Combine(_buildDirectory, "content.contentproj");
string outputPath = Path.Combine(_buildDirectory, "bin");
_rootElement = ProjectRootElement.Create(projectPath);
_rootElement.AddImport("$(MSBuildExtensionsPath)\\Microsoft\\XNA Game Studio\\v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets");
_buildProject = new Project(_rootElement);
_buildProject.SetProperty("XnaPlatform", "Windows");
_buildProject.SetProperty("XnaProfile", "Reach");
_buildProject.SetProperty("XnaFrameworkVersion", "v4.0");
_buildProject.SetProperty("Configuration", "Release");
_buildProject.SetProperty("OutputPath", outputPath);
foreach (string assm in _pipelineAssemblies)
{
_buildProject.AddItem("Reference", assm);
}
_errorLogger = new ErrorLogger();
_buildParameters = new BuildParameters(ProjectCollection.GlobalProjectCollection);
_buildParameters.Loggers = new ILogger[] { _errorLogger };
}
public void AddImportOnlyConditionedImportGroupsExist()
{
string content = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' >
<Import Project='a.proj' />
<ImportGroup Condition='c1'>
<Import Project='b.proj' />
</ImportGroup>
<ImportGroup Condition='c2'>
<Import Project='c.proj' />
</ImportGroup>
</Project>
";
ProjectRootElement project = ProjectRootElement.Create(XmlReader.Create(new StringReader(content)));
project.AddImport("d.proj");
string expectedContent = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' >
<Import Project='a.proj' />
<ImportGroup Condition='c1'>
<Import Project='b.proj' />
</ImportGroup>
<ImportGroup Condition='c2'>
<Import Project='c.proj' />
</ImportGroup>
<Import Project='d.proj' />
</Project>
";
Helpers.CompareProjectXml(expectedContent, project.RawXml);
}
public void UpdateMetadataImported()
{
Assert.Throws <InvalidOperationException>(() =>
{
string file = null;
try
{
file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
ProjectRootElement import = ProjectRootElement.Create(file);
import.AddItemDefinitionGroup().AddItemDefinition("i").AddMetadata("m", "m0");
import.Save();
ProjectRootElement main = ProjectRootElement.Create();
Project project = new Project(main);
main.AddImport(file);
project.ReevaluateIfNecessary();
ProjectItemDefinition definition = project.ItemDefinitions["i"];
definition.SetMetadataValue("m", "m1");
}
finally
{
File.Delete(file);
}
}
);
}
/// <summary>
/// Creates a temporary MSBuild content project in memory.
/// </summary>
void CreateBuildProject()
{
string projectPath = Path.Combine(buildDirectory, "content.contentproj");
string outputPath = Path.Combine(buildDirectory, "bin");
// Create the build project.
projectRootElement = ProjectRootElement.Create(projectPath);
// Include the standard targets file that defines how to build XNA Framework content.
projectRootElement.AddImport("$(MSBuildExtensionsPath)\\Microsoft\\XNA Game Studio\\" +
"v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets");
buildProject = new Project(projectRootElement);
buildProject.SetProperty("XnaPlatform", "Windows");
buildProject.SetProperty("XnaProfile", "Reach");
buildProject.SetProperty("XnaFrameworkVersion", "v4.0");
buildProject.SetProperty("Configuration", "Release");
buildProject.SetProperty("OutputPath", outputPath);
// Register any custom importers or processors.
foreach (string pipelineAssembly in pipelineAssemblies)
{
buildProject.AddItem("Reference", pipelineAssembly);
}
}
public override void Process(
ProjectRootElement project,
Dictionary <string, ProjectPropertyGroupElement> groups
)
{
ProjectPropertyGroupElement imports;
if (!groups.TryGetValue("Imports", out imports))
{
imports = project.AddPropertyGroup();
}
AddOrSetProperty(imports, "PtvsTargetsFile", @"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets");
project.AddImport("$(PtvsTargetsFile)").Condition = "Exists($(PtvsTargetsFile))";
project.AddImport(@"$(MSBuildToolsPath)\Microsoft.Common.targets").Condition = "!Exists($(PtvsTargetsFile))";
}
/// <summary>
/// Creates a temporary MSBuild content project in memory.
/// </summary>
void CreateBuildProject()
{
string projectPath = Path.Combine(buildDirectory, "content.contentproj");
// Create the build project.
projectRootElement = ProjectRootElement.Create(projectPath);
// Include the standard targets file that defines how to build XNA Framework content.
projectRootElement.AddImport("$(MSBuildExtensionsPath)\\Microsoft\\XNA Game Studio\\" +
"v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets");
buildProject = new Project(projectRootElement);
buildProject.SetProperty("XnaPlatform", "Windows");
buildProject.SetProperty("XnaProfile", "Reach");
buildProject.SetProperty("XnaFrameworkVersion", "v4.0");
buildProject.SetProperty("Configuration", "Release");
buildProject.SetProperty("OutputPath", Directory.GetParent(outputDirectory).ToString());
// Register any custom importers or processors.
foreach (string pipelineAssembly in pipelineAssemblies)
{
buildProject.AddItem("Reference", pipelineAssembly);
}
// Hook up our custom error logger.
errorLogger = new ErrorLogger();
buildParameters = new BuildParameters(ProjectCollection.GlobalProjectCollection);
buildParameters.Loggers = new ILogger[] { errorLogger };
}
public override void Process(
ProjectRootElement project,
Dictionary <string, ProjectPropertyGroupElement> groups
)
{
project.AddImport(@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets");
}
public void AddImportOnlyConditionedImportGroupsExist()
{
string content = @"
<Project>
<Import Project='a.proj' />
<ImportGroup Condition='c1'>
<Import Project='b.proj' />
</ImportGroup>
<ImportGroup Condition='c2'>
<Import Project='c.proj' />
</ImportGroup>
</Project>
";
ProjectRootElement project = ProjectRootElement.Create(XmlReader.Create(new StringReader(content)));
project.AddImport("d.proj");
string expectedContent = @"
<Project>
<Import Project='a.proj' />
<ImportGroup Condition='c1'>
<Import Project='b.proj' />
</ImportGroup>
<ImportGroup Condition='c2'>
<Import Project='c.proj' />
</ImportGroup>
<Import Project='d.proj' />
</Project>
";
Helpers.CompareProjectXml(expectedContent, project.RawXml);
}
private Project ConstructStandardProject(String projectPath, String outputPath)
{
ProjectRootElement root = ProjectRootElement.Create(projectPath);
root.AddImport(@"$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\" +
@"v4.0\Microsoft.Xna.GameStudio.ContentPipeline.targets");
Project project = new Project(root);
project.SetProperty("XnaPlatform", "Windows");
project.SetProperty("XnaProfile", "Reach");
project.SetProperty("XnaFrameworkVersion", "v4.0");
project.SetProperty("Configuration", "Release");
project.SetProperty("OutputPath", outputPath);
foreach (String assembly in PipelineAssemblies)
{
project.AddItem("Reference", assembly);
}
String appDirectory = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
foreach (String assembly in _userAssemblies)
{
String path = assembly;
if (!Path.IsPathRooted(assembly))
{
path = Path.Combine(appDirectory, assembly);
}
Assembly.LoadFile(path);
project.AddItem("Reference", path);
}
return(project);
}
private bool AddImports(ProjectRootElement inMemoryProject, Microsoft.Build.Evaluation.Project originalProject)
{
foreach (ResolvedImport import in originalProject.Imports)
{
inMemoryProject.AddImport(import.ImportedProject.FullPath).Condition = import.ImportingElement.Condition;
}
return(true);
}
private void AddCaptureTargetsImport(string projectFolder, ProjectRootElement projectRoot)
{
// Add an additional import that will dump data we are interested in to the build log
var captureTargetsFilePath = CreateCaptureDataTargetsFile(projectFolder);
var captureTarget = projectRoot.AddImport(captureTargetsFilePath);
var projectFilePath = Path.Combine(projectFolder, "valid.project.proj");
projectRoot.Save(projectFilePath);
}
static ProjectImportElement AddImport(
ProjectRootElement projectRoot,
string importedProjectFile,
ProjectImportLocation importLocation)
{
if (importLocation == ProjectImportLocation.Top)
{
return(AddImportAtTop(projectRoot, importedProjectFile));
}
return(projectRoot.AddImport(importedProjectFile));
}
void AddCoreTargets(ProjectRootElement el)
{
var baseDir = new Uri(System.Reflection.Assembly.GetExecutingAssembly().CodeBase).LocalPath;
var props = Path.Combine(baseDir, "..", "..", "source", "Xamarin.Build.Download", "bin", Configuration, "netstandard20", "Xamarin.Build.Download.props");
if (!File.Exists(props))
{
props = Path.Combine(baseDir, "..", "Xamarin.Build.Download.props");
}
el.AddImport(props);
var targets = Path.Combine(baseDir, "..", "..", "source", "Xamarin.Build.Download", "bin", Configuration, "netstandard20", "Xamarin.Build.Download.targets");
if (!File.Exists(targets))
{
targets = Path.Combine(baseDir, "..", "Xamarin.Build.Download.targets");
}
el.AddImport(targets);
}
public override void Run()
{
Log.LogMessage("Generating module build package imports");
ProjectRootElement propsProject = ProjectRootElement.Create(PropsFile);
ProjectRootElement targetsProject = ProjectRootElement.Create(TargetsFile);
ProjectPropertyGroupElement propertyGroup = propsProject.AddPropertyGroup();
foreach (BuildPackageInfo buildPackageInfo in ModulePaths.Select(BuildPackageInfo.FromModulePath).Where(i => i != null))
{
if (buildPackageInfo.PropsPath == null && buildPackageInfo.TargetsPath == null)
{
Log.LogMessage(MessageImportance.Low, $" Skipping '{buildPackageInfo.Id}' because it is not a standard NuGet build package.");
continue;
}
// If this is a cbt module do not auto import props or targets.
if (File.Exists(Path.Combine(Path.GetDirectoryName(buildPackageInfo.PropsPath ?? buildPackageInfo.TargetsPath), "module.config")))
{
Log.LogMessage(MessageImportance.Low, $" Skipping '{buildPackageInfo.Id}' because it is a CBT Module.");
continue;
}
ProjectPropertyElement enableProperty = propertyGroup.AddProperty(buildPackageInfo.EnablePropertyName, "false");
enableProperty.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == '' ";
ProjectPropertyElement runProperty = propertyGroup.AddProperty(buildPackageInfo.RunPropertyName, "true");
runProperty.Condition = $" '$({buildPackageInfo.RunPropertyName})' == '' ";
if (File.Exists(buildPackageInfo.PropsPath))
{
ProjectImportElement import = propsProject.AddImport(buildPackageInfo.PropsPath);
import.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == 'true' And '$({buildPackageInfo.RunPropertyName})' == 'true' ";
}
if (File.Exists(buildPackageInfo.TargetsPath))
{
ProjectImportElement import = targetsProject.AddImport(buildPackageInfo.TargetsPath);
import.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == 'true' And '$({buildPackageInfo.RunPropertyName})' == 'true' ";
}
Log.LogMessage($" Generated imports for '{buildPackageInfo.Id}'.");
}
propsProject.Save();
targetsProject.Save();
}
public void AddCoreTargets(ProjectRootElement el)
{
//var props = Path.Combine (
// Path.GetDirectoryName (GetType ().Assembly.Location),
// "..", "..", "..", "Resizetizer.BuildTasks", "bin", "Debug", "Resizetizer.props"
//);
//el.AddImport (props);
var targets = Path.Combine(
Path.GetDirectoryName(GetType().Assembly.Location),
"..", "..", "..", "Resizetizer.BuildTasks", "bin", "Debug", "Resizetizer.targets"
);
el.AddImport(targets);
}
public void AddCoreTargets(ProjectRootElement el)
{
//var props = Path.Combine(
// Path.GetDirectoryName(GetType().Assembly.Location),
// "..", "..", "..", "buildtasks", "bin", "Debug", "Xamarin.GooglePlayServices.Basement.props"
//);
//el.AddImport(props);
var targets = Path.Combine(
Path.GetDirectoryName(GetType().Assembly.Location),
"..", "..", "..", "buildtasks", "bin", "Debug", "Xamarin.GooglePlayServices.Basement.targets"
);
el.AddImport(targets);
}
public RepositoryProject(string repositoryRoot)
{
_doc = ProjectRootElement.Create(NewProjectFileOptions.None);
var import = _doc.CreateImportElement(@"$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props");
var propGroup = _doc.AddPropertyGroup();
if (repositoryRoot[repositoryRoot.Length - 1] != '\\')
{
repositoryRoot += '\\';
}
propGroup.AddProperty("RepositoryRoot", repositoryRoot);
_doc.AddItemGroup();
_doc.PrependChild(import);
_doc.AddImport(@"$(MSBuildToolsPath)\Microsoft.Common.targets");
}
public Microsoft.Build.Evaluation.Project Orchestrate(string projConfFile)
{
Microsoft.Build.Evaluation.Project msbuildProj = ProjectCollection.GlobalProjectCollection.LoadProject(projConfFile);
if (msbuildProj == null)
{
msbuildProj = new Microsoft.Build.Evaluation.Project(projConfFile);
if (msbuildProj == null)
{
return(null);
}
}
ProjectRootElement projRoot = msbuildProj.Xml;
if (projRoot == null)
{
return(null);
}
string instPath = extensionServ.GetVSIXInstallPath();
bool need_save = false;
string cpTargetsFullPath = Path.GetDirectoryName(projConfFile) + "\\ChartPoints.targets";
if (!File.Exists(cpTargetsFullPath))
{
bool res = CreateFileFromResource("ChartPointsLib.Resources.ChartPoints.targets", cpTargetsFullPath);
}
IEnumerable <ProjectImportElement> importElems = projRoot.Imports.Where(ig => (ig.Project == "ChartPoints.targets"));
if (!importElems.Any())
{
projRoot.AddImport("ChartPoints.targets");
need_save = true;
}
IEnumerable <ProjectPropertyGroupElement> cpPropsGroups = projRoot.PropertyGroups.Where(ig => (ig.Label == "CPTargetsVariables"));
if (!cpPropsGroups.Any())
{
ProjectPropertyGroupElement cpPropsGroup = projRoot.AddPropertyGroup();
cpPropsGroup.Label = "CPTargetsVariables";
cpPropsGroup.AddProperty("TargetFileFullPath", instPath + "\\CPInstrBuildTask.dll");
cpPropsGroup.AddProperty("ThisProjectFullName", "$(MSBuildThisFileFullPath)");
}
if (need_save)
{
msbuildProj.Save();
}
return(msbuildProj);
}
