public IElement GetElementContaining(EventResponseSave ers) { for (int i = 0; i < ObjectFinder.Self.GlueProject.Screens.Count; i++) { foreach (EventResponseSave possibleErs in ObjectFinder.Self.GlueProject.Screens[i].Events) { if (possibleErs == ers) { return(ObjectFinder.Self.GlueProject.Screens[i]); } } } for (int i = 0; i < ObjectFinder.Self.GlueProject.Entities.Count; i++) { foreach (EventResponseSave possibleErs in ObjectFinder.Self.GlueProject.Entities[i].Events) { if (possibleErs == ers) { return(ObjectFinder.Self.GlueProject.Entities[i]); } } } return(null); }
private void SaveText() { if (EditorLogic.CurrentEventResponseSave != null && mIsCodeValid) { IElement currentElement = EditorLogic.CurrentElement; EventResponseSave currentEvent = EditorLogic.CurrentEventResponseSave; if (this.syntaxBoxControl1.Document.Text != mLastSavedText) { if (HasMatchingBrackets(this.syntaxBoxControl1.Document.Text)) { mLastSavedText = this.syntaxBoxControl1.Document.Text; EventCodeGenerator.InjectTextForEventAndSaveCustomFile(currentElement, EditorLogic.CurrentEventResponseSave, mLastSavedText); PluginManager.ReceiveOutput("Saved " + EditorLogic.CurrentEventResponseSave); GlueCommands.Self.GenerateCodeCommands.GenerateCurrentElementCode(); GluxCommands.Self.SaveGlux(); } else { PluginManager.ReceiveError("Mismatch of } and { in event " + EditorLogic.CurrentEventResponseSave); } } } }
private void GetEventSignatureAndArgs(NamedObjectSave namedObjectSave, EventResponseSave eventResponseSave, out string type, out string signatureArgs) { if (namedObjectSave == null) { throw new ArgumentNullException(nameof(namedObjectSave)); } if (namedObjectSave.GetAssetTypeInfo() == AssetTypeInfoManager.Self.CollisionRelationshipAti && eventResponseSave.SourceObjectEvent == "CollisionOccurred") { bool firstThrowaway; bool secondThrowaway; var firstType = AssetTypeInfoManager.GetFirstGenericType(namedObjectSave, out firstThrowaway); var secondType = AssetTypeInfoManager.GetSecondGenericType(namedObjectSave, out secondThrowaway); type = $"System.Action<{firstType}, {secondType}>"; signatureArgs = $"{firstType} first, {secondType} second"; } else { type = null; signatureArgs = null; } }
public void ReactToChange(string changedMember, object oldValue, EventResponseSave ers, IElement container) { if (changedMember == "EventName") { ReactToEventRename(oldValue, ers, container); } }
public void SetBackingObjects(IElement element, EventResponseSave eventResponse) { mElement = element; mEventResponse = eventResponse; RefreshLists(); }
void HandleAfterVariableSet(object sender, VariableSetArgs e) { try { if (mControl != null && mControl.Enabled) { ElementRuntime elementRuntime = sender as ElementRuntime; // If the user has just selected the element runtime,then it hasn't been set // as the current element yet, so we can't use the GlueViewState facade // IElement element = GlueViewState.Self.CurrentElement; IElement element = elementRuntime.AssociatedIElement; if (element != null) { string variableName = e.VariableName; EventResponseSave ers = element.GetEvent("After" + variableName + "Set"); if (ers != null) { mParserLog.AppendLine("Reacting to after " + e.VariableName + " Set in the file :\n\t\t" + EventResponseSave.GetSharedCodeFullFileName(element, FileManager.GetDirectory(GlueViewState.Self.CurrentGlueProjectFile))); ApplyEventResponseSave(elementRuntime, ers); } } } } catch (Exception exception) { int m = 3; } }
private TreeNode FindEventResponseSaveInEntities(EventResponseSave eventResponse, TreeNodeCollection nodeCollection) { TreeNode foundNode = null; foreach (TreeNode treeNode in nodeCollection) { if (treeNode is EntityTreeNode) { foundNode = ((EntityTreeNode)treeNode).GetTreeNodeFor(eventResponse); if (foundNode != null) { break; } } else { foundNode = FindEventResponseSaveInEntities(eventResponse, treeNode.Nodes); if (foundNode != null) { break; } } } return(foundNode); }
internal void HandleEventRemoved(IElement element, EventResponseSave eventResponse) { bool hasAnyEvents = element.Events.Count > 0; if (!hasAnyEvents) { RemoveEventGeneratedCodefile(element); } }
private static void SetUpCodeEditorForEventResponse() { EventResponseSave ers = EditorLogic.CurrentEventResponseSave; EventSave eventSave = ers.GetEventSave(); string args = ers.GetArgsForMethod(EditorLogic.CurrentElement); MainGlueWindow.Self.CodeEditor.TopText = "void On" + ers.EventName + "(" + args + ")\n{"; MainGlueWindow.Self.CodeEditor.BottomText = "}"; }
public TreeNode GetTreeNodeFor(EventResponseSave eventResponse) { foreach (TreeNode treeNode in this.mEventsTreeNode.Nodes) { if (treeNode.Tag == eventResponse) { return(treeNode); } } return(null); }
private void ApplyEventResponseSave(ElementRuntime elementRuntime, EventResponseSave ers) { IElement element = elementRuntime.AssociatedIElement; string projectDirectory = FileManager.GetDirectory(GlueViewState.Self.CurrentGlueProjectFile); string[] lines = GetMethodLines(element, ers, projectDirectory); string fileName = EventResponseSave.GetSharedCodeFullFileName(element, projectDirectory); CodeContext codeContext = new CodeContext(elementRuntime); ApplyLinesInternal(lines, 0, lines.Length, element, codeContext, fileName); }
public void Initialize() { OverallInitializer.Initialize(); mEntitySave = new EntitySave(); mEntitySave.ImplementsIWindow = true; mEntitySave.Name = "EventTestEntity"; mEntitySave.ImplementsIWindow = true; ObjectFinder.Self.GlueProject.Entities.Add(mEntitySave); mScreenSave = new ScreenSave(); mScreenSave.Name = "EventTestScreen"; ObjectFinder.Self.GlueProject.Screens.Add(mScreenSave); NamedObjectSave nos = new NamedObjectSave(); nos.SourceType = SourceType.Entity; nos.SourceClassType = "EventTestEntity"; mScreenSave.NamedObjects.Add(nos); EventResponseSave ers = new EventResponseSave(); ers.SourceObject = "EventTestEntity"; ers.SourceObjectEvent = "Click"; ers.EventName = "EventTestEntityClick"; mScreenSave.Events.Add(ers); EventResponseSave pushErs = new EventResponseSave(); pushErs.SourceObject = "EventTestEntity"; pushErs.SourceObjectEvent = "Push"; pushErs.EventName = "EventTestEntityPush"; mScreenSave.Events.Add(pushErs); // Create a POList so we can expose its event(s) mListNos = new NamedObjectSave(); mListNos.SourceType = SourceType.FlatRedBallType; mListNos.SourceClassType = "PositionedObjectList<T>"; mListNos.SourceClassGenericType = "Sprite"; mScreenSave.NamedObjects.Add(mListNos); mDerivedEntitySave = new EntitySave(); mDerivedEntitySave.Name = "EventTestsDerivedEntity"; mDerivedEntitySave.BaseEntity = mEntitySave.Name; ObjectFinder.Self.GlueProject.Entities.Add(mDerivedEntitySave); }
private void SetEventValue(string categoryString, IEventContainer eventContainer, string value) { switch (categoryString) { case "Active Events": EventResponseSave eventToModify = null; for (int i = eventContainer.Events.Count - 1; i > -1; i--) { if (eventContainer.Events[i].EventName == this.Name) { eventToModify = eventContainer.Events[i]; break; } } if (eventToModify == null) { throw new Exception("Could not find an event by the name of " + Name); } else { string valueAsString = value; if (string.IsNullOrEmpty(valueAsString) || valueAsString == "<NONE>") { eventContainer.Events.Remove(eventToModify); } else { //eventToModify.InstanceMethod = valueAsString; } } //EventSave eventSave = EditorLogic.Current break; case "Unused Events": //EventSave eventSave = EventManager.AllEvents[Name]; //eventSave.InstanceMethod = value; //EditorLogic.CurrentEventContainer.Events.Add(eventSave); break; } }
void HandleResolutionChange(ElementRuntime elementRuntime) { if (elementRuntime != null) { IElement element = elementRuntime.AssociatedIElement; if (element != null) { EventResponseSave ers = element.GetEvent("ResolutionOrOrientationChanged"); if (ers != null) { ApplyEventResponseSave(elementRuntime, ers); } } } }
private void UpdateIncludedAndExcluded(EventResponseSave instance) { ////////////////////Early Out///////////////////////// if (instance == null) { return; } ///////////////////End Early Out/////////////////////// ResetToDefault(); ExcludeMember("ToStringDelegate"); ExcludeMember("Contents"); AvailableCustomVariables typeConverter = new AvailableCustomVariables(CurrentElement); typeConverter.IncludeNone = false; typeConverter.InclusionPredicate = DoesCustomVariableCreateEvent; IncludeMember(typeof(EventResponseSave).GetProperty("SourceVariable").Name, typeof(EventResponseSave), typeConverter); if (string.IsNullOrEmpty(instance.SourceVariable)) { ExcludeMember(typeof(EventResponseSave).GetProperty("BeforeOrAfter").Name); } AvailableNamedObjectsAndFiles availableNamedObjects = new AvailableNamedObjectsAndFiles( CurrentElement); availableNamedObjects.IncludeReferencedFiles = false; IncludeMember(typeof(EventResponseSave).GetProperty("SourceObject").Name, typeof(EventResponseSave), availableNamedObjects); AvailableEvents availableEvents = new AvailableEvents(); availableEvents.Element = CurrentElement; availableEvents.NamedObjectSave = CurrentElement.GetNamedObjectRecursively(instance.SourceObject); IncludeMember(typeof(EventResponseSave).GetProperty("SourceObjectEvent").Name, typeof(EventResponseSave), availableEvents); }
private string[] GetMethodLines(IElement element, EventResponseSave ers, string projectDirectory) { string[] toReturn = null; lock (mCachedMethodLines) { if (!mCachedMethodLines.ContainsKey(ers.EventName)) { ParsedMethod parsedMethod = ers.GetParsedMethodFromAssociatedFile(element, projectDirectory); string[] lines = parsedMethod.MethodContents.Split(separators, StringSplitOptions.RemoveEmptyEntries); mCachedMethodLines.Add(ers.EventName, lines); } toReturn = mCachedMethodLines[ers.EventName]; } return(toReturn); }
public void TestRenamingEvents() { EventResponseSave ers = new EventResponseSave(); ers.EventName = "Whatever"; ers.DelegateType = "System.EventHandler"; mEntitySave.Events.Add(ers); string fileName = ers.GetSharedCodeFullFileName(); if (File.Exists(fileName)) { File.Delete(fileName); } string directory = FileManager.CurrentDirectory + fileName; string contents = "int m = 33;"; string contentsFileName = EventCodeGenerator.InjectTextForEventAndSaveCustomFile( mEntitySave, ers, contents); string entireFileContents = FileManager.FromFileText(contentsFileName); // Make sure that this file contains the contents if (!entireFileContents.Contains(contents)) { throw new Exception("The entire files aren't being added to the event"); } // Test renaming now string oldName = ers.EventName; string newName = "AfterRename"; ers.EventName = newName; // I can't write unit tests for this yet because it requires that // all generate code be moved out of BaseElementTreeNode into CodeWriter: //EventResponseSavePropertyChangeHandler.Self.ReactToChange("EventName", oldName, ers, mEntitySave); //entireFileContents = FileManager.FromFileText(contentsFileName); }
public TreeNode EventResponseTreeNode(EventResponseSave eventResponse) { TreeNode foundNode = null; foreach (ScreenTreeNode treeNode in ElementViewWindow.ScreensTreeNode.Nodes) { foundNode = treeNode.GetTreeNodeFor(eventResponse); if (foundNode != null) { return(foundNode); } } TreeNodeCollection nodeCollection = ElementViewWindow.EntitiesTreeNode.Nodes; foundNode = FindEventResponseSaveInEntities(eventResponse, nodeCollection); return(foundNode); }
public static ICodeBlock FillWithGeneratedEventCode(ICodeBlock currentBlock, EventResponseSave ers, IElement element) { EventSave eventSave = ers.GetEventSave(); string args = ers.GetArgsForMethod(element); if (!string.IsNullOrEmpty(ers.SourceObject) && !string.IsNullOrEmpty(ers.SourceObjectEvent)) { currentBlock = currentBlock .Function("void", "On" + ers.EventName + "Tunnel", args); string reducedArgs = StripTypesFromArguments(args); currentBlock.If("this." + ers.EventName + " != null") .Line(ers.EventName + "(" + reducedArgs + ");") .End(); currentBlock = currentBlock.End(); } return(currentBlock); }
internal void ReactToScreenChangedValue(string changedMember, object oldValue) { ScreenSave screenSave = EditorLogic.CurrentScreenSave; #region Name if (changedMember == "ClassName") { ReactToChangedClassName(oldValue, screenSave); } #endregion #region BaseScreen else if (changedMember == "BaseScreen") { if (ProjectManager.VerifyInheritanceGraph(screenSave) == ProjectManager.CheckResult.Failed) { screenSave.BaseScreen = (string)oldValue; } else { screenSave.UpdateFromBaseType(); } } #endregion EventResponseSave eventSave = screenSave.GetEvent(changedMember); if (eventSave != null) { //if (!string.IsNullOrEmpty(eventSave.InstanceMethod) && EditorLogic.CurrentElement != null) //{ // InsertMethodCallInElementIfNecessary(EditorLogic.CurrentScreenSave, eventSave.InstanceMethod); //} } }
public static ICodeBlock FillWithCustomEventCode(ICodeBlock currentBlock, EventResponseSave ers, string contents, IElement element) { string args = ers.GetArgsForMethod(element); // We used to not // generate the empty // shell of an event if // the contents were empty. // However now we want to for // two reasons: // 1: A user may want to add an // event in Glue, but then mdoify // the event in Visual Studio. The // user shouldn't be forced into adding // some content in Glue first to wdit the // event in Visual Studio. // 2: A designer may decide to remove the // contents of a method. If this happens then // code that the designer doesn't work with shouldn't // break (IE, if the code calls the OnXXXX method). //if (!string.IsNullOrEmpty(contents)) { // Need to modify the event CSV to include the arguments for this event currentBlock = currentBlock .Function("void", "On" + ers.EventName, args); currentBlock.TabCharacter = ""; int tabCount = currentBlock.TabCount; currentBlock.TabCount = 0; currentBlock .Line(contents); currentBlock = currentBlock.End(); } return(currentBlock); }
private void UpdateEventsTreeNode() { while (this.mEventsTreeNode.Nodes.Count < mSaveObject.Events.Count) { int indexAddingAt = mEventsTreeNode.Nodes.Count; TreeNode newNode = mEventsTreeNode.Nodes.Add(mSaveObject.Events[indexAddingAt].EventName); newNode.ImageKey = "edit_code.png"; newNode.SelectedImageKey = "edit_code.png"; } while (this.mEventsTreeNode.Nodes.Count > mSaveObject.Events.Count) { mEventsTreeNode.Nodes.RemoveAt(mEventsTreeNode.Nodes.Count - 1); } for (int i = 0; i < mSaveObject.Events.Count; i++) { TreeNode treeNode = mEventsTreeNode.Nodes[i]; EventResponseSave eventSave = mSaveObject.Events[i]; if (treeNode.Tag != eventSave) { treeNode.Tag = eventSave; } string textToSet = eventSave.EventName; if (treeNode.Text != textToSet) { treeNode.Text = textToSet; } } }
public void UpdateDisplayToCurrentObject() { string fullFileName = "<Unable to get file name>"; try { EventResponseSave eventResponseSave = EditorLogic.CurrentEventResponseSave; IElement element = EditorLogic.CurrentElement; fullFileName = eventResponseSave.GetSharedCodeFullFileName(); string contents = FileManager.FromFileText(fullFileName); CSharpParser parser = new CSharpParser(); SyntaxTree syntaxTree = parser.Parse(contents); mIsCodeValid = syntaxTree.Errors.Count == 0; if (mIsCodeValid) { ParsedMethod parsedMethod = eventResponseSave.GetParsedMethodFromAssociatedFile(); string textToAssign = null; if (parsedMethod == null) { textToAssign = eventResponseSave.GetEventContents(); } else { StringBuilderDocument document = new StringBuilderDocument(contents); bool wasFound; textToAssign = GetMethodContentsFor(syntaxTree, document, eventResponseSave.EventName, out wasFound); if (wasFound) { textToAssign = textToAssign.Replace("\n", "\r\n"); } else { mIsCodeValid = false; textToAssign = "Could not find the method, or encountered a parse error."; } } textToAssign = RemoveWhiteSpaceForCodeWindow(textToAssign); this.syntaxBoxControl1.Document.Text = textToAssign; mLastSavedText = this.syntaxBoxControl1.Document.Text; } else { this.syntaxBoxControl1.Document.Text = "This code file is not a complete code file:\n" + fullFileName + "\nGlue is unable to parse it. Please correct the problems in Visual Studio"; } } catch (Exception e) { mIsCodeValid = false; this.syntaxBoxControl1.Document.Text = "Error parsing file:\n" + fullFileName + "\nMore details:\n\n" + e.ToString(); } }
/// <summary> /// Injects the insideOfMethod into an event for the argument /// </summary> /// <param name="currentElement">The IElement containing the EventResponseSave.</param> /// <param name="eventResponseSave">The EventResponseSave which should have its contents set or replaced.</param> /// <param name="insideOfMethod">The inside of the methods to assign.</param> /// <returns>The full file name which contains the method contents.</returns> public static string InjectTextForEventAndSaveCustomFile(IElement currentElement, EventResponseSave eventResponseSave, string insideOfMethod) { // In case the user passes null we don't want to have null reference exceptions: if (insideOfMethod == null) { insideOfMethod = ""; } ParsedMethod parsedMethod = eventResponseSave.GetParsedMethodFromAssociatedFile(); string fullFileName = eventResponseSave.GetSharedCodeFullFileName(); bool forceRegenerate = false; string fileContents = null; if (File.Exists(fullFileName)) { fileContents = FileManager.FromFileText(fullFileName); forceRegenerate = fileContents.Contains("public partial class") == false && fileContents.Contains("{") == false; if (forceRegenerate) { GlueGui.ShowMessageBox("Forcing a regneration of " + fullFileName + " because it appears to be empty."); } } CreateEmptyCodeIfNecessary(currentElement, fullFileName, forceRegenerate); fileContents = FileManager.FromFileText(fullFileName); int indexToAddAt = 0; if (parsedMethod != null) { int startIndex; int endIndex; GetStartAndEndIndexForMethod(parsedMethod, fileContents, out startIndex, out endIndex); // We want to include the \r\n at the end, so add 2 endIndex += 2; string whatToRemove = fileContents.Substring(startIndex, endIndex - startIndex); fileContents = fileContents.Replace(whatToRemove, null); indexToAddAt = startIndex; // remove the method to re-add it } else { indexToAddAt = EventManager.GetLastLocationInClass(fileContents, startOfLine: true); } ICodeBlock codeBlock = new CodeDocument(2); codeBlock.TabCharacter = " "; insideOfMethod = "" + insideOfMethod.Replace("\r\n", "\r\n "); codeBlock = EventCodeGenerator.FillWithCustomEventCode(codeBlock, eventResponseSave, insideOfMethod, currentElement); string methodContents = codeBlock.ToString(); fileContents = fileContents.Insert(indexToAddAt, codeBlock.ToString()); eventResponseSave.Contents = null; try { FlatRedBall.Glue.IO.FileWatchManager.IgnoreNextChangeOnFile(fullFileName); FileManager.SaveText(fileContents, fullFileName); } catch (Exception e) { PluginManager.ReceiveError("Could not save file to " + fullFileName); } return(fullFileName); }
private static void ReactToEventRename(object oldValue, EventResponseSave ers, IElement container) { string oldName = oldValue as string; string newName = ers.EventName; // The code // inside this // event handler // are saved in the // Element.Event.cs file // so that it can be edited // in Visual Studio. If the // EventResponseSave changes then // it will use a new method. We need // to take out the old method and move // the contents to the new method. // We'll "cheat" by setting the name to the old // one and getting the contents, then switching it // back to the new: string fullFileName = ers.GetSharedCodeFullFileName(); if (!System.IO.File.Exists(fullFileName)) { PluginManager.ReceiveError("Could not find the file " + fullFileName); } else if (CodeEditorControl.DetermineIfCodeFileIsValid(fullFileName) == false) { PluginManager.ReceiveError("Invalid code file " + fullFileName); } else { ers.EventName = oldName; string contents = CodeEditorControl.RemoveWhiteSpaceForCodeWindow(ers.GetEventContents()); ers.EventName = newName; // Now save the contents into the new method: if (string.IsNullOrEmpty(contents) || CodeEditorControl.HasMatchingBrackets(contents)) { EventCodeGenerator.InjectTextForEventAndSaveCustomFile( container, ers, contents); PluginManager.ReceiveOutput("Saved " + ers); GlueCommands.Self.GenerateCodeCommands.GenerateCurrentElementCode(); DialogResult result = MessageBox.Show("Would you like to delete the old method On" + oldName + "?", "Delete old function?", MessageBoxButtons.YesNo); if (result == DialogResult.Yes) { int startIndex; int endIndex; contents = FileManager.FromFileText(fullFileName); EventCodeGenerator.GetStartAndEndIndexForMethod(contents, "On" + oldName, out startIndex, out endIndex); contents = contents.Remove(startIndex, endIndex - startIndex); FileManager.SaveText(contents, fullFileName); } } else { PluginManager.ReceiveError("Mismatch of } and { in event " + ers); } } }
public static void RemoveNamedObject(NamedObjectSave namedObjectToRemove, bool performSave, bool updateUi, List <string> additionalFilesToRemove) { StringBuilder removalInformation = new StringBuilder(); // The additionalFilesToRemove is included for consistency with other methods. It may be used later // There are the following things that need to happen: // 1. Remove the NamedObject from the Glue project (GLUX) // 2. Remove any variables that use this NamedObject as their source // 3. Remove the named object from the GUI // 4. Update the variables for any NamedObjects that use this element containing this NamedObject // 5. Find any Elements that contain NamedObjects that are DefinedByBase - if so, see if we should remove those or make them not DefinedByBase // 6. Remove any events that tunnel into this. IElement element = namedObjectToRemove.GetContainer(); if (element != null) { if (!namedObjectToRemove.RemoveSelfFromNamedObjectList(element.NamedObjects)) { throw new ArgumentException(); } #region Remove all CustomVariables that reference the removed NamedObject for (int i = element.CustomVariables.Count - 1; i > -1; i--) { CustomVariable variable = element.CustomVariables[i]; if (variable.SourceObject == namedObjectToRemove.InstanceName) { removalInformation.AppendLine("Removed variable " + variable.ToString()); element.CustomVariables.RemoveAt(i); } } #endregion // Remove any events that use this for (int i = element.Events.Count - 1; i > -1; i--) { EventResponseSave ers = element.Events[i]; if (ers.SourceObject == namedObjectToRemove.InstanceName) { removalInformation.AppendLine("Removed event " + ers.ToString()); element.Events.RemoveAt(i); } } // Remove any objects that use this as a layer for (int i = 0; i < element.NamedObjects.Count; i++) { if (element.NamedObjects[i].LayerOn == namedObjectToRemove.InstanceName) { removalInformation.AppendLine("Removed the following object from the deleted Layer: " + element.NamedObjects[i].ToString()); element.NamedObjects[i].LayerOn = null; } } element.RefreshStatesToCustomVariables(); #region Ask the user what to do with all NamedObjects that are DefinedByBase List <IElement> derivedElements = new List <IElement>(); if (element is EntitySave) { derivedElements.AddRange(ObjectFinder.Self.GetAllEntitiesThatInheritFrom(element as EntitySave)); } else { derivedElements.AddRange(ObjectFinder.Self.GetAllScreensThatInheritFrom(element as ScreenSave)); } foreach (IElement derivedElement in derivedElements) { // At this point, namedObjectToRemove is already removed from the current Element, so this will only // return NamedObjects that exist in the derived. NamedObjectSave derivedNamedObject = derivedElement.GetNamedObjectRecursively(namedObjectToRemove.InstanceName); if (derivedNamedObject != null && derivedNamedObject != namedObjectToRemove && derivedNamedObject.DefinedByBase) { MultiButtonMessageBox mbmb = new MultiButtonMessageBox(); mbmb.MessageText = "What would you like to do with the object " + derivedNamedObject.ToString(); mbmb.AddButton("Keep it", DialogResult.OK); mbmb.AddButton("Delete it", DialogResult.Cancel); DialogResult result = mbmb.ShowDialog(MainGlueWindow.Self); if (result == DialogResult.OK) { // Keep it derivedNamedObject.DefinedByBase = false; BaseElementTreeNode treeNode = GlueState.Self.Find.ElementTreeNode(derivedElement); if (updateUi) { treeNode.UpdateReferencedTreeNodes(); } CodeWriter.GenerateCode(derivedElement); } else { // Delete it RemoveNamedObject(derivedNamedObject, performSave, updateUi, additionalFilesToRemove); } } } #endregion var elementTreeNode = GlueState.Self.Find.ElementTreeNode(element); if (updateUi) { elementTreeNode.UpdateReferencedTreeNodes(); } CodeWriter.GenerateCode(element); if (element is EntitySave) { List <NamedObjectSave> entityNamedObjects = ObjectFinder.Self.GetAllNamedObjectsThatUseEntity(element.Name); foreach (NamedObjectSave nos in entityNamedObjects) { nos.UpdateCustomProperties(); } } } if (performSave) { GluxCommands.Self.SaveGlux(); } }
public override object GetValue(object component) { if (Owner != null) { if (Owner is FileAssociationSettings) { return(((FileAssociationSettings)Owner).GetApplicationForExtension(this.Name)); } else { return(null); } } #region StateSave if (EditorLogic.CurrentStateSave != null) { return(EditorLogic.CurrentStateSave.GetValue(this.Name)); } #endregion #region NamedObjectSave else if (EditorLogic.CurrentNamedObject != null) { NamedObjectSave asNamedObject = EditorLogic.CurrentNamedObject; if (this.Attributes.Count > 0 && this.Attributes[0] is CategoryAttribute) { string category = ((CategoryAttribute)this.Attributes[0]).Category; switch (category) { case "Active Events": EventSave eventSave = asNamedObject.GetEvent(Name); if (eventSave != null) { return(eventSave.InstanceMethod); } else { return(""); } //break; case "Unused Events": return(""); //break; case "Custom Variable Set Events": return(EditorLogic.CurrentNamedObject.GetCustomVariable(this.Name.Replace(" Set", "")).EventOnSet); //break; default: return(EditorLogic.CurrentNamedObject.GetPropertyValue(this.Name)); } } else { return(EditorLogic.CurrentNamedObject.GetPropertyValue(this.Name)); } } #endregion #region CustomVariable else if (EditorLogic.CurrentCustomVariable != null) { if (EditorLogic.CurrentEntitySave != null) { return(EditorLogic.CurrentEntitySave.GetPropertyValue(EditorLogic.CurrentCustomVariable.Name)); } else { return(EditorLogic.CurrentScreenSave.GetPropertyValue(EditorLogic.CurrentCustomVariable.Name)); } } #endregion #region ScreenSave else if (EditorLogic.CurrentScreenSave != null) { if (this.Attributes.Count > 0 && this.Attributes[0] is CategoryAttribute) { string category = ((CategoryAttribute)this.Attributes[0]).Category; switch (category) { case "Active Events": EventResponseSave eventSave = EditorLogic.CurrentScreenSave.GetEvent(Name); //if (eventSave != null) //{ // return eventSave.InstanceMethod; //} //else { return(""); } case "Unused Events": return(""); default: return(""); } } return(""); } #endregion #region EntitySave else if (EditorLogic.CurrentEntitySave != null) { return(EditorLogic.CurrentEntitySave.GetPropertyValue(this.Name)); } #endregion else { return(null); } }
private void HandleGetEventSignatureArgs(NamedObjectSave namedObject, EventResponseSave eventResponseSave, out string type, out string args) { EventCodeGenerator.Self.HandleGetEventSignatureArgs(namedObject, eventResponseSave, out type, out args); }
private static void GenerateInitializeForEvent(ICodeBlock codeBlock, IElement element, EventResponseSave ers) { bool wasEventAdded = false; //We always want this to happen, even if it's // emtpy //if (!string.IsNullOrEmpty(ers.Contents)) //{ NamedObjectSave sourceNos = null; bool shouldCloseIfStatementForNos = false; if (!string.IsNullOrEmpty(ers.SourceVariable)) { // This is tied to a variable, so the name comes from the variable event rather than the // event name itself string eventName = ers.BeforeOrAfter.ToString() + ers.SourceVariable + "Set"; codeBlock.Line("this." + eventName + " += On" + ers.EventName + ";"); wasEventAdded = true; } else if (string.IsNullOrEmpty(ers.SourceObject) || ers.SourceObject == "<NONE>") { string leftSide = null; EventSave eventSave = ers.GetEventSave(); if (eventSave == null || string.IsNullOrEmpty(eventSave.ExternalEvent)) { leftSide = "this." + ers.EventName; } else { leftSide = eventSave.ExternalEvent; } codeBlock.Line(leftSide + " += On" + ers.EventName + ";"); wasEventAdded = true; } else if (!string.IsNullOrEmpty(ers.SourceObjectEvent)) { // Only append this if the source NOS is fully-defined. If not, we don't want to generate compile errors. sourceNos = element.GetNamedObject(ers.SourceObject); if (sourceNos != null && sourceNos.IsFullyDefined) { NamedObjectSaveCodeGenerator.AddIfConditionalSymbolIfNecesssary(codeBlock, sourceNos); string leftSide = null; leftSide = ers.SourceObject + "." + ers.SourceObjectEvent; codeBlock.Line(leftSide + " += On" + ers.EventName + ";"); wasEventAdded = true; shouldCloseIfStatementForNos = true; } } if (!string.IsNullOrEmpty(ers.SourceObject) && !string.IsNullOrEmpty(ers.SourceObjectEvent) && wasEventAdded) { codeBlock.Line(ers.SourceObject + "." + ers.SourceObjectEvent + " += On" + ers.EventName + "Tunnel;"); if (shouldCloseIfStatementForNos) { NamedObjectSaveCodeGenerator.AddEndIfIfNecessary(codeBlock, sourceNos); } } }
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 } }