public void actionPerformed(ActionEvent e) {

public void run() {

				ExportFormats.initAllExports();

        BasePanel panel = frame.basePanel();

				JFileChooser fc = ExportFormats.createExportFileChooser(

        if (panel == null)

                    Globals.prefs.get("exportWorkingDirectory"));

            return;

				fc.showSaveDialog(frame);

        if (panel.getSelectedEntries().length == 0) {

				File file = fc.getSelectedFile();

            message = Globals.lang("No entries selected.");

				if (file == null)

            getCallBack().update();

					return;

            return;

				FileFilter ff = fc.getFileFilter();

        }

				if (ff instanceof ExportFileFilter) {

        Map<String, IExportFormat> m = ExportFormats.getExportFormats();

        IExportFormat[] formats = new ExportFormat[m.size()];

                    ExportFileFilter eff = (ExportFileFilter) ff;

        String[] array = new String[formats.length];

                    String path = file.getPath();

                    if (!path.endsWith(eff.getExtension()))

        int piv = 0;

                        path = path + eff.getExtension();

		for (IExportFormat format : m.values()) {

                    file = new File(path);

			formats[piv] = format;

                    if (file.exists()) {

			array[piv] = format.getDisplayName();

                        // Warn that the file exists:

			piv++;

                        if (JOptionPane.showConfirmDialog(frame, "'" + file.getName() + "' "

		}

                            + Globals.lang("exists. Overwrite file?"), Globals.lang("Export"),

                            JOptionPane.OK_CANCEL_OPTION) != JOptionPane.OK_OPTION)

        JList list = new JList(array);

                            return;

        list.setBorder(BorderFactory.createEtchedBorder());

                    }

        list.setSelectionInterval(0, 0);

                    final IExportFormat format = eff.getExportFormat();

        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

                    Set<String> entryIds = null;

        int answer = JOptionPane.showOptionDialog(frame, list, Globals.lang("Select format"),

                    if (selectedOnly) {

            JOptionPane.YES_NO_OPTION,

                        BibtexEntry[] selected = frame.basePanel().getSelectedEntries();

            JOptionPane.QUESTION_MESSAGE, null,

                        entryIds = new HashSet<String>();

            new String[]{Globals.lang("Ok"), Globals.lang("Cancel")},

                        for (int i = 0; i < selected.length; i++) {

            Globals.lang("Ok"));

                            BibtexEntry bibtexEntry = selected[i];

                            entryIds.add(bibtexEntry.getId());

        if (answer == JOptionPane.NO_OPTION)

                        }

            return;

                    }

        IExportFormat format = formats[list.getSelectedIndex()];

                    // Set the global variable for this database's file directory before exporting,

                    // so formatters can resolve linked files correctly.

        // Set the global variable for this database's file directory before exporting,

                    // (This is an ugly hack!)

        // so formatters can resolve linked files correctly.

                    Globals.prefs.fileDirForDatabase = frame.basePanel().metaData()

        // (This is an ugly hack!)

                            .getFileDirectory(GUIGlobals.FILE_FIELD);

        Globals.prefs.fileDirForDatabase = frame.basePanel().metaData()

                    // Also store the database's file in a global variable:

                .getFileDirectory(GUIGlobals.FILE_FIELD);

                    Globals.prefs.databaseFile = frame.basePanel().metaData().getFile();

        // Also store the database's file in a global variable:

        Globals.prefs.databaseFile = frame.basePanel().metaData().getFile();

                    // Make sure we remember which filter was used, to set

                    // the default for next time:

                    Globals.prefs.put("lastUsedExport", format.getConsoleName());

        /*final boolean custom = (list.getSelectedIndex() >= Globals.STANDARD_EXPORT_COUNT);

                    Globals.prefs.put("exportWorkingDirectory", file.getParent());

        String dir = null;

        if (custom) {

                    final File finFile = file;

            int index = list.getSelectedIndex() - Globals.STANDARD_EXPORT_COUNT;

                    final Set<String> finEntryIDs = entryIds;

            dir = (String) (Globals.prefs.customExports.getElementAt(index)[1]);

                    AbstractWorker exportWorker = new AbstractWorker() {

            File f = new File(dir);

                        String errorMessage = null;

            lfName = f.getName();

                        public void run() {

            lfName = lfName.substring(0, lfName.indexOf("."));

                            try {

            // Remove file name - we want the directory only.

                                format.performExport(frame.basePanel().database(),

            dir = f.getParent() + System.getProperty("file.separator");

                                        frame.basePanel().metaData(),

        }

                                        finFile.getPath(), frame

        final String format = lfName,

                                    .basePanel().getEncoding(), finEntryIDs);

                directory = dir;

                            } catch (Exception ex) {

        */

                                ex.printStackTrace();

        File tmp = null;

                                if (ex.getMessage()==null ) {

        Reader reader = null;

                                    errorMessage = ex.toString();

        try {

                                } else {

            // To simplify the exporter API we simply do a normal export to a temporary

                                    errorMessage = ex.getMessage();

            // file, and read the contents afterwards:

                                }

            tmp = File.createTempFile("jabrefCb", ".tmp");

                            }

            tmp.deleteOnExit();

                        }

            BibtexEntry[] bes = panel.getSelectedEntries();

            HashSet<String> entries = new HashSet<String>(bes.length);

                        public void update() {

            for (BibtexEntry be : bes)

                            // No error message. Report success:

                entries.add(be.getId());

                            if (errorMessage == null) {

                                frame.output(Globals.lang("%0 export successful", format.getDisplayName()));

            // Write to file:

                            }

            format.performExport(database, panel.metaData(),

                            // ... or show an error dialog:

                    tmp.getPath(), panel.getEncoding(), entries);

                            else {

            // Read the file and put the contents on the clipboard:

                                frame.output(Globals.lang("Could not save file")

            StringBuffer sb = new StringBuffer();

                                        + " - " + errorMessage);

            reader = new InputStreamReader(new FileInputStream(tmp), panel.getEncoding());

                                // Need to warn the user that saving failed!

            int s;

                                JOptionPane.showMessageDialog(frame, Globals.lang("Could not save file")

            while ((s = reader.read()) != -1) {

                                    + ".\n" + errorMessage, Globals.lang("Save database"),

                sb.append((char)s);

                                    JOptionPane.ERROR_MESSAGE);

            }

                            }

            ClipboardOwner owner = new ClipboardOwner() {

                        }

                public void lostOwnership(Clipboard clipboard, Transferable content) {

                    };

                }

            };

                    // Run the export action in a background thread:

            //StringSelection ss = new StringSelection(sw.toString());

                    (exportWorker.getWorker()).run();

            RtfSelection rs = new RtfSelection(sb.toString());

                    // Run the update method:

            Toolkit.getDefaultToolkit().getSystemClipboard()

                    exportWorker.update();

                    .setContents(rs, owner);

                }

            message = Globals.lang("Entries exported to clipboard") + ": " + bes.length;

			}

        } catch (Exception e) {

            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.

            message = Globals.lang("Error exporting to clipboard");

            return;

        } finally {

            // Clean up:

            if (tmp != null)

                tmp.delete();

            if (reader != null)

                try { reader.close(); } catch (IOException ex) { ex.printStackTrace(); }

        }

    }