コード例 #1
0
        public bool Add(string value, AutocompleteItemCategory category)
        {
            AutocompleteItem item = null;

            switch (category)
            {
            case AutocompleteItemCategory.Keyword:
                item = new AutocompleteItem(value);
                break;

            case AutocompleteItemCategory.Method:
                item = new MethodAutocompleteItem(value);    // { ImageIndex = (int)category };
                break;

            default:
                return(false);
            }


            if (item.Text != "")
            {
                if (!_suggestions.Exists(x => x.Text == item.Text))
                {
                    Suggestions.Add(item);
                    return(true);
                }
            }
            return(false);
        }
コード例 #2
0
        public IEnumerator <AutocompleteItem> GetEnumerator()
        {
            var text  = menu.Fragment.Text;
            var parts = text.Split('.');
            List <AutocompleteItem> items = new List <AutocompleteItem>();

            foreach (var item in Autocomplete.UserItems.Keys)
            {
                items.Add(new AutocompleteItem(item));
            }
            if (parts.Length < 2)
            {
                items.AddRange(ProgramData.Project.GetDefaultList());
                foreach (var item in CodeAnalysisEngine.Variables)
                {
                    items.Add(new AutocompleteItem(item));
                }
                foreach (var item in items)
                {
                    yield return(item);
                }
            }
            else
            {
                var className = parts[parts.Length - 2];
                foreach (var methodName in ProgramData.Project.GetListByClassName(className))
                {
                    items.Add(methodName);
                }
                if (Autocomplete.UserItems.ContainsKey(className))
                {
                    foreach (var methodName in Autocomplete.UserItems[className])
                    {
                        items.Add(new MethodAutocompleteItem(methodName));
                    }
                }
                if (CodeAnalysisEngine.Objects.ContainsKey(className))
                {
                    foreach (var methodName in CodeAnalysisEngine.Objects[className])
                    {
                        var item = new MethodAutocompleteItem(methodName);
                        if (!items.Contains(item))
                        {
                            items.Add(item);
                        }
                    }
                }
                foreach (var item in items)
                {
                    yield return(item);
                }
            }
        }
コード例 #3
0
        public Sandbox()
        {
            InitializeComponent();

            fctb = new FastColoredTextBox()
            {
                Dock = DockStyle.Fill, Parent = this
            };
            var menu = new AutocompleteMenu(fctb);
            var item = new MethodAutocompleteItem("ToString");

            menu.Items.SetAutocompleteItems(new AutocompleteItem[] { item });
        }
コード例 #4
0
ファイル: ZCore.cs プロジェクト: mineprogramming/NIDE
        public override List <AutocompleteItem> GetListByClassName(string className)
        {
            List <string>           result;
            List <AutocompleteItem> acList = new List <AutocompleteItem>();

            if (Members.TryGetValue(className, out result))
            {
                foreach (var item in result)
                {
                    MethodAutocompleteItem it = new MethodAutocompleteItem(item);
                    it.ImageIndex = 5;
                    acList.Add(it);
                }
                return(acList);
            }
            else
            {
                return(GetDefaultList());
            }
        }
