| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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.openoffice.xmerge.converter.xml.sxw.pocketword; |
| |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.NamedNodeMap; |
| |
| import org.openoffice.xmerge.ConvertData; |
| import org.openoffice.xmerge.ConvertException; |
| import org.openoffice.xmerge.Document; |
| import org.openoffice.xmerge.DocumentSerializer; |
| |
| import org.openoffice.xmerge.converter.xml.OfficeConstants; |
| import org.openoffice.xmerge.converter.xml.sxw.SxwDocument; |
| |
| import org.openoffice.xmerge.converter.xml.ParaStyle; |
| import org.openoffice.xmerge.converter.xml.TextStyle; |
| import org.openoffice.xmerge.converter.xml.StyleCatalog; |
| |
| import java.io.IOException; |
| |
| |
| /** |
| * <p>Pocket Word implementation of <code>DocumentDeserializer</code> |
| * for use by {@link |
| * org.openoffice.xmerge.converter.xml.sxw.pocketword.PluginFactoryImpl |
| * PluginFactoryImpl}.</p> |
| * |
| * <p>This converts an OpenOffice.org XML Writer files to a Pocket Word file<.</p> |
| * |
| * @author Mark Murnane |
| * @version 1.1 |
| */ |
| public final class DocumentSerializerImpl |
| implements DocumentSerializer, OfficeConstants { |
| |
| private PocketWordDocument pswDoc; |
| private SxwDocument sxwDoc; |
| |
| private StyleCatalog styleCat = null; |
| |
| private boolean inList = false; |
| |
| |
| /** |
| * <p>Initialises a new <code>DocumentSerializerImpl</code> using the.<br> |
| * supplied <code>Document</code></p> |
| * |
| * <p>The supplied document should be an {@link |
| * org.openoffice.xmerge.converter.xml.sxw.SxwDocument SxwDocument} |
| * object.</p> |
| * |
| * @param document The <code>Document</code> to convert. |
| */ |
| public DocumentSerializerImpl(Document doc) { |
| sxwDoc = (SxwDocument)doc; |
| pswDoc = new PocketWordDocument(sxwDoc.getName()); |
| } |
| |
| |
| /** |
| * <p>Convert the data passed into the <code>DocumentSerializerImpl</code> |
| * constructor into Pocket Word format.</p> |
| * |
| * <p>This method may or may not be thread-safe. It is expected |
| * that the user code does not call this method in more than one |
| * thread. And for most cases, this method is only done once.</p> |
| * |
| * @return <code>ConvertData</code> object to pass back the |
| * converted data. |
| * |
| * @throws ConvertException If any conversion error occurs. |
| * @throws IOException If any I/O error occurs. |
| */ |
| public ConvertData serialize() throws IOException, ConvertException { |
| ConvertData cd = new ConvertData(); |
| |
| org.w3c.dom.Document doc = sxwDoc.getContentDOM(); |
| |
| // Load any style info before traversing the document content tree |
| loadStyles(); |
| |
| NodeList list = doc.getElementsByTagName(TAG_OFFICE_BODY); |
| |
| int len = list.getLength(); |
| if (len > 0) { |
| Node node = list.item(0); |
| traverseBody(node); |
| } |
| |
| cd.addDocument(pswDoc); |
| |
| return cd; |
| } |
| |
| |
| /* |
| * Handles the loading of defined styles from the style.xml file as well |
| * as automatic styles from the content.xml file. |
| * |
| * Any change to a defined style, such as a short bold section, falls into |
| * the latter category. |
| */ |
| private void loadStyles() { |
| org.w3c.dom.Document contentDom = sxwDoc.getContentDOM(); |
| org.w3c.dom.Document styleDom = sxwDoc.getStyleDOM(); |
| |
| styleCat = new StyleCatalog(25); |
| |
| NodeList nl = null; |
| String families[] = new String[] { PocketWordConstants.TEXT_STYLE_FAMILY, |
| PocketWordConstants.PARAGRAPH_STYLE_FAMILY, |
| PocketWordConstants.PARAGRAPH_STYLE_FAMILY }; |
| Class classes[] = new Class[] { TextStyle.class, |
| ParaStyle.class, |
| TextStyle.class }; |
| |
| String[] styleTypes = new String[] { TAG_OFFICE_STYLES, |
| TAG_OFFICE_AUTOMATIC_STYLES, |
| TAG_OFFICE_MASTER_STYLES }; |
| |
| /* |
| * Documents converted from PSW -> SXW will not have a style.xml when |
| * being converted back to PSW. This would occur if a document was |
| * not modified within Writer between conversions. |
| * |
| * Any Writer modifications and saves create the style.xml and other |
| * portions of a complete Writer SXW file. |
| */ |
| if (styleDom != null) { |
| // Process the Style XML tree |
| for (int i = 0; i < styleTypes.length; i++ ) { |
| nl = styleDom.getElementsByTagName(styleTypes[i]); |
| if (nl.getLength() != 0) { |
| styleCat.add(nl.item(0), families, classes, null, false); |
| } |
| } |
| } |
| |
| /* |
| * Process the content XML for any other style info. |
| * Should only be automatic types here. |
| */ |
| for (int i = 0; i < styleTypes.length; i++ ) { |
| nl = contentDom.getElementsByTagName(styleTypes[i]); |
| if (nl.getLength() != 0) { |
| styleCat.add(nl.item(0), families, classes, null, false); |
| } |
| } |
| } |
| |
| |
| /* |
| * Process the office:body tag. |
| */ |
| private void traverseBody(Node node) throws IOException, ConvertException { |
| |
| if (node.hasChildNodes()) { |
| NodeList nList = node.getChildNodes(); |
| int len = nList.getLength(); |
| |
| for (int i = 0; i < len; i++) { |
| Node child = nList.item(i); |
| |
| if (child.getNodeType() == Node.ELEMENT_NODE) { |
| String nodeName = child.getNodeName(); |
| |
| if (nodeName.equals(TAG_PARAGRAPH) |
| || nodeName.equals(TAG_HEADING)) { |
| traverseParagraph(child); |
| } |
| |
| if (nodeName.equals(TAG_UNORDERED_LIST) || |
| nodeName.equals(TAG_ORDERED_LIST)) { |
| traverseList(child); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| /* |
| * Process a text:p tag |
| */ |
| private void traverseParagraph(Node node) throws IOException, ConvertException { |
| String styleName = getAttribute(node, ATTRIBUTE_TEXT_STYLE_NAME); |
| |
| ParaStyle pstyle = (ParaStyle)styleCat.lookup(styleName, |
| PocketWordConstants.PARAGRAPH_STYLE_FAMILY, null, |
| ParaStyle.class); |
| if (pstyle != null) { |
| pstyle = (ParaStyle)pstyle.getResolved(); |
| } |
| |
| TextStyle tstyle = (TextStyle)styleCat.lookup(styleName, |
| PocketWordConstants.PARAGRAPH_STYLE_FAMILY, null, |
| TextStyle.class); |
| if (pstyle != null) { |
| tstyle = (TextStyle)tstyle.getResolved(); |
| } |
| |
| try { |
| pswDoc.addParagraph(pstyle, inList); |
| } |
| catch (Exception e) { |
| throw new ConvertException( |
| "Error adding paragraph to PocketWordDocument.\n" |
| + e.toString()); |
| } |
| |
| traverseParagraphContents(node, tstyle); |
| } |
| |
| |
| /* |
| * Process the contents of a paragraph. This method handles situations |
| * where the paragraph contains multiple children, each representing a |
| * differently formatted piece of text. |
| */ |
| private void traverseParagraphContents (Node node, TextStyle defTextStyle) |
| throws IOException, ConvertException { |
| // First up, get the style of this little bit |
| String styleName = getAttribute(node, ATTRIBUTE_TEXT_STYLE_NAME); |
| TextStyle tStyle = (TextStyle)styleCat.lookup(styleName, |
| PocketWordConstants.TEXT_STYLE_FAMILY, null, |
| TextStyle.class); |
| |
| if (tStyle == null) { |
| tStyle = defTextStyle; |
| } |
| |
| if (node.hasChildNodes()) { |
| NodeList nList = node.getChildNodes(); |
| int len = nList.getLength(); |
| |
| for (int i = 0; i < len; i++) { |
| |
| Node child = nList.item(i); |
| short nodeType = child.getNodeType(); |
| |
| switch (nodeType) { |
| case Node.TEXT_NODE: |
| String s = child.getNodeValue(); |
| if (s.length() > 0) { |
| try { |
| pswDoc.addParagraphData(s, tStyle); |
| } |
| catch (Exception e) { |
| throw new ConvertException( |
| "Error adding data to paragraph in " + |
| "PocketWordDocument.\n" + e.toString()); |
| |
| } |
| } |
| break; |
| |
| case Node.ELEMENT_NODE: |
| if (child.getNodeName().equals(TAG_SPACE)) { |
| StringBuffer sb = new StringBuffer(""); |
| int count = 1; |
| |
| NamedNodeMap map = child.getAttributes(); |
| |
| if (map.getLength() > 0) { |
| Node attr = map.getNamedItem(ATTRIBUTE_SPACE_COUNT); |
| count = Integer.parseInt(attr.getNodeValue().trim()); |
| } |
| |
| for ( ; count > 0; count--) { |
| sb.append(" "); |
| } |
| |
| /* |
| * May want to look at style info for spaces. Could |
| * be important when calculating font metrics. |
| */ |
| try { |
| pswDoc.addParagraphData(sb.toString(), tStyle); |
| } |
| catch (Exception e) { |
| throw new ConvertException( |
| "Error adding data to paragraph in " + |
| "PocketWordDocument.\n" + e.toString()); |
| |
| } |
| } |
| else if (child.getNodeName().equals(TAG_TAB_STOP)) { |
| try { |
| pswDoc.addParagraphData("\t", tStyle); |
| } |
| catch (Exception e) { |
| throw new ConvertException( |
| "Error adding data to paragraph in " + |
| "PocketWordDocument.\n" + e.toString()); |
| |
| } |
| } |
| else if (child.getNodeName().equals(TAG_LINE_BREAK)) { |
| /* |
| * Pocket Word does not support soft line breaks. |
| * They are just new paragraphs. |
| */ |
| } |
| else if (child.getNodeName().equals(TAG_SPAN)) { |
| /* |
| * This is where the interesting ones, i.e. format |
| * changes occur. |
| */ |
| traverseParagraphContents (child, defTextStyle); |
| } |
| else if (child.getNodeName().equals(TAG_HYPERLINK)) { |
| traverseParagraphContents (child, defTextStyle); |
| } |
| else { |
| // Should maybe have a default in here. |
| } |
| break; |
| default: |
| // Do nothing |
| } |
| } |
| } |
| else { |
| /* |
| * If the node has no children, then it is a blank paragraph, but |
| * they still require an entry in the Paragraph class to make sense. |
| */ |
| pswDoc.addParagraphData("", tStyle); |
| } |
| } |
| |
| |
| /* |
| * Process a text:ordered-list or text:unordered-list tag. Pocket Word has |
| * no concept of a list so there is no need to differentiate between the |
| * two. |
| * |
| * Each item on the list contains a text:p node. |
| */ |
| private void traverseList (Node node) throws IOException, ConvertException { |
| inList = true; |
| |
| if (node.hasChildNodes()) { |
| NodeList nList = node.getChildNodes(); |
| int len = nList.getLength(); |
| |
| for (int i = 0; i < len; i++) { |
| Node child = nList.item(i); |
| |
| if (child.getNodeType() == Node.ELEMENT_NODE) { |
| String nodeName = child.getNodeName(); |
| |
| if (nodeName.equals(TAG_LIST_ITEM)) { |
| traverseListItem(child); |
| } |
| } |
| } |
| } |
| |
| inList = false; |
| } |
| |
| |
| /* |
| * Process a text:list-item node. They usually contain have a single |
| * text:p child but can also have sections or other lists. |
| * |
| * For this case, only paragraphs are supported. |
| */ |
| private void traverseListItem (Node node) throws IOException, ConvertException { |
| if (node.hasChildNodes()) { |
| NodeList nList = node.getChildNodes(); |
| int len = nList.getLength(); |
| |
| for (int i = 0; i < len; i++) { |
| Node child = nList.item(i); |
| |
| if (child.getNodeType() == Node.ELEMENT_NODE) { |
| String nodeName = child.getNodeName(); |
| |
| if (nodeName.equals(TAG_PARAGRAPH)) { |
| traverseParagraph(child); |
| } |
| } |
| } |
| } |
| |
| } |
| |
| |
| /* |
| * Utility method to retrieve a Node attribute. |
| */ |
| private String getAttribute (Node node, String attribute) { |
| NamedNodeMap attrNodes = node.getAttributes(); |
| |
| if (attrNodes != null) { |
| Node attr = attrNodes.getNamedItem(attribute); |
| if (attr != null) { |
| return attr.getNodeValue(); |
| } |
| } |
| |
| return null; |
| } |
| } |
