view/fantasia/NormalChannelOptionsView.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005-2008 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.fantasia;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Insets;

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

import java.util.logging.Level;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingConstants;

import org.jsampler.AudioDeviceModel;
import org.jsampler.CC;
import org.jsampler.MidiDeviceModel;
import org.jsampler.MidiInstrumentMap;
import org.jsampler.SamplerModel;

import org.jsampler.event.ListEvent;
import org.jsampler.event.ListListener;
import org.jsampler.event.MidiDeviceEvent;
import org.jsampler.event.MidiDeviceListEvent;
import org.jsampler.event.MidiDeviceListListener;
import org.jsampler.event.MidiDeviceListener;
import org.jsampler.event.SamplerAdapter;
import org.jsampler.event.SamplerChannelAdapter;
import org.jsampler.event.SamplerChannelEvent;
import org.jsampler.event.SamplerEvent;
import org.jsampler.event.SamplerListener;

import org.jsampler.view.std.JSChannelOutputRoutingDlg;

import org.linuxsampler.lscp.AudioOutputDevice;
import org.linuxsampler.lscp.MidiInputDevice;
import org.linuxsampler.lscp.MidiPort;
import org.linuxsampler.lscp.SamplerChannel;

import static org.jsampler.view.fantasia.FantasiaI18n.i18n;

/**
 *
 * @author Grigor Iliev
 */
public class NormalChannelOptionsView extends JPanel implements ChannelOptionsView {
        private final Channel channel;
        private MidiDeviceModel midiDevice = null;
        
        private final JComboBox cbMidiDevice = new FantasiaComboBox();
        private final JComboBox cbMidiPort = new FantasiaComboBox();
        private final JComboBox cbMidiChannel = new FantasiaComboBox();
        private final JComboBox cbInstrumentMap = new FantasiaComboBox();
        private final JComboBox cbAudioDevice = new FantasiaComboBox();
        
        private final PixmapButton btnChannelRouting;
        
        private boolean update = false;
        
        private final SamplerListener samplerListener;
        private final MapListListener mapListListener = new MapListListener();
        
        private class NoMap {
                public String
                toString() { return "[None]"; }
        }
        
        private NoMap noMap = new NoMap();
        
        private class DefaultMap {
                public String
                toString() { return "[Default]"; }
        }
        
        private DefaultMap defaultMap = new DefaultMap();
        
        /** Creates a new instance of <code>NormalChannelOptionsView</code> */
        public
        NormalChannelOptionsView(final Channel channel) {
                setLayout(new BorderLayout());
                PixmapPane bgp = new PixmapPane(Res.gfxChannelOptions);
                bgp.setPixmapInsets(new Insets(1, 1, 1, 1));
                
                this.channel = channel;
                
                bgp.setBorder(BorderFactory.createEmptyBorder(5, 4, 5, 4));
                bgp.setLayout(new BoxLayout(bgp, BoxLayout.X_AXIS));
                
                bgp.setPreferredSize(new Dimension(420, 44));
                bgp.setMinimumSize(getPreferredSize());
                bgp.setMaximumSize(getPreferredSize());
                
                JPanel p = new JPanel();
                p.setBorder(BorderFactory.createEmptyBorder(3, 4, 3, 4));
                p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
                JLabel l = new JLabel(Res.gfxMidiInputTitle);
                l.setAlignmentX(LEFT_ALIGNMENT);
                p.add(l);
                
                JPanel p2 = new JPanel();
                p2.setBorder(BorderFactory.createEmptyBorder(3, 0, 0, 0));
                p2.setLayout(new BoxLayout(p2, BoxLayout.X_AXIS));
                
                Object o = cbMidiDevice.getRenderer();
                if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.CENTER);
                
                cbMidiDevice.setPreferredSize(new Dimension(40, 18));
                cbMidiDevice.setMinimumSize(cbMidiDevice.getPreferredSize());
                cbMidiDevice.setMaximumSize(cbMidiDevice.getPreferredSize());
                p2.add(cbMidiDevice);
                
                p2.add(Box.createRigidArea(new Dimension(3, 0)));
                
