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

git-svn-id: svn://svn.code.sf.net/p/writer2latex/code/trunk@26 f0f2a975-2e09-46c8-9428-3b39399b9f3c

Browse source
This commit is contained in:
henrikjust 2009-07-03 08:28:43 +00:00
parent 574e550311
commit 9e78c8fc3d
11 changed files with 932 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
source/distro/doc/user-manual.odt
View file

Binary file not shown.

333
source/java/org/openoffice/da/comp/w2lcommon/tex/tokenizer/Mouth.java Normal file
View file

@ -0,0 +1,333 @@
/************************************************************************
*
* Mouth.java
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Copyright: 2002-2009 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2009-06-18)
*
*/
package org.openoffice.da.comp.w2lcommon.tex.tokenizer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
enum State {
N, // new line
M, // middle of line
S; // ignoring spaces
}
/** <p>The Mouth is the main class of this package. It is a tokenizer to TeX files: According to "The TeXBook", the
* "eyes" and "mouth" of TeX are responsible for turning the input to TeX into a sequence of tokens.
* We are not going to reimplement TeX, but rather providing a service for parsing high-level languages based on
* TeX (eg. LaTeX, ConTeXt). For this reason the tokenizer deviates slightly from TeX: We're not reading a stream
* of bytes but rather a stream of characters (which makes no difference for ASCII files).</p>
*
* <p>In tribute to Donald E. Knuths digestive metaphors, we divide the process in four levels</p>
* <ul>
* <li>The parser should provide a <em>pair of glasses</em> to translate the stream of bytes into a stream of characters</li>
* <li>The <em>eyes</em> sees the stream of characters as a sequence of lines</li>
* <li>The <em>mouth</em> chews a bit on the characters to turn them into tokens</li>
* <li>The <em>tongue</em> reports the "taste" of the token to the parser</li>
* </ul>
*/
public class Mouth {
private Reader reader; // The input
private CatcodeTable catcodes; // The current catcode table
private char cEndlinechar; // The current value of \endlinechar
private Token token; // The token object
private State state; // The current state of the tokenizer
private Eyes eyes; // sic!
/** Construct a new <code>Mouth</code> based on a character stream
*
* @param reader the character stream to tokenize
* @throws IOException if we fail to read the character stream
*/
public Mouth(Reader reader) throws IOException {
this.reader = reader;
catcodes = new CatcodeTable();
cEndlinechar = '\r';
token = new Token();
state = State.N;
eyes = new Eyes();
}
private class Eyes {
private BufferedReader br; // The inpuy
private String sLine; // The current line
private int nLen; // The length of the current line
private int nIndex; // The current index in the current line
Eyes() throws IOException {
br = new BufferedReader(reader);
nextLine();
}
/** Start looking at the next line of input
*
* @throws IOException if we fail to read the underlying stream
*/
void nextLine() throws IOException {
sLine = br.readLine();
if (sLine!=null) {
nLen = sLine.length();
nIndex = 0;
// Delete trailing spaces
while (nLen>0 && sLine.charAt(nLen-1)==' ') { nLen--; }
}
else { // end of stream
nLen = 0;
nIndex = 1;
}
}
/** Test whether the eyes are looking at a character
*
* @return true if the current line still has characters to look at
*/
boolean lookingAtChar() {
return nIndex<=nLen;
}
/** Test whether the eyes a looking at a line
*
* @return true if a current line is available
*/
boolean lookingAtLine() {
return sLine!=null;
}
/** Get the character that the eyes currently sees
*
* @return the character or U+FFFF if the eyes are not looking at a character
*/
char peekChar() {
return getChar(false);
}
/** Get the character that the eyes currently sees and start looking at the next character
*
* @return the character or U+FFFF if the eyes are not looking at a character
*/
char getChar() {
return getChar(true);
}
private char getChar(boolean bMove) {
if (nIndex<nLen) {
char c = sLine.charAt(nIndex);
if (catcodes.get(c)==Catcode.SUPERSCRIPT && nIndex+2<nLen && catcodes.get(sLine.charAt(nIndex+1))==Catcode.SUPERSCRIPT) {
// Found ^^ and at least one more character
char c1 = sLine.charAt(nIndex+2);
if (nIndex+3<nLen && isHex(c1)) {
char c2 = sLine.charAt(nIndex+3);
if (isHex(c2)) {
// Found ^^ and a lower case hexidecimal number
if (bMove) { nIndex+=4; }
char[] digits = {c1, c2};
return (char) Integer.parseInt(new String(digits), 16);
}
}
else if (c1<128) {
// Found ^^ and an ASCII character
if (bMove) { nIndex+=3; }
if (c1<64) { return (char)(c1+64); }
else { return (char)(c1-64); }
}
}
// Found an ordinary character!
if (bMove) { nIndex++; }
return c;
}
else if (nIndex==nLen) {
// Add \endlinechar at the end of the line
if (bMove) { nIndex++; }
return cEndlinechar;
}
else {
// No more characters on the current line
return '\uFFFF';
}
}
private boolean isHex(char c) {
return ('0'<=c && c<='9') || ('a'<=c && c<='z');
}
}
/** Get the currently used catcode table
*
* @return the table
*/
public CatcodeTable getCatcodes() {
return catcodes;
}
/** Set the catcode table. The catcode table can be changed at any time during tokenization.
*
* @param catcodes the table
*/
public void setCatcodes(CatcodeTable catcodes) {
this.catcodes = catcodes;
}
/** Return the current value of the \endlinechar (the character added to the end of each input line)
*
* @return the character
*/
public char getEndlinechar() {
return cEndlinechar;
}
/** Set a new \endlinechar (the character added to the end of each input line). The character can be changed at
* any time during tokenization.
*
* @param c the character
*/
public void setEndlinechar(char c) {
cEndlinechar = c;
}
/** Return the object used to store the current token (the "tongue" of TeX).
* The same object is reused for all tokens, so for convenience the parser can keep a reference to the object.
* If on the other hand the parser needs to store a token list, it must explicitly clone all tokens.
*
* @return the token
*/
public Token getTokenObject() {
return token;
}
/** Get the next token
*
* @return the token (for convenince; the same object is returned by {@link Mouth#getTokenObject}).
* @throws IOException if we fail to read the underlying stream
*/
public Token getToken() throws IOException {
while (eyes.lookingAtLine()) {
while (eyes.lookingAtChar()) {
char c = eyes.getChar();
switch (catcodes.get(c)) {
case ESCAPE:
token.setType(TokenType.COMMAND_SEQUENCE);
token.clearChars();
// TODO: The description in the TeXBook is not completely clear,
// (as long as \r and no other character has catcode END_OF_LINE this should be correct)
if (catcodes.get(eyes.peekChar())==Catcode.LETTER) {
state = State.S;
while (eyes.lookingAtChar() && catcodes.get(eyes.peekChar())==Catcode.LETTER) {
token.addChar(eyes.getChar());
}
}
else if (catcodes.get(eyes.peekChar())==Catcode.SPACE) {
state = State.S;
token.setChar(eyes.getChar());
}
else if (catcodes.get(eyes.peekChar())!=Catcode.END_OF_LINE) {
state = State.M;
token.setChar(eyes.getChar());
}
else {
// Empty control sequence
state = State.M;
}
return token;
case BEGIN_GROUP:
token.set(c, TokenType.BEGIN_GROUP);
return token;
case END_GROUP:
token.set(c, TokenType.END_GROUP);
return token;
case MATH_SHIFT:
token.set(c, TokenType.MATH_SHIFT);
return token;
case ALIGNMENT_TAB:
token.set(c, TokenType.ALIGNMENT_TAB);
return token;
case END_OF_LINE:
// Skip rest of line
while (eyes.lookingAtChar()) { eyes.getChar(); }
switch (state) {
case N:
// This terminates an empty line -> insert a \par
token.setType(TokenType.COMMAND_SEQUENCE);
token.clearChars();
token.addChar('p');
token.addChar('a');
token.addChar('r');
return token;
case M:
// Replace with a space token
token.set(' ', TokenType.SPACE);
return token;
case S:
// ignore the character
}
break;
case PARAMETER:
token.set(c, TokenType.PARAMETER);
return token;
case SUPERSCRIPT:
token.set(c, TokenType.SUPERSCRIPT);
return token;
case SUBSCRIPT:
token.set(c, TokenType.SUBSCRIPT);
return token;
case IGNORED:
// ignore this character
break;
case SPACE:
if (state==State.M) {
state=State.S;
token.set(' ', TokenType.SPACE);
return token;
}
// In state N and S the space character is ignored
break;
case LETTER:
token.set(c, TokenType.LETTER);
return token;
case OTHER:
token.set(c, TokenType.OTHER);
return token;
case ACTIVE:
token.set(c, TokenType.ACTIVE);
return token;
case COMMENT:
// Skip rest of line
while (eyes.lookingAtChar()) { eyes.getChar(); }
break;
case INVALID:
// ignore this character (should issue an error message, but we ignore that)
}
}
eyes.nextLine();
state = State.N;
}
// Nothing more to read
token.setType(TokenType.ENDINPUT);
token.clearChars();
return token;
}
}

