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

Merge w4l int w2l - part 2

Browse source 
git-svn-id: svn://svn.code.sf.net/p/writer2latex/code/trunk@191 f0f2a975-2e09-46c8-9428-3b39399b9f3c
This commit is contained in:
henrikjust 2014-10-29 20:27:54 +00:00
parent fb8e3a55b4
commit 4a038cb21c
11 changed files with 2919 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

485
source/java/org/openoffice/da/comp/writer2latex/ApplicationsDialog.java Normal file
View file

@ -0,0 +1,485 @@
/************************************************************************
*
* ApplicationsDialog.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-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.6 (2014-10-29)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Vector;
import com.sun.star.awt.XControl;
import com.sun.star.awt.XControlContainer;
import com.sun.star.awt.XControlModel;
import com.sun.star.awt.XContainerWindowEventHandler;
import com.sun.star.awt.XDialog;
import com.sun.star.awt.XDialogProvider2;
import com.sun.star.awt.XWindow;
import com.sun.star.beans.XPropertySet;
import com.sun.star.lang.XMultiComponentFactory;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.uno.AnyConverter;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.lib.uno.helper.WeakBase;
import org.openoffice.da.comp.w2lcommon.helper.DialogAccess;
import org.openoffice.da.comp.w2lcommon.helper.FilePicker;
/** This class provides a uno component which implements the configuration
* of applications for the Writer2LaTeX toolbar
*/
public final class ApplicationsDialog
extends WeakBase
implements XServiceInfo, XContainerWindowEventHandler {
private XComponentContext xContext;
private FilePicker filePicker;
private ExternalApps externalApps;
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2latex.ApplicationsDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2latex.ApplicationsDialog";
/** Create a new ApplicationsDialog */
public ApplicationsDialog(XComponentContext xContext) {
this.xContext = xContext;
externalApps = new ExternalApps(xContext);
filePicker = new FilePicker(xContext);
}
// Implement XContainerWindowEventHandler
public boolean callHandlerMethod(XWindow xWindow, Object event, String sMethod)
throws com.sun.star.lang.WrappedTargetException {
try {
if (sMethod.equals("external_event") ){
return handleExternalEvent(xWindow, event);
}
else if (sMethod.equals("ApplicationChange")) {
return changeApplication(xWindow);
}
else if (sMethod.equals("BrowseClick")) {
return browseForExecutable(xWindow);
}
else if (sMethod.equals("ExecutableUnfocus")) {
return updateApplication(xWindow);
}
else if (sMethod.equals("OptionsUnfocus")) {
return updateApplication(xWindow);
}
else if (sMethod.equals("AutomaticClick")) {
return autoConfigure(xWindow);
}
}
catch (com.sun.star.uno.RuntimeException e) {
throw e;
}
catch (com.sun.star.uno.Exception e) {
throw new com.sun.star.lang.WrappedTargetException(sMethod, this, e);
}
return false;
}
public String[] getSupportedMethodNames() {
String[] sNames = { "external_event", "ApplicationChange", "BrowseClick", "ExecutableUnfocus", "OptionsUnfocus", "AutomaticClick" };
return sNames;
}
// Implement the interface XServiceInfo
public boolean supportsService(String sServiceName) {
return sServiceName.equals(__serviceName);
}
public String getImplementationName() {
return __implementationName;
}
public String[] getSupportedServiceNames() {
String[] sSupportedServiceNames = { __serviceName };
return sSupportedServiceNames;
}
// Private stuff
private boolean handleExternalEvent(com.sun.star.awt.XWindow xWindow, Object aEventObject)
throws com.sun.star.uno.Exception {
try {
String sMethod = AnyConverter.toString(aEventObject);
if (sMethod.equals("ok")) {
externalApps.save();
return true;
} else if (sMethod.equals("back") || sMethod.equals("initialize")) {
externalApps.load();
return changeApplication(xWindow);
}
}
catch (com.sun.star.lang.IllegalArgumentException e) {
throw new com.sun.star.lang.IllegalArgumentException(
"Method external_event requires a string in the event object argument.", this,(short) -1);
}
return false;
}
private boolean changeApplication(XWindow xWindow) {
String sAppName = getSelectedAppName(xWindow);
if (sAppName!=null) {
String[] s = externalApps.getApplication(sAppName);
setComboBoxText(xWindow, "Executable", s[0]);
setComboBoxText(xWindow, "Options", s[1]);
}
return true;
}
private boolean browseForExecutable(XWindow xWindow) {
String sPath = filePicker.getPath();
if (sPath!=null) {
try {
setComboBoxText(xWindow, "Executable", new File(new URI(sPath)).getCanonicalPath());
}
catch (IOException e) {
}
catch (URISyntaxException e) {
}
updateApplication(xWindow);
}
return true;
}
private boolean updateApplication(XWindow xWindow) {
String sAppName = getSelectedAppName(xWindow);
if (sAppName!=null) {
externalApps.setApplication(sAppName, getComboBoxText(xWindow, "Executable"), getComboBoxText(xWindow, "Options"));
}
return true;
}
// Unix: Test to determine whether a certain application is available in the OS
// Requires "which", hence Unix only
private boolean hasApp(String sAppName) {
try {
Vector<String> command = new Vector<String>();
command.add("which");
command.add(sAppName);
ProcessBuilder pb = new ProcessBuilder(command);
Process proc = pb.start();
// Gobble the error stream of the application
StreamGobbler errorGobbler = new
StreamGobbler(proc.getErrorStream(), "ERROR");
// Gobble the output stream of the application
StreamGobbler outputGobbler = new
StreamGobbler(proc.getInputStream(), "OUTPUT");
errorGobbler.start();
outputGobbler.start();
// The application exists if the process exits with 0
return proc.waitFor()==0;
}
catch (InterruptedException e) {
return false;
}
catch (IOException e) {
return false;
}
}
// Unix: Configure a certain application testing the availability
private boolean configureApp(String sName, String sAppName, String sArguments) {
if (hasApp(sAppName)) {
externalApps.setApplication(sName, sAppName, sArguments);
return true;
}
else {
externalApps.setApplication(sName, "???", "???");
return false;
}
}
// Unix: Configure a certain application, reporting the availability
private boolean configureApp(String sName, String sAppName, String sArguments, StringBuilder info) {
if (hasApp(sAppName)) {
externalApps.setApplication(sName, sAppName, sArguments);
info.append("Found "+sAppName+" - OK\n");
return true;
}
else {
externalApps.setApplication(sName, "???", "???");
info.append("Failed to find "+sAppName+"\n");
return false;
}
}
// Unix: Configure a certain application testing the availability
// This variant uses an array of potential apps
private boolean configureApp(String sName, String[] sAppNames, String sArguments, StringBuilder info) {
for (String sAppName : sAppNames) {
if (configureApp(sName, sAppName, sArguments)) {
info.append("Found "+sName+": "+sAppName+" - OK\n");
return true;
}
}
info.append("Failed to find "+sName+"\n");
return false;
}
// Windows: Test that the given path contains a given executable
private boolean containsExecutable(String sPath,String sExecutable) {
File dir = new File(sPath);
if (dir.exists() && dir.canRead()) {
File exe = new File(dir,sExecutable);
return exe.exists();
}
return false;
}
// Windows: Configure a certain MikTeX application
private boolean configureMikTeX(String sPath, String sName, String sAppName, String sArguments, StringBuilder info, boolean bRequired) {
File app = new File(new File(sPath),sAppName+".exe");
if (app.exists()) {
externalApps.setApplication(sName, sAppName, sArguments);
info.append(" Found "+sName+": "+sAppName+" - OK\n");
return true;
}
else if (bRequired) {
externalApps.setApplication(sName, "???", "???");
info.append(" Failed to find "+sName+"\n");
}
return false;
}
// Configure the applications automatically (OS dependent)
private boolean autoConfigure(XWindow xWindow) {
String sOsName = System.getProperty("os.name");
String sOsVersion = System.getProperty("os.version");
String sOsArch = System.getProperty("os.arch");
StringBuilder info = new StringBuilder();
info.append("Results of configuration:\n\n");
info.append("Your system identifies itself as "+sOsName+" version "+sOsVersion+ " (" + sOsArch +")\n\n");
if (sOsName.startsWith("Windows")) {
// Assume MikTeX
String sMikTeXPath = null;
String[] sPaths = System.getenv("PATH").split(";");
for (String s : sPaths) {
if (s.toLowerCase().indexOf("miktex")>-1 && containsExecutable(s,"latex.exe")) {
sMikTeXPath = s;
break;
}
}
if (sMikTeXPath==null) {
for (String s : sPaths) {
if (containsExecutable(s,"latex.exe")) {
sMikTeXPath = s;
break;
}
}
}
boolean bFoundTexworks = false;
if (sMikTeXPath!=null) {
info.append("Found MikTeX\n");
configureMikTeX(sMikTeXPath, ExternalApps.LATEX, "latex", "--interaction=batchmode %s", info, true);
configureMikTeX(sMikTeXPath, ExternalApps.PDFLATEX, "pdflatex", "--interaction=batchmode %s", info, true);
configureMikTeX(sMikTeXPath, ExternalApps.XELATEX, "xelatex", "--interaction=batchmode %s", info, true);
configureMikTeX(sMikTeXPath, ExternalApps.DVIPS, "dvips", "%s", info, true);
configureMikTeX(sMikTeXPath, ExternalApps.BIBTEX, "bibtex", "%s", info, true);
configureMikTeX(sMikTeXPath, ExternalApps.MAKEINDEX, "makeindex", "%s", info, true);
//configureMikTeX(sMikTeXPath, ExternalApps.MK4HT, "mk4ht", "%c %s", info, true);
configureMikTeX(sMikTeXPath, ExternalApps.DVIVIEWER, "yap", "--single-instance %s", info, true);
// MikTeX 2.8 provides texworks for pdf viewing
bFoundTexworks = configureMikTeX(sMikTeXPath, ExternalApps.PDFVIEWER, "texworks", "%s", info, true);
}
else {
info.append("Failed to find MikTeX\n");
info.append("Writer2LaTeX has been configured to work if MikTeX is added to your path\n");
externalApps.setApplication(ExternalApps.LATEX, "latex", "--interaction=batchmode %s");
externalApps.setApplication(ExternalApps.PDFLATEX, "pdflatex", "--interaction=batchmode %s");
externalApps.setApplication(ExternalApps.XELATEX, "xelatex", "--interaction=batchmode %s");
externalApps.setApplication(ExternalApps.DVIPS, "dvips", "%s");
externalApps.setApplication(ExternalApps.BIBTEX, "bibtex", "%s");
externalApps.setApplication(ExternalApps.MAKEINDEX, "makeindex", "%s");
//externalApps.setApplication(ExternalApps.MK4HT, "mk4ht", "%c %s");
externalApps.setApplication(ExternalApps.DVIVIEWER, "yap", "--single-instance %s");
}
info.append("\n");
// Assume gsview for pdf and ps
String sGsview = null;
String sProgramFiles = System.getenv("ProgramFiles");
if (sProgramFiles!=null) {
if (containsExecutable(sProgramFiles+"\\ghostgum\\gsview","gsview32.exe")) {
sGsview = sProgramFiles+"\\ghostgum\\gsview\\gsview32.exe";
}
}
if (sGsview!=null) {
info.append("Found gsview - OK\n");
}
else {
info.append("Failed to find gsview\n");
sGsview = "gsview32.exe"; // at least this helps a bit..
}
if (!bFoundTexworks) {
externalApps.setApplication(ExternalApps.PDFVIEWER, sGsview, "-e \"%s\"");
}
externalApps.setApplication(ExternalApps.POSTSCRIPTVIEWER, sGsview, "-e \"%s\"");
}
else { // Assume a Unix-like system supporting the "which" command
configureApp(ExternalApps.LATEX, "latex", "--interaction=batchmode %s",info);
configureApp(ExternalApps.PDFLATEX, "pdflatex", "--interaction=batchmode %s",info);
configureApp(ExternalApps.XELATEX, "xelatex", "--interaction=batchmode %s",info);
configureApp(ExternalApps.DVIPS, "dvips", "%s",info);
configureApp(ExternalApps.BIBTEX, "bibtex", "%s",info);
configureApp(ExternalApps.MAKEINDEX, "makeindex", "%s",info);
//configureApp(ExternalApps.MK4HT, "mk4ht", "%c %s",info);
// We have several possible viewers
String[] sDviViewers = {"evince", "okular", "xdvi"};
configureApp(ExternalApps.DVIVIEWER, sDviViewers, "%s",info);
String[] sPdfViewers = {"evince", "okular", "xpdf"};
configureApp(ExternalApps.PDFVIEWER, sPdfViewers, "%s",info);
String[] sPsViewers = {"evince", "okular", "ghostview"};
configureApp(ExternalApps.POSTSCRIPTVIEWER, sPsViewers, "%s",info);
}
// Maybe add some info for Ubuntu users
// sudo apt-get install texlive
// sudo apt-get install texlive-xetex
// sudo apt-get install texlive-latex-extra
// sudo apt-get install tex4ht
displayAutoConfigInfo(info.toString());
changeApplication(xWindow);
return true;
}
private String getSelectedAppName(XWindow xWindow) {
short nItem = getListBoxSelectedItem(xWindow, "Application");
//String sAppName = null;
switch (nItem) {
case 0: return ExternalApps.LATEX;
case 1: return ExternalApps.PDFLATEX;
case 2: return ExternalApps.XELATEX;
case 3: return ExternalApps.DVIPS;
case 4: return ExternalApps.BIBTEX;
case 5: return ExternalApps.MAKEINDEX;
//case 6: return ExternalApps.MK4HT;
case 6: return ExternalApps.DVIVIEWER;
case 7: return ExternalApps.PDFVIEWER;
case 8: return ExternalApps.POSTSCRIPTVIEWER;
}
return "???";
}
private XDialog getDialog(String sDialogName) {
XMultiComponentFactory xMCF = xContext.getServiceManager();
try {
Object provider = xMCF.createInstanceWithContext(
"com.sun.star.awt.DialogProvider2", xContext);
XDialogProvider2 xDialogProvider = (XDialogProvider2)
UnoRuntime.queryInterface(XDialogProvider2.class, provider);
String sDialogUrl = "vnd.sun.star.script:"+sDialogName+"?location=application";
return xDialogProvider.createDialogWithHandler(sDialogUrl, this);
}
catch (Exception e) {
return null;
}
}
private void displayAutoConfigInfo(String sText) {
XDialog xDialog = getDialog("W4LDialogs.AutoConfigInfo");
if (xDialog!=null) {
DialogAccess info = new DialogAccess(xDialog);
info.setTextFieldText("Info", sText);
xDialog.execute();
xDialog.endExecute();
}
}
// Some helpers copied from DialogBase
private XPropertySet getControlProperties(XWindow xWindow, String sControlName) {
XControlContainer xContainer = (XControlContainer)
UnoRuntime.queryInterface(XControlContainer.class, xWindow);
XControl xControl = xContainer.getControl(sControlName);
XControlModel xModel = xControl.getModel();
XPropertySet xPropertySet = (XPropertySet)
UnoRuntime.queryInterface(XPropertySet.class, xModel);
return xPropertySet;
}
private String getComboBoxText(XWindow xWindow, String sControlName) {
// Returns the text of a combobox
XPropertySet xPropertySet = getControlProperties(xWindow, sControlName);
try {
return (String) xPropertySet.getPropertyValue("Text");
}
catch (Exception e) {
// Will fail if the control does not exist or is not a combo
return "";
}
}
private void setComboBoxText(XWindow xWindow, String sControlName, String sText) {
XPropertySet xPropertySet = getControlProperties(xWindow, sControlName);
try {
xPropertySet.setPropertyValue("Text", sText);
}
catch (Exception e) {
// Will fail if the control does not exist or is not a combo box or
// nText is an illegal value
}
}
private short getListBoxSelectedItem(XWindow xWindow, String sControlName) {
// Returns the first selected element in case of a multiselection
XPropertySet xPropertySet = getControlProperties(xWindow, sControlName);
try {
short[] selection = (short[]) xPropertySet.getPropertyValue("SelectedItems");
return selection[0];
}
catch (Exception e) {
// Will fail if the control does not exist or is not a list box
return -1;
}
}
}