コード例 #5
0
        public IEnumerator <AutocompleteItem> GetEnumerator()
        {
            var compiler = new CSharpCodeProvider();
            // Just to prove a point...

            //get current fragment of the text
            var text = tb.GetLineText(menu.Fragment.ToLine);

            //extract class name (part before dot)
            var parts = text.Split('.');

            if (parts.Length < 2)
            {
                yield break;
            }
            var  obj  = parts[0];
            Type type = null;

            if (obj == "Selected")
            {
                type = typeof(UITreeSelection);
            }
            else if (obj == "Model")
            {
                type = typeof(Model);
            }

            if (type == null)
            {
                yield break;
            }

            PropertyInfo prop;

            for (var i = 1; i < parts.Length - 1; i++)
            {
                var brackets = parts[i].IndexOf('[');
                if (brackets > 0)
                {
                    if (parts[i].IndexOf(']') > brackets + 1)
                    {
                        prop = type.GetProperty(parts[i].Substring(0, brackets));
                        if (prop != null)
                        {
                            var indexerType = prop.PropertyType.GetDefaultMembers().OfType <PropertyInfo>().FirstOrDefault()?.PropertyType;
                            if (indexerType != null)
                            {
                                type = indexerType;
                                continue;
                            }
                            else
                            {
                                yield break;
                            }
                        }
                        else
                        {
                            yield break;
                        }
                    }
                    else
                    {
                        yield break;
                    }
                }

                var parenthesis = parts[i].IndexOf('(');
                if (parenthesis > 0)
                {
                    if (parts[i].IndexOf(')') > brackets)
                    {
                        var method = type.GetMethod(parts[i].Substring(0, parenthesis));
                        if (method != null)
                        {
                            type = method.ReturnType; continue;
                        }
                        else
                        {
                            yield break;
                        }
                    }
                    else
                    {
                        yield break;
                    }
                }

                prop = type.GetProperty(parts[i]);
                if (prop != null)
                {
                    type = prop.PropertyType; continue;
                }
                else
                {
                    yield break;
                }
            }

            if (type == null)
            {
                yield break;
            }

            MethodAutocompleteItem last = null;

            //return methods
            foreach (var mi in type.GetMethods(BindingFlags.Public | BindingFlags.Instance)
                     .Where(m => !m.IsSpecialName && m.DeclaringType != typeof(object)).AsEnumerable())
            {
                switch (mi.Name)
                {
                case "GetEnumerator":
                    continue;
                }

                // Overloaded methods only show up once, but let's display all overrides in the tooltip.
                var    methodName = mi.Name + "()";
                string returnTypeName;
                if (mi.ReturnType == typeof(void))
                {
                    returnTypeName = "void";
                }
                else
                {
                    var returnType = new CodeTypeReference(mi.ReturnType);
                    returnTypeName = compiler.GetTypeOutput(returnType).Replace("TabularEditor.UI.UISelectionList", "IEnumerable").Replace("TabularEditor.TOMWrapper.", "");
                }

                var methodSyntax = returnTypeName + " " + mi.Name + "(" + string.Join(", ", mi.GetParameters().Select(p => p.Name).ToArray()) + ")";

                if (last?.Text == methodName)
                {
                    last.ToolTipTitle += "\n" + methodSyntax;
                }
                else
                {
                    last = new MethodAutocompleteItem(methodName)
                    {
                        ToolTipTitle = methodSyntax,
                        ToolTipText  = mi.GetCustomAttribute <DescriptionAttribute>()?.Description ?? string.Empty,
                        ImageIndex   = TabularIcons.ICON_METHOD
                    };
                    yield return(last);
                }
            }

            // Type derives from IEnumerable, so let's add a few select LINQ methods:
            if (type.GetInterface("IEnumerable") != null)
            {
                yield return(new MethodAutocompleteItem("Select()")
                {
                    ToolTipTitle = "Select",
                    ToolTipText = "Projects each item of the collection into something else using a lambda expression.\nExample: .Select(Measure => Measure.Table)",
                    ImageIndex = TabularIcons.ICON_EXMETHOD
                });

                yield return(new MethodAutocompleteItem("Any()")
                {
                    ToolTipTitle = "Any",
                    ToolTipText = "Determines if the collection contains any items. Specify a lambda expression to determine if the collection contains any items satisfying the given criteria.\nExample: .Any(Measure => Measure.Description == \"\")",
                    ImageIndex = TabularIcons.ICON_EXMETHOD
                });

                yield return(new MethodAutocompleteItem("All()")
                {
                    ToolTipTitle = "All",
                    ToolTipText = "Determines if all items in the collection satisfies the given criteria.\nExample: .All(Measure => Measure.Description == \"\")",
                    ImageIndex = TabularIcons.ICON_EXMETHOD
                });

                // Below adds all LINQ methods, which may be overkill:

                /*foreach (var method in typeof(System.Linq.Enumerable)
                 *  .GetMethods(BindingFlags.Static | BindingFlags.Public).Select(m => m.Name).Distinct())
                 * {
                 *  yield return new MethodAutocompleteItem(method + "()")
                 *  {
                 *      ToolTipTitle = method,
                 *      ImageIndex = TabularIcons.ICON_METHOD
                 *  };
                 * }*/
            }

            //return static properties of the class
            foreach (var pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                var propType     = new CodeTypeReference(pi.PropertyType);
                var propTypeName = compiler.GetTypeOutput(propType).Replace("TabularEditor.UI.UISelectionList", "IEnumerable").Replace("TabularEditor.TOMWrapper.", "");

                yield return(new MethodAutocompleteItem(pi.Name)
                {
                    ToolTipTitle = string.Format("{0} {1} {{ {2}}}", propTypeName, pi.Name, (pi.CanRead ? "get; " : "") + (pi.CanWrite ? "set; " : "")),
                    ToolTipText = pi.GetCustomAttribute <DescriptionAttribute>()?.Description ?? string.Empty,
                    ImageIndex = TabularIcons.ICON_PROPERTY
                });
            }
        }
