diff --git a/source/java/writer2latex/office/OfficeReader.java b/source/java/writer2latex/office/OfficeReader.java index 08b9467..9e73f8c 100644 --- a/source/java/writer2latex/office/OfficeReader.java +++ b/source/java/writer2latex/office/OfficeReader.java @@ -305,6 +305,7 @@ public class OfficeReader { private OfficeStyleFamily list = new OfficeStyleFamily(ListStyle.class); private OfficeStyleFamily pageLayout = new OfficeStyleFamily(PageLayout.class); private OfficeStyleFamily masterPage = new OfficeStyleFamily(MasterPage.class); + private Map masterPages = new HashMap(); // Document-wide styles private ListStyle outline = new ListStyle(); @@ -500,7 +501,12 @@ public class OfficeReader { public MasterPage getMasterPage(String sName) { return (MasterPage) masterPage.getStyle(sName); } - + public Map getAllMasterPages() { + return (masterPages); + } + public MasterPage getFullMasterPage(String sName) { + return masterPages.get(sName); + } public ListStyle getOutlineStyle() { return outline; } public PropertySet getFootnotesConfiguration() { return footnotes; } @@ -904,6 +910,7 @@ public class OfficeReader { } else if (child.getNodeName().equals(XMLString.STYLE_MASTER_PAGE)) { masterPage.loadStyleFromDOM(child,bAutomatic); + masterPages.put(Misc.getAttribute(child,XMLString.STYLE_NAME), (MasterPage) masterPage.getStyle(Misc.getAttribute(child,XMLString.STYLE_NAME)) ); if (firstMasterPage==null) { firstMasterPage = (MasterPage) masterPage.getStyle(Misc.getAttribute(child,XMLString.STYLE_NAME)); } diff --git a/source/java/writer2latex/office/XMLString.java b/source/java/writer2latex/office/XMLString.java index c0d966c..9bb156b 100644 --- a/source/java/writer2latex/office/XMLString.java +++ b/source/java/writer2latex/office/XMLString.java @@ -311,6 +311,7 @@ public class XMLString { public static final String TEXT_LINE_BREAK="text:line-break"; public static final String TEXT_PAGE_NUMBER="text:page-number"; public static final String TEXT_PAGE_COUNT="text:page-count"; + public static final String TEXT_PAGE_ADJUST="text:page-adjust"; public static final String TEXT_CHAPTER="text:chapter"; public static final String TEXT_SEQUENCE="text:sequence"; public static final String TEXT_SEQUENCE_REF="text:sequence-ref"; diff --git a/source/java/writer2latex/xhtml/Converter.java b/source/java/writer2latex/xhtml/Converter.java index aedd606..bb586da 100644 --- a/source/java/writer2latex/xhtml/Converter.java +++ b/source/java/writer2latex/xhtml/Converter.java @@ -630,7 +630,15 @@ public class Converter extends ConverterBase { public Element getPanelNode() { return htmlDoc.getPanelNode(); } - + public String getTitle(){ + String title = metaData.getTitle(); + if (title==null) { + // use filename as fallback + title = htmlDoc.getFileName(); + } + return title; + + } // Prepare next output file public Element nextOutFile() { htmlDoc = new XhtmlDocument(getOutFileName(++nOutFileIndex,false),nType); diff --git a/source/java/writer2latex/xhtml/GreenstoneTags.java b/source/java/writer2latex/xhtml/GreenstoneTags.java new file mode 100644 index 0000000..8184512 --- /dev/null +++ b/source/java/writer2latex/xhtml/GreenstoneTags.java @@ -0,0 +1,148 @@ +package writer2latex.xhtml; + +import java.util.LinkedList; + +import javax.swing.text.Element; + +import org.w3c.dom.Document; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import writer2latex.office.XMLString; +import writer2latex.util.Misc; + + +//LinkedList stringList = new LinkedList(); +public class GreenstoneTags { + + private static LinkedList headerStack = new LinkedList(); + private static boolean pageSection = false; + + protected static boolean processHeading(Node currentNode, Node hnode, int pageNum) { + + String sLevel = Misc.getAttribute(currentNode, XMLString.TEXT_OUTLINE_LEVEL); + //If this heading contain outline-level + if (sLevel != null && !sLevel.isEmpty()) { + int nLevel = Integer.parseInt(sLevel); + // Close page section if opened + if (pageSection) { + closeSection(hnode); + pageSection = false; + } + + //If stack not empty + //Close all sections with level less than current + if (!headerStack.isEmpty()) { + while (nLevel <= headerStack.peek()){ + closeSection(hnode); + headerStack.poll(); + if (headerStack.isEmpty()){ break;} + + } + } + //System.out.println(sLevel +">" +headerStack.peek() ); + Node nextNode = currentNode.getNextSibling(); + //Useless to open section if we are at end of the document + if (nextNode != null){ + //Open Heading section + String title = getTitle(currentNode); + + openSection(hnode, title); + headerStack.offerFirst(Integer.parseInt(sLevel)); + //System.out.println("Current " + sLevel + " stack " + headerStack.peek() + "SUM" + headerStack.size()); + + if (!(nextNode.getNodeType() == Node.ELEMENT_NODE + && nextNode.getNodeName().equals(XMLString.TEXT_H) + && Misc.getAttribute(nextNode, XMLString.TEXT_OUTLINE_LEVEL) != null + && !Misc.getAttribute(nextNode, XMLString.TEXT_OUTLINE_LEVEL).isEmpty())) { + openSection(hnode, pageNum); + } + } + + } + return false; + } + private static String getTitle(Node currentNode) { + Node content = currentNode.cloneNode(true); + NodeList contentNodes = content.getChildNodes(); + String title = null; + + int i = 0; + while (i < contentNodes.getLength()) { + Node child = contentNodes.item(i); + if (child.getNodeType() == Node.ELEMENT_NODE){ + if (child.getNodeName().equals(XMLString.TEXT_TAB) || + child.getNodeName().equals(XMLString.TEXT_LINE_BREAK) ){ + Document doc = child.getOwnerDocument(); + Node testSpace = doc.createTextNode(" "); + content.insertBefore(testSpace, child); + content.removeChild(child); + } + } + i++; + } + + title = content.getTextContent(); + + return title; + } + static void processPageBreak(Node currentNode, Node hnode, Integer pageNum){ + + + if ( !( currentNode.getNodeType() == Node.ELEMENT_NODE + && currentNode.getNodeName().equals(XMLString.TEXT_H) + && Misc.getAttribute(currentNode, XMLString.TEXT_OUTLINE_LEVEL) != null + && !Misc.getAttribute(currentNode, XMLString.TEXT_OUTLINE_LEVEL).isEmpty() + ) + && !headerStack.isEmpty() + ) { + if (pageSection) { + closeSection(hnode); + pageSection = false; + + } + if (pageNum != null) { + openSection(hnode, pageNum); + + } + } + } + //Method to open main document tag + static void StartDocument(Node hnode, String title){ + openSection(hnode, title); + } + //Method to close open tags at the end of the document + static void endDocument(Node hnode){ + if (pageSection){ + closeSection(hnode); + pageSection = false; + } + closeSection(hnode); + } + private static void openSection(Node hnode, Integer pageNum){ + Document doc = hnode.getOwnerDocument(); + String commentText = "
\n\n" + pageNum + + "\n" + pageNum + "\n"; + Node openSection = doc.createComment(commentText); + //Node openSection = doc.createTextNode(commentText); + // insert open section comment before header node + hnode.appendChild(openSection); + pageSection = true; + } + private static void openSection(Node hnode, String title){ + Document doc = hnode.getOwnerDocument(); + String commentText = "
\n\n" + title + + "\n"; + Node openSection = doc.createComment(commentText); + // insert open section comment before header node + hnode.appendChild(openSection); + } + + private static void closeSection(Node hnode){ + Document doc = hnode.getOwnerDocument(); + String commentText = "
"; + Node closeSection = doc.createComment(commentText); + //insert open section comment before header node + hnode.appendChild(closeSection); + } +} diff --git a/source/java/writer2latex/xhtml/PageSplitter.java b/source/java/writer2latex/xhtml/PageSplitter.java new file mode 100644 index 0000000..7eac5aa --- /dev/null +++ b/source/java/writer2latex/xhtml/PageSplitter.java @@ -0,0 +1,607 @@ +package writer2latex.xhtml; + +import javax.print.Doc; + +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import writer2latex.office.OfficeReader; +import writer2latex.office.StyleWithProperties; +import writer2latex.office.XMLString; +import writer2latex.util.Misc; + +public class PageSplitter { + static Node truncatedListItemNodeContent = null; + + protected static Node splitSoftPageBreak(Node onode,OfficeReader ofr){ + //Find par node with soft page break inside and split it + Document document = onode.getOwnerDocument(); + Element softPageBreak = document.createElement(XMLString.TEXT_SOFT_PAGE_BREAK); + NodeList nodes = onode.getChildNodes(); + + int i = 0; + //Loop through the content nodes and split paragraph nodes with soft page break + while (i < nodes.getLength()){ + Node child = nodes.item(i); + + //Necessary check if node is an Element + if ((child.getNodeType() == Node.ELEMENT_NODE) && checkSoftPageBreak(child, false)){ + String nodeName = child.getNodeName(); + //DEBUG + //System.out.println("----------CURRENT NODE IS-------" + nodeName); + //Create Duplicate Node! + Element childFirstPart = (Element) child.cloneNode(false); + StyleWithProperties style = null; + if ((nodeName.equals(XMLString.TEXT_P) || nodeName.equals(XMLString.TEXT_H))) { + //If SPB not the first node + if (handleParagraph(childFirstPart, child)){ + onode.insertBefore(childFirstPart, child); + style = ofr.getTableStyle(Misc.getAttribute(child, XMLString.TEXT_STYLE_NAME)); + } + } else if (nodeName.equals(XMLString.TABLE_TABLE)) { + if (handleTableTable(childFirstPart, child)){ + onode.insertBefore(childFirstPart, child); + style = ofr.getTableStyle(Misc.getAttribute(child, XMLString.TABLE_STYLE_NAME)); + + } + } else if (nodeName.equals(XMLString.TEXT_LIST)) { + if (handleList(childFirstPart, child)){ + onode.insertBefore(childFirstPart, child); + style = ofr.getTableStyle(Misc.getAttribute(child, XMLString.TEXT_LIST_STYLE)); + } + } else if (nodeName.equals(XMLString.TEXT_SECTION)) { + if (handleSection(childFirstPart, child)){ + onode.insertBefore(childFirstPart, child); + style = ofr.getTableStyle(Misc.getAttribute(child, XMLString.TEXT_SECTION)); + } + } else if (nodeName.equals(XMLString.TEXT_TABLE_OF_CONTENT)){ + //HACK + checkSoftPageBreak(childFirstPart, false); + i++; + continue; + } else if (nodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)){ + //HACK + i++; + continue; + } + //TODO: IF fo:break before in original table - don't create SPB + + if (style == null || !"page".equals(style.getProperty(XMLString.FO_BREAK_BEFORE))){ + onode.insertBefore(softPageBreak.cloneNode(false), child); + } + //HACK! + if (truncatedListItemNodeContent != null){ + NodeList itemNodeList= truncatedListItemNodeContent.getChildNodes(); + while (itemNodeList.getLength() > 0){ + onode.insertBefore(itemNodeList.item(0), child); + } + truncatedListItemNodeContent.getParentNode().removeChild(truncatedListItemNodeContent); + truncatedListItemNodeContent = null; + } + if (!child.hasChildNodes()){ + onode.removeChild(child); + } + continue; + } + i++; + } + + return onode; + } + private static boolean handleList(Node listFirstPart, Node list){ + + NodeList listNodes = list.getChildNodes(); + int i = 0; + boolean dataMoved = false; + while (listNodes.getLength() > i) { + Node listChild = listNodes.item(i); + if(listChild.getNodeType() == Node.ELEMENT_NODE){ + String nodeName = listChild.getNodeName(); + if (nodeName.equals(XMLString.TEXT_LIST_HEADER)) { + if(checkSoftPageBreak(listChild, true)){ + //Remove inner SPB + //HACK :( + break; + } + listFirstPart.appendChild(listChild.cloneNode(true)); + //Get next element + i++; + + + } else if (nodeName.equals(XMLString.TEXT_LIST_ITEM)) { + if (checkSoftPageBreak(listChild, false)){ + Node listItemFirstPart = listChild.cloneNode(false); + //remove SPB, move previous nodes to firstPart. + if (handleListItem(listItemFirstPart,listChild)){ + dataMoved = true; + //Add first part of list item to previous list item + listFirstPart.appendChild(listItemFirstPart); + //Get list parent node and move cutted node + //After First Part and SPB but before this list; + //TODO!!!!!!!!!! + truncatedListItemNodeContent = listChild; + listFirstPart.getParentNode(); + //If List item is empty - remove it + if (!listChild.hasChildNodes()){ + list.removeChild(listChild); + } + + + + } + //Add text:continue-numbering="true" + if (dataMoved){ + ((Element) list).setAttribute(XMLString.TEXT_CONTINUE_NUMBERING, "true"); + } + break; + } else { + // Not with SPB yet, move node, set dataMoved=true + listFirstPart.appendChild(listChild); + dataMoved = true; + + } + + } + } + } + return dataMoved; + } + //If SPB before first item - return false, remove SPB + //Otherwise add childNodes before SPB to firstPart, return true + private static boolean handleListItem(Node listItemFirstPart, Node listItem){ + int i = 0; + boolean dataMoved = false; + NodeList listItemNodes = listItem.getChildNodes(); + while(listItemNodes.getLength() > i){ + Node listItemChild = listItemNodes.item(i); + if(listItemChild.getNodeType() == Node.ELEMENT_NODE){ + //Node name + String nodeName = listItemChild.getNodeName(); + if (checkSoftPageBreak(listItemChild, false)){ + Node listItemChildFirstPart = listItemChild.cloneNode(false); + //Break if SPB + if (nodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)) { + //Remove SPB.Return result + listItem.removeChild(listItemChild); + } else if (nodeName.equals(XMLString.TEXT_LIST)) { + if (handleList(listItemChildFirstPart, listItemChild)){ + listItemFirstPart.appendChild(listItemChildFirstPart); + dataMoved=true; + } + + } else if (nodeName.equals(XMLString.TEXT_H) || nodeName.equals(XMLString.TEXT_P)) { + + if (handleParagraph(listItemChildFirstPart, listItemChild)){ + listItemFirstPart.appendChild(listItemChildFirstPart); + dataMoved=true; + } + } + break; + //Move to first part + } else { + + listItemFirstPart.appendChild(listItemChild); + dataMoved = true; + } + } else { + listItemFirstPart.appendChild(listItemChild); + dataMoved = true; + } + //check internal nodes + } + return dataMoved; + } + //Needs finish + private static boolean handleTableTable(Node tableFirstPart, Node table) { + + /* + * // TODO: 0.Test if soft-page-break not at start of table // - in that + * case just remove it and insert before table // 1.Create new table // + * 2.Copy to it table:table-column's and // table:table-header-rows // + * 3.Move nodes before soft-page-break to new table //4. IF in one + * table:row exist more one Algorithm IF SPB at start - just move it + * higher IF SPB between rows - just copy table move row and put SPB + * between tables IF SPB inside row, inside cell - copy table, copy + * empty row, copy each empty cell and in each cell move every node up + * to the first SPB + * + * + */ + NodeList tableChildNodes = table.getChildNodes(); + // Node counter + int i = 0; + boolean dataMoved = false; + // Loop through the TABLE:TABLE child nodes + while (tableChildNodes.getLength() > i) { + Node tableChildNode = tableChildNodes.item(i); + + if (tableChildNode.getNodeType() == Node.ELEMENT_NODE) { + //Node name + String tableChildNodeName = tableChildNode.getNodeName(); + //System.out.println("Table child node " + tableChildNodeName); + if (checkSoftPageBreak(tableChildNode, false)){ + Node tableChildFirstPart = tableChildNode.cloneNode(false); + if (tableChildNodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)) { + // remove inner soft page break node + table.removeChild(tableChildNode); + + } else if (tableChildNodeName.equals(XMLString.TABLE_TABLE_ROW_GROUP)) { + if (handleTableRowGroup(tableChildFirstPart, tableChildNode)){ + dataMoved = true; + tableFirstPart.appendChild(tableChildFirstPart); + } + } else if ( tableChildNodeName.equals(XMLString.TABLE_TABLE_ROWS)) { + if (handleTableRows(tableChildFirstPart, tableChildNode)){ + dataMoved = true; + tableFirstPart.appendChild(tableChildFirstPart); + } + } else if ( tableChildNodeName.equals(XMLString.TABLE_TABLE_ROW)) { + if (handleTableRow(tableChildFirstPart, tableChildNode)){ + dataMoved = true; + tableFirstPart.appendChild(tableChildFirstPart); + } + } else if (tableChildNodeName.equals(XMLString.TABLE_TABLE_COLUMN) + || tableChildNodeName.equals(XMLString.TABLE_TABLE_COLUMN_GROUP) + || tableChildNodeName.equals(XMLString.TABLE_TABLE_HEADER_ROWS) + || tableChildNodeName.equals(XMLString.TABLE_TABLE_HEADER_COLUMNS)) { + //Remove Soft Page Break + checkSoftPageBreak(tableChildNode, true); + } + break; + + } else { + //Before SPB + //Description nodes + if (tableChildNodeName.equals(XMLString.TABLE_TABLE_COLUMN) + || tableChildNodeName.equals(XMLString.TABLE_TABLE_COLUMN_GROUP) + || tableChildNodeName.equals(XMLString.TABLE_TABLE_HEADER_ROWS) + || tableChildNodeName.equals(XMLString.TABLE_TABLE_HEADER_COLUMNS)) { + //Append to clone table + tableFirstPart.appendChild(tableChildNode.cloneNode(true)); + //increment counter + i++; + } else { + //Append to clone table + tableFirstPart.appendChild(tableChildNode); + dataMoved = true; + } + } + } + } + return dataMoved; + } + + private static boolean handleTableRowGroup(Node tableRowGroupFistPart, Node tableRowGroup) { + boolean dataMoved = false; + // Node counter + int i = 0; + NodeList tableRowGroupChildNodes = tableRowGroup.getChildNodes(); + while (tableRowGroupChildNodes.getLength() > i) { + Node tableRowGroupChildNode = tableRowGroupChildNodes.item(0); + if ((tableRowGroupChildNode.getNodeType() == Node.ELEMENT_NODE)) { + + String nodeName = tableRowGroupChildNode.getNodeName(); + + if (checkSoftPageBreak(tableRowGroupChildNode, false)){ + Node tableRowGroupChildFirstPart = tableRowGroupChildNode.cloneNode(false); + if (nodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + tableRowGroup.removeChild(tableRowGroupChildNode); + + } else if (nodeName.equals(XMLString.TABLE_TABLE_HEADER_ROWS)){ + //Nothing IF table-header-rows found - it is description node, + //Not needed to set dataMoved = true, not needed to append First part + + } else if (nodeName.equals(XMLString.TABLE_TABLE_ROW)){ + if (handleTableRow(tableRowGroupChildFirstPart, tableRowGroupChildNode)){ + dataMoved = true; + tableRowGroupFistPart.appendChild(tableRowGroupChildFirstPart); + } + } else if (nodeName.equals(XMLString.TABLE_TABLE_ROW_GROUP)){ + if (handleTableRowGroup(tableRowGroupChildFirstPart, tableRowGroupChildNode)){ + dataMoved = true; + tableRowGroupFistPart.appendChild(tableRowGroupChildFirstPart); + } + } else if (nodeName.equals(XMLString.TABLE_TABLE_ROWS)){ + if (handleTableRows(tableRowGroupChildFirstPart, tableRowGroupChildNode)){ + dataMoved = true; + tableRowGroupFistPart.appendChild(tableRowGroupChildFirstPart); + } + } + break; + } else { + if (nodeName.equals(XMLString.TABLE_TABLE_HEADER_ROWS)){ + tableRowGroupFistPart.appendChild(tableRowGroupChildNode.cloneNode(true)); + //increment counter + i++; + + } else { + tableRowGroupFistPart.appendChild(tableRowGroupChildNode); + dataMoved = true; + } + } + } else { + //Append text nodes + tableRowGroupFistPart.appendChild(tableRowGroupChildNode); + dataMoved = true; + } + + } + return dataMoved; + } + private static boolean handleTableRows(Node tableRowsFistPart, Node tableRows) { + boolean dataMoved = false; + // Node counter + int i = 0; + NodeList tableRowsChildNodes = tableRows.getChildNodes(); + while (tableRowsChildNodes.getLength() > i) { + Node tableRowsChildNode = tableRowsChildNodes.item(0); + if ((tableRowsChildNode.getNodeType() == Node.ELEMENT_NODE)) { + + String nodeName = tableRowsChildNode.getNodeName(); + + if (checkSoftPageBreak(tableRowsChildNode, false)){ + Node tableRowGroupChildFirstPart = tableRowsChildNode.cloneNode(false); + if (nodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + tableRows.removeChild(tableRowsChildNode); + + } else if (nodeName.equals(XMLString.TABLE_TABLE_ROW)){ + if (handleTableRow(tableRowGroupChildFirstPart, tableRowsChildNode)){ + dataMoved = true; + tableRowsFistPart.appendChild(tableRowGroupChildFirstPart); + } + } + break; + } else { + tableRowsFistPart.appendChild(tableRowsChildNode); + dataMoved = true; + } + } else { + System.out.println("ERROR: TEXT NODE FOUND INSIDE tabl:table-rows"); + //Append text nodes + //tableRowsFistPart.appendChild(tableRowsChildNode); + //dataMoved = true; + } + + } + return dataMoved; + } + private static boolean handleTableRow(Node tableRowFistPart, Node tableRow) { + boolean dataMoved = false; + // Node counter + int i = 0; + NodeList tableRowChildNodes = tableRow.getChildNodes(); + while (tableRowChildNodes.getLength() > i) { + Node tableRowChildNode = tableRowChildNodes.item(i); + if ((tableRowChildNode.getNodeType() == Node.ELEMENT_NODE)) { + + String nodeName = tableRowChildNode.getNodeName(); + + if (checkSoftPageBreak(tableRowChildNode, false)){ + Node tableRowGroupChildFirstPart = tableRowChildNode.cloneNode(false); + if (nodeName.equals(XMLString.TABLE_TABLE_CELL)){ + if (handleCell(tableRowGroupChildFirstPart, tableRowChildNode)){ + dataMoved = true; + tableRowFistPart.appendChild(tableRowGroupChildFirstPart); + } + + } else if (nodeName.equals(XMLString.TABLE_COVERED_TABLE_CELL)){ + //Implement handleCoveredCell in future + if (handleCell(tableRowGroupChildFirstPart, tableRowChildNode)){ + dataMoved = true; + tableRowFistPart.appendChild(tableRowGroupChildFirstPart); + } + } + } else { + //System.out.println("HERE " + nodeName); + //Move node without SPB above + tableRowFistPart.appendChild(tableRowChildNode.cloneNode(true)); + Node emptyCell = tableRowChildNode.cloneNode(false); + Document document = tableRow.getOwnerDocument(); + Element textP = document.createElement(XMLString.TEXT_P); + emptyCell.appendChild(textP); + tableRow.insertBefore(emptyCell, tableRowChildNode); + tableRow.removeChild(tableRowChildNode); + + + dataMoved = true; + } + i++; + } else { + System.out.println("ERROR: TEXT NODE FOUND INSIDE tabl:table-row"); + //Append text nodes + //tableRowsFistPart.appendChild(tableRowsChildNode); + //dataMoved = true; + } + + } + return dataMoved; + } + private static boolean handleCell(Node cellFirstPart, Node cellNode) { + boolean dataMoved = false; + // Node counter + int i = 0; + NodeList cellChildNodes = cellNode.getChildNodes(); + while (cellChildNodes.getLength() > i) { + Node cellChildNode = cellChildNodes.item(0); + if ((cellChildNode.getNodeType() == Node.ELEMENT_NODE)) { + String nodeName = cellChildNode.getNodeName(); + if (checkSoftPageBreak(cellChildNode, false)){ + Node cellChildFirstPart = cellChildNode.cloneNode(false); + if (nodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + cellNode.removeChild(cellChildNode); + + } else if (nodeName.equals(XMLString.TEXT_H) || nodeName.equals(XMLString.TEXT_P)) { + + if (handleParagraph(cellChildFirstPart, cellChildNode)){ + cellFirstPart.appendChild(cellChildFirstPart); + dataMoved=true; + } + } + break; + } else { + cellFirstPart.appendChild(cellChildNode); + dataMoved = true; + } + } else { + //Append text nodes + cellFirstPart.appendChild(cellChildNode); + dataMoved = true; + } + + } + return dataMoved; + } + private static boolean handleSection(Node sectionFirstPart, Node sectionNode) { + boolean dataMoved = false; + // Node counter + int i = 0; + NodeList sectionChildNodes = sectionNode.getChildNodes(); + while (sectionChildNodes.getLength() > i) { + Node sectionChildNode = sectionChildNodes.item(0); + if ((sectionChildNode.getNodeType() == Node.ELEMENT_NODE)) { + String nodeName = sectionChildNode.getNodeName(); + if (checkSoftPageBreak(sectionChildNode, false)){ + Node sectionChildFirstPart = sectionChildNode.cloneNode(false); + if (nodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + sectionNode.removeChild(sectionChildNode); + + } else if (nodeName.equals(XMLString.TEXT_H) || nodeName.equals(XMLString.TEXT_P)) { + + if (handleParagraph(sectionChildFirstPart, sectionChildNode)){ + sectionFirstPart.appendChild(sectionChildFirstPart); + dataMoved=true; + } + } + break; + } else { + sectionFirstPart.appendChild(sectionChildNode); + dataMoved = true; + } + } else { + //Append text nodes + sectionFirstPart.appendChild(sectionChildNode); + dataMoved = true; + } + + } + return dataMoved; + } + + + private static boolean handleParagraph(Node paraFirstPart, Node paraNode) { + boolean dataMoved = false; + int i = 0; + NodeList paraChildNodes = paraNode.getChildNodes(); + while (paraChildNodes.getLength() > i) { + Node paraChildNode = paraChildNodes.item(i); + //NOT TEXT NODES + if ((paraChildNode.getNodeType() == Node.ELEMENT_NODE)) { + String nodeName = paraChildNode.getNodeName(); + //System.out.println(nodeName); + //SPB FOUND + if (checkSoftPageBreak(paraChildNode, false)){ + if (nodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + paraNode.removeChild(paraChildNode); + + //Next node in paragraph. If it is text node go further + Node paraNextNode = paraChildNodes.item(i); + Node paraPrevNode = paraFirstPart.getLastChild(); + String nextText = null; + String prevText = null; + if (paraNextNode != null && paraPrevNode != null ){ + + if (paraNextNode.getNodeType() == Node.TEXT_NODE) { + nextText = paraNextNode.getTextContent(); + } else if (paraNextNode.getNodeType() == Node.ELEMENT_NODE) { + Node nextNodeFirstChild = paraNextNode.getFirstChild(); + if (nextNodeFirstChild != null && nextNodeFirstChild.getNodeType() == Node.TEXT_NODE) { + nextText = nextNodeFirstChild.getTextContent(); + } + } + if (paraPrevNode.getNodeType() == Node.TEXT_NODE){ + prevText = paraPrevNode.getTextContent(); + } else if (paraPrevNode.getNodeType() == Node.ELEMENT_NODE) { + Node prevNodeLastChild = paraPrevNode.getLastChild(); + if (prevNodeLastChild != null && prevNodeLastChild.getNodeType() == Node.TEXT_NODE) { + prevText = prevNodeLastChild.getTextContent(); + } + } + //If previous and next texts exists + if (nextText != null && prevText != null) { + //If first character in next text is a letter + //And if last character in previous text is a letter or soft hyphen + if (Character.isLetter(nextText.charAt(0)) + && (Character.isLetter(prevText.charAt(prevText.length() - 1)) + || prevText.charAt(prevText.length() - 1) == 173)) { + paraPrevNode.setTextContent(prevText + "\u2010"); + } + } + } + + /* Check if next node in para is text and first char is a letter + * Check if last node in paraFirstPart is text and last char is a letter + * If both true - add + */ + + + + + + } else { + System.out.println("ERROR: SPB INSIDE Paragraph Element in inner element " + nodeName); + //checkSoftPageBreak(internalNode, true); + //paraFirstPart.appendChild(internalNode); + //dataMoved = true; + } + break; + //ELEMENT WITHOUT SPB + } else if (nodeName.equals(XMLString.TEXT_BOOKMARK_START)){ + paraFirstPart.appendChild(paraChildNode.cloneNode(true)); + i++; + } else { + paraFirstPart.appendChild(paraChildNode); + dataMoved = true; + } + //TEXT NODES + } else { + paraFirstPart.appendChild(paraChildNode); + dataMoved = true; + } + + } + return dataMoved; + } + // Returns true if soft-page-break found. Removes it if removeFound = true + private static boolean checkSoftPageBreak(Node node, boolean removeFound) { + if (node.getNodeType() == Node.ELEMENT_NODE) { + if (node.getNodeName().equals(XMLString.TEXT_SOFT_PAGE_BREAK)) { + if (removeFound) { + Node parent = node.getParentNode(); + parent.removeChild(node); + } + return true; + } + if (node.hasChildNodes()) { + int currentNo = 0; + NodeList childNodes = node.getChildNodes(); + while (currentNo < childNodes.getLength()) { + Node childNode = childNodes.item(currentNo); + if (checkSoftPageBreak(childNode, removeFound)) { + return true; + } + currentNo++; + } + } + } + return false; + } + +} + diff --git a/source/java/writer2latex/xhtml/TextConverter.java b/source/java/writer2latex/xhtml/TextConverter.java index 6a83c34..dd42881 100644 --- a/source/java/writer2latex/xhtml/TextConverter.java +++ b/source/java/writer2latex/xhtml/TextConverter.java @@ -33,7 +33,9 @@ import org.w3c.dom.Element; import writer2latex.util.Misc; import writer2latex.office.FontDeclaration; +import writer2latex.office.MasterPage; import writer2latex.office.OfficeStyle; +import writer2latex.office.PageLayout; import writer2latex.office.XMLString; import writer2latex.office.ListCounter; import writer2latex.office.ListStyle; @@ -94,7 +96,13 @@ public class TextConverter extends ConverterHelper { // Display hidden text? private boolean bDisplayHiddenText = false; - + // Current page number + int pageNum = 1; + //Current master page name + private String currentMasterPage = null; + //Current master page name + private String nextMasterPage = null; + public TextConverter(OfficeReader ofr, XhtmlConfig config, Converter converter) { super(ofr,config,converter); tocCv = new TOCConverter(ofr, config, converter); @@ -132,14 +140,16 @@ public class TextConverter extends ConverterHelper { // Add cover image hnode = getDrawCv().insertCoverImage(hnode); - + //Split pages + onode = (Element) PageSplitter.splitSoftPageBreak(onode,ofr); // Convert content hnode = (Element)traverseBlockText(onode,hnode); // Add footnotes and endnotes footCv.insertFootnotes(hnode,true); + addFooter(hnode); endCv.insertEndnotes(hnode); - + GreenstoneTags.endDocument(hnode); // Generate all indexes bInToc = true; tocCv.generate(); @@ -186,6 +196,8 @@ public class TextConverter extends ConverterHelper { NodeList nList = onode.getChildNodes(); int nLen = nList.getLength(); int i = 0; + //hard Break after marker + boolean breakBeforeNextNode = false; while (i < nLen) { Node child = nList.item(i); @@ -199,6 +211,7 @@ public class TextConverter extends ConverterHelper { } else if (nodeName.equals(XMLString.TEXT_P)) { StyleWithProperties style = ofr.getParStyle(Misc.getAttribute(child,XMLString.TEXT_STYLE_NAME)); + breakBeforeNextNode = processPageBreaks(child, hnode,style, breakBeforeNextNode); hnode = maybeSplit(hnode, style); nCharacterCount+=OfficeReader.getCharacterCount(child); // is there a block element, we should use? @@ -247,6 +260,8 @@ public class TextConverter extends ConverterHelper { StyleWithProperties style = ofr.getParStyle(Misc.getAttribute(child,XMLString.TEXT_STYLE_NAME)); int nOutlineLevel = getOutlineLevel((Element)child); Node rememberNode = hnode; + breakBeforeNextNode = processPageBreaks(child, hnode, style, breakBeforeNextNode); + GreenstoneTags.processHeading(child, hnode, pageNum); hnode = maybeSplit(hnode,style,nOutlineLevel); nCharacterCount+=OfficeReader.getCharacterCount(child); handleHeading((Element)child,(Element)hnode,rememberNode!=hnode); @@ -255,6 +270,7 @@ public class TextConverter extends ConverterHelper { nodeName.equals(XMLString.TEXT_UNORDERED_LIST) || // old nodeName.equals(XMLString.TEXT_ORDERED_LIST)) // old { + breakBeforeNextNode = processPageBreaks(child, hnode,null, breakBeforeNextNode); hnode = maybeSplit(hnode,null); if (listIsOnlyHeadings(child)) { nDontSplitLevel--; @@ -266,7 +282,8 @@ public class TextConverter extends ConverterHelper { } } else if (nodeName.equals(XMLString.TABLE_TABLE)) { - StyleWithProperties style = ofr.getTableStyle(Misc.getAttribute(child,XMLString.TEXT_STYLE_NAME)); + StyleWithProperties style = ofr.getTableStyle(Misc.getAttribute(child, XMLString.TABLE_STYLE_NAME)); + breakBeforeNextNode = processPageBreaks(child, hnode,style, breakBeforeNextNode); hnode = maybeSplit(hnode,style); getTableCv().handleTable(child,hnode); } @@ -306,6 +323,7 @@ public class TextConverter extends ConverterHelper { bibCv.handleIndex((Element)child,(Element)hnode); } else if (nodeName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)) { + breakBeforeNextNode = true; if (nPageBreakSplit==XhtmlConfig.ALL) { bPendingPageBreak = true; } } else if (nodeName.equals(XMLString.OFFICE_ANNOTATION)) { @@ -1239,8 +1257,15 @@ public class TextConverter extends ConverterHelper { } private void handlePageNumber(Node onode, Node hnode) { - // doesn't make any sense... - hnode.appendChild( converter.createTextNode("(Page number)") ); + String adjust = Misc.getAttribute(onode, XMLString.TEXT_PAGE_ADJUST); + //Set current page number + Integer pageNumber = pageNum; + //If there is adjustment apply it + if (adjust != null) { + int pageNumberAdjust = Integer.parseInt(adjust); + pageNumber += pageNumberAdjust; + } + hnode.appendChild(converter.createTextNode(pageNumber.toString())); } private void handlePageCount(Node onode, Node hnode) { @@ -1520,5 +1545,192 @@ public class TextConverter extends ConverterHelper { Misc.getPosInteger(node.getAttribute(XMLString.TEXT_OUTLINE_LEVEL),1): Misc.getPosInteger(node.getAttribute(XMLString.TEXT_LEVEL),1); } + private boolean processPageBreaks(Node currentNode, Node hnode,StyleWithProperties style, boolean breakBeforeNextNode){ + Integer newPageNumber = null; + if (style != null) { + // If style:paragraph-properties extists and contain + // style:page-number + String newPageNumberProperty = style.getParProperty(XMLString.STYLE_PAGE_NUMBER, true); + if (newPageNumberProperty != null) { + // Truncate auto and other string values + newPageNumberProperty = newPageNumberProperty.replaceAll("[^0-9]", ""); + if (!newPageNumberProperty.isEmpty()) { + // Save new page number + newPageNumber = Integer.parseInt(newPageNumberProperty); + } + + } + // Set first master page name + // If Master Page style has been already set + } + if (currentMasterPage == null && style != null) { + // Looks like first page. + if (checkMasterStylePageBreak(style)) { + updateMasterPage(style); + } else { + //Set standard MP + currentMasterPage = "Standard"; + } + if (newPageNumber != null) { + pageNum = newPageNumber; + } else { + fitPageNumberToMasterPageStyle(); + } + + //Start tagging + String sTitle = converter.getTitle(); + GreenstoneTags.StartDocument(hnode, sTitle); + //Print header + addHeader(hnode); + + } else { + //If old master page was defined + + //If new master page definition found + //Or if fo:break-before found + //Or if soft-page-break or fo:break-after appeared before this node + if (checkMasterStylePageBreak(style) || checkHardBreakBefore(style) || breakBeforeNextNode) { + //Insert footnotes + footCv.insertFootnotes(hnode, true); + //Add previous MP footer + addFooter(hnode); + //Update MP + updateMasterPage(style); + //Set new page number if defined or increment if not + if (newPageNumber != null) { + pageNum = newPageNumber; + } else { + pageNum++; + fitPageNumberToMasterPageStyle(); + } + //if + GreenstoneTags.processPageBreak(currentNode, hnode, pageNum); + //Print new header + addHeader(hnode); + //breakBeforeNextNode = false; + return false; + } + + } + if (checkHardBreakAfter(style)) { + + //breakBeforeNextNode = true; + return true; + } + return false; + } + + private void fitPageNumberToMasterPageStyle() { + // TODO: READ master-page style + + MasterPage masterPage = ofr.getFullMasterPage(currentMasterPage); + if (masterPage != null) { + String pageLayoutName = masterPage.getPageLayoutName(); + if (pageLayoutName != null) { + PageLayout pageLayout = ofr.getPageLayout(pageLayoutName); + if (pageLayout != null) { + String pageUsage = pageLayout.getPageUsage(); + if (pageUsage != null) { + int parity = pageNum % 2; + if (parity == 1 && pageUsage.equals("left")){ + pageNum++; + } + if (parity == 0 && pageUsage.equals("right")){ + pageNum++; + } + } else { + } + } else { + } + } else { + } + + } else { + } + } + + private boolean checkMasterStylePageBreak(StyleWithProperties style) { + // Page break was found before + if (style != null) { + + String sMasterPage = style.getMasterPageName(); + if (sMasterPage != null && sMasterPage.length() > 0) { + // System.out.println("GETPAGEBREAK SUCCESS MASTERPAGE STYLE FOUND " + currentMasterPage); + return true; + } + } + + return false; + } + private void updateMasterPage(StyleWithProperties style) { + + if (style != null && checkMasterStylePageBreak(style)) { + String sMasterPage = style.getMasterPageName(); + if (sMasterPage != null && sMasterPage.length() > 0) { + currentMasterPage = sMasterPage; + // Set next master page + MasterPage masterPage = ofr.getFullMasterPage(currentMasterPage); + nextMasterPage = masterPage.getProperty(XMLString.STYLE_NEXT_STYLE_NAME); + } + } else if (nextMasterPage != null){ + currentMasterPage = nextMasterPage; + MasterPage masterPage = ofr.getFullMasterPage(currentMasterPage); + nextMasterPage = masterPage.getProperty(XMLString.STYLE_NEXT_STYLE_NAME); + // System.out.println("Next master page is " + nextMasterPage); + } + + } + + private boolean checkHardBreakBefore(StyleWithProperties style) { + if (style != null && "page".equals(style.getProperty(XMLString.FO_BREAK_BEFORE))) { + return true; + } + return false; + } + + private boolean checkHardBreakAfter(StyleWithProperties style) { + if (style != null && "page".equals(style.getProperty(XMLString.FO_BREAK_AFTER))) { + return true; + } + return false; + } + + private Node addHeader(Node node) { + + MasterPage masterPage = ofr.getFullMasterPage(currentMasterPage); + if (currentMasterPage != null) { + + Node headerNode = masterPage.getHeader(); + if (headerNode != null) { + //Create header element + Element headerElement = converter.createElement("header"); + node.appendChild(headerElement); + traverseBlockText(headerNode, headerElement); + } + } else { + System.out.println("ERROR MP is null"); + } + return node; + } + + private Node addFooter(Node node) { + + MasterPage masterPage = ofr.getFullMasterPage(currentMasterPage); + if (currentMasterPage != null) { + + Node footerNode = masterPage.getFooter(); + if (footerNode != null) { + //Create footer element + Element footerElement = converter.createElement("footer"); + node.appendChild(footerElement); + traverseBlockText(footerNode, footerElement); + } + } else { + System.out.println("ERROR MP is null"); + } + return node; + } + + } diff --git a/source/java/writer2latex/xhtml/XhtmlConfig.java b/source/java/writer2latex/xhtml/XhtmlConfig.java index d95e77b..0dbabf5 100644 --- a/source/java/writer2latex/xhtml/XhtmlConfig.java +++ b/source/java/writer2latex/xhtml/XhtmlConfig.java @@ -40,7 +40,7 @@ import writer2latex.util.Misc; public class XhtmlConfig extends writer2latex.base.ConfigBase { // Implement configuration methods - protected int getOptionCount() { return 59; } + protected int getOptionCount() { return 60; } protected String getDefaultConfigPath() { return "/writer2latex/xhtml/config/"; } // Override setOption: To be backwards compatible, we must accept options @@ -158,6 +158,7 @@ public class XhtmlConfig extends writer2latex.base.ConfigBase { private static final int UPLINK = 56; private static final int DIRECTORY_ICON = 57; private static final int DOCUMENT_ICON = 58; + private static final int CONVERT_HEADER_AND_FOOTER = 59; protected ComplexOption xheading = addComplexOption("heading-map"); protected ComplexOption xpar = addComplexOption("paragraph-map"); @@ -203,7 +204,7 @@ public class XhtmlConfig extends writer2latex.base.ConfigBase { else { nValue = ABSOLUTE; } } }; - options[LIST_FORMATTING] = new IntegerOption("list_formatting","css1") { + options[LIST_FORMATTING] = new IntegerOption("list_formatting","css1_hack") { @Override public void setString(String sValue) { super.setString(sValue); if ("css1_hack".equals(sValue)) { nValue = CSS1_HACK; } @@ -291,6 +292,7 @@ public class XhtmlConfig extends writer2latex.base.ConfigBase { options[UPLINK] = new Option("uplink",""); options[DIRECTORY_ICON] = new Option("directory_icon",""); options[DOCUMENT_ICON] = new Option("document_icon",""); + options[CONVERT_HEADER_AND_FOOTER] = new BooleanOption("convert_header_footer","false"); } protected void readInner(Element elm) { @@ -433,7 +435,8 @@ public class XhtmlConfig extends writer2latex.base.ConfigBase { public String getXhtmlUplink() { return options[UPLINK].getString(); } public String getXhtmlDirectoryIcon() { return options[DIRECTORY_ICON].getString(); } public String getXhtmlDocumentIcon() { return options[DOCUMENT_ICON].getString(); } - + public boolean convertHeaderAndFooter() { return ((BooleanOption) options[CONVERT_HEADER_AND_FOOTER]).getValue(); } + public XhtmlStyleMap getXParStyleMap() { return getStyleMap(xpar); } public XhtmlStyleMap getXHeadingStyleMap() { return getStyleMap(xheading); } public XhtmlStyleMap getXTextStyleMap() { return getStyleMap(xtext); } diff --git a/source/java/writer2latex/xhtml/XhtmlDocument.java b/source/java/writer2latex/xhtml/XhtmlDocument.java index 6b1267c..e8b3482 100644 --- a/source/java/writer2latex/xhtml/XhtmlDocument.java +++ b/source/java/writer2latex/xhtml/XhtmlDocument.java @@ -594,6 +594,7 @@ public class XhtmlDocument extends DOMDocument { } } Element doc = getContentDOM().getDocumentElement(); + optimize(doc,null,null); write(doc,bPrettyPrint ? 0 : -1,osw); osw.flush(); @@ -691,9 +692,11 @@ public class XhtmlDocument extends DOMDocument { write(node.getNodeValue(),osw); break; case Node.COMMENT_NODE: + if (nLevel>=0) { writeSpaces(nLevel,osw); } osw.write(""); if (nLevel>=0) { osw.write("\n"); } }