001    package nl.cwi.sen1.gui.plugin.data;
002    
003    import java.util.HashMap;
004    import java.util.Iterator;
005    import java.util.LinkedList;
006    import java.util.List;
007    import java.util.Map;
008    
009    import javax.swing.event.TreeModelEvent;
010    import javax.swing.tree.TreeModel;
011    import javax.swing.tree.TreePath;
012    
013    import nl.cwi.sen1.ioapi.types.File;
014    import aterm.ATerm;
015    
016    public class ModuleTreeModel extends AbstractModuleTreeModel implements
017                    TreeModel {
018            private ModuleTreeNode root;
019    
020            private List<ModuleSelectionListener> moduleSelectionListeners;
021    
022            private Map<ATerm, Module> moduleTable;
023    
024            public ModuleTreeModel() {
025                    moduleTable = new HashMap<ATerm, Module>();
026                    moduleSelectionListeners = new LinkedList<ModuleSelectionListener>();
027                    root = new ModuleTreeNode(null, "", "", false);
028            }
029    
030            public Object getRoot() {
031                    return root;
032            }
033    
034            public Object getChild(Object parent, int index) {
035                    return ((ModuleTreeNode) parent).getChild(index);
036            }
037    
038            public int getChildCount(Object parent) {
039                    return ((ModuleTreeNode) parent).getChildCount();
040            }
041    
042            public boolean isLeaf(Object node) {
043                    return ((ModuleTreeNode) node).isLeaf();
044            }
045    
046            public void valueForPathChanged(TreePath path, Object newValue) {
047            }
048    
049            public int getIndexOfChild(Object par, Object ch) {
050                    ModuleTreeNode parent = (ModuleTreeNode) par;
051                    ModuleTreeNode child = (ModuleTreeNode) ch;
052    
053                    if (parent == null)
054                            return -1;
055    
056                    return parent.getIndexOfChild(child);
057            }
058    
059            public void addModuleSelectionListener(ModuleSelectionListener listener) {
060                    moduleSelectionListeners.add(listener);
061            }
062    
063            public void selectModule(ATerm moduleId) {
064                    selectModule(getModule(moduleId));
065            }
066    
067            public void selectModule(Module module) {
068                    Iterator<ModuleSelectionListener> iter = moduleSelectionListeners
069                                    .iterator();
070                    while (iter.hasNext()) {
071                            ModuleSelectionListener l = iter.next();
072                            l.moduleSelected(module);
073                    }
074            }
075    
076            public Module getModule(ATerm moduleId) {
077                    return moduleTable.get(moduleId);
078            }
079    
080            public void addModule(Module module) {
081                    ATerm moduleId = module.getId();
082                    File file = module.getFile();
083    
084                    if (file != null && moduleTable.put(moduleId, module) == null) {
085                            root.addChild(moduleId, "", file);
086                            repaintTree();
087                    }
088            }
089    
090            public void removeModule(ATerm id) {
091                    Module module = getModule(id);
092                    File file = module.getFile();
093    
094                    moduleTable.remove(id);
095                    root.removeChild(file);
096                    repaintTree();
097            }
098    
099            public void clearModules() {
100                    moduleTable.clear();
101                    root.clearChildren();
102                    repaintTree();
103            }
104    
105            public TreePath makeTreePath(File file) {
106                    List<ModuleTreeNode> l = root.makePath(file);
107    
108                    return new TreePath(l.toArray());
109            }
110    
111            public void repaintTree() {
112                    Object path[] = new Object[1];
113                    path[0] = root;
114                    fireTreeStructureChanged(new TreeModelEvent(root, path));
115            }
116    
117            public List<Module> getModules() {
118                    return new LinkedList<Module>(moduleTable.values());
119            }
120    
121            public void markError(ATerm moduleId) {
122                    Module module = getModule(moduleId);
123                    File file = module.getFile();
124    
125                    root.setErrorState(file, true);
126                    repaintTree();
127            }
128    
129            public void markNormal(ATerm moduleId) {
130                    Module module = getModule(moduleId);
131                    File file = module.getFile();
132    
133                    root.setErrorState(file, false);
134                    repaintTree();
135            }
136    }