351
source/java/org/openoffice/da/comp/writer2latex/BibliographyDialog.java Normal file
View file

@ -0,0 +1,351 @@
/************************************************************************
*
* BibliographyDialog.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-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.6 (2014-10-29)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import com.sun.star.awt.XContainerWindowEventHandler;
import com.sun.star.awt.XDialog;
import com.sun.star.awt.XWindow;
import com.sun.star.beans.XPropertySet;
import com.sun.star.frame.XDesktop;
import com.sun.star.frame.XModel;
import com.sun.star.lang.XComponent;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.uno.AnyConverter;
import com.sun.star.uno.Exception;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.util.XChangesBatch;
import com.sun.star.lib.uno.helper.WeakBase;
import org.openoffice.da.comp.w2lcommon.helper.DialogAccess;
import org.openoffice.da.comp.w2lcommon.helper.FolderPicker;
import org.openoffice.da.comp.w2lcommon.helper.MessageBox;
import org.openoffice.da.comp.w2lcommon.helper.RegistryHelper;
import org.openoffice.da.comp.w2lcommon.helper.XPropertySetHelper;
/** This class provides a uno component which implements the configuration
* of the bibliography for the Writer2LaTeX toolbar
*/
public final class BibliographyDialog
extends WeakBase
implements XServiceInfo, XContainerWindowEventHandler {
public static final String REGISTRY_PATH = "/org.openoffice.da.Writer2LaTeX.toolbar.ToolbarOptions/BibliographyOptions";
private XComponentContext xContext;
private FolderPicker folderPicker;
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2latex.BibliographyDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2latex.BibliographyDialog";
/** Create a new ConfigurationDialog */
public BibliographyDialog(XComponentContext xContext) {
this.xContext = xContext;
folderPicker = new FolderPicker(xContext);
}
// Implement XContainerWindowEventHandler
public boolean callHandlerMethod(XWindow xWindow, Object event, String sMethod)
throws com.sun.star.lang.WrappedTargetException {
XDialog xDialog = (XDialog)UnoRuntime.queryInterface(XDialog.class, xWindow);
DialogAccess dlg = new DialogAccess(xDialog);
try {
if (sMethod.equals("external_event") ){
return handleExternalEvent(dlg, event);
}
else if (sMethod.equals("ConvertZoteroCitationsChange")) {
return convertZoteroCitationsChange(dlg);
}
else if (sMethod.equals("ConvertJabRefCitationsChange")) {
return convertJabRefCitationsChange(dlg);
}
else if (sMethod.equals("UseExternalBibTeXFilesChange")) {
return useExternalBibTeXFilesChange(dlg);
}
else if (sMethod.equals("UseNatbibChange")) {
return useNatbibChange(dlg);
}
else if (sMethod.equals("BibTeXLocationChange")) {
return bibTeXLocationChange(dlg);
}
else if (sMethod.equals("BibTeXDirClick")) {
return bibTeXDirClick(dlg);
}
}
catch (com.sun.star.uno.RuntimeException e) {
throw e;
}
catch (com.sun.star.uno.Exception e) {
throw new com.sun.star.lang.WrappedTargetException(sMethod, this, e);
}
return false;
}
public String[] getSupportedMethodNames() {
String[] sNames = { "external_event", "UseExternalBibTeXFilesChange", "ConvertZoteroCitationsChange",
"ConvertJabRefCitationsChange", "UseNatbibChange", "BibTeXLocationChange", "ExternalBibTeXDirClick" };
return sNames;
}
// Implement the interface XServiceInfo
public boolean supportsService(String sServiceName) {
return sServiceName.equals(__serviceName);
}
public String getImplementationName() {
return __implementationName;
}
public String[] getSupportedServiceNames() {
String[] sSupportedServiceNames = { __serviceName };
return sSupportedServiceNames;
}
// Private stuff
private boolean handleExternalEvent(DialogAccess dlg, Object aEventObject)
throws com.sun.star.uno.Exception {
try {
String sMethod = AnyConverter.toString(aEventObject);
if (sMethod.equals("ok")) {
saveConfiguration(dlg);
return true;
} else if (sMethod.equals("back") || sMethod.equals("initialize")) {
loadConfiguration(dlg);
enableBibTeXSettings(dlg);
useNatbibChange(dlg);
return true;
}
}
catch (com.sun.star.lang.IllegalArgumentException e) {
throw new com.sun.star.lang.IllegalArgumentException(
"Method external_event requires a string in the event object argument.", this,(short) -1);
}
return false;
}
// Load settings from the registry into the dialog
private void loadConfiguration(DialogAccess dlg) {
RegistryHelper registry = new RegistryHelper(xContext);
try {
Object view = registry.getRegistryView(REGISTRY_PATH, false);
XPropertySet xProps = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,view);
dlg.setCheckBoxStateAsBoolean("UseExternalBibTeXFiles",
XPropertySetHelper.getPropertyValueAsBoolean(xProps, "UseExternalBibTeXFiles"));
dlg.setCheckBoxStateAsBoolean("ConvertZoteroCitations",
XPropertySetHelper.getPropertyValueAsBoolean(xProps, "ConvertZoteroCitations"));
dlg.setCheckBoxStateAsBoolean("ConvertJabRefCitations",
XPropertySetHelper.getPropertyValueAsBoolean(xProps, "ConvertJabRefCitations"));
dlg.setCheckBoxStateAsBoolean("IncludeOriginalCitations",
XPropertySetHelper.getPropertyValueAsBoolean(xProps, "IncludeOriginalCitations"));
dlg.setListBoxSelectedItem("BibTeXLocation",
XPropertySetHelper.getPropertyValueAsShort(xProps, "BibTeXLocation"));
dlg.setTextFieldText("BibTeXDir",
XPropertySetHelper.getPropertyValueAsString(xProps, "BibTeXDir"));
dlg.setCheckBoxStateAsBoolean("UseNatbib",
XPropertySetHelper.getPropertyValueAsBoolean(xProps, "UseNatbib"));
dlg.setTextFieldText("NatbibOptions",
XPropertySetHelper.getPropertyValueAsString(xProps, "NatbibOptions"));
registry.disposeRegistryView(view);
}
catch (Exception e) {
// Failed to get registry view
}
// Update dialog according to the settings
convertZoteroCitationsChange(dlg);
useExternalBibTeXFilesChange(dlg);
}
// Save settings from the dialog to the registry
private void saveConfiguration(DialogAccess dlg) {
RegistryHelper registry = new RegistryHelper(xContext);
try {
Object view = registry.getRegistryView(REGISTRY_PATH, true);
XPropertySet xProps = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,view);
XPropertySetHelper.setPropertyValue(xProps, "UseExternalBibTeXFiles", dlg.getCheckBoxStateAsBoolean("UseExternalBibTeXFiles"));
XPropertySetHelper.setPropertyValue(xProps, "ConvertZoteroCitations", dlg.getCheckBoxStateAsBoolean("ConvertZoteroCitations"));
XPropertySetHelper.setPropertyValue(xProps, "ConvertJabRefCitations", dlg.getCheckBoxStateAsBoolean("ConvertJabRefCitations"));
XPropertySetHelper.setPropertyValue(xProps, "IncludeOriginalCitations", dlg.getCheckBoxStateAsBoolean("IncludeOriginalCitations"));
XPropertySetHelper.setPropertyValue(xProps, "BibTeXLocation", dlg.getListBoxSelectedItem("BibTeXLocation"));
XPropertySetHelper.setPropertyValue(xProps, "BibTeXDir", dlg.getTextFieldText("BibTeXDir"));
XPropertySetHelper.setPropertyValue(xProps, "UseNatbib", dlg.getCheckBoxStateAsBoolean("UseNatbib"));
XPropertySetHelper.setPropertyValue(xProps, "NatbibOptions", dlg.getTextFieldText("NatbibOptions"));
// Commit registry changes
XChangesBatch xUpdateContext = (XChangesBatch)
UnoRuntime.queryInterface(XChangesBatch.class,view);
try {
xUpdateContext.commitChanges();
}
catch (Exception e) {
// ignore
}
registry.disposeRegistryView(view);
}
catch (Exception e) {
// Failed to get registry view
}
}
private boolean useExternalBibTeXFilesChange(DialogAccess dlg) {
enableBibTeXSettings(dlg);
return true;
}
private boolean convertZoteroCitationsChange(DialogAccess dlg) {
enableBibTeXSettings(dlg);
return true;
}
private boolean convertJabRefCitationsChange(DialogAccess dlg) {
enableBibTeXSettings(dlg);
return true;
}
private boolean useNatbibChange(DialogAccess dlg) {
boolean bUseNatbib = dlg.getCheckBoxStateAsBoolean("UseNatbib");
dlg.setControlEnabled("NatbibOptionsLabel", bUseNatbib);
dlg.setControlEnabled("NatbibOptions", bUseNatbib);
return true;
}
private boolean bibTeXLocationChange(DialogAccess dlg) {
enableBibTeXSettings(dlg);
return true;
}
private void enableBibTeXSettings(DialogAccess dlg) {
boolean bConvertZoteroJabRef = dlg.getCheckBoxStateAsBoolean("ConvertZoteroCitations")
|| dlg.getCheckBoxStateAsBoolean("ConvertJabRefCitations");
boolean bEnableLocation = dlg.getCheckBoxStateAsBoolean("UseExternalBibTeXFiles") || bConvertZoteroJabRef;
boolean bEnableDir = dlg.getListBoxSelectedItem("BibTeXLocation")<2;
dlg.setControlEnabled("IncludeOriginalCitations", bConvertZoteroJabRef);
dlg.setControlEnabled("BibTeXLocationLabel", bEnableLocation);
dlg.setControlEnabled("BibTeXLocation", bEnableLocation);
dlg.setControlEnabled("BibTeXDirLabel", bEnableLocation && bEnableDir);
dlg.setControlEnabled("BibTeXDir", bEnableLocation && bEnableDir);
dlg.setControlEnabled("BibTeXDirButton", bEnableLocation && bEnableDir);
}
private String getDocumentDirURL() {
// Get the desktop from the service manager
Object desktop=null;
try {
desktop = xContext.getServiceManager().createInstanceWithContext("com.sun.star.frame.Desktop", xContext);
} catch (Exception e) {
// Failed to get the desktop service
return "";
}
XDesktop xDesktop = (XDesktop) UnoRuntime.queryInterface(XDesktop.class, desktop);
// Get the current component and verify that it really is a text document
if (xDesktop!=null) {
XComponent xComponent = xDesktop.getCurrentComponent();
XServiceInfo xInfo = (XServiceInfo)UnoRuntime.queryInterface(XServiceInfo.class, xComponent);
if (xInfo!=null && xInfo.supportsService("com.sun.star.text.TextDocument")) {
// Get the model, which provides the URL
XModel xModel = (XModel) UnoRuntime.queryInterface(XModel.class, xComponent);
if (xModel!=null) {
String sURL = xModel.getURL();
int nSlash = sURL.lastIndexOf('/');
return nSlash>-1 ? sURL.substring(0, nSlash) : "";
}
}
}
return "";
}
private boolean hasBibTeXFiles(File dir) {
if (dir.isDirectory()) {
File[] files = dir.listFiles();
for (File file : files) {
if (file.isFile() && file.getName().endsWith(".bib")) {
return true;
}
}
}
return false;
}
private boolean bibTeXDirClick(DialogAccess dlg) {
String sPath = folderPicker.getPath();
if (sPath!=null) {
try {
File bibDir = new File(new URI(sPath));
String sBibPath = bibDir.getCanonicalPath();
if (dlg.getListBoxSelectedItem("BibTeXLocation")==1) {
// Path relative to document directory, remove the document directory part
String sDocumentDirURL = getDocumentDirURL();
if (sDocumentDirURL.length()>0) {
String sDocumentDirPath = new File(new URI(sDocumentDirURL)).getCanonicalPath();
if (sBibPath.startsWith(sDocumentDirPath)) {
if (sBibPath.length()>sDocumentDirPath.length()) {
sBibPath = sBibPath.substring(sDocumentDirPath.length()+1);
}
else { // Same as document directory
sBibPath = "";
}
}
else { // not a subdirectory
sBibPath = "";
}
}
}
dlg.setTextFieldText("BibTeXDir", sBibPath);
if (!hasBibTeXFiles(bibDir)) {
MessageBox msgBox = new MessageBox(xContext);
msgBox.showMessage("Writer2LaTeX", "Warning: The selected directory does not contain any BibTeX files");
}
}
catch (IOException e) {
}
catch (URISyntaxException e) {
}
}
return true;
}
}

