Node (c) 1998-2000 (W3C) MIT, INRIA, Keio University See Tidy.cs for the copyright notice. Derived from HTML Tidy Release 4 Aug 2000
Used for elements and text nodes element name is null for text nodes start and end are offsets into lexbuf which contains the textual content of all elements in the parse tree. parent and content allow traversal of the parse tree in any direction. attributes are represented as a linked list of AttVal nodes which hold the strings for attribute/value pairs.
        public virtual void Check(Lexer lexer, Node node)
        {
            node.CheckUniqueAttributes(lexer);

            AttVal lang = node.GetAttrByName("language");
            AttVal type = node.GetAttrByName("type");
            if (type == null)
            {
                Report.AttrError(lexer, node, "type", Report.MISSING_ATTRIBUTE);

                /* check for javascript */
                if (lang != null)
                {
                    string str = lang.Val;
                    if (str.Length > 10)
                    {
                        str = str.Substring(0, 10);
                    }

                    if ((String.CompareOrdinal(str, "javascript") == 0) || (String.CompareOrdinal(str, "jscript") == 0))
                    {
                        node.AddAttribute("type", "text/javascript");
                    }
                }
                else
                {
                    node.AddAttribute("type", "text/javascript");
                }
            }
        }
Exemple #2
0
        /*
        Replace implicit blockquote by div with an indent
        taking care to reduce nested blockquotes to a single
        div with the indent set to match the nesting depth
        */
        public virtual void Bq2Div(Node node)
        {
            while (node != null)
            {
                if (node.Tag == _tt.TagBlockquote && node.Isimplicit)
                {
                    int indent = 1;

                    while (node.HasOneChild() && node.Content.Tag == _tt.TagBlockquote && node.Isimplicit)
                    {
                        ++indent;
                        StripOnlyChild(node);
                    }

                    if (node.Content != null)
                    {
                        Bq2Div(node.Content);
                    }

                    string indentBuf = "margin-left: " + (2*indent).ToString() + "em";

                    node.Element = _tt.TagDiv.Name;
                    node.Tag = _tt.TagDiv;
                    node.AddAttribute("style", indentBuf);
                }
                else if (node.Content != null)
                {
                    Bq2Div(node.Content);
                }

                node = node.Next;
            }
        }
        protected internal virtual void PreTraverse(Node node)
        {
            if (node == null)
            {
                return;
            }

            if (node.Type == Node.START_TAG || node.Type == Node.START_END_TAG)
            {
                if (_currIndex <= _maxIndex && (_tagName.Equals("*") || _tagName.Equals(node.Element)))
                {
                    _currIndex += 1;
                    _currNode = node;
                }
            }
            if (_currIndex > _maxIndex)
            {
                return;
            }

            node = node.Content;
            while (node != null)
            {
                PreTraverse(node);
                node = node.Next;
            }
        }
        public virtual void Check(Lexer lexer, Node node)
        {
            AttVal attval;
            string val = null;

            node.CheckUniqueAttributes(lexer);

            for (attval = node.Attributes; attval != null; attval = attval.Next)
            {
                if (String.CompareOrdinal(attval.Attribute, "align") == 0)
                {
                    val = attval.Val;
                    break;
                }
            }

            if (val != null)
            {
                if (String.CompareOrdinal(val, "left") == 0 || String.CompareOrdinal(val, "right") == 0)
                {
                    lexer.Versions &= HtmlVersion.Html40Loose | HtmlVersion.Frames;
                }
                else if (String.CompareOrdinal(val, "top") == 0 || String.CompareOrdinal(val, "bottom") == 0)
                {
                    lexer.Versions &= HtmlVersion.From32;
                }
                else
                {
                    Report.AttrError(lexer, node, val, Report.BAD_ATTRIBUTE_VALUE);
                }
            }
        }
        public virtual void Check(Lexer lexer, Node node, AttVal attval)
        {
            string val = attval.Val;

            if (val == null)
            {
                Report.AttrError(lexer, node, attval.Attribute, Report.MISSING_ATTR_VALUE);
            }
            else if (String.CompareOrdinal(val, "top") == 0 || String.CompareOrdinal(val, "middle") == 0 ||
                     String.CompareOrdinal(val, "bottom") == 0 || String.CompareOrdinal(val, "baseline") == 0)
            {
                /* all is fine */
            }
            else if (String.CompareOrdinal(val, "left") == 0 || String.CompareOrdinal(val, "right") == 0)
            {
                if (!(node.Tag != null && ((node.Tag.Model & ContentModel.IMG) != 0)))
                {
                    Report.AttrError(lexer, node, val, Report.BAD_ATTRIBUTE_VALUE);
                }
            }
            else if (String.CompareOrdinal(val, "texttop") == 0 || String.CompareOrdinal(val, "absmiddle") == 0 ||
                     String.CompareOrdinal(val, "absbottom") == 0 || String.CompareOrdinal(val, "textbottom") == 0)
            {
                lexer.Versions &= HtmlVersion.Proprietary;
                Report.AttrError(lexer, node, val, Report.PROPRIETARY_ATTR_VALUE);
            }
            else
            {
                Report.AttrError(lexer, node, val, Report.BAD_ATTRIBUTE_VALUE);
            }
        }
