1   /*
2    *  Copyright (c) 1998-2001, The University of Sheffield.
3    *
4    *  This file is part of GATE (see http://gate.ac.uk/), and is free
5    *  software, licenced under the GNU Library General Public License,
6    *  Version 2, June 1991 (in the distribution as file licence.html,
7    *  and also available at http://gate.ac.uk/gate/licence.html).
8    *
9    *  Valentin Tablan 03/10/2001
10   *
11   *  $Id: ResourceParametersEditor.java,v 1.33 2003/02/04 11:14:50 valyt Exp $
12   *
13   */
14  
15  package gate.gui;
16  
17  import java.awt.Frame;
18  import java.awt.BorderLayout;
19  import java.awt.Component;
20  import java.awt.Dimension;
21  import java.awt.Insets;
22  import java.awt.Graphics;
23  import java.awt.Window;
24  import java.awt.event.*;
25  import javax.swing.*;
26  import javax.swing.table.*;
27  import javax.swing.tree.*;
28  import javax.swing.event.*;
29  import javax.swing.border.*;
30  
31  import java.util.*;
32  import java.net.URL;
33  import java.io.IOException;
34  import java.text.*;
35  
36  import gate.*;
37  import gate.util.*;
38  import gate.swing.*;
39  import gate.creole.*;
40  import gate.event.*;
41  
42  /**
43   * Allows the editing of a set of parameters for a resource. It needs a pointer
44   * to the resource and a list of the parameter names for the parameters that
45   * should be displayed. The list of the parameters is actually a list of lists
46   * of strings representing parameter disjunctions.
47   */
48  public class ResourceParametersEditor extends XJTable implements CreoleListener{
49  
50    public ResourceParametersEditor(){
51      initLocalData();
52      initGuiComponents();
53      initListeners();
54    }
55  
56    /**
57     * Initialises this GUI component.
58     * @param resource the resource for which the parameters need to be set.
59     * @param paramaters a list of lists of {@link Parameter} representing
60     * parameter disjunctions.
61     */
62    public void init(Resource resource, List parameters){
63      this.resource = resource;
64      if(parameters != null){
65        parameterDisjunctions = new ArrayList(parameters.size());
66        for(int i = 0; i < parameters.size(); i++){
67          parameterDisjunctions.add(
68                              new ParameterDisjunction(resource,
69                                                       (List)parameters.get(i)));
70        }
71      }else{
72        parameterDisjunctions = null;
73      }
74      tableModel.fireTableDataChanged();
75      adjustSizes();
76    }
77  
78    protected void initLocalData(){
79      resource = null;
80      parameterDisjunctions = null;
81    }// protected void initLocalData()
82  
83    protected void initGuiComponents(){
84      setModel(tableModel = new ParametersTableModel());
85  
86      getColumnModel().getColumn(0).
87                       setCellRenderer(new ParameterDisjunctionRenderer());
88  
89      getColumnModel().getColumn(1).
90                       setCellRenderer(new DefaultTableCellRenderer());
91  
92      getColumnModel().getColumn(2).
93                       setCellRenderer(new BooleanRenderer());
94  
95      getColumnModel().getColumn(3).
96                       setCellRenderer(new ParameterValueRenderer());
97  
98  
99      getColumnModel().getColumn(0).
100                      setCellEditor(new ParameterDisjunctionEditor());
101 
102     getColumnModel().getColumn(3).
103                      setCellEditor(new ParameterValueEditor());
104 
105     setIntercellSpacing(new Dimension(5, 5));
106 
107     setSurrendersFocusOnKeystroke(true);
108   }// protected void initGuiComponents()
109 
110 
111   protected void initListeners(){
112     Gate.getCreoleRegister().addCreoleListener(this);
113     addKeyListener(new KeyAdapter() {
114       public void keyTyped(KeyEvent e) {
115         if(e.getKeyCode() == e.VK_ENTER){
116           if(getEditingColumn() == -1 && getEditingRow() == -1){
117             getParent().dispatchEvent(e);
118           }
119         }
120       }
121 
122       public void keyPressed(KeyEvent e) {
123       }
124 
125       public void keyReleased(KeyEvent e) {
126       }
127     });
128   }
129 
130   /**
131    * Cleans the internal data and prepares this object to be collected
132    */
133   public void cleanup(){
134     Gate.getCreoleRegister().removeCreoleListener(this);
135   }
136 
137 //  /**
138 //   * Disable key handling for most keys by JTable when not editing.
139 //   */
140 //  protected boolean processKeyBinding(KeyStroke ks, KeyEvent e,
141 //                                      int condition, boolean pressed) {
142 //    int keyCode = e.getKeyCode();
143 //    if(isEditing() ||
144 //       keyCode == KeyEvent.VK_UP ||
145 //       keyCode == KeyEvent.VK_DOWN ||
146 //       keyCode == KeyEvent.VK_LEFT ||
147 //       keyCode == KeyEvent.VK_RIGHT ||
148 //       keyCode == KeyEvent.VK_TAB) return super.processKeyBinding(ks, e,
149 //                                                                  condition,
150 //                                                                  pressed);
151 //    return false;
152 //  }
153 
154   /**
155    * Should this GUI comonent allow editing?
156    */
157 
158   /**
159    * Sets the parameters for the resource to their new values as resulted
160    * from the user's edits.
161    */
162   public void setParameters() throws ResourceInstantiationException{
163     if(resource == null || parameterDisjunctions == null) return;
164     //stop current edits
165     if(getEditingColumn() != -1 && getEditingRow() != -1){
166       editingStopped(new ChangeEvent(getCellEditor(getEditingRow(),
167                                                    getEditingColumn())));
168     }
169     //set the parameters
170     for(int i = 0; i < parameterDisjunctions.size(); i++){
171       ParameterDisjunction pDisj = (ParameterDisjunction)
172                                    parameterDisjunctions.get(i);
173       resource.setParameterValue(pDisj.getName(), pDisj.getValue());
174     }
175   }
176 
177   /**
178    * Does this GUI component allow editing?
179    */
180 
181   public Resource getResource() {
182     return resource;
183   }
184 
185   /**
186    * Gets the current values for the parameters.
187    * @return a {@link FeatureMap} conatining the curent values for the curently
188    * selected parameters in each disjunction.
189    */
190   public FeatureMap getParameterValues(){
191     //stop current edits
192     if(getEditingColumn() != -1 && getEditingRow() != -1){
193       editingStopped(new ChangeEvent(getCellEditor(getEditingRow(),
194                                                    getEditingColumn())));
195     }
196     //get the parameters
197     FeatureMap values = Factory.newFeatureMap();
198     if(parameterDisjunctions != null){
199       for(int i = 0; i < parameterDisjunctions.size(); i++){
200         ParameterDisjunction pDisj = (ParameterDisjunction)
201                                      parameterDisjunctions.get(i);
202         values.put(pDisj.getName(), pDisj.getValue());
203       }
204     }
205     return values;
206   }
207 
208   public void resourceLoaded(CreoleEvent e) {
209     repaint();
210   }
211   public void resourceUnloaded(CreoleEvent e) {
212     repaint();
213   }
214 
215   public void resourceRenamed(Resource resource, String oldName,
216                               String newName){
217     repaint();
218   }
219   public void datastoreOpened(CreoleEvent e) {
220   }
221   public void datastoreCreated(CreoleEvent e) {
222   }
223   public void datastoreClosed(CreoleEvent e) {
224   }
225   public void setEditable(boolean editable) {
226     this.editable = editable;
227   }
228   public boolean isEditable() {
229     return editable;
230   }
231 
232   ParametersTableModel tableModel;
233   Resource resource;
234 
235 
236 
237   /**
238    * A list of {@link ParameterDisjunction}
239    */
240   protected List parameterDisjunctions;
241   protected boolean editable = true;
242 
243   //inner classes
244   protected class ParametersTableModel extends AbstractTableModel{
245 
246     public int getColumnCount(){return 4;}
247 
248     public Class getColumnClass(int columnIndex){
249       switch(columnIndex){
250         case 0: return ParameterDisjunction.class;
251         case 1: return String.class;
252         case 2: return Boolean.class;
253         case 3: return Object.class;
254         default: return Object.class;
255       }
256     }// public Class getColumnClass(int columnIndex)
257 
258     public String getColumnName(int columnIndex){
259       switch(columnIndex){
260         case 0: return "Name";
261         case 1: return "Type";
262         case 2: return "Required";
263         case 3: return "Value";
264         default: return "?";
265       }
266     }//public String getColumnName(int columnIndex)
267 
268     public boolean isCellEditable(int rowIndex,
269                               int columnIndex) {
270       switch(columnIndex){
271         case 0: return ((ParameterDisjunction)
272                         parameterDisjunctions.get(rowIndex)).size() > 1;
273         case 1: return false;
274         case 2: return false;
275         case 3: return editable;
276         default: return false;
277       }
278     }// public boolean isCellEditable
279 
280     public int getRowCount(){
281       return (parameterDisjunctions == null) ? 0 : parameterDisjunctions.size();
282     }
283 
284     public Object getValueAt(int rowIndex,
285                          int columnIndex) {
286       ParameterDisjunction pDisj = (ParameterDisjunction)
287                                    parameterDisjunctions.get(rowIndex);
288       switch(columnIndex){
289         case 0: return pDisj;
290         case 1: return pDisj.getType();
291         case 2: return pDisj.isRequired();
292         case 3: return pDisj.getValue();
293         default: return "?";
294       }
295     }// public Object getValueAt
296 
297     public void setValueAt(Object aValue, int rowIndex, int columnIndex){
298       ParameterDisjunction pDisj = (ParameterDisjunction)
299                                    parameterDisjunctions.get(rowIndex);
300       switch(columnIndex){
301         case 0:{
302           pDisj.setSelectedIndex(((Integer)aValue).intValue());
303           break;
304         }
305         case 1:{
306           break;
307         }
308         case 2:{
309           break;
310         }
311         case 3:{
312           pDisj.setValue(aValue);
313           break;
314         }
315         default:{}
316       }
317     }// public void setValueAt
318   }///class FeaturesTableModel extends DefaultTableModel
319 
320   class ParameterDisjunctionRenderer extends DefaultTableCellRenderer {
321     public ParameterDisjunctionRenderer(){
322       combo = new JComboBox();
323       class CustomRenderer extends JLabel implements ListCellRenderer {
324         public Component getListCellRendererComponent(JList list,
325                                                       Object value,
326                                                       int index,
327                                                       boolean isSelected,
328                                                       boolean cellHasFocus){
329 
330           setText(text);
331           setIcon(MainFrame.getIcon(iconName));
332           return this;
333         }
334       };
335       combo.setRenderer(new CustomRenderer());
336     }
337 
338     public Component getTableCellRendererComponent(JTable table,
339                                                    Object value,
340                                                    boolean isSelected,
341                                                    boolean hasFocus,
342                                                    int row,
343                                                    int column) {
344       ParameterDisjunction pDisj = (ParameterDisjunction)value;
345       text = pDisj.getName();
346       String type = pDisj.getType();
347       iconName = "param.gif";
348       if(Gate.isGateType(type)){
349         ResourceData rData = (ResourceData)Gate.getCreoleRegister().get(type);
350         if(rData != null) iconName = rData.getIcon();
351       }
352       if(pDisj.size() > 1){
353         combo.setModel(new DefaultComboBoxModel(new Object[]{text}));
354         return combo;
355       }
356       //prepare the renderer
357       Component comp = super.getTableCellRendererComponent(table,
358                                                            text,
359                                                            isSelected, hasFocus,
360                                                            row, column);
361       setIcon(MainFrame.getIcon(iconName));
362       return this;
363     }// public Component getTableCellRendererComponent
364 
365     //combobox used for OR parameters
366     JComboBox combo;
367     String iconName;
368     String text;
369   }//class ParameterDisjunctionRenderer
370 
371 
372   /**
373    * A renderer that displays a File Open button next to a text field.
374    * Used for setting URLs from files.
375    */
376   class ParameterValueRenderer extends ObjectRenderer {
377     ParameterValueRenderer() {
378       fileButton = new JButton(MainFrame.getIcon("loadFile.gif"));
379       fileButton.setToolTipText("Set from file...");
380       listButton = new JButton(MainFrame.getIcon("editList.gif"));
381       listButton.setToolTipText("Edit the list");
382       textButtonBox = new JPanel();
383       textButtonBox.setLayout(new BoxLayout(textButtonBox, BoxLayout.X_AXIS));
384       textButtonBox.setOpaque(false);
385 
386       combo = new JComboBox();
387       combo.setRenderer(new ResourceRenderer());
388     }// CustomObjectRenderer()
389 
390     public Component getTableCellRendererComponent(JTable table,
391                                                    Object value,
392                                                    boolean isSelected,
393                                                    boolean hasFocus,
394                                                    int row,
395                                                    int column) {
396 
397       String type = ((ParameterDisjunction)table.getValueAt(row, 0)).getType();
398 
399       if(Gate.isGateType(type)){
400         //Gate type
401         if(ResourceParametersEditor.this.isEditable()){
402           combo.setModel(new DefaultComboBoxModel(new Object[]{value == null ?
403                                                                "<none>" :
404                                                                value }));
405           return combo;
406         }else{
407           //not editable; we'll just use the text field
408           //prepare the renderer
409           String text = value == null ? "<none>" : value.toString();
410           super.getTableCellRendererComponent(table, text, isSelected,
411                                                 hasFocus, row, column);
412           return this;
413         }
414       }else{
415         Class typeClass = null;
416         try{
417           typeClass = Class.forName(type);
418         }catch(ClassNotFoundException cnfe){
419         }
420         //non Gate type -> we'll use the text field
421         String text = (value == null) ?
422                       "                                        " +
423                       "                                        " :
424                       value.toString();
425         //prepare the renderer
426         super.getTableCellRendererComponent(table, text, isSelected,
427                                               hasFocus, row, column);
428 
429         if(type.equals("java.net.URL")){
430           if(ResourceParametersEditor.this.isEditable()){
431             textButtonBox.removeAll();
432             textButtonBox.add(this);
433             this.setMaximumSize(new Dimension(Integer.MAX_VALUE,
434                                               getPreferredSize().height));
435             textButtonBox.add(Box.createHorizontalStrut(5));
436             textButtonBox.add(fileButton);
437             return textButtonBox;
438           }else{
439             return this;
440           }
441         }else if(typeClass != null &&
442                  List.class.isAssignableFrom(typeClass)){
443           //List value
444           setText(textForList((List)value));
445           if(ResourceParametersEditor.this.isEditable()){
446           textButtonBox.removeAll();
447           textButtonBox.add(this);
448           this.setMaximumSize(new Dimension(Integer.MAX_VALUE,
449                                             getPreferredSize().height));
450           textButtonBox.add(Box.createHorizontalStrut(5));
451           textButtonBox.add(listButton);
452           return textButtonBox;
453           }else{
454             return this;
455           }
456         }else return this;
457       }
458     }// public Component getTableCellRendererComponent
459 
460     /**
461      * Gets a string representation for a list value
462      */
463     protected String textForList(List list){
464       if(list == null || list.isEmpty()) return "[]";
465       StringBuffer res = new StringBuffer("[");
466       Iterator elemIter = list.iterator();
467       while(elemIter.hasNext()){
468         Object elem = elemIter.next();
469         res.append( ((elem instanceof NameBearer) ?
470                     ((NameBearer)elem).getName() :
471                     elem.toString()) + ", ");
472       }
473       res.delete(res.length() - 2, res.length() - 1);
474       res.append("]");
475       return res.toString();
476     }
477 
478     JButton fileButton;
479     JButton listButton;
480     JComboBox combo;
481     JPanel textButtonBox;
482   }//class ObjectRenderer extends DefaultTableCellRenderer
483 
484   class ParameterDisjunctionEditor extends DefaultCellEditor{
485     public ParameterDisjunctionEditor(){
486       super(new JComboBox());
487       combo = (JComboBox)super.getComponent();
488       class CustomRenderer extends JLabel implements ListCellRenderer {
489         public CustomRenderer(){
490           setOpaque(true);
491         }
492         public Component getListCellRendererComponent(JList list,
493                                                       Object value,
494                                                       int index,
495                                                       boolean isSelected,
496                                                       boolean cellHasFocus){
497           if (isSelected) {
498               setBackground(list.getSelectionBackground());
499               setForeground(list.getSelectionForeground());
500           }
501           else {
502               setBackground(list.getBackground());
503               setForeground(list.getForeground());
504           }
505 
506           setFont(list.getFont());
507 
508           setText((String)value);
509 
510           String iconName = "param.gif";
511           Parameter[] params = pDisj.getParameters();
512           for(int i = 0; i < params.length; i++){
513             Parameter param = (Parameter)params[i];
514             if(param.getName().equals(value)){
515               String type = param.getTypeName();
516               if(Gate.getCreoleRegister().containsKey(type)){
517                 ResourceData rData = (ResourceData)
518                                      Gate.getCreoleRegister().get(type);
519                 if(rData != null) iconName = rData.getIcon();
520               }
521               break;
522             }//if(params[i].getName().equals(value))
523           }//for(int i = 0; params.length; i++)
524 
525           setIcon(MainFrame.getIcon(iconName));
526           return this;
527         }
528       };//class CustomRenderer extends JLabel implements ListCellRenderer
529       combo.setRenderer(new CustomRenderer());
530       combo.addActionListener(new ActionListener() {
531         public void actionPerformed(ActionEvent e) {
532           stopCellEditing();
533         }
534       });
535     }// public ParameterDisjunctionEditor()
536 
537     public Component getTableCellEditorComponent(JTable table,
538                                              Object value,
539                                              boolean isSelected,
540                                              int row,
541                                              int column){
542      pDisj = (ParameterDisjunction)value;
543      combo.setModel(new DefaultComboBoxModel(pDisj.getNames()));
544      return combo;
545     }// public Component getTableCellEditorComponent
546 
547     public Object getCellEditorValue(){
548       return new Integer(combo.getSelectedIndex());
549     }
550 
551     public boolean stopCellEditing(){
552       combo.hidePopup();
553       return super.stopCellEditing();
554     }
555 
556     JComboBox combo;
557     ParameterDisjunction pDisj;
558   }// class ParameterDisjunctionEditor extends DefaultCellEditor
559 
560   class ParameterValueEditor extends AbstractCellEditor
561                              implements TableCellEditor{
562     ParameterValueEditor(){
563       combo = new JComboBox();
564       combo.setRenderer(new ResourceRenderer());
565       combo.setEditable(false);
566 
567       textField = new JTextField();
568 
569       fileChooser = MainFrame.getFileChooser();
570       fileButton = new JButton(MainFrame.getIcon("loadFile.gif"));
571       fileButton.setToolTipText("Set from file...");
572       fileButton.addActionListener(new ActionListener() {
573         public void actionPerformed(ActionEvent e) {
574           fileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
575           fileChooser.setDialogTitle("Select a file");
576           int res = fileChooser.showOpenDialog(ResourceParametersEditor.this);
577           if(res == fileChooser.APPROVE_OPTION){
578             try {
579               textField.setText(fileChooser.getSelectedFile().
580                                 toURL().toExternalForm());
581             } catch(IOException ioe){}
582             fireEditingStopped();
583           }else{
584             fireEditingCanceled();
585           }
586         }
587       });
588 
589       listButton = new JButton(MainFrame.getIcon("editList.gif"));
590       listButton.setToolTipText("Edit the list");
591       listButton.addActionListener(new ActionListener() {
592         public void actionPerformed(ActionEvent e) {
593           List returnedList = listEditor.showDialog();
594           if(returnedList != null){
595             listValue = returnedList;
596             fireEditingStopped();
597           }else{
598             fireEditingCanceled();
599           }
600         }
601       });
602 
603       textButtonBox = new JPanel();
604       textButtonBox.setLayout(new BoxLayout(textButtonBox, BoxLayout.X_AXIS));
605       textButtonBox.setOpaque(false);
606       label = new JLabel(){
607         public boolean isFocusable(){
608           return true;
609         }
610       };
611       label.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
612       label.addMouseListener(new MouseAdapter() {
613         public void mouseClicked(MouseEvent e) {
614           Boolean value = new Boolean(label.getText());
615           value = new Boolean(!value.booleanValue());
616           label.setText(value.toString());
617         }
618       });
619       label.addKeyListener(new KeyAdapter() {
620         public void keyTyped(KeyEvent e) {
621           Boolean value = new Boolean(label.getText());
622           value = new Boolean(!value.booleanValue());
623           label.setText(value.toString());
624         }
625       });
626 
627       textButtonBox.addFocusListener(new FocusAdapter() {
628         public void focusGained(FocusEvent e) {
629           if(comboUsed){
630 
631           }else{
632             textField.requestFocusInWindow();
633           }
634         }
635 
636         public void focusLost(FocusEvent e) {
637         }
638       });
639 
640     }//ParameterValueEditor()
641 
642     public Component getTableCellEditorComponent(JTable table,
643                                                  Object value,
644                                                  boolean isSelected,
645                                                  int row,
646                                                  int column){
647       comboUsed = false;
648       listUsed = false;
649       ParameterDisjunction pDisj = (ParameterDisjunction)
650                                    table.getValueAt(row, 0);
651       type = pDisj.getType();
652 //      ResourceData rData = (ResourceData)Gate.getCreoleRegister().get(type);
653 
654       if(Gate.isGateType(type)){
655         //Gate type
656         comboUsed = true;
657         ArrayList values = new ArrayList();
658         try{
659           values.addAll(Gate.getCreoleRegister().
660                         getAllInstances(type));
661         }catch(GateException ge){
662           ge.printStackTrace(Err.getPrintWriter());
663         }
664         values.add(0, "<none>");
665         combo.setModel(new DefaultComboBoxModel(values.toArray()));
666         combo.setSelectedItem(value == null ? "<none>" : value);
667         return combo;
668       }else{
669         //non Gate type
670         Class typeClass = null;
671         try{
672           typeClass = Class.forName(type);
673         }catch(ClassNotFoundException cnfe){
674         }
675 
676         textField.setText((value == null) ? "" : value.toString());
677         if(type.equals("java.net.URL")){
678           //clean up all filters
679           fileChooser.resetChoosableFileFilters();
680           fileChooser.setAcceptAllFileFilterUsed(true);
681           fileChooser.setFileFilter(fileChooser.getAcceptAllFileFilter());
682           Parameter param = pDisj.getParameter();
683           Set sufixes = param.getSuffixes();
684           if(sufixes != null){
685             ExtensionFileFilter fileFilter = new ExtensionFileFilter();
686             Iterator sufIter = sufixes.iterator();
687             while(sufIter.hasNext()){
688               fileFilter.addExtension((String)sufIter.next());
689             }
690             fileFilter.setDescription("Known file types " + sufixes.toString());
691             fileChooser.addChoosableFileFilter(fileFilter);
692             fileChooser.setFileFilter(fileFilter);
693           }
694 
695           textField.setEditable(true);
696           textButtonBox.removeAll();
697           textButtonBox.add(textField);
698           textButtonBox.add(Box.createHorizontalStrut(5));
699           textButtonBox.add(fileButton);
700           return textButtonBox;
701         }else if(type.equals("java.lang.Boolean")){
702           label.setText(value == null ? "false" : value.toString());
703           return label;
704         }else if(typeClass != null &&
705                       List.class.isAssignableFrom(typeClass)){
706           //List value
707           listUsed = true;
708           Parameter param = pDisj.getParameter();
709           Set sufixes = param.getSuffixes();
710 
711           listValue = (List)value;
712           listEditor = new ListEditorDialog(
713                 SwingUtilities.getAncestorOfClass(
714                 Window.class, ResourceParametersEditor.this),
715                 (List)value, param.getItemClassName());
716 
717           textField.setEditable(false);
718           textField.setText(textForList((List)value));
719           textButtonBox.removeAll();
720           textButtonBox.add(textField);
721           textButtonBox.add(Box.createHorizontalStrut(5));
722           textButtonBox.add(listButton);
723           return textButtonBox;
724         }else{
725           textField.setEditable(true);
726           return textField;
727         }
728       }
729     }//getTableCellEditorComponent
730 
731     /**
732      * Gets a string representation for a list value
733      */
734     protected String textForList(List list){
735       if(list == null || list.isEmpty()) return "[]";
736       StringBuffer res = new StringBuffer("[");
737       Iterator elemIter = list.iterator();
738       while(elemIter.hasNext()){
739         Object elem = elemIter.next();
740         res.append( ((elem instanceof NameBearer) ?
741                     ((NameBearer)elem).getName() :
742                     elem.toString()) + ", ");
743       }
744       res.delete(res.length() - 2, res.length() - 1);
745       res.append("]");
746       return res.toString();
747     }
748 
749     public Object getCellEditorValue(){
750       if(comboUsed){
751         Object value = combo.getSelectedItem();
752          return value == "<none>" ? null : value;
753       }
754       else if(listUsed){
755         return listValue;
756       }else{
757         if(type.equals("java.lang.Boolean")){
758           //get the value from the label
759           return new Boolean(label.getText());
760         }else{
761           //get the value from the text field
762           return textField.getText();
763 //          return ((textField.getText().equals("")) ? null :
764 //                                                     textField.getText());
765         }
766       }
767     }//public Object getCellEditorValue()
768 
769     /**
770      * The type of the value currently being edited
771      */
772     String type;
773 
774     /**
775      * Combobox use as editor for Gate objects (chooses between instances)
776      */
777     JComboBox combo;
778 
779     /**
780      * Editor used for boolean values
781      */
782     JLabel label;
783 
784     /**
785      * Generic editor for all types that are not treated special
786      */
787     JTextField textField;
788 
789     /**
790      * A pointer to the filechooser from MainFrame;
791      */
792     JFileChooser fileChooser;
793 
794     ListEditorDialog listEditor = null;
795     List listValue;
796 
797     boolean comboUsed;
798     boolean listUsed;
799     JButton fileButton;
800     JButton listButton;
801     JPanel textButtonBox;
802   }///class ParameterValueEditor
803 }//class NewResourceDialog