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