Exemple #6
0
 public AttVal(AttVal next, Attribute dict, Node asp, Node php, int delim, string attribute, string val)
 {
     Next = next;
     _dict = dict;
     _asp = asp;
     Php = php;
     Delim = delim;
     Attribute = attribute;
     Val = val;
 }
Exemple #7
0
 public AttVal(AttVal next, Attribute dict, int delim, string attribute, string val)
 {
     Next = next;
     _dict = dict;
     _asp = null;
     Php = null;
     Delim = delim;
     Attribute = attribute;
     Val = val;
 }
Exemple #8
0
 public AttVal()
 {
     Next = null;
     _dict = null;
     _asp = null;
     Php = null;
     Delim = 0;
     Attribute = null;
     Val = null;
 }
        public virtual void Check(Lexer lexer, Node node, AttVal attval)
        {
            /* IMG, OBJECT, APPLET and EMBED use align for vertical position */
            if (node.Tag != null && ((node.Tag.Model & ContentModel.IMG) != 0))
            {
                AttrCheckImpl.CheckValign.Check(lexer, node, attval);
                return;
            }

            string val = attval.Val;

            if (val == null)
            {
                Report.AttrError(lexer, node, attval.Attribute, Report.MISSING_ATTR_VALUE);
            }
            else if (
                !(String.CompareOrdinal(val, "left") == 0 || String.CompareOrdinal(val, "center") == 0 ||
                  String.CompareOrdinal(val, "right") == 0 || String.CompareOrdinal(val, "justify") == 0))
            {
                Report.AttrError(lexer, node, attval.Val, Report.BAD_ATTRIBUTE_VALUE);
            }
        }
 protected internal DomElementImpl(Node adaptee)
     : base(adaptee)
 {
 }