コード例 #6
0
        public void PopulateFromType(Type type)
        {
            this.Clear();
            if (type == null)
            {
                return;
            }
            var compiler = new CSharpCodeProvider();
            MethodAutocompleteItem last = null;

            if (type.IsEnum)
            {
                AddRange(type.GetEnumNames().Select(s => new MethodAutocompleteItem(s)
                {
                    ImageIndex = TabularIcons.ICON_ENUM
                }));
                Add(new MethodAutocompleteItem("HasFlag")
                {
                    ToolTipTitle = "bool Enum.HasFlag(Enum flag)",
                    ToolTipText  = "Determines whether one or more bits are set in the bit mask.",
                    ImageIndex   = TabularIcons.ICON_METHOD
                });
                // TODO: Add our own extensions to the "Types" enum?
                return;
            }

            //return methods
            foreach (var mi in type.GetMethods(BindingFlags.Public | BindingFlags.Instance)
                     .Where(m => !m.IsSpecialName && m.DeclaringType != typeof(object)).AsEnumerable())
            {
                if (mi.GetCustomAttribute <IntelliSenseAttribute>() == null)
                {
                    continue;
                }
                switch (mi.Name)
                {
                case "GetEnumerator":
                    continue;
                }

                // Overloaded methods only show up once, but let's display all overrides in the tooltip.
                var    methodName = mi.Name;
                string returnTypeName;
                if (mi.ReturnType == typeof(void))
                {
                    returnTypeName = "void";
                }
                else
                {
                    var returnType = new CodeTypeReference(mi.ReturnType);
                    returnTypeName = compiler.GetTypeOutput(returnType).Replace("TabularEditor.UI.UISelectionList", "IEnumerable").Replace("TabularEditor.TOMWrapper.", "");
                }

                var methodSyntax = returnTypeName + " " + mi.Name + "(" + string.Join(", ", mi.GetParameters().Select(p => p.Name).ToArray()) + ")";

                if (last?.Text == methodName)
                {
                    last.ToolTipText = methodSyntax + Environment.NewLine + last.ToolTipText;
                }
                else
                {
                    last = new MethodAutocompleteItemParen(methodName)
                    {
                        ToolTipTitle = methodSyntax,
                        ToolTipText  = mi.GetCustomAttribute <IntelliSenseAttribute>()?.Description ?? string.Empty,
                        ImageIndex   = TabularIcons.ICON_METHOD
                    };
                    Add(last);
                }
            }

            // Return constants:
            foreach (var fi in type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy))
            {
                if (fi.IsLiteral)
                {
                    Add(new MethodAutocompleteItem(fi.Name)
                    {
                        ToolTipTitle = $"(constant) int DaxToken.{fi.Name} = {fi.GetRawConstantValue()}",
                        ImageIndex   = TabularIcons.ICON_PROPERTY
                    });
                }
            }

            // Type derives from IEnumerable, so let's add a few select LINQ methods:
            if (type.GetInterface("IEnumerable") != null)
            {
                Add(new MethodAutocompleteItemParen("Select")
                {
                    ToolTipTitle = "object Select(selector)",
                    ToolTipText  = "Projects each item of the collection into something else using a lambda expression.\nExample: .Select(Measure => Measure.Table)",
                    ImageIndex   = TabularIcons.ICON_EXMETHOD
                });
                Add(new MethodAutocompleteItemParen("Any")
                {
                    ToolTipTitle = "bool Any(predicate)",
                    ToolTipText  = "Determines if the collection contains any items. Specify a lambda expression to determine if the collection contains any items satisfying the given condition.\nExample: .Any(Measure => Measure.Description == \"\")",
                    ImageIndex   = TabularIcons.ICON_EXMETHOD
                });
                Add(new MethodAutocompleteItemParen("All")
                {
                    ToolTipTitle = "bool All(predicate)",
                    ToolTipText  = "Determines if all items in the collection satisfies the given condition.\nExample: .All(Measure => Measure.Description == \"\")",
                    ImageIndex   = TabularIcons.ICON_EXMETHOD
                });
                Add(new MethodAutocompleteItemParen("First")
                {
                    ToolTipTitle = type.Name + " First(predicate)",
                    ToolTipText  = "Returns the first element of the sequence, satisfying the (optionally) specified condition.",
                    ImageIndex   = TabularIcons.ICON_EXMETHOD
                });
                Add(new MethodAutocompleteItemParen("Last")
                {
                    ToolTipTitle = type.Name + " Last(predicate)",
                    ToolTipText  = "Returns the last element of the sequency, satisfying the (optionally) specified condition.",
                    ImageIndex   = TabularIcons.ICON_EXMETHOD
                });
                Add(new MethodAutocompleteItemParen("Take")
                {
                    ToolTipTitle = "IEnumerable<" + type.Name + "> Take(count)",
                    ToolTipText  = "Returns a specified number of contiguous elements from the start of a sequence.",
                    ImageIndex   = TabularIcons.ICON_EXMETHOD
                });
                Add(new MethodAutocompleteItemParen("Skip")
                {
                    ToolTipTitle = "IEnumerable<" + type.Name + "> Skip(count)",
                    ToolTipText  = "Bypasses a specified number of elements in a sequence and then returns the remaining elements.",
                    ImageIndex   = TabularIcons.ICON_EXMETHOD
                });

                // Below adds all LINQ methods, which may be overkill:

                /*foreach (var method in typeof(System.Linq.Enumerable)
                 *  .GetMethods(BindingFlags.Static | BindingFlags.Public).Select(m => m.Name).Distinct())
                 * {
                 *  yield return new MethodAutocompleteItem(method + "()")
                 *  {
                 *      ToolTipTitle = method,
                 *      ImageIndex = TabularIcons.ICON_METHOD
                 *  };
                 * }*/
            }

            //return static properties of the class
            foreach (var pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                if (pi.GetCustomAttribute <IntelliSenseAttribute>() == null &&
                    pi.GetCustomAttribute <DisplayNameAttribute>() == null &&
                    pi.GetCustomAttribute <BrowsableAttribute>() == null)
                {
                    continue;
                }
                var propType     = new CodeTypeReference(pi.PropertyType);
                var propTypeName = compiler.GetTypeOutput(propType).Replace("TabularEditor.UI.UISelectionList", "IEnumerable").Replace("TabularEditor.TOMWrapper.", "");

                var canRead  = pi.CanRead && pi.GetMethod.IsPublic;
                var canWrite = pi.CanWrite && pi.SetMethod.IsPublic;

                Add(new MethodAutocompleteItem(pi.Name)
                {
                    ToolTipTitle = string.Format("{0} {1} {{ {2}}}", propTypeName, pi.Name, (canRead ? "get; " : "") + (canWrite ? "set; " : "")),
                    ToolTipText  = pi.GetCustomAttribute <IntelliSenseAttribute>()?.Description ?? string.Empty,
                    ImageIndex   = TabularIcons.ICON_PROPERTY
                });
            }

            this.Sort((a, b) => a.Text.CompareTo(b.Text));
        }