public NamedObjectSave AddNewNamedObjectToSelectedElement(AddObjectViewModel addObjectViewModel) { MembershipInfo membershipInfo = NamedObjectSaveExtensionMethodsGlue.GetMemberMembershipInfo(addObjectViewModel.ObjectName); var newNos = NamedObjectSaveExtensionMethodsGlue.AddNewNamedObjectToSelectedElement(addObjectViewModel.ObjectName, membershipInfo, false); if (addObjectViewModel.SourceClassType != NoType && !string.IsNullOrEmpty(addObjectViewModel.SourceClassType)) { newNos.SourceType = addObjectViewModel.SourceType; newNos.SourceClassType = addObjectViewModel.SourceClassType; newNos.SourceFile = addObjectViewModel.SourceFile; newNos.SourceName = addObjectViewModel.SourceNameInFile; newNos.UpdateCustomProperties(); EditorLogic.CurrentElementTreeNode.UpdateReferencedTreeNodes(); } else if (!string.IsNullOrEmpty(addObjectViewModel.SourceFile)) { newNos.SourceType = addObjectViewModel.SourceType; newNos.SourceFile = addObjectViewModel.SourceFile; newNos.SourceName = addObjectViewModel.SourceNameInFile; newNos.UpdateCustomProperties(); EditorLogic.CurrentElementTreeNode.UpdateReferencedTreeNodes(); } newNos.SourceClassGenericType = addObjectViewModel.SourceClassGenericType; var ati = newNos.GetAssetTypeInfo(); if (ati != null && ati.DefaultPublic) { newNos.HasPublicProperty = true; } var currentEntity = GlueState.Self.CurrentElement as EntitySave; if (currentEntity != null && currentEntity.CreatedByOtherEntities && currentEntity.PooledByFactory) { bool wasAnythingAdded = FlatRedBall.Glue.Factories.FactoryManager.AddResetVariablesFor(newNos); if (wasAnythingAdded) { PluginManager.ReceiveOutput("Added reset variables for " + newNos); } } PluginManager.ReactToNewObject(newNos); MainGlueWindow.Self.PropertyGrid.Refresh(); PropertyGridHelper.UpdateNamedObjectDisplay(); ElementViewWindow.GenerateSelectedElementCode(); // it may already be selected, so force select it MainGlueWindow.Self.ElementTreeView.SelectedNode = null; MainGlueWindow.Self.ElementTreeView.SelectedNode = GlueState.Self.Find.NamedObjectTreeNode(newNos); GluxCommands.Self.SaveGlux(); return(newNos); }
public static NamedObjectSave AddNewNamedObjectTo(string objectName, MembershipInfo membershipInfo, IElement element, NamedObjectSave namedObjectSave, bool raisePluginResponse = true) { NamedObjectSave namedObject = new NamedObjectSave(); namedObject.InstanceName = objectName; namedObject.DefinedByBase = membershipInfo == MembershipInfo.ContainedInBase; #region Adding to a NamedObject (PositionedObjectList) if (namedObjectSave != null) { AddNamedObjectToCurrentNamedObjectList(namedObject); } #endregion else if (element != null) { AddExistingNamedObjectToElement(element, namedObject, true); } if (raisePluginResponse) { PluginManager.ReactToNewObject(namedObject); } MainGlueWindow.Self.PropertyGrid.Refresh(); ElementViewWindow.GenerateSelectedElementCode(); GluxCommands.Self.SaveGlux(); return(namedObject); }
private static void UseFullScreenClick(object sender, EventArgs e) { EditorLogic.CurrentNamedObject.DestinationRectangle = null; ElementViewWindow.GenerateSelectedElementCode(); GluxCommands.Self.SaveGlux(); MainGlueWindow.Self.PropertyGrid.Refresh(); }
private void DoneButton_Click(object sender, EventArgs e) { this.Close(); ElementViewWindow.GenerateSelectedElementCode(); GlueCommands.Self.GenerateCodeCommands.GenerateCustomClassesCode(); GlueCommands.Self.GenerateCodeCommands.GenerateGlobalContentCode(); }
private static void UseCustomRectangleClick(object sender, EventArgs e) { FloatRectangle rectangle = new FloatRectangle(0, 0, ProjectManager.GlueProjectSave.ResolutionWidth, ProjectManager.GlueProjectSave.ResolutionHeight); EditorLogic.CurrentNamedObject.DestinationRectangle = rectangle; ElementViewWindow.GenerateSelectedElementCode(); GluxCommands.Self.SaveGlux(); MainGlueWindow.Self.PropertyGrid.Refresh(); }
public static NamedObjectSave AddNewNamedObjectToSelectedElement(string objectName, MembershipInfo membershipInfo, bool raisePluginResponse = true) { NamedObjectSave namedObject = new NamedObjectSave(); namedObject.InstanceName = objectName; namedObject.DefinedByBase = membershipInfo == MembershipInfo.ContainedInBase; #region Adding to a NamedObject (PositionedObjectList) if (EditorLogic.CurrentNamedObject != null) { AddNamedObjectToCurrentNamedObjectList(namedObject); } #endregion #region else adding to Screen else if (EditorLogic.CurrentScreenTreeNode != null) { ScreenTreeNode screenTreeNode = EditorLogic.CurrentScreenTreeNode; AddNewNamedObjectToElementTreeNode(screenTreeNode, namedObject, true); } #endregion #region else adding to an Entity else if (EditorLogic.CurrentEntityTreeNode != null) { EntityTreeNode entityTreeNode = EditorLogic.CurrentEntityTreeNode; AddNewNamedObjectToElementTreeNode(entityTreeNode, namedObject, true); } #endregion if (raisePluginResponse) { PluginManager.ReactToNewObject(namedObject); } MainGlueWindow.Self.PropertyGrid.Refresh(); ElementViewWindow.GenerateSelectedElementCode(); GluxCommands.Self.SaveGlux(); return(namedObject); }
private static void SetDefaultClick(object sender, EventArgs e) { // set default, reset default, set to default, reset to default if (mHighlightedCustomVariable != null) { mHighlightedCustomVariable.DefaultValue = null; GlueCommands.Self.RefreshCommands.RefreshPropertyGrid(); } else if (EditorLogic.CurrentStateSave != null) { StateSave stateSave = EditorLogic.CurrentStateSave; string valueToChange = MainGlueWindow.Self.PropertyGrid.SelectedGridItem.Label; if (valueToChange.Contains(" set")) { valueToChange = valueToChange.Substring(0, valueToChange.IndexOf(" set")); } for (int i = stateSave.InstructionSaves.Count - 1; i > -1; i--) { if (stateSave.InstructionSaves[i].Member == valueToChange) { stateSave.InstructionSaves.RemoveAt(i); break; } } } else if (EditorLogic.CurrentCustomVariable != null) { EditorLogic.CurrentCustomVariable.DefaultValue = null; GlueCommands.Self.RefreshCommands.RefreshPropertyGrid(); } else { NamedObjectSave currentNamedObject = EditorLogic.CurrentNamedObject; string variableToSet = MainGlueWindow.Self.PropertyGrid.SelectedGridItem.Label; SetVariableToDefault(currentNamedObject, variableToSet); } ElementViewWindow.GenerateSelectedElementCode(); GluxCommands.Self.SaveGlux(); MainGlueWindow.Self.PropertyGrid.Refresh(); }
public void RemoveReferencedFile(ReferencedFileSave referencedFileToRemove, List <string> additionalFilesToRemove, bool regenerateCode) { var isContained = GlueState.Self.Find.IfReferencedFileSaveIsReferenced(referencedFileToRemove); /////////////////////////Early Out////////////////////////////// if (!isContained) { return; } ////////////////////////End Early Out///////////////////////////// // There are some things that need to happen: // 1. Remove the ReferencedFileSave from the Glue project (GLUX) // 2. Remove the GUI item // 3. Remove the item from the Visual Studio project. IElement container = referencedFileToRemove.GetContainer(); #region Remove the file from the current Screen or Entity if there is a current Screen or Entity if (container != null) { // The referenced file better be a globally referenced file if (!container.ReferencedFiles.Contains(referencedFileToRemove)) { throw new ArgumentException(); } else { container.ReferencedFiles.Remove(referencedFileToRemove); } // Ask about any NamedObjects that reference this file. for (int i = container.NamedObjects.Count - 1; i > -1; i--) { var nos = container.NamedObjects[i]; if (nos.SourceType == SourceType.File && nos.SourceFile == referencedFileToRemove.Name) { MainGlueWindow.Self.Invoke(() => { // Ask the user what to do here - remove it? Keep it and not compile? MultiButtonMessageBox mbmb = new MultiButtonMessageBox(); mbmb.MessageText = "The object\n" + nos.ToString() + "\nreferences the file\n" + referencedFileToRemove.Name + "\nWhat would you like to do?"; mbmb.AddButton("Remove this object", DialogResult.Yes); mbmb.AddButton("Keep it (object will not be valid until changed)", DialogResult.No); var result = mbmb.ShowDialog(); if (result == DialogResult.Yes) { container.NamedObjects.RemoveAt(i); } }); } nos.ResetVariablesReferencing(referencedFileToRemove); } MainGlueWindow.Self.Invoke(() => { if (EditorLogic.CurrentScreenTreeNode != null) { EditorLogic.CurrentScreenTreeNode.UpdateReferencedTreeNodes(); } else if (EditorLogic.CurrentEntityTreeNode != null) { EditorLogic.CurrentEntityTreeNode.UpdateReferencedTreeNodes(); } if (regenerateCode) { ElementViewWindow.GenerateSelectedElementCode(); } }); } #endregion #region else, the file is likely part of the GlobalContentFile else { ProjectManager.GlueProjectSave.GlobalFiles.Remove(referencedFileToRemove); ProjectManager.GlueProjectSave.GlobalContentHasChanged = true; // Much faster to just remove the tree node. This was done // to reuse code and make things reactive, but this has gotten // slow on bigger projects. //ElementViewWindow.UpdateGlobalContentTreeNodes(false); // don't save here because projects will get saved below Action refreshUiAction = () => { TreeNode treeNode = GlueState.Self.Find.ReferencedFileSaveTreeNode(referencedFileToRemove); if (treeNode != null) { // treeNode can be null if the user presses delete + enter really really fast, stacking 2 remove // actions if (treeNode.Tag != referencedFileToRemove) { throw new Exception("Error removing the tree node - the selected tree node doesn't reference the file being removed"); } treeNode.Parent.Nodes.Remove(treeNode); } }; MainGlueWindow.Self.Invoke((MethodInvoker) delegate { refreshUiAction(); } ); GlobalContentCodeGenerator.UpdateLoadGlobalContentCode(); List <IElement> elements = ObjectFinder.Self.GetAllElementsReferencingFile(referencedFileToRemove.Name); foreach (IElement element in elements) { if (regenerateCode) { CodeWriter.GenerateCode(element); } } } #endregion // November 10, 2015 // I feel like this may // have been old code before // we had full dependency tracking // in Glue. This file should only be // removed from the project if nothing // else references it, including no entities. // This code does just entities/screens/global // content, but doesn't check the full dependency // tree. I think we can just remove it and depend on // the code below. // Actually, removing this seems to cause problems - files // that should be removed aren't. So instead we'll chnage the // call to use the dependency tree: // replace: List <string> referencedFiles = GlueCommands.Self.FileCommands.GetAllReferencedFileNames().Select(item => item.ToLowerInvariant()).ToList(); string absoluteToLower = GlueCommands.Self.GetAbsoluteFileName(referencedFileToRemove).ToLowerInvariant(); string relativeToProject = FileManager.MakeRelative(absoluteToLower, GlueState.Self.ContentDirectory); bool isReferencedByOtherContent = referencedFiles.Contains(relativeToProject); if (isReferencedByOtherContent == false) { additionalFilesToRemove.Add(referencedFileToRemove.GetRelativePath()); string itemName = referencedFileToRemove.GetRelativePath(); string absoluteName = ProjectManager.MakeAbsolute(referencedFileToRemove.Name, true); // I don't know why we were removing the file from the ProjectBase - it should // be from the Content project //ProjectManager.RemoveItemFromProject(ProjectManager.ProjectBase, itemName); ProjectManager.RemoveItemFromProject(ProjectManager.ProjectBase.ContentProject, itemName, performSave: false); foreach (ProjectBase syncedProject in ProjectManager.SyncedProjects) { ProjectManager.RemoveItemFromProject(syncedProject.ContentProject, absoluteName); } } if (ProjectManager.IsContent(referencedFileToRemove.Name)) { UnreferencedFilesManager.Self.RefreshUnreferencedFiles(false); foreach (var file in UnreferencedFilesManager.LastAddedUnreferencedFiles) { additionalFilesToRemove.Add(file.FilePath); } } ReactToRemovalIfCsv(referencedFileToRemove, additionalFilesToRemove); GluxCommands.Self.SaveGlux(); }
private static EntitySave CreateEntityAndObjects(AddEntityWindow window, string entityName, string directory) { var gluxCommands = GlueCommands.Self.GluxCommands; var newElement = gluxCommands.EntityCommands.AddEntity( directory + entityName, is2D: true); GlueState.Self.CurrentElement = newElement; if (window.SpriteChecked) { AddObjectViewModel addObjectViewModel = new AddObjectViewModel(); addObjectViewModel.ObjectName = "SpriteInstance"; addObjectViewModel.SourceClassType = "Sprite"; addObjectViewModel.SourceType = SourceType.FlatRedBallType; gluxCommands.AddNewNamedObjectToSelectedElement(addObjectViewModel); GlueState.Self.CurrentElement = newElement; } if (window.TextChecked) { AddObjectViewModel addObjectViewModel = new AddObjectViewModel(); addObjectViewModel.ObjectName = "TextInstance"; addObjectViewModel.SourceClassType = "Text"; addObjectViewModel.SourceType = SourceType.FlatRedBallType; gluxCommands.AddNewNamedObjectToSelectedElement(addObjectViewModel); GlueState.Self.CurrentElement = newElement; } if (window.CircleChecked) { AddObjectViewModel addObjectViewModel = new AddObjectViewModel(); addObjectViewModel.ObjectName = "CircleInstance"; addObjectViewModel.SourceClassType = "Circle"; addObjectViewModel.SourceType = SourceType.FlatRedBallType; gluxCommands.AddNewNamedObjectToSelectedElement(addObjectViewModel); GlueState.Self.CurrentElement = newElement; } if (window.AxisAlignedRectangleChecked) { AddObjectViewModel addObjectViewModel = new AddObjectViewModel(); addObjectViewModel.ObjectName = "AxisAlignedRectangleInstance"; addObjectViewModel.SourceClassType = "AxisAlignedRectangle"; addObjectViewModel.SourceType = SourceType.FlatRedBallType; gluxCommands.AddNewNamedObjectToSelectedElement(addObjectViewModel); GlueState.Self.CurrentElement = newElement; } // There are a few important things to note about this function: // 1. Whenever gluxCommands.AddNewNamedObjectToSelectedElement is called, Glue performs a full // refresh and save. The reason for this is that gluxCommands.AddNewNamedObjectToSelectedElement // is the standard way to add a new named object to an element, and it may be called by other parts // of the code (and plugins) that expect the add to be a complete set of logic (add, refresh, save, etc). // This is less efficient than adding all of them and saving only once, but that would require a second add // method, which would add complexity. For now, we deal with the slower calls because it's not really noticeable. // 2. Some actions, like adding Points to a polygon, are done after the polygon is created and added, and that requires // an additional save. Therefore, we do one last save/refresh at the end of this method in certain situations. // Again, this is less efficient than if we performed just a single call, but a single call would be more complicated. // because we'd have to suppress all the other calls. bool needsRefreshAndSave = false; if (window.PolygonChecked) { AddObjectViewModel addObjectViewModel = new AddObjectViewModel(); addObjectViewModel.ObjectName = "PolygonInstance"; addObjectViewModel.SourceClassType = "Polygon"; addObjectViewModel.SourceType = SourceType.FlatRedBallType; var nos = gluxCommands.AddNewNamedObjectToSelectedElement(addObjectViewModel); CustomVariableInNamedObject instructions = null; instructions = nos.GetCustomVariable("Points"); if (instructions == null) { instructions = new CustomVariableInNamedObject(); instructions.Member = "Points"; nos.InstructionSaves.Add(instructions); } var points = new List <Vector2>(); points.Add(new Vector2(-16, 16)); points.Add(new Vector2(16, 16)); points.Add(new Vector2(16, -16)); points.Add(new Vector2(-16, -16)); points.Add(new Vector2(-16, 16)); instructions.Value = points; needsRefreshAndSave = true; GlueState.Self.CurrentElement = newElement; } if (window.IVisibleChecked) { newElement.ImplementsIVisible = true; needsRefreshAndSave = true; } if (window.IClickableChecked) { newElement.ImplementsIClickable = true; needsRefreshAndSave = true; } if (window.IWindowChecked) { newElement.ImplementsIWindow = true; needsRefreshAndSave = true; } if (window.ICollidableChecked) { newElement.ImplementsICollidable = true; needsRefreshAndSave = true; } if (needsRefreshAndSave) { MainGlueWindow.Self.PropertyGrid.Refresh(); ElementViewWindow.GenerateSelectedElementCode(); GluxCommands.Self.SaveGlux(); } return(newElement); }
public TreeNode MoveEntityOn(EntityTreeNode treeNodeMoving, TreeNode targetNode) { TreeNode newTreeNode = null; #region Moving the Entity into (or out of) a directory if (targetNode.IsDirectoryNode() || targetNode.IsRootEntityNode()) { MoveEntityToDirectory(treeNodeMoving, targetNode); } #endregion #region Moving an Entity onto another element to create an instance else if (targetNode.IsEntityNode() || targetNode.IsScreenNode() || targetNode.IsRootNamedObjectNode()) { bool isValidDrop = true; // Make sure that we don't drop an Entity into its own Objects if (targetNode.IsRootNamedObjectNode()) { if (treeNodeMoving == targetNode.GetContainingElementTreeNode()) { isValidDrop = false; } } if (isValidDrop) { newTreeNode = MoveEntityOntoElement(treeNodeMoving, targetNode, newTreeNode); } } #endregion #region Moving an Entity onto a NamedObject (currently supports only Lists) else if (targetNode.IsNamedObjectNode()) { // Allow drop only if it's a list or Layer NamedObjectSave targetNamedObjectSave = targetNode.Tag as NamedObjectSave; if (!targetNamedObjectSave.IsList && !targetNamedObjectSave.IsLayer) { MessageBox.Show("The target is not a List or Layer so we can't add an Object to it.", "Target not valid"); } if (targetNamedObjectSave.IsLayer) { TreeNode parent = targetNode.Parent; newTreeNode = MoveEntityOn(treeNodeMoving, parent); // this created a new NamedObjectSave. Let's put that on the Layer DragDropManager.Self.MoveNamedObject(newTreeNode, targetNode); } else { // Make sure that the two types match string listType = targetNamedObjectSave.SourceClassGenericType; bool isOfTypeOrInherits = listType == treeNodeMoving.EntitySave.Name || treeNodeMoving.EntitySave.InheritsFrom(listType); if (isOfTypeOrInherits == false) { MessageBox.Show("The target list type is of type\n\n" + listType + "\n\nBut the Entity is of type\n\n" + treeNodeMoving.EntitySave.Name + "\n\nCould not add an instance to the list", "Could not add instance"); } else { NamedObjectSave namedObject = new NamedObjectSave(); namedObject.InstanceName = FileManager.RemovePath(treeNodeMoving.EntitySave.Name) + "1"; StringFunctions.MakeNameUnique <NamedObjectSave>( namedObject, targetNamedObjectSave.ContainedObjects); // Not sure if we need to set this or not, but I think // any instance added to a list will not be defined by base namedObject.DefinedByBase = false; NamedObjectSaveExtensionMethodsGlue.AddNamedObjectToCurrentNamedObjectList(namedObject); ElementViewWindow.GenerateSelectedElementCode(); // Don't save the Glux, the caller of this method will take care of it // GluxCommands.Self.SaveGlux(); } } } #endregion else if (targetNode.IsGlobalContentContainerNode()) { AskAndAddAllContainedRfsToGlobalContent(treeNodeMoving.SaveObject); } return(newTreeNode); }
public void MoveNamedObject(TreeNode treeNodeMoving, TreeNode targetNode) { if (targetNode != null) { NamedObjectSave targetNos = targetNode.Tag as NamedObjectSave; NamedObjectSave movingNos = treeNodeMoving.Tag as NamedObjectSave; bool succeeded = false; if (targetNode == null) { // Didn't move on to anything } else if (targetNode.IsRootNamedObjectNode()) { succeeded = MoveObjectOnObjectsRoot(treeNodeMoving, targetNode, movingNos, succeeded); } else if (targetNode.IsRootCustomVariablesNode()) { MoveObjectOnRootCustomVariablesNode(treeNodeMoving, targetNode); } else if (targetNode.Tag is IElement) { succeeded = DragDropNosIntoElement(movingNos, targetNode.Tag as IElement); } else if (targetNode.IsRootEventsNode()) { succeeded = DragDropNosOnRootEventsNode(treeNodeMoving, targetNode); } else if (targetNos != null && targetNos.SourceType == SourceType.FlatRedBallType) { string targetClassType = targetNos.SourceClassType; #region Failure cases if (string.IsNullOrEmpty(targetClassType)) { MessageBox.Show("The target Object does not have a defined type. This operation is not valid"); } #endregion else if (targetClassType == "Layer") { // Only allow this if the NOS's are on the same object if (ObjectFinder.Self.GetElementContaining(movingNos) == ObjectFinder.Self.GetElementContaining(targetNos)) { succeeded = true; movingNos.LayerOn = targetNos.InstanceName; MainGlueWindow.Self.PropertyGrid.Refresh(); } } else if (targetClassType == "ShapeCollection") { succeeded = HandleDropOnShapeCollection(treeNodeMoving, targetNode, targetNos, movingNos); } else if (targetClassType == "PositionedObjectList<T>") { succeeded = HandleDropOnList(treeNodeMoving, targetNode, targetNos, movingNos); } } else { MessageBox.Show("Invalid movement"); } if (succeeded) { if (EditorLogic.CurrentElement != null) { ElementViewWindow.GenerateSelectedElementCode(); } else { GlobalContentCodeGenerator.UpdateLoadGlobalContentCode(); } ProjectManager.SaveProjects(); GluxCommands.Self.SaveGlux(); } } }
public void SetResetVariablesForEntitySave(EntitySave entitySave) { // set reset variables bool hasNamedObjectEntities = false; List <NamedObjectSave> skippedNoses = new List <NamedObjectSave>(); #region Loop through the NamedObjects to identify which variables should be added foreach (NamedObjectSave nos in entitySave.NamedObjects) { hasNamedObjectEntities |= AddResetVariablesFor(skippedNoses, nos); } // let's make sure to get all the NOS's that are defined in base types too: foreach (var element in entitySave.GetAllBaseEntities()) { foreach (NamedObjectSave nos in element.NamedObjects) { if (!nos.DefinedByBase && !nos.SetByDerived) { hasNamedObjectEntities |= AddResetVariablesFor(skippedNoses, nos); } } } if (skippedNoses.Count != 0) { string message = "Couldn't add reset variables for the following objects. This may cause pooling to behave improperly for these objects:"; foreach (NamedObjectSave skipped in skippedNoses) { message += "\n " + skipped.InstanceName; } MessageBox.Show(message); } #endregion #region See if there are any variables to add bool areAnyVariablesBeingAdded = false; foreach (KeyValuePair <NamedObjectSave, List <string> > kvp in mResetVariablesToAdd) { NamedObjectSave nos = kvp.Key; List <string> variables = kvp.Value; // reverse loop here because we're removing from the list for (int i = variables.Count - 1; i > -1; i--) { string variable = variables[i]; if (nos.VariablesToReset.Contains(variable)) { variables.Remove(variable); } else { areAnyVariablesBeingAdded = true; } } } #endregion #region If there are any variables, ask the user if resetting should be added if (areAnyVariablesBeingAdded) { DialogResult result = MessageBox.Show("Glue will add some best-guess variables to be reset " + "to the objects in your Entity. Existing variables will be preserved. You may " + "need to manually add additional variables depending on the logic contained in your Entity." + "\n\nAdd variables?", "Add Variables for " + entitySave.Name + "?", MessageBoxButtons.YesNo); if (result == DialogResult.Yes) { foreach (KeyValuePair <NamedObjectSave, List <string> > kvp in mResetVariablesToAdd) { NamedObjectSave nos = kvp.Key; List <string> variables = kvp.Value; foreach (string s in variables) { Plugins.PluginManager.ReceiveOutput("Added reset variable " + s + " in object " + nos); } nos.VariablesToReset.AddRange(variables); } } GluxCommands.Self.SaveGlux(); ElementViewWindow.GenerateSelectedElementCode(); } else { Plugins.PluginManager.ReceiveOutput("No reset variables added to " + entitySave); } #endregion #region As the user if Glue should reset variables for all NamedObjects which are Entities if (hasNamedObjectEntities) { DialogResult result = MessageBox.Show( "Would you like to set reset variables for all contained objects which reference Entities inside " + entitySave.Name + "? This " + "action is recommended.", "Reset objects referencing Entities?", MessageBoxButtons.YesNo); if (result == DialogResult.Yes) { foreach (NamedObjectSave nos in entitySave.NamedObjects) { if (nos.SourceType == SourceType.Entity) { EntitySave containedEntitySave = nos.GetReferencedElement() as EntitySave; if (containedEntitySave != null) { SetResetVariablesForEntitySave(containedEntitySave); } } } } } #endregion #region Check for inheritance and ask if all derived Entities should have their variables reset too List <EntitySave> inheritingEntities = ObjectFinder.Self.GetAllEntitiesThatInheritFrom(entitySave); if (inheritingEntities.Count != 0) { string message = "Would you like to set reset variables for Entities which inherit from " + entitySave.Name + "? " + "The following Entities will be modified:\n\n"; foreach (EntitySave inheritingEntity in inheritingEntities) { message += inheritingEntity.Name + "\n"; } message += "\nThis " + "action is recommended."; DialogResult result = MessageBox.Show(message, "Reset Entites inheriting from this?", MessageBoxButtons.YesNo); if (result == DialogResult.Yes) { foreach (EntitySave inheritingEntity in inheritingEntities) { SetResetVariablesForEntitySave(inheritingEntity); } } } #endregion foreach (NamedObjectSave nos in entitySave.NamedObjects) { StringFunctions.RemoveDuplicates(nos.VariablesToReset); } CodeWriter.GenerateCode(entitySave); foreach (var element in entitySave.GetAllBaseEntities()) { CodeWriter.GenerateCode(element); } GluxCommands.Self.SaveGlux(); }