Exemple #11
0
        /*
        Called from printTree to print the content of a slide from
        the node slidecontent. On return slidecontent points to the
        node starting the next slide or null. The variables slide
        and count are used to customise the navigation bar.
        */
        public virtual void PrintSlide(Out fout, int mode, int indent, Lexer lexer)
        {
            TagCollection tt = _options.TagTable;

            /* insert div for onclick handler */
            string s = "<div onclick=\"document.location='slide" + (_slide < _count ? _slide + 1 : 1).ToString() +
                       ".html'\">";
            PrintString(s);
            CondFlushLine(fout, indent);

            /* first print the h2 element and navbar */
            if (_slidecontent.Tag == tt.TagH2)
            {
                PrintNavBar(fout, indent);

                /* now print an hr after h2 */

                AddC('<', _linelen++);

                AddC(Lexer.FoldCase('h', _options.UpperCaseTags, _options.XmlTags), _linelen++);
                AddC(Lexer.FoldCase('r', _options.UpperCaseTags, _options.XmlTags), _linelen++);

                if (_options.XmlOut)
                {
                    PrintString(" />");
                }
                else
                {
                    AddC('>', _linelen++);
                }

                if (_options.IndentContent)
                {
                    CondFlushLine(fout, indent);
                }

                /* PrintVertSpacer(fout, indent); */

                /*CondFlushLine(fout, indent); */

                /* print the h2 element */
                PrintTree(fout, mode, (_options.IndentContent ? indent + _options.Spaces : indent), lexer, _slidecontent);

                _slidecontent = _slidecontent.Next;
            }

            /* now continue until we reach the next h2 */

            Node last = null;
            Node content = _slidecontent;

            for (; content != null; content = content.Next)
            {
                if (content.Tag == tt.TagH2)
                {
                    break;
                }

                /* kludge for naked text before block level tag */
                if (last != null && !_options.IndentContent && last.Type == Node.TEXT_NODE && content.Tag != null &&
                    (content.Tag.Model & ContentModel.BLOCK) != 0)
                {
                    FlushLine(fout, indent);
                    FlushLine(fout, indent);
                }

                PrintTree(fout, mode, (_options.IndentContent ? indent + _options.Spaces : indent), lexer, content);

                last = content;
            }

            _slidecontent = content;

            /* now print epilog */

            CondFlushLine(fout, indent);

            PrintString("<br clear=\"all\">");
            CondFlushLine(fout, indent);

            AddC('<', _linelen++);

            AddC(Lexer.FoldCase('h', _options.UpperCaseTags, _options.XmlTags), _linelen++);
            AddC(Lexer.FoldCase('r', _options.UpperCaseTags, _options.XmlTags), _linelen++);

            if (_options.XmlOut)
            {
                PrintString(" />");
            }
            else
            {
                AddC('>', _linelen++);
            }

            if (_options.IndentContent)
            {
                CondFlushLine(fout, indent);
            }

            PrintNavBar(fout, indent);

            /* end tag for div */
            PrintString("</div>");
            CondFlushLine(fout, indent);
        }
 protected internal DomNodeListByTagNameImpl(Node first, string tagName)
 {
     _first = first;
     _tagName = tagName;
 }
Exemple #13
0
        private void PrintPi(Out fout, int indent, Node node)
        {
            if (indent + _linelen < _options.WrapLen)
            {
                _wraphere = _linelen;
            }

            AddC('<', _linelen++);
            AddC('?', _linelen++);

            /* set CDATA to pass < and > unescaped */
            PrintText(fout, CDATA, indent, node.Textarray, node.Start, node.End);

            if (node.Textarray[node.End - 1] != (byte) '?')
            {
                AddC('?', _linelen++);
            }

            AddC('>', _linelen++);
            CondFlushLine(fout, indent);
        }
Exemple #14
0
        private void PrintAttrs(Out fout, int indent, Node node, AttVal attr)
        {
            if (attr != null)
            {
                if (attr.Next != null)
                {
                    PrintAttrs(fout, indent, node, attr.Next);
                }

                if (attr.Attribute != null)
                {
                    PrintAttribute(fout, indent, node, attr);
                }
                else if (attr.Asp != null)
                {
                    AddC(' ', _linelen++);
                    PrintAsp(fout, indent, attr.Asp);
                }
                else if (attr.Php != null)
                {
                    AddC(' ', _linelen++);
                    PrintPhp(fout, indent, attr.Php);
                }
            }

            /* add xml:space attribute to pre and other elements */
            if (_options.XmlOut && _options.XmlSpace && ParserImpl.XmlPreserveWhiteSpace(node, _options.TagTable) &&
                node.GetAttrByName("xml:space") == null)
            {
                PrintString(" xml:space=\"preserve\"");
            }
        }
