jsampler/view/DbDirectoryTreeNode.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.util.Enumeration;
import java.util.Vector;

import javax.swing.tree.TreeNode;

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 DbDirectoryTreeNode implements TreeNode {
        private DbDirectoryTreeNode parent = null;
        private DbDirectoryInfo info;
        private Vector<DbDirectoryTreeNode> dirs = new Vector<DbDirectoryTreeNode>();
        private Vector<DbInstrumentInfo> instrs = new Vector<DbInstrumentInfo>();
        private boolean connected = false;
        private boolean detachedNode = false;
        
        private final Vector<InstrumentsDbListener> listeners = new Vector<InstrumentsDbListener>();
        
        
        /** Creates a new instance of <code>DbDirectoryTreeNode</code>. */
        public
        DbDirectoryTreeNode(DbDirectoryInfo info) {
                this.info = info;
        }
        
        /**
         * Registers the specified listener for receiving event messages.
         * @param l The <code>InstrumentsDbListener</code> to register.
         */
        public void
        addInstrumentsDbListener(InstrumentsDbListener l) {
                listeners.add(l);
        }
        
        /**
         * Removes the specified listener.
         * @param l The <code>InstrumentsDbListener</code> to remove.
         */
        public void
        removeInstrumentsDbListener(InstrumentsDbListener l) {
                listeners.remove(l);
        }
        
        public DbDirectoryInfo
        getInfo() { return info; }
        
        public void
        setInfo(DbDirectoryInfo info) { this.info = info; }
        
        /**
         * Renames this node.
         * Also updates the paths of all children.
         */
        protected void
        setName(String newName) {
                getInfo().setName(newName);
                for(DbInstrumentInfo i : instrs) {
                        i.setDirectoryPath(getInfo().getDirectoryPath());
                }
                
                for(DbDirectoryTreeNode n : dirs) n.updateDirectoryPaths();
        }
        
        /**
         * Invoked when the name of a parent node is changed.
         */
        protected void
        updateDirectoryPaths() {
                getInfo().setParentDirectoryPath(parent.getInfo().getDirectoryPath());
                
                for(DbInstrumentInfo i : instrs) {
                        i.setDirectoryPath(getInfo().getDirectoryPath());
                }
                
                for(DbDirectoryTreeNode n : dirs) n.updateDirectoryPaths();
        }
        
        // Tree node model methods
        public DbDirectoryTreeNode
        getChildAt(int index) { return dirs.get(index); }
        
        public int
        getChildCount() { return dirs.size(); }
        
        public DbDirectoryTreeNode
        getParent() { return parent; }
        
        public int
        getIndex(TreeNode node) { return dirs.indexOf(node); }
        
        public boolean
        getAllowsChildren() { return true; }
        
        public boolean
        isLeaf() { return false; }
        
        public Enumeration
        children() { return dirs.elements(); }
        ///////
        
        public void
        setParent(DbDirectoryTreeNode parent) { this.parent = parent; }
        
        public void
        addDirectory(DbDirectoryTreeNode child) {
                addDirectory(child, true);
        }
        
        private void
        addDirectory(DbDirectoryTreeNode child, boolean doNotify) {
                for(int i = 0; i < dirs.size(); i++) {
                        String s = dirs.get(i).getInfo().toString();
                        if(s.compareToIgnoreCase(child.getInfo().toString()) < 0) continue;
                        
                        dirs.insertElementAt(child, i);
                        child.setParent(this);
                        fireDirectoryCountChanged();
                        return;
                }
                
                dirs.add(child);
                child.setParent(this);
                if(doNotify) fireDirectoryCountChanged();
        }
        
        public void
        addDirectories(DbDirectoryTreeNode[] children) {
                if(children == null || children.length == 0) return;
                for(DbDirectoryTreeNode n : children) addDirectory(n, false);
                fireDirectoryCountChanged();
        }
        
        public void
        removeDirectory(int index) {
                DbDirectoryTreeNode node = dirs.remove(index);
                node.setParent(null);
                fireDirectoryCountChanged();
        }
        
        public void
        removeDirectoryByPathName(String path) {
                if(path == null) return;
                
                for(DbDirectoryTreeNode n : dirs) {
                        if(path.equals(n.getInfo().getDirectoryPath())) {
                                dirs.removeElement(n);
                                return;
                        }
                }
        }
        
        public void
        removeInstrumentByPathName(String path) {
                if(path == null) return;
                
                for(DbInstrumentInfo info : instrs) {
                        if(path.equals(info.getInstrumentPath())) {
                                instrs.removeElement(info);
                                return;
                        }
                }
        }
        
        public void
        removeAllDirectories() {
                dirs.removeAllElements();
                fireDirectoryCountChanged();
        }
        
        public void
        updateDirectory(DbDirectoryInfo info) {
                for(int i = 0; i < dirs.size(); i++) {
                        if(dirs.get(i).getInfo().getName().equals(info.getName())) {
                                dirs.get(i).setInfo(info);
                                fireDirectoryInfoChanged(info.getDirectoryPath());
                                return;
                        }
                }
        }
        
        public void
        addInstrument(DbInstrumentInfo info) {
                instrs.add(info);
                fireInstrumentCountChanged();
        }
        
        public void
        addInstruments(DbInstrumentInfo[] infos) {
                if(infos == null || infos.length == 0) return;
                for(DbInstrumentInfo i : infos) instrs.add(i);
                fireInstrumentCountChanged();
        }
        
        public void
        removeAllInstruments() {
                instrs.removeAllElements();
                fireInstrumentCountChanged();
        }
        
        public void
        updateInstrument(DbInstrumentInfo info) {
                for(int i = 0; i < instrs.size(); i++) {
                        if(instrs.get(i).getName().equals(info.getName())) {
                                instrs.setElementAt(info, i);
                                fireInstrumentInfoChanged(info.getInstrumentPath());
                                return;
                        }
                }
        }
        
        public DbInstrumentInfo
        getInstrumentAt(int index) { return instrs.get(index); }
        
        public int
        getInstrumentCount() { return instrs.size(); }
        
        public int
        getInstrumentIndex(DbInstrumentInfo instr) { return instrs.indexOf(instr); }
        
        public void
        removeInstrument(int index) {
                instrs.remove(index);
                fireInstrumentCountChanged();
        }
        
        /**
         * Gets the instrument with the specified name.
         * @param instrName The name of the instrument to return.
         * @return The instrument with the specified name or <code>null</code>
         * if there is no instrument with the specified name in this directory.
         */
        public DbInstrumentInfo
        getInstrument(String instrName) {
                for(int i = 0; i < getInstrumentCount(); i++) {
                        if(instrName.equals(getInstrumentAt(i).getName())) {
                                return getInstrumentAt(i);
                        }
                }
                
                return null;
        }
        
        public boolean
        isConnected() { return connected; }
        
        public void
        setConnected(boolean b) { connected = b; }
        
        /**
         * Determines whether the node is part of a tree or not.
         * The default value is <code>false</code>.
         */
        public boolean
        isDetached() { return detachedNode; }
        
        /**
         * Sets whether the node is part of a tree or not.
         */
        public void
        setDetached(boolean b) { detachedNode = b; }
        
        public String
        toString() { return info.getName(); }
        
        private void
        fireDirectoryCountChanged() {
                String s = getInfo() == null ? null : getInfo().getDirectoryPath();
                InstrumentsDbEvent e = new InstrumentsDbEvent(this, s);
                for(InstrumentsDbListener l : listeners) l.directoryCountChanged(e);
        }
        
        private void
        fireDirectoryInfoChanged(String dir) {
                InstrumentsDbEvent e = new InstrumentsDbEvent(this, dir);
                for(InstrumentsDbListener l : listeners) l.directoryInfoChanged(e);
        }
        
        private void
        fireInstrumentCountChanged() {
                String s = getInfo() == null ? null : getInfo().getDirectoryPath();
                InstrumentsDbEvent e = new InstrumentsDbEvent(this, s);
                for(InstrumentsDbListener l : listeners) l.instrumentCountChanged(e);
        }
        
        private void
        fireInstrumentInfoChanged(String instr) {
                InstrumentsDbEvent e = new InstrumentsDbEvent(this, instr);
                for(InstrumentsDbListener l : listeners) l.instrumentInfoChanged(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.util.Enumeration;
26	import java.util.Vector;
27
28	import javax.swing.tree.TreeNode;
29
30	import org.linuxsampler.lscp.DbDirectoryInfo;
31	import org.linuxsampler.lscp.DbInstrumentInfo;
32
33	import org.linuxsampler.lscp.event.InstrumentsDbEvent;
34	import org.linuxsampler.lscp.event.InstrumentsDbListener;
35
36	/**
37	*
38	* @author Grigor Iliev
39	*/
40	public class DbDirectoryTreeNode implements TreeNode {
41	private DbDirectoryTreeNode parent = null;
42	private DbDirectoryInfo info;
43	private Vector<DbDirectoryTreeNode> dirs = new Vector<DbDirectoryTreeNode>();
44	private Vector<DbInstrumentInfo> instrs = new Vector<DbInstrumentInfo>();
45	private boolean connected = false;
46	private boolean detachedNode = false;
47
48	private final Vector<InstrumentsDbListener> listeners = new Vector<InstrumentsDbListener>();
49
50
51	/** Creates a new instance of <code>DbDirectoryTreeNode</code>. */
52	public
53	DbDirectoryTreeNode(DbDirectoryInfo info) {
54	this.info = info;
55	}
56
57	/**
58	* Registers the specified listener for receiving event messages.
59	* @param l The <code>InstrumentsDbListener</code> to register.
60	*/
61	public void
62	addInstrumentsDbListener(InstrumentsDbListener l) {
63	listeners.add(l);
64	}
65
66	/**
67	* Removes the specified listener.
68	* @param l The <code>InstrumentsDbListener</code> to remove.
69	*/
70	public void
71	removeInstrumentsDbListener(InstrumentsDbListener l) {
72	listeners.remove(l);
73	}
74
75	public DbDirectoryInfo
76	getInfo() { return info; }
77
78	public void
79	setInfo(DbDirectoryInfo info) { this.info = info; }
80
81	/**
82	* Renames this node.
83	* Also updates the paths of all children.
84	*/
85	protected void
86	setName(String newName) {
87	getInfo().setName(newName);
88	for(DbInstrumentInfo i : instrs) {
89	i.setDirectoryPath(getInfo().getDirectoryPath());
90	}
91
92	for(DbDirectoryTreeNode n : dirs) n.updateDirectoryPaths();
93	}
94
95	/**
96	* Invoked when the name of a parent node is changed.
97	*/
98	protected void
99	updateDirectoryPaths() {
100	getInfo().setParentDirectoryPath(parent.getInfo().getDirectoryPath());
101
102	for(DbInstrumentInfo i : instrs) {
103	i.setDirectoryPath(getInfo().getDirectoryPath());
104	}
105
106	for(DbDirectoryTreeNode n : dirs) n.updateDirectoryPaths();
107	}
108
109	// Tree node model methods
110	public DbDirectoryTreeNode
111	getChildAt(int index) { return dirs.get(index); }
112
113	public int
114	getChildCount() { return dirs.size(); }
115
116	public DbDirectoryTreeNode
117	getParent() { return parent; }
118
119	public int
120	getIndex(TreeNode node) { return dirs.indexOf(node); }
121
122	public boolean
123	getAllowsChildren() { return true; }
124
125	public boolean
126	isLeaf() { return false; }
127
128	public Enumeration
129	children() { return dirs.elements(); }
130	///////
131
132	public void
133	setParent(DbDirectoryTreeNode parent) { this.parent = parent; }
134
135	public void
136	addDirectory(DbDirectoryTreeNode child) {
137	addDirectory(child, true);
138	}
139
140	private void
141	addDirectory(DbDirectoryTreeNode child, boolean doNotify) {
142	for(int i = 0; i < dirs.size(); i++) {
143	String s = dirs.get(i).getInfo().toString();
144	if(s.compareToIgnoreCase(child.getInfo().toString()) < 0) continue;
145
146	dirs.insertElementAt(child, i);
147	child.setParent(this);
148	fireDirectoryCountChanged();
149	return;
150	}
151
152	dirs.add(child);
153	child.setParent(this);
154	if(doNotify) fireDirectoryCountChanged();
155	}
156
157	public void
158	addDirectories(DbDirectoryTreeNode[] children) {
159	if(children == null \|\| children.length == 0) return;
160	for(DbDirectoryTreeNode n : children) addDirectory(n, false);
161	fireDirectoryCountChanged();
162	}
163
164	public void
165	removeDirectory(int index) {
166	DbDirectoryTreeNode node = dirs.remove(index);
167	node.setParent(null);
168	fireDirectoryCountChanged();
169	}
170
171	public void
172	removeDirectoryByPathName(String path) {
173	if(path == null) return;
174
175	for(DbDirectoryTreeNode n : dirs) {
176	if(path.equals(n.getInfo().getDirectoryPath())) {
177	dirs.removeElement(n);
178	return;
179	}
180	}
181	}
182
183	public void
184	removeInstrumentByPathName(String path) {
185	if(path == null) return;
186
187	for(DbInstrumentInfo info : instrs) {
188	if(path.equals(info.getInstrumentPath())) {
189	instrs.removeElement(info);
190	return;
191	}
192	}
193	}
194
195	public void
196	removeAllDirectories() {
197	dirs.removeAllElements();
198	fireDirectoryCountChanged();
199	}
200
201	public void
202	updateDirectory(DbDirectoryInfo info) {
203	for(int i = 0; i < dirs.size(); i++) {
204	if(dirs.get(i).getInfo().getName().equals(info.getName())) {
205	dirs.get(i).setInfo(info);
206	fireDirectoryInfoChanged(info.getDirectoryPath());
207	return;
208	}
209	}
210	}
211
212	public void
213	addInstrument(DbInstrumentInfo info) {
214	instrs.add(info);
215	fireInstrumentCountChanged();
216	}
217
218	public void
219	addInstruments(DbInstrumentInfo[] infos) {
220	if(infos == null \|\| infos.length == 0) return;
221	for(DbInstrumentInfo i : infos) instrs.add(i);
222	fireInstrumentCountChanged();
223	}
224
225	public void
226	removeAllInstruments() {
227	instrs.removeAllElements();
228	fireInstrumentCountChanged();
229	}
230
231	public void
232	updateInstrument(DbInstrumentInfo info) {
233	for(int i = 0; i < instrs.size(); i++) {
234	if(instrs.get(i).getName().equals(info.getName())) {
235	instrs.setElementAt(info, i);
236	fireInstrumentInfoChanged(info.getInstrumentPath());
237	return;
238	}
239	}
240	}
241
242	public DbInstrumentInfo
243	getInstrumentAt(int index) { return instrs.get(index); }
244
245	public int
246	getInstrumentCount() { return instrs.size(); }
247
248	public int
249	getInstrumentIndex(DbInstrumentInfo instr) { return instrs.indexOf(instr); }
250
251	public void
252	removeInstrument(int index) {
253	instrs.remove(index);
254	fireInstrumentCountChanged();
255	}
256
257	/**
258	* Gets the instrument with the specified name.
259	* @param instrName The name of the instrument to return.
260	* @return The instrument with the specified name or <code>null</code>
261	* if there is no instrument with the specified name in this directory.
262	*/
263	public DbInstrumentInfo
264	getInstrument(String instrName) {
265	for(int i = 0; i < getInstrumentCount(); i++) {
266	if(instrName.equals(getInstrumentAt(i).getName())) {
267	return getInstrumentAt(i);
268	}
269	}
270
271	return null;
272	}
273
274	public boolean
275	isConnected() { return connected; }
276
277	public void
278	setConnected(boolean b) { connected = b; }
279
280	/**
281	* Determines whether the node is part of a tree or not.
282	* The default value is <code>false</code>.
283	*/
284	public boolean
285	isDetached() { return detachedNode; }
286
287	/**
288	* Sets whether the node is part of a tree or not.
289	*/
290	public void
291	setDetached(boolean b) { detachedNode = b; }
292
293	public String
294	toString() { return info.getName(); }
295
296	private void
297	fireDirectoryCountChanged() {
298	String s = getInfo() == null ? null : getInfo().getDirectoryPath();
299	InstrumentsDbEvent e = new InstrumentsDbEvent(this, s);
300	for(InstrumentsDbListener l : listeners) l.directoryCountChanged(e);
301	}
302
303	private void
304	fireDirectoryInfoChanged(String dir) {
305	InstrumentsDbEvent e = new InstrumentsDbEvent(this, dir);
306	for(InstrumentsDbListener l : listeners) l.directoryInfoChanged(e);
307	}
308
309	private void
310	fireInstrumentCountChanged() {
311	String s = getInfo() == null ? null : getInfo().getDirectoryPath();
312	InstrumentsDbEvent e = new InstrumentsDbEvent(this, s);
313	for(InstrumentsDbListener l : listeners) l.instrumentCountChanged(e);
314	}
315
316	private void
317	fireInstrumentInfoChanged(String instr) {
318	InstrumentsDbEvent e = new InstrumentsDbEvent(this, instr);
319	for(InstrumentsDbListener l : listeners) l.instrumentInfoChanged(e);
320	}
321	}