Beispiel #1
0
        private void AddMembers(TreeNodeCollection nodes, MemberList members)
        {
            bool   wholeWord              = settings.OutlineFormWholeWord;
            bool   matchCase              = settings.OutlineFormMatchCase;
            string searchedText           = matchCase ? textBox.Text.Trim() : textBox.Text.ToLower().Trim();
            bool   searchedTextIsNotEmpty = !string.IsNullOrEmpty(searchedText);

            foreach (MemberModel member in members)
            {
                string memberText = matchCase ? member.ToString() : member.ToString().ToLower();

                if (searchedTextIsNotEmpty && (!wholeWord && memberText.IndexOf(searchedText) == -1 || wholeWord && !memberText.StartsWith(searchedText)))
                {
                    continue;
                }

                MemberTreeNode node = null;
                if ((member.Flags & (FlagType.Constant | FlagType.Variable | FlagType.Function | FlagType.Getter | FlagType.Setter)) > 0)
                {
                    node = new MemberTreeNode(member, PluginUI.GetIcon(member.Flags, member.Access));
                    nodes.Add(node);
                }

                if (tree.SelectedNode == null)
                {
                    tree.SelectedNode = node;
                }
            }
        }
Beispiel #2
0
        ConstructorInfo FindConstructor(ConstructorInfo[] constructors)
        {
            ConstructorInfo constructor = null;

            if (constructors.Length > 1)
            {
                // Ask them to chose a constructor, if the
                // constructor requires parameters, then select
                // it and get out, otherwise go ahead.
                constructor = ConstructorDialog.
                              GetConstructor(constructors);
                if (constructor != null &&
                    constructor.GetParameters().Length != 0)
                {
                    AssemblySupport.SelectAssyTab();
                    MemberTreeNode.FindMember(constructor).PointToNode();
                    return(null);
                }
            }
            else
            {
                constructor = constructors[0];
            }

            // This was cancelled
            if (constructor == null)
            {
                return(null);
            }

            // Since we need to get parameters, we can't finish
            // this operation now, we refer then to the constructor
            // that they should use and they can drag that
            // constructor where they want the object to do
            if (constructor.GetParameters().Length != 0)
            {
                BrowserTreeNode selNode =
                    MemberTreeNode.FindMember(constructor);
                ErrorDialog.
                Show("Please select the constructor member " +
                     "of this Type, fill in the parameters, " +
                     "and then drag " +
                     "the constructor to where you " +
                     "want this object " +
                     "to be created.",
                     "Provide Parameters",
                     MessageBoxIcon.Information);
                AssemblySupport.SelectAssyTab();
                selNode.PointToNode();
                return(null);
            }
            return(constructor);
        }
        private void AddMembers(TreeNodeCollection nodes, MemberList members)
        {
            String searchedText = textBox.Text.ToLower().Trim();

            foreach (MemberModel member in members)
            {
                String memberText = member.ToString().ToLower();
                if (searchedText.Length > 0 && !memberText.StartsWith(searchedText))
                {
                    continue;
                }

                MemberTreeNode node = null;
                int            imageIndex;
                if ((member.Flags & FlagType.Constant) > 0)
                {
                    imageIndex = ((member.Access & Visibility.Private) > 0) ? ICON_PRIVATE_CONST :
                                 ((member.Access & Visibility.Protected) > 0) ? ICON_PROTECTED_CONST : ICON_CONST;
                    node = new MemberTreeNode(member, imageIndex);
                    nodes.Add(node);
                }
                else if ((member.Flags & FlagType.Variable) > 0)
                {
                    imageIndex = ((member.Access & Visibility.Private) > 0) ? ICON_PRIVATE_VAR :
                                 ((member.Access & Visibility.Protected) > 0) ? ICON_PROTECTED_VAR : ICON_VAR;
                    node = new MemberTreeNode(member, imageIndex);
                    nodes.Add(node);
                }
                else if ((member.Flags & (FlagType.Getter | FlagType.Setter)) > 0)
                {
                    if (node != null && node.Text == member.ToString()) // "collapse" properties
                    {
                        continue;
                    }
                    imageIndex = ((member.Access & Visibility.Private) > 0) ? ICON_PRIVATE_PROPERTY :
                                 ((member.Access & Visibility.Protected) > 0) ? ICON_PROTECTED_PROPERTY : ICON_PROPERTY;
                    node = new MemberTreeNode(member, imageIndex);
                    nodes.Add(node);
                }
                else if ((member.Flags & FlagType.Function) > 0)
                {
                    imageIndex = ((member.Access & Visibility.Private) > 0) ? ICON_PRIVATE_FUNCTION :
                                 ((member.Access & Visibility.Protected) > 0) ? ICON_PROTECTED_FUNCTION : ICON_FUNCTION;
                    node = new MemberTreeNode(member, imageIndex);
                    nodes.Add(node);
                }
                if (tree.SelectedNode == null)
                {
                    tree.SelectedNode = node;
                }
            }
        }
        internal static void NavigateTo(MemberTreeNode node)
        {
            if (node is InheritedMemberTreeNode)
            {
                InheritedMemberTreeNode inheritedNode = (InheritedMemberTreeNode)node;
                FileModel model = ModelsExplorer.Instance.OpenFile(inheritedNode.ClassModel.InFile.FileName);

                // We have to update the Tag to reflect the line number the member starts on
                if (!(node is InheritedClassTreeNode))
                    inheritedNode.Tag = GetInheritedMemberTag(model, inheritedNode.Model.Name) ?? string.Empty;
            }
            else if (node is ImportTreeNode)
            {
                ImportTreeNode importNode = (ImportTreeNode)node;
                ClassModel importModel = (ClassModel)importNode.Model;
                if (!importModel.IsVoid() && importModel.InFile != null)
                    ModelsExplorer.Instance.OpenFile(importModel.InFile.FileName);
            }

            // Navigate to node location
            ASContext.Context.OnSelectOutlineNode(node);
        }
        // When a link is clicked to this, the linkModifier is the
        // type or the assembly
        public void ShowTarget(Object linkModifier)
        {
            if (linkModifier == null)
            {
                return;
            }

            Assembly   assy;
            Type       type       = null;
            MemberInfo memberInfo = null;

            if (linkModifier is Assembly)
            {
                assy = (Assembly)linkModifier;
            }
            else if (linkModifier is Type)
            {
                type = (Type)linkModifier;
                assy = type.Assembly;
            }
            else             // MemberInfo
            {
                memberInfo = (MemberInfo)linkModifier;
                type       = memberInfo.DeclaringType;
                assy       = type.Assembly;
            }

            AssemblySupport.SelectAssyTab();

            AssemblyTreeNode node =
                AssemblySupport.FindAssemblyTreeNode(assy);

            if (node == null)
            {
                throw new Exception("Bug: assembly not found for type: " + type);
            }

            if (type != null)
            {
                TypeTreeNode typeNode = node.GetTypeNode(type);
                if (typeNode == null)
                {
                    throw new Exception("Bug: typeNode not found for type: "
                                        + type);
                }

                if (memberInfo != null)
                {
                    MemberTreeNode memberNode =
                        typeNode.FindMemberNode(memberInfo,
                                                !TypeTreeNode.FIND_NESTED);
                    if (memberNode != null)
                    {
                        memberNode.PointToNode();
                    }
                    else
                    {
                        throw new Exception("Bug: member not found for type: "
                                            + type + " mem: " + memberInfo);
                    }
                }
                else
                {
                    typeNode.PointToNode();
                }
            }
            else
            {
                node.PointToNode();
            }
        }