157
source/java/org/openoffice/da/comp/w2lcommon/tex/tokenizer/Token.java Normal file
View file

@ -0,0 +1,157 @@
/************************************************************************
*
* Token.java
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Copyright: 2002-2009 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2009-06-18)
*
*/
package org.openoffice.da.comp.w2lcommon.tex.tokenizer;
/** This class represent a token in TeX
*/
public class Token implements Cloneable {
private TokenType type;
private char[] tokenChars;
private int nTokenLen;
private int nCapacity;
/** Construct a new <code>Token</code>, initialized as a <code>TokenTYPE.ENDINPUT</code>-token
*/
public Token() {
type = TokenType.ENDINPUT;
tokenChars = new char[25];
nCapacity = 25;
nTokenLen = 0;
}
/** Set the type of this token to a specific <code>TokenType</code>
* (the character content is not changed)
*
* @param type the new <code>TokenType</code>
*/
protected void setType(TokenType type) {
this.type = type;
}
/** Set the character content of this token to a single character
* (the type of the token is not changed)
*
* @param c the character
*/
protected void setChar(char c) {
tokenChars[0] = c;
nTokenLen = 1;
}
/** Set this token as a character token with a specific <code>TokenType</code>
*
* @param c the character
* @param type the <code>TokenType</code> to use
*/
protected void set(char c, TokenType type) {
setType(type);
setChar(c);
}
/** Delete the character content of this token
*/
protected void clearChars() {
nTokenLen = 0;
}
/** Append a character to the character content of this token
*
* @param c the character to be appended
*/
protected void addChar(char c) {
if (nTokenLen == nCapacity) {
char[] temp = tokenChars;
nCapacity+=25;
tokenChars = new char[nCapacity];
System.arraycopy(temp, 0, tokenChars, 0, temp.length);
}
tokenChars[nTokenLen++] = c;
}
/** Test wether this token is a character token of the given type (that is, a single character
* with a token type that is neither <code>COMMAND_SEQUENCE</code> nor <code>ENDINPUT</code>)
*
* @param c the character to test
* @param type the <code>TokenType</code> to test
* @return true if the test was successful
*/
public boolean is(char c, TokenType type) {
return this.type==type && type!=TokenType.COMMAND_SEQUENCE && type!=TokenType.ENDINPUT &&
nTokenLen==1 && tokenChars[0]==c;
}
/** Test wether this token is a <code>COMMAND_SEQUENCE</code> token with a given name
*
* @param sName the name of the command sequence
* @return true if the test was successful
*/
public boolean isCS(String sName) {
if (type==TokenType.COMMAND_SEQUENCE && sName.length()==nTokenLen) {
for (int i=0; i<nTokenLen; i++) {
if (sName.charAt(i)!=tokenChars[i]) { return false; }
}
return true;
}
return false;
}
/** Get the <code>TokenType</code> of this token
*
* @return the type
*/
public TokenType getType() {
return type;
}
/** Get the first character in this token
*
* @return the character or U+FFFF is no characters exist
*/
public char getChar() {
return nTokenLen>0 ? tokenChars[0] : '\uFFFF';
}
/** Get the character content of this token as a string
*
* @return the character content
*/
public String getString() {
return new String(tokenChars,0,nTokenLen);
}
@Override public String toString() {
switch (type) {
case COMMAND_SEQUENCE:
return "\\"+getString();
case ENDINPUT:
return "<EOF>";
default:
return Character.toString(getChar());
}
}
}

