jsampler/view/InstrumentsDbTreeModel.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
 *
 *   This file is part of JSampler.
 *
 *   JSampler is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   JSampler is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with JSampler; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 */

package org.jsampler.view;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import java.util.Vector;

import javax.swing.SwingUtilities;

import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;

import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

import net.sf.juife.event.TaskEvent;
import net.sf.juife.event.TaskListener;

import org.jsampler.CC;

import org.jsampler.task.InstrumentsDb;

import org.linuxsampler.lscp.DbDirectoryInfo;
import org.linuxsampler.lscp.DbInstrumentInfo;

import org.linuxsampler.lscp.event.InstrumentsDbEvent;
import org.linuxsampler.lscp.event.InstrumentsDbListener;

/**
 *
 * @author Grigor Iliev
 */
public class InstrumentsDbTreeModel implements TreeModel {
        private DbDirectoryTreeNode root = null;
        private Vector<TreeModelListener> listeners = new Vector<TreeModelListener>();
        
        /**
         * Creates a new instance of <code>InstrumentsDbTreeModel</code>.
         */
        public
        InstrumentsDbTreeModel() { this(null); }
        
        /**
         * Creates a new instance of <code>InstrumentsDbTreeModel</code>.
         * @param l A listener that will be notified when the root
         * directory content is loaded.
         */
        public
        InstrumentsDbTreeModel(final ActionListener l) {
                final InstrumentsDb.GetDrectory gdi = new InstrumentsDb.GetDrectory("/");
                final InstrumentsDb.GetDrectories gd = new InstrumentsDb.GetDrectories("/");
                final InstrumentsDb.GetInstruments gi = new InstrumentsDb.GetInstruments("/");
                
                gdi.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                if(gdi.doneWithErrors()) return;
                                root = new DbDirectoryTreeNode(gdi.getResult());
                                fireNodeStructureChanged(root);
                                
                                // TODO: This shouldn't be done in the event-dispatcing thread
                                CC.getClient().addInstrumentsDbListener(getHandler());
                                ///////
                                CC.getTaskQueue().add(gd);
                                CC.getTaskQueue().add(gi);
                        }
                });
                
                gd.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                root.setConnected(true);
                                if(gd.doneWithErrors()) return;
                                updateDirectoryContent(root, gd.getResult());
                                
                                for(int i = 0; i < root.getChildCount(); i++) {
                                        DbDirectoryTreeNode node = root.getChildAt(i);
                                        node.setConnected(true);
                                        updateDirectoryContent(node, "/" + node.toString());
                                }
                                
                                if(l != null) l.actionPerformed(null);
                        }
                });
                
                gi.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                if(gi.doneWithErrors()) return;
                                updateDirectoryContent(root, gi.getResult());
                        }
                });
                
                CC.getTaskQueue().add(gdi);
        }
        
        public void
        treeWillExpand(TreePath path) {
                DbDirectoryTreeNode node = (DbDirectoryTreeNode)path.getLastPathComponent();
                
                if(!node.isConnected()) {
                        node.setConnected(true);
                        updateDirectoryContent(node, node.getInfo().getDirectoryPath());
                }
                
                for(int i = 0; i < node.getChildCount(); i++) {
                        DbDirectoryTreeNode child = node.getChildAt(i);
                        if(child.isConnected()) continue;
                        child.setConnected(true);
                        String pathName = getPathName(path.getPath());
                        if(pathName.length() > 1) pathName += "/";
                        updateDirectoryContent(child, pathName + child.toString());
                }
        }
        
        // Tree model methods
        public void
        addTreeModelListener(TreeModelListener l) {
                listeners.add(l);
        }
        
        public void
        removeTreeModelListener(TreeModelListener l) {
                listeners.remove(l);
        }
        
        public Object
        getChild(Object parent, int index) {
                return ((DbDirectoryTreeNode)parent).getChildAt(index);
        }
        
        public int
        getChildCount(Object parent) {
                return ((DbDirectoryTreeNode)parent).getChildCount();
        }
        
        public Object
        getRoot() { return root; }
        
        public int
        getIndexOfChild(Object parent, Object child) {
                if(parent == null || child == null) return -1;
                return ((DbDirectoryTreeNode)parent).getIndex((DbDirectoryTreeNode)child);
        }
        
        public boolean
        isLeaf(Object node) { return ((DbDirectoryTreeNode)node).isLeaf(); }
        
        public void
        valueForPathChanged(TreePath path, Object newValue) {
                
        }
        ///////
        
        /**
         * Schedules an update of the directory content for the specified directory node.
         */
        private void
        updateDirectoryContent(final DbDirectoryTreeNode dirNode, String dirPath) {
                updateDirectoryContent(dirNode, dirPath, null);
        }
        
        /**
         * Schedules an update of the directory content for the specified directory node.
         * @param l A listener that will be notified when the subdirectory list is updated.
         */
        private void
        updateDirectoryContent (
                final DbDirectoryTreeNode dirNode, String dirPath, final ActionListener l
        ) {
                final InstrumentsDb.GetDrectories gd = new InstrumentsDb.GetDrectories(dirPath);
                
                gd.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                if(gd.doneWithErrors()) {
                                        if(l != null) l.actionPerformed(null);
                                        return;
                                }
                                updateDirectoryContent(dirNode, gd.getResult());
                                if(l != null) l.actionPerformed(null);
                        }
                });
                CC.scheduleTask(gd);
                
                final InstrumentsDb.GetInstruments gi = new InstrumentsDb.GetInstruments(dirPath);
                
                gi.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                if(gi.doneWithErrors()) return;
                                updateDirectoryContent(dirNode, gi.getResult());
                        }
                });
                CC.scheduleTask(gi);
        }
        
        private void
        updateDirectoryContent(DbDirectoryTreeNode parent, DbDirectoryInfo[] children) {
                boolean found = false;
                Vector<DbDirectoryTreeNode> removedNodes = new Vector<DbDirectoryTreeNode>();
                for(int i = 0; i < parent.getChildCount(); i++) {
                        for(int j = 0; j < children.length; j++) {
                                if(children[j] == null) continue;
                                if(children[j].getName().equals(parent.getChildAt(i).toString())) {
                                        children[j] = null;
                                        found = true;
                                        break;
                                }
                        }
                        if(!found) removedNodes.add(parent.getChildAt(i));
                        found = false;
                }
                
                for(DbDirectoryTreeNode node : removedNodes) {
                        int i = parent.getIndex(node);
                        parent.removeDirectory(i);
                        fireNodeRemoved(parent, node, i);
                }
                
                for(DbDirectoryInfo info : children) {
                        if(info == null) continue;
                        DbDirectoryTreeNode node = new DbDirectoryTreeNode(info);
                        parent.addDirectory(node);
                        fireNodeInserted(node, parent.getIndex(node));
                        if(parent.getParent() == null) {
                                node.setConnected(true);
                                updateDirectoryContent(node, info.getDirectoryPath());
                        } else if(parent.isConnected()) {
                                updateDirectoryContent(node, info.getDirectoryPath());
                        }
                }
        }
        
        private void
        updateDirectoryContent(DbDirectoryTreeNode parent, DbInstrumentInfo[] children) {
                boolean found = false;
                Vector<DbInstrumentInfo> removedNodes = new Vector<DbInstrumentInfo>();
                for(int i = 0; i < parent.getInstrumentCount(); i++) {
                        String name = parent.getInstrumentAt(i).getName();
                        
                        for(int j = 0; j < children.length; j++) {
                                if(children[j] == null) continue;
                                if(children[j].getName().equals(name)) {
                                        children[j] = null;
                                        found = true;
                                        break;
                                }
                        }
                        if(!found) removedNodes.add(parent.getInstrumentAt(i));
                        found = false;
                }
                
                for(DbInstrumentInfo info : removedNodes) {
                        int i = parent.getInstrumentIndex(info);
                        parent.removeInstrument(i);
                }
                
                for(DbInstrumentInfo info : children) {
                        if(info == null) continue;
                        parent.addInstrument(info);
                }
        }
        
        /**
         * Schedules a task for refreshing the directory content of the specified directory.
         * Note that the specified directory is expected to be connected.
         * @param dir The absolute path name of the directory to refresh.
         */
        public void
        refreshDirectoryContent(String dir) {
                final DbDirectoryTreeNode node = getNodeByPath(dir);
                if(node == null) return;
                
                node.removeAllDirectories();
                fireNodeStructureChanged(node);
                node.removeAllInstruments();
                
                final InstrumentsDb.GetDrectories gd = new InstrumentsDb.GetDrectories(dir);
                
                gd.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                if(gd.doneWithErrors()) return;
                                
                                for(DbDirectoryInfo info : gd.getResult()) {
                                        DbDirectoryTreeNode n = new DbDirectoryTreeNode(info);
                                        node.addDirectory(n);
                                        fireNodeInserted(n, node.getIndex(n));
                                        n.setConnected(true);
                                        updateDirectoryContent(n, n.getInfo().getDirectoryPath());
                                }
                        }
                });
                CC.scheduleTask(gd);
                
                final InstrumentsDb.GetInstruments gi = new InstrumentsDb.GetInstruments(dir);
                
                gi.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                if(gi.doneWithErrors()) return;
                                
                                for(DbInstrumentInfo info : gi.getResult()) {
                                        node.addInstrument(info);
                                }
                        }
                });
                CC.scheduleTask(gi);
        }
        
        protected Object[]
        getPathToRoot(DbDirectoryTreeNode node) {
                Vector v = new Vector();
                
                while(node != null) {
                        v.insertElementAt(node, 0);
                        if(node == getRoot()) break;
                        node = node.getParent();
                }
                
                return v.toArray(new Object[v.size()]);
        }
        
        protected String
        getPathName(Object[] objs) {
                if(objs.length == 1) return "/";
                
                StringBuffer sb = new StringBuffer();
                for(int i = 1; i < objs.length; i++) {
                        sb.append('/').append(objs[i].toString());
                }
                
                return sb.toString();
        }
        
        private void
        fireNodeInserted(DbDirectoryTreeNode node, int index) {
                Object[] path = getPathToRoot(node.getParent());
                int[] idxs = { index };
                Object[] objs = { node };
                TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
                for(TreeModelListener l : listeners) {
                        l.treeNodesInserted(e);
                }
        }
        
        private void
        fireNodeChanged(DbDirectoryTreeNode node, int index) {
                Object[] path = getPathToRoot(node.getParent());
                int[] idxs = { index };
                Object[] objs = { node };
                TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
                for(TreeModelListener l : listeners) {
                        l.treeNodesChanged(e);
                }
        }
        
        private void
        fireNodeRemoved(DbDirectoryTreeNode parent, DbDirectoryTreeNode node, int index) {
                Object[] path = getPathToRoot(parent);
                int[] idxs = { index };
                Object[] objs = { node };
                TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
                for(int i = listeners.size() - 1; i >=0; i--) {
                        listeners.get(i).treeNodesRemoved(e);
                }
        }
        
        private void
        fireNodeStructureChanged(DbDirectoryTreeNode node) {
                Object[] path = getPathToRoot(node);
                Object[] objs = { node };
                TreeModelEvent e = new TreeModelEvent(this, path);
                for(TreeModelListener l : listeners) {
                        l.treeStructureChanged(e);
                }
        }
        
        public DbDirectoryTreeNode
        getNodeByPath(String path) {
                String[] dirs = getDirectoryPath(path);
                if(dirs == null) return null;
                if(dirs.length == 1) return root;
                
                DbDirectoryTreeNode node = root;
                boolean found = false;
                for(int i = 1; i < dirs.length; i++) {
                        for(int k = 0; k < node.getChildCount(); k++) {
                                if(dirs[i].equals(node.getChildAt(k).toString())) {
                                        node = node.getChildAt(k);
                                        found = true;
                                        break;
                                }
                        }
                        
                        if(!found) return null;
                        found = false;
                }
                
                return node;
        }
        
        public String
        getPathByNode(DbDirectoryTreeNode node) {
                if(node == null) return null;
                return getPathName(getPathToRoot(node));
        }
        
        private String[]
        getDirectoryPath(String path) {
                if(path == null || path.length() == 0) return null;
                if(path.charAt(0) != '/') return null;
                Vector<String> v = new Vector<String>();
                v.add("/");
                if(path.length() == 1) return v.toArray(new String[v.size()]);
                
                if(path.charAt(path.length() - 1) != '/') path += "/";
                int i = 1;
                int j = path.indexOf('/', i);
                
                while(j != -1) {
                        v.add(path.substring(i, j));
                        
                        i = j + 1;
                        if(i >= path.length()) return v.toArray(new String[v.size()]);
                        j = path.indexOf('/', i);
                }
                
                return null;
        }
        
        public static String
        getParentDirectory(String path) {
                if(path == null || path.length() == 0) return null;
                if(path.charAt(0) != '/') return null;
                if(path.length() == 1) return null;
                
                if(path.charAt(path.length() - 1) == '/') {
                        path = path.substring(0, path.length() - 1);
                }
                
                int i = path.lastIndexOf('/');
                if(i == 0) return "/";
                return path.substring(0, i);
        }
        
        /**
         * @param l A listener which will be notified when the operation is completed.
         */
        public void
        loadPath(String path, final ActionListener l) {
                // TODO: This method is lazily implemented. Should be optimized.
                final String[] dirs = getDirectoryPath(path);
                if(dirs == null) {
                        l.actionPerformed(null);
                        return;
                }
                
                final ActionListener listener = new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) {
                                String s = "";
                                DbDirectoryTreeNode node = null;
                                for(int i = 0; i < dirs.length; i++) {
                                        if(i > 1) s += "/" + dirs[i];
                                        else s += dirs[i];
                                        node = getNodeByPath(s);
                                        if(node == null) {
                                                if(l != null) l.actionPerformed(null);
                                                return;
                                        }
                                        
                                        if(!node.isConnected()) {
                                                node.setConnected(true);
                                                updateDirectoryContent(node, s, this);
                                                return;
                                        }
                                }
                                
                                if(l != null) l.actionPerformed(null);
                        }
                };
                
                listener.actionPerformed(null);
        }
        
        private final EventHandler eventHandler = new EventHandler();
        
        private EventHandler
        getHandler() { return eventHandler; }
        
        private class EventHandler implements InstrumentsDbListener {
                /**
                 * Invoked when the number of instrument
                 * directories in a specific directory has changed.
                 */
                public void
                directoryCountChanged(final InstrumentsDbEvent e) {
                        SwingUtilities.invokeLater(new Runnable() {
                                public void
                                run() {
                                        DbDirectoryTreeNode node = getNodeByPath(e.getPathName());
                                        if(node == null) {
                                                return;
                                        }
                                        if(!node.isConnected()) {
                                                return;
                                        }
                                        
                                        updateDirectoryContent(node, e.getPathName());
                                }
                        });
                }
                
                /**
                 * Invoked when the settings of an instrument directory are changed.
                 */
                public void
                directoryInfoChanged(final InstrumentsDbEvent e) {
                        SwingUtilities.invokeLater(new Runnable() {
                                public void
                                run() { updateDirectoryInfo(e); }
                        });
                }
                
                private void
                updateDirectoryInfo(InstrumentsDbEvent e) {
                        final DbDirectoryTreeNode node = getNodeByPath(e.getPathName());
                        if(node == null) return;
                        
                        final InstrumentsDb.GetDrectory t =
                                new InstrumentsDb.GetDrectory(e.getPathName());
                        
                        t.addTaskListener(new TaskListener() {
                                public void
                                taskPerformed(TaskEvent e) {
                                        if(t.doneWithErrors()) return;
                                        if(node.getParent() != null) {
                                                node.getParent().updateDirectory(t.getResult());
                                                fireNodeChanged(node, node.getParent().getIndex(node));
                                        }
                                }
                        });
                        
                        CC.getTaskQueue().add(t);
                }
                
                /**
                 * Invoked when an instrument directory is renamed.
                 */
                public void
                directoryNameChanged(final InstrumentsDbEvent e) {
                        SwingUtilities.invokeLater(new Runnable() {
                                public void
                                run() { directoryRenamed(e); }
                        });
                }
                
                private void
                directoryRenamed(InstrumentsDbEvent e) {
                        DbDirectoryTreeNode node = getNodeByPath(e.getPathName());
                        if(node == null) {
                                // If the directory is renamed by this frontend the
                                // directory should already be with the new name
                                String s = getParentDirectory(e.getPathName());
                                if(s.length() == 1) s += e.getNewName();
                                else s += "/" + e.getNewName();
                                node = getNodeByPath(s);
                        }
                        if(node == null || node.getParent() == null) {
                                CC.getLogger().warning("Invalid path: " + e.getPathName());
                                return;
                        }
                        
                        node.getInfo().setName(e.getNewName());
                        DbDirectoryTreeNode parent = node.getParent();
                        
                        int i = parent.getIndex(node);
                        parent.removeDirectory(i);
                        fireNodeRemoved(parent, node, i);
                        
                        parent.addDirectory(node);
                        fireNodeInserted(node, parent.getIndex(node));
                }
                
                /**
                 * Invoked when the number of instruments
                 * in a specific directory has changed.
                 */
                public void
                instrumentCountChanged(final InstrumentsDbEvent e) {
                        SwingUtilities.invokeLater(new Runnable() {
                                public void
                                run() {
                                        DbDirectoryTreeNode node = getNodeByPath(e.getPathName());
                                        if(node == null) {
                                                return;
                                        }
                                        if(!node.isConnected()) {
                                                return;
                                        }
                                        
                                        updateDirectoryContent(node, e.getPathName());
                                }
                        });
                }
                
                /**
                 * Invoked when the settings of an instrument are changed.
                 */
                public void
                instrumentInfoChanged(final InstrumentsDbEvent e) {
                        SwingUtilities.invokeLater(new Runnable() {
                                public void
                                run() { updateInstrumentInfo(e); }
                        });
                }
                
                /**
                 * Invoked when an instrument is renamed.
                 */
                public void
                instrumentNameChanged(final InstrumentsDbEvent e) {
                        SwingUtilities.invokeLater(new Runnable() {
                                public void
                                run() { instrumentRenamed(e); }
                        });
                }
                
                private void
                updateInstrumentInfo(InstrumentsDbEvent e) {
                        String dir = getParentDirectory(e.getPathName());
                        final DbDirectoryTreeNode node = getNodeByPath(dir);
                        if(node == null) return;
                        if(!node.isConnected()) return;
                        
                        final InstrumentsDb.GetInstrument t =
                                new InstrumentsDb.GetInstrument(e.getPathName());
                        
                        t.addTaskListener(new TaskListener() {
                                public void
                                taskPerformed(TaskEvent e) {
                                        if(t.doneWithErrors()) return;
                                        node.updateInstrument(t.getResult());
                                }
                        });
                        
                        CC.getTaskQueue().add(t);
                }
                
                private void
                instrumentRenamed(InstrumentsDbEvent e) {
                        String dir = getParentDirectory(e.getPathName());
                        DbDirectoryTreeNode node = getNodeByPath(dir);
                        if(node == null) return;
                        
                        String instr = e.getPathName();
                        int i = instr.lastIndexOf('/');
                        if(i != -1 && i < instr.length() - 1) instr = instr.substring(i + 1);
                        else return;
                        
                        DbInstrumentInfo info = node.getInstrument(instr);
                        
                        if(info == null) {
                                // If the instrument is renamed by this frontend the
                                // instrument should already be with the new name
                                info = node.getInstrument(e.getNewName());
                        }
                        if(info == null) {
                                CC.getLogger().warning("Invalid path: " + e.getPathName());
                                return;
                        }
                        
                        info.setName(e.getNewName());
                        node.removeInstrument(node.getInstrumentIndex(info));
                        node.addInstrument(info);
                }
                
                /** Invoked when the status of particular job has changed. */
                public void
                jobStatusChanged(InstrumentsDbEvent e) { }
        }
}
1	/*
2	* JSampler - a java front-end for LinuxSampler
3	*
4	* Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
5	*
6	* This file is part of JSampler.
7	*
8	* JSampler is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2
10	* as published by the Free Software Foundation.
11	*
12	* JSampler is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with JSampler; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20	* MA 02111-1307 USA
21	*/
22
23	package org.jsampler.view;
24
25	import java.awt.event.ActionEvent;
26	import java.awt.event.ActionListener;
27
28	import java.util.Vector;
29
30	import javax.swing.SwingUtilities;
31
32	import javax.swing.event.TreeModelEvent;
33	import javax.swing.event.TreeModelListener;
34
35	import javax.swing.tree.TreeModel;
36	import javax.swing.tree.TreePath;
37
38	import net.sf.juife.event.TaskEvent;
39	import net.sf.juife.event.TaskListener;
40
41	import org.jsampler.CC;
42
43	import org.jsampler.task.InstrumentsDb;
44
45	import org.linuxsampler.lscp.DbDirectoryInfo;
46	import org.linuxsampler.lscp.DbInstrumentInfo;
47
48	import org.linuxsampler.lscp.event.InstrumentsDbEvent;
49	import org.linuxsampler.lscp.event.InstrumentsDbListener;
50
51	/**
52	*
53	* @author Grigor Iliev
54	*/
55	public class InstrumentsDbTreeModel implements TreeModel {
56	private DbDirectoryTreeNode root = null;
57	private Vector<TreeModelListener> listeners = new Vector<TreeModelListener>();
58
59	/**
60	* Creates a new instance of <code>InstrumentsDbTreeModel</code>.
61	*/
62	public
63	InstrumentsDbTreeModel() { this(null); }
64
65	/**
66	* Creates a new instance of <code>InstrumentsDbTreeModel</code>.
67	* @param l A listener that will be notified when the root
68	* directory content is loaded.
69	*/
70	public
71	InstrumentsDbTreeModel(final ActionListener l) {
72	final InstrumentsDb.GetDrectory gdi = new InstrumentsDb.GetDrectory("/");
73	final InstrumentsDb.GetDrectories gd = new InstrumentsDb.GetDrectories("/");
74	final InstrumentsDb.GetInstruments gi = new InstrumentsDb.GetInstruments("/");
75
76	gdi.addTaskListener(new TaskListener() {
77	public void
78	taskPerformed(TaskEvent e) {
79	if(gdi.doneWithErrors()) return;
80	root = new DbDirectoryTreeNode(gdi.getResult());
81	fireNodeStructureChanged(root);
82
83	// TODO: This shouldn't be done in the event-dispatcing thread
84	CC.getClient().addInstrumentsDbListener(getHandler());
85	///////
86	CC.getTaskQueue().add(gd);
87	CC.getTaskQueue().add(gi);
88	}
89	});
90
91	gd.addTaskListener(new TaskListener() {
92	public void
93	taskPerformed(TaskEvent e) {
94	root.setConnected(true);
95	if(gd.doneWithErrors()) return;
96	updateDirectoryContent(root, gd.getResult());
97
98	for(int i = 0; i < root.getChildCount(); i++) {
99	DbDirectoryTreeNode node = root.getChildAt(i);
100	node.setConnected(true);
101	updateDirectoryContent(node, "/" + node.toString());
102	}
103
104	if(l != null) l.actionPerformed(null);
105	}
106	});
107
108	gi.addTaskListener(new TaskListener() {
109	public void
110	taskPerformed(TaskEvent e) {
111	if(gi.doneWithErrors()) return;
112	updateDirectoryContent(root, gi.getResult());
113	}
114	});
115
116	CC.getTaskQueue().add(gdi);
117	}
118
119	public void
120	treeWillExpand(TreePath path) {
121	DbDirectoryTreeNode node = (DbDirectoryTreeNode)path.getLastPathComponent();
122
123	if(!node.isConnected()) {
124	node.setConnected(true);
125	updateDirectoryContent(node, node.getInfo().getDirectoryPath());
126	}
127
128	for(int i = 0; i < node.getChildCount(); i++) {
129	DbDirectoryTreeNode child = node.getChildAt(i);
130	if(child.isConnected()) continue;
131	child.setConnected(true);
132	String pathName = getPathName(path.getPath());
133	if(pathName.length() > 1) pathName += "/";
134	updateDirectoryContent(child, pathName + child.toString());
135	}
136	}
137
138	// Tree model methods
139	public void
140	addTreeModelListener(TreeModelListener l) {
141	listeners.add(l);
142	}
143
144	public void
145	removeTreeModelListener(TreeModelListener l) {
146	listeners.remove(l);
147	}
148
149	public Object
150	getChild(Object parent, int index) {
151	return ((DbDirectoryTreeNode)parent).getChildAt(index);
152	}
153
154	public int
155	getChildCount(Object parent) {
156	return ((DbDirectoryTreeNode)parent).getChildCount();
157	}
158
159	public Object
160	getRoot() { return root; }
161
162	public int
163	getIndexOfChild(Object parent, Object child) {
164	if(parent == null \|\| child == null) return -1;
165	return ((DbDirectoryTreeNode)parent).getIndex((DbDirectoryTreeNode)child);
166	}
167
168	public boolean
169	isLeaf(Object node) { return ((DbDirectoryTreeNode)node).isLeaf(); }
170
171	public void
172	valueForPathChanged(TreePath path, Object newValue) {
173
174	}
175	///////
176
177	/**
178	* Schedules an update of the directory content for the specified directory node.
179	*/
180	private void
181	updateDirectoryContent(final DbDirectoryTreeNode dirNode, String dirPath) {
182	updateDirectoryContent(dirNode, dirPath, null);
183	}
184
185	/**
186	* Schedules an update of the directory content for the specified directory node.
187	* @param l A listener that will be notified when the subdirectory list is updated.
188	*/
189	private void
190	updateDirectoryContent (
191	final DbDirectoryTreeNode dirNode, String dirPath, final ActionListener l
192	) {
193	final InstrumentsDb.GetDrectories gd = new InstrumentsDb.GetDrectories(dirPath);
194
195	gd.addTaskListener(new TaskListener() {
196	public void
197	taskPerformed(TaskEvent e) {
198	if(gd.doneWithErrors()) {
199	if(l != null) l.actionPerformed(null);
200	return;
201	}
202	updateDirectoryContent(dirNode, gd.getResult());
203	if(l != null) l.actionPerformed(null);
204	}
205	});
206	CC.scheduleTask(gd);
207
208	final InstrumentsDb.GetInstruments gi = new InstrumentsDb.GetInstruments(dirPath);
209
210	gi.addTaskListener(new TaskListener() {
211	public void
212	taskPerformed(TaskEvent e) {
213	if(gi.doneWithErrors()) return;
214	updateDirectoryContent(dirNode, gi.getResult());
215	}
216	});
217	CC.scheduleTask(gi);
218	}
219
220	private void
221	updateDirectoryContent(DbDirectoryTreeNode parent, DbDirectoryInfo[] children) {
222	boolean found = false;
223	Vector<DbDirectoryTreeNode> removedNodes = new Vector<DbDirectoryTreeNode>();
224	for(int i = 0; i < parent.getChildCount(); i++) {
225	for(int j = 0; j < children.length; j++) {
226	if(children[j] == null) continue;
227	if(children[j].getName().equals(parent.getChildAt(i).toString())) {
228	children[j] = null;
229	found = true;
230	break;
231	}
232	}
233	if(!found) removedNodes.add(parent.getChildAt(i));
234	found = false;
235	}
236
237	for(DbDirectoryTreeNode node : removedNodes) {
238	int i = parent.getIndex(node);
239	parent.removeDirectory(i);
240	fireNodeRemoved(parent, node, i);
241	}
242
243	for(DbDirectoryInfo info : children) {
244	if(info == null) continue;
245	DbDirectoryTreeNode node = new DbDirectoryTreeNode(info);
246	parent.addDirectory(node);
247	fireNodeInserted(node, parent.getIndex(node));
248	if(parent.getParent() == null) {
249	node.setConnected(true);
250	updateDirectoryContent(node, info.getDirectoryPath());
251	} else if(parent.isConnected()) {
252	updateDirectoryContent(node, info.getDirectoryPath());
253	}
254	}
255	}
256
257	private void
258	updateDirectoryContent(DbDirectoryTreeNode parent, DbInstrumentInfo[] children) {
259	boolean found = false;
260	Vector<DbInstrumentInfo> removedNodes = new Vector<DbInstrumentInfo>();
261	for(int i = 0; i < parent.getInstrumentCount(); i++) {
262	String name = parent.getInstrumentAt(i).getName();
263
264	for(int j = 0; j < children.length; j++) {
265	if(children[j] == null) continue;
266	if(children[j].getName().equals(name)) {
267	children[j] = null;
268	found = true;
269	break;
270	}
271	}
272	if(!found) removedNodes.add(parent.getInstrumentAt(i));
273	found = false;
274	}
275
276	for(DbInstrumentInfo info : removedNodes) {
277	int i = parent.getInstrumentIndex(info);
278	parent.removeInstrument(i);
279	}
280
281	for(DbInstrumentInfo info : children) {
282	if(info == null) continue;
283	parent.addInstrument(info);
284	}
285	}
286
287	/**
288	* Schedules a task for refreshing the directory content of the specified directory.
289	* Note that the specified directory is expected to be connected.
290	* @param dir The absolute path name of the directory to refresh.
291	*/
292	public void
293	refreshDirectoryContent(String dir) {
294	final DbDirectoryTreeNode node = getNodeByPath(dir);
295	if(node == null) return;
296
297	node.removeAllDirectories();
298	fireNodeStructureChanged(node);
299	node.removeAllInstruments();
300
301	final InstrumentsDb.GetDrectories gd = new InstrumentsDb.GetDrectories(dir);
302
303	gd.addTaskListener(new TaskListener() {
304	public void
305	taskPerformed(TaskEvent e) {
306	if(gd.doneWithErrors()) return;
307
308	for(DbDirectoryInfo info : gd.getResult()) {
309	DbDirectoryTreeNode n = new DbDirectoryTreeNode(info);
310	node.addDirectory(n);
311	fireNodeInserted(n, node.getIndex(n));
312	n.setConnected(true);
313	updateDirectoryContent(n, n.getInfo().getDirectoryPath());
314	}
315	}
316	});
317	CC.scheduleTask(gd);
318
319	final InstrumentsDb.GetInstruments gi = new InstrumentsDb.GetInstruments(dir);
320
321	gi.addTaskListener(new TaskListener() {
322	public void
323	taskPerformed(TaskEvent e) {
324	if(gi.doneWithErrors()) return;
325
326	for(DbInstrumentInfo info : gi.getResult()) {
327	node.addInstrument(info);
328	}
329	}
330	});
331	CC.scheduleTask(gi);
332	}
333
334	protected Object[]
335	getPathToRoot(DbDirectoryTreeNode node) {
336	Vector v = new Vector();
337
338	while(node != null) {
339	v.insertElementAt(node, 0);
340	if(node == getRoot()) break;
341	node = node.getParent();
342	}
343
344	return v.toArray(new Object[v.size()]);
345	}
346
347	protected String
348	getPathName(Object[] objs) {
349	if(objs.length == 1) return "/";
350
351	StringBuffer sb = new StringBuffer();
352	for(int i = 1; i < objs.length; i++) {
353	sb.append('/').append(objs[i].toString());
354	}
355
356	return sb.toString();
357	}
358
359	private void
360	fireNodeInserted(DbDirectoryTreeNode node, int index) {
361	Object[] path = getPathToRoot(node.getParent());
362	int[] idxs = { index };
363	Object[] objs = { node };
364	TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
365	for(TreeModelListener l : listeners) {
366	l.treeNodesInserted(e);
367	}
368	}
369
370	private void
371	fireNodeChanged(DbDirectoryTreeNode node, int index) {
372	Object[] path = getPathToRoot(node.getParent());
373	int[] idxs = { index };
374	Object[] objs = { node };
375	TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
376	for(TreeModelListener l : listeners) {
377	l.treeNodesChanged(e);
378	}
379	}
380
381	private void
382	fireNodeRemoved(DbDirectoryTreeNode parent, DbDirectoryTreeNode node, int index) {
383	Object[] path = getPathToRoot(parent);
384	int[] idxs = { index };
385	Object[] objs = { node };
386	TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
387	for(int i = listeners.size() - 1; i >=0; i--) {
388	listeners.get(i).treeNodesRemoved(e);
389	}
390	}
391
392	private void
393	fireNodeStructureChanged(DbDirectoryTreeNode node) {
394	Object[] path = getPathToRoot(node);
395	Object[] objs = { node };
396	TreeModelEvent e = new TreeModelEvent(this, path);
397	for(TreeModelListener l : listeners) {
398	l.treeStructureChanged(e);
399	}
400	}
401
402	public DbDirectoryTreeNode
403	getNodeByPath(String path) {
404	String[] dirs = getDirectoryPath(path);
405	if(dirs == null) return null;
406	if(dirs.length == 1) return root;
407
408	DbDirectoryTreeNode node = root;
409	boolean found = false;
410	for(int i = 1; i < dirs.length; i++) {
411	for(int k = 0; k < node.getChildCount(); k++) {
412	if(dirs[i].equals(node.getChildAt(k).toString())) {
413	node = node.getChildAt(k);
414	found = true;
415	break;
416	}
417	}
418
419	if(!found) return null;
420	found = false;
421	}
422
423	return node;
424	}
425
426	public String
427	getPathByNode(DbDirectoryTreeNode node) {
428	if(node == null) return null;
429	return getPathName(getPathToRoot(node));
430	}
431
432	private String[]
433	getDirectoryPath(String path) {
434	if(path == null \|\| path.length() == 0) return null;
435	if(path.charAt(0) != '/') return null;
436	Vector<String> v = new Vector<String>();
437	v.add("/");
438	if(path.length() == 1) return v.toArray(new String[v.size()]);
439
440	if(path.charAt(path.length() - 1) != '/') path += "/";
441	int i = 1;
442	int j = path.indexOf('/', i);
443
444	while(j != -1) {
445	v.add(path.substring(i, j));
446
447	i = j + 1;
448	if(i >= path.length()) return v.toArray(new String[v.size()]);
449	j = path.indexOf('/', i);
450	}
451
452	return null;
453	}
454
455	public static String
456	getParentDirectory(String path) {
457	if(path == null \|\| path.length() == 0) return null;
458	if(path.charAt(0) != '/') return null;
459	if(path.length() == 1) return null;
460
461	if(path.charAt(path.length() - 1) == '/') {
462	path = path.substring(0, path.length() - 1);
463	}
464
465	int i = path.lastIndexOf('/');
466	if(i == 0) return "/";
467	return path.substring(0, i);
468	}
469
470	/**
471	* @param l A listener which will be notified when the operation is completed.
472	*/
473	public void
474	loadPath(String path, final ActionListener l) {
475	// TODO: This method is lazily implemented. Should be optimized.
476	final String[] dirs = getDirectoryPath(path);
477	if(dirs == null) {
478	l.actionPerformed(null);
479	return;
480	}
481
482	final ActionListener listener = new ActionListener() {
483	public void
484	actionPerformed(ActionEvent e) {
485	String s = "";
486	DbDirectoryTreeNode node = null;
487	for(int i = 0; i < dirs.length; i++) {
488	if(i > 1) s += "/" + dirs[i];
489	else s += dirs[i];
490	node = getNodeByPath(s);
491	if(node == null) {
492	if(l != null) l.actionPerformed(null);
493	return;
494	}
495
496	if(!node.isConnected()) {
497	node.setConnected(true);
498	updateDirectoryContent(node, s, this);
499	return;
500	}
501	}
502
503	if(l != null) l.actionPerformed(null);
504	}
505	};
506
507	listener.actionPerformed(null);
508	}
509
510	private final EventHandler eventHandler = new EventHandler();
511
512	private EventHandler
513	getHandler() { return eventHandler; }
514
515	private class EventHandler implements InstrumentsDbListener {
516	/**
517	* Invoked when the number of instrument
518	* directories in a specific directory has changed.
519	*/
520	public void
521	directoryCountChanged(final InstrumentsDbEvent e) {
522	SwingUtilities.invokeLater(new Runnable() {
523	public void
524	run() {
525	DbDirectoryTreeNode node = getNodeByPath(e.getPathName());
526	if(node == null) {
527	return;
528	}
529	if(!node.isConnected()) {
530	return;
531	}
532
533	updateDirectoryContent(node, e.getPathName());
534	}
535	});
536	}
537
538	/**
539	* Invoked when the settings of an instrument directory are changed.
540	*/
541	public void
542	directoryInfoChanged(final InstrumentsDbEvent e) {
543	SwingUtilities.invokeLater(new Runnable() {
544	public void
545	run() { updateDirectoryInfo(e); }
546	});
547	}
548
549	private void
550	updateDirectoryInfo(InstrumentsDbEvent e) {
551	final DbDirectoryTreeNode node = getNodeByPath(e.getPathName());
552	if(node == null) return;
553
554	final InstrumentsDb.GetDrectory t =
555	new InstrumentsDb.GetDrectory(e.getPathName());
556
557	t.addTaskListener(new TaskListener() {
558	public void
559	taskPerformed(TaskEvent e) {
560	if(t.doneWithErrors()) return;
561	if(node.getParent() != null) {
562	node.getParent().updateDirectory(t.getResult());
563	fireNodeChanged(node, node.getParent().getIndex(node));
564	}
565	}
566	});
567
568	CC.getTaskQueue().add(t);
569	}
570
571	/**
572	* Invoked when an instrument directory is renamed.
573	*/
574	public void
575	directoryNameChanged(final InstrumentsDbEvent e) {
576	SwingUtilities.invokeLater(new Runnable() {
577	public void
578	run() { directoryRenamed(e); }
579	});
580	}
581
582	private void
583	directoryRenamed(InstrumentsDbEvent e) {
584	DbDirectoryTreeNode node = getNodeByPath(e.getPathName());
585	if(node == null) {
586	// If the directory is renamed by this frontend the
587	// directory should already be with the new name
588	String s = getParentDirectory(e.getPathName());
589	if(s.length() == 1) s += e.getNewName();
590	else s += "/" + e.getNewName();
591	node = getNodeByPath(s);
592	}
593	if(node == null \|\| node.getParent() == null) {
594	CC.getLogger().warning("Invalid path: " + e.getPathName());
595	return;
596	}
597
598	node.getInfo().setName(e.getNewName());
599	DbDirectoryTreeNode parent = node.getParent();
600
601	int i = parent.getIndex(node);
602	parent.removeDirectory(i);
603	fireNodeRemoved(parent, node, i);
604
605	parent.addDirectory(node);
606	fireNodeInserted(node, parent.getIndex(node));
607	}
608
609	/**
610	* Invoked when the number of instruments
611	* in a specific directory has changed.
612	*/
613	public void
614	instrumentCountChanged(final InstrumentsDbEvent e) {
615	SwingUtilities.invokeLater(new Runnable() {
616	public void
617	run() {
618	DbDirectoryTreeNode node = getNodeByPath(e.getPathName());
619	if(node == null) {
620	return;
621	}
622	if(!node.isConnected()) {
623	return;
624	}
625
626	updateDirectoryContent(node, e.getPathName());
627	}
628	});
629	}
630
631	/**
632	* Invoked when the settings of an instrument are changed.
633	*/
634	public void
635	instrumentInfoChanged(final InstrumentsDbEvent e) {
636	SwingUtilities.invokeLater(new Runnable() {
637	public void
638	run() { updateInstrumentInfo(e); }
639	});
640	}
641
642	/**
643	* Invoked when an instrument is renamed.
644	*/
645	public void
646	instrumentNameChanged(final InstrumentsDbEvent e) {
647	SwingUtilities.invokeLater(new Runnable() {
648	public void
649	run() { instrumentRenamed(e); }
650	});
651	}
652
653	private void
654	updateInstrumentInfo(InstrumentsDbEvent e) {
655	String dir = getParentDirectory(e.getPathName());
656	final DbDirectoryTreeNode node = getNodeByPath(dir);
657	if(node == null) return;
658	if(!node.isConnected()) return;
659
660	final InstrumentsDb.GetInstrument t =
661	new InstrumentsDb.GetInstrument(e.getPathName());
662
663	t.addTaskListener(new TaskListener() {
664	public void
665	taskPerformed(TaskEvent e) {
666	if(t.doneWithErrors()) return;
667	node.updateInstrument(t.getResult());
668	}
669	});
670
671	CC.getTaskQueue().add(t);
672	}
673
674	private void
675	instrumentRenamed(InstrumentsDbEvent e) {
676	String dir = getParentDirectory(e.getPathName());
677	DbDirectoryTreeNode node = getNodeByPath(dir);
678	if(node == null) return;
679
680	String instr = e.getPathName();
681	int i = instr.lastIndexOf('/');
682	if(i != -1 && i < instr.length() - 1) instr = instr.substring(i + 1);
683	else return;
684
685	DbInstrumentInfo info = node.getInstrument(instr);
686
687	if(info == null) {
688	// If the instrument is renamed by this frontend the
689	// instrument should already be with the new name
690	info = node.getInstrument(e.getNewName());
691	}
692	if(info == null) {
693	CC.getLogger().warning("Invalid path: " + e.getPathName());
694	return;
695	}
696
697	info.setName(e.getNewName());
698	node.removeInstrument(node.getInstrumentIndex(info));
699	node.addInstrument(info);
700	}
701
702	/** Invoked when the status of particular job has changed. */
703	public void
704	jobStatusChanged(InstrumentsDbEvent e) { }
705	}
706	}