microsoft
/
Win2D
зеркало из https://github.com/microsoft/Win2D.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
Win2D/Win2D.proj

259 строки
12 KiB
Plaintext
Исходник Обычный вид История

Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
<?xml version="1.0" encoding="utf-8"?>
<!--
Master script for building all permutations of project * platform * configuration.
For best performance, enable parallel builds:
Win2D project name
2014-09-04 02:46:39 +04:00
msbuild Win2D.proj /maxcpucount
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
-->
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0" DefaultTargets="Build">
Win2D project name
2014-09-04 02:46:39 +04:00
<!-- Parameters that can be configured by the caller, eg. "msbuild Win2D.proj /p:BuildPhone=false" -->
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
<PropertyGroup>
<BuildPlatforms>Win32;x64;ARM;AnyCPU</BuildPlatforms>
<BuildConfigurations>Debug;Release</BuildConfigurations>
<BuildWindows>true</BuildWindows>
<BuildPhone>true</BuildPhone>
<BuildTests>true</BuildTests>
<BuildTools>true</BuildTools>
Tooling to create reference documentation, using the open source Sandcastle tool
2014-08-12 08:37:27 +04:00
<BuildDocs>true</BuildDocs>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<RunTests>true</RunTests>
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</PropertyGroup>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<!-- Set default platforms for each project type -->
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
<ItemDefinitionGroup>
<WindowsProject>
<Platforms>Win32;x64;ARM</Platforms>
</WindowsProject>
<PhoneProject>
<Platforms>Win32;ARM</Platforms>
</PhoneProject>
<AnyCPUProject>
<Platforms>AnyCPU</Platforms>
</AnyCPUProject>
</ItemDefinitionGroup>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
<!-- Windows projects implementing the Canvas API -->
<ItemGroup Condition="$(BuildWindows)">
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<WindowsProject Include="winrt\lib\winrt.lib.Windows.vcxproj" />
<WindowsProject Include="winrt\dll\winrt.dll.Windows.vcxproj" />
<WindowsProject Include="numerics\DotNet\DotNetNumerics.Windows.csproj" />
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</ItemGroup>
<!-- Windows Phone projects implementing the Canvas API -->
<ItemGroup Condition="$(BuildPhone)">
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<PhoneProject Include="winrt\lib\winrt.lib.WindowsPhone.vcxproj" />
<PhoneProject Include="winrt\dll\winrt.dll.WindowsPhone.vcxproj" />
<PhoneProject Include="numerics\DotNet\DotNetNumerics.WindowsPhone.csproj" />
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</ItemGroup>
<!-- Windows test projects -->
<ItemGroup Condition="$(BuildWindows) and $(BuildTests)">
<WindowsProject Include="winrt\test.internal\winrt.test.internal.vcxproj">
<Platforms>Win32;x64</Platforms>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<AutomatedTests>desktop</AutomatedTests>
</WindowsProject>
<WindowsProject Include="winrt\test.external\winrt.test.external.Windows.vcxproj">
<AutomatedTests>store</AutomatedTests>
</WindowsProject>
WinRT IVector<T> implementation I could not find any existing implementations that were sufficiently complete, high quality, supported collections of runtime types as well as interfaces and value types, and were under a suitable open source license, so had to write my own. Hopefully this Vector.h will fill that hole for others with similar needs in future! Features: - Implements IVector<T> and IIterable<T>, but not IObservableVector<T> - T can be interface, runtime class, or value type, and is factored such that strings can easily be added if/when needed. - Vectors may optionally be locked to a fixed size, in which case users can change their elements but not add/remove elements. - Vectors track a dirty flag so their owner can tell when their contents changed. This is a lightweight internal-only mechanism rather than full IObservableVector implementation to avoid complications with event handlers causing circular refcount chains. - By default vectors own their content data (internally using an STL collection) but there is also an option to wrap them around some other source so as to just provide a WinRT API surface on top of any other data. - Provides an internal mechanism to get direct access to the STL container inside a WinRT vector, so API implementations can work directly with this rather than having to go through the overhead of WinRT vtable dispatch and exception boundaries for every get/set/iterate operation.
2014-08-26 07:24:14 +04:00
<WindowsProject Include="winrt\test.nativecomponent\winrt.test.nativecomponent.Windows.vcxproj" />
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<WindowsProject Include="winrt\test.managed\Windows\winrt.test.managed.Windows.csproj">
<AutomatedTests>store</AutomatedTests>
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</WindowsProject>
<WindowsProject Include="tests\CsConsumer\Windows\CsConsumer.Windows.csproj" />
ExampleGallery - framework in place for adding new examples to the gallery
2014-07-26 03:35:34 +04:00
<WindowsProject Include="tests\ExampleGallery\Windows\ExampleGallery.Windows.csproj" />
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<WindowsProject Include="numerics\Cpp\tests\CppNumericsTests.Windows.vcxproj">
<AutomatedTests>store</AutomatedTests>
</WindowsProject>
<WindowsProject Include="numerics\DotNet\tests\Windows\DotNetNumericsTests.Windows.csproj">
<AutomatedTests>store</AutomatedTests>
</WindowsProject>
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</ItemGroup>
<!-- Windows Phone test projects -->
<ItemGroup Condition="$(BuildPhone) and $(BuildTests)">
<PhoneProject Include="winrt\test.external\winrt.test.external.WindowsPhone.vcxproj" />
WinRT IVector<T> implementation I could not find any existing implementations that were sufficiently complete, high quality, supported collections of runtime types as well as interfaces and value types, and were under a suitable open source license, so had to write my own. Hopefully this Vector.h will fill that hole for others with similar needs in future! Features: - Implements IVector<T> and IIterable<T>, but not IObservableVector<T> - T can be interface, runtime class, or value type, and is factored such that strings can easily be added if/when needed. - Vectors may optionally be locked to a fixed size, in which case users can change their elements but not add/remove elements. - Vectors track a dirty flag so their owner can tell when their contents changed. This is a lightweight internal-only mechanism rather than full IObservableVector implementation to avoid complications with event handlers causing circular refcount chains. - By default vectors own their content data (internally using an STL collection) but there is also an option to wrap them around some other source so as to just provide a WinRT API surface on top of any other data. - Provides an internal mechanism to get direct access to the STL container inside a WinRT vector, so API implementations can work directly with this rather than having to go through the overhead of WinRT vtable dispatch and exception boundaries for every get/set/iterate operation.
2014-08-26 07:24:14 +04:00
<PhoneProject Include="winrt\test.nativecomponent\winrt.test.nativecomponent.WindowsPhone.vcxproj" />
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
<PhoneProject Include="winrt\test.managed\WindowsPhone\winrt.test.managed.WindowsPhone.csproj" />
<PhoneProject Include="tests\CsConsumer\WindowsPhone\CsConsumer.WindowsPhone.csproj" />
ExampleGallery - framework in place for adding new examples to the gallery
2014-07-26 03:35:34 +04:00
<PhoneProject Include="tests\ExampleGallery\WindowsPhone\ExampleGallery.WindowsPhone.csproj"/>
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
<PhoneProject Include="numerics\Cpp\tests\CppNumericsTests.WindowsPhone.vcxproj" />
<PhoneProject Include="numerics\DotNet\tests\WindowsPhone\DotNetNumericsTests.WindowsPhone.csproj" />
</ItemGroup>
<!-- Tools projects -->
<ItemGroup Condition="$(BuildTools)">
<AnyCPUProject Include="tools\copyright\copyright.csproj" />
<AnyCPUProject Include="tools\codegen\exe\codegen.exe.csproj" />
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<AnyCPUProject Include="tools\codegen\test\codegen.test.csproj" Condition="$(BuildTests)">
<AutomatedTests>desktop</AutomatedTests>
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</AnyCPUProject>
DocDiff tool validates that our documentation properly matches the latest API surface This runs as part of the doc build and compares the placeholder XML docs created by ExtractAPISurface tool against the real ones that are checked into the docsrc folders. It warns if new APIs are missing their documentation, or old APIs have been removed but the stale documentation for them is still there. If documentation is missing, a placeholder XML file is written to obj\docs\MissingDocs.xml. This is formatted in such a way that its contents can be pasted directly into the appropriate docsrc files, as a quick way to get started filling in the tags with real doc content. Used this to remove a couple of stale APIs from the current docsrc XML files. Also updated the ExtractAPISurface tool to include doc comments for every member value of enums.
2014-08-14 04:45:08 +04:00
<AnyCPUProject Include="tools\docs\DocDiff\DocDiff.csproj" />
Tooling to create reference documentation, using the open source Sandcastle tool
2014-08-12 08:37:27 +04:00
<AnyCPUProject Include="tools\docs\ExtractAPISurface\ExtractAPISurface.csproj" />
Support Visual Studio IntelliSense New MergeIntellisense tool merges the various XML files from the docsrc folders to create a single combined XML per DLL. These are included in the NuGet packages, so Visual Studio will automatically pick up all our documentation comments (once written) from the same master format that generates Sandcastle reference docs.
2014-08-12 08:55:09 +04:00
<AnyCPUProject Include="tools\docs\MergeIntellisense\MergeIntellisense.csproj" />
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</ItemGroup>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<!-- Master target just chains to a bunch of workers -->
<Target Name="Build"
Tooling to create reference documentation, using the open source Sandcastle tool
2014-08-12 08:37:27 +04:00
DependsOnTargets="BuildProjects; CheckCopyrightBanners; BuildDocs; RunTests" />
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<!-- Use batching to build each project in turn -->
<Target Name="BuildProjects"
Include version info in DLLs and NuGet packages This change: - Includes a text file containing the SHA-1 hash of the git HEAD version that the code was built from in the NuGet packages - Includes both the latest Win2D version number and git SHA-1 hash in the DLL metadata for output binaries - Cleans up a bunch of stale and inconsistent stuff in AssemblyInfo.cs The version number is only stamped into DLLs when building via win2d.proj, not when using Visual Studio, and only goes into the binaries we intend to ship (Microsoft.Graphics.Canvas.dll and Microsoft.Graphics.Canvas.Numerics.dll).
2014-10-31 00:45:51 +03:00
DependsOnTargets="PrepareVersionInfo; ChooseProjectsToBuild"
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
Inputs="@(ProjectsToBuild)"
Outputs="%(PlatformIndependentName)">
<Message Importance="High" Text="Building all variants of project %(ProjectsToBuild.PlatformIndependentName):" />
<Message Importance="High" Text=" %(ProjectsToBuild.Filename) (%(ProjectsToBuild.Configuration)|%(ProjectsToBuild.Platform))" />
<!-- All the variants (platform and configuration) of a project can be built in parallel -->
Include version info in DLLs and NuGet packages This change: - Includes a text file containing the SHA-1 hash of the git HEAD version that the code was built from in the NuGet packages - Includes both the latest Win2D version number and git SHA-1 hash in the DLL metadata for output binaries - Cleans up a bunch of stale and inconsistent stuff in AssemblyInfo.cs The version number is only stamped into DLLs when building via win2d.proj, not when using Visual Studio, and only goes into the binaries we intend to ship (Microsoft.Graphics.Canvas.dll and Microsoft.Graphics.Canvas.Numerics.dll).
2014-10-31 00:45:51 +03:00
<MSBuild Projects="@(ProjectsToBuild)" BuildInParallel="true" Properties="IncludeVersionInfo=true" />
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
</Target>
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
<Target Name="ChooseProjectsToBuild">
<ItemGroup>
<!-- Expand parameter properties into item groups, so we can batch over them -->
<BuildPlatform Include="$(BuildPlatforms)" />
<BuildConfiguration Include="$(BuildConfigurations)" />
<!-- Generate the cartesian product of all projects * all platforms we are building -->
<CandidateProjects Include="@(WindowsProject);@(PhoneProject);@(AnyCPUProject)">
<Platform>%(BuildPlatform.Identity)</Platform>
</CandidateProjects>
<!-- Filter the list to include only project/platform pairs where the project actually supports that platform -->
<FilteredProjects Include="@(CandidateProjects)" Condition="$([System.String]::new('%(CandidateProjects.Platforms)').Contains('%(CandidateProjects.Platform)'))" />
<!-- Generate the cartesian product of our filtered project list * the configurations we are building -->
<ProjectsPerConfig Include="@(FilteredProjects)">
<Configuration>%(BuildConfiguration.Identity)</Configuration>
</ProjectsPerConfig>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<!-- Move platform and configuration into the AdditionalProperties metadata, and generate a
platform independent name that will be the same for Windows and Phone project variants -->
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
<ProjectsToBuild Include="@(ProjectsPerConfig)">
<AdditionalProperties>Platform=%(ProjectsPerConfig.Platform);Configuration=%(ProjectsPerConfig.Configuration)</AdditionalProperties>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<PlatformIndependentName>$([System.String]::new('%(ProjectsPerConfig.Filename)').Replace('Windows', '').Replace('Phone', '').TrimEnd('.'))</PlatformIndependentName>
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</ProjectsToBuild>
</ItemGroup>
</Target>
Include version info in DLLs and NuGet packages This change: - Includes a text file containing the SHA-1 hash of the git HEAD version that the code was built from in the NuGet packages - Includes both the latest Win2D version number and git SHA-1 hash in the DLL metadata for output binaries - Cleans up a bunch of stale and inconsistent stuff in AssemblyInfo.cs The version number is only stamped into DLLs when building via win2d.proj, not when using Visual Studio, and only goes into the binaries we intend to ship (Microsoft.Graphics.Canvas.dll and Microsoft.Graphics.Canvas.Numerics.dll).
2014-10-31 00:45:51 +03:00
<Target Name="PrepareVersionInfo">
<MakeDir Directories="obj" />
<!-- Read the current Win2D version number -->
<ReadLinesFromFile File="build\nuget\VERSION">
<Output TaskParameter="Lines" PropertyName="Win2DVersion" />
</ReadLinesFromFile>
<!-- Read the SHA-1 hash for git HEAD, so we can later identify exactly what code went into this build -->
<Exec Command="git rev-parse --verify HEAD &gt; obj\Win2D.githash.txt" IgnoreExitCode="true">
<Output TaskParameter="ExitCode" PropertyName="GitExitCode" />
</Exec>
<WriteLinesToFile Condition="$(GitExitCode) != 0" File ="obj\Win2D.githash.txt" Lines="unknown git hash" />
<ReadLinesFromFile File="obj\Win2D.githash.txt">
<Output TaskParameter="Lines" PropertyName="GitHash" />
</ReadLinesFromFile>
<!-- Generate AssemblyVersion.cs, which adds the latest version info to managed assembly outputs -->
<ItemGroup>
<AssemblyVersionCode Include="[assembly: System.Reflection.AssemblyVersion(&quot;$(Win2DVersion)&quot;)]" />
<AssemblyVersionCode Include="[assembly: System.Reflection.AssemblyFileVersion(&quot;$(Win2DVersion)&quot;)]" />
<AssemblyVersionCode Include="[assembly: System.Reflection.AssemblyInformationalVersionAttribute(&quot;$(Win2DVersion) ($(GitHash))&quot;)]" />
</ItemGroup>
<ReadLinesFromFile File="obj\AssemblyVersion.cs">
<Output TaskParameter="Lines" ItemName="ExistingAssemblyVersion" />
</ReadLinesFromFile>
<WriteLinesToFile Condition="@(AssemblyVersionCode) != @(ExistingAssemblyVersion)" File="obj\AssemblyVersion.cs" Lines="@(AssemblyVersionCode)" Overwrite="true" />
<!-- Also generate DllVersion.h, which adds version info to native DLLs -->
<ItemGroup>
<DllVersionCode Include="#define DLL_VERSION $(Win2DVersion.Replace('.', ','))" />
<DllVersionCode Include="#define DLL_VERSION_STRING &quot;$(Win2DVersion)&quot;" />
<DllVersionCode Include="#define DLL_VERSION_STRING_LONG &quot;$(Win2DVersion) ($(GitHash))&quot;" />
</ItemGroup>
<ReadLinesFromFile File="obj\DllVersion.h">
<Output TaskParameter="Lines" ItemName="ExistingDllVersion" />
</ReadLinesFromFile>
<WriteLinesToFile Condition="@(DllVersionCode) != @(ExistingDllVersion)" File="obj\DllVersion.h" Lines="@(DllVersionCode)" Overwrite="true" />
</Target>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<!-- Make sure all our source files have the right copyright -->
<Target Name="CheckCopyrightBanners"
Condition="$(BuildTools) and $(BuildPlatforms.Contains('AnyCPU')) and $(BuildConfigurations.Contains('Release'))">
<Message Importance="High" Text="Checking copyright banners" />
<MSBuild Projects="tools\copyright\CheckCopyrightBanners.proj" />
</Target>
Tooling to create reference documentation, using the open source Sandcastle tool
2014-08-12 08:37:27 +04:00
<!-- Build the reference documentation -->
<Target Name="BuildDocs"
Condition="$(BuildDocs) and
$(BuildTools) and
$(BuildWindows) and
$(BuildPlatforms.Contains('AnyCPU')) and
$(BuildPlatforms.Contains('Win32')) and
$(BuildConfigurations.Contains('Release'))">
<Message Importance="High" Text="Building documentation" />
<MSBuild Projects="tools\docs\BuildDocs.proj" />
</Target>
A bunch of small fixes and improvements to the build system. 1) canvas.proj now performs the copyright banner check and runs all automated tests, so it really is a one-stop-shop for doing everything. 2) Removed the now-obsolete BuildAndTestAllConfigs.cmd (canvas.proj now does exactly what it was intended to) 3) Refactored build-nupkg.cmd and build.cmd so build-nupkg.cmd now only handles the nuget packaging stuff, assuming the code has already been built. The root build.cmd file builds code and then calls build-nupkg.cmd. Previously, build.cmd just called build-nupkg.cmd, which would both build and package the code. 4) canvas.proj now parallelizes across multiple flavors of each project, removing the build phase concept. I think we still have some bugs here, but there are fewer collisions due to parallel builds writing the same files now (at the cost of ~30 seconds slower build time overall). 5) Copyright tool uses more consistent error/warning output formats so MSBuild can parse these properly. 6) Fixed C# app package output location so these get written to the proper bin location.
2014-07-26 01:52:36 +04:00
<!-- Run the automated tests -->
<Target Name="RunTests"
Condition="$(BuildTests) and $(RunTests)"
DependsOnTargets="ChooseProjectsToBuild; ChooseTestsToRun"
Inputs="@(TestProjects)"
Outputs="%(TestProjects.TestAppX)">
<Message Importance="High" Text="Running tests: %(TestProjects.Filename) (%(TestProjects.Configuration)|%(TestProjects.Platform))" />
<Exec Command="vstest.console %(TestProjects.TestBinary)%(TestProjects.TestArgs)" ContinueOnError="ErrorAndContinue" IgnoreStandardErrorWarningFormat="true" />
</Target>
<Target Name="ChooseTestsToRun">
<ItemGroup>
<TestProjects Include="@(ProjectsToBuild)" Condition="%(ProjectsToBuild.AutomatedTests) != '' and %(ProjectsToBuild.Platform) != ARM">
<!-- Remap Win32 to x86 -->
<TestPlatform Condition="%(ProjectsToBuild.Platform) == Win32">x86</TestPlatform>
<TestPlatform Condition="%(ProjectsToBuild.Platform) != Win32">%(ProjectsToBuild.Platform)</TestPlatform>
<!-- Work out where the test binaries are located -->
<TestPath>bin\Windows%(TestProjects.TestPlatform)\%(ProjectsToBuild.Configuration)</TestPath>
<TestAppX Condition="%(ProjectsToBuild.Configuration) == Release">%(ProjectsToBuild.Filename)_1.0.0.0_%(ProjectsToBuild.Platform)</TestAppX>
<TestAppX Condition="%(ProjectsToBuild.Configuration) != Release">%(ProjectsToBuild.Filename)_1.0.0.0_%(ProjectsToBuild.Platform)_%(ProjectsToBuild.Configuration)</TestAppX>
<!-- Binaries can be either a .dll for desktop tests, or .appx for store app tests -->
<TestBinary Condition="%(ProjectsToBuild.AutomatedTests) == desktop">%(TestProjects.TestPath)\%(ProjectsToBuild.Filename)\%(ProjectsToBuild.Filename).dll</TestBinary>
<TestBinary Condition="%(ProjectsToBuild.AutomatedTests) == store">%(TestProjects.TestPath)\%(ProjectsToBuild.Filename)\AppPackages\%(TestProjects.TestAppX)_Test\%(TestProjects.TestAppX).appx</TestBinary>
<!-- Do we need the /Platform or /InIsolation arguments for this test project? -->
<TestArgs Condition="%(ProjectsToBuild.Platform) == x64">%(TestProjects.TestArgs) /Platform:x64</TestArgs>
<TestArgs Condition="%(ProjectsToBuild.Platform) == x64 or %(ProjectsToBuild.AutomatedTests) == store">%(TestProjects.TestArgs) /InIsolation</TestArgs>
</TestProjects>
</ItemGroup>
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</Target>
Tooling to create reference documentation, using the open source Sandcastle tool
2014-08-12 08:37:27 +04:00
Add master msbuild project for building all permutations of project * platform * configuration in one go
2014-07-18 03:32:19 +04:00
</Project>