internal IntelliBoxItem(string text, string code, string toolTip, IntelliType intelliType)
{
this.Text = text;
this.Code = code;
this.ToolTip = toolTip;
this.ImageIndex = (int)intelliType;
}
internal FilterButton(IntelliType intelliType)
{
this.IntelliType = intelliType;
this.Image = ItemIcons[(int)this.IntelliType];
this.ToolTipText = $"Show only {intelliType.ToString().MakePlural()}{GetHotKey(intelliType)}";
this.Margin = new Padding(UIUtil.Scale(2));
}
/// <summary>
/// Fills the iBox with all the Constructors of the given Type.
/// </summary>
internal void Populate(Type type)
{
this.Items.Clear();
unFilteredItems.Clear();
stringFilter = string.Empty;
intelliTypeFilter = IntelliType.None;
membersInBox = false;
if (!type.IsEnum && type.IsValueType)
{
unFilteredItems.Add(new IntelliBoxItem($"{type.Name}()", string.Empty, $"{type.Name}()", IntelliType.Constructor));
}
foreach (ConstructorInfo constructor in type.GetConstructors())
{
string toolTip = $"{type.Name}({constructor.Params()})";
unFilteredItems.Add(new IntelliBoxItem(toolTip, string.Empty, toolTip, IntelliType.Constructor));
}
this.Items.AddRange(unFilteredItems.ToArray());
if (unFilteredItems.Count > 0)
{
this.SelectedIndex = 0;
}
}
private void Clear()
{
this.Items.Clear();
this.unFilteredItems.Clear();
this.stringFilter = string.Empty;
this.intelliTypeFilter = IntelliType.None;
}
private static string GetHotKey(IntelliType intelliType)
{
return(intelliType switch
{
IntelliType.Method => " (Alt+M)",
IntelliType.Property => " (Alt+P)",
IntelliType.Event => " (Alt+V)",
IntelliType.Field => " (Alt+F)",
IntelliType.Keyword => " (Alt+K)",
IntelliType.Variable => " (Alt+L)",
IntelliType.Class => " (Alt+C)",
IntelliType.Struct => " (Alt+S)",
IntelliType.Enum => " (Alt+E)",
IntelliType.Constant => " (Alt+O)",
IntelliType.Snippet => " (Alt+T)",
IntelliType.Interface => " (Alt+I)",
IntelliType.Delegate => " (Alt+D)",
_ => string.Empty,
});
internal void Filter(IntelliType intelliType)
{
IEnumerable <FilterButton> filterbuttons = this.toolStrip.Items.OfType <FilterButton>();
FilterButton filterButton = filterbuttons.Where(b => b.Visible && b.IntelliType == intelliType).FirstOrDefault();
if (filterButton is null)
{
return;
}
filterButton.Checked = !filterButton.Checked;
IEnumerable <IntelliType> matchingTypes = listBox.Items.OfType <IntelliBoxItem>().Select(i => i.IntelliType).Distinct().ToArray();
if (filterbuttons.Any(x => x.Checked))
{
IEnumerable <IntelliType> checkedTypes = filterbuttons.Where(x => x.Checked).Select(x => x.IntelliType).Intersect(matchingTypes);
SetFilterButtonAppearance(checkedTypes);
}
else
{
SetFilterButtonAppearance(matchingTypes);
}
if (intelliType == IntelliType.None)
{
enumFilters.Clear();
}
else if (enumFilters.Contains(intelliType))
{
enumFilters.Remove(intelliType);
}
else
{
enumFilters.Add(intelliType);
}
Filter();
}
private void AddType(Type type, string typeName, bool?isNested)
{
string realName = type.Name;
string name = typeName;
string code = typeName;
if (type.IsGenericType)
{
realName = type.GetGenericName();
if (typeName.Equals(type.Name, StringComparison.Ordinal))
{
name = type.GetGenericName();
code = Regex.Replace(type.Name, @"`\d", string.Empty);
}
if (type.IsGenericTypeDefinition)
{
string constraints = type.GetGenericArguments().GetConstraints().Join("\r\n ");
if (constraints.Length > 0)
{
realName += "\r\n " + constraints;
}
}
}
string baseType = "Type";
IntelliType icon = IntelliType.Type;
if (type.IsEnum)
{
baseType = "enum";
icon = IntelliType.Enum;
}
else if (type.IsValueType)
{
baseType = "struct";
icon = IntelliType.Struct;
}
else if (type.IsDelegate())
{
baseType = "delegate";
icon = IntelliType.Delegate;
}
else if (type.IsClass)
{
baseType = "class";
icon = IntelliType.Class;
}
else if (type.IsInterface)
{
baseType = "interface";
icon = IntelliType.Interface;
}
string toolTip;
if (isNested == null)
{
toolTip = $"{baseType} - {type.DeclaringType.Name}.{realName}\nType"; // User Defined
}
else if (isNested == true)
{
toolTip = $"{baseType} - {realName}\nNested Type";
}
else
{
toolTip = $"{baseType} - {type.Namespace}.{realName}\nType";
}
unFilteredItems.Add(new IntelliBoxItem(name, code, toolTip, icon));
}
internal void Filter(IntelliType intelliTypes)
{
intelliTypeFilter = (intelliTypes == intelliTypeFilter) ? IntelliType.None : intelliTypes;
Filter();
}
/// <summary>
/// Fills the iBox with all non-member objects, and then filters them with the given char.
/// </summary>
internal void Populate(char startChar)
{
this.Items.Clear();
unFilteredItems.Clear();
stringFilter = string.Empty;
intelliTypeFilter = IntelliType.None;
membersInBox = false;
foreach (string type in Intelli.AutoCompleteTypes.Keys)
{
Type t = Intelli.AutoCompleteTypes[type];
string name = t.IsGenericType && type.Equals(t.Name, StringComparison.Ordinal) ? t.GetGenericName() : type;
string realName = t.IsGenericType ? t.GetGenericName() : t.Name;
string code = t.IsGenericType && type.Equals(t.Name, StringComparison.Ordinal) ? Regex.Replace(t.Name, @"`\d", string.Empty) + "<>" : type;
string baseType = "Type";
IntelliType icon = IntelliType.Type;
if (t.IsEnum)
{
baseType = "enum";
icon = IntelliType.Enum;
}
else if (t.IsValueType)
{
baseType = "struct";
icon = IntelliType.Struct;
}
else if (t.IsClass)
{
baseType = "class";
icon = IntelliType.Class;
}
else if (t.IsInterface)
{
// Disabled simply because I don't think they're useful in the context of CodeLab
//baseType = "interface";
//icon = IntelliTypes.Interface;
continue;
}
string toolTip = $"{baseType} - {t.Namespace}.{realName}\nType";
unFilteredItems.Add(new IntelliBoxItem(name, code, toolTip, icon));
}
foreach (string type in Intelli.UserDefinedTypes.Keys)
{
Type t = Intelli.UserDefinedTypes[type];
string name = t.IsGenericType && type.Equals(t.Name, StringComparison.Ordinal) ? t.GetGenericName() : type;
string realName = t.IsGenericType ? t.GetGenericName() : t.Name;
string code = t.IsGenericType && type.Equals(t.Name, StringComparison.Ordinal) ? Regex.Replace(t.Name, @"`\d", string.Empty) + "<>" : type;
string baseType = "Type";
IntelliType icon = IntelliType.Type;
if (t.IsEnum)
{
baseType = "enum";
icon = IntelliType.Enum;
}
else if (t.IsValueType)
{
baseType = "struct";
icon = IntelliType.Struct;
}
else if (t.IsClass)
{
baseType = "class";
icon = IntelliType.Class;
}
else if (t.IsInterface)
{
// Disabled simply because I don't think they're useful in the context of CodeLab
//baseType = "interface";
//icon = IntelliTypes.Interface;
continue;
}
string toolTip = $"{baseType} - {t.DeclaringType.Name}.{realName}\nType";
unFilteredItems.Add(new IntelliBoxItem(name, code, toolTip, icon));
}
foreach (string var in Intelli.Variables.Keys)
{
string type = Intelli.Variables[var].GetDisplayName();
string toolTip = $"{type} - {var}\nLocal Variable";
unFilteredItems.Add(new IntelliBoxItem(var, var, toolTip, IntelliType.Variable));
}
foreach (string para in Intelli.Parameters.Keys)
{
string type = Intelli.Parameters[para].GetDisplayName();
string toolTip = $"{type} - {para}\nParameter";
unFilteredItems.Add(new IntelliBoxItem(para, para, toolTip, IntelliType.Variable)); // use the var icon
}
foreach (string key in Intelli.Keywords)
{
string toolTip = $"{key}\nKeyword";
unFilteredItems.Add(new IntelliBoxItem(key, key, toolTip, IntelliType.Keyword));
}
foreach (string snip in Intelli.Snippets.Keys)
{
string toolTip = $"{snip}\nSnippet - Tab Twice";
unFilteredItems.Add(new IntelliBoxItem(snip, snip, toolTip, IntelliType.Snippet));
}
MemberInfo[] members = Intelli.UserScript.GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MemberInfo memberInfo in members)
{
if (memberInfo.GetCustomAttribute <ObsoleteAttribute>() != null)
{
continue;
}
string returnType = string.Empty;
string toolTip = string.Empty;
switch (memberInfo.MemberType)
{
case MemberTypes.Method:
MethodInfo methodInfo = (MethodInfo)memberInfo;
if (methodInfo.IsSpecialName || methodInfo.DeclaringType != Intelli.UserScript ||
methodInfo.Name.Equals("Render", StringComparison.Ordinal) || methodInfo.Name.Equals("PreRender", StringComparison.Ordinal))
{
continue;
}
string methodParameters = $"({methodInfo.Params()})";
returnType = methodInfo.ReturnType.GetDisplayName();
toolTip = $"{returnType} - {methodInfo.Name}{methodParameters}\n{methodInfo.MemberType}";
unFilteredItems.Add(new IntelliBoxItem(methodInfo.Name + methodParameters, methodInfo.Name, toolTip, IntelliType.Method));
break;
case MemberTypes.Property:
if (memberInfo.Name.Equals("SetRenderInfoCalled", StringComparison.Ordinal) || memberInfo.Name.Equals("__DebugMsgs", StringComparison.Ordinal))
{
continue;
}
string getSet = ((PropertyInfo)memberInfo).GetterSetter();
returnType = ((PropertyInfo)memberInfo).PropertyType.GetDisplayName();
toolTip = $"{returnType} - {memberInfo.Name}{getSet}\n{memberInfo.MemberType}";
unFilteredItems.Add(new IntelliBoxItem(memberInfo.Name, memberInfo.Name, toolTip, IntelliType.Property));
break;
case MemberTypes.Event:
returnType = ((EventInfo)memberInfo).EventHandlerType.GetDisplayName();
toolTip = $"{returnType} - {memberInfo.Name}\n{memberInfo.MemberType}";
unFilteredItems.Add(new IntelliBoxItem(memberInfo.Name, memberInfo.Name, toolTip, IntelliType.Event));
break;
case MemberTypes.Field:
if (memberInfo.Name.Equals("RandomNumber", StringComparison.Ordinal) || memberInfo.Name.Equals("instanceSeed", StringComparison.Ordinal) ||
memberInfo.Name.EndsWith("_BackingField", StringComparison.Ordinal) ||
memberInfo.Name.Equals("__listener", StringComparison.Ordinal) || memberInfo.Name.Equals("__debugWriter", StringComparison.Ordinal))
{
continue;
}
FieldInfo field = (FieldInfo)memberInfo;
string fieldTypeName;
IntelliType fieldType;
string fieldValue;
if (!field.IsStatic)
{
fieldTypeName = "Field";
fieldType = IntelliType.Field;
fieldValue = string.Empty;
}
else if (field.FieldType.IsEnum)
{
fieldTypeName = "Enum Value";
fieldType = IntelliType.EnumItem;
fieldValue = $" ({(int)field.GetValue(null)})";
}
else if (field.IsLiteral && !field.IsInitOnly)
{
fieldTypeName = "Constant";
fieldType = IntelliType.Constant;
fieldValue = $" ({field.GetValue(null)})";
}
else
{
fieldTypeName = "Field";
fieldType = IntelliType.Field;
fieldValue = $" ( {field.GetValue(null)} )";
}
returnType = field.FieldType.GetDisplayName();
toolTip = $"{returnType} - {memberInfo.Name}{fieldValue}\n{fieldTypeName}";
unFilteredItems.Add(new IntelliBoxItem(memberInfo.Name, memberInfo.Name, toolTip, fieldType));
break;
}
}
unFilteredItems.Sort();
Filter(startChar.ToString().Trim());
}
/// <summary>
/// Fills the iBox with members of the given Type.
/// </summary>
internal void Populate(Type type, bool isStatic)
{
this.Items.Clear();
unFilteredItems.Clear();
stringFilter = string.Empty;
intelliTypeFilter = IntelliType.None;
membersInBox = true;
MemberInfo[] members = isStatic ?
type.GetMembers(BindingFlags.Static | BindingFlags.Public) :
type.GetMembers(BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.CreateInstance | BindingFlags.Public);
foreach (MemberInfo memberInfo in members)
{
if ((!memberInfo.ReflectedType.IsVisible && memberInfo.DeclaringType?.DeclaringType?.FullName != "PaintDotNet.Effects.UserScript") ||
memberInfo.ReflectedType.IsSpecialName || memberInfo.GetCustomAttribute <ObsoleteAttribute>() != null)
{
continue;
}
string returnType = string.Empty;
string toolTip = string.Empty;
switch (memberInfo.MemberType)
{
case MemberTypes.Method:
MethodInfo methodInfo = (MethodInfo)memberInfo;
if (methodInfo.IsSpecialName)
{
continue;
}
string methodParameters = $"({methodInfo.Params()})";
returnType = methodInfo.ReturnType.GetDisplayName();
toolTip = $"{returnType} - {methodInfo.Name}{methodParameters}\n{methodInfo.MemberType}";
unFilteredItems.Add(new IntelliBoxItem(methodInfo.Name + methodParameters, methodInfo.Name, toolTip, IntelliType.Method));
break;
case MemberTypes.Property:
PropertyInfo property = (PropertyInfo)memberInfo;
if (property.GetIndexParameters().Length > 0)
{
continue;
}
string getSet = property.GetterSetter();
returnType = property.PropertyType.GetDisplayName();
toolTip = $"{returnType} - {property.Name}{getSet}\n{property.MemberType}";
unFilteredItems.Add(new IntelliBoxItem(property.Name, property.Name, toolTip, IntelliType.Property));
break;
case MemberTypes.Event:
returnType = ((EventInfo)memberInfo).EventHandlerType.GetDisplayName();
toolTip = $"{returnType} - {memberInfo.Name}\n{memberInfo.MemberType}";
unFilteredItems.Add(new IntelliBoxItem(memberInfo.Name, memberInfo.Name, toolTip, IntelliType.Event));
break;
case MemberTypes.Field:
FieldInfo field = (FieldInfo)memberInfo;
string fieldTypeName;
IntelliType fieldType;
string fieldValue;
if (!field.IsStatic)
{
fieldTypeName = "Field";
fieldType = IntelliType.Field;
fieldValue = string.Empty;
}
else if (field.FieldType.IsEnum)
{
fieldTypeName = "Enum Value";
fieldType = IntelliType.EnumItem;
fieldValue = $" ({field.GetEnumValue()})";
}
else if (field.IsLiteral && !field.IsInitOnly)
{
fieldTypeName = "Constant";
fieldType = IntelliType.Constant;
fieldValue = $" ({field.GetValue(null)})";
}
else
{
fieldTypeName = "Field";
fieldType = IntelliType.Field;
fieldValue = $" ( {field.GetValue(null)} )";
}
returnType = field.FieldType.GetDisplayName();
toolTip = $"{returnType} - {field.Name}{fieldValue}\n{fieldTypeName}";
unFilteredItems.Add(new IntelliBoxItem(field.Name, field.Name, toolTip, fieldType));
break;
case MemberTypes.NestedType:
Type nestedType = (Type)memberInfo;
IntelliType intelliType = IntelliType.Type;
string subType = "Type";
if (nestedType.IsEnum)
{
subType = "enum";
intelliType = IntelliType.Enum;
}
else if (nestedType.IsValueType)
{
subType = "struct";
intelliType = IntelliType.Struct;
}
else if (nestedType.IsClass)
{
subType = "class";
intelliType = IntelliType.Class;
}
toolTip = $"{subType} - {nestedType.Name}\nNested Type";
unFilteredItems.Add(new IntelliBoxItem(nestedType.Name, nestedType.Name, toolTip, intelliType));
break;
}
}
unFilteredItems.Sort();
this.Items.AddRange(unFilteredItems.ToArray());
if (this.Items.Contains(this.LastUsedMember))
{
this.SelectedItem = this.LastUsedMember;
}
else if (this.Items.Contains(this.LastUsedNonMember))
{
this.SelectedItem = this.LastUsedNonMember;
}
else if (this.Items.Count > 0)
{
this.SelectedIndex = 0;
}
}