Exemple #15
0
        private void PrintTag(Lexer lexer, Out fout, int mode, int indent, Node node)
        {
            TagCollection tt = _options.TagTable;

            AddC('<', _linelen++);

            if (node.Type == Node.END_TAG)
            {
                AddC('/', _linelen++);
            }

            string p = node.Element;
            for (int i = 0; i < p.Length; i++)
            {
                AddC(Lexer.FoldCase(p[i], _options.UpperCaseTags, _options.XmlTags), _linelen++);
            }

            PrintAttrs(fout, indent, node, node.Attributes);

            if ((_options.XmlOut || lexer != null && lexer.Isvoyager) &&
                (node.Type == Node.START_END_TAG || (node.Tag.Model & ContentModel.EMPTY) != 0))
            {
                AddC(' ', _linelen++); /* compatibility hack */
                AddC('/', _linelen++);
            }

            AddC('>', _linelen++);

            if (node.Type == Node.START_END_TAG || (mode & PREFORMATTED) != 0) return;
            if (indent + _linelen >= _options.WrapLen)
            {
                WrapLine(fout, indent);
            }

            if (indent + _linelen < _options.WrapLen)
            {
                /*
                    wrap after start tag if is <br/> or if it's not
                    inline or it is an empty tag followed by </a>
                    */
                if (AfterSpace(node))
                {
                    if ((mode & NOWRAP) == 0 &&
                        ((node.Tag.Model & ContentModel.INLINE) == 0 || (node.Tag == tt.TagBr) ||
                         (((node.Tag.Model & ContentModel.EMPTY) != 0) && node.Next == null &&
                          node.Parent.Tag == tt.TagA)))
                    {
                        _wraphere = _linelen;
                    }
                }
            }
            else
            {
                CondFlushLine(fout, indent);
            }
        }
Exemple #16
0
        /* note ASP and JSTE share <% ... %> syntax */
        private void PrintAsp(Out fout, int indent, Node node)
        {
            int savewraplen = _options.WrapLen;

            /* disable wrapping if so requested */

            if (!_options.WrapAsp || !_options.WrapJste)
            {
                _options.WrapLen = 0xFFFFFF;
            }
            /* a very large number */

            AddC('<', _linelen++);
            AddC('%', _linelen++);

            PrintText(fout, (_options.WrapAsp ? CDATA : COMMENT), indent, node.Textarray, node.Start, node.End);

            AddC('%', _linelen++);
            AddC('>', _linelen++);

            /* CondFlushLine(fout, indent); */
            _options.WrapLen = savewraplen;
        }
Exemple #17
0
        private void PrintAttribute(Out fout, int indent, Node node, AttVal attr)
        {
            bool wrappable = false;

            if (_options.IndentAttributes)
            {
                FlushLine(fout, indent);
                indent += _options.Spaces;
            }

            string name = attr.Attribute;

            if (indent + _linelen >= _options.WrapLen)
            {
                WrapLine(fout, indent);
            }

            if (!_options.XmlTags && !_options.XmlOut && attr.Dict != null)
            {
                if (AttributeTable.DefaultAttributeTable.IsScript(name))
                {
                    wrappable = _options.WrapScriptlets;
                }
                else if (!attr.Dict.Nowrap && _options.WrapAttVals)
                {
                    wrappable = true;
                }
            }

            if (indent + _linelen < _options.WrapLen)
            {
                _wraphere = _linelen;
                AddC(' ', _linelen++);
            }
            else
            {
                CondFlushLine(fout, indent);
                AddC(' ', _linelen++);
            }

            for (int i = 0; i < name.Length; i++)
            {
                AddC(Lexer.FoldCase(name[i], _options.UpperCaseAttrs, _options.XmlTags), _linelen++);
            }

            if (indent + _linelen >= _options.WrapLen)
            {
                WrapLine(fout, indent);
            }

            if (attr.Val == null)
            {
                if (_options.XmlTags || _options.XmlOut)
                {
                    PrintAttrValue(fout, indent, attr.Attribute, attr.Delim, true);
                }
                else if (!attr.BoolAttribute && !Node.IsNewNode(node))
                {
                    PrintAttrValue(fout, indent, "", attr.Delim, true);
                }
                else if (indent + _linelen < _options.WrapLen)
                {
                    _wraphere = _linelen;
                }
            }
            else
            {
                PrintAttrValue(fout, indent, attr.Val, attr.Delim, wrappable);
            }
        }
 protected internal DomDocumentImpl(Node adaptee)
     : base(adaptee)
 {
     _tt = new TagCollection();
 }