221
source/java/org/openoffice/da/comp/writer2latex/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-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.4 (2014-09-24)
*
*/
package org.openoffice.da.comp.writer2latex;
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;
}
}
}

236
source/java/org/openoffice/da/comp/writer2latex/ExternalApps.java Normal file
View file

@ -0,0 +1,236 @@
/************************************************************************
*
* ExternalApps.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-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.6 (2014-10-29)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.io.File;
import java.io.IOException;
import java.lang.Process;
import java.lang.ProcessBuilder;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
import org.openoffice.da.comp.w2lcommon.helper.RegistryHelper;
//import java.util.Map;
import com.sun.star.beans.XMultiHierarchicalPropertySet;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.util.XChangesBatch;
/** This class manages and executes external applications used by the Writer2LaTeX toolbar.
* These include TeX and friends as well as viewers for the various backend formats.
* The registry is used for persistent storage of the settings.
*/
public class ExternalApps {
public final static String LATEX = "LaTeX";
public final static String PDFLATEX = "PdfLaTeX";
public final static String XELATEX = "XeLaTeX";
public final static String BIBTEX = "BibTeX";
public final static String MAKEINDEX = "Makeindex";
public final static String MK4HT = "Mk4ht";
public final static String DVIPS = "Dvips";
public final static String DVIVIEWER = "DVIViewer";
public final static String POSTSCRIPTVIEWER = "PostscriptViewer";
public final static String PDFVIEWER = "PdfViewer";
private final static String[] sApps = { LATEX, PDFLATEX, XELATEX, BIBTEX, MAKEINDEX, MK4HT, DVIPS, DVIVIEWER, POSTSCRIPTVIEWER, PDFVIEWER };
private XComponentContext xContext;
private HashMap<String,String[]> apps;
/** Construct a new ExternalApps object, with empty definitions */
public ExternalApps(XComponentContext xContext) {
this.xContext = xContext;
apps = new HashMap<String,String[]>();
for (int i=0; i<sApps.length; i++) {
setApplication(sApps[i], "?", "?");
}
}
/** Define an external application
* @param sAppName the name of the application to define
* @param sExecutable the system dependent path to the executable file
* @param sOptions the options to the external application; %s will be
* replaced by the filename on execution
*/
public void setApplication(String sAppName, String sExecutable, String sOptions) {
String[] sValue = { sExecutable, sOptions };
apps.put(sAppName, sValue);
}
/** Get the definition for an external application
* @param sAppName the name of the application to get
* @return a String array containing the system dependent path to the
* executable file as entry 0, and the parameters as entry 1
* returns null if the application is unknown
*/
public String[] getApplication(String sAppName) {
return apps.get(sAppName);
}
/** Execute an external application
* @param sAppName the name of the application to execute
* @param sFileName the file name to use
* @param workDir the working directory to use
* @param env map of environment variables to set (or null if no variables needs to be set)
* @param bWaitFor true if the method should wait for the execution to finish
* @return error code
*/
public int execute(String sAppName, String sFileName, File workDir, Map<String,String> env, boolean bWaitFor) {
return execute(sAppName, "", sFileName, workDir, env, 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 env map of environment variables to set (or null if no variables needs to be set)
* @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, Map<String,String> env, boolean bWaitFor) {
// Assemble the command
String[] sApp = getApplication(sAppName);
if (sApp==null) { return 1; }
try {
Vector<String> command = new Vector<String>();
command.add(sApp[0]);
String[] sArguments = sApp[1].split(" ");
for (String s : sArguments) {
command.add(s.replace("%c",sCommand).replace("%s",sFileName));
}
ProcessBuilder pb = new ProcessBuilder(command);
pb.directory(workDir);
if (env!=null) {
pb.environment().putAll(env);
}
Process proc = pb.start();
// Gobble the error stream of the application
StreamGobbler errorGobbler = new
StreamGobbler(proc.getErrorStream(), "ERROR");
// Gobble the output stream of the application
StreamGobbler outputGobbler = new
StreamGobbler(proc.getInputStream(), "OUTPUT");
// Kick them off
errorGobbler.start();
outputGobbler.start();
// Any error?
return bWaitFor ? proc.waitFor() : 0;
}
catch (InterruptedException e) {
return 1;
}
catch (IOException e) {
return 1;
}
}
/** Load the external applications from the registry
*/
public void load() {
RegistryHelper registry = new RegistryHelper(xContext);
Object view;
try {
// Prepare registry view
view = registry.getRegistryView("/org.openoffice.da.Writer2LaTeX.toolbar.ToolbarOptions/Applications",false);
}
catch (com.sun.star.uno.Exception e) {
// Give up...
return;
}
XMultiHierarchicalPropertySet xProps = (XMultiHierarchicalPropertySet)
UnoRuntime.queryInterface(XMultiHierarchicalPropertySet.class, view);
for (int i=0; i<sApps.length; i++) {
String[] sNames = new String[2];
sNames[0] = sApps[i]+"/Executable";
sNames[1] = sApps[i]+"/Options";
try {
Object[] values = xProps.getHierarchicalPropertyValues(sNames);
setApplication(sApps[i], (String) values[0], (String) values[1]);
}
catch (com.sun.star.uno.Exception e) {
// Ignore...
}
}
registry.disposeRegistryView(view);
}
/** Save the external applications to the registry
*/
public void save() {
RegistryHelper registry = new RegistryHelper(xContext);
Object view;
try {
view = registry.getRegistryView("/org.openoffice.da.Writer2LaTeX.toolbar.ToolbarOptions/Applications",true);
}
catch (com.sun.star.uno.Exception e) {
// Give up...
return;
}
XMultiHierarchicalPropertySet xProps = (XMultiHierarchicalPropertySet)
UnoRuntime.queryInterface(XMultiHierarchicalPropertySet.class, view);
for (int i=0; i<sApps.length; i++) {
String[] sNames = new String[2];
sNames[0] = sApps[i]+"/Executable";
sNames[1] = sApps[i]+"/Options";
String[] sValues = getApplication(sApps[i]);
try {
xProps.setHierarchicalPropertyValues(sNames, sValues);
}
catch (com.sun.star.uno.Exception e) {
// Ignore...
}
}
// Commit registry changes
XChangesBatch xUpdateContext = (XChangesBatch)
UnoRuntime.queryInterface(XChangesBatch.class, view);
try {
xUpdateContext.commitChanges();
}
catch (Exception e) {
// ignore
}
registry.disposeRegistryView(view);
}
}

146
source/java/org/openoffice/da/comp/writer2latex/LogViewerDialog.java Normal file
View file

@ -0,0 +1,146 @@
/************************************************************************
*
* LogViewerDialog.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-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.6 (2014-10-29)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import com.sun.star.awt.XDialog;
import com.sun.star.uno.XComponentContext;
import org.openoffice.da.comp.w2lcommon.helper.DialogBase;
/** This class provides a uno component which displays logfiles
*/
public class LogViewerDialog extends DialogBase
implements com.sun.star.lang.XInitialization {
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2latex.LogViewerDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2latex.LogViewerDialog";
/** Return the name of the library containing the dialog
*/
public String getDialogLibraryName() {
return "W4LDialogs";
}
private String sBaseUrl = null;
private String sLaTeXLog = null;
private String sBibTeXLog = null;
private String sMakeindexLog = null;
/** Return the name of the dialog within the library
*/
public String getDialogName() {
return "LogViewer";
}
public void initialize() {
if (sBaseUrl!=null) {
sLaTeXLog = readTextFile(sBaseUrl+".log");
sBibTeXLog = readTextFile(sBaseUrl+".blg");
sMakeindexLog = readTextFile(sBaseUrl+".ilg");
setComboBoxText("LogContents",sLaTeXLog);
}
}
public void endDialog() {
}
/** Create a new LogViewerDialog */
public LogViewerDialog(XComponentContext xContext) {
super(xContext);
}
// Implement com.sun.star.lang.XInitialization
public void initialize( Object[] object )
throws com.sun.star.uno.Exception {
if ( object.length > 0 ) {
if (object[0] instanceof String) {
sBaseUrl = (String) object[0];
}
}
}
// Implement XDialogEventHandler
public boolean callHandlerMethod(XDialog xDialog, Object event, String sMethod) {
if (sMethod.equals("ViewLaTeXLog")) {
setComboBoxText("LogContents", sLaTeXLog);
}
else if (sMethod.equals("ViewBibTeXLog")) {
setComboBoxText("LogContents", sBibTeXLog);
}
else if (sMethod.equals("ViewMakeindexLog")) {
setComboBoxText("LogContents", sMakeindexLog);
}
return true;
}
public String[] getSupportedMethodNames() {
String[] sNames = { "ViewLaTeXLog", "ViewBibTeXLog", "ViewMakeindexLog" };
return sNames;
}
// Utility methods
private String readTextFile(String sUrl) {
StringBuilder buf = new StringBuilder();
try {
File file = new File(new URI(sUrl));
if (file.exists() && file.isFile()) {
InputStreamReader isr = new InputStreamReader(new FileInputStream(file));
int n;
do {
n = isr.read();
if (n>-1) { buf.append((char)n); }
}
while (n>-1);
isr.close();
}
}
catch (URISyntaxException e) {
return "";
}
catch (IOException e) {
return "";
}
return buf.toString();
}
}

55
source/java/org/openoffice/da/comp/writer2latex/StreamGobbler.java Normal file
View file

@ -0,0 +1,55 @@
/************************************************************************
*
* StreamGobbler.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-03-30)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.io.*;
class StreamGobbler extends Thread {
InputStream is;
String type;
StreamGobbler(InputStream is, String type) {
this.is = is;
this.type = type;
}
public void run() {
try {
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
//String line=null;
//while ( (line = br.readLine()) != null) {
while ( br.readLine() != null) {
// Do nothing...
}
}
catch (IOException ioe) {
ioe.printStackTrace();
}
}
}

174
source/java/org/openoffice/da/comp/writer2latex/TeXDetectService.java Normal file
View file

@ -0,0 +1,174 @@
/************************************************************************
*
* TeXDetectService.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-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.6 (2014-10-29)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.io.IOException;
import com.sun.star.lib.uno.adapter.XInputStreamToInputStreamAdapter;
import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.beans.PropertyValue;
import com.sun.star.document.XExtendedFilterDetection;
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.UnoRuntime;
import com.sun.star.uno.XComponentContext;
/** This class provides detect services for TeX documents
* It is thus an implementation of the service com.sun.star.document.ExtendedTypeDetection
*/
public class TeXDetectService extends WeakBase implements XExtendedFilterDetection, XServiceInfo {
// Constants
// Identify this service
public static final String __implementationName = TeXDetectService.class.getName();
public static final String __serviceName = "com.sun.star.document.ExtendedTypeDetection";
private static final String[] m_serviceNames = { __serviceName };
// The type names
private static final String LATEX_FILE = "org.openoffice.da.writer2latex.LaTeX_File";
private static final String XELATEX_FILE = "org.openoffice.da.writer2latex.XeLaTeX_File";
// From constructor+initialization
private final XComponentContext m_xContext;
/** Construct a new <code>TeXDetectService</code>
*
* @param xContext The Component Context
*/
public TeXDetectService( XComponentContext 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
public String detect(PropertyValue[][] mediaDescriptor) {
// Read the media properties
String sURL = null;
String sTypeName = null;
if (mediaDescriptor.length>0) {
int nLength = mediaDescriptor[0].length;
for (int i=0; i<nLength; i++) {
try {
if (mediaDescriptor[0][i].Name.equals("URL")) {
sURL = AnyConverter.toString(mediaDescriptor[0][i].Value);
}
else if (mediaDescriptor[0][i].Name.equals("TypeName")) {
sTypeName = AnyConverter.toString(mediaDescriptor[0][i].Value);
}
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// AnyConverter failed to convert; ignore this
}
}
}
// If there's no URL, we cannot verify the type (this should never happen on proper use of the service)
if (sURL==null) {
return "";
}
// 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)
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
return "";
}
catch (com.sun.star.uno.Exception e) {
// Failed to create input stream, cannot verify the type
return "";
}
// Ask the deTeXtive
DeTeXtive deTeXtive = new DeTeXtive();
try {
String sType = deTeXtive.deTeXt(is);
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
return "";
}
}
}

340
source/java/org/openoffice/da/comp/writer2latex/TeXImportFilter.java Normal file
View file

@ -0,0 +1,340 @@
/************************************************************************
*
* TeXImportFilter.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-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.6 (2014-10-29)
*
*/
package org.openoffice.da.comp.writer2latex;
//import com.sun.star.lib.uno.helper.Factory;
import java.io.File;
import java.net.URI;
import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.document.XDocumentInsertable;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.task.XStatusIndicator;
import com.sun.star.text.XTextCursor;
import com.sun.star.text.XTextDocument;
import com.sun.star.uno.XComponentContext;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.AnyConverter;
import com.sun.star.beans.PropertyValue;
import com.sun.star.lang.XInitialization;
import com.sun.star.container.XNamed;
import com.sun.star.document.XImporter;
import com.sun.star.document.XFilter;
/** This class implements an import filter for TeX documents using TeX4ht
* It is thus an implementation of the service com.sun.star.document.ImportFilter
*/
public class TeXImportFilter extends WeakBase implements XInitialization, XNamed, XImporter, XFilter, XServiceInfo {
// Constants
// Identify this service
public static final String __implementationName = TeXImportFilter.class.getName();
public static final String __serviceName = "com.sun.star.document.ImportFilter";
private static final String[] m_serviceNames = { __serviceName };
// Possible states of the filtering process
public static final int FILTERPROC_RUNNING = 0;
public static final int FILTERPROC_BREAKING = 1;
public static final int FILTERPROC_STOPPED = 2;
// Global data
// From constructor
private final XComponentContext m_xContext;
// The filter name
private String m_sFilterName;
// The target document for the import
private com.sun.star.text.XTextDocument m_xTargetDoc;
// The current state of the filtering process
private int m_nState;
/** Construct a new <code>TeXImportFilter</code>
*
* @param xContext The Component Context
*/
public TeXImportFilter( XComponentContext xContext ) {
m_xContext = xContext;
m_sFilterName = "";
m_xTargetDoc = null;
m_nState = FILTERPROC_STOPPED;
}
// 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;
}
// The following methods may be called from multiple threads (e.g. if someone wants to cancel the filtering),
// thus all access to class members must be synchronized
// Implement XInitialization:
public void initialize( Object[] arguments ) throws com.sun.star.uno.Exception {
if (arguments.length>0) {
// The first argument contains configuration data, from which we extract the filter name for further reference
// We need this to know which flavour of TeX we're supposed to handle
PropertyValue[] config = (PropertyValue[]) arguments[0];
int nLen = config.length;
for (int i=0; i<nLen; i++) {
if (config[i].Name.equals("Name")) {
synchronized(this) {
try {
m_sFilterName = AnyConverter.toString(config[i].Value);
}
catch(com.sun.star.lang.IllegalArgumentException exConvert) {
// ignore
}
}
}
}
}
}
// Implement XNamed
public String getName() {
synchronized(this) {
return m_sFilterName;
}
}
public void setName( String sName ) {
// must be ignored as we cannot change the filter name
}
// Implement XImporter
public void setTargetDocument( com.sun.star.lang.XComponent xDocument ) throws com.sun.star.lang.IllegalArgumentException {
// If there's no target document we cannot import into it
if (xDocument==null)
throw new com.sun.star.lang.IllegalArgumentException("Null pointer");
// And if it's not a text document we're out of luck too
com.sun.star.lang.XServiceInfo xInfo = (com.sun.star.lang.XServiceInfo)UnoRuntime.queryInterface(
com.sun.star.lang.XServiceInfo.class, xDocument);
if (!xInfo.supportsService("com.sun.star.text.TextDocument"))
throw new com.sun.star.lang.IllegalArgumentException("Wrong document type");
// Otherwise set the target document
synchronized(this) {
m_xTargetDoc = (com.sun.star.text.XTextDocument)UnoRuntime.queryInterface(
com.sun.star.text.XTextDocument.class, xDocument);
}
}
// Implement XFilter:
/** Filter (import only) the document given by the media descriptor
* According to the service contract, we should understand either of
* the properties URL or InputStream, but currently we only use the former.
* We also use the property StatusIndicator: OOo internally uses this to
* pass around an XStatusIndicator instance, and if it's available we
* use it to display a progress bar
*
* @param mediaDescriptor the Media Descriptor
*/
public boolean filter(com.sun.star.beans.PropertyValue[] mediaDescriptor) {
// Extract values from the MediaDescriptor
String sURL = null;
XStatusIndicator xStatusIndicator = null;
int nLength = mediaDescriptor.length;
for (int i=0; i<nLength; i++) {
try {
if (mediaDescriptor[i].Name.equals("URL")) {
sURL = AnyConverter.toString(mediaDescriptor[i].Value);
}
else if (mediaDescriptor[i].Name.equals("InputStream")) {
// Ignore this currently
}
else if (mediaDescriptor[i].Name.equals("StatusIndicator")) {
xStatusIndicator = (XStatusIndicator) AnyConverter.toObject(XStatusIndicator.class, mediaDescriptor[i].Value);
}
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// AnyConverter failed to convert; ignore this
}
}
if (sURL==null) {
// Currently we need and URL to import
return false;
}
// Copy the current value of the target document and mark the filtering process as running
XTextDocument xText = null;
synchronized(this) {
if (m_nState!=FILTERPROC_STOPPED) {
return false;
}
xText = m_xTargetDoc;
m_nState = FILTERPROC_RUNNING;
}
// Do the import
boolean bResult = importTeX(xText,sURL,xStatusIndicator);
m_nState = FILTERPROC_STOPPED;
return bResult;
}
/** Cancel the filtering process. This will not only trigger cancellation, but also wait until it's finished
*/
public void cancel() {
// Change state to "breaking"
synchronized(this) {
if (m_nState==FILTERPROC_RUNNING) m_nState=FILTERPROC_BREAKING;
}
// And wait until state has changed to "stopped"
while (true) {
synchronized(this) {
if (m_nState==FILTERPROC_STOPPED)
break;
}
}
}
// Private helper methods
/** Import a TeX document with TeX4ht
* @param xText into this document
* @param sURL from the TeX document given by this URL
*/
public boolean importTeX(XTextDocument xText, String sURL, XStatusIndicator xStatus) {
int nStep = 0;
if (xStatus!=null) {
xStatus.start("Writer2LaTeX",10);
xStatus.setValue(++nStep);
}
// Get the LaTeX file
File file = null;
try {
file = new File(new URI(sURL));
}
catch (java.net.URISyntaxException e) {
// Could not use the URL provided
if (xStatus!=null) xStatus.end();
return false;
}
if (xStatus!=null) { xStatus.setValue(++nStep); }
// Protect the ODT file if it already exists
String sBaseName = file.getName();
if (sBaseName.endsWith(".tex")) { sBaseName = sBaseName.substring(0, sBaseName.length()-4); }
File odtFile = new File(file.getParentFile(),sBaseName+".odt");
File tempFile = null;
if (odtFile.exists()) {
try {
tempFile = File.createTempFile("w2l", ".tmp", file.getParentFile());
}
catch (java.io.IOException e) {
// Failed to protect the ODT file, give up
if (xStatus!=null) xStatus.end();
return false;
}
odtFile.renameTo(tempFile);
}
if (xStatus!=null) { xStatus.setValue(++nStep); }
// Execute TeX4ht
ExternalApps externalApps = new ExternalApps(m_xContext);
externalApps.load();
if (xStatus!=null) { xStatus.setValue(++nStep); }
// Default is the filter org.openoffice.da.writer2latex.latex
String sCommand = "oolatex";
if ("org.openoffice.da.writer2latex.xelatex".equals(m_sFilterName)) {
sCommand = "ooxelatex";
}
externalApps.execute(ExternalApps.MK4HT, sCommand, file.getName(), file.getParentFile(), null, true);
if (xStatus!=null) { nStep+=5; xStatus.setValue(nStep); }
// Assemble the URL of the ODT file
String sODTURL = sURL;
if (sODTURL.endsWith(".tex")) { sODTURL = sODTURL.substring(0, sODTURL.length()-4); }
sODTURL += ".odt";
// This is the only good time to test if we should cancel the import
boolean bSuccess = true;
synchronized(this) {
if (m_nState==FILTERPROC_BREAKING) bSuccess = false;
}
if (xStatus!=null) {
xStatus.end();
}
if (bSuccess) {
// Load ODT file into the text document
XTextCursor xTextCursor = xText.getText().createTextCursor();
XDocumentInsertable xDocInsert = (XDocumentInsertable)
UnoRuntime.queryInterface(XDocumentInsertable.class, xTextCursor);
try {
PropertyValue[] props = new PropertyValue[0];
xDocInsert.insertDocumentFromURL(sODTURL, props);
}
catch (com.sun.star.lang.IllegalArgumentException e) {
bSuccess = false;
}
catch (com.sun.star.io.IOException e) {
bSuccess = false;
}
}
odtFile.delete();
// Restore origninal ODT file, if any
if (tempFile!=null) {
tempFile.renameTo(odtFile);
}
return bSuccess;
}
}