6
source/java/org/openoffice/da/comp/writer4latex/ConfigurationDialog.java
View file

@ -20,7 +20,7 @@
* *
* All Rights Reserved. * All Rights Reserved.
* *
* Version 1.2 (2009-05-01) * Version 1.2 (2009-06-19)
* *
*/ */
@ -268,7 +268,7 @@ public final class ConfigurationDialog
externalApps.setApplication(ExternalApps.DVIPS, "dvips", "%s"); externalApps.setApplication(ExternalApps.DVIPS, "dvips", "%s");
externalApps.setApplication(ExternalApps.BIBTEX, "bibtex", "%s"); externalApps.setApplication(ExternalApps.BIBTEX, "bibtex", "%s");
externalApps.setApplication(ExternalApps.MAKEINDEX, "makeindex", "%s"); externalApps.setApplication(ExternalApps.MAKEINDEX, "makeindex", "%s");
externalApps.setApplication(ExternalApps.MK4HT, "mk4ht", "oolatex %s"); externalApps.setApplication(ExternalApps.MK4HT, "mk4ht", "%c %s");
externalApps.setApplication(ExternalApps.DVIVIEWER, "yap", "--single-instance %s"); externalApps.setApplication(ExternalApps.DVIVIEWER, "yap", "--single-instance %s");
// And assume gsview for pdf and ps // And assume gsview for pdf and ps
// gsview32 may not be in the path, but at least this helps a bit // gsview32 may not be in the path, but at least this helps a bit
@ -282,7 +282,7 @@ public final class ConfigurationDialog
configureApp(ExternalApps.DVIPS, "dvips", "%s"); configureApp(ExternalApps.DVIPS, "dvips", "%s");
configureApp(ExternalApps.BIBTEX, "bibtex", "%s"); configureApp(ExternalApps.BIBTEX, "bibtex", "%s");
configureApp(ExternalApps.MAKEINDEX, "makeindex", "%s"); configureApp(ExternalApps.MAKEINDEX, "makeindex", "%s");
configureApp(ExternalApps.MK4HT, "mk4ht", "oolatex %s"); configureApp(ExternalApps.MK4HT, "mk4ht", "%c %s");
// We have several possible viewers // We have several possible viewers
String[] sDviViewers = {"evince", "okular", "xdvi"}; String[] sDviViewers = {"evince", "okular", "xdvi"};
configureApp(ExternalApps.DVIVIEWER, sDviViewers, "%s"); configureApp(ExternalApps.DVIVIEWER, sDviViewers, "%s");

