view/classic/ManageOrchestrasPage.java

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

import java.awt.Dimension;

import java.awt.datatransfer.DataFlavor;

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

import java.util.logging.Level;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JToolBar;
import javax.swing.ListSelectionModel;
import javax.swing.TransferHandler;

import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

import net.sf.juife.JuifeUtils;
import net.sf.juife.LinkButton;
import net.sf.juife.NavigationPage;

import org.jsampler.CC;
import org.jsampler.DOMUtils;
import org.jsampler.DefaultOrchestraModel;
import org.jsampler.HF;
import org.jsampler.Instrument;
import org.jsampler.OrchestraListModel;
import org.jsampler.OrchestraModel;

import org.jsampler.view.InstrumentTable;
import org.jsampler.view.InstrumentTableModel;
import org.jsampler.view.OrchestraTable;
import org.jsampler.view.OrchestraTableModel;

import static org.jsampler.view.classic.ClassicI18n.i18n;


/**
 *
 * @author Grigor Iliev
 */
public class ManageOrchestrasPage extends NavigationPage {
        private final JComponent manageOrchestrasPane;
        
        // Manage Orchestra
        private final ToolbarButton btnAddOrchestra = new ToolbarButton(new AddOrchestra());
        private final ToolbarButton btnEditOrchestra = new ToolbarButton(new EditOrchestra());
        private final ToolbarButton btnDeleteOrchestra = new ToolbarButton(new DeleteOrchestra());
        private final ToolbarButton btnOrchestraUp = new ToolbarButton(new OrchestraUp());
        private final ToolbarButton btnOrchestraDown = new ToolbarButton(new OrchestraDown());
        
        private OrchestraTable orchestraTable;
        
        private final ToolbarButton btnAddInstrument = new ToolbarButton(new AddInstrument());
        private final ToolbarButton btnEditInstrument = new ToolbarButton(new EditInstrument());
        private final ToolbarButton btnDeleteInstrument = new ToolbarButton(new DeleteInstrument());
        private final ToolbarButton btnInstrumentUp = new ToolbarButton(new InstrumentUp());
        private final ToolbarButton btnInstrumentDown = new ToolbarButton(new InstrumentDown());
        
        private LinkButton lnkOrchestras =
                new LinkButton(i18n.getButtonLabel("ManageOrchestrasPage.lnkOrchestras"));
        
        private InstrumentTable instrumentTable;
        private OrchestraModel orchestraModel;
        
        
        /** Creates a new instance of <code>ManageOrchestrasPage</code>. */
        public ManageOrchestrasPage() {
                setTitle(i18n.getLabel("ManageOrchestrasPage.title"));
                
                setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
                
                manageOrchestrasPane = createManageOrchestrasPane();
                add(manageOrchestrasPane);
                
                installListeneres();
        }
        
