litvinovg/w2phtml
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases 21 Packages Wiki Activity Actions

Removed batch converter

Browse source
This commit is contained in:
Georgy Litvinov 2020-07-30 12:07:04 +02:00
parent 9e55ee53a5
commit 5ba4cfabe7
5 changed files with 25 additions and 575 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

57
src/main/java/w2phtml/Application.java
View file

@ -37,7 +37,7 @@ import java.util.Hashtable;
import java.util.Set;
import java.util.Vector;
import w2phtml.api.BatchConverter;
import pro.litvinovg.w2phtml.gui.ConfigurationWindow;
import w2phtml.api.Converter;
import w2phtml.api.ConverterFactory;
import w2phtml.api.ConverterResult;
@ -83,6 +83,10 @@ public final class Application {
* @param args The argument passed on the command line.
*/
public static final void main (String[] args){
if (args.length == 0) {
showUsage("");
ConfigurationWindow.runGUI(null);
} else {
try {
//long time = System.currentTimeMillis();
Application app = new Application();
@ -95,16 +99,17 @@ public final class Application {
}
}
}
// Convert the directory or file
private void doConversion() {
sayHello();
File source = new File(sSource);
examineSource(source);
boolean bBatch = source.isDirectory();
// Step 3: Examine target
File target;
target = examineTarget(source, bBatch);
target = examineTarget(source);
// Step 4: Create converters
Converter converter = ConverterFactory.createConverter(sTargetMIME);
@ -113,15 +118,6 @@ public final class Application {
System.exit(1);
}
BatchConverter batchCv = null;
if (bBatch) {
batchCv = ConverterFactory.createBatchConverter(MIMETypes.XHTML);
if (batchCv==null) {
System.out.println("Failed to create batch converter");
System.exit(1);
}
batchCv.setConverter(converter);
}
// Step 5a: Read template
if (sTemplateFileName!=null) {
@ -129,10 +125,6 @@ public final class Application {
System.out.println("Reading template "+sTemplateFileName);
byte [] templateBytes = Misc.inputStreamToByteArray(new FileInputStream(sTemplateFileName));
converter.readTemplate(new ByteArrayInputStream(templateBytes));
if (batchCv!=null) {
// Currently we use the same template for the directory and the files
batchCv.readTemplate(new ByteArrayInputStream(templateBytes));
}
}
catch (FileNotFoundException e) {
System.out.println("--> This file does not exist!");
@ -204,10 +196,7 @@ public final class Application {
try {
byte[] configBytes = Misc.inputStreamToByteArray(new FileInputStream(sConfigFileName));
converter.getConfig().read(new ByteArrayInputStream(configBytes));
if (bBatch) {
// Currently we use the same configuration for the directory and the files
batchCv.getConfig().read(new ByteArrayInputStream(configBytes));
}
}
catch (IOException e) {
System.err.println("--> Failed to read the configuration!");
@ -222,16 +211,11 @@ public final class Application {
String sKey = keys.nextElement();
String sValue = (String) options.get(sKey);
converter.getConfig().setOption(sKey,sValue);
if (batchCv!=null) {
batchCv.getConfig().setOption(sKey,sValue);
}
}
// Step 8: Perform conversion
if (bBatch) {
batchCv.convert(source,target,bRecurse, new BatchHandlerImpl());
}
else {
System.out.println("Converting "+source.getPath());
ConverterResult dataOut = null;
@ -263,33 +247,24 @@ public final class Application {
System.exit(1);
}
}
// Step 9: Say goodbye!
System.out.println("Done!");
}
private File examineTarget(File source, boolean bBatch) {
private File examineTarget(File source) {
File target;
if (bBatch) {
if (sTarget==null) {
target=source;
}
else {
target = new File(sTarget);
}
}
else {
if (sTarget == null) {
target = new File(source.getParent(), Misc.removeExtension(source.getName()));
}
else {
} else {
target = new File(sTarget);
if (sTarget.endsWith(File.separator)) {
target = new File(target, Misc.removeExtension(source.getName()));
}
}
}
return target;
}

95
src/main/java/w2phtml/api/BatchConverter.java
View file

@ -1,95 +0,0 @@
/************************************************************************
*
* BatchConverter.java
*
* Copyright: 2002-2008 by Henrik Just
*
* This file is part of Writer2LaTeX.
*
* Writer2LaTeX is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Writer2LaTeX is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Writer2LaTeX. If not, see <http://www.gnu.org/licenses/>.
*
* Version 1.0 (2008-11-23)
*
*/
package w2phtml.api;
import java.io.File;
import java.io.InputStream;
import java.io.IOException;
/** This is an interface for a converter, which offers conversion of
* all OpenDocument (or OpenOffice.org 1.x) documents in a directory
* (and optionally subdirectories), creating index pages in a specific format.
* Instances of this interface are created using the
* {@link ConverterFactory}
*/
public interface BatchConverter {
/** Get the configuration interface for this batch converter
*
* @return the configuration
*/
public Config getConfig();
/** Define a <code>Converter</code> implementation to use for
* conversion of the individual documents.
* If no converter is given, the <code>convert</code> method cannot
* convert documents (but can still create index pages).
*
* @param converter the <code>Converter</code> to use
*/
public void setConverter(Converter converter);
/** Read a template to use as a base for the index pages.
* The format of the template depends on the <code>BatchConverter</code>
* implementation.
*
* @param is an <code>InputStream</code> from which to read the template
* @throws IOException if some exception occurs while reading the template
*/
public void readTemplate(InputStream is) throws IOException;
/** Read a template to use as a base for the index pages.
* The format of the template depends on the <code>BatchConverter</code>
* implementation.
*
* @param file the file from which to read the template
* @throws IOException if the file does not exist or some exception occurs
* while reading the template
*/
public void readTemplate(File file) throws IOException;
/** Create an index page with specific entries
*
* @param sHeading a heading describing the index page
* @param entries an array of <code>IndexPageEntry</code> objects (null entries
* are allowed, and will be ignored) describing the individual directories
* and documents
*/
public OutputFile createIndexFile(String sHeading, IndexPageEntry[] entries);
/** Convert a directory using the given <code>Converter</code> (if none is given,
* all files will be ignored).
* This method fails silently if you haven't set a converter.
*
* @param source a <code>File</code> representing the directory to convert
* @param target a <code>File</code> representing the directory to contain
* the converted documents
* @param bRecurse determines wether or not to recurse into subdirectories
* @param handler a </code>BatchHandler</code>
*/
public void convert(File source, File target, boolean bRecurse, BatchHandler handler);
}

16
src/main/java/w2phtml/api/ConverterFactory.java
View file

@ -122,22 +122,6 @@ public class ConverterFactory {
return converter instanceof Converter ? (Converter) converter : null;
}
/** <p>Create a <code>BatchConverter</code> implementation which supports
* conversion into the specified MIME type</p>
* <p>The only currently supported MIME type is <code>text/html</code>
* (XHTML 1.0 strict)</p>
*
* @param sMIME the MIME type of the target format
* @return the required <code>BatchConverter</code> or null if a converter
* for the requested MIME type could not be created
*/
public static BatchConverter createBatchConverter(String sMIME) {
Object converter = null;
if (MIMETypes.XHTML.equals(sMIME)) {
converter = createInstance("w2phtml.xhtml.BatchConverterImpl");
}
return converter instanceof BatchConverter ? (BatchConverter) converter : null;
}
/** Create a <code>StarMathConverter</code> implementation
*

180
src/main/java/w2phtml/base/BatchConverterBase.java
View file

@ -1,180 +0,0 @@
/************************************************************************
*
* BatchConverterBase.java
*
* Copyright: 2002-2014 by Henrik Just
*
* This file is part of Writer2LaTeX.
*
* Writer2LaTeX is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Writer2LaTeX is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Writer2LaTeX. If not, see <http://www.gnu.org/licenses/>.
*
* Version 1.4 (2014-08-27)
*
*/
package w2phtml.base;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import w2phtml.api.BatchConverter;
import w2phtml.api.BatchHandler;
import w2phtml.api.Converter;
import w2phtml.api.ConverterResult;
import w2phtml.api.IndexPageEntry;
import w2phtml.api.OutputFile;
import w2phtml.util.Misc;
/**
* Abstract base implementation of <code>writer2latex.api.BatchConverter</code>.
* The base implementation handles the traversal of directories and files, and
* leaves the handling of indexpages to the subclass.
*/
public abstract class BatchConverterBase implements BatchConverter {
private Converter converter;
public BatchConverterBase() {
converter = null;
}
// Partial implementation of the interface
public void setConverter(Converter converter) {
this.converter = converter;
}
public void convert(File source, File target, boolean bRecurse, BatchHandler handler) {
handler.startConversion();
convertDirectory(source, target, bRecurse, source.getName(), handler);
handler.endConversion();
}
protected abstract String getIndexFileName();
// Convert files and directories in the directory indir
// (return false if conversion has been cancelled by the BatchHandler)
private boolean convertDirectory(File indir, File outdir, boolean bRecurse, String sHeading, BatchHandler handler) {
handler.startDirectory(indir.getPath());
// Step 1: Get the directory
File[] contents = indir.listFiles();
int nLen = contents.length;
IndexPageEntry[] entries = new IndexPageEntry[nLen];
// Step 2: Traverse subdirectories, if allowed
if (bRecurse) {
String sUplink = getConfig().getOption("uplink");
for (int i=0; i<nLen; i++) {
if (contents[i].isDirectory()) {
getConfig().setOption("uplink","../"+getIndexFileName());
File newOutdir = new File(outdir,contents[i].getName());
String sNewHeading = sHeading + " - " + contents[i].getName();
boolean bResult = convertDirectory(contents[i],newOutdir,bRecurse,sNewHeading,handler);
getConfig().setOption("uplink", sUplink);
if (!bResult) { return false; }
// Create entry for this subdirectory
IndexPageEntry entry = new IndexPageEntry(Misc.makeHref(contents[i].getName()+"/"+getIndexFileName()),true);
entry.setDisplayName(contents[i].getName());
entries[i]=entry;
}
}
}
// Step 3: Traverse documents, if we have a converter
if (converter!=null) {
String sUplink = getConfig().getOption("uplink");
for (int i=0; i<nLen; i++) {
if (contents[i].isFile()) {
getConfig().setOption("uplink",getIndexFileName());
String sLinkFile = convertFile(contents[i],outdir,handler);
getConfig().setOption("uplink", sUplink);
if (sLinkFile!=null) {
// Create entry for this file
IndexPageEntry entry = new IndexPageEntry(Misc.makeHref(sLinkFile),false);
entry.setDisplayName(Misc.removeExtension(sLinkFile));
entries[i]=entry;
if (handler.cancel()) { return false; }
}
}
}
}
// Step 4: Create and write out the index file
OutputFile indexFile = createIndexFile(sHeading, entries);
if (!outdir.exists()) { outdir.mkdirs(); }
boolean bSuccess = true;
File outfile = new File(outdir,indexFile.getFileName());
try {
FileOutputStream fos = new FileOutputStream(outfile);
indexFile.write(fos);
fos.flush();
fos.close();
} catch (Exception writeExcept) {
bSuccess = false;
}
handler.endDirectory(indir.getPath(), bSuccess);
return !handler.cancel();
}
// Convert a single file, returning the name of the master file
// Returns null if conversion fails
private String convertFile(File infile, File outdir, BatchHandler handler) {
handler.startFile(infile.getPath());
// Currently we discriminate based on file extension
if (!(infile.getName().endsWith(".odt") || infile.getName().endsWith(".ods") || infile.getName().endsWith(".odp"))) {
handler.endFile(infile.getPath(),false);
return null;
}
// Do conversion
ConverterResult dataOut = null;
try {
// The target file name is always the same as the source
dataOut = converter.convert(infile,Misc.removeExtension(infile.getName()));
}
catch (FileNotFoundException e) {
handler.endFile(infile.getPath(),false);
return null;
}
catch (IOException e) {
handler.endFile(infile.getPath(),false);
return null;
}
// Write out files
if (!outdir.exists()) { outdir.mkdirs(); }
try {
dataOut.write(outdir);
}
catch (IOException e) {
handler.endFile(infile.getPath(),false);
return null;
}
handler.endFile(infile.getPath(),true);
return dataOut.iterator().next().getFileName();
}
}

234
src/main/java/w2phtml/xhtml/BatchConverter.java
View file

@ -1,234 +0,0 @@
/************************************************************************
*
* BatchConverterImpl.java
*
* Copyright: 2002-2010 by Henrik Just
*
* This file is part of Writer2LaTeX.
*
* Writer2LaTeX is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Writer2LaTeX is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Writer2LaTeX. If not, see <http://www.gnu.org/licenses/>.
*
* Version 1.2 (2010-04-23)
*
*/
package w2phtml.xhtml;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.util.Locale;
import java.text.Collator;
import org.w3c.dom.Element;
import w2phtml.api.IndexPageEntry;
import w2phtml.api.OutputFile;
import w2phtml.base.BatchConverterBase;
import w2phtml.xhtml.l10n.L10n;
/**
* Implementation of <code>writer2latex.api.BatchConverter</code> for
* xhtml 1.0 strict
*/
public class BatchConverter extends BatchConverterBase {
private XhtmlConfig config;
private XhtmlDocument template;
private String sDefaultLang;
private String sDefaultCountry;
private L10n l10n;
public BatchConverter() {
super();
config = new XhtmlConfig();
template = null;
l10n = new L10n();
sDefaultLang = System.getProperty("user.language");
sDefaultCountry = System.getProperty("user.country");
l10n.setLocale(sDefaultLang, sDefaultCountry);
}
// Implementation of the remaining (xhtml specific) parts of the interface
public w2phtml.api.Config getConfig() {
return config;
}
public void readTemplate(InputStream is) throws IOException {
template = new XhtmlDocument("Template",XhtmlDocument.XHTML10);
try {
template.read(is);
}
catch (IOException e) {
template = null;
throw e;
}
}
public void readTemplate(File file) throws IOException {
readTemplate(new FileInputStream(file));
}
protected String getIndexFileName() {
return "index.html";
}
public OutputFile createIndexFile(String sHeading, IndexPageEntry[] entries) {
// Create the index page (with header/footer or from template)
XhtmlDocument htmlDoc = new XhtmlDocument("index",XhtmlDocument.XHTML10);
htmlDoc.setConfig(config);
if (template!=null) { htmlDoc.readFromTemplate(template); }
else { htmlDoc.createHeaderFooter(); }
org.w3c.dom.Document htmlDOM = htmlDoc.getContentDOM();
Element head = htmlDoc.getHeadNode();
if (head!=null) {
// Declare charset (we need this for xhtml because we have no <?xml ... ?>)
Element meta = htmlDOM.createElement("meta");
meta.setAttribute("http-equiv","Content-Type");
meta.setAttribute("content","text/html; charset="+htmlDoc.getEncoding().toLowerCase());
head.appendChild(meta);
// Add link to stylesheet
if (config.xhtmlCustomStylesheet().length()>0) {
Element htmlStyle = htmlDOM.createElement("link");
htmlStyle.setAttribute("rel","stylesheet");
htmlStyle.setAttribute("type","text/css");
htmlStyle.setAttribute("media","all");
htmlStyle.setAttribute("href",config.xhtmlCustomStylesheet());
head.appendChild(htmlStyle);
}
}
// Add uplink to header and footer
Element header = htmlDoc.getHeaderNode();
if (header!=null) {
if (config.getXhtmlUplink().length()>0) {
Element a = htmlDOM.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(htmlDOM.createTextNode(l10n.get(L10n.UP)));
header.appendChild(a);
}
else {
header.appendChild(htmlDOM.createTextNode(l10n.get(L10n.UP)));
}
}
Element footer = htmlDoc.getFooterNode();
if (footer!=null) {
if (config.getXhtmlUplink().length()>0) {
Element a = htmlDOM.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(htmlDOM.createTextNode(l10n.get(L10n.UP)));
footer.appendChild(a);
}
else {
footer.appendChild(htmlDOM.createTextNode(l10n.get(L10n.UP)));
}
}
// Add title and heading
Element title = htmlDoc.getTitleNode();
if (title!=null) {
title.appendChild(htmlDOM.createTextNode(sHeading));
}
Element h1 = htmlDOM.createElement("h1");
htmlDoc.getContentNode().appendChild(h1);
h1.appendChild(htmlDOM.createTextNode(sHeading));
// Sort the entries
int nLen = entries.length;
Collator collator = Collator.getInstance(new Locale(sDefaultLang,sDefaultCountry));
for (int i = 0; i<nLen; i++) {
if (entries[i]!=null) {
for (int j = i+1; j<nLen ; j++) {
if (entries[j]!=null) {
IndexPageEntry entryi = entries[i];
IndexPageEntry entryj = entries[j];
if (collator.compare(entryi.getDisplayName(), entryj.getDisplayName()) > 0) {
entries[i] = entryj;
entries[j] = entryi;
}
}
}
}
}
// Insert directory entries
boolean bUseIcon = config.getXhtmlDirectoryIcon().length()>0;
for (int i=0; i<nLen; i++) {
if (entries[i]!=null && entries[i].isDirectory()) {
Element p = htmlDOM.createElement("p");
htmlDoc.getContentNode().appendChild(p);
if (bUseIcon) {
Element img = htmlDOM.createElement("img");
p.appendChild(img);
img.setAttribute("src",config.getXhtmlDirectoryIcon());
img.setAttribute("alt",l10n.get(L10n.DIRECTORY));
p.appendChild(htmlDOM.createTextNode(" "));
}
Element a = htmlDOM.createElement("a");
p.appendChild(a);
a.setAttribute("href",entries[i].getFile());
a.appendChild(htmlDOM.createTextNode(entries[i].getDisplayName()));
}
}
// Insert document entries
bUseIcon = config.getXhtmlDocumentIcon().length()>0;
for (int i=0; i<nLen; i++) {
if (entries[i]!=null && !entries[i].isDirectory()) {
Element p = htmlDOM.createElement("p");
htmlDoc.getContentNode().appendChild(p);
if (bUseIcon) {
Element img = htmlDOM.createElement("img");
p.appendChild(img);
img.setAttribute("src",config.getXhtmlDocumentIcon());
img.setAttribute("alt",l10n.get(L10n.DOCUMENT));
p.appendChild(htmlDOM.createTextNode(" "));
}
// Add link to html file
if (entries[i].getFile()!=null) {
Element a = htmlDOM.createElement("a");
p.appendChild(a);
a.setAttribute("href",entries[i].getFile());
a.appendChild(htmlDOM.createTextNode(entries[i].getDisplayName()));
}
else {
p.appendChild(htmlDOM.createTextNode(entries[i].getDisplayName()));
}
// Add link to pdf file
if (entries[i].getPdfFile()!=null) {
p.appendChild(htmlDOM.createTextNode(" "));
Element pdfa = htmlDOM.createElement("a");
p.appendChild(pdfa);
pdfa.setAttribute("href",entries[i].getPdfFile());
pdfa.appendChild(htmlDOM.createTextNode("pdf"));
}
// TODO: Add link to original file if defined
// Add description if available
if (entries[i].getDescription()!=null) {
p.appendChild(htmlDOM.createTextNode(": "+entries[i].getDescription()));
}
}
}
return htmlDoc;
}
}