Coverage Report - wjhk.jupload2.gui.filepanel.treeview.MyTreeTableModel
 
Classes in this File Line Coverage Branch Coverage Complexity
MyTreeTableModel
N/A
N/A
1
 
 1  
 package wjhk.jupload2.gui.filepanel.treeview;
 2  
 
 3  
 import javax.swing.event.TreeModelListener;
 4  
 import javax.swing.tree.TreeModel;
 5  
 import javax.swing.tree.TreePath;
 6  
 
 7  
 import wjhk.jupload2.exception.JUploadExceptionStopAddingFiles;
 8  
 import wjhk.jupload2.gui.filepanel.FilePanelTableImp;
 9  
 
 10  
 /**
 11  
  * This code is taken from the tutorial written by Jörn Hameister, <A
 12  
  * HREF="http://www.hameister.org/JavaSwingTreeTable.html">available here</A>.<BR/>
 13  
  * <BR/>
 14  
  * From Jörn sample, the main modifications are:
 15  
  * <UL>
 16  
  * <LI>Add of the getRoot and setRoot methods</LI>
 17  
  * <LI>Capability to remove an item</LI>
 18  
  * <LI>Transformation in a generic type</LI>
 19  
  * <LI>Add of the reload method, to help refreshing the display.</LI>
 20  
  * <LI>Add of the {@link #getColumnSizePercentage(int)} method, to allow the resizing of the column, along with the
 21  
  * table resizing (see {@link FilePanelTableImp#componentResized(java.awt.event.ComponentEvent)}
 22  
  * <UL>
 23  
  * <BR/>
 24  
  * First, the interface is TreeModel through the interface MyTreeTableModel expanded. This extension creates the
 25  
  * possibility that a node (Node) multiple columns (Columns) can have. <BR/>
 26  
  * <BR/>
 27  
  * This class can not be generic, as TreeModel is not generic
 28  
  * 
 29  
  * @author Jörn Hameister
 30  
  */
 31  
 public interface MyTreeTableModel<T extends MyTreeNode> extends TreeModel {
 32  
 
 33  
     /**
 34  
      * Get the visible root of the JTree view.
 35  
      * 
 36  
      * @param root
 37  
      */
 38  
     public T getRoot();
 39  
 
 40  
     /**
 41  
      * Set the visible root of the JTree view.
 42  
      * 
 43  
      * @param root
 44  
      */
 45  
     public void setRoot(T root);
 46  
 
 47  
     /**
 48  
      * Removes an item from the TreeView. This method just removed the given node. Of course, it detaches all
 49  
      * descendants of this node, if any. <BR/>
 50  
      * There is no impact on the parent, out of the 'detaching' of this node.
 51  
      * 
 52  
      * @param item
 53  
      * @see #removeAndClean(MyTreeNode)
 54  
      */
 55  
     public void remove(T item);
 56  
 
 57  
     /**
 58  
      * Removes an item from the TreeView, detach its descendant, and remove the parent node if this node was the only
 59  
      * child of the parent. If this item has children, then all children are also removed.
 60  
      * 
 61  
      * @param item
 62  
      */
 63  
     public void removeAndClean(T item);
 64  
 
 65  
     /**
 66  
      * This method removes all empty folders. Empty folder can typically be created, when adding files. For instance, if
 67  
      * there is subfolder1/subolfer2, and subfolder2 is empty. Then it is not created. But avoiding to create also
 68  
      * subfolder1 needs to parse the whole hierarchy for each folder. Too long. It's quicker to clean afterwards.
 69  
      * 
 70  
      * @return true if at least one node is removed. The {@link #reload()} method is called.
 71  
      */
 72  
     public boolean cleanHierarchy();
 73  
 
 74  
     /**
 75  
      * <p>
 76  
      * Invoke this method if you've modified the TreeNodes upon which this model depends. The model will notify all of
 77  
      * its listeners that the model has changed. It will fire the events, necessary to update the layout caches and
 78  
      * repaint the tree. The tree will <i>not</i> be properly refreshed if you call the JTree.repaint instead.
 79  
      * </p>
 80  
      * <p>
 81  
      * This method will refresh the information about whole tree from the root. If only part of the tree should be
 82  
      * refreshed, it is more effective to call {@link #reload(TreeNode)}.
 83  
      * </p>
 84  
      * <p>
 85  
      * Note: code taken from the JDK DefaultTreeModel.
 86  
      * </p>
 87  
      */
 88  
     public void reload();
 89  
 
 90  
     /**
 91  
      * Invoke this method if you've modified the TreeNodes upon which this model depends. The model will notify all of
 92  
      * its listeners that the model has changed. It will fire the events, necessary to update the layout caches and
 93  
      * repaint the tree. The tree will <i>not</i> be properly refreshed if you call the JTree.repaint instead.
 94  
      * 
 95  
      * @param node - the tree node, from which the tree nodes have changed (inclusive). If you do not know this node,
 96  
      *            call {@link #reload()} instead.
 97  
      */
 98  
     public void reload(T node);
 99  
 
 100  
     /**
 101  
      * Returns the number of available columns.
 102  
      * 
 103  
      * @return Number of Columns
 104  
      */
 105  
     public int getColumnCount();
 106  
 
 107  
     /**
 108  
      * Returns the column name.
 109  
      * 
 110  
      * @param column Column number
 111  
      * @return Column name
 112  
      */
 113  
     public String getColumnName(int column);
 114  
 
 115  
     /**
 116  
      * Retrieves the default colum percentage size of a column, that is: its percentage of the available width.
 117  
      * 
 118  
      * @param col The index of the column to query.
 119  
      * @return the default size of the requested column.
 120  
      */
 121  
     public int getColumnSizePercentage(int col);
 122  
 
 123  
     /**
 124  
      * Returns the type (class) of a column.
 125  
      * 
 126  
      * @param column Column number
 127  
      * @return Class
 128  
      */
 129  
     public Class<?> getColumnClass(int column);
 130  
 
 131  
 /**
 132  
      * Attach a new Object into the current hierarchy. This method is not mandatory. If not implemented, it should raise
 133  
      * an {@link IllegalStateException].
 134  
      * 
 135  
      * @param o
 136  
      * @return The total number of object added. It may be more than one, for instance, when adding a folder (including
 137  
      *         its descendants) in a file hierarchy
 138  
      * @throws IllegalStateException If this method is called on an instance, which doesn't possess this capability
 139  
      * @throws IllegalArgumentException If the given Object is not of the right type, to allow an attachment into the
 140  
      *             current hierarchy
 141  
      * @throws JUploadExceptionStopAddingFiles When an error occurs, indicating that not all files were added
 142  
      */
 143  
     public int attachObject(Object o) throws IllegalStateException, IllegalArgumentException,
 144  
             JUploadExceptionStopAddingFiles;
 145  
 
 146  
     // TODO Replace Object by a new parameterized type
 147  
 
 148  
     /**
 149  
      * Returns the value of a node in a column.
 150  
      * 
 151  
      * @param node Node
 152  
      * @param column Column number
 153  
      * @return Value of the node in the column
 154  
      */
 155  
     public Object getValueAt(T node, int column);
 156  
 
 157  
     /**
 158  
      * Check if a cell of a node in one column is editable.
 159  
      * 
 160  
      * @param node Node
 161  
      * @param column Column number
 162  
      * @return true/false
 163  
      */
 164  
     public boolean isCellEditable(T node, int column);
 165  
 
 166  
     /**
 167  
      * Sets a value for a node in one column.
 168  
      * 
 169  
      * @param aValue New value
 170  
      * @param node Node
 171  
      * @param column Column number
 172  
      */
 173  
     public void setValueAt(Object aValue, T node, int column);
 174  
 
 175  
     /**
 176  
      * @param tree the tree to set
 177  
      */
 178  
     // FIXME rename this method to setTableCellRenderer
 179  
     public void setTree(MyTreeTableCellRenderer tree);
 180  
 
 181  
     /**
 182  
      * This method must be called when one or more nodes are changed.
 183  
      * 
 184  
      * @param source - the Object responsible for generating the event (typically the creator of the event object passes
 185  
      *            this for its value)
 186  
      * @param path - a TreePath object that identifies the path to the parent of the modified item(s)
 187  
      * @param childIndices - an array of int that specifies the index values of the modified items
 188  
      * @param children - an array of Object containing the inserted, removed, or changed objects
 189  
      * @see TreeModelListener
 190  
      */
 191  
     public void fireTreeNodesChanged(Object source, TreePath path, int[] childIndices, T[] children);
 192  
 
 193  
     /**
 194  
      * This method must be called when one or more nodes are changed.
 195  
      * 
 196  
      * @param source - the Object responsible for generating the event (typically the creator of the event object passes
 197  
      *            this for its value)
 198  
      * @param path - a TreePath object that identifies the path to the parent of the modified item(s)
 199  
      * @param childIndices - an array of int that specifies the index values of the modified items
 200  
      * @param children - an array of Object containing the inserted, removed, or changed objects
 201  
      * @see TreeModelListener
 202  
      */
 203  
     public void fireTreeNodesInserted(Object source, TreePath path, int[] childIndices, T[] children);
 204  
 
 205  
     /**
 206  
      * This method must be called when one or more nodes are changed.
 207  
      * 
 208  
      * @param source - the Object responsible for generating the event (typically the creator of the event object passes
 209  
      *            this for its value)
 210  
      * @param path - a TreePath object that identifies the path to the parent of the modified item(s)
 211  
      * @param childIndices - an array of int that specifies the index values of the modified items
 212  
      * @param children - an array of Object containing the inserted, removed, or changed objects
 213  
      * @see TreeModelListener
 214  
      */
 215  
     public void fireTreeNodesRemoved(Object source, TreePath path, int[] childIndices, T[] children);
 216  
 
 217  
     /**
 218  
      * This method must be called when one or more nodes are changed.
 219  
      * 
 220  
      * @param source - the Object responsible for generating the event (typically the creator of the event object passes
 221  
      *            this for its value)
 222  
      * @param path - a TreePath object that identifies the path to the parent of the modified item(s)
 223  
      * @param childIndices - an array of int that specifies the index values of the modified items
 224  
      * @param children - an array of Object containing the inserted, removed, or changed objects
 225  
      * @see TreeModelListener
 226  
      */
 227  
     public void fireTreeStructureChanged(Object source, TreePath path, int[] childIndices, T[] children);
 228  
 
 229  
     /**
 230  
      * This method build a {@link TreePath} for the given item. This item should be in the current tree.
 231  
      * 
 232  
      * @param item
 233  
      * @return The build TreePath
 234  
      * @throws IllegalArgumentException If item is not in the tree represented by this model.
 235  
      */
 236  
     public TreePath getTreePath(T item);
 237  
 
 238  
     /**
 239  
      * Get the {@link TreePath} for the given object. This method is optional. It is typically only applicable if this
 240  
      * hierarchy maps on another hierarchy (for instance a hierarchy of files, based on a local file system)
 241  
      * 
 242  
      * @param o
 243  
      * @return The TreePath, with the last component being the node linked to the o object. It returns null, if this
 244  
      *         object is not in the hierarchy.
 245  
      * @throws IllegalStateException If this method is called on an instance, which doesn't possess this capability
 246  
      * @throws IllegalArgumentException If the given Object is not of the right type, to allow an attachment into the
 247  
      *             current hierarchy
 248  
      */
 249  
     public TreePath getTreePathForObject(Object o);
 250  
     // TODO Replace Object by a new parameterized type
 251  
 }