PenSynch.java

00001 package edu.stanford.hci.r3.pen.batch;
00002 
00003 import java.io.File;
00004 import java.io.FileInputStream;
00005 import java.io.FileNotFoundException;
00006 import java.text.ParseException;
00007 import java.text.SimpleDateFormat;
00008 import java.util.ArrayList;
00009 import java.util.Date;
00010 import java.util.List;
00011 
00012 import javax.xml.namespace.QName;
00013 import javax.xml.stream.XMLEventReader;
00014 import javax.xml.stream.XMLInputFactory;
00015 import javax.xml.stream.XMLStreamException;
00016 import javax.xml.stream.events.Attribute;
00017 import javax.xml.stream.events.EndElement;
00018 import javax.xml.stream.events.StartElement;
00019 import javax.xml.stream.events.XMLEvent;
00020 
00021 import edu.stanford.hci.r3.pen.PenSample;
00022 import edu.stanford.hci.r3.pen.ink.Ink;
00023 import edu.stanford.hci.r3.pen.ink.InkStroke;
00024 import edu.stanford.hci.r3.util.DebugUtils;
00025 
00038 public class PenSynch {
00039 
00040         private static final String PAGE = "page";
00041         private static final String REQUEST_INFORMATION = "requestInformation";
00042         private static final String STROKE = "stroke";
00043 
00044         public static void main(String[] args) {
00045                 File xmlFile = new File("penSynch/data/XML/2007_03_10__01_09_38_SketchedPaperUI.xml");
00046                 new PenSynch(xmlFile);
00047         }
00048 
00052         private List<Ink> importedInk = new ArrayList<Ink>();
00053         private Date localTime;
00054         private int numPages;
00055         private String penID;
00056         private Date universalTime;
00057 
00058         public PenSynch(File penSynchXMLFile) {
00059                 XMLInputFactory xmlInput = XMLInputFactory.newInstance();
00060                 try {
00061                         XMLEventReader eventReader = xmlInput.createXMLEventReader(new FileInputStream(
00062                                         penSynchXMLFile));
00063 
00064                         while (eventReader.hasNext()) {
00065                                 XMLEvent nextEvent = eventReader.nextEvent();
00066                                 // DebugUtils.println(nextEvent.getEventType());
00067                                 switch (nextEvent.getEventType()) {
00068                                 case XMLEvent.START_DOCUMENT:
00069                                         break;
00070                                 case XMLEvent.START_ELEMENT:
00071                                         // DebugUtils.println(nextEvent);
00072                                         StartElement startEvent = (StartElement) nextEvent;
00073                                         String elementName = startEvent.getName().toString();
00074                                         // DebugUtils.println(startEvent.getName());
00075 
00076                                         if (elementName.equals(REQUEST_INFORMATION)) {
00077                                                 processRequestInformation(eventReader);
00078                                         } else if (elementName.equals(PAGE)) {
00079                                                 processPage(eventReader, startEvent);
00080                                         }
00081                                         break;
00082                                 default:
00083                                         break;
00084                                 }
00085 
00086                         }
00087                 } catch (FileNotFoundException e) {
00088                         e.printStackTrace();
00089                 } catch (XMLStreamException e) {
00090                         e.printStackTrace();
00091                 } catch (ParseException e) {
00092                         e.printStackTrace();
00093                 }
00094 
00095                 // printOutDetails();
00096         }
00097         
00098         public List<Ink> getImportedInk() {
00099                 return importedInk;
00100         }
00101 
00102         public Date getLocalTime() {
00103                 return localTime;
00104         }
00105 
00106         public int getNumPages() {
00107                 return numPages;
00108         }
00109 
00110         public String getPenID() {
00111                 return penID;
00112         }
00113 
00114         public Date getUniversalTime() {
00115                 return universalTime;
00116         }
00117 
00118         public void printOutDetails() {
00119                 DebugUtils.println(importedInk.size() + " page synchronized.");
00120                 for (Ink ink : importedInk) {
00121                         DebugUtils.println(ink.getNumStrokes() + " strokes on page "
00122                                         + ink.getSourcePageAddress());
00123                         DebugUtils.println("Ink Boundaries: " + ink.getMinX() + " " + ink.getMinY() + " "
00124                                         + ink.getMaxX() + " " + ink.getMaxY());
00125 
00126                         List<InkStroke> strokes = ink.getStrokes();
00127                         for (InkStroke s : strokes) {
00128                                 DebugUtils.println(s.toString());
00129                                 List<PenSample> samples = s.getSamples();
00130                                 for (PenSample sample : samples) {
00131                                         DebugUtils.println(sample);
00132                                 }
00133                         }
00134 
00135                 }
00136         }
00137 
00138         private void processPage(XMLEventReader eventReader, StartElement page)
00139                         throws XMLStreamException {
00140 
00141                 Ink pageInk = new Ink();
00142                 pageInk.setSourcePageAddress(page.getAttributeByName(new QName("address")).getValue());
00143 
00144                 // DebugUtils.println(pageInk.getSourcePageAddress());
00145 
00146                 while (eventReader.hasNext()) {
00147                         XMLEvent nextEvent = eventReader.nextEvent();
00148                         String elementName;
00149                         switch (nextEvent.getEventType()) {
00150                         case XMLEvent.START_ELEMENT:
00151                                 StartElement startEvent = (StartElement) nextEvent;
00152                                 elementName = startEvent.getName().toString();
00153                                 if (elementName.equals(STROKE)) {
00154                                         InkStroke stroke = new InkStroke();
00155                                         processStroke(eventReader, stroke);
00156                                         pageInk.addStroke(stroke);
00157                                 }
00158 
00159                                 break;
00160                         case XMLEvent.END_ELEMENT:
00161                                 EndElement endEvent = (EndElement) nextEvent;
00162                                 elementName = endEvent.getName().toString();
00163                                 if (elementName.equals(PAGE)) {
00164 
00165                                         // add to the ink we have read in...
00166                                         importedInk.add(pageInk);
00167 
00168                                         // we are done handling the <page/> tag
00169                                         return;
00170                                 }
00171                                 break;
00172                         default:
00173                                 break;
00174                         }
00175                 }
00176 
00177         }
00178 
00184         private void processRequestInformation(XMLEventReader eventReader) throws XMLStreamException,
00185                         ParseException {
00186                 while (eventReader.hasNext()) {
00187                         XMLEvent nextEvent = eventReader.nextEvent();
00188                         String elementName;
00189                         switch (nextEvent.getEventType()) {
00190                         case XMLEvent.START_DOCUMENT:
00191                                 break;
00192                         case XMLEvent.START_ELEMENT:
00193                                 // DebugUtils.println(nextEvent);
00194                                 StartElement startEvent = (StartElement) nextEvent;
00195                                 elementName = startEvent.getName().toString();
00196                                 // DebugUtils.println(startEvent.getName());
00197                                 if (elementName.equals("universalTime")) {
00198                                         Attribute timeAttr = startEvent.getAttributeByName(new QName("time"));
00199                                         String time = timeAttr.getValue();
00200                                         // DebugUtils.println(time);
00201                                         universalTime = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss a").parse(time);
00202                                 } else if (elementName.equals("localTime")) {
00203                                         Attribute timeAttr = startEvent.getAttributeByName(new QName("time"));
00204                                         String time = timeAttr.getValue();
00205                                         // DebugUtils.println(time);
00206                                         localTime = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss a").parse(time);
00207                                 } else if (elementName.equals("penID")) {
00208                                         Attribute idAttr = startEvent.getAttributeByName(new QName("id"));
00209                                         penID = idAttr.getValue();
00210                                         // DebugUtils.println(penID);
00211                                 } else if (elementName.equals("numPages")) {
00212                                         Attribute idAttr = startEvent.getAttributeByName(new QName("num"));
00213                                         numPages = Integer.parseInt(idAttr.getValue());
00214                                         // DebugUtils.println(numPages);
00215                                 }
00216 
00217                                 break;
00218                         case XMLEvent.END_ELEMENT:
00219                                 EndElement endEvent = (EndElement) nextEvent;
00220                                 elementName = endEvent.getName().toString();
00221                                 if (elementName.equals(REQUEST_INFORMATION)) {
00222                                         // we are done handling the <requestInformation/> tag
00223                                         return;
00224                                 }
00225                                 // DebugUtils.println("End: " + nextEvent);
00226                                 break;
00227                         default:
00228                                 break;
00229                         }
00230                 }
00231         }
00232 
00233         private void processStroke(XMLEventReader eventReader, InkStroke stroke)
00234                         throws XMLStreamException {
00235                 while (eventReader.hasNext()) {
00236                         XMLEvent nextEvent = eventReader.nextEvent();
00237                         String elementName;
00238                         switch (nextEvent.getEventType()) {
00239                         case XMLEvent.START_ELEMENT:
00240                                 StartElement startEvent = (StartElement) nextEvent;
00241                                 elementName = startEvent.getName().toString();
00242                                 if (elementName.equals("p")) {
00243                                         String xAttr = startEvent.getAttributeByName(new QName("x")).getValue();
00244                                         String yAttr = startEvent.getAttributeByName(new QName("y")).getValue();
00245                                         String fAttr = startEvent.getAttributeByName(new QName("f")).getValue();
00246                                         String tAttr = startEvent.getAttributeByName(new QName("t")).getValue();
00247                                         stroke.addSample(Double.parseDouble(xAttr), Double.parseDouble(yAttr), Integer
00248                                                         .parseInt(fAttr), Long.parseLong(tAttr));
00249                                 }
00250                                 break;
00251                         case XMLEvent.END_ELEMENT:
00252                                 EndElement endEvent = (EndElement) nextEvent;
00253                                 elementName = endEvent.getName().toString();
00254                                 if (elementName.equals(STROKE)) {
00255                                         // we are done handling the <stroke/> tag
00256                                         return;
00257                                 }
00258                                 break;
00259                         default:
00260                                 break;
00261                         }
00262                 }
00263         }
00264 }

Generated on Sat Apr 14 18:21:37 2007 for R3 Paper Toolkit by  doxygen 1.4.7