internal static void AddSyncedProject(VSHelpers.Projects.ProjectBase vsp)
{
mSyncedProjects.Add(vsp);
PluginManager.ReactToSyncedProjectLoad(vsp);
}
public override void SyncTo(ProjectBase projectBase, bool performTranslation)
{
throw new NotImplementedException();
}
internal static void RemoveSyncedProject(VSHelpers.Projects.ProjectBase project)
{
mSyncedProjects.Remove(project);
}
private bool IsContentFile(ProjectItem bi, ProjectBase containingProject)
{
bool shouldSkipContent = false;
if (bi.ItemType == "Folder" || bi.ItemType == "_DebugSymbolsOutputPath" || bi.ItemType == "Reference")
{
// Skip trying to add the folder. We don't need to do this because if it
// contains anything, then the contained objects will automatically put themselves in a folder
shouldSkipContent = true;
}
if (!shouldSkipContent)
{
if (bi.ItemType != "Compile" && bi.ItemType != "None")
{
// but wait, the containing project may embed its content, so if so we need to check that
if (containingProject is CombinedEmbeddedContentProject &&
((CombinedEmbeddedContentProject)containingProject).DefaultContentAction == bi.ItemType)
{
// Looks like it really is content
shouldSkipContent = false;
}
else
{
shouldSkipContent = true;
}
}
}
if (!shouldSkipContent)
{
string extension = FileManager.GetExtension(bi.UnevaluatedInclude);
if (ExtensionsToIgnore.Contains(extension))
{
shouldSkipContent = true;
}
if (bi.ItemType == "Compile" && extension == "cs")
{
shouldSkipContent = true;
}
}
// Now that we have checked if we should process this, we want to check if we should exclude it
if (!shouldSkipContent)
{
var rfs = ObjectFinder.Self.GetReferencedFileSaveFromFile(bi.UnevaluatedInclude);
if (rfs != null && rfs.ProjectsToExcludeFrom.Contains(this.Name))
{
shouldSkipContent = true;
}
}
if (!shouldSkipContent)
{
string containingProjectContent = FileManager.Standardize(containingProject.ContentDirectory).ToLowerInvariant();
string standardUnevaluatedInclude = FileManager.Standardize(bi.UnevaluatedInclude).ToLowerInvariant();
shouldSkipContent = standardUnevaluatedInclude.StartsWith(containingProjectContent) == false;
}
return(!shouldSkipContent);
}
private void AddContentFileItemsFrom(ProjectBase projectBase)
{
var contentItemsToSync =
projectBase.ContentProject.EvaluatedItems.Where(item => IsContentFile(item, projectBase.ContentProject))
.ToList();
foreach (var bi in contentItemsToSync)
{
string absoluteFileName = projectBase.ContentProject.MakeAbsolute(bi.UnevaluatedInclude);
bool forceToContent = false;
if (projectBase.ContentCopiedToOutput)
{
forceToContent = !bi.HasMetadata("CopyToOutputDirectory") &&
CanBeContentType;
}
BuildItemMembershipType buildItemMembershipType = DefaultContentBuildType;
if (forceToContent)
{
buildItemMembershipType = BuildItemMembershipType.CompileOrContentPipeline;
}
else if (DefaultContentAction == "Content")
{
buildItemMembershipType = BuildItemMembershipType.Content;
}
if (!ContentProject.IsFilePartOfProject(absoluteFileName, buildItemMembershipType, true))
{
if (ContentProject.GetItem(absoluteFileName) != null)
{
ContentProject.RemoveItem(absoluteFileName);
}
ContentProject.AddContentBuildItem(absoluteFileName, SyncedProjectRelativeType.Linked, forceToContent);
}
var biOnThis = this.GetItem(absoluteFileName);
// Let's process the path to make sure it's matching the latest standards - like
// if we add additional restrictions at some point in Glue
if (biOnThis != null)
{
string includeBefore = biOnThis.UnevaluatedInclude;
string includeAfter = ProcessInclude(biOnThis.UnevaluatedInclude);
if (includeBefore != includeAfter)
{
// simply changing the Include doesn't make a project
// dirty, and we only want to make it dirty if we really
// did change something so that we don't unnecessarily save
// projects.
biOnThis.UnevaluatedInclude = includeAfter;
this.IsDirty = true;
}
string linkBefore = biOnThis.GetLink();
if (!string.IsNullOrEmpty(linkBefore))
{
string linkAfter = ProcessLink(linkBefore);
// If the original project is linking a file outside of
// its own file structure, then the Link value assigned on
// this BuildItem will include "..\". This is an invalid link
// value, so we'll instead try to use the same link as in the original
// file:
{
var linkOnOriginalBuildItem = bi.GetLink();
if (string.IsNullOrEmpty(linkOnOriginalBuildItem) == false)
{
// first let's make the link relative to the main project's content folder
var relativeToProject = FileManager.MakeRelative(linkOnOriginalBuildItem, projectBase.ContentProject.ContentDirectory);
linkAfter = this.ContentDirectory + relativeToProject;
linkAfter = ProcessLink(linkAfter);
}
}
if (linkBefore != linkAfter)
{
// simply changing the Link doesn't make a project
// dirty, and we only want to make it dirty if we really
// did change something so that we don't unnecessarily save
// projects.
biOnThis.SetLink(linkAfter);
this.IsDirty = true;
}
}
}
}
}
public abstract void SyncTo(ProjectBase projectBase, bool performTranslation);
public static CreateProjectResult CreateProject(string fileName)
{
//Project coreVisualStudioProject = new Project(fileName);
Project coreVisualStudioProject = null;
CreateProjectResult result = new CreateProjectResult();
var didErrorOccur = false;
try
{
try
{
coreVisualStudioProject = new Project(fileName, null, null, new ProjectCollection());
}
catch (Microsoft.Build.Exceptions.InvalidProjectFileException exception)
{
// This is a bug I haven't been able to figure out, but have asked about here:
// https://stackoverflow.com/questions/46384075/why-does-microsoft-build-framework-dll-15-3-not-load-csproj-15-1-does
// So I'm going to hack a fix by checking if this has to do with 15.0 vs the other versions:
var message = exception.Message;
if (exception.Message.Contains("\"15.0\"") && exception.Message.Contains("\"14.0\""))
{
coreVisualStudioProject = new Project(fileName, null, "14.0", new ProjectCollection());
}
else
{
throw exception;
}
}
}
catch (Microsoft.Build.Exceptions.InvalidProjectFileException exception)
{
didErrorOccur = true;
var exceptionMessage = exception.Message;
var shouldThrowException = true;
string locationToOpen = null;
bool isMissingMonoGame = exceptionMessage.Contains("MonoGame.Content.Builder.targets\"");
string message;
if (isMissingMonoGame)
{
message = $"Could not load the project {fileName}\nbecause MonoGame files are missing. Try installing MonoGame, then try opening the project in Glue again.\n\n";
locationToOpen = "http://teamcity.monogame.net/repository/download/MonoGame_PackagingWindows/latest.lastSuccessful/MonoGameSetup.exe?guest=1";
shouldThrowException = false;
result.ShouldTryToLoadProject = false;
}
else if (exceptionMessage.Contains("Novell.MonoDroid.CSharp.targets"))
{
message = "This project references Novell.MonoDroid.CSharp.targets, " +
"which is an old file that used to be installed by Xamarin, but which " +
"is now replaced by a different .targets file. You can fix this by editing " +
"the .csproj file and changing the reference to the Xamarin version. You can " +
" also look at a new FlatRedBall Android project to see what this looks like.";
result.ShouldTryToLoadProject = false;
}
else if (exceptionMessage.Contains("Xamarin.Android.CSharp.targets"))
{
message = @"Error loading this Android project. Please verify that you have correctly installed the requirements to build Android projects. Opening:
https://docs.microsoft.com/en-us/xamarin/android/get-started/installation/windows";
locationToOpen = "https://docs.microsoft.com/en-us/xamarin/android/get-started/installation/windows";
result.ShouldTryToLoadProject = false;
shouldThrowException = false;
}
else
{
message = $"Could not load the project {fileName}\n" +
$"Usually this occurs if the Visual Studio XNA plugin is not installed\n\n";
}
if (shouldThrowException)
{
throw new Exception(message, exception);
}
else
{
Plugins.ExportedImplementations.GlueCommands.Self.DialogCommands.ShowMessageBox(message);
if (locationToOpen != null)
{
System.Diagnostics.Process.Start(locationToOpen);
}
}
}
ProjectBase projectBase = null;
if (didErrorOccur == false)
{
projectBase = CreatePlatformSpecificProject(coreVisualStudioProject, fileName);
}
#if GLUE
// It may be null if the project is of an unknown type.
// We'll handle that problem outside of this function.
if (projectBase != null)
{
projectBase.Saving += FlatRedBall.Glue.IO.FileWatchManager.IgnoreNextChangeOnFile;
// Saving seems to cause 2 file changes, so we're going to ignore 2, what a hack!
projectBase.Saving += FlatRedBall.Glue.IO.FileWatchManager.IgnoreNextChangeOnFile;
}
#endif
result.Project = projectBase;
return(result);
}
private static ProjectBase TryGetProjectTypeFromDefineConstants(Project coreVisualStudioProject, out string message)
{
string preProcessorConstants = GetPreProcessorConstantsFromProject(coreVisualStudioProject);
//string sasfd = ProjectManager.LibrariesPath;
// Check for other platforms before checking for FRB_XNA because those projects
// include FRB_XNA in them
ProjectBase toReturn = null;
message = null;
var projectFilePath = new FilePath(coreVisualStudioProject.ProjectFileLocation.File);
var possibleStandardFile = new FilePath(projectFilePath.GetDirectoryContainingThis().GetDirectoryContainingThis() + "/GameStandard/GameStandard.csproj");
if (possibleStandardFile.Exists())
{
var standardProject = new Project(possibleStandardFile.FullPath, null, null, new ProjectCollection());
toReturn = new VisualStudioDotNetStandardProject(coreVisualStudioProject, standardProject);
}
else
{
List <PreprocessorAndFunc> loadCalls = new List <PreprocessorAndFunc>();
loadCalls.Add(new PreprocessorAndFunc("ANDROID", () => new AndroidProject(coreVisualStudioProject)));
loadCalls.Add(new PreprocessorAndFunc("IOS", () => new IosMonogameProject(coreVisualStudioProject)));
loadCalls.Add(new PreprocessorAndFunc("UWP", () => new UwpProject(coreVisualStudioProject)));
loadCalls.Add(new PreprocessorAndFunc("DESKTOP_GL", () => new DesktopGlProject(coreVisualStudioProject)));
// Do XNA_4 last, since every
// other project type has this
// preprocessor type, so every project
// type would return true here
loadCalls.Add(new PreprocessorAndFunc("XNA4", () => new Xna4Project(coreVisualStudioProject)));
// handled above, because it requires 2 projects to construct:
//loadCalls.Add(new PreprocessorAndFunc("Standard", () => new VisualStudioDotNetStandardProject(coreVisualStudioProject)));
foreach (var call in loadCalls)
{
if (preProcessorConstants.Contains(call.Preprocessor))
{
toReturn = call.Func();
break;
}
}
message = null;
if (toReturn == null)
{
message = $"Could not determine project type from preprocessor directives." +
$"\nThe project beign loaded has the folowing preprocessor directives\"{preProcessorConstants}\"" +
$"\nThe following are preprocessor directives to determine project type:";
foreach (var preprocessor in loadCalls)
{
message += "\n" + preprocessor.Preprocessor;
}
}
}
return(toReturn);
}