        private JComponent
        createManageOrchestrasPane() {
                JPanel p = new JPanel();
                p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
                //p.add(Box.createRigidArea(new Dimension(0, 5)));
                
                JToolBar tb = new JToolBar();
                tb.add(btnAddOrchestra);
                tb.add(btnEditOrchestra);
                tb.add(btnDeleteOrchestra);
                
                tb.addSeparator();
                
                tb.add(btnOrchestraUp);
                tb.add(btnOrchestraDown);
                                
                tb.setMaximumSize(new Dimension(Short.MAX_VALUE, tb.getPreferredSize().height));
                tb.setFloatable(false);
                tb.setAlignmentX(LEFT_ALIGNMENT);
                
                p.add(tb);
                
                orchestraTable = new OrchestraTable(new OrchestraTableModel(CC.getOrchestras()));
                JScrollPane sp = new JScrollPane(orchestraTable);
                
                sp.getViewport().addMouseListener(new MouseAdapter() {
                        public void
                        mouseClicked(MouseEvent e) { orchestraTable.clearSelection(); }
                });
                
                Dimension d;
                d = new Dimension(sp.getMinimumSize().width, sp.getPreferredSize().height);
                sp.setPreferredSize(d);
                        
                sp.setAlignmentX(LEFT_ALIGNMENT);
                p.add(sp);
                
                JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
                splitPane.setContinuousLayout(true);
                splitPane.setTopComponent(p);
                
                p = new JPanel();
                p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
                //p.add(Box.createRigidArea(new Dimension(0, 5)));
                
                tb = new JToolBar();
                btnAddInstrument.setEnabled(false);
                tb.add(btnAddInstrument);
                tb.add(btnEditInstrument);
                tb.add(btnDeleteInstrument);
                
                tb.addSeparator();
                
                tb.add(btnInstrumentUp);
                tb.add(btnInstrumentDown);
                
                tb.setMaximumSize(new Dimension(Short.MAX_VALUE, tb.getPreferredSize().height));
                tb.setFloatable(false);
                tb.setAlignmentX(JPanel.LEFT_ALIGNMENT);
                
                p.add(tb);
                
                orchestraModel = new DefaultOrchestraModel();
                instrumentTable = new InstrumentTable(new InstrumentTableModel(orchestraModel));
                sp = new DnDScrollPane(instrumentTable);
                sp.setAlignmentX(LEFT_ALIGNMENT);
                p.add(sp);
                
                //p.add(lnkOrchestras);
                //p.add(Box.createRigidArea(new Dimension(0, 5)));
                
                splitPane.setBottomComponent(p);
                splitPane.setDividerSize(3);
                splitPane.setDividerLocation(180);
                
                return splitPane;
        }
        