                o = cbMidiPort.getRenderer();
                if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.CENTER);
                
                cbMidiPort.setPreferredSize(new Dimension(62, 18));
                cbMidiPort.setMinimumSize(cbMidiPort.getPreferredSize());
                cbMidiPort.setMaximumSize(cbMidiPort.getPreferredSize());
                p2.add(cbMidiPort);
                
                p2.add(Box.createRigidArea(new Dimension(3, 0)));
                
                o = cbMidiChannel.getRenderer();
                if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.CENTER);
                
                cbMidiChannel.addItem("All");
                for(int i = 1; i <= 16; i++) cbMidiChannel.addItem("Channel " + String.valueOf(i));
                cbMidiChannel.setPreferredSize(new Dimension(84, 18));
                cbMidiChannel.setMinimumSize(cbMidiChannel.getPreferredSize());
                cbMidiChannel.setMaximumSize(cbMidiChannel.getPreferredSize());
                
                p2.add(cbMidiChannel);
                p2.setAlignmentX(LEFT_ALIGNMENT);
                p2.setOpaque(false);
                p.add(p2);
                p.setBackground(new java.awt.Color(0x818181));
                
                bgp.add(p);
                
                bgp.add(Box.createRigidArea(new Dimension(4, 0)));
                
                p = new JPanel();
                p.setOpaque(true);
                p.setBorder(BorderFactory.createEmptyBorder(3, 4, 3, 4));
                p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
                l = new JLabel(Res.gfxInstrumentMapTitle);
                l.setAlignmentX(LEFT_ALIGNMENT);
                l.setAlignmentX(LEFT_ALIGNMENT);
                p.add(l);
                
                p.add(Box.createRigidArea(new Dimension(0, 3)));
                
                //o = cbInstrumentMap.getRenderer();
                //if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.CENTER);
                
                cbInstrumentMap.setPreferredSize(new Dimension(122, 18));
                cbInstrumentMap.setMinimumSize(cbInstrumentMap.getPreferredSize());
                cbInstrumentMap.setMaximumSize(cbInstrumentMap.getPreferredSize());
                cbInstrumentMap.setAlignmentX(LEFT_ALIGNMENT);
                p.add(cbInstrumentMap);
                p.setBackground(new java.awt.Color(0x818181));
                bgp.add(p);
                
                bgp.add(Box.createRigidArea(new Dimension(4, 0)));
                
                p = new JPanel();
                p.setOpaque(true);
                p.setBorder(BorderFactory.createEmptyBorder(3, 4, 3, 4));
                p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
                l = new JLabel(Res.gfxAudioOutputTitle);
                l.setAlignmentX(LEFT_ALIGNMENT);
                p.add(l);
                
                //p.add(Box.createRigidArea(new Dimension(0, 3)));
                
                p2 = new JPanel();
                p2.setBorder(BorderFactory.createEmptyBorder(3, 0, 0, 0));
                p2.setLayout(new BoxLayout(p2, BoxLayout.X_AXIS));
                p2.setOpaque(false);
                p2.setAlignmentX(LEFT_ALIGNMENT);
                
                o = cbAudioDevice.getRenderer();
                if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.RIGHT);
                
                cbAudioDevice.setPreferredSize(new Dimension(40, 18));
                cbAudioDevice.setMinimumSize(cbAudioDevice.getPreferredSize());
                cbAudioDevice.setMaximumSize(cbAudioDevice.getPreferredSize());
                
                p2.add(cbAudioDevice);
                p2.add(Box.createRigidArea(new Dimension(3, 0)));
                btnChannelRouting = new PixmapButton(Res.gfxBtnCr, Res.gfxBtnCrRO);
                btnChannelRouting.setPressedIcon(Res.gfxBtnCrRO);
                btnChannelRouting.setEnabled(false);
                btnChannelRouting.setToolTipText(i18n.getLabel("ChannelOptions.routing"));
                
                btnChannelRouting.addActionListener(new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) {
                                SamplerChannel c = channel.getChannelInfo();
                                new JSChannelOutputRoutingDlg(CC.getMainFrame(), c).setVisible(true);
                        
                        }
                });
                
                p2.add(btnChannelRouting);
                
                p.add(p2);
                p.setBackground(new java.awt.Color(0x818181));
                p2 = new JPanel();
                p2.setLayout(new java.awt.BorderLayout());
                p.add(p2);
                bgp.add(p);
                
                add(bgp);
                
                cbMidiDevice.addActionListener(new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) { setMidiDevice(); }
                });
                
                cbMidiPort.addActionListener(new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) { setMidiPort(); }
                });
                
                cbMidiChannel.addActionListener(new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) { setMidiChannel(); }
                });
                
                samplerListener = new SamplerAdapter() {
                        /** Invoked when the default MIDI instrument map is changed. */
                        public void
                        defaultMapChanged(SamplerEvent e) {
                                updateCbInstrumentMapToolTipText();
                                
                        }
                };
                
                CC.getSamplerModel().addSamplerListener(samplerListener);
                
                cbInstrumentMap.addItem(noMap);
                cbInstrumentMap.addItem(defaultMap);
                for(MidiInstrumentMap map : CC.getSamplerModel().getMidiInstrumentMaps()) {
                        cbInstrumentMap.addItem(map);
                }
                
                int map = channel.getModel().getChannelInfo().getMidiInstrumentMapId();
                cbInstrumentMap.setSelectedItem(CC.getSamplerModel().getMidiInstrumentMapById(map));
                if(cbInstrumentMap.getSelectedItem() == null) {
                        if(map == -1) cbInstrumentMap.setSelectedItem(noMap);
                        else if(map == -2) {
                                cbInstrumentMap.setSelectedItem(defaultMap);
                        }
                }
                
                updateCbInstrumentMapToolTipText();
                
                if(channel.getModel().getChannelInfo().getEngine() == null) {
                        cbInstrumentMap.setEnabled(false);
                }
                
                cbInstrumentMap.addActionListener(new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) { updateInstrumentMap(); }
                });
                
                CC.getSamplerModel().addMidiInstrumentMapListListener(mapListListener);
                
                cbAudioDevice.addActionListener(new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) { setBackendAudioDevice(); }
                });
                
                channel.getModel().addSamplerChannelListener(new SamplerChannelAdapter() {
                        public void
                        channelChanged(SamplerChannelEvent e) { updateChannelProperties(); }
                });
                
                CC.getSamplerModel().addMidiDeviceListListener(getHandler());
                CC.getSamplerModel().addAudioDeviceListListener(getHandler());
                
                updateMidiDevices();
                updateAudioDevices();
                updateChannelProperties();
        }
        
        //////////////////////////////////////////////
        // Implementation of the ChannelOptionsView interface
        //////////////////////////////////////////////
        
        public JComponent
        getComponent() { return this; }
        
        public void
        installView() { }
        
        public void
        uninstallView() {
                onDestroy();
        }
        
        public void
        updateChannelInfo() {
                
        }
        
        //////////////////////////////////////////////
        
        /**
         * Updates the channel settings. This method is invoked when changes to the
         * channel were made.
         */
        private void
        updateChannelProperties() {
                SamplerModel sm = CC.getSamplerModel();
                SamplerChannel sc = channel.getModel().getChannelInfo();
                
                MidiDeviceModel mm = sm.getMidiDeviceById(sc.getMidiInputDevice());
                AudioDeviceModel am = sm.getAudioDeviceById(sc.getAudioOutputDevice());
                
                if(isUpdate()) CC.getLogger().warning("Unexpected update state!");
                
                setUpdate(true);
                
                try {
                        cbMidiDevice.setSelectedItem(mm == null ? null : mm.getDeviceInfo());
                        
                        cbAudioDevice.setSelectedItem(am == null ? null : am.getDeviceInfo());
                        btnChannelRouting.setEnabled(am != null);
                } catch(Exception x) {
                        CC.getLogger().log(Level.WARNING, "Unkown error", x);
                }
                
                if(sc.getEngine() != null) {
                        cbInstrumentMap.setEnabled(true);
                        int id = sc.getMidiInstrumentMapId();
                        Object o;
                        if(id == -2) o = defaultMap;
                        else if(id == -1) o = noMap;
                        else o = CC.getSamplerModel().getMidiInstrumentMapById(id);
                        
                        if(cbInstrumentMap.getSelectedItem() != o) {
                                cbInstrumentMap.setSelectedItem(o);
                        }
                } else {
                        cbInstrumentMap.setSelectedItem(noMap);
                        cbInstrumentMap.setEnabled(false);
                }
                
                setUpdate(false);
        }
        
        /**
         * Updates the MIDI device list.
         */
        private void
        updateMidiDevices() {
                SamplerModel sm = CC.getSamplerModel();
                SamplerChannel sc = channel.getModel().getChannelInfo();
                
                setUpdate(true);
                
                try {
                        cbMidiDevice.removeAllItems();
                
                        for(MidiDeviceModel m : sm.getMidiDevices())
                                cbMidiDevice.addItem(m.getDeviceInfo());
                
                        MidiDeviceModel mm = sm.getMidiDeviceById(sc.getMidiInputDevice());
                        cbMidiDevice.setSelectedItem(mm == null ? null : mm.getDeviceInfo());
                } catch(Exception x) {
                        CC.getLogger().log(Level.WARNING, "Unkown error", x);
                }
                 
                setUpdate(false);
        }
        
        
        private void
        updateInstrumentMap() {
                updateCbInstrumentMapToolTipText();
                
                int id = channel.getModel().getChannelInfo().getMidiInstrumentMapId();
                Object o = cbInstrumentMap.getSelectedItem();
                if(o == null && id == -1) return;
                
                int cbId;
                if(o == null || o == noMap) cbId = -1;
                else if(o == defaultMap) cbId = -2;
                else cbId = ((MidiInstrumentMap)o).getMapId();
                
                if(cbId == id) return;
                
                channel.getModel().setBackendMidiInstrumentMap(cbId);
        }
        
        private void
        updateCbInstrumentMapToolTipText() {
                if(cbInstrumentMap.getSelectedItem() != defaultMap) {
                        cbInstrumentMap.setToolTipText(null);
                        return;
                }
                
                MidiInstrumentMap m = CC.getSamplerModel().getDefaultMidiInstrumentMap();
                if(m != null) {
                        String s = i18n.getLabel("Channel.ttDefault", m.getName());
                        cbInstrumentMap.setToolTipText(s);
                } else {
                        cbInstrumentMap.setToolTipText(null);
                }
        }
        
        /**
         * Updates the audio device list.
         */
        private void
        updateAudioDevices() {
                SamplerModel sm = CC.getSamplerModel();
                SamplerChannel sc = channel.getModel().getChannelInfo();
                
                setUpdate(true);
                
                try {
                        cbAudioDevice.removeAllItems();
                
                        for(AudioDeviceModel m : sm.getAudioDevices()) 
                                cbAudioDevice.addItem(m.getDeviceInfo());
                
                        AudioDeviceModel am = sm.getAudioDeviceById(sc.getAudioOutputDevice());
                        cbAudioDevice.setSelectedItem(am == null ? null : am.getDeviceInfo());
                } catch(Exception x) {
                        CC.getLogger().log(Level.WARNING, "Unkown error", x);
                }
                
                setUpdate(false);
        }
        
        private void
        setMidiDevice() {
                MidiInputDevice mid = (MidiInputDevice)cbMidiDevice.getSelectedItem();
                
                if(!isUpdate()) {
                        if(mid != null) {
                                channel.getModel().setBackendMidiInputDevice(mid.getDeviceId());
                        }
                        
                        return;
                }
                
                if(midiDevice != null) midiDevice.removeMidiDeviceListener(getHandler());
                
                cbMidiPort.removeAllItems();
                
                if(mid == null) {
                        midiDevice = null;
                        cbMidiPort.setEnabled(false);
                        
                        cbMidiChannel.setSelectedItem(null);
                        cbMidiChannel.setEnabled(false);
                } else {
                        midiDevice = CC.getSamplerModel().getMidiDeviceById(mid.getDeviceId());
                        if(midiDevice != null) midiDevice.addMidiDeviceListener(getHandler());
                        
                        cbMidiPort.setEnabled(true);
                        
                        MidiPort[] ports = mid.getMidiPorts();
                        for(MidiPort port : ports) cbMidiPort.addItem(port);
                        
                        int p = channel.getModel().getChannelInfo().getMidiInputPort();
                        cbMidiPort.setSelectedItem(p >= 0 && p < ports.length ? ports[p] : null);
                        
                        cbMidiChannel.setEnabled(true);
                        int c = channel.getModel().getChannelInfo().getMidiInputChannel();
                        cbMidiChannel.setSelectedItem(c == -1 ? "All" : "Channel " + (c + 1));
                }
        }
        
        private void
        setMidiPort() {
                if(isUpdate()) return;
                
                channel.getModel().setBackendMidiInputPort(cbMidiPort.getSelectedIndex());
        }
        
        private void
        setMidiChannel() {
                if(isUpdate()) return;
                
                Object o = cbMidiChannel.getSelectedItem();
                if(o == null) return;
                String s = o.toString();
                
                int c = s.equals("All") ? -1 : Integer.parseInt(s.substring(8)) - 1;
                
                channel.getModel().setBackendMidiInputChannel(c);
        }
        
        private void
        setBackendAudioDevice() {
                if(isUpdate()) return;
                AudioOutputDevice dev = (AudioOutputDevice)cbAudioDevice.getSelectedItem();
                if(dev != null) channel.getModel().setBackendAudioOutputDevice(dev.getDeviceId());
        }
        
        /**
         * Determines whether the currently processed changes are due to update.
         * @return <code>true</code> if the currently processed changes are due to update and
         * <code>false</code> if the currently processed changes are due to user input.
         */
        private boolean
        isUpdate() { return update; }
        
        /**
         * Sets whether the currently processed changes are due to update.
         * @param b Specify <code>true</code> to indicate that the currently 
         * processed changes are due to update; <code>false</code> 
         * indicates that the currently processed changes are due to user input.
         */
        private void
        setUpdate(boolean b) { update = b; }
        
        protected void
        onDestroy() {
                SamplerModel sm = CC.getSamplerModel();
                
                sm.removeMidiDeviceListListener(getHandler());
                sm.removeAudioDeviceListListener(getHandler());
                sm.removeMidiInstrumentMapListListener(mapListListener);
                sm.removeSamplerListener(samplerListener);
                
                if(midiDevice != null) {
                        midiDevice.removeMidiDeviceListener(getHandler());
                }
        }
        
        private final Handler handler = new Handler();
        
        private Handler
        getHandler() { return handler; }
        
        private class Handler implements MidiDeviceListListener, ListListener<AudioDeviceModel>,
                                        MidiDeviceListener {
                /**
                 * Invoked when a new MIDI device is created.
                 * @param e A <code>MidiDeviceListEvent</code>
                 * instance providing the event information.
                 */
                public void
                deviceAdded(MidiDeviceListEvent e) {
                        cbMidiDevice.addItem(e.getMidiDeviceModel().getDeviceInfo());
                }
        
                /**
                 * Invoked when a MIDI device is removed.
                 * @param e A <code>MidiDeviceListEvent</code>
                 * instance providing the event information.
                 */
                public void
                deviceRemoved(MidiDeviceListEvent e) {
                        cbMidiDevice.removeItem(e.getMidiDeviceModel().getDeviceInfo());
                }
                
                /**
                 * Invoked when a new audio device is created.
                 * @param e An <code>AudioDeviceListEvent</code>
                 * instance providing the event information.
                 */
                public void
                entryAdded(ListEvent<AudioDeviceModel> e) {
                        cbAudioDevice.addItem(e.getEntry().getDeviceInfo());
                }
        
                /**
                 * Invoked when an audio device is removed.
                 * @param e An <code>AudioDeviceListEvent</code>
                 * instance providing the event information.
                 */
                public void
                entryRemoved(ListEvent<AudioDeviceModel> e) {
                        cbAudioDevice.removeItem(e.getEntry().getDeviceInfo());
                }
                
                public void
                settingsChanged(MidiDeviceEvent e) {
                        if(isUpdate()) {
                                CC.getLogger().warning("Invalid update state");
                                return;
                        }
                        
                        setUpdate(true);
                        int idx = cbMidiPort.getSelectedIndex();
                        MidiInputDevice d = e.getMidiDeviceModel().getDeviceInfo();
                        
                        cbMidiPort.removeAllItems();
                        for(MidiPort port : d.getMidiPorts()) cbMidiPort.addItem(port);
                        
                        if(idx >= cbMidiPort.getModel().getSize()) idx = 0;
                        
                        setUpdate(false);
                        
                        if(cbMidiPort.getModel().getSize() > 0) cbMidiPort.setSelectedIndex(idx);
                }
        }
        
        private class MapListListener implements ListListener<MidiInstrumentMap> {
                /** Invoked when a new MIDI instrument map is added to a list. */
                public void
                entryAdded(ListEvent<MidiInstrumentMap> e) {
                        cbInstrumentMap.insertItemAt(e.getEntry(), cbInstrumentMap.getItemCount());
                        boolean b = channel.getModel().getChannelInfo().getEngine() != null;
                        if(b && !cbInstrumentMap.isEnabled()) cbInstrumentMap.setEnabled(true);
                }
        
                /** Invoked when a new MIDI instrument map is removed from a list. */
                public void
                entryRemoved(ListEvent<MidiInstrumentMap> e) {
                        cbInstrumentMap.removeItem(e.getEntry());
                        if(cbInstrumentMap.getItemCount() == 0) { // TODO: ?
                                cbInstrumentMap.setSelectedItem(noMap);
                                cbInstrumentMap.setEnabled(false);
                        }
                }
        }
}
1	iliev	1730	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4			* Copyright (C) 2005-2008 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.fantasia;
24
25			import java.awt.BorderLayout;
26			import java.awt.Dimension;
27			import java.awt.Insets;
28
29			import java.awt.event.ActionEvent;
30			import java.awt.event.ActionListener;
31
32			import java.util.logging.Level;
33
34			import javax.swing.BorderFactory;
35			import javax.swing.Box;
36			import javax.swing.BoxLayout;
37			import javax.swing.JComboBox;
38			import javax.swing.JComponent;
39			import javax.swing.JLabel;
40			import javax.swing.JPanel;
41			import javax.swing.SwingConstants;
42
43			import org.jsampler.AudioDeviceModel;
44			import org.jsampler.CC;
45			import org.jsampler.MidiDeviceModel;
46			import org.jsampler.MidiInstrumentMap;
47			import org.jsampler.SamplerModel;
48
49			import org.jsampler.event.ListEvent;
50			import org.jsampler.event.ListListener;
51			import org.jsampler.event.MidiDeviceEvent;
52			import org.jsampler.event.MidiDeviceListEvent;
53			import org.jsampler.event.MidiDeviceListListener;
54			import org.jsampler.event.MidiDeviceListener;
55			import org.jsampler.event.SamplerAdapter;
56			import org.jsampler.event.SamplerChannelAdapter;
57			import org.jsampler.event.SamplerChannelEvent;
58			import org.jsampler.event.SamplerEvent;
59			import org.jsampler.event.SamplerListener;
60
61			import org.jsampler.view.std.JSChannelOutputRoutingDlg;
62
63			import org.linuxsampler.lscp.AudioOutputDevice;
64			import org.linuxsampler.lscp.MidiInputDevice;
65			import org.linuxsampler.lscp.MidiPort;
66			import org.linuxsampler.lscp.SamplerChannel;
67
68			import static org.jsampler.view.fantasia.FantasiaI18n.i18n;
69
70			/**
71			*
72			* @author Grigor Iliev
73			*/
74			public class NormalChannelOptionsView extends JPanel implements ChannelOptionsView {
75			private final Channel channel;
76			private MidiDeviceModel midiDevice = null;
77
78			private final JComboBox cbMidiDevice = new FantasiaComboBox();
79			private final JComboBox cbMidiPort = new FantasiaComboBox();
80			private final JComboBox cbMidiChannel = new FantasiaComboBox();
81			private final JComboBox cbInstrumentMap = new FantasiaComboBox();
82			private final JComboBox cbAudioDevice = new FantasiaComboBox();
83
84			private final PixmapButton btnChannelRouting;
85
86			private boolean update = false;
87
88			private final SamplerListener samplerListener;
89			private final MapListListener mapListListener = new MapListListener();
90
91			private class NoMap {
92			public String
93			toString() { return "[None]"; }
94			}
95
96			private NoMap noMap = new NoMap();
97
98			private class DefaultMap {
99			public String
100			toString() { return "[Default]"; }
101			}
102
103			private DefaultMap defaultMap = new DefaultMap();
104
105			/** Creates a new instance of <code>NormalChannelOptionsView</code> */
106			public
107			NormalChannelOptionsView(final Channel channel) {
108			setLayout(new BorderLayout());
109			PixmapPane bgp = new PixmapPane(Res.gfxChannelOptions);
110			bgp.setPixmapInsets(new Insets(1, 1, 1, 1));
111
112			this.channel = channel;
113
114			bgp.setBorder(BorderFactory.createEmptyBorder(5, 4, 5, 4));
115			bgp.setLayout(new BoxLayout(bgp, BoxLayout.X_AXIS));
116
117			bgp.setPreferredSize(new Dimension(420, 44));
118			bgp.setMinimumSize(getPreferredSize());
119			bgp.setMaximumSize(getPreferredSize());
120
121			JPanel p = new JPanel();
122			p.setBorder(BorderFactory.createEmptyBorder(3, 4, 3, 4));
123			p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
124			JLabel l = new JLabel(Res.gfxMidiInputTitle);
125			l.setAlignmentX(LEFT_ALIGNMENT);
126			p.add(l);
127
128			JPanel p2 = new JPanel();
129			p2.setBorder(BorderFactory.createEmptyBorder(3, 0, 0, 0));
130			p2.setLayout(new BoxLayout(p2, BoxLayout.X_AXIS));
131
132			Object o = cbMidiDevice.getRenderer();
133			if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.CENTER);
134
135			cbMidiDevice.setPreferredSize(new Dimension(40, 18));
136			cbMidiDevice.setMinimumSize(cbMidiDevice.getPreferredSize());
137			cbMidiDevice.setMaximumSize(cbMidiDevice.getPreferredSize());
138			p2.add(cbMidiDevice);
139
140			p2.add(Box.createRigidArea(new Dimension(3, 0)));
141
142			o = cbMidiPort.getRenderer();
143			if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.CENTER);
144
145			cbMidiPort.setPreferredSize(new Dimension(62, 18));
146			cbMidiPort.setMinimumSize(cbMidiPort.getPreferredSize());
147			cbMidiPort.setMaximumSize(cbMidiPort.getPreferredSize());
148			p2.add(cbMidiPort);
149
150			p2.add(Box.createRigidArea(new Dimension(3, 0)));
151
152			o = cbMidiChannel.getRenderer();
153			if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.CENTER);
154
155			cbMidiChannel.addItem("All");
156			for(int i = 1; i <= 16; i++) cbMidiChannel.addItem("Channel " + String.valueOf(i));
157			cbMidiChannel.setPreferredSize(new Dimension(84, 18));
158			cbMidiChannel.setMinimumSize(cbMidiChannel.getPreferredSize());
159			cbMidiChannel.setMaximumSize(cbMidiChannel.getPreferredSize());
160
161			p2.add(cbMidiChannel);
162			p2.setAlignmentX(LEFT_ALIGNMENT);
163			p2.setOpaque(false);
164			p.add(p2);
165			p.setBackground(new java.awt.Color(0x818181));
166
167			bgp.add(p);
168
169			bgp.add(Box.createRigidArea(new Dimension(4, 0)));
170
171			p = new JPanel();
172			p.setOpaque(true);
173			p.setBorder(BorderFactory.createEmptyBorder(3, 4, 3, 4));
174			p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
175			l = new JLabel(Res.gfxInstrumentMapTitle);
176			l.setAlignmentX(LEFT_ALIGNMENT);
177			l.setAlignmentX(LEFT_ALIGNMENT);
178			p.add(l);
179
180			p.add(Box.createRigidArea(new Dimension(0, 3)));
181
182			//o = cbInstrumentMap.getRenderer();
183			//if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.CENTER);
184
185			cbInstrumentMap.setPreferredSize(new Dimension(122, 18));
186			cbInstrumentMap.setMinimumSize(cbInstrumentMap.getPreferredSize());
187			cbInstrumentMap.setMaximumSize(cbInstrumentMap.getPreferredSize());
188			cbInstrumentMap.setAlignmentX(LEFT_ALIGNMENT);
189			p.add(cbInstrumentMap);
190			p.setBackground(new java.awt.Color(0x818181));
191			bgp.add(p);
192
193			bgp.add(Box.createRigidArea(new Dimension(4, 0)));
194
195			p = new JPanel();
196			p.setOpaque(true);
197			p.setBorder(BorderFactory.createEmptyBorder(3, 4, 3, 4));
198			p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
199			l = new JLabel(Res.gfxAudioOutputTitle);
200			l.setAlignmentX(LEFT_ALIGNMENT);
201			p.add(l);
202
203			//p.add(Box.createRigidArea(new Dimension(0, 3)));
204
205			p2 = new JPanel();
206			p2.setBorder(BorderFactory.createEmptyBorder(3, 0, 0, 0));
207			p2.setLayout(new BoxLayout(p2, BoxLayout.X_AXIS));
208			p2.setOpaque(false);
209			p2.setAlignmentX(LEFT_ALIGNMENT);
210
211			o = cbAudioDevice.getRenderer();
212			if(o instanceof JLabel) ((JLabel )o).setHorizontalAlignment(SwingConstants.RIGHT);
213
214			cbAudioDevice.setPreferredSize(new Dimension(40, 18));
215			cbAudioDevice.setMinimumSize(cbAudioDevice.getPreferredSize());
216			cbAudioDevice.setMaximumSize(cbAudioDevice.getPreferredSize());
217
218			p2.add(cbAudioDevice);
219			p2.add(Box.createRigidArea(new Dimension(3, 0)));
220			btnChannelRouting = new PixmapButton(Res.gfxBtnCr, Res.gfxBtnCrRO);
221			btnChannelRouting.setPressedIcon(Res.gfxBtnCrRO);
222			btnChannelRouting.setEnabled(false);
223			btnChannelRouting.setToolTipText(i18n.getLabel("ChannelOptions.routing"));
224
225			btnChannelRouting.addActionListener(new ActionListener() {
226			public void
227			actionPerformed(ActionEvent e) {
228			SamplerChannel c = channel.getChannelInfo();
229			new JSChannelOutputRoutingDlg(CC.getMainFrame(), c).setVisible(true);
230
231			}
232			});
233
234			p2.add(btnChannelRouting);
235
236			p.add(p2);
237			p.setBackground(new java.awt.Color(0x818181));
238			p2 = new JPanel();
239			p2.setLayout(new java.awt.BorderLayout());
240			p.add(p2);
241			bgp.add(p);
242
243			add(bgp);
244
245			cbMidiDevice.addActionListener(new ActionListener() {
246			public void
247			actionPerformed(ActionEvent e) { setMidiDevice(); }
248			});
249
250			cbMidiPort.addActionListener(new ActionListener() {
251			public void
252			actionPerformed(ActionEvent e) { setMidiPort(); }
253			});
254
255			cbMidiChannel.addActionListener(new ActionListener() {
256			public void
257			actionPerformed(ActionEvent e) { setMidiChannel(); }
258			});
259
260			samplerListener = new SamplerAdapter() {
261			/** Invoked when the default MIDI instrument map is changed. */
262			public void
263			defaultMapChanged(SamplerEvent e) {
264			updateCbInstrumentMapToolTipText();
265
266			}
267			};
268
269			CC.getSamplerModel().addSamplerListener(samplerListener);
270
271			cbInstrumentMap.addItem(noMap);
272			cbInstrumentMap.addItem(defaultMap);
273			for(MidiInstrumentMap map : CC.getSamplerModel().getMidiInstrumentMaps()) {
274			cbInstrumentMap.addItem(map);
275			}
276
277			int map = channel.getModel().getChannelInfo().getMidiInstrumentMapId();
278			cbInstrumentMap.setSelectedItem(CC.getSamplerModel().getMidiInstrumentMapById(map));
279			if(cbInstrumentMap.getSelectedItem() == null) {
280			if(map == -1) cbInstrumentMap.setSelectedItem(noMap);
281			else if(map == -2) {
282			cbInstrumentMap.setSelectedItem(defaultMap);
283			}
284			}
285
286			updateCbInstrumentMapToolTipText();
287
288			if(channel.getModel().getChannelInfo().getEngine() == null) {
289			cbInstrumentMap.setEnabled(false);
290			}
291
292			cbInstrumentMap.addActionListener(new ActionListener() {
293			public void
294			actionPerformed(ActionEvent e) { updateInstrumentMap(); }
295			});
296
297			CC.getSamplerModel().addMidiInstrumentMapListListener(mapListListener);
298
299			cbAudioDevice.addActionListener(new ActionListener() {
300			public void
301			actionPerformed(ActionEvent e) { setBackendAudioDevice(); }
302			});
303
304			channel.getModel().addSamplerChannelListener(new SamplerChannelAdapter() {
305			public void
306			channelChanged(SamplerChannelEvent e) { updateChannelProperties(); }
307			});
308
309			CC.getSamplerModel().addMidiDeviceListListener(getHandler());
310			CC.getSamplerModel().addAudioDeviceListListener(getHandler());
311
312			updateMidiDevices();
313			updateAudioDevices();
314			updateChannelProperties();
315			}
316
317			//////////////////////////////////////////////
318			// Implementation of the ChannelOptionsView interface
319			//////////////////////////////////////////////
320
321			public JComponent
322			getComponent() { return this; }
323
324			public void
325			installView() { }
326
327			public void
328			uninstallView() {
329			onDestroy();
330			}
331
332			public void
333			updateChannelInfo() {
334
335			}
336
337			//////////////////////////////////////////////
338
339			/**
340			* Updates the channel settings. This method is invoked when changes to the
341			* channel were made.
342			*/
343			private void
344			updateChannelProperties() {
345			SamplerModel sm = CC.getSamplerModel();
346			SamplerChannel sc = channel.getModel().getChannelInfo();
347
348			MidiDeviceModel mm = sm.getMidiDeviceById(sc.getMidiInputDevice());
349			AudioDeviceModel am = sm.getAudioDeviceById(sc.getAudioOutputDevice());
350
351			if(isUpdate()) CC.getLogger().warning("Unexpected update state!");
352
353			setUpdate(true);
354
355			try {
356			cbMidiDevice.setSelectedItem(mm == null ? null : mm.getDeviceInfo());
357
358			cbAudioDevice.setSelectedItem(am == null ? null : am.getDeviceInfo());
359			btnChannelRouting.setEnabled(am != null);
360			} catch(Exception x) {
361			CC.getLogger().log(Level.WARNING, "Unkown error", x);
362			}
363
364			if(sc.getEngine() != null) {
365			cbInstrumentMap.setEnabled(true);
366			int id = sc.getMidiInstrumentMapId();
367			Object o;
368			if(id == -2) o = defaultMap;
369			else if(id == -1) o = noMap;
370			else o = CC.getSamplerModel().getMidiInstrumentMapById(id);
371
372			if(cbInstrumentMap.getSelectedItem() != o) {
373			cbInstrumentMap.setSelectedItem(o);
374			}
375			} else {
376			cbInstrumentMap.setSelectedItem(noMap);
377			cbInstrumentMap.setEnabled(false);
378			}
379
380			setUpdate(false);
381			}
382
383			/**
384			* Updates the MIDI device list.
385			*/
386			private void
387			updateMidiDevices() {
388			SamplerModel sm = CC.getSamplerModel();
389			SamplerChannel sc = channel.getModel().getChannelInfo();
390
391			setUpdate(true);
392
393			try {
394			cbMidiDevice.removeAllItems();
395
396			for(MidiDeviceModel m : sm.getMidiDevices())
397			cbMidiDevice.addItem(m.getDeviceInfo());
398
399			MidiDeviceModel mm = sm.getMidiDeviceById(sc.getMidiInputDevice());
400			cbMidiDevice.setSelectedItem(mm == null ? null : mm.getDeviceInfo());
401			} catch(Exception x) {
402			CC.getLogger().log(Level.WARNING, "Unkown error", x);
403			}
404
405			setUpdate(false);
406			}
407
408
409			private void
410			updateInstrumentMap() {
411			updateCbInstrumentMapToolTipText();
412
413			int id = channel.getModel().getChannelInfo().getMidiInstrumentMapId();
414			Object o = cbInstrumentMap.getSelectedItem();
415			if(o == null && id == -1) return;
416
417			int cbId;
418			if(o == null \|\| o == noMap) cbId = -1;
419			else if(o == defaultMap) cbId = -2;
420			else cbId = ((MidiInstrumentMap)o).getMapId();
421
422			if(cbId == id) return;
423
424			channel.getModel().setBackendMidiInstrumentMap(cbId);
425			}
426
427			private void
428			updateCbInstrumentMapToolTipText() {
429			if(cbInstrumentMap.getSelectedItem() != defaultMap) {
430			cbInstrumentMap.setToolTipText(null);
431			return;
432			}
433
434			MidiInstrumentMap m = CC.getSamplerModel().getDefaultMidiInstrumentMap();
435			if(m != null) {
436			String s = i18n.getLabel("Channel.ttDefault", m.getName());
437			cbInstrumentMap.setToolTipText(s);
438			} else {
439			cbInstrumentMap.setToolTipText(null);
440			}
441			}
442
443			/**
444			* Updates the audio device list.
445			*/
446			private void
447			updateAudioDevices() {
448			SamplerModel sm = CC.getSamplerModel();
449			SamplerChannel sc = channel.getModel().getChannelInfo();
450
451			setUpdate(true);
452
453			try {
454			cbAudioDevice.removeAllItems();
455
456			for(AudioDeviceModel m : sm.getAudioDevices())
457			cbAudioDevice.addItem(m.getDeviceInfo());
458
459			AudioDeviceModel am = sm.getAudioDeviceById(sc.getAudioOutputDevice());
460			cbAudioDevice.setSelectedItem(am == null ? null : am.getDeviceInfo());
461			} catch(Exception x) {
462			CC.getLogger().log(Level.WARNING, "Unkown error", x);
463			}
464
465			setUpdate(false);
466			}
467
468			private void
469			setMidiDevice() {
470			MidiInputDevice mid = (MidiInputDevice)cbMidiDevice.getSelectedItem();
471
472			if(!isUpdate()) {
473			if(mid != null) {
474			channel.getModel().setBackendMidiInputDevice(mid.getDeviceId());
475			}
476
477			return;
478			}
479
480			if(midiDevice != null) midiDevice.removeMidiDeviceListener(getHandler());
481
482			cbMidiPort.removeAllItems();
483
484			if(mid == null) {
485			midiDevice = null;
486			cbMidiPort.setEnabled(false);
487
488			cbMidiChannel.setSelectedItem(null);
489			cbMidiChannel.setEnabled(false);
490			} else {
491			midiDevice = CC.getSamplerModel().getMidiDeviceById(mid.getDeviceId());
492			if(midiDevice != null) midiDevice.addMidiDeviceListener(getHandler());
493
494			cbMidiPort.setEnabled(true);
495
496			MidiPort[] ports = mid.getMidiPorts();
497			for(MidiPort port : ports) cbMidiPort.addItem(port);
498
499			int p = channel.getModel().getChannelInfo().getMidiInputPort();
500			cbMidiPort.setSelectedItem(p >= 0 && p < ports.length ? ports[p] : null);
501
502			cbMidiChannel.setEnabled(true);
503			int c = channel.getModel().getChannelInfo().getMidiInputChannel();
504			cbMidiChannel.setSelectedItem(c == -1 ? "All" : "Channel " + (c + 1));
505			}
506			}
507
508			private void
509			setMidiPort() {
510			if(isUpdate()) return;
511
512			channel.getModel().setBackendMidiInputPort(cbMidiPort.getSelectedIndex());
513			}
514
515			private void
516			setMidiChannel() {
517			if(isUpdate()) return;
518
519			Object o = cbMidiChannel.getSelectedItem();
520			if(o == null) return;
521			String s = o.toString();
522
523			int c = s.equals("All") ? -1 : Integer.parseInt(s.substring(8)) - 1;
524
525			channel.getModel().setBackendMidiInputChannel(c);
526			}
527
528			private void
529			setBackendAudioDevice() {
530			if(isUpdate()) return;
531			AudioOutputDevice dev = (AudioOutputDevice)cbAudioDevice.getSelectedItem();
532			if(dev != null) channel.getModel().setBackendAudioOutputDevice(dev.getDeviceId());
533			}
534
535			/**
536			* Determines whether the currently processed changes are due to update.
537			* @return <code>true</code> if the currently processed changes are due to update and
538			* <code>false</code> if the currently processed changes are due to user input.
539			*/
540			private boolean
541			isUpdate() { return update; }
542
543			/**
544			* Sets whether the currently processed changes are due to update.
545			* @param b Specify <code>true</code> to indicate that the currently
546			* processed changes are due to update; <code>false</code>
547			* indicates that the currently processed changes are due to user input.
548			*/
549			private void
550			setUpdate(boolean b) { update = b; }
551
552			protected void
553			onDestroy() {
554			SamplerModel sm = CC.getSamplerModel();
555
556			sm.removeMidiDeviceListListener(getHandler());
557			sm.removeAudioDeviceListListener(getHandler());
558			sm.removeMidiInstrumentMapListListener(mapListListener);
559			sm.removeSamplerListener(samplerListener);
560
561			if(midiDevice != null) {
562			midiDevice.removeMidiDeviceListener(getHandler());
563			}
564			}
565
566			private final Handler handler = new Handler();
567
568			private Handler
569			getHandler() { return handler; }
570
571			private class Handler implements MidiDeviceListListener, ListListener<AudioDeviceModel>,
572			MidiDeviceListener {
573			/**
574			* Invoked when a new MIDI device is created.
575			* @param e A <code>MidiDeviceListEvent</code>
576			* instance providing the event information.
577			*/
578			public void
579			deviceAdded(MidiDeviceListEvent e) {
580			cbMidiDevice.addItem(e.getMidiDeviceModel().getDeviceInfo());
581			}
582
583			/**
584			* Invoked when a MIDI device is removed.
585			* @param e A <code>MidiDeviceListEvent</code>
586			* instance providing the event information.
587			*/
588			public void
589			deviceRemoved(MidiDeviceListEvent e) {
590			cbMidiDevice.removeItem(e.getMidiDeviceModel().getDeviceInfo());
591			}
592
593			/**
594			* Invoked when a new audio device is created.
595			* @param e An <code>AudioDeviceListEvent</code>
596			* instance providing the event information.
597			*/
598			public void
599			entryAdded(ListEvent<AudioDeviceModel> e) {
600			cbAudioDevice.addItem(e.getEntry().getDeviceInfo());
601			}
602
603			/**
604			* Invoked when an audio device is removed.
605			* @param e An <code>AudioDeviceListEvent</code>
606			* instance providing the event information.
607			*/
608			public void
609			entryRemoved(ListEvent<AudioDeviceModel> e) {
610			cbAudioDevice.removeItem(e.getEntry().getDeviceInfo());
611			}
612
613			public void
614			settingsChanged(MidiDeviceEvent e) {
615			if(isUpdate()) {
616			CC.getLogger().warning("Invalid update state");
617			return;
618			}
619
620			setUpdate(true);
621			int idx = cbMidiPort.getSelectedIndex();
622			MidiInputDevice d = e.getMidiDeviceModel().getDeviceInfo();
623
624			cbMidiPort.removeAllItems();
625			for(MidiPort port : d.getMidiPorts()) cbMidiPort.addItem(port);
626
627			if(idx >= cbMidiPort.getModel().getSize()) idx = 0;
628
629			setUpdate(false);
630
631			if(cbMidiPort.getModel().getSize() > 0) cbMidiPort.setSelectedIndex(idx);
632			}
633			}
634
635			private class MapListListener implements ListListener<MidiInstrumentMap> {
636			/** Invoked when a new MIDI instrument map is added to a list. */
637			public void
638			entryAdded(ListEvent<MidiInstrumentMap> e) {
639			cbInstrumentMap.insertItemAt(e.getEntry(), cbInstrumentMap.getItemCount());
640			boolean b = channel.getModel().getChannelInfo().getEngine() != null;
641			if(b && !cbInstrumentMap.isEnabled()) cbInstrumentMap.setEnabled(true);
642			}
643
644			/** Invoked when a new MIDI instrument map is removed from a list. */
645			public void
646			entryRemoved(ListEvent<MidiInstrumentMap> e) {
647			cbInstrumentMap.removeItem(e.getEntry());
648			if(cbInstrumentMap.getItemCount() == 0) { // TODO: ?
649			cbInstrumentMap.setSelectedItem(noMap);
650			cbInstrumentMap.setEnabled(false);
651			}
652			}
653			}
654			}