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 23/01/2001
10   *
11   *  $Id: FeaturesEditor.java,v 1.13 2002/05/16 17:05:41 valyt Exp $
12   *
13   */
14  
15  package gate.gui;
16  
17  import gate.*;
18  import gate.util.*;
19  import gate.swing.*;
20  import gate.creole.*;
21  
22  import javax.swing.*;
23  import java.awt.BorderLayout;
24  import java.awt.Component;
25  import java.awt.Color;
26  import java.awt.Dimension;
27  import javax.swing.table.*;
28  import javax.swing.event.*;
29  import java.awt.event.*;
30  
31  import java.util.*;
32  
33  import gate.creole.AbstractVisualResource;
34  
35  public class FeaturesEditor extends AbstractVisualResource{
36  
37    public FeaturesEditor() {
38      initLocalData();
39      initGuiComponents();
40      initListeners();
41    }// FeaturesEditor()
42  
43    protected void initLocalData(){
44      features = Factory.newFeatureMap();
45    }
46  
47    protected void initGuiComponents(){
48      this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
49      tableModel = new FeaturesTableModel();
50      table = new XJTable(tableModel);
51  //    table.setIntercellSpacing(new Dimension(5,5));
52      table.setDefaultRenderer(String.class, new ObjectRenderer());
53      table.setDefaultRenderer(Object.class, new ObjectRenderer());
54  
55      DefaultCellEditor editor = new DefaultCellEditor(new JTextField());
56      editor.setClickCountToStart(0);
57      table.setDefaultEditor(String.class, editor);
58      table.setDefaultEditor(Object.class, editor);
59  
60      JScrollPane scroll = new JScrollPane(table);
61      this.add(scroll, BorderLayout.CENTER);
62      this.add(Box.createVerticalStrut(5));
63  
64      Box box = Box.createHorizontalBox();
65      newFeatureField = new JTextField(10);
66      newFeatureField.setMaximumSize(new Dimension(Integer.MAX_VALUE,
67                                                   newFeatureField.
68                                                   getPreferredSize().height));
69  
70      Box vBox = Box.createVerticalBox();
71      vBox.add(new JLabel("New feature name"));
72      vBox.add(newFeatureField);
73      box.add(vBox);
74      box.add(Box.createHorizontalStrut(5));
75  
76      newValueField = new JTextField(10);
77      newValueField.setMaximumSize(new Dimension(Integer.MAX_VALUE,
78                                                   newValueField.
79                                                   getPreferredSize().height));
80  
81      vBox = Box.createVerticalBox();
82      vBox.add(new JLabel("New feature value"));
83      vBox.add(newValueField);
84      box.add(vBox);
85      box.add(Box.createHorizontalStrut(5));
86  
87      addNewBtn = new JButton("Add feature");
88      box.add(addNewBtn);
89  
90      this.add(box);
91      this.add(Box.createVerticalGlue());
92  
93    }// protected void initGuiComponents()
94  
95    protected void initListeners(){
96      addNewBtn.addActionListener(new ActionListener() {
97        public void actionPerformed(ActionEvent e) {
98          String name = newFeatureField.getText();
99          String value = newValueField.getText();
100         if(name != null){
101           features.put(name, value);
102           tableModel.fireTableDataChanged();
103           newFeatureField.setText("");
104           newValueField.setText("");
105         }
106       }
107     });
108   }
109 
110   public void cleanup(){
111     super.cleanup();
112     features = null;
113     resource = null;
114   }
115 
116   public void setFeatureBearer(FeatureBearer newResource) {
117     if(newResource == null){
118       resource = null;
119       features = null;
120     }else{
121       resource = newResource;
122       features = resource.getFeatures();
123     }
124     tableModel.fireTableDataChanged();
125   }// public void setFeatureBearer(FeatureBearer newResource)
126 
127   public void setTarget(Object target) {
128     if(target == null || target instanceof FeatureBearer){
129       setFeatureBearer((FeatureBearer)target);
130     }else{
131       throw new IllegalArgumentException(
132         "FeatureEditors can only be used with FeatureBearer!\n" +
133         target.getClass().toString() + " is not a FeatureBearer!");
134     }
135   }//public void setResource(Resource resource)
136 
137   public void setHandle(Handle handle){
138     //NOP
139   }
140 
141 
142   public FeatureBearer getFeatureBearer() {
143     return resource;
144   }
145 
146   XJTable table;
147   FeaturesTableModel tableModel;
148   private FeatureBearer resource;
149   FeatureMap features;
150   JTextField newFeatureField;
151   JTextField newValueField;
152 
153   JButton addNewBtn;
154 
155   class FeaturesTableModel extends AbstractTableModel{
156     public int getColumnCount(){
157       return 2;
158     }
159 
160     public int getRowCount(){
161       return features == null ? 0 : features.size();
162     }
163 
164     public String getColumnName(int columnIndex){
165       switch(columnIndex){
166         case 0: return "Feature";
167         case 1: return "Value";
168         default: return "?";
169       }
170     }//public String getColumnName(int columnIndex)
171 
172     public Class getColumnClass(int columnIndex){
173       switch(columnIndex){
174         case 0: return String.class;
175         case 1: return Object.class;
176         default: return Object.class;
177       }
178     }
179 
180     public boolean isCellEditable(int rowIndex,
181                               int columnIndex){
182       if(features == null) return false;
183       return rowIndex == features.size()
184              ||
185              ((!((String)table.getModel().getValueAt(rowIndex, 0)).
186               startsWith("gate."))
187              );
188     }// public boolean isCellEditable
189 
190     public Object getValueAt(int rowIndex,
191                          int columnIndex){
192       if(features == null) return null;
193       List keys = new ArrayList(features.keySet());
194       Collections.sort(keys);
195       Object key = keys.get(rowIndex);
196       switch(columnIndex){
197         case 0:{
198           return key;
199         }
200         case 1:{
201           return features.get(key) == null ? "" : features.get(key).toString();
202         }
203         default:{
204           return null;
205         }
206       }
207     }// public Object getValueAt
208 
209     public void setValueAt(Object aValue,
210                        int rowIndex,
211                        int columnIndex){
212 
213       if(columnIndex == 0) {
214         //the name of the feature changed
215         //if the name is null or empty the feature will be deleted
216         String oldName = (String)getValueAt(rowIndex, 0);
217         Object oldValue = features.remove(oldName);
218         if(aValue != null && !aValue.equals("")){
219           features.put(aValue, oldValue);
220         }
221       } else {
222         //the value of a feature changed
223         features.put(getValueAt(rowIndex, 0), aValue);
224       }
225       fireTableDataChanged();
226     }// public void setValueAt
227 
228   }///class FeaturesTableModel extends DefaultTableModel
229 /*
230   class FeaturesTableRenderer extends DefaultTableCellRenderer{
231     public Component getTableCellRendererComponent(JTable table,
232                                                    Object value,
233                                                    boolean isSelected,
234                                                    boolean hasFocus,
235                                                    int row,
236                                                    int column){
237 
238       super.getTableCellRendererComponent(table, value, false, hasFocus,
239                                           row, column);
240       setEnabled(table.isCellEditable(row, column));
241       return this;
242     }
243 
244   }// class FeaturesTableRenderer
245 */
246 }// class FeaturesEditor