160
source/java/org/openoffice/da/comp/writer2latex/TeXify.java Normal file
View file

@ -0,0 +1,160 @@
/************************************************************************
*
* TeXify.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-2010 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-01-25)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import com.sun.star.uno.XComponentContext;
/** This class builds LaTeX documents into DVI, Postscript or PDF and displays
* the result.
*/
public final class TeXify {
/** Backend format generic (dvi) */
public static final short GENERIC = 1;
/** Backend format dvips (postscript) */
public static final short DVIPS = 2;
/** Backend format pdfTeX (pdf) */
public static final short PDFTEX = 3;
/** Backend format XeTeX (also pdf, usually) */
public static final short XETEX = 4;
// Define the applications to run for each backend
private static final String[] genericTexify = {
ExternalApps.LATEX, ExternalApps.BIBTEX, ExternalApps.MAKEINDEX,
ExternalApps.LATEX, ExternalApps.MAKEINDEX, ExternalApps.LATEX };
private static final String[] pdfTexify = {
ExternalApps.PDFLATEX, ExternalApps.BIBTEX, ExternalApps.MAKEINDEX,
ExternalApps.PDFLATEX, ExternalApps.MAKEINDEX, ExternalApps.PDFLATEX };
private static final String[] dvipsTexify = {
ExternalApps.LATEX, ExternalApps.BIBTEX, ExternalApps.MAKEINDEX,
ExternalApps.LATEX, ExternalApps.MAKEINDEX, ExternalApps.LATEX,
ExternalApps.DVIPS };
private static final String[] xeTexify = {
ExternalApps.XELATEX, ExternalApps.BIBTEX, ExternalApps.MAKEINDEX,
ExternalApps.XELATEX, ExternalApps.MAKEINDEX, ExternalApps.XELATEX };
// Global objects
//private XComponentContext xContext;
private ExternalApps externalApps;
public TeXify(XComponentContext xContext) {
//this.xContext = xContext;
externalApps = new ExternalApps(xContext);
}
/** Process a document
* @param file the LaTeX file to process
* @param sBibinputs value for the BIBINPUTS environment variable (or null if it should not be extended)
* @param nBackend the desired backend format (generic, dvips, pdftex)
* @param bView set the true if the result should be displayed in the viewer
* @throws IOException if the document cannot be read
* @return true if the first LaTeX run was successful
*/
public boolean process(File file, String sBibinputs, short nBackend, boolean bView) throws IOException {
// Remove extension from file
if (file.getName().endsWith(".tex")) {
file = new File(file.getParentFile(),
file.getName().substring(0,file.getName().length()-4));
}
// Update external apps from registry
externalApps.load();
// Process LaTeX document
boolean bResult = false;
if (nBackend==GENERIC) {
bResult = doTeXify(genericTexify, file, sBibinputs);
if (!bResult) return false;
if (externalApps.execute(ExternalApps.DVIVIEWER,
new File(file.getParentFile(),file.getName()+".dvi").getPath(),
file.getParentFile(), null, false)>0) {
throw new IOException("Error executing dvi viewer");
}
}
else if (nBackend==PDFTEX) {
bResult = doTeXify(pdfTexify, file, sBibinputs);
if (!bResult) return false;
if (externalApps.execute(ExternalApps.PDFVIEWER,
new File(file.getParentFile(),file.getName()+".pdf").getPath(),
file.getParentFile(), null, false)>0) {
throw new IOException("Error executing pdf viewer");
}
}
else if (nBackend==DVIPS) {
bResult = doTeXify(dvipsTexify, file, sBibinputs);
if (!bResult) return false;
if (externalApps.execute(ExternalApps.POSTSCRIPTVIEWER,
new File(file.getParentFile(),file.getName()+".ps").getPath(),
file.getParentFile(), null, false)>0) {
throw new IOException("Error executing postscript viewer");
}
}
else if (nBackend==XETEX) {
bResult = doTeXify(xeTexify, file, sBibinputs);
if (!bResult) return false;
if (externalApps.execute(ExternalApps.PDFVIEWER,
new File(file.getParentFile(),file.getName()+".pdf").getPath(),
file.getParentFile(), null, false)>0) {
throw new IOException("Error executing pdf viewer");
}
}
return bResult;
}
private boolean doTeXify(String[] sAppList, File file, String sBibinputs) throws IOException {
// Remove the .aux file first (to avoid potential error messages)
File aux = new File(file.getParentFile(), file.getName()+".aux");
aux.delete();
for (int i=0; i<sAppList.length; i++) {
// Execute external application
Map<String,String> env =null;
if (ExternalApps.BIBTEX.equals(sAppList[i]) && sBibinputs!=null) {
env = new HashMap<String,String>();
env.put("BIBINPUTS", sBibinputs);
}
int nReturnCode = externalApps.execute(
sAppList[i], file.getName(), file.getParentFile(), env, true);
if (i==0 && nReturnCode>0) {
return false;
//throw new IOException("Error executing "+sAppList[i]);
}
}
return true;
}
}

