示例#1
0
        private static bool ShouldBeVisibleBasedOnKind(CodeItemKindEnum kind)
        {
            switch (kind)
            {
            case CodeItemKindEnum.Constant:
                return(Settings.Default.ShowConstants);

            case CodeItemKindEnum.Constructor:
                return(Settings.Default.ShowConstructors);

            case CodeItemKindEnum.Delegate:
                return(Settings.Default.ShowConstructors);

            case CodeItemKindEnum.Enum:
                return(Settings.Default.ShowEnums);

            case CodeItemKindEnum.EnumMember:
                return(Settings.Default.ShowEnumItems);

            case CodeItemKindEnum.Event:
                return(Settings.Default.ShowEvents);

            case CodeItemKindEnum.Method:
                return(Settings.Default.ShowMethods);

            case CodeItemKindEnum.Property:
                return(Settings.Default.ShowProperties);

            case CodeItemKindEnum.Struct:
                return(Settings.Default.ShowStructs);

            case CodeItemKindEnum.Variable:
                return(Settings.Default.ShowVariables);

            case CodeItemKindEnum.Switch:
                return(Settings.Default.ShowSwitch);

            case CodeItemKindEnum.SwitchSection:
                return(Settings.Default.ShowSwitchItems);

            case CodeItemKindEnum.Class:
            case CodeItemKindEnum.Interface:
            case CodeItemKindEnum.Region:
            case CodeItemKindEnum.Namespace:
            case CodeItemKindEnum.ImplementedInterface:
                return(true);

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
示例#2
0
        public static bool ShouldBeVisible(CodeItemKindEnum kind)
        {
            var visible = true;

            if (Settings.Default.FilterRules != null)
            {
                var filterRule = Settings.Default.FilterRules.LastOrDefault(f =>
                                                                            (f.Kind == kind || f.Kind == CodeItemKindEnum.All));

                if (filterRule != null)
                {
                    visible = filterRule.Visible;
                }
            }

            return(visible);
        }
示例#3
0
        public static ImageMoniker MapMoniker(CodeItemKindEnum kind, CodeItemAccessEnum access)
        {
            string monikerString;
            var    accessString = GetEnumDescription(access);

            switch (kind)
            {
            case CodeItemKindEnum.Class:
                monikerString = $"Class{accessString}";
                break;

            case CodeItemKindEnum.Constant:
                monikerString = $"Constant{accessString}";
                break;

            case CodeItemKindEnum.Delegate:
                monikerString = $"Delegate{accessString}";
                break;

            case CodeItemKindEnum.Enum:
                monikerString = $"Enumeration{accessString}";
                break;

            case CodeItemKindEnum.EnumMember:
                monikerString = $"EnumerationItem{accessString}";
                break;

            case CodeItemKindEnum.Event:
                monikerString = $"Event{accessString}";
                break;

            case CodeItemKindEnum.Interface:
                monikerString = $"Interface{accessString}";
                break;

            case CodeItemKindEnum.Constructor:
            case CodeItemKindEnum.Method:
                monikerString = $"Method{accessString}";
                break;

            case CodeItemKindEnum.Property:
                monikerString = $"Property{accessString}";
                break;

            case CodeItemKindEnum.Struct:
                monikerString = $"Structure{accessString}";
                break;

            case CodeItemKindEnum.Variable:
                monikerString = $"Field{accessString}";
                break;

            case CodeItemKindEnum.Switch:
                monikerString = "FlowSwitch";
                break;

            case CodeItemKindEnum.SwitchSection:
                monikerString = "FlowDecision";
                break;

            default:
                monikerString = $"Property{accessString}";
                break;
            }

            var monikers = typeof(KnownMonikers).GetProperties();

            var imageMoniker = monikers.FirstOrDefault(m => monikerString.Equals(m.Name))?.GetValue(null, null);

            if (imageMoniker != null)
            {
                return((ImageMoniker)imageMoniker);
            }

            return(KnownMonikers.QuestionMark);
        }
示例#4
0
        public static IEnumerable <CodeItem> Find(List <CodeItem> found, IEnumerable <CodeItem> items, CodeItemKindEnum kind)
        {
            foreach (var item in items)
            {
                if (item.Kind == kind)
                {
                    found.Add(item);
                }

                if (item is IMembers)
                {
                    found.AddRange(Find(found, ((IMembers)item).Members, kind));
                }
            }

            return(found);
        }