221
source/java/org/openoffice/da/comp/writer4latex/DeTeXtive.java Normal file
View file

@ -0,0 +1,221 @@
/************************************************************************
*
* DeTeXtive.java
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Copyright: 2002-2009 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2009-06-19)
*
*/
package org.openoffice.da.comp.writer4latex;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.HashSet;
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.Mouth;
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.Token;
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.TokenType;
/** This class analyzes a stream and detects if it is a TeX stream.
* Currently it is able to identify LaTeX and XeLaTeX (ConTeXt and plain TeX may be
* added later).
*/
public class DeTeXtive {
private Mouth mouth;
private Token token;
private HashSet<String> packages;
/** Construct a new DeTeXtive
*/
public DeTeXtive() {
}
/** Detect the format of a given stream
*
* @param is the input stream
* @return a string representing the detected format; null if the format is unknown.
* Currently the values "LaTeX", "XeLaTeX" are supported.
* @throws IOException if we fail to read the stream
*/
public String deTeXt(InputStream is) throws IOException {
// It makes no harm to assume that the stream uses ISO Latin1 - we only consider ASCII characters
mouth = new Mouth(new InputStreamReader(is,"ISO8859_1"));
token = mouth.getTokenObject();
packages = new HashSet<String>();
mouth.getToken();
if (parseHeader() && parsePreamble()) {
if (packages.contains("xunicode")) {
return "XeLaTeX";
}
else {
return "LaTeX";
}
}
// Unknown format
return null;
}
// The parser!
// Parse a LaTeX header such as \documentclass[a4paper]{article}
// Return true in case of success
private boolean parseHeader() throws IOException {
skipBlanks();
if (token.isCS("documentclass") || token.isCS("documentstyle")) {
// The first non-blank token is \documentclass or \documentstyle => could be a LaTeX document
System.out.println("** Found "+token.toString());
mouth.getToken();
skipSpaces();
// Skip options, if any
if (token.is('[',TokenType.OTHER)) {
skipOptional();
skipSpaces();
}
if (token.getType()==TokenType.BEGIN_GROUP) {
// Get class name
String sClassName = parseArgumentAsString();
System.out.println("** Found the class name "+sClassName);
// Accept any class name of one or more characters
if (sClassName.length()>0) { return true; }
}
}
System.out.println("** Doesn't look like LaTeX; failed to get class name");
return false;
}
// Parse a LaTeX preamble
// Return true in case of success (that is, \begin{document} was found)
private boolean parsePreamble() throws IOException {
while (token.getType()!=TokenType.ENDINPUT) {
if (token.isCS("usepackage")) {
// We collect the names of all used packages, but discard their options
// (Recall that this is only relevant for LaTeX 2e)
mouth.getToken();
skipSpaces();
if (token.is('[',TokenType.OTHER)) {
skipOptional();
skipSpaces();
}
String sName = parseArgumentAsString();
System.out.println("** Found package "+sName);
packages.add(sName);
}
else if (token.getType()==TokenType.BEGIN_GROUP) {
// We ignore anything inside a group
skipGroup();
}
else if (token.isCS("begin")) {
// This would usually indicate the end of the preamble
mouth.getToken();
skipSpaces();
if ("document".equals(parseArgumentAsString())) {
System.out.println("Found \\begin{document}");
return true;
}
}
else {
// Any other content in the preamble is simply ignored
mouth.getToken();
}
}
System.out.println("** Doesn't look like LaTeX; failed to find \\begin{document}");
return false;
}
private void skipBlanks() throws IOException {
while (token.getType()==TokenType.SPACE || token.isCS("par")) {
mouth.getToken();
}
}
private void skipSpaces() throws IOException {
// Actually, we will never get two space tokens in a row
while (token.getType()==TokenType.SPACE) {
mouth.getToken();
}
}
private void skipOptional() throws IOException {
assert token.is('[', TokenType.OTHER);
mouth.getToken(); // skip the [
while (!token.is(']',TokenType.OTHER) && token.getType()!=TokenType.ENDINPUT) {
if (token.getType()==TokenType.BEGIN_GROUP) {
skipGroup();
}
else {
mouth.getToken(); // skip this token
}
}
mouth.getToken(); // skip the ]
}
private void skipGroup() throws IOException {
assert token.getType()==TokenType.BEGIN_GROUP;
mouth.getToken(); // skip the {
while (token.getType()!=TokenType.END_GROUP && token.getType()!=TokenType.ENDINPUT) {
if (token.getType()==TokenType.BEGIN_GROUP) {
skipGroup();
}
else {
mouth.getToken(); // skip this token
}
}
mouth.getToken(); // skip the }
}
private String parseArgumentAsString() throws IOException {
if (token.getType()==TokenType.BEGIN_GROUP) {
// Argument is contained in a group
mouth.getToken(); // skip the {
StringBuilder sb = new StringBuilder();
while (token.getType()!=TokenType.END_GROUP && token.getType()!=TokenType.ENDINPUT) {
if (token.getType()!=TokenType.COMMAND_SEQUENCE) {
// should not include cs, ignore if it happens
sb.append(token.getChar());
}
mouth.getToken();
}
mouth.getToken(); // skip the }
return sb.toString();
}
else {
// Argument is a single token
String s = "";
if (token.getType()!=TokenType.COMMAND_SEQUENCE) {
// should not include cs, ignore if it happens
s = token.getString();
}
mouth.getToken();
return s;
}
}
}

