view/std/JSMidiInstrumentTree.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.std;

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

import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JTree;

import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeSelectionModel;

import org.jsampler.CC;
import org.jsampler.HF;
import org.jsampler.MidiInstrument;
import org.jsampler.MidiInstrumentMap;

import org.jsampler.event.MidiInstrumentEvent;
import org.jsampler.event.MidiInstrumentListener;
import org.jsampler.event.MidiInstrumentMapEvent;
import org.jsampler.event.MidiInstrumentMapListener;

import org.linuxsampler.lscp.MidiInstrumentInfo;
import org.linuxsampler.lscp.MidiInstrumentMapInfo;

import static org.jsampler.view.std.StdI18n.i18n;


/**
 *
 * @author Grigor Iliev
 */
public class JSMidiInstrumentTree extends JTree {
        private DefaultTreeModel model;
        private MidiInstrumentMap midiInstrumentMap;
        
        /**
         * Creates a new instance of <code>JSMidiInstrumentTree</code>
         */
        public
        JSMidiInstrumentTree() {
                setRootVisible(false);
                setShowsRootHandles(true);
                setEditable(false);
                
                addMouseListener(new MouseAdapter() {
                        public void
                        mousePressed(MouseEvent e) {
                                if(e.getButton() != e.BUTTON3) return;
                                setSelectionPath(getClosestPathForLocation(e.getX(), e.getY()));
                        }
                        
                        public void
                        mouseClicked(MouseEvent e) {
                                if(e.getButton() != e.BUTTON1) return;
                                if(e.getClickCount() > 1) editSelectedInstrument();
                        }
                });
                
                setMidiInstrumentMap(null);
                
                getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
                ContextMenu contextMenu = new ContextMenu();
                addMouseListener(contextMenu);
                addTreeSelectionListener(contextMenu);
        }
        
        /**
         * Gets the MIDI instrument map that is represented by this MIDI instrument tree.
         * @return The MIDI instrument map that is represented by this MIDI instrument tree.
         */
        public MidiInstrumentMap
        getMidiInstrumentMap() { return midiInstrumentMap; }
        
        /**
         * Sets the MIDI instrument map to be represented by this MIDI instrument tree.
         * @param map The MIDI instrument map to be represented by this MIDI instrument tree.
         */
        public void
        setMidiInstrumentMap(MidiInstrumentMap map) {
                if(getMidiInstrumentMap() != null) {
                        for(MidiInstrument instr : getMidiInstrumentMap().getAllMidiInstruments()) {
                                instr.removeMidiInstrumentListener(getHandler());
                        }
                        
                        getMidiInstrumentMap().removeMidiInstrumentMapListener(getHandler());
                }
                
                midiInstrumentMap = map;
                
                DefaultMutableTreeNode root = new DefaultMutableTreeNode() {
                        public boolean
                        isLeaf() { return false; }
                        
                        public Object
                        getUserObject() { return "/"; }
                };
                
                model = new DefaultTreeModel(root);
                
                if(map != null) {
                        for(MidiInstrument instr : map.getAllMidiInstruments()) {
                                mapInstrument(instr);
                                instr.addMidiInstrumentListener(getHandler());
                        }
                
                        map.addMidiInstrumentMapListener(getHandler());
                }
                
                setEnabled(map != null);
                
                setModel(model);
        }
        
        /**
         * Adds the specified MIDI instrument to this tree.
         * @param instr The MIDI instrument to add.
         */
        public void
        mapInstrument(MidiInstrument instr) {
                MidiBank bank = new MidiBank(instr.getInfo().getMidiBank());
                DefaultMutableTreeNode bankNode = findBank(bank);
                
                if(bankNode == null) {
                        bankNode = new BankTreeNode(bank);
                        
                        model.insertNodeInto (
                                bankNode,
                                (DefaultMutableTreeNode)model.getRoot(),
                                findBankPosition(bank.getID())
                        );
                }
                
                model.insertNodeInto (
                        new InstrTreeNode(instr),
                        bankNode,
                        removeProgram(bankNode, instr.getInfo().getMidiProgram())
                );
        }
        
