Example #1
0
 private void VisitorOnVisitNode(XmlExpressionNode node)
 {
     if (Handler != null)
     {
         Handler.HighlightNode(node);
     }
 }
Example #2
0
        internal XmlExpressionNode GetNodeAt(int start, int end)
        {
            XmlExpressionNode selectedNode = null;

            foreach (var node in _visitor.Nodes)
            {
                if (node.Start > start)
                {
                    continue;
                }
                if (selectedNode == null)
                {
                    if (node.End >= end)
                    {
                        selectedNode = node;
                    }
                }
                else
                {
                    if (node.End > end)
                    {
                        if (node.Start >= selectedNode.Start || node.End <= selectedNode.End)
                        {
                            selectedNode = node;
                        }
                    }
                }
            }
            return(selectedNode);
        }
Example #3
0
        public List <XmlExpressionNode> Parse(string xmlText)
        {
            _tokenizer.SetSource(xmlText);
            _tokenizer.NextToken(true);
            var xmlExpressionNodes = new List <XmlExpressionNode>();

            while (_tokenizer.Token != TokenType.Eof)
            {
                XmlExpressionNode parse = TryParse();
                xmlExpressionNodes.Add(parse);
                if (_tokenizer.Token != TokenType.LessThan && _tokenizer.Token != XmlTokens.StartComment)
                {
                    _tokenizer.NextToken(true);
                }
            }
            return(xmlExpressionNodes);
        }
Example #4
0
 private void VisitorOnVisitNode(XmlExpressionNode node)
 {
     Handler?.HighlightNode(node);
 }
Example #5
0
 internal void Highlight(Color color, XmlExpressionNode node, Font font = null)
 {
     Highlight(color, node.Start, node.Length, font);
 }
        void IXmlHandler.HighlightNode(XmlExpressionNode node)
        {
            var commentExpressionNode = node as XmlCommentExpressionNode;
            if (commentExpressionNode != null)
            {
                bindingEditor.Highlight(CommentColor, node);
                return;
            }

            var expressionNode = node as XmlValueExpressionNode;
            if (expressionNode == null)
                return;
            SortedDictionary<string, AutoCompleteItem> list = null;
            XmlAttributeExpressionNode attr;
            switch (expressionNode.Type)
            {
                case XmlValueExpressionType.ElementStartTag:
                case XmlValueExpressionType.ElementStartTagEnd:
                case XmlValueExpressionType.ElementEndTag:
                    var element = node.Parent as XmlElementExpressionNode;
                    if (element == null)
                        return;
                    var elementColor = (element.Parent == null || _controlsDictionary.TryGetValue(element.Name, out list))
                        ? KnownControlColor
                        : UnknownControlColor;
                    bindingEditor.Highlight(elementColor, node);
                    break;
                case XmlValueExpressionType.AttributeName:
                    element = node.Parent as XmlElementExpressionNode;
                    if (element == null)
                    {
                        attr = node.Parent as XmlAttributeExpressionNode;
                        if (attr != null)
                            element = attr.Parent;
                    }
                    if (element == null)
                        return;
                    _controlsDictionary.TryGetValue(element.Name, out list);
                    if (list == null)
                    {
                        bindingEditor.Highlight(UnknownAttachedMemberColor, node);
                        return;
                    }
                    var memberName = node.GetValue(bindingEditor.Text);
                    var members = memberName.Split(DotSeparator, StringSplitOptions.None);

                    AutoCompleteItem member;
                    if (members.Length == 0 || !list.TryGetValue(members[0], out member))
                    {
                        bindingEditor.Highlight(UnknownAttachedMemberColor, node);
                        return;
                    }

                    HighlightMember(member.MemberType, node.Start, members[0].Length);
                    //Highlight for complex path.
                    if (members.Length > 1)
                    {
                        Type type = member.Type;
                        int startIndex = node.Start + members[0].Length + 1;
                        for (int i = 1; i < members.Length; i++)
                        {
                            var path = members[i];
                            MemberTypes? memberType = null;
                            if (type != null)
                            {
                                var bindingMember = BindingServiceProvider
                                    .MemberProvider
                                    .GetBindingMember(type, path, false, false);

                                if (bindingMember == null)
                                    type = null;
                                else
                                {
                                    type = bindingMember.Type;
                                    memberType = bindingMember.Member == null
                                        ? MemberTypes.Custom
                                        : bindingMember.Member.MemberType;
                                }
                            }
                            HighlightMember(memberType, startIndex, path.Length);
                            startIndex += path.Length + 1;
                        }
                    }
                    break;
                case XmlValueExpressionType.AttributeEqual:
                case XmlValueExpressionType.AttributeValue:
                    attr = node.Parent as XmlAttributeExpressionNode;
                    if (attr != null)
                        bindingEditor.Highlight(ValueColor, node);
                    break;
            }
        }
