.
writer2latex-1.4/source/java/ 0000755 0001750 0001750 00000000000 12603463650 014704 5 ustar rene rene writer2latex-1.4/source/java/org/ 0000755 0001750 0001750 00000000000 12636604221 015470 5 ustar rene rene writer2latex-1.4/source/java/org/openoffice/ 0000755 0001750 0001750 00000000000 12603463647 017616 5 ustar rene rene writer2latex-1.4/source/java/org/openoffice/da/ 0000755 0001750 0001750 00000000000 12603463647 020202 5 ustar rene rene writer2latex-1.4/source/java/org/openoffice/da/comp/ 0000755 0001750 0001750 00000000000 12603463650 021132 5 ustar rene rene writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/ 0000755 0001750 0001750 00000000000 12603463650 023605 5 ustar rene rene writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/EpubOptionsDialog.java 0000644 0001750 0001750 00000034417 12411277733 030052 0 ustar rene rene /************************************************************************
*
* EpubOptionsDialog.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-25)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import java.awt.GraphicsEnvironment;
import com.sun.star.awt.XDialog;
import com.sun.star.beans.XPropertySet;
import com.sun.star.lang.XComponent;
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.PropertyHelper;
import org.openoffice.da.comp.w2lcommon.filter.OptionsDialogBase;
/** This class provides a UNO component which implements a filter UI for the
* EPUB export
*/
public class EpubOptionsDialog extends OptionsDialogBase {
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2xhtml.EpubOptionsDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2xhtml.EpubOptionsDialog";
@Override public String getDialogLibraryName() { return "W2XDialogs2"; }
/** Return the name of the dialog within the library
*/
@Override public String getDialogName() { return "EpubOptions"; }
/** Return the name of the registry path
*/
@Override public String getRegistryPath() {
return "/org.openoffice.da.Writer2xhtml.Options/EpubOptions";
}
/** Create a new EpubOptionsDialog */
public EpubOptionsDialog(XComponentContext xContext) {
super(xContext);
xMSF = W2XRegistration.xMultiServiceFactory;
}
/** Load settings from the registry to the dialog */
@Override protected void loadSettings(XPropertySet xProps) {
// Style
loadConfig(xProps);
int nScaling = loadNumericOption(xProps, "Scaling");
if (nScaling<=1) { // Workaround for an obscure bug in the extension manager
setNumericFieldValue("Scaling",100);
}
int nColumnScaling = loadNumericOption(xProps, "ColumnScaling");
if (nColumnScaling<=1) {
setNumericFieldValue("ColumnScaling",100);
}
loadCheckBoxOption(xProps, "RelativeFontSize");
loadNumericOption(xProps, "FontScaling");
int nFontScaling = loadNumericOption(xProps, "FontScaling");
if (nFontScaling<=1) {
setNumericFieldValue("FontScaling",100);
}
loadCheckBoxOption(xProps, "RelativeFontSize");
loadCheckBoxOption(xProps, "UseDefaultFont");
loadComboBoxOption(xProps, "DefaultFontName");
loadCheckBoxOption(xProps, "ConvertToPx");
loadListBoxOption(xProps, "ImageSize");
// Fill the font name list with all installed fonts
setListBoxStringItemList("DefaultFontName",
GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames());
// AutoCorrect
loadCheckBoxOption(xProps, "IgnoreHardLineBreaks");
loadCheckBoxOption(xProps, "IgnoreEmptyParagraphs");
loadCheckBoxOption(xProps, "IgnoreDoubleSpaces");
// Special content
loadCheckBoxOption(xProps, "DisplayHiddenText");
loadCheckBoxOption(xProps, "Notes");
// Document division
loadListBoxOption(xProps, "SplitLevel");
loadListBoxOption(xProps, "PageBreakSplit");
loadCheckBoxOption(xProps, "UseImageSplit");
loadNumericOption(xProps, "ImageSplit");
loadCheckBoxOption(xProps, "CoverImage");
loadCheckBoxOption(xProps, "UseSplitAfter");
loadNumericOption(xProps, "SplitAfter");
// Navigation table
loadListBoxOption(xProps, "ExternalTocDepth");
loadCheckBoxOption(xProps, "IncludeToc");
updateLockedOptions();
enableControls();
}
/** Save settings from the dialog to the registry and create FilterData */
@Override protected void saveSettings(XPropertySet xProps, PropertyHelper helper) {
// Style
short nConfig = saveConfig(xProps, helper);
switch (nConfig) {
case 0: helper.put("ConfigURL","*default.xml"); break;
case 1: helper.put("ConfigURL","$(user)/writer2xhtml.xml");
helper.put("AutoCreate","true");
helper.put("TemplateURL", "$(user)/writer2xhtml-template.xhtml");
helper.put("StyleSheetURL", "$(user)/writer2xhtml-styles.css");
helper.put("ResourceURL", "$(user)/writer2xhtml-resources");
}
saveNumericOptionAsPercentage(xProps, helper, "Scaling", "scaling");
saveNumericOptionAsPercentage(xProps, helper, "ColumnScaling", "column_scaling");
saveCheckBoxOption(xProps, helper, "RelativeFontSize", "relative_font_size");
saveNumericOptionAsPercentage(xProps, helper, "FontScaling", "font_scaling");
saveCheckBoxOption(xProps, helper, "UseDefaultFont", "use_default_font");
saveTextFieldOption(xProps, helper, "DefaultFontName", "default_font_name");
saveCheckBoxOption(xProps, helper, "ConvertToPx", "convert_to_px");
saveListBoxOption(xProps, "ImageSize");
switch (getListBoxSelectedItem("ImageSize")) {
case 0: helper.put("image_size", "absolute"); break;
case 1: helper.put("image_size", "relative"); break;
case 2: helper.put("image_size", "none");
}
// AutoCorrect
saveCheckBoxOption(xProps, helper, "IgnoreHardLineBreaks", "ignore_hard_line_breaks");
saveCheckBoxOption(xProps, helper, "IgnoreEmptyParagraphs", "ignore_empty_paragraphs");
saveCheckBoxOption(xProps, helper, "IgnoreDoubleSpaces", "ignore_double_spaces");
// Special content
saveCheckBoxOption(xProps, helper, "DisplayHiddenText", "display_hidden_text");
saveCheckBoxOption(xProps, helper, "Notes", "notes");
// Document division
short nSplitLevel = saveListBoxOption(xProps, "SplitLevel");
if (!isLocked("split_level")) {
helper.put("split_level",Integer.toString(nSplitLevel));
}
short nPageBreakSplit = saveListBoxOption(xProps, "PageBreakSplit");
if (!isLocked("page_break_split")) {
switch (nPageBreakSplit) {
case 0: helper.put("page_break_split","none"); break;
case 1: helper.put("page_break_split", "styles"); break;
case 2: helper.put("page_break_split", "explicit"); break;
case 3: helper.put("page_break_split", "all");
}
}
boolean bUseImageSplit = saveCheckBoxOption(xProps, "UseImageSplit");
int nImageSplit = saveNumericOption(xProps, "ImageSplit");
if (!isLocked("image_split")) {
if (bUseImageSplit) {
helper.put("image_split", nImageSplit+"%");
}
else {
helper.put("image_split", "none");
}
}
saveCheckBoxOption(xProps, helper, "CoverImage", "cover_image");
boolean bUseSplitAfter = saveCheckBoxOption(xProps, "UseSplitAfter");
int nSplitAfter = saveNumericOption(xProps, "SplitAfter");
if (!isLocked("split_after")) {
if (bUseSplitAfter) {
helper.put("split_after", Integer.toString(nSplitAfter));
}
else {
helper.put("split_after", "0");
}
}
// Navigation table
short nExternalTocDepth = saveListBoxOption(xProps, "ExternalTocDepth");
helper.put("external_toc_depth", Integer.toString(nExternalTocDepth+1));
saveCheckBoxOption(xProps, helper, "IncludeToc", "include_toc");
}
// Implement XDialogEventHandler
@Override public boolean callHandlerMethod(XDialog xDialog, Object event, String sMethod) {
if (sMethod.equals("ConfigChange")) {
updateLockedOptions();
enableControls();
}
else if (sMethod.equals("RelativeFontSizeChange")) {
relativeFontSizeChange();
}
else if (sMethod.equals("UseDefaultFontChange")) {
useDefaultFontChange();
}
else if (sMethod.equals("EditMetadataClick")) {
editMetadataClick();
}
else if (sMethod.equals("UseImageSplitChange")) {
useImageSplitChange();
}
else if (sMethod.equals("UseSplitAfterChange")) {
useSplitAfterChange();
}
return true;
}
@Override public String[] getSupportedMethodNames() {
String[] sNames = { "ConfigChange", "RelativeFontSizeChange", "UseDefaultFontChange", "EditMetadataClick",
"UseImageSplitChange", "UseSplitAfterChange" };
return sNames;
}
private void enableControls() {
// Style
setControlEnabled("ScalingLabel",!isLocked("scaling"));
setControlEnabled("Scaling",!isLocked("scaling"));
setControlEnabled("ColumnScalingLabel",!isLocked("column_scaling"));
setControlEnabled("ColumnScaling",!isLocked("column_scaling"));
boolean bRelativeFontSize = getCheckBoxStateAsBoolean("RelativeFontSize");
setControlEnabled("RelativeFontSize",!isLocked("relative_font_size"));
setControlEnabled("FontScalingLabel", !isLocked("font_scaling") && bRelativeFontSize);
setControlEnabled("FontScaling",!isLocked("font_scaling") && bRelativeFontSize);
setControlEnabled("FontScalingPercentLabel", !isLocked("font_scaling") && bRelativeFontSize);
boolean bUseDefaultFont = getCheckBoxStateAsBoolean("UseDefaultFont");
setControlEnabled("UseDefaultFont",!isLocked("use_default_font"));
setControlEnabled("DefaultFontNameLabel",!isLocked("default_font_name") && bUseDefaultFont);
setControlEnabled("DefaultFontName",!isLocked("default_font_name") && bUseDefaultFont);
setControlEnabled("ConvertToPx",!isLocked("convert_to_px"));
setControlEnabled("ImageSize",!isLocked("image_size"));
// AutoCorrect
setControlEnabled("IgnoreHardLineBreaks",!isLocked("ignore_hard_line_breaks"));
setControlEnabled("IgnoreEmptyParagraphs",!isLocked("ignore_empty_paragraphs"));
setControlEnabled("IgnoreDoubleSpaces",!isLocked("ignore_double_spaces"));
// Special content
setControlEnabled("DisplayHiddenText",!isLocked("display_hidden_text"));
setControlEnabled("Notes",!isLocked("notes"));
// Document division
setControlEnabled("SplitLevelLabel",!isLocked("split_level"));
setControlEnabled("SplitLevel",!isLocked("split_level"));
setControlEnabled("PageBreakSplitLabel",!isLocked("page_break_split"));
setControlEnabled("PageBreakSplit",!isLocked("page_break_split"));
boolean bUseImageSplit = getCheckBoxStateAsBoolean("UseImageSplit");
setControlEnabled("UseImageSplit",!isLocked("image_split"));
setControlEnabled("ImageSplitLabel",!isLocked("image_split") && bUseImageSplit);
setControlEnabled("ImageSplit",!isLocked("image_split") && bUseImageSplit);
setControlEnabled("ImageSplitPercentLabel",!isLocked("image_split") && bUseImageSplit);
setControlEnabled("CoverImage", !isLocked("cover_image"));
boolean bUseSplitAfter = getCheckBoxStateAsBoolean("UseSplitAfter");
setControlEnabled("UseSplitAfter",!isLocked("split_after"));
setControlEnabled("SplitAfterLabel",!isLocked("split_after") && bUseSplitAfter);
setControlEnabled("SplitAfter",!isLocked("split_after") && bUseSplitAfter);
// Navigation table
setControlEnabled("ExternalTocDepthLabel", !isLocked("external_toc_depth"));
setControlEnabled("ExternalTocDepth", !isLocked("external_toc_depth"));
setControlEnabled("IncludeToc", !isLocked("include_toc"));
}
private void relativeFontSizeChange() {
if (!isLocked("font_scaling")) {
boolean bState = getCheckBoxStateAsBoolean("RelativeFontSize");
setControlEnabled("FontScalingLabel", bState);
setControlEnabled("FontScaling", bState);
setControlEnabled("FontScalingPercentLabel", bState);
}
}
private void useDefaultFontChange() {
if (!isLocked("default_font_name")) {
boolean bState = getCheckBoxStateAsBoolean("UseDefaultFont");
setControlEnabled("DefaultFontNameLabel", bState);
setControlEnabled("DefaultFontName", bState);
}
}
private void editMetadataClick() {
Object dialog;
try {
dialog = xContext.getServiceManager().createInstanceWithContext("org.openoffice.da.writer2xhtml.EpubMetadataDialog", xContext);
XExecutableDialog xDialog = (XExecutableDialog) UnoRuntime.queryInterface(XExecutableDialog.class, dialog);
xDialog.execute();
// Dispose the dialog after execution (to free up the memory)
XComponent xComponent = (XComponent) UnoRuntime.queryInterface(XComponent.class, dialog);
if (xComponent!=null) {
xComponent.dispose();
}
} catch (Exception e) {
// Failed to get dialog
}
}
private void useImageSplitChange() {
if (!isLocked("image_split")) {
boolean bEnable = getCheckBoxStateAsBoolean("UseImageSplit");
setControlEnabled("ImageSplitLabel",bEnable);
setControlEnabled("ImageSplit",bEnable);
setControlEnabled("ImageSplitPercentLabel",bEnable);
}
}
private void useSplitAfterChange() {
if (!isLocked("split_after")) {
boolean bState = getCheckBoxStateAsBoolean("UseSplitAfter");
setControlEnabled("SplitAfterLabel",bState);
setControlEnabled("SplitAfter",bState);
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/BatchHandlerAdapter.java 0000644 0001750 0001750 00000004101 11147474702 030266 0 ustar rene rene /************************************************************************
*
* BatchHandlerAdapter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-10-05)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import writer2latex.api.BatchHandler;
import org.openoffice.da.writer2xhtml.XBatchHandler;
/** The uno interface provides an XBatchHandler implementation, the java
* interface requires a BatchHandler implementation. This simple class
* implements the latter using an instance of the former.
*/
public class BatchHandlerAdapter implements BatchHandler {
private XBatchHandler unoHandler;
public BatchHandlerAdapter(XBatchHandler unoHandler) {
this.unoHandler = unoHandler;
}
public void startConversion() {
unoHandler.startConversion();
}
public void endConversion() {
unoHandler.endConversion();
}
public void startDirectory(String sName) {
unoHandler.startDirectory(sName);
}
public void endDirectory(String sName, boolean bSuccess) {
unoHandler.endDirectory(sName, bSuccess);
}
public void startFile(String sName) {
unoHandler.startFile(sName);
}
public void endFile(String sName, boolean bSuccess) {
unoHandler.endFile(sName, bSuccess);
}
public boolean cancel() {
return unoHandler.cancel();
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/W2XRegistration.java 0000644 0001750 0001750 00000014351 12375043725 027472 0 ustar rene rene /************************************************************************
*
* W2XRegistration.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-08-18)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XSingleServiceFactory;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.comp.loader.FactoryHelper;
/** This class provides a static method to instantiate our uno components
* on demand (__getServiceFactory()), and a static method to give
* information about the components (__writeRegistryServiceInfo()).
* Furthermore, it saves the XMultiServiceFactory provided to the
* __getServiceFactory method for future reference by the componentes.
*/
public class W2XRegistration {
public static XMultiServiceFactory xMultiServiceFactory;
/**
* Returns a factory for creating the service.
* This method is called by the JavaLoader
*
* @return returns a XSingleServiceFactory for creating the
* component
*
* @param implName the name of the implementation for which a
* service is desired
* @param multiFactory the service manager to be used if needed
* @param regKey the registryKey
*
* @see com.sun.star.comp.loader.JavaLoader
*/
public static XSingleServiceFactory __getServiceFactory(String implName,
XMultiServiceFactory multiFactory, XRegistryKey regKey) {
xMultiServiceFactory = multiFactory;
XSingleServiceFactory xSingleServiceFactory = null;
if (implName.equals(W2XExportFilter.class.getName()) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(W2XExportFilter.class,
W2XExportFilter.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(BatchConverter.__implementationName) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(BatchConverter.class,
BatchConverter.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(XhtmlOptionsDialog.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(XhtmlOptionsDialog.class,
XhtmlOptionsDialog.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(XhtmlOptionsDialogMath.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(XhtmlOptionsDialogMath.class,
XhtmlOptionsDialogMath.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(XhtmlOptionsDialogCalc.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(XhtmlOptionsDialogCalc.class,
XhtmlOptionsDialogCalc.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(EpubOptionsDialog.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(EpubOptionsDialog.class,
EpubOptionsDialog.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(EpubMetadataDialog.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(EpubMetadataDialog.class,
EpubMetadataDialog.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(ConfigurationDialog.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(ConfigurationDialog.class,
ConfigurationDialog.__serviceName,
multiFactory,
regKey);
}
return xSingleServiceFactory;
}
/**
* Writes the service information into the given registry key.
* This method is called by the JavaLoader
*
* @return returns true if the operation succeeded
* @param regKey the registryKey
* @see com.sun.star.comp.loader.JavaLoader
*/
public static boolean __writeRegistryServiceInfo(XRegistryKey regKey) {
return
FactoryHelper.writeRegistryServiceInfo(BatchConverter.__implementationName,
BatchConverter.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(W2XExportFilter.__implementationName,
W2XExportFilter.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(XhtmlOptionsDialog.__implementationName,
XhtmlOptionsDialog.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(XhtmlOptionsDialogMath.__implementationName,
XhtmlOptionsDialogMath.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(XhtmlOptionsDialogCalc.__implementationName,
XhtmlOptionsDialogCalc.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(EpubOptionsDialog.__implementationName,
EpubOptionsDialog.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(EpubMetadataDialog.__implementationName,
EpubMetadataDialog.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(ConfigurationDialog.__implementationName,
ConfigurationDialog.__serviceName, regKey);
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/XhtmlOptionsDialogMath.java 0000644 0001750 0001750 00000003335 12375043725 031061 0 ustar rene rene /************************************************************************
*
* XhtmlOptionsDialogXsl.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-2004 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.4 (2014-08-18)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import com.sun.star.uno.XComponentContext;
/** This class provides a uno component which implements a filter ui for the
* Xhtml export for the XHTML+MathML and HTML export.
* This variant of the dialog has the MahtJax setting enabled
*/
public class XhtmlOptionsDialogMath extends XhtmlOptionsDialog {
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2xhtml.XhtmlOptionsDialogMath";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2xhtml.XhtmlOptionsDialogMath";
/** Create a new XhtmlOptionsDialogMath */
public XhtmlOptionsDialogMath(XComponentContext xContext) {
super(xContext);
}
} writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/ConfigurationDialog.java 0000644 0001750 0001750 00000050013 12410605107 030365 0 ustar rene rene /************************************************************************
*
* ConfigurationDialog.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-23)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import java.util.Map;
import org.openoffice.da.comp.w2lcommon.filter.ConfigurationDialogBase;
import org.openoffice.da.comp.w2lcommon.helper.DialogAccess;
import com.sun.star.container.NoSuchElementException;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.ucb.CommandAbortedException;
import com.sun.star.uno.Exception;
import com.sun.star.uno.XComponentContext;
public class ConfigurationDialog extends ConfigurationDialogBase implements XServiceInfo {
private String sResourceDirName;
// Implement the interface XServiceInfo
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2xhtml.ConfigurationDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2xhtml.ConfigurationDialog";
public boolean supportsService(String sServiceName) {
return sServiceName.equals(__serviceName);
}
public String getImplementationName() {
return __implementationName;
}
public String[] getSupportedServiceNames() {
String[] sSupportedServiceNames = { __serviceName };
return sSupportedServiceNames;
}
// Configure the base class
@Override protected String getMIMEType() { return "text/html"; }
@Override protected String getDialogLibraryName() { return "W2XDialogs2"; }
@Override protected String getConfigFileName() { return "writer2xhtml.xml"; }
/** Construct a new ConfigurationDialog */
public ConfigurationDialog(XComponentContext xContext) {
super(xContext);
// Create the resource dir name
try {
sResourceDirName = xPathSub.substituteVariables("$(user)/writer2xhtml-resources", false);
}
catch (NoSuchElementException e) {
sResourceDirName = "writer2xhtml-resources";
}
pageHandlers.put("General", new GeneralHandler());
pageHandlers.put("Template", new TemplateHandler());
pageHandlers.put("Stylesheets", new StylesheetsHandler());
pageHandlers.put("Formatting", new FormattingHandler());
pageHandlers.put("Styles1", new Styles1Handler());
pageHandlers.put("Styles2", new Styles2Handler());
pageHandlers.put("Formatting", new FormattingHandler());
pageHandlers.put("Content", new ContentHandler());
}
// Implement remaining method from XContainerWindowEventHandler
public String[] getSupportedMethodNames() {
String[] sNames = { "EncodingChange", // General
"CustomTemplateChange", "LoadTemplateClick", // Template
"UseCustomStylesheetChange", "IncludeCustomStylesheetClick", "LoadStylesheetClick",
"NewResourceClick", "DeleteResourceClick", // Stylesheet
"StyleFamilyChange", "StyleNameChange", "NewStyleClick", "DeleteStyleClick", "LoadDefaultsClick" // Styles1
};
return sNames;
}
// the page handlers
private final String[] sCharElements = { "span", "abbr", "acronym", "b", "big", "cite", "code", "del", "dfn", "em", "i",
"ins", "kbd", "samp", "small", "strong", "sub", "sup", "tt", "var", "q" };
private class GeneralHandler extends PageHandler {
private final String[] sEncodingValues = { "UTF-8", "UTF-16", "ISO-8859-1", "US-ASCII" };
@Override protected void setControls(DialogAccess dlg) {
checkBoxFromConfig(dlg, "NoDoctype", "no_doctype");
listBoxFromConfig(dlg, "Encoding", "encoding", sEncodingValues, (short) 0);
checkBoxFromConfig(dlg, "AddBOM", "add_bom");
if ("true".equals(config.getOption("hexadecimal_entities"))) {
dlg.setListBoxSelectedItem("HexadecimalEntities", (short) 0);
}
else {
dlg.setListBoxSelectedItem("HexadecimalEntities", (short) 1);
}
checkBoxFromConfig(dlg, "UseNamedEntities", "use_named_entities");
checkBoxFromConfig(dlg, "Multilingual", "multilingual");
checkBoxFromConfig(dlg, "PrettyPrint", "pretty_print");
encodingChange(dlg);
}
@Override protected void getControls(DialogAccess dlg) {
checkBoxToConfig(dlg, "NoDoctype", "no_doctype");
listBoxToConfig(dlg, "Encoding", "encoding", sEncodingValues);
checkBoxToConfig(dlg, "AddBOM", "add_bom");
config.setOption("hexadecimal_entities", Boolean.toString(dlg.getListBoxSelectedItem("HexadecimalEntities")==(short)0));
checkBoxToConfig(dlg, "UseNamedEntities", "use_named_entities");
checkBoxToConfig(dlg, "Multilingual", "multilingual");
checkBoxToConfig(dlg, "PrettyPrint", "pretty_print");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("EncodingChange")) {
encodingChange(dlg);
return true;
}
return false;
}
private void encodingChange(DialogAccess dlg) {
int nEncoding = dlg.getListBoxSelectedItem("Encoding");
dlg.setControlEnabled("AddBOM", nEncoding==0); // Only for UTF-8
dlg.setControlEnabled("HexadecimalEntitiesLabel", nEncoding>1); // Not for UNICODE
dlg.setControlEnabled("HexadecimalEntities", nEncoding>1); // Not for UNICODE
}
}
private class TemplateHandler extends CustomFileHandler {
protected String getSuffix() {
return "Template";
}
protected String getFileName() {
return "writer2xhtml-template.xhtml";
}
protected void useCustomInner(DialogAccess dlg, boolean bEnable) {
dlg.setControlEnabled("ContentIdLabel", bEnable);
dlg.setControlEnabled("ContentId", bEnable);
dlg.setControlEnabled("HeaderIdLabel", bEnable);
dlg.setControlEnabled("HeaderId", bEnable);
dlg.setControlEnabled("FooterIdLabel", bEnable);
dlg.setControlEnabled("FooterId", bEnable);
dlg.setControlEnabled("PanelIdLabel", bEnable);
dlg.setControlEnabled("PanelId", bEnable);
}
@Override protected void setControls(DialogAccess dlg) {
super.setControls(dlg);
String[] sCustomIds = config.getOption("template_ids").split(",");
if (sCustomIds.length>0) { dlg.setComboBoxText("ContentId", sCustomIds[0]); }
if (sCustomIds.length>1) { dlg.setComboBoxText("HeaderId", sCustomIds[1]); }
if (sCustomIds.length>2) { dlg.setComboBoxText("FooterId", sCustomIds[2]); }
if (sCustomIds.length>3) { dlg.setComboBoxText("PanelId", sCustomIds[3]); }
}
@Override protected void getControls(DialogAccess dlg) {
super.getControls(dlg);
config.setOption("template_ids",
dlg.getComboBoxText("ContentId").trim()+","+
dlg.getComboBoxText("HeaderId").trim()+","+
dlg.getComboBoxText("FooterId").trim()+","+
dlg.getComboBoxText("PanelId").trim());
}
}
private class StylesheetsHandler extends CustomFileHandler {
protected String getSuffix() {
return "Stylesheet";
}
protected String getFileName() {
return "writer2xhtml-styles.css";
}
protected void useCustomInner(DialogAccess dlg, boolean bEnable) {
dlg.setControlEnabled("ResourceLabel", bEnable);
dlg.setControlEnabled("Resources", bEnable);
dlg.setControlEnabled("NewResourceButton", bEnable);
dlg.setControlEnabled("DeleteResourceButton", bEnable);
updateResources(dlg);
}
@Override protected void setControls(DialogAccess dlg) {
super.setControls(dlg);
dlg.setCheckBoxStateAsBoolean("LinkCustomStylesheet", config.getOption("custom_stylesheet").length()>0);
textFieldFromConfig(dlg, "CustomStylesheetURL", "custom_stylesheet");
linkCustomStylesheetChange(dlg);
updateResources(dlg);
}
@Override protected void getControls(DialogAccess dlg) {
super.getControls(dlg);
if (dlg.getCheckBoxStateAsBoolean("LinkCustomStylesheet")) {
textFieldToConfig(dlg, "CustomStylesheetURL", "custom_stylesheet");
}
else {
config.setOption("custom_stylesheet", "");
}
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (super.handleEvent(dlg, sMethod)) {
return true;
}
if (sMethod.equals("LinkCustomStylesheetChange")) {
linkCustomStylesheetChange(dlg);
return true;
}
else if (sMethod.equals("NewResourceClick")) {
newResourceClick(dlg);
return true;
}
else if (sMethod.equals("DeleteResourceClick")) {
deleteResourceClick(dlg);
return true;
}
return false;
}
private void linkCustomStylesheetChange(DialogAccess dlg) {
boolean bLinkCustomStylesheet = dlg.getCheckBoxStateAsBoolean("LinkCustomStylesheet");
dlg.setControlEnabled("CustomStylesheetURLLabel", bLinkCustomStylesheet);
dlg.setControlEnabled("CustomStylesheetURL", bLinkCustomStylesheet);
}
private void newResourceClick(DialogAccess dlg) {
String[] sFileNames=filePicker.getPaths();
if (sFileNames!=null) {
createResourceDir();
for (String sFileName : sFileNames) {
String sBaseFileName = sFileName.substring(sFileName.lastIndexOf('/')+1);
try {
String sTargetFileName = sResourceDirName+"/"+sBaseFileName;
if (fileExists(sTargetFileName)) { killFile(sTargetFileName); }
sfa2.copy(sFileName, sTargetFileName);
} catch (CommandAbortedException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
updateResources(dlg);
}
}
private void deleteResourceClick(DialogAccess dlg) {
int nItem = dlg.getListBoxSelectedItem("Resources");
if (nItem>=0) {
String sFileName = dlg.getListBoxStringItemList("Resources")[nItem];
if (deleteItem(sFileName)) {
killFile(sResourceDirName+"/"+sFileName);
updateResources(dlg);
}
}
}
private void updateResources(DialogAccess dlg) {
createResourceDir();
try {
String[] sFiles = sfa2.getFolderContents(sResourceDirName, false); // do not include folders
int nCount = sFiles.length;
for (int i=0; i attr) {
if (!attr.containsKey("element")) { attr.put("element", ""); }
if (!attr.containsKey("css")) { attr.put("css", ""); }
dlg.setComboBoxText("Element", attr.get("element"));
dlg.setTextFieldText("Css", none2empty(attr.get("css")));
if (nCurrentFamily==1 || nCurrentFamily==2) {
if (!attr.containsKey("block-element")) { attr.put("block-element", ""); }
if (!attr.containsKey("block-css")) { attr.put("block-css", ""); }
dlg.setComboBoxText("BlockElement", attr.get("block-element"));
dlg.setTextFieldText("BlockCss", none2empty(attr.get("block-css")));
}
else {
dlg.setComboBoxText("BlockElement", "");
dlg.setTextFieldText("BlockCss", "");
}
}
protected void getControls(DialogAccess dlg, Map attr) {
attr.put("element", dlg.getComboBoxText("Element"));
attr.put("css", empty2none(dlg.getTextFieldText("Css")));
if (nCurrentFamily==1 || nCurrentFamily==2) {
attr.put("block-element", dlg.getComboBoxText("BlockElement"));
attr.put("block-css", empty2none(dlg.getTextFieldText("BlockCss")));
}
}
protected void clearControls(DialogAccess dlg) {
dlg.setComboBoxText("Element", "");
dlg.setTextFieldText("Css", "");
dlg.setComboBoxText("BlockElement", "");
dlg.setTextFieldText("BlockCss", "");
}
protected void prepareControls(DialogAccess dlg, boolean bHasMappings) {
dlg.setListBoxStringItemList("Element", sElements[nCurrentFamily]);
dlg.setListBoxStringItemList("BlockElement", sBlockElements[nCurrentFamily]);
dlg.setControlEnabled("ElementLabel", bHasMappings && nCurrentFamily<=2);
dlg.setControlEnabled("Element", bHasMappings && nCurrentFamily<=2);
dlg.setControlEnabled("CssLabel", bHasMappings);
dlg.setControlEnabled("Css", bHasMappings);
dlg.setControlEnabled("BlockElementLabel", bHasMappings && (nCurrentFamily==1 || nCurrentFamily==2));
dlg.setControlEnabled("BlockElement", bHasMappings && (nCurrentFamily==1 || nCurrentFamily==2));
dlg.setControlEnabled("BlockCssLabel", bHasMappings && (nCurrentFamily==1 || nCurrentFamily==2));
dlg.setControlEnabled("BlockCss", bHasMappings && (nCurrentFamily==1 || nCurrentFamily==2));
}
}
private class Styles2Handler extends AttributePageHandler {
private String[] sXhtmlAttributeNames = { "bold", "italics", "fixed", "superscript", "subscript", "underline", "overstrike" };
public Styles2Handler() {
sAttributeNames = sXhtmlAttributeNames;
}
@Override public void setControls(DialogAccess dlg) {
super.setControls(dlg);
textFieldFromConfig(dlg,"TabstopStyle","tabstop_style");
}
@Override public void getControls(DialogAccess dlg) {
super.getControls(dlg);
textFieldToConfig(dlg,"TabstopStyle","tabstop_style");
}
protected void setControls(DialogAccess dlg, Map attr) {
if (!attr.containsKey("element")) { attr.put("element", ""); }
if (!attr.containsKey("css")) { attr.put("css", ""); }
dlg.setListBoxStringItemList("Element", sCharElements);
dlg.setComboBoxText("Element", attr.get("element"));
dlg.setTextFieldText("Css", none2empty(attr.get("css")));
}
protected void getControls(DialogAccess dlg, Map attr) {
attr.put("element", dlg.getComboBoxText("Element"));
attr.put("css", empty2none(dlg.getTextFieldText("Css")));
}
protected void prepareControls(DialogAccess dlg, boolean bEnable) {
dlg.setControlEnabled("ElementLabel", bEnable);
dlg.setControlEnabled("Element", bEnable);
dlg.setControlEnabled("CssLabel", bEnable);
dlg.setControlEnabled("Css", bEnable);
}
}
private class FormattingHandler extends PageHandler {
private final String[] sExportValues = { "convert_all", "ignore_styles", "ignore_hard", "ignore_all" };
private final String[] sListExportValues = { "css1", "css1_hack", "hard_labels" };
@Override protected void setControls(DialogAccess dlg) {
listBoxFromConfig(dlg, "Formatting", "formatting", sExportValues, (short) 0);
listBoxFromConfig(dlg, "FrameFormatting", "frame_formatting", sExportValues, (short) 0);
// OOo does not support styles for sections and tables, hence this simplified variant
dlg.setCheckBoxStateAsBoolean("SectionFormatting",
config.getOption("section_formatting").equals("convert_all") ||
config.getOption("section_formatting").equals("ignore_styles"));
dlg.setCheckBoxStateAsBoolean("TableFormatting",
config.getOption("table_formatting").equals("convert_all") ||
config.getOption("table_formatting").equals("ignore_styles"));
checkBoxFromConfig(dlg, "IgnoreTableDimensions", "ignore_table_dimensions");
listBoxFromConfig(dlg, "ListFormatting", "list_formatting", sListExportValues, (short) 0);
//TODO: These have been postponed
//checkBoxFromConfig(dlg, "ConvertToPx", "convert_to_px");
//checkBoxFromConfig(dlg, "SeparateStylesheet", "separate_stylesheet");
}
@Override protected void getControls(DialogAccess dlg) {
listBoxToConfig(dlg, "Formatting", "formatting", sExportValues);
listBoxToConfig(dlg, "FrameFormatting", "frame_formatting", sExportValues);
config.setOption("section_formatting", dlg.getCheckBoxStateAsBoolean("SectionFormatting") ? "convert_all" : "ignore_all");
config.setOption("table_formatting", dlg.getCheckBoxStateAsBoolean("TableFormatting") ? "convert_all" : "ignore_all");
checkBoxToConfig(dlg, "IgnoreTableDimensions", "ignore_table_dimensions");
listBoxToConfig(dlg, "ListFormatting", "list_formatting", sListExportValues);
//TODO: These have been postponed
//checkBoxToConfig(dlg, "ConvertToPx", "convert_to_px");
//checkBoxToConfig(dlg, "SeparateStylesheet", "separate_stylesheet");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
return false;
}
}
private class ContentHandler extends PageHandler {
private final String[] sFormulaValues = { "image+starmath", "image+latex", "starmath", "latex" };
@Override protected void setControls(DialogAccess dlg) {
listBoxFromConfig(dlg, "Formulas", "formulas", sFormulaValues, (short) 0);
textFieldFromConfig(dlg, "EndnotesHeading", "endnotes_heading");
textFieldFromConfig(dlg, "FootnotesHeading", "footnotes_heading");
checkBoxFromConfig(dlg, "EmbedSvg", "embed_svg");
}
@Override protected void getControls(DialogAccess dlg) {
listBoxToConfig(dlg, "Formulas", "formulas", sFormulaValues);
textFieldToConfig(dlg, "EndnotesHeading", "endnotes_heading");
textFieldToConfig(dlg, "FootnotesHeading", "footnotes_heading");
checkBoxToConfig(dlg, "EmbedSvg", "embed_svg");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
return false;
}
}
private String none2empty(String s) {
return s.equals("(none)") ? "" : s;
}
private String empty2none(String s) {
String t = s.trim();
return t.length()==0 ? "(none)" : t;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/BatchConverter.java 0000644 0001750 0001750 00000045552 12367640075 027401 0 ustar rene rene /************************************************************************
*
* BatchConverter.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.3.1 (2014-08-04)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import com.sun.star.lib.uno.adapter.XInputStreamToInputStreamAdapter;
import com.sun.star.lib.uno.adapter.XOutputStreamToOutputStreamAdapter;
import com.sun.star.beans.PropertyValue;
import com.sun.star.document.XDocumentProperties;
import com.sun.star.document.XDocumentPropertiesSupplier;
import com.sun.star.frame.XComponentLoader;
import com.sun.star.frame.XStorable;
import com.sun.star.io.NotConnectedException;
import com.sun.star.io.XInputStream;
import com.sun.star.io.XOutputStream;
import com.sun.star.lang.XComponent;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.lang.XServiceName;
import com.sun.star.lang.XTypeProvider;
import com.sun.star.sheet.XSpreadsheetDocument;
import com.sun.star.text.XTextDocument;
import com.sun.star.ucb.CommandAbortedException;
import com.sun.star.ucb.XSimpleFileAccess2;
import com.sun.star.uno.AnyConverter;
import com.sun.star.uno.Type;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
//import writer2latex.api.BatchConverter;
//import writer2latex.api.BatchHandler;
//import writer2latex.api.Converter;
import writer2latex.api.ConverterFactory;
import writer2latex.api.IndexPageEntry;
import writer2latex.api.MIMETypes;
import writer2latex.api.OutputFile;
// Import interfaces as defined in uno idl
import org.openoffice.da.writer2xhtml.XBatchConverter;
import org.openoffice.da.writer2xhtml.XBatchHandler;
import org.openoffice.da.comp.w2lcommon.helper.PropertyHelper;
/** This class provides a uno component which implements the interface
* org.openoffice.da.writer2xhtml.XBatchConverter
*/
public class BatchConverter implements
XBatchConverter,
XServiceName,
XServiceInfo,
XTypeProvider {
/** The component will be registered under this name.
*/
public static final String __serviceName = "org.openoffice.da.writer2xhtml.BatchConverter";
public static final String __implementationName = "org.openoffice.da.comp.writer2xhtml.BatchConverter";
private XComponentContext xComponentContext = null;
private XSimpleFileAccess2 sfa2 = null;
private writer2latex.api.BatchConverter batchConverter = null;
private XBatchHandler handler;
// Based on convert arguments
private boolean bRecurse = true;
private String sWriterFilterName = "org.openoffice.da.writer2xhtml";
private Object writerFilterData = null;
private String sCalcFilterName = "org.openoffice.da.calc2xhtml";
private Object calcFilterData = null;
private boolean bIncludePdf = true;
private boolean bIncludeOriginal = false;
private boolean bUseTitle = true;
private boolean bUseDescription = true;
private String sUplink = "";
private String sDirectoryIcon = "";
private String sDocumentIcon = "";
private String sTemplateURL = null;
public BatchConverter(XComponentContext xComponentContext) {
this.xComponentContext = xComponentContext;
// Get the SimpleFileAccess service
try {
Object sfaObject = xComponentContext.getServiceManager().createInstanceWithContext(
"com.sun.star.ucb.SimpleFileAccess", xComponentContext);
sfa2 = (XSimpleFileAccess2) UnoRuntime.queryInterface(XSimpleFileAccess2.class, sfaObject);
}
catch (com.sun.star.uno.Exception e) {
// failed to get SimpleFileAccess service (should not happen)
}
}
// Helper: Get a string from an any
private String getValue(Object any) {
if (AnyConverter.isString(any)) {
try {
return AnyConverter.toString(any);
}
catch (com.sun.star.lang.IllegalArgumentException e) {
return "";
}
}
else {
return "";
}
}
// Implementation of XBatchConverter:
public void convert(String sSourceURL, String sTargetURL, PropertyValue[] lArguments, XBatchHandler handler) {
// Create batch converter (currently we don't need to set a converter)
batchConverter = ConverterFactory.createBatchConverter(MIMETypes.XHTML);
this.handler = handler;
// Read the arguments
int nSize = lArguments.length;
for (int i=0; i0) {
entry.setDisplayName(loadedTitle);
}
String loadedDescription = docProps.getDescription();
if (bUseDescription && loadedDescription.length()>0) {
entry.setDescription(loadedDescription);
}
// Determine the type of the component
boolean bText = false;
boolean bSpreadsheet = false;
if (UnoRuntime.queryInterface(XTextDocument.class, xDocument)!=null) { bText=true; }
else if (UnoRuntime.queryInterface(XSpreadsheetDocument.class, xDocument)!=null) { bSpreadsheet=true; }
if (!bText && !bSpreadsheet) {
handler.endFile(sSourceFileURL,false);
xDocument.dispose();
return null;
}
// Convert using requested filter
boolean bHtmlSuccess = true;
PropertyHelper exportProps = new PropertyHelper();
exportProps.put("FilterName", bText ? sWriterFilterName : sCalcFilterName);
exportProps.put("Overwrite", new Boolean(true));
if (bText && writerFilterData!=null) { exportProps.put("FilterData", writerFilterData); }
if (bSpreadsheet && calcFilterData!=null) { exportProps.put("FilterData", calcFilterData); }
try {
XStorable xStore = (XStorable) UnoRuntime.queryInterface (XStorable.class, xDocument);
xStore.storeToURL (sTargetFileURL, exportProps.toArray());
}
catch (com.sun.star.io.IOException e) {
// Failed to convert; continue anyway, but don't link to the file name
entry.setFile(null);
bHtmlSuccess = false;
}
// Convet to pdf if requested
boolean bPdfSuccess = true;
if (bIncludePdf) {
PropertyValue[] pdfProps = new PropertyValue[2];
pdfProps[0] = new PropertyValue();
pdfProps[0].Name = "FilterName";
pdfProps[0].Value = bText ? "writer_pdf_Export" : "calc_pdf_Export";
pdfProps[1] = new PropertyValue();
pdfProps[1].Name = "Overwrite";
pdfProps[1].Value = new Boolean(true);
String sPdfFileURL = ensureSlash(sTargetURL) + getBaseName(sSourceFileURL) + ".pdf";
try {
XStorable xStore = (XStorable) UnoRuntime.queryInterface (XStorable.class, xDocument);
xStore.storeToURL (sPdfFileURL, pdfProps);
entry.setPdfFile(sPdfFileURL);
}
catch (com.sun.star.io.IOException e) {
// Not critical, continue without pdf
bPdfSuccess = false;
}
}
xDocument.dispose();
// Include original document if required
if (bIncludeOriginal) {
// TODO
}
// Report a failure to the user if either of the exports failed
handler.endFile(sSourceFileURL,bHtmlSuccess && bPdfSuccess);
// But return the index entry even if only one succeded
if (bHtmlSuccess || bPdfSuccess) { return entry; }
else { return null; }
}
private String getName(String sURL) {
int n = sURL.lastIndexOf("/");
return n>-1 ? sURL.substring(n+1) : sURL;
}
private String getBaseName(String sURL) {
String sName = getName(sURL);
int n = sName.lastIndexOf(".");
return n>-1 ? sName.substring(0,n) : sName;
}
private String ensureSlash(String sURL) {
return sURL.endsWith("/") ? sURL : sURL+"/";
}
private String decodeURL(String sURL) {
try {
return new URI(sURL).getPath();
}
catch (URISyntaxException e) {
return sURL;
}
}
// Implement methods from interface XTypeProvider
public com.sun.star.uno.Type[] getTypes() {
Type[] typeReturn = {};
try {
typeReturn = new Type[] {
new Type( XBatchConverter.class ),
new Type( XTypeProvider.class ),
new Type( XServiceName.class ),
new Type( XServiceInfo.class ) };
}
catch( Exception exception ) {
}
return( typeReturn );
}
public byte[] getImplementationId() {
byte[] byteReturn = {};
byteReturn = new String( "" + this.hashCode() ).getBytes();
return( byteReturn );
}
// Implement method from interface XServiceName
public String getServiceName() {
return( __serviceName );
}
// Implement methods from interface XServiceInfo
public boolean supportsService(String stringServiceName) {
return( stringServiceName.equals( __serviceName ) );
}
public String getImplementationName() {
return( __implementationName );
}
public String[] getSupportedServiceNames() {
String[] stringSupportedServiceNames = { __serviceName };
return( stringSupportedServiceNames );
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/XhtmlOptionsDialog.java 0000644 0001750 0001750 00000021343 12411277733 030245 0 ustar rene rene /************************************************************************
*
* XhtmlOptionsDialog.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-25)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import com.sun.star.awt.XDialog;
import com.sun.star.beans.XPropertySet;
import com.sun.star.uno.XComponentContext;
import org.openoffice.da.comp.w2lcommon.helper.PropertyHelper;
import org.openoffice.da.comp.w2lcommon.filter.OptionsDialogBase;
/** This class provides a uno component which implements a filter ui for the
* Xhtml export
*/
public class XhtmlOptionsDialog extends OptionsDialogBase {
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2xhtml.XhtmlOptionsDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2xhtml.XhtmlOptionsDialog";
public String getDialogLibraryName() { return "W2XDialogs"; }
/** Return the name of the dialog within the library
*/
public String getDialogName() { return "XhtmlOptions"; }
/** Return the name of the registry path
*/
public String getRegistryPath() {
return "/org.openoffice.da.Writer2xhtml.Options/XhtmlOptions";
}
/** Create a new XhtmlOptionsDialog */
public XhtmlOptionsDialog(XComponentContext xContext) {
super(xContext);
xMSF = W2XRegistration.xMultiServiceFactory;
}
/** Load settings from the registry to the dialog */
protected void loadSettings(XPropertySet xProps) {
// Style
loadConfig(xProps);
loadCheckBoxOption(xProps, "ConvertToPx");
int nScaling = loadNumericOption(xProps, "Scaling");
if (nScaling<=1) { // Workaround for an obscure bug in the extension manager
setNumericFieldValue("Scaling",100);
}
int nColumnScaling = loadNumericOption(xProps, "ColumnScaling");
if (nColumnScaling<=1) {
setNumericFieldValue("ColumnScaling",100);
}
loadCheckBoxOption(xProps, "OriginalImageSize");
// Special content
loadCheckBoxOption(xProps, "Notes");
loadCheckBoxOption(xProps, "UseDublinCore");
// AutoCorrect
loadCheckBoxOption(xProps, "IgnoreHardLineBreaks");
loadCheckBoxOption(xProps, "IgnoreEmptyParagraphs");
loadCheckBoxOption(xProps, "IgnoreDoubleSpaces");
// Files
loadCheckBoxOption(xProps, "Split");
loadListBoxOption(xProps, "SplitLevel");
loadListBoxOption(xProps, "RepeatLevels");
loadCheckBoxOption(xProps, "SaveImagesInSubdir");
loadCheckBoxOption(xProps, "UseMathjax");
updateLockedOptions();
enableControls();
}
/** Save settings from the dialog to the registry and create FilterData */
protected void saveSettings(XPropertySet xProps, PropertyHelper helper) {
// Style
short nConfig = saveConfig(xProps, helper);
String[] sCoreStyles = { "Chocolate", "Midnight", "Modernist",
"Oldstyle", "Steely", "Swiss", "Traditional", "Ultramarine" };
switch (nConfig) {
case 0: helper.put("ConfigURL","*default.xml"); break;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8: helper.put("ConfigURL","*cleanxhtml.xml");
helper.put("custom_stylesheet", "http://www.w3.org/StyleSheets/Core/"+sCoreStyles[nConfig-1]);
break;
case 9: helper.put("ConfigURL","$(user)/writer2xhtml.xml");
helper.put("AutoCreate","true");
helper.put("TemplateURL", "$(user)/writer2xhtml-template.xhtml");
helper.put("StyleSheetURL", "$(user)/writer2xhtml-styles.css");
}
saveCheckBoxOption(xProps, helper, "ConvertToPx", "convert_to_px");
saveNumericOptionAsPercentage(xProps, helper, "Scaling", "scaling");
saveNumericOptionAsPercentage(xProps, helper, "ColumnScaling", "column_scaling");
saveCheckBoxOption(xProps, "OriginalImageSize");
// TODO: Support "relative"
helper.put("image_size", getCheckBoxStateAsBoolean("OriginalImageSize") ? "none" : "absolute");
// Special content
saveCheckBoxOption(xProps, helper, "Notes", "notes");
saveCheckBoxOption(xProps, helper, "UseDublinCore", "use_dublin_core");
// AutoCorrect
saveCheckBoxOption(xProps, helper, "IgnoreHardLineBreaks", "ignore_hard_line_breaks");
saveCheckBoxOption(xProps, helper, "IgnoreEmptyParagraphs", "ignore_empty_paragraphs");
saveCheckBoxOption(xProps, helper, "IgnoreDoubleSpaces", "ignore_double_spaces");
// Files
boolean bSplit = saveCheckBoxOption(xProps, "Split");
short nSplitLevel = saveListBoxOption(xProps, "SplitLevel");
short nRepeatLevels = saveListBoxOption(xProps, "RepeatLevels");
if (!isLocked("split_level")) {
if (bSplit) {
helper.put("split_level",Integer.toString(nSplitLevel+1));
helper.put("repeat_levels",Integer.toString(nRepeatLevels));
}
else {
helper.put("split_level","0");
}
}
saveCheckBoxOption(xProps, helper, "SaveImagesInSubdir", "save_images_in_subdir");
saveCheckBoxOption(xProps, helper, "UseMathjax", "use_mathjax");
}
// Implement XDialogEventHandler
public boolean callHandlerMethod(XDialog xDialog, Object event, String sMethod) {
if (sMethod.equals("ConfigChange")) {
updateLockedOptions();
enableControls();
}
else if (sMethod.equals("SplitChange")) {
enableSplitLevel();
}
return true;
}
public String[] getSupportedMethodNames() {
String[] sNames = { "ConfigChange", "SplitChange" };
return sNames;
}
private void enableControls() {
// Style
setControlEnabled("ScalingLabel",!isLocked("scaling"));
setControlEnabled("Scaling",!isLocked("scaling"));
setControlEnabled("ColumnScalingLabel",!isLocked("column_scaling"));
setControlEnabled("ColumnScaling",!isLocked("column_scaling"));
setControlEnabled("ConvertToPx",!isLocked("convert_to_px"));
setControlEnabled("OriginalImageSize",!isLocked("image_size") && !isLocked("original_image_size"));
// Special content
setControlEnabled("Notes",!isLocked("notes"));
setControlEnabled("UseDublinCore",!isLocked("use_dublin_core"));
// AutoCorrect
setControlEnabled("IgnoreHardLineBreaks",!isLocked("ignore_hard_line_breaks"));
setControlEnabled("IgnoreEmptyParagraphs",!isLocked("ignore_empty_paragraphs"));
setControlEnabled("IgnoreDoubleSpaces",!isLocked("ignore_double_spaces"));
// Files
boolean bSplit = getCheckBoxStateAsBoolean("Split");
setControlEnabled("Split",!isLocked("split_level"));
setControlEnabled("SplitLevelLabel",!isLocked("split_level") && bSplit);
setControlEnabled("SplitLevel",!isLocked("split_level") && bSplit);
setControlEnabled("RepeatLevelsLabel",!isLocked("repeat_levels") && !isLocked("split_level") && bSplit);
setControlEnabled("RepeatLevels",!isLocked("repeat_levels") && !isLocked("split_level") && bSplit);
setControlEnabled("SaveImagesInSubdir",!isLocked("save_images_in_subdir"));
setControlEnabled("UseMathjax",(this instanceof XhtmlOptionsDialogMath) && !isLocked("use_mathjax"));
}
private void enableSplitLevel() {
if (!isLocked("split_level")) {
boolean bState = getCheckBoxStateAsBoolean("Split");
setControlEnabled("SplitLevelLabel",bState);
setControlEnabled("SplitLevel",bState);
if (!isLocked("repeat_levels")) {
setControlEnabled("RepeatLevelsLabel",bState);
setControlEnabled("RepeatLevels",bState);
}
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/W2XExportFilter.java 0000644 0001750 0001750 00000003351 11251136744 027441 0 ustar rene rene /************************************************************************
*
* W2XExportFilter.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-09-06)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import com.sun.star.uno.XComponentContext;
import org.openoffice.da.comp.w2lcommon.filter.ExportFilterBase;
/** This class implements the xhtml export filter component
*/
public class W2XExportFilter extends ExportFilterBase {
/** Service name for the component */
public static final String __serviceName = "org.openoffice.da.comp.writer2xhtml.W2XExportFilter";
/** Implementation name for the component */
public static final String __implementationName = "org.openoffice.da.comp.writer2xhtml.W2XExportFilter";
/** Filter name to include in error messages */
public final String __displayName = "Writer2xhtml";
public W2XExportFilter(XComponentContext xComponentContext1) {
super(xComponentContext1);
xMSF = W2XRegistration.xMultiServiceFactory;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/XhtmlOptionsDialogCalc.java 0000644 0001750 0001750 00000016155 12411277733 031035 0 ustar rene rene /************************************************************************
*
* XhtmlOptionsDialogCalc.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-25)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import com.sun.star.awt.XDialog;
import com.sun.star.beans.XPropertySet;
import com.sun.star.uno.XComponentContext;
import org.openoffice.da.comp.w2lcommon.helper.PropertyHelper;
import org.openoffice.da.comp.w2lcommon.filter.OptionsDialogBase;
/** This class provides a uno component which implements a filter ui for the
* Xhtml export in Calc
*/
public class XhtmlOptionsDialogCalc extends OptionsDialogBase {
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writerxhtml.XhtmlOptionsDialogCalc";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2xhtml.XhtmlOptionsDialogCalc";
public String getDialogLibraryName() { return "W2XDialogs"; }
/** Return the name of the dialog within the library
*/
public String getDialogName() { return "XhtmlOptionsCalc"; }
/** Return the name of the registry path
*/
public String getRegistryPath() {
return "/org.openoffice.da.Writer2xhtml.Options/XhtmlOptionsCalc";
}
/** Create a new XhtmlOptionsDialogCalc */
public XhtmlOptionsDialogCalc(XComponentContext xContext) {
super(xContext);
xMSF = W2XRegistration.xMultiServiceFactory;
}
/** Load settings from the registry to the dialog */
protected void loadSettings(XPropertySet xProps) {
// Style
loadConfig(xProps);
loadCheckBoxOption(xProps, "ConvertToPx");
int nScaling = loadNumericOption(xProps, "Scaling");
if (nScaling<=1) { // Workaround for an obscure bug in the extension manager
setNumericFieldValue("Scaling",100);
}
int nColumnScaling = loadNumericOption(xProps, "ColumnScaling");
if (nColumnScaling<=1) {
setNumericFieldValue("ColumnScaling",100);
}
loadCheckBoxOption(xProps, "OriginalImageSize");
// Special content
loadCheckBoxOption(xProps, "Notes");
loadCheckBoxOption(xProps, "UseDublinCore");
// Sheets
loadCheckBoxOption(xProps, "DisplayHiddenSheets");
loadCheckBoxOption(xProps, "DisplayHiddenRowsCols");
loadCheckBoxOption(xProps, "DisplayFilteredRowsCols");
loadCheckBoxOption(xProps, "ApplyPrintRanges");
loadCheckBoxOption(xProps, "UseTitleAsHeading");
loadCheckBoxOption(xProps, "UseSheetNamesAsHeadings");
// Files
loadCheckBoxOption(xProps, "CalcSplit");
loadCheckBoxOption(xProps, "SaveImagesInSubdir");
updateLockedOptions();
enableControls();
}
/** Save settings from the dialog to the registry and create FilterData */
protected void saveSettings(XPropertySet xProps, PropertyHelper helper) {
// Style
short nConfig = saveConfig(xProps, helper);
if (nConfig==0) {
helper.put("ConfigURL","*default.xml");
}
else if (nConfig==1) {
helper.put("ConfigURL","$(user)/writer2xhtml.xml");
helper.put("AutoCreate","true");
}
saveCheckBoxOption(xProps, helper, "ConvertToPx", "convert_to_px");
saveNumericOptionAsPercentage(xProps, helper, "Scaling", "scaling");
saveNumericOptionAsPercentage(xProps, helper, "ColumnScaling", "column_scaling");
saveCheckBoxOption(xProps, "OriginalImageSize");
// TODO: Support "relative"
helper.put("image_size", getCheckBoxStateAsBoolean("OriginalImageSize") ? "none" : "absolute");
// Special content
saveCheckBoxOption(xProps, helper, "Notes", "notes");
saveCheckBoxOption(xProps, helper, "UseDublinCore", "use_dublin_core");
// Sheets
saveCheckBoxOption(xProps, helper, "DisplayHiddenSheets", "display_hidden_sheets");
saveCheckBoxOption(xProps, helper, "DisplayHiddenRowsCols", "display_hidden_rows_cols");
saveCheckBoxOption(xProps, helper, "DisplayFilteredRowsCols", "display_filtered_rows_cols");
saveCheckBoxOption(xProps, helper, "ApplyPrintRanges", "apply_print_ranges");
saveCheckBoxOption(xProps, helper, "UseTitleAsHeading", "use_title_as_heading");
saveCheckBoxOption(xProps, helper, "UseSheetNamesAsHeadings", "use_sheet_names_as_headings");
// Files
saveCheckBoxOption(xProps, helper, "CalcSplit", "calc_split");
saveCheckBoxOption(xProps, helper, "SaveImagesInSubdir", "save_images_in_subdir");
}
// Implement XDialogEventHandler
public boolean callHandlerMethod(XDialog xDialog, Object event, String sMethod) {
if (sMethod.equals("ConfigChange")) {
updateLockedOptions();
enableControls();
}
return true;
}
public String[] getSupportedMethodNames() {
String[] sNames = { "ConfigChange" };
return sNames;
}
private void enableControls() {
// Style
setControlEnabled("ConvertToPx",!isLocked("convert_to_px"));
setControlEnabled("ScalingLabel",!isLocked("scaling"));
setControlEnabled("Scaling",!isLocked("scaling"));
setControlEnabled("ColumnScalingLabel",!isLocked("column_scaling"));
setControlEnabled("ColumnScaling",!isLocked("column_scaling"));
setControlEnabled("OriginalImageSize",!isLocked("image_size") && !isLocked("original_image_size"));
// Special content
setControlEnabled("Notes",!isLocked("notes"));
setControlEnabled("UseDublinCore",!isLocked("use_dublin_core"));
// Sheets
setControlEnabled("DisplayHiddenSheets", !isLocked("display_hidden_sheets"));
setControlEnabled("DisplayHiddenRowsCols", !isLocked("display_hidden_rows_cols"));
setControlEnabled("DisplayFilteredRowsCols", !isLocked("display_filtered_rows_cols"));
setControlEnabled("ApplyPrintRanges", !isLocked("apply_print_ranges"));
setControlEnabled("UseTitleAsHeading", !isLocked("use_title_as_heading"));
setControlEnabled("UseSheetNamesAsHeadings", !isLocked("use_sheet_names_as_headings"));
// Files
setControlEnabled("CalcSplit",!isLocked("calc_split"));
setControlEnabled("SaveImagesInSubdir",!isLocked("save_images_in_subdir"));
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2xhtml/EpubMetadataDialog.java 0000644 0001750 0001750 00000060411 12411031012 030102 0 ustar rene rene /************************************************************************
*
* EpubMetadataDialog.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-2011 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-07-20)
*
*/
package org.openoffice.da.comp.writer2xhtml;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.openoffice.da.comp.w2lcommon.helper.DialogBase;
import org.openoffice.da.comp.w2lcommon.helper.SimpleDialog;
import writer2latex.util.CSVList;
import writer2latex.util.Misc;
import com.sun.star.awt.XDialog;
import com.sun.star.beans.IllegalTypeException;
import com.sun.star.beans.NotRemoveableException;
import com.sun.star.beans.Property;
import com.sun.star.beans.PropertyExistException;
import com.sun.star.beans.PropertyVetoException;
import com.sun.star.beans.UnknownPropertyException;
import com.sun.star.beans.XPropertyContainer;
import com.sun.star.beans.XPropertySet;
import com.sun.star.document.XDocumentProperties;
import com.sun.star.document.XDocumentPropertiesSupplier;
import com.sun.star.frame.XDesktop;
import com.sun.star.lang.IllegalArgumentException;
import com.sun.star.lang.WrappedTargetException;
import com.sun.star.lang.XComponent;
import com.sun.star.ui.dialogs.ExecutableDialogResults;
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.DateTime;
// TODO: Create the UNO helper class DocumentPropertiesAccess
/** This class provides a UNO component which implements a custom metadata editor UI for the EPUB export
*/
public class EpubMetadataDialog extends DialogBase {
// Author data
private class AuthorInfo {
String sName = "";
boolean isCreator = true;
String sRole = "";
}
// Date data
private class DateInfo {
int nDate = 0;
String sEvent = "";
}
// All the user defined properties we handle
private static final String IDENTIFIER="Identifier";
private static final String CREATOR="Creator";
private static final String CONTRIBUTOR="Contributor";
private static final String DATE="Date";
private static final String PUBLISHER="Publisher";
private static final String TYPE="Type";
private static final String FORMAT="Format";
private static final String SOURCE="Source";
private static final String RELATION="Relation";
private static final String COVERAGE="Coverage";
private static final String RIGHTS="Rights";
private static final String[] sRoles = {"", "adp", "ann", "arr", "art", "asn", "aut", "aqt", "aft", "aui", "ant", "bkp",
"clb", "cmm", "dsr", "edt", "ill", "lyr", "mdc", "mus", "nrt", "oth", "pht", "prt", "red", "rev", "spn", "ths", "trc", "trl"};
private static HashMap backRoles;
static {
backRoles = new HashMap();
int nCount = sRoles.length;
for (short i=0; i authors = new Vector();
private Vector dates = new Vector();
// Number formatter
private NumberFormat formatter = new DecimalFormat("00");
// Pattern matcher for dates
Pattern datePattern = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
public EpubMetadataDialog(XComponentContext xContext) {
super(xContext);
}
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2xhtml.EpubMetadataDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2xhtml.EpubMetadataDialog";
// --------------------------------------------------
// Ensure that the super can find us :-)
@Override public String getDialogLibraryName() {
return "W2XDialogs2";
}
@Override public String getDialogName() {
return "EpubMetadata";
}
// --------------------------------------------------
// Implement the interface XDialogEventHandler
@Override public boolean callHandlerMethod(XDialog xDialog, Object event, String sMethod) {
if (sMethod.equals("UseCustomIdentifierChange")) {
return useCustomIdentifierChange();
}
else if (sMethod.equals("AuthorAddClick")) {
return authorAddclick();
}
else if (sMethod.equals("AuthorModifyClick")) {
return authorModifyclick();
}
else if (sMethod.equals("AuthorDeleteClick")) {
return authorDeleteclick();
}
else if (sMethod.equals("AuthorUpClick")) {
return authorUpclick();
}
else if (sMethod.equals("AuthorDownClick")) {
return authorDownclick();
}
else if (sMethod.equals("DateAddClick")) {
return dateAddClick();
}
else if (sMethod.equals("DateModifyClick")) {
return dateModifyClick();
}
else if (sMethod.equals("DateDeleteClick")) {
return dateDeleteClick();
}
else if (sMethod.equals("DateUpClick")) {
return dateUpClick();
}
else if (sMethod.equals("DateDownClick")) {
return dateDownClick();
}
return false;
}
@Override public String[] getSupportedMethodNames() {
String[] sNames = { "UseCustomIdentifierChange",
"AuthorAddClick", "AuthorModifyClick", "AuthorDeleteClick", "AuthorUpClick", "AuthorDownClick",
"DataAddClick", "DateModifyClick", "DateDeleteClick", "DateUpClick", "DateDownClick"};
return sNames;
}
private boolean useCustomIdentifierChange() {
boolean bEnabled = getCheckBoxStateAsBoolean("UseCustomIdentifier");
setControlEnabled("IdentifierLabel",bEnabled);
setControlEnabled("Identifier",bEnabled);
setControlEnabled("IdentifierTypeLabel",bEnabled);
setControlEnabled("IdentifierType",bEnabled);
return true;
}
private boolean authorAddclick() {
SimpleDialog dialog = new SimpleDialog(xContext,"W2XDialogs2.AuthorDialog");
if (dialog.getDialog()!=null) {
dialog.getControls().setListBoxSelectedItem("Type", (short) 0);
dialog.getControls().setListBoxSelectedItem("Role", (short) 0);
if (dialog.getDialog().execute()==ExecutableDialogResults.OK) {
AuthorInfo author = new AuthorInfo();
author.sName = dialog.getControls().getTextFieldText("Author");
author.sRole = sRoles[dialog.getControls().getListBoxSelectedItem("Role")];
author.isCreator = dialog.getControls().getListBoxSelectedItem("Type")==0;
authors.add(author);
updateAuthorList((short) (authors.size()-1));
}
dialog.getDialog().endExecute();
}
return true;
}
private boolean authorModifyclick() {
short nIndex = getListBoxSelectedItem("Authors");
AuthorInfo author = authors.get(nIndex);
SimpleDialog dialog = new SimpleDialog(xContext,"W2XDialogs2.AuthorDialog");
if (dialog.getDialog()!=null) {
dialog.getControls().setTextFieldText("Author", author.sName);
dialog.getControls().setListBoxSelectedItem("Type", author.isCreator ? (short)0 : (short) 1);
dialog.getControls().setListBoxSelectedItem("Role", backRoles.containsKey(author.sRole)? backRoles.get(author.sRole) : (short)0);
if (dialog.getDialog().execute()==ExecutableDialogResults.OK) {
author.sName = dialog.getControls().getTextFieldText("Author");
author.sRole = sRoles[dialog.getControls().getListBoxSelectedItem("Role")];
author.isCreator = dialog.getControls().getListBoxSelectedItem("Type")==0;
updateAuthorList(nIndex);
}
dialog.getDialog().endExecute();
}
return true;
}
private boolean authorDeleteclick() {
if (authors.size()>0) {
SimpleDialog dialog = new SimpleDialog(xContext,"W2XDialogs2.DeleteDialog");
if (dialog.getDialog()!=null) {
short nIndex = getListBoxSelectedItem("Authors");
String sLabel = dialog.getControls().getLabelText("DeleteLabel");
sLabel = sLabel.replaceAll("%s", authors.get(nIndex).sName);
dialog.getControls().setLabelText("DeleteLabel", sLabel);
if (dialog.getDialog().execute()==ExecutableDialogResults.OK) {
authors.remove(nIndex);
updateAuthorList(nIndex0) {
AuthorInfo author = authors.get(nIndex);
authors.set(nIndex, authors.get(nIndex-1));
authors.set(nIndex-1, author);
updateAuthorList((short) (nIndex-1));
}
return true;
}
private boolean authorDownclick() {
short nIndex = getListBoxSelectedItem("Authors");
if (nIndex+10) {
SimpleDialog dialog = new SimpleDialog(xContext,"W2XDialogs2.DeleteDialog");
if (dialog.getDialog()!=null) {
short nIndex = getListBoxSelectedItem("Dates");
String sLabel = dialog.getControls().getLabelText("DeleteLabel");
sLabel = sLabel.replaceAll("%s", formatDate(dates.get(nIndex).nDate));
dialog.getControls().setLabelText("DeleteLabel", sLabel);
if (dialog.getDialog().execute()==ExecutableDialogResults.OK) {
dates.remove(nIndex);
updateDateList(nIndex0) {
DateInfo date = dates.get(nIndex);
dates.set(nIndex, dates.get(nIndex-1));
dates.set(nIndex-1, date);
updateDateList((short) (nIndex-1));
}
return true;
}
private boolean dateDownClick() {
short nIndex = getListBoxSelectedItem("Dates");
if (nIndex+10);
useCustomIdentifierChange();
if (sIdentifiers.length>0) { // Use the first if we have several...
setTextFieldText("Identifier",getStringValue(sIdentifiers[0]));
setTextFieldText("IdentifierType",getSuffix(sIdentifiers[0]));
}
// Get the authors and set the list box
String[] sCreators = getProperties(CREATOR,false);
for (String sCreator : sCreators) {
AuthorInfo creator = new AuthorInfo();
creator.sName = getStringValue(sCreator);
creator.sRole = getSuffix(sCreator);
creator.isCreator = true;
authors.add(creator);
}
String[] sContributors = getProperties(CONTRIBUTOR,false);
for (String sContributor : sContributors) {
AuthorInfo contributor = new AuthorInfo();
contributor.sName = getStringValue(sContributor);
contributor.sRole = getSuffix(sContributor);
contributor.isCreator = false;
authors.add(contributor);
}
updateAuthorList((short) 0);
// Get the dates and set the list box
String[] sDates = getProperties(DATE,false);
for (String sDate : sDates) {
DateInfo date = new DateInfo();
DateTime dt = getDateValue(sDate);
if (dt!=null) { // We accept either a date
date.nDate = datetime2int(dt);
}
else { // Or a string in the form yyyy-mm-dd
date.nDate = parseDate(getStringValue(sDate));
}
date.sEvent = getSuffix(sDate);
dates.add(date);
}
updateDateList((short) 0);
// Get the standard properties and set the text fields
setTextFieldText("Title",xDocumentProperties.getTitle());
setTextFieldText("Subject",xDocumentProperties.getSubject());
String[] sKeywords = xDocumentProperties.getKeywords();
CSVList keywords = new CSVList(", ");
for (String sKeyword : sKeywords) {
keywords.addValue(sKeyword);
}
setTextFieldText("Keywords",keywords.toString());
setTextFieldText("Description",xDocumentProperties.getDescription());
// Get the simple user properties and set the text fields
readSimpleProperty(PUBLISHER);
readSimpleProperty(TYPE);
readSimpleProperty(FORMAT);
readSimpleProperty(SOURCE);
readSimpleProperty(RELATION);
readSimpleProperty(COVERAGE);
readSimpleProperty(RIGHTS);
}
@Override protected void endDialog() {
// Set the custom identifier from the text fields
String[] sIdentifiers = getProperties(IDENTIFIER,false);
for (String sIdentifier : sIdentifiers) { // Remove old identifier(s)
removeProperty(sIdentifier);
}
if (getCheckBoxStateAsBoolean("UseCustomIdentifier")) {
String sName = IDENTIFIER;
if (getTextFieldText("IdentifierType").trim().length()>0) {
sName+="."+getTextFieldText("IdentifierType").trim();
}
addProperty(sName);
setValue(sName,getTextFieldText("Identifier"));
}
// Set the authors from the list box
String[] sCreators = getProperties(CREATOR,false);
for (String sCreator : sCreators) { // remove old creators
removeProperty(sCreator);
}
String[] sContributors = getProperties(CONTRIBUTOR,false);
for (String sContributor : sContributors) { // remove old contributors
removeProperty(sContributor);
}
int i=0;
for (AuthorInfo author : authors) {
String sName = (author.isCreator ? CREATOR : CONTRIBUTOR)+formatter.format(++i);
if (author.sRole.length()>0) {
sName+="."+author.sRole;
}
addProperty(sName);
setValue(sName,author.sName);
}
// Set the dates from the list box
String[] sDates = getProperties(DATE,false);
for (String sDate : sDates) { // remove old dates
removeProperty(sDate);
}
i=0;
for (DateInfo date : dates) {
String sName = DATE+formatter.format(++i);
if (date.sEvent.length()>0) {
sName+="."+date.sEvent;
}
addProperty(sName);
setValue(sName,formatDate(date.nDate));
// Doesn't work (why not?)
//setValue(sName,int2datetime(date.nDate));
}
// Set the standard properties from the text fields
xDocumentProperties.setTitle(getTextFieldText("Title"));
xDocumentProperties.setSubject(getTextFieldText("Subject"));
String[] sKeywords = getTextFieldText("Keywords").split(",");
for (int j=0; j-1 ? sPropertyName.substring(nDot+1) : "";
}
// Get all currently defined user properties with a specific name or prefix
private String[] getProperties(String sPrefix, boolean bComplete) {
HashSet names = new HashSet();
Property[] xProps = xUserPropertySet.getPropertySetInfo().getProperties();
for (Property prop : xProps) {
String sName = prop.Name;
String sLCName = sName.toLowerCase();
String sLCPrefix = sPrefix.toLowerCase();
if ((bComplete && sLCName.equals(sLCPrefix)) || (!bComplete && sLCName.startsWith(sLCPrefix))) {
names.add(sName);
}
}
return Misc.sortStringSet(names);
}
// Add a user property
private void addProperty(String sName) {
try {
xUserProperties.addProperty(sName, (short) 128, ""); // 128 means removeable, last parameter is default value
} catch (PropertyExistException e) {
} catch (IllegalTypeException e) {
} catch (IllegalArgumentException e) {
}
}
// Delete a user property
private void removeProperty(String sName) {
try {
xUserProperties.removeProperty(sName);
} catch (UnknownPropertyException e) {
} catch (NotRemoveableException e) {
}
}
// Set the value of a user property (failing silently if the property does not exist)
private void setValue(String sName, Object value) {
try {
xUserPropertySet.setPropertyValue(sName, value);
} catch (UnknownPropertyException e) {
} catch (PropertyVetoException e) {
} catch (IllegalArgumentException e) {
} catch (WrappedTargetException e) {
}
}
// Get the string value of a user property (returning null if the property does not exist)
private String getStringValue(String sName) {
Object value = getValue(sName);
if (value!=null && AnyConverter.isString(value)) {
try {
return AnyConverter.toString(value);
} catch (IllegalArgumentException e) {
return null;
}
}
return null;
}
private DateTime getDateValue(String sName) {
Object value = getValue(sName);
if (value!=null && value instanceof DateTime) {
return (DateTime) value;
}
return null;
}
// Get the value of a user property (returning null if the property does not exist)
private Object getValue(String sName) {
try {
return xUserPropertySet.getPropertyValue(sName);
} catch (UnknownPropertyException e) {
return null;
} catch (WrappedTargetException e) {
return null;
}
}
private void updateAuthorList(short nItem) {
int nCount = authors.size();
if (nCount>0) {
String[] sAuthors = new String[nCount];
for (int i=0; i0 ? ", "+author.sRole : "")
+")";
}
setListBoxStringItemList("Authors", sAuthors);
setListBoxSelectedItem("Authors",nItem);
setControlEnabled("Authors", true);
}
else { // Display the fall-back author
String[] sAuthors = new String[1];
//sAuthors[0] = xDocumentProperties.getAuthor()+" (default creator)";
sAuthors[0] = xDocumentProperties.getModifiedBy()+" (default creator)";
setListBoxStringItemList("Authors", sAuthors);
setControlEnabled("Authors", false);
}
setControlEnabled("ModifyAuthorButton",nCount>0);
setControlEnabled("DeleteAuthorButton",nCount>0);
setControlEnabled("AuthorUpButton",nCount>1);
setControlEnabled("AuthorDownButton",nCount>1);
}
private void updateDateList(short nItem) {
int nCount = dates.size();
if (nCount>0) {
String[] sDates = new String[nCount];
for (int i=0; i0) {
sDates[i]+=" (" + date.sEvent + ")";
}
}
setListBoxStringItemList("Dates", sDates);
setListBoxSelectedItem("Dates",nItem);
setControlEnabled("Dates", true);
}
else { // Display the fall-back date
String[] sDates = new String[1];
sDates[0] = formatDate(datetime2int(xDocumentProperties.getModificationDate()))+" (default date)";
setListBoxStringItemList("Dates", sDates);
setControlEnabled("Dates", false);
}
setControlEnabled("ModifyDateButton",nCount>0);
setControlEnabled("DeleteDateButton",nCount>0);
setControlEnabled("DateUpButton",nCount>1);
setControlEnabled("DateDownButton",nCount>1);
}
private void readSimpleProperty(String sName) {
String[] sNames = getProperties(sName,true);
if (sNames.length>0) {
String sValue = getStringValue(sNames[0]);
if (sValue!=null) {
setTextFieldText(sName, sValue);
}
}
}
private void writeSimpleProperty(String sName) {
String[] sOldNames = getProperties(sName,true);
for (String sOldName : sOldNames) {
removeProperty(sOldName);
}
String sValue = getTextFieldText(sName);
if (sValue.length()>0) {
addProperty(sName);
setValue(sName,sValue);
}
}
// Date fields uses integers for dates (format yyyymmdd)
// Document properties uses com.sun.star.util.DateTime
// Also dates should be formatted as yyyy-mm-dd as strings
// Thus we need a few conversion methods
// Format a integer date as yyyy-mm-dd
private String formatDate(int nDate) {
String sDate = Integer.toString(nDate);
if (sDate.length()==8) {
return sDate.substring(0,4)+"-"+sDate.substring(4, 6)+"-"+sDate.substring(6);
}
else {
return "???";
}
}
// Parse a string as a date in the format yyyy-mm-dd (returning 0 on failure)
private int parseDate(String sDate) {
Matcher matcher = datePattern.matcher(sDate);
if (matcher.matches()) {
return Misc.getPosInteger(matcher.group(1)+matcher.group(2)+matcher.group(3),0);
}
return 0;
}
// Convert an integer to com.sun.star.util.DateTime
/*private DateTime int2datetime(int nDate) {
DateTime date = new DateTime();
date.Year = (short) (nDate/10000);
date.Month = (short) ((nDate%10000)/100);
date.Day = (short) (nDate%100);
return date;
}*/
// Convert a com.sun.star.util.DateTime to integer
private int datetime2int(DateTime date) {
return 10000*date.Year+100*date.Month+date.Day;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2latex/ 0000755 0001750 0001750 00000000000 12603463650 023566 5 ustar rene rene writer2latex-1.4/source/java/org/openoffice/da/comp/writer2latex/W2LStarMathConverter.java 0000644 0001750 0001750 00000007514 11147474702 030402 0 ustar rene rene /************************************************************************
*
* W2LStarMathConverter.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-2008 by Henrik Just
*
* All Rights Reserved.
*/
// Version 1.0 (2008-11-22)
package org.openoffice.da.comp.writer2latex;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.lang.XTypeProvider;
import com.sun.star.uno.Type;
//import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.lang.XServiceName;
import writer2latex.api.ConverterFactory;
import writer2latex.api.StarMathConverter;
// Import interface as defined in uno idl
import org.openoffice.da.writer2latex.XW2LStarMathConverter;
/** This class provides a uno component which implements the interface
* org.openoffice.da.writer2latex.XW2LConverter
*/
public class W2LStarMathConverter implements
XW2LStarMathConverter,
XServiceName,
XServiceInfo,
XTypeProvider {
/** The component will be registered under this name.
*/
public static final String __serviceName = "org.openoffice.da.writer2latex.W2LStarMathConverter";
public static final String __implementationName = "org.openoffice.da.comp.writer2latex.W2LStarMathConverter";
//private static XComponentContext xComponentContext = null;
private static StarMathConverter starMathConverter;
public W2LStarMathConverter(XComponentContext xComponentContext1) {
starMathConverter = ConverterFactory.createStarMathConverter();
}
// Implementation of XW2LConverter:
public String convertFormula(String sStarMathFormula) {
return starMathConverter.convert(sStarMathFormula);
}
public String getPreamble() {
return starMathConverter.getPreamble();
}
// Implement methods from interface XTypeProvider
// Implementation of XTypeProvider
public com.sun.star.uno.Type[] getTypes() {
Type[] typeReturn = {};
try {
typeReturn = new Type[] {
new Type( XW2LStarMathConverter.class ),
new Type( XTypeProvider.class ),
new Type( XServiceName.class ),
new Type( XServiceInfo.class ) };
}
catch( Exception exception ) {
}
return( typeReturn );
}
public byte[] getImplementationId() {
byte[] byteReturn = {};
byteReturn = new String( "" + this.hashCode() ).getBytes();
return( byteReturn );
}
// Implement method from interface XServiceName
public String getServiceName() {
return( __serviceName );
}
// Implement methods from interface XServiceInfo
public boolean supportsService(String stringServiceName) {
return( stringServiceName.equals( __serviceName ) );
}
public String getImplementationName() {
return( __implementationName );
}
public String[] getSupportedServiceNames() {
String[] stringSupportedServiceNames = { __serviceName };
return( stringSupportedServiceNames );
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2latex/ConfigurationDialog.java 0000644 0001750 0001750 00000123410 12406234417 030357 0 ustar rene rene /************************************************************************
*
* ConfigurationDialog.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-16)
*
*/
package org.openoffice.da.comp.writer2latex;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import writer2latex.api.ComplexOption;
import writer2latex.util.Misc;
import org.openoffice.da.comp.w2lcommon.filter.ConfigurationDialogBase;
import org.openoffice.da.comp.w2lcommon.helper.DialogAccess;
import org.openoffice.da.comp.w2lcommon.helper.FieldMasterNameProvider;
import org.openoffice.da.comp.w2lcommon.helper.StyleNameProvider;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.uno.XComponentContext;
/** This class provides a UNO component which implements the configuration
* of Writer2LaTeX. The same component is used for all pages - using the
* dialog title to distinguish between the pages.
*/
public final class ConfigurationDialog extends ConfigurationDialogBase implements XServiceInfo {
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2latex.ConfigurationDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer2latex.ConfigurationDialog";
// 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;
}
// Configure the base class
@Override protected String getMIMEType() { return "application/x-latex"; }
@Override protected String getDialogLibraryName() { return "W2LDialogs2"; }
@Override protected String getConfigFileName() { return "writer2latex.xml"; }
/** Construct a new ConfigurationDialog */
public ConfigurationDialog(XComponentContext xContext) {
super(xContext);
pageHandlers.put("Documentclass", new DocumentclassHandler());
pageHandlers.put("Headings", new HeadingsHandler());
pageHandlers.put("Styles", new StylesHandler());
pageHandlers.put("Characters", new CharactersHandler());
pageHandlers.put("Fonts", new FontsHandler());
pageHandlers.put("Pages", new PagesHandler());
pageHandlers.put("Tables", new TablesHandler());
pageHandlers.put("Figures", new FiguresHandler());
pageHandlers.put("TextAndMath", new TextAndMathHandler());
}
// Implement remaining method from XContainerWindowEventHandler
public String[] getSupportedMethodNames() {
String[] sNames = {
"NoPreambleChange", // Documentclass
"MaxLevelChange", "WriterLevelChange", "NoIndexChange", // Headings
"StyleFamilyChange", "StyleNameChange", "NewStyleClick", "DeleteStyleClick", "AddNextClick",
"RemoveNextClick", "LoadDefaultsClick", // Styles
"UseSoulChange", "FormattingAttributeChange", "CustomAttributeChange", // Characters
"ExportGeometryChange", "ExportHeaderAndFooterChange", // Pages
"NoTablesChange", "UseSupertabularChange", "UseLongtableChange", // Tables
"NoImagesChange", // Figures
"MathSymbolNameChange", "NewSymbolClick", "DeleteSymbolClick",
"TextInputChange", "NewTextClick", "DeleteTextClick" // Text and Math
};
return sNames;
}
// The page "Documentclass"
// This page handles the options no_preamble, documentclass, global_options and the custom-preamble
private class DocumentclassHandler extends PageHandler {
@Override protected void setControls(DialogAccess dlg) {
checkBoxFromConfig(dlg,"NoPreamble","no_preamble");
textFieldFromConfig(dlg,"Documentclass","documentclass");
textFieldFromConfig(dlg,"GlobalOptions","global_options");
textFieldFromConfig(dlg,"CustomPreamble","custom-preamble");
noPreambleChange(dlg);
}
@Override protected void getControls(DialogAccess dlg) {
checkBoxToConfig(dlg,"NoPreamble", "no_preamble");
textFieldToConfig(dlg,"Documentclass","documentclass");
textFieldToConfig(dlg,"GlobalOptions","global_options");
textFieldToConfig(dlg,"CustomPreamble","custom-preamble");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("NoPreambleChange")) {
noPreambleChange(dlg);
return true;
}
return false;
}
private void noPreambleChange(DialogAccess dlg) {
boolean bPreamble = !dlg.getCheckBoxStateAsBoolean("NoPreamble");
dlg.setControlEnabled("DocumentclassLabel",bPreamble);
dlg.setControlEnabled("Documentclass",bPreamble);
dlg.setControlEnabled("GlobalOptionsLabel",bPreamble);
dlg.setControlEnabled("GlobalOptions",bPreamble);
dlg.setControlEnabled("CustomPreambleLabel",bPreamble);
dlg.setControlEnabled("CustomPreamble",bPreamble);
}
}
// The page "Headings"
// This page handles the heading map as well as the options no_index, use_titlesec and use_titletoc
private class HeadingsHandler extends PageHandler {
ComplexOption headingMap = new ComplexOption(); // Cached heading map
short nCurrentWriterLevel = -1; // Currently displayed level
@Override protected void setControls(DialogAccess dlg) {
// Load heading map from config
headingMap.clear();
headingMap.copyAll(config.getComplexOption("heading-map"));
nCurrentWriterLevel = -1;
// Determine and set the max level (from 0 to 10)
short nMaxLevel = 0;
while(nMaxLevel<10 && headingMap.containsKey(Integer.toString(nMaxLevel+1))) {
nMaxLevel++;
}
dlg.setListBoxSelectedItem("MaxLevel", nMaxLevel);
maxLevelChange(dlg);
// Get other controls from config
checkBoxFromConfig(dlg,"UseTitlesec","use_titlesec");
checkBoxFromConfig(dlg,"NoIndex","no_index");
checkBoxFromConfig(dlg,"UseTitletoc","use_titletoc");
noIndexChange(dlg);
}
@Override protected void getControls(DialogAccess dlg) {
updateHeadingMap(dlg);
// Save heading map to config
config.getComplexOption("heading-map").clear();
int nMaxLevel = dlg.getListBoxSelectedItem("MaxLevel");
for (int i=1; i<=nMaxLevel; i++) {
String sLevel = Integer.toString(i);
config.getComplexOption("heading-map").copy(sLevel,headingMap.get(sLevel));
}
// Save other controls to config
checkBoxToConfig(dlg,"UseTitlesec","use_titlesec");
checkBoxToConfig(dlg,"NoIndex","no_index");
checkBoxToConfig(dlg,"UseTitletoc","use_titletoc");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("MaxLevelChange")) {
maxLevelChange(dlg);
return true;
}
else if (sMethod.equals("WriterLevelChange")) {
writerLevelChange(dlg);
return true;
}
else if (sMethod.equals("NoIndexChange")) {
noIndexChange(dlg);
return true;
}
return false;
}
private void maxLevelChange(DialogAccess dlg) {
// Remember current writer level and clear it
short nPreviousWriterLevel = nCurrentWriterLevel;
dlg.setListBoxSelectedItem("WriterLevel", (short) -1);
// Adjust the presented writer levels to the max level
short nMaxLevel = dlg.getListBoxSelectedItem("MaxLevel");
String[] sWriterLevels = new String[nMaxLevel];
for (int i=0; i0) {
short nNewWriterLevel;
if (nPreviousWriterLevel+1>nMaxLevel) {
// If we lower the max level, we may have to change the displayed Writer level
nNewWriterLevel = (short)(nMaxLevel-1);
}
else if (nPreviousWriterLevel>-1){
// Otherwise reselect the current level, if any
nNewWriterLevel = nPreviousWriterLevel;
}
else {
// Or select the top level
nNewWriterLevel = (short) 0;
}
dlg.setListBoxSelectedItem("WriterLevel", nNewWriterLevel);
}
writerLevelChange(dlg);
// All controls should be disabled if the maximum level is zero
boolean bUpdate = dlg.getListBoxSelectedItem("MaxLevel")>0;
dlg.setControlEnabled("WriterLevelLabel", bUpdate);
dlg.setControlEnabled("WriterLevel", bUpdate);
dlg.setControlEnabled("LaTeXLevelLabel", bUpdate);
dlg.setControlEnabled("LaTeXLevel", bUpdate);
dlg.setControlEnabled("LaTeXNameLabel", bUpdate);
dlg.setControlEnabled("LaTeXName", bUpdate);
// Until implemented:
dlg.setControlEnabled("UseTitlesec", false);
//dlg.setControlEnabled("UseTitlesec", bUpdate);
}
private void writerLevelChange(DialogAccess dlg) {
updateHeadingMap(dlg);
// Load the values for the new level
nCurrentWriterLevel = dlg.getListBoxSelectedItem("WriterLevel");
if (nCurrentWriterLevel>-1) {
String sLevel = Integer.toString(nCurrentWriterLevel+1);
if (headingMap.containsKey(sLevel)) {
Map attr = headingMap.get(sLevel);
dlg.setComboBoxText("LaTeXLevel", attr.containsKey("level") ? attr.get("level") : "");
dlg.setComboBoxText("LaTeXName", attr.containsKey("name") ? attr.get("name") : "");
}
else {
dlg.setListBoxSelectedItem("LaTeXLevel", (short)2);
dlg.setComboBoxText("LaTeXName", "");
}
}
else {
dlg.setComboBoxText("LaTeXLevel", "");
dlg.setComboBoxText("LaTeXName", "");
}
}
private void noIndexChange(DialogAccess dlg) {
// Until implemented:
dlg.setControlEnabled("UseTitletoc", false);
//boolean bNoIndex = dlg.getCheckBoxStateAsBoolean("NoIndex");
//dlg.setControlEnabled("UseTitletoc", !bNoIndex);
}
private void updateHeadingMap(DialogAccess dlg) {
// Save the current writer level in our cache
if (nCurrentWriterLevel>-1) {
Map attr = new HashMap();
attr.put("name", dlg.getComboBoxText("LaTeXName"));
attr.put("level", dlg.getComboBoxText("LaTeXLevel"));
headingMap.put(Integer.toString(nCurrentWriterLevel+1), attr);
}
}
}
// The page "Styles"
// This page handles the various style maps as well as the options other_styles and formatting
// Limitation: Cannot handle the values "error" and "warning" for other_styles
private class StylesHandler extends StylesPageHandler {
private final String[] sLaTeXFamilyNames = { "text", "paragraph", "paragraph-block", "list", "listitem" };
private final String[] sLaTeXOOoFamilyNames = { "CharacterStyles", "ParagraphStyles", "ParagraphStyles", "NumberingStyles", "NumberingStyles" };
protected StylesHandler() {
super(5);
sFamilyNames =sLaTeXFamilyNames;
sOOoFamilyNames = sLaTeXOOoFamilyNames;
}
// Override standard PageHandler methods
@Override public void setControls(DialogAccess dlg) {
super.setControls(dlg);
String sOtherStyles = config.getOption("other_styles");
if ("accept".equals(sOtherStyles)) {
dlg.setListBoxSelectedItem("OtherStyles", (short)1);
}
else {
dlg.setListBoxSelectedItem("OtherStyles", (short)0);
}
String sFormatting = config.getOption("formatting");
if ("ignore_all".equals(sFormatting)) {
dlg.setListBoxSelectedItem("Formatting", (short)0);
}
else if ("ignore_most".equals(sFormatting)) {
dlg.setListBoxSelectedItem("Formatting", (short)1);
}
else if ("convert_most".equals(sFormatting)) {
dlg.setListBoxSelectedItem("Formatting", (short)3);
}
else if ("convert_all".equals(sFormatting)) {
dlg.setListBoxSelectedItem("Formatting", (short)4);
}
else {
dlg.setListBoxSelectedItem("Formatting", (short)2);
}
}
@Override public void getControls(DialogAccess dlg) {
super.getControls(dlg);
switch (dlg.getListBoxSelectedItem("OtherStyles")) {
case 0: config.setOption("other_styles", "ignore"); break;
case 1: config.setOption("other_styles", "accept");
}
switch (dlg.getListBoxSelectedItem("Formatting")) {
case 0: config.setOption("formatting", "ignore_all"); break;
case 1: config.setOption("formatting", "ignore_most"); break;
case 2: config.setOption("formatting", "convert_basic"); break;
case 3: config.setOption("formatting", "convert_most"); break;
case 4: config.setOption("formatting", "convert_all");
}
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("AddNextClick")) {
addNextClick(dlg);
return true;
}
else if (sMethod.equals("RemoveNextClick")) {
removeNextClick(dlg);
return true;
}
return super.handleEvent(dlg, sMethod);
}
// Define methods required by super
protected String getDefaultConfigName() {
return "clean.xml";
}
protected void setControls(DialogAccess dlg, Map attr) {
// Always set before and after, and ensure they are defined
if (!attr.containsKey("before")) { attr.put("before", ""); }
if (!attr.containsKey("after")) { attr.put("after", ""); }
dlg.setTextFieldText("Before", attr.get("before"));
dlg.setTextFieldText("After", attr.get("after"));
// Set next for paragraph block only
String[] sNextItems;
if (nCurrentFamily==2 && attr.containsKey("next") && attr.get("next").length()>0) {
sNextItems = attr.get("next").split(";");
// Localize known styles
Map displayNames = styleNameProvider.getDisplayNames(sOOoFamilyNames[nCurrentFamily]);
int nLen = sNextItems.length;
for (int i=0; i attr) {
// Always get before and after
attr.put("before", dlg.getTextFieldText("Before"));
attr.put("after", dlg.getTextFieldText("After"));
// Get next for paragraph block only
if (nCurrentFamily==2) {
String[] sNextItems = dlg.getListBoxStringItemList("Next");
// Internalize known styles
Map internalNames = styleNameProvider.getInternalNames(sOOoFamilyNames[nCurrentFamily]);
int nLen = sNextItems.length;
for (int i=0; i0) list.append(';');
list.append(sNextItems[i]);
}
attr.put("next", list.toString());
}
// Get verbatim for paragraph and character styles only
if (nCurrentFamily<2) {
attr.put("verbatim", Boolean.toString(dlg.getCheckBoxStateAsBoolean("Verbatim")));
}
// Get line break for paragraph style only
if (nCurrentFamily==1) {
attr.put("line-break", Boolean.toString(dlg.getCheckBoxStateAsBoolean("LineBreak")));
}
}
protected void clearControls(DialogAccess dlg) {
dlg.setTextFieldText("Before", "");
dlg.setTextFieldText("After", "");
dlg.setListBoxStringItemList("Next", new String[0]);
dlg.setCheckBoxStateAsBoolean("Verbatim", false);
dlg.setCheckBoxStateAsBoolean("LineBreak", false);
}
protected void prepareControls(DialogAccess dlg, boolean bHasMappings) {
dlg.setControlEnabled("BeforeLabel", bHasMappings);
dlg.setControlEnabled("Before", bHasMappings);
dlg.setControlEnabled("AfterLabel", bHasMappings);
dlg.setControlEnabled("After", bHasMappings);
dlg.setControlEnabled("NextLabel", bHasMappings && nCurrentFamily==2);
dlg.setControlEnabled("Next", bHasMappings && nCurrentFamily==2);
dlg.setControlEnabled("AddNextButton", bHasMappings && nCurrentFamily==2);
//dlg.setControlEnabled("RemoveNextButton", bHasMappings && nCurrentFamily==2);
dlg.setControlEnabled("Verbatim", bHasMappings && nCurrentFamily<2);
dlg.setControlEnabled("LineBreak", bHasMappings && nCurrentFamily==1);
updateRemoveNextButton(dlg);
}
// Define own event handlers
private void addNextClick(DialogAccess dlg) {
appendItem(dlg, "Next",styleNameProvider.getInternalNames(sOOoFamilyNames[nCurrentFamily]).keySet());
updateRemoveNextButton(dlg);
}
private void removeNextClick(DialogAccess dlg) {
deleteCurrentItem(dlg, "Next");
updateRemoveNextButton(dlg);
}
private void updateRemoveNextButton(DialogAccess dlg) {
dlg.setControlEnabled("RemoveNextButton", dlg.getListBoxStringItemList("Next").length>0);
}
}
// The page "Characters"
// This page handles the options use_color, use_soul, use_ulem and use_hyperref
// In addition it handles style maps for formatting attributes
private class CharactersHandler extends AttributePageHandler {
private final String[] sLaTeXAttributeNames = { "bold", "italic", "small-caps", "superscript", "subscript" };
protected CharactersHandler() {
super();
sAttributeNames = sLaTeXAttributeNames;
}
@Override protected void setControls(DialogAccess dlg) {
super.setControls(dlg);
checkBoxFromConfig(dlg,"UseHyperref","use_hyperref");
checkBoxFromConfig(dlg,"UseColor","use_color");
checkBoxFromConfig(dlg,"UseSoul","use_soul");
checkBoxFromConfig(dlg,"UseUlem","use_ulem");
}
@Override protected void getControls(DialogAccess dlg) {
super.getControls(dlg);
checkBoxToConfig(dlg,"UseHyperref","use_hyperref");
checkBoxToConfig(dlg,"UseColor","use_color");
checkBoxToConfig(dlg,"UseSoul","use_soul");
checkBoxToConfig(dlg,"UseUlem","use_ulem");
}
@Override protected void setControls(DialogAccess dlg, Map attr) {
if (!attr.containsKey("before")) { attr.put("before", ""); }
if (!attr.containsKey("after")) { attr.put("after", ""); }
dlg.setTextFieldText("Before", attr.get("before"));
dlg.setTextFieldText("After", attr.get("after"));
}
@Override protected void getControls(DialogAccess dlg, Map attr) {
attr.put("before", dlg.getComboBoxText("Before"));
attr.put("after", dlg.getComboBoxText("After"));
}
@Override protected void prepareControls(DialogAccess dlg, boolean bEnable) {
dlg.setControlEnabled("BeforeLabel", bEnable);
dlg.setControlEnabled("Before", bEnable);
dlg.setControlEnabled("AfterLabel", bEnable);
dlg.setControlEnabled("After", bEnable);
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("UseSoulChange")) {
useSoulChange(dlg);
return true;
}
else {
return super.handleEvent(dlg, sMethod);
}
}
private void useSoulChange(DialogAccess dlg) {
// Until implemented...
dlg.setControlEnabled("UseSoul", false);
// After which it should be...
//boolean bUseSoul = dlg.getCheckBoxStateAsBoolean("UseSoul");
//dlg.setControlEnabled("UseUlem", !bUseSoul);
}
}
// The page "Fonts"
// This page handles the options use_fontspec, use_pifont, use_tipa, use_eurosym, use_wasysym,
// use_ifsym, use_bbding
private class FontsHandler extends PageHandler {
@Override protected void setControls(DialogAccess dlg) {
checkBoxFromConfig(dlg,"UsePifont","use_pifont");
checkBoxFromConfig(dlg,"UseTipa","use_tipa");
checkBoxFromConfig(dlg,"UseEurosym","use_eurosym");
checkBoxFromConfig(dlg,"UseWasysym","use_wasysym");
checkBoxFromConfig(dlg,"UseIfsym","use_ifsym");
checkBoxFromConfig(dlg,"UseBbding","use_bbding");
checkBoxFromConfig(dlg,"UseFontspec","use_fontspec");
// Until implemented:
dlg.setControlEnabled("UseFontspec", false);
}
@Override protected void getControls(DialogAccess dlg) {
checkBoxToConfig(dlg,"UsePifont","use_pifont");
checkBoxToConfig(dlg,"UseTipa","use_tipa");
checkBoxToConfig(dlg,"UseEurosym","use_eurosym");
checkBoxToConfig(dlg,"UseWasysym","use_wasysym");
checkBoxToConfig(dlg,"UseIfsym","use_ifsym");
checkBoxToConfig(dlg,"UseBbding","use_bbding");
checkBoxToConfig(dlg,"UseFontspec","use_fontspec");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
// Currently no events
return false;
}
}
// The page "Pages"
// This page handles the options page_formatting, use_geometry, use_fancyhdr, use_lastpage and use_endnotes
private class PagesHandler extends PageHandler {
@Override protected void setControls(DialogAccess dlg) {
// The option page_formatting is presented as two options in the user interface
String sPageFormatting = config.getOption("page_formatting");
if ("ignore_all".equals(sPageFormatting)) {
dlg.setCheckBoxStateAsBoolean("ExportGeometry", false);
dlg.setCheckBoxStateAsBoolean("ExportHeaderFooter", false);
}
else if ("convert_geometry".equals(sPageFormatting)) {
dlg.setCheckBoxStateAsBoolean("ExportGeometry", true);
dlg.setCheckBoxStateAsBoolean("ExportHeaderFooter", false);
}
else if ("convert_header_footer".equals(sPageFormatting)) {
dlg.setCheckBoxStateAsBoolean("ExportGeometry", false);
dlg.setCheckBoxStateAsBoolean("ExportHeaderFooter", true);
}
else if ("convert_all".equals(sPageFormatting)) {
dlg.setCheckBoxStateAsBoolean("ExportGeometry", true);
dlg.setCheckBoxStateAsBoolean("ExportHeaderFooter", true);
}
checkBoxFromConfig(dlg,"UseGeometry", "use_geometry");
checkBoxFromConfig(dlg,"UseFancyhdr", "use_fancyhdr");
checkBoxFromConfig(dlg,"UseLastpage", "use_lastpage");
checkBoxFromConfig(dlg,"UseEndnotes", "use_endnotes");
// Trigger change events
exportGeometryChange(dlg);
exportHeaderAndFooterChange(dlg);
}
@Override protected void getControls(DialogAccess dlg) {
boolean bGeometry = dlg.getCheckBoxStateAsBoolean("ExportGeometry");
boolean bHeaderFooter = dlg.getCheckBoxStateAsBoolean("ExportHeaderFooter");
if (bGeometry && bHeaderFooter) {
config.setOption("page_formatting", "convert_all");
}
else if (bGeometry && !bHeaderFooter) {
config.setOption("page_formatting", "convert_geometry");
}
else if (!bGeometry && bHeaderFooter) {
config.setOption("page_formatting", "convert_header_footer");
}
else {
config.setOption("page_formatting", "ignore_all");
}
checkBoxToConfig(dlg,"UseGeometry", "use_geometry");
checkBoxToConfig(dlg,"UseFancyhdr", "use_fancyhdr");
checkBoxToConfig(dlg,"UseLastpage", "use_lastpage");
checkBoxToConfig(dlg,"UseEndnotes", "use_endnotes");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("ExportGeometryChange")) {
exportGeometryChange(dlg);
return true;
}
else if (sMethod.equals("ExportHeaderAndFooterChange")) {
exportHeaderAndFooterChange(dlg);
return true;
}
return false;
}
private void exportGeometryChange(DialogAccess dlg) {
dlg.setControlEnabled("UseGeometry", dlg.getCheckBoxStateAsBoolean("ExportGeometry"));
}
private void exportHeaderAndFooterChange(DialogAccess dlg) {
dlg.setControlEnabled("UseFancyhdr", dlg.getCheckBoxStateAsBoolean("ExportHeaderFooter"));
}
}
// The page "Tables"
// This page handles the options table_content, use_tabulary, use_colortbl, use_multirow, use_supertabular, use_longtable,
// table_first_head_style, table_head_style, table_foot_style, table_last_foot_style
// Limitation: Cannot handle the values "error" and "warning" for table_content
private class TablesHandler extends PageHandler {
protected TablesHandler() {
}
@Override protected void setControls(DialogAccess dlg) {
// Fill the table style combo boxes with style names
StyleNameProvider styleNameProvider = new StyleNameProvider(xContext);
Map internalNames = styleNameProvider.getInternalNames("ParagraphStyles");
if (internalNames!=null) {
String[] styleNames = Misc.sortStringSet(internalNames.keySet());
dlg.setListBoxStringItemList("TableFirstHeadStyle",styleNames);
dlg.setListBoxStringItemList("TableHeadStyle",styleNames);
dlg.setListBoxStringItemList("TableFootStyle",styleNames);
dlg.setListBoxStringItemList("TableLastFootStyle",styleNames);
}
// Fill the table sequence combo box with sequence names
FieldMasterNameProvider fieldMasterNameProvider = new FieldMasterNameProvider(xContext);
dlg.setListBoxStringItemList("TableSequenceName",
Misc.sortStringSet(fieldMasterNameProvider.getFieldMasterNames("com.sun.star.text.fieldmaster.SetExpression.")));
dlg.setCheckBoxStateAsBoolean("NoTables", !"accept".equals(config.getOption("table_content")));
checkBoxFromConfig(dlg,"UseColortbl","use_colortbl");
checkBoxFromConfig(dlg,"UseTabulary","use_tabulary");
//checkBoxFromConfig(dlg,"UseMultirow","use_multirow");
checkBoxFromConfig(dlg,"UseSupertabular","use_supertabular");
checkBoxFromConfig(dlg,"UseLongtable","use_longtable");
textFieldFromConfig(dlg,"TableFirstHeadStyle","table_first_head_style");
textFieldFromConfig(dlg,"TableHeadStyle","table_head_style");
textFieldFromConfig(dlg,"TableFootStyle","table_foot_style");
textFieldFromConfig(dlg,"TableLastFootStyle","table_last_foot_style");
textFieldFromConfig(dlg,"TableSequenceName","table_sequence_name");
checkBoxChange(dlg);
}
@Override protected void getControls(DialogAccess dlg) {
config.setOption("table_content", dlg.getCheckBoxStateAsBoolean("NoTables") ? "ignore" : "accept");
checkBoxToConfig(dlg,"UseColortbl","use_colortbl");
checkBoxToConfig(dlg,"UseTabulary","use_tabulary");
//checkBoxToConfig(dlg,"UseMultirow","use_multirow");
checkBoxToConfig(dlg,"UseSupertabular","use_supertabular");
checkBoxToConfig(dlg,"UseLongtable","use_longtable");
textFieldToConfig(dlg,"TableFirstHeadStyle","table_first_head_style");
textFieldToConfig(dlg,"TableHeadStyle","table_head_style");
textFieldToConfig(dlg,"TableFootStyle","table_foot_style");
textFieldToConfig(dlg,"TableLastFootStyle","table_last_foot_style");
textFieldToConfig(dlg,"TableSequenceName","table_sequence_name");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("NoTablesChange")) {
checkBoxChange(dlg);
return true;
}
else if (sMethod.equals("UseSupertabularChange")) {
checkBoxChange(dlg);
return true;
}
else if (sMethod.equals("UseLongtableChange")) {
checkBoxChange(dlg);
return true;
}
return false;
}
private void checkBoxChange(DialogAccess dlg) {
boolean bNoTables = dlg.getCheckBoxStateAsBoolean("NoTables");
boolean bSupertabular = dlg.getCheckBoxStateAsBoolean("UseSupertabular");
boolean bLongtable = dlg.getCheckBoxStateAsBoolean("UseLongtable");
dlg.setControlEnabled("UseColortbl", !bNoTables);
dlg.setControlEnabled("UseTabulary", !bNoTables);
dlg.setControlEnabled("UseMultirow", false);
dlg.setControlEnabled("UseSupertabular", !bNoTables);
dlg.setControlEnabled("UseLongtable", !bNoTables && !bSupertabular);
dlg.setControlEnabled("TableFirstHeadLabel", !bNoTables && (bSupertabular || bLongtable));
dlg.setControlEnabled("TableFirstHeadStyle", !bNoTables && (bSupertabular || bLongtable));
dlg.setControlEnabled("TableHeadLabel", !bNoTables && (bSupertabular || bLongtable));
dlg.setControlEnabled("TableHeadStyle", !bNoTables && (bSupertabular || bLongtable));
dlg.setControlEnabled("TableFootLabel", !bNoTables && (bSupertabular || bLongtable));
dlg.setControlEnabled("TableFootStyle", !bNoTables && (bSupertabular || bLongtable));
dlg.setControlEnabled("TableLastFootLabel", !bNoTables && (bSupertabular || bLongtable));
dlg.setControlEnabled("TableLastFootStyle", !bNoTables && (bSupertabular || bLongtable));
dlg.setControlEnabled("TableSequenceLabel", !bNoTables);
dlg.setControlEnabled("TableSequenceName", !bNoTables);
}
}
// The page "Figures"
// This page handles the options use_caption, align_frames, figure_sequence_name, image_content,
// remove_graphics_extension and image_options
// Limitation: Cannot handle the values "error" and "warning" for image_content
private class FiguresHandler extends PageHandler {
@Override protected void setControls(DialogAccess dlg) {
// Fill the figure sequence combo box with sequence names
FieldMasterNameProvider fieldMasterNameProvider = new FieldMasterNameProvider(xContext);
dlg.setListBoxStringItemList("FigureSequenceName",
Misc.sortStringSet(fieldMasterNameProvider.getFieldMasterNames("com.sun.star.text.fieldmaster.SetExpression.")));
checkBoxFromConfig(dlg,"UseCaption","use_caption");
checkBoxFromConfig(dlg,"AlignFrames","align_frames");
textFieldFromConfig(dlg,"FigureSequenceName","figure_sequence_name");
dlg.setCheckBoxStateAsBoolean("NoImages", !"accept".equals(config.getOption("image_content")));
checkBoxFromConfig(dlg,"RemoveGraphicsExtension","remove_graphics_extension");
textFieldFromConfig(dlg,"ImageOptions","image_options");
noImagesChange(dlg);
}
@Override protected void getControls(DialogAccess dlg) {
checkBoxToConfig(dlg,"UseCaption","use_caption");
checkBoxToConfig(dlg,"AlignFrames","align_frames");
textFieldToConfig(dlg,"FigureSequenceName","figure_sequence_name");
config.setOption("image_content", dlg.getCheckBoxStateAsBoolean("NoImages") ? "ignore" : "accept");
checkBoxToConfig(dlg,"RemoveGraphicsExtension","remove_graphics_extension");
textFieldToConfig(dlg,"ImageOptions","image_options");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("NoImagesChange")) {
noImagesChange(dlg);
return true;
}
return false;
}
private void noImagesChange(DialogAccess dlg) {
boolean bNoImages = dlg.getCheckBoxStateAsBoolean("NoImages");
dlg.setControlEnabled("RemoveGraphicsExtension", !bNoImages);
dlg.setControlEnabled("ImageOptionsLabel", !bNoImages);
dlg.setControlEnabled("ImageOptions", !bNoImages);
}
}
// The page "TextAndMath"
// This page handles the options use_ooomath and tabstop as well as the
// text replacements and math symbol definitions
private class TextAndMathHandler extends UserListPageHandler {
private CustomSymbolNameProvider customSymbolNameProvider = null;
private ComplexOption mathSymbols;
private ComplexOption stringReplace;
private String sCurrentMathSymbol = null;
private String sCurrentText = null;
protected TextAndMathHandler() {
super();
customSymbolNameProvider = new CustomSymbolNameProvider(xContext);
}
@Override protected void setControls(DialogAccess dlg) {
// Get math symbols from config
if (mathSymbols!=null) { mathSymbols.clear(); }
else { mathSymbols = new ComplexOption(); }
mathSymbols.copyAll(config.getComplexOption("math-symbol-map"));
sCurrentMathSymbol = null;
dlg.setListBoxStringItemList("MathSymbolName", Misc.sortStringSet(mathSymbols.keySet()));
dlg.setListBoxSelectedItem("MathSymbolName", (short)Math.min(0,mathSymbols.keySet().size()-1));
// Trigger change event (on some versions of OOo this is automatic due to a bug)
mathSymbolNameChange(dlg);
// Get string replace from config
if (stringReplace!=null) { stringReplace.clear(); }
else { stringReplace = new ComplexOption(); }
stringReplace.copyAll(config.getComplexOption("string-replace"));
sCurrentText = null;
dlg.setListBoxStringItemList("TextInput", Misc.sortStringSet(stringReplace.keySet()));
dlg.setListBoxSelectedItem("TextInput", (short)Math.min(0,stringReplace.keySet().size()-1));
// Trigger change event (on some versions of OOo this is automatic due to a bug)
textInputChange(dlg);
// Get other options from config
checkBoxFromConfig(dlg,"UseOoomath","use_ooomath");
textFieldFromConfig(dlg,"TabStopLaTeX", "tabstop");
}
@Override protected void getControls(DialogAccess dlg) {
// Save math symbols to config
updateSymbol(dlg);
config.getComplexOption("math-symbol-map").clear();
config.getComplexOption("math-symbol-map").copyAll(mathSymbols);
// Save string replace to config
updateText(dlg);
config.getComplexOption("string-replace").clear();
config.getComplexOption("string-replace").copyAll(stringReplace);
// Save other options to config
checkBoxToConfig(dlg,"UseOoomath","use_ooomath");
textFieldToConfig(dlg,"TabStopLaTeX", "tabstop");
}
@Override protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("MathSymbolNameChange")) {
mathSymbolNameChange(dlg);
return true;
}
else if (sMethod.equals("NewSymbolClick")) {
newSymbolClick(dlg);
return true;
}
else if (sMethod.equals("DeleteSymbolClick")) {
deleteSymbolClick(dlg);
return true;
}
else if (sMethod.equals("TextInputChange")) {
textInputChange(dlg);
return true;
}
else if (sMethod.equals("NewTextClick")) {
newTextClick(dlg);
return true;
}
else if (sMethod.equals("DeleteTextClick")) {
deleteTextClick(dlg);
return true;
}
return false;
}
private void mathSymbolNameChange(DialogAccess dlg) {
updateSymbol(dlg);
updateSymbolControls(dlg);
}
private void newSymbolClick(DialogAccess dlg) {
appendItem(dlg,"MathSymbolName",customSymbolNameProvider.getNames());
// Trigger change event (on some versions of OOo this is automatic due to a bug)
mathSymbolNameChange(dlg);
}
private void deleteSymbolClick(DialogAccess dlg) {
String sMathSymbol = sCurrentMathSymbol;
if (deleteCurrentItem(dlg,"MathSymbolName")) {
mathSymbols.remove(sMathSymbol);
sCurrentMathSymbol=null; // invalidate current symbol
}
// Trigger change event (on some versions of OOo this is automatic due to a bug)
mathSymbolNameChange(dlg);
}
private void updateSymbol(DialogAccess dlg) {
// Save the current math symbol in our cache
if (sCurrentMathSymbol!=null) {
Map attr = new HashMap();
attr.put("latex", dlg.getTextFieldText("MathLaTeX"));
mathSymbols.put(sCurrentMathSymbol, attr);
}
}
// Update symbol controls based on currently selected list item
private void updateSymbolControls(DialogAccess dlg) {
short nSymbolItem = dlg.getListBoxSelectedItem("MathSymbolName");
if (nSymbolItem>=0) {
sCurrentMathSymbol = dlg.getListBoxStringItemList("MathSymbolName")[nSymbolItem];
Map attributes;
if (mathSymbols.containsKey(sCurrentMathSymbol)) {
attributes = mathSymbols.get(sCurrentMathSymbol);
}
else { // New symbol, add empty definition to cache
attributes = new HashMap();
attributes.put("latex", "");
mathSymbols.put(sCurrentMathSymbol, attributes);
}
dlg.setTextFieldText("MathLaTeX", attributes.get("latex"));
dlg.setControlEnabled("MathLaTeX", true);
dlg.setControlEnabled("DeleteSymbolButton", true);
}
else { // The list is empty, or nothing is selected
sCurrentMathSymbol = null;
dlg.setTextFieldText("MathLaTeX", "");
dlg.setControlEnabled("MathLaTeX", false);
dlg.setControlEnabled("DeleteSymbolButton", false);
}
}
private void textInputChange(DialogAccess dlg) {
updateText(dlg);
updateTextControls(dlg);
}
private void newTextClick(DialogAccess dlg) {
appendItem(dlg, "TextInput", new HashSet());
// Trigger change event (on some versions of OOo this is automatic due to a bug)
textInputChange(dlg);
}
private void deleteTextClick(DialogAccess dlg) {
String sText = sCurrentText;
if (deleteCurrentItem(dlg, "TextInput")) {
stringReplace.remove(sText);
sCurrentText = null; // Invalidate current string replace
}
// Trigger change event (on some versions of OOo this is automatic due to a bug)
textInputChange(dlg);
}
private void updateText(DialogAccess dlg) {
// Save the current string replace in our cache
if (sCurrentText!=null) {
Map attr = new HashMap();
attr.put("latex-code", dlg.getTextFieldText("LaTeX"));
attr.put("fontenc", "any");
stringReplace.put(sCurrentText, attr);
}
}
// Update text controls based on currently selected list item
private void updateTextControls(DialogAccess dlg) {
// Get the current input string, if any
short nItem = dlg.getListBoxSelectedItem("TextInput");
if (nItem>=0) {
sCurrentText = dlg.getListBoxStringItemList("TextInput")[nItem];
Map attributes;
if (stringReplace.containsKey(sCurrentText)) {
attributes = stringReplace.get(sCurrentText);
}
else { // New string replace, add empty definition to cache
attributes = new HashMap();
attributes.put("latex-code", "");
attributes.put("fontenc", "any");
stringReplace.put(sCurrentText, attributes);
}
dlg.setTextFieldText("LaTeX", attributes.get("latex-code"));
//dlg.setTextFieldText("Fontenc", attributes.get("fontenc"));
dlg.setControlEnabled("LaTeX", true);
dlg.setControlEnabled("DeleteTextButton",
!"\u00A0!".equals(sCurrentText) && !"\u00A0?".equals(sCurrentText) &&
!"\u00A0:".equals(sCurrentText) && !"\u00A0;".equals(sCurrentText) &&
!"\u00A0\u2014".equals(sCurrentText));
}
else { // The list is empty, or nothing is selected
sCurrentText = null;
dlg.setTextFieldText("LaTeX", "");
//dlg.setTextFieldText("Fontenc", "any");
dlg.setControlEnabled("DeleteTextButton", false);
}
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2latex/W2LRegistration.java 0000644 0001750 0001750 00000010763 11251136744 027436 0 ustar rene rene /************************************************************************
*
* W2LRegistration.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-09-06)
*
*/
package org.openoffice.da.comp.writer2latex;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XSingleServiceFactory;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.comp.loader.FactoryHelper;
/** This class provides a static method to instantiate our uno components
* on demand (__getServiceFactory()), and a static method to give
* information about the components (__writeRegistryServiceInfo()).
* Furthermore, it saves the XMultiServiceFactory provided to the
* __getServiceFactory method for future reference by the componentes.
*/
public class W2LRegistration {
public static XMultiServiceFactory xMultiServiceFactory;
/**
* Returns a factory for creating the service.
* This method is called by the JavaLoader
*
* @return returns a XSingleServiceFactory for creating the
* component
*
* @param implName the name of the implementation for which a
* service is desired
* @param multiFactory the service manager to be used if needed
* @param regKey the registryKey
*
* @see com.sun.star.comp.loader.JavaLoader
*/
public static XSingleServiceFactory __getServiceFactory(String implName,
XMultiServiceFactory multiFactory, XRegistryKey regKey) {
xMultiServiceFactory = multiFactory;
XSingleServiceFactory xSingleServiceFactory = null;
if (implName.equals(W2LExportFilter.class.getName()) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(W2LExportFilter.class,
W2LExportFilter.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(LaTeXOptionsDialog.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(LaTeXOptionsDialog.class,
LaTeXOptionsDialog.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(W2LStarMathConverter.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(W2LStarMathConverter.class,
W2LStarMathConverter.__serviceName,
multiFactory,
regKey);
}
else if (implName.equals(ConfigurationDialog.__implementationName)) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(ConfigurationDialog.class,
ConfigurationDialog.__serviceName,
multiFactory,
regKey);
}
return xSingleServiceFactory;
}
/**
* Writes the service information into the given registry key.
* This method is called by the JavaLoader
*
* @return returns true if the operation succeeded
* @param regKey the registryKey
* @see com.sun.star.comp.loader.JavaLoader
*/
public static boolean __writeRegistryServiceInfo(XRegistryKey regKey) {
return
FactoryHelper.writeRegistryServiceInfo(W2LExportFilter.__implementationName,
W2LExportFilter.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(LaTeXOptionsDialog.__implementationName,
LaTeXOptionsDialog.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(W2LStarMathConverter.__implementationName,
W2LStarMathConverter.__serviceName, regKey) &
FactoryHelper.writeRegistryServiceInfo(ConfigurationDialog.__implementationName,
ConfigurationDialog.__serviceName, regKey);
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2latex/CustomSymbolNameProvider.java 0000644 0001750 0001750 00000005600 11351636127 031406 0 ustar rene rene /**
* CustomSymbolNameProvider.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-11-09)
*
*/
package org.openoffice.da.comp.writer2latex;
import org.openoffice.da.comp.w2lcommon.helper.RegistryHelper;
import org.openoffice.da.comp.w2lcommon.helper.XPropertySetHelper;
import com.sun.star.beans.XPropertySet;
import com.sun.star.container.XNameAccess;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/** This class provides access to the names of all user defined symbols in math
*
*/
public class CustomSymbolNameProvider {
Set names;
/** Construct a new CustomSymbolNameProvider
*
* @param xContext the component context providing access to the api
*/
public CustomSymbolNameProvider(XComponentContext xContext) {
names = new HashSet();
RegistryHelper registry = new RegistryHelper(xContext);
try {
// Prepare registry view
Object view = registry.getRegistryView("/org.openoffice.Office.Math/",false);
XPropertySet xProps = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,view);
// Get the list of symbols
Object symbols = XPropertySetHelper.getPropertyValue(xProps,"SymbolList");
XNameAccess xSymbols = (XNameAccess) UnoRuntime.queryInterface(XNameAccess.class,symbols);
String[] sNames = xSymbols.getElementNames();
int nCount = sNames.length;
for (int i=0; i getNames() {
return Collections.unmodifiableSet(names);
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2latex/W2LExportFilter.java 0000644 0001750 0001750 00000003364 11251136744 027412 0 ustar rene rene /************************************************************************
*
* W2LExportFilter.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-09-06)
*
*/
package org.openoffice.da.comp.writer2latex;
import com.sun.star.uno.XComponentContext;
import org.openoffice.da.comp.w2lcommon.filter.ExportFilterBase;
/** This class implements the LaTeX and BibTeX export filter component
*/
public class W2LExportFilter extends ExportFilterBase {
/** Service name for the component */
public static final String __serviceName = "org.openoffice.da.comp.writer2latex.W2LExportFilter";
/** Implementation name for the component */
public static final String __implementationName = "org.openoffice.da.comp.writer2latex.W2LExportFilter";
/** Filter name to include in error messages */
public final String __displayName = "Writer2LaTeX";
public W2LExportFilter(XComponentContext xComponentContext1) {
super(xComponentContext1);
xMSF = W2LRegistration.xMultiServiceFactory;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer2latex/LaTeXOptionsDialog.java 0000644 0001750 0001750 00000037123 12407045472 030110 0 ustar rene rene /************************************************************************
*
* LaTeXOptionsDialog.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-19)
*
*/
package org.openoffice.da.comp.writer2latex;
import com.sun.star.awt.XDialog;
import com.sun.star.beans.XPropertySet;
//import com.sun.star.frame.XDesktop;
//import com.sun.star.lang.XComponent;
//import com.sun.star.text.XTextFieldsSupplier;
//import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import org.openoffice.da.comp.w2lcommon.helper.PropertyHelper;
import org.openoffice.da.comp.w2lcommon.filter.OptionsDialogBase;
/** This class provides a UNO component which implements a filter ui for the
* LaTeX export
*/
public class LaTeXOptionsDialog extends OptionsDialogBase {
// Translate list box items to configuration option values
private static final String[] BACKEND_VALUES =
{ "generic", "pdftex", "dvips", "xetex", "unspecified" };
private static final String[] INPUTENCODING_VALUES =
{ "ascii", "latin1", "latin2", "iso-8859-7", "cp1250", "cp1251", "koi8-r", "utf8" };
private static final String[] NOTES_VALUES =
{ "ignore", "comment", "marginpar", "pdfannotation" };
private static final String[] FLOATOPTIONS_VALUES =
{ "", "tp", "bp", "htp", "hbp" };
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer2latex.LaTeXOptionsDialog";
/** The component should also have an implementation name.
* The subclass should override this with a suitable name
*/
public static String __implementationName = "org.openoffice.da.comp.writer2latex.LaTeXOptionsDialog";
public String getDialogLibraryName() { return "W2LDialogs"; }
/** Create a new LaTeXOptionsDialog */
public LaTeXOptionsDialog(XComponentContext xContext) {
super(xContext);
xMSF = W2LRegistration.xMultiServiceFactory;
}
/** Return the name of the dialog within the library
*/
public String getDialogName() { return "LaTeXOptions"; }
/** Return the name of the registry path
*/
public String getRegistryPath() {
return "/org.openoffice.da.Writer2LaTeX.Options/LaTeXOptions";
}
/** Load settings from the registry to the dialog */
protected void loadSettings(XPropertySet xProps) {
// General
loadConfig(xProps);
loadListBoxOption(xProps,"Backend");
loadListBoxOption(xProps,"Inputencoding");
loadCheckBoxOption(xProps,"Multilingual");
loadCheckBoxOption(xProps,"GreekMath");
loadCheckBoxOption(xProps,"AdditionalSymbols");
// Bibliography
loadCheckBoxOption(xProps,"UseBibtex");
loadComboBoxOption(xProps,"BibtexStyle");
// Files
loadCheckBoxOption(xProps,"WrapLines");
loadNumericOption(xProps,"WrapLinesAfter");
loadCheckBoxOption(xProps,"SplitLinkedSections");
loadCheckBoxOption(xProps,"SplitToplevelSections");
loadCheckBoxOption(xProps,"SaveImagesInSubdir");
// Special content
loadListBoxOption(xProps,"Notes");
loadCheckBoxOption(xProps,"Metadata");
loadCheckBoxOption(xProps,"DisplayHiddenText");
// Figures and tables
loadCheckBoxOption(xProps,"OriginalImageSize");
loadCheckBoxOption(xProps,"OptimizeSimpleTables");
loadNumericOption(xProps,"SimpleTableLimit");
loadCheckBoxOption(xProps,"FloatTables");
loadCheckBoxOption(xProps,"FloatFigures");
loadListBoxOption(xProps,"FloatOptions");
// AutoCorrect
loadCheckBoxOption(xProps,"IgnoreHardPageBreaks");
loadCheckBoxOption(xProps,"IgnoreHardLineBreaks");
loadCheckBoxOption(xProps,"IgnoreEmptyParagraphs");
loadCheckBoxOption(xProps,"IgnoreDoubleSpaces");
updateLockedOptions();
enableControls();
}
/** Save settings from the dialog to the registry and create FilterData */
protected void saveSettings(XPropertySet xProps, PropertyHelper filterData) {
// General
short nConfig = saveConfig(xProps, filterData);
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");
}
saveListBoxOption(xProps, filterData, "Backend", "backend", BACKEND_VALUES );
if (getListBoxSelectedItem("Config")==4) {
// pdfscreen locks the backend to pdftex
filterData.put("backend","pdftex");
}
saveListBoxOption(xProps, filterData, "Inputencoding", "inputencoding", INPUTENCODING_VALUES);
saveCheckBoxOption(xProps, filterData, "Multilingual", "multilingual");
saveCheckBoxOption(xProps, filterData, "GreekMath", "greek_math");
// AdditionalSymbols sets 5 different w2l options...
saveCheckBoxOption(xProps, filterData, "AdditionalSymbols", "use_pifont");
saveCheckBoxOption(xProps, filterData, "AdditionalSymbols", "use_ifsym");
saveCheckBoxOption(xProps, filterData, "AdditionalSymbols", "use_wasysym");
saveCheckBoxOption(xProps, filterData, "AdditionalSymbols", "use_eurosym");
saveCheckBoxOption(xProps, filterData, "AdditionalSymbols", "use_tipa");
// Bibliography
saveCheckBoxOption(xProps, filterData, "UseBibtex", "use_bibtex");
saveComboBoxOption(xProps, filterData, "BibtexStyle", "bibtex_style");
// Files
boolean bWrapLines = saveCheckBoxOption(xProps, "WrapLines");
int nWrapLinesAfter = saveNumericOption(xProps, "WrapLinesAfter");
if (!isLocked("wrap_lines_after")) {
if (bWrapLines) {
filterData.put("wrap_lines_after",Integer.toString(nWrapLinesAfter));
}
else {
filterData.put("wrap_lines_after","0");
}
}
saveCheckBoxOption(xProps, filterData, "SplitLinkedSections", "split_linked_sections");
saveCheckBoxOption(xProps, filterData, "SplitToplevelSections", "split_toplevel_sections");
saveCheckBoxOption(xProps, filterData, "SaveImagesInSubdir", "save_images_in_subdir");
// Special content
saveListBoxOption(xProps, filterData, "Notes", "notes", NOTES_VALUES);
saveCheckBoxOption(xProps, filterData, "Metadata", "metadata");
saveCheckBoxOption(xProps, filterData, "DisplayHiddenText", "display_hidden_text");
// Figures and tables
saveCheckBoxOption(xProps, filterData, "OriginalImageSize", "original_image_size");
boolean bOptimizeSimpleTables = saveCheckBoxOption(xProps,"OptimizeSimpleTables");
int nSimpleTableLimit = saveNumericOption(xProps,"SimpleTableLimit");
if (!isLocked("simple_table_limit")) {
if (bOptimizeSimpleTables) {
filterData.put("simple_table_limit",Integer.toString(nSimpleTableLimit));
}
else {
filterData.put("simple_table_limit","0");
}
}
saveCheckBoxOption(xProps, filterData, "FloatTables", "float_tables");
saveCheckBoxOption(xProps, filterData, "FloatFigures", "float_figures");
saveListBoxOption(xProps, filterData, "FloatOptions", "float_options", FLOATOPTIONS_VALUES);
// AutoCorrect
saveCheckBoxOption(xProps, filterData, "IgnoreHardPageBreaks", "ignore_hard_page_breaks");
saveCheckBoxOption(xProps, filterData, "IgnoreHardLineBreaks", "ignore_hard_line_breaks");
saveCheckBoxOption(xProps, filterData, "IgnoreEmptyParagraphs", "ignore_empty_paragraphs");
saveCheckBoxOption(xProps, filterData, "IgnoreDoubleSpaces", "ignore_double_spaces");
}
// Implement XDialogEventHandler
public boolean callHandlerMethod(XDialog xDialog, Object event, String sMethod) {
if (sMethod.equals("ConfigChange") || sMethod.equals("BackendChange")) {
updateLockedOptions();
enableControls();
}
else if (sMethod.equals("UseBibtexChange")) {
enableBibtexStyle();
}
else if (sMethod.equals("WrapLinesChange")) {
enableWrapLinesAfter();
}
else if (sMethod.equals("OptimizeSimpleTablesChange")) {
enableSimpleTableLimit();
}
else if (sMethod.equals("FloatTablesChange")) {
enableFloatOptions();
}
else if (sMethod.equals("FloatFiguresChange")) {
enableFloatOptions();
}
return true;
}
public String[] getSupportedMethodNames() {
String[] sNames = { "ConfigChange", "UseBibtexChange", "WrapLinesChange",
"OptimizeSimpleTablesChange", "FloatTablesChange", "FloatFiguresChange" };
return sNames;
}
protected boolean isLocked(String sOptionName) {
if ("backend".equals(sOptionName)) {
// backend must be pdf for pdfscreen
return getListBoxSelectedItem("Config")==4 || super.isLocked(sOptionName);
}
else if ("inputencoding".equals(sOptionName)) {
// backend=xetex locks the encoding to utf8
return getListBoxSelectedItem("Backend")==3 || super.isLocked(sOptionName);
}
else if ("greek_math".equals(sOptionName)) {
// this option has no effect if backend=xetex
return getListBoxSelectedItem("Backend")==3 || super.isLocked(sOptionName);
}
else if ("additional_symbols".equals(sOptionName)) {
// additional_symbols is disabled for custom config (where the 5
// individual options can be set independently)
// it is also disabled for backend=xetex
return getListBoxSelectedItem("Backend")==3 || getListBoxSelectedItem("Config")==5 || super.isLocked(sOptionName);
}
else if ("use_pifont".equals(sOptionName)) {
return isLocked("additional_symbols");
}
else if ("use_ifsym".equals(sOptionName)) {
return isLocked("additional_symbols");
}
else if ("use_wasysym".equals(sOptionName)) {
return isLocked("additional_symbols");
}
else if ("use_eurosym".equals(sOptionName)) {
return isLocked("additional_symbols");
}
else if ("use_tipa".equals(sOptionName)) {
return isLocked("additional_symbols");
}
else {
return super.isLocked(sOptionName);
}
}
private void enableControls() {
// General
setControlEnabled("BackendLabel",!isLocked("backend"));
setControlEnabled("Backend",!isLocked("backend"));
setControlEnabled("InputencodingLabel",!isLocked("inputencoding"));
setControlEnabled("Inputencoding",!isLocked("inputencoding"));
setControlEnabled("Multilingual",!isLocked("multilingual"));
setControlEnabled("GreekMath",!isLocked("greek_math"));
setControlEnabled("AdditionalSymbols",!isLocked("additional_symbols"));
// Bibliography
setControlEnabled("UseBibtex",!isLocked("use_bibtex"));
boolean bUseBibtex = getCheckBoxStateAsBoolean("UseBibtex");
setControlEnabled("BibtexStyleLabel",!isLocked("bibtex_style") && bUseBibtex);
setControlEnabled("BibtexStyle",!isLocked("bibtex_style") && bUseBibtex);
// Files
setControlEnabled("WrapLines",!isLocked("wrap_lines_after"));
boolean bWrapLines = getCheckBoxStateAsBoolean("WrapLines");
setControlEnabled("WrapLinesAfterLabel",!isLocked("wrap_lines_after") && bWrapLines);
setControlEnabled("WrapLinesAfter",!isLocked("wrap_lines_after") && bWrapLines);
setControlEnabled("SplitLinkedSections",!isLocked("split_linked_sections"));
setControlEnabled("SplitToplevelSections",!isLocked("split_toplevel_sections"));
setControlEnabled("SaveImagesInSubdir",!isLocked("save_images_in_subdir"));
// Special content
setControlEnabled("NotesLabel",!isLocked("notes"));
setControlEnabled("Notes",!isLocked("notes"));
setControlEnabled("Metadata",!isLocked("metadata"));
setControlEnabled("DisplayHiddenText",!isLocked("display_hidden_text"));
// Figures and tables
setControlEnabled("OriginalImageSize",!isLocked("original_image_size"));
setControlEnabled("OptimizeSimpleTables",!isLocked("simple_table_limit"));
boolean bOptimizeSimpleTables = getCheckBoxStateAsBoolean("OptimizeSimpleTables");
setControlEnabled("SimpleTableLimitLabel",!isLocked("simple_table_limit") && bOptimizeSimpleTables);
setControlEnabled("SimpleTableLimit",!isLocked("simple_table_limit") && bOptimizeSimpleTables);
setControlEnabled("FloatTables",!isLocked("float_tables"));
setControlEnabled("FloatFigures",!isLocked("float_figures"));
boolean bFloat = getCheckBoxStateAsBoolean("FloatFigures") ||
getCheckBoxStateAsBoolean("FloatTables");
setControlEnabled("FloatOptionsLabel",!isLocked("float_options") && bFloat);
setControlEnabled("FloatOptions",!isLocked("float_options") && bFloat);
// AutoCorrect
setControlEnabled("IgnoreHardPageBreaks",!isLocked("ignore_hard_page_breaks"));
setControlEnabled("IgnoreHardLineBreaks",!isLocked("ignore_hard_line_breaks"));
setControlEnabled("IgnoreEmptyParagraphs",!isLocked("ignore_empty_paragraphs"));
setControlEnabled("IgnoreDoubleSpaces",!isLocked("ignore_double_spaces"));
}
private void enableBibtexStyle() {
if (!isLocked("bibtex_style")) {
boolean bState = getCheckBoxStateAsBoolean("UseBibtex");
setControlEnabled("BibtexStyleLabel",bState);
setControlEnabled("BibtexStyle",bState);
}
}
private void enableWrapLinesAfter() {
if (!isLocked("wrap_lines_after")) {
boolean bState = getCheckBoxStateAsBoolean("WrapLines");
setControlEnabled("WrapLinesAfterLabel",bState);
setControlEnabled("WrapLinesAfter",bState);
}
}
private void enableSimpleTableLimit() {
if (!isLocked("simple_table_limit")) {
boolean bState = getCheckBoxStateAsBoolean("OptimizeSimpleTables");
setControlEnabled("SimpleTableLimitLabel",bState);
setControlEnabled("SimpleTableLimit",bState);
}
}
private void enableFloatOptions() {
if (!isLocked("float_options")) {
boolean bState = getCheckBoxStateAsBoolean("FloatFigures") ||
getCheckBoxStateAsBoolean("FloatTables");
setControlEnabled("FloatOptionsLabel",bState);
setControlEnabled("FloatOptions",bState);
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/ 0000755 0001750 0001750 00000000000 12603463650 023570 5 ustar rene rene writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/ExternalApps.java 0000644 0001750 0001750 00000021006 11524722053 027034 0 ustar rene rene /************************************************************************
*
* 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-2011 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-01-25)
*
*/
package org.openoffice.da.comp.writer4latex;
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 Writer4LaTeX.
* 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 apps;
/** Construct a new ExternalApps object, with empty definitions */
public ExternalApps(XComponentContext xContext) {
this.xContext = xContext;
apps = new HashMap();
for (int i=0; i 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 env, boolean bWaitFor) {
// Assemble the command
String[] sApp = getApplication(sAppName);
if (sApp==null) { return 1; }
try {
Vector command = new Vector();
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.Writer4LaTeX.Options/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 command = new Vector();
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("Writer4LaTeX 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;
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/Writer4LaTeX.java 0000644 0001750 0001750 00000070741 11542571044 026700 0 ustar rene rene /************************************************************************
*
* Writer4LaTeX.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-2011 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-03-23)
*
*/
package org.openoffice.da.comp.writer4latex;
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 Writer4LaTeX.
* The actual processing is done by the three core classes TeXify,
* LaTeXImporter and BibTeXImporter
*/
public final class Writer4LaTeX 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.writer4latex:";
// 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 = Writer4LaTeX.class.getName();
public static final String __serviceName = "com.sun.star.frame.ProtocolHandler";
private static final String[] m_serviceNames = { __serviceName };
public Writer4LaTeX( 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;
}
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;
}
}
}
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("Writer4LaTeX",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("Writer4LaTeX 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("Writer4LaTeX 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("Writer4LaTeX 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.writer4latex.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) {
}
}
}
// 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);
// If Writer2LaTeX is not installed, this will return null
if (dialog==null) {
mediaProps = null;
MessageBox msgBox = new MessageBox(m_xContext, m_xFrame);
msgBox.showMessage("Writer4LaTeX Error","Please install Writer2LaTeX version 1.0 or later");
return false;
}
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='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 "writer4latex"; }
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 ".";
}
}*/
} writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/W4LRegistration.java 0000644 0001750 0001750 00000012476 11455250660 027445 0 ustar rene rene /************************************************************************
*
* W4LRegistration.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 (2010-10-10)
*
*/
package org.openoffice.da.comp.writer4latex;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XSingleServiceFactory;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.comp.loader.FactoryHelper;
/** This class provides a static method to instantiate our uno components
* on demand (__getServiceFactory()), and a static method to give
* information about the components (__writeRegistryServiceInfo()).
* Furthermore, it saves the XMultiServiceFactory provided to the
* __getServiceFactory method for future reference by the componentes.
*/
public class W4LRegistration {
public static XMultiServiceFactory xMultiServiceFactory;
/**
* Returns a factory for creating the service.
* This method is called by the JavaLoader
*
* @return returns a XSingleServiceFactory for creating the
* component
*
* @param implName the name of the implementation for which a
* service is desired
* @param multiFactory the service manager to be used if needed
* @param regKey the registryKey
*
* @see com.sun.star.comp.loader.JavaLoader
*/
public static XSingleServiceFactory __getServiceFactory(String implName,
XMultiServiceFactory multiFactory, XRegistryKey regKey) {
xMultiServiceFactory = multiFactory;
XSingleServiceFactory xSingleServiceFactory = null;
if (implName.equals(Writer4LaTeX.__implementationName) ) {
xSingleServiceFactory = FactoryHelper.getServiceFactory(Writer4LaTeX.class,
Writer4LaTeX.__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;
}
/**
* Writes the service information into the given registry key.
* This method is called by the JavaLoader
*
* @return returns true if the operation succeeded
* @param regKey the registryKey
* @see com.sun.star.comp.loader.JavaLoader
*/
public static boolean __writeRegistryServiceInfo(XRegistryKey regKey) {
return
FactoryHelper.writeRegistryServiceInfo(Writer4LaTeX.__implementationName,
Writer4LaTeX.__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);
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/TeXify.java 0000644 0001750 0001750 00000014274 11540075666 025660 0 ustar rene rene /************************************************************************
*
* 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.writer4latex;
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 env =null;
if (ExternalApps.BIBTEX.equals(sAppList[i]) && sBibinputs!=null) {
env = new HashMap();
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;
}
} writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/TeXImportFilter.java 0000644 0001750 0001750 00000025374 12411031012 027463 0 ustar rene rene /************************************************************************
*
* 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.4 (2014-09-24)
*
*/
package org.openoffice.da.comp.writer4latex;
//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 TeXImportFilter
*
* @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 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();
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/BibliographyDialog.java 0000644 0001750 0001750 00000032507 11524722053 030171 0 ustar rene rene /************************************************************************
*
* 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-2011 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-01-31)
*
*/
package org.openoffice.da.comp.writer4latex;
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 in Writer4LaTeX.
*/
public final class BibliographyDialog
extends WeakBase
implements XServiceInfo, XContainerWindowEventHandler {
public static final String REGISTRY_PATH = "/org.openoffice.da.Writer4LaTeX.Options/BibliographyOptions";
private XComponentContext xContext;
private FolderPicker folderPicker;
/** The component will be registered under this name.
*/
public static String __serviceName = "org.openoffice.da.writer4latex.BibliographyDialog";
/** The component should also have an implementation name.
*/
public static String __implementationName = "org.openoffice.da.comp.writer4latex.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("Writer4LaTeX warning", "The selected directory does not contain any BibTeX files");
}
}
catch (IOException e) {
}
catch (URISyntaxException e) {
}
}
return true;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/DeTeXtive.java 0000644 0001750 0001750 00000014462 12411031012 026257 0 ustar rene rene /************************************************************************
*
* 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.writer4latex;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.HashSet;
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.Mouth;
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.Token;
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.TokenType;
/** This class analyzes a stream and detects if it is a TeX stream.
* Currently it is able to identify LaTeX and XeLaTeX (ConTeXt and plain TeX may be
* added later).
*/
public class DeTeXtive {
private Mouth mouth;
private Token token;
private HashSet 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();
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;
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/writer4latex/TeXDetectService.java 0000644 0001750 0001750 00000011774 12411031012 027573 0 ustar rene rene /************************************************************************
*
* 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.4 (2014-09-24)
*
*/
package org.openoffice.da.comp.writer4latex;
import java.io.IOException;
import com.sun.star.lib.uno.adapter.XInputStreamToInputStreamAdapter;
import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.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.writer4latex.LaTeX_File";
private static final String XELATEX_FILE = "org.openoffice.da.writer4latex.XeLaTeX_File";
// From constructor+initialization
private final XComponentContext m_xContext;
/** Construct a new TeXDetectService
*
* @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; iFieldMasterNameProvider
*
* @param xContext the component context to get the desktop from
*/
public FieldMasterNameProvider(XComponentContext xContext) {
fieldMasterNames = new String[0];
// TODO: This code should be shared (identical with StyleNameProvider...)
// Get the model for the current frame
XModel xModel = null;
try {
Object desktop = xContext.getServiceManager().createInstanceWithContext("com.sun.star.frame.Desktop", xContext);
XDesktop xDesktop = (XDesktop)UnoRuntime.queryInterface(XDesktop.class, desktop);
XController xController = xDesktop.getCurrentFrame().getController();
if (xController!=null) {
xModel = xController.getModel();
}
}
catch (Exception e) {
// do nothing
}
// Get the field masters from the model
if (xModel!=null) {
XTextFieldsSupplier xSupplier = (XTextFieldsSupplier) UnoRuntime.queryInterface(
XTextFieldsSupplier.class, xModel);
if (xSupplier!=null) {
XNameAccess xFieldMasters = xSupplier.getTextFieldMasters();
fieldMasterNames = xFieldMasters.getElementNames();
}
}
}
/** Get the names of all field masters relative to a given prefix
*
* @param sPrefix the prefix to look for, e.g. "com.sun.star.text.fieldmaster.SetExpression."
* @return a read only Set containing all known names with the given prefix, stripped for the prefix
*/
public Set getFieldMasterNames(String sPrefix) {
Set names = new HashSet();
for (String sName : fieldMasterNames) {
if (sName.startsWith(sPrefix)) {
names.add(sName.substring(sPrefix.length()));
}
}
return names;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/helper/MacroExpander.java 0000644 0001750 0001750 00000004341 11360606615 027722 0 ustar rene rene /************************************************************************
*
* MacroExpander.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 (2010-03-12)
*
*/
package org.openoffice.da.comp.w2lcommon.helper;
import com.sun.star.lang.IllegalArgumentException;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.util.XMacroExpander;
public class MacroExpander {
private XMacroExpander xExpander;
/** Convenience wrapper class for the UNO Macro Expander singleton
*
* @param xContext the UNO component context from which "theMacroExpander" can be created
*/
public MacroExpander(XComponentContext xContext) {
Object expander = xContext.getValueByName("/singletons/com.sun.star.util.theMacroExpander");
xExpander = (XMacroExpander) UnoRuntime.queryInterface (XMacroExpander.class, expander);
}
/** Expand macros in a string
*
* @param s the string
* @return the expanded string
*/
public String expandMacros(String s) {
if (xExpander!=null && s.startsWith("vnd.sun.star.expand:")) {
// The string contains a macro, usually as a result of using %origin% in the registry
s = s.substring(20);
try {
return xExpander.expandMacros(s);
}
catch (IllegalArgumentException e) {
// Unknown macro name found, proceed and hope for the best
return s;
}
}
else {
return s;
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/helper/DialogAccess.java 0000644 0001750 0001750 00000030047 12425376526 027525 0 ustar rene rene /************************************************************************
*
* DialogAccess.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-10-27)
*
*/
package org.openoffice.da.comp.w2lcommon.helper;
import com.sun.star.awt.XControl;
import com.sun.star.awt.XControlContainer;
import com.sun.star.awt.XControlModel;
import com.sun.star.awt.XDialog;
import com.sun.star.beans.XPropertySet;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.util.Date;
/** This class provides some convenient methods to access a uno dialog
*/
public class DialogAccess {
/** The XDialog containing the controls. The subclass must override this */
private Object xDialog = null;
// State of a checkbox
public static final short CHECKBOX_NOT_CHECKED = 0;
public static final short CHECKBOX_CHECKED = 1;
public static final short CHECKBOX_DONT_KNOW = 2;
public DialogAccess(XDialog xDialog) {
this.xDialog = xDialog;
}
//////////////////////////////////////////////////////////////////////////
// Helpers to access controls in the dialog (to be used by the subclass)
// Note: The helpers fail silently if an exception occurs. Could query the
// the ClassId property for the control type and check that the property
// exists to ensure a correct behaviour in all cases, but as long as the
// helpers are used correctly, this doesn't really matter.
// Get the properties of a named control in the dialog
public XPropertySet getControlProperties(String sControlName) {
XControlContainer xContainer = (XControlContainer)
UnoRuntime.queryInterface(XControlContainer.class, xDialog);
XControl xControl = xContainer.getControl(sControlName);
XControlModel xModel = xControl.getModel();
XPropertySet xPropertySet = (XPropertySet)
UnoRuntime.queryInterface(XPropertySet.class, xModel);
return xPropertySet;
}
public boolean getControlEnabled(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return ((Boolean) xPropertySet.getPropertyValue("Enabled")).booleanValue();
}
catch (Exception e) {
// Will fail if the control does not exist
return false;
}
}
public void setControlEnabled(String sControlName, boolean bEnabled) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
xPropertySet.setPropertyValue("Enabled", new Boolean(bEnabled));
}
catch (Exception e) {
// Will fail if the control does not exist
}
}
public short getCheckBoxState(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return ((Short) xPropertySet.getPropertyValue("State")).shortValue();
}
catch (Exception e) {
// Will fail if the control does not exist or is not a checkbox
return CHECKBOX_DONT_KNOW;
}
}
public boolean getCheckBoxStateAsBoolean(String sControlName) {
return getCheckBoxState(sControlName)==CHECKBOX_CHECKED;
}
public void setCheckBoxState(String sControlName, short nState) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
xPropertySet.setPropertyValue("State",new Short(nState));
}
catch (Exception e) {
// will fail if the control does not exist or is not a checkbox or
// nState has an illegal value
}
}
public void setCheckBoxStateAsBoolean(String sControlName, boolean bChecked) {
setCheckBoxState(sControlName,bChecked ? CHECKBOX_CHECKED : CHECKBOX_NOT_CHECKED);
}
public String[] getListBoxStringItemList(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return (String[]) xPropertySet.getPropertyValue("StringItemList");
}
catch (Exception e) {
// Will fail if the control does not exist or is not a list box
return new String[0];
}
}
public void setListBoxStringItemList(String sControlName, String[] items) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
xPropertySet.setPropertyValue("StringItemList",items);
}
catch (Exception e) {
// Will fail if the control does not exist or is not a list box
}
}
public short getListBoxSelectedItem(String sControlName) {
// Returns the first selected element in case of a multiselection
XPropertySet xPropertySet = getControlProperties(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;
}
}
public void setListBoxSelectedItem(String sControlName, short nIndex) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
short[] selection = new short[1];
selection[0] = nIndex;
xPropertySet.setPropertyValue("SelectedItems",selection);
}
catch (Exception e) {
// Will fail if the control does not exist or is not a list box or
// nIndex is an illegal value
}
}
public short getListBoxLineCount(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return ((Short) xPropertySet.getPropertyValue("LineCount")).shortValue();
}
catch (Exception e) {
// Will fail if the control does not exist or is not a list box
return 0;
}
}
public void setListBoxLineCount(String sControlName, short nLineCount) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
xPropertySet.setPropertyValue("LineCount",new Short(nLineCount));
}
catch (Exception e) {
// Will fail if the control does not exist or is not a list box or
// nLineCount is an illegal value
}
}
public String getComboBoxText(String sControlName) {
// Returns the text of a combobox
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return (String) xPropertySet.getPropertyValue("Text");
}
catch (Exception e) {
// Will fail if the control does not exist or is not a combo
return "";
}
}
public void setComboBoxText(String sControlName, String sText) {
XPropertySet xPropertySet = getControlProperties(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
}
}
public String getLabelText(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return (String) xPropertySet.getPropertyValue("Label");
}
catch (Exception e) {
// Will fail if the control does not exist or is not a label
return "";
}
}
public void setLabelText(String sControlName, String sLabel) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
xPropertySet.setPropertyValue("Label",sLabel);
}
catch (Exception e) {
// Will fail if the control does not exist or is not a label
}
}
public String getTextFieldText(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return (String) xPropertySet.getPropertyValue("Text");
}
catch (Exception e) {
// Will fail if the control does not exist or is not a text field
return "";
}
}
public void setTextFieldText(String sControlName, String sText) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
xPropertySet.setPropertyValue("Text",sText);
}
catch (Exception e) {
// Will fail if the control does not exist or is not a text field
}
}
public String getFormattedFieldText(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return (String) xPropertySet.getPropertyValue("Text");
}
catch (Exception e) {
// Will fail if the control does not exist or is not a formatted field
return "";
}
}
public void setFormattedFieldText(String sControlName, String sText) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
xPropertySet.setPropertyValue("Text",sText);
}
catch (Exception e) {
// Will fail if the control does not exist or is not a formatted field
}
}
public int getDateFieldValue(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
Object dateObject = xPropertySet.getPropertyValue("Date");
if (dateObject instanceof Date) {
// Since LO 4.1
Date date = (Date) dateObject;
return 10000*date.Year+100*date.Month+date.Day;
}
else if (dateObject instanceof Integer) {
// AOO and older versions of LO
return ((Integer) dateObject).intValue();
}
else {
// The date field does not have a value
return 0;
}
}
catch (Exception e) {
// Will fail if the control does not exist or is not a date field
return 0;
}
}
public void setDateFieldValue(String sControlName, int nValue) {
XPropertySet xPropertySet = getControlProperties(sControlName);
Date date = new Date();
date.Year = (short) (nValue/10000);
date.Month = (short) ((nValue%10000)/100);
date.Day = (short) (nValue%100);
// TODO: Use reflection to identify the correct type of the property
try {
// Since LO 4.1
xPropertySet.setPropertyValue("Date", date);
} catch (Exception e) {
// AOO and older versions of LO
try {
xPropertySet.setPropertyValue("Date", nValue);
} catch (Exception e1) {
}
}
}
public int getNumericFieldValue(String sControlName) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
return ((Double) xPropertySet.getPropertyValue("Value")).intValue();
}
catch (Exception e) {
// Will fail if the control does not exist or is not a numeric field
return 0;
}
}
public void setNumericFieldValue(String sControlName, int nValue) {
XPropertySet xPropertySet = getControlProperties(sControlName);
try {
xPropertySet.setPropertyValue("Value",new Double(nValue));
}
catch (Exception e) {
// Will fail if the control does not exist or is not a numeric field
}
}
} writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/helper/PropertyHelper.java 0000644 0001750 0001750 00000004253 11164073375 030163 0 ustar rene rene /************************************************************************
*
* PropertyHelper.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-07-21)
*
*/
package org.openoffice.da.comp.w2lcommon.helper;
import java.util.Enumeration;
import java.util.Hashtable;
import com.sun.star.beans.PropertyValue;
/** This class provides access by name to a PropertyValue array
*/
public class PropertyHelper {
private Hashtable data;
public PropertyHelper() {
data = new Hashtable();
}
public PropertyHelper(PropertyValue[] props) {
data = new Hashtable();
int nLen = props.length;
for (int i=0; i keys() {
return data.keys();
}
public PropertyValue[] toArray() {
int nSize = data.size();
PropertyValue[] props = new PropertyValue[nSize];
int i=0;
Enumeration keys = keys();
while (keys.hasMoreElements()) {
String sKey = keys.nextElement();
props[i] = new PropertyValue();
props[i].Name = sKey;
props[i++].Value = get(sKey);
}
return props;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/helper/SimpleDialog.java 0000644 0001750 0001750 00000005131 11531425761 027542 0 ustar rene rene /************************************************************************
*
* SimpleDialog.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-2011 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-02-23)
*
*/
package org.openoffice.da.comp.w2lcommon.helper;
import com.sun.star.awt.XDialog;
import com.sun.star.awt.XDialogProvider2;
import com.sun.star.lang.XMultiComponentFactory;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
/** This is a simple helper class to display and access a dialog based on an
* XML description (using the DialogProvider2 service).
* Unlike DialogBase, this class creates a dialog without event handlers.
*
* TODO: Use this class in ConfigurationDialogBase
*/
public class SimpleDialog {
private XDialog xDialog;
private DialogAccess dialogAccess;
/** Create a new dialog
*
* @param xContext the component context from which to get the service manager
* @param sDialogPath the path to the dialog
*/
public SimpleDialog(XComponentContext xContext, String sDialogPath) {
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:"+sDialogPath+"?location=application";
xDialog = xDialogProvider.createDialog(sDialogUrl);
dialogAccess = new DialogAccess(xDialog);
} catch (com.sun.star.uno.Exception e) {
xDialog = null;
dialogAccess = null;
}
}
/** Get the UNO dialog
*
* @return the dialog, or null if creation failed
*/
public XDialog getDialog() {
return xDialog;
}
/** Get access to the controls of the dialog
*
* @return the control access helper, or null if creation failed
*/
public DialogAccess getControls() {
return dialogAccess;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/helper/FilePicker.java 0000644 0001750 0001750 00000007515 12411031012 027172 0 ustar rene rene /************************************************************************
*
* FilePicker.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.w2lcommon.helper;
import com.sun.star.lang.IllegalArgumentException;
import com.sun.star.lang.XComponent;
import com.sun.star.ui.dialogs.ExecutableDialogResults;
import com.sun.star.ui.dialogs.XExecutableDialog;
import com.sun.star.ui.dialogs.XFilePicker;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
public class FilePicker {
private XComponentContext xContext;
// The default directory for the dialog
private String sDirectoryURL;
/** Convenience wrapper class for the UNO file picker service
*
* @param xContext the UNO component context from which the file picker can be created
*/
public FilePicker(XComponentContext xContext) {
this.xContext = xContext;
sDirectoryURL = null;
}
/** Get one or more user selected paths with a file picker
*
* Warning: This does not work on all platforms when using native file pickers
* (but always when using Office file pickers)
*
* @return array containing the path URLs or null if the dialog is canceled
*/
public String[] getPaths() {
return getPaths(true);
}
/** Get a user selected path with a file picker
*
* @return the path URL or null if the dialog is canceled
*/
public String getPath() {
String[] sPaths = getPaths(false);
if (sPaths!=null && sPaths.length>0) {
return sPaths[0];
}
return null;
}
private String[] getPaths(boolean bAllowMultiSelection) {
// Create FilePicker
Object filePicker = null;
try {
// Note: Could be changed for OfficeFilePicker to always use internal file pickers
filePicker = xContext.getServiceManager().createInstanceWithContext("com.sun.star.ui.dialogs.FilePicker", xContext);
}
catch (com.sun.star.uno.Exception e) {
return null;
}
// Get the required interfaces
XFilePicker xFilePicker = (XFilePicker) UnoRuntime.queryInterface(XFilePicker.class, filePicker);
XExecutableDialog xExecutable = (XExecutableDialog) UnoRuntime.queryInterface(XExecutableDialog.class, xFilePicker);
// Configure the file picker
xFilePicker.setMultiSelectionMode(bAllowMultiSelection);
if (sDirectoryURL!=null) {
try {
xFilePicker.setDisplayDirectory(sDirectoryURL);
} catch (IllegalArgumentException e) {
e.printStackTrace();
}
}
// Get the paths
String[] sPaths = null;
if (xExecutable.execute() == ExecutableDialogResults.OK) {
sDirectoryURL = xFilePicker.getDisplayDirectory();
String[] sPathList = xFilePicker.getFiles();
int nCount = sPathList.length;
if (nCount>1) {
// According to the spec, the first entry is the path and remaining entries are file names
sPaths = new String[nCount-1];
for (int i=1; i> displayNameCollection;
private Map> internalNameCollection;
/** Construct a new StyleNameProvider
*
* @param xContext the componemt context to get the desktop from
*/
public StyleNameProvider(XComponentContext xContext) {
displayNameCollection = new HashMap>();
internalNameCollection = new HashMap>();
// Get the model for the current frame
XModel xModel = null;
try {
Object desktop = xContext.getServiceManager().createInstanceWithContext("com.sun.star.frame.Desktop", xContext);
XDesktop xDesktop = (XDesktop)UnoRuntime.queryInterface(XDesktop.class, desktop);
XController xController = xDesktop.getCurrentFrame().getController();
if (xController!=null) {
xModel = xController.getModel();
}
}
catch (Exception e) {
// do nothing
}
// Get the styles from the model
if (xModel!=null) {
XStyleFamiliesSupplier xSupplier = (XStyleFamiliesSupplier) UnoRuntime.queryInterface(
XStyleFamiliesSupplier.class, xModel);
if (xSupplier!=null) {
XNameAccess xFamilies = xSupplier.getStyleFamilies();
String[] sFamilyNames = xFamilies.getElementNames();
for (String sFamilyName : sFamilyNames) {
Map displayNames = new HashMap();
displayNameCollection.put(sFamilyName, displayNames);
Map internalNames = new HashMap();
internalNameCollection.put(sFamilyName, internalNames);
try {
XNameContainer xFamily = (XNameContainer) UnoRuntime.queryInterface(
XNameContainer.class, xFamilies.getByName(sFamilyName));
if (xFamily!=null) {
String[] sStyleNames = xFamily.getElementNames();
for (String sStyleName : sStyleNames) {
XPropertySet xProps = (XPropertySet) UnoRuntime.queryInterface(
XPropertySet.class, xFamily.getByName(sStyleName));
if (xProps!=null) {
String sDisplayName = (String) xProps.getPropertyValue("DisplayName");
displayNames.put(sStyleName, sDisplayName);
internalNames.put(sDisplayName, sStyleName);
}
}
}
}
catch (WrappedTargetException e) {
// ignore
}
catch (NoSuchElementException e) {
// will not happen
}
catch (UnknownPropertyException e) {
// will not happen
}
}
}
}
}
/** Get the mapping of internal names to display names for a style family
*
* @param sFamily the style family (for text documents this should be CharacterStyles, ParagraphStyles, FrameStyles, PageStyles or NumberingStyles)
* @return a read only map from internal names to display names, or null if the family is not known to the provider
*/
public Map getDisplayNames(String sFamily) {
if (displayNameCollection.containsKey(sFamily)) {
return Collections.unmodifiableMap(displayNameCollection.get(sFamily));
}
return null;
}
/** Get the mapping of display names to internal names for a style family
*
* @param sFamily the style family (for text documents this should be CharacterStyles, ParagraphStyles, FrameStyles, PageStyles or NumberingStyles)
* @return a read only map from display names to internal names, or null if the family is not known to the provider
*/
public Map getInternalNames(String sFamily) {
if (internalNameCollection.containsKey(sFamily)) {
return Collections.unmodifiableMap(internalNameCollection.get(sFamily));
}
return null;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/helper/MessageBox.java 0000644 0001750 0001750 00000007357 11251136744 027241 0 ustar rene rene /************************************************************************
*
* MessageBox.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-07-21)
*
*/
package org.openoffice.da.comp.w2lcommon.helper;
import com.sun.star.awt.Rectangle;
import com.sun.star.awt.WindowAttribute;
import com.sun.star.awt.WindowClass;
import com.sun.star.awt.WindowDescriptor;
import com.sun.star.awt.XMessageBox;
import com.sun.star.awt.XToolkit;
import com.sun.star.awt.XWindowPeer;
import com.sun.star.frame.XDesktop;
import com.sun.star.frame.XFrame;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
/** This class provides simple access to a uno awt message box
*/
public class MessageBox {
private XFrame xFrame;
private XToolkit xToolkit;
/** Create a new MessageBox belonging to the current frame
*/
public MessageBox(XComponentContext xContext) {
this(xContext,null);
}
/** Create a new MessageBox belonging to a specific frame
*/
public MessageBox(XComponentContext xContext, XFrame xFrame) {
try {
Object toolkit = xContext.getServiceManager()
.createInstanceWithContext("com.sun.star.awt.Toolkit",xContext);
xToolkit = (XToolkit) UnoRuntime.queryInterface(XToolkit.class,toolkit);
if (xFrame==null) {
Object desktop = xContext.getServiceManager()
.createInstanceWithContext("com.sun.star.frame.Desktop",xContext);
XDesktop xDesktop = (XDesktop) UnoRuntime.queryInterface(XDesktop.class,desktop);
xFrame = xDesktop.getCurrentFrame();
}
this.xFrame = xFrame;
}
catch (Exception e) {
// Failed to get toolkit or frame
xToolkit = null;
xFrame = null;
}
}
public void showMessage(String sTitle, String sMessage) {
if (xToolkit==null || xFrame==null) { return; }
try {
WindowDescriptor descriptor = new WindowDescriptor();
descriptor.Type = WindowClass.MODALTOP;
descriptor.WindowServiceName = "infobox";
descriptor.ParentIndex = -1;
descriptor.Parent = (XWindowPeer) UnoRuntime.queryInterface(
XWindowPeer.class,xFrame.getContainerWindow());
descriptor.Bounds = new Rectangle(0,0,300,200);
descriptor.WindowAttributes = WindowAttribute.BORDER |
WindowAttribute.MOVEABLE | WindowAttribute.CLOSEABLE;
XWindowPeer xPeer = xToolkit.createWindow(descriptor);
if (xPeer!=null) {
XMessageBox xMessageBox = (XMessageBox)
UnoRuntime.queryInterface(XMessageBox.class,xPeer);
if (xMessageBox!=null) {
xMessageBox.setCaptionText(sTitle);
xMessageBox.setMessageText(sMessage);
xMessageBox.execute();
}
}
}
catch (Exception e) {
// ignore, give up...
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/helper/RegistryHelper.java 0000644 0001750 0001750 00000005573 11455250660 030152 0 ustar rene rene /**
* RegistryHelper.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-05-01)
*
*
*/
package org.openoffice.da.comp.w2lcommon.helper;
import com.sun.star.beans.PropertyValue;
import com.sun.star.lang.XComponent;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
/** This class defines convenience methods to access the OOo registry
* using a given base path
*/
public class RegistryHelper {
private XComponentContext xContext;
/** Construct a new RegistryHelper using a given component context
*
* @param xContext the context to use to create new services
*/
public RegistryHelper(XComponentContext xContext) {
this.xContext = xContext;
}
/** Get a registry view relative to the given path
*
* @param sPath the base path within the registry
* @param bUpdate true if we need update access
* @return the registry view
* @throws com.sun.star.uno.Exception
*/
public Object getRegistryView(String sPath, boolean bUpdate)
throws com.sun.star.uno.Exception {
//Object provider = xMSF.createInstance(
Object provider = xContext.getServiceManager().createInstanceWithContext(
"com.sun.star.configuration.ConfigurationProvider", xContext);
XMultiServiceFactory xProvider = (XMultiServiceFactory)
UnoRuntime.queryInterface(XMultiServiceFactory.class,provider);
PropertyValue[] args = new PropertyValue[1];
args[0] = new PropertyValue();
args[0].Name = "nodepath";
args[0].Value = sPath;
String sServiceName = bUpdate ?
"com.sun.star.configuration.ConfigurationUpdateAccess" :
"com.sun.star.configuration.ConfigurationAccess";
Object view = xProvider.createInstanceWithArguments(sServiceName,args);
return view;
}
/** Dispose a previously obtained registry view
*
* @param view the view to dispose
*/
public void disposeRegistryView(Object view) {
XComponent xComponent = (XComponent)
UnoRuntime.queryInterface(XComponent.class,view);
xComponent.dispose();
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/helper/XPropertySetHelper.java 0000644 0001750 0001750 00000006734 11176671674 031006 0 ustar rene rene /************************************************************************
*
* XPropertySetHelper.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-07-21)
*
*/
package org.openoffice.da.comp.w2lcommon.helper;
import com.sun.star.beans.PropertyVetoException;
import com.sun.star.beans.UnknownPropertyException;
import com.sun.star.beans.XPropertySet;
import com.sun.star.lang.IllegalArgumentException;
import com.sun.star.lang.WrappedTargetException;
/** Helper class providing staic convenience methods for accesing an XPropertySet
* The helpers will fail silently if names or data is provided, but the user is expected to
* apply them with correct data only...
*/
public class XPropertySetHelper {
public static Object getPropertyValue(XPropertySet xProps, String sName) {
try {
return xProps.getPropertyValue(sName);
}
catch (UnknownPropertyException e) {
return null;
}
catch (WrappedTargetException e) {
return null;
}
}
public static void setPropertyValue(XPropertySet xProps, String sName, Object value) {
try {
xProps.setPropertyValue(sName,value);
}
catch (UnknownPropertyException e) {
}
catch (PropertyVetoException e) { // unacceptable value
}
catch (IllegalArgumentException e) {
}
catch (WrappedTargetException e) {
}
}
public static String getPropertyValueAsString(XPropertySet xProps, String sName) {
Object value = getPropertyValue(xProps,sName);
return value instanceof String ? (String) value : "";
}
public static int getPropertyValueAsInteger(XPropertySet xProps, String sName) {
Object value = getPropertyValue(xProps,sName);
return value instanceof Integer ? ((Integer) value).intValue() : 0;
}
public static void setPropertyValue(XPropertySet xProps, String sName, int nValue) {
setPropertyValue(xProps,sName,new Integer(nValue));
}
public static short getPropertyValueAsShort(XPropertySet xProps, String sName) {
Object value = getPropertyValue(xProps,sName);
return value instanceof Short ? ((Short) value).shortValue() : 0;
}
public static void setPropertyValue(XPropertySet xProps, String sName, short nValue) {
setPropertyValue(xProps,sName,new Short(nValue));
}
public static boolean getPropertyValueAsBoolean(XPropertySet xProps, String sName) {
Object value = getPropertyValue(xProps,sName);
return value instanceof Boolean ? ((Boolean) value).booleanValue() : false;
}
public static void setPropertyValue(XPropertySet xProps, String sName, boolean bValue) {
setPropertyValue(xProps,sName,new Boolean(bValue));
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/ 0000755 0001750 0001750 00000000000 12603463650 024334 5 ustar rene rene writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/ByteArrayXStream.java 0000644 0001750 0001750 00000016522 11251136744 030412 0 ustar rene rene /************************************************************************
*
* ByteArrayXStream.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-07-22)
*
*/
package org.openoffice.da.comp.w2lcommon.filter;
// This class is based on these java uno adapter classes:
// com.sun.star.lib.uno.adapter.ByteArrayToXInputStreamAdapter;
// com.sun.star.lib.uno.adapter.XOutputStreamToByteArrayAdapter;
// See http://go-oo.org/lxr/source/udk/javaunohelper/com/sun/star/lib/uno/adapter/XOutputStreamToByteArrayAdapter.java
// and http://go-oo.org/lxr/source/udk/javaunohelper/com/sun/star/lib/uno/adapter/ByteArrayToXInputStreamAdapter.java
// for original source
import com.sun.star.io.XInputStream;
import com.sun.star.io.XOutputStream;
import com.sun.star.io.XSeekable;
import com.sun.star.io.XStream;
/** This is a java-uno adapter class which implements XStream using a
* byte array. (We need this because XGraphicProvider demans read/write access
* when storing a graphic to a stream.)
*/
public class ByteArrayXStream implements XInputStream, XOutputStream, XSeekable, XStream {
// Keep data about our byte array (we read and write to the same byte array)
private int initialSize = 100240; // 10 kb
private int size = 0; // The current buffer size
private int position = 0; // The current write position, always<=size
private int readPosition = 0; // The current read position, always<=position
private boolean closed = false; // The XStream is closed
private byte[] buffer; // The buffer
// Constructor: Initialize the byte array
public ByteArrayXStream() {
size = initialSize;
buffer = new byte[size];
}
// Implementation of XOutputStream
public void closeOutput()
throws com.sun.star.io.NotConnectedException,
com.sun.star.io.BufferSizeExceededException,
com.sun.star.io.IOException {
// trim buffer
if ( buffer.length > position) {
byte[] newBuffer = new byte[position];
System.arraycopy(buffer, 0, newBuffer, 0, position);
buffer = newBuffer;
}
closed = true;
}
public void flush()
throws com.sun.star.io.NotConnectedException,
com.sun.star.io.BufferSizeExceededException,
com.sun.star.io.IOException {
}
public void writeBytes(byte[] values)
throws com.sun.star.io.NotConnectedException,
com.sun.star.io.BufferSizeExceededException,
com.sun.star.io.IOException {
if ( values.length > size-position ) {
byte[] newBuffer = null;
while ( values.length > size-position )
size *= 2;
newBuffer = new byte[size];
System.arraycopy(buffer, 0, newBuffer, 0, position);
buffer = newBuffer;
}
System.arraycopy(values, 0, buffer, position, values.length);
position += values.length;
}
// Implementation of XInputStream
private void _check() throws com.sun.star.io.NotConnectedException, com.sun.star.io.IOException {
if(closed) {
throw new com.sun.star.io.IOException("input closed");
}
}
public int available() throws com.sun.star.io.NotConnectedException, com.sun.star.io.IOException {
_check();
return position - readPosition;
}
public void closeInput() throws com.sun.star.io.NotConnectedException, com.sun.star.io.IOException {
closed = true;
}
public int readBytes(byte[][] values, int param) throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException {
_check();
try {
int remain = (int)(position - readPosition);
if (param > remain) param = remain;
/* ARGH!!! */
if (values[0] == null){
values[0] = new byte[param];
// System.err.println("allocated new buffer of "+param+" bytes");
}
System.arraycopy(buffer, readPosition, values[0], 0, param);
// System.err.println("readbytes() -> "+param);
readPosition += param;
return param;
} catch (ArrayIndexOutOfBoundsException ae) {
// System.err.println("readbytes() -> ArrayIndexOutOfBounds");
ae.printStackTrace();
throw new com.sun.star.io.BufferSizeExceededException("buffer overflow");
} catch (Exception e) {
// System.err.println("readbytes() -> Exception: "+e.getMessage());
e.printStackTrace();
throw new com.sun.star.io.IOException("error accessing buffer");
}
}
public int readSomeBytes(byte[][] values, int param) throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException {
// System.err.println("readSomebytes()");
return readBytes(values, param);
}
public void skipBytes(int param) throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException {
// System.err.println("skipBytes("+param+")");
_check();
if (param > (position - readPosition))
throw new com.sun.star.io.BufferSizeExceededException("buffer overflow");
readPosition += param;
}
// Implementation of XSeekable
public long getLength() throws com.sun.star.io.IOException {
// System.err.println("getLength() -> "+m_length);
if (buffer != null) return position;
else throw new com.sun.star.io.IOException("no bytes");
}
public long getPosition() throws com.sun.star.io.IOException {
// System.err.println("getPosition() -> "+m_pos);
if (buffer != null) return readPosition;
else throw new com.sun.star.io.IOException("no bytes");
}
public void seek(long param) throws com.sun.star.lang.IllegalArgumentException, com.sun.star.io.IOException {
// System.err.println("seek("+param+")");
if (buffer != null) {
if (param < 0 || param > position) throw new com.sun.star.lang.IllegalArgumentException("invalid seek position");
else readPosition = (int)param;
} else throw new com.sun.star.io.IOException("no bytes");
}
// Implementation of XStream
public XInputStream getInputStream() { return this; }
public XOutputStream getOutputStream() { return this; }
// Get the buffer
public byte[] getBuffer() { return buffer; }
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/ConfigurationDialogBase.java 0000644 0001750 0001750 00000070454 12406234417 031731 0 ustar rene rene /************************************************************************
*
* ConfigurationDialogBase.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-16)
*
*/
package org.openoffice.da.comp.w2lcommon.filter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
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.container.NoSuchElementException;
import com.sun.star.io.NotConnectedException;
import com.sun.star.io.XInputStream;
import com.sun.star.io.XOutputStream;
import com.sun.star.lang.XMultiComponentFactory;
import com.sun.star.ucb.CommandAbortedException;
import com.sun.star.ucb.XSimpleFileAccess2;
import com.sun.star.ui.dialogs.ExecutableDialogResults;
import com.sun.star.uno.AnyConverter;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.util.XStringSubstitution;
import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.lib.uno.adapter.XInputStreamToInputStreamAdapter;
import com.sun.star.lib.uno.adapter.XOutputStreamToOutputStreamAdapter;
import writer2latex.api.ComplexOption;
import writer2latex.api.Config;
import writer2latex.api.ConverterFactory;
import writer2latex.util.Misc;
import org.openoffice.da.comp.w2lcommon.helper.DialogAccess;
import org.openoffice.da.comp.w2lcommon.helper.FilePicker;
import org.openoffice.da.comp.w2lcommon.helper.StyleNameProvider;
/** This is a base implementation of a uno component which supports several option pages
* with a single XContainerWindowEventHandler. The title of the dialogs
* are used to differentiate between the individual pages
*/
public abstract class ConfigurationDialogBase extends WeakBase implements XContainerWindowEventHandler {
// The full path to the configuration file we handle
private String sConfigFileName = null;
// The component context
protected XComponentContext xContext;
// File picker wrapper
protected FilePicker filePicker = null;
// UNO simple file access service
protected XSimpleFileAccess2 sfa2 = null;
// UNO path substitution
protected XStringSubstitution xPathSub = null;
// The configuration implementation
protected Config config;
// The individual page handlers (the subclass must populate this)
protected Map pageHandlers = new HashMap();
// The subclass must provide these:
// MIME type of the document type we configure
protected abstract String getMIMEType();
// The dialog library containing the "new" and "delete" dialogs
protected abstract String getDialogLibraryName();
// The file name used for persistent storage of the edited configuration
protected abstract String getConfigFileName();
/** Create a new ConfigurationDialogBase */
public ConfigurationDialogBase(XComponentContext xContext) {
this.xContext = xContext;
// Get the file picker
filePicker = new FilePicker(xContext);
// Get the SimpleFileAccess service
try {
Object sfaObject = xContext.getServiceManager().createInstanceWithContext(
"com.sun.star.ucb.SimpleFileAccess", xContext);
sfa2 = (XSimpleFileAccess2) UnoRuntime.queryInterface(XSimpleFileAccess2.class, sfaObject);
}
catch (com.sun.star.uno.Exception e) {
// failed to get SimpleFileAccess service (should not happen)
}
// Create the config file name
try {
Object psObject = xContext.getServiceManager().createInstanceWithContext(
"com.sun.star.util.PathSubstitution", xContext);
xPathSub = (XStringSubstitution) UnoRuntime.queryInterface(XStringSubstitution.class, psObject);
sConfigFileName = xPathSub.substituteVariables("$(user)/"+getConfigFileName(), false);
}
catch (com.sun.star.uno.Exception e) {
// failed to get PathSubstitution service (should not happen)
}
// Create the configuration
config = ConverterFactory.createConverter(getMIMEType()).getConfig();
}
// 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);
String sTitle = xDialog.getTitle();
if (!pageHandlers.containsKey(sTitle)) {
throw new com.sun.star.lang.WrappedTargetException("Unknown dialog "+sTitle);
}
DialogAccess dlg = new DialogAccess(xDialog);
try {
if (sMethod.equals("external_event") ) {
return handleExternalEvent(dlg, sTitle, event);
}
}
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 pageHandlers.get(sTitle).handleEvent(dlg, sMethod);
}
private boolean handleExternalEvent(DialogAccess dlg, String sTitle, Object aEventObject) throws com.sun.star.uno.Exception {
try {
String sMethod = AnyConverter.toString(aEventObject);
if (sMethod.equals("ok")) {
loadConfig(); // The file may have been changed by other pages, thus we reload
pageHandlers.get(sTitle).getControls(dlg);
saveConfig();
return true;
}
else if (sMethod.equals("back") || sMethod.equals("initialize")) {
loadConfig();
pageHandlers.get(sTitle).setControls(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 the user configuration from file
private void loadConfig() {
if (sfa2!=null && sConfigFileName!=null) {
try {
XInputStream xIs = sfa2.openFileRead(sConfigFileName);
if (xIs!=null) {
InputStream is = new XInputStreamToInputStreamAdapter(xIs);
config.read(is);
is.close();
xIs.closeInput();
}
}
catch (IOException e) {
// ignore
}
catch (NotConnectedException e) {
// ignore
}
catch (CommandAbortedException e) {
// ignore
}
catch (com.sun.star.uno.Exception e) {
// ignore
}
}
}
// Save the user configuration
private void saveConfig() {
if (sfa2!=null && sConfigFileName!=null) {
try {
//Remove the file if it exists
if (sfa2.exists(sConfigFileName)) {
sfa2.kill(sConfigFileName);
}
// Then write the new contents
XOutputStream xOs = sfa2.openFileWrite(sConfigFileName);
if (xOs!=null) {
OutputStream os = new XOutputStreamToOutputStreamAdapter(xOs);
config.write(os);
os.close();
xOs.closeOutput();
}
}
catch (IOException e) {
// ignore
}
catch (NotConnectedException e) {
// ignore
}
catch (CommandAbortedException e) {
// ignore
}
catch (com.sun.star.uno.Exception e) {
// ignore
}
}
}
// Inner class to handle the individual option pages
protected abstract class PageHandler {
protected abstract void getControls(DialogAccess dlg);
protected abstract void setControls(DialogAccess dlg);
protected abstract boolean handleEvent(DialogAccess dlg, String sMethodName);
// Methods to set and get controls based on config
protected void checkBoxFromConfig(DialogAccess dlg, String sCheckBoxName, String sConfigName) {
dlg.setCheckBoxStateAsBoolean(sCheckBoxName, "true".equals(config.getOption(sConfigName)));
}
protected void checkBoxToConfig(DialogAccess dlg, String sCheckBoxName, String sConfigName) {
config.setOption(sConfigName, Boolean.toString(dlg.getCheckBoxStateAsBoolean(sCheckBoxName)));
}
protected void textFieldFromConfig(DialogAccess dlg, String sTextBoxName, String sConfigName) {
dlg.setTextFieldText(sTextBoxName, config.getOption(sConfigName));
}
protected void textFieldToConfig(DialogAccess dlg, String sTextBoxName, String sConfigName) {
config.setOption(sConfigName, dlg.getTextFieldText(sTextBoxName));
}
protected void listBoxFromConfig(DialogAccess dlg, String sListBoxName, String sConfigName, String[] sConfigValues, short nDefault) {
String sCurrentValue = config.getOption(sConfigName);
int nCount = sConfigValues.length;
for (short i=0; i=0 && deleteItem(sItems[nSelected])) {
int nOldLen = sItems.length;
String[] sNewItems = new String[nOldLen-1];
if (nSelected>0) {
System.arraycopy(sItems, 0, sNewItems, 0, nSelected);
}
if (nSelected suggestions) {
XDialog xDialog=getDialog(getDialogLibraryName()+".NewDialog");
if (xDialog!=null) {
String[] sItems = Misc.sortStringSet(suggestions);
DialogAccess ndlg = new DialogAccess(xDialog);
ndlg.setListBoxStringItemList("Name", sItems);
String sResult = null;
if (xDialog.execute()==ExecutableDialogResults.OK) {
DialogAccess dlg = new DialogAccess(xDialog);
sResult = dlg.getTextFieldText("Name");
}
xDialog.endExecute();
return sResult;
}
return null;
}
protected String appendItem(DialogAccess dlg, String sListName, Set suggestions) {
String[] sItems = dlg.getListBoxStringItemList(sListName);
String sNewItem = newItem(suggestions);
if (sNewItem!=null) {
int nOldLen = sItems.length;
for (short i=0; i attr);
protected abstract void setControls(DialogAccess dlg, Map attr);
protected abstract void clearControls(DialogAccess dlg);
protected abstract void prepareControls(DialogAccess dlg, boolean bHasDefinitions);
// Constructor
protected StylesPageHandler(int nCount) {
// Get the style name provider
styleNameProvider = new StyleNameProvider(xContext);
// Reset the options
styleMap = new ComplexOption[nCount];
for (int i=0; i displayNames = styleNameProvider.getDisplayNames(sOOoFamilyNames[i]);
copyStyles(configMap, styleMap[i], displayNames);
}
// Display paragraph maps first
nCurrentFamily = -1;
sCurrentStyleName = null;
dlg.setListBoxSelectedItem("StyleFamily", (short)1);
styleFamilyChange(dlg);
}
protected void getControls(DialogAccess dlg) {
updateStyleMaps(dlg);
// Save style maps to config (translating keys back to internal names)
int nCount = sFamilyNames.length;
for (int i=0; i internalNames = styleNameProvider.getInternalNames(sOOoFamilyNames[i]);
copyStyles(styleMap[i], configMap, internalNames);
}
}
protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("StyleFamilyChange")) {
styleFamilyChange(dlg);
return true;
}
else if (sMethod.equals("StyleNameChange")) {
styleNameChange(dlg);
return true;
}
else if (sMethod.equals("NewStyleClick")) {
newStyleClick(dlg);
return true;
}
else if (sMethod.equals("DeleteStyleClick")) {
deleteStyleClick(dlg);
return true;
}
else if (sMethod.equals("LoadDefaultsClick")) {
loadDefaultsClick(dlg);
return true;
}
return false;
}
// Internal methods
private void updateStyleMaps(DialogAccess dlg) {
// Save the current style map, if any
if (nCurrentFamily>-1 && sCurrentStyleName!=null) {
getControls(dlg,styleMap[nCurrentFamily].get(sCurrentStyleName));
}
}
private void styleFamilyChange(DialogAccess dlg) {
short nNewFamily = dlg.getListBoxSelectedItem("StyleFamily");
if (nNewFamily>-1 && nNewFamily!=nCurrentFamily) {
// The user has changed the family; load and display the corresponding style names
updateStyleMaps(dlg);
nCurrentFamily = nNewFamily;
sCurrentStyleName = null;
String[] sStyleNames = Misc.sortStringSet(styleMap[nNewFamily].keySet());
dlg.setListBoxStringItemList("StyleName", sStyleNames);
if (sStyleNames.length>0) {
dlg.setListBoxSelectedItem("StyleName", (short)0);
}
else {
dlg.setListBoxSelectedItem("StyleName", (short)-1);
}
updateStyleControls(dlg);
styleNameChange(dlg);
}
}
private void styleNameChange(DialogAccess dlg) {
if (nCurrentFamily>-1) {
updateStyleMaps(dlg);
short nStyleNameItem = dlg.getListBoxSelectedItem("StyleName");
if (nStyleNameItem>=0) {
sCurrentStyleName = dlg.getListBoxStringItemList("StyleName")[nStyleNameItem];
setControls(dlg,styleMap[nCurrentFamily].get(sCurrentStyleName));
}
else {
sCurrentStyleName = null;
clearControls(dlg);
}
}
}
private void newStyleClick(DialogAccess dlg) {
if (nCurrentFamily>-1) {
updateStyleMaps(dlg);
// Invalidate current style name in any case (appendItem returns null if the user
// selects an existing style, but it still changes the current item)
sCurrentStyleName = null;
String sNewName = appendItem(dlg, "StyleName",styleNameProvider.getInternalNames(sOOoFamilyNames[nCurrentFamily]).keySet());
if (sNewName!=null) {
styleMap[nCurrentFamily].put(sNewName, new HashMap());
clearControls(dlg);
}
styleNameChange(dlg);
updateStyleControls(dlg);
}
}
private void deleteStyleClick(DialogAccess dlg) {
if (nCurrentFamily>-1 && sCurrentStyleName!=null) {
String sStyleName = sCurrentStyleName;
if (deleteCurrentItem(dlg,"StyleName")) {
styleMap[nCurrentFamily].remove(sStyleName);
sCurrentStyleName=null;
styleNameChange(dlg);
}
updateStyleControls(dlg);
}
}
private void loadDefaultsClick(DialogAccess dlg) {
updateStyleMaps(dlg);
// Count styles that we will overwrite
Config clean = ConverterFactory.createConverter(getMIMEType()).getConfig();
clean.readDefaultConfig(getDefaultConfigName());
int nCount = 0;
int nFamilyCount = sFamilyNames.length;
for (int i=0; i displayNames = styleNameProvider.getDisplayNames(sOOoFamilyNames[i]);
for (String sName : cleanMap.keySet()) {
String sDisplayName = (displayNames!=null && displayNames.containsKey(sName)) ? displayNames.get(sName) : "";
if (styleMap[i].containsKey(sDisplayName)) { nCount++; }
}
}
// Display confirmation dialog
boolean bConfirm = false;
XDialog xDialog=getDialog(getDialogLibraryName()+".LoadDefaults");
if (xDialog!=null) {
DialogAccess ldlg = new DialogAccess(xDialog);
if (nCount>0) {
String sLabel = ldlg.getLabelText("OverwriteLabel");
sLabel = sLabel.replaceAll("%s", Integer.toString(nCount));
ldlg.setLabelText("OverwriteLabel", sLabel);
}
else {
ldlg.setLabelText("OverwriteLabel", "");
}
bConfirm = xDialog.execute()==ExecutableDialogResults.OK;
xDialog.endExecute();
}
// Do the replacement
if (bConfirm) {
for (int i=0; i displayNames = styleNameProvider.getDisplayNames(sOOoFamilyNames[i]);
copyStyles(cleanMap, styleMap[i], displayNames);
}
}
// Force update of the user interface
nCurrentFamily = -1;
sCurrentStyleName = null;
styleFamilyChange(dlg);
}
private void updateStyleControls(DialogAccess dlg) {
boolean bHasMappings = dlg.getListBoxStringItemList("StyleName").length>0;
dlg.setControlEnabled("DeleteStyleButton", bHasMappings);
prepareControls(dlg,bHasMappings);
}
private void copyStyles(ComplexOption source, ComplexOption target, Map nameTranslation) {
for (String sName : source.keySet()) {
String sNewName = sName;
if (nameTranslation!=null && nameTranslation.containsKey(sName)) {
sNewName = nameTranslation.get(sName);
}
target.copy(sNewName, source.get(sName));
}
}
}
protected abstract class AttributePageHandler extends PageHandler {
// The subclass must define this
protected String[] sAttributeNames;
// Our data
private ComplexOption attributeMap = new ComplexOption();
private int nCurrentAttribute = -1;
// Some methods to be implemented by subclass
protected abstract void getControls(DialogAccess dlg, Map attr);
protected abstract void setControls(DialogAccess dlg, Map attr);
protected abstract void prepareControls(DialogAccess dlg, boolean bEnable);
// Implement abstract methods from our super
protected void setControls(DialogAccess dlg) {
// Load attribute maps from config
attributeMap.clear();
attributeMap.copyAll(config.getComplexOption("text-attribute-map"));
// Update the dialog
nCurrentAttribute = -1;
dlg.setListBoxSelectedItem("FormattingAttribute", (short)0);
formattingAttributeChange(dlg);
}
protected void getControls(DialogAccess dlg) {
updateAttributeMaps(dlg);
// Save attribute maps to config
ComplexOption configMap = config.getComplexOption("text-attribute-map");
configMap.clear();
for (String s: attributeMap.keySet()) {
Map attr = attributeMap.get(s);
if (!attr.containsKey("deleted") || attr.get("deleted").equals("false")) {
configMap.copy(s, attr);
}
}
}
protected boolean handleEvent(DialogAccess dlg, String sMethod) {
if (sMethod.equals("FormattingAttributeChange")) {
formattingAttributeChange(dlg);
return true;
}
else if (sMethod.equals("CustomAttributeChange")) {
customAttributeChange(dlg);
return true;
}
return false;
}
// Internal methods
private void updateAttributeMaps(DialogAccess dlg) {
// Save the current attribute map, if any
if (nCurrentAttribute>-1) {
String sName = sAttributeNames[nCurrentAttribute];
if (!attributeMap.containsKey(sName)) {
attributeMap.put(sName, new HashMap());
}
Map attr = attributeMap.get(sName);
attr.put("deleted", Boolean.toString(!dlg.getCheckBoxStateAsBoolean("CustomAttribute")));
getControls(dlg,attr);
attributeMap.put(sName, attr);
}
}
private void formattingAttributeChange(DialogAccess dlg) {
updateAttributeMaps(dlg);
short nNewAttribute = dlg.getListBoxSelectedItem("FormattingAttribute");
if (nNewAttribute>-1 && nNewAttribute!=nCurrentAttribute) {
nCurrentAttribute = nNewAttribute;
String sName = sAttributeNames[nCurrentAttribute];
if (!attributeMap.containsKey(sName)) {
attributeMap.put(sName, new HashMap());
attributeMap.get(sName).put("deleted", "true");
}
Map attr = attributeMap.get(sName);
dlg.setCheckBoxStateAsBoolean("CustomAttribute", !attr.containsKey("deleted") || attr.get("deleted").equals("false"));
customAttributeChange(dlg);
setControls(dlg,attr);
}
}
private void customAttributeChange(DialogAccess dlg) {
prepareControls(dlg,dlg.getCheckBoxStateAsBoolean("CustomAttribute"));
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/OptionsDialogBase.java 0000644 0001750 0001750 00000052536 12425376526 030567 0 ustar rene rene /************************************************************************
*
* OptionsDialogBase.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-11-01)
*
*/
package org.openoffice.da.comp.w2lcommon.filter;
import java.util.HashSet;
import com.sun.star.awt.XDialogEventHandler;
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.document.XDocumentPropertiesSupplier;
import com.sun.star.frame.XDesktop;
import com.sun.star.lang.XComponent;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.lang.XServiceName;
import com.sun.star.lang.XTypeProvider;
import com.sun.star.ui.dialogs.XExecutableDialog;
import com.sun.star.uno.Type;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.util.XChangesBatch;
import org.openoffice.da.comp.w2lcommon.helper.DialogBase;
import org.openoffice.da.comp.w2lcommon.helper.MacroExpander;
import org.openoffice.da.comp.w2lcommon.helper.PropertyHelper;
import org.openoffice.da.comp.w2lcommon.helper.XPropertySetHelper;
/** This class provides an abstract uno component which implements a filter ui
*/
public abstract class OptionsDialogBase extends DialogBase implements
XPropertyAccess { // Filter ui requires XExecutableDialog + XPropertyAccess
//////////////////////////////////////////////////////////////////////////
// The subclass must override the following; and override the
// implementation of XDialogEventHandler if needed
/** Load settings from the registry to the dialog
* The subclass must implement this
*/
protected abstract void loadSettings(XPropertySet xRegistryProps);
/** Save settings from the dialog to the registry and create FilterData
* The subclass must implement this
*/
protected abstract void saveSettings(XPropertySet xRegistryProps, PropertyHelper filterData);
/** Return the name of the library containing the dialog
*/
public abstract String getDialogLibraryName();
/** Return the name of the dialog within the library
*/
public abstract String getDialogName();
/** Return the path to the options in the registry */
public abstract String getRegistryPath();
/** Create a new OptionsDialogBase */
public OptionsDialogBase(XComponentContext xContext) {
super(xContext);
this.xMSF = null; // must be set properly by subclass
mediaProps = null;
sConfigNames = null;
lockedOptions = new HashSet();
}
//////////////////////////////////////////////////////////////////////////
// Implement some methods required by DialogBase
/** Initialize the dialog (eg. with settings from the registry)
*/
public void initialize() {
try {
// Prepare registry view
Object view = getRegistryView(false);
XPropertySet xProps = (XPropertySet)
UnoRuntime.queryInterface(XPropertySet.class,view);
// Load settings using method from subclass
loadSettings(xProps);
// Dispose the registry view
disposeRegistryView(view);
}
catch (com.sun.star.uno.Exception e) {
// Failed to get registry view
}
}
/** Finalize the dialog after execution (eg. save settings to the registry)
*/
public void endDialog() {
try {
// Prepare registry view
Object rwview = getRegistryView(true);
XPropertySet xProps = (XPropertySet)
UnoRuntime.queryInterface(XPropertySet.class,rwview);
// Save settings and create FilterData using method from subclass
PropertyHelper filterData = new PropertyHelper();
saveSettings(xProps, filterData);
// Commit registry changes
XChangesBatch xUpdateContext = (XChangesBatch)
UnoRuntime.queryInterface(XChangesBatch.class,rwview);
try {
xUpdateContext.commitChanges();
}
catch (Exception e) {
// ignore
}
// Dispose the registry view
disposeRegistryView(rwview);
// 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
}
}
//////////////////////////////////////////////////////////////////////////
// Some private global variables
// The service factory
protected XMultiServiceFactory xMSF;
// The media properties (set/get via XPropertyAccess implementation)
private PropertyValue[] mediaProps;
// Configuration names (stored during execution of dialog)
private String[] sConfigNames;
// Set of locked controls
private HashSet lockedOptions;
//////////////////////////////////////////////////////////////////////////
// Some private utility methods
// Get the template name from the document with ui focus
private String getTemplateName() {
try {
// Get current component
Object desktop = xContext.getServiceManager()
.createInstanceWithContext("com.sun.star.frame.Desktop",xContext);
XDesktop xDesktop = (XDesktop) UnoRuntime.queryInterface(XDesktop.class,desktop);
XComponent xComponent = xDesktop.getCurrentComponent();
// Get the document info property set
XDocumentPropertiesSupplier xDocPropsSuppl =
UnoRuntime.queryInterface(XDocumentPropertiesSupplier.class, xComponent);
return xDocPropsSuppl.getDocumentProperties().getTemplateName();
}
catch (Exception e) {
return "";
}
}
// Get a view of the options root in the registry
private Object getRegistryView(boolean bUpdate)
throws com.sun.star.uno.Exception {
Object provider = xMSF.createInstance(
"com.sun.star.configuration.ConfigurationProvider");
XMultiServiceFactory xProvider = (XMultiServiceFactory)
UnoRuntime.queryInterface(XMultiServiceFactory.class,provider);
PropertyValue[] args = new PropertyValue[1];
args[0] = new PropertyValue();
args[0].Name = "nodepath";
args[0].Value = getRegistryPath();
String sServiceName = bUpdate ?
"com.sun.star.configuration.ConfigurationUpdateAccess" :
"com.sun.star.configuration.ConfigurationAccess";
Object view = xProvider.createInstanceWithArguments(sServiceName,args);
return view;
}
// Dispose a previously obtained registry view
private void disposeRegistryView(Object view) {
XComponent xComponent = (XComponent)
UnoRuntime.queryInterface(XComponent.class,view);
xComponent.dispose();
}
//////////////////////////////////////////////////////////////////////////
// Implement uno interfaces
// Override getTypes() from the interface XTypeProvider
public Type[] getTypes() {
Type[] typeReturn = {};
try {
typeReturn = new Type[] {
new Type( XServiceName.class ),
new Type( XServiceInfo.class ),
new Type( XTypeProvider.class ),
new Type( XExecutableDialog.class ),
new Type( XPropertyAccess.class ),
new Type( XDialogEventHandler.class ) };
} catch(Exception exception) {
}
return typeReturn;
}
// Implement the interface XPropertyAccess
public PropertyValue[] getPropertyValues() {
return mediaProps;
}
public void setPropertyValues(PropertyValue[] props) {
mediaProps = props;
}
//////////////////////////////////////////////////////////////////////////
// Various utility methods to be used by the sublasses
// Helpers to load and save settings
protected void updateLockedOptions() {
lockedOptions.clear();
short nItem = getListBoxSelectedItem("Config");
int nStdConfigs = getListBoxStringItemList("Config").length - sConfigNames.length;
if (nItem>=nStdConfigs) {
// Get current configuration name
String sName = sConfigNames[nItem-nStdConfigs];
try {
// Prepare registry view
Object view = getRegistryView(false);
XPropertySet xProps = (XPropertySet)
UnoRuntime.queryInterface(XPropertySet.class,view);
// Get the available configurations
Object configurations = XPropertySetHelper.getPropertyValue(xProps,"Configurations");
XNameAccess xConfigurations = (XNameAccess)
UnoRuntime.queryInterface(XNameAccess.class,configurations);
// Get the LockedOptions node from the desired configuration
String sLockedOptions = "";
Object config = xConfigurations.getByName(sName);
XPropertySet xCfgProps = (XPropertySet)
UnoRuntime.queryInterface(XPropertySet.class,config);
sLockedOptions = XPropertySetHelper.getPropertyValueAsString(xCfgProps,"LockedOptions");
// Dispose the registry view
disposeRegistryView(view);
// Feed lockedOptions with the comma separated list of options
int nStart = 0;
for (int i=0; i=nStdConfigs) { // only handle registry configurations
int i = nConfig-nStdConfigs;
XPropertySetHelper.setPropertyValue(xProps,"ConfigName",sConfigNames[i]);
try {
Object config = xNameAccess.getByName(sConfigNames[i]);
XPropertySet xCfgProps = (XPropertySet)
UnoRuntime.queryInterface(XPropertySet.class,config);
MacroExpander expander = new MacroExpander(xContext);
filterData.put("ConfigURL",expander.expandMacros(XPropertySetHelper.getPropertyValueAsString(xCfgProps,"ConfigURL")));
filterData.put("TemplateURL",expander.expandMacros(XPropertySetHelper.getPropertyValueAsString(xCfgProps,"TargetTemplateURL")));
filterData.put("StyleSheetURL",expander.expandMacros(XPropertySetHelper.getPropertyValueAsString(xCfgProps,"StyleSheetURL")));
// The resources are provided as a set
Object resources = XPropertySetHelper.getPropertyValue(xCfgProps,"Resources");
XNameAccess xResourceNameAccess = (XNameAccess) UnoRuntime.queryInterface(XNameAccess.class,resources);
if (xResourceNameAccess!=null) {
StringBuilder buf = new StringBuilder();
String[] sResourceNames = xResourceNameAccess.getElementNames();
for (String sName : sResourceNames) {
Object resource = xResourceNameAccess.getByName(sName);
XPropertySet xResourceProps = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,resource);
String sURL = expander.expandMacros(XPropertySetHelper.getPropertyValueAsString(xResourceProps,"URL"));
String sFileName = expander.expandMacros(XPropertySetHelper.getPropertyValueAsString(xResourceProps,"FileName"));
String sMediaType = expander.expandMacros(XPropertySetHelper.getPropertyValueAsString(xResourceProps,"MediaType"));
if (buf.length()>0) { buf.append(';'); }
buf.append(sURL).append("::").append(sFileName).append("::").append(sMediaType);
}
filterData.put("Resources",buf.toString());
}
}
catch (Exception e) {
}
}
else { // Standard configurations have no name
XPropertySetHelper.setPropertyValue(xProps,"ConfigName","");
}
XPropertySetHelper.setPropertyValue(xProps,"Config",nConfig);
return nConfig;
}
// Check box option (boolean)
protected boolean loadCheckBoxOption(XPropertySet xProps, String sName) {
boolean bValue = XPropertySetHelper.getPropertyValueAsBoolean(xProps,sName);
setCheckBoxStateAsBoolean(sName, bValue);
return bValue;
}
protected boolean saveCheckBoxOption(XPropertySet xProps, String sName) {
boolean bValue = getCheckBoxStateAsBoolean(sName);
XPropertySetHelper.setPropertyValue(xProps, sName, bValue);
return bValue;
}
protected boolean saveCheckBoxOption(XPropertySet xProps, PropertyHelper filterData,
String sName, String sOptionName) {
boolean bValue = saveCheckBoxOption(xProps, sName);
if (!isLocked(sOptionName)) {
filterData.put(sOptionName, Boolean.toString(bValue));
}
return bValue;
}
// List box option
protected short loadListBoxOption(XPropertySet xProps, String sName) {
short nValue = XPropertySetHelper.getPropertyValueAsShort(xProps, sName);
setListBoxSelectedItem(sName ,nValue);
return nValue;
}
protected short saveListBoxOption(XPropertySet xProps, String sName) {
short nValue = getListBoxSelectedItem(sName);
XPropertySetHelper.setPropertyValue(xProps, sName, nValue);
return nValue;
}
protected short saveListBoxOption(XPropertySet xProps, PropertyHelper filterData,
String sName, String sOptionName, String[] sValues) {
short nValue = saveListBoxOption(xProps, sName);
if (!isLocked(sOptionName) && (nValue>=0) && (nValue importFilter;
private Hashtable exportFilter;
private EPSCleaner epsCleaner;
public GraphicConverterImpl2(XComponentContext xComponentContext) {
this.xComponentContext = xComponentContext;
importFilter = new Hashtable();
importFilter.put(MIMETypes.BMP, "BMP - MS Windows");
importFilter.put(MIMETypes.EMF, "EMF - MS Windows Metafile");
importFilter.put(MIMETypes.EPS, "EPS - Encapsulated PostScript");
importFilter.put(MIMETypes.GIF, "GIF - Graphics Interchange Format");
importFilter.put(MIMETypes.JPEG, "JPG - JPEG");
importFilter.put(MIMETypes.PNG, "PNG - Portable Network Graphic");
importFilter.put(MIMETypes.SVM, "SVM - StarView Metafile");
importFilter.put(MIMETypes.TIFF, "TIF - Tag Image File");
importFilter.put(MIMETypes.WMF, "WMF - MS Windows Metafile");
exportFilter = new Hashtable();
exportFilter.put(MIMETypes.BMP,"draw_bmp_Export");
exportFilter.put(MIMETypes.EMF,"draw_emf_Export");
exportFilter.put(MIMETypes.EPS,"draw_eps_Export");
exportFilter.put(MIMETypes.GIF,"draw_gif_Export");
exportFilter.put(MIMETypes.JPEG,"draw_jpg_Export");
exportFilter.put(MIMETypes.PNG,"draw_png_Export");
exportFilter.put(MIMETypes.SVG,"draw_svg_Export");
exportFilter.put(MIMETypes.SVM,"draw_svm_Export");
exportFilter.put(MIMETypes.TIFF,"draw_tif_Export");
exportFilter.put(MIMETypes.WMF,"draw_wmf_Export");
exportFilter.put(MIMETypes.PDF,"draw_pdf_Export");
epsCleaner = new EPSCleaner();
}
public boolean supportsConversion(String sSourceMime, String sTargetMime, boolean bCrop, boolean bResize) {
// We don't support cropping and resizing
if (bCrop || bResize) { return false; }
// We currently support conversion of bitmaps and SVM into PDF, EPS and SVG
// TODO: SVG does not seem to work in all versions of OOo/LO?
// Trying WMF/EMF causes an IllegalArgumentException "URL seems to be an unsupported one"
// Seems to be an OOo bug; workaround: Use temporary files..??
boolean bSupportsSource = MIMETypes.SVM.equals(sSourceMime) ||
MIMETypes.PNG.equals(sSourceMime) || MIMETypes.JPEG.equals(sSourceMime) ||
MIMETypes.GIF.equals(sSourceMime) || MIMETypes.TIFF.equals(sSourceMime) ||
MIMETypes.BMP.equals(sSourceMime);
//|| MIMETypes.WMF.equals(sSourceMime) || MIMETypes.EMF.equals(sSourceMime);
boolean bSupportsTarget = MIMETypes.PDF.equals(sTargetMime) || MIMETypes.EPS.equals(sTargetMime) ||
MIMETypes.SVG.equals(sTargetMime);
return bSupportsSource && bSupportsTarget;
}
public byte[] convert(byte[] source, String sSourceMime, String sTargetMime) {
// Open a hidden sdraw document
XMultiComponentFactory xMCF = xComponentContext.getServiceManager();
try {
// Load the graphic into a new draw document as xDocument
// using a named filter
Object desktop = xMCF.createInstanceWithContext(
"com.sun.star.frame.Desktop", xComponentContext);
XComponentLoader xComponentLoader = (XComponentLoader)
UnoRuntime.queryInterface(XComponentLoader.class, desktop);
PropertyValue[] fileProps = new PropertyValue[3];
fileProps[0] = new PropertyValue();
fileProps[0].Name = "FilterName";
fileProps[0].Value = importFilter.get(sSourceMime);
fileProps[1] = new PropertyValue();
fileProps[1].Name = "InputStream";
fileProps[1].Value = new ByteArrayToXInputStreamAdapter(source);
fileProps[2] = new PropertyValue();
fileProps[2].Name = "Hidden";
fileProps[2].Value = new Boolean(true);
XComponent xDocument = xComponentLoader.loadComponentFromURL(
"private:stream", "_blank", 0, fileProps);
// Get the first draw page as xDrawPage
XDrawPagesSupplier xDrawPagesSupplier = (XDrawPagesSupplier)
UnoRuntime.queryInterface(XDrawPagesSupplier.class, xDocument);
XDrawPages xDrawPages = xDrawPagesSupplier.getDrawPages();
Object drawPage = xDrawPages.getByIndex(0);
XDrawPage xDrawPage = (XDrawPage) UnoRuntime.queryInterface(
XDrawPage.class, drawPage);
// Get the shape as xShape
Object shape = xDrawPage.getByIndex(0);
XShape xShape = (XShape) UnoRuntime.queryInterface(XShape.class, shape);
// Move the shape to upper left corner of the page
Point position = new Point();
position.X = 0;
position.Y = 0;
xShape.setPosition(position);
// Adjust the page size and margin to the size of the graphic
XPropertySet xPageProps = (XPropertySet) UnoRuntime.queryInterface(
XPropertySet.class, xDrawPage);
Size size = xShape.getSize();
xPageProps.setPropertyValue("Width", new Integer(size.Width));
xPageProps.setPropertyValue("Height", new Integer(size.Height));
xPageProps.setPropertyValue("BorderTop", new Integer(0));
xPageProps.setPropertyValue("BorderBottom", new Integer(0));
xPageProps.setPropertyValue("BorderLeft", new Integer(0));
xPageProps.setPropertyValue("BorderRight", new Integer(0));
// Export the draw document (xDocument)
refreshDocument(xDocument);
XOutputStreamToByteArrayAdapter outputStream = new XOutputStreamToByteArrayAdapter();
PropertyValue[] exportProps = new PropertyValue[3];
exportProps[0] = new PropertyValue();
exportProps[0].Name = "FilterName";
exportProps[0].Value = exportFilter.get(sTargetMime);
exportProps[1] = new PropertyValue();
exportProps[1].Name = "OutputStream";
exportProps[1].Value = outputStream;
exportProps[2] = new PropertyValue();
exportProps[2].Name = "Overwrite";
exportProps[2].Value = new Boolean(true);
XStorable xStore = (XStorable) UnoRuntime.queryInterface (
XStorable.class, xDocument);
xStore.storeToURL ("private:stream", exportProps);
outputStream.closeOutput();
byte[] result = outputStream.getBuffer();
xDocument.dispose();
if (MIMETypes.EPS.equals(sTargetMime)) {
return epsCleaner.cleanEps(result);
}
else {
return result;
}
}
catch (com.sun.star.beans.PropertyVetoException e) {
}
catch (com.sun.star.beans.UnknownPropertyException e) {
}
catch (com.sun.star.io.IOException e) {
}
catch (com.sun.star.lang.IllegalArgumentException e) {
}
catch (com.sun.star.lang.IndexOutOfBoundsException e) {
}
catch (com.sun.star.lang.WrappedTargetException e) {
}
catch (com.sun.star.uno.Exception e) {
}
// Conversion failed, for whatever reason
return null;
}
protected void refreshDocument(XComponent document) {
XRefreshable refreshable = (XRefreshable) UnoRuntime.queryInterface(XRefreshable.class, document);
if (refreshable != null) {
refreshable.refresh();
}
}
/* Dim SelSize As New com.sun.star.awt.Size
SelSize = oGraphic.Size
oDrawGraphic.GraphicURL = oGraphic.GraphicURL
oDrawGraphic.Size = SelSize
oDrawPage.add(oDrawGraphic)
oDrawGraphic.GraphicCrop = oGraphic.GraphicCrop
oDrawPage.Width = oGraphic.Size.Width
oDrawPage.Height = oGraphic.Size.Height
Dim aFilterData (1) As new com.sun.star.beans.PropertyValue
aFilterData(0).Name = "PixelWidth" '
aFilterData(0).Value = oDrawPage.Width/100 * iPixels / 25.40
aFilterData(1).Name = "PixelHeight"
aFilterData(1).Value = oDrawPage.Height/100 * iPixels / 25.40
Export( oDrawPage, sURLImageResized , aFilterData() )
On error resume Next
oDrawDoc.Close(True)
On error goto 0
SUB Export( xObject, sFileUrl As String, aFilterData )
Dim xExporter As Object
xExporter = createUnoService( "com.sun.star.drawing.GraphicExportFilter" )
xExporter.SetSourceDocument( xObject )
Dim aArgs (2) As new com.sun.star.beans.PropertyValue
'sFileURL = ConvertToURL(sFileURL)
aArgs(0).Name = "FilterName"
aArgs(0).Value = "jpg"
aArgs(1).Name = "URL"
aArgs(1).Value = sFileURL
'print sFileURL
aArgs(2).Name = "FilterData"
aArgs(2).Value = aFilterData
xExporter.filter( aArgs() )
END SUB*/
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/GraphicConverterImpl1.java 0000644 0001750 0001750 00000014200 12402657065 031346 0 ustar rene rene /************************************************************************
*
* GraphicConverterImpl1.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-05)
*/
package org.openoffice.da.comp.w2lcommon.filter;
// Java uno helper class
import com.sun.star.lib.uno.adapter.ByteArrayToXInputStreamAdapter;
// UNO classes
import com.sun.star.beans.PropertyValue;
import com.sun.star.graphic.XGraphic;
import com.sun.star.graphic.XGraphicProvider;
//import com.sun.star.io.XInputStream;
//import com.sun.star.io.XOutputStream;
import com.sun.star.lang.XMultiComponentFactory;
import com.sun.star.uno.XComponentContext;
import com.sun.star.uno.UnoRuntime;
//import java.io.InputStream;
//import java.io.OutputStream;
import writer2latex.api.GraphicConverter;
import writer2latex.api.MIMETypes;
/** A GraphicConverter implementation which uses the GraphicProvider service
* to convert the graphic. This service does only support simple format
* conversion using the "internal" graphics filters in Draw. Advanced features
* like pdf, crop and resize thus cannot be handled.
*/
public class GraphicConverterImpl1 implements GraphicConverter {
private XGraphicProvider xGraphicProvider;
private EPSCleaner epsCleaner;
public GraphicConverterImpl1(XComponentContext xComponentContext) {
try {
// Get the XGraphicProvider interface of the GraphicProvider service
XMultiComponentFactory xMCF = xComponentContext.getServiceManager();
Object graphicProviderObject = xMCF.createInstanceWithContext("com.sun.star.graphic.GraphicProvider", xComponentContext);
xGraphicProvider = (XGraphicProvider) UnoRuntime.queryInterface(XGraphicProvider.class, graphicProviderObject);
}
catch (com.sun.star.uno.Exception ex) {
System.err.println("Failed to get XGraphicProvider object");
xGraphicProvider = null;
}
epsCleaner = new EPSCleaner();
}
public boolean supportsConversion(String sSourceMime, String sTargetMime, boolean bCrop, boolean bResize) {
// We don't support cropping and resizing
if (bCrop || bResize) { return false; }
// We can convert vector formats to EPS and SVG
if ((MIMETypes.EPS.equals(sTargetMime) || MIMETypes.SVG.equals(sTargetMime)) &&
(MIMETypes.EMF.equals(sSourceMime) || MIMETypes.WMF.equals(sSourceMime) || MIMETypes.SVM.equals(sSourceMime))) {
return true;
}
// And we can convert all formats to bitmaps
boolean bSupportsSource =
MIMETypes.PNG.equals(sSourceMime) || MIMETypes.JPEG.equals(sSourceMime) ||
MIMETypes.GIF.equals(sSourceMime) || MIMETypes.TIFF.equals(sSourceMime) ||
MIMETypes.BMP.equals(sSourceMime) || MIMETypes.EMF.equals(sSourceMime) ||
MIMETypes.WMF.equals(sSourceMime) || MIMETypes.SVM.equals(sSourceMime);
boolean bSupportsTarget =
MIMETypes.PNG.equals(sTargetMime) || MIMETypes.JPEG.equals(sTargetMime) ||
MIMETypes.GIF.equals(sTargetMime) || MIMETypes.TIFF.equals(sTargetMime) ||
MIMETypes.BMP.equals(sTargetMime);
return bSupportsSource && bSupportsTarget;
}
public byte[] convert(byte[] source, String sSourceMime, String sTargetMime) {
// It seems that the GraphicProvider can only create proper eps if
// the source is a vector format, hence
if (MIMETypes.EPS.equals(sTargetMime)) {
if (!MIMETypes.EMF.equals(sSourceMime) && !MIMETypes.WMF.equals(sSourceMime) && !MIMETypes.SVM.equals(sSourceMime)) {
return null;
}
}
ByteArrayToXInputStreamAdapter xSource = new ByteArrayToXInputStreamAdapter(source);
ByteArrayXStream xTarget = new ByteArrayXStream();
try {
// Read the source
PropertyValue[] sourceProps = new PropertyValue[1];
sourceProps[0] = new PropertyValue();
sourceProps[0].Name = "InputStream";
sourceProps[0].Value = xSource;
XGraphic result = xGraphicProvider.queryGraphic(sourceProps);
// Store as new type
PropertyValue[] targetProps = new PropertyValue[2];
targetProps[0] = new PropertyValue();
targetProps[0].Name = "MimeType";
targetProps[0].Value = sTargetMime;
targetProps[1] = new PropertyValue();
targetProps[1].Name = "OutputStream";
targetProps[1].Value = xTarget;
xGraphicProvider.storeGraphic(result,targetProps);
// Close the output and return the result
xTarget.flush();
xTarget.closeOutput();
if (MIMETypes.EPS.equals(sTargetMime)) {
return epsCleaner.cleanEps(xTarget.getBuffer());
}
else {
byte[] converted = xTarget.getBuffer();
if (converted.length>0) { // Older versions of AOO/LO fails to convert to SVG (empty result)
return converted;
}
return null;
}
}
catch (com.sun.star.io.IOException e) {
return null;
}
catch (com.sun.star.lang.IllegalArgumentException e) {
return null;
}
catch (com.sun.star.lang.WrappedTargetException e) {
return null;
}
catch (Throwable e) {
return null;
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/GraphicConverterImpl.java 0000644 0001750 0001750 00000004447 11147474702 031301 0 ustar rene rene /************************************************************************
*
* GraphicConverterImpl.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-07-21)
*
*/
package org.openoffice.da.comp.w2lcommon.filter;
import com.sun.star.uno.XComponentContext;
import writer2latex.api.GraphicConverter;
public class GraphicConverterImpl implements GraphicConverter {
private GraphicConverter graphicConverter1;
private GraphicConverter graphicConverter2;
public GraphicConverterImpl(XComponentContext xComponentContext) {
graphicConverter1 = new GraphicConverterImpl1(xComponentContext);
graphicConverter2 = new GraphicConverterImpl2(xComponentContext);
}
public boolean supportsConversion(String sSourceMime, String sTargetMime, boolean bCrop, boolean bResize) {
return graphicConverter1.supportsConversion(sSourceMime, sTargetMime, bCrop, bResize) ||
graphicConverter2.supportsConversion(sSourceMime, sTargetMime, bCrop, bResize);
}
public byte[] convert(byte[] source, String sSourceMime, String sTargetMime) {
byte[] result = null;
// Prefer the simple implementation (GraphicProvider)
if (graphicConverter1.supportsConversion(sSourceMime, sTargetMime, false, false)) {
result = graphicConverter1.convert(source, sSourceMime, sTargetMime);
}
// If this is not possible or fails, try the complex implementation
if (result==null) {
result = graphicConverter2.convert(source, sSourceMime, sTargetMime);
}
return result;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/ExportFilterBase.java 0000644 0001750 0001750 00000027526 12401536577 030442 0 ustar rene rene /************************************************************************
*
* ExportFilterBase.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-08-28)
*
*/
package org.openoffice.da.comp.w2lcommon.filter;
import com.sun.star.lib.uno.adapter.XOutputStreamToOutputStreamAdapter;
import com.sun.star.io.XInputStream;
import com.sun.star.io.XOutputStream;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.lang.XServiceName;
import com.sun.star.lang.XTypeProvider;
import com.sun.star.uno.AnyConverter;
import com.sun.star.ucb.XSimpleFileAccess2;
import com.sun.star.uno.Type;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.xml.sax.XDocumentHandler;
import com.sun.star.xml.XExportFilter;
import org.openoffice.da.comp.w2lcommon.helper.MessageBox;
import writer2latex.api.Converter;
import writer2latex.api.ConverterFactory;
import writer2latex.api.OutputFile;
import writer2latex.util.Misc;
import writer2latex.util.SimpleDOMBuilder;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Iterator;
/** This class provides an abstract UNO component which implements an XExportFilter.
* The filter is actually generic and only the constructor and 3 strings needs
* to be changed by the subclass.
*/
public abstract class ExportFilterBase implements
XExportFilter,
XServiceName,
XServiceInfo,
XDocumentHandler,
XTypeProvider {
/** Service name for the component */
public static final String __serviceName = "";
/** Implementation name for the component */
public static final String __implementationName = "";
/** Filter name to include in error messages */
public String __displayName = "";
private static XComponentContext xComponentContext = null;
protected static XMultiServiceFactory xMSF;
private SimpleDOMBuilder domBuilder = new SimpleDOMBuilder();
private static XOutputStream xos = null;
private static String sdMime=null;
private static String sURL="";
private Object filterData;
private XSimpleFileAccess2 sfa2;
/** We need to get the Service Manager from the Component context to
* instantiate certain services, hence this constructor.
* The subclass must override this to set xMSF properly from the registration class
*/
public ExportFilterBase(XComponentContext xComponentContext1) {
xComponentContext = xComponentContext1;
xMSF = null;
}
// Utility method:
String getFileName(String origName) {
String name=null;
if (origName !=null) {
if(origName.equalsIgnoreCase(""))
name = "OutFile";
else {
if (origName.lastIndexOf("/")>=0) {
origName=origName.substring(origName.lastIndexOf("/")+1,origName.length());
}
if (origName.lastIndexOf(".")>=0) {
name = origName.substring(0,(origName.lastIndexOf(".")));
}
else {
name=origName;
}
}
}
else{
name = "OutFile";
}
return name;
}
// Implementation of XExportFilter:
public boolean exporter(com.sun.star.beans.PropertyValue[] aSourceData,
java.lang.String[] msUserData) throws com.sun.star.uno.RuntimeException{
sURL=null;
filterData = null;
// Get user data from configuration (type detection)
//String udConvertClass=msUserData[0];
//String udImport =msUserData[2];
//String udExport =msUserData[3];
sdMime = msUserData[5];
// Get source data (only the OutputStream and the URL are actually used)
com.sun.star.beans.PropertyValue[] pValue = aSourceData;
for (int i = 0 ; i < pValue.length; i++) {
try{
if (pValue[i].Name.compareTo("OutputStream")==0){
xos=(com.sun.star.io.XOutputStream)AnyConverter.toObject(new Type(com.sun.star.io.XOutputStream.class), pValue[i].Value);
}
//if (pValue[i].Name.compareTo("FileName")==0){
// sFileName=(String)AnyConverter.toObject(new Type(java.lang.String.class), pValue[i].Value);
//}
if (pValue[i].Name.compareTo("URL")==0){
sURL=(String)AnyConverter.toObject(new Type(java.lang.String.class), pValue[i].Value);
}
//if (pValue[i].Name.compareTo("Title")==0){
// title=(String)AnyConverter.toObject(new Type(java.lang.String.class), pValue[i].Value);
//}
if (pValue[i].Name.compareTo("FilterData")==0) {
filterData = pValue[i].Value;
}
}
catch(com.sun.star.lang.IllegalArgumentException AnyExec){
System.err.println("\nIllegalArgumentException "+AnyExec);
}
}
if (sURL==null){
sURL="";
}
return true;
}
// Implementation of XDocumentHandler:
// A flat XML DOM tree is created by the SAX events and finally converted
public void startDocument () {
//Do nothing
}
public void endDocument()throws com.sun.star.uno.RuntimeException {
try{
convert(domBuilder.getDOM(),xos);
}
catch (IOException e){
MessageBox msgBox = new MessageBox(xComponentContext);
msgBox.showMessage(__displayName+": IO error in conversion",
e.toString()+" at "+e.getStackTrace()[0].toString());
throw new com.sun.star.uno.RuntimeException(e.getMessage());
}
catch (Exception e){
MessageBox msgBox = new MessageBox(xComponentContext);
msgBox.showMessage(__displayName+": Internal error in conversion",
e.toString()+" at "+e.getStackTrace()[0].toString());
throw new com.sun.star.uno.RuntimeException(__displayName+" Exception");
}
}
public void startElement (String sTagName, com.sun.star.xml.sax.XAttributeList xAttribs) {
domBuilder.startElement(sTagName);
int nLen = xAttribs.getLength();
for (short i=0;i docEnum = converter.convert(dom,Misc.makeFileName(getFileName(sURL)),true).iterator();
if (docEnum.hasNext()) {
// The master document is written to the XOutStream supplied by the XMLFilterAdaptor
XOutputStreamToOutputStreamAdapter newxos =new XOutputStreamToOutputStreamAdapter(exportStream);
docEnum.next().write(newxos);
newxos.flush();
newxos.close();
if (docEnum.hasNext() && sURL.startsWith("file:")) {
// Additional files are written directly using UCB
// Initialize the file access (used to write all additional output files)
sfa2 = null;
try {
Object sfaObject = xComponentContext.getServiceManager().createInstanceWithContext(
"com.sun.star.ucb.SimpleFileAccess", xComponentContext);
sfa2 = (XSimpleFileAccess2) UnoRuntime.queryInterface(XSimpleFileAccess2.class, sfaObject);
}
catch (com.sun.star.uno.Exception e) {
// failed to get SimpleFileAccess service (should not happen)
}
if (sfa2!=null) {
// Remove the file name part of the URL
String sNewURL = null;
if (sURL.lastIndexOf("/")>-1) {
// Take the URL up to and including the last slash
sNewURL = sURL.substring(0,sURL.lastIndexOf("/")+1);
}
else {
// The URL does not include a path; this should not really happen,
// but in this case we will write to the current default directory
sNewURL = "";
}
while (docEnum.hasNext()) {
OutputFile docOut = docEnum.next();
// Get the file name and the (optional) directory name
String sFullFileName = Misc.makeHref(docOut.getFileName());
String sDirName = "";
String sFileName = sFullFileName;
int nSlash = sFileName.indexOf("/");
if (nSlash>-1) {
sDirName = sFileName.substring(0,nSlash);
sFileName = sFileName.substring(nSlash+1);
}
try{
// Create subdirectory if required
if (sDirName.length()>0 && !sfa2.exists(sNewURL+sDirName)) {
sfa2.createFolder(sNewURL+sDirName);
}
// writeFile demands an InputStream, so we need a pipe
Object xPipeObj=xMSF.createInstance("com.sun.star.io.Pipe");
XInputStream xInStream = (XInputStream) UnoRuntime.queryInterface(XInputStream.class, xPipeObj );
XOutputStream xOutStream = (XOutputStream) UnoRuntime.queryInterface(XOutputStream.class, xPipeObj );
OutputStream outStream = new XOutputStreamToOutputStreamAdapter(xOutStream);
// Feed the pipe with content...
docOut.write(outStream);
outStream.flush();
outStream.close();
xOutStream.closeOutput();
// ...and then write the content to the URL
sfa2.writeFile(sNewURL+sFullFileName,xInStream);
}
catch (Throwable e){
MessageBox msgBox = new MessageBox(xComponentContext);
msgBox.showMessage(__displayName+": Error writing files",
e.toString()+" at "+e.getStackTrace()[0].toString());
}
}
}
}
}
else {
// The converter did not produce any files (should not happen)
MessageBox msgBox = new MessageBox(xComponentContext);
msgBox.showMessage(__displayName+": Conversion failed","Internal error");
}
}
// Implement methods from interface XTypeProvider
// Implementation of XTypeProvider
public com.sun.star.uno.Type[] getTypes() {
Type[] typeReturn = {};
try {
typeReturn = new Type[] {
new Type( XTypeProvider.class ),
new Type( XExportFilter.class ),
new Type( XServiceName.class ),
new Type( XServiceInfo.class ) };
}
catch( Exception exception ) {
}
return( typeReturn );
}
public byte[] getImplementationId() {
byte[] byteReturn = {};
byteReturn = new String( "" + this.hashCode() ).getBytes();
return( byteReturn );
}
// Implement method from interface XServiceName
public String getServiceName() {
return( __serviceName );
}
// Implement methods from interface XServiceInfo
public boolean supportsService(String stringServiceName) {
return( stringServiceName.equals( __serviceName ) );
}
public String getImplementationName() {
return __implementationName;
}
public String[] getSupportedServiceNames() {
String[] stringSupportedServiceNames = { __serviceName };
return( stringSupportedServiceNames );
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/FilterDataParser.java 0000644 0001750 0001750 00000034604 11573364333 030405 0 ustar rene rene /************************************************************************
*
* FilterDataParser.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-2011 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-06-07)
*
*/
package org.openoffice.da.comp.w2lcommon.filter;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Enumeration;
import com.sun.star.beans.PropertyValue;
import com.sun.star.io.NotConnectedException;
import com.sun.star.io.XInputStream;
import com.sun.star.io.XOutputStream;
import com.sun.star.ucb.CommandAbortedException;
import com.sun.star.ucb.XSimpleFileAccess2;
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.XStringSubstitution;
import com.sun.star.lib.uno.adapter.XInputStreamToInputStreamAdapter;
import com.sun.star.lib.uno.adapter.XOutputStreamToOutputStreamAdapter;
import org.openoffice.da.comp.w2lcommon.helper.PropertyHelper;
import writer2latex.api.Converter;
/** This class parses the FilterData property passed to the filter and
* applies it to a Converter
* All errors are silently ignored
*/
public class FilterDataParser {
// TODO: Use JSON format
//private static XComponentContext xComponentContext = null;
private XSimpleFileAccess2 sfa2;
private XStringSubstitution xPathSub;
public FilterDataParser(XComponentContext xComponentContext) {
//this.xComponentContext = xComponentContext;
// Get the SimpleFileAccess service
sfa2 = null;
try {
Object sfaObject = xComponentContext.getServiceManager().createInstanceWithContext(
"com.sun.star.ucb.SimpleFileAccess", xComponentContext);
sfa2 = (XSimpleFileAccess2) UnoRuntime.queryInterface(XSimpleFileAccess2.class, sfaObject);
}
catch (com.sun.star.uno.Exception e) {
// failed to get SimpleFileAccess service (should not happen)
}
// Get the PathSubstitution service
xPathSub = null;
try {
Object psObject = xComponentContext.getServiceManager().createInstanceWithContext(
"com.sun.star.util.PathSubstitution", xComponentContext);
xPathSub = (XStringSubstitution) UnoRuntime.queryInterface(XStringSubstitution.class, psObject);
}
catch (com.sun.star.uno.Exception e) {
// failed to get PathSubstitution service (should not happen)
}
}
/** Apply the given FilterData property to the given converter
* @param data an Any containing the FilterData property
* @param converter a writer2latex.api.Converter implementation
*/
public void applyFilterData(Object data, Converter converter) {
// Get the array from the data, if possible
PropertyValue[] filterData = null;
if (AnyConverter.isArray(data)) {
try {
Object[] arrayData = (Object[]) AnyConverter.toArray(data);
if (arrayData instanceof PropertyValue[]) {
filterData = (PropertyValue[]) arrayData;
}
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// Failed to convert to array; should not happen - ignore
}
}
if (filterData==null) { return; }
PropertyHelper props = new PropertyHelper(filterData);
// Get the special properties TemplateURL, StyleSheetURL, ResourceURL, Resources, ConfigURL and AutoCreate
Object tpl = props.get("TemplateURL");
String sTemplate = null;
if (tpl!=null && AnyConverter.isString(tpl)) {
try {
sTemplate = substituteVariables(AnyConverter.toString(tpl));
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// Failed to convert to String; should not happen - ignore
}
}
Object styles = props.get("StyleSheetURL");
String sStyleSheet = null;
if (styles!=null && AnyConverter.isString(styles)) {
try {
sStyleSheet = substituteVariables(AnyConverter.toString(styles));
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// Failed to convert to String; should not happen - ignore
}
}
// This property accepts an URL pointing to a folder containing the resources to include
Object resourcedir = props.get("ResourceURL");
String sResourceURL = null;
if (resourcedir!=null && AnyConverter.isString(resourcedir)) {
try {
sResourceURL = substituteVariables(AnyConverter.toString(resourcedir));
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// Failed to convert to String; should not happen - ignore
}
}
// This property accepts a semicolon separated list of [[::]::]
Object resources = props.get("Resources");
String[] sResources = null;
if (resources!=null && AnyConverter.isString(resources)) {
try {
sResources = substituteVariables(AnyConverter.toString(resources)).split(";");
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// Failed to convert to String; should not happen - ignore
}
}
Object auto = props.get("AutoCreate");
boolean bAutoCreate = false;
if (auto!=null && AnyConverter.isString(auto)) {
try {
if ("true".equals(AnyConverter.toString(auto))) {
bAutoCreate = true;
}
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// Failed to convert to String; should not happen - ignore
}
}
Object cfg = props.get("ConfigURL");
String sConfig = null;
if (cfg!=null && AnyConverter.isString(cfg)) {
try {
sConfig = substituteVariables(AnyConverter.toString(cfg));
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// Failed to convert to String; should not happen - ignore
}
}
// Load the template from the specified URL, if any
if (sfa2!=null && sTemplate!=null && sTemplate.length()>0) {
try {
XInputStream xIs = sfa2.openFileRead(sTemplate);
if (xIs!=null) {
InputStream is = new XInputStreamToInputStreamAdapter(xIs);
converter.readTemplate(is);
is.close();
xIs.closeInput();
}
}
catch (IOException e) {
// ignore
}
catch (NotConnectedException e) {
// ignore
}
catch (CommandAbortedException e) {
// ignore
}
catch (com.sun.star.uno.Exception e) {
// ignore
}
}
// Load the style sheet from the specified URL, if any
if (sfa2!=null && sStyleSheet!=null && sStyleSheet.length()>0) {
try {
XInputStream xIs = sfa2.openFileRead(sStyleSheet);
if (xIs!=null) {
InputStream is = new XInputStreamToInputStreamAdapter(xIs);
converter.readStyleSheet(is);
is.close();
xIs.closeInput();
}
}
catch (IOException e) {
// ignore
}
catch (NotConnectedException e) {
// ignore
}
catch (CommandAbortedException e) {
// ignore
}
catch (com.sun.star.uno.Exception e) {
// ignore
}
}
// Load the resource from the specified folder URL, if any
if (sfa2!=null && sResourceURL!=null && sResourceURL.length()>0) {
String[] sURLs;
try {
sURLs = sfa2.getFolderContents(sResourceURL, false); // do not include folders
for (String sURL : sURLs) {
XInputStream xIs = sfa2.openFileRead(sURL);
if (xIs!=null) {
String sFileName = sURL.substring(sURL.lastIndexOf('/')+1);
InputStream is = new XInputStreamToInputStreamAdapter(xIs);
converter.readResource(is,sFileName,null);
is.close();
xIs.closeInput();
}
}
} catch (IOException e) {
// ignore
} catch (CommandAbortedException e1) {
// ignore
} catch (Exception e1) {
// ignore
}
}
// Load the resources from the specified URLs, if any
if (sfa2!=null && sResources!=null) {
for (String sResource : sResources) {
// Format is [[::]::]
String[] sParts = sResource.split("::");
if (sParts.length>0) {
String sURL=sParts[0];
String sFileName;
String sMediaType=null;
if (sParts.length==3) {
sFileName = sParts[1];
sMediaType = sParts[2];
}
else {
sFileName = sURL.substring(sURL.lastIndexOf('/')+1);
if (sParts.length==2) {
sMediaType = sParts[1];
}
}
try {
XInputStream xIs = sfa2.openFileRead(sURL);
if (xIs!=null) {
InputStream is = new XInputStreamToInputStreamAdapter(xIs);
converter.readResource(is, sFileName, sMediaType);
is.close();
xIs.closeInput();
} // otherwise wrong format, ignore
}
catch (IOException e) {
// ignore
}
catch (NotConnectedException e) {
// ignore
}
catch (CommandAbortedException e) {
// ignore
}
catch (com.sun.star.uno.Exception e) {
// ignore
}
}
}
}
// Create config if required
try {
if (bAutoCreate && sfa2!=null && sConfig!=null && !sConfig.startsWith("*") && !sfa2.exists(sConfig)) {
// Note: Requires random access, ie. must be a file URL:
XOutputStream xOs = sfa2.openFileWrite(sConfig);
if (xOs!=null) {
OutputStream os = new XOutputStreamToOutputStreamAdapter(xOs);
converter.getConfig().write(os);
os.flush();
os.close();
xOs.closeOutput();
}
}
}
catch (IOException e) {
// ignore
}
catch (NotConnectedException e) {
// ignore
}
catch (CommandAbortedException e) {
// Ignore
}
catch (com.sun.star.uno.Exception e) {
// Ignore
}
// Load the configuration from the specified URL, if any
if (sConfig!=null) {
if (sConfig.startsWith("*")) { // internal configuration
try {
converter.getConfig().readDefaultConfig(sConfig.substring(1));
}
catch (IllegalArgumentException e) {
// ignore
}
}
else if (sfa2!=null) { // real URL
try {
XInputStream xIs = sfa2.openFileRead(sConfig);;
if (xIs!=null) {
InputStream is = new XInputStreamToInputStreamAdapter(xIs);
converter.getConfig().read(is);
is.close();
xIs.closeInput();
}
}
catch (IOException e) {
// Ignore
}
catch (NotConnectedException e) {
// Ignore
}
catch (CommandAbortedException e) {
// Ignore
}
catch (com.sun.star.uno.Exception e) {
// Ignore
}
}
}
// Read further configuration properties
Enumeration keys = props.keys();
while (keys.hasMoreElements()) {
String sKey = keys.nextElement();
if (!"ConfigURL".equals(sKey) && !"TemplateURL".equals(sKey) && !"StyleSheetURL".equals(sKey)
&& !"Resources".equals(sKey) && !"AutoCreate".equals(sKey)) {
Object value = props.get(sKey);
if (AnyConverter.isString(value)) {
try {
converter.getConfig().setOption(sKey,AnyConverter.toString(value));
}
catch (com.sun.star.lang.IllegalArgumentException e) {
// Failed to convert to String; should not happen - ignore
}
}
}
}
}
private String substituteVariables(String sUrl) {
if (xPathSub!=null) {
try {
return xPathSub.substituteVariables(sUrl, false);
}
catch (com.sun.star.container.NoSuchElementException e) {
// Found an unknown variable, no substitution
// (This will only happen if false is replaced by true above)
return sUrl;
}
}
else { // Not path substitution available
return sUrl;
}
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/filter/EPSCleaner.java 0000644 0001750 0001750 00000005040 11251136744 027116 0 ustar rene rene /************************************************************************
*
* EPSCleaner.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.0 (2009-03-09)
*/
package org.openoffice.da.comp.w2lcommon.filter;
/** This class removes redundant binary information from EPS files created by OOo.
* See the issue http://qa.openoffice.org/issues/show_bug.cgi?id=25256
* According to this message http://markmail.org/message/dc6rprmtktxuq35v
* on dev@openoffice.org the binary data is an EPSI preview in TIFF format
* TODO: Is it possible to avoid this export?
*/
public class EPSCleaner {
// Signatures for start and end in eps
private byte[] psStart;
private byte[] psEnd;
public EPSCleaner() {
try {
psStart = "%!PS-Adobe".getBytes("US-ASCII");
psEnd = "%%EOF".getBytes("US-ASCII");
}
catch (java.io.UnsupportedEncodingException ex) {
// US-ASCII *is* supported :-)
}
}
//
public byte[] cleanEps(byte[] blob) {
int n = blob.length;
int nStart = 0;
for (int i=0; i=blob.length) { return false; }
for (int i=0; iThe Mouth is the main class of this package. It is a tokenizer to TeX files: According to "The TeXBook", the
* "eyes" and "mouth" of TeX are responsible for turning the input to TeX into a sequence of tokens.
* We are not going to reimplement TeX, but rather providing a service for parsing high-level languages based on
* TeX (eg. LaTeX, ConTeXt). For this reason the tokenizer deviates slightly from TeX: We're not reading a stream
* of bytes but rather a stream of characters (which makes no difference for ASCII files).
*
* In tribute to Donald E. Knuths digestive metaphors, we divide the process in four levels
*
* - The parser should provide a pair of glasses to translate the stream of bytes into a stream of characters
* - The eyes sees the stream of characters as a sequence of lines
* - The mouth chews a bit on the characters to turn them into tokens
* - The tongue reports the "taste" of the token to the parser
*
*/
public class Mouth {
private Reader reader; // The input
private CatcodeTable catcodes; // The current catcode table
private char cEndlinechar; // The current value of \endlinechar
private Token token; // The token object
private State state; // The current state of the tokenizer
private Eyes eyes; // sic!
/** Construct a new Mouth based on a character stream
*
* @param reader the character stream to tokenize
* @throws IOException if we fail to read the character stream
*/
public Mouth(Reader reader) throws IOException {
this.reader = reader;
catcodes = new CatcodeTable();
cEndlinechar = '\r';
token = new Token();
state = State.N;
eyes = new Eyes();
}
private class Eyes {
private BufferedReader br; // The input
private String sLine; // The current line
private int nLen; // The length of the current line
private int nIndex; // The current index in the current line
Eyes() throws IOException {
br = new BufferedReader(reader);
nextLine();
}
/** Start looking at the next line of input
*
* @throws IOException if we fail to read the underlying stream
*/
void nextLine() throws IOException {
sLine = br.readLine();
if (sLine!=null) {
nLen = sLine.length();
nIndex = 0;
// Delete trailing spaces
while (nLen>0 && sLine.charAt(nLen-1)==' ') { nLen--; }
}
else { // end of stream
nLen = 0;
nIndex = 1;
}
}
/** Test whether the eyes are looking at a character
*
* @return true if the current line still has characters to look at
*/
boolean lookingAtChar() {
return nIndex<=nLen;
}
/** Test whether the eyes a looking at a line
*
* @return true if a current line is available
*/
boolean lookingAtLine() {
return sLine!=null;
}
/** Get the character that the eyes currently sees
*
* @return the character or U+FFFF if the eyes are not looking at a character
*/
char peekChar() {
return getChar(false);
}
/** Get the character that the eyes currently sees and start looking at the next character
*
* @return the character or U+FFFF if the eyes are not looking at a character
*/
char getChar() {
return getChar(true);
}
private char getChar(boolean bMove) {
if (nIndex insert a \par
token.setType(TokenType.COMMAND_SEQUENCE);
token.clearChars();
token.addChar('p');
token.addChar('a');
token.addChar('r');
return token;
case M:
// Replace with a space token
token.set(' ', TokenType.SPACE);
return token;
case S:
// ignore the character
}
break;
case PARAMETER:
state = State.M;
token.set(c, TokenType.PARAMETER);
return token;
case SUPERSCRIPT:
state = State.M;
token.set(c, TokenType.SUPERSCRIPT);
return token;
case SUBSCRIPT:
state = State.M;
token.set(c, TokenType.SUBSCRIPT);
return token;
case IGNORED:
// ignore this character
break;
case SPACE:
if (state==State.M) {
state=State.S;
token.set(' ', TokenType.SPACE);
return token;
}
// In state N and S the space character is ignored
break;
case LETTER:
state = State.M;
token.set(c, TokenType.LETTER);
return token;
case OTHER:
state = State.M;
token.set(c, TokenType.OTHER);
return token;
case ACTIVE:
state = State.M;
token.set(c, TokenType.ACTIVE);
return token;
case COMMENT:
// Skip rest of line
while (eyes.lookingAtChar()) { eyes.getChar(); }
break;
case INVALID:
// ignore this character (should issue an error message, but we ignore that)
}
}
eyes.nextLine();
state = State.N;
}
// Nothing more to read
token.setType(TokenType.ENDINPUT);
token.clearChars();
return token;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/tex/tokenizer/Token.java 0000644 0001750 0001750 00000010667 11461243470 027613 0 ustar rene rene /************************************************************************
*
* Token.java
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Copyright: 2002-2010 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2010-10-25)
*
*/
package org.openoffice.da.comp.w2lcommon.tex.tokenizer;
/** This class represent a token in TeX
*/
public class Token implements Cloneable {
private TokenType type;
private char[] tokenChars;
private int nTokenLen;
private int nCapacity;
/** Construct a new Token, initialized as a TokenTYPE.ENDINPUT-token
*/
public Token() {
type = TokenType.ENDINPUT;
tokenChars = new char[25];
nCapacity = 25;
nTokenLen = 0;
}
/** Set the type of this token to a specific TokenType
* (the character content is not changed)
*
* @param type the new TokenType
*/
protected void setType(TokenType type) {
this.type = type;
}
/** Set the character content of this token to a single character
* (the type of the token is not changed)
*
* @param c the character
*/
protected void setChar(char c) {
tokenChars[0] = c;
nTokenLen = 1;
}
/** Set this token as a character token with a specific TokenType
*
* @param c the character
* @param type the TokenType to use
*/
protected void set(char c, TokenType type) {
setType(type);
setChar(c);
}
/** Delete the character content of this token
*/
protected void clearChars() {
nTokenLen = 0;
}
/** Append a character to the character content of this token
*
* @param c the character to be appended
*/
protected void addChar(char c) {
if (nTokenLen == nCapacity) {
char[] temp = tokenChars;
nCapacity+=25;
tokenChars = new char[nCapacity];
System.arraycopy(temp, 0, tokenChars, 0, temp.length);
}
tokenChars[nTokenLen++] = c;
}
/** Test wether this token is a character token of the given type (that is, a single character
* with a token type that is neither COMMAND_SEQUENCE nor ENDINPUT)
*
* @param c the character to test
* @param type the TokenType to test
* @return true if the test was successful
*/
public boolean is(char c, TokenType type) {
return this.type==type && type!=TokenType.COMMAND_SEQUENCE && type!=TokenType.ENDINPUT &&
nTokenLen==1 && tokenChars[0]==c;
}
/** Test wether this token is a COMMAND_SEQUENCE token with a given name
*
* @param sName the name of the command sequence
* @return true if the test was successful
*/
public boolean isCS(String sName) {
if (type==TokenType.COMMAND_SEQUENCE && sName.length()==nTokenLen) {
for (int i=0; iTokenType of this token
*
* @return the type
*/
public TokenType getType() {
return type;
}
/** Get the first character in this token
*
* @return the character or U+FFFF is no characters exist
*/
public char getChar() {
return nTokenLen>0 ? tokenChars[0] : '\uFFFF';
}
/** Get the character content of this token as a string
*
* @return the character content
*/
public String getString() {
return new String(tokenChars,0,nTokenLen);
}
@Override public String toString() {
switch (type) {
case COMMAND_SEQUENCE:
return "\\"+getString();
case ENDINPUT:
return "";
default:
return Character.toString(getChar());
}
}
@Override public Object clone() {
Token newToken = new Token();
newToken.type = this.type;
newToken.nTokenLen = this.nTokenLen;
newToken.nCapacity = this.nCapacity;
newToken.tokenChars = new char[newToken.nCapacity];
System.arraycopy(this.tokenChars, 0, newToken.tokenChars, 0, newToken.nCapacity);
return newToken;
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/tex/tokenizer/CatcodeTable.java 0000644 0001750 0001750 00000005756 11214140141 031033 0 ustar rene rene /************************************************************************
*
* CatcodeTable.java
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Copyright: 2002-2009 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2009-06-11)
*
*/
package org.openoffice.da.comp.w2lcommon.tex.tokenizer;
/** This class maintains a mapping from characters to catcodes.
* In this implementation, non-ascii characters always has the
* category Catcode.OTHER.
*/
public class CatcodeTable {
private Catcode[] catcodes;
/** Construct a new CatcodeTable, defining catcodes
* as by INITeX plus the additional catcodes defined by plain TeX
*/
public CatcodeTable() {
catcodes = new Catcode[128];
// First define all the catcodes from INITeX (Chapter 7 in "The TeXbook")
for (int i=0; i<128; i++) {
catcodes[i] = Catcode.OTHER;
}
for (char c='A'; c<='Z'; c++) {
catcodes[c] = Catcode.LETTER;
}
for (char c='a'; c<='z'; c++) {
catcodes[c] = Catcode.LETTER;
}
catcodes['\r']=Catcode.END_OF_LINE;
catcodes[' ']=Catcode.SPACE;
catcodes['\u0000']=Catcode.IGNORED; // ASCII NUL
catcodes['\u007F']=Catcode.INVALID; // ASCII DEL
catcodes['%']=Catcode.COMMENT;
catcodes['\\']=Catcode.ESCAPE;
// Then define all the catcodes from plain TeX (Appendix B in "The TeXbook")
catcodes['{']=Catcode.BEGIN_GROUP;
catcodes['}']=Catcode.END_GROUP;
catcodes['$']=Catcode.MATH_SHIFT;
catcodes['&']=Catcode.ALIGNMENT_TAB;
catcodes['#']=Catcode.PARAMETER;
catcodes['^']=Catcode.SUPERSCRIPT;
catcodes['\u000B']=Catcode.SUPERSCRIPT; // ASCII VT ("uparrow")
catcodes['_']=Catcode.SUBSCRIPT;
catcodes['\u0001']=Catcode.SUBSCRIPT; // ASCII SOH ("downarrow")
catcodes['\t']=Catcode.SPACE;
catcodes['~']=Catcode.ACTIVE;
catcodes['\u000C']=Catcode.ACTIVE; // ASCII FF
}
/** Set the catcode of a character. The request is silently ignored
* for all characters outside the ASCII character set
*
* @param c the character
* @param cc the desired catcode
*/
public void set(char c, Catcode cc) {
if (c<128) { catcodes[c]=cc; }
}
/** Get the catcode of a character. Characters outside the ASCII character
* set always have the catcode Catcode.OTHER
*
* @param c the character
* @return the current catcode
*/
public Catcode get(char c) {
if (c<128) { return catcodes[c]; }
else { return Catcode.OTHER; }
}
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/tex/tokenizer/TokenType.java 0000644 0001750 0001750 00000002662 11214140141 030434 0 ustar rene rene /************************************************************************
*
* TokenType.java
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Copyright: 2002-2009 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2009-06-11)
*
*/
package org.openoffice.da.comp.w2lcommon.tex.tokenizer;
/** This enumerates possible TeX tokens. According to chapter 7 in
* "The TeX book", a token is either a character with an associated
* catcode or a control sequence. We add "end of input" token as
* a convenience. Not all catcodes can actually end up in a token,
* so we only include the relevant ones.
*/
public enum TokenType {
ESCAPE,
BEGIN_GROUP,
END_GROUP,
MATH_SHIFT,
ALIGNMENT_TAB,
PARAMETER,
SUPERSCRIPT,
SUBSCRIPT,
SPACE,
LETTER,
OTHER,
ACTIVE,
COMMAND_SEQUENCE,
ENDINPUT;
}
writer2latex-1.4/source/java/org/openoffice/da/comp/w2lcommon/tex/tokenizer/Catcode.java 0000644 0001750 0001750 00000002367 11214140141 030056 0 ustar rene rene /************************************************************************
*
* Catcode.java
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Copyright: 2002-2009 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2009-06-11)
*
*/
package org.openoffice.da.comp.w2lcommon.tex.tokenizer;
/** This enumerates TeX category codes (catcodes) for characters as defined in
* chapter 7 of "The TeXbook"
*/
public enum Catcode {
ESCAPE,
BEGIN_GROUP,
END_GROUP,
MATH_SHIFT,
ALIGNMENT_TAB,
END_OF_LINE,
PARAMETER,
SUPERSCRIPT,
SUBSCRIPT,
IGNORED,
SPACE,
LETTER,
OTHER,
ACTIVE,
COMMENT,
INVALID;
}
writer2latex-1.4/source/java/writer2latex/ 0000755 0001750 0001750 00000000000 12603463652 017342 5 ustar rene rene writer2latex-1.4/source/java/writer2latex/xhtml/ 0000755 0001750 0001750 00000000000 12603463651 020475 5 ustar rene rene writer2latex-1.4/source/java/writer2latex/xhtml/l10n/ 0000755 0001750 0001750 00000000000 12603463651 021247 5 ustar rene rene writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_tr.properties 0000644 0001750 0001750 00000000335 11731717233 026540 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Yukar\u0131
first=\u0130lk
previous=\u00d6nceki
next=Sonraki
last=Son
contents=\u0130\u00e7indekiler
index=\u0130ndeks
home=Ev
directory=Klas\u00f6r
document=D\u00f6k\u00fcman
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_nn.properties 0000644 0001750 0001750 00000000266 11731717233 026531 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Opp
first=F\u00f8rste
previous=Forrige
next=Neste
last=Siste
contents=Innhald
index=Register
home=Heim
directory=Mappe
document=Dokument
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_pt_BR.properties 0000644 0001750 0001750 00000000326 11731717233 027121 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Acima
first=Primeiro
previous=Anterior
next=Pr\u00f3ximo
last=\u00daltimo
contents=Conte\u00fado
index=\u00cdndice
home=Home
directory=Diret\u00f3rio
document=Documento
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_ru.properties 0000644 0001750 0001750 00000001113 11731717233 026534 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=\u0412\u0432\u0435\u0440\u0445
first=\u041f\u0435\u0440\u0432\u0430\u044f
previous=\u041f\u0440\u0435\u0434\u044b\u0434\u0443\u0449\u0430\u044f
next=\u0421\u043b\u0435\u0434\u0443\u044e\u0449\u0430\u044f
last=\u041f\u043e\u0441\u043b\u0435\u0434\u043d\u044f\u044f
contents=\u0421\u043e\u0434\u0435\u0440\u0436\u0430\u043d\u0438\u0435
index=\u0421\u043f\u0438\u0441\u043e\u043a
home=\u0414\u043e\u043c\u043e\u0439
directory=\u0414\u0438\u0440\u0435\u043a\u0442\u043e\u0440\u0438\u044f
document=\u0414\u043e\u043a\u0443\u043c\u0435\u043d\u0442
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_fa.properties 0000644 0001750 0001750 00000000543 11731717233 026502 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=\u0628\u0627\u0644\u0627
first=\u0627\u0648\u0644
previous=\u0642\u0628\u0644\u06cc
next=\u0628\u0639\u062f\u06cc
last=\u0627\u062e\u0631\u06cc\u0646
contents=Contents
index=\u0641\u0647\u0631\u0633\u062a
home=\u062e\u0627\u0646\u0647
directory=\u067e\u0648\u0634\u0647
document=\u0645\u0633\u062a\u0646\u062f
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_fr.properties 0000644 0001750 0001750 00000000336 11731717233 026523 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Haut
first=D\u00e9but
previous=Pr\u00e9c\u00e9dent
next=Suivant
last=Dernier
contents=Contenus
index=Index
home=Documents Personnels
directory=R\u00e9pertoire
document=Document
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_nl.properties 0000644 0001750 0001750 00000000277 11731717233 026531 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Omhoog
first=Eerste
previous=Vorige
next=Volgende
last=Laatste
contents=Inhoud
index=Index
home=Hoofdpagina
directory=Directory
document=Document
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_it.properties 0000644 0001750 0001750 00000000272 11731717233 026527 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Su
first=Inizio
previous=Precedente
next=Successivo
last=Fine
contents=Sommario
index=Indice
home=Home
directory=Cartella
document=Documento
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_uk.properties 0000644 0001750 0001750 00000000767 11731717233 026543 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=\u041d\u0430\u0433\u043e\u0440\u0443
first=\u041f\u0435\u0440\u0448\u0430
previous=\u041f\u043e\u043f\u0435\u0440\u0435\u0434\u043d\u044f
next=\u041d\u0430\u0441\u0442\u0443\u043f\u043d\u0430
last=\u041e\u0441\u0442\u0430\u043d\u043d\u044f
contents=\u0417\u043c\u0456\u0441\u0442
index=\u0421\u043f\u0438\u0441\u043e\u043a
home=\u0414\u043e\u0434\u043e\u043c\u0443
directory=\u0422\u0435\u043a\u0430
document=\u0414\u043e\u043a\u0443\u043c\u0435\u043d\u0442
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_hr.properties 0000644 0001750 0001750 00000000301 11731717233 026515 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Up
first=Prvi
previous=Prethodan
next=slijede\u0107i
last=Zadnji
contents=Sadr\u017Eaj
index=Indeks
home=Home
directory=Directory
document=Document
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_cs.properties 0000644 0001750 0001750 00000000375 11731717233 026524 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Nahoru
first=Prvn\u00ed
previous=P\u0159edchoz\u00ed
next=Dal\u0161\u00ed
last=Posledn\u00ed
contents=Obsah
index=Rejst\u0159\u00edk
home=Dom\u016f
directory=Adres\u00e1\u0159 (slo\u017eka)
document=Dokument
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/L10n.java 0000644 0001750 0001750 00000006331 11731717233 022626 0 ustar rene rene /************************************************************************
*
* L10n.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-2012 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.4 (2012-03-16)
*
*/
package writer2latex.xhtml.l10n;
import java.util.Locale;
import java.util.ResourceBundle;
/* This class handles localized strings (used for navigation links in the exported document)
* Note that the US-English strings need duplicated due to ResourceBundles' search order.
* Default strings are needed for the special case that neither strings for the document language,
* nor for the system default language are available.
* US-English strings are needed if the document language is English and the system locale is not.
*/
public class L10n {
public final static int UP = 0;
public final static int FIRST = 1;
public final static int PREVIOUS = 2;
public final static int NEXT = 3;
public final static int LAST = 4;
public final static int CONTENTS = 5;
public final static int INDEX = 6;
public final static int HOME = 7;
public final static int DIRECTORY = 8;
public final static int DOCUMENT = 9;
private ResourceBundle resourceBundle = ResourceBundle.getBundle("writer2latex.xhtml.l10n.XhtmlStrings",Locale.getDefault());
private Locale locale = null;
public void setLocale(String sLanguage, String sCountry) {
if (sLanguage!=null) {
if (sCountry!=null) {
locale = new Locale(sLanguage,sCountry);
}
else {
locale = new Locale(sLanguage);
}
}
else {
locale = Locale.getDefault();
}
resourceBundle = ResourceBundle.getBundle("writer2latex.xhtml.l10n.XhtmlStrings",locale);
}
public Locale getLocale() {
return locale;
}
public String get(int nString) {
switch (nString) {
case UP: return resourceBundle.getString("up");
case FIRST : return resourceBundle.getString("first");
case PREVIOUS : return resourceBundle.getString("previous");
case NEXT : return resourceBundle.getString("next");
case LAST : return resourceBundle.getString("last");
case CONTENTS : return resourceBundle.getString("contents");
case INDEX : return resourceBundle.getString("index");
case HOME : return resourceBundle.getString("home");
case DIRECTORY: return resourceBundle.getString("directory");
case DOCUMENT: return resourceBundle.getString("document");
default: return "???";
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings.properties 0000644 0001750 0001750 00000000260 11731717233 026030 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Up
first=First
previous=Previous
next=Next
last=Last
contents=Contents
index=Index
home=Home
directory=Directory
document=Document
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_es.properties 0000644 0001750 0001750 00000000313 11731717233 026516 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Arriba
first=Primero
previous=Previo
next=Siguiente
last=\u00daltimo
contents=Contenido
index=\u00cdndice
home=Inicio
directory=Directorio
document=Documento
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_en.properties 0000644 0001750 0001750 00000000260 11731717233 026512 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Up
first=First
previous=Previous
next=Next
last=Last
contents=Contents
index=Index
home=Home
directory=Directory
document=Document
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_da.properties 0000644 0001750 0001750 00000000272 11731717233 026477 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Op
first=F\u00F8rste
previous=Forrige
next=N\u00E6ste
last=Sidste
contents=Indhold
index=Stikord
home=Hjem
directory=Mappe
document=Dokument
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_fi.properties 0000644 0001750 0001750 00000000331 11731717233 026505 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Yl\u00f6s
first=Ensimm\u00e4inen
previous=Edellinen
next=Seuraava
last=Viimeinen
contents=Sis\u00e4lt\u00f6
index=Indeksi
home=Koti
directory=Hakemisto
document=Dokumentti
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_de.properties 0000644 0001750 0001750 00000000303 11731717233 026476 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Nach oben
first=Anfang
previous=Vorheriges
next=N\u00e4chstes
last=Ende
contents=Inhalte
index=Index
home=Home
directory=Verzeichnis
document=Dokument writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_pl.properties 0000644 0001750 0001750 00000000340 11731717233 026522 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=W g\u00f3r\u0119
first=Pierwsza
previous=Poprzednia
next=Nast\u0119pna
last=Ostatnia
contents=Spis tre\u015bci
index=Indeks
home=Pocz\u0105tek
directory=Katalog
document=Dokument
writer2latex-1.4/source/java/writer2latex/xhtml/l10n/XhtmlStrings_ca.properties 0000644 0001750 0001750 00000000320 11731717233 026470 0 ustar rene rene # XHTML specific strings for Writer2LaTeX
up=Amunt
first=Comen\u00e7ament
previous=Precedent
next=Seg\u00fcent
last=Darrer
contents=Contingut
index=\u00cdndex
home=Arrel
directory=Directori
document=Document
writer2latex-1.4/source/java/writer2latex/xhtml/ListStyleConverter.java 0000644 0001750 0001750 00000021404 12406234417 025162 0 ustar rene rene /************************************************************************
*
* ListStyleConverter.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-16)
*
*/
package writer2latex.xhtml;
import java.util.Enumeration;
//import java.util.Hashtable;
import writer2latex.office.ListStyle;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
/**
* This class converts OpenDocument list styles to
* CSS2 styles (currently, actually CSS1).
*/
public class ListStyleConverter extends StyleConverterHelper {
/** Create a new ListStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public ListStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
this.styleMap = config.getXListStyleMap();
this.bConvertStyles = config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_HARD;
this.bConvertHard = config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_STYLES;
}
public void applyStyle(int nLevel, String sStyleName, StyleInfo info) {
ListStyle style = ofr.getListStyle(sStyleName);
if (style!=null) {
if (style.isAutomatic()) {
applyStyle(nLevel,style.getParentName(),info);
if (bConvertHard) { cssList(style,nLevel,info.props); }
}
else {
String sDisplayName = style.getDisplayName();
if (styleMap.contains(sDisplayName)) {
if (styleMap.getElement(sDisplayName).length()>0) {
info.sTagName = styleMap.getElement(sDisplayName);
}
if (!"(none)".equals(styleMap.getCss(sDisplayName))) {
info.sClass = styleMap.getCss(sDisplayName);
}
}
else {
info.sClass = "listlevel"+Integer.toString(nLevel)
+styleNames.getExportName(sDisplayName);
}
}
}
}
/** Convert style information for used styles
* @param sIndent a String of spaces to add before each line
*/
public String getStyleDeclarations(String sIndent) {
if (bConvertStyles) {
StringBuilder buf = new StringBuilder();
Enumeration names = styleNames.keys();
while (names.hasMoreElements()) {
String sDisplayName = names.nextElement();
ListStyle style = (ListStyle)
getStyles().getStyleByDisplayName(sDisplayName);
if (!style.isAutomatic()) {
for (int nLevel=1; nLevel<10; nLevel++) {
CSVList props = new CSVList(";");
cssList(style,nLevel,props);
buf.append(sIndent);
buf.append(".listlevel");
buf.append(nLevel);
buf.append(styleNames.getExportName(sDisplayName));
buf.append(" {");
buf.append(props.toString());
buf.append("}");
buf.append(config.prettyPrint() ? "\n" : " ");
if (config.listFormatting()==XhtmlConfig.HARD_LABELS) {
// Apply left margin and text indent to the paragraphs contained in the list
CSVList parProps = new CSVList(";");
cssListParMargins(style,nLevel,parProps);
if (!parProps.isEmpty()) {
buf.append(sIndent)
.append(".listlevel")
.append(nLevel)
.append(styleNames.getExportName(sDisplayName))
.append(" p {").append(parProps.toString()).append("}").append(config.prettyPrint() ? "\n" : " ");
}
}
}
}
}
return buf.toString();
}
else {
return "";
}
}
/** Get the family of list styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getListStyles();
}
private void cssList(ListStyle style, int nLevel, CSVList props){
// translates "list" style properties for a particular level
// Mozilla does not seem to support the "marker" mechanism of CSS2
// so we will stick with the simpler CSS1-like list style properties
props.addValue("margin-top","0");
props.addValue("margin-bottom","0");
if (config.listFormatting()!=XhtmlConfig.HARD_LABELS) {
// Export the numbering to CSS1
String sLevelType = style.getLevelType(nLevel);
if (XMLString.TEXT_LIST_LEVEL_STYLE_NUMBER.equals(sLevelType)) {
// Numbering style, get number format
String sNumFormat = style.getLevelProperty(nLevel,XMLString.STYLE_NUM_FORMAT);
if ("1".equals(sNumFormat)) { props.addValue("list-style-type","decimal"); }
else if ("i".equals(sNumFormat)) { props.addValue("list-style-type","lower-roman"); }
else if ("I".equals(sNumFormat)) { props.addValue("list-style-type","upper-roman"); }
else if ("a".equals(sNumFormat)) { props.addValue("list-style-type","lower-alpha"); }
else if ("A".equals(sNumFormat)) { props.addValue("list-style-type","upper-alpha"); }
}
else if (XMLString.TEXT_LIST_LEVEL_STYLE_BULLET.equals(sLevelType)) {
// Bullet. We can only choose from disc, bullet and square
switch (nLevel % 3) {
case 1: props.addValue("list-style-type","disc"); break;
case 2: props.addValue("list-style-type","bullet"); break;
case 0: props.addValue("list-style-type","square"); break;
}
}
else if (XMLString.TEXT_LIST_LEVEL_STYLE_IMAGE.equals(sLevelType)) {
// Image. TODO: Handle embedded images
String sHref = style.getLevelProperty(nLevel,XMLString.XLINK_HREF);
if (sHref!=null) { props.addValue("list-style-image","url('"+sHref+"')"); }
}
}
else {
// No numbering generated by the list; we add hard numbering to the paragraph
props.addValue("list-style-type:none");
// In this case we also set the left margin for the list
// For real styles the margins are applied to the paragraphs
// This is more tricky for hard styles, so we use a default left margin on the list
if (style.isAutomatic() && nLevel>1) {
props.addValue("margin-left", "2em");
}
else {
props.addValue("margin-left","0");
}
// Also reset the padding (some browsers use a non-zero default value)
props.addValue("padding-left", "0");
}
// We don't want floats to pass a list to the left (Mozilla and IE both
//handles this terribly!)
props.addValue("clear:left");
}
private void cssListParMargins(ListStyle style, int nLevel, CSVList props){
// Instead margin is applied to the paragraphs in the list, more precisely the list style defines a
// left margin and a text indent to *replace* the values from the paragraph style
String sMarginLeft = style.getLevelStyleProperty(nLevel, XMLString.FO_MARGIN_LEFT);
if (sMarginLeft!=null) {
props.addValue("margin-left", sMarginLeft);
}
else {
props.addValue("margin-left", "0");
}
String sTextIndent = style.getLevelStyleProperty(nLevel, XMLString.FO_TEXT_INDENT);
if (sTextIndent!=null) {
props.addValue("text-indent", sTextIndent);
}
else {
props.addValue("text-indent", "0");
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/CellStyleConverter.java 0000644 0001750 0001750 00000010371 11147474702 025133 0 ustar rene rene /************************************************************************
*
* CellStyleConverter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-09-08)
*
*/
package writer2latex.xhtml;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
/**
* This class converts OpenDocument cell styles to CSS2 styles.
* Cells are formatted using box properties and alignment.
*/
public class CellStyleConverter extends StyleWithPropertiesConverterHelper {
/** Create a new CellStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public CellStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
// Style maps for Cells are currently not supported.
// (In OOo, cell styles are only supported by Calc)
this.styleMap = new XhtmlStyleMap();
this.bConvertStyles = config.xhtmlTableFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlTableFormatting()==XhtmlConfig.IGNORE_HARD;
this.bConvertHard = config.xhtmlTableFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlTableFormatting()==XhtmlConfig.IGNORE_STYLES;
}
/** Get the family of cell styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getCellStyles();
}
/** Create default tag name to represent a Cell object
* @param style to use
* @return the tag name.
*/
public String getDefaultTagName(StyleWithProperties style) {
return "td";
}
/** Convert formatting properties for a specific Cell style.
* @param style the style to convert
* @param props the CSVList object to add information to
* @param bInherit true if properties should be inherited from parent style(s)
*/
public void applyProperties(StyleWithProperties style, CSVList props, boolean bInherit) {
// Apply "inner" box properties (no margins)
getFrameSc().cssBorder(style,props,bInherit);
getFrameSc().cssPadding(style,props,bInherit);
getFrameSc().cssBackground(style,props,bInherit);
// only relevant for spreadsheets
getParSc().cssPar(style,props,bInherit);
getTextSc().cssTextCommon(style,props,bInherit);
// Cell-specific properties (vertical alignment)
cssCell(style,props,bInherit);
}
private void cssCell(StyleWithProperties style, CSVList props, boolean bInherit){
// Vertical align: Some values fit with css
String s = ofr.isOpenDocument() ?
style.getProperty(XMLString.STYLE_VERTICAL_ALIGN,bInherit) :
style.getProperty(XMLString.FO_VERTICAL_ALIGN,bInherit);
if ("middle".equals(s)) { props.addValue("vertical-align","middle"); }
else if ("bottom".equals(s)) { props.addValue("vertical-align","bottom"); }
else if ("top".equals(s)) { props.addValue("vertical-align","top"); }
else {
// No value or "automatic" means, according to the spec,
//"The application decide how to align the text."
// We treat this case like OOo does:
props.addValue("vertical-align", ofr.isSpreadsheet() ? "bottom" : "top");
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/TextStyleConverter.java 0000644 0001750 0001750 00000044701 12406234417 025200 0 ustar rene rene /************************************************************************
*
* TextStyleConverter.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-16)
*
*/
package writer2latex.xhtml;
import java.util.Enumeration;
import java.util.Hashtable;
import writer2latex.office.FontDeclaration;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
import writer2latex.util.ExportNameCollection;
import writer2latex.util.Misc;
/**
* This class converts OpenDocument text styles to CSS2 styles.
* This includes conversion of text properties in other styles
* (paragraph, cell, graphic and presentation styles).
* - TODO: Support CJK and CTL
* - TODO: Support style:use-window-font-color ("automatic color")
* - TODO: Support style:font-charset (other encoding)
* - TODO: Support style:font-size-rel
* - TODO: Support text:display and text:condition
*/
public class TextStyleConverter extends StyleWithPropertiesConverterHelper {
// OpenDocument does *not* define the style for links without style name,
// but OOo uses these styles, and so do we if they are available
// (Caveat: OOo does not export "Visited Internet Link" until a link is actually clicked)
private static final String DEFAULT_LINK_STYLE = "Internet link"; // Not "Link"!
private static final String DEFAULT_VISITED_LINK_STYLE = "Visited Internet Link";
// Bookkeeping for anchors
private ExportNameCollection anchorStyleNames = new ExportNameCollection(true);
private ExportNameCollection anchorVisitedStyleNames = new ExportNameCollection(true);
private Hashtable anchorCombinedStyleNames = new Hashtable();
private Hashtable orgAnchorStyleNames = new Hashtable();
private Hashtable orgAnchorVisitedStyleNames = new Hashtable();
// Export font sizes as percentages?
private boolean bRelativeFontSize = false;
private String sFontScaling = "100%";
private String sBaseFontSize = "12pt";
// Use default font?
private boolean bConvertFont = false;
/** Create a new TextStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of XHTML to use
*/
public TextStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
this.styleMap = config.getXTextStyleMap();
this.bConvertStyles = config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_HARD;
this.bConvertHard = config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_STYLES;
this.bRelativeFontSize = converter.isOPS() && config.relativeFontSize();
this.sFontScaling = config.fontScaling();
StyleWithProperties defaultStyle = ofr.getDefaultParStyle();
if (defaultStyle!=null) {
String sFontSize = defaultStyle.getProperty(XMLString.FO_FONT_SIZE,false);
if (sFontSize!=null) {
sBaseFontSize = sFontSize;
}
}
this.bConvertFont = !config.useDefaultFont();
}
/** Apply a link style, using a combination of two text styles
* @param sStyleName name of the OpenDocument style
* @param sVisitedStyleName name of the OpenDocument style for visited links
* @param info the StyleInfo object to add information to
*/
public void applyAnchorStyle(String sStyleName, String sVisitedStyleName,
StyleInfo info) {
if (sStyleName==null || sVisitedStyleName==null) { return; }
if (sStyleName.length()==0 || sVisitedStyleName.length()==0) { return; }
// Look for a style map
String sDisplayName = ofr.getTextStyles().getDisplayName(sStyleName);
if (styleMap.contains(sDisplayName)) { // class name from config
if (!"(none)".equals(styleMap.getCss(sDisplayName))) {
info.sClass = styleMap.getCss(sDisplayName);
}
return;
}
String sName = sStyleName+sVisitedStyleName;
if (!anchorCombinedStyleNames.containsKey(sName)) {
String sExportName;
// This combination is not seen before, but the base style may be known
// In that case, use the visited style name as well
if (anchorStyleNames.containsName(sStyleName)) {
sExportName = anchorStyleNames.getExportName(sStyleName)
+anchorVisitedStyleNames.getExportName(sVisitedStyleName);
}
else {
sExportName = anchorStyleNames.getExportName(sStyleName);
}
anchorCombinedStyleNames.put(sName,sExportName);
orgAnchorStyleNames.put(sExportName,sStyleName);
orgAnchorVisitedStyleNames.put(sExportName,sVisitedStyleName);
}
info.sClass = anchorCombinedStyleNames.get(sName);
}
/** Convert style information for used styles
* @param sIndent a String of spaces to add before each line
*/
public String getStyleDeclarations(String sIndent) {
StringBuilder buf = new StringBuilder();
buf.append(super.getStyleDeclarations(sIndent));
if (bConvertStyles) {
// Export anchor styles
// Default is always the styles "Internet link" and "Visited Internet Link"(?)
StyleWithProperties defaultLinkStyle = (StyleWithProperties)
getStyles().getStyleByDisplayName(DEFAULT_LINK_STYLE);
if (defaultLinkStyle!=null) {
CSVList props = new CSVList(";");
cssText(defaultLinkStyle,props,true);
cssHyperlink(defaultLinkStyle,props);
buf.append(sIndent)
.append("a:link {").append(props.toString()).append("}\n");
}
defaultLinkStyle = (StyleWithProperties)
getStyles().getStyleByDisplayName(DEFAULT_VISITED_LINK_STYLE);
if (defaultLinkStyle!=null) {
CSVList props = new CSVList(";");
cssText(defaultLinkStyle,props,true);
cssHyperlink(defaultLinkStyle,props);
buf.append(sIndent)
.append("a:visited {").append(props.toString()).append("}\n");
}
// Remaining link styles...
Enumeration enumer = anchorCombinedStyleNames.elements();
while (enumer.hasMoreElements()) {
String sExportName = enumer.nextElement();
String sStyleName = orgAnchorStyleNames.get(sExportName);
String sVisitedStyleName = orgAnchorVisitedStyleNames.get(sExportName);
StyleWithProperties style = ofr.getTextStyle(sStyleName);
if (style!=null) {
CSVList props = new CSVList(";");
cssText(style,props,true);
cssHyperlink(style,props);
buf.append(sIndent).append("a.").append(sExportName)
.append(":link {").append(props.toString()).append("}\n");
}
style = ofr.getTextStyle(sVisitedStyleName);
if (style!=null) {
CSVList props = new CSVList(";");
cssText(style,props,true);
cssHyperlink(style,props);
buf.append(sIndent).append("a.").append(sExportName)
.append(":visited {").append(props.toString()).append("}\n");
}
}
}
return buf.toString();
}
/** Get the family of text (character) styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getTextStyles();
}
/** Create default tag name to represent a text
* @param style to use
* @return the tag name.
*/
public String getDefaultTagName(StyleWithProperties style) {
return "span";
}
/** Convert formatting properties for a specific text style.
* @param style the style to convert
* @param props the CSVList object to add information to
* @param bInherit true if properties should be inherited from parent style(s)
*/
public void applyProperties(StyleWithProperties style, CSVList props, boolean bInherit) {
cssText(style,props,bInherit);
}
////////////////////////////////////////////////////////////////////////////
// OpenDocument text properties
// Text properties can be applied to text, paragraph, cell, graphic and
// presentation styles.
// Language and country attributes are handled elsewhere
// The following attributes are currently not supported:
// - style:use-window-font-color ("automatic color")
// - style:font-charset (other encoding)
// - style:font-size-rel
// - text:display
// - text:condition
// Also all attributes for CJK and CTL text are currently ignored:
// style:font-name-*, style:font-family-*, style:font-family-generic-*,
// style:font-style-name-*, style:font-pitch-*, style:font-charset-*,
// style:font-size-*, style:font-size-rel-*, style:script-type
// The following attributes cannot be supported using CSS2:
// - style:text-outline
// - style:font-relief
// - style:text-line-trough-* (formatting of line through)
// - style:text-underline-* (formatting of underline)
// - style:letter-kerning
// - style:text-combine-*
// - style:text-emphasis
// - style:text-scale
// - style:text-rotation-*
// - fo:hyphenate
// - fo:hyphenation-*
//
public void cssText(StyleWithProperties style, CSVList props, boolean bInherit) {
cssTextCommon(style,props,bInherit);
cssTextBackground(style,props,bInherit);
}
public void cssTextCommon(StyleWithProperties style, CSVList props, boolean bInherit) {
String s=null,s2=null,s3=null,s4=null;
CSVList val;
// Font family
if (bConvertFont && (bInherit || style.getProperty(XMLString.STYLE_FONT_NAME,false)!=null)) {
val = new CSVList(","); // multivalue property!
// Get font family information from font declaration or from style
s = style.getProperty(XMLString.STYLE_FONT_NAME);
if (s!=null) {
FontDeclaration fd = (FontDeclaration) ofr.getFontDeclarations().getStyle(s);
if (fd!=null) {
s = fd.getFontFamily();
s2 = fd.getFontFamilyGeneric();
s3 = fd.getFontPitch();
}
}
else {
s = style.getProperty(XMLString.FO_FONT_FAMILY);
s2 = style.getProperty(XMLString.STYLE_FONT_FAMILY_GENERIC);
s3 = style.getProperty(XMLString.STYLE_FONT_PITCH);
}
// Add the western font family (CJK and CTL is more complicated)
if (s!=null) { val.addValue(s); }
// Add generic font family
if ("fixed".equals(s3)) { val.addValue("monospace"); }
else if ("roman".equals(s2)) { val.addValue("serif"); }
else if ("swiss".equals(s2)) { val.addValue("sans-serif"); }
else if ("modern".equals(s2)) { val.addValue("monospace"); }
else if ("decorative".equals(s2)) { val.addValue("fantasy"); }
else if ("script".equals(s2)) { val.addValue("cursive"); }
else if ("system".equals(s2)) { val.addValue("serif"); } // System default font
if (!val.isEmpty()) { props.addValue("font-family",val.toString()); }
}
// Font style (italics): This property fit with css2
s = style.getProperty(XMLString.FO_FONT_STYLE,bInherit);
if (s!=null) { props.addValue("font-style",s); }
// Font variant (small caps): This property fit with css2
s = style.getProperty(XMLString.FO_FONT_VARIANT,bInherit);
if (s!=null) { props.addValue("font-variant",s); }
// Font weight (bold): This property fit with css2
s = style.getProperty(XMLString.FO_FONT_WEIGHT,bInherit);
if (s!=null) { props.addValue("font-weight",s); }
// Font size: Absolute values of this property fit with css2
// this is handled together with sub- and superscripts (style:text-position)
// First value: sub, super or percentage (raise/lower relative to font height)
// Second value (optional): percentage (relative size);
if (bInherit || style.getProperty(XMLString.FO_FONT_SIZE,false)!=null
|| style.getProperty(XMLString.STYLE_TEXT_POSITION,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_FONT_SIZE);
s2 = style.getProperty(XMLString.STYLE_TEXT_POSITION);
if (s2!=null) {
s2 = s2.trim();
int i = s2.indexOf(" ");
if (i>0) { // two values
s3 = s2.substring(0,i);
s4 = s2.substring(i+1);
}
else { // one value
s3 = s2; s4="100%";
}
if (s!=null) {
if (bRelativeFontSize) {
String sFontSize = Misc.divide(Misc.multiply(sFontScaling, Misc.multiply(s4,s)), sBaseFontSize);
if (!"100%".equals(sFontSize)) props.addValue("font-size", sFontSize);
}
else {
props.addValue("font-size",Misc.multiply(s4,scale(s)));
}
}
else {
props.addValue("font-size",s4);
}
if (!"0%".equals(s3)) {
props.addValue("vertical-align",s3);
}
}
else if (s!=null) {
if (bRelativeFontSize) {
String sFontSize = Misc.divide(Misc.multiply(sFontScaling, s),sBaseFontSize);
if (!"100%".equals(sFontSize)) props.addValue("font-size", sFontSize);
}
else {
props.addValue("font-size",scale(s));
}
}
}
// Color: This attribute fit with css2
s = style.getProperty(XMLString.FO_COLOR,bInherit);
if (s!=null) { props.addValue("color",s); }
// Shadow: This attribute fit with css2
// (Currently OOo has only one shadow style, which is saved as 1pt 1pt)
s = style.getProperty(XMLString.FO_TEXT_SHADOW,bInherit);
if (s!=null) { props.addValue("text-shadow",s); }
// Text decoration. Here OOo is more flexible that CSS2.
if (ofr.isOpenDocument()) {
s = style.getProperty(XMLString.STYLE_TEXT_LINE_THROUGH_STYLE,bInherit);
s2 = style.getProperty(XMLString.STYLE_TEXT_UNDERLINE_STYLE,bInherit);
}
else {
s = style.getProperty(XMLString.STYLE_TEXT_CROSSING_OUT,bInherit);
s2 = style.getProperty(XMLString.STYLE_TEXT_UNDERLINE,bInherit);
}
s3 = style.getProperty(XMLString.STYLE_TEXT_BLINKING,bInherit);
// Issue: Since these three properties all maps to the single CSS property
// text-decoration, there is no way to turn on one kind of decoration and
// turn another one off (without creating another inline element).
// If one decoration is turned of, we turn them all off:
if ("none".equals(s) || "none".equals(s2) || "false".equals(s3)) {
props.addValue("text-decoration","none");
}
else { // set the required properties
val = new CSVList(" "); // multivalue property!
if (s!=null && !"none".equals(s)) { val.addValue("line-through"); }
if (s2!=null && !"none".equals(s2)) { val.addValue("underline"); }
if (s3!=null && "true".equals(s3)) { val.addValue("blink"); }
if (!val.isEmpty()) { props.addValue("text-decoration",val.toString()); }
}
// Letter spacing: This property fit with css
s = style.getProperty(XMLString.FO_LETTER_SPACING,bInherit);
if (s!=null) { props.addValue("letter-spacing",scale(s)); }
// Capitalization: This property fit with css
s = style.getProperty(XMLString.FO_TEXT_TRANSFORM,bInherit);
if (s!=null) { props.addValue("text-transform",s); }
}
public void cssTextBackground(StyleWithProperties style, CSVList props, boolean bInherit) {
// Background color: This attribute fit with css when applied to inline text
String s =ofr.isOpenDocument() ?
style.getTextProperty(XMLString.FO_BACKGROUND_COLOR,bInherit) :
style.getTextProperty(XMLString.STYLE_TEXT_BACKGROUND_COLOR,bInherit);
if (s!=null) { props.addValue("background-color",s); }
}
private void cssHyperlink(StyleWithProperties style, CSVList props) {
String s1,s2;
// For hyperlinks, export text-decoration:none even if nothing is defined in source
if (ofr.isOpenDocument()) {
s1 = style.getProperty(XMLString.STYLE_TEXT_LINE_THROUGH_STYLE,true);
s2 = style.getProperty(XMLString.STYLE_TEXT_UNDERLINE_STYLE,true);
}
else {
s1 = style.getProperty(XMLString.STYLE_TEXT_CROSSING_OUT,true);
s2 = style.getProperty(XMLString.STYLE_TEXT_UNDERLINE,true);
}
String s3 = style.getProperty(XMLString.STYLE_TEXT_BLINKING,true);
if (s1==null && s2==null && s3==null) {
props.addValue("text-decoration","none");
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/DrawConverter.java 0000644 0001750 0001750 00000136001 12411031012 024101 0 ustar rene rene /************************************************************************
*
* DrawConverter.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)
*
*/
/* TODO (impress2xhtml)
* Support master page content!
* New option: xhtml_draw_scaling: scale all draw objects this percentage
* (applies to applySize in this class + page size in PageStyleConverter)
* Certain options should have a fixed value for impress2xhtml:
* original_image_size: always false
* xhtml_formatting: always "convert_all"
* xhtml_frame_formatting: always "convert_all"
* xhtml_use_list_hack: always "true" (until list merge is fixed..)
* apply hard draw page background (see below)
* apply z-order for draw objects (frames)
* export notes (part of draw-page)
* export list-style-image for image bullets!
*/
package writer2latex.xhtml;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import org.xml.sax.SAXException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Element;
import writer2latex.util.Misc;
import writer2latex.util.CSVList;
import writer2latex.util.SimpleXMLParser;
import writer2latex.base.BinaryGraphicsDocument;
import writer2latex.office.EmbeddedObject;
import writer2latex.office.EmbeddedXMLObject;
import writer2latex.office.XMLString;
import writer2latex.office.MIMETypes;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.FormReader;
import writer2latex.office.ControlReader;
//import writer2latex.office.MasterPage;
//import writer2latex.office.PageLayout;
import writer2latex.office.OfficeReader;
//import writer2latex.xhtml.XhtmlStyleMap;
public class DrawConverter extends ConverterHelper {
/** Identifies objects that should be displayed inline.
*/
public static final int INLINE = 0;
/** Identifies objects that should be displayed as floats, either alone
* or with text wrap (using the css attribute float:left or float:right)
*/
public static final int FLOATING = 1;
/** Identifies objects that should be positioned absolute (using the css
* attribute postion:absolute)
*/
public static final int ABSOLUTE = 2;
/** Identifies objects that should be placed centered */
public static final int CENTERED = 3;
/** Identifies objects that should fill the entire screen */
public static final int FULL_SCREEN = 4;
private FormReader form = null;
private String sScale;
private boolean bConvertToPx;
private int nImageSize;
private String sImageSplit;
private boolean bCoverImage;
private boolean bEmbedSVG;
// Embedded SVG images for recycling are collected here
private HashMap svgImages = new HashMap();
// Frames in spreadsheet documents are collected here
private Vector frames = new Vector();
// This flag determines whether to collect frames or insert them immediately
private boolean bCollectFrames = false;
// Large images (for full screen) in EPUB export are collected here
private Vector fullscreenFrames = new Vector();
// This flag determines whether to collect full screen images or insert them immediately
private boolean bCollectFullscreenFrames = true;
public DrawConverter(OfficeReader ofr, XhtmlConfig config, Converter converter) {
super(ofr,config,converter);
// We can only handle one form; pick an arbitrary one.
// Also we cannot split a form over several files.
Iterator formsIterator = ofr.getForms().getFormsIterator();
if (formsIterator.hasNext() && config.getXhtmlSplitLevel()==0) {
form = formsIterator.next();
}
bCollectFrames = ofr.isSpreadsheet();
bCollectFullscreenFrames = true;
sScale = config.getXhtmlScaling();
bConvertToPx = config.xhtmlConvertToPx();
nImageSize = config.imageSize();
sImageSplit = config.imageSplit();
bCoverImage = config.coverImage();
bEmbedSVG = config.embedSVG();
}
///////////////////////////////////////////////////////////////////////
// Complete Draw documents/presentations
public void convertDrawContent(Element onode) {
if (!onode.hasChildNodes()) { return; }
NodeList nList = onode.getChildNodes();
int nLen = nList.getLength();
for (int i=0; iCreate form, if there is a form in this document
* @return the form element, or null if there are no forms in the document
*/
public Element createForm() {
if (form==null) return null;
Element htmlForm = converter.createElement("form");
htmlForm.setAttribute("name", form.getAttribute(XMLString.FORM_NAME));
htmlForm.setAttribute("action", form.getAttribute(XMLString.XLINK_HREF));
String sMethod = form.getAttribute(XMLString.FORM_METHOD);
htmlForm.setAttribute("method", sMethod!=null ? sMethod : "get");
return htmlForm;
}
/////////////////////////////////////////////////////////////////////////
// DRAW ELEMENTS
/** A draw element with a hyperlink is represented as two elements,
* eg. <draw:a><draw:image/></draw:a>.
* We thus need methods to switch between the two elements.
* This method takes a draw-element.
* If this element is a hyperlink, the child element is returned.
* Otherwise the argument is returned unchanged.
* @param onode the draw:a element
* @return the corresponding element
*/
public Element getRealDrawElement(Element onode) {
if (XMLString.DRAW_A.equals(onode.getTagName())) {
Node child = onode.getFirstChild();
while (child!=null) {
if (OfficeReader.isDrawElement(child)) { return (Element) child; }
child = child.getNextSibling();
}
return null; // empty anchor
}
return onode;
}
/** A draw element with a hyperlink is represented as two elements,
* eg. <draw:a><draw:image/></draw:a>.
* We thus need methods to switch between the two elements.
* This method takes a draw-element.
* If this element is contained in a hyperlink, the hyperlink is returned.
* Otherwise null is returned.
* @param onode the draw:a element
* @return the hyperlink element, if any
*/
public Element getDrawAnchor(Element onode) {
Element parent = (Element) onode.getParentNode();
// in oasis format, we need to skip the frame as well
if (XMLString.DRAW_FRAME.equals(parent.getTagName())) {
parent = (Element) parent.getParentNode();
}
if (XMLString.DRAW_A.equals(parent.getTagName())) { return parent; }
return null;
}
private Element getFrame(Element onode) {
if (ofr.isOpenDocument()) return (Element) onode.getParentNode();
else return onode;
}
// Add cover image (the first image in the document is taken out of context)
public Element insertCoverImage(Element hnode) {
Element currentNode = hnode;
if (bCoverImage) {
Element cover = ofr.getFirstImage();
if (cover!=null) {
converter.setCoverFile(null);
bCollectFullscreenFrames = false;
handleDrawElement(cover,currentNode,null,FULL_SCREEN);
bCollectFullscreenFrames = true;
// Add margin:0 to body
Element head = Misc.getChildByTagName(hnode.getOwnerDocument().getDocumentElement(),"head");
if (head!=null) {
Element style = converter.createElement("style");
head.appendChild(style);
style.setAttribute("type", "text/css");
style.appendChild(converter.createTextNode("body { margin:0 }"));
}
currentNode = getTextCv().doMaybeSplit(hnode, 0);
}
}
return currentNode;
}
// Flush all full screen images, returning the new document node
public Element flushFullscreenFrames(Element hnode) {
Element currentNode = hnode;
if (converter.isTopLevel() && !fullscreenFrames.isEmpty()) {
bCollectFullscreenFrames = false;
currentNode = getTextCv().doMaybeSplit(hnode, 0);
for (Element image : fullscreenFrames) {
handleDrawElement(image,currentNode,null,FULL_SCREEN);
currentNode = getTextCv().doMaybeSplit(hnode, 0);
}
fullscreenFrames.clear();
bCollectFullscreenFrames = true;
}
return currentNode;
}
public void flushFrames(Element hnode) {
bCollectFrames = false;
int nCount = frames.size();
for (int i=0; iConvert a draw element to xhtml. The presentation depends on the
* parameter nMode:
* DrawConverter.INLINE: Presented inline. The hnode
* must accept inline content. An inline container must be
* provided.DrawConverter.FLOAT: Presented as a float. The hnode
* must accept block/flow content. A block container must be
* provided.DrawConverter.ABSOLUTE: Presented at an absolute
* position. A block container must be provided.
* Containers for block and inline elements should be supplied.
* The containers may be identical (flow container).
* Note: A draw:text-box will be ignored in inline mode.
* @param onode the draw element
* @param hnodeBlock the xhtml element to attach the converted element to if it's a block element
* @param hnodeInline the xhtml element to attach the converted element to if it's an inline element
* @param nMode identifies how the element should be presented
*/
public void handleDrawElement(Element onode, Element hnodeBlock, Element hnodeInline, int nMode) {
if (bCollectFrames) {
frames.add(onode);
return;
}
String sName = onode.getNodeName();
if (sName.equals(XMLString.DRAW_OBJECT)) {
handleDrawObject(onode,hnodeBlock,hnodeInline,nMode);
}
else if (sName.equals(XMLString.DRAW_OBJECT_OLE)) {
handleDrawObject(onode,hnodeBlock,hnodeInline,nMode);
}
else if (sName.equals(XMLString.DRAW_IMAGE)) {
handleDrawImage(onode,hnodeBlock,hnodeInline,nMode);
}
else if (sName.equals(XMLString.DRAW_TEXT_BOX)) {
handleDrawTextBox(onode,hnodeBlock,hnodeInline,nMode);
}
else if (sName.equals(XMLString.DRAW_A)) {
Element elm = getRealDrawElement(onode);
if (elm!=null) {
handleDrawElement(elm,hnodeBlock,hnodeInline,nMode);
}
}
else if (sName.equals(XMLString.DRAW_FRAME)) {
// First check for TexMaths equation
if (!getMathCv().convertTexMathsEquation(onode, hnodeBlock, hnodeInline, nMode)) {
// OpenDocument embeds the draw element in a frame element
handleDrawElement(Misc.getFirstChildElement(onode),hnodeBlock,hnodeInline,nMode);
}
}
else if (sName.equals(XMLString.DRAW_G)) {
// First check for TexMaths equation
if (!getMathCv().convertTexMathsEquation(onode, hnodeBlock, hnodeInline, nMode)) {
handleDrawGroup(onode,hnodeBlock,hnodeInline,nMode);
}
}
else if (sName.equals(XMLString.DRAW_CONTROL)) {
handleDrawControl(onode,hnodeBlock,hnodeInline,nMode);
}
}
private void handleDrawObject(Element onode, Element hnodeBlock, Element hnodeInline, int nMode) {
// TODO: Placement if not inline
// If possible, add the object inline. In pure block context, add a div.
Element hnode;
if (hnodeInline!=null) {
hnode = hnodeInline;
}
else {
Element div = converter.createElement("div");
hnodeBlock.appendChild(div);
hnode = div;
}
boolean bNoTextPar = OfficeReader.isNoTextPar(OfficeReader.getParagraph(onode));
String sHref = Misc.getAttribute(onode, XMLString.XLINK_HREF);
if (sHref!=null) { // Embedded object in package or linked object
if (ofr.isInPackage(sHref)) { // Embedded object in package
if (sHref.startsWith("#")) { sHref=sHref.substring(1); }
if (sHref.startsWith("./")) { sHref=sHref.substring(2); }
EmbeddedObject object = converter.getEmbeddedObject(sHref);
if (MIMETypes.MATH.equals(object.getType()) || MIMETypes.ODF.equals(object.getType())) { // Formula!
EmbeddedXMLObject xmlObject = (EmbeddedXMLObject) object;
// Document settings = object.getSettingsDOM();
Element replacementImage = null;
if (ofr.isOpenDocument()) { // look for replacement image
replacementImage = Misc.getChildByTagName(getFrame(onode),XMLString.DRAW_IMAGE);
}
try {
hnode.appendChild(converter.createTextNode(" "));
getMathCv().convert(replacementImage,xmlObject.getContentDOM().getDocumentElement(),hnode,bNoTextPar);
hnode.appendChild(converter.createTextNode(" "));
}
catch (SAXException e) {
e.printStackTrace();
}
catch (IOException e) {
e.printStackTrace();
}
}
else { // unsupported object
boolean bIgnore = true;
if (ofr.isOpenDocument()) { // look for replacement image
Element replacementImage = Misc.getChildByTagName(getFrame(onode),XMLString.DRAW_IMAGE);
if (replacementImage!=null) {
handleDrawImage(replacementImage,hnodeBlock,hnodeInline,nMode);
bIgnore = false;
}
}
if (bIgnore) {
hnode.appendChild( converter.createTextNode("[Warning: object ignored]"));
}
}
}
else { // TODO: Linked object
hnode.appendChild( converter.createTextNode("[Warning: Linked object ignored]"));
}
}
else { // flat xml format
Element formula = Misc.getChildByTagName(onode,XMLString.MATH); // Since OOo 3.2
if (formula==null) {
formula = Misc.getChildByTagName(onode,XMLString.MATH_MATH);
}
if (formula != null) {
Element replacementImage = null;
if (ofr.isOpenDocument()) { // look for replacement image
replacementImage = Misc.getChildByTagName(getFrame(onode),XMLString.DRAW_IMAGE);
}
hnode.appendChild(converter.createTextNode(" "));
getMathCv().convert(replacementImage,formula,hnode,bNoTextPar);
hnode.appendChild(converter.createTextNode(" "));
}
else { // unsupported object
boolean bIgnore = true;
if (ofr.isOpenDocument()) { // look for replacement image
Element replacementImage = Misc.getChildByTagName(getFrame(onode),XMLString.DRAW_IMAGE);
if (replacementImage!=null) {
handleDrawImage(replacementImage,hnodeBlock,hnodeInline,nMode);
bIgnore = false;
}
}
if (bIgnore) {
hnode.appendChild( converter.createTextNode("[Warning: object ignored]"));
}
}
}
}
private void handleDrawImage(Element onode, Element hnodeBlock, Element hnodeInline, int nMode) {
Element frame = getFrame(onode);
// For EPUB document some images require special treatment: Cover image and full screen images
if (bCollectFullscreenFrames && converter.isOPS()) {
// First check whether this is the cover image
if (bCoverImage && onode==ofr.getFirstImage()) {
return;
}
// Next check to see if we should treat this image as a "full screen" image
// (Currently only images are handled like this, hence the code is here rather than in handleDrawElement)
else if (!"none".equals(sImageSplit) && converter.isTopLevel()) {
StyleWithProperties style = ofr.getFrameStyle(frame.getAttribute(XMLString.DRAW_STYLE_NAME));
String sWidth = getFrameWidth(frame, style);
String sHeight = getFrameHeight(frame, style);
// It is if the image width exceeds a certain percentage of the current text width and the height is
// greater than 1.33*the width (recommended by Michel "Coolmicro")
if (sWidth!=null && sHeight!=null &&
Misc.sub(Misc.multiply("133%",sWidth), sHeight).startsWith("-") &&
Misc.sub(Misc.multiply(sImageSplit,converter.getContentWidth()),
Misc.multiply(sScale,Misc.truncateLength(sWidth))).startsWith("-")) {
fullscreenFrames.add(onode);
return;
}
}
}
// Get the image from the ImageLoader
BinaryGraphicsDocument bgd = null;
String sFileName = null;
bgd = converter.getImageCv().getImage(onode);
if (bgd!=null) {
if (!bgd.isLinked()) { // embedded image
sFileName = bgd.getFileName();
// If this is the cover image, add it to the converter result
if (bCoverImage && onode==ofr.getFirstImage()) {
converter.setCoverImageFile(bgd,null);
}
}
else { // linked image
if (!converter.isOPS()) { // Cannot have linked images in EPUB, ignore the image
sFileName = bgd.getFileName();
}
}
}
if (sFileName==null) { return; } // TODO: Add warning?
// Create the image (sFileName contains the file name)
Element imageElement = null;
if (converter.nType==XhtmlDocument.HTML5 && bEmbedSVG && bgd!=null && MIMETypes.SVG.equals(bgd.getMIMEType())) {
// In HTML5 we may embed SVG images directly in the document
if (bgd.isRecycled()) {
// Get from the cache (actually we are certain it is there)
if (svgImages.containsKey(bgd.getFileName())) {
Element elm = hnodeInline!=null ? hnodeInline : hnodeBlock;
imageElement = (Element) elm.getOwnerDocument().importNode(svgImages.get(bgd.getFileName()), true);
}
}
else {
// Parse the data
byte[] blob = bgd.getData();
try {
Document dom = SimpleXMLParser.parse(new ByteArrayInputStream(blob));
if (dom!=null) {
Element elm = hnodeInline!=null ? hnodeInline : hnodeBlock;
imageElement = (Element) elm.getOwnerDocument().importNode(dom.getDocumentElement(), true);
// Store in cache in case we need to recycle
svgImages.put(bgd.getFileName(), imageElement);
}
// Else fail silently
} catch (IOException e) {
// Will not happen with a byte array
} catch (SAXException e) {
// Fail silently
}
}
}
else {
// In all other cases, create an img element
if (bgd!=null && !bgd.isLinked() && !bgd.isRecycled()) { converter.addDocument(bgd); }
Element image = converter.createElement("img");
String sName = Misc.getAttribute(getFrame(onode),XMLString.DRAW_NAME);
converter.addTarget(image,sName+"|graphic");
image.setAttribute("src",sFileName);
// Add alternative text, using either alt.text, name or file name
Element desc = Misc.getChildByTagName(frame,XMLString.SVG_DESC);
if (desc==null) {
desc = Misc.getChildByTagName(frame,XMLString.SVG_TITLE);
}
String sAltText = desc!=null ? Misc.getPCDATA(desc) : (sName!=null ? sName : sFileName);
image.setAttribute("alt",sAltText);
imageElement = image;
}
if (imageElement!=null) {
// Now style it
StyleInfo info = new StyleInfo();
String sStyleName = Misc.getAttribute(frame, XMLString.DRAW_STYLE_NAME);
if (nMode!=FULL_SCREEN) { getFrameSc().applyStyle(sStyleName,info); }
applyImageSize(frame,info.props,nMode,false);
// Apply placement
applyPlacement(frame, hnodeBlock, hnodeInline, nMode, imageElement, info);
applyStyle(info,imageElement);
addLink(onode,imageElement);
}
}
private void handleDrawTextBox(Element onode, Element hnodeBlock, Element hnodeInline, int nMode) {
// Create the div with id=name
Element textbox = converter.createElement("div");
if (hnodeBlock!=null) {
hnodeBlock.appendChild(textbox);
}
else { // cannot include the div inline, ignore
return;
}
// Add name, if defined
String sName = Misc.getAttribute(getFrame(onode),XMLString.DRAW_NAME);
if (sName!=null) { converter.addTarget(textbox,sName+"|frame"); }
// Now style it
Element frame = getFrame(onode);
StyleInfo info = new StyleInfo();
// Draw frame style
String sStyleName = Misc.getAttribute(frame, XMLString.DRAW_STYLE_NAME);
if (sStyleName!=null) {
getFrameSc().applyStyle(sStyleName,info);
}
// Presentation frame style
String sPresentationStyleName = Misc.getAttribute(frame, XMLString.PRESENTATION_STYLE_NAME);
if (sPresentationStyleName!=null) {
if ("outline".equals(Misc.getAttribute(frame, XMLString.PRESENTATION_CLASS))) {
getPresentationSc().enterOutline(sPresentationStyleName);
}
getPresentationSc().applyStyle(sPresentationStyleName,info);
}
// Additional text formatting
String sTextStyleName = Misc.getAttribute(frame, XMLString.DRAW_TEXT_STYLE_NAME);
if (sTextStyleName!=null) {
//getStyleCv().applyParStyle(sTextStyleName,info);
}
// Apply placement
String sContentWidth = null;
switch (nMode) {
case INLINE:
break;
case ABSOLUTE:
sContentWidth = applyImageSize(frame,info.props,nMode,false);
info.props.addValue("margin-left","auto");
info.props.addValue("margin-right","auto");
applyPosition(frame,info.props);
break;
case CENTERED:
info.props.addValue("margin-top","2px");
info.props.addValue("margin-bottom","2px");
info.props.addValue("margin-left","auto");
info.props.addValue("margin-right","auto");
sContentWidth = applyImageSize(frame,info.props,nMode,true);
break;
case FLOATING:
sContentWidth = applyImageSize(frame,info.props,nMode,true);
StyleWithProperties style = ofr.getFrameStyle(sStyleName);
if (style!=null) {
String sPos = style.getProperty(XMLString.STYLE_HORIZONTAL_POS);
String sWrap = style.getProperty(XMLString.STYLE_WRAP);
if (isLeft(sPos)) {
if (mayWrapRight(sWrap)) {
info.props.addValue("float","left");
}
else {
// TODO: Remove the margin-right attribute from the existing properties
// and likewise for the other two cases below (requires new CSVList)
info.props.addValue("margin-right", "auto");
}
}
else if (isRight(sPos)) {
if (mayWrapLeft(sWrap)) {
info.props.addValue("float","right");
}
else {
info.props.addValue("margin-left", "auto");
}
}
else if (isCenter(sPos)) {
info.props.addValue("margin-left", "auto");
info.props.addValue("margin-right", "auto");
}
else if (isFromLeft(sPos)) {
if (mayWrapRight(sWrap)) {
info.props.addValue("float","left");
}
String sX = frame.getAttribute(XMLString.SVG_X);
if (sX!=null && sX.length()>0) {
info.props.addValue("margin-left",scale(sX));
}
}
}
}
//Finish
applyStyle(info,textbox);
if (sContentWidth!=null) {
converter.pushContentWidth(sContentWidth);
}
getTextCv().traverseBlockText(onode,textbox);
if (sContentWidth!=null) {
converter.popContentWidth();
}
getPresentationSc().exitOutline();
}
private void handleDrawGroup(Element onode, Element hnodeBlock, Element hnodeInline, int nMode) {
// TODO: style-name and z-index should be transferred to children
Node child = onode.getFirstChild();
while (child!=null) {
if (OfficeReader.isDrawElement(child)) {
handleDrawElement((Element) child, hnodeBlock, hnodeInline, nMode);
}
child = child.getNextSibling();
}
}
//////////////////////////////////////////////////////////////////////////
// Forms
private void handleDrawControl(Element onode, Element hnodeBlock, Element hnodeInline, int nMode) {
// Get the control, if possible
if (form==null) { return; }
ControlReader control = ofr.isOpenDocument() ?
ofr.getForms().getControl(Misc.getAttribute(onode,XMLString.DRAW_CONTROL)) :
ofr.getForms().getControl(Misc.getAttribute(onode,XMLString.FORM_ID));
if (control==null || control.getOwnerForm()!=form) { return; }
// Create the control element
Element hcontrol = null;
String sType = control.getControlType();
if (XMLString.FORM_TEXT.equals(sType)) {
hcontrol = createInputText(control,false);
}
else if (XMLString.FORM_PASSWORD.equals(sType)) {
hcontrol = createInputText(control,true);
}
else if (XMLString.FORM_FILE.equals(sType)) {
hcontrol = createInputFile(control);
}
else if (XMLString.FORM_IMAGE.equals(sType)) {
hcontrol = createInput(control,"image");
}
else if (XMLString.FORM_HIDDEN.equals(sType)) {
hcontrol = createInput(control,"hidden");
}
else if (XMLString.FORM_CHECKBOX.equals(sType)) {
hcontrol = createInputCheck(control,false);
}
else if (XMLString.FORM_RADIO.equals(sType)) {
hcontrol = createInputCheck(control,true);
}
else if (XMLString.FORM_BUTTON.equals(sType)) {
hcontrol = createInputButton(control);
}
else if (XMLString.FORM_FIXED_TEXT.equals(sType)) {
hcontrol = createLabel(control);
}
else if (XMLString.FORM_TEXTAREA.equals(sType)) {
hcontrol = createTextarea(control);
}
else if (XMLString.FORM_LISTBOX.equals(sType)) {
hcontrol = createSelect(control);
}
// ignore other controls
if (hcontrol!=null) {
Element frame = onode; // controls are *not* contained in a draw:frame!
StyleInfo info = new StyleInfo();
getFrameSc().applyStyle(frame.getAttribute(XMLString.DRAW_STYLE_NAME),info);
applySize(frame,info.props,false);
applyPlacement(frame,hnodeBlock,hnodeInline,nMode,hcontrol,info);
applyStyle(info,hcontrol);
}
}
private Element createInput(ControlReader control, String sType) {
// Create the element
Element input = converter.createElement("input");
input.setAttribute("type",sType);
return input;
}
private Element createInputFile(ControlReader control) {
Element input = converter.createElement("input");
input.setAttribute("type","file");
setCommonAttributes(control,input);
setDisabled(control,input);
setReadonly(control,input);
setValue(control,input);
return input;
}
private Element createInputText(ControlReader control, boolean bPassword) {
Element input = converter.createElement("input");
input.setAttribute("type",bPassword ? "password" : "text");
setCommonAttributes(control,input);
setName(control,input,true);
setValue(control,input);
setMaxLength(control,input);
setDisabled(control,input);
setReadonly(control,input);
return input;
}
private Element createInputCheck(ControlReader control, boolean bRadio) {
Element input = converter.createElement("input");
input.setAttribute("type",bRadio ? "radio" : "checkbox");
setCommonAttributes(control,input);
setName(control,input,true);
setValue(control,input);
setChecked(control,input);
setDisabled(control,input);
setReadonly(control,input);
// Add a label for the check/radio
Element label = converter.createElement("label");
setFor(control,label);
label.appendChild(input);
label.appendChild(converter.createTextNode(control.getTypeAttribute(XMLString.FORM_LABEL)));
return label;
}
private Element createInputButton(ControlReader control) {
Element input = converter.createElement("input");
String sButtonType = control.getTypeAttribute(XMLString.FORM_BUTTON_TYPE);
if ("submit".equals(sButtonType)) {
input.setAttribute("type","submit");
}
else if ("reset".equals(sButtonType)) {
input.setAttribute("type","reset");
}
else { // TODO: url button (using javascript)
input.setAttribute("type","button");
}
setCommonAttributes(control,input);
setName(control,input,true);
input.setAttribute("value",control.getTypeAttribute(XMLString.FORM_LABEL));
setDisabled(control,input);
return input;
}
private Element createLabel(ControlReader control) {
Element label = converter.createElement("label");
setCommonAttributes(control,label);
setFor(control,label);
label.setAttribute("value",control.getTypeAttribute(XMLString.FORM_LABEL));
label.appendChild(converter.createTextNode(control.getTypeAttribute(XMLString.FORM_LABEL)));
return label;
}
private Element createTextarea(ControlReader control) {
Element textarea = converter.createElement("textarea");
setCommonAttributes(control,textarea);
setName(control,textarea,true);
setDisabled(control,textarea);
setReadonly(control,textarea);
// rows & cols are required - but css will override them!
textarea.setAttribute("rows","10");
textarea.setAttribute("cols","5");
// The value attribute should be used as content
String s = control.getTypeAttribute(XMLString.FORM_VALUE);
if (s!=null) {
textarea.appendChild(converter.createTextNode(s));
}
return textarea;
}
private Element createSelect(ControlReader control) {
Element select = converter.createElement("select");
setCommonAttributes(control,select);
setName(control,select,false);
setSize(control,select);
setMultiple(control,select);
setDisabled(control,select);
// Add options
int nCount = control.getItemCount();
for (int i=0; i0) {
Element hanchor = converter.createLink(oanchor);
hnode.getParentNode().replaceChild(hanchor,hnode);
hanchor.appendChild(hnode);
}
}
}
// The width attribute in CSS refers to the content width, excluding borders and padding
// We thus have to subtract the borders and padding to get the correct width
// This method handles this
private String getFrameWidth(Element node, StyleWithProperties style) {
String sWidth = node.getAttribute(XMLString.SVG_WIDTH);
if (sWidth.length()>0) {
if (style!=null) {
// Subtract padding
String s = style.getProperty(XMLString.FO_PADDING_LEFT);
if (s!=null) sWidth = Misc.sub(sWidth, s);
s = style.getProperty(XMLString.FO_PADDING_RIGHT);
if (s!=null) sWidth = Misc.sub(sWidth, s);
s = style.getProperty(XMLString.FO_PADDING);
if (s!=null) sWidth = Misc.sub(sWidth, Misc.multiply("200%", s));
// Subtract border
s = style.getProperty(XMLString.FO_BORDER_LEFT);
if (s!=null) sWidth = Misc.sub(sWidth, getTableCv().borderWidth(s));
s = style.getProperty(XMLString.FO_BORDER_RIGHT);
if (s!=null) sWidth = Misc.sub(sWidth, getTableCv().borderWidth(s));
s = style.getProperty(XMLString.FO_BORDER);
if (s!=null) sWidth = Misc.sub(sWidth, Misc.multiply("200%", getTableCv().borderWidth(s)));
}
return sWidth;
}
return null;
}
// Same for height
private String getFrameHeight(Element node, StyleWithProperties style) {
String sHeight = node.getAttribute(XMLString.SVG_HEIGHT);
if (sHeight.length()>0) {
if (style!=null) {
// Subtract padding
String s = style.getProperty(XMLString.FO_PADDING_TOP);
if (s!=null) sHeight = Misc.sub(sHeight, s);
s = style.getProperty(XMLString.FO_PADDING_BOTTOM);
if (s!=null) sHeight = Misc.sub(sHeight, s);
s = style.getProperty(XMLString.FO_PADDING);
if (s!=null) sHeight = Misc.sub(sHeight, Misc.multiply("200%", s));
// Subtract border
s = style.getProperty(XMLString.FO_BORDER_TOP);
if (s!=null) sHeight = Misc.sub(sHeight, getTableCv().borderWidth(s));
s = style.getProperty(XMLString.FO_BORDER_BOTTOM);
if (s!=null) sHeight = Misc.sub(sHeight, getTableCv().borderWidth(s));
s = style.getProperty(XMLString.FO_BORDER);
if (s!=null) sHeight = Misc.sub(sHeight, Misc.multiply("200%", getTableCv().borderWidth(s)));
}
return sHeight;
}
return null;
}
// Return the (unscaled) content width, or null if it's unknown
private String applySize(Element node, CSVList props, boolean bOnlyWidth) {
StyleWithProperties style = ofr.getFrameStyle(node.getAttribute(XMLString.DRAW_STYLE_NAME));
String sWidth = getFrameWidth(node, style);
if (sWidth!=null) {
props.addValue("width",scale(sWidth));
}
if (!bOnlyWidth) {
String sHeight = getFrameHeight(node,style);
if (sHeight!=null) {
props.addValue("height",scale(sHeight));
}
}
return sWidth;
}
// TODO: For absolute placement, only absolute size makes sense
// TODO: How to handle NONE in case of text boxes? (currently using browser default, usually 100% width)
private String applyImageSize(Element node, CSVList props, int nMode, boolean bOnlyWidth) {
switch (nImageSize) {
case XhtmlConfig.ABSOLUTE:
return applySize(node, props, bOnlyWidth);
case XhtmlConfig.RELATIVE:
if (nMode==FULL_SCREEN) {
props.addValue("max-width","100%");
props.addValue("height","100%");
}
else {
String sWidth = getFrameWidth(node, ofr.getFrameStyle(node.getAttribute(XMLString.DRAW_STYLE_NAME)));
if (sWidth!=null) {
props.addValue("width", Misc.divide(Misc.multiply(sScale,Misc.truncateLength(sWidth)),converter.getContentWidth()));
}
return sWidth;
}
case XhtmlConfig.NONE:
// Nothing to do :-)
return getFrameWidth(node, ofr.getFrameStyle(node.getAttribute(XMLString.DRAW_STYLE_NAME)));
}
return null;
}
private void applyPosition(Element node, CSVList props) {
// The left and top attributes in css refers to the entire box, including margins
// We thus have to subtract the margins to get correct placement
String sX = node.getAttribute(XMLString.SVG_X);
if (sX.length()==0) sX="0";
String sY = node.getAttribute(XMLString.SVG_Y);
if (sY.length()==0) sY="0";
StyleWithProperties style = ofr.getFrameStyle(node.getAttribute(XMLString.DRAW_STYLE_NAME));
if (style!=null) {
String s = style.getProperty(XMLString.FO_MARGIN_TOP);
if (s!=null) sX=Misc.sub(sX,s);
s = style.getProperty(XMLString.FO_MARGIN_LEFT);
if (s!=null) sY=Misc.sub(sY,s);
}
props.addValue("position","absolute");
if (sX!=null && sX.length()>0) { props.addValue("left",scale(sX)); }
if (sY!=null && sY.length()>0) { props.addValue("top",scale(sY)); }
}
private void applyPlacement(Element onode, Element hnodeBlock,
Element hnodeInline, int nMode, Element object, StyleInfo info) {
switch (nMode) {
case INLINE :
hnodeInline.appendChild(object);
break;
case ABSOLUTE:
applyPosition(onode,info.props);
if (hnodeInline!=null) {
hnodeInline.appendChild(object);
}
else {
Element div = converter.createElement("div");
hnodeBlock.appendChild(div);
div.appendChild(object);
}
break;
case CENTERED:
Element centerdiv = converter.createElement("div");
centerdiv.setAttribute("style","margin:2px 0px 2px 0px");
hnodeBlock.appendChild(centerdiv);
centerdiv.appendChild(object);
break;
case FULL_SCREEN:
if (hnodeBlock!=null) {
Element div = converter.createElement("div");
div.setAttribute("style", "text-align:center");
hnodeBlock.appendChild(div);
div.appendChild(object);
}
break;
case FLOATING:
boolean bWrap = false;
String sAlign = "center";
String sX = null;
String sStyleName = Misc.getAttribute(onode, XMLString.DRAW_STYLE_NAME);
StyleWithProperties style = ofr.getFrameStyle(sStyleName);
if (style!=null) {
String sPos = style.getProperty(XMLString.STYLE_HORIZONTAL_POS);
String sWrap = style.getProperty(XMLString.STYLE_WRAP);
if (isLeft(sPos)) {
bWrap = mayWrapRight(sWrap);
sAlign = "left";
}
else if (isRight(sPos)) {
bWrap = mayWrapLeft(sWrap);
sAlign = "right";
}
else if (isFromLeft(sPos)) {
bWrap = mayWrapRight(sWrap);
sAlign = "left";
sX = onode.getAttribute(XMLString.SVG_X);
}
}
if (bWrap) {
info.props.addValue("float",sAlign);
if (sX!=null && sX.length()>0) { info.props.addValue("margin-left",sX); }
if (hnodeInline!=null) {
hnodeInline.appendChild(object);
}
else {
Element div = converter.createElement("div");
hnodeBlock.appendChild(div);
div.appendChild(object);
}
}
else {
Element div = converter.createElement("div");
hnodeBlock.appendChild(div);
div.appendChild(object);
CSVList props = new CSVList(";");
props.addValue("text-align",sAlign);
if (sX!=null && sX.length()>0) { props.addValue("margin-left",sX); }
div.setAttribute("style",props.toString());
}
}
}
private boolean isLeft(String sHPos) {
return "left".equals(sHPos) || "inside".equals(sHPos);
}
private boolean isCenter(String sHPos) {
return "center".equals(sHPos);
}
private boolean isRight(String sHPos) {
return "right".equals(sHPos) || "outside".equals(sHPos);
}
private boolean isFromLeft(String sHPos) {
return "from-left".equals(sHPos) || "from-inside".equals(sHPos);
}
private boolean mayWrapLeft(String sWrap) {
return "left".equals(sWrap) || "parallel".equals(sWrap) || "biggest".equals(sWrap) ||
"dynamic".equals(sWrap) || "run-through".equals(sWrap);
}
private boolean mayWrapRight(String sWrap) {
return "right".equals(sWrap) || "parallel".equals(sWrap) || "biggest".equals(sWrap) ||
"dynamic".equals(sWrap) || "run-through".equals(sWrap);
}
// TODO: Move to ConverterHelper.java
private String scale(String s) {
if (bConvertToPx) {
return Misc.length2px(Misc.multiply(sScale,Misc.truncateLength(s)));
}
else {
return Misc.multiply(sScale,Misc.truncateLength(s));
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/Xhtml10Converter.java 0000644 0001750 0001750 00000002047 11147474702 024471 0 ustar rene rene /************************************************************************
*
* Xhtml10Converter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-09-09)
*
*/
package writer2latex.xhtml;
public class Xhtml10Converter extends Converter {
public Xhtml10Converter() {
super(XhtmlDocument.XHTML10);
}
} writer2latex-1.4/source/java/writer2latex/xhtml/SectionStyleConverter.java 0000644 0001750 0001750 00000006350 11147474702 025662 0 ustar rene rene /************************************************************************
*
* SectionStyleConverter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-11-22)
*
*/
package writer2latex.xhtml;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
//import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
/**
* This class converts OpenDocument section styles to CSS2 styles.
* Sections are formatted using (a subset of) box properties and with columns.
* The latter would require css3 to be converted (column-count property)
*/
public class SectionStyleConverter extends StyleWithPropertiesConverterHelper {
/** Create a new SectionStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public SectionStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
// Style maps for sections are currently not supported.
// (Section styles are not supported by OOo yet)
this.styleMap = new XhtmlStyleMap();
this.bConvertStyles = config.xhtmlSectionFormatting()==XhtmlConfig.CONVERT_ALL
|| config.xhtmlSectionFormatting()==XhtmlConfig.IGNORE_HARD;
this.bConvertHard = config.xhtmlSectionFormatting()==XhtmlConfig.CONVERT_ALL
|| config.xhtmlSectionFormatting()==XhtmlConfig.IGNORE_STYLES;
}
/** Get the family of section styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getSectionStyles();
}
/** Create default tag name to represent a section object
* @param style to use
* @return the tag name. If the style is null, a default result should be
* returned.
*/
public String getDefaultTagName(StyleWithProperties style) {
return "div";
}
/** Convert formatting properties for a specific section style.
* @param style the style to convert
* @param props the CSVList object to add information to
* @param bInherit true if properties should be inherited from parent style(s)
*/
public void applyProperties(StyleWithProperties style, CSVList props, boolean bInherit) {
getFrameSc().cssBox(style,props,bInherit);
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/PageStyleConverter.java 0000644 0001750 0001750 00000023704 12406234417 025130 0 ustar rene rene /************************************************************************
*
* PageStyleConverter.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-16)
*
*/
package writer2latex.xhtml;
import java.util.Enumeration;
import writer2latex.office.MasterPage;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.PageLayout;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
import writer2latex.util.Misc;
/**
* This class converts OpenDocument page styles to CSS2 styles.
* A page style in a presentation is represented through the master page,
* which links to a page layout defining the geometry and optionally a drawing
* page defining the drawing background.
*
* In a presentation document we export the full page style.
* In a text document we export the writing direction, background color and footnote rule for the first master page only
*/
public class PageStyleConverter extends StyleConverterHelper {
private boolean bHasFootnoteRules = false;
/** Create a new PageStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public PageStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
this.bConvertStyles = config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_HARD;
}
/** Get the text width of the first master page (page width minus left and right margin)
*
* @return the text width
*/
public String getTextWidth() {
MasterPage masterPage = ofr.getFirstMasterPage();
if (masterPage!=null) {
PageLayout pageLayout = ofr.getPageLayout(masterPage.getPageLayoutName());
if (pageLayout!=null) {
String sWidth = pageLayout.getProperty(XMLString.FO_PAGE_WIDTH);
if (sWidth!=null) {
String sMarginLeft = pageLayout.getProperty(XMLString.FO_MARGIN_LEFT);
if (sMarginLeft!=null) {
sWidth = Misc.sub(sWidth, sMarginLeft);
}
String sMarginRight = pageLayout.getProperty(XMLString.FO_MARGIN_RIGHT);
if (sMarginRight!=null) {
sWidth = Misc.sub(sWidth, sMarginRight);
}
return sWidth;
}
}
}
return "17cm"; // Default in Writer, hence usable as a fallback value
}
/** Apply footnote rule formatting (based on first master page)
*
* @param info then StyleInfo to which style information should be attached
*/
public void applyFootnoteRuleStyle(StyleInfo info) {
bHasFootnoteRules = true;
info.sClass="footnoterule";
}
/** Apply default writing direction (based on first master page)
*
* @param info then StyleInfo to which style information should be attached
*/
public void applyDefaultWritingDirection(StyleInfo info) {
MasterPage masterPage = ofr.getFirstMasterPage();
if (masterPage!=null) {
PageLayout pageLayout = ofr.getPageLayout(masterPage.getPageLayoutName());
if (pageLayout!=null) {
applyDirection(pageLayout,info);
}
}
}
/** Apply a master page style - currently only for presentations
*
* @param sStyleName The name of the master page
* @param info the StyleInfo to which style information should be attached
*/
public void applyStyle(String sStyleName, StyleInfo info) {
MasterPage masterPage = ofr.getMasterPage(sStyleName);
if (masterPage!=null) {
String sDisplayName = masterPage.getDisplayName();
if (ofr.isPresentation()) {
// Always generates class name
info.sClass="masterpage"+styleNames.getExportName(sDisplayName);
}
}
}
/** Convert style information for used styles
* @param sIndent a String of spaces to add before each line
*/
public String getStyleDeclarations(String sIndent) {
StringBuilder buf = new StringBuilder();
// This will be master pages for presentations only
Enumeration names = styleNames.keys();
while (names.hasMoreElements()) {
String sDisplayName = names.nextElement();
MasterPage style = (MasterPage)
getStyles().getStyleByDisplayName(sDisplayName);
StyleInfo info = new StyleInfo();
// First apply page layout (size)
PageLayout pageLayout = ofr.getPageLayout(style.getPageLayoutName());
if (pageLayout!=null) {
applyDirection(pageLayout,info);
cssPageSize(pageLayout,info.props);
getFrameSc().cssBackground(pageLayout,info.props,true);
}
// Next apply drawing-page style (draw background)
StyleWithProperties drawingPage = ofr.getDrawingPageStyle(style.getProperty(XMLString.DRAW_STYLE_NAME));
if (drawingPage!=null) {
cssDrawBackground(drawingPage,info.props,true);
}
// Then export the results
buf.append(sIndent)
.append(".masterpage").append(styleNames.getExportName(sDisplayName))
.append(" {").append(info.props.toString()).append("}")
.append(config.prettyPrint() ? "\n" : " ");
}
if (ofr.isText()) {
// Export page formatting for first master page in text documents
MasterPage masterPage = ofr.getFirstMasterPage();
if (masterPage!=null) {
PageLayout pageLayout = ofr.getPageLayout(masterPage.getPageLayoutName());
if (pageLayout!=null) {
if (bConvertStyles) {
// Background color
StyleInfo pageInfo = new StyleInfo();
getFrameSc().cssBackground(pageLayout,pageInfo.props,true);
/*if (converter.isOPS()) { // Use zero margin for EPUB and default margins for XHTML
pageInfo.props.addValue("margin", "0");
}*/
if (pageInfo.hasAttributes()) {
buf.append(sIndent).append("body {").append(pageInfo.props.toString()).append("}")
.append(config.prettyPrint() ? "\n" : " ");
}
// Footnote rule
if (bHasFootnoteRules) {
StyleInfo ruleInfo = new StyleInfo();
cssFootnoteRule(pageLayout,ruleInfo.props);
buf.append(sIndent).append("hr.footnoterule {").append(ruleInfo.props.toString()).append("}")
.append(config.prettyPrint() ? "\n" : " ");
}
}
}
}
}
return buf.toString();
}
/** Get the family of page styles (master pages)
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getMasterPages();
}
// Background properties in draw: Color, gradient, hatching or bitmap
private void cssDrawBackground(StyleWithProperties style, CSVList props, boolean bInherit){
// Fill color: Same as in css
String s = style.getProperty(XMLString.DRAW_FILL_COLOR,bInherit);
if (s!=null) { props.addValue("background-color",s); }
}
private void cssPageSize(PageLayout style, CSVList props) {
String sWidth = style.getProperty(XMLString.FO_PAGE_WIDTH);
if (sWidth!=null) { props.addValue("width",scale(sWidth)); }
String sHeight = style.getProperty(XMLString.FO_PAGE_HEIGHT);
if (sHeight!=null) { props.addValue("height",scale(sHeight)); }
}
// Footnote rule
private void cssFootnoteRule(PageLayout style, CSVList props) {
String sBefore = style.getFootnoteProperty(XMLString.STYLE_DISTANCE_BEFORE_SEP);
if (sBefore!=null) { props.addValue("margin-top",scale(sBefore)); }
String sAfter = style.getFootnoteProperty(XMLString.STYLE_DISTANCE_AFTER_SEP);
if (sAfter!=null) { props.addValue("margin-bottom", scale(sAfter)); }
String sHeight = style.getFootnoteProperty(XMLString.STYLE_WIDTH);
if (sHeight!=null) { props.addValue("height", scale(sHeight)); }
String sWidth = style.getFootnoteProperty(XMLString.STYLE_REL_WIDTH);
if (sWidth!=null) { props.addValue("width", sWidth); }
String sColor = style.getFootnoteProperty(XMLString.STYLE_COLOR);
if (sColor!=null) { // To get the expected result in all browsers we must set both
props.addValue("color", sColor);
props.addValue("background-color", sColor);
}
String sAdjustment = style.getFootnoteProperty(XMLString.STYLE_ADJUSTMENT);
if ("right".equals(sAdjustment)) {
props.addValue("margin-left", "auto");
props.addValue("margin-right", "0");
}
else if ("center".equals(sAdjustment)) {
props.addValue("margin-left", "auto");
props.addValue("margin-right", "auto");
}
else { // default left
props.addValue("margin-left", "0");
props.addValue("margin-right", "auto");
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/Converter.java 0000644 0001750 0001750 00000107414 12407045472 023315 0 ustar rene rene /************************************************************************
*
* Converter.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-18)
*
*/
package writer2latex.xhtml;
import java.io.File;
import java.io.FileInputStream;
import java.util.HashSet;
import java.util.ListIterator;
import java.util.LinkedList;
import java.util.Set;
import java.util.Stack;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Iterator;
import java.io.InputStream;
import java.io.IOException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.Text;
import writer2latex.api.Config;
import writer2latex.api.ContentEntry;
import writer2latex.api.ConverterFactory;
import writer2latex.api.OutputFile;
import writer2latex.base.ContentEntryImpl;
import writer2latex.base.ConverterBase;
import writer2latex.office.MIMETypes;
import writer2latex.office.OfficeReader;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.XMLString;
import writer2latex.util.ExportNameCollection;
import writer2latex.util.Misc;
import writer2latex.xhtml.l10n.L10n;
/**
* This class converts an OpenDocument file to an XHTML(+MathML) or EPUB document.
*
*/
public class Converter extends ConverterBase {
private static final String EPUB_STYLES_FOLDER = "styles/";
private static final String EPUB_STYLESHEET = "styles/styles1.css";
private static final String EPUB_CUSTOM_STYLESHEET = "styles/styles.css";
// Config
private XhtmlConfig config;
public Config getConfig() { return config; }
protected XhtmlConfig getXhtmlConfig() { return config; }
// The locale
private L10n l10n;
// The helpers
private StyleConverter styleCv;
private TextConverter textCv;
private TableConverter tableCv;
private DrawConverter drawCv;
private MathConverter mathCv;
// The template
private XhtmlDocument template = null;
// The included style sheet and associated resources
private CssDocument styleSheet = null;
private Set resources = new HashSet();
// The xhtml output file(s)
protected int nType = XhtmlDocument.XHTML10; // the doctype
private boolean bOPS = false; // Do we need to be OPS conforming?
Vector outFiles;
private int nOutFileIndex;
private XhtmlDocument htmlDoc; // current outfile
private Document htmlDOM; // current DOM, usually within htmlDoc
private boolean bNeedHeaderFooter = false;
//private int nTocFileIndex = -1;
//private int nAlphabeticalIndex = -1;
// Hyperlinks
Hashtable targets = new Hashtable();
LinkedList links = new LinkedList();
// Strip illegal characters from internal hyperlink targets
private ExportNameCollection targetNames = new ExportNameCollection(true);
// The current context (currently we only track the content width, but this might be expanded with formatting
// attributes - at least background color and font size later)
private Stack contentWidth = new Stack();
// Constructor setting the DOCTYPE
public Converter(int nType) {
super();
config = new XhtmlConfig();
this.nType = nType;
}
// override methods to read templates, style sheets and resources
@Override public void readTemplate(InputStream is) throws IOException {
template = new XhtmlDocument("Template",nType);
template.read(is);
}
@Override public void readTemplate(File file) throws IOException {
readTemplate(new FileInputStream(file));
}
@Override public void readStyleSheet(InputStream is) throws IOException {
if (styleSheet==null) {
styleSheet = new CssDocument(EPUB_CUSTOM_STYLESHEET);
}
styleSheet.read(is);
}
@Override public void readStyleSheet(File file) throws IOException {
readStyleSheet(new FileInputStream(file));
}
@Override public void readResource(InputStream is, String sFileName, String sMediaType) throws IOException {
if (sMediaType==null) {
// Guess the media type from the file extension
sMediaType="";
String sfilename = sFileName.toLowerCase();
// PNG, JPEG and GIF are the basic raster image formats that must be supported by EPUB readers
if (sfilename.endsWith(MIMETypes.PNG_EXT)) { sMediaType = MIMETypes.PNG; }
else if (sfilename.endsWith(MIMETypes.JPEG_EXT)) { sMediaType = MIMETypes.JPEG; }
else if (sfilename.endsWith(".jpeg")) { sMediaType = MIMETypes.JPEG; }
else if (sfilename.endsWith(MIMETypes.GIF_EXT)) { sMediaType = MIMETypes.GIF; }
// The OPS 2.0.1 specification recommends (and only mentions) OpenType with this media type
else if (sfilename.endsWith(".otf")) { sMediaType = "application/vnd.ms-opentype"; }
// For convenience we also include a media type for true type fonts (the most common, it seems)
else if (sfilename.endsWith(".ttf")) { sMediaType = "application/x-font-ttf"; }
}
ResourceDocument doc = new ResourceDocument(EPUB_STYLES_FOLDER+sFileName, sMediaType);
doc.read(is);
resources.add(doc);
}
@Override public void readResource(File file, String sFileName, String sMediaType) throws IOException {
readResource(new FileInputStream(file), sFileName, sMediaType);
}
protected String getContentWidth() {
return contentWidth.peek();
}
protected String pushContentWidth(String sWidth) {
return contentWidth.push(sWidth);
}
protected void popContentWidth() {
contentWidth.pop();
}
protected boolean isTopLevel() {
return contentWidth.size()==1;
}
protected StyleConverter getStyleCv() { return styleCv; }
protected TextConverter getTextCv() { return textCv; }
protected TableConverter getTableCv() { return tableCv; }
protected DrawConverter getDrawCv() { return drawCv; }
protected MathConverter getMathCv() { return mathCv; }
protected int getType() { return nType; }
protected int getOutFileIndex() { return nOutFileIndex; }
protected void addContentEntry(String sTitle, int nLevel, String sTarget) {
converterResult.addContentEntry(new ContentEntryImpl(sTitle,nLevel,htmlDoc,sTarget));
}
protected void setTocFile(String sTarget) {
converterResult.setTocFile(new ContentEntryImpl(l10n.get(L10n.CONTENTS),1,htmlDoc,sTarget));
//nTocFileIndex = nOutFileIndex;
}
protected void setLofFile(String sTarget) {
converterResult.setLofFile(new ContentEntryImpl("Figures",1,htmlDoc,sTarget));
}
protected void setLotFile(String sTarget) {
converterResult.setLotFile(new ContentEntryImpl("Tables",1,htmlDoc,sTarget));
}
protected void setIndexFile(String sTarget) {
converterResult.setIndexFile(new ContentEntryImpl(l10n.get(L10n.INDEX),1,htmlDoc,sTarget));
//nAlphabeticalIndex = nOutFileIndex;
}
protected void setCoverFile(String sTarget) {
converterResult.setCoverFile(new ContentEntryImpl("Cover",0,htmlDoc,sTarget));
}
protected void setCoverImageFile(OutputFile file, String sTarget) {
converterResult.setCoverImageFile(new ContentEntryImpl("Cover image",0,file,sTarget));
}
protected Element createElement(String s) { return htmlDOM.createElement(s); }
protected Text createTextNode(String s) { return htmlDOM.createTextNode(s); }
protected Node importNode(Node node, boolean bDeep) { return htmlDOM.importNode(node,bDeep); }
protected L10n getL10n() { return l10n; }
public void setOPS(boolean b) { bOPS = true; }
public boolean isOPS() { return bOPS; }
@Override public void convertInner() throws IOException {
sTargetFileName = Misc.trimDocumentName(sTargetFileName,XhtmlDocument.getExtension(nType));
outFiles = new Vector();
nOutFileIndex = -1;
bNeedHeaderFooter = !bOPS && (ofr.isSpreadsheet() || ofr.isPresentation() || config.getXhtmlSplitLevel()>0 || config.pageBreakSplit()>XhtmlConfig.NONE || config.getXhtmlUplink().length()>0);
l10n = new L10n();
if (isOPS()) {
imageConverter.setBaseFileName("image");
imageConverter.setUseSubdir("images");
}
else {
imageConverter.setBaseFileName(sTargetFileName+"-img");
if (config.saveImagesInSubdir()) {
imageConverter.setUseSubdir(sTargetFileName+"-img");
}
}
imageConverter.setDefaultFormat(MIMETypes.PNG);
imageConverter.addAcceptedFormat(MIMETypes.JPEG);
imageConverter.addAcceptedFormat(MIMETypes.GIF);
if (nType==XhtmlDocument.HTML5) { // HTML supports SVG as well
imageConverter.setDefaultVectorFormat(MIMETypes.SVG);
}
styleCv = new StyleConverter(ofr,config,this,nType);
textCv = new TextConverter(ofr,config,this);
tableCv = new TableConverter(ofr,config,this);
drawCv = new DrawConverter(ofr,config,this);
mathCv = new MathConverter(ofr,config,this,nType!=XhtmlDocument.XHTML10 && nType!=XhtmlDocument.XHTML11);
// Set locale to document language
StyleWithProperties style = ofr.isSpreadsheet() ? ofr.getDefaultCellStyle() : ofr.getDefaultParStyle();
if (style!=null) {
// The only CTL language recognized currently is farsi
if ("fa".equals(style.getProperty(XMLString.STYLE_LANGUAGE_COMPLEX))) {
l10n.setLocale("fa", "IR");
}
else {
l10n.setLocale(style.getProperty(XMLString.FO_LANGUAGE), style.getProperty(XMLString.FO_COUNTRY));
}
}
// Set the main content width
pushContentWidth(getStyleCv().getPageSc().getTextWidth());
// Traverse the body
Element body = ofr.getContent();
if (ofr.isSpreadsheet()) { tableCv.convertTableContent(body); }
else if (ofr.isPresentation()) { drawCv.convertDrawContent(body); }
else { textCv.convertTextContent(body); }
// Set the title page and text page entries
if (converterResult.getContent().isEmpty()) {
// No headings in the document: There is no title page and the text page is the first page
converterResult.setTextFile(new ContentEntryImpl("Text", 1, outFiles.get(0), null));
// We also have to add a toc entry (the ncx file cannot be empty)
converterResult.addContentEntry(new ContentEntryImpl("Text", 1, outFiles.get(0), null));
}
else {
ContentEntry firstHeading = converterResult.getContent().get(0);
// The title page is the first page after the cover, unless the first page starts with a heading
int nFirstPage = converterResult.getCoverFile()!=null ? 1 : 0;
if (outFiles.get(nFirstPage)!=firstHeading.getFile() || firstHeading.getTarget()!=null) {
converterResult.setTitlePageFile(new ContentEntryImpl("Title page", 1, outFiles.get(nFirstPage), null));
}
// The text page is the one containing the first heading
converterResult.setTextFile(new ContentEntryImpl("Text", 1, firstHeading.getFile(), firstHeading.getTarget()));
}
// Resolve links
ListIterator iter = links.listIterator();
while (iter.hasNext()) {
LinkDescriptor ld = iter.next();
Integer targetIndex = targets.get(ld.sId);
if (targetIndex!=null) {
int nTargetIndex = targetIndex.intValue();
if (nTargetIndex == ld.nIndex) { // same file
ld.element.setAttribute("href","#"+targetNames.getExportName(ld.sId));
}
else {
ld.element.setAttribute("href",getOutFileName(nTargetIndex,true)
+"#"+targetNames.getExportName(ld.sId));
}
}
}
// Add included style sheet, if any - and we are creating OPS content
if (bOPS && styleSheet!=null) {
converterResult.addDocument(styleSheet);
for (ResourceDocument doc : resources) {
converterResult.addDocument(doc);
}
}
// Export styles (XHTML)
if (!isOPS() && !config.separateStylesheet()) {
for (int i=0; i<=nOutFileIndex; i++) {
Element head = outFiles.get(i).getHeadNode();
if (head!=null) {
Node styles = styleCv.exportStyles(outFiles.get(i).getContentDOM());
if (styles!=null) {
head.appendChild(styles);
}
}
}
}
// Load MathJax
// TODO: Should we support different configurations of MathJax?
if ((nType==XhtmlDocument.HTML5 || nType==XhtmlDocument.XHTML_MATHML) && config.useMathJax()) {
for (int i=0; i<=nOutFileIndex; i++) {
if (outFiles.get(i).hasMath()) {
XhtmlDocument doc = outFiles.get(i);
Element head = doc.getHeadNode();
if (head!=null) {
Element script = doc.getContentDOM().createElement("script");
head.appendChild(script);
script.setAttribute("type", "text/javascript");
script.setAttribute("src", "http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML");
}
}
}
}
// Create headers & footers (if nodes are available)
if (ofr.isSpreadsheet()) {
for (int i=0; i<=nOutFileIndex; i++) {
XhtmlDocument doc = outFiles.get(i);
Document dom = doc.getContentDOM();
Element header = doc.getHeaderNode();
Element footer = doc.getFooterNode();
Element headerPar = dom.createElement("p");
Element footerPar = dom.createElement("p");
footerPar.setAttribute("style","clear:both"); // no floats may pass!
// Add uplink
if (config.getXhtmlUplink().length()>0) {
Element a = dom.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(dom.createTextNode(l10n.get(L10n.UP)));
headerPar.appendChild(a);
headerPar.appendChild(dom.createTextNode(" "));
a = dom.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(dom.createTextNode(l10n.get(L10n.UP)));
footerPar.appendChild(a);
footerPar.appendChild(dom.createTextNode(" "));
}
// Add links to all sheets:
int nSheets = tableCv.sheetNames.size();
for (int j=0; j0) {
for (int i=0; i<=nOutFileIndex; i++) {
XhtmlDocument doc = outFiles.get(i);
Document dom = doc.getContentDOM();
//Element content = doc.getContentNode();
// Header links
Element header = doc.getHeaderNode();
if (header!=null) {
if (ofr.isPresentation()) {
// Absolute placement in presentations (quick and dirty solution)
header.setAttribute("style","position:absolute;top:0;left:0");
}
if (config.getXhtmlUplink().length()>0) {
Element a = dom.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(dom.createTextNode(l10n.get(L10n.UP)));
header.appendChild(a);
header.appendChild(dom.createTextNode(" "));
}
addNavigationLink(dom,header,l10n.get(L10n.FIRST),0);
addNavigationLink(dom,header,l10n.get(L10n.PREVIOUS),i-1);
addNavigationLink(dom,header,l10n.get(L10n.NEXT),i+1);
addNavigationLink(dom,header,l10n.get(L10n.LAST),nOutFileIndex);
if (textCv.getTocIndex()>=0) {
addNavigationLink(dom,header,l10n.get(L10n.CONTENTS),textCv.getTocIndex());
}
if (textCv.getAlphabeticalIndex()>=0) {
addNavigationLink(dom,header,l10n.get(L10n.INDEX),textCv.getAlphabeticalIndex());
}
}
// Footer links
Element footer = doc.getFooterNode();
if (footer!=null && !ofr.isPresentation()) {
// No footer in presentations
if (config.getXhtmlUplink().length()>0) {
Element a = dom.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(dom.createTextNode(l10n.get(L10n.UP)));
footer.appendChild(a);
footer.appendChild(dom.createTextNode(" "));
}
addNavigationLink(dom,footer,l10n.get(L10n.FIRST),0);
addNavigationLink(dom,footer,l10n.get(L10n.PREVIOUS),i-1);
addNavigationLink(dom,footer,l10n.get(L10n.NEXT),i+1);
addNavigationLink(dom,footer,l10n.get(L10n.LAST),nOutFileIndex);
if (textCv.getTocIndex()>=0) {
addNavigationLink(dom,footer,l10n.get(L10n.CONTENTS),textCv.getTocIndex());
}
if (textCv.getAlphabeticalIndex()>=0) {
addNavigationLink(dom,footer,l10n.get(L10n.INDEX),textCv.getAlphabeticalIndex());
}
}
}
}
else if (config.getXhtmlUplink().length()>0) {
for (int i=0; i<=nOutFileIndex; i++) {
XhtmlDocument doc = outFiles.get(i);
Document dom = doc.getContentDOM();
//Element content = doc.getContentNode();
Element header = doc.getHeaderNode();
if (header!=null) {
Element a = dom.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(dom.createTextNode(l10n.get(L10n.UP)));
header.appendChild(a);
header.appendChild(dom.createTextNode(" "));
}
Element footer = doc.getFooterNode();
if (footer!=null) {
Element a = dom.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(dom.createTextNode(l10n.get(L10n.UP)));
footer.appendChild(a);
footer.appendChild(dom.createTextNode(" "));
}
}
}
// Export styles
if (config.xhtmlFormatting()>XhtmlConfig.IGNORE_STYLES) {
if (isOPS()) { // EPUB
CssDocument cssDoc = new CssDocument(EPUB_STYLESHEET);
cssDoc.read(styleCv.exportStyles(false));
converterResult.addDocument(cssDoc);
}
else if (config.separateStylesheet()) { // XHTML
CssDocument cssDoc = new CssDocument(sTargetFileName+"-styles.css");
cssDoc.read(styleCv.exportStyles(false));
converterResult.addDocument(cssDoc);
}
}
}
private void addNavigationLink(Document dom, Node node, String s, int nIndex) {
if (nIndex>=0 && nIndex<=nOutFileIndex) {
Element a = dom.createElement("a");
a.setAttribute("href",Misc.makeHref(getOutFileName(nIndex,true)));
a.appendChild(dom.createTextNode(s));
//node.appendChild(dom.createTextNode("["));
node.appendChild(a);
node.appendChild(dom.createTextNode(" "));
//node.appendChild(dom.createTextNode("] "));
}
else {
Element span = dom.createElement("span");
span.setAttribute("class","nolink");
node.appendChild(span);
span.appendChild(dom.createTextNode(s));
node.appendChild(dom.createTextNode(" "));
//node.appendChild(dom.createTextNode("["+s+"] "));
}
}
private void addInternalNavigationLink(Document dom, Node node, String s, String sLink) {
Element a = dom.createElement("a");
a.setAttribute("href","#"+sLink);
a.appendChild(dom.createTextNode(s));
//node.appendChild(dom.createTextNode("["));
node.appendChild(a);
node.appendChild(dom.createTextNode(" "));
//node.appendChild(dom.createTextNode("] "));
}
/* get inline text, ignoring any draw objects, footnotes, formatting and hyperlinks */
protected String getPlainInlineText(Node node) {
StringBuilder buf = new StringBuilder();
Node child = node.getFirstChild();
while (child!=null) {
short nodeType = child.getNodeType();
switch (nodeType) {
case Node.TEXT_NODE:
buf.append(child.getNodeValue());
break;
case Node.ELEMENT_NODE:
String sName = child.getNodeName();
if (sName.equals(XMLString.TEXT_S)) {
buf.append(" ");
}
else if (sName.equals(XMLString.TEXT_LINE_BREAK) || sName.equals(XMLString.TEXT_TAB_STOP) || sName.equals(XMLString.TEXT_TAB)) { // text:tab in oasis
buf.append(" ");
}
else if (OfficeReader.isNoteElement(child)) {
// ignore
}
else if (OfficeReader.isTextElement(child)) {
buf.append(getPlainInlineText(child));
}
break;
default:
// Do nothing
}
child = child.getNextSibling();
}
return buf.toString();
}
public void handleOfficeAnnotation(Node onode, Node hnode) {
if (config.xhtmlNotes()) {
// Extract the text from the paragraphs, separate paragraphs with newline
StringBuilder buf = new StringBuilder();
Element creator = null;
Element date = null;
Node child = onode.getFirstChild();
while (child!=null) {
if (Misc.isElement(child, XMLString.TEXT_P)) {
if (buf.length()>0) { buf.append('\n'); }
buf.append(getPlainInlineText(child));
}
else if (Misc.isElement(child, XMLString.DC_CREATOR)) {
creator = (Element) child;
}
else if (Misc.isElement(child, XMLString.DC_DATE)) {
date = (Element) child;
}
child = child.getNextSibling();
}
if (creator!=null) {
if (buf.length()>0) { buf.append('\n'); }
buf.append(getPlainInlineText(creator));
}
if (date!=null) {
if (buf.length()>0) { buf.append('\n'); }
buf.append(Misc.formatDate(OfficeReader.getTextContent(date), l10n.getLocale().getLanguage(), l10n.getLocale().getCountry()));
}
Node commentNode = htmlDOM.createComment(buf.toString());
hnode.appendChild(commentNode);
}
}
/////////////////////////////////////////////////////////////////////////
// UTILITY METHODS
// Create output file name (docname.html, docname1.html, docname2.html etc.)
public String getOutFileName(int nIndex, boolean bWithExt) {
return sTargetFileName + (nIndex>0 ? Integer.toString(nIndex) : "")
+ (bWithExt ? htmlDoc.getFileExtension() : "");
}
// Return true if the current outfile has a non-empty body
public boolean outFileHasContent() {
return htmlDoc.getContentNode().hasChildNodes();
}
// Use another document. TODO: This is very ugly; clean it up!!!
public void changeOutFile(int nIndex) {
nOutFileIndex = nIndex;
htmlDoc = outFiles.get(nIndex);
htmlDOM = htmlDoc.getContentDOM();
}
public Element getPanelNode() {
return htmlDoc.getPanelNode();
}
// Prepare next output file
public Element nextOutFile() {
htmlDoc = new XhtmlDocument(getOutFileName(++nOutFileIndex,false),nType);
htmlDoc.setConfig(config);
if (template!=null) { htmlDoc.readFromTemplate(template); }
else if (bNeedHeaderFooter) { htmlDoc.createHeaderFooter(); }
outFiles.add(nOutFileIndex,htmlDoc);
converterResult.addDocument(htmlDoc);
// Create head + body
htmlDOM = htmlDoc.getContentDOM();
Element rootElement = htmlDOM.getDocumentElement();
styleCv.applyDefaultLanguage(rootElement);
rootElement.insertBefore(htmlDOM.createComment(
"This file was converted to xhtml by "
+ (ofr.isText() ? "Writer" : (ofr.isSpreadsheet() ? "Calc" : "Impress"))
+ "2xhtml ver. " + ConverterFactory.getVersion() +
". See http://writer2latex.sourceforge.net for more info."),
rootElement.getFirstChild());
// Apply default writing direction
if (!ofr.isPresentation()) {
StyleInfo pageInfo = new StyleInfo();
styleCv.getPageSc().applyDefaultWritingDirection(pageInfo);
styleCv.getPageSc().applyStyle(pageInfo,htmlDoc.getContentNode());
}
// Add title (required by xhtml)
Element title = htmlDoc.getTitleNode();
if (title!=null) {
String sTitle = metaData.getTitle();
if (sTitle==null) { // use filename as fallback
sTitle = htmlDoc.getFileName();
}
title.appendChild( htmlDOM.createTextNode(sTitle) );
}
Element head = htmlDoc.getHeadNode();
if (head!=null) {
// Declare charset (we need this for XHTML 1.0 strict and HTML5 because we have no )
if (nType==XhtmlDocument.XHTML10) {
Element meta = htmlDOM.createElement("meta");
meta.setAttribute("http-equiv","Content-Type");
meta.setAttribute("content","text/html; charset="+htmlDoc.getEncoding().toLowerCase());
head.appendChild(meta);
}
else if (nType==XhtmlDocument.HTML5) {
// The encoding should be UTF-8, but we still respect the user's setting
Element meta = htmlDOM.createElement("meta");
meta.setAttribute("charset",htmlDoc.getEncoding().toUpperCase());
head.appendChild(meta);
}
// Add meta data (for EPUB the meta data belongs to the .opf file)
if (!bOPS) {
// "Traditional" meta data
//createMeta("generator","Writer2LaTeX "+Misc.VERSION);
createMeta(head,"description",metaData.getDescription());
createMeta(head,"keywords",metaData.getKeywords());
// Dublin core meta data (optional)
// Format as recommended on dublincore.org (http://dublincore.org/documents/dc-html/)
// Declare meta data profile
if (config.xhtmlUseDublinCore()) {
head.setAttribute("profile","http://dublincore.org/documents/2008/08/04/dc-html/");
// Add link to declare namespace
Element dclink = htmlDOM.createElement("link");
dclink.setAttribute("rel","schema.DC");
dclink.setAttribute("href","http://purl.org/dc/elements/1.1/");
head.appendChild(dclink);
// Insert the actual meta data
createMeta(head,"DC.title",metaData.getTitle());
// DC.subject actually contains subject+keywords, so we merge them
String sDCSubject = "";
if (metaData.getSubject()!=null && metaData.getSubject().length()>0) {
sDCSubject = metaData.getSubject();
}
if (metaData.getKeywords()!=null && metaData.getKeywords().length()>0) {
if (sDCSubject.length()>0) { sDCSubject+=", "; }
sDCSubject += metaData.getKeywords();
}
createMeta(head,"DC.subject",sDCSubject);
createMeta(head,"DC.description",metaData.getDescription());
createMeta(head,"DC.creator",metaData.getCreator());
createMeta(head,"DC.date",metaData.getDate());
createMeta(head,"DC.language",metaData.getLanguage());
}
}
// Add link to custom stylesheet, if producing normal XHTML
if (!bOPS && config.xhtmlCustomStylesheet().length()>0) {
Element htmlStyle = htmlDOM.createElement("link");
htmlStyle.setAttribute("rel","stylesheet");
htmlStyle.setAttribute("type","text/css");
htmlStyle.setAttribute("media","all");
htmlStyle.setAttribute("href",config.xhtmlCustomStylesheet());
head.appendChild(htmlStyle);
}
// Add link to generated stylesheet if producing normal XHTML and the user wants separate css
if (!bOPS && config.separateStylesheet() && config.xhtmlFormatting()>XhtmlConfig.IGNORE_STYLES) {
Element htmlStyle = htmlDOM.createElement("link");
htmlStyle.setAttribute("rel","stylesheet");
htmlStyle.setAttribute("type","text/css");
htmlStyle.setAttribute("media","all");
htmlStyle.setAttribute("href",sTargetFileName+"-styles.css");
head.appendChild(htmlStyle);
}
// Add link to included style sheet if producing OPS content
if (bOPS && styleSheet!=null) {
Element sty = htmlDOM.createElement("link");
sty.setAttribute("rel", "stylesheet");
sty.setAttribute("type", "text/css");
sty.setAttribute("href", EPUB_CUSTOM_STYLESHEET);
head.appendChild(sty);
}
// Add link to generated stylesheet if producing OPS content
if (isOPS() && config.xhtmlFormatting()>XhtmlConfig.IGNORE_STYLES) {
Element htmlStyle = htmlDOM.createElement("link");
htmlStyle.setAttribute("rel","stylesheet");
htmlStyle.setAttribute("type","text/css");
htmlStyle.setAttribute("href",EPUB_STYLESHEET);
head.appendChild(htmlStyle);
}
}
// Recreate nested sections, if any
if (!textCv.sections.isEmpty()) {
Iterator iter = textCv.sections.iterator();
while (iter.hasNext()) {
Element section = (Element) iter.next();
String sStyleName = Misc.getAttribute(section,XMLString.TEXT_STYLE_NAME);
Element div = htmlDOM.createElement("div");
htmlDoc.getContentNode().appendChild(div);
htmlDoc.setContentNode(div);
StyleInfo sectionInfo = new StyleInfo();
styleCv.getSectionSc().applyStyle(sStyleName,sectionInfo);
styleCv.getSectionSc().applyStyle(sectionInfo,div);
}
}
return htmlDoc.getContentNode();
}
// create a target
public Element createTarget(String sId) {
Element a = htmlDOM.createElement("a");
a.setAttribute("id",targetNames.getExportName(sId));
targets.put(sId, new Integer(nOutFileIndex));
return a;
}
// put a target id on an existing element
public void addTarget(Element node,String sId) {
node.setAttribute("id",targetNames.getExportName(sId));
targets.put(sId, new Integer(nOutFileIndex));
}
// create an internal link
public Element createLink(String sId) {
Element a = htmlDOM.createElement("a");
LinkDescriptor ld = new LinkDescriptor();
ld.element = a; ld.sId = sId; ld.nIndex = nOutFileIndex;
links.add(ld);
return a;
}
// create a link
public Element createLink(Element onode) {
// First create the anchor
String sHref = onode.getAttribute(XMLString.XLINK_HREF);
Element anchor;
if (sHref.startsWith("#")) { // internal link
anchor = createLink(sHref.substring(1));
}
else { // external link
anchor = htmlDOM.createElement("a");
sHref = ofr.fixRelativeLink(sHref);
// Workaround for an OOo problem:
if (sHref.indexOf("?")==-1) { // No question mark
int n3F=sHref.indexOf("%3F");
if (n3F>0) { // encoded question mark
sHref = sHref.substring(0,n3F)+"?"+sHref.substring(n3F+3);
}
}
anchor.setAttribute("href",sHref);
String sName = Misc.getAttribute(onode,XMLString.OFFICE_NAME);
if (sName!=null) {
// The name attribute is rarely use (usually the user will insert a bookmark)
// Hence we (mis)use it to set additional attributes that are not supported by OOo
if (sName.indexOf(";")==-1 && sName.indexOf("=")==-1) {
// Simple case, use the value to set name and title
anchor.setAttribute("name",sName);
anchor.setAttribute("title",sName);
}
else {
// Complex case - using the syntax: name=value;name=value;...
String[] sElements = sName.split(";");
for (String sElement : sElements) {
String[] sNameVal = sElement.split("=");
if (sNameVal.length>=2) {
anchor.setAttribute(sNameVal[0].trim(),sNameVal[1].trim());
}
}
}
}
// TODO: target has been deprecated in xhtml 1.0 strict
String sTarget = Misc.getAttribute(onode,XMLString.OFFICE_TARGET_FRAME_NAME);
if (sTarget!=null) { anchor.setAttribute("target",sTarget); }
}
// Then style it
String sStyleName = onode.getAttribute(XMLString.TEXT_STYLE_NAME);
String sVisitedStyleName = onode.getAttribute(XMLString.TEXT_VISITED_STYLE_NAME);
StyleInfo anchorInfo = new StyleInfo();
styleCv.getTextSc().applyAnchorStyle(sStyleName,sVisitedStyleName,anchorInfo);
styleCv.getTextSc().applyStyle(anchorInfo,anchor);
return anchor;
}
private void createMeta(Element head, String sName, String sValue) {
if (sValue==null) { return; }
Element meta = htmlDOM.createElement("meta");
meta.setAttribute("name",sName);
meta.setAttribute("content",sValue);
head.appendChild(meta);
}
} writer2latex-1.4/source/java/writer2latex/xhtml/ResourceDocument.java 0000644 0001750 0001750 00000004075 11506322720 024624 0 ustar rene rene /************************************************************************
*
* ResourceDocument.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 (2010-12-21)
*
*/
package writer2latex.xhtml;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import writer2latex.api.OutputFile;
import writer2latex.util.Misc;
/**
* An implementation of OutputFile for resource documents.
* (A resource document is an arbitrary binary file to include in the converter result)
*/
public class ResourceDocument implements OutputFile {
// Content
private String sFileName;
private String sMediaType;
private byte[] content;
/**
* Constructor (creates an empty document)
* @param sFileName Document name.
* @param sMediaType the media type
*/
public ResourceDocument(String sFileName, String sMediaType) {
this.sFileName = sFileName;
this.sMediaType = sMediaType;
content = new byte[0];
}
public String getFileName() {
return sFileName;
}
public String getMIMEType() {
return sMediaType;
}
public boolean isMasterDocument() {
return false;
}
public void write(OutputStream os) throws IOException {
os.write(content);
}
public void read(InputStream is) throws IOException {
content = Misc.inputStreamToByteArray(is);
}
} writer2latex-1.4/source/java/writer2latex/xhtml/Html5Converter.java 0000644 0001750 0001750 00000002037 11736036010 024212 0 ustar rene rene /************************************************************************
*
* Html5Converter.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-2012 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.4 (2012-03-28)
*
*/
package writer2latex.xhtml;
public class Html5Converter extends Converter {
public Html5Converter() {
super(XhtmlDocument.HTML5);
}
} writer2latex-1.4/source/java/writer2latex/xhtml/XhtmlFormatOption.java 0000644 0001750 0001750 00000002741 11147474702 025003 0 ustar rene rene /************************************************************************
*
* XhtmlFormatOption.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-09-08)
*
*/
package writer2latex.xhtml;
import writer2latex.base.IntegerOption;
class XhtmlFormatOption extends IntegerOption {
public XhtmlFormatOption(String sName, String sDefaultValue) {
super(sName,sDefaultValue);
}
public void setString(String sValue) {
super.setString(sValue);
if ("ignore_styles".equals(sValue)) nValue = XhtmlConfig.IGNORE_STYLES;
else if ("ignore_hard".equals(sValue)) nValue = XhtmlConfig.IGNORE_HARD;
else if ("ignore_all".equals(sValue)) nValue = XhtmlConfig.IGNORE_ALL;
else nValue = XhtmlConfig.CONVERT_ALL;
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/ParStyleConverter.java 0000644 0001750 0001750 00000015157 11374171551 025003 0 ustar rene rene /************************************************************************
*
* ParStyleConverter.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 (2010-05-13)
*
*/
package writer2latex.xhtml;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
/*
TODO: drop caps (contained in a child of the style:properties element)
The CSS attributes should be applied to the :first-letter
pseudo-element or to an additional inline element.
*/
/**
* This class converts OpenDocument paragraph styles to CSS2 styles for
* use in ordinary paragraphs.
* This also includes conversion of paragraph properties in other styles
* (heading styles, cell styles).
*/
public class ParStyleConverter extends StyleWithPropertiesConverterHelper {
/** Create a new ParStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of XHTML to use
*/
public ParStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
this.styleMap = config.getXParStyleMap();
this.bConvertStyles = config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_HARD;
this.bConvertHard = config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_STYLES;
}
/** Get the family of paragraph styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getParStyles();
}
/** Create default tag name to represent a paragraph
* @param style to use
* @return the tag name.
*/
public String getDefaultTagName(StyleWithProperties style) {
return "p";
}
/** Convert formatting properties for a specific Par style.
* @param style the style to convert
* @param props the CSVList object to add information to
* @param bInherit true if properties should be inherited from parent style(s)
*/
public void applyProperties(StyleWithProperties style, CSVList props, boolean bInherit) {
cssPageBreak(style,props,bInherit);
getFrameSc().cssMargins(style,props,bInherit);
getFrameSc().cssBorder(style,props,bInherit);
getFrameSc().cssPadding(style,props,bInherit);
getFrameSc().cssBackgroundCommon(style,props,bInherit);
cssPar(style,props,bInherit);
getTextSc().cssTextCommon(style,props,bInherit);
}
public String getTextBackground(String sStyleName) {
CSVList props = new CSVList(";");
StyleWithProperties style = ofr.getParStyle(sStyleName);
if (style!=null) {
getTextSc().cssTextBackground(style,props,true);
}
return props.toString();
}
// TODO: get rid of this
public String getRealParStyleName(String sStyleName) {
if (sStyleName==null) { return sStyleName; }
StyleWithProperties style = ofr.getParStyle(sStyleName);
if (style==null || !style.isAutomatic()) { return sStyleName; }
return style.getParentName();
}
public void cssPageBreak(StyleWithProperties style, CSVList props, boolean bInherit) {
if ("page".equals(style.getProperty(XMLString.FO_BREAK_BEFORE, bInherit))) {
props.addValue("page-break-before", "always");
}
else if ("page".equals(style.getProperty(XMLString.FO_BREAK_AFTER, bInherit))) {
props.addValue("page-break-after", "always");
}
}
public void cssPar(StyleWithProperties style, CSVList props, boolean bInherit){
String s;
// translates paragraph style properties.
// The following properties are not supported by CSS2:
// style:justify-single-word and style:text-align-last
/* problem: 120% times normal makes no sense...
s = style.getProperty(XMLString.FO_LINE_HEIGHT);
if (s!=null && s.equals("normal")) {
props.addValue("line-height:normal;";
}
else { // length or percentage
s = style.getAbsoluteProperty(XMLString.FO_LINE_HEIGHT);
if (s!=null) { props.addValue("line-height",s); }
}
*/
// TODO: style:line-height-at-least and stype:line-spacing
// Background color fits with css (note: Paragraph property!)
s = style.getParProperty(XMLString.FO_BACKGROUND_COLOR,bInherit);
if (s!=null) { props.addValue("background-color",s); }
// Indentation: Absolute values of this property fit with css...
if (bInherit || style.getProperty(XMLString.FO_TEXT_INDENT,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_TEXT_INDENT);
if (s!=null) {
props.addValue("text-indent",scale(s));
}
else { // ... but css doesn't have this one
s = style.getProperty(XMLString.STYLE_AUTO_TEXT_INDENT);
if ("true".equals(s)) { props.addValue("text-indent","2em"); }
}
}
// Alignment: This property fit with css, but two values have different names
s = style.getProperty(XMLString.FO_TEXT_ALIGN,bInherit);
if (s!=null) { // rename two property values:
if (s.equals("start")) { s="left"; }
else if (s.equals("end")) { s="right"; }
props.addValue("text-align",s);
}
// Wrap (only in table cells, only in spreadsheets):
if (ofr.isSpreadsheet()) {
s = style.getProperty(XMLString.FO_WRAP_OPTION,bInherit);
if ("no-wrap".equals(s)) props.addValue("white-space","nowrap");
else if ("wrap".equals(s)) props.addValue("white-space","normal");
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/PresentationStyleConverter.java 0000644 0001750 0001750 00000013721 12406234417 026725 0 ustar rene rene /************************************************************************
*
* PresentationStyleConverter.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-16)
*
*/
package writer2latex.xhtml;
import java.util.Enumeration;
import java.util.Hashtable;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
//import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
import writer2latex.util.ExportNameCollection;
/**
* This class converts OpenDocument presentation styles to CSS2 styles.
* Presentation styles are special frame styles, used to style the standard
* elements in a presentation (title, subtitle and textbox)
*/
public class PresentationStyleConverter extends FrameStyleConverter {
// Data about outline styles
String sCurrentOutlineStyle = null;
Hashtable outlineStyles = new Hashtable();
ExportNameCollection outlineStyleNames = new ExportNameCollection(true);
/** Create a new PresentationStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public PresentationStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
// style maps for presentations are currently not supported:
this.styleMap = new XhtmlStyleMap();
}
/** Return a prefix to be used in generated css class names
* @return the prefix
*/
public String getClassNamePrefix() { return "prsnt"; }
/** Get the family of presentation styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getPresentationStyles();
}
/** Create default tag name to represent a presentation object
* @param style to use
* @return the tag name.
*/
public String getDefaultTagName(StyleWithProperties style) {
return "div";
}
/** Convert style information for used styles
* @param sIndent a String of spaces to add before each line
*/
public String getStyleDeclarations(String sIndent) {
if (bConvertStyles) {
StringBuilder buf = new StringBuilder();
buf.append(super.getStyleDeclarations(sIndent));
Enumeration names = outlineStyleNames.keys();
while (names.hasMoreElements()) {
String sDisplayName = names.nextElement();
StyleWithProperties style = (StyleWithProperties)
getStyles().getStyleByDisplayName(sDisplayName);
if (!style.isAutomatic()) {
// Apply style to paragraphs within a list item with this class
CSVList props = new CSVList(";");
getFrameSc().cssMargins(style,props,true);
getParSc().cssPar(style,props,true);
getTextSc().cssTextCommon(style,props,true);
if (!props.isEmpty()) {
buf.append(sIndent)
.append("li.outline")
.append(styleNames.getExportName(sDisplayName))
.append(" p {").append(props.toString()).append("}")
.append(config.prettyPrint() ? "\n" : " ");
}
}
}
return buf.toString();
}
else {
return "";
}
}
public void enterOutline(String sStyleName) {
sCurrentOutlineStyle = sStyleName;
if (!outlineStyles.containsKey(sCurrentOutlineStyle)) {
String[] sNames = new String[10];
outlineStyles.put(sCurrentOutlineStyle,sNames);
StyleWithProperties style1 = ofr.getPresentationStyle(sCurrentOutlineStyle);
if (style1!=null) {
String sCurrentOutlineStyle1 = sCurrentOutlineStyle;
if (style1.isAutomatic()) { sCurrentOutlineStyle1 = style1.getParentName(); }
sNames[1] = sCurrentOutlineStyle1;
String sBaseName = sCurrentOutlineStyle1.substring(0,sCurrentOutlineStyle1.length()-1);
for (int i=2; i<10; i++) {
String sName = sBaseName + Integer.toString(i);
StyleWithProperties style = ofr.getPresentationStyle(sName);
if (style!=null && style.getParentName().equals(sNames[i-1])) {
sNames[i] = sName;
}
else {
break;
}
}
sNames[1] = null;
}
}
}
public void exitOutline() {
sCurrentOutlineStyle = null;
}
public void applyOutlineStyle(int nLevel, StyleInfo info) {
if (2<=nLevel && nLevel<=9 && sCurrentOutlineStyle!=null) {
if (outlineStyles.containsKey(sCurrentOutlineStyle)) {
info.sClass = "outline"+outlineStyleNames.getExportName(outlineStyles.get(sCurrentOutlineStyle)[nLevel]);
}
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/StyleInfo.java 0000644 0001750 0001750 00000002407 11147474702 023260 0 ustar rene rene /************************************************************************
*
* StyleInfo.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-2007 by Henrik Just
*
* All Rights Reserved.
*
* Version 0.5 (2007-02-27)
*
*/
package writer2latex.xhtml;
import writer2latex.util.CSVList;
public class StyleInfo {
public String sTagName = null;
public String sClass = null;
public CSVList props = new CSVList(";");
public String sLang = null;
public String sDir = null;
public boolean hasAttributes() {
return !props.isEmpty() || sClass!=null || sLang!=null || sDir!=null;
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/StyleWithPropertiesConverterHelper.java 0000644 0001750 0001750 00000013450 12406234417 030401 0 ustar rene rene /************************************************************************
*
* StyleWithPropertiesConverterHelper.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-16)
*
*/
package writer2latex.xhtml;
import java.util.Enumeration;
//import java.util.Hashtable;
//import writer2latex.latex.util.Info;
import writer2latex.office.OfficeReader;
import writer2latex.office.StyleWithProperties;
import writer2latex.util.CSVList;
//import writer2latex.util.ExportNameCollection;
/**
* This is an abstract class to convert an OpenDocument style family
* represented by StyleWithProperties to CSS2 styles.
*/
public abstract class StyleWithPropertiesConverterHelper
extends StyleConverterHelper {
/** Create a new StyleWithPropertiesConverterHelper
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public StyleWithPropertiesConverterHelper(OfficeReader ofr, XhtmlConfig config,
Converter converter, int nType) {
super(ofr,config,converter,nType);
}
/** Apply a style, either by converting the style or by applying the
* style map from the configuarion
* @param sStyleName name of the OpenDocument style
* @param info the StyleInfo object to add information to
*/
public void applyStyle(String sStyleName, StyleInfo info) {
StyleWithProperties style = (StyleWithProperties) getStyles().getStyle(sStyleName);
info.sTagName = getDefaultTagName(style);
if (style!=null) {
if (config.multilingual()) { applyLang(style,info); }
applyDirection(style,info);
if (style.isAutomatic()) {
// Apply parent style + hard formatting
applyStyle(style.getParentName(),info);
if (bConvertHard) { applyProperties(style,info.props,false); }
}
else {
String sDisplayName = style.getDisplayName();
if (styleMap.contains(sDisplayName)) {
// Apply attributes as specified in style map from user
if (styleMap.getElement(sDisplayName).length()>0) {
info.sTagName = styleMap.getElement(sDisplayName);
}
if (!"(none)".equals(styleMap.getCss(sDisplayName))) {
info.sClass = styleMap.getCss(sDisplayName);
}
}
else {
// Generate class name from display name
info.sClass = getClassNamePrefix()
+ styleNames.getExportName(sDisplayName);
}
}
}
}
/** Convert style information for used styles
* @param sIndent a String of spaces to add before each line
*/
public String getStyleDeclarations(String sIndent) {
if (bConvertStyles) {
StringBuilder buf = new StringBuilder();
Enumeration names = styleNames.keys();
while (names.hasMoreElements()) {
String sDisplayName = names.nextElement();
StyleWithProperties style = (StyleWithProperties)
getStyles().getStyleByDisplayName(sDisplayName);
if (!style.isAutomatic()) {
CSVList props = new CSVList(";");
applyProperties(style,props,true);
buf.append(sIndent);
buf.append(getDefaultTagName(null));
buf.append(".");
buf.append(getClassNamePrefix());
buf.append(styleNames.getExportName(sDisplayName));
buf.append(" {");
buf.append(props.toString());
buf.append("}");
buf.append(config.prettyPrint() ? "\n" : " ");
// TODO: Create a method "getStyleDeclarationsInner"
// to be used by eg. FrameStyleConverter
}
}
return buf.toString();
}
else {
return "";
}
}
/** Return a prefix to be used in generated css class names
* @return the prefix
*/
public String getClassNamePrefix() { return ""; }
/** Create default tag name to represent a specific style, e.g.
* span (text style) or ul (unordered list)
* @param style to use
* @return the tag name. If the style is null, a default result should be
* returned.
*/
public abstract String getDefaultTagName(StyleWithProperties style);
/** Convert formatting properties for a specific style.
* @param style the style to convert
* @param props the CSVList object to add information to
* @param bInherit true if properties should be inherited from parent style(s)
*/
public abstract void applyProperties(StyleWithProperties style, CSVList props, boolean bInherit);
}
writer2latex-1.4/source/java/writer2latex/xhtml/XhtmlStyleMap.java 0000644 0001750 0001750 00000004163 11164073375 024120 0 ustar rene rene /************************************************************************
*
* XhtmlStyleMap.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-2003 by Henrik Just
*
* All Rights Reserved.
*
* Version 0.3.2 (2003-11-25)
*
*/
package writer2latex.xhtml;
import java.util.Hashtable;
import java.util.Enumeration;
public class XhtmlStyleMap {
private Hashtable blockElement = new Hashtable();
private Hashtable blockCss = new Hashtable();
private Hashtable element = new Hashtable();
private Hashtable css = new Hashtable();
public void put(String sName, String sBlockElement, String sBlockCss, String sElement, String sCss) {
blockElement.put(sName,sBlockElement);
blockCss.put(sName,sBlockCss);
element.put(sName,sElement);
css.put(sName,sCss);
}
public boolean contains(String sName) {
return sName!=null && element.containsKey(sName);
}
public String getBlockElement(String sName) {
return blockElement.get(sName);
}
public String getBlockCss(String sName) {
return blockCss.get(sName);
}
public String getElement(String sName) {
return element.get(sName);
}
public String getCss(String sName) {
return css.get(sName);
}
public Enumeration getNames() {
return element.keys();
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/ConverterHelper.java 0000644 0001750 0001750 00000006646 12372604023 024454 0 ustar rene rene /************************************************************************
*
* ConverterHelper.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-08-13)
*
*/
package writer2latex.xhtml;
import org.w3c.dom.Element;
import writer2latex.office.OfficeReader;
public class ConverterHelper {
protected OfficeReader ofr;
protected XhtmlConfig config;
protected Converter converter;
protected StyleConverter getStyleCv() { return converter.getStyleCv(); }
protected TextStyleConverter getTextSc() { return converter.getStyleCv().getTextSc(); }
protected ParStyleConverter getParSc() { return converter.getStyleCv().getParSc(); }
protected HeadingStyleConverter getHeadingSc() { return converter.getStyleCv().getHeadingSc(); }
protected ListStyleConverter getListSc() { return converter.getStyleCv().getListSc(); }
protected SectionStyleConverter getSectionSc() { return converter.getStyleCv().getSectionSc(); }
protected TableStyleConverter getTableSc() { return converter.getStyleCv().getTableSc(); }
protected RowStyleConverter getRowSc() { return converter.getStyleCv().getRowSc(); }
protected CellStyleConverter getCellSc() { return converter.getStyleCv().getCellSc(); }
protected FrameStyleConverter getFrameSc() { return converter.getStyleCv().getFrameSc(); }
protected PresentationStyleConverter getPresentationSc() { return converter.getStyleCv().getPresentationSc(); }
protected PageStyleConverter getPageSc() { return converter.getStyleCv().getPageSc(); }
protected TextConverter getTextCv() { return converter.getTextCv(); }
protected TableConverter getTableCv() { return converter.getTableCv(); }
protected DrawConverter getDrawCv() { return converter.getDrawCv(); }
protected MathConverter getMathCv() { return converter.getMathCv(); }
// TODO: Move to StyleInfo!
protected void applyStyle(StyleInfo info, Element hnode) {
if (info.sClass!=null) {
hnode.setAttribute("class",info.sClass);
}
if (!info.props.isEmpty()) {
hnode.setAttribute("style",info.props.toString());
}
if (info.sLang!=null) {
hnode.setAttribute("xml:lang",info.sLang);
if (converter.getType()==XhtmlDocument.XHTML10 || converter.getType()==XhtmlDocument.HTML5) {
hnode.setAttribute("lang",info.sLang); // HTML4 compatibility/polyglot HTML5S
}
}
if (info.sDir!=null) {
hnode.setAttribute("dir",info.sDir);
}
}
public ConverterHelper(OfficeReader ofr, XhtmlConfig config, Converter converter) {
this.ofr = ofr;
this.config = config;
this.converter = converter;
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/config/ 0000755 0001750 0001750 00000000000 12603463651 021742 5 ustar rene rene writer2latex-1.4/source/java/writer2latex/xhtml/config/cleanxhtml.xml 0000644 0001750 0001750 00000007415 11374175733 024637 0 ustar rene rene
writer2latex-1.4/source/java/writer2latex/xhtml/StyleConverter.java 0000644 0001750 0001750 00000016364 12406234417 024337 0 ustar rene rene /************************************************************************
*
* StyleConverter.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-16)
*
*/
package writer2latex.xhtml;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import writer2latex.office.*;
import writer2latex.util.*;
/**
* This class converts OpenDocument styles to CSS2 styles.
* Note that some elements in OpenDocument has attributes that also maps
* to CSS2 properties. Example: the width of a text box.
* Also note, that some OpenDocument style properties cannot be mapped to
* CSS2 without creating an additional inline element.
* The class uses one helper class per OpenDocument style family
* (paragraph, frame etc.)
*/
class StyleConverter extends ConverterHelper {
// Helpers for text styles
private TextStyleConverter textSc;
private ParStyleConverter parSc;
private HeadingStyleConverter headingSc;
private ListStyleConverter listSc;
private SectionStyleConverter sectionSc;
// Helpers for table styles
private TableStyleConverter tableSc;
private RowStyleConverter rowSc;
private CellStyleConverter cellSc;
// Helpers for drawing styles
private FrameStyleConverter frameSc;
private PresentationStyleConverter presentationSc;
// Helper for page styles
private PageStyleConverter pageSc;
/** Create a new StyleConverter
*/
public StyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter);
// Create the helpers
textSc = new TextStyleConverter(ofr,config,converter,nType);
parSc = new ParStyleConverter(ofr,config,converter,nType);
headingSc = new HeadingStyleConverter(ofr,config,converter,nType);
listSc = new ListStyleConverter(ofr,config,converter,nType);
sectionSc = new SectionStyleConverter(ofr,config,converter,nType);
tableSc = new TableStyleConverter(ofr,config,converter,nType);
rowSc = new RowStyleConverter(ofr,config,converter,nType);
cellSc = new CellStyleConverter(ofr,config,converter,nType);
frameSc = new FrameStyleConverter(ofr,config,converter,nType);
presentationSc = new PresentationStyleConverter(ofr,config,converter,nType);
pageSc = new PageStyleConverter(ofr,config,converter,nType);
}
// Accessor methods for helpers
protected TextStyleConverter getTextSc() { return textSc; }
protected ParStyleConverter getParSc() { return parSc; }
protected HeadingStyleConverter getHeadingSc() { return headingSc; }
protected ListStyleConverter getListSc() { return listSc; }
protected SectionStyleConverter getSectionSc() { return sectionSc; }
protected TableStyleConverter getTableSc() { return tableSc; }
protected RowStyleConverter getRowSc() { return rowSc; }
protected CellStyleConverter getCellSc() { return cellSc; }
protected FrameStyleConverter getFrameSc() { return frameSc; }
protected PresentationStyleConverter getPresentationSc() { return presentationSc; }
protected PageStyleConverter getPageSc() { return pageSc; }
private StyleWithProperties getDefaultStyle() {
if (ofr.isSpreadsheet()) return ofr.getDefaultCellStyle();
else if (ofr.isPresentation()) return ofr.getDefaultFrameStyle();
else return ofr.getDefaultParStyle();
}
// Apply the default language
public void applyDefaultLanguage(Element node) {
StyleWithProperties style = getDefaultStyle();
if (style!=null) {
StyleInfo info = new StyleInfo();
StyleConverterHelper.applyLang(style,info);
applyStyle(info,node);
}
}
public String exportStyles(boolean bIndent) {
String sIndent = bIndent ? " " : "";
StringBuilder buf = new StringBuilder();
// Export default style
if (config.xhtmlCustomStylesheet().length()==0 &&
(config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL ||
config.xhtmlFormatting()==XhtmlConfig.IGNORE_HARD)) {
// Default paragraph/cell/frame style is applied to the body element
StyleWithProperties defaultStyle = getDefaultStyle();
if (defaultStyle!=null) {
CSVList props = new CSVList(";");
// text properties only!
getTextSc().cssTextCommon(defaultStyle,props,true);
if (config.useDefaultFont() && config.defaultFontName().length()>0) {
props.addValue("font-family", "'"+config.defaultFontName()+"'");
}
buf.append(sIndent)
.append("body {").append(props.toString()).append("}").append(config.prettyPrint() ? "\n" : " ");
}
}
// Export declarations from helpers
// For OpenDocument documents created with OOo only some will generate content:
// Text documents: text, par, list, frame
// Spreadsheet documents: cell
// Presentation documents: frame, presentation, page
buf.append(getTextSc().getStyleDeclarations(sIndent));
buf.append(getParSc().getStyleDeclarations(sIndent));
buf.append(getHeadingSc().getStyleDeclarations(sIndent));
buf.append(getListSc().getStyleDeclarations(sIndent));
buf.append(getSectionSc().getStyleDeclarations(sIndent));
buf.append(getCellSc().getStyleDeclarations(sIndent));
buf.append(getTableSc().getStyleDeclarations(sIndent));
buf.append(getRowSc().getStyleDeclarations(sIndent));
buf.append(getFrameSc().getStyleDeclarations(sIndent));
buf.append(getPresentationSc().getStyleDeclarations(sIndent));
buf.append(getPageSc().getStyleDeclarations(sIndent));
return buf.toString();
}
// Export used styles to CSS
public Node exportStyles(Document htmlDOM) {
String sStyles = exportStyles(config.prettyPrint());
// Create node
if (sStyles.length()>0) {
Element htmlStyle = htmlDOM.createElement("style");
htmlStyle.setAttribute("media","all");
htmlStyle.setAttribute("type","text/css");
htmlStyle.appendChild(htmlDOM.createTextNode(config.prettyPrint() ? "\n" : " "));
htmlStyle.appendChild(htmlDOM.createTextNode(sStyles));
if (config.prettyPrint()) { htmlStyle.appendChild(htmlDOM.createTextNode(" ")); }
return htmlStyle;
}
else {
return null;
}
}
} writer2latex-1.4/source/java/writer2latex/xhtml/XhtmlConfig.java 0000644 0001750 0001750 00000055265 12410605107 023565 0 ustar rene rene /************************************************************************
*
* XhtmlConfig.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-23)
*
*/
package writer2latex.xhtml;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import writer2latex.api.ComplexOption;
import writer2latex.base.BooleanOption;
import writer2latex.base.IntegerOption;
import writer2latex.base.Option;
import writer2latex.util.Misc;
public class XhtmlConfig extends writer2latex.base.ConfigBase {
// Implement configuration methods
protected int getOptionCount() { return 56; }
protected String getDefaultConfigPath() { return "/writer2latex/xhtml/config/"; }
// Override setOption: To be backwards compatible, we must accept options
// with the prefix xhtml_
public void setOption(String sName,String sValue) {
if (sName.startsWith("xhtml_")) { sName = sName.substring(6); }
// this option has been renamed:
if (sName.equals("keep_image_size")) { sName = "original_image_size"; }
// and later renamed and extended:
if (sName.equals("original_image_size")) {
sName = "image_size";
if (sValue.equals("true")) { sValue = "none"; }
else { sValue="absolute"; }
}
// this option has been renamed and extended:
if (sName.equals("use_list_hack")) {
sName = "list_formatting";
if (sValue.equals("true")) { sValue = "css1_hack"; }
else { sValue = "css1"; }
}
// this option has been renamed and extended
if (sName.equals("ignore_table_dimensions")) {
sName = "table_size";
if (sValue.equals("true")) { sValue="none"; }
else { sValue="absolute"; }
}
super.setOption(sName, sValue);
}
// Formatting
public static final int IGNORE_ALL = 0;
public static final int IGNORE_STYLES = 1;
public static final int IGNORE_HARD = 2;
public static final int CONVERT_ALL = 3;
// List formatting
public static final int CSS1 = 0;
public static final int CSS1_HACK = 1;
public static final int HARD_LABELS = 2;
// Image and table dimensions
public static final int NONE = 0;
public static final int ABSOLUTE = 1;
public static final int RELATIVE = 2;
// Formulas (for XHTML 1.0 strict)
public static final int STARMATH = 0;
public static final int LATEX = 1;
public static final int IMAGE_STARMATH = 2;
public static final int IMAGE_LATEX = 3;
// Page breaks
// public static final int NONE = 0;
public static final int STYLES = 1;
public static final int EXPLICIT = 2;
public static final int ALL = 3;
// Options
private static final int IGNORE_HARD_LINE_BREAKS = 0;
private static final int IGNORE_EMPTY_PARAGRAPHS = 1;
private static final int IGNORE_DOUBLE_SPACES = 2;
private static final int IMAGE_SIZE = 3;
private static final int NO_DOCTYPE = 4;
private static final int ADD_BOM = 5;
private static final int ENCODING = 6;
private static final int USE_NAMED_ENTITIES = 7;
private static final int HEXADECIMAL_ENTITIES = 8;
private static final int PRETTY_PRINT = 9;
private static final int MULTILINGUAL = 10;
private static final int TEMPLATE_IDS = 11;
private static final int SEPARATE_STYLESHEET = 12;
private static final int CUSTOM_STYLESHEET = 13;
private static final int FORMATTING = 14;
private static final int FRAME_FORMATTING = 15;
private static final int SECTION_FORMATTING = 16;
private static final int TABLE_FORMATTING = 17;
private static final int TABLE_SIZE = 18;
private static final int LIST_FORMATTING = 19;
private static final int USE_DEFAULT_FONT = 20;
private static final int DEFAULT_FONT_NAME = 21;
private static final int USE_DUBLIN_CORE = 22;
private static final int NOTES = 23;
private static final int DISPLAY_HIDDEN_TEXT = 24;
private static final int CONVERT_TO_PX = 25;
private static final int SCALING = 26;
private static final int COLUMN_SCALING = 27;
private static final int RELATIVE_FONT_SIZE = 28;
private static final int FONT_SCALING = 29;
private static final int FLOAT_OBJECTS = 30;
private static final int TABSTOP_STYLE = 31;
private static final int FORMULAS = 32;
private static final int ENDNOTES_HEADING = 33;
private static final int FOOTNOTES_HEADING = 34;
private static final int EXTERNAL_TOC_DEPTH = 35;
private static final int INCLUDE_TOC = 36;
private static final int SPLIT_LEVEL = 37;
private static final int REPEAT_LEVELS = 38;
private static final int PAGE_BREAK_SPLIT = 39;
private static final int SPLIT_AFTER = 40;
private static final int IMAGE_SPLIT = 41;
private static final int COVER_IMAGE = 42;
private static final int EMBED_SVG = 43;
private static final int USE_MATHJAX = 44;
private static final int CALC_SPLIT = 45;
private static final int DISPLAY_HIDDEN_SHEETS = 46;
private static final int DISPLAY_HIDDEN_ROWS_COLS = 47;
private static final int DISPLAY_FILTERED_ROWS_COLS = 48;
private static final int APPLY_PRINT_RANGES = 49;
private static final int USE_TITLE_AS_HEADING = 50;
private static final int USE_SHEET_NAMES_AS_HEADINGS = 51;
private static final int SAVE_IMAGES_IN_SUBDIR = 52;
private static final int UPLINK = 53;
private static final int DIRECTORY_ICON = 54;
private static final int DOCUMENT_ICON = 55;
protected ComplexOption xheading = addComplexOption("heading-map");
protected ComplexOption xpar = addComplexOption("paragraph-map");
protected ComplexOption xtext = addComplexOption("text-map");
protected ComplexOption xframe = addComplexOption("frame-map");
protected ComplexOption xlist = addComplexOption("list-map");
protected ComplexOption xattr = addComplexOption("text-attribute-map");
public XhtmlConfig() {
super();
// create options with default values
options[IGNORE_HARD_LINE_BREAKS] = new BooleanOption("ignore_hard_line_breaks","false");
options[IGNORE_EMPTY_PARAGRAPHS] = new BooleanOption("ignore_empty_paragraphs","false");
options[IGNORE_DOUBLE_SPACES] = new BooleanOption("ignore_double_spaces","false");
options[IMAGE_SIZE] = new IntegerOption("image_size","auto") {
@Override public void setString(String sValue) {
super.setString(sValue);
if ("relative".equals(sValue)) { nValue = RELATIVE; }
else if ("none".equals(sValue)) { nValue = NONE; }
else if ("original_image_size".equals(sValue)) { nValue = NONE; }
else { nValue = ABSOLUTE; }
}
};
options[NO_DOCTYPE] = new BooleanOption("no_doctype","false");
options[ADD_BOM] = new BooleanOption("add_bom","false");
options[ENCODING] = new Option("encoding","UTF-8");
options[USE_NAMED_ENTITIES] = new BooleanOption("use_named_entities","false");
options[HEXADECIMAL_ENTITIES] = new BooleanOption("hexadecimal_entities","true");
options[PRETTY_PRINT] = new BooleanOption("pretty_print","true");
options[MULTILINGUAL] = new BooleanOption("multilingual","true");
options[TEMPLATE_IDS] = new Option("template_ids","");
options[SEPARATE_STYLESHEET] = new BooleanOption("separate_stylesheet","false");
options[CUSTOM_STYLESHEET] = new Option("custom_stylesheet","");
options[FORMATTING] = new XhtmlFormatOption("formatting","convert_all");
options[FRAME_FORMATTING] = new XhtmlFormatOption("frame_formatting","convert_all");
options[SECTION_FORMATTING] = new XhtmlFormatOption("section_formatting","convert_all");
options[TABLE_FORMATTING] = new XhtmlFormatOption("table_formatting","convert_all");
options[TABLE_SIZE] = new IntegerOption("table_size","auto") {
@Override public void setString(String sValue) {
super.setString(sValue);
if ("relative".equals(sValue)) { nValue = RELATIVE; }
else if ("none".equals(sValue)) { nValue = NONE; }
else { nValue = ABSOLUTE; }
}
};
options[LIST_FORMATTING] = new IntegerOption("list_formatting","css1") {
@Override public void setString(String sValue) {
super.setString(sValue);
if ("css1_hack".equals(sValue)) { nValue = CSS1_HACK; }
else if ("hard_labels".equals(sValue)) { nValue = HARD_LABELS; }
else { nValue = CSS1; }
}
};
options[USE_DEFAULT_FONT] = new BooleanOption("use_default_font","false");
options[DEFAULT_FONT_NAME] = new BooleanOption("default_font_name","");
options[USE_DUBLIN_CORE] = new BooleanOption("use_dublin_core","true");
options[NOTES] = new BooleanOption("notes","true");
options[DISPLAY_HIDDEN_TEXT] = new BooleanOption("display_hidden_text", "false");
options[CONVERT_TO_PX] = new BooleanOption("convert_to_px","true");
options[SCALING] = new Option("scaling","100%");
options[COLUMN_SCALING] = new Option("column_scaling","100%");
options[RELATIVE_FONT_SIZE] = new BooleanOption("relative_font_size","false");
options[FONT_SCALING] = new Option("font_scaling","100%");
options[FLOAT_OBJECTS] = new BooleanOption("float_objects","true");
options[TABSTOP_STYLE] = new Option("tabstop_style","");
options[ENDNOTES_HEADING] = new Option("endnotes_heading","");
options[FOOTNOTES_HEADING] = new Option("footnotes_heading","");
options[FORMULAS] = new IntegerOption("formulas","image+starmath") {
@Override public void setString(String sValue) {
super.setString(sValue);
if ("latex".equals(sValue)) { nValue = LATEX; }
else if ("image+latex".equals(sValue)) { nValue = IMAGE_LATEX; }
else if ("starmath".equals(sValue)) { nValue = STARMATH; }
else { nValue = IMAGE_STARMATH; }
}
};
options[EXTERNAL_TOC_DEPTH] = new IntegerOption("external_toc_depth","auto") {
@Override public void setString(String sValue) {
super.setString(sValue);
if ("auto".equals(sValue)) {
nValue = 0;
}
else {
nValue = Misc.getPosInteger(sValue,1);
}
}
};
options[INCLUDE_TOC] = new BooleanOption("include_toc","true");
options[SPLIT_LEVEL] = new IntegerOption("split_level","0") {
@Override public void setString(String sValue) {
super.setString(sValue);
nValue = Misc.getPosInteger(sValue,0);
}
};
options[REPEAT_LEVELS] = new IntegerOption("repeat_levels","5") {
@Override public void setString(String sValue) {
super.setString(sValue);
nValue = Misc.getPosInteger(sValue,0);
}
};
options[PAGE_BREAK_SPLIT] = new IntegerOption("page_break_split", "none") {
@Override public void setString(String sValue) {
super.setString(sValue);
if ("styles".equals(sValue)) { nValue = STYLES; }
else if ("explicit".equals(sValue)) { nValue = EXPLICIT; }
else if ("all".equals(sValue)) { nValue = ALL; }
else { nValue = NONE; }
}
};
options[SPLIT_AFTER] = new IntegerOption("split_after","0") {
@Override public void setString(String sValue) {
super.setString(sValue);
nValue = Misc.getPosInteger(sValue, 0);
}
};
options[IMAGE_SPLIT] = new Option("image_split","none");
options[COVER_IMAGE] = new BooleanOption("cover_image","false");
options[EMBED_SVG] = new BooleanOption("embed_svg","false");
options[USE_MATHJAX] = new BooleanOption("use_mathjax","false");
options[CALC_SPLIT] = new BooleanOption("calc_split","false");
options[DISPLAY_HIDDEN_SHEETS] = new BooleanOption("display_hidden_sheets", "false");
options[DISPLAY_HIDDEN_ROWS_COLS] = new BooleanOption("display_hidden_rows_cols","false");
options[DISPLAY_FILTERED_ROWS_COLS] = new BooleanOption("display_filtered_rows_cols","false");
options[APPLY_PRINT_RANGES] = new BooleanOption("apply_print_ranges","false");
options[USE_TITLE_AS_HEADING] = new BooleanOption("use_title_as_heading","true");
options[USE_SHEET_NAMES_AS_HEADINGS] = new BooleanOption("use_sheet_names_as_headings","true");
options[SAVE_IMAGES_IN_SUBDIR] = new BooleanOption("save_images_in_subdir","false");
options[UPLINK] = new Option("uplink","");
options[DIRECTORY_ICON] = new Option("directory_icon","");
options[DOCUMENT_ICON] = new Option("document_icon","");
}
protected void readInner(Element elm) {
if (elm.getTagName().equals("xhtml-style-map")) {
String sName = elm.getAttribute("name");
String sFamily = elm.getAttribute("family");
if (sFamily.length()==0) { // try old name
sFamily = elm.getAttribute("class");
}
String sElement = elm.getAttribute("element");
String sCss = elm.getAttribute("css");
if (sCss.length()==0) { sCss="(none)"; }
Map attr = new HashMap();
attr.put("element", sElement);
attr.put("css", sCss);
String sBlockElement = elm.getAttribute("block-element");
String sBlockCss = elm.getAttribute("block-css");
if (sBlockCss.length()==0) { sBlockCss="(none)"; }
if ("heading".equals(sFamily)) {
attr.put("block-element", sBlockElement);
attr.put("block-css", sBlockCss);
xheading.put(sName,attr);
}
if ("paragraph".equals(sFamily)) {
attr.put("block-element", sBlockElement);
attr.put("block-css", sBlockCss);
xpar.put(sName,attr);
}
else if ("text".equals(sFamily)) {
xtext.put(sName,attr);
}
else if ("frame".equals(sFamily)) {
xframe.put(sName,attr);
}
else if ("list".equals(sFamily)) {
xlist.put(sName,attr);
}
else if ("attribute".equals(sFamily)) {
xattr.put(sName,attr);
}
}
}
protected void writeInner(Document dom) {
writeXStyleMap(dom,xheading,"heading");
writeXStyleMap(dom,xpar,"paragraph");
writeXStyleMap(dom,xtext,"text");
writeXStyleMap(dom,xlist,"list");
writeXStyleMap(dom,xframe,"frame");
writeXStyleMap(dom,xattr,"attribute");
}
private void writeXStyleMap(Document dom, ComplexOption option, String sFamily) {
Iterator iter = option.keySet().iterator();
while (iter.hasNext()) {
String sName = iter.next();
Element smNode = dom.createElement("xhtml-style-map");
smNode.setAttribute("name",sName);
smNode.setAttribute("family",sFamily);
Map attr = option.get(sName);
smNode.setAttribute("element",attr.get("element"));
smNode.setAttribute("css",attr.get("css"));
if (attr.containsKey("block-element")) smNode.setAttribute("block-element",attr.get("block-element"));
if (attr.containsKey("block-css")) smNode.setAttribute("block-css",attr.get("block-css"));
dom.getDocumentElement().appendChild(smNode);
}
}
// Convenience accessor methods
public boolean ignoreHardLineBreaks() { return ((BooleanOption) options[IGNORE_HARD_LINE_BREAKS]).getValue(); }
public boolean ignoreEmptyParagraphs() { return ((BooleanOption) options[IGNORE_EMPTY_PARAGRAPHS]).getValue(); }
public boolean ignoreDoubleSpaces() { return ((BooleanOption) options[IGNORE_DOUBLE_SPACES]).getValue(); }
public int imageSize() { return ((IntegerOption) options[IMAGE_SIZE]).getValue(); }
public boolean xhtmlNoDoctype() { return ((BooleanOption) options[NO_DOCTYPE]).getValue(); }
public boolean xhtmlAddBOM() { return ((BooleanOption) options[ADD_BOM]).getValue(); }
public String xhtmlEncoding() { return options[ENCODING].getString(); }
public boolean useNamedEntities() { return ((BooleanOption) options[USE_NAMED_ENTITIES]).getValue(); }
public boolean hexadecimalEntities() { return ((BooleanOption) options[HEXADECIMAL_ENTITIES]).getValue(); }
public boolean prettyPrint() { return ((BooleanOption) options[PRETTY_PRINT]).getValue(); }
public boolean multilingual() { return ((BooleanOption) options[MULTILINGUAL]).getValue(); }
public String templateIds() { return options[TEMPLATE_IDS].getString(); }
public boolean separateStylesheet() { return ((BooleanOption) options[SEPARATE_STYLESHEET]).getValue(); }
public String xhtmlCustomStylesheet() { return options[CUSTOM_STYLESHEET].getString(); }
public int xhtmlFormatting() { return ((XhtmlFormatOption) options[FORMATTING]).getValue(); }
public int xhtmlFrameFormatting() { return ((XhtmlFormatOption) options[FRAME_FORMATTING]).getValue(); }
public int xhtmlSectionFormatting() { return ((XhtmlFormatOption) options[SECTION_FORMATTING]).getValue(); }
public int xhtmlTableFormatting() { return ((XhtmlFormatOption) options[TABLE_FORMATTING]).getValue(); }
public int tableSize() { return ((IntegerOption) options[TABLE_SIZE]).getValue(); }
public int listFormatting() { return ((IntegerOption) options[LIST_FORMATTING]).getValue(); }
public boolean useDefaultFont() { return ((BooleanOption) options[USE_DEFAULT_FONT]).getValue(); }
public String defaultFontName() { return options[DEFAULT_FONT_NAME].getString(); }
public boolean xhtmlUseDublinCore() { return ((BooleanOption) options[USE_DUBLIN_CORE]).getValue(); }
public boolean xhtmlNotes() { return ((BooleanOption) options[NOTES]).getValue(); }
public boolean displayHiddenText() { return ((BooleanOption) options[DISPLAY_HIDDEN_TEXT]).getValue(); }
public boolean xhtmlConvertToPx() { return ((BooleanOption) options[CONVERT_TO_PX]).getValue(); }
public String getXhtmlScaling() { return options[SCALING].getString(); }
public String getXhtmlColumnScaling() { return options[COLUMN_SCALING].getString(); }
public boolean relativeFontSize() { return ((BooleanOption) options[RELATIVE_FONT_SIZE]).getValue(); }
public String fontScaling() { return options[FONT_SCALING].getString(); }
public boolean xhtmlFloatObjects() { return ((BooleanOption) options[FLOAT_OBJECTS]).getValue(); }
public String getXhtmlTabstopStyle() { return options[TABSTOP_STYLE].getString(); }
public String getEndnotesHeading() { return options[ENDNOTES_HEADING].getString(); }
public String getFootnotesHeading() { return options[FOOTNOTES_HEADING].getString(); }
public int formulas() { return ((IntegerOption) options[FORMULAS]).getValue(); }
public int externalTocDepth() { return ((IntegerOption) options[EXTERNAL_TOC_DEPTH]).getValue(); }
public boolean includeToc() { return ((BooleanOption) options[INCLUDE_TOC]).getValue(); }
public int getXhtmlSplitLevel() { return ((IntegerOption) options[SPLIT_LEVEL]).getValue(); }
public int getXhtmlRepeatLevels() { return ((IntegerOption) options[REPEAT_LEVELS]).getValue(); }
public int pageBreakSplit() { return ((IntegerOption) options[PAGE_BREAK_SPLIT]).getValue(); }
public int splitAfter() { return ((IntegerOption) options[SPLIT_AFTER]).getValue(); }
public String imageSplit() { return options[IMAGE_SPLIT].getString(); }
public boolean coverImage() { return ((BooleanOption) options[COVER_IMAGE]).getValue(); }
public boolean embedSVG() { return ((BooleanOption) options[EMBED_SVG]).getValue(); }
public boolean useMathJax() { return ((BooleanOption) options[USE_MATHJAX]).getValue(); }
public boolean xhtmlCalcSplit() { return ((BooleanOption) options[CALC_SPLIT]).getValue(); }
public boolean xhtmlDisplayHiddenSheets() { return ((BooleanOption) options[DISPLAY_HIDDEN_SHEETS]).getValue(); }
public boolean displayHiddenRowsCols() { return ((BooleanOption) options[DISPLAY_HIDDEN_ROWS_COLS]).getValue(); }
public boolean displayFilteredRowsCols() { return ((BooleanOption) options[DISPLAY_FILTERED_ROWS_COLS]).getValue(); }
public boolean applyPrintRanges() { return ((BooleanOption) options[APPLY_PRINT_RANGES]).getValue(); }
public boolean xhtmlUseTitleAsHeading() { return ((BooleanOption) options[USE_TITLE_AS_HEADING]).getValue(); }
public boolean xhtmlUseSheetNamesAsHeadings() { return ((BooleanOption) options[USE_SHEET_NAMES_AS_HEADINGS]).getValue(); }
public boolean saveImagesInSubdir() { return ((BooleanOption) options[SAVE_IMAGES_IN_SUBDIR]).getValue(); }
public String getXhtmlUplink() { return options[UPLINK].getString(); }
public String getXhtmlDirectoryIcon() { return options[DIRECTORY_ICON].getString(); }
public String getXhtmlDocumentIcon() { return options[DOCUMENT_ICON].getString(); }
public XhtmlStyleMap getXParStyleMap() { return getStyleMap(xpar); }
public XhtmlStyleMap getXHeadingStyleMap() { return getStyleMap(xheading); }
public XhtmlStyleMap getXTextStyleMap() { return getStyleMap(xtext); }
public XhtmlStyleMap getXFrameStyleMap() { return getStyleMap(xframe); }
public XhtmlStyleMap getXListStyleMap() { return getStyleMap(xlist); }
public XhtmlStyleMap getXAttrStyleMap() { return getStyleMap(xattr); }
private XhtmlStyleMap getStyleMap(ComplexOption co) {
XhtmlStyleMap map = new XhtmlStyleMap();
for (String sName : co.keySet()) {
Map attr = co.get(sName);
String sElement = attr.containsKey("element") ? attr.get("element") : "";
String sCss = attr.containsKey("css") ? attr.get("css") : "";
String sBlockElement = attr.containsKey("block-element") ? attr.get("block-element") : "";
String sBlockCss = attr.containsKey("block-css") ? attr.get("block-css") : "";
map.put(sName, sBlockElement, sBlockCss, sElement, sCss);
}
return map;
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/BatchConverterImpl.java 0000644 0001750 0001750 00000021223 11731717233 025072 0 ustar rene rene /************************************************************************
*
* BatchConverterImpl.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 (2010-04-23)
*
*/
package writer2latex.xhtml;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.util.Locale;
import java.text.Collator;
import org.w3c.dom.Element;
import writer2latex.api.IndexPageEntry;
import writer2latex.api.OutputFile;
import writer2latex.base.BatchConverterBase;
import writer2latex.xhtml.l10n.L10n;
/**
* Implementation of writer2latex.api.BatchConverter for
* xhtml 1.0 strict
*/
public class BatchConverterImpl extends BatchConverterBase {
private XhtmlConfig config;
private XhtmlDocument template;
private String sDefaultLang;
private String sDefaultCountry;
private L10n l10n;
public BatchConverterImpl() {
super();
config = new XhtmlConfig();
template = null;
l10n = new L10n();
sDefaultLang = System.getProperty("user.language");
sDefaultCountry = System.getProperty("user.country");
l10n.setLocale(sDefaultLang, sDefaultCountry);
}
// Implementation of the remaining (xhtml specific) parts of the interface
public writer2latex.api.Config getConfig() {
return config;
}
public void readTemplate(InputStream is) throws IOException {
template = new XhtmlDocument("Template",XhtmlDocument.XHTML10);
try {
template.read(is);
}
catch (IOException e) {
template = null;
throw e;
}
}
public void readTemplate(File file) throws IOException {
readTemplate(new FileInputStream(file));
}
protected String getIndexFileName() {
return "index.html";
}
public OutputFile createIndexFile(String sHeading, IndexPageEntry[] entries) {
// Create the index page (with header/footer or from template)
XhtmlDocument htmlDoc = new XhtmlDocument("index",XhtmlDocument.XHTML10);
htmlDoc.setConfig(config);
if (template!=null) { htmlDoc.readFromTemplate(template); }
else { htmlDoc.createHeaderFooter(); }
org.w3c.dom.Document htmlDOM = htmlDoc.getContentDOM();
Element head = htmlDoc.getHeadNode();
if (head!=null) {
// Declare charset (we need this for xhtml because we have no )
Element meta = htmlDOM.createElement("meta");
meta.setAttribute("http-equiv","Content-Type");
meta.setAttribute("content","text/html; charset="+htmlDoc.getEncoding().toLowerCase());
head.appendChild(meta);
// Add link to stylesheet
if (config.xhtmlCustomStylesheet().length()>0) {
Element htmlStyle = htmlDOM.createElement("link");
htmlStyle.setAttribute("rel","stylesheet");
htmlStyle.setAttribute("type","text/css");
htmlStyle.setAttribute("media","all");
htmlStyle.setAttribute("href",config.xhtmlCustomStylesheet());
head.appendChild(htmlStyle);
}
}
// Add uplink to header and footer
Element header = htmlDoc.getHeaderNode();
if (header!=null) {
if (config.getXhtmlUplink().length()>0) {
Element a = htmlDOM.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(htmlDOM.createTextNode(l10n.get(L10n.UP)));
header.appendChild(a);
}
else {
header.appendChild(htmlDOM.createTextNode(l10n.get(L10n.UP)));
}
}
Element footer = htmlDoc.getFooterNode();
if (footer!=null) {
if (config.getXhtmlUplink().length()>0) {
Element a = htmlDOM.createElement("a");
a.setAttribute("href",config.getXhtmlUplink());
a.appendChild(htmlDOM.createTextNode(l10n.get(L10n.UP)));
footer.appendChild(a);
}
else {
footer.appendChild(htmlDOM.createTextNode(l10n.get(L10n.UP)));
}
}
// Add title and heading
Element title = htmlDoc.getTitleNode();
if (title!=null) {
title.appendChild(htmlDOM.createTextNode(sHeading));
}
Element h1 = htmlDOM.createElement("h1");
htmlDoc.getContentNode().appendChild(h1);
h1.appendChild(htmlDOM.createTextNode(sHeading));
// Sort the entries
int nLen = entries.length;
Collator collator = Collator.getInstance(new Locale(sDefaultLang,sDefaultCountry));
for (int i = 0; i 0) {
entries[i] = entryj;
entries[j] = entryi;
}
}
}
}
}
// Insert directory entries
boolean bUseIcon = config.getXhtmlDirectoryIcon().length()>0;
for (int i=0; i0;
for (int i=0; i sheetNames = new Vector();
public TableConverter(OfficeReader ofr, XhtmlConfig config, Converter converter) {
super(ofr,config,converter);
}
/** Converts an office node as a complete table (spreadsheet) document
*
* @param onode the Office node containing the content to convert
*/
public void convertTableContent(Element onode) {
Element hnode = null;
if (!onode.hasChildNodes()) { return; }
if (!config.xhtmlCalcSplit()) { hnode = nextOutFile(); }
NodeList nList = onode.getChildNodes();
int nLen = nList.getLength();
for (int i=0; i0)) {
if (config.xhtmlCalcSplit()) { hnode = nextOutFile(); }
// Collect name
String sName = Misc.getAttribute(child,XMLString.TABLE_NAME);
sheetNames.add(sName);
// Add sheet name as heading, if required
if (config.xhtmlUseSheetNamesAsHeadings()) {
Element heading = converter.createElement("h2");
hnode.appendChild(heading);
heading.setAttribute("id","tableheading"+(sheetNames.size()-1));
heading.appendChild(converter.createTextNode(sName));
}
// Handle the table
handleTable(child,hnode);
// Add frames belonging to this table
Element div = converter.createElement("div");
Element shapes = Misc.getChildByTagName(child,XMLString.TABLE_SHAPES);
if (shapes!=null) {
Node shape = shapes.getFirstChild();
while (shape!=null) {
if (OfficeReader.isDrawElement(shape)) {
// Actually only the first parameter is used
getDrawCv().handleDrawElement((Element)shape,div,null,DrawConverter.CENTERED);
}
shape = shape.getNextSibling();
}
}
getDrawCv().flushFrames(div);
if (div.hasChildNodes()) { hnode.appendChild(div); }
}
}
}
}
if (converter.getOutFileIndex()<0) {
// No files, add an empty one (This may happen if apply_print_ranges=true
// and the document does not contain any print ranges)
nextOutFile();
}
}
private Element nextOutFile() {
Element hnode = converter.nextOutFile();
// Add title, if required by config
if (config.xhtmlUseTitleAsHeading()) {
String sTitle = converter.getMetaData().getTitle();
if (sTitle!=null) {
Element title = converter.createElement("h1");
hnode.appendChild(title);
title.appendChild(converter.createTextNode(sTitle));
}
}
return hnode;
}
/** Process a table:table tag
*
* @param onode the Office node containing the table element
* @param hnode the XHTML node to which the table should be attached
*/
public void handleTable(Node onode, Node hnode) {
TableReader tblr = ofr.getTableReader((Element)onode);
if (config.applyPrintRanges()) {
if (tblr.getPrintRangeCount()>0) {
Element div = converter.createElement("div");
if (!tblr.isSubTable()) {
converter.addTarget(div,tblr.getTableName()+"|table");
}
hnode.appendChild(div);
int nCount = tblr.getPrintRangeCount();
for (int nRange=0; nRange1) {
bFirstRowColSpan = true;
}
}
}
// Create columns; only for tables with relative width
// Otherwise we set the cell width. Reason: IE and Mozilla does not
// interpret column width the same way. IE excludes padding and border,
// Mozilla (like OOo) includes them.
// If the first row contains colspan we have to add anyway
if (config.tableSize()!=XhtmlConfig.NONE) {
if (view.getRelTableWidth()!=null || config.tableSize()==XhtmlConfig.RELATIVE || bFirstRowColSpan) {
Element colgroup = hnode;
if (converter.nType==XhtmlDocument.HTML5) {
// Polyglot HTML5 documents must use an explicit colgroup
colgroup = converter.createElement("colgroup");
hnode.appendChild(colgroup);
}
if (view.getRelTableWidth()!=null || config.tableSize()==XhtmlConfig.RELATIVE) {
for (int nCol=0; nCol1) {
td.setAttribute("rowspan",Integer.toString(nRowSpan));
}
int nColSpan = view.getColSpan(nRow,nCol);
if (nColSpan>1) {
td.setAttribute("colspan",Integer.toString(nColSpan));
}
// Handle content
if (!isEmptyCell(cell)) {
String sWidth = view.getCellWidth(nRow, nCol);
if (sWidth!=null) {
converter.pushContentWidth(sWidth);
}
getTextCv().traverseBlockText(cell,td);
if (sWidth!=null) {
converter.popContentWidth();
}
}
else {
// Hack to display empty cells even in msie...
Element par = converter.createElement("p");
td.appendChild(par);
par.setAttribute("style","margin:0;font-size:1px");
par.appendChild(converter.createTextNode("\u00A0"));
}
// Is this a subtable?
Node subTable = Misc.getChildByTagName(cell,XMLString.TABLE_SUB_TABLE);
String sTotalWidth=null;
if (nColSpan==1) {
sTotalWidth = view.getCellWidth(nRow,nCol);
}
String sValueType = ofr.isOpenDocument() ?
Misc.getAttribute(cell,XMLString.OFFICE_VALUE_TYPE) :
Misc.getAttribute(cell,XMLString.TABLE_VALUE_TYPE);
applyCellStyle(view.getCellStyleName(nRow,nCol), view.getRelTableWidth()!=null, sTotalWidth, sValueType, td, subTable!=null);
}
else if (XMLString.TABLE_COVERED_TABLE_CELL.equals(cell.getNodeName())) {
// covered table cells are not part of xhtml table model
}
}
else {
// non-existing cell, not needed in the xhtml table model (it will probably be a trailing cell)
}
}
}
}
private boolean isEmptyCell(Node cell) {
if (!cell.hasChildNodes()) {
return true;
}
else if (OfficeReader.isSingleParagraph(cell)) {
Element par = Misc.getChildByTagName(cell,XMLString.TEXT_P);
return par==null || !par.hasChildNodes();
}
return false;
}
private void applyTableStyle(String sStyleName, Element table, boolean bIsSubTable) {
StyleInfo info = new StyleInfo();
getTableSc().applyStyle(sStyleName,info);
if (config.tableSize()!=XhtmlConfig.NONE) {
StyleWithProperties style = ofr.getTableStyle(sStyleName);
if (style!=null) {
// Set table width
String sWidth = style.getProperty(XMLString.STYLE_REL_WIDTH);
if (sWidth!=null) {
info.props.addValue("width",sWidth);
}
else {
sWidth = style.getProperty(XMLString.STYLE_WIDTH);
if (sWidth!=null) {
if (config.tableSize()==XhtmlConfig.RELATIVE){
// Force relative width
sWidth=Misc.divide(sWidth, converter.getContentWidth(), true);
info.props.addValue("width",sWidth);
}
else {
info.props.addValue("width",getTableSc().colScale(sWidth));
}
}
}
}
}
// Writer uses a separating border model, Calc a collapsing:
// props.addValue("border-collapse", bCalc ? "collapse" : "separate");
// For now always use separating model:
info.props.addValue("border-collapse", "separate");
info.props.addValue("border-spacing", "0");
info.props.addValue("table-layout","fixed");
//info.props.addValue("empty-cells","show"); use instead...
if (ofr.isSpreadsheet()) { info.props.addValue("white-space","nowrap"); }
if (bIsSubTable) {
// Should try to fill the cell; hence:
info.props.addValue("width","100%");
info.props.addValue("margin","0");
}
applyStyle(info,table);
}
private void applyRowStyle(String sStyleName, Element row) {
StyleInfo info = new StyleInfo();
getRowSc().applyStyle(sStyleName,info);
if (config.tableSize()!=XhtmlConfig.NONE) {
StyleWithProperties style = ofr.getRowStyle(sStyleName);
if (style!=null) {
// Translates row style properties
// OOo offers style:row-height and style:min-row-height
// In css row heights are always minimal, so both are exported as height
// If neither is specified, the tallest cell rules; this fits with css.
String s = style.getAbsoluteProperty(XMLString.STYLE_ROW_HEIGHT);
// Do not export minimal row height; causes trouble with ie
//if (s==null) { s = style.getAbsoluteProperty(XMLString.STYLE_MIN_ROW_HEIGHT); }
if (s!=null) { info.props.addValue("height",getRowSc().scale(s)); }
}
}
applyStyle(info,row);
}
private void applyCellStyle(String sStyleName, boolean bIsRelative, String sTotalWidth, String sValueType, Element cell, boolean bIsSubTable) {
StyleInfo info = new StyleInfo();
getCellSc().applyStyle(sStyleName,info);
StyleWithProperties style = ofr.getCellStyle(sStyleName);
if (style!=null) {
if (config.tableSize()==XhtmlConfig.ABSOLUTE && !bIsRelative) {
String sEdge = "0";
// Set the cell width. This is calculated as
// "total cell width" - "border" - "padding"
String s = style.getProperty(XMLString.FO_PADDING_LEFT);
if (s!=null) {
sEdge=Misc.add(sEdge,getTableSc().colScale(s));
}
s = style.getProperty(XMLString.FO_PADDING_RIGHT);
if (s!=null) {
sEdge=Misc.add(sEdge,getTableSc().colScale(s));
}
s = style.getProperty(XMLString.FO_PADDING);
if (s!=null) {
sEdge=Misc.add(sEdge,Misc.multiply("200%",getTableSc().colScale(s)));
}
s = style.getProperty(XMLString.FO_BORDER_LEFT);
if (s!=null) {
sEdge=Misc.add(sEdge,getTableSc().colScale(borderWidth(s)));
}
s = style.getProperty(XMLString.FO_BORDER_RIGHT);
if (s!=null) {
sEdge=Misc.add(sEdge,getTableSc().colScale(borderWidth(s)));
}
s = style.getProperty(XMLString.FO_BORDER);
if (s!=null) {
sEdge=Misc.add(sEdge,Misc.multiply("200%",getTableSc().colScale(borderWidth(s))));
}
if (sTotalWidth!=null) {
info.props.addValue("width",Misc.sub(getTableSc().colScale(sTotalWidth),sEdge));
}
}
// Automatic horizontal alignment (calc only)
if (ofr.isSpreadsheet() && !"fix".equals(style.getProperty(XMLString.STYLE_TEXT_ALIGN_SOURCE))) {
// Strings go left, other types (float, time, date, percentage, currency, boolean) go right
// The default is string
info.props.addValue("text-align", sValueType==null || "string".equals(sValueType) ? "left" : "right");
}
}
if (!cell.hasChildNodes()) { // hack to handle empty cells even in msie
// info.props.addValue("line-height","1px"); TODO: Reenable this...
cell.appendChild( converter.createTextNode("\u00A0") );
}
if (bIsSubTable) {
// Cannot set height of a subtable, if the subtable does not fill
// the entire cell it is placed at the top
info.props.addValue("vertical-align","top");
// Don't add padding if there's a subtable in the cell!
info.props.addValue("padding","0");
}
applyStyle(info,cell);
}
// TODO: Move me to a more logical place!
public String borderWidth(String sBorder) {
if (sBorder==null || sBorder.equals("none")) { return "0"; }
SimpleInputBuffer in = new SimpleInputBuffer(sBorder);
while (in.peekChar()!='\0') {
// Skip spaces
while(in.peekChar()==' ') { in.getChar(); }
// If it's a number it must be a unit -> get it
if ('0'<=in.peekChar() && in.peekChar()<='9') {
return in.getNumber()+in.getIdentifier();
}
// skip other characters
while (in.peekChar()!=' ' && in.peekChar()!='\0') { }
}
return "0";
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/FrameStyleConverter.java 0000644 0001750 0001750 00000032215 12406234417 025303 0 ustar rene rene /************************************************************************
*
* FrameStyleConverter.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-16)
*
*/
package writer2latex.xhtml;
import java.util.Enumeration;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
import writer2latex.util.Misc;
//import writer2latex.util.Misc;
import writer2latex.util.SimpleInputBuffer;
/**
* This class converts OpenDocument graphic (frame) styles to CSS2 styles.
* This includes conversion of frame properties in other styles (paragraph,
* cell, section, page and presentation styles).
*/
public class FrameStyleConverter extends StyleWithPropertiesConverterHelper {
/** Create a new FrameStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public FrameStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
this.styleMap = config.getXFrameStyleMap();
this.bConvertStyles = config.xhtmlFrameFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFrameFormatting()==XhtmlConfig.IGNORE_HARD;
this.bConvertHard = config.xhtmlFrameFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFrameFormatting()==XhtmlConfig.IGNORE_STYLES;
}
/** Convert style information for used styles
* @param sIndent a String of spaces to add before each line
*/
public String getStyleDeclarations(String sIndent) {
if (bConvertStyles) {
StringBuilder buf = new StringBuilder();
buf.append(super.getStyleDeclarations(sIndent));
Enumeration names = styleNames.keys();
while (names.hasMoreElements()) {
String sDisplayName = names.nextElement();
StyleWithProperties style = (StyleWithProperties)
getStyles().getStyleByDisplayName(sDisplayName);
if (!style.isAutomatic()) {
// Apply style to paragraphs contained in this frame
CSVList props = new CSVList(";");
getFrameSc().cssMargins(style,props,true);
getParSc().cssPar(style,props,true);
getTextSc().cssTextCommon(style,props,true);
if (!props.isEmpty()) {
buf.append(sIndent)
.append(getDefaultTagName(null))
.append(".").append(getClassNamePrefix())
.append(styleNames.getExportName(sDisplayName))
.append(" p {").append(props.toString()).append("}").append(config.prettyPrint() ? "\n" : " ");
}
}
}
return buf.toString();
}
else {
return "";
}
}
/** Return a prefix to be used in generated css class names
* @return the prefix
*/
public String getClassNamePrefix() { return "frame"; }
/** Get the family of frame styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getFrameStyles();
}
/** Create default tag name to represent a frame
* @param style to use
* @return the tag name.
*/
public String getDefaultTagName(StyleWithProperties style) {
return "";
}
/** Convert formatting properties for a specific frame style.
* @param style the style to convert
* @param props the CSVList object to add information to
* @param bInherit true if properties should be inherited from parent style(s)
*/
public void applyProperties(StyleWithProperties style, CSVList props, boolean bInherit) {
cssBox(style,props,bInherit);
getTextSc().cssTextCommon(style,props,bInherit); // only in presentations
}
////////////////////////////////////////////////////////////////////////////
// OpenDocument frame properties
public void cssBox(StyleWithProperties style, CSVList props, boolean bInherit){
// translates "box" style properties.
// these can be applied to paragraph styles, frame styles and page styles.
// The following properties are not supported by CSS2:
// style:border-line-width and style:border-line-width-*
// TODO: What about shadow?
cssMargins(style,props,bInherit);
cssBorder(style,props,bInherit);
cssPadding(style,props,bInherit);
cssBackground(style,props,bInherit);
}
public void cssMargins(StyleWithProperties style, CSVList props, boolean bInherit){
// *Absolute* values fit with css
String s;
if (bInherit || style.getProperty(XMLString.FO_MARGIN_LEFT,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_MARGIN_LEFT);
if (s!=null) { props.addValue("margin-left",scale(s)); }
else { props.addValue("margin-left","0"); }
}
if (bInherit || style.getProperty(XMLString.FO_MARGIN_RIGHT,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_MARGIN_RIGHT);
if (s!=null) { props.addValue("margin-right",scale(s)); }
else { props.addValue("margin-right","0"); }
}
if (bInherit || style.getProperty(XMLString.FO_MARGIN_TOP,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_MARGIN_TOP);
if (s!=null) { props.addValue("margin-top",scale(s)); }
else { props.addValue("margin-top","0"); }
}
if (bInherit || style.getProperty(XMLString.FO_MARGIN_BOTTOM,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_MARGIN_BOTTOM);
if (s!=null) { props.addValue("margin-bottom",scale(s)); }
else { props.addValue("margin-bottom","0"); }
}
}
public void cssBorder(StyleWithProperties style, CSVList props, boolean bInherit){
// Same as in css
boolean bHasBorder = false;
String s=null;
if (bInherit || style.getProperty(XMLString.FO_BORDER,false)!=null) {
s = style.getProperty(XMLString.FO_BORDER);
}
if (s!=null) {
props.addValue("border",borderScale(s)); bHasBorder = true;
}
else { // apply individual borders
if (bInherit || style.getProperty(XMLString.FO_BORDER_TOP,false)!=null) {
s = style.getProperty(XMLString.FO_BORDER_TOP);
if (s!=null) { props.addValue("border-top",borderScale(s)); bHasBorder=true; }
}
if (bInherit || style.getProperty(XMLString.FO_BORDER_BOTTOM,false)!=null) {
s = style.getProperty(XMLString.FO_BORDER_BOTTOM);
if (s!=null) { props.addValue("border-bottom",borderScale(s)); bHasBorder=true; }
}
if (bInherit || style.getProperty(XMLString.FO_BORDER_LEFT,false)!=null) {
s = style.getProperty(XMLString.FO_BORDER_LEFT);
if (s!=null) { props.addValue("border-left",borderScale(s)); bHasBorder=true; }
}
if (bInherit || style.getProperty(XMLString.FO_BORDER_RIGHT,false)!=null) {
s = style.getProperty(XMLString.FO_BORDER_RIGHT);
if (s!=null) { props.addValue("border-right",borderScale(s)); bHasBorder=true; }
}
}
// Default to no border:
if (bInherit && !bHasBorder) { props.addValue("border","none"); }
}
public void cssPadding(StyleWithProperties style, CSVList props, boolean bInherit){
// *Absolute* values fit with css
String s=null;
if (bInherit || style.getProperty(XMLString.FO_PADDING,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_PADDING);
}
if (s!=null) {
props.addValue("padding",scale(s));
}
else { // apply individual paddings
boolean bTop = false;
boolean bBottom = false;
boolean bLeft = false;
boolean bRight = false;
if (bInherit || style.getProperty(XMLString.FO_PADDING_TOP,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_PADDING_TOP);
if (s!=null) { props.addValue("padding-top",scale(s)); bTop=true; }
}
if (bInherit || style.getProperty(XMLString.FO_PADDING_BOTTOM,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_PADDING_BOTTOM);
if (s!=null) { props.addValue("padding-bottom",scale(s)); bBottom=true; }
}
if (bInherit || style.getProperty(XMLString.FO_PADDING_LEFT,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_PADDING_LEFT);
if (s!=null) { props.addValue("padding-left",scale(s)); bLeft=true; }
}
if (bInherit || style.getProperty(XMLString.FO_PADDING_RIGHT,false)!=null) {
s = style.getAbsoluteProperty(XMLString.FO_PADDING_RIGHT);
if (s!=null) { props.addValue("padding-right",scale(s)); bRight=true; }
}
if (bInherit) { // must specify padding
if (!bTop && !bBottom && !bLeft && !bRight) {
props.addValue("padding","0");
}
else {
if (!bTop) { props.addValue("padding-top","0"); }
if (!bBottom) { props.addValue("padding-bottom","0"); }
if (!bLeft) { props.addValue("padding-left","0"); }
if (!bRight) { props.addValue("padding-right","0"); }
}
}
}
}
// parapgrah styles need this for special treatment of background color
public void cssBackgroundCommon(StyleWithProperties style, CSVList props, boolean bInherit){
// Background image:
String sUrl = style.getBackgroundImageProperty(XMLString.XLINK_HREF);
if (sUrl!=null) { // currently only support for linked image
props.addValue("background-image","url("+escapeUrl(sUrl)+")");
String sRepeat = style.getBackgroundImageProperty(XMLString.STYLE_REPEAT);
if ("no-repeat".equals(sRepeat) || "stretch".equals(sRepeat)) {
props.addValue("background-repeat","no-repeat");
}
else {
props.addValue("background-repeat","repeat");
}
String sPosition = style.getBackgroundImageProperty(XMLString.STYLE_POSITION);
if (sPosition!=null) { props.addValue("background-position",sPosition); }
}
}
public void cssBackground(StyleWithProperties style, CSVList props, boolean bInherit){
// Background color: Same as in css
String s = style.getProperty(XMLString.FO_BACKGROUND_COLOR,bInherit);
if (s!=null) { props.addValue("background-color",s); }
cssBackgroundCommon(style,props,bInherit);
}
// Scale the border with while preserving the rest of the attribute
public String borderScale(String sBorder) {
SimpleInputBuffer in = new SimpleInputBuffer(sBorder);
StringBuilder out = new StringBuilder();
while (in.peekChar()!='\0') {
// Skip spaces
while(in.peekChar()==' ') { out.append(" "); in.getChar(); }
// If it's a number it must be a unit -> convert it
if ('0'<=in.peekChar() && in.peekChar()<='9') {
String sDim = scale(in.getNumber()+in.getIdentifier());
// Do not output a border less than 1px wide - some browsers will render it invisible
out.append(Misc.isLessThan(sDim, "1px") ? "1px" : sDim);
}
// skip other characters
while (in.peekChar()!=' ' && in.peekChar()!='\0') {
out.append(in.getChar());
}
}
return out.toString();
}
// Must escape certain characters in the url property
private String escapeUrl(String sUrl) {
StringBuilder buf = new StringBuilder();
int nLen = sUrl.length();
for (int i=0; iDocument for
* XHTML documents.
*/
public class XhtmlDocument extends DOMDocument {
/** Constant to identify XHTML 1.0 strict documents */
public static final int XHTML10 = 0;
/** Constant to identify XHTML 1.1 documents */
public static final int XHTML11 = 1;
/** Constant to identify XHTML + MathML documents */
public static final int XHTML_MATHML = 2;
/** Constant to identify HTML5 documents */
public static final int HTML5 = 3;
// Some static data
private static final String[] sExtension = { ".html", ".xhtml", ".xhtml", ".html" };
private static Set blockPrettyPrint;
private static Set conditionalBlockPrettyPrint;
private static Set emptyElements;
private static Set emptyHtml5Elements;
private static String[] entities; // Not convenient to define directly due to a lot of null values
// Type of document
private int nType;
// Configuration
private String sEncoding = "UTF-8";
private boolean bUseNamedEntities = false;
private boolean bHexadecimalEntities = true;
private char cLimit = 65535;
private boolean bNoDoctype = false;
private boolean bAddBOM = false;
private boolean bPrettyPrint = true;
private String sContentId = "content";
private String sHeaderId = "header";
private String sFooterId = "footer";
private String sPanelId = "panel";
// Content
private Element headNode = null;
private Element bodyNode = null;
private Element titleNode = null;
private Element contentNode = null;
private Element panelNode = null;
private Element headerNode = null;
private Element footerNode = null;
// Initialize static data
static {
// Paragraphs and headings always block pretty printing
blockPrettyPrint = new HashSet();
blockPrettyPrint.add("p");
blockPrettyPrint.add("h1");
blockPrettyPrint.add("h2");
blockPrettyPrint.add("h3");
blockPrettyPrint.add("h4");
blockPrettyPrint.add("h5");
blockPrettyPrint.add("h6");
// List items and table cells may block pretty printing, depending on the context
conditionalBlockPrettyPrint = new HashSet();
conditionalBlockPrettyPrint.add("li");
conditionalBlockPrettyPrint.add("th");
conditionalBlockPrettyPrint.add("td");
// These elements are empty
emptyElements = new HashSet();
emptyElements.add("base");
emptyElements.add("meta");
emptyElements.add("link");
emptyElements.add("hr");
emptyElements.add("br");
emptyElements.add("param");
emptyElements.add("img");
emptyElements.add("area");
emptyElements.add("input");
emptyElements.add("col");
// These elements are empty in HTML5
emptyHtml5Elements = new HashSet();
emptyHtml5Elements.add("base");
emptyHtml5Elements.add("meta");
emptyHtml5Elements.add("link");
emptyHtml5Elements.add("hr");
emptyHtml5Elements.add("br");
emptyHtml5Elements.add("param");
emptyHtml5Elements.add("img");
emptyHtml5Elements.add("area");
emptyHtml5Elements.add("input");
emptyHtml5Elements.add("col");
emptyHtml5Elements.add("command");
emptyHtml5Elements.add("embed");
emptyHtml5Elements.add("keygen");
emptyHtml5Elements.add("source");
// Named character entities (currently only those within the ISO latin 1 range)
entities = new String[256];
// Latin 1 symbols
entities[160]=" ";
entities[161]="¡";
entities[162]="¢";
entities[163]="£";
entities[164]="¤";
entities[165]="¥";
entities[166]="¦";
entities[167]="§";
entities[168]="¨";
entities[169]="©";
entities[170]="ª";
entities[171]="«";
entities[172]="¬";
entities[173]="";
entities[174]="®";
entities[175]="¯";
entities[176]="°";
entities[177]="±";
entities[178]="²";
entities[179]="³";
entities[180]="´";
entities[181]="µ";
entities[182]="¶";
entities[183]="·";
entities[184]="¸";
entities[185]="¹";
entities[186]="º";
entities[187]="»";
entities[188]="¼";
entities[189]="½";
entities[190]="¾";
entities[191]="¿";
entities[215]="×";
entities[247]="÷";
// Latin 1 characters
entities[192]="À";
entities[193]="Á";
entities[194]="Â";
entities[195]="Ã";
entities[196]="Ä";
entities[197]="Å";
entities[198]="Æ";
entities[199]="Ç";
entities[200]="È";
entities[201]="É";
entities[202]="Ê";
entities[203]="Ë";
entities[204]="Ì";
entities[205]="Í";
entities[206]="Î";
entities[207]="Ï";
entities[208]="Ð";
entities[209]="Ñ";
entities[210]="Ò";
entities[211]="Ó";
entities[212]="Ô";
entities[213]="Õ";
entities[214]="Ö";
entities[216]="Ø";
entities[217]="Ù";
entities[218]="Ú";
entities[219]="Û";
entities[220]="Ü";
entities[221]="Ý";
entities[222]="Þ";
entities[223]="ß";
entities[224]="à";
entities[225]="á";
entities[226]="â";
entities[227]="ã";
entities[228]="ä";
entities[229]="å";
entities[230]="æ";
entities[231]="ç";
entities[232]="è";
entities[233]="é";
entities[234]="ê";
entities[235]="ë";
entities[236]="ì";
entities[237]="í";
entities[238]="î";
entities[239]="ï";
entities[240]="ð";
entities[241]="ñ";
entities[242]="ò";
entities[243]="ó";
entities[244]="ô";
entities[245]="õ";
entities[246]="ö";
entities[248]="ø";
entities[249]="ù";
entities[250]="ú";
entities[251]="û";
entities[252]="ü";
entities[253]="ý";
entities[254]="þ";
entities[255]="ÿ";
}
public static final String getExtension(int nType) {
return sExtension[nType];
}
/**
* Constructor. This constructor also creates the DOM (minimal: root, head,
* title and body node only)
* @param name name of this document
* @param nType the type of document
*/
public XhtmlDocument(String name, int nType) {
super(name,sExtension[nType]);
this.nType = nType;
// create DOM
Document contentDOM = null;
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
DOMImplementation domImpl = builder.getDOMImplementation();
String[] sDocType = getDoctypeStrings();
DocumentType doctype = domImpl.createDocumentType("html", sDocType[0], sDocType[1]);
contentDOM = domImpl.createDocument("http://www.w3.org/1999/xhtml","html",doctype);
contentDOM.getDocumentElement().setAttribute("xmlns","http://www.w3.org/1999/xhtml");
// add head, title and body
headNode = contentDOM.createElement("head");
titleNode = contentDOM.createElement("title");
bodyNode = contentDOM.createElement("body");
contentDOM.getDocumentElement().appendChild(headNode);
headNode.appendChild(titleNode);
contentDOM.getDocumentElement().appendChild(bodyNode);
contentNode = bodyNode;
setContentDOM(contentDOM);
}
catch (ParserConfigurationException e) {
// The newDocumentBuilder() method may in theory throw this, but this will not happen
e.printStackTrace();
}
}
@Override public String getMIMEType() {
switch (nType) {
case XHTML10: return MIMETypes.XHTML;
case XHTML11: return MIMETypes.XHTML_MATHML; // TODO: Change the constant names in MIMETypes, this is a bit confusing...
case XHTML_MATHML: return MIMETypes.XHTML_MATHML;
case HTML5: return MIMETypes.HTML5;
}
return "";
}
@Override public boolean isMasterDocument() {
return true;
}
public Element getHeadNode() { return headNode; }
public Element getBodyNode() { return bodyNode; }
public Element getTitleNode() { return titleNode; }
public Element getContentNode() { return contentNode; }
public void setContentNode(Element contentNode) { this.contentNode = contentNode; }
public Element getPanelNode() { return panelNode; }
public Element getHeaderNode() { return headerNode; }
public Element getFooterNode() { return footerNode; }
public void createHeaderFooter() {
if (nType==HTML5) {
Element header1 = getContentDOM().createElement("header");
bodyNode.appendChild(header1);
headerNode = getContentDOM().createElement("nav");
header1.appendChild(headerNode);
}
else {
headerNode = getContentDOM().createElement("div");
bodyNode.appendChild(headerNode);
}
headerNode.setAttribute("id",sHeaderId);
contentNode = getContentDOM().createElement("div");
contentNode.setAttribute("id",sContentId);
bodyNode.appendChild(contentNode);
if (nType==HTML5) {
Element footer1 = getContentDOM().createElement("footer");
bodyNode.appendChild(footer1);
footerNode = getContentDOM().createElement("nav");
footer1.appendChild(footerNode);
}
else {
footerNode = getContentDOM().createElement("div");
bodyNode.appendChild(footerNode);
}
footerNode.setAttribute("id",sFooterId);
}
public void setContentDOM(Document doc) {
super.setContentDOM(doc);
collectNodes();
}
/** Does this document contain any math nodes?
*
* @return true if so
*/
public boolean hasMath() {
return hasMath(getContentDOM().getDocumentElement());
}
private boolean hasMath(Element node) {
// Check this element
if (node.getTagName().equals(XMLString.MATH)) {
return true;
}
// Check children
Node child = node.getFirstChild();
while (child!=null) {
if (child.getNodeType()==Node.ELEMENT_NODE && hasMath((Element)child)) {
return true;
}
child = child.getNextSibling();
}
// Found nothing
return false;
}
public void read(InputStream is) throws IOException {
super.read(is);
collectNodes();
}
public void readFromTemplate(XhtmlDocument template) {
// create a new DOM
Document templateDOM = template.getContentDOM();
Document newDOM = null;
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
DOMImplementation domImpl = builder.getDOMImplementation();
String[] sDocType = getDoctypeStrings();
DocumentType doctype = domImpl.createDocumentType("html", sDocType[0], sDocType[1]);
newDOM = domImpl.createDocument("http://www.w3.org/1999/xhtml",
templateDOM.getDocumentElement().getTagName(),doctype);
setContentDOM(newDOM);
// Import attributes on root element
Element templateRoot = templateDOM.getDocumentElement();
Element newRoot = newDOM.getDocumentElement();
NamedNodeMap attributes = templateRoot.getAttributes();
int nCount = attributes.getLength();
for (int i=0; i0 && sTemplateIds[0].trim().length()>0) sContentId = sTemplateIds[0].trim(); else sContentId = "content";
if (nIdCount>1) sHeaderId = sTemplateIds[1].trim(); else sHeaderId = "header";
if (nIdCount>2) sFooterId = sTemplateIds[2].trim(); else sFooterId = "footer";
if (nIdCount>3) sPanelId = sTemplateIds[3].trim(); else sPanelId = "panel";
}
public String getEncoding() { return sEncoding; }
public String getFileExtension() { return super.getFileExtension(); }
// Optimize the usage of xml:dir and xml:lang attributes
private void optimize(Element node, String sLang, String sDir) {
if (node.hasAttribute("xml:lang")) {
if (node.getAttribute("xml:lang").equals(sLang)) {
node.removeAttribute("xml:lang");
if (node.hasAttribute("lang")) {
node.removeAttribute("lang");
}
}
else {
sLang = node.getAttribute("xml:lang");
}
}
if (node.hasAttribute("xml:dir")) {
if (node.getAttribute("xml:dir").equals(sDir)) {
node.removeAttribute("xml:dir");
}
else {
sDir = node.getAttribute("xml:dir");
}
}
Node child = node.getFirstChild();
while (child!=null) {
if (child.getNodeType()==Node.ELEMENT_NODE) {
optimize((Element)child, sLang, sDir);
}
child = child.getNextSibling();
}
}
/**
* Write out content to the supplied OutputStream.
* (with pretty printing)
* @param os XML OutputStream.
* @throws IOException If any I/O error occurs.
*/
public void write(OutputStream os) throws IOException {
OutputStreamWriter osw = new OutputStreamWriter(os,sEncoding);
// Add a BOM if the user desires so
if (bAddBOM) { osw.write("\uFEFF"); }
// Omit XML prolog for pure XHTML 1.0 strict documents (HTML 4 compaitbility)
// and for HTML5 documents (polyglot document)
if (nType!=XHTML10 && nType!=HTML5) {
osw.write("\n");
}
// Specify DOCTYPE (the user may require that no DOCTYPE is used;
// this may be desirable for further transformations)
if (!bNoDoctype) {
if (nType==HTML5) {
osw.write("\n");
}
else {
DocumentType docType = getContentDOM().getDoctype();
if (docType!=null) {
osw.write("\n");
}
}
}
Element doc = getContentDOM().getDocumentElement();
optimize(doc,null,null);
write(doc,bPrettyPrint ? 0 : -1,osw);
osw.flush();
osw.close();
}
private static boolean blockThis(Element node) {
String sTagName = node.getTagName();
if (blockPrettyPrint.contains(sTagName)) {
return true;
}
else if (conditionalBlockPrettyPrint.contains(sTagName)) {
// Block pretty printing if the content is anything but elements that block pretty print
Node child = node.getFirstChild();
while (child!=null) {
if (child.getNodeType()==Node.ELEMENT_NODE && !blockPrettyPrint.contains(child.getNodeName())) {
return true;
}
child = child.getNextSibling();
}
return false;
}
else {
// Other elements block pretty printing if they contain text nodes
Node child = node.getFirstChild();
while (child!=null) {
if (child.getNodeType()==Node.TEXT_NODE) {
return true;
}
child = child.getNextSibling();
}
return false;
}
}
private boolean isEmpty(String sTagName) {
return nType==HTML5 ? emptyHtml5Elements.contains(sTagName) : emptyElements.contains(sTagName);
}
// Write nodes; we only need element, text and comment nodes
private void write(Node node, int nLevel, OutputStreamWriter osw) throws IOException {
short nType = node.getNodeType();
switch (nType) {
case Node.ELEMENT_NODE:
if (isEmpty(node.getNodeName())) {
// This node must be empty, we ignore child nodes
String sNodeName = node.getNodeName();
if (nLevel>=0) { writeSpaces(nLevel,osw); }
osw.write("<"+sNodeName);
writeAttributes(node,osw);
osw.write(" />");
if (nLevel>=0) { osw.write("\n"); }
}
else if (node.hasChildNodes()) {
int nNextLevel = (nLevel<0 || blockThis((Element)node)) ? -1 : nLevel+1;
// Print start tag
boolean bRedundantElement = !node.hasAttributes() &&
(node.getNodeName().equals("a") || node.getNodeName().equals("span"));
if (!bRedundantElement) {
// Writer2xhtml may produce and without attributes, these are removed here
if (nLevel>=0) { writeSpaces(nLevel,osw); }
osw.write("<"+node.getNodeName());
writeAttributes(node,osw);
osw.write(">");
if (nNextLevel>=0) { osw.write("\n"); }
}
// Print children
Node child = node.getFirstChild();
while (child!=null) {
write(child,nNextLevel,osw);
child = child.getNextSibling();
}
// Print end tag
if (!bRedundantElement) {
if (nNextLevel>=0) { writeSpaces(nLevel,osw); }
osw.write("");
if (nLevel>=0) { osw.write("\n"); }
}
}
else { // empty element
if (nLevel>=0) { writeSpaces(nLevel,osw); }
osw.write("<"+node.getNodeName());
writeAttributes(node,osw);
// HTML compatibility: use end-tag even if empty
if (nType<=XHTML11 || nType==HTML5) {
osw.write(">");
}
else {
osw.write(" />");
}
if (nLevel>=0) { osw.write("\n"); }
}
break;
case Node.TEXT_NODE:
write(node.getNodeValue(),osw);
break;
case Node.COMMENT_NODE:
if (nLevel>=0) { writeSpaces(nLevel,osw); }
osw.write("");
if (nLevel>=0) { osw.write("\n"); }
}
}
private void writeAttributes(Node node, OutputStreamWriter osw) throws IOException {
NamedNodeMap attr = node.getAttributes();
int nLen = attr.getLength();
for (int i=0; i'): osw.write(">"); break;
case ('&'): osw.write("&"); break;
default:
write(c,osw);
}
}
}
private void writeAttribute(String s, OutputStreamWriter osw) throws IOException {
int nLen = s.length();
char c;
for (int i=0; i'): osw.write(">"); break;
case ('&'): osw.write("&"); break;
case ('"'): osw.write("""); break;
case ('\''): osw.write( nType == XHTML10 ? "'" : "'"); break;
default:
write(c,osw);
}
}
}
private void write(char c, OutputStreamWriter osw) throws IOException {
if (bUseNamedEntities) {
if (c<256 && entities[c]!=null) {
// XHTML has a named entity here
osw.write(entities[c]);
return;
}
String s=getMathMLEntity(c);
if (s!=null && (nType==XHTML_MATHML)) {
// There's a MathML entity to use
osw.write(s);
return;
}
}
if (c>cLimit) {
if (bHexadecimalEntities) {
osw.write("&#x"+Integer.toHexString(c).toUpperCase()+";");
}
else {
osw.write("&#"+Integer.toString(c).toUpperCase()+";");
}
}
else {
osw.write(c);
}
}
// Translate character to MathML entity (contributed by Bruno Mascret)
private String getMathMLEntity(char c) {
switch (c) {
case '\u0192': return "ƒ";// lettre minuscule latine f hameon
case '\u0391': return "Α";// lettre majuscule grecque alpha
case '\u0392': return "Β";// lettre majuscule grecque beta
case '\u0393': return "Γ";// lettre majuscule grecque gamma
case '\u0394': return "Δ";// lettre majuscule grecque delta
case '\u0395': return "Ε";// lettre majuscule grecque epsilon
case '\u0396': return "Ζ";// lettre majuscule grecque zeta
case '\u0397': return "Η";// lettre majuscule grecque eta
case '\u0398': return "Θ";// lettre majuscule grecque theta
case '\u0399': return "Ι";// lettre majuscule grecque iota
case '\u039A': return "Κ";// lettre majuscule grecque kappa
case '\u039B': return "Λ";// lettre majuscule grecque lambda
case '\u039C': return "Μ";// lettre majuscule grecque mu
case '\u039D': return "Ν";// lettre majuscule grecque nu
case '\u039E': return "Ξ";// lettre majuscule grecque xi
case '\u039F': return "Ο";// lettre majuscule grecque omicron
case '\u03A0': return "Π";// lettre majuscule grecque pi
case '\u03A1': return "Ρ";// lettre majuscule grecque rho
case '\u03A3': return "Σ";// lettre majuscule grecque sigma (Il n'y pas de caractere Sigmaf ni U+03A2 non plus)
case '\u03A4': return "Τ";// lettre majuscule grecque tau
case '\u03A5': return "Υ";// lettre majuscule grecque upsilon
case '\u03A6': return "Φ";// lettre majuscule grecque phi
case '\u03A7': return "Χ";// lettre majuscule grecque chi
case '\u03A8': return "Ψ";// lettre majuscule grecque psi
case '\u03A9': return "Ω";// lettre majuscule grecque omega
case '\u03B1': return "α";// lettre minuscule grecque alpha
case '\u03B2': return "β";// lettre minuscule grecque beta
case '\u03B3': return "γ";// lettre minuscule grecque gamma
case '\u03B4': return "δ";// lettre minuscule grecque delta
//case '\u03B4': return "δ";// lettre minuscule grecque delta
case '\u03B5': return "ε";// lettre minuscule grecque epsilon
case '\u03B6': return "ζ";// lettre minuscule grecque zeta
case '\u03B7': return "η";// lettre minuscule grecque eta
case '\u03B8': return "θ";// lettre minuscule grecque theta
case '\u03B9': return "ι";// lettre minuscule grecque iota
case '\u03BA': return "κ";// lettre minuscule grecque kappa
case '\u03BB': return "λ";// lettre minuscule grecque lambda
case '\u03BC': return "μ";// lettre minuscule grecque mu
case '\u03BD': return "ν";// lettre minuscule grecque nu
case '\u03BE': return "ξ";// lettre minuscule grecque xi
case '\u03BF': return "ο";// lettre minuscule grecque omicron
case '\u03C0': return "π";// lettre minuscule grecque pi
case '\u03C1': return "ρ";// lettre minuscule grecque rho
case '\u03C2': return "ς";// lettre minuscule grecque final sigma
case '\u03C3': return "σ";// lettre minuscule grecque sigma
case '\u03C4': return "τ";// lettre minuscule grecque tau
case '\u03C5': return "υ";// lettre minuscule grecque upsilon
case '\u03C6': return "φ";// lettre minuscule grecque phi
case '\u03C7': return "χ";// lettre minuscule grecque chi
case '\u03C8': return "ψ";// lettre minuscule grecque psi
case '\u03C9': return "ω";// lettre minuscule grecque omega
case '\u03D1': return "ϑ";// lettre minuscule grecque theta symbol
case '\u03D2': return "ϒ";// symbole grec upsilon crochet
case '\u03D6': return "ϖ";// symbole grec pi
case '\u2022': return "•";// puce (Ce N'EST PAS la meme chose que l'operateur puce, U+2219)
case '\u2026': return "…";// points de suspension
case '\u2032': return "′";// prime
case '\u2033': return "″";// double prime
case '\u203E': return "‾";// tiret en chef
case '\u2044': return "⁄";// barre de fraction
case '\u2118': return "℘";// fonction elliptique de Weierstrass
case '\u2111': return "ℑ";// majuscule I gothique = partie imaginaire
case '\u211C': return "ℜ";// majuscule R gothique = partie reelle
case '\u2122': return "™";// symbole marque commerciale
case '\u2135': return "ℵ";// symbole alef = premier nombre transfini (Le symbole alef N'EST PAS pareil a la lettre hebreue alef, U+05D0 meme si on pourrait utiliser le meme glyphe pour representer les deux caracteres)
case '\u2190': return "←";// fleche vers la gauche
case '\u2191': return "↑";// fleche vers le haut
case '\u2192': return "→";// fleche vers la droite
case '\u2193': return "↓";// fleche vers le bas
case '\u2194': return "↔";// fleche bilaterale
case '\u21B5': return "↵";// fleche vers le bas avec coin vers la gauche = retour de chariot
case '\u21D0': return "⇐";// double fleche vers la gauche (ISO 10646 ne dit pas que lArr est la meme chose que la fleche 'est implique par' et n'a pas non plus d'autre caractere pour cette fonction. Alors ? On peut utiliser lArr pour 'est implique par' comme le suggere)
case '\u21D1': return "⇑";// double fleche vers le haut
case '\u21D2': return "⇒";// double fleche vers la droite (ISO 10646 ne dit pas qu'il s'agit du caractere 'implique' et n'a pas non plus d'autre caractere avec cette fonction. Alors ? On peut utiliser rArr pour 'implique' comme le suggere)
case '\u21D3': return "⇓";// double fleche vers le bas
case '\u21D4': return "⇔";// double fleche bilaterale
case '\u2200': return "∀";// pour tous
case '\u2202': return "∂";// derivee partielle
case '\u2203': return "∃";// il existe
case '\u2205': return "∅";// ensemble vide = symbole diametre
case '\u2207': return "∇";// nabla
case '\u2208': return "∈";// appartient
case '\u2209': return "∉";// n'appartient pas
case '\u220B': return "∋";// contient comme element (Est-ce qu'il ne pourrait pas y avoir un nom plus parlant que 'ni' ?)
case '\u220F': return "∏";// produit de la famille = signe produit (prod N'EST PAS le meme caractere que U+03A0 'lettre capitale grecque pi' meme si le meme glyphe peut s'utiliser pour les deux)
case '\u2211': return "∑";// sommation de la famille (sum N'EST PAS le meme caractere que U+03A3 'ettre capitale grecque sigma' meme si le meme glyphe peut s'utiliser pour les deux)
case '\u2212': return "−";// signe moins
case '\u2217': return "∗";// operateur asterisque
case '\u221A': return "√";// racine carree = signe radical
case '\u221D': return "∝";// proportionnel
case '\u221E': return "∞";// infini
case '\u2220': return "∠";// angle
case '\u2227': return "∧";// ET logique
case '\u2228': return "∨";// OU logique
case '\u2229': return "∩";// intersection = cap
case '\u222A': return "∪";// union = cup
case '\u222B': return "∫";// integrale
case '\u2234': return "∴";// par consequent
case '\u223C': return "∼";// operateur tilde = varie avec = similaire (L'operateur tilde N'EST PAS le meme caractere que le tilde U+007E, meme si le meme glyphe peut s'utiliser pour les deux)
case '\u2245': return "≅";// approximativement egal
case '\u2248': return "≈";// presque egal = asymptotique
case '\u2260': return "≠";// pas egal
case '\u2261': return "≡";// identique
//case '\u2261': return "≡";// identique
case '\u2264': return "≤";// plus petit ou egal
case '\u2265': return "≥";// plus grand ou egal
case '\u2282': return "⊂";// sous-ensemble de
case '\u2283': return "⊃";// sur-ensemble de (Remarquez que nsup 'pas un sur-ensemble de' 2285, n'est pas couvert par le codage de la police Symbol. Devrait-il l'etre par symetrie ? Il est dans)
case '\u2284': return "⊄";// pas un sous-ensemble de
case '\u2286': return "⊆";// sous-ensemble ou egal
case '\u2287': return "⊇";// sur-ensemble de ou egal
case '\u2295': return "⊕";// plus cercle = somme directe
case '\u2297': return "⊗";// multiplie par cercle = produit vectoriel
case '\u22A5': return "⊥";// taquet vers le haut = orthogonal = perpendiculaire
case '\u22C5': return "⋅";// operateur point (L'operateur point N'EST PAS le meme caractere que le 'point median', U+00B7)
case '\u2308': return "⌈";// plafond gauche = anglet gauche
case '\u2309': return "⌉";// plafond droite
case '\u230A': return "⌊";// plancher gauche
case '\u230B': return "⌋";// plancher droite
case '\u2329': return "⟨";// chevron vers la gauche (lang N'EST PAS le meme caractere que U+003C 'inferieur' ou U+2039 'guillemet simple vers la gauche')
case '\u232A': return "⟩";// chevron vers la droite (rang iN'EST PAS le meme caractere que U+003E 'superieur' ou U+203A 'guillemet simple vers la droite')
case '\u25CA': return "◊";// losange
case '\u2660': return "♠";// pique noir (Noir semble dire ici rempli par opposition ajoure)
case '\u2663': return "♣";// trefle noir
case '\u2665': return "♥";// coeur noir
case '\u2666': return "♦";// carreau noir
// truc pas prevus
case '\u2102': return "ℂ";// ensemble C des complexes
case '\u2115': return "ℕ";// ensemble N des entiers
case '\u211A': return "ℚ";// ensemble Q des rationnels
case '\u211D': return "ℝ";// ensemble R des reels
case '\u2124': return "ℤ";// ensemble R des entiers relatifs
case '\u2223': return "∣";// divise
case '\u2224': return "∤";// ne divise pas
case '\u2243': return "≃";// asymptotiquement egal
case '\u2244': return "≄";// asymptotiquement egal
case '\u2225': return "∥";// parallele
case '\u00B1': return "±";// plus ou moins
case '\u2213': return "∓"; // moins ou plus (different de plus ou moins)
case '\u2494': return "⩽"; // inferieur ou egal incline
case '\u2270': return "≰"; //non inferieur ou egal incline
case '\u00AC': return "¬";// signe not
case '\u00B0': return "ˆ";// petit cercle, operateur concatenation, normalement ° mais on va le considere comme circ
case '\u224A': return "≊";// approxivativement egal
case '\u002B': return "+"; // signe plus
case '\u00D7': return "×"; // signe multiplication (croix)
case '\u003D': return "="; // signe egal
case '\u226E': return "≮"; // non inferieur
case '\u2A7D': return "⩽"; // inferieur incline = leqslant
case '\u220A': return "∈";// appartient
case '\u2216': return "∖";// difference d'ensemble
case '\u2288': return "⊈";// ni un sous-ensemble ni egal
case '\u2289': return "⊉";// ni un surensemble ni egal
case '\u2285': return "⊅";// non un surensemble de
case '\u301A': return "⟦";// crochet gauche avec barre
case '\u301B': return "⟧";// crochet droit avec barre
case '\u2210': return "∐";// coproduit (Pi l'envers)
case '\u222C': return "∬";// integrale double
case '\u222D': return "∭";// integrale triple
case '\u222E': return "∮";// integrale de contour
case '\u222F': return "∯";// integrale de surface
case '\u2230': return "∰";// integrale de volume
case '\u210F': return "ℏ";// const de Planck sur 2Pi
case '\u2253': return "&;";// BUG points suspensions diagonale descendant droite
case '\u22EE': return "⋮";// points suspensions verticaux
case '\u22EF': return "⋯";// points suspensions horizontaux medians
case '\u22F0': return "⋰";// points suspensions diagonale montant droite
case '\u22F1': return "⋱";// points suspensions diagonale descendant droite
case '\u02DA': return "˚"; //rond en chef
case '\u00A8': return "¨"; // double point en chef(trema)
case '\u02D9': return "˙"; // point en chef
case '\u2015': return "―"; // barre horizonthale
case '\u00AF': return "¯"; // barre horizonthale en chef
case '\u0332': return "_"; // souligne
case '\u2222': return "∢"; // angle spherique
case '\u03F1': return "ϱ"; // symbole grec rho final
case '\u226B': return "≫"; // tres superieur
case '\u226A': return "≪"; // tres inferieur
default: return null;
}
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/RowStyleConverter.java 0000644 0001750 0001750 00000005761 11147474702 025032 0 ustar rene rene /************************************************************************
*
* RowStyleConverter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-11-22)
*
*/
package writer2latex.xhtml;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
//import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
/**
* This class converts OpenDocument row styles to CSS2 styles.
* Rows formatting includes background, and also height,
* which is considered elsewhere.
*/
public class RowStyleConverter extends StyleWithPropertiesConverterHelper {
/** Create a new RowStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public RowStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
// Style maps for rows are currently not supported.
this.styleMap = new XhtmlStyleMap();
this.bConvertStyles = config.xhtmlTableFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlTableFormatting()==XhtmlConfig.IGNORE_HARD;
this.bConvertHard = config.xhtmlTableFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlTableFormatting()==XhtmlConfig.IGNORE_STYLES;
}
/** Get the family of row styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getRowStyles();
}
/** Create default tag name to represent a row object
* @param style to use
* @return the tag name.
*/
public String getDefaultTagName(StyleWithProperties style) {
return "tr";
}
/** Convert formatting properties for a specific Row style.
* @param style the style to convert
* @param props the CSVList object to add information to
* @param bInherit true if properties should be inherited from parent style(s)
*/
public void applyProperties(StyleWithProperties style, CSVList props, boolean bInherit) {
getFrameSc().cssBackground(style,props,bInherit);
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/TableStyleConverter.java 0000644 0001750 0001750 00000011164 11374171551 025302 0 ustar rene rene /************************************************************************
*
* TableStyleConverter.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 (2010-05-13)
*
*/
package writer2latex.xhtml;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.XMLString;
import writer2latex.util.CSVList;
/**
* This class converts OpenDocument table styles to CSS2 styles.
* Table formatting includes background, alignment,
* margins, and also width, which is considered elsewhere.
*/
public class TableStyleConverter extends StyleWithPropertiesConverterHelper {
/** Create a new TableStyleConverter
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public TableStyleConverter(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter,nType);
// Style maps for tables are currently not supported.
this.styleMap = new XhtmlStyleMap();
this.bConvertStyles = config.xhtmlTableFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlTableFormatting()==XhtmlConfig.IGNORE_HARD;
this.bConvertHard = config.xhtmlTableFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlTableFormatting()==XhtmlConfig.IGNORE_STYLES;
}
/** Get the family of table styles
* @return the style family
*/
public OfficeStyleFamily getStyles() {
return ofr.getTableStyles();
}
/** Create default tag name to represent a table object
* @param style to use
* @return the tag name
*/
public String getDefaultTagName(StyleWithProperties style) {
return "table";
}
/** Convert formatting properties for a specific table style.
* @param style the style to convert
* @param props the CSVList object to add information to
* @param bInherit true if properties should be inherited from parent style(s)
*/
public void applyProperties(StyleWithProperties style, CSVList props, boolean bInherit) {
// Page break
getParSc().cssPageBreak(style, props, bInherit);
// Apply background
getFrameSc().cssBackground(style,props,bInherit);
// Table-specific properties
cssTable(style,props,bInherit);
}
private void cssTable(StyleWithProperties style, CSVList props, boolean bInherit){
// Top and bottom margins
String sMarginTop = style.getAbsoluteProperty(XMLString.FO_MARGIN_TOP);
if (sMarginTop!=null) { props.addValue("margin-top",scale(sMarginTop)); }
else { props.addValue("margin-top","0"); }
String sMarginBottom = style.getAbsoluteProperty(XMLString.FO_MARGIN_BOTTOM);
if (sMarginBottom!=null) { props.addValue("margin-bottom",scale(sMarginBottom)); }
else { props.addValue("margin-bottom","0"); }
// Left and right margins and horizontal alignment
String sAlign = style.getProperty(XMLString.TABLE_ALIGN);
String sMarginLeft = style.getAbsoluteProperty(XMLString.FO_MARGIN_LEFT);
if (sMarginLeft!=null) { sMarginLeft = scale(sMarginLeft); }
String sMarginRight = style.getAbsoluteProperty(XMLString.FO_MARGIN_RIGHT);
if (sMarginRight!=null) { sMarginRight = scale(sMarginRight); }
if ("center".equals(sAlign)) {
sMarginLeft = "auto"; sMarginRight = "auto";
}
else if ("right".equals(sAlign)) {
sMarginLeft = "auto";
}
else if ("left".equals(sAlign)) {
sMarginRight = "auto";
}
if (sMarginLeft!=null) { props.addValue("margin-left",sMarginLeft); }
if (sMarginRight!=null) { props.addValue("margin-right",sMarginRight); }
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/MathConverter.java 0000644 0001750 0001750 00000035576 12434610042 024127 0 ustar rene rene /************************************************************************
*
* MathConverter.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-11-24)
*
*/
package writer2latex.xhtml;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import writer2latex.office.*;
import writer2latex.util.Misc;
import writer2latex.base.BinaryGraphicsDocument;
import writer2latex.latex.StarMathConverter;
/** This class converts formulas: Either as MathML, as an image or as plain text (StarMath or LaTeX format)
*/
public class MathConverter extends ConverterHelper {
private StarMathConverter smc = null;
private boolean bSupportMathML;
private boolean bUseImage;
private boolean bUseLaTeX;
/** Create a new MathConverter
*
* @param ofr the OfficeReader to query about the document
* @param config the configuration determining the type of export
* @param converter the converter instance
* @param bSupportMathML true if the formula should be exported as MathML
*/
public MathConverter(OfficeReader ofr, XhtmlConfig config, Converter converter,
boolean bSupportMathML) {
super(ofr,config,converter);
this.bSupportMathML = bSupportMathML;
this.bUseImage = config.formulas()==XhtmlConfig.IMAGE_LATEX || config.formulas()==XhtmlConfig.IMAGE_STARMATH;
this.bUseLaTeX = config.formulas()==XhtmlConfig.IMAGE_LATEX || config.formulas()==XhtmlConfig.LATEX;
if (bUseLaTeX) { smc = new StarMathConverter(); }
}
/** Convert a formula
*
* @param image image version of the formula (or null if no image is available)
* @param onode the math node
* @param hnode the xhtml node to which content should be added
*/
public void convert(Element image, Element onode, Node hnode, boolean bAllowDisplayStyle) {
if (bSupportMathML) {
convertAsMathML(onode,hnode,bAllowDisplayStyle);
}
else {
convertAsImageOrText(image,onode,hnode);
}
}
public boolean convertTexMathsEquation(Element onode, Element hnodeBlock, Element hnodeInline, int nMode) {
// If possible, add the object inline. In pure block context, add a div.
Element hnode;
if (hnodeInline!=null) {
hnode = hnodeInline;
}
else {
Element div = converter.createElement("div");
hnodeBlock.appendChild(div);
hnode = div;
}
String sLaTeX = null;
Element equation = converter.getTexMathsEquation(onode);
if (equation!=null) {
sLaTeX = Misc.getPCDATA(equation);
}
else { // Try OOoLaTeX
// The LaTeX code is embedded in a custom style attribute:
StyleWithProperties style = ofr.getFrameStyle(Misc.getAttribute(onode, XMLString.DRAW_STYLE_NAME));
if (style!=null) {
sLaTeX = style.getProperty("OOoLatexArgs");
}
}
if (sLaTeX!=null) {
// Format is XXXXX
// where X is a paragraph sign
String sMathJax;
if (config.useMathJax() && bSupportMathML) {
switch (converter.getTexMathsStyle(sLaTeX)) {
case inline:
sMathJax = "\\("+converter.getTexMathsEquation(sLaTeX)+"\\)";
break;
case display:
sMathJax = "\\["+converter.getTexMathsEquation(sLaTeX)+"\\]";
break;
case latex:
default: // Arbitrary LaTeX; this is the tricky bit
sMathJax = "\\("+converter.getTexMathsEquation(sLaTeX)+"\\)";
}
}
else {
sMathJax = " "+converter.getTexMathsEquation(sLaTeX)+" ";
}
hnode.appendChild(converter.createTextNode(sMathJax));
return true;
}
return false;
}
// For plain xhtml: Convert the formula as an image or as plain text
private void convertAsImageOrText(Element image, Node onode, Node hnode) {
NodeList annotationList = ((Element) onode).getElementsByTagName(XMLString.ANNOTATION); // Since OOo 3.2
if (annotationList.getLength()==0) {
annotationList = ((Element) onode).getElementsByTagName(XMLString.MATH_ANNOTATION);
}
if (annotationList.getLength()>0 && annotationList.item(0).hasChildNodes()) {
// First create the annotation (either StarMath or LaTeX)
String sAnnotation = "";
Node child = annotationList.item(0).getFirstChild();
while (child!=null) {
sAnnotation+=child.getNodeValue();
child = child.getNextSibling();
}
if (bUseLaTeX) { sAnnotation = smc.convert(sAnnotation); }
// Next insert the image if required and available
if (bUseImage) {
// Get the image from the ImageLoader
String sHref = Misc.getAttribute(onode,XMLString.XLINK_HREF);
if (sHref==null || sHref.length()==0 || ofr.isInPackage(sHref)) {
BinaryGraphicsDocument bgd = converter.getImageCv().getImage(image);
if (bgd!=null) {
String sMIME = bgd.getMIMEType();
if (MIMETypes.PNG.equals(sMIME) || MIMETypes.JPEG.equals(sMIME) || MIMETypes.GIF.equals(sMIME)) {
converter.addDocument(bgd);
// Create the image and add the StarMath/LaTeX formula as alternative text
Element img = converter.createElement("img");
img.setAttribute("src",bgd.getFileName());
img.setAttribute("class", "formula");
img.setAttribute("alt",sAnnotation);
hnode.appendChild(img);
return;
}
}
}
}
// Otherwise insert the StarMath/LaTeX annotation as a kbd element
Element kbd = converter.createElement("kbd");
kbd.setAttribute("class", "formula");
hnode.appendChild(kbd);
kbd.appendChild(converter.createTextNode(sAnnotation));
}
else {
hnode.appendChild(converter.createTextNode("[Warning: formula ignored]"));
}
}
// For xhtml+mathml: Insert the mathml, removing the namespace (if any) and the annotation
private void convertAsMathML(Element onode, Node hnode, boolean bAllowDisplay) {
Element math = converter.createElement("math");
if (onode.hasAttribute("xmlns:math")) {
math.setAttribute("xmlns", onode.getAttribute("xmlns:math"));
}
else if (onode.hasAttribute("xmlns") && converter.nType!=XhtmlDocument.HTML5) {
// Don't include xmlns attribute in HTML5
math.setAttribute("xmlns", onode.getAttribute("xmlns"));
}
if (bAllowDisplay && onode.hasAttribute("display")) {
// Starting with version 4.2, LO exports display="block" for display equations
// This is a good thing, but in XHTML we can unfortunately only allow this for
// paragraphs with no other text content
math.setAttribute("display", onode.getAttribute("display"));
}
hnode.appendChild(math);
convertMathMLNodeList(onode.getChildNodes(), math);
}
private void convertElementAsMathML(Node onode, Node hnode) {
if (onode.getNodeType()==Node.ELEMENT_NODE) {
if (onode.getNodeName().equals(XMLString.SEMANTICS)) { // Since OOo 3.2
// ignore this construction
convertMathMLNodeList(onode.getChildNodes(),hnode);
}
else if (onode.getNodeName().equals(XMLString.MATH_SEMANTICS)) {
// ignore this construction
convertMathMLNodeList(onode.getChildNodes(),hnode);
}
else if (onode.getNodeName().equals(XMLString.ANNOTATION)) { // Since OOo 3.2
// ignore the annotation (StarMath) completely
// (mozilla renders it for some reason)
}
else if (onode.getNodeName().equals(XMLString.MATH_ANNOTATION)) {
// ignore the annotation (StarMath) completely
// (mozilla renders it for some reason)
}
else {
String sElementName = stripNamespace(onode.getNodeName());
Element newNode = converter.createElement(sElementName);
hnode.appendChild(newNode);
if (onode.hasAttributes()) {
NamedNodeMap attr = onode.getAttributes();
int nLen = attr.getLength();
for (int i=0; i-1) { return s.substring(nPos+1); }
else { return s; }
}
// OOo exports some characters (from the OpenSymbol/StarSymbol font)
// in the private use area of unicode. These should be replaced
// with real unicode positions.
private String replacePrivateChars(String s) {
int nLen = s.length();
StringBuilder buf = new StringBuilder(nLen);
for (int i=0; i
The package writer2latex.xhtml
This package contains xhtml specific code.
It contains a writerlatex.api.Converter implementation for
conversion into xhtml and xhtml+MathML.
Since version 1.0 you can build Writer2LaTeX without this package if you
don't need xhtml support.
writer2latex-1.4/source/java/writer2latex/xhtml/XhtmlMathMLConverter.java 0000644 0001750 0001750 00000002070 11147474702 025367 0 ustar rene rene /************************************************************************
*
* XhtmlMathMLConverter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-09-09)
*
*/
package writer2latex.xhtml;
public class XhtmlMathMLConverter extends Converter {
public XhtmlMathMLConverter() {
super(XhtmlDocument.XHTML_MATHML);
}
} writer2latex-1.4/source/java/writer2latex/xhtml/CssDocument.java 0000644 0001750 0001750 00000004522 12406234417 023567 0 ustar rene rene /************************************************************************
*
* CssDocument.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-16)
*
*/
package writer2latex.xhtml;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import writer2latex.api.OutputFile;
/**
* An implementation of OutputFile for CSS documents.
* (Actually this is a trivial implementation which never parses the files)
*/
public class CssDocument implements OutputFile {
// Content
private String sName;
private String sContent;
/**
* Constructor (creates an empty document)
* @param sName Document name.
*/
public CssDocument(String sName) {
this.sName = sName;
sContent = "";
}
public String getFileName() {
return sName;
}
public String getMIMEType() {
return "text/css";
}
public boolean isMasterDocument() {
return false;
}
public void write(OutputStream os) throws IOException {
OutputStreamWriter osw = new OutputStreamWriter(os,"UTF-8");
osw.write(sContent);
osw.flush();
osw.close();
}
public void read(InputStream is) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(is,"UTF-8"));
StringBuilder buf = new StringBuilder();
String sLine;
while ((sLine=reader.readLine())!=null) {
buf.append(sLine).append('\n');
}
sContent = buf.toString();
}
public void read(String s) {
sContent = s;
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/TextConverter.java 0000644 0001750 0001750 00000267121 12410352667 024165 0 ustar rene rene /************************************************************************
*
* TextConverter.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-23)
*
*/
package writer2latex.xhtml;
import java.util.Hashtable;
import java.util.Stack;
import java.util.Vector;
import java.util.LinkedList;
import java.util.Locale;
import java.text.Collator;
//import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Element;
import writer2latex.util.Misc;
import writer2latex.xhtml.l10n.L10n;
import writer2latex.office.FontDeclaration;
import writer2latex.office.OfficeStyle;
import writer2latex.office.XMLString;
import writer2latex.office.IndexMark;
import writer2latex.office.ListCounter;
import writer2latex.office.ListStyle;
import writer2latex.office.PropertySet;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.OfficeReader;
import writer2latex.office.TocReader;
// Helper class (a struct) to contain information about an alphabetical
// index entry.
final class AlphabeticalEntry {
String sWord; // the word for the index
int nIndex; // the original index of this entry
}
// Helper class (a struct) to contain information about a toc entry
// (ie. a heading, other paragraph or toc-mark)
final class TocEntry {
Element onode; // the original node
String sLabel = null; // generated label for the entry
int nFileIndex; // the file index for the generated content
int nOutlineLevel; // the outline level for this heading
int[] nOutlineNumber; // the natural outline number for this heading
}
// Helper class (a struct) to point back to indexes that should be processed
final class IndexData {
int nOutFileIndex; // the index of the out file containing the index
Element onode; // the original node
Element chapter; // the chapter containing this toc
Element hnode; // a div node where the index should be added
}
/** This class handles text content
*/
public class TextConverter extends ConverterHelper {
// Data used to handle splitting over several files
// TODO: Accessor methods for sections
// Some (Sony?) EPUB readers have a limit on the file size of individual files
// In any case very large files could be a performance problem, hence we do automatic splitting
// after this number of characters. TODO: Make configurable.
private int nSplitAfter = 150000;
private int nPageBreakSplit = XhtmlConfig.NONE; // Should we split at page breaks?
// TODO: Collect soft page breaks between table rows
private boolean bPendingPageBreak = false; // We have encountered a page break which should be inserted asap
private int nExternalTocDepth = 1; // The number of levels to include in the "external" table of contents
private int nSplit = 0; // The outline level at which to split files (0=no split)
private int nRepeatLevels = 5; // The number of levels to repeat when splitting (0=no repeat)
private int nLastSplitLevel = 1; // The outline level at which the last split occurred
private int nDontSplitLevel = 0; // if > 0 splitting is forbidden
boolean bAfterHeading=false; // last element was a top level heading
protected Stack sections = new Stack(); // stack of nested sections
Element[] currentHeading = new Element[7]; // Last headings (repeated when splitting)
private int nCharacterCount = 0; // The number of text characters in the current document
// Counters for generated numbers
private ListCounter outlineNumbering;
private Hashtable listCounters = new Hashtable();
private String sCurrentListLabel = null;
private ListStyle currentListStyle = null;
private int nCurrentListLevel = 0;
// Mode used to handle floats (depends on source doc type and config)
private int nFloatMode;
// Data used for index bookkeeping
private Vector indexes = new Vector();
// Data used to handle Alphabetical Index
Vector index = new Vector(); // All words for the index
private int nIndexIndex = -1; // Current index used for id's (of form idxN)
private int nAlphabeticalIndex = -1; // File containing alphabetical index
// Data used to handle Table of Contents
private Vector tocEntries = new Vector(); // All potential(!) toc items
private int nTocFileIndex = -1; // file index for main toc
private Element currentChapter = null; // Node for the current chapter (level 1) heading
private int nTocIndex = -1; // Current index for id's (of form tocN)
private ListCounter naturalOutline = new ListCounter(); // Current "natural" outline number
// Style names for foot- and endnotes
private String sFntCitBodyStyle = null;
private String sFntCitStyle = null;
private String sEntCitBodyStyle = null;
private String sEntCitStyle = null;
// Footnote position (can be page or document)
private boolean bFootnotesAtPage = true;
// Gather the footnotes and endnotes
private LinkedList footnotes = new LinkedList();
private LinkedList endnotes = new LinkedList();
// Sometimes we have to create an inlinenode in a block context
// (labels for footnotes and endnotes)
// We put it here and insert it in the first paragraph/heading to come:
private Node asapNode = null;
// When generating toc, a few things should be done differently
private boolean bInToc = false;
// Display hidden text?
private boolean bDisplayHiddenText = false;
public TextConverter(OfficeReader ofr, XhtmlConfig config, Converter converter) {
super(ofr,config,converter);
nSplitAfter = 1000*config.splitAfter();
nPageBreakSplit = config.pageBreakSplit();
nSplit = config.getXhtmlSplitLevel();
nRepeatLevels = converter.isOPS() ? 0 : config.getXhtmlRepeatLevels(); // never repeat headings in EPUB
nExternalTocDepth = config.externalTocDepth();
if (nExternalTocDepth==0) { // A value of zero means auto (i.e. determine from split level)
nExternalTocDepth = Math.max(nSplit,1);
}
nFloatMode = ofr.isText() && config.xhtmlFloatObjects() ?
DrawConverter.FLOATING : DrawConverter.ABSOLUTE;
outlineNumbering = new ListCounter(ofr.getOutlineStyle());
// Styles for footnotes and endnotes
PropertySet notes = ofr.getFootnotesConfiguration();
if (notes!=null) {
sFntCitBodyStyle = notes.getProperty(XMLString.TEXT_CITATION_BODY_STYLE_NAME);
sFntCitStyle = notes.getProperty(XMLString.TEXT_CITATION_STYLE_NAME);
bFootnotesAtPage = !"document".equals(notes.getProperty(XMLString.TEXT_FOOTNOTES_POSITION));
}
notes = ofr.getEndnotesConfiguration();
if (notes!=null) {
sEntCitBodyStyle = notes.getProperty(XMLString.TEXT_CITATION_BODY_STYLE_NAME);
sEntCitStyle = notes.getProperty(XMLString.TEXT_CITATION_STYLE_NAME);
}
bDisplayHiddenText = config.displayHiddenText();
}
/** Converts an office node as a complete text document
*
* @param onode the Office node containing the content to convert
*/
public void convertTextContent(Element onode) {
Element hnode = converter.nextOutFile();
// Create form
if (nSplit==0) {
Element form = getDrawCv().createForm();
if (form!=null) {
hnode.appendChild(form);
hnode = form;
}
}
// Add cover image
hnode = getDrawCv().insertCoverImage(hnode);
// Convert content
hnode = (Element)traverseBlockText(onode,hnode);
// Add footnotes and endnotes
insertFootnotes(hnode,true);
insertEndnotes(hnode);
// Generate all indexes
int nIndexCount = indexes.size();
for (int i=0; i=0; i--) {
TocEntry entry = tocEntries.get(i);
if (XMLString.TEXT_H.equals(entry.onode.getTagName()) && entry.nFileIndex==nIndex && entry.nOutlineLevel<=nSplit) {
entryCurrent = entry; break;
}
}
if (entryCurrent==null) {
entryCurrent = fakeEntry;
if (nIndex==0) { bHasFrontMatter=true; }
}
// Determine the maximum outline level to include
int nMaxLevel = entryCurrent.nOutlineLevel;
if (nMaxLevelnPrevFileIndex+1) {
// Skipping a file index means we have passed an index
for (int k=nPrevFileIndex+1; k0) {
inline.appendChild(converter.createTextNode(entry.sLabel));
if (!entry.sLabel.endsWith(" ")) {
inline.appendChild(converter.createTextNode(" "));
}
}
traverseInlineText(entry.onode,inline);
}
}
}
if (nPrevFileIndex0) {
Element block = converter.createElement(xpar.getBlockElement(sDisplayName));
if (!"(none)".equals(xpar.getBlockCss(sDisplayName))) {
block.setAttribute("class",xpar.getBlockCss(sDisplayName));
}
hnode.appendChild(block);
curHnode = block;
}
boolean bMoreParagraphs = true;
do {
handleParagraph(child,curHnode);
bMoreParagraphs = false;
if (++iXhtmlConfig.NONE) {
// If we don't consider manual page breaks, we may have to consider the parent style
if (style.isAutomatic() && nPageBreakSplit0) {
return true;
}
}
return false;
}
private Node maybeSplit(Node node, StyleWithProperties style) {
return maybeSplit(node,style,-1);
}
private Node maybeSplit(Node node, StyleWithProperties style, int nLevel) {
if (bPendingPageBreak) {
return doMaybeSplit(node, 0);
}
if (getPageBreak(style)) {
return doMaybeSplit(node, 0);
}
if (converter.isOPS() && nSplitAfter>0 && nCharacterCount>nSplitAfter) {
return doMaybeSplit(node, 0);
}
if (nLevel>=0) {
return doMaybeSplit(node, nLevel);
}
else {
return node;
}
}
protected Element doMaybeSplit(Node node, int nLevel) {
if (nDontSplitLevel>1) { // we cannot split due to a nested structure
return (Element) node;
}
if (!converter.isOPS() && bAfterHeading && nLevel-nLastSplitLevel<=nRepeatLevels) {
// we cannot split because we are right after a heading and the
// maximum number of parent headings on the page is not reached
// TODO: Something wrong here....nLastSplitLevel is never set???
return (Element) node;
}
if (nSplit>=nLevel && converter.outFileHasContent()) {
// No objections, this is a level that causes splitting
nCharacterCount = 0;
bPendingPageBreak = false;
if (converter.getOutFileIndex()>=0) { insertFootnotes(node,false); }
return converter.nextOutFile();
}
return (Element) node;
}
/* Process a text:section tag (returns current html node) */
private Node handleSection(Node onode, Node hnode) {
// Unlike headings, paragraphs and spans, text:display is not attached to the style:
if (!bDisplayHiddenText && "none".equals(Misc.getAttribute(onode,XMLString.TEXT_DISPLAY))) { return hnode; }
String sName = Misc.getAttribute(onode,XMLString.TEXT_NAME);
String sStyleName = Misc.getAttribute(onode,XMLString.TEXT_STYLE_NAME);
Element div = converter.createElement("div");
hnode.appendChild(div);
converter.addTarget(div,sName+"|region");
StyleInfo sectionInfo = new StyleInfo();
getSectionSc().applyStyle(sStyleName,sectionInfo);
applyStyle(sectionInfo,div);
sections.push(onode);
Node newhnode = traverseBlockText(onode, div);
sections.pop();
return newhnode.getParentNode();
}
private void handleHeading(Element onode, Node hnode, boolean bAfterSplit) {
int nListLevel = getOutlineLevel((Element)onode);
boolean bUnNumbered = "true".equals(Misc.getAttribute(onode,XMLString.TEXT_IS_LIST_HEADER));
boolean bRestart = "true".equals(Misc.getAttribute(onode,XMLString.TEXT_RESTART_NUMBERING));
int nStartValue = Misc.getPosInteger(Misc.getAttribute(onode,XMLString.TEXT_START_VALUE),1)-1;
handleHeading(onode, hnode, bAfterSplit, ofr.getOutlineStyle(),
nListLevel, bUnNumbered, bRestart, nStartValue);
}
/*
* Process a text:h tag
*/
private void handleHeading(Element onode, Node hnode, boolean bAfterSplit,
ListStyle listStyle, int nListLevel, boolean bUnNumbered,
boolean bRestart, int nStartValue) {
// Note: nListLevel may in theory be different from the outline level,
// though the ui in OOo does not allow this
// Numbering: It is possible to define outline numbering in CSS2
// using counters; but this is not supported in all browsers
// TODO: Offer CSS2 solution as an alternative later.
// Note: Conditional styles are not supported
int nLevel = getOutlineLevel(onode);
if (nLevel<=6) { // Export as heading
String sStyleName = onode.getAttribute(XMLString.TEXT_STYLE_NAME);
StyleWithProperties style = ofr.getParStyle(sStyleName);
// Check for hidden text
if (!bDisplayHiddenText && style!=null && "none".equals(style.getProperty(XMLString.TEXT_DISPLAY))) { return; }
// Numbering
if (!bUnNumbered) {
// If the heading uses a paragraph style which sets an explicit empty list style name, it's unnumbered
if (style!=null) {
String sListStyleName = style.getListStyleName();
if (sListStyleName!=null && sListStyleName.length()==0) {
bUnNumbered = true;
}
}
}
ListCounter counter = null;
String sLabel="";
if (!bUnNumbered) {
counter = getListCounter(listStyle);
if (bRestart) { counter.restart(nListLevel,nStartValue); }
sLabel = counter.step(nListLevel).getLabel();
}
// In EPUB export, a striked out heading will only appear in the external toc
boolean bTocOnly = false;
if (converter.isOPS() && style!=null) {
String sStrikeOut = style.getProperty(XMLString.STYLE_TEXT_LINE_THROUGH_STYLE, true);
if (sStrikeOut!=null && !"none".equals(sStrikeOut)) {
bTocOnly = true;
}
}
// Export the heading
if (!bTocOnly) {
if (nLevel==1) { currentChapter = onode; }
// If split output, add headings of higher levels
if (bAfterSplit && nSplit>0) {
int nFirst = nLevel-nRepeatLevels;
if (nFirst<0) { nFirst=0; }
for (int i=nFirst; inSplit ? sTarget : null);
}
// Add to real toc
TocEntry entry = new TocEntry();
entry.onode = onode;
entry.sLabel = sLabel;
entry.nFileIndex = converter.getOutFileIndex();
entry.nOutlineLevel = nLevel;
entry.nOutlineNumber = naturalOutline.step(nLevel).getValues();
tocEntries.add(entry);
}
// Convert content
StyleInfo innerInfo = new StyleInfo();
getHeadingSc().applyInnerStyle(nLevel, sStyleName, innerInfo);
Element content = heading;
if (innerInfo.sTagName!=null && innerInfo.sTagName.length()>0) {
content = converter.createElement(innerInfo.sTagName);
heading.appendChild(content);
applyStyle(innerInfo, content);
}
traverseInlineText(onode,content);
// Keep track of current headings for split output
currentHeading[nLevel] = heading;
for (int i=nLevel+1; i<=6; i++) {
currentHeading[i] = null;
}
}
else {
if (!bInToc) {
// Add in external content. For single file output we include all level 1 headings + their target
// Targets are added only when the toc level is deeper than the split level
if (nLevel<=nExternalTocDepth) {
// Add an empty div to use as target, if required
String sTarget = null;
if (nLevel>nSplit) {
Element div = converter.createElement("div");
hnode.appendChild(div);
sTarget = "toc"+(++nTocIndex);
converter.addTarget(div,sTarget);
}
converter.addContentEntry(sLabel+converter.getPlainInlineText(onode), nLevel, sTarget);
}
}
// Keep track of current headings for split output
currentHeading[nLevel] = null;
for (int i=nLevel+1; i<=6; i++) {
currentHeading[i] = null;
}
}
}
else { // beyond h6 - export as ordinary paragraph
handleParagraph(onode,hnode);
}
}
/*
* Process a text:p tag
*/
private void handleParagraph(Node onode, Node hnode) {
boolean bIsEmpty = OfficeReader.isWhitespaceContent(onode);
if (config.ignoreEmptyParagraphs() && bIsEmpty) { return; }
String sStyleName = Misc.getAttribute(onode,XMLString.TEXT_STYLE_NAME);
StyleWithProperties style = ofr.getParStyle(sStyleName);
if (!bDisplayHiddenText && style!=null && "none".equals(style.getProperty(XMLString.TEXT_DISPLAY))) { return; }
Element par;
if (ofr.isSpreadsheet()) { // attach inline text directly to parent (always a table cell)
par = (Element) hnode;
}
else {
// Hack because createParagraph doesn't work the way we need here :-(
Element temp = converter.createElement("temp");
par = createParagraph(temp, sStyleName);
prependAsapNode(par);
traverseFloats(onode,hnode,par);
hnode.appendChild(temp.getFirstChild());
}
// Maybe add to toc
if (ofr.isIndexSourceStyle(getParSc().getRealParStyleName(sStyleName))) {
converter.addTarget(par,"toc"+(++nTocIndex));
TocEntry entry = new TocEntry();
entry.onode = (Element) onode;
entry.sLabel = sCurrentListLabel;
entry.nFileIndex = converter.getOutFileIndex();
tocEntries.add(entry);
}
if (!bIsEmpty) {
par = createTextBackground(par, sStyleName);
if (config.listFormatting()==XhtmlConfig.HARD_LABELS) {
insertListLabel(currentListStyle, nCurrentListLevel, "ItemNumber", null, sCurrentListLabel, par);
}
sCurrentListLabel = null;
traverseInlineText(onode,par);
}
else {
// An empty paragraph (this includes paragraphs that only contains
// whitespace) is ignored by the browser, hence we add
par.appendChild( converter.createTextNode("\u00A0") );
sCurrentListLabel = null;
}
// Finally, in EPUB export, if the exported paragraph turns out to be empty, remove it
if (converter.isOPS() && !par.hasChildNodes()) {
hnode.removeChild(par);
}
}
private void prependAsapNode(Node node) {
if (asapNode!=null) {
// May float past a split; check this first
if (asapNode.getOwnerDocument()!=node.getOwnerDocument()) {
asapNode = converter.importNode(asapNode,true);
}
node.appendChild(asapNode); asapNode = null;
}
}
///////////////////////////////////////////////////////////////////////////
// LISTS
///////////////////////////////////////////////////////////////////////////
// Helper: Get a list counter for a list style
private ListCounter getListCounter(ListStyle style) {
if (style==ofr.getOutlineStyle()) {
// Outline numbering has a special counter
return outlineNumbering;
}
else if (style!=null) {
// Get existing or create new counter
if (listCounters.containsKey(style.getName())) {
return listCounters.get(style.getName());
}
else {
ListCounter counter = new ListCounter(style);
listCounters.put(style.getName(),counter);
return counter;
}
}
else {
// No style, return a dummy
return new ListCounter();
}
}
// Helper: Insert a list label formatted with a list style
private void insertListLabel(ListStyle style, int nLevel, String sDefaultStyle, String sPrefix, String sLabel, Element hnode) {
if (sLabel!=null && sLabel.length()>0) {
if (sPrefix!=null) {
Element prefix = converter.createElement("span");
prefix.setAttribute("class", "chapter-name");
hnode.appendChild(prefix);
prefix.appendChild( converter.createTextNode(sPrefix));
}
StyleInfo info = new StyleInfo();
if (style!=null) {
String sTextStyleName = style.getLevelProperty(nLevel,XMLString.TEXT_STYLE_NAME);
getTextSc().applyStyle(sTextStyleName, info);
}
if (info.sTagName==null) { info.sTagName = "span"; }
if (info.sClass==null) { info.sClass = sDefaultStyle; }
Element content = converter.createElement(info.sTagName);
getTextSc().applyStyle(info, content);
hnode.appendChild(content);
content.appendChild( converter.createTextNode(sLabel) );
}
}
// Helper: Check if a list contains any items
private boolean hasItems(Node onode) {
Node child = onode.getFirstChild();
while (child!=null) {
if (Misc.isElement(child,XMLString.TEXT_LIST_ITEM) ||
Misc.isElement(child,XMLString.TEXT_LIST_HEADER)) {
return true;
}
child = child.getNextSibling();
}
return false;
}
// TODO: Merge these three methods
/*
* Process a text:ordered-list tag.
*/
private void handleOL (Node onode, int nLevel, String sStyleName, Node hnode) {
if (hasItems(onode)) {
// add an OL element
Element list = converter.createElement("ol");
StyleInfo listInfo = new StyleInfo();
getListSc().applyStyle(nLevel,sStyleName,listInfo);
applyStyle(listInfo,list);
hnode.appendChild(list);
traverseList(onode,nLevel,sStyleName,list);
}
}
/*
* Process a text:unordered-list tag.
*/
private void handleUL (Node onode, int nLevel, String sStyleName, Node hnode) {
if (hasItems(onode)) {
// add an UL element
Element list = converter.createElement("ul");
StyleInfo listInfo = new StyleInfo();
getListSc().applyStyle(nLevel,sStyleName,listInfo);
applyStyle(listInfo,list);
hnode.appendChild(list);
traverseList(onode,nLevel,sStyleName,list);
}
}
private void handleList(Node onode, int nLevel, String sStyleName, Node hnode) {
// In OpenDocument, we should use the style to determine the type of list
String sStyleName1 = Misc.getAttribute(onode,XMLString.TEXT_STYLE_NAME);
if (sStyleName1!=null) { sStyleName = sStyleName1; }
ListStyle style = ofr.getListStyle(sStyleName);
if (style!=null && style.isNumber(nLevel)) {
handleOL(onode,nLevel,sStyleName,hnode);
}
else {
handleUL(onode,nLevel,sStyleName,hnode);
}
}
/*
* Process the contents of a list (Changed as suggested by Nick Bower)
* The option xhtml_use_list_hack triggers some *invalid* code:
* - the attribute start on ol (is valid in html 4 transitional)
* - the attribute value on li (is valid in html 4 transitional)
* (these attributes are supposed to be replaced by css, but browsers
* generally don't support that)
* - generates - ...
instead of
* - ...
in case the first child of
* a list item is a new list. This occurs when a list is *continued* at
* level 2 or higher. This hack seems to be the only solution that
* actually produces correct results in browsers :-(
*/
private void traverseList (Node onode, int nLevel, String styleName, Element hnode) {
ListCounter counter = getListCounter(ofr.getListStyle(styleName));
// Restart numbering, if required
//if (counter!=null) {
boolean bContinueNumbering = "true".equals(Misc.getAttribute(onode,XMLString.TEXT_CONTINUE_NUMBERING));
if (!bContinueNumbering && counter!=null) {
counter.restart(nLevel);
}
if (config.listFormatting()==XhtmlConfig.CSS1_HACK && counter.getValue(nLevel)>0) {
hnode.setAttribute("start",Integer.toString(counter.getValue(nLevel)+1));
}
//}
if (onode.hasChildNodes()) {
NodeList nList = onode.getChildNodes();
int len = nList.getLength();
for (int i = 0; i < len; i++) {
Node child = nList.item(i);
if (child.getNodeType() == Node.ELEMENT_NODE) {
String nodeName = child.getNodeName();
if (nodeName.equals(XMLString.TEXT_LIST_ITEM)) {
// Check to see if first child is a new list
boolean bIsImmediateNestedList = false;
Element child1 = Misc.getFirstChildElement(child);
if (child1.getTagName().equals(XMLString.TEXT_ORDERED_LIST) || // old
child1.getTagName().equals(XMLString.TEXT_UNORDERED_LIST) || // old
child1.getTagName().equals(XMLString.TEXT_LIST)) { // oasis
bIsImmediateNestedList = true;
}
if (config.listFormatting()==XhtmlConfig.CSS1_HACK && bIsImmediateNestedList) {
traverseListItem(child,nLevel,styleName,hnode);
}
else {
// add an li element
//if (counter!=null) {
sCurrentListLabel = counter.step(nLevel).getLabel();
//}
currentListStyle = ofr.getListStyle(styleName);
nCurrentListLevel = nLevel;
Element item = converter.createElement("li");
StyleInfo info = new StyleInfo();
getPresentationSc().applyOutlineStyle(nLevel,info);
applyStyle(info,item);
hnode.appendChild(item);
if (config.listFormatting()==XhtmlConfig.CSS1_HACK) {
boolean bRestart = "true".equals(Misc.getAttribute(child,
XMLString.TEXT_RESTART_NUMBERING));
int nStartValue = Misc.getPosInteger(Misc.getAttribute(child,
XMLString.TEXT_START_VALUE),1);
if (bRestart) {
item.setAttribute("value",Integer.toString(nStartValue));
//if (counter!=null) {
sCurrentListLabel = counter.restart(nLevel,nStartValue).getLabel();
//}
}
}
traverseListItem(child,nLevel,styleName,item);
}
}
if (nodeName.equals(XMLString.TEXT_LIST_HEADER)) {
// add an li element
Element item = converter.createElement("li");
hnode.appendChild(item);
item.setAttribute("style","list-style-type:none");
traverseListItem(child,nLevel,styleName,item);
}
}
}
}
}
/*
* Process the contents of a list item
* (a list header should only contain paragraphs, but we don't care)
*/
private void traverseListItem (Node onode, int nLevel, String styleName, Node hnode) {
// First check if we have a single paragraph to be omitted
// This should happen if we ignore styles and have no style-map
// for the paragraph style used
if (config.xhtmlFormatting()!=XhtmlConfig.CONVERT_ALL && onode.hasChildNodes()) {
NodeList list = onode.getChildNodes();
int nLen = list.getLength();
int nParCount = 0;
boolean bNoPTag = true;
for (int i=0; i 0) {
index.set(i,entryj);
index.set(j,entryi);
}
}
}
// Generate the index
Element table = converter.createElement("table");
table.setAttribute("style","width:100%");
div.appendChild(table);
Element tr = converter.createElement("tr");
table.appendChild(tr);
Element[] td = new Element[4];
for (int i=0; i<4; i++) {
td[i] = converter.createElement("td");
td[i].setAttribute("style","vertical-align:top");
tr.appendChild(td[i]);
}
int nColEntries = nIndexIndex/4+1;
int nColIndex = -1;
for (int i=0; i<=nIndexIndex; i++) {
if (i%nColEntries==0) { nColIndex++; }
AlphabeticalEntry entry = index.get(i);
Element p = createParagraph(td[nColIndex],sEntryStyleName);
Element a = converter.createLink("idx"+entry.nIndex);
p.appendChild(a);
a.appendChild(converter.createTextNode(entry.sWord));
}
}
}
/*
* Process Bibliography
*/
private void handleBibliography (Node onode, Node hnode) {
// Use the content, not the template
// This is a temp. solution. Later we want to be able to create
// hyperlinks from the bib-item to the actual entry in the bibliography,
// so we have to recreate the bibliography from the template.
Node body = Misc.getChildByTagName(onode,XMLString.TEXT_INDEX_BODY);
if (body!=null) {
Element div = converter.createElement("div");
converter.addTarget(div,"bibliography");
hnode.appendChild(div);
//asapNode = converter.createTarget("bibliography");
Node title = Misc.getChildByTagName(body,XMLString.TEXT_INDEX_TITLE);
if (title!=null) { traverseBlockText(title,div); }
traverseBlockText(body,div);
}
}
////////////////////////////////////////////////////////////////////////
// INLINE TEXT
////////////////////////////////////////////////////////////////////////
/* Process floating frames bound to this inline text (ie. paragraph) */
private void traverseFloats(Node onode, Node hnodeBlock, Node hnodeInline) {
Node child = onode.getFirstChild();
while (child!=null) {
if (child.getNodeType()==Node.ELEMENT_NODE) {
Element elm = (Element) child;
if (OfficeReader.isDrawElement(elm)) {
elm = getDrawCv().getRealDrawElement(elm);
String sAnchor = elm.getAttribute(XMLString.TEXT_ANCHOR_TYPE);
if (Misc.isElement(elm, XMLString.DRAW_FRAME)) {
elm = Misc.getFirstChildElement(elm);
}
if (elm!=null) {
String sTag = elm.getTagName();
// Convert only floating frames; text-boxes must always float
if (!"as-char".equals(sAnchor)) {
getDrawCv().handleDrawElement(elm,(Element)hnodeBlock,
(Element)hnodeInline,nFloatMode);
}
else if (XMLString.DRAW_TEXT_BOX.equals(sTag)) {
getDrawCv().handleDrawElement(elm,(Element)hnodeBlock,
(Element)hnodeInline,DrawConverter.INLINE);
}
}
}
else if (OfficeReader.isTextElement(elm)) {
// Do not descend into {foot|end}notes
if (!OfficeReader.isNoteElement(elm)) {
traverseFloats(elm,hnodeBlock,hnodeInline);
}
}
}
child = child.getNextSibling();
}
}
/*
* Process inline text
*/
private void traverseInlineText (Node onode,Node hnode) {
//String styleName = Misc.getAttribute(onode, XMLString.TEXT_STYLE_NAME);
if (onode.hasChildNodes()) {
NodeList nList = onode.getChildNodes();
int nLen = nList.getLength();
for (int i = 0; i < nLen; i++) {
Node child = nList.item(i);
short nodeType = child.getNodeType();
switch (nodeType) {
case Node.TEXT_NODE:
String s = child.getNodeValue();
if (s.length() > 0) {
hnode.appendChild( converter.createTextNode(s) );
}
break;
case Node.ELEMENT_NODE:
String sName = child.getNodeName();
if (OfficeReader.isDrawElement(child)) {
Element elm = getDrawCv().getRealDrawElement((Element)child);
if (elm!=null) {
String sAnchor = (elm.getAttribute(XMLString.TEXT_ANCHOR_TYPE));
if ("as-char".equals(sAnchor)) {
getDrawCv().handleDrawElement(elm,null,(Element)hnode,DrawConverter.INLINE);
}
}
}
else if (child.getNodeName().equals(XMLString.TEXT_S)) {
if (config.ignoreDoubleSpaces()) {
hnode.appendChild( converter.createTextNode(" ") );
}
else {
int count= Misc.getPosInteger(Misc.getAttribute(child,XMLString.TEXT_C),1);
for ( ; count > 0; count--) {
hnode.appendChild( converter.createTextNode("\u00A0") );
}
}
}
else if (sName.equals(XMLString.TEXT_TAB_STOP)) {
handleTabStop(child,hnode);
}
else if (sName.equals(XMLString.TEXT_TAB)) { // oasis
handleTabStop(child,hnode);
}
else if (sName.equals(XMLString.TEXT_LINE_BREAK)) {
if (!config.ignoreHardLineBreaks()) {
hnode.appendChild( converter.createElement("br") );
}
}
else if (sName.equals(XMLString.TEXT_SPAN)) {
handleSpan(child,hnode);
}
else if (sName.equals(XMLString.TEXT_A)) {
handleAnchor(child,hnode);
}
else if (sName.equals(XMLString.TEXT_FOOTNOTE)) {
handleFootnote(child,hnode);
}
else if (sName.equals(XMLString.TEXT_ENDNOTE)) {
handleEndnote(child,hnode);
}
else if (sName.equals(XMLString.TEXT_NOTE)) { // oasis
if ("endnote".equals(Misc.getAttribute(child,XMLString.TEXT_NOTE_CLASS))) {
handleEndnote(child,hnode);
}
else {
handleFootnote(child,hnode);
}
}
else if (sName.equals(XMLString.TEXT_SEQUENCE)) {
handleSequence(child,hnode);
}
else if (sName.equals(XMLString.TEXT_PAGE_NUMBER)) {
handlePageNumber(child,hnode);
}
else if (sName.equals(XMLString.TEXT_PAGE_COUNT)) {
handlePageCount(child,hnode);
}
else if (sName.equals(XMLString.TEXT_SEQUENCE_REF)) {
handleSequenceRef(child,hnode);
}
else if (sName.equals(XMLString.TEXT_FOOTNOTE_REF)) {
handleNoteRef(child,hnode);
}
else if (sName.equals(XMLString.TEXT_ENDNOTE_REF)) {
handleNoteRef(child,hnode);
}
else if (sName.equals(XMLString.TEXT_NOTE_REF)) { // oasis
handleNoteRef(child,hnode);
}
else if (sName.equals(XMLString.TEXT_REFERENCE_MARK)) {
handleReferenceMark(child,hnode);
}
else if (sName.equals(XMLString.TEXT_REFERENCE_MARK_START)) {
handleReferenceMark(child,hnode);
}
else if (sName.equals(XMLString.TEXT_REFERENCE_REF)) {
handleReferenceRef(child,hnode);
}
else if (sName.equals(XMLString.TEXT_BOOKMARK)) {
handleBookmark(child,hnode);
}
else if (sName.equals(XMLString.TEXT_BOOKMARK_START)) {
handleBookmark(child,hnode);
}
else if (sName.equals(XMLString.TEXT_BOOKMARK_REF)) {
handleBookmarkRef(child,hnode);
}
else if (sName.equals(XMLString.TEXT_ALPHABETICAL_INDEX_MARK)) {
handleAlphabeticalIndexMark(child,hnode);
}
else if (sName.equals(XMLString.TEXT_ALPHABETICAL_INDEX_MARK_START)) {
handleAlphabeticalIndexMarkStart(child,hnode);
}
else if (sName.equals(XMLString.TEXT_TOC_MARK)) {
handleTocMark(child,hnode);
}
else if (sName.equals(XMLString.TEXT_TOC_MARK_START)) {
handleTocMark(child,hnode);
}
else if (sName.equals(XMLString.TEXT_BIBLIOGRAPHY_MARK)) {
handleBibliographyMark(child,hnode);
}
else if (sName.equals(XMLString.TEXT_SOFT_PAGE_BREAK)) {
if (nPageBreakSplit==XhtmlConfig.ALL) { bPendingPageBreak = true; }
}
else if (sName.equals(XMLString.OFFICE_ANNOTATION)) {
converter.handleOfficeAnnotation(child,hnode);
}
else if (sName.startsWith("text:")) {
traverseInlineText(child,hnode);
}
// other tags are ignored;
break;
default:
// Do nothing
}
}
}
}
private void handleTabStop(Node onode, Node hnode) {
// xhtml does not have tab stops, but we export and ASCII TAB character, which the
// user may choose to format
if (config.getXhtmlTabstopStyle().length()>0) {
Element span = converter.createElement("span");
hnode.appendChild(span);
span.setAttribute("class",config.getXhtmlTabstopStyle());
span.appendChild(converter.createTextNode("\t"));
}
else {
hnode.appendChild(converter.createTextNode("\t"));
}
}
private void handleSpan(Node onode, Node hnode) {
StyleWithProperties style = ofr.getTextStyle(Misc.getAttribute(onode, XMLString.TEXT_STYLE_NAME));
if (!bDisplayHiddenText && style!=null && "none".equals(style.getProperty(XMLString.TEXT_DISPLAY))) { return; }
if (!bInToc) {
String sStyleName = Misc.getAttribute(onode,XMLString.TEXT_STYLE_NAME);
Element span = createInline((Element) hnode,sStyleName);
traverseInlineText(onode,span);
}
else {
traverseInlineText(onode,hnode);
}
}
private void traversePCDATA(Node onode, Node hnode) {
if (onode.hasChildNodes()) {
NodeList nl = onode.getChildNodes();
int nLen = nl.getLength();
for (int i=0; i0) {
if (bFootnotesAtPage) { // Add footnote rule
Element rule = converter.createElement("hr");
StyleInfo info = new StyleInfo();
getPageSc().applyFootnoteRuleStyle(info);
getPageSc().applyStyle(info, rule);
hnode.appendChild(rule);
}
else if (bFinal) { // New page if required for footnotes as endnotes
if (nSplit>0) { hnode = converter.nextOutFile(); }
insertNoteHeading(hnode, config.getFootnotesHeading(), "footnotes");
}
if (bFinal || bFootnotesAtPage) { // Insert the footnotes
for (int i=0; i0) {
if (nSplit>0) { hnode = converter.nextOutFile(); }
insertNoteHeading(hnode, config.getEndnotesHeading(), "endnotes");
for (int i=0; i0) {
Element heading = converter.createElement("h1");
hnode.appendChild(heading);
heading.appendChild(converter.createTextNode(sHeading));
// Add to external content.
if (nSplit>0) {
converter.addContentEntry(sHeading, 1, null);
}
else {
//For single output file we need a target
converter.addTarget(heading,sTarget);
converter.addContentEntry(sHeading, 1, sTarget);
}
}
}
/*
* Process the contents of a footnote or endnote
*/
private void traverseNoteBody (String sId, String sCitStyle, Node citation, Node onode, Node hnode, PropertySet noteConfig) {
// Create the anchor/footnote symbol:
// Create target and link
Element link = converter.createLink("body"+sId);
converter.addTarget(link,sId);
StyleInfo linkInfo = new StyleInfo();
getTextSc().applyStyle(sCitStyle,linkInfo);
applyStyle(linkInfo,link);
String sPrefix = noteConfig.getProperty(XMLString.STYLE_NUM_PREFIX);
if (sPrefix!=null) {
link.appendChild(converter.createTextNode(sPrefix));
}
traversePCDATA(citation,link);
String sSuffix = noteConfig.getProperty(XMLString.STYLE_NUM_SUFFIX);
if (sSuffix!=null) {
link.appendChild(converter.createTextNode(sSuffix));
}
// Add a space and save it for later insertion
Element span = converter.createElement("span");
span.appendChild(link);
span.appendChild(converter.createTextNode(" "));
asapNode = span;
traverseBlockText(onode,hnode);
}
private void handlePageNumber(Node onode, Node hnode) {
// doesn't make any sense...
hnode.appendChild( converter.createTextNode("(Page number)") );
}
private void handlePageCount(Node onode, Node hnode) {
// also no sense
hnode.appendChild( converter.createTextNode("(Page count)") );
}
private void handleSequence(Node onode, Node hnode) {
// Use current value, but turn references into hyperlinks
String sName = Misc.getAttribute(onode,XMLString.TEXT_REF_NAME);
if (sName!=null && !bInToc && ofr.hasSequenceRefTo(sName)) {
Element anchor = converter.createTarget("seq"+sName);
hnode.appendChild(anchor);
traversePCDATA(onode,anchor);
}
else {
traversePCDATA(onode,hnode);
}
}
private void createReference(Node onode, Node hnode, String sPrefix) {
// Turn reference into hyperlink
String sFormat = Misc.getAttribute(onode,XMLString.TEXT_REFERENCE_FORMAT);
String sName = Misc.getAttribute(onode,XMLString.TEXT_REF_NAME);
Element anchor = converter.createLink(sPrefix+sName);
hnode.appendChild(anchor);
if ("page".equals(sFormat)) { // all page numbers are 1 :-)
anchor.appendChild( converter.createTextNode("1") );
}
else { // in other cases use current value
traversePCDATA(onode,anchor);
}
}
private void handleSequenceRef(Node onode, Node hnode) {
createReference(onode,hnode,"seq");
}
private void handleNoteRef(Node onode, Node hnode) {
createReference(onode,hnode,"");
}
private void handleReferenceMark(Node onode, Node hnode) {
String sName = Misc.getAttribute(onode,XMLString.TEXT_NAME);
if (sName!=null && !bInToc && ofr.hasReferenceRefTo(sName)) {
hnode.appendChild(converter.createTarget("ref"+sName));
}
}
private void handleReferenceRef(Node onode, Node hnode) {
createReference(onode,hnode,"ref");
}
private void handleBookmark(Node onode, Node hnode) {
// Note: Two targets (may be the target of a hyperlink or a reference)
String sName = Misc.getAttribute(onode,XMLString.TEXT_NAME);
if (sName!=null && !bInToc) {
hnode.appendChild(converter.createTarget(sName));
if (ofr.hasBookmarkRefTo(sName)) {
hnode.appendChild(converter.createTarget("bkm"+sName));
}
}
}
private void handleBookmarkRef(Node onode, Node hnode) {
createReference(onode,hnode,"bkm");
}
private void handleAlphabeticalIndexMark(Node onode, Node hnode) {
if (bInToc) { return; }
String sWord = Misc.getAttribute(onode,XMLString.TEXT_STRING_VALUE);
if (sWord==null) { return; }
AlphabeticalEntry entry = new AlphabeticalEntry();
entry.sWord = sWord; entry.nIndex = ++nIndexIndex;
index.add(entry);
hnode.appendChild(converter.createTarget("idx"+nIndexIndex));
}
private void handleAlphabeticalIndexMarkStart(Node onode, Node hnode) {
if (bInToc) { return; }
String sWord = IndexMark.getIndexValue(onode);
if (sWord==null) { return; }
AlphabeticalEntry entry = new AlphabeticalEntry();
entry.sWord = sWord; entry.nIndex = ++nIndexIndex;
index.add(entry);
hnode.appendChild(converter.createTarget("idx"+nIndexIndex));
}
private void handleTocMark(Node onode, Node hnode) {
hnode.appendChild(converter.createTarget("toc"+(++nTocIndex)));
TocEntry entry = new TocEntry();
entry.onode = (Element) onode;
entry.nFileIndex = converter.getOutFileIndex();
tocEntries.add(entry);
}
private void handleBibliographyMark(Node onode, Node hnode) {
if (bInToc) {
traversePCDATA(onode,hnode);
}
else {
Element anchor = converter.createLink("bibliography");
hnode.appendChild(anchor);
traversePCDATA(onode,anchor);
}
}
///////////////////////////////////////////////////////////////////////////
// UTILITY METHODS
///////////////////////////////////////////////////////////////////////////
// Methods to query individual formatting properties (no inheritance)
// Does this style contain the bold attribute?
private boolean isBold(StyleWithProperties style) {
String s = style.getProperty(XMLString.FO_FONT_WEIGHT,false);
return s!=null && "bold".equals(s);
}
// Does this style contain the italics/oblique attribute?
private boolean isItalics(StyleWithProperties style) {
String s = style.getProperty(XMLString.FO_FONT_STYLE,false);
return s!=null && !"normal".equals(s);
}
// Does this style contain a fixed pitch font?
private boolean isFixed(StyleWithProperties style) {
String s = style.getProperty(XMLString.STYLE_FONT_NAME,false);
String s2 = null;
String s3 = null;
if (s!=null) {
FontDeclaration fd = (FontDeclaration) ofr.getFontDeclarations().getStyle(s);
if (fd!=null) {
s2 = fd.getFontFamilyGeneric();
s3 = fd.getFontPitch();
}
}
else {
s = style.getProperty(XMLString.FO_FONT_FAMILY,false);
s2 = style.getProperty(XMLString.STYLE_FONT_FAMILY_GENERIC,false);
s3 = style.getProperty(XMLString.STYLE_FONT_PITCH,false);
}
if ("fixed".equals(s3)) { return true; }
if ("modern".equals(s2)) { return true; }
return false;
}
// Does this style specify superscript?
private boolean isSuperscript(StyleWithProperties style) {
String sPos = style.getProperty(XMLString.STYLE_TEXT_POSITION,false);
if (sPos==null) return false;
if (sPos.startsWith("sub")) return false;
if (sPos.startsWith("-")) return false;
if (sPos.startsWith("0%")) return false;
return true;
}
// Does this style specify subscript?
private boolean isSubscript(StyleWithProperties style) {
String sPos = style.getProperty(XMLString.STYLE_TEXT_POSITION,false);
if (sPos==null) return false;
if (sPos.startsWith("sub")) return true;
if (sPos.startsWith("-")) return true;
return false;
}
// Does this style specify underline?
private boolean isUnderline(StyleWithProperties style) {
String s;
if (ofr.isOpenDocument()) {
s = style.getProperty(XMLString.STYLE_TEXT_UNDERLINE_STYLE,false);
}
else {
s = style.getProperty(XMLString.STYLE_TEXT_UNDERLINE,false);
}
return s!=null && !"none".equals(s);
}
// Does this style specify overstrike?
private boolean isOverstrike(StyleWithProperties style) {
String s;
if (ofr.isOpenDocument()) {
s = style.getProperty(XMLString.STYLE_TEXT_LINE_THROUGH_STYLE,false);
}
else {
s = style.getProperty(XMLString.STYLE_TEXT_CROSSING_OUT,false);
}
return s!=null && !"none".equals(s);
}
/* apply hard formatting attribute style maps */
private Element applyAttributes(Element node, StyleWithProperties style) {
// Do nothing if we convert hard formatting
if (config.xhtmlFormatting()==XhtmlConfig.CONVERT_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_STYLES) { return node; }
// Do nothing if this is not an automatic style
if (style==null) { return node; }
if (!style.isAutomatic()) { return node; }
node = applyAttribute(node,"bold",isBold(style));
node = applyAttribute(node,"italics",isItalics(style));
node = applyAttribute(node,"fixed",isFixed(style));
node = applyAttribute(node,"superscript",isSuperscript(style));
node = applyAttribute(node,"subscript",isSubscript(style));
node = applyAttribute(node,"underline",isUnderline(style));
node = applyAttribute(node,"overstrike",isOverstrike(style));
return node;
}
/* apply hard formatting attribute style maps */
private Element applyAttribute(Element node, String sAttr, boolean bApply) {
if (bApply) {
XhtmlStyleMap xattr = config.getXAttrStyleMap();
if (xattr.contains(sAttr) && xattr.getElement(sAttr).length()>0) {
Element attr = converter.createElement(xattr.getElement(sAttr));
if (!"(none)".equals(xattr.getCss(sAttr))) {
attr.setAttribute("class",xattr.getCss(sAttr));
}
node.appendChild(attr);
return attr;
}
}
return node;
}
/* Create a styled paragraph node */
private Element createParagraph(Element node, String sStyleName) {
StyleInfo info = new StyleInfo();
getParSc().applyStyle(sStyleName,info);
Element par = converter.createElement(info.sTagName);
node.appendChild(par);
applyStyle(info,par);
StyleWithProperties style = ofr.getParStyle(sStyleName);
if (style!=null && style.isAutomatic()) {
return applyAttributes(par,style);
}
else {
return par;
}
}
/* Create an inline node with background style from paragraph style */
private Element createTextBackground(Element node, String sStyleName) {
if (config.xhtmlFormatting()==XhtmlConfig.IGNORE_ALL || config.xhtmlFormatting()==XhtmlConfig.IGNORE_HARD) {
return node;
}
String sBack = getParSc().getTextBackground(sStyleName);
if (sBack.length()>0) {
Element span = converter.createElement("span");
span.setAttribute("style",sBack);
node.appendChild(span);
return span;
}
else {
return node;
}
}
/* Create a styled inline node */
private Element createInline(Element node, String sStyleName) {
StyleInfo info = new StyleInfo();
getTextSc().applyStyle(sStyleName,info);
Element newNode = node;
if (info.hasAttributes() || !"span".equals(info.sTagName)) {
// We (probably) need to create a new element
newNode = converter.createElement(info.sTagName);
applyStyle(info,newNode);
// But we may want to merge it with the previous element
Node prev = node.getLastChild();
if (prev!=null && Misc.isElement(prev, info.sTagName)) {
// The previous node is of the same type, compare attributes
Element prevNode = (Element) prev;
if (newNode.getAttribute("class").equals(prevNode.getAttribute("class")) &&
newNode.getAttribute("style").equals(prevNode.getAttribute("style")) &&
newNode.getAttribute("xml:lang").equals(prevNode.getAttribute("xml:lang")) &&
newNode.getAttribute("dir").equals(prevNode.getAttribute("dir"))) {
// Attribute style mapped elements are *not* merged, we will live with that
return applyAttributes(prevNode,ofr.getTextStyle(sStyleName));
}
}
node.appendChild(newNode);
}
return applyAttributes(newNode,ofr.getTextStyle(sStyleName));
}
private int getOutlineLevel(Element node) {
return ofr.isOpenDocument() ?
Misc.getPosInteger(node.getAttribute(XMLString.TEXT_OUTLINE_LEVEL),1):
Misc.getPosInteger(node.getAttribute(XMLString.TEXT_LEVEL),1);
}
}
writer2latex-1.4/source/java/writer2latex/xhtml/StyleConverterHelper.java 0000644 0001750 0001750 00000010314 11536173366 025474 0 ustar rene rene /************************************************************************
*
* StyleConverterHelper.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-2011 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-03-10)
*
*/
package writer2latex.xhtml;
import writer2latex.office.OfficeReader;
import writer2latex.office.OfficeStyleFamily;
import writer2latex.office.StyleWithProperties;
import writer2latex.office.XMLString;
import writer2latex.util.ExportNameCollection;
import writer2latex.util.Misc;
/**
* This is an abstract base class to convert an OpenDocument style family to
* CSS2 styles.
*/
public abstract class StyleConverterHelper extends ConverterHelper {
// Translation of OpenDocument style names to CSS class names
protected ExportNameCollection styleNames = new ExportNameCollection(true);
// Style map to use
protected XhtmlStyleMap styleMap;
// Should we convert styles resp. hard formatting?
protected boolean bConvertStyles = true;
protected boolean bConvertHard = true;
// The type of xhtml document
protected int nType;
// Scaling and unit transformation to use
private String sScale;
private String sColScale;
private boolean bConvertToPx;
/** Create a new StyleConverterHelper
* @param ofr an OfficeReader to read style information from
* @param config the configuration to use
* @param converter the main Converter class
* @param nType the type of xhtml to use
*/
public StyleConverterHelper(OfficeReader ofr, XhtmlConfig config, Converter converter, int nType) {
super(ofr,config,converter);
this.nType = nType;
sScale = config.getXhtmlScaling();
sColScale = config.getXhtmlColumnScaling();
bConvertToPx = config.xhtmlConvertToPx();
}
protected String scale(String s) {
if (bConvertToPx) {
return Misc.length2px(Misc.multiply(sScale,s));
}
else {
return Misc.multiply(sScale,s);
}
}
protected String colScale(String s) {
return scale(Misc.multiply(sColScale,s));
}
/** Apply the writing direction (ltr or rtl) attribute from a style
* @param style the OpenDocument style to use
* @param info the StyleInfo object to add information to
*/
protected static void applyDirection(StyleWithProperties style, StyleInfo info) {
String sDir = style.getProperty(XMLString.STYLE_WRITING_MODE);
if ("lr-tb".equals(sDir)) { info.sDir="ltr"; }
else if ("rl-tb".equals(sDir)) { info.sDir="rtl"; }
}
/** Apply language+country from a style
* @param style the OpenDocument style to use
* @param info the StyleInfo object to add information to
*/
protected static void applyLang(StyleWithProperties style, StyleInfo info) {
String sLang = style.getProperty(XMLString.FO_LANGUAGE);
String sCountry = style.getProperty(XMLString.FO_COUNTRY);
if (sLang!=null) {
if (sCountry==null || sCountry.equals("none")) { info.sLang = sLang; }
else { info.sLang = sLang+"-"+sCountry; }
}
}
/** Get the OpenDocument style family associated with this
* StyleConverterHelper
* @return the style family
*/
public abstract OfficeStyleFamily getStyles();
/** Convert style information for used styles
* @param sIndent a String of spaces to add before each line
*/
public abstract String getStyleDeclarations(String sIndent);
}
writer2latex-1.4/source/java/writer2latex/epub/ 0000755 0001750 0001750 00000000000 12603463651 020274 5 ustar rene rene writer2latex-1.4/source/java/writer2latex/epub/OPFWriter.java 0000644 0001750 0001750 00000031642 12377303742 022770 0 ustar rene rene /************************************************************************
*
* OPFWriter.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: 2001-2014 by Henrik Just
*
* All Rights Reserved.
*
* version 1.4 (2014-08-26)
*
*/
package writer2latex.epub;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.UUID;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import writer2latex.api.ContentEntry;
import writer2latex.api.ConverterResult;
import writer2latex.api.OutputFile;
import writer2latex.base.DOMDocument;
import writer2latex.util.Misc;
/** This class writes an OPF-file for an EPUB document (see http://www.idpf.org/2007/opf/OPF_2.0_final_spec.html).
*/
public class OPFWriter extends DOMDocument {
private String sUID=null;
public OPFWriter(ConverterResult cr) {
super("book", "opf");
// create DOM
Document contentDOM = null;
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
DOMImplementation domImpl = builder.getDOMImplementation();
DocumentType doctype = domImpl.createDocumentType("package","","");
contentDOM = domImpl.createDocument("http://www.idpf.org/2007/opf","package",doctype);
}
catch (ParserConfigurationException t) { // this should never happen
throw new RuntimeException(t);
}
// Populate the DOM tree
Element pack = contentDOM.getDocumentElement();
pack.setAttribute("version", "2.0");
pack.setAttribute("xmlns","http://www.idpf.org/2007/opf");
pack.setAttribute("unique-identifier", "BookId");
// Meta data, at least dc:title, dc:language and dc:identifier are required by the specification
Element metadata = contentDOM.createElement("metadata");
metadata.setAttribute("xmlns:dc", "http://purl.org/dc/elements/1.1/");
metadata.setAttribute("xmlns:opf", "http://www.idpf.org/2007/opf");
pack.appendChild(metadata);
// Title and language (required)
appendElement(contentDOM, metadata, "dc:title", cr.getMetaData().getTitle());
appendElement(contentDOM, metadata, "dc:language", cr.getMetaData().getLanguage());
// Subject and keywords in ODF both map to Dublin core subjects
if (cr.getMetaData().getSubject().length()>0) {
appendElement(contentDOM, metadata, "dc:subject", cr.getMetaData().getSubject());
}
if (cr.getMetaData().getKeywords().length()>0) {
String[] sKeywords = cr.getMetaData().getKeywords().split(",");
for (String sKeyword : sKeywords) {
appendElement(contentDOM, metadata, "dc:subject", sKeyword.trim());
}
}
if (cr.getMetaData().getDescription().length()>0) {
appendElement(contentDOM, metadata, "dc:description", cr.getMetaData().getDescription());
}
// User defined meta data
// The identifier, creator, contributor and date has an optional attribute and there may be multiple instances of
// the first three. The key must be in the form name[id][.attribute]
// where the id is some unique id amongst the instances with the same name
// Furthermore the instances will be sorted on the id
// Thus you can have e.g. creator1.aut="John Doe" and creator2.aut="Jane Doe", and "John Doe" will be the first author
boolean bHasIdentifier = false;
boolean bHasCreator = false;
boolean bHasDate = false;
// First rearrange the user-defined meta data
Map userDefinedMetaData = cr.getMetaData().getUserDefinedMetaData();
Map dc = new HashMap();
for (String sKey : userDefinedMetaData.keySet()) {
if (sKey.length()>0) {
String[] sValue = new String[2];
sValue[0] = userDefinedMetaData.get(sKey);
String sNewKey;
int nDot = sKey.indexOf(".");
if (nDot>0) {
sNewKey = sKey.substring(0, nDot).toLowerCase();
sValue[1] = sKey.substring(nDot+1);
}
else {
sNewKey = sKey.toLowerCase();
sValue[1] = null;
}
dc.put(sNewKey, sValue);
}
}
// Then export it
String[] sKeys = Misc.sortStringSet(dc.keySet());
for (String sKey : sKeys) {
String sValue = dc.get(sKey)[0];
String sAttributeValue = dc.get(sKey)[1];
if (sKey.startsWith("identifier")) {
Element identifier = appendElement(contentDOM, metadata, "dc:identifier", sValue);
if (!bHasIdentifier) { // The first identifier is the unique ID
identifier.setAttribute("id", "BookId");
sUID = sValue;
}
if (sAttributeValue!=null) {
identifier.setAttribute("opf:scheme", sAttributeValue);
}
bHasIdentifier = true;
}
else if (sKey.startsWith("creator")) {
Element creator = appendElement(contentDOM, metadata, "dc:creator", sValue);
creator.setAttribute("opf:file-as", fileAs(sValue));
if (sAttributeValue!=null) {
creator.setAttribute("opf:role", sAttributeValue);
}
bHasCreator = true;
}
else if (sKey.startsWith("contributor")) {
Element contributor = appendElement(contentDOM, metadata, "dc:contributor", sValue);
contributor.setAttribute("opf:file-as", fileAs(sValue));
if (sAttributeValue!=null) {
contributor.setAttribute("opf:role", sAttributeValue);
}
}
else if (sKey.startsWith("date")) {
Element date = appendElement(contentDOM, metadata, "dc:date", sValue);
if (sAttributeValue!=null) {
date.setAttribute("opf:event", sAttributeValue);
}
bHasDate = true;
}
// Remaining properties must be unique and has not attributes, hence
else if (sAttributeValue==null) {
if ("publisher".equals(sKey)) {
appendElement(contentDOM, metadata, "dc:publisher", sValue);
}
else if ("type".equals(sKey)) {
appendElement(contentDOM, metadata, "dc:type", sValue);
}
else if ("format".equals(sKey)) {
appendElement(contentDOM, metadata, "dc:format", sValue);
}
else if ("source".equals(sKey)) {
appendElement(contentDOM, metadata, "dc:source", sValue);
}
else if ("relation".equals(sKey)) {
appendElement(contentDOM, metadata, "dc:relation", sValue);
}
else if ("coverage".equals(sKey)) {
appendElement(contentDOM, metadata, "dc:coverage", sValue);
}
else if ("rights".equals(sKey)) {
appendElement(contentDOM, metadata, "dc:rights", sValue);
}
}
}
// Fall back values for identifier, creator and date
if (!bHasIdentifier) {
// Create a universal unique ID
sUID = UUID.randomUUID().toString();
Element identifier = appendElement(contentDOM, metadata, "dc:identifier", sUID);
identifier.setAttribute("id", "BookId");
identifier.setAttribute("opf:scheme", "UUID");
}
if (!bHasCreator && cr.getMetaData().getCreator().length()>0) {
appendElement(contentDOM, metadata, "dc:creator", cr.getMetaData().getCreator())
.setAttribute("opf:file-as", fileAs(cr.getMetaData().getCreator()));
}
if (!bHasDate && cr.getMetaData().getDate().length()>0) {
// TODO: Support meta:creation-date?
appendElement(contentDOM, metadata, "dc:date", Misc.dateOnly(cr.getMetaData().getDate()));
}
// Manifest must contain references to all the files in the XHTML converter result
// Spine should contain references to all the master documents within the converter result
Element manifest = contentDOM.createElement("manifest");
pack.appendChild(manifest);
Element spine = contentDOM.createElement("spine");
spine.setAttribute("toc", "ncx");
pack.appendChild(spine);
int nMasterCount = 0;
int nResourceCount = 0;
Iterator iterator = cr.iterator();
while (iterator.hasNext()) {
OutputFile file = iterator.next();
Element item = contentDOM.createElement("item");
manifest.appendChild(item);
item.setAttribute("href",Misc.makeHref(file.getFileName()));
item.setAttribute("media-type", file.getMIMEType());
// Treat cover as recommended by Threepress consulting (http://blog.threepress.org/2009/11/20/best-practices-in-epub-cover-images/)
if (cr.getCoverFile()!=null && cr.getCoverFile().getFile()==file) {
item.setAttribute("id", "cover");
Element itemref = contentDOM.createElement("itemref");
itemref.setAttribute("idref", "cover");
itemref.setAttribute("linear", "no"); // maybe problematic
spine.appendChild(itemref);
}
else if (cr.getCoverImageFile()!=null && cr.getCoverImageFile().getFile()==file) {
item.setAttribute("id", "cover-image");
Element meta = contentDOM.createElement("meta");
meta.setAttribute("name", "cover");
meta.setAttribute("content", "cover-image");
metadata.appendChild(meta);
}
else if (file.isMasterDocument()) {
String sId = "text"+(++nMasterCount);
item.setAttribute("id", sId);
Element itemref = contentDOM.createElement("itemref");
itemref.setAttribute("idref", sId);
spine.appendChild(itemref);
}
else {
item.setAttribute("id", "resource"+(++nResourceCount));
}
}
Element item = contentDOM.createElement("item");
item.setAttribute("href", "book.ncx");
item.setAttribute("media-type", "application/x-dtbncx+xml");
item.setAttribute("id", "ncx");
manifest.appendChild(item);
// The guide may contain references to some fundamental structural components
Element guide = contentDOM.createElement("guide");
pack.appendChild(guide);
addGuideReference(contentDOM,guide,"cover",cr.getCoverFile());
addGuideReference(contentDOM,guide,"title-page",cr.getTitlePageFile());
addGuideReference(contentDOM,guide,"text",cr.getTextFile());
addGuideReference(contentDOM,guide,"toc",cr.getTocFile());
addGuideReference(contentDOM,guide,"index",cr.getIndexFile());
addGuideReference(contentDOM,guide,"loi",cr.getLofFile());
addGuideReference(contentDOM,guide,"lot",cr.getLotFile());
addGuideReference(contentDOM,guide,"bibliography",cr.getBibliographyFile());
setContentDOM(contentDOM);
}
/** Get the unique ID associated with this EPUB document (either collected from the user-defined
* meta data or a generated UUID)
*
* @return the ID
*/
public String getUid() {
return sUID;
}
private String fileAs(String sName) {
int nSpace = sName.lastIndexOf(' ');
if (nSpace>-1) {
return sName.substring(nSpace+1).trim()+", "+sName.substring(0, nSpace).trim();
}
else {
return sName.trim();
}
}
private Element appendElement(Document contentDOM, Element node, String sTagName, String sContent) {
Element child = contentDOM.createElement(sTagName);
node.appendChild(child);
child.appendChild(contentDOM.createTextNode(sContent));
return child;
}
private void addGuideReference(Document contentDOM, Element guide, String sType, ContentEntry entry) {
if (entry!=null) {
Element reference = contentDOM.createElement("reference");
reference.setAttribute("type", sType);
reference.setAttribute("title", entry.getTitle());
String sHref = Misc.makeHref(entry.getFile().getFileName());
if (entry.getTarget()!=null) { sHref+="#"+entry.getTarget(); }
reference.setAttribute("href", sHref);
guide.appendChild(reference);
}
}
}
writer2latex-1.4/source/java/writer2latex/epub/EPUBConverter.java 0000644 0001750 0001750 00000004316 12411031012 023541 0 ustar rene rene /************************************************************************
*
* EPUBConverter.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: 2001-2014 by Henrik Just
*
* All Rights Reserved.
*
* version 1.4 (2014-09-24)
*
*/
package writer2latex.epub;
import java.io.IOException;
import java.io.InputStream;
import writer2latex.api.ConverterResult;
import writer2latex.base.ConverterResultImpl;
import writer2latex.xhtml.Xhtml11Converter;
/** This class converts an OpenDocument file to an EPUB document.
*/
public final class EPUBConverter extends Xhtml11Converter {
// Constructor
public EPUBConverter() {
super();
}
@Override public ConverterResult convert(InputStream is, String sTargetFileName) throws IOException {
setOPS(true);
ConverterResult xhtmlResult = super.convert(is, "chapter");
return createPackage(xhtmlResult,sTargetFileName);
}
@Override public ConverterResult convert(org.w3c.dom.Document dom, String sTargetFileName, boolean bDestructive) throws IOException {
setOPS(true);
ConverterResult xhtmlResult = super.convert(dom, "chapter", bDestructive);
return createPackage(xhtmlResult,sTargetFileName);
}
private ConverterResult createPackage(ConverterResult xhtmlResult, String sTargetFileName) {
ConverterResultImpl epubResult = new ConverterResultImpl();
epubResult.addDocument(new EPUBWriter(xhtmlResult,sTargetFileName,getXhtmlConfig()));
epubResult.setMetaData(xhtmlResult.getMetaData());
return epubResult;
}
} writer2latex-1.4/source/java/writer2latex/epub/EPUBWriter.java 0000644 0001750 0001750 00000007643 12403642160 023071 0 ustar rene rene /************************************************************************
*
* EPUBWriter.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: 2001-2014 by Henrik Just
*
* All Rights Reserved.
*
* version 1.4 (2014-09-07)
*
*/
package writer2latex.epub;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import writer2latex.api.ConverterResult;
import writer2latex.api.OutputFile;
import writer2latex.util.Misc;
import writer2latex.xhtml.XhtmlConfig;
/** This class repackages an XHTML document into EPUB format.
* Some filenames are hard wired in this implementation: The main directory is OEBPS and
* the OPF and NCX files are book.opf and book.ncx respectively
*/
public class EPUBWriter implements OutputFile {
private static final byte[] mimeBytes = { 'a', 'p', 'p', 'l', 'i', 'c', 'a', 't', 'i', 'o', 'n', '/',
'e', 'p', 'u', 'b', '+', 'z', 'i', 'p'};
private ConverterResult xhtmlResult;
private String sFileName;
//private XhtmlConfig config;
public EPUBWriter(ConverterResult xhtmlResult, String sFileName, XhtmlConfig config) {
this.xhtmlResult = xhtmlResult;
this.sFileName = Misc.removeExtension(sFileName);
//this.config = config;
}
public String getFileName() {
return sFileName+".epub";
}
public String getMIMEType() {
return "application/epub+zip";
}
public boolean isMasterDocument() {
return true;
}
public void write(OutputStream os) throws IOException {
ZipOutputStream zos = new ZipOutputStream(os);
// Write uncompressed MIME type as first entry
ZipEntry mimeEntry = new ZipEntry("mimetype");
mimeEntry.setMethod(ZipEntry.STORED);
mimeEntry.setCrc(0x2CAB616F);
mimeEntry.setSize(mimeBytes.length);
zos.putNextEntry(mimeEntry);
zos.write(mimeBytes, 0, mimeBytes.length);
zos.closeEntry();
// Write container entry next
OutputFile containerWriter = new ContainerWriter();
ZipEntry containerEntry = new ZipEntry("META-INF/container.xml");
zos.putNextEntry(containerEntry);
writeZipEntry(containerWriter,zos);
zos.closeEntry();
// Then manifest
OPFWriter manifest = new OPFWriter(xhtmlResult);
ZipEntry manifestEntry = new ZipEntry("OEBPS/book.opf");
zos.putNextEntry(manifestEntry);
writeZipEntry(manifest,zos);
zos.closeEntry();
// And content table
OutputFile ncx = new NCXWriter(xhtmlResult, manifest.getUid());
ZipEntry ncxEntry = new ZipEntry("OEBPS/book.ncx");
zos.putNextEntry(ncxEntry);
writeZipEntry(ncx,zos);
zos.closeEntry();
// Finally XHTML content
Iterator iter = xhtmlResult.iterator();
while (iter.hasNext()) {
OutputFile file = iter.next();
ZipEntry entry = new ZipEntry("OEBPS/"+file.getFileName());
zos.putNextEntry(entry);
writeZipEntry(file, zos);
zos.closeEntry();
}
zos.close();
}
private void writeZipEntry(OutputFile file, ZipOutputStream zos) throws IOException {
// Unfortunately we cannot simply do file.write(zos) because the write method of OutputFile
// closes the OutputStream. Hence this suboptimal solution
ByteArrayOutputStream baos = new ByteArrayOutputStream();
file.write(baos);
byte[] content = baos.toByteArray();
zos.write(content, 0, content.length);
}
}
writer2latex-1.4/source/java/writer2latex/epub/ContainerWriter.java 0000644 0001750 0001750 00000005414 12377303742 024264 0 ustar rene rene /************************************************************************
*
* ContainerWriter.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: 2001-2014 by Henrik Just
*
* All Rights Reserved.
*
* version 1.4 (2014-08-26)
*
*/
package writer2latex.epub;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import writer2latex.base.DOMDocument;
/** This class creates the required META-INF/container.xml file for an EPUB package
* (see http://www.idpf.org/ocf/ocf1.0/download/ocf10.htm).
*/
public class ContainerWriter extends DOMDocument {
public ContainerWriter() {
super("container", "xml");
// create DOM
Document contentDOM = null;
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
DOMImplementation domImpl = builder.getDOMImplementation();
DocumentType doctype = domImpl.createDocumentType("container","","");
contentDOM = domImpl.createDocument("urn:oasis:names:tc:opendocument:xmlns:container","container",doctype);
}
catch (ParserConfigurationException t) { // this should never happen
throw new RuntimeException(t);
}
// Populate the DOM tree
Element container = contentDOM.getDocumentElement();
container.setAttribute("version", "1.0");
container.setAttribute("xmlns","urn:oasis:names:tc:opendocument:xmlns:container");
Element rootfiles = contentDOM.createElement("rootfiles");
container.appendChild(rootfiles);
Element rootfile = contentDOM.createElement("rootfile");
rootfile.setAttribute("full-path", "OEBPS/book.opf");
rootfile.setAttribute("media-type", "application/oebps-package+xml");
rootfiles.appendChild(rootfile);
setContentDOM(contentDOM);
}
}
writer2latex-1.4/source/java/writer2latex/epub/Package.html 0000644 0001750 0001750 00000000463 11351636127 022517 0 ustar rene rene
The package writer2latex.epub
This package contains EPUB specific code.
It contains a writerlatex.api.Converter implementation for
conversion into EPUB.
writer2latex-1.4/source/java/writer2latex/epub/NCXWriter.java 0000644 0001750 0001750 00000014364 12377303742 022776 0 ustar rene rene /************************************************************************
*
* NCXWriter.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: 2001-2014 by Henrik Just
*
* All Rights Reserved.
*
* version 1.4 (2014-08-26)
*
*/
package writer2latex.epub;
import java.util.Iterator;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import writer2latex.api.ContentEntry;
import writer2latex.api.ConverterResult;
import writer2latex.base.DOMDocument;
import writer2latex.util.Misc;
/** This class creates the required NXC file for an EPUB document
* (see http://www.idpf.org/2007/opf/OPF_2.0_final_spec.html#Section2.4).
*/
public class NCXWriter extends DOMDocument {
public NCXWriter(ConverterResult cr, String sUUID) {
super("book", "ncx");
// create DOM
Document contentDOM = null;
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
DOMImplementation domImpl = builder.getDOMImplementation();
DocumentType doctype = domImpl.createDocumentType("ncx","","");
contentDOM = domImpl.createDocument("http://www.daisy.org/z3986/2005/ncx/","ncx",doctype);
}
catch (ParserConfigurationException t) { // this should never happen
throw new RuntimeException(t);
}
// Populate the DOM tree
Element ncx = contentDOM.getDocumentElement();
ncx.setAttribute("version", "2005-1");
ncx.setAttribute("xml:lang", cr.getMetaData().getLanguage());
ncx.setAttribute("xmlns","http://www.daisy.org/z3986/2005/ncx/");
// The head has four required meta data items
Element head = contentDOM.createElement("head");
ncx.appendChild(head);
Element uid = contentDOM.createElement("meta");
uid.setAttribute("name","dtb:uid");
uid.setAttribute("content", sUUID);
head.appendChild(uid);
Element depth = contentDOM.createElement("meta");
depth.setAttribute("name","dtb:depth");
// Setting the content attribute later
head.appendChild(depth);
Element totalPageCount = contentDOM.createElement("meta");
totalPageCount.setAttribute("name","dtb:totalPageCount");
totalPageCount.setAttribute("content", "0");
head.appendChild(totalPageCount);
Element maxPageNumber = contentDOM.createElement("meta");
maxPageNumber.setAttribute("name","dtb:maxPageNumber");
maxPageNumber.setAttribute("content", "0");
head.appendChild(maxPageNumber);
// The ncx must contain a docTitle element
Element docTitle = contentDOM.createElement("docTitle");
ncx.appendChild(docTitle);
Element docTitleText = contentDOM.createElement("text");
docTitle.appendChild(docTitleText);
docTitleText.appendChild(contentDOM.createTextNode(cr.getMetaData().getTitle()));
// Build the navMap from the content table in the converter result
Element navMap = contentDOM.createElement("navMap");
ncx.appendChild(navMap);
Element currentContainer = ncx;
int nCurrentLevel = 0;
int nCurrentEntryLevel = 0; // This may differ from nCurrentLevel if the heading levels "jump" in then document
int nDepth = 0;
int nPlayOrder = 0;
Iterator content = cr.getContent().iterator();
while (content.hasNext()) {
ContentEntry entry = content.next();
int nEntryLevel = Math.max(entry.getLevel(), 1);
if (nEntryLevelnCurrentEntryLevel) {
// To lower level (always one step; a jump from e.g. heading 1 to heading 3 in the document
// is considered an error)
currentContainer = (Element) currentContainer.getLastChild();
nCurrentLevel++;
}
nCurrentEntryLevel = nEntryLevel;
Element navPoint = contentDOM.createElement("navPoint");
navPoint.setAttribute("playOrder", Integer.toString(++nPlayOrder));
navPoint.setAttribute("id", "text"+nPlayOrder);
currentContainer.appendChild(navPoint);
Element navLabel = contentDOM.createElement("navLabel");
navPoint.appendChild(navLabel);
Element navLabelText = contentDOM.createElement("text");
navLabel.appendChild(navLabelText);
navLabelText.appendChild(contentDOM.createTextNode(entry.getTitle()));
Element navPointContent = contentDOM.createElement("content");
String sHref = Misc.makeHref(entry.getFile().getFileName());
if (entry.getTarget()!=null) { sHref+="#"+entry.getTarget(); }
navPointContent.setAttribute("src", sHref);
navPoint.appendChild(navPointContent);
nDepth = Math.max(nDepth, nCurrentLevel);
}
if (nDepth==0) {
// TODO: We're in trouble: The document has no headings
}
depth.setAttribute("content", Integer.toString(nDepth));
setContentDOM(contentDOM);
}
}
writer2latex-1.4/source/java/writer2latex/api/ 0000755 0001750 0001750 00000000000 12603463651 020112 5 ustar rene rene writer2latex-1.4/source/java/writer2latex/api/ConverterFactory.java 0000644 0001750 0001750 00000013131 12470406570 024252 0 ustar rene rene /************************************************************************
*
* ConverterFactory.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-2015 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.4 (2015-02-16)
*
*/
package writer2latex.api;
/** This is a factory class which provides static methods to create converters
* for documents in OpenDocument (or OpenOffice.org 1.x) format into a specific MIME type
*/
public class ConverterFactory {
// Version information
private static final String VERSION = "1.4";
private static final String DATE = "2014-02-16";
/** Return the Writer2LaTeX version in the form
* (major version).(minor version).(patch level)
* Development versions have an odd minor version number
* @return the version number
*/
public static String getVersion() { return VERSION; }
/** Return date information
* @return the release date for this Writer2LaTeX version
*/
public static String getDate() { return DATE; }
/** Create a Converter implementation which supports
* conversion into the specified MIME type.
* Currently supported MIME types are:
*
* application/x-latex for LaTeX formatapplication/x-bibtex for BibTeX formattext/html for XHTML 1.0 strict formatapplication/xhtml11 for XHTML 1.1 format
* Note that this is not the recommended media type for XHTML 1.1
* (see http://www.w3.org/TR/xhtml-media-types/), but it is used internally
* by Writer2xhtml to distinguish from XHTML+MathMLapplication/xhtml+xml for XHTML+MathMLtext/html5 for HTML5 documents
* Note that this is not the recommended media type for HTML5
* (see http://wiki.whatwg.org/), but it is used internally
* by Writer2xhtml to distinguish from HTML5application/epub+zip
*
* @param sMIME the MIME type of the target format
* @return the required Converter or null if a converter for
* the requested MIME type could not be created
*/
public static Converter createConverter(String sMIME) {
Object converter = null;
if (MIMETypes.LATEX.equals(sMIME)) {
converter = createInstance("writer2latex.latex.ConverterPalette");
}
else if (MIMETypes.BIBTEX.equals(sMIME)) {
converter = createInstance("writer2latex.bibtex.Converter");
}
else if (MIMETypes.XHTML.equals(sMIME)) {
converter = createInstance("writer2latex.xhtml.Xhtml10Converter");
}
else if (MIMETypes.XHTML11.equals(sMIME)) {
converter = createInstance("writer2latex.xhtml.Xhtml11Converter");
}
else if (MIMETypes.XHTML_MATHML.equals(sMIME)) {
converter = createInstance("writer2latex.xhtml.XhtmlMathMLConverter");
}
else if (MIMETypes.HTML5.equals(sMIME)) {
converter = createInstance("writer2latex.xhtml.Html5Converter");
}
else if (MIMETypes.EPUB.equals(sMIME)) {
converter = createInstance("writer2latex.epub.EPUBConverter");
}
return converter instanceof Converter ? (Converter) converter : null;
}
/** Create a BatchConverter implementation which supports
* conversion into the specified MIME type
* The only currently supported MIME type is text/html
* (XHTML 1.0 strict)
*
* @param sMIME the MIME type of the target format
* @return the required BatchConverter or null if a converter
* for the requested MIME type could not be created
*/
public static BatchConverter createBatchConverter(String sMIME) {
Object converter = null;
if (MIMETypes.XHTML.equals(sMIME)) {
converter = createInstance("writer2latex.xhtml.BatchConverterImpl");
}
return converter instanceof BatchConverter ? (BatchConverter) converter : null;
}
/** Create a StarMathConverter implementation
*
* @return the converter
*/
public static StarMathConverter createStarMathConverter() {
Object converter = createInstance("writer2latex.latex.StarMathConverter");
return converter instanceof StarMathConverter ? (StarMathConverter) converter : null;
}
private static Object createInstance(String sClassName) {
try {
return Class.forName(sClassName).newInstance();
}
catch (java.lang.ClassNotFoundException e) {
return null;
}
catch (java.lang.InstantiationException e) {
return null;
}
catch (java.lang.IllegalAccessException e) {
return null;
}
}
}
writer2latex-1.4/source/java/writer2latex/api/MetaData.java 0000644 0001750 0001750 00000004325 11502355120 022425 0 ustar rene rene /************************************************************************
*
* MetaData.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 (2010-12-15)
*
*/
package writer2latex.api;
import java.util.Map;
/** This interface provides access to the predefined meta data of the
* source document (currently incomplete)
*/
public interface MetaData {
/** Get the title of the source document
*
* @return the title (may return an empty string)
*/
public String getTitle();
/** Get the subject of the source document
*
* @return the subject (may return an empty string)
*/
public String getSubject();
/** Get the keywords of the source document
*
* @return the keywords as a comma separated list (may return an empty string)
*/
public String getKeywords();
/** Get the description of the source document
*
* @return the description (may return an empty string)
*/
public String getDescription();
/** Get the creator of the source document (or the initial creator if none is specified)
*
* @return the creator (may return an empty string)
*/
public String getCreator();
/** Get the (main) language of the document
*
* @return the language
*/
public String getLanguage();
/** Get the date of the source document
*
* @return the date (may return an empty string)
*/
public String getDate();
/** Get the user-defined meta data
*
* @return the user-defined meta data as a name-value map
*/
public Map getUserDefinedMetaData();
}
writer2latex-1.4/source/java/writer2latex/api/StarMathConverter.java 0000644 0001750 0001750 00000003437 11147474702 024400 0 ustar rene rene /************************************************************************
*
* StarMathConverter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-11-23)
*
*/
package writer2latex.api;
//import java.io.InputStream;
//import java.io.IOException;
/** This is an interface for a converter, which offers conversion of
* a StarMath formula into LaTeX
* Instances of this interface are created using the
* {@link ConverterFactory}
*/
public interface StarMathConverter {
/** Get the configuration used when converting.
*
* @return the configuration used by this converter
*/
public Config getConfig();
/** Convert a StarMath formula
*
* @param sStarMathFormula is a string containing the StarMath formula
* @return a string containing the converted LaTeX formula
*/
public String convert(String sStarMathFormula);
/** Create a suitable LaTeX preamble to process the formulas converted so far
*
* @return a string containg the entire LaTeX preamble
*/
public String getPreamble();
}
writer2latex-1.4/source/java/writer2latex/api/Converter.java 0000644 0001750 0001750 00000015316 12401536577 022736 0 ustar rene rene /************************************************************************
*
* Converter.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-08-28)
*
*/
package writer2latex.api;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.IOException;
/** This is an interface for a converter, which offers conversion of
* OpenDocument (or OpenOffice.org 1.x) documents into a specific format.
* Instances of this interface are created using the
* ConverterFactory
*/
public interface Converter {
/** Get the interface for the configuration of this converter
*
* @return the configuration
*/
public Config getConfig();
/** Define a GraphicConverter implementation to use for
* conversion of graphic files. If no converter is specified, graphic
* files will not be converted into other formats.
*
* @param gc the GraphicConverter to use
*/
public void setGraphicConverter(GraphicConverter gc);
/** Read a template to use as a base for the converted document.
* The format of the template depends on the Converter
* implementation.
*
* @param is an InputStream from which to read the template
* @throws IOException if some exception occurs while reading the template
*/
public void readTemplate(InputStream is) throws IOException;
/** Read a template to use as a base for the converted document.
* The format of the template depends on the Converter
* implementation.
*
* @param file a file from which to read the template
* @throws IOException if the file does not exist or some exception occurs
* while reading the template
*/
public void readTemplate(File file) throws IOException;
/** Read a style sheet to include with the converted document.
* The format of the style sheet depends on the Converter
* implementation.
*
* @param is an InputStream from which to read the style sheet
* @throws IOException if some exception occurs while reading the style sheet
*/
public void readStyleSheet(InputStream is) throws IOException;
/** Read a style sheet to include with the converted document.
* The format of the style sheet depends on the Converter
* implementation.
*
* @param file a file from which to read the style sheet
* @throws IOException if the file does not exist or some exception occurs
* while reading the style sheet
*/
public void readStyleSheet(File file) throws IOException;
/** Read a resource to include with the converted document.
* A resource can be any (binary) file and will be placed in the same directory as
* the style sheet
*
* @param is an InputStream from which to read the resource
* @param sFileName the file name to use for the resource
* @param sMediaType the media type of the resource, if null the media type will be guessed from the file name
* @throws IOException if some exception occurs while reading the resource
*/
public void readResource(InputStream is, String sFileName, String sMediaType) throws IOException;
/** Read a style sheet to include with the converted document.
* A resource can be any (binary) file and will be placed in the same directory as
* the style sheet
*
* @param file a file from which to read the style sheet
* @param sFileName the file name to use for the resource
* @param sMediaType the media type of the resource, if null the media type will be guessed from the file name
* @throws IOException if the file does not exist or some exception occurs
* while reading the resource
*/
public void readResource(File file, String sFileName, String sMediaType) throws IOException;
/** Convert a document
*
* @param is an InputStream from which to read the source document.
* @param sTargetFileName the file name to use for the converted document
* (if the converted document is a compound document consisting consisting
* of several files, this name will be used for the master document)
* @return a ConverterResult containing the converted document
* @throws IOException if some exception occurs while reading the document
*/
public ConverterResult convert(InputStream is, String sTargetFileName)
throws IOException;
/** Convert a document
*
* @param source a File from which to read the source document.
* @param sTargetFileName the file name to use for the converted document
* (if the converted document is a compound document consisting consisting
* of several files, this name will be used for the master document)
* @return a ConverterResult containing the converted document
* @throws FileNotFoundException if the file does not exist
* @throws IOException if some exception occurs while reading the document
*/
public ConverterResult convert(File source, String sTargetFileName)
throws FileNotFoundException, IOException;
/** Convert a document
*
* @param dom a DOM tree representing the document as flat XML
* @param sTargetFileName the file name to use for the converted document
* (if the converted document is a compound document consisting consisting
* of several files, this name will be used for the master document)
* @param bDestructive set to true if the converter is allowed to remove contents from the DOM tree (to save memory)
* @return a ConverterResult containing the converted document
* @throws IOException if some exception occurs while reading the document
*/
public ConverterResult convert(org.w3c.dom.Document dom, String sTargetFileName, boolean bDestructive)
throws IOException;
}
writer2latex-1.4/source/java/writer2latex/api/OutputFile.java 0000644 0001750 0001750 00000004165 11354104754 023061 0 ustar rene rene /************************************************************************
*
* OutputFile.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 (2010-03-28)
*
*/
package writer2latex.api;
import java.io.OutputStream;
import java.io.IOException;
/** An OutputFile represents a single file in a
* {@link ConverterResult}, which is output from a {@link Converter}
* implementation.
*/
public interface OutputFile {
/** Writes the OutputFile to an OutputStream.
*
* @param os OutputStream to which the content should be written
* @throws IOException if any I/O error occurs
*/
public void write(OutputStream os) throws IOException;
/** Returns the file name of the OutputFile. This includes
* the file extension and may also include a relative path, always using
* / as separator.
*
* @return the file name of this OutputFile
*/
public String getFileName();
/** Get the MIME type of the OutputFile.
*
* @return string representation of the MIME type
*/
public String getMIMEType();
/** Test whether this document is part of the main document flow (master documents) or
* an auxiliary document
*
* @return true if this document is a master document
*/
public boolean isMasterDocument();
}
writer2latex-1.4/source/java/writer2latex/api/BatchHandler.java 0000644 0001750 0001750 00000005045 11147474702 023301 0 ustar rene rene /************************************************************************
*
* BatchHandler.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-11-23)
*
*/
package writer2latex.api;
/** This is a call back interface to handle user interaction during a
* batch conversion with a {@link BatchConverter}
*/
public interface BatchHandler {
/** Notification that the conversion is started */
public void startConversion();
/** Notification that the conversion has finished */
public void endConversion();
/** Notification that a directory conversion starts
*
* @param sName the name of the directory to convert
*/
public void startDirectory(String sName);
/** Notification that a directory conversion has finished
*
* @param sName the name of the directory
* @param bSuccess true if the conversion was successful (this only means
* that the index page was created with success, not that the conversion
* of files and subdirectories was successful)
*/
public void endDirectory(String sName, boolean bSuccess);
/** Notification that a file conversion starts
*
* @param sName the name of the file to convert
*/
public void startFile(String sName);
/** Notification that a file conversion has finished
*
* @param sName the name of the file
* @param bSuccess true if the conversion of this file was successful
*/
public void endFile(String sName, boolean bSuccess);
/** Notification that the conversion may be cancelled. The
* {@link BatchConverter} fires this event once per document.
* Cancelling the conversion does not delete files that was already
* converted
*
* @return true if the handler wants to cancel the conversion
*/
public boolean cancel();
}
writer2latex-1.4/source/java/writer2latex/api/Config.java 0000644 0001750 0001750 00000006676 11351636127 022200 0 ustar rene rene /************************************************************************
*
* Config.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-09-22)
*
*/
package writer2latex.api;
import java.io.File;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.IllegalArgumentException;
/** This is an interface for configuration of a {@link Converter}.
* A configuration always supports simple name/value options.
* In addition, you can read and write configurations using streams
* or abstract file names. The format depends on the {@link Converter}
* implementation, cf. the user's manual.
*/
public interface Config {
/** Read a default configuration: The available configurations depend on the
* {@link Converter} implementation
*
* @param sName the name of the configuration
* @throws IllegalArgumentException if the configuration does not exist
*/
public void readDefaultConfig(String sName) throws IllegalArgumentException;
/** Read a configuration (stream based version)
*
* @param is the InputStream to read from
* @throws IOException if an error occurs reading the stream, or the data
* is not in the right format
*/
public void read(InputStream is) throws IOException;
/** Read a configuration (file based version)
*
* @param file the File to read from
* @throws IOException if the file does not exist, an error occurs reading
* the file, or the data is not in the right format
*/
public void read(File file) throws IOException;
/** Write the configuration (stream based version)
*
* @param os the OutputStream to write to
* @throws IOException if an error occurs writing to the stream
*/
public void write(OutputStream os) throws IOException;
/** Write the configuration (file based version)
*
* @param file the File to write to
* @throws IOException if an error occurs writing to the file
*/
public void write(File file) throws IOException;
/** Set a name/value option. Options that are not defined by the
* {@link Converter} implementation as well as null values are
* silently ignored
*
* @param sName the name of the option
* @param sValue the value of the option
*/
public void setOption(String sName, String sValue);
/** Get a named option
*
* @param sName the name of the option
* @return the value of the option, or null if the option does
* not exist or the given name is null
*/
public String getOption(String sName);
/** Get a complex option
*
* @param sName the name of the complex option
* @return the option
*/
public ComplexOption getComplexOption(String sName);
}
writer2latex-1.4/source/java/writer2latex/api/IndexPageEntry.java 0000644 0001750 0001750 00000007346 11251136744 023653 0 ustar rene rene /************************************************************************
*
* IndexPageEntry.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.0 (2009-02-08)
*
*/
package writer2latex.api;
/** This class represents a single entry on an index page created by a batch converter
*/
public class IndexPageEntry {
private String sFile;
private String sDisplayName;
private String sDescription = null;
private String sPdfFile = null;
private String sOriginalFile = null;
private boolean bIsDirectory;
/** Construct a new IndexPageEntry based on a file name.
* The file name is also used as display name.
*
* @param sFile the file name for this entry
* @param bIsDirectory true if this is a directory, false if it is a file
*/
public IndexPageEntry(String sFile, boolean bIsDirectory) {
this.sFile = sFile;
this.sDisplayName = sFile;
this.bIsDirectory = bIsDirectory;
}
/** Set the file name
*
* @param sFile the file name
*/
public void setFile(String sFile) {
this.sFile = sFile;
}
/** Set the display name for this entry. The display name is the
* name presented on the index page.
*
* @param sDisplayName the display name
*/
public void setDisplayName(String sDisplayName) {
this.sDisplayName = sDisplayName;
}
/** Set the description of this file (additional information about the file)
*
* @param sDescription the description
*/
public void setDescription(String sDescription) {
this.sDescription = sDescription;
}
/** Set the file name for a pdf file associated with this file
*
* @param sPdfFile the file name
*/
public void setPdfFile(String sPdfFile) {
this.sPdfFile = sPdfFile;
}
/** Set the file name for the original file
*
* @param sOriginalFile the origianl file name
*/
public void setOriginalFile(String sOriginalFile) {
this.sOriginalFile = sOriginalFile;
}
/** Get the file name
*
* @return the file name
*/
public String getFile() {
return sFile;
}
/** Get the display name
*
* @return the display name
*/
public String getDisplayName() {
return sDisplayName;
}
/** Get the description
*
* @return the description, or null if there is no description
*/
public String getDescription() {
return sDescription;
}
/** Get the pdf file name
*
* @return the file name or null if there is none
*/
public String getPdfFile() {
return sPdfFile;
}
/** Get the original file name
*
* @return the file name or null if there is none
*/
public String getOriginalFile() {
return sOriginalFile;
}
/** Check whether this is a file or a directory
*
* @return true for a directory, false for a file
*/
public boolean isDirectory() {
return bIsDirectory;
}
}
writer2latex-1.4/source/java/writer2latex/api/ContentEntry.java 0000644 0001750 0001750 00000003407 11351636127 023414 0 ustar rene rene /************************************************************************
*
* ContentEntry.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 (2010-03-15)
*
*/
package writer2latex.api;
/** This interface represents a content entry, that is a named reference
* to a position within the output document.
*/
public interface ContentEntry {
/** Get the outline level of this ContentEntry.
* The top level is 1 (entries corresponding to indexes are considered
* top level).
* Note that intermediate levels may be missing (e.g. a heading of
* level 3 may follow immediately after a heading of level 1).
*
* @return the outline level
*/
public int getLevel();
/** Get the title for this entry
*
* @return the title
*/
public String getTitle();
/** Get the file associated with the entry
*
* @return the output file
*/
public OutputFile getFile();
/** Get the name of a target within the file, if any
*
* @return the target name, or null if no target is needed
*/
public String getTarget();
}
writer2latex-1.4/source/java/writer2latex/api/BatchConverter.java 0000644 0001750 0001750 00000007200 11147474702 023666 0 ustar rene rene /************************************************************************
*
* BatchConverter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-11-23)
*
*/
package writer2latex.api;
import java.io.File;
import java.io.InputStream;
import java.io.IOException;
/** This is an interface for a converter, which offers conversion of
* all OpenDocument (or OpenOffice.org 1.x) documents in a directory
* (and optionally subdirectories), creating index pages in a specific format.
* Instances of this interface are created using the
* {@link ConverterFactory}
*/
public interface BatchConverter {
/** Get the configuration interface for this batch converter
*
* @return the configuration
*/
public Config getConfig();
/** Define a Converter implementation to use for
* conversion of the individual documents.
* If no converter is given, the convert method cannot
* convert documents (but can still create index pages).
*
* @param converter the Converter to use
*/
public void setConverter(Converter converter);
/** Read a template to use as a base for the index pages.
* The format of the template depends on the BatchConverter
* implementation.
*
* @param is an InputStream from which to read the template
* @throws IOException if some exception occurs while reading the template
*/
public void readTemplate(InputStream is) throws IOException;
/** Read a template to use as a base for the index pages.
* The format of the template depends on the BatchConverter
* implementation.
*
* @param file the file from which to read the template
* @throws IOException if the file does not exist or some exception occurs
* while reading the template
*/
public void readTemplate(File file) throws IOException;
/** Create an index page with specific entries
*
* @param sHeading a heading describing the index page
* @param entries an array of IndexPageEntry objects (null entries
* are allowed, and will be ignored) describing the individual directories
* and documents
*/
public OutputFile createIndexFile(String sHeading, IndexPageEntry[] entries);
/** Convert a directory using the given Converter (if none is given,
* all files will be ignored).
* This method fails silently if you haven't set a converter.
*
* @param source a File representing the directory to convert
* @param target a File representing the directory to contain
* the converted documents
* @param bRecurse determines wether or not to recurse into subdirectories
* @param handler a BatchHandler
*/
public void convert(File source, File target, boolean bRecurse, BatchHandler handler);
}
writer2latex-1.4/source/java/writer2latex/api/MIMETypes.java 0000644 0001750 0001750 00000004644 12373123423 022533 0 ustar rene rene /************************************************************************
*
* MIMETypes.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-08-13)
*
*/
package writer2latex.api;
/* Some helpers to handle the MIME types used by OOo and Writer2LaTeX
*/
public class MIMETypes {
// Various graphics formats, see
// http://api.openoffice.org/docs/common/ref/com/sun/star/graphic/MediaProperties.html#MimeType
public static final String PNG="image/png";
public static final String JPEG="image/jpeg";
public static final String GIF="image/gif";
public static final String TIFF="image/tiff";
public static final String BMP="image/bmp";
public static final String EMF="image/x-emf";
public static final String WMF="image/x-wmf";
public static final String EPS="image/x-eps";
public static final String SVG="image/svg+xml";
// MIME type for SVM has changed
//public static final String SVM="image/x-svm";
public static final String SVM="application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"";
public static final String PDF="application/pdf";
// Destination formats
public static final String XHTML="text/html";
/** This is a fake MIME type, for internal use only */
public static final String XHTML11="application/xhtml11";
public static final String XHTML_MATHML="application/xhtml+xml";
/** This is a fake MIME type, for internal use only */
public static final String HTML5="text/html5";
public static final String EPUB="application/epub+zip";
public static final String LATEX="application/x-latex";
public static final String BIBTEX="application/x-bibtex";
public static final String TEXT="text";
} writer2latex-1.4/source/java/writer2latex/api/GraphicConverter.java 0000644 0001750 0001750 00000004151 11251136744 024221 0 ustar rene rene /************************************************************************
*
* GraphicConverter.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-11-23)
*
*/
package writer2latex.api;
/** A simple interface for a graphic converter which converts between various
* graphics formats
*/
public interface GraphicConverter {
/** Check whether a certain conversion is supported by the converter
*
* @param sSourceMime a string containing the source Mime type
* @param sTargetMime a string containing the target Mime type
* @param bCrop true if the target graphic should be cropped
* @param bResize true if the target graphic should be resized
* (the last two parameters are for future use)
* @return true if the conversion is supported
*/
public boolean supportsConversion(String sSourceMime, String sTargetMime, boolean bCrop, boolean bResize);
/** Convert a graphics file from one format to another
*
* @param source a byte array containing the source graphic
* @param sSourceMime a string containing the Mime type of the source
* @param sTargetMime a string containing the desired Mime type of the target
* @return a byte array containing the converted graphic. Returns null
* if the conversion failed.
*/
public byte[] convert(byte[] source, String sSourceMime, String sTargetMime);
}
writer2latex-1.4/source/java/writer2latex/api/ConverterResult.java 0000644 0001750 0001750 00000010574 11611533231 024120 0 ustar rene rene /************************************************************************
*
* ConverterResult.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-2011 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.2 (2011-07-20)
*
*/
package writer2latex.api;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
/** A ConverterResult represent a document, which is the result
* of a conversion performed by a Converterimplementation.
*/
public interface ConverterResult {
/** Get the master document
* Deprecated as of Writer2LaTeX 1.2: The master document is always the first document
* returned by the iterator
*
* @return OutputFile the master document
*/
@Deprecated public OutputFile getMasterDocument();
/** Gets an Iterator to access all files in the
* ConverterResult. The iterator will return the master documents first
* in logical order (starting with the primary master document)
* @return an Iterator of all files
*/
public Iterator iterator();
/** Get the meta data associated with the source document
* @return the meta data
*/
public MetaData getMetaData();
/** Get the content table (based on headings) for this ConverterResult
*
* @return list view of the content
*/
public List getContent();
/** Get the entry which contains the table page
*
* @return the entry or null if there is no title page
*/
public ContentEntry getTitlePageFile();
/** Get the entry which contains the start of the actual text (the first chapter, or simply the start of
* the document if there are no headings)
*
* @return the entry
*/
public ContentEntry getTextFile();
/** Get the entry which contains the table of contents
*
* @return the entry or null if a table of content does not exist
*/
public ContentEntry getTocFile();
/** Get the entry which contains the list of tables
*
* @return the entry or null if a list of tables does not exist
*/
public ContentEntry getLotFile();
/** Get the entry which contains the list of figures
*
* @return the entry or null if a list of figures does not exist
*/
public ContentEntry getLofFile();
/** Get the entry which contains the alphabetical index
*
* @return the entry or null if an alphabetical index does not exist
*/
public ContentEntry getIndexFile();
/** Get the entry which contains the bibliography
*
* @return the entry or null if a bibliography does not exist
*/
public ContentEntry getBibliographyFile();
/** Get the entry which contains the cover (which usually will contain a cover image)
*
* @return the entry or null if a cover does not exist
*/
public ContentEntry getCoverFile();
/** Get the entry which contains the actual cover image
*
* @return the entry or null if a cover image does not exist
*/
public ContentEntry getCoverImageFile();
/** Write all files of the ConverterResult to a directory.
* Subdirectories are created as required by the individual
* OutputFiles.
* @param dir the directory to write to (this directory must exist).
If the parameter is null, the default directory is used
* @throws IOException if the directory does not exist or one or more files
* could not be written
*/
public void write(File dir) throws IOException;
}
writer2latex-1.4/source/java/writer2latex/api/ComplexOption.java 0000644 0001750 0001750 00000006607 11302572361 023560 0 ustar rene rene /************************************************************************
*
* Config.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-11-19)
*
*/
package writer2latex.api;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/** A complex option is a set of named keys, each pointing to a set of named attributes
*/
public class ComplexOption {
private Map> options = new HashMap>();
/** Clear the contents of the set
*
*/
public void clear() {
options.clear();
}
/** Remove an option from the set, if it exists
*
* @param sName the name of the key to remove
*/
public void remove(String sName) {
if (options.containsKey(sName)) {
options.remove(sName);
}
}
/** Define a key. If the key already exists, the old value will be replaced
*
* @param sName the name of the key. The name must be non-empty, otherwise the request will be ignored.
* @param attributes
*/
public void put(String sName, Map attributes) {
if (sName!=null && sName.length()>0) {
options.put(sName, attributes);
}
}
/** Define a key using a copy of a the provided attributes.
* If the key already exists, the old value will be replaced
*
* @param sName the name of the key. The name must be non-empty, otherwise the request will be ignored.
* @param attributes
*/
public void copy(String sName, Map attributes) {
if (sName!=null && sName.length()>0) {
Map newAttributes = new HashMap();
for (String sAttrName : attributes.keySet()) {
newAttributes.put(sAttrName, attributes.get(sAttrName));
}
put(sName, newAttributes);
}
}
/** Get the value belonging to a key
*
* @param sName the name of the key
* @return the attributes, or null if the option doesn't exist
*/
public Map get(String sName) {
return options.get(sName);
}
/** Copy all values from another ComplexOption
* (overwrites existing values)
* @param co another instance of ComplexOption
*/
public void copyAll(ComplexOption co) {
for (String sName : co.keySet()) {
copy(sName, co.get(sName));
}
}
/** Get the names of all options that are currently defined by this complex option
*
* @return all names as a Set
*/
public Set keySet() {
return options.keySet();
}
/** Test if this complex options contains a specific option name
*
* @param sName the name to test
* @return true if the name exists
*/
public boolean containsKey(String sName) {
return options.containsKey(sName);
}
}
writer2latex-1.4/source/java/writer2latex/api/Package.html 0000644 0001750 0001750 00000000542 11147474702 022335 0 ustar rene rene
The package writer2latex.api
This package contains the api for using Writer2LaTeX.
The api consitst of a factory class and a number of interfaces, and is
used by the command line application as well as by the filters.
writer2latex-1.4/source/java/writer2latex/BatchHandlerImpl.java 0000644 0001750 0001750 00000005254 11147474702 023354 0 ustar rene rene /************************************************************************
*
* BatchHandlerImpl.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-2008 by Henrik Just
*
* All Rights Reserved.
*
* Version 1.0 (2008-10-03)
*
*/
package writer2latex;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import writer2latex.api.BatchHandler;
/** This class implements a BatchHandler for command line usage
*/
public class BatchHandlerImpl implements BatchHandler {
private int nIndent = 0;
private void writeMessage(String sMsg) {
for (int i=0; i Conversion of the directory "+sName+" failed!");
}
}
public void startFile(String sName) {
writeMessage("Converting file "+sName);
nIndent++;
}
public void endFile(String sName, boolean bSuccess) {
nIndent--;
if (!bSuccess) {
writeMessage("--> Conversion of the file "+sName+" failed!");
}
}
public boolean cancel() {
try {
if (System.in.available()>0) {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
in.readLine();
System.out.print("Do you want to cancel the conversion (y/n)? ");
String s = in.readLine();
if (s!= null && s.toLowerCase().startsWith("y")) { return true; }
}
}
catch (IOException e) {
}
return false;
}
}
writer2latex-1.4/source/java/writer2latex/Application.java 0000644 0001750 0001750 00000042777 12411031012 022443 0 ustar rene rene /************************************************************************
*
* Application.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-08-25)
*
*/
package writer2latex;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileNotFoundException;
//import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Set;
import java.util.Vector;
import writer2latex.api.BatchConverter;
import writer2latex.api.Converter;
import writer2latex.api.ConverterFactory;
import writer2latex.api.ConverterResult;
import writer2latex.api.MIMETypes;
//import writer2latex.api.OutputFile;
import writer2latex.util.Misc;
/**
* Command line utility to convert an OpenOffice.org Writer XML file into XHTML/LaTeX/BibTeX
* The utility is invoked with the following command line:
* java -jar writer2latex.jar [options] source [target]
* Where the available options are
*
* -latex, -bibtex, -html5, -xhtml,
-xhtml+mathml, -epub
* -recurse
* -ultraclean, -clean, -pdfscreen,
* -pdfprint, -cleanxhtml
* -config[=]filename
* -template[=]filename
* -stylesheet[=]filename
* -resource[=]filename[::media type]
* -option[=]value
*
* where option can be any simple option known to Writer2LaTeX
* (see documentation for the configuration file).
*/
public final class Application {
/* Based on command-line parameters. */
private String sTargetMIME = MIMETypes.LATEX;
private boolean bRecurse = false;
private Vector configFileNames = new Vector();
private String sTemplateFileName = null;
private String sStyleSheetFileName = null;
private Set resources = new HashSet();
private Hashtable options = new Hashtable();
private String sSource = null;
private String sTarget = null;
/**
* Main method
*
* @param args The argument passed on the command line.
*/
public static final void main (String[] args){
try {
//long time = System.currentTimeMillis();
Application app = new Application();
app.parseCommandLine(args);
app.doConversion();
//System.out.println("Total conversion time was "+(System.currentTimeMillis()-time)+" miliseconds");
} catch (IllegalArgumentException ex) {
String msg = ex.getMessage();
showUsage(msg);
}
}
// Convert the directory or file
private void doConversion() {
// Step 1: Say hello...
String sOutputFormat;
if (MIMETypes.LATEX.equals(sTargetMIME)) { sOutputFormat = "LaTeX"; }
else if (MIMETypes.BIBTEX.equals(sTargetMIME)) { sOutputFormat = "BibTeX"; }
else { sOutputFormat = "xhtml"; }
System.out.println();
System.out.println("This is Writer2" + sOutputFormat +
", Version " + ConverterFactory.getVersion() +
" (" + ConverterFactory.getDate() + ")");
System.out.println();
System.out.println("Starting conversion...");
// Step 2: Examine source
File source = new File(sSource);
if (!source.exists()) {
System.out.println("I'm sorry, I can't find "+sSource);
System.exit(1);
}
if (!source.canRead()) {
System.out.println("I'm sorry, I can't read "+sSource);
System.exit(1);
}
boolean bBatch = source.isDirectory();
// Step 3: Examine target
File target;
if (bBatch) {
if (sTarget==null) {
target=source;
}
else {
target = new File(sTarget);
}
}
else {
if (sTarget==null) {
target = new File(source.getParent(),Misc.removeExtension(source.getName()));
}
else {
target = new File(sTarget);
if (sTarget.endsWith(File.separator)) {
target = new File(target,Misc.removeExtension(source.getName()));
}
}
}
// Step 4: Create converters
Converter converter = ConverterFactory.createConverter(sTargetMIME);
if (converter==null) {
System.out.println("Failed to create converter for "+sTargetMIME);
System.exit(1);
}
BatchConverter batchCv = null;
if (bBatch) {
batchCv = ConverterFactory.createBatchConverter(MIMETypes.XHTML);
if (batchCv==null) {
System.out.println("Failed to create batch converter");
System.exit(1);
}
batchCv.setConverter(converter);
}
// Step 5a: Read template
if (sTemplateFileName!=null) {
try {
System.out.println("Reading template "+sTemplateFileName);
byte [] templateBytes = Misc.inputStreamToByteArray(new FileInputStream(sTemplateFileName));
converter.readTemplate(new ByteArrayInputStream(templateBytes));
if (batchCv!=null) {
// Currently we use the same template for the directory and the files
batchCv.readTemplate(new ByteArrayInputStream(templateBytes));
}
}
catch (FileNotFoundException e) {
System.out.println("--> This file does not exist!");
System.out.println(" "+e.getMessage());
}
catch (IOException e) {
System.out.println("--> Failed to read the template file!");
System.out.println(" "+e.getMessage());
}
}
// Step 5b: Read style sheet
if (sStyleSheetFileName!=null) {
try {
System.out.println("Reading style sheet "+sStyleSheetFileName);
byte [] styleSheetBytes = Misc.inputStreamToByteArray(new FileInputStream(sStyleSheetFileName));
converter.readStyleSheet(new ByteArrayInputStream(styleSheetBytes));
}
catch (FileNotFoundException e) {
System.out.println("--> This file does not exist!");
System.out.println(" "+e.getMessage());
}
catch (IOException e) {
System.out.println("--> Failed to read the style sheet file!");
System.out.println(" "+e.getMessage());
}
}
// Step 5c: Read style resources
for (String sResource : resources) {
String sMediaType;
String sFileName;
int nSeparator = sResource.indexOf("::");
if (nSeparator>-1) {
sFileName = sResource.substring(0,nSeparator);
sMediaType = sResource.substring(nSeparator+2);
}
else {
sFileName = sResource;
sMediaType = null;
}
System.out.println("Reading resource file "+sFileName);
try {
byte [] resourceBytes = Misc.inputStreamToByteArray(new FileInputStream(sFileName));
converter.readResource(new ByteArrayInputStream(resourceBytes),sFileName,sMediaType);
} catch (IOException e) {
System.out.println("--> Failed to read the resource file!");
System.out.println(" "+e.getMessage());
}
}
// Step 6: Read config
for (int i=0; i This configuration is unknown!");
System.out.println(" "+e.getMessage());
}
}
else {
System.out.println("Reading configuration file "+sConfigFileName);
try {
byte[] configBytes = Misc.inputStreamToByteArray(new FileInputStream(sConfigFileName));
converter.getConfig().read(new ByteArrayInputStream(configBytes));
if (bBatch) {
// Currently we use the same configuration for the directory and the files
batchCv.getConfig().read(new ByteArrayInputStream(configBytes));
}
}
catch (IOException e) {
System.err.println("--> Failed to read the configuration!");
System.out.println(" "+e.getMessage());
}
}
}
// Step 7: Set options from command line
Enumeration keys = options.keys();
while (keys.hasMoreElements()) {
String sKey = keys.nextElement();
String sValue = (String) options.get(sKey);
converter.getConfig().setOption(sKey,sValue);
if (batchCv!=null) {
batchCv.getConfig().setOption(sKey,sValue);
}
}
// Step 8: Perform conversion
if (bBatch) {
batchCv.convert(source,target,bRecurse, new BatchHandlerImpl());
}
else {
System.out.println("Converting "+source.getPath());
ConverterResult dataOut = null;
try {
dataOut = converter.convert(source,target.getName());
}
catch (FileNotFoundException e) {
System.out.println("--> The file "+source.getPath()+" does not exist!");
System.out.println(" "+e.getMessage());
System.exit(1);
}
catch (IOException e) {
System.out.println("--> Failed to convert the file "+source.getPath()+"!");
System.out.println(" "+e.getMessage());
System.out.println(" Please make sure the file is in OpenDocument format");
System.exit(1);
}
// TODO: Should do some further checking on the feasability of writing
// the directory and the files.
File targetDir = target.getParentFile();
if (targetDir!=null && !targetDir.exists()) { targetDir.mkdirs(); }
try {
dataOut.write(targetDir);
}
catch (IOException e) {
System.out.println("--> Error writing out file!");
System.out.println(" "+e.getMessage());
System.exit(1);
}
}
// Step 9: Say goodbye!
System.out.println("Done!");
}
/**
* Display usage.
*/
private static void showUsage(String msg) {
System.out.println();
System.out.println("This is Writer2LaTeX, Version " + ConverterFactory.getVersion()
+ " (" + ConverterFactory.getDate() + ")");
System.out.println();
if (msg != null) System.out.println(msg);
System.out.println();
System.out.println("Usage:");
System.out.println(" java -jar /writer2latex.jar