InkXMLParser.java

package edu.stanford.hci.r3.pen.ink;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.ArrayList;

import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;

import edu.stanford.hci.r3.pattern.coordinates.PageAddress;
import edu.stanford.hci.r3.pen.PenSample;
import edu.stanford.hci.r3.util.xml.TagType;

public class InkXMLParser {

        public enum Attributes {
                ADDRESS, BEGIN, END, F, T, X, Y
        }

        public enum Nodes {
                INK, P, STROKE
        }

        private Ink ink;

        private String recentXMLText = "";

        private ArrayList<PenSample> currentStroke;

        private PenSample currentSample;

        private long t;

        private int f;

        private double y;

        private double x;

        private long endTS;

        private long beginTS;

        public InkXMLParser(Ink theInk) {
                ink = theInk;
        }

        public void parse(File xmlFileSource) {
                // Create an input factory
                final XMLInputFactory xmlif = XMLInputFactory.newInstance();
                // Create an XML stream reader
                XMLStreamReader xmlr;
                try {
                        xmlr = xmlif.createXMLStreamReader(new FileReader(xmlFileSource));
                        // Loop over XML input stream and process events
                        while (xmlr.hasNext()) {
                                processEvent(xmlr);
                                xmlr.next();
                        }
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (XMLStreamException e) {
                        e.printStackTrace();
                }

        }

        private void processAttribute(XMLStreamReader xmlr, int index) {
                // String prefix = xmlr.getAttributePrefix(index);
                // String namespace = xmlr.getAttributeNamespace(index);
                final String localName = xmlr.getAttributeName(index).toString();
                // DebugUtils.println(localName);

                try {
                        final Attributes type = Attributes.valueOf(localName.toUpperCase());
                        final String value = xmlr.getAttributeValue(index);
                        switch (type) {
                        case ADDRESS:
                                ink.setSourcePageAddress(new PageAddress(value));
                                break;
                        case BEGIN:
                                beginTS = Long.parseLong(value);
                                break;
                        case END:
                                endTS = Long.parseLong(value);
                                break;
                        case X:
                                x = Double.parseDouble(value);
                                break;
                        case Y:
                                y = Double.parseDouble(value);
                                break;
                        case F:
                                f = Integer.parseInt(value);
                                break;
                        case T:
                                t = Long.parseLong(value);
                                break;
                        }
                } catch (IllegalArgumentException iae) {
                        // System.out.println("Not Handling Attribute: " + localName);
                }
        }

        private void processAttributes(XMLStreamReader xmlr) {
                for (int i = 0; i < xmlr.getAttributeCount(); i++) {
                        processAttribute(xmlr, i);
                }
        }

        private void processEvent(XMLStreamReader xmlr) {
                int start = 0;
                int length = 0;
                String text = "";

                switch (xmlr.getEventType()) {
                case XMLStreamConstants.START_ELEMENT:
                        recentXMLText = "";
                        processTag(xmlr, TagType.BEGIN_TAG);
                        processAttributes(xmlr);
                        break;
                case XMLStreamConstants.END_ELEMENT:
                        processTag(xmlr, TagType.END_TAG);
                        recentXMLText = "";
                        break;
                case XMLStreamConstants.CHARACTERS:
                        start = xmlr.getTextStart();
                        length = xmlr.getTextLength();
                        text = new String(xmlr.getTextCharacters(), start, length);
                        recentXMLText += text;
                        break;
                case XMLStreamConstants.SPACE:
                        start = xmlr.getTextStart();
                        length = xmlr.getTextLength();
                        text = new String(xmlr.getTextCharacters(), start, length);
                        break;
                }
        }

        private void processTag(XMLStreamReader xmlr, TagType beginOrEnd) {
                if (!xmlr.hasName()) {
                        return;
                }
                final String localName = xmlr.getLocalName();
                // DebugUtils.println(localName);
                final Nodes type = Nodes.valueOf(localName.toUpperCase());
                if (beginOrEnd == TagType.BEGIN_TAG) { // BEGIN
                        switch (type) {
                        case STROKE:
                                // DebugUtils.println("Stroke");
                                currentStroke = new ArrayList<PenSample>();
                                break;
                        case P:
                                break;
                        case INK:
                                break;
                        }
                } else { // END
                        switch (type) {
                        case STROKE:
                                // set the up flag for the last sample we parsed
                                currentSample.setPenUp(true);
                                ink.addStroke(new InkStroke(currentStroke));
                                break;
                        case P:
                                currentSample = new PenSample(x, y, f, t);
                                currentStroke.add(currentSample);
                                break;
                        case INK:
                                break;
                        }
                }
        }

}

---