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