396 lines
10 KiB
Java
396 lines
10 KiB
Java
package writer2latex.xhtml.content;
|
|
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
|
|
import org.w3c.dom.Document;
|
|
import org.w3c.dom.Element;
|
|
import org.w3c.dom.Node;
|
|
import org.w3c.dom.NodeList;
|
|
|
|
import pro.litvinovg.xml.Debug;
|
|
import writer2latex.office.XMLString;
|
|
import writer2latex.xhtml.Converter;
|
|
import writer2latex.xhtml.XhtmlConfig;
|
|
|
|
import static writer2latex.util.Misc.*;
|
|
|
|
//LinkedList<String> stringList = new LinkedList<String>();
|
|
public class Separator {
|
|
|
|
private static final String NONE = "none";
|
|
private static final String SECTIONS = "sections";
|
|
private static final String DIV = "div";
|
|
private int splitLevel = 0;
|
|
private boolean alignSplitToPages;
|
|
private int lastSplitPageNum = 1;
|
|
private Integer pageNumber = null;
|
|
private String breakStyle = null;
|
|
|
|
private static LinkedList<Integer> greenstoneStack = new LinkedList<Integer>();
|
|
private int[] headingPath;
|
|
private static boolean pageOpened = false;
|
|
// headings none
|
|
private static boolean greenstoneSeparation;
|
|
private static boolean rdfSeparation = false;
|
|
// sections div none
|
|
private static boolean pagination;
|
|
private static Converter converter = null;
|
|
private Node prevPageContainer = null;
|
|
private PageContainer pageContainer = null;
|
|
|
|
public Separator(XhtmlConfig config, Converter converter) {
|
|
this.converter = converter;
|
|
greenstoneSeparation = config.getGreenstoneSeparation();
|
|
pagination = config.pagination();
|
|
splitLevel = config.getXhtmlSplitLevel();
|
|
alignSplitToPages = config.getAlignSplitsToPages();
|
|
breakStyle = config.getPageBreakStyle();
|
|
pageContainer = converter.pageContainer;
|
|
rdfSeparation = converter.isRDF;
|
|
headingPath = new int[10];
|
|
}
|
|
|
|
public Node processOutlineLevel(Node currentNode, Node hnode, int pageNum) {
|
|
|
|
// Get outline level
|
|
String sLevel = getAttribute(currentNode, XMLString.TEXT_OUTLINE_LEVEL);
|
|
// System.out.println(sLevel);
|
|
if (sLevel == null || sLevel.isEmpty()) {
|
|
return hnode;
|
|
}
|
|
String title = getTitle(currentNode).trim();
|
|
if (title == null || title.isEmpty()) {
|
|
return hnode;
|
|
}
|
|
// System.out.println(sLevel + "after title");
|
|
|
|
int curLevel = Integer.parseInt(sLevel);
|
|
|
|
|
|
if (noSplitNeeded(pageNum, curLevel)) {
|
|
System.out.println(sLevel + "no split needed");
|
|
|
|
return hnode;
|
|
}
|
|
|
|
if (isSplitTime(curLevel, pageNum)) {
|
|
prevPageContainer = hnode;
|
|
}
|
|
|
|
if (pageOpened) {
|
|
hnode = closePage(hnode);
|
|
}
|
|
|
|
if (greenstoneSeparation) {
|
|
closeCommentHeadings(hnode, curLevel);
|
|
}
|
|
|
|
updateHeadingPath(curLevel);
|
|
|
|
if (isSplitTime(curLevel, pageNum)) {
|
|
hnode = splitFiles(hnode);
|
|
lastSplitPageNum = pageNum;
|
|
}
|
|
if (greenstoneSeparation) {
|
|
openCommentHeading(hnode, title);
|
|
addToCommentStack(sLevel);
|
|
}
|
|
|
|
if (pagination) {
|
|
hnode = openPage(hnode, pageNum);
|
|
}
|
|
|
|
return hnode;
|
|
}
|
|
|
|
private boolean noSplitNeeded(int pageNum, int curLevel) {
|
|
return !greenstoneSeparation && !isSplitTime(curLevel,pageNum);
|
|
}
|
|
|
|
private void addToCommentStack(String sLevel) {
|
|
greenstoneStack.offerFirst(Integer.parseInt(sLevel));
|
|
}
|
|
|
|
private void updateHeadingPath(int level) {
|
|
if (level == 0) {
|
|
return;
|
|
}
|
|
for (int i = 9; i > level - 1; i--) {
|
|
headingPath[i] = 0;
|
|
}
|
|
headingPath[level - 1]++;
|
|
}
|
|
|
|
private Node splitFiles(Node hnode) {
|
|
String path = "";
|
|
for (int i = 0; i < 10; i++) {
|
|
path = path + " " + headingPath[i];
|
|
}
|
|
hnode = converter.nextOutFile();
|
|
((Element) hnode).setAttribute("path", path.trim());
|
|
return hnode;
|
|
}
|
|
|
|
private boolean isSplitTime(int curLevel, int pageNum) {
|
|
if ((rdfSeparation || splitLevel >= curLevel ) && converter.outFileHasContent()) {
|
|
if (alignSplitToPages) {
|
|
if (lastSplitPageNum != pageNum) {
|
|
return true;
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public Node processPageBreak(Node currentNode, Node hnode, Integer pageNum) {
|
|
if (!pagination) {
|
|
return hnode;
|
|
}
|
|
if (pageOpened) {
|
|
hnode = closePage(hnode);
|
|
}
|
|
hnode = openPage(hnode, pageNum);
|
|
|
|
return hnode;
|
|
}
|
|
|
|
public boolean isPageOpened() {
|
|
return pageOpened;
|
|
}
|
|
|
|
/**
|
|
* Opens main document section heading tag
|
|
*/
|
|
public Node startDocument(Node hnode, String title, int pageNum) {
|
|
if (!greenstoneSeparation && !pagination) {
|
|
return hnode;
|
|
}
|
|
if (greenstoneSeparation) {
|
|
// Create global section
|
|
openCommentHeading(hnode, title);
|
|
}
|
|
hnode = openPage(hnode, pageNum);
|
|
|
|
return hnode;
|
|
}
|
|
|
|
// Method to close open tags at the end of the document
|
|
public Node endDocument(Node hnode) {
|
|
if (!greenstoneSeparation && !pagination) {
|
|
return hnode;
|
|
}
|
|
if (pageOpened) {
|
|
hnode = closePage(hnode);
|
|
}
|
|
if (greenstoneSeparation) {
|
|
closeCommentHeadings(hnode, 0);
|
|
// Close global section
|
|
addCloseComment(hnode);
|
|
}
|
|
|
|
return hnode;
|
|
}
|
|
|
|
private Node openPageDiv(Node node, int curPageNum) {
|
|
if (node == null) {
|
|
System.out.println("Error: node is null on openPageDiv");
|
|
return node;
|
|
}
|
|
if (prevPageContainer != null && alignSplitToPages) {
|
|
alignFilesByHeadings(node, curPageNum);
|
|
}
|
|
breakPage(node, curPageNum);
|
|
Document doc = node.getOwnerDocument();
|
|
Element openBlock = (Element) doc.createElement(DIV);
|
|
openBlock.setAttribute("class", "pageNum");
|
|
openBlock.setAttribute("page", Integer.toString(curPageNum));
|
|
// insert open section comment before header node
|
|
node.appendChild((Node) openBlock);
|
|
node = openBlock;
|
|
return openBlock;
|
|
}
|
|
|
|
private void breakPage(Node node, int curPageNum) {
|
|
if (pageNumber != null && pageNumber != curPageNum) {
|
|
Document doc = node.getOwnerDocument();
|
|
Element pageBreak = (Element) doc.createElement(DIV);
|
|
pageBreak.setAttribute("class", "pageBreak");
|
|
if (breakStyleIsSet()) {
|
|
applyBreakStyle(pageBreak);
|
|
}
|
|
node.appendChild(pageBreak);
|
|
}
|
|
pageNumber = curPageNum;
|
|
}
|
|
|
|
private void applyBreakStyle(Element pageBreak) {
|
|
pageBreak.setAttribute("style", breakStyle);
|
|
}
|
|
|
|
public boolean breakStyleIsSet() {
|
|
if (breakStyle == null || breakStyle.isEmpty()) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private void alignFilesByHeadings(Node node, int pageNum) {
|
|
Document newdoc = node.getOwnerDocument();
|
|
Node prevPage = prevPageContainer.getParentNode();
|
|
String prevPageNum = getAttribute(prevPage, "page");
|
|
if (prevPageNum != null && prevPageNum.equals(Integer.toString(pageNum))) {
|
|
if (isElement(prevPage, DIV)) {
|
|
Node importedNode = newdoc.importNode(prevPage, true);
|
|
node.appendChild(importedNode);
|
|
Node prevDoc = prevPage.getParentNode();
|
|
if (prevDoc != null) {
|
|
prevDoc.removeChild(prevPage);
|
|
}
|
|
}
|
|
}
|
|
// no more arrange needed till next file separation
|
|
prevPageContainer = null;
|
|
|
|
}
|
|
|
|
private static Node exitPageDiv(Node node) {
|
|
|
|
while (!isRoot(node) && !isElement(node, DIV)) {
|
|
node = node.getParentNode();
|
|
}
|
|
Node result = node.getParentNode();
|
|
if (node.getChildNodes().getLength() == 1) {
|
|
if (node.getFirstChild().getChildNodes().getLength() == 0) {
|
|
result.removeChild(node);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static String getTitle(Node currentNode) {
|
|
Node content = currentNode.cloneNode(true);
|
|
String title = null;
|
|
NodeList lineBreaks = ((Element) content).getElementsByTagName(XMLString.TEXT_LINE_BREAK);
|
|
NodeList textTabs = ((Element) content).getElementsByTagName(XMLString.TEXT_TAB);
|
|
|
|
replaceWithSpaces(lineBreaks);
|
|
replaceWithSpaces(textTabs);
|
|
deleteNotesIn(content);
|
|
title = content.getTextContent();
|
|
return title;
|
|
}
|
|
|
|
private static void deleteNotesIn(Node content) {
|
|
NodeList notes = ((Element) content).getElementsByTagName(XMLString.TEXT_NOTE);
|
|
int j = 0;
|
|
while (j < notes.getLength()) {
|
|
Node note = notes.item(j);
|
|
note.getParentNode().removeChild(note);
|
|
}
|
|
}
|
|
|
|
private static void replaceWithSpaces(NodeList contentNodes) {
|
|
int i = 0;
|
|
while (i < contentNodes.getLength()) {
|
|
Node node = contentNodes.item(i);
|
|
Document doc = node.getOwnerDocument();
|
|
Node testSpace = doc.createTextNode(" ");
|
|
node.getParentNode().insertBefore(testSpace, node);
|
|
node.getParentNode().removeChild(node);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
private static void openCommentHeading(Node hnode, String title) {
|
|
Document doc = hnode.getOwnerDocument();
|
|
Node openSection = doc.createComment(openHeadingCommentText(title));
|
|
// insert open section comment before header node
|
|
hnode.appendChild(openSection);
|
|
}
|
|
|
|
private static void addCloseComment(Node node) {
|
|
Document doc = node.getOwnerDocument();
|
|
Node closeSection = doc.createComment("</Section>");
|
|
// insert open section comment before header node
|
|
node.appendChild(closeSection);
|
|
}
|
|
|
|
private static void closeCommentHeadings(Node hnode, int nLevel) {
|
|
if (greenstoneStack.isEmpty()) {
|
|
return;
|
|
}
|
|
// Close all sections with level less than current
|
|
while (nLevel <= greenstoneStack.peek()) {
|
|
addCloseComment(hnode);
|
|
greenstoneStack.poll();
|
|
if (greenstoneStack.isEmpty()) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Node closePage(Node hnode) {
|
|
if (pageOpened == false) {
|
|
return hnode;
|
|
}
|
|
hnode = exitPageContainer(hnode);
|
|
if (pagination) {
|
|
hnode = exitPageDiv(hnode);
|
|
}
|
|
pageOpened = false;
|
|
return hnode;
|
|
}
|
|
|
|
public Node openPage(Node hnode, Integer pageNum) {
|
|
if (pageOpened == true || !pagination) {
|
|
return hnode;
|
|
}
|
|
hnode = openPageDiv(hnode, pageNum);
|
|
pageOpened = true;
|
|
hnode = enterPageContainer(hnode);
|
|
return hnode;
|
|
}
|
|
|
|
private Node exitPageContainer(Node hnode) {
|
|
String className = ((Element) hnode).getAttribute("class");
|
|
if (!className.equals("pageContainer")) {
|
|
System.out.println("Can't exit not my container!");
|
|
Debug.printNode(hnode);
|
|
Debug.printStackTrace();
|
|
System.exit(1);
|
|
}
|
|
Element parentNode = (Element) hnode.getParentNode();
|
|
return parentNode;
|
|
}
|
|
|
|
private Node enterPageContainer(Node hnode) {
|
|
if (hnode == null) {
|
|
System.out.println("Enter page container error. hnode is null");
|
|
Debug.printStackTrace();
|
|
System.exit(1);
|
|
}
|
|
Element container = converter.createElement("div");
|
|
container.setAttribute("class", "pageContainer");
|
|
if (!pageContainer.getCurrentStyle().isEmpty()) {
|
|
container.setAttribute("style", pageContainer.getCurrentStyle());
|
|
}
|
|
hnode.appendChild(container);
|
|
return container;
|
|
}
|
|
|
|
private static String openHeadingCommentText(String title) {
|
|
String comment = "<Section>\n<Description>\n<Metadata name=\"Title\">" + title + "</Metadata>\n</Description>";
|
|
return comment;
|
|
}
|
|
|
|
private static String openPageCommentText(Integer pageNum) {
|
|
String comment = "<Section>\n<Description>\n<Metadata name=\"Title\">" + pageNum + "</Metadata>\n<Metadata name=\"Page\">" + pageNum + "</Metadata>\n</Description>";
|
|
return comment;
|
|
}
|
|
|
|
}
|