/************************************************************************ | |
* | |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER | |
* | |
* Copyright 2008, 2010 Oracle and/or its affiliates. All rights reserved. | |
* | |
* Use is subject to license terms. | |
* | |
* 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. You can also | |
* obtain a copy of the License at http://odftoolkit.org/docs/license.txt | |
* | |
* 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.odftoolkit.odfdom.pkg; | |
import java.io.ByteArrayOutputStream; | |
import java.io.File; | |
import java.io.IOException; | |
import java.io.InputStream; | |
import java.util.logging.Level; | |
import java.util.logging.Logger; | |
import javax.xml.parsers.ParserConfigurationException; | |
import javax.xml.transform.Result; | |
import javax.xml.transform.Source; | |
import javax.xml.transform.Templates; | |
import javax.xml.transform.Transformer; | |
import javax.xml.transform.TransformerConfigurationException; | |
import javax.xml.transform.TransformerException; | |
import javax.xml.transform.TransformerFactory; | |
import javax.xml.transform.dom.DOMSource; | |
import javax.xml.transform.stream.StreamResult; | |
import javax.xml.transform.stream.StreamSource; | |
import org.odftoolkit.odfdom.pkg.rdfa.Util; | |
import org.w3c.dom.Document; | |
import org.w3c.dom.DocumentType; | |
import org.xml.sax.ContentHandler; | |
import org.xml.sax.ErrorHandler; | |
import org.xml.sax.InputSource; | |
import org.xml.sax.SAXException; | |
import org.xml.sax.XMLReader; | |
class OdfXMLHelper { | |
/** | |
* create an XMLReader | |
* with a Resolver set to parse content in a ODF Package | |
* | |
* @param pkg the ODF Package | |
* @return a SAX XMLReader | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public XMLReader newXMLReader(OdfPackage pkg) | |
throws SAXException, ParserConfigurationException { | |
XMLReader xmlReader = pkg.getXMLReader(); | |
xmlReader.setEntityResolver(pkg.getEntityResolver()); | |
return xmlReader; | |
} | |
/** | |
* use SAX parser to parse content of package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param contentHandler a SAX Content handler to receive SAX Events | |
* @param errorHandler a SAX Error handler to be called on errors during parsing | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
*/ | |
public void parse(OdfPackage pkg, String path, ContentHandler contentHandler, ErrorHandler errorHandler) | |
throws SAXException, ParserConfigurationException, IOException, IllegalArgumentException, TransformerConfigurationException, TransformerException { | |
InputStream is = null; | |
try { | |
is = pkg.getInputStream(path); | |
XMLReader reader = newXMLReader(pkg); | |
String uri = pkg.getBaseURI() + path; | |
if (contentHandler != null) { | |
reader.setContentHandler(contentHandler); | |
} | |
if (errorHandler != null) { | |
reader.setErrorHandler(errorHandler); | |
} | |
InputSource ins = new InputSource(is); | |
ins.setSystemId(uri); | |
reader.parse(ins); | |
} catch (Exception ex) { | |
Logger.getLogger(OdfXMLHelper.class.getName()).log(Level.SEVERE, null, ex); | |
} finally { | |
try { | |
is.close(); | |
} catch (IOException ex) { | |
Logger.getLogger(OdfXMLHelper.class.getName()).log(Level.SEVERE, null, ex); | |
} | |
} | |
} | |
/** | |
* Do XSL-Transformation on content contained in package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param templatePath a path to a file in the filesystem containing an XSL Template | |
* @param outPath a path in the filesystem for the output of the XSL Transformation | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, String templatePath, String outPath) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, ParserConfigurationException { | |
transform(pkg, path, new File(templatePath), new File(outPath)); | |
} | |
/** | |
* Do XSL-Transformation on content contained in package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param templateSource TraX Source of an XSL Transformation Template | |
* @param outPath path to an output file for the XSL Transformation | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, Source templateSource, String outPath) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, ParserConfigurationException { | |
transform(pkg, path, templateSource, new File(outPath)); | |
} | |
/** | |
* Do XSL-Transformation on content contained in package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param templateSource TraX Source of an XSL Transformation | |
* @param out an output File | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, Source templateSource, File out) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, ParserConfigurationException { | |
transform(pkg, path, templateSource, new StreamResult(out)); | |
} | |
/** | |
* Do XSL-Transformation on content contained in package | |
* insert result back to package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param templatePath path inside the filesystem to an XSL template file | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, String templatePath) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, ParserConfigurationException { | |
transform(pkg, path, new File(templatePath)); | |
} | |
/** | |
* Do XSL-Transformation on content contained in package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param template File containing an XSLT Template | |
* @param out File for the XSLT ouput | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, File template, File out) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, ParserConfigurationException { | |
TransformerFactory transformerfactory = TransformerFactory.newInstance(); | |
Templates templates = transformerfactory.newTemplates(new StreamSource(template)); | |
transform(pkg, path, templates, new StreamResult(out)); | |
} | |
/** | |
* Do XSL-Transformation on content contained in package | |
* insert result back to package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param template a File containing an XSLT Template | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, File template) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, ParserConfigurationException { | |
TransformerFactory transformerfactory = TransformerFactory.newInstance(); | |
Templates templates = transformerfactory.newTemplates(new StreamSource(template)); | |
transform(pkg, path, templates); | |
} | |
/** | |
* Do XSL-Transformation on content contained in package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param templateSource TraX Source of an XSLT Template | |
* @param result TraX Result of XSL-Tranformation | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, Source templateSource, Result result) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, | |
ParserConfigurationException { | |
TransformerFactory transformerfactory = TransformerFactory.newInstance(); | |
transformerfactory.setURIResolver(pkg.getURIResolver()); | |
Templates templates = transformerfactory.newTemplates(templateSource); | |
transform(pkg, path, templates, result); | |
} | |
/** | |
* Does an XSL-Transformation on content contained in package.<br/><br/> | |
* | |
* There are three default parameters provided to the transformation: | |
* There are three default parameters provided to the transformation: | |
* <ol> | |
* <li><b>sourceURL:</b> the URL of the source directory </li> | |
* <li><b>sourceBaseURL:</b> baseURL of the source file (the package). | |
* This URL necessary to access any content within the package from the XSLT scripts. | |
* The relative package path will concatenated after the 'sourceBaseURL'.</li> | |
* <li><b>targetURL:</b> the URL of the target directory</li> | |
* <li><b>targetBaseURL:</b>the baseURL of the target file</li> | |
* </ol> | |
* | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param templates TraX XSLT Template | |
* @param result TraX XSLT Result | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, Templates templates, Result result) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, | |
ParserConfigurationException { | |
try { | |
Source source = null; | |
String uri = pkg.getBaseURI() + path; | |
Document doc = pkg.getDom(path); | |
source = new DOMSource(doc); | |
Transformer transformer = templates.newTransformer(); | |
transformer.setURIResolver(pkg.getURIResolver()); | |
transformer.setParameter("sourceURL", uri); | |
// switch to this, for odf2rdf.xsl grddl transformation | |
transformer.setParameter("sourceBaseURL", Util.getRDFBaseUri(pkg.getBaseURI(), path)); | |
uri = result.getSystemId(); | |
if (uri != null) { | |
transformer.setParameter("targetURL", uri); | |
int i = uri.lastIndexOf('/'); | |
if (i > 0) { | |
uri = uri.substring(0, i + 1); | |
transformer.setParameter("targetBaseURL", uri); | |
} | |
} | |
DocumentType doctype = doc.getDoctype(); | |
if (doctype != null) { | |
if (doctype.getPublicId() != null) { | |
transformer.setParameter("publicType", doctype.getPublicId()); | |
} | |
if (doctype.getSystemId() != null) { | |
transformer.setParameter("systemType", doctype.getSystemId()); | |
} | |
} | |
transformer.transform(source, result); | |
} catch (Exception ex) { | |
Logger.getLogger(OdfXMLHelper.class.getName()).log(Level.SEVERE, ex.getMessage(), ex); | |
} | |
} | |
/** | |
* Do XSL-Transformation on content contained in package | |
* and insert result back to package | |
* @param pkg a OdfPackage | |
* @param path a path inside the OdfPackage, eg. to a contained content.xml stream | |
* @param templates Trax XSLT Template | |
* @throws TransformerConfigurationException | |
* @throws TransformerException | |
* @throws IOException | |
* @throws IllegalArgumentException | |
* @throws SAXException | |
* @throws ParserConfigurationException | |
*/ | |
public void transform(OdfPackage pkg, String path, Templates templates) | |
throws TransformerConfigurationException, TransformerException, | |
IOException, IllegalArgumentException, SAXException, ParserConfigurationException { | |
Result result = null; | |
ByteArrayOutputStream baos = null; | |
// if (pkg.isDomCached(path)) { | |
// result = new DOMResult(); | |
// } else { | |
baos = new ByteArrayOutputStream(); | |
result = new StreamResult(baos); | |
// } | |
transform(pkg, path, templates, result); | |
// if (pkg.isDomCached(path)) { | |
// try { | |
// pkg.insert((Document) ((DOMResult) result).getNode(), path, null); | |
// } catch (Exception ex) { | |
// Logger.getLogger(OdfXMLHelper.class.getName()).log(Level.SEVERE, null, ex); | |
// } | |
// } else { | |
try { | |
byte[] data = baos.toByteArray(); | |
pkg.insert(data, path, "text/xml"); | |
} catch (Exception ex) { | |
Logger.getLogger(OdfXMLHelper.class.getName()).log(Level.SEVERE, null, ex); | |
} | |
// } | |
} | |
} | |