Exemple #19
0
        private bool ShouldIndent(Node node)
        {
            TagCollection tt = _options.TagTable;

            if (!_options.IndentContent)
                return false;

            if (_options.SmartIndent)
            {
                if (node.Content != null && ((node.Tag.Model & ContentModel.NO_INDENT) != 0))
                {
                    for (node = node.Content; node != null; node = node.Next)
                    {
                        if (node.Tag != null && (node.Tag.Model & ContentModel.BLOCK) != 0)
                        {
                            return true;
                        }
                    }

                    return false;
                }

                if ((node.Tag.Model & ContentModel.HEADING) != 0)
                {
                    return false;
                }

                if (node.Tag == tt.TagP)
                {
                    return false;
                }

                if (node.Tag == tt.TagTitle)
                {
                    return false;
                }
            }

            if ((node.Tag.Model & (ContentModel.FIELD | ContentModel.OBJECT)) != 0)
            {
                return true;
            }

            if (node.Tag == tt.TagMap)
            {
                return true;
            }

            return (node.Tag.Model & ContentModel.INLINE) == 0;
        }
        public virtual IElement CreateElement(string tagName)
        {
            var node = new Node(Node.START_END_TAG, null, 0, 0, tagName, _tt);
            if (node.Tag == null)
                node.Tag = _tt.XmlTags;

            return (IElement) node.Adapter;
        }
 protected internal DomProcessingInstructionImpl(Node adaptee)
     : base(adaptee)
 {
 }
Exemple #22
0
        public virtual void CreateSlides(Lexer lexer, Node root)
        {
            Out output = new OutImpl();

            Node body = root.FindBody(lexer.Options.TagTable);
            _count = CountSlides(body);
            _slidecontent = body.Content;
            AddTransitionEffect(lexer, root, EFFECT_BLEND, 3.0);

            for (_slide = 1; _slide <= _count; ++_slide)
            {
                string buf = "slide" + _slide + ".html";
                output.State = StreamIn.FSM_ASCII;
                output.Encoding = _options.CharEncoding;

                try
                {
                    output.Output = new MemoryStream();
                    PrintTree(output, 0, 0, lexer, root);
                    FlushLine(output, 0);
                }
                catch (IOException e)
                {
                    Debug.WriteLine(buf + e);
                }
            }
        }
Exemple #23
0
        /* split parse tree by h2 elements and output to separate files */
        /* counts number of h2 children belonging to node */
        public virtual int CountSlides(Node node)
        {
            int n = 1;
            TagCollection tt = _options.TagTable;

            for (node = node.Content; node != null; node = node.Next)
            {
                if (node.Tag == tt.TagH2)
                {
                    ++n;
                }
            }

            return n;
        }
Exemple #24
0
        /*
        Add meta element for page transition effect, this works on IE but not NS
        */
        public virtual void AddTransitionEffect(Lexer lexer, Node root, short effect, double duration)
        {
            Node head = root.FindHead(lexer.Options.TagTable);
            string transition;

            if (0 <= effect && effect <= 23)
            {
                transition = "revealTrans(Duration=" + (duration).ToString() + ",Transition=" + effect + ")";
            }
            else
            {
                transition = "blendTrans(Duration=" + (duration).ToString() + ")";
            }

            if (head != null)
            {
                Node meta = lexer.InferredTag("meta");
                meta.AddAttribute("http-equiv", "Page-Enter");
                meta.AddAttribute("content", transition);
                Node.InsertNodeAtStart(head, meta);
            }
        }
 public virtual IComment CreateComment(string data)
 {
     byte[] textarray = Lexer.GetBytes(data);
     var node = new Node(Node.COMMENT_TAG, textarray, 0, textarray.Length);
     return (IComment) node.Adapter;
 }