Example #7
0
        void IXmlHandler.HighlightNode(XmlExpressionNode node)
        {
            var commentExpressionNode = node as XmlCommentExpressionNode;

            if (commentExpressionNode != null)
            {
                bindingEditor.Highlight(CommentColor, node);
                return;
            }

            var expressionNode = node as XmlValueExpressionNode;

            if (expressionNode == null)
            {
                return;
            }
            SortedDictionary <string, AutoCompleteItem> list = null;
            XmlAttributeExpressionNode attr;

            switch (expressionNode.Type)
            {
            case XmlValueExpressionType.ElementStartTag:
            case XmlValueExpressionType.ElementStartTagEnd:
            case XmlValueExpressionType.ElementEndTag:
                var element = node.Parent as XmlElementExpressionNode;
                if (element == null)
                {
                    return;
                }
                var elementColor = element.Parent == null || _controlsDictionary.TryGetValue(element.Name, out list)
                        ? KnownControlColor
                        : UnknownControlColor;
                bindingEditor.Highlight(elementColor, node);
                break;

            case XmlValueExpressionType.AttributeName:
                element = node.Parent as XmlElementExpressionNode;
                if (element == null)
                {
                    attr = node.Parent as XmlAttributeExpressionNode;
                    if (attr != null)
                    {
                        element = attr.Parent;
                    }
                }
                if (element == null)
                {
                    return;
                }
                _controlsDictionary.TryGetValue(element.Name, out list);
                if (list == null)
                {
                    bindingEditor.Highlight(UnknownAttachedMemberColor, node);
                    return;
                }
                var memberName = node.GetValue(bindingEditor.Text);
                var members    = memberName.Split(DotSeparator, StringSplitOptions.None);

                AutoCompleteItem member;
                if (members.Length == 0 || !list.TryGetValue(members[0], out member))
                {
                    bindingEditor.Highlight(UnknownAttachedMemberColor, node);
                    return;
                }

                HighlightMember(member.MemberType, node.Start, members[0].Length);
                //Highlight for complex path.
                if (members.Length > 1)
                {
                    Type type       = member.Type;
                    int  startIndex = node.Start + members[0].Length + 1;
                    for (int i = 1; i < members.Length; i++)
                    {
                        var         path       = members[i];
                        MemberTypes?memberType = null;
                        if (type != null)
                        {
                            var bindingMember = BindingServiceProvider
                                                .MemberProvider
                                                .GetBindingMember(type, path, false, false);

                            if (bindingMember == null)
                            {
                                type = null;
                            }
                            else
                            {
                                type       = bindingMember.Type;
                                memberType = (bindingMember.Member as MemberInfo)?.MemberType ?? MemberTypes.Custom;
                            }
                        }
                        HighlightMember(memberType, startIndex, path.Length);
                        startIndex += path.Length + 1;
                    }
                }
                break;

            case XmlValueExpressionType.AttributeEqual:
            case XmlValueExpressionType.AttributeValue:
                attr = node.Parent as XmlAttributeExpressionNode;
                if (attr != null)
                {
                    bindingEditor.Highlight(ValueColor, node);
                }
                break;
            }
        }
