Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
  
     Copyright 1999-2003  The Apache Software Foundation 
  
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at
  
         http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 
 */
 
 package org.apache.batik.svggen;
 
 import java.io.Writer;
 
Writes a Node as text output. Package access. This is *not* a full Xml printout implementation. It only covers what is needed by the Graphics2D class. The code for this class draws heavily from the work done for Sun's Project X by David Brownell.

Author(s):
Vincent Hardy
Version:
$Id: XmlWriter.java,v 1.11 2005/02/17 11:47:05 deweese Exp $
 
 class XmlWriter implements SVGConstants {
 
     static private String EOL;
     static private final String TAG_END = " />";
     static private final String TAG_START = "</";
     static private final String SPACE = " ";
 
     static private final char[] SPACES = 
     { ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
       ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ' };
     static private final int    SPACES_LEN = .;
 
     static {
         String  temp;
         try { temp = System.getProperty ("line.separator""\n"); }
         catch (SecurityException e) { temp = "\n"; }
          = temp;
     }
 
     static class IndentWriter extends Writer {
         protected Writer proxied;
         protected int    indentLevel;
         protected int    column;
 
         public IndentWriter(Writer proxied){
             if (proxied == null)
                 throw new SVGGraphics2DRuntimeException(.);
 
             this. = proxied;
         }
 
         public void setIndentLevel(int indentLevel){
             this. = indentLevel;
         }
 
         public int getIndentLevel(){
             return ;
         }
 
         public void printIndent() throws IOException{
             .write();
             int temp = ;
             while(temp > 0){
                 if (temp > ) {
                     .write(, 0, );
                     temp -= ;
                 } else {
                     .write(, 0, temp);
                     break;
                 }
             }
              = ;
         }
 
        public Writer getProxied(){
            return ;
        }
        public int getColumn() { return ; }
        public void write(int cthrows IOException {
            ++;
            .write(c);
        }
        public void write(char cbuf[]) throws IOException {
            +=cbuf.length;
            .write(cbuf);
        }
        public void write(char cbuf[], int offint lenthrows IOException{
            +=len;
            .write(cbufofflen);
        }
        public void write(String strthrows IOException {
            +=str.length();
            .write(str);
        }
        public void write(String strint offint lenthrows IOException {
            +=len;
            .write(strofflen);
        }
        public void flush() throws IOException{
            .flush();
        }
        public void close() throws IOException{
             = -1;
            .close();
        }
    }
    private static void writeXml(Attr attrIndentWriter out
        throws IOException{
        String name = attr.getName();
        out.write (name);
        out.write ("=\"");
        writeChildrenXml(attrout);
        out.write ('"');
    }

    
Writes the attribute's value.
    private static void writeChildrenXml(Attr attrIndentWriter out)
        throws IOException {
        char data[] = attr.getValue().toCharArray();
        if (data == nullreturn;
        int         length = data.length;
        int         start=0, last=0;
        while (last < length) {
            char c = data[last];
            switch (c) {
            case '<':
                out.write (datastartlast - start);
                start = last + 1;
                out.write ("&lt;"); 
                break;
            case '>':  
                out.write (datastartlast - start);
                start = last + 1;
                out.write ("&gt;"); 
                break;
            case '&':  
                out.write (datastartlast - start);
                start = last + 1;
                out.write ("&amp;"); 
                break;
            case '\''
                out.write (datastartlast - start);
                start = last + 1;
                out.write ("&apos;"); 
                break;
            case '"':  
                out.write (datastartlast - start);
                start = last + 1;
                out.write ("&quot;"); 
                break;
            default:
            }
            last++;
        }
        out.write (datastartlast - start);
    }

    
Writes out the comment. Note that spaces may be added to prevent illegal comments: between consecutive dashes ("--") or if the last character of the comment is a dash.
    private static void writeXml(Comment commentIndentWriter out)
        throws IOException {
        char data[] = comment.getData().toCharArray();
        if (data == null) {
            out.write("<!---->");
            return;
        }
        out.write ("<!--");
        boolean     sawDash = false;
        int         length = data.length;
        int         start=0, last=0;
        
        // "--" illegal in comments, insert a space.
        while (last < length) {
            char c = data[last];
            if (c == '-') {
                if (sawDash) {
                    out.write (datastartlast - start);
                    start = last;
                    out.write (' ');
                }
                sawDash = true;
            } else {
                sawDash = false;
            }
            last++;
        }
        out.write (datastartlast - start);
        if (sawDash)
            out.write (' ');
        out.write ("-->");
    }
    private static void writeXml(Text textIndentWriter out
        throws IOException {
        writeXml(textoutfalse);
    }
    private static void writeXml(Text textIndentWriter outboolean trimWS)
        throws IOException {
        char data[] = text.getData().toCharArray();
        // XXX saw this once -- being paranoid
        if (data == null)
            { ..println ("Null text data??"); return; }
        int length = data.length;
        int start = 0, last = 0;
        if (trimWS) {
            while (last < length) {
                char c = data[last];
                switch (c) {
                case ' 'case '\t'case '\n'case '\r'last++; continue;
                defaultbreak;
                }
                break;
            }
            start = last;
        }
         
        while (last < length) {
            char c = data [last];
            // escape markup delimiters only ... and do bulk
            // writes wherever possible, for best performance
            //
            // note that character data can't have the CDATA
            // termination "]]>"; escaping ">" suffices, and
            // doing it very generally helps simple parsers
            // that may not be quite correct.
            //
            switch(c) {
            case ' 'case '\t'case '\n'case '\r':
                if (trimWS) {
                    int wsStart = lastlast++;
                    while (last < length) {
                        switch(data[last]) {
                        case ' 'case '\t'case '\n'case '\r'
                            last++; continue;
                        defaultbreak;
                        }
                        break;
                    }
                    if (last == length) {
                        out.write(datastartwsStart-start);
                        return;
                    } else {
                        continue;
                    }
                }
                break;
            case '<':                     // not legal in char data
                out.write (datastartlast - start);
                start = last + 1;
                out.write ("&lt;");
                break;
            case '>':                     // see above
                out.write (datastartlast - start);
                start = last + 1;
                out.write ("&gt;");
                break;
            case '&':                    // not legal in char data
                out.write (datastartlast - start);
                start = last + 1;
                out.write ("&amp;");
                break;
            }
            last++;
        }
        out.write (datastartlast - start);
    }
    private static void writeXml(CDATASection cdataSectionIndentWriter out)
        throws IOException {
        char[] data = cdataSection.getData().toCharArray();
        if (data == null) {
            out.write ("<![CDATA[]]>");
            return;
        }
        out.write ("<![CDATA[");
        int length = data.length;
        int  start = 0, last = 0;
        while (last < length) {
            char c = data [last];
            // embedded "]]>" needs to be split into adjacent
            // CDATA blocks ... can be split at either point
            if (c == ']') {
                if (((last + 2) < data.length) && 
                    (data [last + 1] == ']')   &&
                    (data [last + 2] == '>')) {
                    out.write (datastartlast - start);
                    start = last + 1;
                    out.write ("]]]]><![CDATA[>");
                    continue;
                }
            }
            last++;
        }
        out.write (datastartlast - start);
        out.write ("]]>");
    }
    private static void writeXml(Element elementIndentWriter out)
        throws IOExceptionSVGGraphics2DIOException {
        out.write (, 0, 1);    // "<"
        out.write (element.getTagName());
        NamedNodeMap attributes = element.getAttributes();
        if (attributes != null){
            int nAttr = attributes.getLength();
            for(int i=0; i<nAttri++){
                Attr attr = (Attr)attributes.item(i);
                out.write(' ');
                writeXml(attrout);
            }
        }
        //
        // Write empty nodes as "<EMPTY />" to make sure version 3
        // and 4 web browsers can read empty tag output as HTML.
        // XML allows "<EMPTY/>" too, of course.
        //
        if (!element.hasChildNodes())
            out.write(, 0, 3);   // " />"
        else  {
            out.write(, 2, 1);   // ">"
            writeChildrenXml(elementout);
            out.write (, 0, 2);        // "</"
            out.write (element.getTagName());
            out.write (, 2, 1);  // ">"
        }
    }
    private static void writeChildrenXml(Element elementIndentWriter out)
        throws IOExceptionSVGGraphics2DIOException {
        NodeList children = element.getChildNodes();
        if (children == null)
            return;
        int length = children.getLength();
        int     oldIndent = 0;
        oldIndent = out.getIndentLevel();
        try {
            out.setIndentLevel(oldIndent + 2);
            for(int i = 0; i < lengthi++) {
                if(children.item(i).getNodeType () != .) {
                    out.printIndent ();
                }
                writeXml(children.item(i), out);
            }
        } finally {
            out.setIndentLevel(oldIndent);
            if (length > 0 && children.item(length-1).getNodeType() != .){
                out.printIndent();          // for ETag
            }
        }
    }
    private static void writeDocumentHeader(IndentWriter out)
        throws IOException {
        String  encoding = null;
        if (out.getProxied() instanceof OutputStreamWriter)
            encoding =
                java2std(((OutputStreamWriter)out.getProxied()).getEncoding());
        out.write ("<?xml version=\"1.0\"");
        if (encoding != null) {
            out.write (" encoding=\"");
            out.write (encoding);
            out.write ('\"');
        }
        out.write ("?>");
        out.write ();
        out.write ();
        // Write DOCTYPE declaration here. Skip until specification is released.
        out.write ("<!DOCTYPE svg PUBLIC '");
        out.write ();
        out.write ("' '");
        out.write ();
        out.write ("'");
        out.write (">");
        out.write ();
    }
    private static void writeXml(Document documentIndentWriter out)
        throws IOExceptionSVGGraphics2DIOException {
        writeDocumentHeader(out);
        NodeList childList = document.getChildNodes();
        writeXml(childListout);
    }
    private static void writeXml(NodeList childListIndentWriter out)
        throws IOExceptionSVGGraphics2DIOException {
        int     length = childList.getLength ();
        if (length == 0)
            return;
        for (int i = 0; i < lengthi++) {
            Node child = childList.item(i);
            writeXml(childout);
            out.write ();
        }
    }
    static String java2std(String encodingName) {
        if (encodingName == null)
            return null;
        //
        // ISO-8859-N is a common family of 8 bit encodings;
        // N=1 is the eight bit subset of UNICODE, and there
        // seem to be at least drafts for some N >10.
        //
        if (encodingName.startsWith ("ISO8859_"))       // JDK 1.2
            return "ISO-8859-" + encodingName.substring (8);
        if (encodingName.startsWith ("8859_"))          // JDK 1.1
            return "ISO-8859-" + encodingName.substring (5);
        // XXX seven bit encodings ISO-2022-* ...
        // XXX EBCDIC encodings ...
        if ("ASCII7".equalsIgnoreCase (encodingName)
            || "ASCII".equalsIgnoreCase (encodingName))
            return "US-ASCII";
        //
        // All XML parsers _must_ support UTF-8 and UTF-16.
        // (UTF-16 ~= ISO-10646-UCS-2 plus surrogate pairs)
        //
        if ("UTF8".equalsIgnoreCase (encodingName))
            return "UTF-8";
        if (encodingName.startsWith ("Unicode"))
            return "UTF-16";
        //
        // Some common Japanese character sets.
        //
        if ("SJIS".equalsIgnoreCase (encodingName))
            return "Shift_JIS";
        if ("JIS".equalsIgnoreCase (encodingName))
            return "ISO-2022-JP";
        if ("EUCJIS".equalsIgnoreCase (encodingName))
            return "EUC-JP";
        // else we can't really do anything
        return encodingName;
    }
    public static void writeXml(Node nodeWriter writer)
        throws SVGGraphics2DIOException {
        try {
            IndentWriter out = null;
            if (writer instanceof IndentWriter)
                out = (IndentWriter)writer;
            else
                out = new IndentWriter(writer);
            switch (node.getNodeType()) {
            case .:
                writeXml((Attr)nodeout);
                break;
            case .:
                writeXml((Comment)nodeout);
                break;
            case .:
                writeXml((Text)nodeout);
                break;
            case .:
                writeXml((CDATASection)nodeout);
                break;
            case .:
                writeXml((Document)nodeout);
                break;
            case .:
                writeDocumentHeader(out);
                NodeList childList = node.getChildNodes();
                writeXml(childListout);
                break;
            case .:
                writeXml((Element)nodeout);
                break;
            default:
                throw
                    new SVGGraphics2DRuntimeException(.+
                                                      node.getClass().
                                                      getName());
            }
        } catch (IOException io) {
            throw new SVGGraphics2DIOException(io);
        }
    }
New to GrepCode? Check out our FAQ X