        /**
         * Removes the specified MIDI instrument from the tree.
         * @param instr The MIDI instrument to remove.
         * @throws IllegalArgumentException If the specified instrument is not found.
         */
        public void
        unmapInstrument(MidiInstrument instr) {
                MidiBank bank = new MidiBank(instr.getInfo().getMidiBank());
                DefaultMutableTreeNode bankNode = findBank(bank);
                
                if(bankNode == null)
                        throw new IllegalArgumentException("Missing MIDI bank: " + bank.getID());
                
                removeProgram(bankNode, instr.getInfo().getMidiProgram());
                if(bankNode.getChildCount() == 0) model.removeNodeFromParent(bankNode);
        }
        
        /**
         * Gets the selected MIDI instrument.
         * @return The selected MIDI instrument, or
         * <code>null</code> if there is no MIDI instrument selected.
         */
        public MidiInstrument
        getSelectedInstrument() {
                if(getSelectionCount() == 0) return null;
                Object obj = getSelectionPath().getLastPathComponent();
                if(!(obj instanceof InstrTreeNode)) return null;
                obj = ((InstrTreeNode)obj).getUserObject();
                return (MidiInstrument)obj;
        }
        
        /**
         * Removes (on the backend side) the selected MIDI instrument or MIDI bank.
         */
        public void
        removeSelectedInstrumentOrBank() {
                if(getSelectionCount() == 0) return;
                
                Object obj = getSelectionPath().getLastPathComponent();
                if(obj instanceof InstrTreeNode) {
                        obj = ((InstrTreeNode)obj).getUserObject();
                        removeInstrument((MidiInstrument)obj);
                } else if(obj instanceof BankTreeNode) {
                        BankTreeNode n = (BankTreeNode)obj;
                        int c = n.getChildCount();
                        if(c > 1) {
                                String s;
                                s = i18n.getMessage("JSMidiInstrumentTree.removeInstruments?", c);
                                if(!HF.showYesNoDialog(CC.getMainFrame(), s)) return;
                        }
                        
                        for(int i = c - 1; i >= 0; i--) {
                                obj = ((InstrTreeNode)n.getChildAt(i)).getUserObject();
                                removeInstrument((MidiInstrument)obj);
                        }
                }
        }
        
        /**
         * Removes (on the backend side) the specified MIDI instrument.
         */
        private void
        removeInstrument(MidiInstrument instr) {
                MidiInstrumentInfo i = instr.getInfo();
                CC.getSamplerModel().unmapBackendMidiInstrument (
                        i.getMapId(), i.getMidiBank(), i.getMidiProgram()
                );
        }
        
        /**
         * Returns the position, where the specified bank should be inserted.
         */
        private int
        findBankPosition(int bankID) {
                DefaultMutableTreeNode root = (DefaultMutableTreeNode)model.getRoot();
                
                for(int i = 0; i < root.getChildCount(); i++) {
                        DefaultMutableTreeNode node = (DefaultMutableTreeNode)root.getChildAt(i);
                        MidiBank bank = (MidiBank)node.getUserObject();
                        if(bank.getID() > bankID) return i;
                }
                
                return root.getChildCount();
        }
        
        /**
         * If there is already an instrument with MIDI program <code>program</code>,
         * those instrument is removed from the tree.
         * @return The position, where the instrument of the specified program should be inserted.
         */
        private int
        removeProgram(DefaultMutableTreeNode bankNode, int program) {
                
                for(int i = 0; i < bankNode.getChildCount(); i++) {
                        DefaultMutableTreeNode n = (DefaultMutableTreeNode)bankNode.getChildAt(i);
                        MidiInstrument instr = (MidiInstrument)n.getUserObject();
                        
                        if(instr.getInfo().getMidiProgram() == program) {
                                model.removeNodeFromParent(n);
                                return i;
                        }
                        
                        if(instr.getInfo().getMidiProgram() > program) return i;
                }
                
                return bankNode.getChildCount();
        }
        