54
source/java/org/openoffice/da/comp/writer2latex/W2LRegistration.java
View file

@ -16,11 +16,11 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Copyright: 2002-2009 by Henrik Just
* Copyright: 2002-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2009-09-06)
* Version 1.4 (2014-10-29)
*
*/
@ -84,6 +84,42 @@ public class W2LRegistration {
multiFactory,
regKey);
}
else if (implName.equals(Writer2LaTeX.__implementationName) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(Writer2LaTeX.class,
Writer2LaTeX.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(TeXImportFilter.__implementationName) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(TeXImportFilter.class,
TeXImportFilter.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(TeXDetectService.__implementationName) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(TeXDetectService.class,
TeXDetectService.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(ApplicationsDialog.__implementationName) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(ApplicationsDialog.class,
ApplicationsDialog.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(BibliographyDialog.__implementationName) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(BibliographyDialog.class,
BibliographyDialog.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(LogViewerDialog.__implementationName) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(LogViewerDialog.class,
LogViewerDialog.__serviceName,
multiFactory,
regKey);
}
return xSingleServiceFactory;
}
@ -105,7 +141,19 @@ public class W2LRegistration {
FactoryHelper.writeRegistryServiceInfo(W2LStarMathConverter.__implementationName,
W2LStarMathConverter.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(ConfigurationDialog.__implementationName,
ConfigurationDialog.__serviceName, regKey);
ConfigurationDialog.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(Writer2LaTeX.__implementationName,
Writer2LaTeX.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(TeXImportFilter.__implementationName,
TeXImportFilter.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(TeXDetectService.__implementationName,
TeXDetectService.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(ApplicationsDialog.__implementationName,
ApplicationsDialog.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(BibliographyDialog.__implementationName,
BibliographyDialog.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(LogViewerDialog.__implementationName,
LogViewerDialog.__serviceName, regKey);
}
}

700
source/java/org/openoffice/da/comp/writer2latex/Writer2LaTeX.java Normal file
View file

@ -0,0 +1,700 @@
/************************************************************************
*
* Writer2LaTeX.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-2014 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.6 (2014-10-29)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.regex.Pattern;
import com.sun.star.beans.PropertyValue;
import com.sun.star.beans.XPropertyAccess;
import com.sun.star.beans.XPropertySet;
import com.sun.star.container.XNameAccess;
import com.sun.star.frame.XController;
import com.sun.star.frame.XFrame;
import com.sun.star.frame.XModel;
import com.sun.star.frame.XStorable;
import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.task.XStatusIndicator;
import com.sun.star.task.XStatusIndicatorFactory;
import com.sun.star.ui.dialogs.ExecutableDialogResults;
import com.sun.star.ui.dialogs.XExecutableDialog;
import com.sun.star.uno.Exception;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import org.openoffice.da.comp.w2lcommon.helper.MacroExpander;
import org.openoffice.da.comp.w2lcommon.helper.MessageBox;
import org.openoffice.da.comp.w2lcommon.helper.PropertyHelper;
import org.openoffice.da.comp.w2lcommon.helper.RegistryHelper;
import org.openoffice.da.comp.w2lcommon.helper.XPropertySetHelper;
import writer2latex.util.CSVList;
import writer2latex.util.Misc;
/** This class implements the ui (dispatch) commands provided by the Writer2LaTeX toolbar.
* The actual processing is done by the three core classes <code>TeXify</code>,
* <code>LaTeXImporter</code> and <code>BibTeXImporter</code>
*/
public final class Writer2LaTeX extends WeakBase
implements com.sun.star.lang.XServiceInfo,
com.sun.star.frame.XDispatchProvider,
com.sun.star.lang.XInitialization,
com.sun.star.frame.XDispatch {
private static final String PROTOCOL = "org.openoffice.da.writer2latex:";
// From constructor+initialization
private final XComponentContext m_xContext;
private XFrame m_xFrame;
private XModel xModel = null;
// Global data
private TeXify texify = null;
private PropertyValue[] mediaProps = null;
private String sBasePath = null;
private String sBaseFileName = null;
public static final String __implementationName = Writer2LaTeX.class.getName();
public static final String __serviceName = "com.sun.star.frame.ProtocolHandler";
private static final String[] m_serviceNames = { __serviceName };
public Writer2LaTeX( XComponentContext xContext ) {
m_xContext = xContext;
}
// com.sun.star.lang.XInitialization:
public void initialize( Object[] object )
throws com.sun.star.uno.Exception {
if ( object.length > 0 ) {
// The first item is the current frame
m_xFrame = (com.sun.star.frame.XFrame) UnoRuntime.queryInterface(
com.sun.star.frame.XFrame.class, object[0]);
// Get the model for the document from the frame
XController xController = m_xFrame.getController();
if (xController!=null) {
xModel = xController.getModel();
}
}
}
// 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;
}
// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch queryDispatch( com.sun.star.util.URL aURL,
String sTargetFrameName, int iSearchFlags ) {
if ( aURL.Protocol.compareTo(PROTOCOL) == 0 ) {
if ( aURL.Path.compareTo("ProcessDocument") == 0 )
return this;
else if ( aURL.Path.compareTo("ProcessDirectly") == 0 )
return this;
else if ( aURL.Path.compareTo("ViewLog") == 0 )
return this;
else if ( aURL.Path.compareTo("InsertBibTeX") == 0 )
return this;
}
return null;
}
public com.sun.star.frame.XDispatch[] queryDispatches(
com.sun.star.frame.DispatchDescriptor[] seqDescriptors ) {
int nCount = seqDescriptors.length;
com.sun.star.frame.XDispatch[] seqDispatcher =
new com.sun.star.frame.XDispatch[seqDescriptors.length];
for( int i=0; i < nCount; ++i ) {
seqDispatcher[i] = queryDispatch(seqDescriptors[i].FeatureURL,
seqDescriptors[i].FrameName,
seqDescriptors[i].SearchFlags );
}
return seqDispatcher;
}
// com.sun.star.frame.XDispatch:
public void dispatch( com.sun.star.util.URL aURL,
com.sun.star.beans.PropertyValue[] aArguments ) {
if ( aURL.Protocol.compareTo(PROTOCOL) == 0 ) {
if ( aURL.Path.compareTo("ProcessDocument") == 0 ) {
if (updateLocation() && updateMediaProperties()) {
process();
}
return;
}
else if ( aURL.Path.compareTo("ProcessDirectly") == 0 ) {
if (updateLocation()) {
updateMediaPropertiesSilent();
process();
}
return;
}
else if ( aURL.Path.compareTo("ViewLog") == 0 ) {
viewLog();
return;
}
else if ( aURL.Path.compareTo("InsertBibTeX") == 0 ) {
insertBibTeX();
return;
}
}
}
public void addStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL ) {
}
public void removeStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL ) {
}
// The actual commands...
private void process() {
// Create a (somewhat coarse grained) status indicator/progress bar
XStatusIndicatorFactory xFactory = (com.sun.star.task.XStatusIndicatorFactory)
UnoRuntime.queryInterface(com.sun.star.task.XStatusIndicatorFactory.class, m_xFrame);
XStatusIndicator xStatus = xFactory.createStatusIndicator();
xStatus.start("Writer2LaTeX",10);
xStatus.setValue(1); // At least we have started, that's 10% :-)
// First work a bit on the FilterData (get the backend and set bibliography options)
String sBackend = "generic";
String sBibinputs = null;
PropertyHelper mediaHelper = new PropertyHelper(mediaProps);
Object filterData = mediaHelper.get("FilterData");
if (filterData instanceof PropertyValue[]) {
PropertyHelper filterHelper = new PropertyHelper((PropertyValue[])filterData);
// Get the backend
Object backend = filterHelper.get("backend");
if (backend instanceof String) {
sBackend = (String) backend;
}
// Set the bibliography options according to the settings
RegistryHelper registry = new RegistryHelper(m_xContext);
try {
Object view = registry.getRegistryView(BibliographyDialog.REGISTRY_PATH, false);
XPropertySet xProps = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,view);
String sBibTeXFiles = getFileList(XPropertySetHelper.getPropertyValueAsShort(xProps, "BibTeXLocation"),
XPropertySetHelper.getPropertyValueAsString(xProps, "BibTeXDir"));
if (XPropertySetHelper.getPropertyValueAsBoolean(xProps, "ConvertZoteroCitations")) {
filterHelper.put("zotero_bibtex_files", sBibTeXFiles);
}
if (XPropertySetHelper.getPropertyValueAsBoolean(xProps, "ConvertJabRefCitations")) {
filterHelper.put("jabref_bibtex_files", sBibTeXFiles);
}
if (XPropertySetHelper.getPropertyValueAsBoolean(xProps, "UseExternalBibTeXFiles")) {
filterHelper.put("external_bibtex_files", sBibTeXFiles);
}
filterHelper.put("include_original_citations",
Boolean.toString(XPropertySetHelper.getPropertyValueAsBoolean(xProps, "IncludeOriginalCitations")));
String sBibTeXDir = XPropertySetHelper.getPropertyValueAsString(xProps, "BibTeXDir");
if (sBibTeXDir.length()>0) {
// The separator character in BIBINPUTS is OS specific
sBibinputs = sBibTeXDir+File.pathSeparatorChar;
}
filterHelper.put("use_natbib", Boolean.toString(XPropertySetHelper.getPropertyValueAsBoolean(xProps, "UseNatbib")));
filterHelper.put("natbib_options", XPropertySetHelper.getPropertyValueAsString(xProps, "NatbibOptions"));
mediaHelper.put("FilterData",filterHelper.toArray());
mediaProps = mediaHelper.toArray();
registry.disposeRegistryView(view);
}
catch (Exception e) {
// Failed to get registry view
}
}
try {
// Convert to LaTeX
String sTargetUrl = sBasePath+sBaseFileName+".tex";
XStorable xStorable = (XStorable) UnoRuntime.queryInterface(XStorable.class, xModel);
xStorable.storeToURL(sTargetUrl, mediaProps);
}
catch (com.sun.star.io.IOException e) {
xStatus.end();
MessageBox msgBox = new MessageBox(m_xContext, m_xFrame);
msgBox.showMessage("Writer2LaTeX","Error: Failed to export document to LaTeX");
return;
}
xStatus.setValue(6); // Export is finished, that's more than half :-)
if (texify==null) { texify = new TeXify(m_xContext); }
File file = new File(urlToFile(sBasePath),sBaseFileName);
boolean bResult = true;
try {
if (sBackend=="pdftex") {
bResult = texify.process(file, sBibinputs, TeXify.PDFTEX, true);
}
else if (sBackend=="dvips") {
bResult = texify.process(file, sBibinputs, TeXify.DVIPS, true);
}
else if (sBackend=="xetex") {
bResult = texify.process(file, sBibinputs, TeXify.XETEX, true);
}
else if (sBackend=="generic") {
bResult = texify.process(file, sBibinputs, TeXify.GENERIC, true);
}
}
catch (IOException e) {
MessageBox msgBox = new MessageBox(m_xContext, m_xFrame);
msgBox.showMessage("Writer2LaTeX","Error: "+e.getMessage());
}
xStatus.setValue(10); // The user will usually not see this...
if (!bResult) {
MessageBox msgBox = new MessageBox(m_xContext, m_xFrame);
msgBox.showMessage("Writer2LaTeX","Error: Failed to execute LaTeX - see log for details");
}
xStatus.end();
}
private String getFileList(short nType, String sDirectory) {
File dir;
switch (nType) {
case 0: // absolute path
dir = new File(sDirectory);
break;
case 1: // relative path
dir = new File(urlToFile(sBasePath),sDirectory);
break;
default: // document directory
dir = urlToFile(sBasePath);
}
CSVList filelist = new CSVList(",");
if (dir.isDirectory()) {
File[] files = dir.listFiles();
for (File file : files) {
if (file.isFile() && file.getName().endsWith(".bib")) {
//filelist.addValue(file.getAbsolutePath());
filelist.addValue(Misc.removeExtension(file.getName()));
}
}
}
String sFileList = filelist.toString();
return sFileList.length()>0 ? sFileList : "dummy";
}
private void viewLog() {
if (updateLocation()) {
// Execute the log viewer dialog
try {
Object[] args = new Object[1];
args[0] = sBasePath+sBaseFileName;
Object dialog = m_xContext.getServiceManager()
.createInstanceWithArgumentsAndContext(
"org.openoffice.da.writer2latex.LogViewerDialog", args, m_xContext);
XExecutableDialog xDialog = (XExecutableDialog)
UnoRuntime.queryInterface(XExecutableDialog.class, dialog);
if (xDialog.execute()==ExecutableDialogResults.OK) {
// Closed with the close button
}
}
catch (com.sun.star.uno.Exception e) {
}
}
}
private void insertBibTeX() {
MessageBox msgBox = new MessageBox(m_xContext, m_xFrame);
msgBox.showMessage("Writer2LaTeX","This feature is not implemented yet");
}
// Some utility methods
private void prepareMediaProperties() {
// Create inital media properties
mediaProps = new PropertyValue[2];
mediaProps[0] = new PropertyValue();
mediaProps[0].Name = "FilterName";
mediaProps[0].Value = "org.openoffice.da.writer2latex";
mediaProps[1] = new PropertyValue();
mediaProps[1].Name = "Overwrite";
mediaProps[1].Value = "true";
}
private boolean updateMediaProperties() {
prepareMediaProperties();
try {
// Display options dialog
Object dialog = m_xContext.getServiceManager()
.createInstanceWithContext("org.openoffice.da.writer2latex.LaTeXOptionsDialog", m_xContext);
XPropertyAccess xPropertyAccess = (XPropertyAccess)
UnoRuntime.queryInterface(XPropertyAccess.class, dialog);
xPropertyAccess.setPropertyValues(mediaProps);
XExecutableDialog xDialog = (XExecutableDialog)
UnoRuntime.queryInterface(XExecutableDialog.class, dialog);
if (xDialog.execute()==ExecutableDialogResults.OK) {
mediaProps = xPropertyAccess.getPropertyValues();
return true;
}
else {
mediaProps = null;
return false;
}
}
catch (com.sun.star.beans.UnknownPropertyException e) {
// setPropertyValues will not fail..
mediaProps = null;
return false;
}
catch (com.sun.star.uno.Exception e) {
// getServiceManager will not fail..
mediaProps = null;
return false;
}
}
private String getOptionAsString(XPropertySet xProps, String sName) {
Object value = XPropertySetHelper.getPropertyValue(xProps, sName);
// Try to convert the value to a string
if (value instanceof String) return (String) value;
else if (value instanceof Boolean) return ((Boolean) value).toString();
else if (value instanceof Integer) return ((Integer) value).toString();
else if (value instanceof Short) return ((Short) value).toString();
else return null;
}
private void loadOption(XPropertySet xProps, PropertyHelper filterData, String sRegName, String sOptionName) {
String sValue = getOptionAsString(xProps,sRegName);
if (sValue!=null) {
// Set the filter data
filterData.put(sOptionName, sValue);
}
}
// Read the configuration directly from the registry rather than using the dialog
// TODO: Should probably do some refactoring in the Options dialogs to avoid this solution
private void updateMediaPropertiesSilent() {
prepareMediaProperties();
RegistryHelper registry = new RegistryHelper(m_xContext);
// Read the stored settings from the registry rather than displaying a dialog
try {
// Prepare registry view
Object view = registry.getRegistryView("/org.openoffice.da.Writer2LaTeX.Options/LaTeXOptions",true);
XPropertySet xProps = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,view);
PropertyHelper filterData = new PropertyHelper();
// Read the configuration file
short nConfig = XPropertySetHelper.getPropertyValueAsShort(xProps, "Config");
switch (nConfig) {
case 0: filterData.put("ConfigURL","*ultraclean.xml"); break;
case 1: filterData.put("ConfigURL","*clean.xml"); break;
case 2: filterData.put("ConfigURL","*default.xml"); break;
case 3: filterData.put("ConfigURL","*pdfprint.xml"); break;
case 4: filterData.put("ConfigURL","*pdfscreen.xml"); break;
case 5: filterData.put("ConfigURL","$(user)/writer2latex.xml");
filterData.put("AutoCreate","true"); break;
default:
// Get the actual URL from the registry
String sConfigName = XPropertySetHelper.getPropertyValueAsString(xProps, "ConfigName");
Object configurations = XPropertySetHelper.getPropertyValue(xProps,"Configurations");
XNameAccess xNameAccess = (XNameAccess) UnoRuntime.queryInterface(XNameAccess.class,configurations);
Object config = xNameAccess.getByName(sConfigName);
XPropertySet xCfgProps = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,config);
MacroExpander expander = new MacroExpander(m_xContext);
filterData.put("ConfigURL",expander.expandMacros(XPropertySetHelper.getPropertyValueAsString(xCfgProps,"ConfigURL")));
}
// Read the options
// General
short nBackend = XPropertySetHelper.getPropertyValueAsShort(xProps,"Backend");
switch (nBackend) {
case 0: filterData.put("backend","generic"); break;
case 1: filterData.put("backend","pdftex"); break;
case 2: filterData.put("backend","dvips"); break;
case 3: filterData.put("backend","xetex"); break;
case 4: filterData.put("backend","unspecified");
}
short nInputencoding = XPropertySetHelper.getPropertyValueAsShort(xProps,"Inputencoding");
switch (nInputencoding) {
case 0: filterData.put("inputencoding", "ascii"); break;
case 1: filterData.put("inputencoding", "latin1"); break;
case 2: filterData.put("inputencoding", "latin2"); break;
case 3: filterData.put("inputencoding", "iso-8859-7"); break;
case 4: filterData.put("inputencoding", "cp1250"); break;
case 5: filterData.put("inputencoding", "cp1251"); break;
case 6: filterData.put("inputencoding", "koi8-r"); break;
case 7: filterData.put("inputencoding", "utf8");
}
loadOption(xProps,filterData,"Multilingual","multilingual");
loadOption(xProps,filterData,"GreekMath","greek_math");
loadOption(xProps,filterData,"AdditionalSymbols","use_pifont");
loadOption(xProps,filterData,"AdditionalSymbols","use_ifsym");
loadOption(xProps,filterData,"AdditionalSymbols","use_wasysym");
loadOption(xProps,filterData,"AdditionalSymbols","use_eurosym");
loadOption(xProps,filterData,"AdditionalSymbols","use_tipa");
// Bibliography
loadOption(xProps,filterData,"UseBibtex","use_bibtex");
loadOption(xProps,filterData,"BibtexStyle","bibtex_style");
// Files
boolean bWrapLines = XPropertySetHelper.getPropertyValueAsBoolean(xProps,"WrapLines");
if (bWrapLines) {
loadOption(xProps,filterData,"WrapLinesAfter","wrap_lines_after");
}
else {
filterData.put("wrap_lines_after", "0");
}
loadOption(xProps,filterData,"SplitLinkedSections","split_linked_sections");
loadOption(xProps,filterData,"SplitToplevelSections","split_toplevel_sections");
loadOption(xProps,filterData,"SaveImagesInSubdir","save_images_in_subdir");
// Special content
short nNotes = XPropertySetHelper.getPropertyValueAsShort(xProps, "Notes");
switch (nNotes) {
case 0: filterData.put("notes","ignore"); break;
case 1: filterData.put("notes","comment"); break;
case 2: filterData.put("notes","pdfannotation"); break;
case 3: filterData.put("notes","marginpar");
}
loadOption(xProps,filterData,"Metadata","metadata");
// Figures and tables
loadOption(xProps,filterData,"OriginalImageSize","original_image_size");
boolean bOptimizeSimpleTables = XPropertySetHelper.getPropertyValueAsBoolean(xProps,"OptimizeSimpleTables");
if (bOptimizeSimpleTables) {
loadOption(xProps,filterData,"SimpleTableLimit","simple_table_limit");
}
else {
filterData.put("simple_table_limit", "0");
}
loadOption(xProps,filterData,"FloatTables","float_tables");
loadOption(xProps,filterData,"FloatFigures","float_figures");
loadOption(xProps,filterData,"FloatOptions","float_options");
short nFloatOptions = XPropertySetHelper.getPropertyValueAsShort(xProps, "FloatOptions");
switch (nFloatOptions) {
case 0: filterData.put("float_options", ""); break;
case 1: filterData.put("float_options", "tp"); break;
case 2: filterData.put("float_options", "bp"); break;
case 3: filterData.put("float_options", "htp"); break;
case 4: filterData.put("float_options", "hbp");
}
// AutoCorrect
loadOption(xProps,filterData,"IgnoreHardPageBreaks","ignore_hard_page_breaks");
loadOption(xProps,filterData,"IgnoreHardLineBreaks","ignore_hard_line_breaks");
loadOption(xProps,filterData,"IgnoreEmptyParagraphs","ignore_empty_paragraphs");
loadOption(xProps,filterData,"IgnoreDoubleSpaces","ignore_empty_spaces");
registry.disposeRegistryView(view);
// Update the media properties with the FilterData
PropertyHelper helper = new PropertyHelper(mediaProps);
helper.put("FilterData",filterData.toArray());
mediaProps = helper.toArray();
}
catch (com.sun.star.uno.Exception e) {
// Failed to get registry view, ignore
}
}
private boolean updateLocation() {
String sDocumentUrl = xModel.getURL();
if (sDocumentUrl.length()!=0) {
if (sDocumentUrl.startsWith("file:")) {
if (System.getProperty("os.name").startsWith("Windows")) {
Pattern windowsPattern = Pattern.compile("^file:///[A-Za-z][|:].*");
if (!windowsPattern.matcher(sDocumentUrl).matches()) {
MessageBox msgBox = new MessageBox(m_xContext, m_xFrame);
msgBox.showMessage("Please save the document on a location with a drive name!",
"LaTeX does not support UNC paths");
return false;
}
}
// Get the file name (without extension)
File f = urlToFile(sDocumentUrl);
sBaseFileName = f.getName();
int iDot = sBaseFileName.lastIndexOf(".");
if (iDot>-1) { // remove extension
sBaseFileName = sBaseFileName.substring(0,iDot);
}
sBaseFileName=makeTeXSafe(sBaseFileName);
// Get the path
int iSlash = sDocumentUrl.lastIndexOf("/");
if (iSlash>-1) {
sBasePath = sDocumentUrl.substring(0,iSlash+1);
}
else {
sBasePath = "";
}
return true;
}
else {
MessageBox msgBox = new MessageBox(m_xContext, m_xFrame);
msgBox.showMessage("Please save the document locally!","LaTeX does not support documents in remote storages");
return false;
}
}
else {
MessageBox msgBox = new MessageBox(m_xContext, m_xFrame);
msgBox.showMessage("Document not saved!","Please save the document before processing the file");
return false;
}
}
private String makeTeXSafe(String sArgument) {
String sResult = "";
for (int i=0; i<sArgument.length(); i++) {
char c = sArgument.charAt(i);
if ((c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9')) {
sResult += Character.toString(c);
}
else {
switch (c) {
case '.': sResult += "."; break;
case '-': sResult += "-"; break;
case ' ' : sResult += "-"; break;
case '_' : sResult += "-"; break;
// Replace accented and national characters
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 "writer2latex"; }
else { return sResult; }
}
private File urlToFile(String sUrl) {
try {
return new File(new URI(sUrl));
}
catch (URISyntaxException e) {
return new File(".");
}
}
/*private String urlToPath(String sUrl) {
try {
return (new File(new URI(sUrl))).getCanonicalPath();
}
catch (URISyntaxException e) {
return ".";
}
catch (IOException e) {
return ".";
}
}*/
}