24
source/java/org/openoffice/da/comp/writer4latex/ExternalApps.java
View file

@ -20,7 +20,7 @@
* *
* All Rights Reserved. * All Rights Reserved.
* *
* Version 1.2 (2009-03-30) * Version 1.2 (2009-06-19)
* *
*/ */
@ -95,7 +95,7 @@ public class ExternalApps {
public String[] getApplication(String sAppName) { public String[] getApplication(String sAppName) {
return apps.get(sAppName); return apps.get(sAppName);
} }
/** Execute an external application /** Execute an external application
* @param sAppName the name of the application to execute * @param sAppName the name of the application to execute
* @param sFileName the file name to use * @param sFileName the file name to use
@ -104,6 +104,18 @@ public class ExternalApps {
* @return error code * @return error code
*/ */
public int execute(String sAppName, String sFileName, File workDir, boolean bWaitFor) { public int execute(String sAppName, String sFileName, File workDir, boolean bWaitFor) {
return execute(sAppName, "", sFileName, workDir, bWaitFor);
}
/** Execute an external application
* @param sAppName the name of the application to execute
* @param sCommand subcommand/option to pass to the command
* @param sFileName the file name to use
* @param workDir the working directory to use
* @param bWaitFor true if the method should wait for the execution to finish
* @return error code
*/
public int execute(String sAppName, String sCommand, String sFileName, File workDir, boolean bWaitFor) {
// Assemble the command // Assemble the command
String[] sApp = getApplication(sAppName); String[] sApp = getApplication(sAppName);
if (sApp==null) { return 1; } if (sApp==null) { return 1; }
@ -113,19 +125,13 @@ public class ExternalApps {
command.add(sApp[0]); command.add(sApp[0]);
String[] sArguments = sApp[1].split(" "); String[] sArguments = sApp[1].split(" ");
for (String s : sArguments) { for (String s : sArguments) {
command.add(s.replace("%s",sFileName)); command.add(s.replace("%c",sCommand).replace("%s",sFileName));
} }
ProcessBuilder pb = new ProcessBuilder(command); ProcessBuilder pb = new ProcessBuilder(command);
//Map<String, String> env = pb.environment();
//env.put("VAR1", "myValue");
pb.directory(workDir); pb.directory(workDir);
Process proc = pb.start(); Process proc = pb.start();
//Runtime rt = Runtime.getRuntime();
//Process proc = rt.exec(sCommand, new String[0], workDir);
// Gobble the error stream of the application // Gobble the error stream of the application
StreamGobbler errorGobbler = new StreamGobbler errorGobbler = new
StreamGobbler(proc.getErrorStream(), "ERROR"); StreamGobbler(proc.getErrorStream(), "ERROR");

105
source/java/org/openoffice/da/comp/writer4latex/TeXDetectService.java
View file

@ -20,25 +20,33 @@
* *
* All Rights Reserved. * All Rights Reserved.
* *
* Version 1.2 (2009-05-20) * Version 1.2 (2009-06-19)
* *
*/ */
package org.openoffice.da.comp.writer4latex; package org.openoffice.da.comp.writer4latex;
import java.io.IOException;
import com.sun.star.lib.uno.adapter.XInputStreamToInputStreamAdapter;
import com.sun.star.lib.uno.helper.WeakBase; import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.beans.PropertyValue; import com.sun.star.beans.PropertyValue;
import com.sun.star.document.XExtendedFilterDetection; import com.sun.star.document.XExtendedFilterDetection;
import com.sun.star.task.XStatusIndicator; import com.sun.star.lang.XServiceInfo;
import com.sun.star.io.XInputStream;
import com.sun.star.ucb.XSimpleFileAccess2;
import com.sun.star.uno.AnyConverter; import com.sun.star.uno.AnyConverter;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext; import com.sun.star.uno.XComponentContext;
/** This class provides detect services for TeX documents /** This class provides detect services for TeX documents
* It is thus an implementation of the service com.sun.star.document.ExtendedTypeDetection * It is thus an implementation of the service com.sun.star.document.ExtendedTypeDetection
*/ */
public class TeXDetectService extends WeakBase implements XExtendedFilterDetection { public class TeXDetectService extends WeakBase implements XExtendedFilterDetection, XServiceInfo {
// Constants // Constants
@ -47,17 +55,40 @@ public class TeXDetectService extends WeakBase implements XExtendedFilterDetecti
public static final String __serviceName = "com.sun.star.document.ExtendedTypeDetection"; public static final String __serviceName = "com.sun.star.document.ExtendedTypeDetection";
private static final String[] m_serviceNames = { __serviceName }; private static final String[] m_serviceNames = { __serviceName };
// The type names
private static final String LATEX_FILE = "org.openoffice.da.writer4latex.LaTeX_File";
private static final String XELATEX_FILE = "org.openoffice.da.writer4latex.XeLaTeX_File";
// From constructor+initialization // From constructor+initialization
private final XComponentContext m_xContext; private final XComponentContext m_xContext;
/** Construct a new <code>TeXDetectService</code> /** Construct a new <code>TeXDetectService</code>
* *
* @param xContext The Component Context * @param xContext The Component Context
*/ */
public TeXDetectService( XComponentContext xContext ) { public TeXDetectService( XComponentContext xContext ) {
m_xContext = xContext; m_xContext = xContext;
} }
// Implement com.sun.star.lang.XServiceInfo:
public String getImplementationName() {
return __implementationName;
}
public boolean supportsService( String sService ) {
int len = m_serviceNames.length;
for(int i=0; i < len; i++) {
if (sService.equals(m_serviceNames[i]))
return true;
}
return false;
}
public String[] getSupportedServiceNames() {
return m_serviceNames;
}
// Implement XExtendedFilterDetection // Implement XExtendedFilterDetection
public String detect(PropertyValue[][] mediaDescriptor) { public String detect(PropertyValue[][] mediaDescriptor) {
// Read the media properties // Read the media properties
@ -80,10 +111,66 @@ public class TeXDetectService extends WeakBase implements XExtendedFilterDetecti
} }
} }
if ("org.openoffice.da.writer4latex.LaTeX_File".equals(sTypeName)) { // If there's no URL, we cannot verify the type (this should never happen on proper use of the service)
return sTypeName; if (sURL==null) {
System.out.println("No URL given!");
return "";
} }
else {
System.out.println("Asked to verify the type "+sTypeName);
// Also, we can only verify LaTeX and XeLaTeX
if (sTypeName==null || !(sTypeName.equals(LATEX_FILE) || sTypeName.equals(XELATEX_FILE))) {
return "";
}
// Initialise the file access
XSimpleFileAccess2 sfa2 = null;
try {
Object sfaObject = m_xContext.getServiceManager().createInstanceWithContext(
"com.sun.star.ucb.SimpleFileAccess", m_xContext);
sfa2 = (XSimpleFileAccess2) UnoRuntime.queryInterface(XSimpleFileAccess2.class, sfaObject);
}
catch (com.sun.star.uno.Exception e) {
// failed to get SimpleFileAccess service (should not happen)
System.out.println("Failed to get SFA service");
return "";
}
// Get the input stream
XInputStreamToInputStreamAdapter is = null;
try {
XInputStream xis = sfa2.openFileRead(sURL);
is = new XInputStreamToInputStreamAdapter(xis);
}
catch (com.sun.star.ucb.CommandAbortedException e) {
// Failed to create input stream, cannot verify the type
System.out.println("Failed to get input stream");
return "";
}
catch (com.sun.star.uno.Exception e) {
// Failed to create input stream, cannot verify the type
System.out.println("Failed to get input stream");
return "";
}
// Ask the deTeXtive
DeTeXtive deTeXtive = new DeTeXtive();
try {
String sType = deTeXtive.deTeXt(is);
System.out.println("The DeTeXtive returned the type "+sType);
if ("LaTeX".equals(sType)) {
return LATEX_FILE;
}
else if ("XeLaTeX".equals(sType)) {
return XELATEX_FILE;
}
else {
return "";
}
}
catch (IOException e) {
// Failed to read the stream, cannot verify the type
System.out.println("Failed to read the input stream");
return ""; return "";
} }

15
source/java/org/openoffice/da/comp/writer4latex/TeXImportFilter.java
View file

@ -20,7 +20,7 @@
* *
* All Rights Reserved. * All Rights Reserved.
* *
* Version 1.2 (2009-05-19) * Version 1.2 (2009-06-19)
* *
*/ */
@ -32,6 +32,7 @@ import java.net.URI;
import com.sun.star.lib.uno.helper.WeakBase; import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.document.XDocumentInsertable; import com.sun.star.document.XDocumentInsertable;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.task.XStatusIndicator; import com.sun.star.task.XStatusIndicator;
import com.sun.star.text.XTextCursor; import com.sun.star.text.XTextCursor;
import com.sun.star.text.XTextDocument; import com.sun.star.text.XTextDocument;
@ -48,7 +49,7 @@ import com.sun.star.document.XFilter;
/** This class implements an import filter for TeX documents using TeX4ht /** This class implements an import filter for TeX documents using TeX4ht
* It is thus an implementation of the service com.sun.star.document.ImportFilter * It is thus an implementation of the service com.sun.star.document.ImportFilter
*/ */
public class TeXImportFilter extends WeakBase implements XInitialization, XNamed, XImporter, XFilter { public class TeXImportFilter extends WeakBase implements XInitialization, XNamed, XImporter, XFilter, XServiceInfo {
// Constants // Constants
@ -282,7 +283,15 @@ public class TeXImportFilter extends WeakBase implements XInitialization, XNamed
if (xStatus!=null) { xStatus.setValue(++nStep); } if (xStatus!=null) { xStatus.setValue(++nStep); }
externalApps.execute(ExternalApps.MK4HT, file.getName(), file.getParentFile(), true); // Default is the filter org.openoffice.da.writer4latex.latex
String sCommand = "oolatex";
if ("org.openoffice.da.writer4latex.xelatex".equals(m_sFilterName)) {
sCommand = "ooxelatex";
}
System.out.println("Executing tex4ht with command "+sCommand+" on file "+file.getName());
externalApps.execute(ExternalApps.MK4HT, sCommand, file.getName(), file.getParentFile(), true);
if (xStatus!=null) { nStep+=5; xStatus.setValue(nStep); } if (xStatus!=null) { nStep+=5; xStatus.setValue(nStep); }

81
source/java/org/openoffice/da/comp/writer4latex/Writer4LaTeX.java
View file

@ -20,7 +20,7 @@
* *
* All Rights Reserved. * All Rights Reserved.
* *
* Version 1.2 (2009-05-18) * Version 1.2 (2009-06-19)
* *
*/ */
@ -505,17 +505,78 @@ public final class Writer4LaTeX extends WeakBase
String sResult = ""; String sResult = "";
for (int i=0; i<sArgument.length(); i++) { for (int i=0; i<sArgument.length(); i++) {
char c = sArgument.charAt(i); char c = sArgument.charAt(i);
if ((c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9') || c=='-' || c=='.') { if ((c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9')) {
sResult += Character.toString(c); sResult += Character.toString(c);
} }
// TODO: Create replacement table for other latin characters.. else {
else if (c==' ') { sResult += "-"; } switch (c) {
else if (c=='\u00c6') { sResult += "AE"; } case '.': sResult += "."; break;
else if (c=='\u00d8') { sResult += "OE"; } case '-': sResult += "-"; break;
else if (c=='\u00c5') { sResult += "AA"; } case ' ' : sResult += "-"; break;
else if (c=='\u00e6') { sResult += "ae"; } case '_' : sResult += "-"; break;
else if (c=='\u00f8') { sResult += "oe"; } // Replace accented and national characters
else if (c=='\u00e5') { sResult += "aa"; } case '\u00c0' : sResult += "A"; break;
case '\u00c1' : sResult += "A"; break;
case '\u00c2' : sResult += "A"; break;
case '\u00c3' : sResult += "A"; break;
case '\u00c4' : sResult += "AE"; break;
case '\u00c5' : sResult += "AA"; break;
case '\u00c6' : sResult += "AE"; break;
case '\u00c7' : sResult += "C"; break;
case '\u00c8' : sResult += "E"; break;
case '\u00c9' : sResult += "E"; break;
case '\u00ca' : sResult += "E"; break;
case '\u00cb' : sResult += "E"; break;
case '\u00cc' : sResult += "I"; break;
case '\u00cd' : sResult += "I"; break;
case '\u00ce' : sResult += "I"; break;
case '\u00cf' : sResult += "I"; break;
case '\u00d0' : sResult += "D"; break;
case '\u00d1' : sResult += "N"; break;
case '\u00d2' : sResult += "O"; break;
case '\u00d3' : sResult += "O"; break;
case '\u00d4' : sResult += "O"; break;
case '\u00d5' : sResult += "O"; break;
case '\u00d6' : sResult += "OE"; break;
case '\u00d8' : sResult += "OE"; break;
case '\u00d9' : sResult += "U"; break;
case '\u00da' : sResult += "U"; break;
case '\u00db' : sResult += "U"; break;
case '\u00dc' : sResult += "UE"; break;
case '\u00dd' : sResult += "Y"; break;
case '\u00df' : sResult += "sz"; break;
case '\u00e0' : sResult += "a"; break;
case '\u00e1' : sResult += "a"; break;
case '\u00e2' : sResult += "a"; break;
case '\u00e3' : sResult += "a"; break;
case '\u00e4' : sResult += "ae"; break;
case '\u00e5' : sResult += "aa"; break;
case '\u00e6' : sResult += "ae"; break;
case '\u00e7' : sResult += "c"; break;
case '\u00e8' : sResult += "e"; break;
case '\u00e9' : sResult += "e"; break;
case '\u00ea' : sResult += "e"; break;
case '\u00eb' : sResult += "e"; break;
case '\u00ec' : sResult += "i"; break;
case '\u00ed' : sResult += "i"; break;
case '\u00ee' : sResult += "i"; break;
case '\u00ef' : sResult += "i"; break;
case '\u00f0' : sResult += "d"; break;
case '\u00f1' : sResult += "n"; break;
case '\u00f2' : sResult += "o"; break;
case '\u00f3' : sResult += "o"; break;
case '\u00f4' : sResult += "o"; break;
case '\u00f5' : sResult += "o"; break;
case '\u00f6' : sResult += "oe"; break;
case '\u00f8' : sResult += "oe"; break;
case '\u00f9' : sResult += "u"; break;
case '\u00fa' : sResult += "u"; break;
case '\u00fb' : sResult += "u"; break;
case '\u00fc' : sResult += "ue"; break;
case '\u00fd' : sResult += "y"; break;
case '\u00ff' : sResult += "y"; break;
}
}
} }
if (sResult.length()==0) { return "writer4latex"; } if (sResult.length()==0) { return "writer4latex"; }
else { return sResult; } else { return sResult; }

12
source/oxt/writer4latex/w4l_filters.xcu
View file

@ -15,6 +15,18 @@
<prop oor:name="TemplateName"/> <prop oor:name="TemplateName"/>
</node> </node>
<node oor:name="org.openoffice.da.writer4latex.xelatex" oor:op="replace" oor:finalized="true" oor:mandatory="true">
<prop oor:name="UIName"><value>XeLaTeX</value></prop>
<prop oor:name="Type"><value>org.openoffice.da.writer4latex.XeLaTeX_File</value></prop>
<prop oor:name="DocumentService"><value>com.sun.star.text.TextDocument</value></prop>
<prop oor:name="FilterService"><value>org.openoffice.da.comp.writer4latex.TeXImportFilter</value></prop>
<prop oor:name="UIComponent"/>
<prop oor:name="Flags"><value>IMPORT TEMPLATE TEMPLATEPATH ALIEN 3RDPARTYFILTER</value></prop>
<prop oor:name="UserData"/>
<prop oor:name="FileFormatVersion"><value>0</value></prop>
<prop oor:name="TemplateName"/>
</node>
</node> </node>
</oor:component-data> </oor:component-data>

12
source/oxt/writer4latex/w4l_types.xcu
View file

@ -13,6 +13,18 @@
<prop oor:name="DetectService"><value>org.openoffice.da.comp.writer4latex.TeXDetectService</value></prop> <prop oor:name="DetectService"><value>org.openoffice.da.comp.writer4latex.TeXDetectService</value></prop>
<prop oor:name="PreferredFilter"><value>org.openoffice.da.writer4latex.latex</value></prop> <prop oor:name="PreferredFilter"><value>org.openoffice.da.writer4latex.latex</value></prop>
</node> </node>
<node oor:name="org.openoffice.da.writer4latex.XeLaTeX_File" oor:op="replace" oor:finalized="true" oor:mandatory="true">
<prop oor:name="UIName"><value>XeLaTeX File</value></prop>
<prop oor:name="MediaType"/>
<prop oor:name="ClipboardFormat"/>
<prop oor:name="URLPattern"/>
<prop oor:name="Extensions"><value>tex</value></prop>
<prop oor:name="Preferred"><value>true</value></prop>
<prop oor:name="DetectService"><value>org.openoffice.da.comp.writer4latex.TeXDetectService</value></prop>
<prop oor:name="PreferredFilter"><value>org.openoffice.da.writer4latex.xelatex</value></prop>
</node>
</node> </node>
</oor:component-data> </oor:component-data>