        private DefaultMutableTreeNode 
        findNode(DefaultMutableTreeNode parent, Object obj) {
                for(int i = 0; i < parent.getChildCount(); i++) {
                        DefaultMutableTreeNode node = (DefaultMutableTreeNode)parent.getChildAt(i);
                        if(node.getUserObject().equals(obj)) return node;
                }
                
                return null;
        }
        
        private DefaultMutableTreeNode 
        findBank(Object obj) {
                return findNode((DefaultMutableTreeNode)model.getRoot(), obj);
        }
        
        private DefaultMutableTreeNode
        findInstrument(Object obj) {
                if(obj == null || !(obj instanceof MidiInstrument)) return null;
                MidiInstrument i = (MidiInstrument) obj;
                DefaultMutableTreeNode bank = findBank(new MidiBank(i.getInfo().getMidiBank()));
                if(bank == null) return null;
                return findNode(bank, obj);
        }
        
        
        private class MidiBank {
                int id;
                
                MidiBank(int id) {
                        this.id = id;
                }
                
                public int
                getID() { return id; }
                
                public boolean
                equals(Object obj) {
                        if(obj == null) return false;
                        if(!(obj instanceof MidiBank)) return false;
                        if(getID() == ((MidiBank)obj).getID()) return true;
                        return false;
                }
                
                public String
                toString() { return i18n.getLabel("JSMidiInstrumentTree.MidiBank.name", id); }
        }
        
        protected class BankTreeNode extends DefaultMutableTreeNode {
                BankTreeNode(Object obj) {
                        super(obj);
                }
                
                public void
                setUserObject(Object userObject) {
                        if(userObject instanceof MidiBank) {
                                super.setUserObject(userObject);
                                return;
                        }
                        
                        // If we are here, this means that tree editing occurs.
                        CC.getLogger().info("MidiInstrumentTree: editing not supported");
                }
                
                public boolean
                isLeaf() { return false; }
        }
        
        protected class InstrTreeNode extends DefaultMutableTreeNode {
                InstrTreeNode(Object obj) {
                        super(obj);
                }
                
                public void
                setUserObject(Object userObject) {
                        if(userObject instanceof MidiInstrument) {
                                super.setUserObject(userObject);
                                return;
                        }
                        
                        // If we are here, this means that tree editing occurs.
                        CC.getLogger().info("MidiInstrumentTree: editing not supported");
                }
                
                public boolean
                isLeaf() { return true; }
        }
                
        private void
        editSelectedInstrument() {
                MidiInstrument i = getSelectedInstrument();
                if(i == null) return;
                JSEditMidiInstrumentDlg dlg = new JSEditMidiInstrumentDlg(i.getInfo());
                dlg.setVisible(true);
                
                if(dlg.isCancelled()) return;
                
                MidiInstrumentInfo info = dlg.getInstrument();
                CC.getSamplerModel().mapBackendMidiInstrument (
                        info.getMapId(), info.getMidiBank(), info.getMidiProgram(), info
                );
        }
        
        private final EventHandler eventHandler = new EventHandler();
        
        private EventHandler
        getHandler() { return eventHandler; }
        
        private class EventHandler implements MidiInstrumentListener, MidiInstrumentMapListener {
                
                /** Invoked when a MIDI instrument in a MIDI instrument map is changed. */
                public void
                instrumentInfoChanged(MidiInstrumentEvent e) {
                        DefaultMutableTreeNode n = findInstrument(e.getSource());
                        if(n != null) model.nodeChanged(n);
                }
                
                /** Invoked when the name of MIDI instrument map is changed. */
                public void nameChanged(MidiInstrumentMapEvent e) { }
                
                /** Invoked when an instrument is added to a MIDI instrument map. */
                public void
                instrumentAdded(MidiInstrumentMapEvent e) {
                        e.getInstrument().addMidiInstrumentListener(getHandler());
                        mapInstrument(e.getInstrument());
                        
                }
        
                /** Invoked when an instrument is removed from a MIDI instrument map. */
                public void
                instrumentRemoved(MidiInstrumentMapEvent e) {
                        unmapInstrument(e.getInstrument());
                        e.getInstrument().removeMidiInstrumentListener(getHandler());
                }
        }
        
