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);
}
}
