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

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