<", "><");
//System.err.println("*** Format is now: " + gs3formatstr);
String gs3formatstr_notags = gs3formatstr;
gs3formatstr = addSurroundingTags(gs3formatstr);
String validationMsg = XMLTools.parseDOM(gs3formatstr);
if(!validationMsg.startsWith(XMLTools.WELLFORMED)) {
// Run Html Tidy in XML mode
System.err.println("*** Needing to run HTML Tidy on: ");
System.err.println(gs3formatstr_notags);
// HTMLTidy returns 0 if no warnings or errors, 1 if just Warnings, 2 if Errors (failure)
// http://sourceforge.net/p/tidy/mailman/tidy-develop/thread/20020811204058.GD1137@shaw.ca/
String htmltidy_string = runInteractiveProgram(XMLTIDY, gs3formatstr_notags);//removeSurroundingTags(gs3formatstr));
if(process_exitValue >= 2) {
System.err.println("@@@ Process exit value: " + process_exitValue);
errorMsg = Dictionary.get("FormatConversionDialog.Tidy_Failed")
+ " " + Dictionary.get("FormatConversionDialog.XML_Still_Invalid");
} else {
errorMsg = "";
gs3formatstr_notags = htmltidy_string;
gs3formatstr_notags = removeHTMLTags(i, gs3formatstr_notags, startsWithTableCell);
gs3formatstr = addSurroundingTags(gs3formatstr_notags);
// Having applied html-tidy, setGS3Format() will return true if it finally parsed
}
}
// For now, assume HTML Tidy has worked and that the gs3format has now been parsed successfully
boolean parsed = setGS3Format(i, gs3formatstr); // will parse the gs3formatstr into a DOM object
if(!parsed && errorMsg.equals("")) {
errorMsg = Dictionary.get("FormatConversionDialog.Tidy_Done")
+ " " + Dictionary.get("FormatConversionDialog.XML_Still_Invalid");
}
return errorMsg;
//return gs3formatstr;
}
// HTML tidy adds entire HTML tags around a single format statement. This method removes it.
private String removeHTMLTags(int i, String gs3formatstr_notags, boolean startsWithTD) {
// if it's a VList classifier
// and the gs2 format statement starts with a | ,
// then remove up to and including the outermost | ,
// else remove up to and including the tag
String removeOuterTag = "body>";
Element parent = (Element)getParentNode(i); // gets parent of GS2format:
if(parent.hasAttribute("match") && (!parent.hasAttribute("mode") || !parent.getAttribute("mode").equals("horizontal"))) {
if(startsWithTD) {
removeOuterTag = "tr>"; // remove the outermost cell HTML tidy added around the tablecell
}
}
//
//
// lines we want
//
//
int end = gs3formatstr_notags.indexOf(removeOuterTag);
if(end != -1) {
gs3formatstr_notags = gs3formatstr_notags.substring(end+removeOuterTag.length());
}
int start = gs3formatstr_notags.lastIndexOf(": text
private void setGS2Format(int i, String text) {
XMLTools.setElementTextValue(getGS2Format(i), text);
}
// gs3FormatStr represents DOM, and must be parsed and appended as sibling to the gs2format element
// as . If it fails to parse, nest it in a CDATA element of
private boolean setGS3Format(int i, String gs3formatstr) {
Document ownerDoc = getGS2Format(i).getOwnerDocument();
Node gs3format = null;
boolean parse_success = false;
String validationMsg = XMLTools.parseDOM(gs3formatstr);
if(!validationMsg.startsWith(XMLTools.WELLFORMED)) {
// silently add the gs3formatstr in a CDATA block into the root
gs3formatstr = removeSurroundingTags(gs3formatstr);
gs3format = ownerDoc.createElement(GSF_GS3_ROOT_TAG);
Node cdataSection = ownerDoc.createCDATASection(gs3formatstr);
gs3format.appendChild(cdataSection);
parse_success = false;
}
else {
// parse DOM into XML
Document doc = XMLTools.getDOM(gs3formatstr);
Element root = doc.getDocumentElement();
gs3format = ownerDoc.importNode(root, true); // an element
parse_success = true;
// System.err.println("@@@@ ROOT:\n" + XMLTools.xmlNodeToString(root));
}
// add gs3format element as sibling to gs2format element
Element oldgs3format = getGS3Format(i);
if(oldgs3format == null) {
getParentNode(i).appendChild(gs3format);
// System.err.println("@@@ APPEND");
} else {
// replace the existing
getParentNode(i).replaceChild(gs3format, oldgs3format);
// System.err.println("@@@ REPLACE");
}
//http://stackoverflow.com/questions/12524727/remove-empty-nodes-from-a-xml-recursively
return parse_success;
}
private Node getParentNode(int i) {
return gsf_format_gs2_list.item(i).getParentNode();
}
private Element getGS2Format(int i) {
return (Element)gsf_format_gs2_list.item(i);
}
private String getGS2FormatString(int i) {
return XMLTools.getElementTextValue(getGS2Format(i));
}
private Element getGS3Format(int i) {
Element parent = (Element)getParentNode(i);
NodeList nl = parent.getElementsByTagName(GSF_GS3_ROOT_TAG);
if(nl.getLength() > 0) {
return (Element)nl.item(0);
}
return null;
}
private String getGS3FormatString(int i) {
Element gs3format = getGS3Format(i);
if(gs3format == null) {
return "";
} else {
// if any child is a CData section, return its text as-is. There will be no indenting
NodeList children = gs3format.getChildNodes();
for(int j = 0 ; j < children.getLength(); j++) {
if(children.item(j).getNodeType() == Node.CDATA_SECTION_NODE) {
return children.item(j).getNodeValue(); // content of CDataSection
}
}
// else we have proper nodes, return indented string
StringBuffer sb = new StringBuffer();
XMLTools.xmlNodeToString(sb, gs3format, true, " ", 0);
return sb.toString();
}
}
private String getLabel(int i) {
String label = "";
// Given XML of the form:
//
//
//
//
//
//
//
// Want to return the label: "browse|search > documentNode|classifierNode [> horizontal]"
Element parent = (Element)getParentNode(i); // gets parent of GS2format:
label = parent.getAttribute("match"); //e.g. documentNode, classifierNode
if(parent.hasAttribute("mode")) { // e.g. classifierNode mode=horizontal
label = label + " > " + parent.getAttribute("mode");
}
Element ancestor = (Element) parent.getParentNode().getParentNode(); // ancestor: |
label = ancestor.getTagName() + " > " + label;
return label;
}
// gs2 format statements have spaces instead of newlines. For display, replace with newlines
private String makeLines(String gs2formatstr) {
return gs2formatstr.replaceAll(">\\s+<", ">\n<");
}
private String singleLine(String gs2formatstr) {
return gs2formatstr.replace(">\n<", "> <"); // put the spaces back
}
private String removeSurroundingTags(String xml)
{
//return xml.replace("<"+GSF_GS3_ROOT_TAG+" xmlns:gsf=\"http://www.greenstone.org/greenstone3/schema/ConfigFormat\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">\n", "").replace("\n", "");//.trim();
return xml.replaceAll("<"+GSF_GS3_ROOT_TAG+" xmlns:gsf=(\"|\')http://www.greenstone.org/greenstone3/schema/ConfigFormat(\"|\') xmlns:xsl=(\"|\')http://www.w3.org/1999/XSL/Transform(\"|\')>\n?", "").replaceAll("\n?", "");//.trim();
}
private String addSurroundingTags(String gs3formatstr) {
return "<"+GSF_GS3_ROOT_TAG+" xmlns:gsf='http://www.greenstone.org/greenstone3/schema/ConfigFormat' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>"+gs3formatstr+"";
}
//*************************FUNCTIONS THAT INTERACT WITH WIDGETS************************//
// increment() loads the next values into the dialog
private boolean increment() {
current_index++;
section_label.setText ( getLabel(current_index) );
gs2_textarea.setText( makeLines(getGS2FormatString(current_index)) );
gs3_textarea.setText( removeSurroundingTags(getGS3FormatString(current_index)) );
statusbar.setText("");
// as we're on a new screen of dialog, need to clear all undo/redo history
undoManager.discardAllEdits();
undo_button.setEnabled(false);
redo_button.setEnabled(false);
int len = gsf_format_gs2_list.getLength();
count_label.setText((current_index+1) + " / " + len);
if((current_index+1) == len) {
return false;
} else {
return true;
}
}
private void setStatus(String msg) {
statusbar.setText(msg);
}
private void setErrorStatus(String msg) {
statusbar.setBackground(Color.red);
statusbar.setText(msg);
}
public void dispose() {
//System.err.println("@@@@ DIALOG CLOSING!");
if(dlgResult != OpenCollectionDialog.CANCEL_OPTION) {
// Need to remove the siblings of all
// Then, get the children of each and add these as siblings of
int len = gsf_format_gs2_list.getLength();
for(int k=len-1; k >= 0; k--) {
Element parent = (Element)getParentNode(k);
//parent.normalize();
NodeList children = parent.getChildNodes();
// now have to loop/remove nodes in reverse order, since the following loop
// modifies the very nodelist we're looping over by removing nodes from it
int numChildren = children.getLength()-1;
for(int i=numChildren; i >= 0; i--) {
//for(int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
if(child.getNodeName().equals(GSF_FORMAT_GS2_TAG)) {
// if we're dealing with gs2-format-stmts, put their textnode contents in CData sections
// http://www.w3schools.com/xml/xml_cdata.asp
// This avoids having to look at html-encoded gs2-format tags in the Format pane
Element gs2format = (Element)child;
String gs2formatstr = XMLTools.getElementTextValue(gs2format);
gs2formatstr = Codec.transform(gs2formatstr, Codec.ESCAPEDHTML_TO_UNESCAPED);
Node textNode = XMLTools.getNodeTextNode(gs2format);
Node cdataSection = gs2format.getOwnerDocument().createCDATASection(gs2formatstr);
gs2format.replaceChild(cdataSection, textNode);
}
else if(child.getNodeName().equals(GSF_GS3_ROOT_TAG)) {
// remove GS3 node and append its children to the parent in its place
// the elements wouldn't be in the xml_file_doc DOM tree
// unless they were valid XML, so don't need to check for validity here
Node gs3root = child;
NodeList gs3_format_lines = gs3root.getChildNodes();
for(int j = 0; j < gs3_format_lines.getLength(); j++) {
Node duplicate = gs3_format_lines.item(j).cloneNode(true);
parent.appendChild(duplicate);
}
gs3root = parent.removeChild(gs3root);
gs3root = null; // finished processing
} // else - skip all nodes other than and
}
}
Element root = xml_file_doc.getDocumentElement();
//System.err.println("### XML file to write out:\n" + XMLTools.xmlNodeToString(root));
// Finally, write out the collection xml file
String[] nonEscapingTagNames = { StaticStrings.FORMAT_STR, StaticStrings.DISPLAYITEM_STR };
XMLTools.writeXMLFile(collect_cfg_file, xml_file_doc, nonEscapingTagNames);
}
super.dispose();
}
//******************INNER CLASSES including LISTENERS and STREAMGOBBLERS****************//
/**
* A textarea with the line number next to each line of the text
*/
public class NumberedJTextArea extends RSyntaxTextArea /* JTextArea */
{
public void paintComponent(Graphics g)
{
Insets insets = getInsets();
Rectangle rectangle = g.getClipBounds();
g.setColor(Color.white);
g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
super.paintComponent(g);
if (rectangle.x < insets.left)
{
FontMetrics font_metrics = g.getFontMetrics();
int font_height = font_metrics.getHeight();
int y = font_metrics.getAscent() + insets.top;
int line_number_start_point = ((rectangle.y + insets.top) / font_height) + 1;
if (y < rectangle.y)
{
y = line_number_start_point * font_height - (font_height - font_metrics.getAscent());
}
int y_axis_end_point = y + rectangle.height + font_height;
int x_axis_start_point = insets.left;
x_axis_start_point -= getFontMetrics(getFont()).stringWidth(Math.max(getRows(), getLineCount() + 1) + " ");
if (!this.getText().trim().equals(""))
{
g.setColor(Color.DARK_GRAY);
}
else
{
g.setColor(Color.white);
}
int length = ("" + Math.max(getRows(), getLineCount() + 1)).length();
while (y < y_axis_end_point)
{
g.drawString(line_number_start_point + " ", x_axis_start_point, y);
y += font_height;
line_number_start_point++;
}
}
}
public Insets getInsets()
{
Insets insets = super.getInsets(new Insets(0, 0, 0, 0));
insets.left += getFontMetrics(getFont()).stringWidth(Math.max(getRows(), getLineCount() + 1) + " ");
return insets;
}
}
// windowClosing() is called when the user presses the top-right close button the dialog
// this means the user wanted to cancel out of the entire Format Conversion Wizard.
private class WindowClosingListener extends WindowAdapter {
public void windowClosing(WindowEvent e) {
dlgResult = OpenCollectionDialog.CANCEL_OPTION;
}
}
private class ReconvertListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
String gs2formatstr = singleLine(gs2_textarea.getText());
String errorMsg = processFormatStatement(current_index, gs2formatstr);
gs3_textarea.setText( removeSurroundingTags(getGS3FormatString(current_index)) );
if(!errorMsg.equals("")) {
setErrorStatus(errorMsg);
} else {
statusbar.setText("");
}
}
}
private class NextButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
//statusbar.setText("");
// check if the GS3 format statement is valid XML before storing. If not, let user to decide
// whether they want to re-edit it or if they want to keep it as-is, in which case it needs
// to be stored as CDATA, which will make it an inactive format statement.
// See http://www.w3schools.com/xml/xml_cdata.asp
// setGS3Format() already stores invalidXML as CDATA.
// Check if the GS3 format statement is valid XML before storing. If not, let the
// user to decide whether they want to re-edit it or store it as-is and continue
// user okay-ed the lines currently displayed, store them
setGS2Format( current_index, singleLine(gs2_textarea.getText()) );
boolean parse_success = setGS3Format( current_index, addSurroundingTags(gs3_textarea.getText()) );
if(!parse_success) { // invalid XML, warn the user
String message = Dictionary.get("FormatConversionDialog.Invalid_XML") + " " + Dictionary.get("FormatConversionDialog.Cancel_Or_Continue_Next");
int user_choice = JOptionPane.showConfirmDialog(FormatConversionDialog.this, message, WARNING_TITLE, JOptionPane.OK_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);
if(user_choice == JOptionPane.CANCEL_OPTION) {
return; // do nothing on this NextButton press. Don't increment. Let user re-adjust invalid XML for GS3 statement.
}
}
if(increment()) {
repaint();
} else {
next_button.setEnabled(false);
getRootPane().setDefaultButton(accept_all_button);
}
}
}
private class CancelButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
dlgResult = OpenCollectionDialog.CANCEL_OPTION;
FormatConversionDialog.this.dispose(); // close dialog
}
}
private class AcceptAllButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
//statusbar.setText("");
// user okay-ed the lines, store them
setGS2Format(current_index, gs2_textarea.getText());
String gs3formatstr = gs3_textarea.getText();
boolean parse_success = setGS3Format(current_index, addSurroundingTags(gs3formatstr));
String message = "";
if(!parse_success) { // invalid XML for current format statement, warn the user
setErrorStatus(Dictionary.get("FormatConversionDialog.Invalid_XML"));
message = Dictionary.get("FormatConversionDialog.Invalid_XML") + " " + Dictionary.get("FormatConversionDialog.Cancel_Or_Continue_Next");
}
// Even if the current GS3 format statement is valid XML, the user could have pressed
// Accept All at the very start of the FormatConversion dialog too. Check all the
// subsequent format statements, and if any have invalid XML, warn user.
for(int i = current_index+1; parse_success && i < gsf_format_gs2_list.getLength(); i++) {
gs3formatstr = getGS3FormatString(i);
String validationMsg = XMLTools.parseDOM(gs3formatstr);
if(!validationMsg.startsWith(XMLTools.WELLFORMED)) {
parse_success = false;
message = Dictionary.get("FormatConversionDialog.Cancel_Or_Accept_All");
}
}
if(!parse_success) {
int user_choice = JOptionPane.showConfirmDialog(FormatConversionDialog.this, message, WARNING_TITLE, JOptionPane.OK_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);
if(user_choice == JOptionPane.CANCEL_OPTION) {
return; // Don't close the dialog. Let the user continue looking at this or subsequent GS3 format statements.
}
}
// If we're here, then either the format statements parsed, or the user accepted them anyway
FormatConversionDialog.this.dispose(); // close dialog
}
}
private class XMLTidyButtonListener implements ActionListener {
// run HTML tidy taking input from stdin
// http://www.w3.org/People/Raggett/tidy/
public void actionPerformed(ActionEvent e) {
String gs3formatstr_notags = gs3_textarea.getText();
// Flag to determine which tags that HTML tidy adds need to be removed
boolean startsWithTableCell = (gs3formatstr_notags.trim().toLowerCase().startsWith("= 2) {
System.err.println("@@@ Process exit value: " + process_exitValue);
setErrorStatus(Dictionary.get("FormatConversionDialog.Tidy_Failed"));
} else {
gs3formatstr_notags = htmltidy_string;
// HTML tidy adds extra HTML markup around the formatstring, so will need to remove it:
gs3formatstr_notags = removeHTMLTags(current_index, gs3formatstr_notags, startsWithTableCell);
// put the XML tags around the gs3 format string again so we can convert it to a DOM object
String gs3formatstr = addSurroundingTags(gs3formatstr_notags);
boolean parse_success = setGS3Format(current_index, gs3formatstr); // converts to DOM object
// Get indented GS3 format string from DOM object and display it in the text area
gs3_textarea.setText( removeSurroundingTags(getGS3FormatString(current_index)) );
if(parse_success) {
statusbar.setText(Dictionary.get("FormatConversionDialog.Tidy_Done"));
} else {
setErrorStatus(Dictionary.get("FormatConversionDialog.Tidy_Done")
+ " " + Dictionary.get("FormatConversionDialog.Error_GS3_Format")
+ " " + Dictionary.get("FormatConversionDialog.Invalid_XML"));
}
}
}
}
// http://www.javaworld.com/article/2071275/core-java/when-runtime-exec---won-t.html?page=2
class ReadStreamGobbler extends Thread
{
InputStream is = null;
StringBuffer outputstr = new StringBuffer();
boolean split_newlines = false;
public ReadStreamGobbler(InputStream is)
{
this.is = is;
split_newlines = false;
}
public ReadStreamGobbler(InputStream is, boolean split_newlines)
{
this.is = is;
this.split_newlines = split_newlines;
}
public void run()
{
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
String line=null;
while ( (line = br.readLine()) != null) {
//System.out.println("@@@ GOT LINE: " + line);
outputstr.append(line);
if(split_newlines) {
outputstr.append("\n");
}
}
} catch (IOException ioe) {
ioe.printStackTrace();
} finally {
closeResource(br);
}
}
public String getOutput() {
return outputstr.toString(); // implicit toString() call anyway. //return outputstr;
}
}
class SendStreamGobbler extends Thread
{
OutputStream os = null;
String inputstr = "";
public SendStreamGobbler(OutputStream os, String inputstr)
{
this.os = os;
this.inputstr = inputstr;
}
public void run()
{
BufferedWriter osw = null;
try {
osw = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
//System.out.println("@@@ SENDING LINE: " + inputstr);
osw.write(inputstr, 0, inputstr.length());
osw.newLine();//osw.write("\n");
osw.flush();
// Don't explicitly send EOF when using StreamGobblers as below,
// as the EOF char is echoed to output.
// Flushing the write handle and/or closing the resource seems
// to already send EOF silently.
/*if(Utility.isWindows()) {
osw.write("\032"); // octal for Ctrl-Z, EOF on Windows
} else { // EOF on Linux/Mac is Ctrl-D
osw.write("\004"); // octal for Ctrl-D, see http://www.unix-manuals.com/refs/misc/ascii-table.html
}
osw.flush();
*/
} catch (IOException ioe) {
ioe.printStackTrace();
} finally {
closeResource(osw);
}
}
}
private class UndoListener implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
try {
if (undoManager.canUndo()) {
redo_button.setEnabled(true);
undoManager.undo();
}
if (!undoManager.canUndo()) {
undo_button.setEnabled(false);
} else {
undo_button.setEnabled(true);
}
} catch (Exception e) {
System.err.println("Exception trying to undo: " + e.getMessage());
}
}
}
private class RedoListener implements ActionListener
{
public void actionPerformed(ActionEvent evt)
{
try {
if (undoManager.canRedo()) {
undo_button.setEnabled(true); // the difference with Format4gs3Manager, and no DocumentListener
undoManager.redo();
}
if (!undoManager.canRedo()) {
redo_button.setEnabled(false);
} else {
redo_button.setEnabled(true);
}
} catch (Exception e) {
System.err.println("Exception trying to redo: " + e.getMessage());
}
}
}
private class CustomUndoableEditListener implements UndoableEditListener {
public void undoableEditHappened(UndoableEditEvent evt)
{
undoManager.addEdit(evt.getEdit());
redo_button.setEnabled(false);
undo_button.setEnabled(true);
}
}
}