Exemple #26
0
        public virtual void PrintTree(Out fout, int mode, int indent, Lexer lexer, Node node)
        {
            Node content;
            TagCollection tt = _options.TagTable;

            if (node == null)
                return;

            if (node.Type == Node.TEXT_NODE)
            {
                PrintText(fout, mode, indent, node.Textarray, node.Start, node.End);
            }
            else if (node.Type == Node.COMMENT_TAG)
            {
                PrintComment(fout, indent, node);
            }
            else if (node.Type == Node.ROOT_NODE)
            {
                for (content = node.Content; content != null; content = content.Next)
                {
                    PrintTree(fout, mode, indent, lexer, content);
                }
            }
            else if (node.Type == Node.DOC_TYPE_TAG)
            {
                PrintDocType(fout, indent, node);
            }
            else if (node.Type == Node.PROC_INS_TAG)
            {
                PrintPi(fout, indent, node);
            }
            else if (node.Type == Node.CDATA_TAG)
            {
                PrintCdata(fout, indent, node);
            }
            else if (node.Type == Node.SECTION_TAG)
            {
                PrintSection(fout, indent, node);
            }
            else if (node.Type == Node.ASP_TAG)
            {
                PrintAsp(fout, indent, node);
            }
            else if (node.Type == Node.JSTE_TAG)
            {
                PrintJste(fout, indent, node);
            }
            else if (node.Type == Node.PHP_TAG)
            {
                PrintPhp(fout, indent, node);
            }
            else if ((node.Tag.Model & ContentModel.EMPTY) != 0 || node.Type == Node.START_END_TAG)
            {
                if ((node.Tag.Model & ContentModel.INLINE) == 0)
                {
                    CondFlushLine(fout, indent);
                }

                if (node.Tag == tt.TagBr && node.Prev != null && node.Prev.Tag != tt.TagBr && _options.BreakBeforeBr)
                {
                    FlushLine(fout, indent);
                }

                if (_options.MakeClean && node.Tag == tt.TagWbr)
                {
                    PrintString(" ");
                }
                else
                {
                    PrintTag(lexer, fout, mode, indent, node);
                }

                if (node.Tag == tt.TagParam || node.Tag == tt.TagArea)
                {
                    CondFlushLine(fout, indent);
                }
                else if (node.Tag == tt.TagBr || node.Tag == tt.TagHr)
                {
                    FlushLine(fout, indent);
                }
            }
            else
            {
                /* some kind of container element */
                if (node.Tag != null && node.Tag.Parser == ParserImpl.ParsePre)
                {
                    CondFlushLine(fout, indent);

                    indent = 0;
                    CondFlushLine(fout, indent);
                    PrintTag(lexer, fout, mode, indent, node);
                    FlushLine(fout, indent);

                    for (content = node.Content; content != null; content = content.Next)
                    {
                        PrintTree(fout, (mode | PREFORMATTED | NOWRAP), indent, lexer, content);
                    }

                    CondFlushLine(fout, indent);
                    PrintEndTag(node);
                    FlushLine(fout, indent);

                    if (_options.IndentContent == false && node.Next != null)
                    {
                        FlushLine(fout, indent);
                    }
                }
                else if (node.Tag == tt.TagStyle || node.Tag == tt.TagScript)
                {
                    CondFlushLine(fout, indent);

                    indent = 0;
                    CondFlushLine(fout, indent);
                    PrintTag(lexer, fout, mode, indent, node);
                    FlushLine(fout, indent);

                    for (content = node.Content; content != null; content = content.Next)
                    {
                        PrintTree(fout, (mode | PREFORMATTED | NOWRAP | CDATA), indent, lexer, content);
                    }

                    CondFlushLine(fout, indent);
                    PrintEndTag(node);
                    FlushLine(fout, indent);

                    if (_options.IndentContent == false && node.Next != null)
                    {
                        FlushLine(fout, indent);
                    }
                }
                else if ((node.Tag.Model & ContentModel.INLINE) != 0)
                {
                    if (_options.MakeClean)
                    {
                        /* discards <font> and </font> tags */
                        if (node.Tag == tt.TagFont)
                        {
                            for (content = node.Content; content != null; content = content.Next)
                            {
                                PrintTree(fout, mode, indent, lexer, content);
                            }
                            return;
                        }

                        /* replace <nobr>...</nobr> by &nbsp; or &#160; etc. */
                        if (node.Tag == tt.TagNobr)
                        {
                            for (content = node.Content; content != null; content = content.Next)
                            {
                                PrintTree(fout, (mode | NOWRAP), indent, lexer, content);
                            }
                            return;
                        }
                    }

                    /* otherwise a normal inline element */

                    PrintTag(lexer, fout, mode, indent, node);

                    /* indent content for SELECT, TEXTAREA, MAP, OBJECT and APPLET */

                    if (ShouldIndent(node))
                    {
                        CondFlushLine(fout, indent);
                        indent += _options.Spaces;

                        for (content = node.Content; content != null; content = content.Next)
                        {
                            PrintTree(fout, mode, indent, lexer, content);
                        }

                        CondFlushLine(fout, indent);
                        indent -= _options.Spaces;
                        CondFlushLine(fout, indent);
                    }
                    else
                    {
                        for (content = node.Content; content != null; content = content.Next)
                        {
                            PrintTree(fout, mode, indent, lexer, content);
                        }
                    }

                    PrintEndTag(node);
                }
                else
                {
                    /* other tags */
                    CondFlushLine(fout, indent);

                    if (_options.SmartIndent && node.Prev != null)
                    {
                        FlushLine(fout, indent);
                    }

                    if (_options.HideEndTags == false ||
                        !(node.Tag != null && ((node.Tag.Model & ContentModel.OMIT_ST) != 0)))
                    {
                        PrintTag(lexer, fout, mode, indent, node);

                        if (ShouldIndent(node))
                        {
                            CondFlushLine(fout, indent);
                        }
                        else if ((node.Tag.Model & ContentModel.HTML) != 0 || node.Tag == tt.TagNoframes ||
                                 ((node.Tag.Model & ContentModel.HEAD) != 0 && node.Tag != tt.TagTitle))
                        {
                            FlushLine(fout, indent);
                        }
                    }

                    if (node.Tag == tt.TagBody && _options.BurstSlides)
                    {
                        PrintSlide(fout, mode, (_options.IndentContent ? indent + _options.Spaces : indent), lexer);
                    }
                    else
                    {
                        Node last = null;

                        for (content = node.Content; content != null; content = content.Next)
                        {
                            /* kludge for naked text before block level tag */
                            if (last != null && !_options.IndentContent && last.Type == Node.TEXT_NODE &&
                                content.Tag != null && (content.Tag.Model & ContentModel.BLOCK) != 0)
                            {
                                FlushLine(fout, indent);
                                FlushLine(fout, indent);
                            }

                            PrintTree(fout, mode, (ShouldIndent(node) ? indent + _options.Spaces : indent), lexer,
                                      content);

                            last = content;
                        }
                    }

                    /* don't flush line for td and th */
                    if (ShouldIndent(node) ||
                        (((node.Tag.Model & ContentModel.HTML) != 0 || node.Tag == tt.TagNoframes ||
                          ((node.Tag.Model & ContentModel.HEAD) != 0 && node.Tag != tt.TagTitle)) &&
                         _options.HideEndTags == false))
                    {
                        CondFlushLine(fout, (_options.IndentContent ? indent + _options.Spaces : indent));

                        if (_options.HideEndTags == false || (node.Tag.Model & ContentModel.OPT) == 0)
                        {
                            PrintEndTag(node);
                            FlushLine(fout, indent);
                        }
                    }
                    else
                    {
                        if (_options.HideEndTags == false || (node.Tag.Model & ContentModel.OPT) == 0)
                        {
                            PrintEndTag(node);
                        }

                        FlushLine(fout, indent);
                    }

                    if (_options.IndentContent == false && node.Next != null && _options.HideEndTags == false &&
                        (node.Tag.Model &
                         (ContentModel.BLOCK | ContentModel.LIST | ContentModel.DEFLIST | ContentModel.TABLE)) != 0)
                    {
                        FlushLine(fout, indent);
                    }
                }
            }
        }
 public virtual IText CreateTextNode(string data)
 {
     byte[] textarray = Lexer.GetBytes(data);
     var node = new Node(Node.TEXT_NODE, textarray, 0, textarray.Length);
     return (IText) node.Adapter;
 }
