src/java/net/sf/jabref/external/ExternalFileTypeEditor.java

   1 package net.sf.jabref.external;
   2
   3 import net.sf.jabref.JabRefFrame;
   4 import net.sf.jabref.Globals;
   5 import net.sf.jabref.GUIGlobals;
   6 import net.sf.jabref.MnemonicAwareAction;
   7
   8 import javax.swing.*;
   9 import javax.swing.table.AbstractTableModel;
  10 import javax.swing.table.TableCellRenderer;
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.awt.*;
  14 import java.awt.event.ActionListener;
  15 import java.awt.event.ActionEvent;
  16 import java.awt.event.MouseAdapter;
  17 import java.awt.event.MouseEvent;
  18
  19 import com.jgoodies.forms.builder.ButtonBarBuilder;
  20 import com.jgoodies.forms.builder.ButtonStackBuilder;
  21
  22 /**
  23  * Editor for external file types.
  24  */
  25 public class ExternalFileTypeEditor extends JDialog {
  26
  27     private JFrame frame = null;
  28     private JDialog dialog = null;
  29     private ArrayList<ExternalFileType> fileTypes;
  30     private JTable table;
  31     private ExternalFileTypeEntryEditor entryEditor = null;
  32     private FileTypeTableModel tableModel;
  33     private JButton ok = new JButton(Globals.lang("Ok")),
  34         cancel = new JButton(Globals.lang("Cancel"));
  35     private JButton add = new JButton(GUIGlobals.getImage("add")),
  36         remove = new JButton(GUIGlobals.getImage("remove")),
  37         edit = new JButton(GUIGlobals.getImage("edit")),
  38         toDefaults = new JButton(Globals.lang("Default"));
  39     private EditListener editListener = new EditListener();
  40
  41     public ExternalFileTypeEditor(JFrame frame) {
  42         super(frame, Globals.lang("Manage external file types"), true);
  43         this.frame = frame;
  44         init();
  45     }
  46
  47     public ExternalFileTypeEditor(JDialog dialog) {
  48         super(dialog, Globals.lang("Manage external file types"), true);
  49         this.dialog = dialog;
  50         init();
  51     }
  52
  53     /**
  54      * Update the editor to show the current settings in Preferences.
  55      */
  56     public void setValues() {
  57         fileTypes.clear();
  58         ExternalFileType[] types = Globals.prefs.getExternalFileTypeSelection();
  59         for (int i = 0; i < types.length; i++) {
  60
  61             fileTypes.add(types[i].copy());
  62         }
  63         Collections.sort(fileTypes);
  64     }
  65
  66     /**
  67      * Store the list of external entry types to Preferences.
  68      */
  69     public void storeSettings() {
  70         Globals.prefs.setExternalFileTypes(fileTypes);
  71     }
  72
  73     private void init() {
  74
  75         ok.addActionListener(new ActionListener() {
  76             public void actionPerformed(ActionEvent e) {
  77                 storeSettings();
  78                 dispose();
  79             }
  80         });
  81         AbstractAction cancelAction = new AbstractAction() {
  82             public void actionPerformed(ActionEvent e) {
  83                 dispose();
  84             }
  85         };
  86         cancel.addActionListener(cancelAction);
  87         // The toDefaults resets the entire list to its default values.
  88         toDefaults.addActionListener(new ActionListener() {
  89             public void actionPerformed(ActionEvent e) {
  90                 /*int reply = JOptionPane.showConfirmDialog(ExternalFileTypeEditor.this,
  91                         Globals.lang("All custom file types will be lost. Proceed?"),
  92                         Globals.lang("Reset file type definitons"), JOptionPane.YES_NO_OPTION,
  93                         JOptionPane.QUESTION_MESSAGE);*/
  94                 //if (reply == JOptionPane.YES_OPTION) {
  95                     java.util.List<ExternalFileType> list = Globals.prefs.getDefaultExternalFileTypes();
  96                     fileTypes.clear();
  97                     fileTypes.addAll(list);
  98                     Collections.sort(fileTypes);
  99                     //Globals.prefs.resetExternalFileTypesToDefault();
 100                     //setValues();
 101                     tableModel.fireTableDataChanged();
 102                 //}
 103             }
 104         });
 105
 106
 107         add.addActionListener(new AddListener());
 108         remove.addActionListener(new RemoveListener());
 109         edit.addActionListener(editListener);
 110         fileTypes = new ArrayList<ExternalFileType>();
 111         setValues();
 112
 113
 114         tableModel = new FileTypeTableModel();
 115         table = new JTable(tableModel);
 116         table.setDefaultRenderer(ImageIcon.class, new IconRenderer());
 117         table.addMouseListener(new TableClickListener());
 118
 119         table.getColumnModel().getColumn(0).setMaxWidth(24);
 120         table.getColumnModel().getColumn(0).setMinWidth(24);
 121         table.getColumnModel().getColumn(1).setMinWidth(170);
 122         table.getColumnModel().getColumn(2).setMinWidth(60);
 123         table.getColumnModel().getColumn(3).setMinWidth(100);
 124         table.getColumnModel().getColumn(0).setResizable(false);
 125
 126         JScrollPane sp = new JScrollPane(table);
 127
 128         JPanel upper = new JPanel();
 129         upper.setLayout(new BorderLayout());
 130         upper.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
 131         upper.add(sp, BorderLayout.CENTER);
 132         getContentPane().add(upper, BorderLayout.CENTER);
 133
 134         ButtonStackBuilder bs = new ButtonStackBuilder();
 135         bs.addGridded(add);
 136         bs.addGridded(remove);
 137         bs.addGridded(edit);
 138         bs.addRelatedGap();
 139         bs.addGridded(toDefaults);
 140         upper.add(bs.getPanel(), BorderLayout.EAST);
 141
 142         ButtonBarBuilder bb = new ButtonBarBuilder();
 143         bb.addGlue();
 144         bb.addGridded(ok);
 145         bb.addGridded(cancel);
 146         bb.addGlue();
 147         bb.getPanel().setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
 148         getContentPane().add(bb.getPanel(), BorderLayout.SOUTH);
 149         pack();
 150
 151         // Key bindings:
 152         ActionMap am = upper.getActionMap();
 153         InputMap im = upper.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
 154         im.put(Globals.prefs.getKey("Close dialog"), "close");
 155         am.put("close", cancelAction);
 156         am = bb.getPanel().getActionMap();
 157         im = bb.getPanel().getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
 158         im.put(Globals.prefs.getKey("Close dialog"), "close");
 159         am.put("close", cancelAction);
 160
 161         if (frame != null)
 162             setLocationRelativeTo(frame);
 163         else
 164             setLocationRelativeTo(dialog);
 165     }
 166
 167     private ExternalFileTypeEntryEditor getEditor(ExternalFileType type) {
 168         if (entryEditor == null)
 169             entryEditor = new ExternalFileTypeEntryEditor(ExternalFileTypeEditor.this,  type);
 170         else
 171             entryEditor.setEntry(type);
 172         return entryEditor;
 173     }
 174
 175     /**
 176      * Get an AbstractAction for opening the external file types editor.
 177      * @param frame The JFrame used as parent window for the dialog.
 178      * @return An Action for opening the editor.
 179      */
 180     public static AbstractAction getAction(JabRefFrame frame) {
 181         return new EditExternalFileTypesAction(frame);
 182     }
 183
 184     /**
 185      * Get an AbstractAction for opening the external file types editor.
 186      * @param dialog The JDialog used as parent window for the dialog.
 187      * @return An Action for opening the editor.
 188      */
 189     public static AbstractAction getAction(JDialog dialog) {
 190         return new EditExternalFileTypesAction(dialog);
 191     }
 192
 193     class AddListener implements ActionListener {
 194         public void actionPerformed(ActionEvent e) {
 195             // Generate a new file type:
 196             ExternalFileType type = new ExternalFileType("", "", "", "new");
 197             // Show the file type editor:
 198             getEditor(type).setVisible(true);
 199             if (entryEditor.okPressed()) {
 200                 // Ok was pressed. Add the new file type and update the table:
 201                 fileTypes.add(type);
 202                 tableModel.fireTableDataChanged();
 203             }
 204         }
 205     }
 206
 207     class RemoveListener implements ActionListener {
 208
 209         public void actionPerformed(ActionEvent e) {
 210             int[] rows = table.getSelectedRows();
 211             if (rows.length == 0)
 212                 return;
 213             for (int i=rows.length-1; i>=0; i--) {
 214                 fileTypes.remove(rows[i]);
 215             }
 216             tableModel.fireTableDataChanged();
 217             if (fileTypes.size() > 0) {
 218                 int row = Math.min(rows[0], fileTypes.size()-1);
 219                 table.setRowSelectionInterval(row, row);
 220             }
 221         }
 222     }
 223
 224     class EditListener implements ActionListener {
 225
 226         public void actionPerformed(ActionEvent e) {
 227             int[] rows = table.getSelectedRows();
 228             if (rows.length != 1)
 229                 return;
 230             getEditor(fileTypes.get(rows[0])).setVisible(true);
 231             if (entryEditor.okPressed())
 232                 tableModel.fireTableDataChanged();
 233         }
 234     }
 235
 236     class IconRenderer implements TableCellRenderer {
 237         JLabel lab = new JLabel();
 238
 239         public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
 240             lab.setText(null);
 241             lab.setIcon((ImageIcon)value);
 242             return lab;
 243         }
 244     }
 245
 246     class FileTypeTableModel extends AbstractTableModel {
 247
 248         public int getColumnCount() {
 249             return 4;
 250         }
 251
 252         public int getRowCount() {
 253             return fileTypes.size();
 254         }
 255
 256         public String getColumnName(int column) {
 257             switch (column) {
 258                 case 0:
 259                     return " ";
 260                 case 1:
 261                     return Globals.lang("Name");
 262                 case 2:
 263                     return Globals.lang("Extension");
 264                 case 3:
 265                     return Globals.lang("Application");
 266                 default:
 267                     return null;
 268             }
 269         }
 270
 271         public Class<?> getColumnClass(int columnIndex) {
 272             if (columnIndex == 0)
 273                 return ImageIcon.class;
 274             else return String.class;
 275         }
 276
 277         public Object getValueAt(int rowIndex, int columnIndex) {
 278             ExternalFileType type = fileTypes.get(rowIndex);
 279             switch (columnIndex) {
 280                 case 0:
 281                     return type.getIcon();
 282                 case 1:
 283                     return type.getName();
 284                 case 2:
 285                     return type.getExtension();
 286                 case 3:
 287                     return type.getOpenWith();
 288                 default:
 289                     return null;
 290             }
 291         }
 292     }
 293
 294     class TableClickListener extends MouseAdapter {
 295
 296         private void handleClick(MouseEvent e) {
 297             if (e.getClickCount() == 2) {
 298                 editListener.actionPerformed(null);
 299             }
 300         }
 301
 302         public void mouseClicked(MouseEvent e) {
 303             handleClick(e);
 304         }
 305
 306         public void mousePressed(MouseEvent e) {
 307             handleClick(e);
 308         }
 309
 310         public void mouseReleased(MouseEvent e) {
 311             handleClick(e);
 312         }
 313     }
 314
 315     public static class EditExternalFileTypesAction extends MnemonicAwareAction {
 316         private JFrame frame = null;
 317         private JDialog dialog = null;
 318         ExternalFileTypeEditor editor = null;
 319
 320         public EditExternalFileTypesAction(JFrame frame) {
 321             super();
 322             putValue(NAME, "Manage external file types");
 323             this.frame = frame;
 324         }
 325
 326         public EditExternalFileTypesAction(JDialog dialog) {
 327             super();
 328             putValue(NAME, "Manage external file types");
 329             this.dialog = dialog;
 330         }
 331
 332         public void actionPerformed(ActionEvent e) {
 333             if (editor == null) {
 334                 if (frame != null)
 335                     editor = new ExternalFileTypeEditor(frame);
 336                 else
 337                     editor = new ExternalFileTypeEditor(dialog);
 338             }
 339             editor.setValues();
 340             editor.setVisible(true);
 341         }
 342     }
 343
 344 }