public ReferencedFileSave CreateReferencedFileSaveForExistingFile(IElement containerForFile, string directoryInsideContainer, string absoluteFileName,
PromptHandleEnum unknownTypeHandle, AssetTypeInfo ati, out string creationReport, out string errorMessage)
{
creationReport = "";
errorMessage = null;
ReferencedFileSave referencedFileSaveToReturn = null;
string whyItIsntValid;
// Let's see if there is already an Entity with the same name
string fileWithoutPath = FileManager.RemovePath(FileManager.RemoveExtension(absoluteFileName));
bool isValid =
NameVerifier.IsReferencedFileNameValid(fileWithoutPath, ati, referencedFileSaveToReturn, containerForFile, out whyItIsntValid);
if (!isValid)
{
errorMessage = "Invalid file name:\n" + fileWithoutPath + "\n" + whyItIsntValid;
}
else
{
Zipper.UnzipAndModifyFileIfZip(ref absoluteFileName);
string extension = FileManager.GetExtension(absoluteFileName);
bool isValidExtensionOrIsConfirmedByUser;
bool isUnknownType;
CheckAndWarnAboutUnknownFileTypes(unknownTypeHandle, extension, out isValidExtensionOrIsConfirmedByUser, out isUnknownType);
string fileToAdd = null;
if (isValidExtensionOrIsConfirmedByUser)
{
string directoryThatFileShouldBeRelativeTo = GetFullPathContentDirectory(containerForFile, directoryInsideContainer);
string projectDirectory = ProjectManager.ContentProject.GetAbsoluteContentFolder();
bool needsToCopy = !FileManager.IsRelativeTo(absoluteFileName, projectDirectory);
if (needsToCopy)
{
fileToAdd = directoryThatFileShouldBeRelativeTo + FileManager.RemovePath(absoluteFileName);
fileToAdd = FileManager.MakeRelative(fileToAdd, ProjectManager.ContentProject.GetAbsoluteContentFolder());
try
{
FileHelper.RecursivelyCopyContentTo(absoluteFileName,
FileManager.GetDirectory(absoluteFileName),
directoryThatFileShouldBeRelativeTo);
}
catch (System.IO.FileNotFoundException fnfe)
{
errorMessage = "Could not copy the files because of a missing file: " + fnfe.Message;
}
}
else
{
fileToAdd = GetNameOfFileRelativeToContentFolder(absoluteFileName, directoryThatFileShouldBeRelativeTo, projectDirectory);
}
}
if (string.IsNullOrEmpty(errorMessage))
{
BuildToolAssociation bta = null;
if (ati != null && !string.IsNullOrEmpty(ati.CustomBuildToolName))
{
bta =
BuildToolAssociationManager.Self.GetBuilderToolAssociationByName(ati.CustomBuildToolName);
}
if (containerForFile != null)
{
referencedFileSaveToReturn = containerForFile.AddReferencedFile(fileToAdd, ati, bta);
}
else
{
bool useFullPathAsName = false;
// todo - support built files here
referencedFileSaveToReturn = AddReferencedFileToGlobalContent(fileToAdd, useFullPathAsName);
}
// This will be null if there was an error above in creating this file
if (referencedFileSaveToReturn != null)
{
if (containerForFile != null)
{
containerForFile.HasChanged = true;
}
if (fileToAdd.EndsWith(".csv"))
{
string fileToAddAbsolute = ProjectManager.MakeAbsolute(fileToAdd);
CsvCodeGenerator.GenerateAndSaveDataClass(referencedFileSaveToReturn, referencedFileSaveToReturn.CsvDelimiter);
}
if (isUnknownType)
{
referencedFileSaveToReturn.LoadedAtRuntime = false;
}
GlueCommands.Self.ProjectCommands.UpdateFileMembershipInProject(referencedFileSaveToReturn);
PluginManager.ReactToNewFile(referencedFileSaveToReturn);
GluxCommands.Self.SaveGlux();
ProjectManager.SaveProjects();
UnreferencedFilesManager.Self.RefreshUnreferencedFiles(false);
string error;
referencedFileSaveToReturn.RefreshSourceFileCache(false, out error);
if (!string.IsNullOrEmpty(error))
{
ErrorReporter.ReportError(referencedFileSaveToReturn.Name, error, false);
}
}
}
}
return(referencedFileSaveToReturn);
}
public override object TryGetObjectFromFile(ICollection <LoadedFile> allFileObjects, ReferencedFileSave rfs, string objectType, string objectName)
{
return(null);
}
internal string GetAddToManagersFunc(IElement glueElement, NamedObjectSave namedObjectSave, ReferencedFileSave referencedFileSave, string layerName)
{
var stringBuilder = new StringBuilder();
var namedObjectName = namedObjectSave.FieldName;
string layerCode = "null";
if (!string.IsNullOrEmpty(layerName))
{
layerCode = $"System.Linq.Enumerable.FirstOrDefault(FlatRedBall.Gum.GumIdb.AllGumLayersOnFrbLayer({layerName}))";
}
if (glueElement is EntitySave)
{
stringBuilder.AppendLine("{");
stringBuilder.AppendLine($"{namedObjectName}.AddToManagers(RenderingLibrary.SystemManagers.Default, {layerCode});");
var shouldGenerateWrapper = namedObjectSave.AttachToContainer;
if (shouldGenerateWrapper)
{
stringBuilder.AppendLine($"var wrapperForAttachment = new GumCoreShared.FlatRedBall.Embedded.PositionedObjectGueWrapper(this, {namedObjectName});");
stringBuilder.AppendLine("FlatRedBall.SpriteManager.AddPositionedObject(wrapperForAttachment);");
stringBuilder.AppendLine("gumAttachmentWrappers.Add(wrapperForAttachment);");
}
stringBuilder.AppendLine("}");
}
else
{
stringBuilder.AppendLine($"{namedObjectName}.AddToManagers(RenderingLibrary.SystemManagers.Default, {layerCode});");
}
return(stringBuilder.ToString());
}
private void UpdateIncludedAndExcluded(ReferencedFileSave instance)
{
ResetToDefault();
AssetTypeInfo ati = instance.GetAssetTypeInfo();
ExcludeMember(nameof(ReferencedFileSave.InvalidFileNameCharacters));
ExcludeMember(nameof(ReferencedFileSave.ToStringDelegate));
ExcludeMember(nameof(ReferencedFileSave.Properties));
ContainerType containerType = instance.GetContainerType();
if (containerType == ContainerType.Entity)
{
// We do this because this is set automatically if the Entity is unique
ExcludeMember(nameof(ReferencedFileSave.IsSharedStatic));
// We do this because whether the objects from a file are manually updated or not
// should be up to the entity, not the source file.
ExcludeMember(nameof(ReferencedFileSave.IsManuallyUpdated));
}
if (containerType == ContainerType.Entity || ati == null || ati.QualifiedRuntimeTypeName.QualifiedType != "Microsoft.Xna.Framework.Media.Song")
{
ExcludeMember(nameof(ReferencedFileSave.DestroyOnUnload));
}
#region Extension-based additions/removals
string extension = FileManager.GetExtension(instance.Name);
if (extension != "csv" && !instance.TreatAsCsv)
{
ExcludeMember(nameof(ReferencedFileSave.CreatesDictionary));
ExcludeMember(nameof(ReferencedFileSave.IsDatabaseForLocalizing));
ExcludeMember(nameof(ReferencedFileSave.UniformRowType));
}
else
{
IncludeMember(nameof(ReferencedFileSave.UniformRowType), typeof(ReferencedFileSave), new AvailablePrimitiveTypeArraysStringConverter());
}
if ((extension != "txt" && extension != "csv") ||
(extension == "txt" && instance.TreatAsCsv == false)
)
{
ExcludeMember(nameof(ReferencedFileSave.CsvDelimiter));
}
if (extension != "txt")
{
ExcludeMember(nameof(ReferencedFileSave.TreatAsCsv));
}
if (extension == "png")
{
Attribute[] fileDetailsCategoryAttribute = new Attribute[] {
new CategoryAttribute("File Details")
};
IncludeMember("ImageWidth", typeof(int), null, GetImageWidth, null, fileDetailsCategoryAttribute);
IncludeMember("ImageHeight", typeof(int), null, GetImageHeight, null, fileDetailsCategoryAttribute);
}
if (extension == "emix")
{
Attribute[] fileDetailsCategoryAttribute = new Attribute[] {
new CategoryAttribute("File Details")
};
IncludeMember("EquilibriumParticleCount", typeof(float), null, GetEquilibriumParticleCount, null, fileDetailsCategoryAttribute);
IncludeMember("BurstParticleCount", typeof(float), null, GetBurstParticleCount, null, fileDetailsCategoryAttribute);
}
#endregion
AddProjectSpecificFileMember();
if (!instance.LoadedAtRuntime)
{
ExcludeMember(nameof(ReferencedFileSave.IsSharedStatic));
ExcludeMember(nameof(ReferencedFileSave.IsManuallyUpdated));
ExcludeMember(nameof(ReferencedFileSave.LoadedOnlyWhenReferenced));
ExcludeMember(nameof(ReferencedFileSave.HasPublicProperty));
ExcludeMember("InstanceName");
ExcludeMember(nameof(ReferencedFileSave.IncludeDirectoryRelativeToContainer));
}
if (ati == null || string.IsNullOrEmpty(ati.MakeManuallyUpdatedMethod))
{
ExcludeMember(nameof(ReferencedFileSave.IsManuallyUpdated));
}
if (!instance.GetCanUseContentPipeline())
{
ExcludeMember(nameof(ReferencedFileSave.UseContentPipeline));
}
if (!instance.UseContentPipeline || ati.QualifiedRuntimeTypeName.QualifiedType != "Microsoft.Xna.Framework.Graphics.Texture2D")
{
ExcludeMember("TextureFormat");
}
IncludeMember("OpensWith", typeof(ReferencedFileSave), new AvailableApplicationsStringConverters());
bool shouldShowRuntimeType = instance.LoadedAtRuntime;
if (shouldShowRuntimeType)
{
IncludeMember("RuntimeType", typeof(ReferencedFileSave), new AvailableRuntimeTypeConverter()
{
ReferencedFileSave = instance
});
}
else
{
ExcludeMember(nameof(ReferencedFileSave.RuntimeType));
}
if (string.IsNullOrEmpty(instance.SourceFile))
{
ExcludeMember(nameof(ReferencedFileSave.SourceFile));
ExcludeMember(nameof(ReferencedFileSave.BuildTool));
ExcludeMember(nameof(ReferencedFileSave.AdditionalArguments));
ExcludeMember(nameof(ReferencedFileSave.ConditionalCompilationSymbols));
}
else
{
}
}
private string GenerateConstructionFunc(IElement parentElement, NamedObjectSave namedObject, ReferencedFileSave referencedFile)
{
return(TileShapeCollectionInitializeCodeGenerator.GenerateConstructorFor(namedObject));
}
public static string GetFullDataFileNameFor(ReferencedFileSave rfs)
{
string toReturn = "DataTypes/" + rfs.GetUnqualifiedTypeForCsv() + ".Generated.cs";
return(toReturn);
}
public static void UpdateGlobalContentTreeNodes(bool performSave)
{
#region Loop through all referenced files. Create a tree node if needed, or remove it from the project if the file doesn't exist.
for (int i = 0; i < ProjectManager.GlueProjectSave.GlobalFiles.Count; i++)
{
ReferencedFileSave rfs = ProjectManager.GlueProjectSave.GlobalFiles[i];
TreeNode nodeForFile = GetTreeNodeForGlobalContent(rfs, mGlobalContentNode);
#region If there is no tree node for this file, make one
if (nodeForFile == null)
{
string fullFileName = ProjectManager.MakeAbsolute(rfs.Name, true);
if (FileManager.FileExists(fullFileName))
{
nodeForFile = new TreeNode(FileManager.RemovePath(rfs.Name));
nodeForFile.ImageKey = "file.png";
nodeForFile.SelectedImageKey = "file.png";
string absoluteRfs = ProjectManager.MakeAbsolute(rfs.Name, true);
TreeNode nodeToAddTo = GlueState.Self.Find.TreeNodeForDirectory(FileManager.GetDirectory(absoluteRfs));
if (nodeToAddTo == null)
{
nodeToAddTo = GlobalContentFileNode;
}
nodeToAddTo.Nodes.Add(nodeForFile);
nodeToAddTo.Nodes.SortByTextConsideringDirectories();
nodeForFile.Tag = rfs;
}
else
{
ProjectManager.GlueProjectSave.GlobalFiles.RemoveAt(i);
// Do we want to do this?
// ProjectManager.GlueProjectSave.GlobalContentHasChanged = true;
i--;
}
}
#endregion
#region else, there is already one
else
{
string textToSet = FileManager.RemovePath(rfs.Name);
if (nodeForFile.Text != textToSet)
{
nodeForFile.Text = textToSet;
}
}
#endregion
}
#endregion
#region Do cleanup - remove tree nodes that exist but represent objects no longer in the project
for (int i = mGlobalContentNode.Nodes.Count - 1; i > -1; i--)
{
TreeNode treeNode = mGlobalContentNode.Nodes[i];
RemoveGlobalContentTreeNodesIfNecessary(treeNode);
}
#endregion
if (performSave)
{
ProjectManager.SaveProjects();
}
}
private static string ConstructorFunc(IElement element, NamedObjectSave namedObject, ReferencedFileSave referencedFile)
{
var emitterTypeSelected = namedObject.GetCustomVariable(LogicVarName)?.Value as string;
var emitterGroupName = namedObject.GetCustomVariable(GroupVarName)?.Value as string;
if (string.IsNullOrWhiteSpace(emitterTypeSelected))
{
// No behavior selected, so we can't actually create the emitter
return(string.Empty);
}
var parentString = element is EntitySave ? "this" : "null";
var groupNameString = $"\"{emitterGroupName}\"";
var result = new StringBuilder();
result.AppendLine($"{namedObject.FieldName} = Parme.Frb.ParmeEmitterManager.Instance");
result.AppendLine($" .CreateEmitter(new {emitterTypeSelected}(), {parentString}, {groupNameString});");
return(result.ToString());
}
private static ContentItem GetContentItem(ReferencedFileSave referencedFileSave, ProjectBase project, bool createEvenIfProjectTypeNotSupported)
{
var fullFileName = GlueCommands.FileCommands.GetFullFileName(referencedFileSave);
return(GetContentItem(fullFileName, project, createEvenIfProjectTypeNotSupported));
}
/// <summary>
/// Creates a runtime object and adds the LoadedFile to the element.
/// </summary>
/// <param name="objectToLoad"></param>
/// <param name="container"></param>
/// <param name="elementRuntime"></param>
/// <param name="objectType"></param>
/// <param name="objectJustLoaded"></param>
/// <param name="newElementRuntime"></param>
/// <param name="toAddTo"></param>
/// <param name="layerToAddTo"></param>
/// <param name="rfs"></param>
/// <param name="pullsFromEntireNamedObject"></param>
/// <returns></returns>
private static LoadedFile CreateRuntimeObjectForNamedObject(NamedObjectSave objectToLoad,
IElement container, ElementRuntime elementRuntime, string objectType,
LoadedFile objectJustLoaded,
ElementRuntime newElementRuntime,
object toAddTo,
Layer layerToAddTo, ReferencedFileSave rfs, bool pullsFromEntireNamedObject)
{
var fileName = ElementRuntime.ContentDirectory + objectToLoad.SourceFile;
bool shouldClone = rfs != null && (rfs.IsSharedStatic && !(container is ScreenSave)) && !pullsFromEntireNamedObject;
LoadedFile toReturn = null;
// This could have a ( in the name in a file like .scnx, so use the last (
//int indexOfType = objectToLoad.SourceName.IndexOf("(");
int indexOfType = objectToLoad.SourceName.LastIndexOf("(");
string objectName = objectToLoad.SourceName.Substring(0, indexOfType - 1);
switch (objectType)
{
case "Scene":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
foreach (Text text in scene.Texts)
{
text.AdjustPositionForPixelPerfectDrawing = true;
if (ObjectFinder.Self.GlueProject.UsesTranslation)
{
text.DisplayText = LocalizationManager.Translate(text.DisplayText);
}
}
if (shouldClone)
{
scene = scene.Clone();
elementRuntime.EntireScenes.Add(objectToLoad.SourceFile, scene);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = scene;
loadedFile.FilePath = objectToLoad.SourceFile;
loadedFile.ReferencedFileSave = rfs;
toReturn = loadedFile;
newElementRuntime.ReferencedFileRuntimeList.Add(loadedFile);
scene.AddToManagers(layerToAddTo);
}
}
break;
case "Sprite":
{
Sprite loadedSprite = null;
Scene scene = objectJustLoaded.RuntimeObject as Scene;
if (scene != null)
{
loadedSprite = scene.Sprites.FindByName(objectName);
}
if (loadedSprite == null)
{
System.Windows.Forms.MessageBox.Show("There is a missing Sprite called\n\n" + objectName + "\n\n" +
"in the object\n\n" + elementRuntime.Name + "\n\n" +
"This probably happened if someone changed the name of a Sprite in a .scnx file but didn't update " +
"the associated object in Glue", "Missing Sprite");
}
else
{
if (shouldClone)
{
loadedSprite = loadedSprite.Clone();
(toAddTo as Scene).Sprites.Add(loadedSprite);
SpriteManager.AddToLayer(loadedSprite, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSprite;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "SpriteFrame":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
SpriteFrame loadedSpriteFrame = scene.SpriteFrames.FindByName(objectName);
if (loadedSpriteFrame != null)
{
if (shouldClone)
{
loadedSpriteFrame = loadedSpriteFrame.Clone();
(toAddTo as Scene).SpriteFrames.Add(loadedSpriteFrame);
SpriteManager.AddToLayer(loadedSpriteFrame, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSpriteFrame;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "SpriteGrid":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
SpriteGrid spriteGrid = null;
for (int i = 0; i < scene.SpriteGrids.Count; i++)
{
if (scene.SpriteGrids[i].Name == objectName)
{
spriteGrid = scene.SpriteGrids[i];
break;
}
}
if (spriteGrid != null)
{
if (shouldClone)
{
spriteGrid = spriteGrid.Clone();
(toAddTo as Scene).SpriteGrids.Add(spriteGrid);
spriteGrid.Layer = layerToAddTo;
spriteGrid.PopulateGrid();
spriteGrid.RefreshPaint();
spriteGrid.Manage();
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = spriteGrid;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "Text":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
Text loadedText = scene.Texts.FindByName(objectName);
if (loadedText != null)
{
if (shouldClone)
{
loadedText = loadedText.Clone();
(toAddTo as Scene).Texts.Add(loadedText);
TextManager.AddToLayer(loadedText, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedText;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
loadedText.AdjustPositionForPixelPerfectDrawing = true;
if (LocalizationManager.HasDatabase)
{
loadedText.DisplayText = LocalizationManager.Translate(loadedText.DisplayText);
}
}
}
break;
case "ShapeCollection":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
if (shouldClone)
{
shapeCollection = shapeCollection.Clone();
elementRuntime.EntireShapeCollections.Add(objectToLoad.SourceFile, shapeCollection);
newElementRuntime.ReferencedFileRuntimeList.LoadedShapeCollections.Add(shapeCollection);
shapeCollection.AddToManagers(layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = shapeCollection;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
// Most cases are handled below in an AttachTo method, but
// ShapeCollection isn't a PositionedObject so we have to do it manually here
if (objectToLoad.AttachToContainer)
{
shapeCollection.AttachTo(elementRuntime, true);
}
}
break;
case "AxisAlignedCube":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
AxisAlignedCube loadedAxisAlignedCube = shapeCollection.AxisAlignedCubes.FindByName(objectName);
if (shouldClone)
{
loadedAxisAlignedCube = loadedAxisAlignedCube.Clone();
(toAddTo as ShapeCollection).AxisAlignedCubes.Add(loadedAxisAlignedCube);
ShapeManager.AddToLayer(loadedAxisAlignedCube, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedAxisAlignedCube;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "AxisAlignedRectangle":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
AxisAlignedRectangle loadedAxisAlignedRectangle = shapeCollection.AxisAlignedRectangles.FindByName(objectName);
if (shouldClone)
{
loadedAxisAlignedRectangle = loadedAxisAlignedRectangle.Clone();
(toAddTo as ShapeCollection).AxisAlignedRectangles.Add(loadedAxisAlignedRectangle);
ShapeManager.AddToLayer(loadedAxisAlignedRectangle, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedAxisAlignedRectangle;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Circle":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Circle loadedCircle = shapeCollection.Circles.FindByName(objectName);
if (shouldClone)
{
loadedCircle = loadedCircle.Clone();
(toAddTo as ShapeCollection).Circles.Add(loadedCircle);
ShapeManager.AddToLayer(loadedCircle, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedCircle;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Polygon":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Polygon loadedPolygon = shapeCollection.Polygons.FindByName(objectName);
if (shouldClone)
{
loadedPolygon = loadedPolygon.Clone();
(toAddTo as ShapeCollection).Polygons.Add(loadedPolygon);
ShapeManager.AddToLayer(loadedPolygon, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedPolygon;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Sphere":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Sphere loadedSphere = shapeCollection.Spheres.FindByName(objectName);
if (shouldClone)
{
loadedSphere = loadedSphere.Clone();
(toAddTo as ShapeCollection).Spheres.Add(loadedSphere);
ShapeManager.AddToLayer(loadedSphere, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSphere;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Capsule2D":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Capsule2D loadedCapsule2D = shapeCollection.Capsule2Ds.FindByName(objectName);
if (shouldClone)
{
loadedCapsule2D = loadedCapsule2D.Clone();
(toAddTo as ShapeCollection).Capsule2Ds.Add(loadedCapsule2D);
ShapeManager.AddToLayer(loadedCapsule2D, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedCapsule2D;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Emitter":
{
EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;
Emitter loadedEmitter = emitterList.FindByName(objectName);
if (shouldClone && loadedEmitter != null)
{
loadedEmitter = loadedEmitter.Clone();
(toAddTo as EmitterList).Add(loadedEmitter);
SpriteManager.AddEmitter(loadedEmitter, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedEmitter;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "EmitterList":
{
EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;
if (shouldClone && emitterList != null)
{
emitterList = emitterList.Clone();
foreach (var item in emitterList)
{
SpriteManager.AddEmitter(item);
}
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = emitterList;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "NodeNetwork":
{
NodeNetwork nodeNetwork = objectJustLoaded.RuntimeObject as NodeNetwork;
if (shouldClone)
{
nodeNetwork = nodeNetwork.Clone();
elementRuntime.EntireNodeNetworks.Add(objectToLoad.SourceFile, nodeNetwork);
newElementRuntime.ReferencedFileRuntimeList.LoadedNodeNetworks.Add(nodeNetwork);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = nodeNetwork;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "SplineList":
{
SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
if (shouldClone)
{
splineList = splineList.Clone();
elementRuntime.EntireSplineLists.Add(splineList.Name, splineList);
foreach (var spline in splineList)
{
spline.CalculateVelocities();
spline.CalculateAccelerations();
}
splineList.AddToManagers();
splineList[0].UpdateShapes();
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = splineList;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Spline":
{
SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
Spline spline = splineList.FirstOrDefault(item => item.Name == objectName);
if (shouldClone && spline != null)
{
spline = spline.Clone();
(toAddTo as SplineList).Add(spline);
// Eventually support layers?
//ShapeManager.AddToLayer(spline, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = spline;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
spline.CalculateVelocities();
spline.CalculateAccelerations();
}
break;
}
if (toReturn == null)
{
foreach (var manager in ReferencedFileRuntimeList.FileManagers)
{
var objectFromFile = manager.TryGetObjectFromFile(elementRuntime.ReferencedFileRuntimeList.LoadedRfses, rfs, objectType, objectName);
if (objectFromFile != null)
{
var runtimeObject = objectFromFile;
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = runtimeObject;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
break;
}
}
}
if (toReturn != null && objectToLoad.AttachToContainer)
{
if (toReturn.RuntimeObject is PositionedObject)
{
// If the object is already attached to something, that means it
// came from a file, so we don't want to re-attach it.
PositionedObject asPositionedObject = toReturn.RuntimeObject as PositionedObject;
if (asPositionedObject.Parent == null)
{
asPositionedObject.AttachTo(elementRuntime, true);
}
}
else if (toReturn.RuntimeObject is Scene)
{
((Scene)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
}
else if (toReturn.RuntimeObject is ShapeCollection)
{
((ShapeCollection)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
}
}
return(toReturn);
}
private static LoadedFile LoadObject(NamedObjectSave namedObjectSave, IElement elementSave,
Layer layerToPutOn,
PositionedObjectList <ElementRuntime> listToPopulate, ElementRuntime elementRuntime)
{
int length = namedObjectSave.SourceName.Length;
// need to use the last index of ( in case the name has a "(" in it)
//int indexOfType = namedObjectSave.SourceName.IndexOf("(");
// add 1 to not include the opening paren
int indexOfType = namedObjectSave.SourceName.LastIndexOf("(") + 1;
// subtract 1 to remove the last paren
string objectType = namedObjectSave.SourceName.Substring(indexOfType, length - (indexOfType) - 1);
string sourceFile = namedObjectSave.SourceFile;
bool pullsFromEntireObject = false;
ReferencedFileSave rfs = elementSave.GetReferencedFileSaveRecursively(sourceFile);
var rfsFilePath = ElementRuntime.ContentDirectory + rfs.Name;
// This is the original file that contains the object that is going to be cloned from.
var loadedObjectToPullFrom =
elementRuntime.ReferencedFileRuntimeList.LoadedRfses.FirstOrDefault(item => item.FilePath ==
rfsFilePath);
pullsFromEntireObject = loadedObjectToPullFrom != null;
if (loadedObjectToPullFrom == null)
{
loadedObjectToPullFrom = elementRuntime.ReferencedFileRuntimeList.LoadReferencedFileSave(rfs, true, elementSave);
}
ElementRuntime newElementRuntime = CreateNewOrGetExistingElementRuntime(namedObjectSave, layerToPutOn,
listToPopulate, elementRuntime);
object toAddTo = null;
if (!namedObjectSave.IsEntireFile)
{
// we need to clone the container
toAddTo = newElementRuntime.ReferencedFileRuntimeList.CreateAndAddEmptyCloneOf(loadedObjectToPullFrom);
}
Layer layerToAddTo = GetLayerToAddTo(namedObjectSave, layerToPutOn, elementRuntime);
LoadedFile toReturn = null;
if (loadedObjectToPullFrom != null)
{
// This might be null if the NOS references a file that doesn't exist.
// This is usually not a valid circumstance but it's something that can
// occur with tools modifying the .glux and not properly verifying that the
// file exists. GView should tolerate this invalid definition.
toReturn = CreateRuntimeObjectForNamedObject(namedObjectSave, elementSave, elementRuntime,
objectType,
loadedObjectToPullFrom,
newElementRuntime,
toAddTo,
layerToAddTo, rfs, pullsFromEntireObject);
if (toReturn != null)
{
elementRuntime.ReferencedFileRuntimeList.Add(toReturn);
}
}
newElementRuntime.DirectObjectReference = toReturn?.RuntimeObject;
return(toReturn);
}
public IEnumerable <FilePath> GetFilePathsReferencedBy(ReferencedFileSave file, EditorObjects.Parsing.TopLevelOrRecursive topLevelOrRecursive)
{
var absolute = GlueCommands.GetAbsoluteFileName(file);
return(GetFilesReferencedBy(absolute, topLevelOrRecursive).Select(item => new FilePath(item)));
}
public IEnumerable <string> GetFilesReferencedBy(ReferencedFileSave file, EditorObjects.Parsing.TopLevelOrRecursive topLevelOrRecursive)
{
var absolute = GlueCommands.GetAbsoluteFileName(file);
return(GetFilesReferencedBy(absolute, topLevelOrRecursive));
}
private bool IsBuiltByContentPipeline(ReferencedFileSave file)
{
string extension = FileManager.GetExtension(file.Name);
return(extension == "mp3" || extension == "ogg" || extension == "wav");
}
private static bool GenerateClassFromMembers(ReferencedFileSave rfs, bool succeeded, string className, List <TypedMemberBase> members, Dictionary <string, string> untypedMembers)
{
ICodeBlock codeBlock = new CodeDocument();
// If the CSV
// is going to
// be deserialized
// to a dictionary,
// then we should create
// const members for all of
// the keys in the dictionary
// to make accessing the dictionary
// type-safe.
if (rfs != null)
{
succeeded = CreateConstsForCsvEntries(rfs, members, untypedMembers, codeBlock);
}
if (succeeded)
{
ICodeBlock codeContent = CodeWriter.CreateClass(ProjectManager.ProjectNamespace + ".DataTypes", className, true, members,
false, new List <string>(), untypedMembers, codeBlock);
string absoluteFileName = null;
if (rfs != null)
{
absoluteFileName = Plugins.ExportedImplementations.GlueState.Self.CurrentGlueProjectDirectory + GetFullDataFileNameFor(rfs);
}
else
{
absoluteFileName = Plugins.ExportedImplementations.GlueState.Self.CurrentGlueProjectDirectory + "DataTypes/" + className + ".Generated.cs";
}
CodeWriter.SaveFileContents(codeContent.ToString(), absoluteFileName, true);
#region Add the code item for the generated .cs file if it's not already part of the project
if (ProjectManager.ProjectBase.GetItem(absoluteFileName) == null)
{
ProjectManager.ProjectBase.AddCodeBuildItem(absoluteFileName);
}
#endregion
}
if (succeeded)
{
string message;
if (rfs != null)
{
message = "Generating class " + className + " from CSV " + rfs.Name;
}
else
{
message = "Generating class " + className + " from Custom Class";
}
Plugins.PluginManager.ReceiveOutput(message);
}
return(succeeded);
}
private void TryAddXnbReferencesAndBuild(ReferencedFileSave referencedFile, ProjectBase project, bool save)
{
var fullFileName = GlueCommands.FileCommands.GetFullFileName(referencedFile);
TryAddXnbReferencesAndBuild(fullFileName, project, save);
}
private static bool CreateConstsForCsvEntries(ReferencedFileSave initialRfs, List <TypedMemberBase> members, Dictionary <string, string> untypedMembers, ICodeBlock codeBlock)
{
bool succeeded = true;
bool addToOrderedLists = true;
CustomClassSave customClass = GetCustomClassForCsv(initialRfs.Name);
bool usesCustomClass = customClass != null;
List <ReferencedFileSave> rfsesForClass = new List <ReferencedFileSave>();
if (usesCustomClass)
{
foreach (string name in customClass.CsvFilesUsingThis)
{
ReferencedFileSave foundRfs = ObjectFinder.Self.GetReferencedFileSaveFromFile(name);
// A dupe was added one during a Glue crash, so let's protect against that:
if (foundRfs != null && rfsesForClass.Contains(foundRfs) == false)
{
rfsesForClass.Add(foundRfs);
}
}
}
else
{
rfsesForClass.Add(initialRfs);
}
Dictionary <ReferencedFileSave, RuntimeCsvRepresentation> representations = new Dictionary <ReferencedFileSave, RuntimeCsvRepresentation>();
List <string> allKeys = new List <string>();
foreach (ReferencedFileSave rfs in rfsesForClass)
{
if (rfs.CreatesDictionary)
{
string fileName = rfs.Name;
fileName = ProjectManager.MakeAbsolute(fileName);
var rcr = CsvFileManager.CsvDeserializeToRuntime(fileName);
representations.Add(rfs, rcr);
rcr.RemoveHeaderWhitespaceAndDetermineIfRequired();
int requiredIndex = rcr.GetRequiredIndex();
if (requiredIndex == -1)
{
succeeded = false;
GlueGui.ShowMessageBox("The file " + rfs.Name + " is marked as a dictionary but has no column marked as required");
}
else
{
var requiredValues = RequiredColumnValues(rcr);
allKeys.AddRange(requiredValues);
}
}
}
if (allKeys.Any())
{
var distinct = allKeys.Distinct();
var firstRcr = representations.First().Value;
int requiredIndex = firstRcr.GetRequiredIndex();
string type = GetRequiredKeyType(firstRcr, members, untypedMembers, requiredIndex);
FillCodeBlockWithKeys(codeBlock, type, firstRcr, allKeys.Distinct().ToArray());
// the first rcr defines the ordered keys. Others won't add themselves to this list
FillOrderedListWithKeys(codeBlock, type, firstRcr);
}
return(succeeded);
}
private static bool IsBuiltByContentPipeline(ReferencedFileSave file, bool forcePngsToContentPipeline)
{
return(IsBuiltByContentPipeline(file.Name, file.UseContentPipeline, forcePngsToContentPipeline));
}
void HandleNewFile(ReferencedFileSave rfs)
{
HandleBuiltFileChange(ProjectManager.MakeAbsolute(rfs.Name));
}
public static void TryRemoveXnbReferences(ProjectBase project, ReferencedFileSave referencedFile, bool save = true)
{
var fullFileName = GlueCommands.FileCommands.GetFullFileName(referencedFile);
TryRemoveXnbReferences(project, fullFileName, save);
}
public static void ElementDoubleClicked()
{
TreeNode selectedNode = SelectedNode;
if (selectedNode != null)
{
string text = selectedNode.Text;
#region Double-clicked a file
string extension = FileManager.GetExtension(text);
string sourceExtension = null;
if (EditorLogic.CurrentReferencedFile != null && !string.IsNullOrEmpty(EditorLogic.CurrentReferencedFile.SourceFile))
{
sourceExtension = FileManager.GetExtension(EditorLogic.CurrentReferencedFile.SourceFile);
}
if (EditorLogic.CurrentReferencedFile != null && !string.IsNullOrEmpty(extension))
{
string application = "";
ReferencedFileSave currentReferencedFileSave = EditorLogic.CurrentReferencedFile;
string fileName;
if (currentReferencedFileSave != null && currentReferencedFileSave.OpensWith != "<DEFAULT>")
{
application = currentReferencedFileSave.OpensWith;
}
else
{
if (!string.IsNullOrEmpty(sourceExtension))
{
application = EditorData.FileAssociationSettings.GetApplicationForExtension(sourceExtension);
}
else
{
application = EditorData.FileAssociationSettings.GetApplicationForExtension(extension);
}
}
if (currentReferencedFileSave != null)
{
if (!string.IsNullOrEmpty(currentReferencedFileSave.SourceFile))
{
fileName = "\"" + ProjectManager.MakeAbsolute(ProjectManager.ContentDirectoryRelative + currentReferencedFileSave.SourceFile, true) + "\"";
}
else
{
fileName = "\"" + ProjectManager.MakeAbsolute(ProjectManager.ContentDirectoryRelative + currentReferencedFileSave.Name) + "\"";
}
}
else
{
fileName = "\"" + ProjectManager.MakeAbsolute(text) + "\"";
}
if (string.IsNullOrEmpty(application) || application == "<DEFAULT>")
{
try
{
ProcessManager.OpenProcess(fileName, null);
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show("Error opening " + fileName + "\nTry navigating to this file and opening it through explorer");
}
}
else
{
bool applicationFound = true;
try
{
application = FileManager.Standardize(application);
}
catch
{
applicationFound = false;
}
if (!System.IO.File.Exists(application) || applicationFound == false)
{
string error = "Could not find the application\n\n" + application;
System.Windows.Forms.MessageBox.Show(error);
}
else
{
ProcessManager.OpenProcess(application, fileName);
}
}
}
#endregion
#region Double-clicked a named object
else if (selectedNode.IsNamedObjectNode())
{
NamedObjectSave nos = selectedNode.Tag as NamedObjectSave;
if (nos.SourceType == SourceType.Entity)
{
TreeNode entityNode = GlueState.Self.Find.EntityTreeNode(nos.SourceClassType);
SelectedNode = entityNode;
}
else if (nos.SourceType == SourceType.FlatRedBallType && nos.IsGenericType)
{
// Is this an entity?
EntitySave genericEntityType = ObjectFinder.Self.GetEntitySave(nos.SourceClassGenericType);
if (genericEntityType != null)
{
SelectedNode = GlueState.Self.Find.EntityTreeNode(genericEntityType);
}
}
else if (nos.SourceType == SourceType.File && !string.IsNullOrEmpty(nos.SourceFile))
{
ReferencedFileSave rfs = nos.GetContainer().GetReferencedFileSave(nos.SourceFile);
TreeNode treeNode = GlueState.Self.Find.ReferencedFileSaveTreeNode(rfs);
SelectedNode = treeNode;
}
}
#endregion
#region Double-clicked a CustomVariable
else if (selectedNode.IsCustomVariable())
{
CustomVariable customVariable = EditorLogic.CurrentCustomVariable;
if (!string.IsNullOrEmpty(customVariable.SourceObject))
{
NamedObjectSave namedObjectSave = EditorLogic.CurrentElement.GetNamedObjectRecursively(customVariable.SourceObject);
if (namedObjectSave != null)
{
SelectedNode = GlueState.Self.Find.NamedObjectTreeNode(namedObjectSave);
}
}
}
#endregion
#region Double-click an Event
else if (selectedNode.IsEventResponseTreeNode())
{
EventResponseSave ers = EditorLogic.CurrentEventResponseSave;
if (!string.IsNullOrEmpty(ers.SourceObject))
{
NamedObjectSave namedObjectSave = EditorLogic.CurrentElement.GetNamedObjectRecursively(ers.SourceObject);
if (namedObjectSave != null)
{
SelectedNode = GlueState.Self.Find.NamedObjectTreeNode(namedObjectSave);
}
}
}
#endregion
#region Double-click an Enity/Screen
else if (selectedNode.IsElementNode())
{
IElement element = selectedNode.Tag as IElement;
string baseObject = element.BaseElement;
if (!string.IsNullOrEmpty(baseObject))
{
IElement baseElement = ObjectFinder.Self.GetIElement(baseObject);
SelectedNode = GlueState.Self.Find.ElementTreeNode(baseElement);
}
}
#endregion
#region Code
else if (selectedNode.IsCodeNode())
{
var fileName = selectedNode.Text;
var absolute = GlueState.Self.CurrentGlueProjectDirectory + fileName;
if (System.IO.File.Exists(absolute))
{
System.Diagnostics.Process.Start(absolute);
}
}
#endregion
}
}
public string GetAbsoluteFileName(ReferencedFileSave rfs)
{
throw new NotImplementedException();
}
public void ReactToNamedObjectChangedValue(string changedMember, string parent, object oldValue)
{
string combinedMember;
if (string.IsNullOrEmpty(parent))
{
combinedMember = changedMember;
}
else
{
combinedMember = parent + "." + changedMember;
}
NamedObjectSave namedObjectSave = EditorLogic.CurrentNamedObject;
IElement element = EditorLogic.CurrentElement;
if (PropertiesToMethods.ContainsKey(changedMember))
{
PropertiesToMethods[changedMember](namedObjectSave, oldValue);
}
#region SourceType changed
else if (changedMember == "SourceType")
{
bool didErrorOccur = false;
if (didErrorOccur)
{
namedObjectSave.SourceType = (SourceType)oldValue;
}
else
{
if (namedObjectSave.SourceType == SourceType.Entity)
{
namedObjectSave.AddToManagers = true;
}
else if (namedObjectSave.SourceType == SourceType.File &&
namedObjectSave.GetContainerType() == ContainerType.Screen)
{
namedObjectSave.AddToManagers = false;
}
}
}
#endregion
#region SourceClassType changed
else if (changedMember == "SourceClassType")
{
ReactToChangedSourceClassType(namedObjectSave, oldValue);
}
#endregion
#region SourceFile changed
else if (changedMember == "SourceFile")
{
if (namedObjectSave.SourceFile != (string)oldValue)
{
// See if the current SourceName is valid or not
List <string> availableSourceNames =
AvailableNameablesStringConverter.GetAvailableNamedObjectSourceNames(namedObjectSave);
bool isSourceNameValid = availableSourceNames.Contains(namedObjectSave.SourceName);
if (!isSourceNameValid)
{
namedObjectSave.SourceName = "<NONE>";
}
}
}
#endregion
#region SourceName
else if (changedMember == "SourceName")
{
// This needs to happen before we update custom properties
ReactToChangedNosSourceName(namedObjectSave, oldValue as string);
namedObjectSave.UpdateCustomProperties();
}
#endregion
#region InstanceName changed
else if (changedMember == "InstanceName")
{
ReactToNamedObjectChangedInstanceName(namedObjectSave, oldValue);
}
#endregion
#region SetByDerived Changed
else if (changedMember == "SetByDerived")
{
if (namedObjectSave.SourceType == SourceType.Entity &&
!string.IsNullOrEmpty(namedObjectSave.SourceClassType))
{
if (ProjectManager.VerifyReferenceGraph(ObjectFinder.Self.GetEntitySave(namedObjectSave.SourceClassType)) == ProjectManager.CheckResult.Failed)
{
namedObjectSave.SetByDerived = !namedObjectSave.SetByDerived;
}
}
if (namedObjectSave.SetByDerived && namedObjectSave.ExposedInDerived)
{
// The user has just set SetByDerived to true, but ExposedInDerived means that
// the derived expects that the base instantiates. We need to tell the user that
// both values can't be true at the same time, and that ExposedInDerived will be set
// to false.
MessageBox.Show("You have set SetByDerived to true, but ExposedInDerived is also true. Both cannot be true at the same time " +
"so Glue will set ExposedInDerived to false.");
namedObjectSave.ExposedInDerived = false;
}
if (namedObjectSave.SourceType == SourceType.FlatRedBallType &&
namedObjectSave.IsList &&
namedObjectSave.SetByDerived == true &&
namedObjectSave.ContainedObjects.Count != 0)
{
MessageBox.Show("This list is not empty, so it can't be set to \"Set By Derived\". You must first empty the list", "Invalid Setting");
namedObjectSave.SetByDerived = false;
}
else
{
ProjectManager.UpdateAllDerivedElementFromBaseValues(false, true);
}
}
#endregion
#region ExposedInDerived Changed
else if (changedMember == "ExposedInDerived")
{
if (namedObjectSave.SetByDerived && namedObjectSave.ExposedInDerived)
{
// See comment in ExposedByDerived block on why this occurs
MessageBox.Show("You have set ExposedInDerived to true, but SetByDerived is also true. Both cannot be true at the same time " +
"so Glue will set SetByDerived to false.");
namedObjectSave.SetByDerived = false;
}
SetExposedByDerivedRecursively(namedObjectSave, oldValue);
ProjectManager.UpdateAllDerivedElementFromBaseValues(false, true);
}
#endregion
#region SourceClassGenericType
else if (changedMember == "SourceClassGenericType")
{
ReactToSourceClassGenericType(namedObjectSave, oldValue);
}
#endregion
#region IsDisabled
else if (changedMember == "IsDisabled")
{
GlueState.Self.Find.ElementTreeNode(EditorLogic.CurrentElement).UpdateReferencedTreeNodes();
}
#endregion
#region SetByContainer Changed
else if (changedMember == "SetByContainer")
{
if (namedObjectSave.SourceType == SourceType.Entity &&
!string.IsNullOrEmpty(namedObjectSave.SourceClassType))
{
if (ProjectManager.VerifyReferenceGraph(ObjectFinder.Self.GetEntitySave(namedObjectSave.SourceClassType)) == ProjectManager.CheckResult.Failed)
{
namedObjectSave.SetByContainer = !namedObjectSave.SetByContainer;
}
}
List <IElement> derivedElements = ObjectFinder.Self.GetAllElementsThatInheritFrom(
EditorLogic.CurrentElement.Name);
foreach (IElement derived in derivedElements)
{
foreach (NamedObjectSave nos in derived.NamedObjects)
{
if (nos.InstanceName == namedObjectSave.InstanceName)
{
nos.SetByContainer = namedObjectSave.SetByContainer;
}
}
}
if (EditorLogic.CurrentEntitySave != null)
{
List <NamedObjectSave> entityNamedObjects = ObjectFinder.Self.GetAllNamedObjectsThatUseEntity(EditorLogic.CurrentEntitySave.Name);
foreach (NamedObjectSave nos in entityNamedObjects)
{
nos.UpdateCustomProperties();
}
}
}
#endregion
#region AddToManagers Changed
else if (changedMember == "AddToManagers")
{
if (namedObjectSave.AddToManagers &&
namedObjectSave.GetContainerType() == ContainerType.Screen && namedObjectSave.SourceType == SourceType.File)
{
ScreenSave screenSave = namedObjectSave.GetContainer() as ScreenSave;
ReferencedFileSave rfs = screenSave.GetReferencedFileSave(namedObjectSave.SourceFile);
if (rfs != null && !rfs.IsSharedStatic)
{
System.Windows.Forms.MessageBox.Show("This object comes from a file. Files which are part of Screens " +
"are automatically added to the engine managers. " +
"Adding this object would result in double-membership in the engine which may cause unexpected results. " +
"\n\nGlue will now set this value back to false.");
namedObjectSave.AddToManagers = false;
}
}
}
#endregion
#region LayerOn
else if (changedMember == "LayerOn")
{
if (namedObjectSave.IsList)
{
DialogResult result = DialogResult.No;
if (string.IsNullOrEmpty(namedObjectSave.LayerOn))
{
result = MessageBox.Show("Do you want to remove every object in the List " + namedObjectSave.InstanceName +
" from its Layer?",
"Remove all from Layer?",
MessageBoxButtons.YesNo);
}
else
{
result = MessageBox.Show("Do you want to add every object contained in the List " + namedObjectSave.InstanceName +
" to the Layer " + namedObjectSave.LayerOn + "?",
"Add all to Layer?",
MessageBoxButtons.YesNo);
}
if (result == DialogResult.Yes)
{
namedObjectSave.SetLayerRecursively(namedObjectSave.LayerOn);
}
}
}
#endregion
#region IsContainer
else if (changedMember == "IsContainer")
{
HandleChangedIsContainer(namedObjectSave, element);
}
#endregion
#region AttachToCamera
else if (changedMember == "AttachToCamera")
{
if (namedObjectSave.IsList)
{
DialogResult result = DialogResult.No;
if (namedObjectSave.AttachToCamera)
{
result = MessageBox.Show("Do you want to attach every object contained in the list " + namedObjectSave.InstanceName +
" to the Camera?", "Attach all to Camera?",
MessageBoxButtons.YesNo);
}
else
{
result = MessageBox.Show("Do you want to detach every object contained in the list " + namedObjectSave.InstanceName +
" from the Camera?", "Detach all from the Camera?",
MessageBoxButtons.YesNo);
}
if (result == DialogResult.Yes)
{
namedObjectSave.SetAttachToCameraRecursively(namedObjectSave.AttachToCamera);
}
}
}
#endregion
#region DestinationRectangle.Y (for Layers)
else if (parent == "DestinationRectangle" && changedMember == "Y")
{
// If the Y is odd, we should warn the user that it should be even
// or else text will draw incorrectly
if (namedObjectSave.DestinationRectangle.HasValue && namedObjectSave.DestinationRectangle.Value.Y % 2 == 1)
{
MessageBox.Show("Setting an odd value to the DestinationRectangle's Y may cause text to render improperly. An " +
"even value is recommended");
}
}
#endregion
#region RemoveFromManagersWhenInvisible
else if (changedMember == "RemoveFromManagersWhenInvisible")
{
// is this an Entity instance?
if (namedObjectSave.SourceType == SourceType.Entity && namedObjectSave.RemoveFromManagersWhenInvisible)
{
var entitySave = ObjectFinder.Self.GetEntitySave(namedObjectSave.SourceClassType);
if (entitySave != null)
{
// Is this CreatedByOtherEntities?
if (!entitySave.CreatedByOtherEntities)
{
MessageBox.Show("The Entity " + entitySave + " should have its CreatedByOtherEntities set to true to enable " +
"visibility-based removal to work properly");
}
}
}
}
#endregion
else if (namedObjectSave?.GetCustomVariable(changedMember) != null)
{
// See if this variable is tunneled into in this element.
// If so, set that value too.
CustomVariableInNamedObject cvino = namedObjectSave.GetCustomVariable(changedMember);
object value = cvino.Value;
foreach (CustomVariable customVariable in EditorLogic.CurrentElement.CustomVariables)
{
if (customVariable.SourceObject == namedObjectSave.InstanceName &&
customVariable.SourceObjectProperty == changedMember)
{
// The custom variable may have a different type:
if (!string.IsNullOrEmpty(customVariable.OverridingPropertyType))
{
// it does, so convert
Type overridingType = TypeManager.GetTypeFromString(customVariable.OverridingPropertyType);
customVariable.DefaultValue = System.Convert.ChangeType(value, overridingType);
}
else
{
customVariable.DefaultValue = value;
}
break;
}
}
}
// If we changed BitmapFont and if the NOS is marked as PixelPerfect
// and if it's a Text object, then we should set the Scale, Spacing, and
// NewLineDistance according to the set BitmapFont
// We don't do an else because there could be a CustomVariable by the name
// of BitmapFont as well, and we dont' want to eliminate that.
if (changedMember == "Font" && namedObjectSave.SourceType == SourceType.FlatRedBallType &&
namedObjectSave.SourceClassType == "Text" && namedObjectSave.IsPixelPerfect)
{
ReactToFontSet(namedObjectSave, oldValue);
}
PropertyGridHelper.UpdateNamedObjectDisplay();
PluginManager.ReactToNamedObjectChangedValue(changedMember, oldValue);
}
public static bool UpdateFileMembershipInProject(ReferencedFileSave referencedFileSave)
{
return(GlueCommands.Self.ProjectCommands.UpdateFileMembershipInProject(referencedFileSave));
}
public static bool UpdateFile(string changedFile)
{
bool shouldSave = false;
bool handled = false;
lock (mUpdateFileLock)
{
if (ProjectManager.ProjectBase != null)
{
handled = TryHandleProjectFileChanges(changedFile);
string projectFileName = ProjectManager.ProjectBase.FullFileName;
var standardizedGlux = FileManager.RemoveExtension(FileManager.Standardize(projectFileName).ToLower()) + ".glux";
var partialGlux = FileManager.RemoveExtension(FileManager.Standardize(projectFileName).ToLower()) + @"\..*\.generated\.glux";
var partialGluxRegex = new Regex(partialGlux);
if (!handled && ((changedFile.ToLower() == standardizedGlux) || partialGluxRegex.IsMatch(changedFile.ToLower())))
{
TaskManager.Self.OnUiThread(ReloadGlux);
handled = true;
}
if (ProjectManager.IsContent(changedFile))
{
PluginManager.ReactToChangedFile(changedFile);
}
#region If it's a CSV, then re-generate the code for the objects
string extension = FileManager.GetExtension(changedFile);
if (extension == "csv" ||
extension == "txt")
{
ReferencedFileSave rfs = ObjectFinder.Self.GetReferencedFileSaveFromFile(changedFile);
bool shouldGenerate = rfs != null &&
(extension == "csv" || rfs.TreatAsCsv) &&
rfs.IsDatabaseForLocalizing == false;
if (shouldGenerate)
{
try
{
CsvCodeGenerator.GenerateAndSaveDataClass(rfs, rfs.CsvDelimiter);
shouldSave = true;
}
catch (Exception e)
{
GlueCommands.Self.PrintError("Error saving Class from CSV " + rfs.Name +
"\n" + e.ToString());
}
}
}
#endregion
#region If it's a file that references other content we may need to update the project
if (FileHelper.DoesFileReferenceContent(changedFile))
{
ReferencedFileSave rfs = ObjectFinder.Self.GetReferencedFileSaveFromFile(changedFile);
if (rfs != null)
{
string error;
rfs.RefreshSourceFileCache(false, out error);
if (!string.IsNullOrEmpty(error))
{
ErrorReporter.ReportError(rfs.Name, error, false);
}
else
{
handled = true;
}
handled |= GlueCommands.Self.ProjectCommands.UpdateFileMembershipInProject(rfs);
shouldSave = true;
MainGlueWindow.Self.Invoke((MethodInvoker) delegate
{
if (rfs.GetContainerType() == ContainerType.Entity)
{
if (EditorLogic.CurrentEntityTreeNode != null)
{
if (EditorLogic.CurrentEntitySave == rfs.GetContainer())
{
PluginManager.RefreshCurrentElement();
}
}
}
else if (rfs.GetContainerType() == ContainerType.Screen)
{
if (EditorLogic.CurrentScreenTreeNode != null)
{
if (EditorLogic.CurrentScreenSave == rfs.GetContainer())
{
PluginManager.RefreshCurrentElement();
}
}
}
});
}
else
{
// There may not be a RFS for this in Glue, but even if there's not,
// this file may be referenced by other RFS's. I don't want to do a full
// project scan, so we'll just see if this file is part of Visual Studio. If so
// then let's add its children
if (ProjectManager.ContentProject.IsFilePartOfProject(changedFile))
{
string relativePath = ProjectManager.MakeRelativeContent(changedFile);
shouldSave |= GlueCommands.Self.ProjectCommands.UpdateFileMembershipInProject(
ProjectManager.ProjectBase, relativePath, false, false);
handled |= shouldSave;
}
}
}
#endregion
#region If it's a .cs file, we should see if we've added a new .cs file, and if so refresh the Element for it
if (extension == "cs")
{
TaskManager.Self.OnUiThread(() => ReactToChangedCodeFile(changedFile));
}
#endregion
#region Maybe it's a directory that was added or removed
if (FileManager.GetExtension(changedFile) == "")
{
ElementViewWindow.Invoke((MethodInvoker) delegate
{
try
{
// It's a directory, so let's just rebuild our directory TreeNodes
ElementViewWindow.AddDirectoryNodes();
}
catch (System.IO.IOException)
{
// this could be because something else is accessing the directory, so sleep, try again
System.Threading.Thread.Sleep(100);
ElementViewWindow.AddDirectoryNodes();
}
});
}
#endregion
#region Check for broken references to objects in file - like an Entity may reference an object in a file but it may have been removed
if (ObjectFinder.Self.GetReferencedFileSaveFromFile(changedFile) != null)
{
// This is a file that is part of the project, so let's see if any named objects are missing references
CheckForBrokenReferencesToObjectsInFile(changedFile);
}
#endregion
// This could be an externally built file:
ProjectManager.UpdateExternallyBuiltFile(changedFile);
if (handled)
{
PluginManager.ReceiveOutput("Handled changed file: " + changedFile);
}
if (shouldSave)
{
ProjectManager.SaveProjects();
}
}
}
return(handled);
}
public override bool GetIfIsFixed()
{
// This is fixed if:
// 1: AbsoluteMissingFile is now on disk
// 2: Any file in the stack no longer exists
// 3: Any file in the stack no longer references the next file in the stack
// 4: The ReferencedFileSave has been removed from the project
bool isFixed = false;
if (AbsoluteMissingFile.Exists())
{
isFixed = true;
}
if (!isFixed)
{
foreach (var file in ReferenceStack)
{
// 2:
if (file.Exists() == false)
{
isFixed = true;
break;
}
}
}
if (!isFixed)
{
// 3:
for (int i = 0; i < ReferenceStack.Count; i++)
{
var current = ReferenceStack[i];
FilePath next;
if (i + 1 < ReferenceStack.Count)
{
next = ReferenceStack[i + 1];
}
else
{
next = AbsoluteMissingFile;
}
var referencedFiles =
GlueCommands.Self.FileCommands.GetFilePathsReferencedBy(current.Standardized, EditorObjects.Parsing.TopLevelOrRecursive.TopLevel);
var stillReferences = referencedFiles.Any(item => item == next);
if (!stillReferences)
{
isFixed = true;
break;
}
}
}
if (!isFixed)
{
bool isReferencedByElement = ReferencedFileSave.GetContainer() != null;
bool isGlobalContent = false;
if (!isReferencedByElement)
{
isGlobalContent = GlueState.Self.CurrentGlueProject.GetAllReferencedFiles().Contains(ReferencedFileSave);
}
if (!isReferencedByElement && !isGlobalContent)
{
// the root RFS has been removed
isFixed = true;
}
}
return(isFixed);
}
private void HandleFileRemoved(IElement container, ReferencedFileSave removedFile)
{
RefreshLogic.HandleReferencedFileRemoved(removedFile, errorListViewModel);
}
public static void GenerateAndSaveDataClass(ReferencedFileSave rfs, AvailableDelimiters delimiter)
{
string fileName = rfs.Name;
fileName = ProjectManager.MakeAbsolute(fileName);
#region See if the CSV file doesn't exist and warn the user if not
if (!System.IO.File.Exists(fileName))
{
MessageBox.Show("Could not find the CSV file " + fileName +
" when trying to generate a data file");
}
#endregion
else // CSV exists
{
#region Save off the old delimiter and switch to using the new one - we need the old one so we can switch back after this function finishes
char oldDelimiter = CsvFileManager.Delimiter;
CsvFileManager.Delimiter = delimiter.ToChar();
#endregion
if (!string.IsNullOrEmpty(rfs.UniformRowType))
{
// This simply
// checks to make
// sure the CSV is
// set up right - it
// doesn't actually generate
// any code because the CSV will
// deserialize to an array of primitives.
CheckUniformTypeValidity(rfs, fileName, oldDelimiter);
}
else
{
RuntimeCsvRepresentation rcr;
bool succeeded;
DeserializeToRcr(delimiter, fileName, out rcr, out succeeded);
if (succeeded)
{
CsvFileManager.Delimiter = oldDelimiter;
string whyIsCsvWrong = GetWhyCsvIsWrong(rcr, rfs.CreatesDictionary, fileName);
if (!string.IsNullOrEmpty(whyIsCsvWrong))
{
GlueGui.ShowMessageBox(whyIsCsvWrong);
succeeded = false;
}
else
{
string className;
List <TypedMemberBase> members;
Dictionary <string, string> untypedMembers;
CustomClassSave customClass = GetCustomClassForCsv(rfs.Name);
if (customClass == null || customClass.GenerateCode)
{
fileName = GetClassInfoFromCsvs(rfs, fileName, rcr, out className, out members, out untypedMembers);
succeeded = GenerateClassFromMembers(rfs, succeeded, className, members, untypedMembers);
}
}
}
}
}
}
public string GetFullFileName(ReferencedFileSave rfs)
{
return(GlueState.ContentDirectory + rfs.Name);
}
private static void DragAddFileToGlobalContent(TreeNode treeNodeMoving, ReferencedFileSave referencedFileSave)
{
if (referencedFileSave.GetContainerType() == ContainerType.None)
{
// This means the user dragged a file from global content onto the global content tree node -
// we shouldn't do anything here. It's not a valid operation, but at the same time, it may have
// happened accidentally and we don't want to burden the user with popups.
}
else
{
bool isAlreadyPartOfReferencedFiles = false;
// If the file is already part of GlobalContent, then warn the user and do nothing
foreach (ReferencedFileSave fileInGlobalContent in ObjectFinder.Self.GlueProject.GlobalFiles)
{
if (fileInGlobalContent.Name == referencedFileSave.Name)
{
isAlreadyPartOfReferencedFiles = true;
break;
}
}
if (isAlreadyPartOfReferencedFiles)
{
MessageBox.Show("The file\n\n" + referencedFileSave.Name + "\n\nis already a Global Content File");
}
else
{
// If we got here, that means that the file that
// the user is dragging in to Global Content Files
// can be added to Global Content Files; however, the
// owner of the file may not be using global content. We
// should ask the user if the containing IElement should use
// global content
IElement container = referencedFileSave.GetContainer();
if (!container.UseGlobalContent)
{
string screenOrEntity = "Screen";
if (container is EntitySave)
{
screenOrEntity = "Entity";
}
DialogResult result = MessageBox.Show("The " + screenOrEntity + " " + container.ToString() +
"does not UseGlobalContent. Would you like " +
" to set UseGlobalContent to true?", "Set UseGlobalContent to true?", MessageBoxButtons.YesNo);
if (result == DialogResult.Yes)
{
container.UseGlobalContent = true;
}
}
bool useFullPathAsName = true;
ElementCommands.Self.AddReferencedFileToGlobalContent(referencedFileSave.Name, useFullPathAsName);
ContentLoadWriter.UpdateLoadGlobalContentCode();
ProjectManager.SaveProjects();
GluxCommands.Self.SaveGlux();
}
}
}