Example #8
0
        private XmlExpressionNode TryParseElement()
        {
            int startPosition = _tokenizer.FirstCharPosition;
            var tagEnd        = _tokenizer.Position;

            _tokenizer.NextToken(false);
            if (!IsXmlIdentifier())
            {
                var node = new XmlValueExpressionNode(XmlValueExpressionType.ElementStartTag, startPosition, tagEnd);
                return(InvalidExpression(XmlInvalidExpressionType.Element, startPosition, node));
            }

            var startTag = new XmlValueExpressionNode(XmlValueExpressionType.ElementStartTag, startPosition,
                                                      _tokenizer.Position);
            string nameString = _tokenizer.Value;

            _tokenizer.NextToken(true);
            var elementNode = new XmlElementExpressionNode(startTag, nameString, startPosition, -1);

            while (_tokenizer.Token != TokenType.Eof)
            {
                if (IsXmlIdentifier())
                {
                    XmlExpressionNode attribute = TryParseAttribute(elementNode);
                    elementNode.AddAttribute(attribute);
                    continue;
                }

                if (_tokenizer.Token == XmlTokens.CloseElement)
                {
                    elementNode.UpdateCloseTag(
                        new XmlValueExpressionNode(XmlValueExpressionType.ElementEndTag, _tokenizer.FirstCharPosition,
                                                   _tokenizer.Position),
                        _tokenizer.Position);
                    _tokenizer.NextToken(false);
                    return(elementNode);
                }

                if (_tokenizer.Token == TokenType.GreaterThan)
                {
                    elementNode.UpdateStartTagEnd(new XmlValueExpressionNode(XmlValueExpressionType.ElementStartTagEnd,
                                                                             _tokenizer.FirstCharPosition,
                                                                             _tokenizer.Position));
                    _tokenizer.NextToken(false);
                    IList <XmlExpressionNode> nodes = TryParseElementValue();
                    for (int i = 0; i < nodes.Count; i++)
                    {
                        elementNode.AddElement(nodes[i]);
                    }

                    int closeElementPosition = _tokenizer.FirstCharPosition;
                    if (_tokenizer.Token != XmlTokens.ComplexCloseElement)
                    {
                        return(InvalidExpression(XmlInvalidExpressionType.Element, startPosition, elementNode));
                    }
                    _tokenizer.NextToken(false);
                    if (_tokenizer.Value != nameString)
                    {
                        return(InvalidExpression(XmlInvalidExpressionType.Element, startPosition, elementNode));
                    }
                    if (_tokenizer.NextToken(false) != TokenType.GreaterThan)
                    {
                        return(InvalidExpression(XmlInvalidExpressionType.Element, startPosition, elementNode));
                    }
                    elementNode.UpdateCloseTag(
                        new XmlValueExpressionNode(XmlValueExpressionType.ElementEndTag, closeElementPosition,
                                                   _tokenizer.Position),
                        _tokenizer.Position);
                    _tokenizer.NextToken(false);
                    return(elementNode);
                }
                if (_tokenizer.Token == TokenType.Whitespace)
                {
                    _tokenizer.NextToken(true);
                }
                return(InvalidExpression(XmlInvalidExpressionType.Element, startPosition, elementNode));
            }
            return(InvalidExpression(XmlInvalidExpressionType.Element, startPosition, elementNode));
        }
 public XmlValueExpressionNode(XmlExpressionNode parent, XmlValueExpressionType type, int start, int end)
     : this(type, start, end)
 {
     UpdateParent(this, parent);
 }
Example #10
0
 private void VisitorOnVisitNode(XmlExpressionNode node)
 {
     if (Handler != null)
         Handler.HighlightNode(node);
 }
Example #11
0
 internal void Highlight(Color color, XmlExpressionNode node, Font font = null)
 {
     Highlight(color, node.Start, node.Length, font);
 }