001    /* DefaultCellEditor.java --
002       Copyright (C) 2002, 2004, 2006, Free Software Foundation, Inc.
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    
039    package javax.swing;
040    
041    import java.awt.Component;
042    import java.awt.event.ActionEvent;
043    import java.awt.event.ActionListener;
044    import java.awt.event.ItemEvent;
045    import java.awt.event.ItemListener;
046    import java.awt.event.MouseEvent;
047    import java.io.Serializable;
048    import java.util.EventObject;
049    
050    import javax.swing.JTable;
051    import javax.swing.JTextField;
052    import javax.swing.event.CellEditorListener;
053    import javax.swing.table.TableCellEditor;
054    import javax.swing.tree.TreeCellEditor;
055    
056    /**
057     * The default implementation of {@link TableCellEditor} and
058     * {@link TreeCellEditor}. It provides editor components for
059     * some standard object types.
060     * 
061     * @author Andrew Selkirk
062     * @author Audrius Meskauskas
063     */
064    public class DefaultCellEditor
065      extends AbstractCellEditor
066      implements TableCellEditor, TreeCellEditor
067    {
068      private static final long serialVersionUID = 3564035141373880027L;
069    
070      /**
071       * This changeable module access the editor component in the component
072       * specific way. For instance, to set the value for JTextField, we need to 
073       * call setText(String), and for JCheckBox we need to call 
074       * setSelected(boolean). Each default editor has the component specific
075       * derivative of this class. These derivatives are private inner classes of
076       * the DefaultCellEditor.
077       * 
078       * The editor delegate is also set for the editor component as the action
079       * listener. It listens for the events that indicate that editing has stopped.
080       */
081      protected class EditorDelegate
082        implements ActionListener, ItemListener, Serializable
083      {
084        /**
085         * Use the serial version UID for interoperability.
086         */
087        private static final long serialVersionUID = -1420007406015481933L;
088    
089        /**
090         * The object value (updated when getting and setting the value).
091         */
092        protected Object value;
093    
094        /**
095         * Constructor EditorDelegate
096         */
097        protected EditorDelegate()
098        {
099          // Nothing to do here.
100        }
101        
102        /**
103         * Set the value for the editor component. This method is normally
104         * overridden to set the value in the way, specific for the text
105         * component, check box or combo box.
106         *
107         * @param aValue the value to set (String, Boolean or Number).
108         */
109        public void setValue(Object aValue)
110        {
111          value = aValue;
112        }
113    
114        /**
115         * Get the value for the editor component. This method is normally
116         * overridden to obtain the value in the way, specific for the text
117         * component, check box or combo box.
118         *
119         * @return value the value of the component (String, Boolean or Number).
120         */
121        public Object getCellEditorValue()
122        {
123          return value;
124        } 
125    
126        /**
127         * The default method returns true for the {@link MouseEvent} and false 
128         * for any other events.
129         * 
130         * @param event the event to check
131         *
132         * @return true if the passed event is the mouse event and false otherwise.
133         */
134        public boolean isCellEditable(EventObject event)
135        {
136          if (event == null || !(event instanceof MouseEvent) ||
137              (((MouseEvent) event).getClickCount() >= getClickCountToStart()))
138            return true;
139          return false;
140        } // isCellEditable()
141    
142        /**
143         * Returns true to indicate that the editing cell can be selected.
144         * 
145         * The default method returns true without action but may be overridden
146         * in derived classes for more specific behavior.
147         * 
148         * @param event unused in default method
149         *
150         * @return true always
151         */
152        public boolean shouldSelectCell(EventObject event)
153        {
154          // return true to indicate that the editing cell may be selected
155          return true;
156        }
157    
158        /**
159         * Finish the cell editing session. This method notifies the registered
160         * cell editor listeners (including the table) that the editing has been
161         * stopped. 
162         * 
163         * @return boolean
164         */
165        public boolean stopCellEditing()
166        {
167          fireEditingStopped();
168          return true;
169        } // stopCellEditing()
170    
171        /**
172         * Cancel the cell editing session. This method notifies the registered
173         * cell editor listeners (including the table) that the editing has been
174         * canceled.
175         */
176        public void cancelCellEditing()
177        {
178          fireEditingCanceled();
179        } // cancelCellEditing()
180    
181        /**
182         * Start editing session and returns true to indicate the editing has begun.
183         * The default method returns true without action but may be overridden
184         * in derived classes for more specific behavior.
185         * 
186         * @param event  the event.
187         * 
188         * @return true, always
189         */
190        public boolean startCellEditing(EventObject event)
191        {
192          // return true to indicate that editing has begun
193          return true;
194        } // startCellEditing()
195    
196        /**
197         * This event is fired by the editor component (for instance, by pressing
198         * ENTER in the {@link JTextField}. The default method delegates call to
199         * the {@link #stopCellEditing}, finishing the editing session. 
200         * 
201         * @param event unused in default method
202         */
203        public void actionPerformed(ActionEvent event)
204        {
205          stopCellEditing();
206        } // actionPerformed()
207    
208        /**
209         * This event is fired by the editor component.The default method delegates
210         * call to the {@link #stopCellEditing}, finishing the editing session. 
211         * 
212         * @param event unused in default method
213         */
214        public void itemStateChanged(ItemEvent event)
215        {
216          stopCellEditing();
217        } // itemStateChanged()
218    
219        /**
220         * Notify the registered listeners (including the table) that the editing
221         * has been completed.
222         */
223        void fireEditingStopped()
224        {
225          CellEditorListener[] listeners = getCellEditorListeners();
226          for (int index = 0; index < listeners.length; index++)
227            listeners[index].editingStopped(changeEvent);
228          
229        }
230        
231        /**
232         * Notify the registered listeners (including the table) that the editing
233         * has been canceled.
234         */
235        void fireEditingCanceled()
236        {
237          CellEditorListener[] listeners = getCellEditorListeners();
238          for (int index = 0; index < listeners.length; index++)
239            listeners[index].editingCanceled(changeEvent);
240        }
241      } // EditorDelegate
242      
243      /**
244       * Provides getter and setter methods to work with the text component.
245       * 
246       * @author Audrius Meskauskas (audriusa@Bioinformatics.org)
247       */
248      private class JTextFieldDelegate extends EditorDelegate
249      {
250        /**
251         * Use the serial version UID for interoperability.
252         */
253        private static final long serialVersionUID = 1;
254        
255        /**
256         * Set the value for the editor component.
257         *
258         * @param aValue the value to set (toString() will be called).
259         */
260        public void setValue(Object aValue)
261        {
262          value = aValue;
263          JTextField f = (JTextField) editorComponent;
264          if (value == null)
265            f.setText("");
266          else
267            f.setText(value.toString());
268        }
269    
270        /**
271         * Get the value for the editor component. 
272         *
273         * @return value the value of the component (String)
274         */
275        public Object getCellEditorValue()
276        {
277          JTextField f = (JTextField) editorComponent;
278          return value = f.getText();      
279        }     
280      }
281    
282      /**
283       * Provides getter and setter methods to work with the combo box.
284       * 
285       * @author Audrius Meskauskas (audriusa@Bioinformatics.org) 
286       */
287      private class JComboBoxDelegate extends EditorDelegate
288      {
289        /**
290         * Use the serial version UID for interoperability.
291         */
292        private static final long serialVersionUID = 1;
293        
294        /**
295         * Set the value for the editor component.
296         *
297         * @param aValue the value to set.
298         */
299        public void setValue(Object aValue)
300        {
301          value = aValue;      
302          JComboBox c = (JComboBox) editorComponent;
303          if (value != null)
304            c.setSelectedItem(value);
305        }
306    
307        /**
308         * Get the value for the editor component. 
309         *
310         * @return value the value of the component (as String)
311         */
312        public Object getCellEditorValue()
313        {
314          JComboBox c = (JComboBox) editorComponent;
315          return value = c.getSelectedItem();
316        } 
317        
318        /**
319         * Returns true to indicate that the editing cell can be selected. If the
320         * check box is not editable, expands it. If it is editable, brings
321         * focus to the editor field.
322         * 
323         * @param event unused in default method
324         *
325         * @return true always
326         */
327        public boolean shouldSelectCell(EventObject event)
328        {
329          JComboBox c = (JComboBox) editorComponent;
330          if (!c.isEditable)
331            c.showPopup();
332          return true;
333        }    
334      }
335    
336      /**
337       * Provides getter and setter methods to work with the check box.
338       * 
339       * @author Audrius Meskauskas (audriusa@Bioinformatics.org) 
340       */
341      private class JCheckBoxDelegate extends EditorDelegate
342      {
343        /**
344         * Use the serial version UID for interoperability.
345         */
346        private static final long serialVersionUID = 1;
347        
348        /**
349         * Set the value for the editor component.
350         *
351         * @param value the value to set (must be Boolean).
352         */
353        public void setValue(Object value)
354        {
355          JCheckBox c = (JCheckBox) editorComponent;
356          
357          if (value == null)
358            c.setSelected(false);
359          else
360            c.setSelected( ((Boolean) value).booleanValue());
361        }
362    
363        /**
364         * Get the value for the editor component. 
365         *
366         * @return value the value of the component (must be CharSequence)
367         */
368        public Object getCellEditorValue()
369        {
370          JCheckBox c = (JCheckBox) editorComponent;
371          value = c.isSelected() ? Boolean.TRUE : Boolean.FALSE;
372          return value;
373        }     
374      }
375      
376      /**
377       * The Swing JComponent, performing the editing session.
378       */
379      protected JComponent editorComponent;
380    
381      /**
382       * The editor delegate, responsible for listening the {@link #editorComponent}
383       * events and getting/setting its value.
384       */
385      protected EditorDelegate delegate;
386    
387      /**
388       * The number of the mouse clicks, required to start the editing session.
389       */
390      protected int clickCountToStart;
391    
392      /**
393       * Create the DefaultCellEditor that uses the text field as its editor
394       * component (appropriate for the text content)
395       * 
396       * @param textfield the text field as will be used as the editor component
397       */
398      public DefaultCellEditor(JTextField textfield)
399      {
400        editorComponent = textfield;
401        clickCountToStart = 2;
402        delegate = new JTextFieldDelegate();
403        textfield.addActionListener(delegate);
404      } // DefaultCellEditor()
405    
406      /**
407       * Constructor DefaultCellEditor that uses the checkbox (appropriate
408       * for boolean values)
409       * 
410       * @param checkbox the checkbox that will be used with this editor.
411       */
412      public DefaultCellEditor(JCheckBox checkbox)
413      {
414        editorComponent = checkbox;
415        clickCountToStart = 1;
416        delegate = new JCheckBoxDelegate();
417        checkbox.addActionListener(delegate);
418      } // DefaultCellEditor()
419    
420      /**
421       * Constructor DefaultCellEditor that uses the combo box.
422       * 
423       * @param combobox the combo box that will be used with this editor.
424       */
425      public DefaultCellEditor(JComboBox combobox)
426      {
427        editorComponent = combobox;
428        clickCountToStart = 1;
429        delegate = new JComboBoxDelegate();
430        combobox.addActionListener(delegate);
431      } // DefaultCellEditor()
432    
433      /**
434       * Get the component that performs the editing sessions. It is the same 
435       * component that was passed in constructor.
436       * 
437       * @return the component, performing the editing sessions. 
438       */
439      public Component getComponent()
440      {
441        return editorComponent; 
442      } // getComponent()
443    
444      /**
445       * Get the number of mouse clicks, required to start the editing session.
446       * 
447       * @return int the number of mouse clicks, required to start the session
448       */
449      public int getClickCountToStart()
450      {
451        return clickCountToStart;
452      } // getClickCountToStart()
453    
454      /**
455       * Set the number of mouse clicks, required to start the editing session.
456       * 
457       * @param count the number of clicks, required to start the session
458       */
459      public void setClickCountToStart(int count)
460      {
461        clickCountToStart = count;
462      } // setClickCountToStart()
463    
464      /**
465       * Get the value, currently being displayed by the editor component. The 
466       * call is forwarded to the {@link #delegate}.
467       * 
468       * @return Object the value (class depends on the editor component)
469       */
470      public Object getCellEditorValue()
471      {
472        return delegate.getCellEditorValue();
473      } // getCellEditorValue()
474    
475      /**
476       * Forwards call to the {@link #delegate}.
477       * 
478       * @param event forwarded to the delegate.
479       *
480       * @return boolean returned by delegate
481       */
482      public boolean isCellEditable(EventObject event)
483      {
484        return delegate.isCellEditable(event);
485      } // isCellEditable()
486    
487      /**
488       * Forwards call to the {@link #delegate}.
489       * 
490       * @param event forwarded to the delegate.
491       *
492       * @return boolean returned by delegate
493       */
494      public boolean shouldSelectCell(EventObject event)
495      {
496        return delegate.shouldSelectCell(event);
497      } // shouldSelectCell()
498    
499      /**
500       * Forwards call to the {@link #delegate}.
501       * 
502       * @return boolean returned by delegate
503       */
504      public boolean stopCellEditing()
505      {
506        return delegate.stopCellEditing();
507      } // stopCellEditing()
508    
509      /**
510       * Forwards call to the {@link #delegate}.
511       */
512      public void cancelCellEditing()
513      {
514        delegate.cancelCellEditing();
515      } // cancelCellEditing()
516    
517      /**
518       * Sets an initial value for the editor. 
519       * This will cause the editor to stopEditing and lose any partially 
520       * edited value if the editor is editing when this method is called.
521       * Returns the component that should be added to the client's Component 
522       * hierarchy. Once installed in the client's hierarchy this component will 
523       * then be able to draw and receive user input. 
524       * 
525       * @param tree - the JTree that is asking the editor to edit; this 
526       * parameter can be null
527       * @param value - the value of the cell to be edited
528       * @param isSelected - true is the cell is to be renderer with selection
529       * highlighting
530       * @param expanded - true if the node is expanded
531       * @param leaf - true if the node is a leaf node
532       * @param row - the row index of the node being edited
533       *
534       * @return Component the component for editing
535       */
536      public Component getTreeCellEditorComponent(JTree tree, Object value,
537                                                  boolean isSelected,
538                                                  boolean expanded, boolean leaf,
539                                                  int row)
540      {
541        delegate.setValue(value);
542        return editorComponent;
543      } // getTreeCellEditorComponent()
544    
545      /**
546       * Get the cell editor component that will perform the editing session. If
547       * returned once, the same component is also returned on the repetetive calls
548       * again (reused).
549       * 
550       * @param table the table where the editing is performed
551       * @param value the current value of the table. It is set as the initial 
552       *        component value.
553       * @param isSelected if true, the cell is currently selected
554       * @param row the row of the cell being edited
555       * @param column the column of the cell being edited
556       * 
557       * @return Component the component that will perform the editing session
558       */
559      public Component getTableCellEditorComponent(JTable table, Object value,
560                                                   boolean isSelected, int row,
561                                                   int column)
562      {
563        // NOTE: as specified by Sun, we don't call new() everytime, we return 
564        // editorComponent on each call to getTableCellEditorComponent or
565        // getTreeCellEditorComponent.
566        delegate.setValue(value);
567        return editorComponent;
568      } // getTableCellEditorComponent()
569    
570    }