        class ContextMenu extends MouseAdapter implements TreeSelectionListener {
                private final JPopupMenu cmenu = new JPopupMenu();
                JMenuItem miEdit = new JMenuItem(i18n.getMenuLabel("ContextMenu.edit"));
                
                ContextMenu() {
                        cmenu.add(miEdit);
                        miEdit.addActionListener(new ActionListener() {
                                public void
                                actionPerformed(ActionEvent e) {
                                        editSelectedInstrument();
                                }
                        });
                        
                        JMenuItem mi = new JMenuItem(i18n.getMenuLabel("ContextMenu.delete"));
                        cmenu.add(mi);
                        mi.addActionListener(new ActionListener() {
                                public void
                                actionPerformed(ActionEvent e) {
                                        removeSelectedInstrumentOrBank();
                                }
                        });
                        
                }
                
                public void
                mousePressed(MouseEvent e) {
                        if(e.isPopupTrigger()) show(e);
                }
        
                public void
                mouseReleased(MouseEvent e) {
                        if(e.isPopupTrigger()) show(e);
                }
        
                void
                show(MouseEvent e) {
                        if(getSelectionCount() == 0) return;
                        cmenu.show(e.getComponent(), e.getX(), e.getY());
                }
                
                public void
                valueChanged(TreeSelectionEvent e) {
                        miEdit.setVisible(getSelectedInstrument() != null);
                }
        }
}
1	iliev	1286	/*
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.std;
24
25			import java.awt.event.ActionEvent;
26			import java.awt.event.ActionListener;
27			import java.awt.event.MouseAdapter;
28			import java.awt.event.MouseEvent;
29
30			import javax.swing.JMenuItem;
31			import javax.swing.JPopupMenu;
32			import javax.swing.JTree;
33
34			import javax.swing.event.TreeSelectionEvent;
35			import javax.swing.event.TreeSelectionListener;
36
37			import javax.swing.tree.DefaultMutableTreeNode;
38			import javax.swing.tree.DefaultTreeModel;
39			import javax.swing.tree.TreeSelectionModel;
40
41			import org.jsampler.CC;
42			import org.jsampler.HF;
43			import org.jsampler.MidiInstrument;
44			import org.jsampler.MidiInstrumentMap;
45
46			import org.jsampler.event.MidiInstrumentEvent;
47			import org.jsampler.event.MidiInstrumentListener;
48			import org.jsampler.event.MidiInstrumentMapEvent;
49			import org.jsampler.event.MidiInstrumentMapListener;
50
51			import org.linuxsampler.lscp.MidiInstrumentInfo;
52			import org.linuxsampler.lscp.MidiInstrumentMapInfo;
53
54			import static org.jsampler.view.std.StdI18n.i18n;
55
56
57			/**
58			*
59			* @author Grigor Iliev
60			*/
61			public class JSMidiInstrumentTree extends JTree {
62			private DefaultTreeModel model;
63			private MidiInstrumentMap midiInstrumentMap;
64
65			/**
66			* Creates a new instance of <code>JSMidiInstrumentTree</code>
67			*/
68			public
69			JSMidiInstrumentTree() {
70			setRootVisible(false);
71			setShowsRootHandles(true);
72			setEditable(false);
73
74			addMouseListener(new MouseAdapter() {
75			public void
76			mousePressed(MouseEvent e) {
77			if(e.getButton() != e.BUTTON3) return;
78			setSelectionPath(getClosestPathForLocation(e.getX(), e.getY()));
79			}
80
81			public void
82			mouseClicked(MouseEvent e) {
83			if(e.getButton() != e.BUTTON1) return;
84			if(e.getClickCount() > 1) editSelectedInstrument();
85			}
86			});
87
88			setMidiInstrumentMap(null);
89
90			getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
91			ContextMenu contextMenu = new ContextMenu();
92			addMouseListener(contextMenu);
93			addTreeSelectionListener(contextMenu);
94			}
95
96			/**
97			* Gets the MIDI instrument map that is represented by this MIDI instrument tree.
98			* @return The MIDI instrument map that is represented by this MIDI instrument tree.
99			*/
100			public MidiInstrumentMap
101			getMidiInstrumentMap() { return midiInstrumentMap; }
102
103			/**
104			* Sets the MIDI instrument map to be represented by this MIDI instrument tree.
105			* @param map The MIDI instrument map to be represented by this MIDI instrument tree.
106			*/
107			public void
108			setMidiInstrumentMap(MidiInstrumentMap map) {
109			if(getMidiInstrumentMap() != null) {
110			for(MidiInstrument instr : getMidiInstrumentMap().getAllMidiInstruments()) {
111			instr.removeMidiInstrumentListener(getHandler());
112			}
113
114			getMidiInstrumentMap().removeMidiInstrumentMapListener(getHandler());
115			}
116
117			midiInstrumentMap = map;
118
119			DefaultMutableTreeNode root = new DefaultMutableTreeNode() {
120			public boolean
121			isLeaf() { return false; }
122
123			public Object
124			getUserObject() { return "/"; }
125			};
126
127			model = new DefaultTreeModel(root);
128
129			if(map != null) {
130			for(MidiInstrument instr : map.getAllMidiInstruments()) {
131			mapInstrument(instr);
132			instr.addMidiInstrumentListener(getHandler());
133			}
134
135			map.addMidiInstrumentMapListener(getHandler());
136			}
137
138			setEnabled(map != null);
139
140			setModel(model);
141			}
142
143			/**
144			* Adds the specified MIDI instrument to this tree.
145			* @param instr The MIDI instrument to add.
146			*/
147			public void
148			mapInstrument(MidiInstrument instr) {
149			MidiBank bank = new MidiBank(instr.getInfo().getMidiBank());
150			DefaultMutableTreeNode bankNode = findBank(bank);
151
152			if(bankNode == null) {
153			bankNode = new BankTreeNode(bank);
154
155			model.insertNodeInto (
156			bankNode,
157			(DefaultMutableTreeNode)model.getRoot(),
158			findBankPosition(bank.getID())
159			);
160			}
161
162			model.insertNodeInto (
163			new InstrTreeNode(instr),
164			bankNode,
165			removeProgram(bankNode, instr.getInfo().getMidiProgram())
166			);
167			}
168
169			/**
170			* Removes the specified MIDI instrument from the tree.
171			* @param instr The MIDI instrument to remove.
172			* @throws IllegalArgumentException If the specified instrument is not found.
173			*/
174			public void
175			unmapInstrument(MidiInstrument instr) {
176			MidiBank bank = new MidiBank(instr.getInfo().getMidiBank());
177			DefaultMutableTreeNode bankNode = findBank(bank);
178
179			if(bankNode == null)
180			throw new IllegalArgumentException("Missing MIDI bank: " + bank.getID());
181
182			removeProgram(bankNode, instr.getInfo().getMidiProgram());
183			if(bankNode.getChildCount() == 0) model.removeNodeFromParent(bankNode);
184			}
185
186			/**
187			* Gets the selected MIDI instrument.
188			* @return The selected MIDI instrument, or
189			* <code>null</code> if there is no MIDI instrument selected.
190			*/
191			public MidiInstrument
192			getSelectedInstrument() {
193			if(getSelectionCount() == 0) return null;
194			Object obj = getSelectionPath().getLastPathComponent();
195			if(!(obj instanceof InstrTreeNode)) return null;
196			obj = ((InstrTreeNode)obj).getUserObject();
197			return (MidiInstrument)obj;
198			}
199
200			/**
201			* Removes (on the backend side) the selected MIDI instrument or MIDI bank.
202			*/
203			public void
204			removeSelectedInstrumentOrBank() {
205			if(getSelectionCount() == 0) return;
206
207			Object obj = getSelectionPath().getLastPathComponent();
208			if(obj instanceof InstrTreeNode) {
209			obj = ((InstrTreeNode)obj).getUserObject();
210			removeInstrument((MidiInstrument)obj);
211			} else if(obj instanceof BankTreeNode) {
212			BankTreeNode n = (BankTreeNode)obj;
213			int c = n.getChildCount();
214			if(c > 1) {
215			String s;
216			s = i18n.getMessage("JSMidiInstrumentTree.removeInstruments?", c);
217			if(!HF.showYesNoDialog(CC.getMainFrame(), s)) return;
218			}
219
220			for(int i = c - 1; i >= 0; i--) {
221			obj = ((InstrTreeNode)n.getChildAt(i)).getUserObject();
222			removeInstrument((MidiInstrument)obj);
223			}
224			}
225			}
226
227			/**
228			* Removes (on the backend side) the specified MIDI instrument.
229			*/
230			private void
231			removeInstrument(MidiInstrument instr) {
232			MidiInstrumentInfo i = instr.getInfo();
233			CC.getSamplerModel().unmapBackendMidiInstrument (
234			i.getMapId(), i.getMidiBank(), i.getMidiProgram()
235			);
236			}
237
238			/**
239			* Returns the position, where the specified bank should be inserted.
240			*/
241			private int
242			findBankPosition(int bankID) {
243			DefaultMutableTreeNode root = (DefaultMutableTreeNode)model.getRoot();
244
245			for(int i = 0; i < root.getChildCount(); i++) {
246			DefaultMutableTreeNode node = (DefaultMutableTreeNode)root.getChildAt(i);
247			MidiBank bank = (MidiBank)node.getUserObject();
248			if(bank.getID() > bankID) return i;
249			}
250
251			return root.getChildCount();
252			}
253
254			/**
255			* If there is already an instrument with MIDI program <code>program</code>,
256			* those instrument is removed from the tree.
257			* @return The position, where the instrument of the specified program should be inserted.
258			*/
259			private int
260			removeProgram(DefaultMutableTreeNode bankNode, int program) {
261
262			for(int i = 0; i < bankNode.getChildCount(); i++) {
263			DefaultMutableTreeNode n = (DefaultMutableTreeNode)bankNode.getChildAt(i);
264			MidiInstrument instr = (MidiInstrument)n.getUserObject();
265
266			if(instr.getInfo().getMidiProgram() == program) {
267			model.removeNodeFromParent(n);
268			return i;
269			}
270
271			if(instr.getInfo().getMidiProgram() > program) return i;
272			}
273
274			return bankNode.getChildCount();
275			}
276
277			private DefaultMutableTreeNode
278			findNode(DefaultMutableTreeNode parent, Object obj) {
279			for(int i = 0; i < parent.getChildCount(); i++) {
280			DefaultMutableTreeNode node = (DefaultMutableTreeNode)parent.getChildAt(i);
281			if(node.getUserObject().equals(obj)) return node;
282			}
283
284			return null;
285			}
286
287			private DefaultMutableTreeNode
288			findBank(Object obj) {
289			return findNode((DefaultMutableTreeNode)model.getRoot(), obj);
290			}
291
292			private DefaultMutableTreeNode
293			findInstrument(Object obj) {
294			if(obj == null \|\| !(obj instanceof MidiInstrument)) return null;
295			MidiInstrument i = (MidiInstrument) obj;
296			DefaultMutableTreeNode bank = findBank(new MidiBank(i.getInfo().getMidiBank()));
297			if(bank == null) return null;
298			return findNode(bank, obj);
299			}
300
301
302			private class MidiBank {
303			int id;
304
305			MidiBank(int id) {
306			this.id = id;
307			}
308
309			public int
310			getID() { return id; }
311
312			public boolean
313			equals(Object obj) {
314			if(obj == null) return false;
315			if(!(obj instanceof MidiBank)) return false;
316			if(getID() == ((MidiBank)obj).getID()) return true;
317			return false;
318			}
319
320			public String
321			toString() { return i18n.getLabel("JSMidiInstrumentTree.MidiBank.name", id); }
322			}
323
324			protected class BankTreeNode extends DefaultMutableTreeNode {
325			BankTreeNode(Object obj) {
326			super(obj);
327			}
328
329			public void
330			setUserObject(Object userObject) {
331			if(userObject instanceof MidiBank) {
332			super.setUserObject(userObject);
333			return;
334			}
335
336			// If we are here, this means that tree editing occurs.
337			CC.getLogger().info("MidiInstrumentTree: editing not supported");
338			}
339
340			public boolean
341			isLeaf() { return false; }
342			}
343
344			protected class InstrTreeNode extends DefaultMutableTreeNode {
345			InstrTreeNode(Object obj) {
346			super(obj);
347			}
348
349			public void
350			setUserObject(Object userObject) {
351			if(userObject instanceof MidiInstrument) {
352			super.setUserObject(userObject);
353			return;
354			}
355
356			// If we are here, this means that tree editing occurs.
357			CC.getLogger().info("MidiInstrumentTree: editing not supported");
358			}
359
360			public boolean
361			isLeaf() { return true; }
362			}
363
364			private void
365			editSelectedInstrument() {
366			MidiInstrument i = getSelectedInstrument();
367			if(i == null) return;
368			JSEditMidiInstrumentDlg dlg = new JSEditMidiInstrumentDlg(i.getInfo());
369			dlg.setVisible(true);
370
371			if(dlg.isCancelled()) return;
372
373			MidiInstrumentInfo info = dlg.getInstrument();
374			CC.getSamplerModel().mapBackendMidiInstrument (
375			info.getMapId(), info.getMidiBank(), info.getMidiProgram(), info
376			);
377			}
378
379			private final EventHandler eventHandler = new EventHandler();
380
381			private EventHandler
382			getHandler() { return eventHandler; }
383
384			private class EventHandler implements MidiInstrumentListener, MidiInstrumentMapListener {
385
386			/** Invoked when a MIDI instrument in a MIDI instrument map is changed. */
387			public void
388			instrumentInfoChanged(MidiInstrumentEvent e) {
389			DefaultMutableTreeNode n = findInstrument(e.getSource());
390			if(n != null) model.nodeChanged(n);
391			}
392
393			/** Invoked when the name of MIDI instrument map is changed. */
394			public void nameChanged(MidiInstrumentMapEvent e) { }
395
396			/** Invoked when an instrument is added to a MIDI instrument map. */
397			public void
398			instrumentAdded(MidiInstrumentMapEvent e) {
399			e.getInstrument().addMidiInstrumentListener(getHandler());
400			mapInstrument(e.getInstrument());
401
402			}
403
404			/** Invoked when an instrument is removed from a MIDI instrument map. */
405			public void
406			instrumentRemoved(MidiInstrumentMapEvent e) {
407			unmapInstrument(e.getInstrument());
408			e.getInstrument().removeMidiInstrumentListener(getHandler());
409			}
410			}
411
412			class ContextMenu extends MouseAdapter implements TreeSelectionListener {
413			private final JPopupMenu cmenu = new JPopupMenu();
414			JMenuItem miEdit = new JMenuItem(i18n.getMenuLabel("ContextMenu.edit"));
415
416			ContextMenu() {
417			cmenu.add(miEdit);
418			miEdit.addActionListener(new ActionListener() {
419			public void
420			actionPerformed(ActionEvent e) {
421			editSelectedInstrument();
422			}
423			});
424
425			JMenuItem mi = new JMenuItem(i18n.getMenuLabel("ContextMenu.delete"));
426			cmenu.add(mi);
427			mi.addActionListener(new ActionListener() {
428			public void
429			actionPerformed(ActionEvent e) {
430			removeSelectedInstrumentOrBank();
431			}
432			});
433
434			}
435
436			public void
437			mousePressed(MouseEvent e) {
438			if(e.isPopupTrigger()) show(e);
439			}
440
441			public void
442			mouseReleased(MouseEvent e) {
443			if(e.isPopupTrigger()) show(e);
444			}
445
446			void
447			show(MouseEvent e) {
448	iliev	1329	if(getSelectionCount() == 0) return;
449	iliev	1286	cmenu.show(e.getComponent(), e.getX(), e.getY());
450			}
451
452			public void
453			valueChanged(TreeSelectionEvent e) {
454			miEdit.setVisible(getSelectedInstrument() != null);
455			}
456			}
457			}