1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
/* * @(#)CellEditor.java 1.26 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package javax.swing; import java.util.EventObject; import javax.swing.event.*; /** * This interface defines the methods any general editor should be able * to implement. <p> * * Having this interface enables complex components (the client of the * editor) such as <code>JTree</code> and * <code>JTable</code> to allow any generic editor to * edit values in a table cell, or tree cell, etc. Without this generic * editor interface, <code>JTable</code> would have to know about specific editors, * such as <code>JTextField</code>, <code>JCheckBox</code>, <code>JComboBox</code>, * etc. In addition, without this interface, clients of editors such as * <code>JTable</code> would not be able * to work with any editors developed in the future by the user * or a 3rd party ISV. <p> * * To use this interface, a developer creating a new editor can have the * new component implement the interface. Or the developer can * choose a wrapper based approach and provide a companion object which * implements the <code>CellEditor</code> interface (See * <code>JCellEditor</code> for example). The wrapper approach * is particularly useful if the user want to use a 3rd party ISV * editor with <code>JTable</code>, but the ISV didn't implement the * <code>CellEditor</code> interface. The user can simply create an object * that contains an instance of the 3rd party editor object and "translate" * the <code>CellEditor</code> API into the 3rd party editor's API. * * @see javax.swing.event.CellEditorListener * * @version 1.26 11/17/05 * @author Alan Chung */ public interface CellEditor { /** * Returns the value contained in the editor. * @return the value contained in the editor */ public Object getCellEditorValue(); /** * Asks the editor if it can start editing using <code>anEvent</code>. * <code>anEvent</code> is in the invoking component coordinate system. * The editor can not assume the Component returned by * <code>getCellEditorComponent</code> is installed. This method * is intended for the use of client to avoid the cost of setting up * and installing the editor component if editing is not possible. * If editing can be started this method returns true. * * @param anEvent the event the editor should use to consider * whether to begin editing or not * @return true if editing can be started * @see #shouldSelectCell */ public boolean isCellEditable(EventObject anEvent); /** * Returns true if the editing cell should be selected, false otherwise. * Typically, the return value is true, because is most cases the editing * cell should be selected. However, it is useful to return false to * keep the selection from changing for some types of edits. * eg. A table that contains a column of check boxes, the user might * want to be able to change those checkboxes without altering the * selection. (See Netscape Communicator for just such an example) * Of course, it is up to the client of the editor to use the return * value, but it doesn't need to if it doesn't want to. * * @param anEvent the event the editor should use to start * editing * @return true if the editor would like the editing cell to be selected; * otherwise returns false * @see #isCellEditable */ public boolean shouldSelectCell(EventObject anEvent); /** * Tells the editor to stop editing and accept any partially edited * value as the value of the editor. The editor returns false if * editing was not stopped; this is useful for editors that validate * and can not accept invalid entries. * * @return true if editing was stopped; false otherwise */ public boolean stopCellEditing(); /** * Tells the editor to cancel editing and not accept any partially * edited value. */ public void cancelCellEditing(); /** * Adds a listener to the list that's notified when the editor * stops, or cancels editing. * * @param l the CellEditorListener */ public void addCellEditorListener(CellEditorListener l); /** * Removes a listener from the list that's notified * * @param l the CellEditorListener */ public void removeCellEditorListener(CellEditorListener l); }