public override void SaveProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject project)
{
EnsureNuGetPackageBuildImportsTargetUpdater currentUpdater = Updater;
if (currentUpdater != null) {
currentUpdater.UpdateProject (project);
}
}
protected override void LoadProject (IProgressMonitor monitor, MSBuildProject msproject)
{
var doc = msproject.Document;
projitemsFile = null;
foreach (var no in doc.DocumentElement.ChildNodes) {
var im = no as XmlElement;
if (im != null && im.LocalName == "Import" && im.GetAttribute ("Label") == "Shared") {
projitemsFile = im.GetAttribute ("Project");
break;
}
}
if (projitemsFile == null)
return;
// TODO: load the type from msbuild
((SharedAssetsProject)EntityItem).LanguageName = "C#";
projitemsFile = Path.Combine (Path.GetDirectoryName (msproject.FileName), projitemsFile);
MSBuildProject p = new MSBuildProject ();
p.Load (projitemsFile);
MSBuildSerializer ser = CreateSerializer ();
ser.SerializationContext.BaseFile = EntityItem.FileName;
ser.SerializationContext.ProgressMonitor = monitor;
Item.SetItemHandler (this);
var cp = p.PropertyGroups.FirstOrDefault (g => g.Label == "Configuration");
if (cp != null)
((SharedAssetsProject)EntityItem).DefaultNamespace = cp.GetPropertyValue ("Import_RootNamespace");
LoadProjectItems (p, ser, ProjectItemFlags.None);
}
public override void LoadProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject msproject)
{
base.LoadProject (monitor, item, msproject);
var dnp = item as DotNetProject;
if (dnp == null)
return;
// Convert .projitems imports into project references
foreach (var sp in msproject.Imports.Where (im => im.Label == "Shared" && im.Project.EndsWith (".projitems"))) {
var projitemsFile = sp.Project;
if (!string.IsNullOrEmpty (projitemsFile)) {
projitemsFile = MSBuildProjectService.FromMSBuildPath (item.ItemDirectory, projitemsFile);
projitemsFile = Path.Combine (Path.GetDirectoryName (msproject.FileName), projitemsFile);
if (File.Exists (projitemsFile)) {
MSBuildSerializer iser = Handler.CreateSerializer ();
iser.SerializationContext.BaseFile = projitemsFile;
iser.SerializationContext.ProgressMonitor = monitor;
MSBuildProject p = new MSBuildProject ();
p.Load (projitemsFile);
Handler.LoadProjectItems (p, iser, ProjectItemFlags.Hidden | ProjectItemFlags.DontPersist);
var r = new ProjectReference (ReferenceType.Project, Path.GetFileNameWithoutExtension (projitemsFile));
r.Flags = ProjectItemFlags.DontPersist;
r.SetItemsProjectPath (projitemsFile);
dnp.References.Add (r);
}
}
}
}
protected override MSBuildProject SaveProject (IProgressMonitor monitor)
{
MSBuildSerializer ser = CreateSerializer ();
ser.SerializationContext.BaseFile = EntityItem.FileName;
ser.SerializationContext.ProgressMonitor = monitor;
MSBuildProject projitemsProject = new MSBuildProject ();
MSBuildProject msproject = new MSBuildProject ();
var newProject = EntityItem.FileName == null || !File.Exists (EntityItem.FileName);
if (newProject) {
var grp = msproject.GetGlobalPropertyGroup ();
if (grp == null)
grp = msproject.AddNewPropertyGroup (false);
grp.SetPropertyValue ("ProjectGuid", EntityItem.ItemId, false);
var import = msproject.AddNewImport (@"$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props");
import.Condition = @"Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')";
msproject.AddNewImport (@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props");
msproject.AddNewImport (@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props");
import = msproject.AddNewImport (Path.ChangeExtension (EntityItem.FileName.FileName, ".projitems"));
import.Label = "Shared";
msproject.AddNewImport (@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets");
} else {
msproject.Load (EntityItem.FileName);
}
// having no ToolsVersion is equivalent to 2.0, roundtrip that correctly
if (ToolsVersion != "2.0")
msproject.ToolsVersion = ToolsVersion;
else if (string.IsNullOrEmpty (msproject.ToolsVersion))
msproject.ToolsVersion = null;
else
msproject.ToolsVersion = "2.0";
if (projitemsFile == null)
projitemsFile = ((SharedAssetsProject)Item).ProjItemsPath;
if (File.Exists (projitemsFile)) {
projitemsProject.Load (projitemsFile);
} else {
var grp = projitemsProject.AddNewPropertyGroup (true);
grp.SetPropertyValue ("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)", false);
grp.SetPropertyValue ("HasSharedItems", "true", false);
grp.SetPropertyValue ("SharedGUID", EntityItem.ItemId, false);
}
var configGrp = projitemsProject.PropertyGroups.FirstOrDefault (g => g.Label == "Configuration");
if (configGrp == null) {
configGrp = projitemsProject.AddNewPropertyGroup (true);
configGrp.Label = "Configuration";
}
configGrp.SetPropertyValue ("Import_RootNamespace", ((SharedAssetsProject)EntityItem).DefaultNamespace, false);
SaveProjectItems (monitor, new MSBuildFileFormatVS12 (), ser, projitemsProject, "$(MSBuildThisFileDirectory)");
projitemsProject.Save (projitemsFile);
return msproject;
}
public static void AddImportIfMissing(
this DotNetProject project,
string importedProjectFile,
ProjectImportLocation importLocation)
{
var msbuildProject = new MSBuildProject ();
msbuildProject.Load (project.FileName);
msbuildProject.AddImportIfMissing (importedProjectFile, importLocation, GetCondition (importedProjectFile));
msbuildProject.Save (project.FileName);
}
public void Merge (MSBuildProject originalMSBuildProject)
{
this.originalMSBuildProject = originalMSBuildProject;
int msbuildProjectImportCount = msbuildProject.Xml.Imports.Count;
int dotProjectImportCount = originalMSBuildProject.Imports.Count ();
if (msbuildProjectImportCount > dotProjectImportCount) {
AddNewImports ();
} else if (msbuildProjectImportCount < dotProjectImportCount) {
RemoveMissingImports ();
}
}
public override void SaveProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject project)
{
try {
MSBuildProjectImportsMerger merger = ImportsMerger;
if (merger != null) {
merger.Merge (project);
}
} finally {
ImportsMerger = null;
}
}
public bool Migrate (IProjectLoadProgressMonitor monitor, MSBuildProject project, string fileName, string language)
{
// Migrate 'Page' build action to 'InterfaceDefinition' (see Bug 147 - XIB files need Build Action other than Page)
// NOTE: Work around mono bug by calling ToList() before iterating: http://bugzilla.xamarin.com/show_bug.cgi?id=520
foreach (var item in project.GetAllItems ().Where (item => item.Name == "Page").ToList ()) {
var newElement = project.doc.CreateElement (BuildAction.InterfaceDefinition);
newElement.InnerXml = item.Element.InnerXml;
foreach (System.Xml.XmlAttribute attribute in item.Element.Attributes)
newElement.SetAttribute (attribute.Name, attribute.Value);
item.Element.ParentNode.ReplaceChild (newElement, item.Element);
}
return true;
}
public bool Migrate (MSBuildProject project, string fileName, string language)
{
var buttonBackupAndMigrate = new AlertButton (GettextCatalog.GetString ("Back up and migrate"));
var buttonMigrate = new AlertButton (GettextCatalog.GetString ("Migrate"));
var buttonIgnore = new AlertButton (GettextCatalog.GetString ("Ignore"));
var response = MessageService.AskQuestion (
GettextCatalog.GetString ("Migrate MonoMac Project?"),
GettextCatalog.GetString (
"The MonoMac project '{0}' must be migrated to a new format. " +
"After migration, it will not be able to be opened in " +
"older versions of MonoDevelop.\n\n" +
"If you choose to back up the project before migration, a copy of the project " +
"file will be saved in a 'backup' directory in the project directory.", Path.GetFileNameWithoutExtension (fileName)),
buttonIgnore, buttonMigrate, buttonBackupAndMigrate);
if (response == buttonIgnore)
return false;
FilePath baseDir = Path.GetDirectoryName (fileName);
bool backup = response == buttonBackupAndMigrate;
if (backup) {
var backupDirFirst = baseDir.Combine ("backup");
string backupDir = backupDirFirst;
int i = 0;
while (Directory.Exists (backupDir)) {
backupDir = backupDirFirst + "-" + i.ToString ();
if (i > 20) {
throw new Exception ("Too many backup directories");
}
}
Directory.CreateDirectory (backupDir);
File.Copy (fileName, Path.Combine (backupDir, Path.GetFileName (fileName)));
}
// Migrate 'Page' build action to 'InterfaceDefinition' (see Bug 147 - XIB files need Build Action other than Page)
// NOTE: Work around mono bug by calling ToList() before iterating: http://bugzilla.xamarin.com/show_bug.cgi?id=520
foreach (var item in project.GetAllItems ().Where (item => item.Name == "Page").ToList ()) {
var newElement = project.doc.CreateElement (BuildAction.InterfaceDefinition);
newElement.InnerXml = item.Element.InnerXml;
foreach (System.Xml.XmlAttribute attribute in item.Element.Attributes)
newElement.SetAttribute (attribute.Name, attribute.Value);
item.Element.ParentNode.ReplaceChild (newElement, item.Element);
}
return true;
}
public void UpdateProject (MSBuildProject project)
{
if (importToRemove == null)
return;
MSBuildTarget nugetImportTarget = FindNuGetImportTarget (project);
if (nugetImportTarget == null)
return;
MSBuildTask msbuildTask = FindErrorTaskForImport (nugetImportTarget, importToRemove);
if (msbuildTask == null)
return;
RemoveFromProject (msbuildTask.Element);
if (nugetImportTarget.Tasks.Count () == 0) {
RemoveFromProject (nugetImportTarget.Element);
}
}
public override void SaveProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject project)
{
base.SaveProject (monitor, item, project);
var dnp = item as DotNetProject;
if (dnp == null)
return;
HashSet<string> validProjitems = new HashSet<string> ();
foreach (var r in dnp.References.Where (rp => rp.ReferenceType == ReferenceType.Project)) {
var ip = r.GetItemsProjectPath ();
if (!string.IsNullOrEmpty (ip)) {
ip = MSBuildProjectService.ToMSBuildPath (item.ItemDirectory, ip);
validProjitems.Add (ip);
if (!project.Imports.Any (im => im.Project == ip)) {
var im = project.AddNewImport (ip, project.Imports.FirstOrDefault (i => i.Label != "Shared"));
im.Label = "Shared";
im.Condition = "Exists('" + ip + "')";
}
}
}
foreach (var im in project.Imports) {
if (im.Label == "Shared" && im.Project.EndsWith (".projitems") && !(validProjitems.Contains (im.Project)))
project.RemoveImport (im.Project);
}
}
public MSBuildPropertyGroup(MSBuildProject parent, XmlElement elem) : base(elem)
{
this.parent = parent;
}
MSBuildProject CreateMSBuildProject()
{
msbuildProject = new MSBuildProject ();
msbuildProject.ToolsVersion = "14.0";
msbuildProject.DefaultTargets = "Build";
string projectGuid = GetProjectGuid (dnxProject.ItemId);
string rootNamespace = dnxProject.DefaultNamespace;
AddVisualStudioProperties ();
AddDnxProps ();
AddGlobalsProperties (projectGuid, rootNamespace);
AddSchemaVersion ();
AddDnxTargets ();
return msbuildProject;
}
public virtual void SaveProject(SolutionEntityItem item, MSBuildProject project)
{
}
void CreateMSBuildProject (string xml)
{
msbuildProject = new MSBuildProject ();
msbuildProject.Document.LoadXml (xml);
}
MSBuildProject CreateMSBuildProject (string xml)
{
var msbuildProject = new MSBuildProject ();
msbuildProject.Document.LoadXml (xml);
return msbuildProject;
}
public virtual void SaveProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject project)
{
}
public virtual void SaveProject(IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject project)
{
}
static MSBuildTarget FindNuGetImportTarget (MSBuildProject project)
{
return project.Targets
.FirstOrDefault (target => IsMatchIgnoringCase (target.Name, NuGetTargetName));
}
public virtual void SaveProject (SolutionEntityItem item, MSBuildProject project)
{
}
internal MSBuildItemGroup(MSBuildProject parent, XmlElement elem) : base(elem)
{
this.parent = parent;
}
internal void InitEvaluation (MSBuildProject project)
{
this.project = project;
SetPropertyValue ("MSBuildThisFile", Path.GetFileName (project.FileName));
SetPropertyValue ("MSBuildThisFileName", Path.GetFileNameWithoutExtension (project.FileName));
SetPropertyValue ("MSBuildThisFileDirectory", Path.GetDirectoryName (project.FileName) + Path.DirectorySeparatorChar);
SetPropertyValue ("MSBuildThisFileExtension", Path.GetExtension (project.FileName));
SetPropertyValue ("MSBuildThisFileFullPath", Path.GetFullPath (project.FileName));
SetPropertyValue ("VisualStudioReferenceAssemblyVersion", project.ToolsVersion + ".0.0");
}
public MSBuildPropertyGroup (MSBuildProject parent, XmlElement elem): base (elem)
{
this.parent = parent;
foreach (var pelem in Element.ChildNodes.OfType<XmlElement> ()) {
MSBuildProperty prevSameName;
if (properties.TryGetValue (pelem.Name, out prevSameName))
prevSameName.Overwritten = true;
var prop = new MSBuildProperty (pelem);
propertyList.Add (prop);
properties [pelem.Name] = prop; // If a property is defined more than once, we only care about the last registered value
}
}
public MSBuildEvaluationContext (MSBuildProject project)
{
this.project = project;
}
public MSBuildPropertyGroup (MSBuildProject parent, XmlElement elem): base (elem)
{
this.parent = parent;
}
public static void RemoveImport(this DotNetProject project, string importedProjectFile)
{
var msbuildProject = new MSBuildProject ();
msbuildProject.Load (project.FileName);
msbuildProject.RemoveImportIfExists (importedProjectFile);
msbuildProject.Save (project.FileName);
}
static string LoadProjectTypeGuids (string fileName)
{
MSBuildProject project = new MSBuildProject ();
project.Load (fileName);
MSBuildPropertySet globalGroup = project.GetGlobalPropertyGroup ();
if (globalGroup == null)
return null;
return globalGroup.GetPropertyValue ("ProjectTypeGuids");
}
static bool UpgradeMonoGameProject (MonoDevelop.Core.IProgressMonitor monitor, MonoDevelop.Projects.SolutionEntityItem item, MSBuildProject project)
{
bool needsSave = false;
bool containsMGCB = project.ItemGroups.Any (x => x.Items.Any (i => System.IO.Path.GetExtension (i.Include) == ".mgcb"));
bool isMonoGame = project.PropertyGroups.Any (x => x.Properties.Any (p => p.Name == "MonoGamePlatform")) ||
project.ItemGroups.Any (x => x.Items.Any (i => i.Name == "Reference" && i.Include == "MonoGame.Framework")) ||
containsMGCB;
bool isApplication = project.PropertyGroups.Any (x => x.Properties.Any (p => p.Name == "OutputType" && p.GetValue () == "Exe")) ||
project.PropertyGroups.Any (x => x.Properties.Any (p => p.Name == "AndroidApplication" && string.Compare (p.GetValue (), bool.TrueString, true)==0));
bool isShared = project.PropertyGroups.Any (x => x.Properties.Any (p => p.Name == "HasSharedItems" && p.GetValue () == "true"));
var type = item.GetType ().Name;
monitor.Log.WriteLine ("Found {0}", type);
var platform = Environment.OSVersion.Platform == PlatformID.Win32NT ? "Windows" : "DesktopGL";
var path = MonoGameExtensionsPath;
switch (type) {
case "XamarinIOSProject":
platform = "iOS";
break;
case "MonoDroidProject":
platform = "Android";
break;
case "XamMac2Project":
case "MonoGameProject":
platform = "DesktopGL";
break;
case "XamMac":
case "XamMacProject":
platform = "DesktopGL";
// Xamarin.Mac Classic does not use MSBuild so we need to absolute path.
path = MonoGameExtensionsAbsolutePath;
break;
case "MonoMac":
case "MonoMacProject":
platform = "MacOSX";
// Xamarin.Mac Classic does not use MSBuild so we need to absolute path.
path = MonoGameExtensionsAbsolutePath;
break;
}
monitor.Log.WriteLine ("Platform = {0}", platform);
monitor.Log.WriteLine ("Path = {0}", path);
monitor.Log.WriteLine ("isMonoGame {0}", isMonoGame);
if (isMonoGame) {
var ritems = new List<MSBuildItem> ();
foreach (var ig in project.ItemGroups) {
foreach (var i in ig.Items.Where (x => x.Name == "Reference" && x.Include == "MonoGame.Framework")) {
if (!i.HasMetadata ("HintPath")) {
monitor.Log.WriteLine ("Fixing {0} to be MonoGameContentReference", i.Include);
var a = ig.AddNewItem ("Reference", i.Include);
a.SetMetadata ("HintPath", string.Format (path, platform, "MonoGame.Framework.dll"));
ritems.Add (i);
needsSave = true;
}
}
foreach (var i in ig.Items.Where (x => x.Name == "Reference" && x.Include == "Tao.Sdl")) {
if (!i.HasMetadata ("HintPath")) {
monitor.Log.WriteLine ("Fixing {0} to be Tao.Sdl", i.Include);
var a = ig.AddNewItem ("Reference", i.Include);
a.SetMetadata ("HintPath", string.Format (path, platform, "Tao.Sdl.dll"));
ritems.Add (i);
needsSave = true;
}
}
foreach (var i in ig.Items.Where (x => x.Name == "Reference" && x.Include.StartsWith ("OpenTK") &&
(platform != "iOS" && platform != "Android"))) {
if (!i.HasMetadata ("HintPath")) {
monitor.Log.WriteLine ("Fixing {0} to be OpenTK", i.Include);
var a = ig.AddNewItem ("Reference", i.Include);
a.SetMetadata ("HintPath", string.Format (path, platform, "OpenTK.dll"));
a.SetMetadata ("SpecificVersion", "true");
ritems.Add (i);
needsSave = true;
}
}
foreach (var i in ig.Items.Where (x => x.Name == "Reference" && x.Include == "NVorbis")) {
if (!i.HasMetadata ("HintPath")) {
monitor.Log.WriteLine ("Fixing {0} to be NVorbis", i.Include);
var a = ig.AddNewItem ("Reference", i.Include);
a.SetMetadata ("HintPath", string.Format (path, platform, "NVorbis.dll"));
ritems.Add (i);
needsSave = true;
}
}
}
foreach (var a in ritems) {
project.RemoveItem (a);
}
var dotNetProject = item as DotNetProject;
if (dotNetProject != null && (type == "MonoMacProject" || type == "XamMacProject" )) {
var items = new List<ProjectReference> ();
var newitems = new List<ProjectReference> ();
foreach (var reference in dotNetProject.References) {
if (reference.Reference == "MonoGame.Framework" && string.IsNullOrEmpty (reference.HintPath)) {
items.Add (reference);
newitems.Add (new ProjectReference (ReferenceType.Assembly, reference.Reference, string.Format (path, platform, "MonoGame.Framework.dll")));
}
if (reference.Reference.StartsWith ("OpenTK") && string.IsNullOrEmpty (reference.HintPath)) {
items.Add (reference);
newitems.Add (new ProjectReference (ReferenceType.Assembly, reference.Reference, string.Format (path, platform, "OpenTK.dll")));
}
if (reference.Reference == "NVorbis" && string.IsNullOrEmpty (reference.HintPath)) {
items.Add (reference);
newitems.Add (new ProjectReference (ReferenceType.Assembly, reference.Reference, string.Format (path, platform, "NVorbis.dll")));
}
if (reference.Reference == "Tao.Sdl" && string.IsNullOrEmpty (reference.HintPath)) {
items.Add (reference);
newitems.Add (new ProjectReference (ReferenceType.Assembly, reference.Reference, string.Format (path, platform, "Tao.Sdl.dll")));
}
}
dotNetProject.References.RemoveRange (items);
dotNetProject.References.AddRange (newitems);
}
}
if (isMonoGame && containsMGCB && (isApplication || isShared)) {
if (!project.PropertyGroups.Any (x => x.Properties.Any (p => p.Name == "MonoGamePlatform")) && !isShared) {
monitor.Log.WriteLine ("Adding MonoGamePlatform", platform);
project.PropertyGroups.First ().SetPropertyValue ("MonoGamePlatform", platform, true);
needsSave = true;
}
if (!project.Imports.Any (x => x.Project.StartsWith (MonoGameCommonProps, StringComparison.OrdinalIgnoreCase))&& !isShared) {
monitor.Log.WriteLine ("Adding MonoGame.Common.props Import");
var e = project.Document.DocumentElement;
var manager = new XmlNamespaceManager (new NameTable ());
var schema = "http://schemas.microsoft.com/developer/msbuild/2003";
manager.AddNamespace ("tns", schema);
var import = project.Document.CreateElement ("Import", schema);
import.SetAttribute ("Project", MonoGameCommonProps);
import.SetAttribute ("Condition", string.Format ("Exists('{0}')", MonoGameCommonProps));
project.Document.DocumentElement.InsertBefore (import, project.Document.DocumentElement.FirstChild);
needsSave = true;
}
if (containsMGCB) {
var ritems = new List<MSBuildItem> ();
foreach (var ig in project.ItemGroups) {
foreach (var i in ig.Items.Where (x => System.IO.Path.GetExtension (x.Include) == ".mgcb")) {
if (i.Name != "MonoGameContentReference" && i.Name == "None") {
monitor.Log.WriteLine ("Fixing {0} to be MonoGameContentReference", i.Include);
ig.AddNewItem ("MonoGameContentReference", i.Include);
ritems.Add (i);
needsSave = true;
}
}
}
foreach (var a in ritems) {
project.RemoveItem (a);
}
}
if (!project.Imports.Any (x => x.Project.StartsWith (MonoGameContentBuildTargets, StringComparison.OrdinalIgnoreCase)) && !isShared) {
monitor.Log.WriteLine ("Adding MonoGame Content Builder .targets");
project.AddNewImport (MonoGameContentBuildTargets);
needsSave = true;
}
}
return needsSave;
}
void CreateProject ()
{
project = new MSBuildProject ();
}
public override void SaveProject (MonoDevelop.Core.IProgressMonitor monitor, MonoDevelop.Projects.SolutionEntityItem item, MSBuildProject project)
{
var changed = UpgradeMonoGameProject (monitor, item, project);
base.SaveProject (monitor, item, project);
if (changed) {
this.LoadProject (monitor, item, project);
}
}
internal MSBuildItemGroup (MSBuildProject parent, XmlElement elem): base (elem)
{
this.parent = parent;
}
public MSBuildEvaluationContext(MSBuildProject project)
{
this.project = project;
}