        private void
        installListeneres() {
                lnkOrchestras.addActionListener(new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) {
                                LeftPane.getLeftPane().showOrchestrasPage();
                        }
                });
                
                OrchestraSelectionHandler l = new OrchestraSelectionHandler();
                orchestraTable.getSelectionModel().addListSelectionListener(l);
                
                orchestraTable.addMouseListener(new MouseAdapter() {
                        public void
                        mouseClicked(MouseEvent e) {
                                if(e.getClickCount() < 2) return;
                                
                                if(orchestraTable.getSelectedOrchestra() == null) return;
                                btnEditOrchestra.doClick(0);
                        }
                });
                
                InstrumentSelectionHandler l2 = new InstrumentSelectionHandler();
                instrumentTable.getSelectionModel().addListSelectionListener(l2);
                
                instrumentTable.addMouseListener(new MouseAdapter() {
                        public void
                        mouseClicked(MouseEvent e) {
                                if(e.getClickCount() < 2) return;
                                
                                if(instrumentTable.getSelectedInstrument() == null) return;
                                btnEditInstrument.doClick(0);
                        }
                });
        }
        
        public class DnDScrollPane extends JScrollPane {
                private InstrumentTable instrumentTable;
                
                private
                DnDScrollPane(InstrumentTable table) {
                        instrumentTable = table;
                        setViewport(new DnDViewPort());
                        setViewportView(instrumentTable);
                        
                        Dimension d;
                        d = new Dimension(getMinimumSize().width, getPreferredSize().height);
                        setPreferredSize(d);
                }
                
                public class DnDViewPort extends javax.swing.JViewport {
                        private
                        DnDViewPort() {
                                setTransferHandler(new TransferHandler("instrument") {
                                        public boolean
                                        canImport(JComponent comp, DataFlavor[] flavors) {
                                                if(instrumentTable.isPerformingDnD()) return false;
                                                if(!btnAddInstrument.isEnabled()) return false;
                                
                                                return super.canImport(comp, flavors);
                                        }       
                                });
                                
                                addMouseListener(new MouseAdapter() {
                                        public void
                                        mouseClicked(MouseEvent e) {
                                                instrumentTable.clearSelection();
                                        }
                                });
                        }
                        
                        public String
                        getInstrument() { return null; }
                        
                        public void
                        setInstrument(String instr) {
                                instrumentTable.setSelectedInstrument(null);
                                instrumentTable.setInstrument(instr);
                        }
                }
        }
        
        private class OrchestraSelectionHandler implements ListSelectionListener {
                public void
                valueChanged(ListSelectionEvent e) {
                        if(e.getValueIsAdjusting()) return;
                        
                        if(orchestraTable.getSelectedOrchestra() == null) {
                                btnEditOrchestra.setEnabled(false);
                                btnDeleteOrchestra.setEnabled(false);
                                btnAddInstrument.setEnabled(false);
                                btnOrchestraUp.setEnabled(false);
                                btnOrchestraDown.setEnabled(false);
                                instrumentTable.setModel(new InstrumentTableModel());
                                return;
                        }
                        
                        btnEditOrchestra.setEnabled(true);
                        btnDeleteOrchestra.setEnabled(true);
                        btnAddInstrument.setEnabled(true);
                        
                        orchestraModel = orchestraTable.getSelectedOrchestra();
                        int idx = orchestraTable.getSelectedRow();
                        btnOrchestraUp.setEnabled(idx != 0);
                        btnOrchestraDown.setEnabled(idx != orchestraTable.getRowCount() - 1);
                        
                        instrumentTable.getModel().setOrchestraModel(orchestraModel);
                }
        }
        
        private class InstrumentSelectionHandler implements ListSelectionListener {
                public void
                valueChanged(ListSelectionEvent e) {
                        if(e.getValueIsAdjusting()) return;
                        
                        if(instrumentTable.getSelectedInstrument() == null) {
                                btnEditInstrument.setEnabled(false);
                                btnDeleteInstrument.setEnabled(false);
                                btnInstrumentUp.setEnabled(false);
                                btnInstrumentDown.setEnabled(false);
                                return;
                        }
                        
                        btnEditInstrument.setEnabled(true);
                        btnDeleteInstrument.setEnabled(true);
                        
                        int idx = instrumentTable.getSelectedRow();
                        btnInstrumentUp.setEnabled(idx != 0);
                        btnInstrumentDown.setEnabled(idx != instrumentTable.getRowCount() - 1);
                }
        }
        
        private class AddOrchestra extends AbstractAction {
                AddOrchestra() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.ttAddOrchestra");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconNew16);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        AddOrchestraDlg dlg = new AddOrchestraDlg();
                        dlg.setVisible(true);
                        
                        if(dlg.isCancelled()) return;
                        
                        OrchestraModel om = orchestraTable.getSelectedOrchestra();
                        int idx = CC.getOrchestras().getOrchestraIndex(om);
                        if(idx < 0) CC.getOrchestras().addOrchestra(dlg.getOrchestra());
                        else CC.getOrchestras().insertOrchestra(dlg.getOrchestra(), idx);
                        
                        orchestraTable.setSelectedOrchestra(dlg.getOrchestra());
                }
        }
        
        private class EditOrchestra extends AbstractAction {
                EditOrchestra() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.ttEditOrchestra");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconEdit16);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        OrchestraModel m = orchestraTable.getSelectedOrchestra();
                        AddOrchestraDlg dlg = new AddOrchestraDlg(m);
                        dlg.setVisible(true);
                }
        }
        
        private class DeleteOrchestra extends AbstractAction {
                DeleteOrchestra() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.ttDeleteOrchestra");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconDelete16);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        OrchestraModel om = orchestraTable.getSelectedOrchestra();
                        if(om == null) return;
                        if(om.getInstrumentCount() > 0) {
                                String s = i18n.getMessage("ManageOrchestrasPage.removeOrchestra?");
                                if(!HF.showYesNoDialog(CC.getMainFrame(), s)) return;
                        }
                        
                        CC.getOrchestras().removeOrchestra(om);
                }
        }
        
        private class OrchestraUp extends AbstractAction {
                OrchestraUp() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.OrchestraUp");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconUp16);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        OrchestraModel om = orchestraTable.getSelectedOrchestra();
                        CC.getOrchestras().moveOrchestraUp(om);
                        orchestraTable.setSelectedOrchestra(om);
                }
        }
        
        private class OrchestraDown extends AbstractAction {
                OrchestraDown() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.OrchestraDown");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconDown16);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        OrchestraModel om = orchestraTable.getSelectedOrchestra();
                        CC.getOrchestras().moveOrchestraDown(om);
                        orchestraTable.setSelectedOrchestra(om);
                }
        }
        
        private class AddInstrument extends AbstractAction {
                AddInstrument() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.ttAddInstrument");
                        putValue(SHORT_DESCRIPTION, s);
                        
                        try {
                                putValue(Action.SMALL_ICON, Res.iconNew16);
                        } catch(Exception x) {
                                CC.getLogger().log(Level.INFO, HF.getErrorMessage(x), x);
                        }
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        AddInstrumentDlg dlg = new AddInstrumentDlg();
                        dlg.setVisible(true);
                        
                        if(dlg.isCancelled()) return;
                        
                        orchestraModel.addInstrument(dlg.getInstrument());
                }
        }
        
        private class EditInstrument extends AbstractAction {
                EditInstrument() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.ttEditInstrument");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconEdit16);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        Instrument instr = instrumentTable.getSelectedInstrument();
                        AddInstrumentDlg dlg = new AddInstrumentDlg(instr);
                        dlg.setVisible(true);
                }
        }
        
        private class DeleteInstrument extends AbstractAction {
                DeleteInstrument() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.ttDeleteInstrument");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconDelete16);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        Instrument instr = instrumentTable.getSelectedInstrument();
                        if(instr == null) return;
                        orchestraModel.removeInstrument(instr);
                }
        }
        
        private class InstrumentUp extends AbstractAction {
                InstrumentUp() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.InstrumentUp");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconUp16);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        Instrument instr = instrumentTable.getSelectedInstrument();
                        instrumentTable.getModel().getOrchestraModel().moveInstrumentUp(instr);
                        instrumentTable.setSelectedInstrument(instr);
                }
        }
        
        private class InstrumentDown extends AbstractAction {
                InstrumentDown() {
                        super("");
                        
                        String s = i18n.getLabel("ManageOrchestrasPage.InstrumentDown");
                        putValue(SHORT_DESCRIPTION, s);
                        putValue(Action.SMALL_ICON, Res.iconDown16);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        Instrument instr = instrumentTable.getSelectedInstrument();
                        instrumentTable.getModel().getOrchestraModel().moveInstrumentDown(instr);
                        instrumentTable.setSelectedInstrument(instr);
                }
        }
}
1	iliev	913	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4	iliev	1143	* Copyright (C) 2005-2006 Grigor Iliev <grigor@grigoriliev.com>
5	iliev	913	*
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.classic;
24
25			import java.awt.Dimension;
26
27			import java.awt.datatransfer.DataFlavor;
28
29			import java.awt.event.ActionEvent;
30			import java.awt.event.ActionListener;
31			import java.awt.event.MouseAdapter;
32			import java.awt.event.MouseEvent;
33
34			import java.util.logging.Level;
35
36			import javax.swing.AbstractAction;
37			import javax.swing.Action;
38			import javax.swing.Box;
39			import javax.swing.BoxLayout;
40			import javax.swing.JComponent;
41			import javax.swing.JPanel;
42			import javax.swing.JScrollPane;
43			import javax.swing.JSplitPane;
44			import javax.swing.JToolBar;
45			import javax.swing.ListSelectionModel;
46			import javax.swing.TransferHandler;
47
48			import javax.swing.event.ListSelectionEvent;
49			import javax.swing.event.ListSelectionListener;
50
51			import net.sf.juife.JuifeUtils;
52			import net.sf.juife.LinkButton;
53			import net.sf.juife.NavigationPage;
54
55			import org.jsampler.CC;
56			import org.jsampler.DOMUtils;
57			import org.jsampler.DefaultOrchestraModel;
58			import org.jsampler.HF;
59			import org.jsampler.Instrument;
60			import org.jsampler.OrchestraListModel;
61			import org.jsampler.OrchestraModel;
62
63			import org.jsampler.view.InstrumentTable;
64			import org.jsampler.view.InstrumentTableModel;
65			import org.jsampler.view.OrchestraTable;
66			import org.jsampler.view.OrchestraTableModel;
67
68			import static org.jsampler.view.classic.ClassicI18n.i18n;
69
70
71			/**
72			*
73			* @author Grigor Iliev
74			*/
75			public class ManageOrchestrasPage extends NavigationPage {
76			private final JComponent manageOrchestrasPane;
77
78			// Manage Orchestra
79			private final ToolbarButton btnAddOrchestra = new ToolbarButton(new AddOrchestra());
80			private final ToolbarButton btnEditOrchestra = new ToolbarButton(new EditOrchestra());
81			private final ToolbarButton btnDeleteOrchestra = new ToolbarButton(new DeleteOrchestra());
82			private final ToolbarButton btnOrchestraUp = new ToolbarButton(new OrchestraUp());
83			private final ToolbarButton btnOrchestraDown = new ToolbarButton(new OrchestraDown());
84
85			private OrchestraTable orchestraTable;
86
87			private final ToolbarButton btnAddInstrument = new ToolbarButton(new AddInstrument());
88			private final ToolbarButton btnEditInstrument = new ToolbarButton(new EditInstrument());
89			private final ToolbarButton btnDeleteInstrument = new ToolbarButton(new DeleteInstrument());
90			private final ToolbarButton btnInstrumentUp = new ToolbarButton(new InstrumentUp());
91			private final ToolbarButton btnInstrumentDown = new ToolbarButton(new InstrumentDown());
92
93			private LinkButton lnkOrchestras =
94			new LinkButton(i18n.getButtonLabel("ManageOrchestrasPage.lnkOrchestras"));
95
96			private InstrumentTable instrumentTable;
97			private OrchestraModel orchestraModel;
98
99
100			/** Creates a new instance of <code>ManageOrchestrasPage</code>. */
101			public ManageOrchestrasPage() {
102			setTitle(i18n.getLabel("ManageOrchestrasPage.title"));
103
104			setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
105
106			manageOrchestrasPane = createManageOrchestrasPane();
107			add(manageOrchestrasPane);
108
109			installListeneres();
110			}
111
112			private JComponent
113			createManageOrchestrasPane() {
114			JPanel p = new JPanel();
115			p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
116			//p.add(Box.createRigidArea(new Dimension(0, 5)));
117
118			JToolBar tb = new JToolBar();
119			tb.add(btnAddOrchestra);
120			tb.add(btnEditOrchestra);
121			tb.add(btnDeleteOrchestra);
122
123			tb.addSeparator();
124
125			tb.add(btnOrchestraUp);
126			tb.add(btnOrchestraDown);
127
128			tb.setMaximumSize(new Dimension(Short.MAX_VALUE, tb.getPreferredSize().height));
129			tb.setFloatable(false);
130			tb.setAlignmentX(LEFT_ALIGNMENT);
131
132			p.add(tb);
133
134			orchestraTable = new OrchestraTable(new OrchestraTableModel(CC.getOrchestras()));
135			JScrollPane sp = new JScrollPane(orchestraTable);
136
137			sp.getViewport().addMouseListener(new MouseAdapter() {
138			public void
139			mouseClicked(MouseEvent e) { orchestraTable.clearSelection(); }
140			});
141
142			Dimension d;
143			d = new Dimension(sp.getMinimumSize().width, sp.getPreferredSize().height);
144			sp.setPreferredSize(d);
145
146			sp.setAlignmentX(LEFT_ALIGNMENT);
147			p.add(sp);
148
149			JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
150	iliev	1143	splitPane.setContinuousLayout(true);
151	iliev	913	splitPane.setTopComponent(p);
152
153			p = new JPanel();
154			p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
155			//p.add(Box.createRigidArea(new Dimension(0, 5)));
156
157			tb = new JToolBar();
158			btnAddInstrument.setEnabled(false);
159			tb.add(btnAddInstrument);
160			tb.add(btnEditInstrument);
161			tb.add(btnDeleteInstrument);
162
163			tb.addSeparator();
164
165			tb.add(btnInstrumentUp);
166			tb.add(btnInstrumentDown);
167
168			tb.setMaximumSize(new Dimension(Short.MAX_VALUE, tb.getPreferredSize().height));
169			tb.setFloatable(false);
170			tb.setAlignmentX(JPanel.LEFT_ALIGNMENT);
171
172			p.add(tb);
173
174			orchestraModel = new DefaultOrchestraModel();
175			instrumentTable = new InstrumentTable(new InstrumentTableModel(orchestraModel));
176			sp = new DnDScrollPane(instrumentTable);
177			sp.setAlignmentX(LEFT_ALIGNMENT);
178			p.add(sp);
179
180			//p.add(lnkOrchestras);
181			//p.add(Box.createRigidArea(new Dimension(0, 5)));
182
183			splitPane.setBottomComponent(p);
184			splitPane.setDividerSize(3);
185			splitPane.setDividerLocation(180);
186
187			return splitPane;
188			}
189
190			private void
191			installListeneres() {
192			lnkOrchestras.addActionListener(new ActionListener() {
193			public void
194			actionPerformed(ActionEvent e) {
195			LeftPane.getLeftPane().showOrchestrasPage();
196			}
197			});
198
199			OrchestraSelectionHandler l = new OrchestraSelectionHandler();
200			orchestraTable.getSelectionModel().addListSelectionListener(l);
201
202			orchestraTable.addMouseListener(new MouseAdapter() {
203			public void
204			mouseClicked(MouseEvent e) {
205			if(e.getClickCount() < 2) return;
206
207			if(orchestraTable.getSelectedOrchestra() == null) return;
208			btnEditOrchestra.doClick(0);
209			}
210			});
211
212			InstrumentSelectionHandler l2 = new InstrumentSelectionHandler();
213			instrumentTable.getSelectionModel().addListSelectionListener(l2);
214
215			instrumentTable.addMouseListener(new MouseAdapter() {
216			public void
217			mouseClicked(MouseEvent e) {
218			if(e.getClickCount() < 2) return;
219
220			if(instrumentTable.getSelectedInstrument() == null) return;
221			btnEditInstrument.doClick(0);
222			}
223			});
224			}
225
226			public class DnDScrollPane extends JScrollPane {
227			private InstrumentTable instrumentTable;
228
229			private
230			DnDScrollPane(InstrumentTable table) {
231			instrumentTable = table;
232			setViewport(new DnDViewPort());
233			setViewportView(instrumentTable);
234
235			Dimension d;
236			d = new Dimension(getMinimumSize().width, getPreferredSize().height);
237			setPreferredSize(d);
238			}
239
240			public class DnDViewPort extends javax.swing.JViewport {
241			private
242			DnDViewPort() {
243			setTransferHandler(new TransferHandler("instrument") {
244			public boolean
245			canImport(JComponent comp, DataFlavor[] flavors) {
246			if(instrumentTable.isPerformingDnD()) return false;
247			if(!btnAddInstrument.isEnabled()) return false;
248
249			return super.canImport(comp, flavors);
250			}
251			});
252
253			addMouseListener(new MouseAdapter() {
254			public void
255			mouseClicked(MouseEvent e) {
256			instrumentTable.clearSelection();
257			}
258			});
259			}
260
261			public String
262			getInstrument() { return null; }
263
264			public void
265			setInstrument(String instr) {
266			instrumentTable.setSelectedInstrument(null);
267			instrumentTable.setInstrument(instr);
268			}
269			}
270			}
271
272			private class OrchestraSelectionHandler implements ListSelectionListener {
273			public void
274			valueChanged(ListSelectionEvent e) {
275			if(e.getValueIsAdjusting()) return;
276
277			if(orchestraTable.getSelectedOrchestra() == null) {
278			btnEditOrchestra.setEnabled(false);
279			btnDeleteOrchestra.setEnabled(false);
280			btnAddInstrument.setEnabled(false);
281			btnOrchestraUp.setEnabled(false);
282			btnOrchestraDown.setEnabled(false);
283			instrumentTable.setModel(new InstrumentTableModel());
284			return;
285			}
286
287			btnEditOrchestra.setEnabled(true);
288			btnDeleteOrchestra.setEnabled(true);
289			btnAddInstrument.setEnabled(true);
290
291			orchestraModel = orchestraTable.getSelectedOrchestra();
292			int idx = orchestraTable.getSelectedRow();
293			btnOrchestraUp.setEnabled(idx != 0);
294			btnOrchestraDown.setEnabled(idx != orchestraTable.getRowCount() - 1);
295
296			instrumentTable.getModel().setOrchestraModel(orchestraModel);
297			}
298			}
299
300			private class InstrumentSelectionHandler implements ListSelectionListener {
301			public void
302			valueChanged(ListSelectionEvent e) {
303			if(e.getValueIsAdjusting()) return;
304
305			if(instrumentTable.getSelectedInstrument() == null) {
306			btnEditInstrument.setEnabled(false);
307			btnDeleteInstrument.setEnabled(false);
308			btnInstrumentUp.setEnabled(false);
309			btnInstrumentDown.setEnabled(false);
310			return;
311			}
312
313			btnEditInstrument.setEnabled(true);
314			btnDeleteInstrument.setEnabled(true);
315
316			int idx = instrumentTable.getSelectedRow();
317			btnInstrumentUp.setEnabled(idx != 0);
318			btnInstrumentDown.setEnabled(idx != instrumentTable.getRowCount() - 1);
319			}
320			}
321
322			private class AddOrchestra extends AbstractAction {
323			AddOrchestra() {
324			super("");
325
326			String s = i18n.getLabel("ManageOrchestrasPage.ttAddOrchestra");
327			putValue(SHORT_DESCRIPTION, s);
328			putValue(Action.SMALL_ICON, Res.iconNew16);
329			}
330
331			public void
332			actionPerformed(ActionEvent e) {
333			AddOrchestraDlg dlg = new AddOrchestraDlg();
334			dlg.setVisible(true);
335
336			if(dlg.isCancelled()) return;
337
338			OrchestraModel om = orchestraTable.getSelectedOrchestra();
339			int idx = CC.getOrchestras().getOrchestraIndex(om);
340			if(idx < 0) CC.getOrchestras().addOrchestra(dlg.getOrchestra());
341			else CC.getOrchestras().insertOrchestra(dlg.getOrchestra(), idx);
342
343			orchestraTable.setSelectedOrchestra(dlg.getOrchestra());
344			}
345			}
346
347			private class EditOrchestra extends AbstractAction {
348			EditOrchestra() {
349			super("");
350
351			String s = i18n.getLabel("ManageOrchestrasPage.ttEditOrchestra");
352			putValue(SHORT_DESCRIPTION, s);
353			putValue(Action.SMALL_ICON, Res.iconEdit16);
354
355			setEnabled(false);
356			}
357
358			public void
359			actionPerformed(ActionEvent e) {
360			OrchestraModel m = orchestraTable.getSelectedOrchestra();
361			AddOrchestraDlg dlg = new AddOrchestraDlg(m);
362			dlg.setVisible(true);
363			}
364			}
365
366			private class DeleteOrchestra extends AbstractAction {
367			DeleteOrchestra() {
368			super("");
369
370			String s = i18n.getLabel("ManageOrchestrasPage.ttDeleteOrchestra");
371			putValue(SHORT_DESCRIPTION, s);
372			putValue(Action.SMALL_ICON, Res.iconDelete16);
373
374			setEnabled(false);
375			}
376
377			public void
378			actionPerformed(ActionEvent e) {
379			OrchestraModel om = orchestraTable.getSelectedOrchestra();
380			if(om == null) return;
381			if(om.getInstrumentCount() > 0) {
382			String s = i18n.getMessage("ManageOrchestrasPage.removeOrchestra?");
383			if(!HF.showYesNoDialog(CC.getMainFrame(), s)) return;
384			}
385
386			CC.getOrchestras().removeOrchestra(om);
387			}
388			}
389
390			private class OrchestraUp extends AbstractAction {
391			OrchestraUp() {
392			super("");
393
394			String s = i18n.getLabel("ManageOrchestrasPage.OrchestraUp");
395			putValue(SHORT_DESCRIPTION, s);
396			putValue(Action.SMALL_ICON, Res.iconUp16);
397
398			setEnabled(false);
399			}
400
401			public void
402			actionPerformed(ActionEvent e) {
403			OrchestraModel om = orchestraTable.getSelectedOrchestra();
404			CC.getOrchestras().moveOrchestraUp(om);
405			orchestraTable.setSelectedOrchestra(om);
406			}
407			}
408
409			private class OrchestraDown extends AbstractAction {
410			OrchestraDown() {
411			super("");
412
413			String s = i18n.getLabel("ManageOrchestrasPage.OrchestraDown");
414			putValue(SHORT_DESCRIPTION, s);
415			putValue(Action.SMALL_ICON, Res.iconDown16);
416
417			setEnabled(false);
418			}
419
420			public void
421			actionPerformed(ActionEvent e) {
422			OrchestraModel om = orchestraTable.getSelectedOrchestra();
423			CC.getOrchestras().moveOrchestraDown(om);
424			orchestraTable.setSelectedOrchestra(om);
425			}
426			}
427
428			private class AddInstrument extends AbstractAction {
429			AddInstrument() {
430			super("");
431
432			String s = i18n.getLabel("ManageOrchestrasPage.ttAddInstrument");
433			putValue(SHORT_DESCRIPTION, s);
434
435			try {
436			putValue(Action.SMALL_ICON, Res.iconNew16);
437			} catch(Exception x) {
438			CC.getLogger().log(Level.INFO, HF.getErrorMessage(x), x);
439			}
440			}
441
442			public void
443			actionPerformed(ActionEvent e) {
444			AddInstrumentDlg dlg = new AddInstrumentDlg();
445			dlg.setVisible(true);
446
447			if(dlg.isCancelled()) return;
448
449			orchestraModel.addInstrument(dlg.getInstrument());
450			}
451			}
452
453			private class EditInstrument extends AbstractAction {
454			EditInstrument() {
455			super("");
456
457			String s = i18n.getLabel("ManageOrchestrasPage.ttEditInstrument");
458			putValue(SHORT_DESCRIPTION, s);
459			putValue(Action.SMALL_ICON, Res.iconEdit16);
460
461			setEnabled(false);
462			}
463
464			public void
465			actionPerformed(ActionEvent e) {
466			Instrument instr = instrumentTable.getSelectedInstrument();
467			AddInstrumentDlg dlg = new AddInstrumentDlg(instr);
468			dlg.setVisible(true);
469			}
470			}
471
472			private class DeleteInstrument extends AbstractAction {
473			DeleteInstrument() {
474			super("");
475
476			String s = i18n.getLabel("ManageOrchestrasPage.ttDeleteInstrument");
477			putValue(SHORT_DESCRIPTION, s);
478			putValue(Action.SMALL_ICON, Res.iconDelete16);
479
480			setEnabled(false);
481			}
482
483			public void
484			actionPerformed(ActionEvent e) {
485			Instrument instr = instrumentTable.getSelectedInstrument();
486			if(instr == null) return;
487			orchestraModel.removeInstrument(instr);
488			}
489			}
490
491			private class InstrumentUp extends AbstractAction {
492			InstrumentUp() {
493			super("");
494
495			String s = i18n.getLabel("ManageOrchestrasPage.InstrumentUp");
496			putValue(SHORT_DESCRIPTION, s);
497			putValue(Action.SMALL_ICON, Res.iconUp16);
498
499			setEnabled(false);
500			}
501
502			public void
503			actionPerformed(ActionEvent e) {
504			Instrument instr = instrumentTable.getSelectedInstrument();
505			instrumentTable.getModel().getOrchestraModel().moveInstrumentUp(instr);
506			instrumentTable.setSelectedInstrument(instr);
507			}
508			}
509
510			private class InstrumentDown extends AbstractAction {
511			InstrumentDown() {
512			super("");
513
514			String s = i18n.getLabel("ManageOrchestrasPage.InstrumentDown");
515			putValue(SHORT_DESCRIPTION, s);
516			putValue(Action.SMALL_ICON, Res.iconDown16);
517
518			setEnabled(false);
519			}
520
521			public void
522			actionPerformed(ActionEvent e) {
523			Instrument instr = instrumentTable.getSelectedInstrument();
524			instrumentTable.getModel().getOrchestraModel().moveInstrumentDown(instr);
525			instrumentTable.setSelectedInstrument(instr);
526			}
527			}
528			}