Exemple #28
0
        public virtual void PrintXmlTree(Out fout, int mode, int indent, Lexer lexer, Node node)
        {
            TagCollection tt = _options.TagTable;

            if (node == null)
            {
                return;
            }

            if (node.Type == Node.TEXT_NODE)
            {
                PrintText(fout, mode, indent, node.Textarray, node.Start, node.End);
            }
            else if (node.Type == Node.COMMENT_TAG)
            {
                CondFlushLine(fout, indent);
                PrintComment(fout, 0, node);
                CondFlushLine(fout, 0);
            }
            else if (node.Type == Node.ROOT_NODE)
            {
                Node content;

                for (content = node.Content; content != null; content = content.Next)
                {
                    PrintXmlTree(fout, mode, indent, lexer, content);
                }
            }
            else if (node.Type == Node.DOC_TYPE_TAG)
            {
                PrintDocType(fout, indent, node);
            }
            else if (node.Type == Node.PROC_INS_TAG)
            {
                PrintPi(fout, indent, node);
            }
            else if (node.Type == Node.SECTION_TAG)
            {
                PrintSection(fout, indent, node);
            }
            else if (node.Type == Node.ASP_TAG)
            {
                PrintAsp(fout, indent, node);
            }
            else if (node.Type == Node.JSTE_TAG)
            {
                PrintJste(fout, indent, node);
            }
            else if (node.Type == Node.PHP_TAG)
            {
                PrintPhp(fout, indent, node);
            }
            else if ((node.Tag.Model & ContentModel.EMPTY) != 0 || node.Type == Node.START_END_TAG)
            {
                CondFlushLine(fout, indent);
                PrintTag(lexer, fout, mode, indent, node);
                FlushLine(fout, indent);

                if (node.Next != null)
                {
                    FlushLine(fout, indent);
                }
            }
            else
            {
                /* some kind of container element */
                Node content;
                bool mixed = false;
                int cindent;

                for (content = node.Content; content != null; content = content.Next)
                {
                    if (content.Type == Node.TEXT_NODE)
                    {
                        mixed = true;
                        break;
                    }
                }

                CondFlushLine(fout, indent);

                if (ParserImpl.XmlPreserveWhiteSpace(node, tt))
                {
                    indent = 0;
                    cindent = 0;
                    mixed = false;
                }
                else if (mixed)
                {
                    cindent = indent;
                }
                else
                {
                    cindent = indent + _options.Spaces;
                }

                PrintTag(lexer, fout, mode, indent, node);

                if (!mixed)
                {
                    FlushLine(fout, indent);
                }

                for (content = node.Content; content != null; content = content.Next)
                {
                    PrintXmlTree(fout, mode, cindent, lexer, content);
                }

                if (!mixed)
                {
                    CondFlushLine(fout, cindent);
                }
                PrintEndTag(node);
                CondFlushLine(fout, indent);

                if (node.Next != null)
                {
                    FlushLine(fout, indent);
                }
            }
        }
 protected internal DomCdataSectionImpl(Node adaptee)
     : base(adaptee)
 {
 }
Exemple #30
0
        /*
        Line can be wrapped immediately after inline start tag provided
        if follows a text node ending in a space, or it parent is an
        inline element that that rule applies to. This behaviour was
        reverse engineered from Netscape 3.0
        */
        private static bool AfterSpace(Node node)
        {
            if (node == null || node.Tag == null || (node.Tag.Model & ContentModel.INLINE) == 0)
            {
                return true;
            }

            Node prev = node.Prev;

            if (prev != null)
            {
                if (prev.Type == Node.TEXT_NODE && prev.End > prev.Start)
                {
                    int c = (prev.Textarray[prev.End - 1]) & 0xFF;

                    if (c == 160 || c == ' ' || c == '\n')
                    {
                        return true;
                    }
                }

                return false;
            }

            return AfterSpace(node.Parent);
        }