jsampler/view/SamplerTreeModel.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2011 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 javax.swing.event.TreeModelEvent;
import javax.swing.tree.TreePath;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;

import org.jsampler.AudioDeviceModel;
import org.jsampler.CC;
import org.jsampler.EffectChain;
import org.jsampler.event.AudioDeviceAdapter;
import org.jsampler.event.AudioDeviceEvent;
import org.jsampler.event.EffectChainEvent;
import org.jsampler.event.EffectChainListener;
import org.jsampler.event.ListEvent;
import org.jsampler.event.ListListener;

import org.linuxsampler.lscp.Effect;
import org.linuxsampler.lscp.EffectInstance;

import static org.jsampler.JSI18n.i18n;

/**
 *
 * @author Grigor Iliev
 */
public class SamplerTreeModel implements TreeModel {
        private final SamplerTreeNode root = new SamplerTreeNode(this);
        private ArrayList<TreeModelListener> listeners = new ArrayList<TreeModelListener>();
        
        private final AudioDevicesTreeNode audioDevices;
        private final InternalEffectsTreeNode internalEffects;
        
        public
        SamplerTreeModel() {
                audioDevices = new AudioDevicesTreeNode(this, root);
                root.addChild(audioDevices);
                
                for(AudioDeviceModel a : CC.getSamplerModel().getAudioDevices()) {
                        audioDevices.addChild(new AudioDeviceTreeNode(this, audioDevices, a));
                        a.addAudioDeviceListener(getHandler());
                }
                
                CC.getSamplerModel().addAudioDeviceListListener(getHandler());
                
                internalEffects = new InternalEffectsTreeNode(this, root);
                root.addChild(internalEffects);
                for(int i = 0; i < CC.getSamplerModel().getEffects().getEffectCount(); i++) {
                        Effect fx = CC.getSamplerModel().getEffects().getEffect(i);
                        internalEffects.addChild(new InternalEffectTreeNode(internalEffects, fx));
                }
        }
        
        // Tree model methods
        @Override
        public void
        addTreeModelListener(TreeModelListener l) {
                listeners.add(l);
        }
        
        @Override
        public void
        removeTreeModelListener(TreeModelListener l) {
                listeners.remove(l);
        }
        
        @Override
        public Object
        getChild(Object parent, int index) {
                return ((TreeNode)parent).getChildAt(index);
        }
        
        @Override
        public int
        getChildCount(Object parent) {
                return ((TreeNode)parent).getChildCount();
        }
        
        @Override
        public Object
        getRoot() { return root; }
        
        @Override
        public int
        getIndexOfChild(Object parent, Object child) {
                if(parent == null || child == null) return -1;
                return ((TreeNode)parent).getIndex((TreeNode)child);
        }
        
        @Override
        public boolean
        isLeaf(Object node) { return ((TreeNode)node).isLeaf(); }
        
        @Override
        public void
        valueForPathChanged(TreePath path, Object newValue) {
                
        }
        ///////
        
