From b954415d1ab8134d0feabf119d26ca0b65352d9f Mon Sep 17 00:00:00 2001 From: Georgy Litvinov Date: Fri, 24 Jul 2020 20:45:18 +0200 Subject: [PATCH] Refactored splitters --- .../pageSplitters/ABIndexSplitter.java | 44 ++++++ .../w2phtml/pageSplitters/BasicSplitter.java | 128 ++++++++++++++++++ .../java/w2phtml/pageSplitters/ISplitter.java | 9 ++ .../IllustrationIndexSplitter.java | 44 ++++++ .../pageSplitters/IndexBodySplitter.java | 47 +++++++ .../pageSplitters/ListItemSplitter.java | 69 ++++++++++ .../w2phtml/pageSplitters/ListSplitter.java | 93 +++++++++++++ .../w2phtml/pageSplitters/PageSplitter.java | 80 +++++++++++ .../pageSplitters/SectionSplitter.java | 102 ++++++++++++++ .../w2phtml/pageSplitters/SpanSplitter.java | 43 ++++++ .../w2phtml/pageSplitters/SplitFactory.java | 72 ++++++++++ .../pageSplitters/TableCellSplitter.java | 76 +++++++++++ .../pageSplitters/TableRowGroupSplitter.java | 86 ++++++++++++ .../pageSplitters/TableRowSplitter.java | 77 +++++++++++ .../pageSplitters/TableRowsSplitter.java | 61 +++++++++ .../w2phtml/pageSplitters/TableSplitter.java | 107 +++++++++++++++ .../w2phtml/pageSplitters/TextSplitter.java | 101 ++++++++++++++ 17 files changed, 1239 insertions(+) create mode 100644 src/main/java/w2phtml/pageSplitters/ABIndexSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/BasicSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/ISplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/IllustrationIndexSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/IndexBodySplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/ListItemSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/ListSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/PageSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/SectionSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/SpanSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/SplitFactory.java create mode 100644 src/main/java/w2phtml/pageSplitters/TableCellSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/TableRowGroupSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/TableRowSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/TableRowsSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/TableSplitter.java create mode 100644 src/main/java/w2phtml/pageSplitters/TextSplitter.java diff --git a/src/main/java/w2phtml/pageSplitters/ABIndexSplitter.java b/src/main/java/w2phtml/pageSplitters/ABIndexSplitter.java new file mode 100644 index 0000000..b52b5b5 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/ABIndexSplitter.java @@ -0,0 +1,44 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TEXT_ALPHABETICAL_INDEX_SOURCE; +import static w2phtml.office.XMLString.TEXT_INDEX_BODY; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class ABIndexSplitter extends BasicSplitter implements ISplitter { + + public ABIndexSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node abIndex) { + Node parent = abIndex.getParentNode(); + Node abIndexFirstPart = abIndex.cloneNode(false); + NodeList childs = abIndex.getChildNodes(); + boolean dataMoved = false; + int i = 0; + while (childs.getLength() > i) { + Node child = childs.item(i); + String childName = child.getNodeName(); + if (childName.equals(TEXT_ALPHABETICAL_INDEX_SOURCE)) { + abIndexFirstPart.appendChild(child.cloneNode(true)); + } else + if (childName.equals(TEXT_INDEX_BODY)) { + if (factory.split(child)) { + abIndexFirstPart.appendChild(child.getPreviousSibling()); + dataMoved = true; + } + } + i++; + } + if (dataMoved) { + parent.insertBefore(abIndexFirstPart, abIndex); + } + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/BasicSplitter.java b/src/main/java/w2phtml/pageSplitters/BasicSplitter.java new file mode 100644 index 0000000..c69d20e --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/BasicSplitter.java @@ -0,0 +1,128 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.FO_TEXT_INDENT; +import static w2phtml.office.XMLString.TEXT_NOTE_BODY; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; +import static w2phtml.office.XMLString.TEXT_STYLE_NAME; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; +import w2phtml.office.StyleWithProperties; +import w2phtml.util.Misc; + +public class BasicSplitter { + protected OfficeReader officeReader; + protected SplitFactory factory; + + public BasicSplitter(OfficeReader officeReader, SplitFactory factory) { + this.officeReader = officeReader; + this.factory = factory; + } + protected static boolean appendChild(Node parent, Node child) { + boolean dataMoved; + parent.appendChild(child); + dataMoved = true; + return dataMoved; + } + + protected static void addHyphen(Node para, Node paraBefore) { + //Debug.printNode(paraBefore); + //Debug.printNode(para); + Character softHyphen = 0x00ad; + Character lastChar = getLastChar(paraBefore); + Character firstChar = getFirstChar(para); + + if (lastChar == null || firstChar == null) { + return; + } + Node lastNode = paraBefore; + while (lastNode.hasChildNodes()) { + lastNode = lastNode.getLastChild(); + } + String lineEndsWith = lastNode.getTextContent(); + if (Character.isLetter(lastChar) && Character.isLetter(firstChar)) { + + lastNode.setTextContent(lastNode.getTextContent() + "\u2010"); + } else if (lastChar.equals(softHyphen)) { + lastNode.setTextContent(lineEndsWith.substring(0, lineEndsWith.length()-1) + "\u2010"); + } + } + protected static Character getLastChar(Node para) { + if (para == null) { return null; } + Node lastNode = para; + while (lastNode.hasChildNodes()) { + lastNode = lastNode.getLastChild(); + } + String content = lastNode.getTextContent(); + if (content != null && !content.isEmpty()) { + return content.charAt(content.length()-1); + } + return null; + } + + protected static Character getFirstChar(Node para) { + if (para == null) { return null; } + Node firstNode = para; + while (firstNode.hasChildNodes()) { + firstNode = firstNode.getFirstChild(); + } + String content = firstNode.getTextContent(); + if (content != null && !content.isEmpty()) { + return content.charAt(0); + } + return null; + } + + protected void removeIndent(Node paraAfter) { + String baseStyleName = Misc.getAttribute(paraAfter, TEXT_STYLE_NAME); + String newStyleName = officeReader.cloneParStyle(baseStyleName); + + Node styleAttr = paraAfter.getAttributes().getNamedItem(TEXT_STYLE_NAME); + styleAttr.setTextContent(newStyleName); + + StyleWithProperties newStyle = officeReader.getParStyle(Misc.getAttribute(paraAfter, TEXT_STYLE_NAME)); + newStyle.setParProperty(FO_TEXT_INDENT, "0"); + } + + protected static boolean containsSPB(Node node) { + Node parent = node.getParentNode(); + if (node.getNodeType() == Node.ELEMENT_NODE) { + if (node.getNodeName().equals(TEXT_SOFT_PAGE_BREAK) && (parent.getNodeName() != TEXT_NOTE_BODY)) { + return true; + } + if (node.hasChildNodes()) { + int currentNo = 0; + NodeList childNodes = node.getChildNodes(); + while (currentNo < childNodes.getLength()) { + Node childNode = childNodes.item(currentNo); + if (containsSPB(childNode)) { + return true; + } + currentNo++; + } + } + } + return false; + } + + protected static void removeSPB(Node node) { + if (node.getNodeType() == Node.ELEMENT_NODE) { + if (node.getNodeName().equals(TEXT_SOFT_PAGE_BREAK)) { + Node parent = node.getParentNode(); + parent.removeChild(node); + return; + } + if (node.hasChildNodes()) { + int currentNo = 0; + NodeList childNodes = node.getChildNodes(); + while (currentNo < childNodes.getLength()) { + Node childNode = childNodes.item(currentNo); + removeSPB(childNode); + currentNo++; + } + } + } + } +} diff --git a/src/main/java/w2phtml/pageSplitters/ISplitter.java b/src/main/java/w2phtml/pageSplitters/ISplitter.java new file mode 100644 index 0000000..862dc11 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/ISplitter.java @@ -0,0 +1,9 @@ +package w2phtml.pageSplitters; + +import org.w3c.dom.Node; + +public interface ISplitter { + + public boolean Split(Node node); + +} diff --git a/src/main/java/w2phtml/pageSplitters/IllustrationIndexSplitter.java b/src/main/java/w2phtml/pageSplitters/IllustrationIndexSplitter.java new file mode 100644 index 0000000..02c4bd8 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/IllustrationIndexSplitter.java @@ -0,0 +1,44 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TEXT_ILLUSTRATION_INDEX_SOURCE; +import static w2phtml.office.XMLString.TEXT_INDEX_BODY; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class IllustrationIndexSplitter extends BasicSplitter implements ISplitter{ + + public IllustrationIndexSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node illustrationIndex) { + Node parent = illustrationIndex.getParentNode(); + Node illustrationIndexFirstPart = illustrationIndex.cloneNode(false); + NodeList childs = illustrationIndex.getChildNodes(); + boolean dataMoved = false; + int i = 0; + while (childs.getLength() > i) { + Node child = childs.item(i); + String childName = child.getNodeName(); + if (childName.equals(TEXT_ILLUSTRATION_INDEX_SOURCE)) { + illustrationIndexFirstPart.appendChild(child.cloneNode(true)); + } else + if (childName.equals(TEXT_INDEX_BODY)) { + if(factory.split(child)) { + illustrationIndexFirstPart.appendChild(child.getPreviousSibling()); + dataMoved = true; + } + } + i++; + } + if (dataMoved) { + parent.insertBefore(illustrationIndexFirstPart, illustrationIndex); + } + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/IndexBodySplitter.java b/src/main/java/w2phtml/pageSplitters/IndexBodySplitter.java new file mode 100644 index 0000000..2d8b1d6 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/IndexBodySplitter.java @@ -0,0 +1,47 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TEXT_P; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class IndexBodySplitter extends BasicSplitter implements ISplitter { + + public IndexBodySplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node indexBody) { + Node indexBodyFirstPart = indexBody.cloneNode(false); + NodeList childs = indexBody.getChildNodes(); + boolean dataMoved = false; + int i = 0; + while (childs.getLength() > i) { + Node child = childs.item(i); + if (!containsSPB(child)) { + indexBodyFirstPart.appendChild(child); + } else { + String childName = child.getNodeName(); + if (childName.equals(TEXT_P)) { + if (factory.split(child)) { + indexBodyFirstPart.appendChild(child.getPreviousSibling()); + dataMoved = true; + } + return dataMoved; + } else + if (childName.equals(TEXT_SOFT_PAGE_BREAK)) { + //indexBody.removeChild(child); + //return dataMoved; + System.out.println("Error. Soft page break inside " + childName); + System.exit(1); + } + } + } + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/ListItemSplitter.java b/src/main/java/w2phtml/pageSplitters/ListItemSplitter.java new file mode 100644 index 0000000..5b1955a --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/ListItemSplitter.java @@ -0,0 +1,69 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TEXT_H; +import static w2phtml.office.XMLString.TEXT_LIST; +import static w2phtml.office.XMLString.TEXT_P; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class ListItemSplitter extends BasicSplitter implements ISplitter { + + public ListItemSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node listItem) { + Node listItemFirstPart = listItem.cloneNode(false); + Node parent = listItem.getParentNode(); + 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 (containsSPB(listItemChild)){ + //Break if SPB + if (nodeName.equals(TEXT_SOFT_PAGE_BREAK)) { + //Remove SPB.Return result + listItem.removeChild(listItemChild); + } else if (nodeName.equals(TEXT_LIST)) { + if (factory.split(listItemChild)){ + dataMoved=true; + } + + } else if (nodeName.equals(TEXT_H) || nodeName.equals(TEXT_P)) { + if (factory.split(listItemChild)){ + listItemFirstPart.appendChild(listItemChild.getPreviousSibling()); + dataMoved=true; + } + } else { + System.out.println("Error. SPB in List item child node " + nodeName); + System.exit(1); + } + break; + //Move to first part + } else { + + listItemFirstPart.appendChild(listItemChild); + dataMoved = true; + } + } else { + listItemFirstPart.appendChild(listItemChild); + dataMoved = true; + } + //check internal nodes + } + if(dataMoved) { + parent.insertBefore(listItemFirstPart, listItem); + } + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/ListSplitter.java b/src/main/java/w2phtml/pageSplitters/ListSplitter.java new file mode 100644 index 0000000..d401c50 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/ListSplitter.java @@ -0,0 +1,93 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TEXT_CONTINUE_NUMBERING; +import static w2phtml.office.XMLString.TEXT_LIST_HEADER; +import static w2phtml.office.XMLString.TEXT_LIST_ITEM; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; + +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class ListSplitter extends BasicSplitter implements ISplitter { + + public ListSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node list) { + Node parent = list.getParentNode(); + Node listFirstPart = list.cloneNode(false); + NodeList listNodes = list.getChildNodes(); + Document document = list.getOwnerDocument(); + Element softPageBreak = document.createElement(TEXT_SOFT_PAGE_BREAK); + Node hangingItem = null; + int i = 0; + boolean dataMoved = false; + while (listNodes.getLength() > i) { + Node child = listNodes.item(i); + if(child.getNodeType() == Node.ELEMENT_NODE){ + String nodeName = child.getNodeName(); + if (nodeName.equals(TEXT_LIST_HEADER)) { + if(containsSPB(child)){ + //Remove inner SPB + removeSPB(child); + //HACK :( + break; + } + listFirstPart.appendChild(child.cloneNode(true)); + //Get next element + i++; + } else if (nodeName.equals(TEXT_LIST_ITEM)) { + if (containsSPB(child)){ + + //remove SPB, move previous nodes to firstPart. + if (factory.split(child)){ + dataMoved = true; + //Add first part of list item to previous list item + listFirstPart.appendChild(child.getPreviousSibling()); + if (child.hasChildNodes()){ + hangingItem = child; + } else { + list.removeChild(child); + } + } + //Add text:continue-numbering="true" + if (dataMoved){ + ((Element) list).setAttribute(TEXT_CONTINUE_NUMBERING, "true"); + } + break; + } else { + // Not with SPB yet, move node, set dataMoved=true + listFirstPart.appendChild(child); + dataMoved = true; + } + } else { + System.out.println("Error. SPB in List child node " + nodeName); + System.exit(1); + } + } + } + if (dataMoved) { + parent.insertBefore(listFirstPart, list); + parent.insertBefore(softPageBreak, list); + if (hangingItem != null) { + i = 0; + NodeList freeNodes = hangingItem.getChildNodes(); + while (freeNodes.getLength() > 0 ) { + Node freeNode = freeNodes.item(i); + parent.insertBefore(freeNode, list); + } + list.removeChild(hangingItem); + } + + } + + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/PageSplitter.java b/src/main/java/w2phtml/pageSplitters/PageSplitter.java new file mode 100644 index 0000000..ff52ea2 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/PageSplitter.java @@ -0,0 +1,80 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TEXT_BOOKMARK_START; +import static w2phtml.office.XMLString.TEXT_NOTE; +import static w2phtml.office.XMLString.TEXT_NOTE_BODY; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; +import static w2phtml.office.XMLString.TEXT_SPAN; + +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class PageSplitter extends BasicSplitter implements ISplitter { + + public PageSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + // TODO Auto-generated constructor stub + } + + @Override + public boolean Split(Node para) { + Node parent = para.getParentNode(); + //System.out.println("handlePara"); + Node paraFirstPart = para.cloneNode(false); + boolean dataMoved = false; + int i = 0; + NodeList childs = para.getChildNodes(); + while (childs.getLength() > i) { + //System.out.println("In WHILE HANDLE PARA"); + Node child = childs.item(i); + //NOT TEXT NODES + if ((child.getNodeType() == Node.ELEMENT_NODE)) { + String childName = child.getNodeName(); + //SPB FOUND + if (containsSPB(child)){ + //System.out.println(childName); + if (childName.equals(TEXT_SOFT_PAGE_BREAK)){ + //removeSPB + //System.out.println("REMOVE SPB"); + para.removeChild(child); + } else + if (childName.equals(TEXT_NOTE)){ + Element textNote = (Element) child; + //System.out.println("handle TextNote in para"); + factory.split(textNote.getElementsByTagName(TEXT_NOTE_BODY).item(0)); + } else + if (childName.equals(TEXT_SPAN)){ + factory.split(child); + } else { + //Debug.printNode(child); + System.out.println("ERROR: SPB INSIDE Paragraph Element in inner element " + childName); + System.exit(1); + } + break; + //Other elements + } else if (childName.equals(TEXT_BOOKMARK_START)){ + paraFirstPart.appendChild(child.cloneNode(true)); + i++; + } else { + dataMoved = appendChild(paraFirstPart, child); + } + //TEXT NODES + } else { + dataMoved = appendChild(paraFirstPart, child); + } + + } + addHyphen(para,paraFirstPart); + + if (dataMoved) { + removeIndent(para); + parent.insertBefore(paraFirstPart, para); + } + + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/SectionSplitter.java b/src/main/java/w2phtml/pageSplitters/SectionSplitter.java new file mode 100644 index 0000000..2451dda --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/SectionSplitter.java @@ -0,0 +1,102 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TABLE_TABLE; +import static w2phtml.office.XMLString.TEXT_H; +import static w2phtml.office.XMLString.TEXT_LIST; +import static w2phtml.office.XMLString.TEXT_P; +import static w2phtml.office.XMLString.TEXT_SECTION; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; +import static w2phtml.office.XMLString.TEXT_TABLE_OF_CONTENT; + +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class SectionSplitter extends BasicSplitter implements ISplitter { + + public SectionSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + // TODO Auto-generated constructor stub + } + + @Override + public boolean Split(Node section) { + Node parent = section.getParentNode(); + setLastAttribute(section); + Node sectionFirstPart = section.cloneNode(false); + removeLastAttribute(sectionFirstPart); + boolean dataMoved = false; + // Node counter + int i = 0; + NodeList childs = section.getChildNodes(); + while (childs.getLength() > i) { + + Node child = childs.item(0); + if ((child.getNodeType() == Node.ELEMENT_NODE)) { + String nodeName = child.getNodeName(); + if (containsSPB(child)){ + if (nodeName.equals(TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + section.removeChild(child); + } else if (nodeName.equals(TEXT_H) || nodeName.equals(TEXT_P)) { + if (factory.split(child)){ + sectionFirstPart.appendChild(child.getPreviousSibling()); + dataMoved=true; + } + } else if (nodeName.equals(TEXT_TABLE_OF_CONTENT)) { + + //HACK + removeSPB(section); + i++; + continue; + } else if (nodeName.equals(TABLE_TABLE)) { + if (factory.split(child)){ + sectionFirstPart.appendChild(child.getPreviousSibling()); + dataMoved=true; + } + } else if (nodeName.equals(TEXT_SECTION)) { + if (factory.split(child)){ + sectionFirstPart.appendChild(child.getPreviousSibling()); + dataMoved=true; + } + } else if (nodeName.equals(TEXT_LIST)) { + if (factory.split(child)){ + dataMoved=true; + } + } else { + System.out.println("Error. SPB in Section child node " + nodeName); + System.exit(1); + } + //split node with spb and exit + break; + } else { + sectionFirstPart.appendChild(child); + dataMoved = true; + } + } else { + //Append text nodes + sectionFirstPart.appendChild(child); + dataMoved = true; + } + + } + if (dataMoved) { + parent.insertBefore(sectionFirstPart, section); + } + + return dataMoved; + } + + + private static void removeLastAttribute(Node section) { + Element sectionEl = (Element) section; + sectionEl.setAttribute("last", "false"); + } + private static void setLastAttribute(Node section) { + Element sectionEl = (Element) section; + sectionEl.setAttribute("last", "true"); + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/SpanSplitter.java b/src/main/java/w2phtml/pageSplitters/SpanSplitter.java new file mode 100644 index 0000000..a6de391 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/SpanSplitter.java @@ -0,0 +1,43 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TEXT_NOTE; +import static w2phtml.office.XMLString.TEXT_NOTE_BODY; +import static w2phtml.office.XMLString.TEXT_SPAN; + +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class SpanSplitter extends BasicSplitter implements ISplitter{ + + public SpanSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node span) { + NodeList childs = span.getChildNodes(); + int i = 0; + while (childs.getLength() > i) { + Node child = childs.item(i); + String childName = child.getNodeName(); + if (child.getNodeType() == Node.ELEMENT_NODE) { + if (containsSPB(child)) { + if (childName.equals(TEXT_NOTE)) { + factory.split(((Element)child).getElementsByTagName(TEXT_NOTE_BODY).item(0)); + } else if (childName.equals(TEXT_SPAN)){ + factory.split(child); + } else { + System.out.println("Error. SPB in unknown element " + childName); + System.exit(1); + } + } + } + i++; + } + return false; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/SplitFactory.java b/src/main/java/w2phtml/pageSplitters/SplitFactory.java new file mode 100644 index 0000000..dbcec07 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/SplitFactory.java @@ -0,0 +1,72 @@ +package w2phtml.pageSplitters; + +import org.w3c.dom.Node; +import static w2phtml.office.XMLString.*; +import pro.litvinovg.xml.Debug; +import w2phtml.office.OfficeReader; + +public class SplitFactory { + private OfficeReader officeReader; + public SplitFactory(OfficeReader ofr){ + this.officeReader = ofr; + } + public boolean split(Node node) { + if(node == null) { + System.out.println("Error. Node is null."); + Debug.printStackTrace(); + System.exit(1); + } + String nodeName = node.getNodeName(); + System.out.println(nodeName); + ISplitter splitter = null; + if (nodeName.contentEquals(TEXT_SPAN)) { + splitter = new SpanSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TEXT_P) || nodeName.contentEquals(TEXT_H)) { + splitter = new PageSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TEXT_NOTE) || nodeName.contentEquals(OFFICE_TEXT)) { + splitter = new TextSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TEXT_ILLUSTRATION_INDEX)) { + splitter = new IllustrationIndexSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TEXT_INDEX_BODY)) { + splitter = new IndexBodySplitter(officeReader, this); + } else + if (nodeName.contentEquals(TEXT_ALPHABETICAL_INDEX)) { + splitter = new ABIndexSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TABLE_TABLE)) { + splitter = new TableSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TABLE_TABLE_ROW)) { + splitter = new TableRowSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TABLE_TABLE_ROWS)) { + splitter = new TableRowsSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TEXT_LIST)) { + splitter = new ListSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TEXT_SECTION)) { + splitter = new SectionSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TEXT_LIST_ITEM)) { + splitter = new ListItemSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TABLE_TABLE_ROW_GROUP)) { + splitter = new TableRowGroupSplitter(officeReader, this); + } else + if (nodeName.contentEquals(TABLE_TABLE_CELL) || nodeName.contentEquals(TABLE_COVERED_TABLE_CELL)) { + splitter = new TableCellSplitter(officeReader, this); + } + + + if (splitter == null) { + System.out.println("Error. Splitter for element " + nodeName + " is not implemented, yet. Exit."); + System.exit(1); + } + return splitter.Split(node); + } +} diff --git a/src/main/java/w2phtml/pageSplitters/TableCellSplitter.java b/src/main/java/w2phtml/pageSplitters/TableCellSplitter.java new file mode 100644 index 0000000..7ccf083 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/TableCellSplitter.java @@ -0,0 +1,76 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TABLE_TABLE; +import static w2phtml.office.XMLString.TEXT_H; +import static w2phtml.office.XMLString.TEXT_LIST; +import static w2phtml.office.XMLString.TEXT_P; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class TableCellSplitter extends BasicSplitter implements ISplitter { + + public TableCellSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + // TODO Auto-generated constructor stub + } + + @Override + public boolean Split(Node cellNode) { + Node cellFirstPart = cellNode.cloneNode(false); + Node parent = cellNode.getParentNode(); + 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 (containsSPB(cellChildNode)){ + if (nodeName.equals(TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + cellNode.removeChild(cellChildNode); + } else if (nodeName.equals(TEXT_H) || nodeName.equals(TEXT_P)) { + if (factory.split(cellChildNode)){ + cellFirstPart.appendChild(cellChildNode.getPreviousSibling()); + dataMoved=true; + } + } else if (nodeName.equals(TEXT_LIST)) { + if (factory.split(cellChildNode)){ + cellFirstPart.appendChild(cellChildNode.getPreviousSibling()); + dataMoved=true; + } + } else if (nodeName.equals(TABLE_TABLE)) { + if (factory.split(cellChildNode)){ + cellFirstPart.appendChild(cellChildNode.getPreviousSibling()); + dataMoved=true; + } + } else { + System.out.println("Error. SPB in Cell child node " + nodeName); + System.exit(1); + } + + break; + } else { + cellFirstPart.appendChild(cellChildNode); + dataMoved = true; + } + } else { + //Append text nodes + cellFirstPart.appendChild(cellChildNode); + dataMoved = true; + } + + } + if (dataMoved) { + parent.insertBefore(cellFirstPart, cellNode); + } + + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/TableRowGroupSplitter.java b/src/main/java/w2phtml/pageSplitters/TableRowGroupSplitter.java new file mode 100644 index 0000000..35e4590 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/TableRowGroupSplitter.java @@ -0,0 +1,86 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TABLE_TABLE_HEADER_ROWS; +import static w2phtml.office.XMLString.TABLE_TABLE_ROW; +import static w2phtml.office.XMLString.TABLE_TABLE_ROWS; +import static w2phtml.office.XMLString.TABLE_TABLE_ROW_GROUP; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class TableRowGroupSplitter extends BasicSplitter implements ISplitter { + + public TableRowGroupSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + // TODO Auto-generated constructor stub + } + + @Override + public boolean Split(Node tableRowGroup) { + boolean dataMoved = false; + Node parent = tableRowGroup.getParentNode(); + Node tableRowGroupFistPart = tableRowGroup.cloneNode(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 (containsSPB(tableRowGroupChildNode)){ + if (nodeName.equals(TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + tableRowGroup.removeChild(tableRowGroupChildNode); + + } else if (nodeName.equals(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(TABLE_TABLE_ROW)){ + if (factory.split(tableRowGroupChildNode)){ + dataMoved = true; + tableRowGroupFistPart.appendChild(tableRowGroupChildNode.getPreviousSibling()); + } + } else if (nodeName.equals(TABLE_TABLE_ROW_GROUP)){ + if (factory.split(tableRowGroupChildNode)){ + dataMoved = true; + tableRowGroupFistPart.appendChild(tableRowGroupChildNode.getPreviousSibling()); + } + } else if (nodeName.equals(TABLE_TABLE_ROWS)){ + if (factory.split(tableRowGroupChildNode)){ + dataMoved = true; + tableRowGroupFistPart.appendChild(tableRowGroupChildNode.getPreviousSibling()); + } + } + break; + } else { + if (nodeName.equals(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; + } + + } + if (dataMoved) { + parent.insertBefore(tableRowGroupFistPart, tableRowGroup); + } + + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/TableRowSplitter.java b/src/main/java/w2phtml/pageSplitters/TableRowSplitter.java new file mode 100644 index 0000000..ca1d66c --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/TableRowSplitter.java @@ -0,0 +1,77 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TABLE_COVERED_TABLE_CELL; +import static w2phtml.office.XMLString.TABLE_TABLE_CELL; +import static w2phtml.office.XMLString.TEXT_P; + +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class TableRowSplitter extends BasicSplitter implements ISplitter { + + public TableRowSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node tableRow) { + Node tableRowFirstPart = tableRow.cloneNode(false); + Node parent = tableRow.getParentNode(); + 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 (containsSPB(tableRowChildNode)){ + if (nodeName.equals(TABLE_TABLE_CELL)){ + if (factory.split(tableRowChildNode)){ + dataMoved = true; + tableRowFirstPart.appendChild(tableRowChildNode.getPreviousSibling()); + } + + } else if (nodeName.equals(TABLE_COVERED_TABLE_CELL)){ + //Implement handleCoveredCell in future + if (factory.split(tableRowChildNode)){ + dataMoved = true; + tableRowFirstPart.appendChild(tableRowChildNode.getPreviousSibling()); + } + } + } else { + //System.out.println("HERE " + nodeName); + //Move node without SPB above + tableRowFirstPart.appendChild(tableRowChildNode.cloneNode(true)); + Node emptyCell = tableRowChildNode.cloneNode(false); + Document document = tableRow.getOwnerDocument(); + Element textP = document.createElement(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; + } + + } + if (dataMoved) { + parent.insertBefore(tableRowFirstPart, tableRow); + } + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/TableRowsSplitter.java b/src/main/java/w2phtml/pageSplitters/TableRowsSplitter.java new file mode 100644 index 0000000..1a4bd04 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/TableRowsSplitter.java @@ -0,0 +1,61 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TABLE_TABLE_ROW; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class TableRowsSplitter extends BasicSplitter implements ISplitter { + + public TableRowsSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node tableRows) { + Node tableRowsFirstPart = tableRows.cloneNode(false); + Node parent = tableRows.getParentNode(); + 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 (containsSPB(tableRowsChildNode)){ + if (nodeName.equals(TEXT_SOFT_PAGE_BREAK)){ + // remove inner soft page break node + tableRows.removeChild(tableRowsChildNode); + + } else if (nodeName.equals(TABLE_TABLE_ROW)){ + if (factory.split(tableRowsChildNode)){ + dataMoved = true; + tableRowsFirstPart.appendChild(tableRowsChildNode.getPreviousSibling()); + } + } + break; + } else { + tableRowsFirstPart.appendChild(tableRowsChildNode); + dataMoved = true; + } + } else { + System.out.println("ERROR: TEXT NODE FOUND INSIDE tabl:table-rows"); + //Append text nodes + //tableRowsFistPart.appendChild(tableRowsChildNode); + //dataMoved = true; + } + + } + if (dataMoved) { + parent.insertBefore(tableRowsFirstPart, tableRows); + } + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/TableSplitter.java b/src/main/java/w2phtml/pageSplitters/TableSplitter.java new file mode 100644 index 0000000..b7df79c --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/TableSplitter.java @@ -0,0 +1,107 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.TABLE_TABLE_COLUMN; +import static w2phtml.office.XMLString.TABLE_TABLE_COLUMN_GROUP; +import static w2phtml.office.XMLString.TABLE_TABLE_HEADER_COLUMNS; +import static w2phtml.office.XMLString.TABLE_TABLE_HEADER_ROWS; +import static w2phtml.office.XMLString.TABLE_TABLE_ROW; +import static w2phtml.office.XMLString.TABLE_TABLE_ROWS; +import static w2phtml.office.XMLString.TABLE_TABLE_ROW_GROUP; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; + +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import w2phtml.office.OfficeReader; + +public class TableSplitter extends BasicSplitter implements ISplitter { + + public TableSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(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 + * + * + */ + Node parent = table.getParentNode(); + Node tableFirstPart = table.cloneNode(false); + 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 (containsSPB(tableChildNode)){ + if (tableChildNodeName.equals(TEXT_SOFT_PAGE_BREAK)) { + // remove inner soft page break node + table.removeChild(tableChildNode); + + } else if (tableChildNodeName.equals(TABLE_TABLE_ROW_GROUP)) { + if (factory.split(tableChildNode)){ + dataMoved = true; + tableFirstPart.appendChild(tableChildNode.getPreviousSibling()); + } + } else if ( tableChildNodeName.equals(TABLE_TABLE_ROWS)) { + if (factory.split(tableChildNode)){ + dataMoved = true; + tableFirstPart.appendChild(tableChildNode.getPreviousSibling()); + } + } else if ( tableChildNodeName.equals(TABLE_TABLE_ROW)) { + if (factory.split(tableChildNode)){ + dataMoved = true; + tableFirstPart.appendChild(tableChildNode.getPreviousSibling()); + } + } else if (tableChildNodeName.equals(TABLE_TABLE_COLUMN) + || tableChildNodeName.equals(TABLE_TABLE_COLUMN_GROUP) + || tableChildNodeName.equals(TABLE_TABLE_HEADER_ROWS) + || tableChildNodeName.equals(TABLE_TABLE_HEADER_COLUMNS)) { + //Remove Soft Page Break + removeSPB(tableChildNode); + } + break; + + } else { + //Before SPB + //Description nodes + if (tableChildNodeName.equals(TABLE_TABLE_COLUMN) + || tableChildNodeName.equals(TABLE_TABLE_COLUMN_GROUP) + || tableChildNodeName.equals(TABLE_TABLE_HEADER_ROWS) + || tableChildNodeName.equals(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; + } + } + } + } + if (dataMoved) { + parent.insertBefore(tableFirstPart, table); + } + return dataMoved; + } + +} diff --git a/src/main/java/w2phtml/pageSplitters/TextSplitter.java b/src/main/java/w2phtml/pageSplitters/TextSplitter.java new file mode 100644 index 0000000..e1d38d5 --- /dev/null +++ b/src/main/java/w2phtml/pageSplitters/TextSplitter.java @@ -0,0 +1,101 @@ +package w2phtml.pageSplitters; + +import static w2phtml.office.XMLString.FO_BREAK_BEFORE; +import static w2phtml.office.XMLString.TABLE_STYLE_NAME; +import static w2phtml.office.XMLString.TABLE_TABLE; +import static w2phtml.office.XMLString.TEXT_ALPHABETICAL_INDEX; +import static w2phtml.office.XMLString.TEXT_H; +import static w2phtml.office.XMLString.TEXT_ILLUSTRATION_INDEX; +import static w2phtml.office.XMLString.TEXT_LIST; +import static w2phtml.office.XMLString.TEXT_P; +import static w2phtml.office.XMLString.TEXT_SECTION; +import static w2phtml.office.XMLString.TEXT_SOFT_PAGE_BREAK; +import static w2phtml.office.XMLString.TEXT_STYLE_NAME; +import static w2phtml.office.XMLString.TEXT_TABLE_OF_CONTENT; + +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 w2phtml.office.OfficeReader; +import w2phtml.office.StyleWithProperties; +import w2phtml.util.Misc; + +public class TextSplitter extends BasicSplitter implements ISplitter { + + public TextSplitter(OfficeReader officeReader, SplitFactory factory) { + super(officeReader, factory); + } + + @Override + public boolean Split(Node onode) { + //Find par node with soft page break inside and split it + Document document = onode.getOwnerDocument(); + Element softPageBreak = document.createElement(TEXT_SOFT_PAGE_BREAK); + NodeList nodes = onode.getChildNodes(); + + int i = 0; + //Loop through the content nodes and split nodes with soft page break + while (i < nodes.getLength()){ + Node child = nodes.item(i); + + + //Necessary check if node is an Element + if (containsSPB(child)){ + String nodeName = child.getNodeName(); + //Create Duplicate Node! + Element childFirstPart = (Element) child.cloneNode(false); + StyleWithProperties style = null; + if ((nodeName.equals(TEXT_P) || nodeName.equals(TEXT_H))) { + //If SPB not the first node + + if (factory.split(child)){ + style = officeReader.getParStyle(Misc.getAttribute(child, TEXT_STYLE_NAME)); + } + } else if (nodeName.equals(TABLE_TABLE)) { + if (factory.split(child)){ + style = officeReader.getTableStyle(Misc.getAttribute(child, TABLE_STYLE_NAME)); + } + } else if (nodeName.equals(TEXT_LIST)) { + factory.split(child); + } else if (nodeName.equals(TEXT_ILLUSTRATION_INDEX)) { + factory.split(child); + } else if (nodeName.equals(TEXT_ALPHABETICAL_INDEX)) { + factory.split(child); + } else if (nodeName.equals(TEXT_SECTION)) { + if (factory.split(child)) { + style = officeReader.getSectionStyle(Misc.getAttribute(child, TEXT_SECTION)); + } + } else if (nodeName.equals(TEXT_TABLE_OF_CONTENT)){ + //HACK + containsSPB(childFirstPart); + i++; + continue; + } else if (nodeName.equals(TEXT_SOFT_PAGE_BREAK)){ + //HACK + i++; + continue; + } else { + Debug.printNode(child); + System.exit(1); + } + + if (style == null || !"page".equals(style.getProperty(FO_BREAK_BEFORE))){ + if (!nodeName.equals(TEXT_LIST)) { + onode.insertBefore(softPageBreak.cloneNode(false), child); + } + } + if (!child.hasChildNodes()){ + onode.removeChild(child); + } + continue; + } + i++; + } + //Debug.printNode(onode); + return false; + } + +}