/************************************************************************
 *
 *  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-2009 by Henrik Just
 *
 *  All Rights Reserved.
 * 
 *  Version 1.2 (2009-11-02)
 *
 */ 
 
package org.openoffice.da.comp.writer2latex;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.Collator;
import java.util.Arrays;
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.io.NotConnectedException;
import com.sun.star.io.XInputStream;
import com.sun.star.io.XOutputStream;
import com.sun.star.lang.XMultiComponentFactory;
import com.sun.star.lang.XServiceInfo;
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 org.openoffice.da.comp.w2lcommon.helper.DialogAccess;

/** 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 tha pages.
 */
public final class ConfigurationDialog extends WeakBase
    implements XServiceInfo, XContainerWindowEventHandler {
	
	private String[] sFamilyNames = { "text", "paragraph", "paragraph-block", "list", "listitem" };
	private String[] sAttributeNames = { "bold", "italics", "small-caps", "superscript", "subscipt" };

    private XComponentContext xContext;
    private XSimpleFileAccess2 sfa2;
    private String sConfigFileName = null;
    Config config;
    // Local cache of complex options
    ComplexOption[] styleMap;
    ComplexOption attributeMap;
    ComplexOption headingMap;
    ComplexOption mathSymbols;
    ComplexOption stringReplace;
    short nCurrentFamily = -1;
    String sCurrentStyleName = null;
    short nCurrentAttribute = -1;
    short nCurrentMaxLevel = -1;
    short nCurrentWriterLevel = 0;
    String sCurrentMathSymbol = null;
    String sCurrentText = null;
    private String sTitle = null;
    private DialogAccess dlg = null;
    
    /** 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";

    /** Create a new ConfigurationDialog */
    public ConfigurationDialog(XComponentContext xContext) {
        this.xContext = xContext;

        // Get the SimpleFileAccess service
        sfa2 = null;
        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
        XStringSubstitution xPathSub = null;
        try {
            Object psObject = xContext.getServiceManager().createInstanceWithContext(
               "com.sun.star.util.PathSubstitution", xContext);
            xPathSub = (XStringSubstitution) UnoRuntime.queryInterface(XStringSubstitution.class, psObject);
            sConfigFileName = xPathSub.substituteVariables("$(user)/writer2latex.xml", false);
        }
        catch (com.sun.star.uno.Exception e) {
            // failed to get PathSubstitution service (should not happen)
        }
        
        // Create the configuration
        config = ConverterFactory.createConverter("application/x-latex").getConfig();
        
        // Initialize the local cache of complex options
        styleMap = new ComplexOption[5];
        for (int i=0; i<5; i++) { styleMap[i]=new ComplexOption(); }
        attributeMap = new ComplexOption();
        headingMap = new ComplexOption();
        mathSymbols = new ComplexOption();
        stringReplace = new ComplexOption();
    }
        	
    // 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);
    	sTitle = xDialog.getTitle();
   		dlg = new DialogAccess(xDialog);

   		try {
            if (sMethod.equals("external_event") ){
                return handleExternalEvent(event);
            }
            // Documentclass page
            else if (sMethod.equals("NoPreambleChange")) {
                updateDocumentclassControls();
                return true;
            }
            // Headings page
            else if (sMethod.equals("MaxLevelChange")) {
            	saveHeadings();
                updateHeadingsControls();
                return true;
            }
            else if (sMethod.equals("WriterLevelChange")) {
            	saveHeadings();
                updateHeadingsControls();
                return true;
            }
            else if (sMethod.equals("NoIndexChange")) {
                updateHeadingsControls();
                return true;
            }
            // Styles page
            else if (sMethod.equals("StyleFamilyChange")) {
            	saveStyles();
            	updateStylesControls();
            	return true;
            }
            else if (sMethod.equals("StyleNameChange")) {
            	saveStyles();
            	updateStylesControls();
            	return true;
            }
            else if (sMethod.equals("NewStyleClick")) {
            	if (nCurrentFamily>-1) {
            		String sNewName = appendItem("StyleName");
            		if (sNewName!=null) {
            			Map<String,String> attr = new HashMap<String,String>();
            			attr.put("before", "");
            			attr.put("after", "");
            			attr.put("after", "");
            			attr.put("verbatim", "");
            			attr.put("line-break","");
            			styleMap[nCurrentFamily].put(sNewName, attr);
            		}
            		saveStyles();
            		updateStylesControls();
            	}
            	return true;
            }
            else if (sMethod.equals("DeleteStyleClick")) {
            	if (nCurrentFamily>-1 && sCurrentStyleName!=null) {
            		if (deleteCurrentItem("StyleName")) {
            			styleMap[nCurrentFamily].remove(sCurrentStyleName);
                		updateStylesControls();
            		}
            	}
            	return true;
            }
            // Characters page
            else if (sMethod.equals("UseSoulChange")) {
            	updateCharactersControls();
                return true;
            }
            else if (sMethod.equals("FormattingAttributeChange")) {
            	saveCharacters();
            	updateCharactersControls();
                return true;
            }
            else if (sMethod.equals("CustomAttributeChange")) {
            	updateCharactersControls();
                return true;
            }
            // Fonts page
            // Pages page
            else if (sMethod.equals("ExportGeometryChange")) {
            	updatePagesControls();
                return true;
            }
            else if (sMethod.equals("ExportHeaderAndFooterChange")) {
            	updatePagesControls();
                return true;
            }
            // Tables page
            else if (sMethod.equals("NoTablesChange")) {
            	updateTablesControls();
            	return true;
            }
            else if (sMethod.equals("UseSupertabularChange")) {
            	updateTablesControls();
            	return true;
            }
            else if (sMethod.equals("UseLongtableChange")) {
            	updateTablesControls();
            	return true;
            }
            // Figures page
            else if (sMethod.equals("NoImagesChange")) {
            	updateFiguresControls();
            	return true;
            }
            // Text and math page
            else if (sMethod.equals("MathSymbolNameChange")) {
            	saveTextAndMath();
            	updateTextAndMathControls();
            	return true;
            }
            else if (sMethod.equals("NewSymbolClick")) {
            	String sNewName = appendItem("MathSymbolName");
            	if (sNewName!=null) {
            		Map<String,String> attr = new HashMap<String,String>();
            		attr.put("latex", "");
            		mathSymbols.put(sNewName, attr);
            	}
            	saveTextAndMath();
            	updateTextAndMathControls();
            	return true;
            }
            else if (sMethod.equals("DeleteSymbolClick")) {
            	if (deleteCurrentItem("MathSymbolName")) {
            		mathSymbols.remove(sCurrentMathSymbol);
            		updateTextAndMathControls();
            	}
            	return true;
            }
            else if (sMethod.equals("TextInputChange")) {
            	saveTextAndMath();
            	updateTextAndMathControls();
            	return true;
            }
            else if (sMethod.equals("NewTextClick")) {
            	String sNewName = appendItem("TextInput");
            	if (sNewName!=null) {
            		Map<String,String> attr = new HashMap<String,String>();
            		attr.put("latex-code", "");
            		attr.put("fontenc", "any");
            		stringReplace.put(sNewName, attr);
            	}
            	saveTextAndMath();
            	updateTextAndMathControls();
            	return true;
            }
            else if (sMethod.equals("DeleteTextClick")) {
            	if (deleteCurrentItem("TextInput")) {
            		stringReplace.remove(sCurrentText);
            		updateTextAndMathControls();
            	}
            	return true;
            }            
        }
        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", 
        		"NoPreambleChange", // Documentclass
        		"MaxLevelChange", "WriterLevelChange", "NoIndexChange", // Headings
        		"StyleFamilyChange", "StyleNameChange", "NewStyleClick", "DeleteStyleClick", // Styles
        		"UseSoulChange", "FormattingAttributeChange", "CustomAttributeChange", // Characters
        		"ExportGeometryChange", "ExportHeaderAndFooterChange", // Pages
        		"NoTablesChange", "UseSupertabularChange", "UseLongtableChange", // Tables
        		"NoImagesChange", // Images
        		"MathSymbolNameChange", "NewSymbolClick", "DeleteSymbolClick",
        		"TextInputChange", "NewTextClick", "DeleteTextClick" // Text and Math
        };
        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(Object aEventObject)
    throws com.sun.star.uno.Exception {
    	try {
    		String sMethod = AnyConverter.toString(aEventObject);
    		if (sMethod.equals("ok")) {
    			loadConfig();
    			getControls();
    			for (int i=0; i<5; i++) {
    				config.getComplexOption(sFamilyNames[i]+"-map").clear();
    				config.getComplexOption(sFamilyNames[i]+"-map").copyAll(styleMap[i]);
    			}
    			config.getComplexOption("text-attribute-map").clear();
    			config.getComplexOption("text-attribute-map").copyAll(attributeMap);
    			if (nCurrentMaxLevel>-1) {
    				for (int i=nCurrentMaxLevel+1; i<11; i++) {
    					headingMap.remove(Integer.toString(i));
    				}
    			}
    			config.getComplexOption("heading-map").clear();
    			config.getComplexOption("heading-map").copyAll(headingMap);
    			config.getComplexOption("math-symbol-map").clear();
    			config.getComplexOption("math-symbol-map").copyAll(mathSymbols);
    			config.getComplexOption("string-replace").clear();
    			config.getComplexOption("string-replace").copyAll(stringReplace);
    			saveConfig();
    			return true;
    		} else if (sMethod.equals("back") || sMethod.equals("initialize")) {
    			loadConfig();
    			for (int i=0; i<5; i++) {
    				styleMap[i].clear();
    				styleMap[i].copyAll(config.getComplexOption(sFamilyNames[i]+"-map"));
    			}
    			attributeMap.clear();
    			attributeMap.copyAll(config.getComplexOption("text-attribute-map"));
    			headingMap.clear();
    			headingMap.copyAll(config.getComplexOption("heading-map"));
    			mathSymbols.clear();
    			mathSymbols.copyAll(config.getComplexOption("math-symbol-map"));
    			stringReplace.clear();
    			stringReplace.copyAll(config.getComplexOption("string-replace"));
    			setControls();
    			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;
    }
    
    // Display a dialog
    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 boolean deleteItem() {
    	XDialog xDialog=getDialog("W2LDialogs2.DeleteDialog");
    	if (xDialog!=null) {
    		boolean bDelete = xDialog.execute()==ExecutableDialogResults.OK;
    		xDialog.endExecute();
    		return bDelete;
    	}
    	return false;
    }
    
    private boolean deleteCurrentItem(String sListName) {
    	String[] sItems = dlg.getListBoxStringItemList(sListName);
    	short nSelected = dlg.getListBoxSelectedItem(sListName);
    	if (nSelected>=0 && deleteItem()) {
    		int nOldLen = sItems.length;
    		String[] sNewItems = new String[nOldLen-1];
    		if (nSelected>0) {
    			System.arraycopy(sItems, 0, sNewItems, 0, nSelected);
    		}
    		if (nSelected<nOldLen-1) {
        		System.arraycopy(sItems, nSelected+1, sNewItems, nSelected, nOldLen-1-nSelected);
    		}
    		dlg.setListBoxStringItemList(sListName, sNewItems);
    		short nNewSelected = nSelected<nOldLen-1 ? nSelected : (short)(nSelected-1);
			dlg.setListBoxSelectedItem(sListName, nNewSelected);
			return true;
    	}
    	return false;
    }
    
    private String newItem() {
    	XDialog xDialog=getDialog("W2LDialogs2.NewDialog");
    	if (xDialog!=null) {
    		String sResult = null;
    		if (xDialog.execute()==ExecutableDialogResults.OK) {
    			DialogAccess dlg = new DialogAccess(xDialog);
    			sResult = dlg.getTextFieldText("Name");
    		}
    		xDialog.endExecute();
    		return sResult;
    	}
    	return null;
    }
    
    private String appendItem(String sListName) {
    	String[] sItems = dlg.getListBoxStringItemList(sListName);
    	String sNewItem = newItem();
    	if (sNewItem!=null) {
    		int nOldLen = sItems.length;
    		for (short i=0; i<nOldLen; i++) {
    			if (sNewItem.equals(sItems[i])) {
    				// Item already exists, select the existing one
    				dlg.setListBoxSelectedItem(sListName, i);
    				return null;
    			}
    		}
    		String[] sNewItems = new String[nOldLen+1];
    		System.arraycopy(sItems, 0, sNewItems, 0, nOldLen);
    		sNewItems[nOldLen]=sNewItem;
    		dlg.setListBoxStringItemList(sListName, sNewItems);
    		dlg.setListBoxSelectedItem(sListName, (short)nOldLen);
    	}
    	return sNewItem;
    }
    
	// 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
            }
        }
    }
    
	// Set controls based on the config
    private void setControls() {
    	if ("Documentclass".equals(sTitle)) {
    		loadDocumentclass();
    	}
    	else if ("Headings".equals(sTitle)) {
    		loadHeadings();
    	}
    	else if ("Styles".equals(sTitle)) {
    		loadStyles();
    	}
    	else if ("Characters".equals(sTitle)) {
    		loadCharacters();
    	}
    	else if ("Fonts".equals(sTitle)) {
    		loadFonts();
    	}
    	else if ("Pages".equals(sTitle)) {
    		loadPages();
    	}
    	else if ("Tables".equals(sTitle)) {
    		loadTables();
    	}
    	else if ("Figures".equals(sTitle)) {
    		loadFigures();
    	}
    	else if ("TextAndMath".equals(sTitle)) {
    		loadTextAndMath();
    	}
    }
    
	// Change the config based on the controls
    private void getControls() {
    	if ("Documentclass".equals(sTitle)) {
    		saveDocumentclass();
    	}
    	else if ("Headings".equals(sTitle)) {
    		saveHeadings();
    	}
    	else if ("Styles".equals(sTitle)) {
    		saveStyles();
    	}
    	else if ("Characters".equals(sTitle)) {
    		saveCharacters();
    	}
    	else if ("Fonts".equals(sTitle)) {
    		saveFonts();
    	}
    	else if ("Pages".equals(sTitle)) {
    		savePages();
    	}
    	else if ("Tables".equals(sTitle)) {
    		saveTables();
    	}
    	else if ("Figures".equals(sTitle)) {
    		saveFigures();
    	}
    	else if ("TextAndMath".equals(sTitle)) {
    		saveTextAndMath();
    	}    	
    }
    
    // The page "Documentclass"
    // This page handles the options no_preamble, documentclass, global_options and the custom-preamble
    
    private void loadDocumentclass() {
    	dlg.setCheckBoxStateAsBoolean("NoPreamble","true".equals(config.getOption("no_preamble")));
    	dlg.setTextFieldText("Documentclass",config.getOption("documentclass"));
    	dlg.setTextFieldText("GlobalOptions",config.getOption("global_options"));
    	dlg.setTextFieldText("CustomPreamble",config.getOption("custom-preamble"));
    	updateDocumentclassControls();
    }
    
    private void saveDocumentclass() {
    	config.setOption("no_preamble", Boolean.toString(dlg.getCheckBoxStateAsBoolean("NoPreamble")));
    	config.setOption("documentclass", dlg.getTextFieldText("Documentclass"));
    	config.setOption("global_options", dlg.getTextFieldText("GlobalOptions"));
    	config.setOption("custom-preamble", dlg.getTextFieldText("CustomPreamble"));
    }

    private void updateDocumentclassControls() {
    	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 void loadHeadings() {
    	// Determine the max level (from 0 to 10)
    	Set<String> writerLevels = headingMap.keySet();
    	nCurrentMaxLevel = 0;
    	while(nCurrentMaxLevel<10 && writerLevels.contains(Integer.toString(nCurrentMaxLevel+1))) {
    		nCurrentMaxLevel++;
    	}
    	dlg.setListBoxSelectedItem("MaxLevel", nCurrentMaxLevel);
    	
    	dlg.setCheckBoxStateAsBoolean("UseTitlesec","true".equals(config.getOption("use_titlesec")));
    	dlg.setCheckBoxStateAsBoolean("NoIndex","true".equals(config.getOption("no_index")));
    	dlg.setCheckBoxStateAsBoolean("UseTitletoc","true".equals(config.getOption("use_titletoc")));

    	updateHeadingsControls();
    }
    
    private void saveHeadings() {
    	// Save the current writer level in our cache
    	if (nCurrentWriterLevel>-1) {
    		Map<String,String> attr = new HashMap<String,String>();
    		attr.put("name", dlg.getComboBoxText("LaTeXName"));
    		attr.put("level", dlg.getComboBoxText("LaTeXLevel"));
    		headingMap.put(Integer.toString(nCurrentWriterLevel+1), attr);
    	}

    	config.setOption("use_titlesec", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseTitlesec")));    	
    	config.setOption("no_index", Boolean.toString(dlg.getCheckBoxStateAsBoolean("NoIndex")));
    	config.setOption("use_titletoc", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseTitletoc")));    		
    }
    
    private void updateHeadingsControls() {
    	// Adjust the presented writer levels to the max level
    	nCurrentMaxLevel = dlg.getListBoxSelectedItem("MaxLevel");
    	nCurrentWriterLevel = dlg.getListBoxSelectedItem("WriterLevel");
    	String[] sWriterLevels = new String[nCurrentMaxLevel];
    	for (int i=0; i<nCurrentMaxLevel; i++) {
    		sWriterLevels[i]=Integer.toString(i+1);
    	}
    	dlg.setListBoxStringItemList("WriterLevel", sWriterLevels);
    	if (nCurrentWriterLevel+1>nCurrentMaxLevel) { nCurrentWriterLevel = (short)(nCurrentMaxLevel-1); }
    	else if (nCurrentWriterLevel<0 && nCurrentMaxLevel>0) { nCurrentWriterLevel=0; }
    	dlg.setListBoxSelectedItem("WriterLevel", nCurrentWriterLevel);
    	
    	// Load the values for the current level
    	if (nCurrentWriterLevel>-1) {
    		String sLevel = Integer.toString(nCurrentWriterLevel+1);
    		if (headingMap.keySet().contains(sLevel)) {
    			Map<String,String> attr = headingMap.get(sLevel);
    			dlg.setComboBoxText("LaTeXLevel", attr.get("level"));
    			dlg.setComboBoxText("LaTeXName", attr.get("name"));
    		}
    		else {
    			dlg.setListBoxSelectedItem("LaTeXLevel", (short)2);
    			dlg.setComboBoxText("LaTeXName", "");
    		}
    	}

    	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);

    	// Until implemented:
    	dlg.setControlEnabled("UseTitletoc", false);
    	//boolean bNoIndex = dlg.getCheckBoxStateAsBoolean("NoIndex");
    	//dlg.setControlEnabled("UseTitletoc", !bNoIndex);

    }
    
    // The page "Styles"
    // This page handles the various style maps as well as the options other_styles and formatting
    
    private void loadStyles() {
    	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);
    	}

    	updateStylesControls();
    }
    
    private void saveStyles() {
    	// Save the current style map, if any
    	if (nCurrentFamily>-1 && sCurrentStyleName!=null) {
    		Map<String,String> attr=new HashMap<String,String>();
    		attr.put("before", dlg.getTextFieldText("Before"));
    		attr.put("after", dlg.getTextFieldText("After"));
    		if (dlg.getControlEnabled("Next")) {
    			attr.put("next", dlg.getTextFieldText("Next"));
    		}
    		if (dlg.getControlEnabled("LineBreak")) {
    			attr.put("line-break", Boolean.toString(dlg.getCheckBoxStateAsBoolean("LineBreak")));
    		}
    		if (dlg.getControlEnabled("Verbatim")) {
    			attr.put("verbatim", Boolean.toString(dlg.getCheckBoxStateAsBoolean("Verbatim")));
    		}
    		styleMap[nCurrentFamily].put(sCurrentStyleName, attr);
    	}
    	
    	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");
    	}

    }
    
    private void updateStylesControls() {
    	short nNewFamily = dlg.getListBoxSelectedItem("StyleFamily");
    	if (nNewFamily>-1 && nNewFamily!=nCurrentFamily) {
    		// The user has changed the family; load and display the corresponding style names
    		Set<String> items = styleMap[nNewFamily].keySet();
        	String[] sStyleNames = new String[items.size()];
        	int i=0;
        	for (String s : items) {
        		sStyleNames[i++] = s;
        	}
        	sortStringArray(sStyleNames);
        	dlg.setListBoxStringItemList("StyleName", sStyleNames);
        	dlg.setListBoxSelectedItem("StyleName", (short)Math.min(sStyleNames.length-1, 0));
        	dlg.setControlEnabled("NextLabel", nNewFamily==2);
        	dlg.setControlEnabled("Next", nNewFamily==2);
        	dlg.setControlEnabled("Verbatim", nNewFamily<2);
        	dlg.setControlEnabled("LineBreak", nNewFamily==1);
        	nCurrentFamily = nNewFamily;
    	}
    	
    	if (nCurrentFamily>-1) {
    		short nStyleNameItem = dlg.getListBoxSelectedItem("StyleName");
    		if (nStyleNameItem>=0) {
    			sCurrentStyleName = dlg.getListBoxStringItemList("StyleName")[nStyleNameItem];
    			
    			Map<String,String> attr = styleMap[nCurrentFamily].get(sCurrentStyleName);
    			dlg.setTextFieldText("Before", attr.containsKey("before") ? attr.get("before") : "");
    			dlg.setTextFieldText("After", attr.containsKey("after") ? attr.get("before") : "");
    			dlg.setTextFieldText("Next", attr.containsKey("next") ? attr.get("next") : "");
    			dlg.setTextFieldText("Verbatim", attr.containsKey("verbatim") ? attr.get("verbatim") : "");
    			dlg.setTextFieldText("LineBreak", attr.containsKey("line-break") ? attr.get("line-break") : "");
    			dlg.setControlEnabled("DeleteStyleButton", true);
    			System.out.println("...OK loading style");
    		}
    		else {
    			sCurrentStyleName = null;
    			dlg.setTextFieldText("Before", "");
    			dlg.setTextFieldText("After", "");
    			dlg.setTextFieldText("Next", "");
    			dlg.setCheckBoxStateAsBoolean("Verbatim", false);
    			dlg.setCheckBoxStateAsBoolean("LineBreak", false);
    			dlg.setControlEnabled("DeleteStyleButton", false);
    		}
    	}
    }
    
    // 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 void loadCharacters() {
    	dlg.setCheckBoxStateAsBoolean("UseHyperref","true".equals(config.getOption("use_hyperref")));
    	dlg.setCheckBoxStateAsBoolean("UseColor","true".equals(config.getOption("use_color")));
    	dlg.setCheckBoxStateAsBoolean("UseSoul","true".equals(config.getOption("use_soul")));
    	dlg.setCheckBoxStateAsBoolean("UseUlem","true".equals(config.getOption("use_ulem")));
    	
    	updateCharactersControls();
    }
    
    private void saveCharacters() {
    	// Save the current attribute map, if any
    	if (nCurrentAttribute>-1) {
    		if (dlg.getCheckBoxStateAsBoolean("CustomAttribute")) {
    			HashMap<String,String> attr = new HashMap<String,String>();
    			attr.put("before", dlg.getTextFieldText("Before"));
    			attr.put("after", dlg.getTextFieldText("After"));
    			attributeMap.put(sAttributeNames[nCurrentAttribute], attr);
    		}
    		else {
    			attributeMap.remove(sAttributeNames[nCurrentAttribute]);
    		}
    	}
    	
    	config.setOption("use_hyperref", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseHyperref")));    	
    	config.setOption("use_color", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseColor")));    	
    	config.setOption("use_soul", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseSoul")));    	
    	config.setOption("use_ulem", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseUlem")));    
    }
    
    private void updateCharactersControls() {
    	short nNewAttribute = dlg.getListBoxSelectedItem("FormattingAttribute");
    	if (nNewAttribute>-1 && nCurrentAttribute!=nNewAttribute) {
    		String sName = sAttributeNames[nNewAttribute];
    		if (attributeMap.keySet().contains(sName)) {
    			dlg.setCheckBoxStateAsBoolean("CustomAttribute", true);
    			dlg.setTextFieldText("Before", 
    				attributeMap.get(sName).containsKey("before") ? attributeMap.get(sName).get("before") : "");
    			dlg.setTextFieldText("After",
    				attributeMap.get(sName).containsKey("after") ? attributeMap.get(sName).get("after") : "");
    		}
    		else {
    			dlg.setCheckBoxStateAsBoolean("CustomAttribute", false);
    			dlg.setTextFieldText("Before", "");
    			dlg.setTextFieldText("After", "");
    		}
    		nCurrentAttribute = nNewAttribute;
    	}
    	
    	boolean bCustom = dlg.getCheckBoxStateAsBoolean("CustomAttribute");
    	dlg.setControlEnabled("Before", bCustom);
    	dlg.setControlEnabled("After", bCustom);
    	
    	// 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 void loadFonts() {
    	dlg.setCheckBoxStateAsBoolean("UseFontspec","true".equals(config.getOption("use_fontspec")));
    	dlg.setCheckBoxStateAsBoolean("UsePifont","true".equals(config.getOption("use_pifont")));
    	dlg.setCheckBoxStateAsBoolean("UseTipa","true".equals(config.getOption("use_tipa")));
    	dlg.setCheckBoxStateAsBoolean("UseEurosym","true".equals(config.getOption("use_eurosym")));
    	dlg.setCheckBoxStateAsBoolean("UseWasysym","true".equals(config.getOption("use_wasysym")));
    	dlg.setCheckBoxStateAsBoolean("UseIfsym","true".equals(config.getOption("use_ifsym")));
    	dlg.setCheckBoxStateAsBoolean("UseBbding","true".equals(config.getOption("use_bbding")));
    	
    	updateFontsControls();
    }
    
    private void saveFonts() {    	
    	config.setOption("use_fontspec", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseFontspec")));    	
    	config.setOption("use_pifont", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UsePifont")));    	
    	config.setOption("use_tipa", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseTipa")));    	
    	config.setOption("use_eurosym", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseEurosym")));    	
    	config.setOption("use_wasysym", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseWasysym")));    	
    	config.setOption("use_ifsym", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseIfsym")));    	
    	config.setOption("use_bbding", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseBbding")));    	    	
    }
    
    private void updateFontsControls() {
    	// Until implemented...
    	dlg.setControlEnabled("UseFontspec", false);
    	// Nothing to do
    }
    
    // The page "Pages"
    // This page handles the options page_formatting, use_geometry, use_fancyhdr, use_lastpage and use_endnotes
    
    private void loadPages() {
    	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);
    	}
    	
    	dlg.setCheckBoxStateAsBoolean("UseGeometry", "true".equals(config.getOption("use_geometry")));
    	dlg.setCheckBoxStateAsBoolean("UseFancyhdr", "true".equals(config.getOption("use_fancyhdr")));
    	dlg.setCheckBoxStateAsBoolean("UseLastpage", "true".equals(config.getOption("use_lastpage")));
    	dlg.setCheckBoxStateAsBoolean("UseEndnotes", "true".equals(config.getOption("use_endnotes")));
    	
    	updatePagesControls();
    }
    
    private void savePages() {
    	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");
    	}
    	
    	config.setOption("use_geometry", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseGeometry")));
    	config.setOption("use_fancyhdr", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseFancyhdr")));
    	config.setOption("use_lastpage", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseLastpage")));
    	config.setOption("use_endnotes", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseEndnotes")));
    }
    
    private void updatePagesControls() {
    	boolean bExportGeometry = dlg.getCheckBoxStateAsBoolean("ExportGeometry");
    	dlg.setControlEnabled("UseGeometry",bExportGeometry);

    	boolean bExport = dlg.getCheckBoxStateAsBoolean("ExportHeaderFooter");
    	dlg.setControlEnabled("UseFancyhdr",bExport);
    }
    
    // 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 void loadTables() {
    	dlg.setCheckBoxStateAsBoolean("NoTables", !"accept".equals(config.getOption("table_content")));
    	dlg.setCheckBoxStateAsBoolean("UseColortbl","true".equals(config.getOption("use_colortbl")));
    	dlg.setCheckBoxStateAsBoolean("UseTabulary", "true".equals(config.getOption("use_tabulary")));
    	//dlg.setCheckBoxStateAsBoolean("UseMultirow", "true".equals(config.getOption("use_multirow")));
    	dlg.setCheckBoxStateAsBoolean("UseSupertabular","true".equals(config.getOption("use_supertabular")));
    	dlg.setCheckBoxStateAsBoolean("UseLongtable", "true".equals(config.getOption("use_longtable")));
    	dlg.setTextFieldText("TableFirstHeadStyle", config.getOption("table_first_head_style"));
    	dlg.setTextFieldText("TableHeadStyle", config.getOption("table_head_style"));
    	dlg.setTextFieldText("TableFootStyle", config.getOption("table_foot_style"));
    	dlg.setTextFieldText("TableLastFootStyle", config.getOption("table_last_foot_style"));
    	dlg.setTextFieldText("TableSequenceName", config.getOption("table_sequence_name"));
    	updateTablesControls();
    }
    
    private void saveTables() {
    	config.setOption("table_content", dlg.getCheckBoxStateAsBoolean("NoTables") ? "ignore" : "accept");
    	config.setOption("use_colortbl", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseColortbl")));    	
    	config.setOption("use_tabulary", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseTabulary")));
    	//config.setOption("use_multirow", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseMultirow")));
    	config.setOption("use_supertabular", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseSupertabular")));
    	config.setOption("use_longtable", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseLongtable")));
    	config.setOption("table_first_head_style", dlg.getTextFieldText("TableFirstHeadStyle"));
    	config.setOption("table_head_style", dlg.getTextFieldText("TableHeadStyle"));
    	config.setOption("table_foot_style", dlg.getTextFieldText("TableFootStyle"));
    	config.setOption("table_last_foot_style", dlg.getTextFieldText("TableLastFootStyle"));
    	config.setOption("table_sequence_name", dlg.getTextFieldText("TableSequenceName"));
    }
    
    private void updateTablesControls() {
    	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 void loadFigures() {
    	dlg.setCheckBoxStateAsBoolean("UseCaption", "true".equals(config.getOption("use_caption")));
    	dlg.setCheckBoxStateAsBoolean("AlignFrames", "true".equals(config.getOption("align_frames")));
    	dlg.setTextFieldText("FigureSequenceName", config.getOption("figure_sequence_name"));
    	dlg.setCheckBoxStateAsBoolean("NoImages", !"accept".equals(config.getOption("image_content")));
    	dlg.setCheckBoxStateAsBoolean("RemoveGraphicsExtension", "true".equals(config.getOption("remove_graphics_extension")));
    	dlg.setTextFieldText("ImageOptions", config.getOption("image_options"));
    	updateFiguresControls();
     }
    
    private void saveFigures() {
    	config.setOption("use_caption", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseCaption")));
    	config.setOption("align_frames", Boolean.toString(dlg.getCheckBoxStateAsBoolean("AlignFrames")));
    	config.setOption("figure_sequence_name", dlg.getTextFieldText("FigureSequenceName"));
    	config.setOption("image_content", dlg.getCheckBoxStateAsBoolean("NoImages") ? "ignore" : "accept");
    	config.setOption("remove_graphics_extension", Boolean.toString(dlg.getCheckBoxStateAsBoolean("RemoveGraphicsExtension")));
    	config.setOption("image_options", dlg.getTextFieldText("ImageOptions"));
    }

    private void updateFiguresControls() {
    	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 void loadTextAndMath() {
    	dlg.setCheckBoxStateAsBoolean("UseOoomath","true".equals(config.getOption("use_ooomath")));
    	
       	Set<String> symbolnames = config.getComplexOption("math-symbol-map").keySet();
    	String[] sSymbolNames = new String[symbolnames.size()];
    	int i=0;
    	for (String s : symbolnames) {
    		sSymbolNames[i++] = s;
    	}
    	sortStringArray(sSymbolNames);
    	dlg.setListBoxStringItemList("MathSymbolName", sSymbolNames);
    	dlg.setListBoxSelectedItem("MathSymbolName", (short)0);
    	//sCurrentMathSymbol = symbolnames.size()>0 ? sSymbolNames[0] : null;
    	
    	Set<String> names = config.getComplexOption("string-replace").keySet();
    	String[] sNames = new String[names.size()];
    	int j=0;
    	for (String s : names) {
    		sNames[j++] = s;
    	}
    	sortStringArray(sNames);
    	dlg.setListBoxStringItemList("TextInput", sNames);
    	dlg.setListBoxSelectedItem("TextInput", (short)0);
    	//sCurrentText = sNames[0];
    	
    	dlg.setTextFieldText("TabStopLaTeX", config.getOption("tabstop"));
    	
    	updateTextAndMathControls();
    }
    
    private void saveTextAndMath() {
    	config.setOption("use_ooomath", Boolean.toString(dlg.getCheckBoxStateAsBoolean("UseOoomath")));
    	
    	// Save the current math symbol in our cache
    	if (sCurrentMathSymbol!=null) {
    		Map<String,String> attr = new HashMap<String,String>();
    		attr.put("latex", dlg.getTextFieldText("MathLaTeX"));
    		mathSymbols.put(sCurrentMathSymbol, attr);
    	}
    	
    	// Save the current string replace in our cache
    	if (sCurrentText!=null) {
    		Map<String,String> attr = new HashMap<String,String>();
    		attr.put("latex-code", dlg.getTextFieldText("LaTeX"));
    		attr.put("fontenc", "any");
    		stringReplace.put(sCurrentText, attr);
    	}
    	
    	config.setOption("tabstop", dlg.getTextFieldText("TabStopLaTeX"));
    }
    
    private void updateTextAndMathControls() {
    	// Get the current math symbol, if any
    	short nSymbolItem = dlg.getListBoxSelectedItem("MathSymbolName");
    	if (nSymbolItem>=0) {
    		sCurrentMathSymbol = dlg.getListBoxStringItemList("MathSymbolName")[nSymbolItem];
    		
    		Map<String,String> attributes = mathSymbols.get(sCurrentMathSymbol);
    		dlg.setTextFieldText("MathLaTeX", attributes.get("latex"));
    		dlg.setControlEnabled("DeleteSymbolButton", true);
    	}
    	else {
    		sCurrentMathSymbol = null;
    		dlg.setTextFieldText("MathLaTeX", "");
    		dlg.setControlEnabled("DeleteSymbolButton", false);
    	}
    	
    	// Get the current input string, if any
    	short nItem = dlg.getListBoxSelectedItem("TextInput");
    	if (nItem>=0) {
    		sCurrentText = dlg.getListBoxStringItemList("TextInput")[nItem];
    		
    		Map<String,String> attributes = stringReplace.get(sCurrentText);
    		dlg.setTextFieldText("LaTeX", attributes.get("latex-code"));
    		//dlg.setTextFieldText("Fontenc", attributes.get("fontenc"));
    		dlg.setControlEnabled("DeleteTextButton",
    				!"\u00A0!".equals(sCurrentText) && !"\u00A0?".equals(sCurrentText) && 
    				!"\u00A0:".equals(sCurrentText) && !"\u00A0;".equals(sCurrentText) &&
    				!"\u00A0\u2014".equals(sCurrentText));
    	}
    	else {
    		sCurrentText = null;
    		dlg.setTextFieldText("LaTeX", "");
    		//dlg.setTextFieldText("Fontenc", "any");
    		dlg.setControlEnabled("DeleteTextButton", false);
    	}
    	
    }
    
    // Utilities
    private void sortStringArray(String[] theArray) {
    	// TODO: Get locale from OOo rather than the system
        Collator collator = Collator.getInstance();
    	Arrays.sort(theArray, collator);
    }
	
}