        protected Object[]
        getPathToRoot(TreeNode 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()]);
        }
        
        private void
        fireNodeInserted(TreeNode 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(TreeNode 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(TreeNode parent, TreeNode 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(TreeNode node) {
                Object[] path = getPathToRoot(node);
                Object[] objs = { node };
                TreeModelEvent e = new TreeModelEvent(this, path);
                for(TreeModelListener l : listeners) {
                        l.treeStructureChanged(e);
                }
        }
        
        
        private final EventHandler eventHandler = new EventHandler();
        
        private EventHandler
        getHandler() { return eventHandler; }
        
        private class EventHandler extends AudioDeviceAdapter implements ListListener<AudioDeviceModel> {
                
        
                /** Invoked when a new entry is added to a list. */
                @Override
                public void
                entryAdded(final ListEvent<AudioDeviceModel> e) {
                        e.getEntry().addAudioDeviceListener(getHandler());
                        AudioDeviceTreeNode node =
                                new AudioDeviceTreeNode(SamplerTreeModel.this, audioDevices, e.getEntry());
                        audioDevices.addChild(node);
                        fireNodeInserted(node, audioDevices.getIndex(node));
                }
        
                /** Invoked when an entry is removed from a list. */
                @Override
                public void
                entryRemoved(ListEvent<AudioDeviceModel> e) {
                        TreeNode node = audioDevices.getChildById(e.getEntry().getDeviceId());
                        int i = audioDevices.getIndex(node);
                        if(i == -1) return;
                        
                        audioDevices.removeChildAt(i);
                        fireNodeRemoved(audioDevices, node, i);
                        
                        e.getEntry().removeAudioDeviceListener(getHandler());
                }
                
                /** Invoked when a new send effect chain is added to the audio device. */
                @Override
                public void
                sendEffectChainAdded(AudioDeviceEvent e) {
                        AudioDeviceTreeNode node = 
                                audioDevices.getChildById(e.getAudioDeviceModel().getDeviceId());
                        
                        if(node == null) {
                                CC.getLogger().warning("Missing audio device node. This is a bug!");
                                return;
                        }
                        
                        SendEffectChainTreeNode child =
                                new SendEffectChainTreeNode(SamplerTreeModel.this, node, e.getEffectChain());
                        node.addChild(child);
                        fireNodeInserted(child, node.getIndex(child));
                }
        
                /** Invoked when when a send effect chain is removed from the audio device. */
                @Override
                public void
                sendEffectChainRemoved(AudioDeviceEvent e) {
                        AudioDeviceTreeNode node = 
                                audioDevices.getChildById(e.getAudioDeviceModel().getDeviceId());
                        
                        if(node == null) {
                                CC.getLogger().warning("Missing audio device node. This is a bug!");
                                return;
                        }
                        
                        SendEffectChainTreeNode child = node.getChildById(e.getEffectChain().getChainId());
                        if(child == null)  {
                                CC.getLogger().warning("Missing send effect chain node. This is a bug!");
                                return;
                        }
                        
                        int idx = node.getIndex(child);
                        node.removeChildAt(idx);
                        fireNodeRemoved(node, child, idx);
                }
        }

        public static class AbstractTreeNode<T extends TreeNode> implements TreeNode {
                protected final SamplerTreeModel treeModel;
                private final TreeNode parent;
                private final Vector<T> children = new Vector<T>();
        
                public
                AbstractTreeNode(SamplerTreeModel treeModel) { this(treeModel, null); }
        
                public
                AbstractTreeNode(SamplerTreeModel treeModel, TreeNode parent) {
                        this.parent = parent;
                        this.treeModel = treeModel;
                }
        
                // Tree node model methods
                @Override
                public T
                getChildAt(int index) { return children.get(index); }
        
                @Override
                public int
                getChildCount() { return children.size(); }
        
                @Override
                public TreeNode
                getParent() { return parent; }
        
                @Override
                public int
                getIndex(TreeNode node) { return children.indexOf(node); }
        
                @Override
                public boolean
                getAllowsChildren() { return true; }
        
                @Override
                public boolean
                isLeaf() { return false; }
        
                @Override
                public Enumeration
                children() { return children.elements(); }
                ///////
        
                public void
                addChild(T child) { children.add(child); }
        
                public T
                removeChildAt(int index) { return children.remove(index); }
        
                public void
                removeAllChildren() { children.removeAllElements(); }
        }

        public static class AbstractTreeLeaf<T extends TreeNode> implements TreeNode {
                private final T parent;
        
                public
                AbstractTreeLeaf() { this(null); }
        
                public
                AbstractTreeLeaf(T parent) {this.parent = parent; }
        
                // Tree node model methods
                @Override
                public TreeNode
                getChildAt(int index) { return null; }
        
                @Override
                public int
                getChildCount() { return 0; }
        
                @Override
                public T
                getParent() { return parent; }
        
                @Override
                public int
                getIndex(TreeNode node) { return -1; }
        
                @Override
                public boolean
                getAllowsChildren() { return false; }
        
                @Override
                public boolean
                isLeaf() { return true; }
        
                @Override
                public Enumeration
                children() { return null; }
                ///////
        }

        public static class SamplerTreeNode extends AbstractTreeNode {
                public
                SamplerTreeNode(SamplerTreeModel treeModel) {
                        super(treeModel);
                }
        
                @Override
                public String
                toString() { return i18n.getLabel("SamplerTreeNode.toString"); }
        }

        public static class AudioDevicesTreeNode extends AbstractTreeNode<AudioDeviceTreeNode> {
                public
                AudioDevicesTreeNode(SamplerTreeModel treeModel, TreeNode parent) {
                        super(treeModel, parent);
                }
        
                public AudioDeviceTreeNode
                getChildById(int audioDeviceId) {
                        for(int i = 0; i < getChildCount(); i++) {
                                if(getChildAt(i).getAudioDeviceId() == audioDeviceId) return getChildAt(i);
                        }
                
                        return null;
                }
        
                @Override
                public String
                toString() { return i18n.getLabel("AudioDevicesTreeNode.toString"); }
        }

        public static class AudioDeviceTreeNode extends AbstractTreeNode<SendEffectChainTreeNode> {
                private final AudioDeviceModel audioDevice;
        
                public
                AudioDeviceTreeNode (
                        SamplerTreeModel treeModel, TreeNode parent, AudioDeviceModel audioDevice
                ) {
                        super(treeModel, parent);
                        this.audioDevice = audioDevice;
                        
                        for(int i = 0; i < audioDevice.getSendEffectChainCount(); i++) {
                                EffectChain chain = audioDevice.getSendEffectChain(i);
                                addChild(new SendEffectChainTreeNode(treeModel, this, chain));
                        }
                }
        
                public AudioDeviceModel
                getAudioDevice() { return audioDevice; }
        
                public int
                getAudioDeviceId() { return audioDevice.getDeviceId(); }
                
                public SendEffectChainTreeNode
                getChildById(int chainId) {
                        for(int i = 0; i < getChildCount(); i++) {
                                if(getChildAt(i).getChainId() == chainId) return getChildAt(i);
                        }
                        
                        return null;
                }
        
                @Override
                public String
                toString() { return i18n.getLabel("AudioDeviceTreeNode.toString", getAudioDeviceId()); }
        }

        public static class SendEffectChainTreeNode extends AbstractTreeNode<EffectInstanceTreeNode>
                                                        implements EffectChainListener {
                private final EffectChain chain;
        
                public
                SendEffectChainTreeNode (
                        SamplerTreeModel treeModel, AudioDeviceTreeNode parent, EffectChain chain
                ) {
                        super(treeModel, parent);
                        this.chain = chain;
                        chain.addAudioDeviceListener(this);
                        updateEffectInstanceList();
                }
                ///////
                
                public EffectChain
                getEffectChain() { return chain; }
                
                public int
                getChainId() { return chain.getChainId(); }
        
                /**
                 * Gets the audio device to which the
                 * send effect chain represented by this tree node belongs.
                 */
                public AudioDeviceModel
                getAudioDevice() { return ((AudioDeviceTreeNode)getParent()).getAudioDevice(); }
        
                @Override
                public String
                toString() { return i18n.getLabel("SendEffectChainTreeNode.toString", chain.getChainId()); }
                
                @Override
                public void
                effectInstanceListChanged(EffectChainEvent e) {
                        updateEffectInstanceList();
                        treeModel.fireNodeStructureChanged(this);
                }
                
                private void
                updateEffectInstanceList() {
                        removeAllChildren();
                        for(int i = 0; i < chain.getEffectInstanceCount(); i++) {
                                EffectInstance ei = chain.getEffectInstance(i);
                                addChild(new EffectInstanceTreeNode(this, ei));
                        }
                        
                        
                }
        }

        public static class EffectInstanceTreeNode extends AbstractTreeLeaf<SendEffectChainTreeNode> {
                private final EffectInstance effectInstance;
                
                public
                EffectInstanceTreeNode(SendEffectChainTreeNode parent, EffectInstance ei) {
                        super(parent);
                        effectInstance = ei;
                }
                
                public int
                getInstanceId() { return effectInstance.getInstanceId(); }
        
                @Override
                public String
                toString() { return effectInstance.getDescription(); }
        }

        public static class InternalEffectsTreeNode extends AbstractTreeNode<InternalEffectTreeNode> {
                public
                InternalEffectsTreeNode(SamplerTreeModel treeModel, TreeNode parent) {
                        super(treeModel, parent);
                }
        
                @Override
                public String
                toString() { return i18n.getLabel("InternalEffectsTreeNode.toString"); }
        }

        public static class InternalEffectTreeNode extends AbstractTreeLeaf {
                private final Effect effect;
                
                public
                InternalEffectTreeNode(TreeNode parent, Effect effect) {
                        super(parent);
                        this.effect = effect;
                }
        
                @Override
                public String
                toString() { return effect.getDescription(); }
        }

}
1	iliev	2192	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4			* Copyright (C) 2011 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			package org.jsampler.view;
23
24			import javax.swing.event.TreeModelEvent;
25			import javax.swing.tree.TreePath;
26			import java.util.ArrayList;
27			import java.util.Enumeration;
28			import java.util.Vector;
29			import javax.swing.event.TreeModelListener;
30			import javax.swing.tree.TreeModel;
31			import javax.swing.tree.TreeNode;
32
33			import org.jsampler.AudioDeviceModel;
34			import org.jsampler.CC;
35			import org.jsampler.EffectChain;
36			import org.jsampler.event.AudioDeviceAdapter;
37			import org.jsampler.event.AudioDeviceEvent;
38			import org.jsampler.event.EffectChainEvent;
39			import org.jsampler.event.EffectChainListener;
40			import org.jsampler.event.ListEvent;
41			import org.jsampler.event.ListListener;
42
43			import org.linuxsampler.lscp.Effect;
44			import org.linuxsampler.lscp.EffectInstance;
45
46			import static org.jsampler.JSI18n.i18n;
47
48			/**
49			*
50			* @author Grigor Iliev
51			*/
52			public class SamplerTreeModel implements TreeModel {
53			private final SamplerTreeNode root = new SamplerTreeNode(this);
54			private ArrayList<TreeModelListener> listeners = new ArrayList<TreeModelListener>();
55
56			private final AudioDevicesTreeNode audioDevices;
57			private final InternalEffectsTreeNode internalEffects;
58
59			public
60			SamplerTreeModel() {
61			audioDevices = new AudioDevicesTreeNode(this, root);
62			root.addChild(audioDevices);
63
64			for(AudioDeviceModel a : CC.getSamplerModel().getAudioDevices()) {
65			audioDevices.addChild(new AudioDeviceTreeNode(this, audioDevices, a));
66			a.addAudioDeviceListener(getHandler());
67			}
68
69			CC.getSamplerModel().addAudioDeviceListListener(getHandler());
70
71			internalEffects = new InternalEffectsTreeNode(this, root);
72			root.addChild(internalEffects);
73			for(int i = 0; i < CC.getSamplerModel().getEffects().getEffectCount(); i++) {
74			Effect fx = CC.getSamplerModel().getEffects().getEffect(i);
75			internalEffects.addChild(new InternalEffectTreeNode(internalEffects, fx));
76			}
77			}
78
79			// Tree model methods
80			@Override
81			public void
82			addTreeModelListener(TreeModelListener l) {
83			listeners.add(l);
84			}
85
86			@Override
87			public void
88			removeTreeModelListener(TreeModelListener l) {
89			listeners.remove(l);
90			}
91
92			@Override
93			public Object
94			getChild(Object parent, int index) {
95			return ((TreeNode)parent).getChildAt(index);
96			}
97
98			@Override
99			public int
100			getChildCount(Object parent) {
101			return ((TreeNode)parent).getChildCount();
102			}
103
104			@Override
105			public Object
106			getRoot() { return root; }
107
108			@Override
109			public int
110			getIndexOfChild(Object parent, Object child) {
111			if(parent == null \|\| child == null) return -1;
112			return ((TreeNode)parent).getIndex((TreeNode)child);
113			}
114
115			@Override
116			public boolean
117			isLeaf(Object node) { return ((TreeNode)node).isLeaf(); }
118
119			@Override
120			public void
121			valueForPathChanged(TreePath path, Object newValue) {
122
123			}
124			///////
125
126			protected Object[]
127			getPathToRoot(TreeNode node) {
128			Vector v = new Vector();
129
130			while(node != null) {
131			v.insertElementAt(node, 0);
132			if(node == getRoot()) break;
133			node = node.getParent();
134			}
135
136			return v.toArray(new Object[v.size()]);
137			}
138
139			private void
140			fireNodeInserted(TreeNode node, int index) {
141			Object[] path = getPathToRoot(node.getParent());
142
143			int[] idxs = { index };
144			Object[] objs = { node };
145			TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
146			for(TreeModelListener l : listeners) {
147			l.treeNodesInserted(e);
148			}
149			}
150
151			private void
152			fireNodeChanged(TreeNode node, int index) {
153			Object[] path = getPathToRoot(node.getParent());
154			int[] idxs = { index };
155			Object[] objs = { node };
156			TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
157			for(TreeModelListener l : listeners) {
158			l.treeNodesChanged(e);
159			}
160			}
161
162			private void
163			fireNodeRemoved(TreeNode parent, TreeNode node, int index) {
164			Object[] path = getPathToRoot(parent);
165			int[] idxs = { index };
166			Object[] objs = { node };
167			TreeModelEvent e = new TreeModelEvent(this, path, idxs, objs);
168			for(int i = listeners.size() - 1; i >=0; i--) {
169			listeners.get(i).treeNodesRemoved(e);
170			}
171			}
172
173			private void
174			fireNodeStructureChanged(TreeNode node) {
175			Object[] path = getPathToRoot(node);
176			Object[] objs = { node };
177			TreeModelEvent e = new TreeModelEvent(this, path);
178			for(TreeModelListener l : listeners) {
179			l.treeStructureChanged(e);
180			}
181			}
182
183
184			private final EventHandler eventHandler = new EventHandler();
185
186			private EventHandler
187			getHandler() { return eventHandler; }
188
189			private class EventHandler extends AudioDeviceAdapter implements ListListener<AudioDeviceModel> {
190
191
192			/** Invoked when a new entry is added to a list. */
193			@Override
194			public void
195			entryAdded(final ListEvent<AudioDeviceModel> e) {
196			e.getEntry().addAudioDeviceListener(getHandler());
197			AudioDeviceTreeNode node =
198			new AudioDeviceTreeNode(SamplerTreeModel.this, audioDevices, e.getEntry());
199			audioDevices.addChild(node);
200			fireNodeInserted(node, audioDevices.getIndex(node));
201			}
202
203			/** Invoked when an entry is removed from a list. */
204			@Override
205			public void
206			entryRemoved(ListEvent<AudioDeviceModel> e) {
207			TreeNode node = audioDevices.getChildById(e.getEntry().getDeviceId());
208			int i = audioDevices.getIndex(node);
209			if(i == -1) return;
210
211			audioDevices.removeChildAt(i);
212			fireNodeRemoved(audioDevices, node, i);
213
214			e.getEntry().removeAudioDeviceListener(getHandler());
215			}
216
217			/** Invoked when a new send effect chain is added to the audio device. */
218			@Override
219			public void
220			sendEffectChainAdded(AudioDeviceEvent e) {
221			AudioDeviceTreeNode node =
222			audioDevices.getChildById(e.getAudioDeviceModel().getDeviceId());
223
224			if(node == null) {
225			CC.getLogger().warning("Missing audio device node. This is a bug!");
226			return;
227			}
228
229			SendEffectChainTreeNode child =
230			new SendEffectChainTreeNode(SamplerTreeModel.this, node, e.getEffectChain());
231			node.addChild(child);
232			fireNodeInserted(child, node.getIndex(child));
233			}
234
235			/** Invoked when when a send effect chain is removed from the audio device. */
236			@Override
237			public void
238			sendEffectChainRemoved(AudioDeviceEvent e) {
239			AudioDeviceTreeNode node =
240			audioDevices.getChildById(e.getAudioDeviceModel().getDeviceId());
241
242			if(node == null) {
243			CC.getLogger().warning("Missing audio device node. This is a bug!");
244			return;
245			}
246
247			SendEffectChainTreeNode child = node.getChildById(e.getEffectChain().getChainId());
248			if(child == null) {
249			CC.getLogger().warning("Missing send effect chain node. This is a bug!");
250			return;
251			}
252
253			int idx = node.getIndex(child);
254			node.removeChildAt(idx);
255			fireNodeRemoved(node, child, idx);
256			}
257			}
258
259			public static class AbstractTreeNode<T extends TreeNode> implements TreeNode {
260			protected final SamplerTreeModel treeModel;
261			private final TreeNode parent;
262			private final Vector<T> children = new Vector<T>();
263
264			public
265			AbstractTreeNode(SamplerTreeModel treeModel) { this(treeModel, null); }
266
267			public
268			AbstractTreeNode(SamplerTreeModel treeModel, TreeNode parent) {
269			this.parent = parent;
270			this.treeModel = treeModel;
271			}
272
273			// Tree node model methods
274			@Override
275			public T
276			getChildAt(int index) { return children.get(index); }
277
278			@Override
279			public int
280			getChildCount() { return children.size(); }
281
282			@Override
283			public TreeNode
284			getParent() { return parent; }
285
286			@Override
287			public int
288			getIndex(TreeNode node) { return children.indexOf(node); }
289
290			@Override
291			public boolean
292			getAllowsChildren() { return true; }
293
294			@Override
295			public boolean
296			isLeaf() { return false; }
297
298			@Override
299			public Enumeration
300			children() { return children.elements(); }
301			///////
302
303			public void
304			addChild(T child) { children.add(child); }
305
306			public T
307			removeChildAt(int index) { return children.remove(index); }
308
309			public void
310			removeAllChildren() { children.removeAllElements(); }
311			}
312
313			public static class AbstractTreeLeaf<T extends TreeNode> implements TreeNode {
314			private final T parent;
315
316			public
317			AbstractTreeLeaf() { this(null); }
318
319			public
320			AbstractTreeLeaf(T parent) {this.parent = parent; }
321
322			// Tree node model methods
323			@Override
324			public TreeNode
325			getChildAt(int index) { return null; }
326
327			@Override
328			public int
329			getChildCount() { return 0; }
330
331			@Override
332			public T
333			getParent() { return parent; }
334
335			@Override
336			public int
337			getIndex(TreeNode node) { return -1; }
338
339			@Override
340			public boolean
341			getAllowsChildren() { return false; }
342
343			@Override
344			public boolean
345			isLeaf() { return true; }
346
347			@Override
348			public Enumeration
349			children() { return null; }
350			///////
351			}
352
353			public static class SamplerTreeNode extends AbstractTreeNode {
354			public
355			SamplerTreeNode(SamplerTreeModel treeModel) {
356			super(treeModel);
357			}
358
359			@Override
360			public String
361			toString() { return i18n.getLabel("SamplerTreeNode.toString"); }
362			}
363
364			public static class AudioDevicesTreeNode extends AbstractTreeNode<AudioDeviceTreeNode> {
365			public
366			AudioDevicesTreeNode(SamplerTreeModel treeModel, TreeNode parent) {
367			super(treeModel, parent);
368			}
369
370			public AudioDeviceTreeNode
371			getChildById(int audioDeviceId) {
372			for(int i = 0; i < getChildCount(); i++) {
373			if(getChildAt(i).getAudioDeviceId() == audioDeviceId) return getChildAt(i);
374			}
375
376			return null;
377			}
378
379			@Override
380			public String
381			toString() { return i18n.getLabel("AudioDevicesTreeNode.toString"); }
382			}
383
384			public static class AudioDeviceTreeNode extends AbstractTreeNode<SendEffectChainTreeNode> {
385			private final AudioDeviceModel audioDevice;
386
387			public
388			AudioDeviceTreeNode (
389			SamplerTreeModel treeModel, TreeNode parent, AudioDeviceModel audioDevice
390			) {
391			super(treeModel, parent);
392			this.audioDevice = audioDevice;
393
394			for(int i = 0; i < audioDevice.getSendEffectChainCount(); i++) {
395			EffectChain chain = audioDevice.getSendEffectChain(i);
396			addChild(new SendEffectChainTreeNode(treeModel, this, chain));
397			}
398			}
399
400			public AudioDeviceModel
401			getAudioDevice() { return audioDevice; }
402
403			public int
404			getAudioDeviceId() { return audioDevice.getDeviceId(); }
405
406			public SendEffectChainTreeNode
407			getChildById(int chainId) {
408			for(int i = 0; i < getChildCount(); i++) {
409			if(getChildAt(i).getChainId() == chainId) return getChildAt(i);
410			}
411
412			return null;
413			}
414
415			@Override
416			public String
417			toString() { return i18n.getLabel("AudioDeviceTreeNode.toString", getAudioDeviceId()); }
418			}
419
420			public static class SendEffectChainTreeNode extends AbstractTreeNode<EffectInstanceTreeNode>
421			implements EffectChainListener {
422			private final EffectChain chain;
423
424			public
425			SendEffectChainTreeNode (
426			SamplerTreeModel treeModel, AudioDeviceTreeNode parent, EffectChain chain
427			) {
428			super(treeModel, parent);
429			this.chain = chain;
430			chain.addAudioDeviceListener(this);
431			updateEffectInstanceList();
432			}
433			///////
434
435			public EffectChain
436			getEffectChain() { return chain; }
437
438			public int
439			getChainId() { return chain.getChainId(); }
440
441			/**
442			* Gets the audio device to which the
443			* send effect chain represented by this tree node belongs.
444			*/
445			public AudioDeviceModel
446			getAudioDevice() { return ((AudioDeviceTreeNode)getParent()).getAudioDevice(); }
447
448			@Override
449			public String
450			toString() { return i18n.getLabel("SendEffectChainTreeNode.toString", chain.getChainId()); }
451
452			@Override
453			public void
454			effectInstanceListChanged(EffectChainEvent e) {
455			updateEffectInstanceList();
456			treeModel.fireNodeStructureChanged(this);
457			}
458
459			private void
460			updateEffectInstanceList() {
461			removeAllChildren();
462			for(int i = 0; i < chain.getEffectInstanceCount(); i++) {
463			EffectInstance ei = chain.getEffectInstance(i);
464			addChild(new EffectInstanceTreeNode(this, ei));
465			}
466
467
468			}
469			}
470
471			public static class EffectInstanceTreeNode extends AbstractTreeLeaf<SendEffectChainTreeNode> {
472			private final EffectInstance effectInstance;
473
474			public
475			EffectInstanceTreeNode(SendEffectChainTreeNode parent, EffectInstance ei) {
476			super(parent);
477			effectInstance = ei;
478			}
479
480			public int
481			getInstanceId() { return effectInstance.getInstanceId(); }
482
483			@Override
484			public String
485			toString() { return effectInstance.getDescription(); }
486			}
487
488			public static class InternalEffectsTreeNode extends AbstractTreeNode<InternalEffectTreeNode> {
489			public
490			InternalEffectsTreeNode(SamplerTreeModel treeModel, TreeNode parent) {
491			super(treeModel, parent);
492			}
493
494			@Override
495			public String
496			toString() { return i18n.getLabel("InternalEffectsTreeNode.toString"); }
497			}
498
499			public static class InternalEffectTreeNode extends AbstractTreeLeaf {
500			private final Effect effect;
501
502			public
503			InternalEffectTreeNode(TreeNode parent, Effect effect) {
504			super(parent);
505			this.effect = effect;
506			}
507
508			@Override
509			public String
510			toString() { return effect.getDescription(); }
511			}
512
513			}