public void ReactToChange(string changedMember, object oldValue, EventResponseSave ers, IElement container) { if (changedMember == "EventName") { ReactToEventRename(oldValue, ers, container); } }
/// <summary> /// Gets associated EventSave that comes from BuiltInEvents.csv. This may be null /// if the EventResponseSave is an event responding to a changed variable. /// </summary> public static EventSave GetEventSave(this EventResponseSave instance) { EventSave toReturn = null; string key = ""; if (!string.IsNullOrEmpty(instance.SourceObject) && !string.IsNullOrEmpty(instance.SourceObjectEvent)) { key = instance.SourceObjectEvent; IElement container = ObjectFinder.Self.GetElementContaining(instance); if (container != null) { NamedObjectSave nos = container.GetNamedObjectRecursively(instance.SourceObject); #if GLUE string type; string args; FlatRedBall.Glue.Plugins.PluginManager.GetEventSignatureArgs(nos, instance, out type, out args); if (type != null) { toReturn = new EventSave(); toReturn.Arguments = args; toReturn.DelegateType = type; } #endif if (toReturn == null && nos != null && nos.SourceType == SourceType.Entity) { // This may be a tunnel into a tunneled event FlatRedBall.Glue.SaveClasses.IElement element = ObjectFinder.Self.GetIElement(nos.SourceClassType); if (element != null) { foreach (EventResponseSave ers in element.Events) { if (ers.EventName == instance.SourceObjectEvent) { toReturn = ers.GetEventSave(); break; } } } } } } else { key = instance.EventName; } if (toReturn == null && EventManager.AllEvents.ContainsKey(key)) { toReturn = EventManager.AllEvents[key]; } return(toReturn); }
public static IElement GetContainer(this EventResponseSave instance) { if (ObjectFinder.Self.GlueProject != null) { return(ObjectFinder.Self.GetElementContaining(instance)); } else { return(null); } }
public static string GetSharedCodeFullFileName(this EventResponseSave instance) { var container = instance.GetContainer(); if (container != null) { return(FileManager.GetDirectory(ProjectManager.GlueProjectFileName) + EventResponseSave.GetEventFileNameForElement(instance.GetContainer())); } else { return(null); } }
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 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); }
public static string GetEventContents(this EventResponseSave instance) { IElement element = instance.GetContainer(); string textToAssign = null; if (FacadeContainer.Self.GlueState.CurrentEventResponseSave != null) { if (!string.IsNullOrEmpty(instance.Contents)) { textToAssign = instance.Contents; } else { // Is there a non-Generated.Event.cs file? string fileToLookFor = FileManager.RelativeDirectory + EventResponseSave.GetEventFileNameForElement(element); if (File.Exists(fileToLookFor)) { ParsedMethod parsedMethod = instance.GetParsedMethodFromAssociatedFile(); if (parsedMethod != null) { textToAssign = parsedMethod.MethodContents; } } } } else { textToAssign = null; } return(textToAssign); }
public static string GetEffectiveDelegateType(this EventResponseSave ers, IElement containingElement) { if (ers.GetIsTunneling()) { IElement tunneledElement; EventResponseSave tunneledTo = ers.GetEventThisTunnelsTo(containingElement, out tunneledElement); if (tunneledTo != null) { return(tunneledTo.GetEffectiveDelegateType(tunneledElement)); } } EventSave eventSave = ers.GetEventSave(); string delegateType; if (eventSave != null && !string.IsNullOrEmpty(eventSave.DelegateType)) { delegateType = eventSave.DelegateType; } else if (!string.IsNullOrEmpty(ers.DelegateType)) { delegateType = ers.DelegateType; } else { delegateType = "EventHandler"; } if (delegateType == "Action") { delegateType = "System.Action"; } return(delegateType); }
public static EventResponseSave GetEventThisTunnelsTo(this EventResponseSave instance, IElement element, out IElement containingElement) { if (instance.GetIsTunneling() == false) { containingElement = null; return(null); } else { NamedObjectSave nos = element.GetNamedObject(instance.SourceObject); if (nos != null && nos.SourceType == SourceType.Entity) { containingElement = ObjectFinder.Self.GetIElement(nos.SourceClassType); if (containingElement != null) { return(containingElement.GetEvent(instance.SourceObjectEvent)); } } } containingElement = null; 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 static ParsedMethod GetParsedMethodFromAssociatedFile(string fullFileName, EventResponseSave instance) { if (File.Exists(fullFileName)) { ParsedFile file = new ParsedFile(fullFileName, false, false); if (file.Namespaces.Count != 0) { ParsedNamespace parsedNamespace = file.Namespaces[0]; if (parsedNamespace.Classes.Count != 0) { ParsedClass parsedClass = parsedNamespace.Classes[0]; return parsedClass.GetMethod("On" + instance.EventName); } } } return null; }
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)) { 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 ParsedMethod GetParsedMethodFromAssociatedFile(this EventResponseSave instance, IElement container, string baseProjectDirectory) { string fullFileName = EventResponseSave.GetSharedCodeFullFileName(container, baseProjectDirectory); return(GetParsedMethodFromAssociatedFile(fullFileName, instance)); }
public TreeNode GetTreeNodeFor(EventResponseSave eventResponse) { foreach (TreeNode treeNode in this.mEventsTreeNode.Nodes) { if (treeNode.Tag == eventResponse) { return treeNode; } } return null; }
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 static void AddEventToElementAndSave(IElement currentElement, EventResponseSave eventResponseSave) { currentElement.Events.Add(eventResponseSave); string fullGeneratedFileName = ProjectManager.ProjectBase.Directory + EventManager.GetGeneratedEventFileNameForElement(currentElement); if (!File.Exists(fullGeneratedFileName)) { CodeWriter.AddEventGeneratedCodeFileForElement(currentElement); } ElementViewWindow.GenerateSelectedElementCode(); EditorLogic.CurrentElementTreeNode.UpdateReferencedTreeNodes(); GluxCommands.Self.SaveGlux(); EditorLogic.CurrentEventResponseSave = eventResponseSave; }
public static bool GetIsTunneling(this EventResponseSave instance) { return(!string.IsNullOrEmpty(instance.SourceObject) && !string.IsNullOrEmpty(instance.SourceObjectEvent)); }
public static string EventResponseSaveToString(this EventResponseSave eventResponseSave) { return(eventResponseSave.EventName + "(Event Response in " + eventResponseSave.GetContainer() + ")"); }
public static string GetArgsForMethod(this EventResponseSave ers, IElement containingElement) { EventSave eventSave = ers.GetEventSave(); string args = null; bool foundArgs = false; if (eventSave != null) { args = eventSave.Arguments; foundArgs = true; } else if (ers.GetIsTunneling()) { IElement tunneledContainingElement; EventResponseSave tunneled = ers.GetEventThisTunnelsTo(containingElement, out tunneledContainingElement); if (tunneled != null) { return(tunneled.GetArgsForMethod(tunneledContainingElement)); } } else if (!string.IsNullOrEmpty(ers.DelegateType)) { if (ers.DelegateType.StartsWith("System.Action<")) { string delegateType = ers.DelegateType; int startOfGeneric = delegateType.IndexOf("<") + 1; int endofGeneric = delegateType.LastIndexOf(">"); int lengthOfGeneric = endofGeneric - startOfGeneric; string genericType = delegateType.Substring(startOfGeneric, lengthOfGeneric); args = genericType + " value"; foundArgs = true; } else { Type type = TypeManager.GetTypeFromString(ers.DelegateType); if (type != null) { MethodInfo methodInfo = type.GetMethod("Invoke"); ParameterInfo[] parameters = methodInfo.GetParameters(); for (int i = 0; i < parameters.Length; i++) { if (i != 0) { args += ", "; } ParameterInfo param = parameters[i]; args += param.ParameterType.FullName + " " + param.Name; Console.WriteLine("{0} {1}", param.ParameterType.Name, param.Name); } foundArgs = true; } } } if (!foundArgs) { args = "object sender, EventArgs e"; } return(args); }
public static bool GetIsNewEvent(this EventResponseSave eventResponseSave) { return(!eventResponseSave.GetIsExposing() && !eventResponseSave.GetIsTunneling() && !string.IsNullOrEmpty(eventResponseSave.DelegateType)); }
public static ParsedMethod GetParsedMethodFromAssociatedFile(string fullFileName, EventResponseSave instance) { if (File.Exists(fullFileName)) { ParsedFile file = new ParsedFile(fullFileName, false, false); if (file.Namespaces.Count != 0) { ParsedNamespace parsedNamespace = file.Namespaces[0]; if (parsedNamespace.Classes.Count != 0) { ParsedClass parsedClass = parsedNamespace.Classes[0]; return(parsedClass.GetMethod("On" + instance.EventName)); } } } return(null); }
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; }
private static void HandleAddEventOk(AddEventWindow addEventWindow) { string resultName = addEventWindow.ResultName; IElement currentElement = EditorLogic.CurrentElement; #region Show message boxes if there is an error with the variable bool isInvalid = IsVariableInvalid(null, resultName, currentElement); #endregion if (!isInvalid) { EventResponseSave eventResponseSave = new EventResponseSave(); eventResponseSave.EventName = resultName; eventResponseSave.SourceObject = addEventWindow.TunnelingObject; eventResponseSave.SourceObjectEvent = addEventWindow.TunnelingEvent; eventResponseSave.SourceVariable = addEventWindow.SourceVariable; eventResponseSave.BeforeOrAfter = addEventWindow.BeforeOrAfter; eventResponseSave.DelegateType = addEventWindow.ResultDelegateType; AddEventToElementAndSave(currentElement, eventResponseSave); } }
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 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 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; }
public static ParsedMethod GetParsedMethodFromAssociatedFile(this EventResponseSave instance) { string fullFileName = instance.GetSharedCodeFullFileName(); return(EventResponseSaveExtensionMethods.GetParsedMethodFromAssociatedFile(fullFileName, instance)); }
/// <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; }
public static bool GetIsExposing(this EventResponseSave instance) { return(instance.GetEventSave() != null && instance.GetEventSave().CreatesEventMember); }
public static bool GetCreatesEvent(this EventResponseSave eventResponseSave) { return(eventResponseSave.GetEventSave() != null && eventResponseSave.GetEventSave().CreatesEventMember); }
public void SetBackingObjects(IElement element, EventResponseSave eventResponse) { mElement = element; mEventResponse = eventResponse; RefreshLists(); }
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; }
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; }
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; }