srcjar/fr/orsay/lri/varna/applications/fragseq/FragSeqTreeModel.java

   1 package fr.orsay.lri.varna.applications.fragseq;
   2
   3 import java.io.File;
   4 import java.io.FilenameFilter;
   5 import java.io.IOException;
   6 import java.util.ArrayList;
   7 import java.util.Enumeration;
   8 import java.util.Hashtable;
   9 import java.util.PriorityQueue;
  10 import java.util.Random;
  11 import java.util.TreeSet;
  12
  13 import javax.swing.event.TreeExpansionEvent;
  14 import javax.swing.event.TreeWillExpandListener;
  15 import javax.swing.tree.DefaultTreeModel;
  16 import javax.swing.tree.ExpandVetoException;
  17 import javax.swing.tree.TreeNode;
  18 import javax.swing.tree.TreePath;
  19
  20 public class FragSeqTreeModel extends DefaultTreeModel implements TreeWillExpandListener{
  21
  22           private FragSeqNode _rootIDs = new FragSeqNode("IDs");
  23           private FragSeqNode _rootFolders = new FragSeqNode("Folders");
  24
  25         private TreeSet<String> _folders = new TreeSet<String>();
  26   private Hashtable<String,FragSeqNode> _folderPathToFolderNode = new Hashtable<String,FragSeqNode>();
  27
  28   private Hashtable<String,FragSeqNode> _idsToNode = new Hashtable<String,FragSeqNode>();
  29   private Hashtable<String,ArrayList<FragSeqNode>> _pathToIDFileNodes = new Hashtable<String,ArrayList<FragSeqNode>>();
  30
  31   public enum SORT_MODE{
  32           PATH,
  33           ID
  34   }
  35
  36   private SORT_MODE _mode = SORT_MODE.PATH;
  37
  38   public FragSeqTreeModel()
  39   {
  40           this(new FragSeqNode("Folders"));
  41
  42   }
  43   public FragSeqTreeModel(TreeNode t)
  44   {
  45           super(t);
  46           this.setRoot(_rootFolders);
  47   }
  48
  49
  50   public FragSeqNode getPathViewRoot()
  51   {
  52           return _rootFolders;
  53   }
  54
  55   public FragSeqNode getIDViewRoot()
  56   {
  57           return _rootIDs;
  58   }
  59
  60   public void switchToIDView()
  61   {
  62           if (_mode!=SORT_MODE.ID)
  63           {
  64                   this.setRoot(this._rootIDs);
  65
  66           }
  67           _mode=SORT_MODE.ID;
  68
  69   }
  70
  71   private void removeAllNodes(ArrayList<FragSeqNode> toBeRemoved)
  72   {
  73           for(FragSeqNode leafNode : toBeRemoved)
  74           {
  75                   FragSeqNode parent = (FragSeqNode) leafNode.getParent();
  76                   parent.remove(leafNode);
  77                   if (parent.getChildCount()==0)
  78                   {
  79                           parent.removeFromParent();
  80                           _folderPathToFolderNode.remove(parent);
  81                           if (parent.getUserObject() instanceof String)
  82                           {
  83                                   String path = parent.getUserObject().toString();
  84                           }
  85                   }
  86                   else
  87                   {
  88                           reload(parent);
  89                   }
  90           }
  91   }
  92
  93
  94   public FragSeqNode getNodeForId(String id)
  95   {
  96           if(!_idsToNode.containsKey(id))
  97           {
  98                   FragSeqNode idNode = new FragSeqNode(id);
  99                   _idsToNode.put(id, idNode);
 100                   _rootIDs.add(idNode);
 101           }
 102           FragSeqNode idNode = _idsToNode.get(id);
 103           return idNode;
 104   }
 105
 106   public void removeFolder(String path)
 107   {
 108           ArrayList<FragSeqNode> toBeRemoved = new ArrayList<FragSeqNode>();
 109           Enumeration en = _folderPathToFolderNode.get(path).children();
 110           while(en.hasMoreElements())
 111           {
 112                   FragSeqNode n = (FragSeqNode) en.nextElement();
 113                   toBeRemoved.add(n);
 114           }
 115           removeAllNodes(toBeRemoved);
 116           _folders.remove(path);
 117   }
 118
 119
 120   public FragSeqNode insertGroupNode(String crit, TreeSet<String> t)
 121   {
 122           FragSeqNode groupNode = new FragSeqNode(crit);
 123           FragSeqNode parent = getRoot();
 124           int pos = t.headSet(crit).size();
 125           parent.insert(groupNode, pos);
 126           reload(groupNode);
 127           return groupNode;
 128   }
 129
 130
 131
 132   public void insertFileNode(FragSeqNode parent, FragSeqFileModel m)
 133   {
 134           FragSeqNode leafNode = new FragSeqNode(m);
 135           parent.add(leafNode);
 136   }
 137
 138   public FragSeqNode addFolder(String path)
 139   {
 140           FragSeqNode groupNode = null;
 141           try {
 142                   if (!_folders.contains(path))
 143                   {
 144                           File dir = new File(path);
 145                           if (dir.isDirectory())
 146                           {
 147                                   path = dir.getCanonicalPath();
 148                                   _folders.add(path);
 149                                   groupNode = insertGroupNode(path, _folders);
 150                                   _folderPathToFolderNode.put(path,groupNode);
 151                                   for(File f:dir.listFiles(_f))
 152                                   {
 153                                           addFile(path,f.getCanonicalPath());
 154                                   }
 155                           }
 156                   }
 157           } catch (IOException e) {
 158                   e.printStackTrace();
 159           }
 160           return groupNode;
 161   }
 162
 163   private void addFile(String folder, String path)
 164   {
 165           System.out.println("  => "+path);
 166           FragSeqFileModel m = new FragSeqFileModel(folder,path);
 167           addFolder(folder);
 168           insertFileNode(_folderPathToFolderNode.get(folder), m);
 169   }
 170
 171   public FragSeqNode getRoot()
 172   {
 173           return (FragSeqNode) super.getRoot();
 174   }
 175
 176   public ArrayList<String> getFolders()
 177   {
 178           ArrayList<String> result = new ArrayList<String>(_folders);
 179           return result;
 180   }
 181
 182
 183    FilenameFilter _f = new FilenameFilter(){
 184                 public boolean accept(File dir, String name) {
 185                         return name.toLowerCase().endsWith(".dbn")
 186                         || name.toLowerCase().endsWith(".ct")
 187                         || name.toLowerCase().endsWith(".bpseq")
 188                         || name.toLowerCase().endsWith(".rnaml");
 189                 }};
 190
 191   public FilenameFilter getFileNameFilter()
 192   {
 193         return _f;
 194   }
 195
 196   public void setFileNameFilter(FilenameFilter f)
 197   {
 198         _f = f;
 199   }
 200
 201
 202 private Hashtable<FragSeqNode,Boolean> _isExpanded = new Hashtable<FragSeqNode,Boolean>();
 203
 204 public boolean isExpanded(FragSeqNode n)
 205 {
 206   if(_isExpanded.containsKey(n))
 207   {
 208         return _isExpanded.get(n);
 209   }
 210   else
 211           return false;
 212 }
 213
 214 public void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException {
 215         if (event.getSource() instanceof FragSeqTree)
 216         {
 217                 FragSeqTree tree = (FragSeqTree) event.getSource();
 218                 TreePath t = event.getPath();
 219                 FragSeqNode n = (FragSeqNode) t.getLastPathComponent();
 220                 _isExpanded.put(n, true);
 221                 Object o = n.getUserObject();
 222                 if (o instanceof FragSeqFileModel)
 223                 {
 224                         FragSeqFileModel f = (FragSeqFileModel) o;
 225                         if (!f._cached)
 226                         {
 227                                 String path = f.getPath();
 228                                 if (!_pathToIDFileNodes.containsKey(path))
 229                                 {
 230                                         _pathToIDFileNodes.put(path, new ArrayList<FragSeqNode>());
 231                                 }
 232                                 ArrayList<FragSeqNode> nodesForID = _pathToIDFileNodes.get(path);
 233                                 for(FragSeqModel m: f.getModels())
 234                                 {
 235                                         n.add(new FragSeqNode(m));
 236                                         FragSeqNode nid = getNodeForId(m.getID());
 237                                         nid.add(new FragSeqNode(m));
 238                                         nodesForID.add(nid);
 239                                 }
 240                         }
 241                 }
 242         }
 243 }
 244
 245 public void treeWillCollapse(TreeExpansionEvent event)
 246                 throws ExpandVetoException {
 247         // TODO Auto-generated method stub
 248         TreePath t = event.getPath();
 249         FragSeqNode n = (FragSeqNode) t.getLastPathComponent();
 250         _isExpanded.put(n, false);
 251
 252
 253 }
 254
 255
 256 }