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; }
        
        // 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	iliev	1204	/*
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			// Tree node model methods
82			public DbDirectoryTreeNode
83			getChildAt(int index) { return dirs.get(index); }
84
85			public int
86			getChildCount() { return dirs.size(); }
87
88			public DbDirectoryTreeNode
89			getParent() { return parent; }
90
91			public int
92			getIndex(TreeNode node) { return dirs.indexOf(node); }
93
94			public boolean
95			getAllowsChildren() { return true; }
96
97			public boolean
98			isLeaf() { return false; }
99
100			public Enumeration
101			children() { return dirs.elements(); }
102			///////
103
104			public void
105			setParent(DbDirectoryTreeNode parent) { this.parent = parent; }
106
107			public void
108			addDirectory(DbDirectoryTreeNode child) {
109			addDirectory(child, true);
110			}
111
112			private void
113			addDirectory(DbDirectoryTreeNode child, boolean doNotify) {
114			for(int i = 0; i < dirs.size(); i++) {
115			String s = dirs.get(i).getInfo().toString();
116			if(s.compareToIgnoreCase(child.getInfo().toString()) < 0) continue;
117
118			dirs.insertElementAt(child, i);
119			child.setParent(this);
120			fireDirectoryCountChanged();
121			return;
122			}
123
124			dirs.add(child);
125			child.setParent(this);
126			if(doNotify) fireDirectoryCountChanged();
127			}
128
129			public void
130			addDirectories(DbDirectoryTreeNode[] children) {
131			if(children == null \|\| children.length == 0) return;
132			for(DbDirectoryTreeNode n : children) addDirectory(n, false);
133			fireDirectoryCountChanged();
134			}
135
136			public void
137			removeDirectory(int index) {
138			DbDirectoryTreeNode node = dirs.remove(index);
139			node.setParent(null);
140			fireDirectoryCountChanged();
141			}
142
143			public void
144			removeDirectoryByPathName(String path) {
145			if(path == null) return;
146
147			for(DbDirectoryTreeNode n : dirs) {
148			if(path.equals(n.getInfo().getDirectoryPath())) {
149			dirs.removeElement(n);
150			return;
151			}
152			}
153			}
154
155			public void
156			removeInstrumentByPathName(String path) {
157			if(path == null) return;
158
159			for(DbInstrumentInfo info : instrs) {
160			if(path.equals(info.getInstrumentPath())) {
161			instrs.removeElement(info);
162			return;
163			}
164			}
165			}
166
167			public void
168			removeAllDirectories() {
169			dirs.removeAllElements();
170			fireDirectoryCountChanged();
171			}
172
173			public void
174			updateDirectory(DbDirectoryInfo info) {
175			for(int i = 0; i < dirs.size(); i++) {
176			if(dirs.get(i).getInfo().getName().equals(info.getName())) {
177			dirs.get(i).setInfo(info);
178			fireDirectoryInfoChanged(info.getDirectoryPath());
179			return;
180			}
181			}
182			}
183
184			public void
185			addInstrument(DbInstrumentInfo info) {
186			instrs.add(info);
187			fireInstrumentCountChanged();
188			}
189
190			public void
191			addInstruments(DbInstrumentInfo[] infos) {
192			if(infos == null \|\| infos.length == 0) return;
193			for(DbInstrumentInfo i : infos) instrs.add(i);
194			fireInstrumentCountChanged();
195			}
196
197			public void
198			removeAllInstruments() {
199			instrs.removeAllElements();
200			fireInstrumentCountChanged();
201			}
202
203			public void
204			updateInstrument(DbInstrumentInfo info) {
205			for(int i = 0; i < instrs.size(); i++) {
206			if(instrs.get(i).getName().equals(info.getName())) {
207			instrs.setElementAt(info, i);
208			fireInstrumentInfoChanged(info.getInstrumentPath());
209			return;
210			}
211			}
212			}
213
214			public DbInstrumentInfo
215			getInstrumentAt(int index) { return instrs.get(index); }
216
217			public int
218			getInstrumentCount() { return instrs.size(); }
219
220			public int
221			getInstrumentIndex(DbInstrumentInfo instr) { return instrs.indexOf(instr); }
222
223			public void
224			removeInstrument(int index) {
225			instrs.remove(index);
226			fireInstrumentCountChanged();
227			}
228
229			/**
230			* Gets the instrument with the specified name.
231			* @param instrName The name of the instrument to return.
232			* @return The instrument with the specified name or <code>null</code>
233			* if there is no instrument with the specified name in this directory.
234			*/
235			public DbInstrumentInfo
236			getInstrument(String instrName) {
237			for(int i = 0; i < getInstrumentCount(); i++) {
238			if(instrName.equals(getInstrumentAt(i).getName())) {
239			return getInstrumentAt(i);
240			}
241			}
242
243			return null;
244			}
245
246			public boolean
247			isConnected() { return connected; }
248
249			public void
250			setConnected(boolean b) { connected = b; }
251
252			/**
253			* Determines whether the node is part of a tree or not.
254			* The default value is <code>false</code>.
255			*/
256			public boolean
257			isDetached() { return detachedNode; }
258
259			/**
260			* Sets whether the node is part of a tree or not.
261			*/
262			public void
263			setDetached(boolean b) { detachedNode = b; }
264
265			public String
266			toString() { return info.getName(); }
267
268			private void
269			fireDirectoryCountChanged() {
270			String s = getInfo() == null ? null : getInfo().getDirectoryPath();
271			InstrumentsDbEvent e = new InstrumentsDbEvent(this, s);
272			for(InstrumentsDbListener l : listeners) l.directoryCountChanged(e);
273			}
274
275			private void
276			fireDirectoryInfoChanged(String dir) {
277			InstrumentsDbEvent e = new InstrumentsDbEvent(this, dir);
278			for(InstrumentsDbListener l : listeners) l.directoryInfoChanged(e);
279			}
280
281			private void
282			fireInstrumentCountChanged() {
283			String s = getInfo() == null ? null : getInfo().getDirectoryPath();
284			InstrumentsDbEvent e = new InstrumentsDbEvent(this, s);
285			for(InstrumentsDbListener l : listeners) l.instrumentCountChanged(e);
286			}
287
288			private void
289			fireInstrumentInfoChanged(String instr) {
290			InstrumentsDbEvent e = new InstrumentsDbEvent(this, instr);
291			for(InstrumentsDbListener l : listeners) l.instrumentInfoChanged(e);
292			}
293			}