protected LookupMenuItem GetPropertyMenuItem( Variable v, int offset) { LookupMenuItem lmi1 = new LookupMenuItem(); string padding = new String(' ', offset); string typeName; if (v.IsArray || v.IsGeneric) { typeName = v.GetVariableType(); } else { typeName = v.DeclaredType; } string propertyName = v.Name.TrimStart('_'); if (propertyName.Length > 1) { propertyName = propertyName.Substring(0, 1).ToUpper() + propertyName.Substring(1); } else { propertyName = propertyName.ToUpper(); } string displayText1 = Resources.InsertProperty; string insertText1 = String.Format( @"public {0} {1} {3}{{ {3} get {{ return {2}; }} {3} set {{ {2} = value; }} {3}}}", typeName, propertyName, v.Name, padding); lmi1.DisplayText = displayText1; lmi1.InsertText = insertText1; return(lmi1); }
private void AddExtensionMethod( Dictionary <String, LookupListItem> foundItems, MethodInfo mi) { if (!foundItems.ContainsKey(mi.Name)) { LookupListItem lli = new LookupListItem(); lli.DisplayText = mi.Name; lli.InsertText = mi.Name; lli.ToolTipText = String.Format( "{0} {1}_OVR_\r\nDeclared in: {2}", CSharpFormattingTools.GetTypeSignature(mi.ReturnType), CSharpFormattingTools.GetMethodSignature(mi, true, true), mi.DeclaringType.FullName); lli.Category = QuickSharp.CodeAssist.Constants.METHOD_EXTENSION; LookupMenuItem lmi = new LookupMenuItem(); lmi.DisplayText = String.Format("{0} {1}", CSharpFormattingTools.GetTypeSignature(mi.ReturnType), CSharpFormattingTools.GetMethodSignature(mi, true, true)); lmi.InsertText = CSharpFormattingTools.GetMethodSignature(mi, true, true); lli.MenuItems.Add(lmi); foundItems.Add(lli.DisplayText, lli); } else { // Overloaded methods LookupListItem lli = foundItems[mi.Name]; LookupMenuItem lmi = new LookupMenuItem(); lmi.DisplayText = String.Format("{0} {1}", CSharpFormattingTools.GetTypeSignature(mi.ReturnType), CSharpFormattingTools.GetMethodSignature(mi, true, true)); lmi.InsertText = CSharpFormattingTools.GetMethodSignature(mi, true, true); lli.MenuItems.Add(lmi); } }
protected void AddConstructors(Type type, LookupListItem item) { BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance; ConstructorInfo[] cia = type.GetConstructors(bindingAttr); foreach (ConstructorInfo ci in cia) { LookupMenuItem lmi = new LookupMenuItem(); lmi.DisplayText = CSharpFormattingTools. GetConstructorSignature(ci, type); lmi.InsertText = CSharpFormattingTools. GetMinimalConstructorSignature(ci, type); item.MenuItems.Add(lmi); } }
public List <LookupListItem> GetList( DeclarationContext declarationContext) { Dictionary <String, LookupListItem> dict = new Dictionary <String, LookupListItem>(); foreach (MethodDefinition method in _methods) { /* * Hide any dummy methods used intenally. * The convention is that such methods begin * with a '0' which is illegal in C#. */ if (method.Name[0] == '0') { continue; } /* * Check visibility of methods. */ bool showMethod = false; if (method.IsStatic && declarationContext != DeclarationContext.Instance) { showMethod = true; } if (!method.IsStatic && declarationContext != DeclarationContext.Static) { showMethod = true; } if (!showMethod) { continue; } /* * Add the method to the list. */ if (!dict.ContainsKey(method.Name)) { LookupListItem listItem = new LookupListItem(); listItem.DisplayText = method.Name; if (method.Visibility == "internal" || method.IsProtectedInternal) { listItem.Category = QuickSharp.CodeAssist.Constants.METHOD_FRIEND; } else if (method.Visibility == "protected") { listItem.Category = QuickSharp.CodeAssist.Constants.METHOD_PROTECTED; } else if (method.Visibility == "private") { listItem.Category = QuickSharp.CodeAssist.Constants.METHOD_PRIVATE; } else { listItem.Category = QuickSharp.CodeAssist.Constants.METHOD; } if (method.ReturnType != null) { listItem.ToolTipText = String.Format("{0} {1}({2})", method.ReturnType, method.Name, method.Parameters); } else { listItem.ToolTipText = String.Format("{0}({1})", method.Name, method.Parameters); } listItem.InsertText = method.Name; LookupMenuItem menuItem = new LookupMenuItem(); menuItem.DisplayText = listItem.ToolTipText; menuItem.InsertText = String.Format("{0}({1})", method.Name, GetParameterNames(method)); listItem.MenuItems.Add(menuItem); dict[method.Name] = listItem; } else { LookupListItem listItem = dict[method.Name]; LookupMenuItem menuItem = new LookupMenuItem(); if (method.ReturnType != null) { menuItem.DisplayText = String.Format("{0} {1}({2})", method.ReturnType, method.Name, method.Parameters); } else { menuItem.DisplayText = String.Format("{0}({1})", method.Name, method.Parameters); } menuItem.InsertText = String.Format("{0}({1})", method.Name, method.Parameters); listItem.MenuItems.Add(menuItem); } } /* * Convert the dictionary to a list and fixup the * overloaded items to show the correct icon and * tooltip text. */ List <LookupListItem> list = new List <LookupListItem>(); foreach (LookupListItem listItem in dict.Values) { if (listItem.MenuItems.Count > 1) { switch (listItem.Category) { case QuickSharp.CodeAssist.Constants.METHOD_FRIEND: listItem.Category = QuickSharp.CodeAssist.Constants.METHODOVERLOAD_FRIEND; break; case QuickSharp.CodeAssist.Constants.METHOD_PROTECTED: listItem.Category = QuickSharp.CodeAssist.Constants.METHODOVERLOAD_PROTECTED; break; case QuickSharp.CodeAssist.Constants.METHOD_PRIVATE: listItem.Category = QuickSharp.CodeAssist.Constants.METHODOVERLOAD_PRIVATE; break; default: listItem.Category = QuickSharp.CodeAssist.Constants.METHODOVERLOAD; break; } listItem.ToolTipText = String.Format("{0} (+{1} {2})", listItem.ToolTipText, listItem.MenuItems.Count - 1, listItem.MenuItems.Count == 2 ? "overload" : "overloads"); } list.Add(listItem); } return(list); }
/* * Create a LookupListItem from a type. */ protected LookupListItem GetItem(Type type) { string typeName = CSharpFormattingTools.GetTypeSignature(type); string fullName = CSharpFormattingTools.GetTypeSignature(type, true); LookupListItem item = new LookupListItem(); item.DisplayText = typeName; item.InsertText = type.ContainsGenericParameters ? CSharpFormattingTools.RemoveGenericSignature(typeName) : typeName; // Classify the type - order is important here if (type.IsClass && type.IsSubclassOf(typeof(System.Delegate))) { item.Category = QuickSharp.CodeAssist.Constants.DELEGATE; item.ToolTipText = String.Format("delegate {0}", fullName); } else if (type.IsEnum) { item.Category = QuickSharp.CodeAssist.Constants.ENUM; item.ToolTipText = String.Format("enum {0}", fullName); } else if (type.IsValueType) { item.Category = QuickSharp.CodeAssist.Constants.VALUETYPE; item.ToolTipText = String.Format("struct {0}", fullName); } else if (type.IsInterface) { item.Category = QuickSharp.CodeAssist.Constants.INTERFACE; item.ToolTipText = String.Format("interface {0}", fullName); } else { if (type.IsSealed) { item.Category = QuickSharp.CodeAssist.Constants.CLASS_SEALED; } else { item.Category = QuickSharp.CodeAssist.Constants.CLASS; } item.ToolTipText = String.Format("class {0}", fullName); BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance; ConstructorInfo[] cia = type.GetConstructors(bindingAttr); foreach (ConstructorInfo ci in cia) { LookupMenuItem lmi = new LookupMenuItem(); lmi.DisplayText = JScriptFormattingTools. GetConstructorSignature(ci, type); lmi.InsertText = JScriptFormattingTools. GetMinimalConstructorSignature(ci, type); item.MenuItems.Add(lmi); } } return(item); }
private void AddMethod( Dictionary <String, LookupListItem> foundItems, MemberInfo item) { MethodInfo mi = (MethodInfo)item; if (mi.IsSpecialName) { return; } if (mi.IsPrivate) { return; } if (mi.Name == "Finalize") { return; } if (!foundItems.ContainsKey(mi.Name)) { bool isExtensionMethod = mi.GetCustomAttributes( typeof(ExtensionAttribute), false).Length > 0; LookupListItem lli = new LookupListItem(); lli.DisplayText = mi.Name; lli.InsertText = mi.Name; lli.ToolTipText = String.Format("{0} {1}_OVR_", JScriptFormattingTools.GetTypeSignature(mi.ReturnType), JScriptFormattingTools.GetMethodSignature(mi)); if (isExtensionMethod) { lli.Category = QuickSharp.CodeAssist.Constants.METHOD_EXTENSION; } else if (mi.IsPublic) { lli.Category = QuickSharp.CodeAssist.Constants.METHOD; } else if (mi.IsFamily) { lli.Category = QuickSharp.CodeAssist.Constants.METHOD_PROTECTED; } else { lli.Category = QuickSharp.CodeAssist.Constants.METHOD_FRIEND; } LookupMenuItem lmi = new LookupMenuItem(); lmi.DisplayText = String.Format("{0} {1}", JScriptFormattingTools.GetTypeSignature(mi.ReturnType), JScriptFormattingTools.GetMethodSignature(mi)); lmi.InsertText = JScriptFormattingTools.GetMinimalMethodSignature(mi); lli.MenuItems.Add(lmi); foundItems.Add(mi.Name, lli); } else { // Overloaded method LookupListItem lli = foundItems[mi.Name]; LookupMenuItem lmi = new LookupMenuItem(); lmi.DisplayText = String.Format("{0} {1}", JScriptFormattingTools.GetTypeSignature(mi.ReturnType), JScriptFormattingTools.GetMethodSignature(mi)); lmi.InsertText = JScriptFormattingTools.GetMinimalMethodSignature(mi); lli.MenuItems.Add(lmi); } }
private void AddEventHandlerMenuItems( string targetName, string eventName, Type handlerType, int indent, LookupListItem item) { BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance; MethodInfo[] mia = handlerType.GetMethods(bindingAttr); foreach (MethodInfo mi in mia) { if (mi.Name != "Invoke") { continue; } string paddingFull = new String(' ', indent); string paddingShort = new String(' ', (indent > 4 ? indent - 4 : indent)); string methodParameters = CSharpFormattingTools.GetMethodParameters( mi.GetParameters()); string methodParameterNames = CSharpFormattingTools.GetMethodParameterNames( mi.GetParameters()); /* * Full event handler. */ LookupMenuItem lmi1 = new LookupMenuItem(); string displayText1 = Resources.InsertEventHandler; string insertText1 = String.Format( @"{0} += new {1}({2}_{0}); {4}private void {2}_{0}{3} {4}{{ {4}}} ", eventName, handlerType.Name, FormatEventHandlerName(targetName), methodParameters, paddingShort); lmi1.DisplayText = displayText1; lmi1.InsertText = insertText1; item.MenuItems.Add(lmi1); /* * Anonymous event handler. */ LookupMenuItem lmi2 = new LookupMenuItem(); string displayText2 = Resources.InsertAnonEventHandler; string insertText2 = String.Format( @"{0} += delegate {1} {2}{{ {2}}};", eventName, methodParameters, paddingFull); lmi2.DisplayText = displayText2; lmi2.InsertText = insertText2; item.MenuItems.Add(lmi2); /* * Lambda event handler. */ LookupMenuItem lmi3 = new LookupMenuItem(); string displayText3 = Resources.InsertLambdaEventHandler; string insertText3 = String.Format( @"{0} += {1} => {2}{{ {2}}};", eventName, methodParameterNames, paddingFull); lmi3.DisplayText = displayText3; lmi3.InsertText = insertText3; item.MenuItems.Add(lmi3); } }