Subversion Repositories svn.mios

Rev

Rev 757 | Rev 800 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 757 Rev 762
1
/*
1
/*
2
 * @(#)MIOSStudioGUI.java   beta8   2006/04/23
2
 * @(#)MIOSStudioGUI.java   beta8   2006/04/23
3
 *
3
 *
4
 * Copyright (C) 2008    Adam King (adamjking@optusnet.com.au)
4
 * Copyright (C) 2008    Adam King (adamjking@optusnet.com.au)
5
 *
5
 *
6
 * This application is free software; you can redistribute it and/or modify
6
 * This application is free software; you can redistribute it and/or modify
7
 * it under the terms of the GNU General Public License as published by
7
 * it under the terms of the GNU General Public License as published by
8
 * the Free Software Foundation; either version 2 of the License, or
8
 * the Free Software Foundation; either version 2 of the License, or
9
 * (at your option) any later version.
9
 * (at your option) any later version.
10
 *
10
 *
11
 * This application is distributed in the hope that it will be useful,
11
 * This application is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 * GNU General Public License for more details.
14
 * GNU General Public License for more details.
15
 *
15
 *
16
 * You should have received a copy of the GNU General Public License
16
 * You should have received a copy of the GNU General Public License
17
 * along with this application; if not, write to the Free Software
17
 * along with this application; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 */
19
 */
20
20
21
package org.midibox.apps.miosstudio.gui;
21
package org.midibox.apps.miosstudio.gui;
22
22
23
import java.awt.BorderLayout;
23
import java.awt.BorderLayout;
24
import java.awt.Color;
24
import java.awt.Color;
25
import java.awt.Dimension;
25
import java.awt.Dimension;
26
import java.awt.FontMetrics;
26
import java.awt.FontMetrics;
27
import java.awt.Graphics;
27
import java.awt.Graphics;
28
import java.awt.Graphics2D;
28
import java.awt.Graphics2D;
29
import java.awt.GridBagConstraints;
29
import java.awt.GridBagConstraints;
30
import java.awt.GridBagLayout;
30
import java.awt.GridBagLayout;
31
import java.awt.Insets;
31
import java.awt.Insets;
32
import java.awt.event.ActionEvent;
32
import java.awt.event.ActionEvent;
33
import java.awt.event.ActionListener;
33
import java.awt.event.ActionListener;
34
import java.awt.event.KeyEvent;
34
import java.awt.event.KeyEvent;
35
import java.awt.event.MouseEvent;
35
import java.awt.event.MouseEvent;
36
import java.awt.event.MouseListener;
36
import java.awt.event.MouseListener;
37
import java.awt.event.WindowAdapter;
37
import java.awt.event.WindowAdapter;
38
import java.awt.event.WindowEvent;
38
import java.awt.event.WindowEvent;
39
import java.beans.PropertyChangeEvent;
39
import java.beans.PropertyChangeEvent;
40
import java.beans.PropertyChangeListener;
40
import java.beans.PropertyChangeListener;
41
import java.io.File;
41
import java.io.File;
42
import java.net.URL;
42
import java.net.URL;
43
import java.util.Iterator;
43
import java.util.Iterator;
44
import java.util.Observable;
44
import java.util.Observable;
45
import java.util.Observer;
45
import java.util.Observer;
46
import java.util.Vector;
46
import java.util.Vector;
47
47
48
import javax.swing.Box;
48
import javax.swing.Box;
49
import javax.swing.ButtonGroup;
-
 
50
import javax.swing.Icon;
49
import javax.swing.Icon;
51
import javax.swing.ImageIcon;
50
import javax.swing.ImageIcon;
52
import javax.swing.JButton;
51
import javax.swing.JButton;
53
import javax.swing.JCheckBox;
52
import javax.swing.JCheckBox;
54
import javax.swing.JCheckBoxMenuItem;
53
import javax.swing.JCheckBoxMenuItem;
55
import javax.swing.JComponent;
54
import javax.swing.JComponent;
56
import javax.swing.JDesktopPane;
55
import javax.swing.JDesktopPane;
57
import javax.swing.JDialog;
56
import javax.swing.JDialog;
58
import javax.swing.JFileChooser;
57
import javax.swing.JFileChooser;
59
import javax.swing.JInternalFrame;
58
import javax.swing.JInternalFrame;
60
import javax.swing.JLabel;
59
import javax.swing.JLabel;
61
import javax.swing.JMenu;
60
import javax.swing.JMenu;
62
import javax.swing.JMenuBar;
61
import javax.swing.JMenuBar;
63
import javax.swing.JMenuItem;
62
import javax.swing.JMenuItem;
64
import javax.swing.JOptionPane;
63
import javax.swing.JOptionPane;
65
import javax.swing.JPanel;
64
import javax.swing.JPanel;
66
import javax.swing.JPopupMenu;
65
import javax.swing.JPopupMenu;
67
import javax.swing.JRadioButton;
-
 
68
import javax.swing.JSeparator;
66
import javax.swing.JSeparator;
69
import javax.swing.JTextField;
67
import javax.swing.JTextField;
70
import javax.swing.JToolBar;
68
import javax.swing.JToolBar;
71
import javax.swing.KeyStroke;
69
import javax.swing.KeyStroke;
72
import javax.swing.UIManager;
70
import javax.swing.UIManager;
73
import javax.swing.event.MenuEvent;
71
import javax.swing.event.MenuEvent;
74
import javax.swing.event.MenuListener;
72
import javax.swing.event.MenuListener;
75
import javax.swing.event.PopupMenuEvent;
73
import javax.swing.event.PopupMenuEvent;
76
import javax.swing.event.PopupMenuListener;
74
import javax.swing.event.PopupMenuListener;
77
75
78
import org.midibox.apps.miosstudio.MIOSStudio;
76
import org.midibox.apps.miosstudio.MIOSStudio;
79
import org.midibox.apps.miosstudio.gui.xml.MIOSStudioGUIXML;
77
import org.midibox.apps.miosstudio.gui.xml.MIOSStudioGUIXML;
80
import org.midibox.apps.miosstudio.xml.MIOSStudioXML;
78
import org.midibox.apps.miosstudio.xml.MIOSStudioXML;
81
import org.midibox.midi.MidiFilterDevice;
79
import org.midibox.midi.MidiFilterDevice;
82
import org.midibox.midi.MidiKeyboardControllerDevice;
80
import org.midibox.midi.MidiKeyboardControllerDevice;
83
import org.midibox.midi.MidiRouterDevice;
81
import org.midibox.midi.MidiRouterDevice;
84
import org.midibox.midi.SysexSendReceiveDevice;
82
import org.midibox.midi.SysexSendReceiveDevice;
85
import org.midibox.midi.gui.MidiDeviceManagerGUI;
83
import org.midibox.midi.gui.MidiDeviceManagerGUI;
86
import org.midibox.midi.gui.MidiDeviceRoutingGUI;
84
import org.midibox.midi.gui.MidiDeviceRoutingGUI;
87
import org.midibox.midi.gui.MidiFilterDeviceManagerGUI;
85
import org.midibox.midi.gui.MidiFilterDeviceManagerGUI;
88
import org.midibox.midi.gui.MidiFilterGUI;
86
import org.midibox.midi.gui.MidiFilterGUI;
89
import org.midibox.midi.gui.MidiKeyboardControllerGUI;
87
import org.midibox.midi.gui.MidiKeyboardControllerGUI;
90
import org.midibox.midi.gui.MidiMonitorFilteredGUI;
88
import org.midibox.midi.gui.MidiMonitorFilteredGUI;
91
import org.midibox.mios.HexFileUploadDevice;
89
import org.midibox.mios.HexFileUploadDevice;
92
import org.midibox.mios.gui.DebugFunctionGUI;
90
import org.midibox.mios.gui.DebugFunctionGUI;
93
import org.midibox.mios.gui.HexFileUploadDeviceManagerGUI;
91
import org.midibox.mios.gui.HexFileUploadDeviceManagerGUI;
94
import org.midibox.mios.gui.LCDMessageGUI;
92
import org.midibox.mios.gui.LCDMessageGUI;
95
import org.midibox.utils.ResourceLoader;
93
import org.midibox.utils.ResourceLoader;
96
import org.midibox.utils.gui.DialogOwner;
94
import org.midibox.utils.gui.DialogOwner;
97
import org.midibox.utils.gui.FontLoader;
95
import org.midibox.utils.gui.FontLoader;
98
import org.midibox.utils.gui.HelpPane;
96
import org.midibox.utils.gui.HelpPane;
99
import org.midibox.utils.gui.ImageLoader;
97
import org.midibox.utils.gui.ImageLoader;
100
import org.midibox.utils.gui.SimpleFileChooserFilter;
98
import org.midibox.utils.gui.SimpleFileChooserFilter;
101
import org.midibox.utils.gui.SplitButton;
99
import org.midibox.utils.gui.SplitButton;
102
100
103
public class MIOSStudioGUI extends JPanel implements ActionListener,
101
public class MIOSStudioGUI extends JPanel implements ActionListener,
104
        MouseListener, PropertyChangeListener, MenuListener, Observer {
102
        MouseListener, PropertyChangeListener, MenuListener, Observer {
105
103
106
    protected MIOSStudio miosStudio;
104
    protected MIOSStudio miosStudio;
107
105
108
    private JDesktopPane desktop;
106
    private JDesktopPane desktop;
109
107
110
    private HelpPane helpPane;
108
    private HelpPane helpPane;
111
109
112
    protected Vector internalFrames;
110
    protected Vector internalFrames;
113
111
114
    private MIOSStudioInternalFrame helpWindow;
112
    private MIOSStudioInternalFrame helpWindow;
115
113
116
    private JDialog midiDeviceManagerDialog;
114
    private JDialog midiDeviceManagerDialog;
117
115
118
    private JDialog midiFilterManagerDialog;
116
    private JDialog midiFilterManagerDialog;
119
117
120
    protected MidiDeviceRoutingGUI midiDeviceRoutingGUI;
118
    protected MidiDeviceRoutingGUI midiDeviceRoutingGUI;
121
119
122
    private MIOSStudioInternalFrame midiDeviceRoutingWindow;
120
    private MIOSStudioInternalFrame midiDeviceRoutingWindow;
123
121
124
    private MidiMonitorFilteredGUI midiOutPortMonitorGUI;
122
    private MidiMonitorFilteredGUI midiOutPortMonitorGUI;
125
123
126
    private MIOSStudioInternalFrame midiOutPortMonitorWindow;
124
    private MIOSStudioInternalFrame midiOutPortMonitorWindow;
127
125
128
    private MidiMonitorFilteredGUI midiInPortMonitorGUI;
126
    private MidiMonitorFilteredGUI midiInPortMonitorGUI;
129
127
130
    private MIOSStudioInternalFrame midiInPortMonitorWindow;
128
    private MIOSStudioInternalFrame midiInPortMonitorWindow;
131
129
132
    private MidiKeyboardControllerGUI midiKeyboardControllerGUI;
130
    private MidiKeyboardControllerGUI midiKeyboardControllerGUI;
133
131
134
    private MIOSStudioInternalFrame midiKeyboardControllerWindow;
132
    private MIOSStudioInternalFrame midiKeyboardControllerWindow;
135
133
136
    /*
134
    /*
137
     * private SysexSendReceiveDeviceManagerGUI
135
     * private SysexSendReceiveDeviceManagerGUI
138
     * sysexSendReceiveDeviceManagerGUI;
136
     * sysexSendReceiveDeviceManagerGUI;
139
     *
137
     *
140
     * private MIOSStudioInternalFrame sysexSendReceiveDeviceManagerWindow;
138
     * private MIOSStudioInternalFrame sysexSendReceiveDeviceManagerWindow;
141
     */
139
     */
142
140
143
    private HexFileUploadDeviceManagerGUI hexFileUploadDeviceManagerGUI;
141
    private HexFileUploadDeviceManagerGUI hexFileUploadDeviceManagerGUI;
144
142
145
    private MIOSStudioInternalFrame hexFileUploadDeviceManagerWindow;
143
    private MIOSStudioInternalFrame hexFileUploadDeviceManagerWindow;
146
144
147
    /*
145
    /*
148
     * private MemoryReadWriteGUI memoryReadWriteGUI;
146
     * private MemoryReadWriteGUI memoryReadWriteGUI;
149
     */
147
     */
150
148
151
    private LCDMessageGUI lcdMessageGUI;
149
    private LCDMessageGUI lcdMessageGUI;
152
150
153
    private MIOSStudioInternalFrame lcdMessageWindow;
151
    private MIOSStudioInternalFrame lcdMessageWindow;
154
152
155
    private DebugFunctionGUI debugFunctionGUI;
153
    private DebugFunctionGUI debugFunctionGUI;
156
154
157
    private MIOSStudioInternalFrame debugFunctionWindow;
155
    private MIOSStudioInternalFrame debugFunctionWindow;
158
156
159
    private MidiMonitorFilteredGUI miosTerminalGUI;
157
    private MidiMonitorFilteredGUI miosTerminalGUI;
160
158
161
    private MIOSStudioInternalFrame miosTerminalWindow;
159
    private MIOSStudioInternalFrame miosTerminalWindow;
162
160
163
    private JDialog thruFilterProperties;
161
    private JDialog thruFilterProperties;
164
162
165
    /*
163
    /*
166
     * private JDialog thruMapProperties;
164
     * private JDialog thruMapProperties;
167
     */
165
     */
168
    protected JToolBar toolBar;
166
    protected JToolBar toolBar;
169
167
170
    protected JPopupMenu toolBarMenu;
168
    protected JPopupMenu toolBarMenu;
171
169
172
    private ExternalButtonProperties externalButtonProperties;
170
    private ExternalButtonProperties externalButtonProperties;
173
171
174
    private Vector externalCommands = new Vector();
172
    private Vector externalCommands = new Vector();
175
173
176
    protected JMenu fileMenu;
174
    protected JMenu fileMenu;
177
175
178
    protected JMenu midiMenu;
176
    protected JMenu midiMenu;
179
177
180
    protected JMenu miosMenu;
178
    protected JMenu miosMenu;
181
179
182
    protected JMenu optionsMenu;
180
    protected JMenu optionsMenu;
183
181
184
    protected WindowMenu windowMenu;
182
    protected WindowMenu windowMenu;
185
183
186
    protected JMenu helpMenu;
184
    protected JMenu helpMenu;
187
185
188
    private JMenuItem midiThruMenuItem;
186
    private JMenuItem midiThruMenuItem;
189
187
190
    private JCheckBoxMenuItem showInternalMenuItem;
188
    private JCheckBoxMenuItem showInternalMenuItem;
191
189
192
    private JMenu lookAndFeelMenu;
190
    private JMenu lookAndFeelMenu;
193
191
194
    private String lookAndFeel;
192
    private String lookAndFeel;
195
193
196
    private JLabel commentLabel;
194
    private JLabel commentLabel;
197
195
198
    private JMenu MRUMenu;
196
    private JMenu MRUMenu;
199
197
200
    private JPopupMenu MRUPopupMenu;
198
    private JPopupMenu MRUPopupMenu;
201
199
202
    private SplitButton openMRUButton;
200
    private SplitButton openMRUButton;
203
201
204
    private static int maxMRU = 10;
202
    private static int maxMRU = 10;
205
203
206
    private static String currentDirectory = "";
204
    private static String currentDirectory = "";
207
205
208
    private static Vector MRU = new Vector();
206
    private static Vector MRU = new Vector();
209
207
210
    private static JFileChooser fc = null;
208
    private static JFileChooser fc = null;
211
209
212
    public MIOSStudioGUI(MIOSStudio miosStudio) {
210
    public MIOSStudioGUI(MIOSStudio miosStudio) {
213
211
214
        super(new BorderLayout());
212
        super(new BorderLayout());
215
213
216
        this.miosStudio = miosStudio;
214
        this.miosStudio = miosStudio;
217
215
218
        miosStudio.addObserver(this);
216
        miosStudio.addObserver(this);
219
217
220
        lookAndFeel = UIManager.getLookAndFeel().getClass().getName();
218
        lookAndFeel = UIManager.getLookAndFeel().getClass().getName();
221
219
222
        add(createToolBar(), BorderLayout.NORTH);
220
        add(createToolBar(), BorderLayout.NORTH);
223
        add(createMainPanel(), BorderLayout.CENTER);
221
        add(createMainPanel(), BorderLayout.CENTER);
224
        add(createCommentBar(), BorderLayout.SOUTH);
222
        add(createCommentBar(), BorderLayout.SOUTH);
225
    }
223
    }
226
224
227
    private JDesktopPane createMainPanel() {
225
    private JDesktopPane createMainPanel() {
228
        desktop = new JDesktopPane() {
226
        desktop = new JDesktopPane() {
229
            ImageIcon backgroundImage = ImageLoader
227
            ImageIcon backgroundImage = ImageLoader
230
                    .getImageIcon("logo_watermark.png");
228
                    .getImageIcon("logo_watermark.png");
231
229
232
            public void paintComponent(Graphics g) {
230
            public void paintComponent(Graphics g) {
233
                super.paintComponent(g);
231
                super.paintComponent(g);
234
                backgroundImage
232
                backgroundImage
235
                        .paintIcon(this, g, (this.getWidth() - backgroundImage
233
                        .paintIcon(this, g, (this.getWidth() - backgroundImage
236
                                .getIconWidth()) - 20,
234
                                .getIconWidth()) - 20,
237
                                (this.getHeight() - backgroundImage
235
                                (this.getHeight() - backgroundImage
238
                                        .getIconHeight()) - 20);
236
                                        .getIconHeight()) - 20);
239
            }
237
            }
240
        }; // JDesktop pane with paint method overridden to display watermark
238
        }; // JDesktop pane with paint method overridden to display watermark
241
239
242
        desktop.setBackground(Color.WHITE);
240
        desktop.setBackground(Color.WHITE);
243
241
244
        createInternalFrames();
242
        createInternalFrames();
245
243
246
        midiDeviceRoutingGUI.addMidiDeviceIcon(MidiRouterDevice.class,
244
        midiDeviceRoutingGUI.addMidiDeviceIcon(MidiRouterDevice.class,
247
                ImageLoader.getImageIcon("virtualMidiDevice.png"));
245
                ImageLoader.getImageIcon("virtualMidiDevice.png"));
248
246
249
        midiDeviceRoutingGUI.addMidiDeviceIcon(MidiFilterDevice.class,
247
        midiDeviceRoutingGUI.addMidiDeviceIcon(MidiFilterDevice.class,
250
                ImageLoader.getImageIcon("filter.png"));
248
                ImageLoader.getImageIcon("filter.png"));
251
249
252
        // start In/Out/Terminal thread
250
        // start In/Out/Terminal thread
253
        miosStudio.getMidiInPortMonitorDevice().getMidiMonitorFiltered()
251
        miosStudio.getMidiInPortMonitorDevice().getMidiMonitorFiltered()
254
                .getMidiMonitor().deleteObserver(midiInPortMonitorGUI);
252
                .getMidiMonitor().deleteObserver(midiInPortMonitorGUI);
255
253
256
        miosStudio.getMidiOutPortMonitorDevice().getMidiMonitorFiltered()
254
        miosStudio.getMidiOutPortMonitorDevice().getMidiMonitorFiltered()
257
                .getMidiMonitor().deleteObserver(midiOutPortMonitorGUI);
255
                .getMidiMonitor().deleteObserver(midiOutPortMonitorGUI);
258
256
259
        miosStudio.getMIOSTerminalDevice().getMidiMonitorFiltered()
257
        miosStudio.getMIOSTerminalDevice().getMidiMonitorFiltered()
260
                .getMidiMonitor().deleteObserver(miosTerminalGUI);
258
                .getMidiMonitor().deleteObserver(miosTerminalGUI);
261
259
262
        Thread t = new Thread() {
260
        Thread t = new Thread() {
263
261
264
            public void run() {
262
            public void run() {
265
263
266
                while (true) {
264
                while (true) {
267
265
268
                    midiInPortMonitorGUI.check();
266
                    midiInPortMonitorGUI.check();
269
                    midiOutPortMonitorGUI.check();
267
                    midiOutPortMonitorGUI.check();
270
                    miosTerminalGUI.check();
268
                    miosTerminalGUI.check();
271
269
272
                    try {
270
                    try {
273
                        Thread.sleep(50);
271
                        Thread.sleep(50);
274
                    } catch (Exception e) {
272
                    } catch (Exception e) {
275
273
276
                    }
274
                    }
277
                }
275
                }
278
            }
276
            }
279
277
280
        };
278
        };
281
279
282
        t.start();
280
        t.start();
283
281
284
        return desktop;
282
        return desktop;
285
    }
283
    }
286
284
287
    protected void createInternalFrames() {
285
    protected void createInternalFrames() {
288
286
289
        internalFrames = new Vector();
287
        internalFrames = new Vector();
290
288
291
        // Help Window
289
        // Help Window
292
290
293
        helpPane = HelpPane.createSingleton(ResourceLoader
291
        helpPane = HelpPane.createSingleton(ResourceLoader
294
                .getResource("help/index.html"));
292
                .getResource("help/index.html"));
295
        helpPane.addPropertyChangeListener(this);
293
        helpPane.addPropertyChangeListener(this);
296
294
297
        helpWindow = new MIOSStudioInternalFrame("MIOS Studio Help", true,
295
        helpWindow = new MIOSStudioInternalFrame("MIOS Studio Help", true,
298
                true, true, true, ImageLoader.getImageIcon("help.png"),
296
                true, true, true, ImageLoader.getImageIcon("help.png"),
299
                helpPane);
297
                helpPane);
300
        helpWindow.pack();
298
        helpWindow.pack();
301
299
302
        internalFrames.add(helpWindow);
300
        internalFrames.add(helpWindow);
303
301
304
        // MIDI Device Routing
302
        // MIDI Device Routing
305
303
306
        Icon icon = ImageLoader.getImageIcon("midiRouting.png");
304
        Icon icon = ImageLoader.getImageIcon("midiRouting.png");
307
        midiDeviceRoutingGUI = new MidiDeviceRoutingGUI(miosStudio
305
        midiDeviceRoutingGUI = new MidiDeviceRoutingGUI(miosStudio
308
                .getMidiDeviceRouting());
306
                .getMidiDeviceRouting());
309
307
310
        midiDeviceRoutingWindow = new MIOSStudioInternalFrame(
308
        midiDeviceRoutingWindow = new MIOSStudioInternalFrame(
311
                "MIDI Device Routing", true, // resizable
309
                "MIDI Device Routing", true, // resizable
312
                true, // closable
310
                true, // closable
313
                true, // maximizable
311
                true, // maximizable
314
                true, icon, midiDeviceRoutingGUI);
312
                true, icon, midiDeviceRoutingGUI);
315
313
316
        midiDeviceRoutingWindow.pack();
314
        midiDeviceRoutingWindow.pack();
317
315
318
        internalFrames.add(midiDeviceRoutingWindow);
316
        internalFrames.add(midiDeviceRoutingWindow);
319
317
320
        icon = ImageLoader.getImageIcon("ucIcon.png");
318
        icon = ImageLoader.getImageIcon("ucIcon.png");
321
319
322
        /*
320
        /*
323
         * midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
321
         * midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
324
         * .getMiosStudioInPort(), icon);
322
         * .getMiosStudioInPort(), icon);
325
         *
323
         *
326
         * midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
324
         * midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
327
         * .getMiosStudioOutPort(), icon);
325
         * .getMiosStudioOutPort(), icon);
328
         */
326
         */
329
327
330
        // MIDI OUT Port
328
        // MIDI OUT Port
331
        midiOutPortMonitorGUI = new MidiMonitorFilteredGUI(miosStudio
329
        midiOutPortMonitorGUI = new MidiMonitorFilteredGUI(miosStudio
332
                .getMidiOutPortMonitorDevice().getMidiMonitorFiltered());
330
                .getMidiOutPortMonitorDevice().getMidiMonitorFiltered());
333
331
334
        icon = ImageLoader.getImageIcon("midiOut.png");
332
        icon = ImageLoader.getImageIcon("midiOut.png");
335
333
336
        midiOutPortMonitorWindow = new MIOSStudioInternalFrame(
334
        midiOutPortMonitorWindow = new MIOSStudioInternalFrame(
337
                "MIDI Monitor: OUT", true, true, true, true, icon,
335
                "MIDI Monitor: OUT", true, true, true, true, icon,
338
                midiOutPortMonitorGUI);
336
                midiOutPortMonitorGUI);
339
337
340
        midiOutPortMonitorWindow.pack();
338
        midiOutPortMonitorWindow.pack();
341
339
342
        internalFrames.add(midiOutPortMonitorWindow);
340
        internalFrames.add(midiOutPortMonitorWindow);
343
341
344
        midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
342
        midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
345
                .getMidiOutPortMonitorDevice(), icon);
343
                .getMidiOutPortMonitorDevice(), icon);
346
344
347
        // MIDI IN Port
345
        // MIDI IN Port
348
        midiInPortMonitorGUI = new MidiMonitorFilteredGUI(miosStudio
346
        midiInPortMonitorGUI = new MidiMonitorFilteredGUI(miosStudio
349
                .getMidiInPortMonitorDevice().getMidiMonitorFiltered());
347
                .getMidiInPortMonitorDevice().getMidiMonitorFiltered());
350
348
351
        icon = ImageLoader.getImageIcon("midiIn.png");
349
        icon = ImageLoader.getImageIcon("midiIn.png");
352
350
353
        midiInPortMonitorWindow = new MIOSStudioInternalFrame(
351
        midiInPortMonitorWindow = new MIOSStudioInternalFrame(
354
                "MIDI Monitor: IN", true, true, true, true, icon,
352
                "MIDI Monitor: IN", true, true, true, true, icon,
355
                midiInPortMonitorGUI);
353
                midiInPortMonitorGUI);
356
354
357
        midiInPortMonitorWindow.pack();
355
        midiInPortMonitorWindow.pack();
358
356
359
        internalFrames.add(midiInPortMonitorWindow);
357
        internalFrames.add(midiInPortMonitorWindow);
360
358
361
        midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
359
        midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
362
                .getMidiInPortMonitorDevice(), icon);
360
                .getMidiInPortMonitorDevice(), icon);
363
361
364
        // MIDI Keyboard Controller
362
        // MIDI Keyboard Controller
365
363
366
        icon = ImageLoader.getImageIcon("piano.png");
364
        icon = ImageLoader.getImageIcon("piano.png");
367
365
368
        midiKeyboardControllerGUI = new MidiKeyboardControllerGUI(miosStudio
366
        midiKeyboardControllerGUI = new MidiKeyboardControllerGUI(miosStudio
369
                .getMidiKeyboardControllerDevice().getMidiKeyboardController());
367
                .getMidiKeyboardControllerDevice().getMidiKeyboardController());
370
368
371
        midiKeyboardControllerWindow = new MIOSStudioInternalFrame(
369
        midiKeyboardControllerWindow = new MIOSStudioInternalFrame(
372
                "MIDI Keyboard Controller", false, // resizable
370
                "MIDI Keyboard Controller", false, // resizable
373
                true, // closable
371
                true, // closable
374
                false, // maximizable
372
                false, // maximizable
375
                true, icon, midiKeyboardControllerGUI);
373
                true, icon, midiKeyboardControllerGUI);
376
374
377
        midiKeyboardControllerWindow.pack();
375
        midiKeyboardControllerWindow.pack();
378
376
379
        internalFrames.add(midiKeyboardControllerWindow);
377
        internalFrames.add(midiKeyboardControllerWindow);
380
378
381
        midiDeviceRoutingGUI.addMidiDeviceIcon(
379
        midiDeviceRoutingGUI.addMidiDeviceIcon(
382
                MidiKeyboardControllerDevice.class, icon);
380
                MidiKeyboardControllerDevice.class, icon);
383
381
384
        // Sysex Send/Receive
382
        // Sysex Send/Receive
385
        /*
383
        /*
386
         * sysexSendReceiveDeviceManagerGUI = new
384
         * sysexSendReceiveDeviceManagerGUI = new
387
         * SysexSendReceiveDeviceManagerGUI(
385
         * SysexSendReceiveDeviceManagerGUI(
388
         * miosStudio.getSysexSendReceiveDeviceManager());
386
         * miosStudio.getSysexSendReceiveDeviceManager());
389
         *
387
         *
390
         * icon = ImageLoader.getImageIcon("sysex.png");
388
         * icon = ImageLoader.getImageIcon("sysex.png");
391
         *
389
         *
392
         * sysexSendReceiveDeviceManagerWindow = new MIOSStudioInternalFrame(
390
         * sysexSendReceiveDeviceManagerWindow = new MIOSStudioInternalFrame(
393
         * "Sysex Send/Receive", true, true, true, true, icon,
391
         * "Sysex Send/Receive", true, true, true, true, icon,
394
         * sysexSendReceiveDeviceManagerGUI);
392
         * sysexSendReceiveDeviceManagerGUI);
395
         *
393
         *
396
         * sysexSendReceiveDeviceManagerWindow.pack();
394
         * sysexSendReceiveDeviceManagerWindow.pack();
397
         */
395
         */
398
396
399
        midiDeviceRoutingGUI.addMidiDeviceIcon(SysexSendReceiveDevice.class,
397
        midiDeviceRoutingGUI.addMidiDeviceIcon(SysexSendReceiveDevice.class,
400
                icon);
398
                icon);
401
399
402
        // Hex Upload
400
        // Hex Upload
403
401
404
        hexFileUploadDeviceManagerGUI = new HexFileUploadDeviceManagerGUI(
402
        hexFileUploadDeviceManagerGUI = new HexFileUploadDeviceManagerGUI(
405
                miosStudio.getHexFileUploadDeviceManager());
403
                miosStudio.getHexFileUploadDeviceManager());
406
404
407
        icon = ImageLoader.getImageIcon("hex.png");
405
        icon = ImageLoader.getImageIcon("hex.png");
408
406
409
        hexFileUploadDeviceManagerWindow = new MIOSStudioInternalFrame(
407
        hexFileUploadDeviceManagerWindow = new MIOSStudioInternalFrame(
410
                "MIOS Hex File Upload", true, true, true, true, icon,
408
                "MIOS Hex File Upload", true, true, true, true, icon,
411
                hexFileUploadDeviceManagerGUI);
409
                hexFileUploadDeviceManagerGUI);
412
410
413
        hexFileUploadDeviceManagerWindow.pack();
411
        hexFileUploadDeviceManagerWindow.pack();
414
412
415
        internalFrames.add(hexFileUploadDeviceManagerWindow);
413
        internalFrames.add(hexFileUploadDeviceManagerWindow);
416
414
417
        midiDeviceRoutingGUI.addMidiDeviceIcon(HexFileUploadDevice.class, icon);
415
        midiDeviceRoutingGUI.addMidiDeviceIcon(HexFileUploadDevice.class, icon);
418
416
419
        // Read/Write
417
        // Read/Write
420
        /*
418
        /*
421
         * icon = ImageLoader.getImageIcon("readWrite.png");
419
         * icon = ImageLoader.getImageIcon("readWrite.png");
422
         *
420
         *
423
         * memoryReadWriteGUI = new MemoryReadWriteGUI(miosStudio
421
         * memoryReadWriteGUI = new MemoryReadWriteGUI(miosStudio
424
         * .getMemoryReadWriteDevice().getMemoryReadWrite());
422
         * .getMemoryReadWriteDevice().getMemoryReadWrite());
425
         *
423
         *
426
         * tabbedPane.addTab("MIOS Memory Read/Write", icon,
424
         * tabbedPane.addTab("MIOS Memory Read/Write", icon,
427
         * memoryReadWriteGUI);
425
         * memoryReadWriteGUI);
428
         * midiDeviceRoutingGUI.addMidiDeviceIcon(MemoryReadWriteDevice.class,
426
         * midiDeviceRoutingGUI.addMidiDeviceIcon(MemoryReadWriteDevice.class,
429
         * icon);
427
         * icon);
430
         */
428
         */
431
429
432
        // LCD Message
430
        // LCD Message
433
        icon = ImageLoader.getImageIcon("lcd.png");
431
        icon = ImageLoader.getImageIcon("lcd.png");
434
432
435
        lcdMessageGUI = new LCDMessageGUI(miosStudio.getLcdMessageDevice()
433
        lcdMessageGUI = new LCDMessageGUI(miosStudio.getLcdMessageDevice()
436
                .getLCDMessage());
434
                .getLCDMessage());
437
435
438
        lcdMessageWindow = new MIOSStudioInternalFrame("MIOS LCD Message",
436
        lcdMessageWindow = new MIOSStudioInternalFrame("MIOS LCD Message",
439
                true, true, true, true, icon, lcdMessageGUI);
437
                true, true, true, true, icon, lcdMessageGUI);
440
438
441
        lcdMessageWindow.pack();
439
        lcdMessageWindow.pack();
442
440
443
        internalFrames.add(lcdMessageWindow);
441
        internalFrames.add(lcdMessageWindow);
444
442
445
        midiDeviceRoutingGUI.addMidiDeviceIcon(
443
        midiDeviceRoutingGUI.addMidiDeviceIcon(
446
                miosStudio.getLcdMessageDevice(), icon);
444
                miosStudio.getLcdMessageDevice(), icon);
447
445
448
        // MIOS Debug
446
        // MIOS Debug
449
447
450
        icon = ImageLoader.getImageIcon("debug.png");
448
        icon = ImageLoader.getImageIcon("debug.png");
451
449
452
        debugFunctionGUI = new DebugFunctionGUI(miosStudio
450
        debugFunctionGUI = new DebugFunctionGUI(miosStudio
453
                .getDebugFunctionDevice().getDebugFunction());
451
                .getDebugFunctionDevice().getDebugFunction());
454
452
455
        debugFunctionWindow = new MIOSStudioInternalFrame(
453
        debugFunctionWindow = new MIOSStudioInternalFrame(
456
                "MIOS Debug Functions", true, true, true, true, icon,
454
                "MIOS Debug Functions", true, true, true, true, icon,
457
                debugFunctionGUI);
455
                debugFunctionGUI);
458
456
459
        debugFunctionWindow.pack();
457
        debugFunctionWindow.pack();
460
458
461
        internalFrames.add(debugFunctionWindow);
459
        internalFrames.add(debugFunctionWindow);
462
460
463
        midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
461
        midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
464
                .getDebugFunctionDevice(), icon);
462
                .getDebugFunctionDevice(), icon);
465
463
466
        // MIOS Terminal
464
        // MIOS Terminal
467
        miosTerminalGUI = new MidiMonitorFilteredGUI(miosStudio
465
        miosTerminalGUI = new MidiMonitorFilteredGUI(miosStudio
468
                .getMIOSTerminalDevice().getMidiMonitorFiltered());
466
                .getMIOSTerminalDevice().getMidiMonitorFiltered());
469
467
470
        icon = ImageLoader.getImageIcon("miosTerminal.png");
468
        icon = ImageLoader.getImageIcon("miosTerminal.png");
471
469
472
        miosTerminalWindow = new MIOSStudioInternalFrame("MIOS Terminal", true,
470
        miosTerminalWindow = new MIOSStudioInternalFrame("MIOS Terminal", true,
473
                true, true, true, icon, miosTerminalGUI);
471
                true, true, true, icon, miosTerminalGUI);
474
472
475
        miosTerminalWindow.pack();
473
        miosTerminalWindow.pack();
476
474
477
        internalFrames.add(miosTerminalWindow);
475
        internalFrames.add(miosTerminalWindow);
478
476
479
        midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
477
        midiDeviceRoutingGUI.addMidiDeviceIcon(miosStudio
480
                .getMIOSTerminalDevice(), icon);
478
                .getMIOSTerminalDevice(), icon);
481
    }
479
    }
482
480
483
    public JMenuBar createMenuBar() {
481
    public JMenuBar createMenuBar() {
484
        JMenuBar menuBar = new JMenuBar();
482
        JMenuBar menuBar = new JMenuBar();
485
483
486
        createFileMenu();
484
        createFileMenu();
487
        createMIDIMenu();
485
        createMIDIMenu();
488
        createMIOSMenu();
486
        createMIOSMenu();
489
        createOptionsMenu();
487
        createOptionsMenu();
490
        createWindowMenu();
488
        createWindowMenu();
491
        createHelpMenu();
489
        createHelpMenu();
492
490
493
        menuBar.add(fileMenu);
491
        menuBar.add(fileMenu);
494
        menuBar.add(midiMenu);
492
        menuBar.add(midiMenu);
495
        menuBar.add(miosMenu);
493
        menuBar.add(miosMenu);
496
        menuBar.add(optionsMenu);
494
        menuBar.add(optionsMenu);
497
        menuBar.add(windowMenu);
495
        menuBar.add(windowMenu);
498
        menuBar.add(helpMenu);
496
        menuBar.add(helpMenu);
499
497
500
        return menuBar;
498
        return menuBar;
501
    }
499
    }
502
500
503
    protected void createFileMenu() {
501
    protected void createFileMenu() {
504
502
505
        fileMenu = new JMenu("File");
503
        fileMenu = new JMenu("File");
506
        fileMenu.setMnemonic(KeyEvent.VK_F);
504
        fileMenu.setMnemonic(KeyEvent.VK_F);
507
505
508
        JMenuItem menuItem = new JMenuItem("Open Workspace");
506
        JMenuItem menuItem = new JMenuItem("Open Workspace");
509
        menuItem.setActionCommand("open_workspace");
507
        menuItem.setActionCommand("open_workspace");
510
        menuItem.addActionListener(this);
508
        menuItem.addActionListener(this);
511
        fileMenu.add(menuItem);
509
        fileMenu.add(menuItem);
512
510
513
        MRUMenu = new JMenu("Open Recent Workspace");
511
        MRUMenu = new JMenu("Open Recent Workspace");
514
        MRUMenu.addMenuListener(this);
512
        MRUMenu.addMenuListener(this);
515
        fileMenu.add(MRUMenu);
513
        fileMenu.add(MRUMenu);
516
514
517
        menuItem = new JMenuItem("Save Workspace");
515
        menuItem = new JMenuItem("Save Workspace");
518
        menuItem.setActionCommand("save_workspace");
516
        menuItem.setActionCommand("save_workspace");
519
        menuItem.addActionListener(this);
517
        menuItem.addActionListener(this);
520
        fileMenu.add(menuItem);
518
        fileMenu.add(menuItem);
521
    }
519
    }
522
520
523
    protected void createMIDIMenu() {
521
    protected void createMIDIMenu() {
524
        midiMenu = new JMenu("MIDI");
522
        midiMenu = new JMenu("MIDI");
525
        midiMenu.setMnemonic(KeyEvent.VK_M);
523
        midiMenu.setMnemonic(KeyEvent.VK_M);
526
524
527
        JMenuItem menuItem = new JMenuItem("MIDI Devices");
525
        JMenuItem menuItem = new JMenuItem("MIDI Devices");
528
        menuItem.setMnemonic(KeyEvent.VK_M);
526
        menuItem.setMnemonic(KeyEvent.VK_M);
529
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M,
527
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M,
530
                ActionEvent.CTRL_MASK));
528
                ActionEvent.CTRL_MASK));
531
        menuItem.setActionCommand("midi_devices");
529
        menuItem.setActionCommand("midi_devices");
532
        menuItem.addActionListener(this);
530
        menuItem.addActionListener(this);
533
        midiMenu.add(menuItem);
531
        midiMenu.add(menuItem);
534
532
535
        menuItem = new JMenuItem("MIDI Filters");
533
        menuItem = new JMenuItem("MIDI Filters");
536
        menuItem.setMnemonic(KeyEvent.VK_F);
534
        menuItem.setMnemonic(KeyEvent.VK_F);
537
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F,
535
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F,
538
                ActionEvent.CTRL_MASK));
536
                ActionEvent.CTRL_MASK));
539
        menuItem.setActionCommand("midi_filters");
537
        menuItem.setActionCommand("midi_filters");
540
        menuItem.addActionListener(this);
538
        menuItem.addActionListener(this);
541
        midiMenu.add(menuItem);
539
        midiMenu.add(menuItem);
542
540
543
        menuItem = new JMenuItem("MIDI Monitor: OUT");
541
        menuItem = new JMenuItem("MIDI Monitor: OUT");
544
        menuItem.setMnemonic(KeyEvent.VK_O);
542
        menuItem.setMnemonic(KeyEvent.VK_O);
545
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,
543
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,
546
                ActionEvent.CTRL_MASK));
544
                ActionEvent.CTRL_MASK));
547
        menuItem.setActionCommand("midi_out_port_monitor");
545
        menuItem.setActionCommand("midi_out_port_monitor");
548
        menuItem.addActionListener(this);
546
        menuItem.addActionListener(this);
549
        midiMenu.add(menuItem);
547
        midiMenu.add(menuItem);
550
548
551
        menuItem = new JMenuItem("MIDI Monitor: IN");
549
        menuItem = new JMenuItem("MIDI Monitor: IN");
552
        menuItem.setMnemonic(KeyEvent.VK_I);
550
        menuItem.setMnemonic(KeyEvent.VK_I);
553
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I,
551
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I,
554
                ActionEvent.CTRL_MASK));
552
                ActionEvent.CTRL_MASK));
555
        menuItem.setActionCommand("midi_in_port_monitor");
553
        menuItem.setActionCommand("midi_in_port_monitor");
556
        menuItem.addActionListener(this);
554
        menuItem.addActionListener(this);
557
        midiMenu.add(menuItem);
555
        midiMenu.add(menuItem);
558
556
559
        menuItem = new JMenuItem("MIDI Keyboard Controller");
557
        menuItem = new JMenuItem("MIDI Keyboard Controller");
560
        menuItem.setMnemonic(KeyEvent.VK_K);
558
        menuItem.setMnemonic(KeyEvent.VK_K);
561
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_K,
559
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_K,
562
                ActionEvent.CTRL_MASK));
560
                ActionEvent.CTRL_MASK));
563
        menuItem.setActionCommand("piano_controller");
561
        menuItem.setActionCommand("piano_controller");
564
        menuItem.addActionListener(this);
562
        menuItem.addActionListener(this);
565
        midiMenu.add(menuItem);
563
        midiMenu.add(menuItem);
566
564
567
        /*
565
        /*
568
         * menuItem = new JMenuItem("Sysex Send/Recieve");
566
         * menuItem = new JMenuItem("Sysex Send/Recieve");
569
         * menuItem.setMnemonic(KeyEvent.VK_S);
567
         * menuItem.setMnemonic(KeyEvent.VK_S);
570
         * menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,
568
         * menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,
571
         * ActionEvent.CTRL_MASK)); menuItem.setActionCommand("sysex");
569
         * ActionEvent.CTRL_MASK)); menuItem.setActionCommand("sysex");
572
         * menuItem.addActionListener(this); menu.add(menuItem);
570
         * menuItem.addActionListener(this); menu.add(menuItem);
573
         */
571
         */
574
572
575
    }
573
    }
576
574
577
    protected void createMIOSMenu() {
575
    protected void createMIOSMenu() {
578
576
579
        miosMenu = new JMenu("MIOS");
577
        miosMenu = new JMenu("MIOS");
580
        miosMenu.setMnemonic(KeyEvent.VK_O);
578
        miosMenu.setMnemonic(KeyEvent.VK_O);
581
579
582
        JMenuItem menuItem = new JMenuItem("MIOS Hex File Upload");
580
        JMenuItem menuItem = new JMenuItem("MIOS Hex File Upload");
583
        menuItem.setMnemonic(KeyEvent.VK_U);
581
        menuItem.setMnemonic(KeyEvent.VK_U);
584
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_U,
582
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_U,
585
                ActionEvent.CTRL_MASK));
583
                ActionEvent.CTRL_MASK));
586
        menuItem.setActionCommand("open_hex_file");
584
        menuItem.setActionCommand("open_hex_file");
587
        menuItem.addActionListener(this);
585
        menuItem.addActionListener(this);
588
        miosMenu.add(menuItem);
586
        miosMenu.add(menuItem);
589
587
590
        menuItem = new JMenuItem("MIOS LCD Message");
588
        menuItem = new JMenuItem("MIOS LCD Message");
591
        menuItem.setMnemonic(KeyEvent.VK_L);
589
        menuItem.setMnemonic(KeyEvent.VK_L);
592
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_L,
590
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_L,
593
                ActionEvent.CTRL_MASK));
591
                ActionEvent.CTRL_MASK));
594
        menuItem.setActionCommand("lcd_message");
592
        menuItem.setActionCommand("lcd_message");
595
        menuItem.addActionListener(this);
593
        menuItem.addActionListener(this);
596
        miosMenu.add(menuItem);
594
        miosMenu.add(menuItem);
597
595
598
        menuItem = new JMenuItem("MIOS Debug Functions");
596
        menuItem = new JMenuItem("MIOS Debug Functions");
599
        menuItem.setMnemonic(KeyEvent.VK_D);
597
        menuItem.setMnemonic(KeyEvent.VK_D);
600
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D,
598
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D,
601
                ActionEvent.CTRL_MASK));
599
                ActionEvent.CTRL_MASK));
602
        menuItem.setActionCommand("debug_functions");
600
        menuItem.setActionCommand("debug_functions");
603
        menuItem.addActionListener(this);
601
        menuItem.addActionListener(this);
604
        miosMenu.add(menuItem);
602
        miosMenu.add(menuItem);
605
603
606
        menuItem = new JMenuItem("MIOS Terminal");
604
        menuItem = new JMenuItem("MIOS Terminal");
607
        menuItem.setMnemonic(KeyEvent.VK_T);
605
        menuItem.setMnemonic(KeyEvent.VK_T);
608
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T,
606
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T,
609
                ActionEvent.CTRL_MASK));
607
                ActionEvent.CTRL_MASK));
610
        menuItem.setActionCommand("mios_terminal");
608
        menuItem.setActionCommand("mios_terminal");
611
        menuItem.addActionListener(this);
609
        menuItem.addActionListener(this);
612
        miosMenu.add(menuItem);
610
        miosMenu.add(menuItem);
613
    }
611
    }
614
612
615
    protected void createOptionsMenu() {
613
    protected void createOptionsMenu() {
616
614
617
        optionsMenu = new JMenu("Options");
615
        optionsMenu = new JMenu("Options");
618
        optionsMenu.setMnemonic(KeyEvent.VK_P);
616
        optionsMenu.setMnemonic(KeyEvent.VK_P);
619
617
620
        JMenuItem menuItem = new JMenuItem("MIDI Device Routing");
618
        JMenuItem menuItem = new JMenuItem("MIDI Device Routing");
621
        menuItem.setMnemonic(KeyEvent.VK_R);
619
        menuItem.setMnemonic(KeyEvent.VK_R);
622
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,
620
        menuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,
623
                ActionEvent.CTRL_MASK));
621
                ActionEvent.CTRL_MASK));
624
        menuItem.setActionCommand("midi_routing");
622
        menuItem.setActionCommand("midi_routing");
625
        menuItem.addActionListener(this);
623
        menuItem.addActionListener(this);
626
        optionsMenu.add(menuItem);
624
        optionsMenu.add(menuItem);
627
625
628
        showInternalMenuItem = new JCheckBoxMenuItem("Show Internal Routing",
626
        showInternalMenuItem = new JCheckBoxMenuItem("Show Internal Routing",
629
                miosStudio.isRouteIndividualDevices());
627
                miosStudio.isRouteIndividualDevices());
630
        showInternalMenuItem.setActionCommand("route_internal");
628
        showInternalMenuItem.setActionCommand("route_internal");
631
        showInternalMenuItem.addActionListener(this);
629
        showInternalMenuItem.addActionListener(this);
632
        optionsMenu.add(showInternalMenuItem);
630
        optionsMenu.add(showInternalMenuItem);
633
631
634
        menuItem = new JMenuItem("Restore Default Internal Routing");
632
        menuItem = new JMenuItem("Restore Default Internal Routing");
635
        menuItem.setActionCommand("restore_default");
633
        menuItem.setActionCommand("restore_default");
636
        menuItem.addActionListener(this);
634
        menuItem.addActionListener(this);
637
        optionsMenu.add(menuItem);
635
        optionsMenu.add(menuItem);
638
636
639
        optionsMenu.addSeparator();
637
        optionsMenu.addSeparator();
640
        JMenu thruMenu = new JMenu("MIDI Thru");
638
        JMenu thruMenu = new JMenu("MIDI Thru");
641
639
642
        midiThruMenuItem = new JCheckBoxMenuItem("Send MIDI Thru via Out Port",
640
        midiThruMenuItem = new JCheckBoxMenuItem("Send MIDI Thru via Out Port",
643
                miosStudio.isMidiThruOutPort());
641
                miosStudio.isMidiThruOutPort());
644
        midiThruMenuItem.setActionCommand("midi_thru");
642
        midiThruMenuItem.setActionCommand("midi_thru");
645
        midiThruMenuItem.addActionListener(this);
643
        midiThruMenuItem.addActionListener(this);
646
        thruMenu.add(midiThruMenuItem);
644
        thruMenu.add(midiThruMenuItem);
647
645
648
        menuItem = new JMenuItem("MIDI Thru Filter");
646
        menuItem = new JMenuItem("MIDI Thru Filter");
649
        menuItem.setActionCommand("midi_thru_filter");
647
        menuItem.setActionCommand("midi_thru_filter");
650
        menuItem.addActionListener(this);
648
        menuItem.addActionListener(this);
651
        thruMenu.add(menuItem);
649
        thruMenu.add(menuItem);
652
650
653
        /*
651
        /*
654
         * menuItem = new JMenuItem("Show MIDI Thru Map");
652
         * menuItem = new JMenuItem("Show MIDI Thru Map");
655
         * menuItem.setActionCommand("midi_thru_map");
653
         * menuItem.setActionCommand("midi_thru_map");
656
         * menuItem.addActionListener(this); thruMenu.add(menuItem);
654
         * menuItem.addActionListener(this); thruMenu.add(menuItem);
657
         */
655
         */
658
656
659
        optionsMenu.add(thruMenu);
657
        optionsMenu.add(thruMenu);
660
        optionsMenu.addSeparator();
658
        optionsMenu.addSeparator();
661
        lookAndFeelMenu = new JMenu("Look & Feel");
659
        lookAndFeelMenu = new JMenu("Look & Feel");
662
        lookAndFeelMenu.addMenuListener(this);
660
        lookAndFeelMenu.addMenuListener(this);
663
        optionsMenu.add(lookAndFeelMenu);
661
        optionsMenu.add(lookAndFeelMenu);
664
    }
662
    }
665
663
666
    protected void createWindowMenu() {
664
    protected void createWindowMenu() {
667
665
668
        windowMenu = new WindowMenu(this);
666
        windowMenu = new WindowMenu(this);
669
        windowMenu.setMnemonic(KeyEvent.VK_W);
667
        windowMenu.setMnemonic(KeyEvent.VK_W);
670
    }
668
    }
671
669
672
    protected void createHelpMenu() {
670
    protected void createHelpMenu() {
673
671
674
        helpMenu = new JMenu("Help");
672
        helpMenu = new JMenu("Help");
675
        helpMenu.setMnemonic(KeyEvent.VK_H);
673
        helpMenu.setMnemonic(KeyEvent.VK_H);
676
674
677
        JMenuItem menuItem = new JMenuItem("MIOS Studio Help");
675
        JMenuItem menuItem = new JMenuItem("MIOS Studio Help");
678
        menuItem.setMnemonic(KeyEvent.VK_I);
676
        menuItem.setMnemonic(KeyEvent.VK_I);
679
677
680
        menuItem.setActionCommand("help_index");
678
        menuItem.setActionCommand("help_index");
681
        menuItem.addActionListener(this);
679
        menuItem.addActionListener(this);
682
        helpMenu.add(menuItem);
680
        helpMenu.add(menuItem);
683
681
684
        menuItem = new JMenuItem("MIOS Function Reference");
682
        menuItem = new JMenuItem("MIOS Function Reference");
685
        menuItem.setMnemonic(KeyEvent.VK_F);
683
        menuItem.setMnemonic(KeyEvent.VK_F);
686
684
687
        menuItem.setActionCommand("mios_fun");
685
        menuItem.setActionCommand("mios_fun");
688
        menuItem.addActionListener(this);
686
        menuItem.addActionListener(this);
689
        helpMenu.add(menuItem);
687
        helpMenu.add(menuItem);
690
    }
688
    }
691
689
692
    public void addExternalCommandButton(String commandName, String command) {
690
    public void addExternalCommandButton(String commandName, String command) {
693
        ExternalCommandButton button = new ExternalCommandButton();
691
        ExternalCommandButton button = new ExternalCommandButton();
694
        button.setCommandName(commandName);
692
        button.setCommandName(commandName);
695
        button.setExternalCommand(command);
693
        button.setExternalCommand(command);
696
        externalCommands.add(button);
694
        externalCommands.add(button);
697
        toolBar.add(button);
695
        toolBar.add(button);
698
        assignExternalButtonMnemonics();
696
        assignExternalButtonMnemonics();
699
        toolBar.setVisible(false);
697
        toolBar.setVisible(false);
700
        toolBar.setVisible(true);
698
        toolBar.setVisible(true);
701
    }
699
    }
702
700
703
    public HexFileUploadDeviceManagerGUI getHexFileUploadDeviceManagerGUI() {
701
    public HexFileUploadDeviceManagerGUI getHexFileUploadDeviceManagerGUI() {
704
        return hexFileUploadDeviceManagerGUI;
702
        return hexFileUploadDeviceManagerGUI;
705
    }
703
    }
706
704
707
    public Vector getInternalFrames() {
705
    public Vector getInternalFrames() {
708
        return internalFrames;
706
        return internalFrames;
709
    }
707
    }
710
708
711
    public static String getCurrentDirectory() {
709
    public static String getCurrentDirectory() {
712
        return currentDirectory;
710
        return currentDirectory;
713
    }
711
    }
714
712
715
    public static void setCurrentDirectory(String currentDirectory) {
713
    public static void setCurrentDirectory(String currentDirectory) {
716
714
717
        MIOSStudioGUI.currentDirectory = currentDirectory;
715
        MIOSStudioGUI.currentDirectory = currentDirectory;
718
    }
716
    }
719
717
720
    public void setLookAndFeel(String lookAndFeel) {
718
    public void setLookAndFeel(String lookAndFeel) {
721
719
722
        this.lookAndFeel = lookAndFeel;
720
        this.lookAndFeel = lookAndFeel;
723
721
724
        if (!lookAndFeel
722
        if (!lookAndFeel
725
                .equals(UIManager.getLookAndFeel().getClass().getName())) {
723
                .equals(UIManager.getLookAndFeel().getClass().getName())) {
726
724
727
            JOptionPane
725
            JOptionPane
728
                    .showMessageDialog(
726
                    .showMessageDialog(
729
                            MIOSStudioGUI.this,
727
                            MIOSStudioGUI.this,
730
                            "The selected Look & Feel will be applied the next time you restart MIOS Studio",
728
                            "The selected Look & Feel will be applied the next time you restart MIOS Studio",
731
                            "ALERT", JOptionPane.ERROR_MESSAGE);
729
                            "ALERT", JOptionPane.ERROR_MESSAGE);
732
        }
730
        }
733
    }
731
    }
734
732
735
    public static Vector getMRU() {
733
    public static Vector getMRU() {
736
        return MRU;
734
        return MRU;
737
    }
735
    }
738
736
739
    public void removeExternalCommandButton(ExternalCommandButton button) {
737
    public void removeExternalCommandButton(ExternalCommandButton button) {
740
        externalCommands.remove(button);
738
        externalCommands.remove(button);
741
        toolBar.remove(button);
739
        toolBar.remove(button);
742
        assignExternalButtonMnemonics();
740
        assignExternalButtonMnemonics();
743
        toolBar.setVisible(false);
741
        toolBar.setVisible(false);
744
        toolBar.setVisible(true);
742
        toolBar.setVisible(true);
745
    }
743
    }
746
744
747
    protected void assignExternalButtonMnemonics() {
745
    protected void assignExternalButtonMnemonics() {
748
        for (int i = 0; i < externalCommands.size() && i < 9; i++) {
746
        for (int i = 0; i < externalCommands.size() && i < 9; i++) {
749
            ((ExternalCommandButton) externalCommands.elementAt(i))
747
            ((ExternalCommandButton) externalCommands.elementAt(i))
750
                    .setMnemonic(0x31 + i);
748
                    .setMnemonic(0x31 + i);
751
        }
749
        }
752
    }
750
    }
753
751
754
    protected JToolBar createToolBar() {
752
    protected JToolBar createToolBar() {
755
753
756
        toolBar = new JToolBar("Tool Bar", JToolBar.HORIZONTAL);
754
        toolBar = new JToolBar("Tool Bar", JToolBar.HORIZONTAL);
757
        toolBar.setFloatable(false);
755
        toolBar.setFloatable(false);
758
        toolBar.setRollover(true);
756
        toolBar.setRollover(true);
759
757
760
        createWorkspaceButtons();
758
        createWorkspaceButtons();
761
759
762
        toolBar.addSeparator();
760
        toolBar.addSeparator();
763
761
764
        createMIDIButtons();
762
        createMIDIButtons();
765
763
766
        toolBar.addSeparator();
764
        toolBar.addSeparator();
767
765
768
        createMIOSButtons();
766
        createMIOSButtons();
769
767
770
        toolBar.addSeparator();
768
        toolBar.addSeparator();
771
769
772
        createOptionsButtons();
770
        createOptionsButtons();
773
771
774
        toolBar.addSeparator();
772
        toolBar.addSeparator();
775
773
776
        createHelpButtons();
774
        createHelpButtons();
777
775
778
        toolBar.addSeparator();
776
        toolBar.addSeparator();
779
777
780
        toolBarMenu = new JPopupMenu();
778
        toolBarMenu = new JPopupMenu();
781
        JMenuItem addButton = new JMenuItem("Add External Command Button");
779
        JMenuItem addButton = new JMenuItem("Add External Command Button");
782
        addButton.setActionCommand("add_command_button");
780
        addButton.setActionCommand("add_command_button");
783
        addButton.addActionListener(this);
781
        addButton.addActionListener(this);
784
        toolBarMenu.add(addButton);
782
        toolBarMenu.add(addButton);
785
783
786
        toolBar.addMouseListener(this);
784
        toolBar.addMouseListener(this);
787
        toolBar.setVisible(true);
785
        toolBar.setVisible(true);
788
        return toolBar;
786
        return toolBar;
789
    }
787
    }
790
788
791
    protected void createWorkspaceButtons() {
789
    protected void createWorkspaceButtons() {
792
790
793
        Insets insets = new Insets(2, 2, 2, 2);
791
        Insets insets = new Insets(2, 2, 2, 2);
794
792
795
        JButton button = new JButton(ImageLoader.getImageIcon("open.png"));
793
        JButton button = new JButton(ImageLoader.getImageIcon("open.png"));
796
        button.setToolTipText("Open Workspace");
794
        button.setToolTipText("Open Workspace");
797
        button.setActionCommand("open_workspace");
795
        button.setActionCommand("open_workspace");
798
        button.addActionListener(this);
796
        button.addActionListener(this);
799
        button.setMargin(insets);
797
        button.setMargin(insets);
800
798
801
        MRUPopupMenu = new JPopupMenu();
799
        MRUPopupMenu = new JPopupMenu();
802
        MRUPopupMenu.addPopupMenuListener(new PopupMenuListener() {
800
        MRUPopupMenu.addPopupMenuListener(new PopupMenuListener() {
803
801
804
            public void popupMenuCanceled(PopupMenuEvent e) {
802
            public void popupMenuCanceled(PopupMenuEvent e) {
805
803
806
            }
804
            }
807
805
808
            public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
806
            public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
809
807
810
            }
808
            }
811
809
812
            public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
810
            public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
813
811
814
                MIOSStudioGUI.this.buildMRUMenu(MRUPopupMenu);
812
                MIOSStudioGUI.this.buildMRUMenu(MRUPopupMenu);
815
813
816
            }
814
            }
817
        });
815
        });
818
816
819
        openMRUButton = new SplitButton(button, MRUPopupMenu);
817
        openMRUButton = new SplitButton(button, MRUPopupMenu);
820
        openMRUButton.setRollover(true);
818
        openMRUButton.setRollover(true);
821
819
822
        toolBar.add(openMRUButton);
820
        toolBar.add(openMRUButton);
823
821
824
        button = new JButton(ImageLoader.getImageIcon("save.png"));
822
        button = new JButton(ImageLoader.getImageIcon("save.png"));
825
        button.setToolTipText("Save Workspace");
823
        button.setToolTipText("Save Workspace");
826
        button.setActionCommand("save_workspace");
824
        button.setActionCommand("save_workspace");
827
        button.addActionListener(this);
825
        button.addActionListener(this);
828
        button.setMargin(insets);
826
        button.setMargin(insets);
829
        toolBar.add(button);
827
        toolBar.add(button);
830
828
831
    }
829
    }
832
830
833
    protected void createMIDIButtons() {
831
    protected void createMIDIButtons() {
834
832
835
        Insets insets = new Insets(2, 2, 2, 2);
833
        Insets insets = new Insets(2, 2, 2, 2);
836
834
837
        JButton button = new JButton(ImageLoader
835
        JButton button = new JButton(ImageLoader
838
                .getImageIcon("midiDevices.png"));
836
                .getImageIcon("midiDevices.png"));
839
        button.setToolTipText("MIDI Devices");
837
        button.setToolTipText("MIDI Devices");
840
        button.setActionCommand("midi_devices");
838
        button.setActionCommand("midi_devices");
841
        button.addActionListener(this);
839
        button.addActionListener(this);
842
        button.setMargin(insets);
840
        button.setMargin(insets);
843
        toolBar.add(button);
841
        toolBar.add(button);
844
842
845
        button = new JButton(ImageLoader.getImageIcon("filter.png"));
843
        button = new JButton(ImageLoader.getImageIcon("filter.png"));
846
        button.setToolTipText("MIDI Filters");
844
        button.setToolTipText("MIDI Filters");
847
        button.setActionCommand("midi_filters");
845
        button.setActionCommand("midi_filters");
848
        button.addActionListener(this);
846
        button.addActionListener(this);
849
        button.setMargin(insets);
847
        button.setMargin(insets);
850
        toolBar.add(button);
848
        toolBar.add(button);
851
849
852
        toolBar.addSeparator();
850
        toolBar.addSeparator();
853
851
854
        button = new JButton(ImageLoader.getImageIcon("midiOut.png"));
852
        button = new JButton(ImageLoader.getImageIcon("midiOut.png"));
855
        button.setToolTipText("MIDI Monitor: OUT");
853
        button.setToolTipText("MIDI Monitor: OUT");
856
        button.setActionCommand("midi_out_port_monitor");
854
        button.setActionCommand("midi_out_port_monitor");
857
        button.addActionListener(this);
855
        button.addActionListener(this);
858
        button.setMargin(insets);
856
        button.setMargin(insets);
859
        toolBar.add(button);
857
        toolBar.add(button);
860
858
861
        button = new JButton(ImageLoader.getImageIcon("midiIn.png"));
859
        button = new JButton(ImageLoader.getImageIcon("midiIn.png"));
862
        button.setToolTipText("MIDI Monitor: IN");
860
        button.setToolTipText("MIDI Monitor: IN");
863
        button.setActionCommand("midi_in_port_monitor");
861
        button.setActionCommand("midi_in_port_monitor");
864
        button.addActionListener(this);
862
        button.addActionListener(this);
865
        button.setMargin(insets);
863
        button.setMargin(insets);
866
        toolBar.add(button);
864
        toolBar.add(button);
867
865
868
        button = new JButton(ImageLoader.getImageIcon("piano.png"));
866
        button = new JButton(ImageLoader.getImageIcon("piano.png"));
869
        button.setToolTipText("MIDI Keyboard Controller");
867
        button.setToolTipText("MIDI Keyboard Controller");
870
        button.setActionCommand("piano_controller");
868
        button.setActionCommand("piano_controller");
871
        button.addActionListener(this);
869
        button.addActionListener(this);
872
        button.setMargin(insets);
870
        button.setMargin(insets);
873
        toolBar.add(button);
871
        toolBar.add(button);
874
872
875
        /*
873
        /*
876
         * button = new JButton(ImageLoader.getImageIcon("sysex.png"));
874
         * button = new JButton(ImageLoader.getImageIcon("sysex.png"));
877
         * button.setToolTipText("Sysex Send/Receive");
875
         * button.setToolTipText("Sysex Send/Receive");
878
         * button.setActionCommand("sysex"); button.addActionListener(this);
876
         * button.setActionCommand("sysex"); button.addActionListener(this);
879
         * button.setMargin(insets); toolBar.add(button);
877
         * button.setMargin(insets); toolBar.add(button);
880
         */
878
         */
881
879
882
    }
880
    }
883
881
884
    protected void createMIOSButtons() {
882
    protected void createMIOSButtons() {
885
883
886
        Insets insets = new Insets(2, 2, 2, 2);
884
        Insets insets = new Insets(2, 2, 2, 2);
887
885
888
        JButton button = new JButton(ImageLoader.getImageIcon("hex.png"));
886
        JButton button = new JButton(ImageLoader.getImageIcon("hex.png"));
889
        button.setToolTipText("MIOS Hex File Upload");
887
        button.setToolTipText("MIOS Hex File Upload");
890
        button.setActionCommand("open_hex_file");
888
        button.setActionCommand("open_hex_file");
891
        button.addActionListener(this);
889
        button.addActionListener(this);
892
        button.setMargin(insets);
890
        button.setMargin(insets);
893
        toolBar.add(button);
891
        toolBar.add(button);
894
892
895
        button = new JButton(ImageLoader.getImageIcon("lcd.png"));
893
        button = new JButton(ImageLoader.getImageIcon("lcd.png"));
896
        button.setToolTipText("MIOS LCD Message");
894
        button.setToolTipText("MIOS LCD Message");
897
        button.setActionCommand("lcd_message");
895
        button.setActionCommand("lcd_message");
898
        button.addActionListener(this);
896
        button.addActionListener(this);
899
        button.setMargin(insets);
897
        button.setMargin(insets);
900
        toolBar.add(button);
898
        toolBar.add(button);
901
899
902
        button = new JButton(ImageLoader.getImageIcon("debug.png"));
900
        button = new JButton(ImageLoader.getImageIcon("debug.png"));
903
        button.setToolTipText("MIOS Debug Functions");
901
        button.setToolTipText("MIOS Debug Functions");
904
        button.setActionCommand("debug_functions");
902
        button.setActionCommand("debug_functions");
905
        button.addActionListener(this);
903
        button.addActionListener(this);
906
        button.setMargin(insets);
904
        button.setMargin(insets);
907
        toolBar.add(button);
905
        toolBar.add(button);
908
906
909
        button = new JButton(ImageLoader.getImageIcon("miosTerminal.png"));
907
        button = new JButton(ImageLoader.getImageIcon("miosTerminal.png"));
910
        button.setToolTipText("MIOS Terminal");
908
        button.setToolTipText("MIOS Terminal");
911
        button.setActionCommand("mios_terminal");
909
        button.setActionCommand("mios_terminal");
912
        button.addActionListener(this);
910
        button.addActionListener(this);
913
        button.setMargin(insets);
911
        button.setMargin(insets);
914
        toolBar.add(button);
912
        toolBar.add(button);
915
    }
913
    }
916
914
917
    protected void createOptionsButtons() {
915
    protected void createOptionsButtons() {
918
916
919
        Insets insets = new Insets(2, 2, 2, 2);
917
        Insets insets = new Insets(2, 2, 2, 2);
920
918
921
        JButton button = new JButton(ImageLoader
919
        JButton button = new JButton(ImageLoader
922
                .getImageIcon("midiRouting.png"));
920
                .getImageIcon("midiRouting.png"));
923
        button.setToolTipText("MIDI Device Routing");
921
        button.setToolTipText("MIDI Device Routing");
924
        button.setActionCommand("midi_routing");
922
        button.setActionCommand("midi_routing");
925
        button.addActionListener(this);
923
        button.addActionListener(this);
926
        button.setMargin(insets);
924
        button.setMargin(insets);
927
        toolBar.add(button);
925
        toolBar.add(button);
928
    }
926
    }
929
927
930
    protected void createHelpButtons() {
928
    protected void createHelpButtons() {
931
929
932
        Insets insets = new Insets(2, 2, 2, 2);
930
        Insets insets = new Insets(2, 2, 2, 2);
933
931
934
        JButton button = new JButton(ImageLoader.getImageIcon("help.png"));
932
        JButton button = new JButton(ImageLoader.getImageIcon("help.png"));
935
        button.setToolTipText("MIOS Studio Help");
933
        button.setToolTipText("MIOS Studio Help");
936
        button.setActionCommand("help_window");
934
        button.setActionCommand("help_window");
937
        button.addActionListener(this);
935
        button.addActionListener(this);
938
        button.setMargin(insets);
936
        button.setMargin(insets);
939
        toolBar.add(button);
937
        toolBar.add(button);
940
938
941
    }
939
    }
942
940
943
    private void runExternalCommand(String command) {
941
    private void runExternalCommand(String command) {
944
        try {
942
        try {
945
            Runtime rt = Runtime.getRuntime();
943
            Runtime rt = Runtime.getRuntime();
946
            rt.exec(command);
944
            rt.exec(command);
947
        } catch (Exception e) {
945
        } catch (Exception e) {
948
            JOptionPane.showMessageDialog(this, "Cannot run command: "
946
            JOptionPane.showMessageDialog(this, "Cannot run command: "
949
                    + command + "\nReceived error: " + e.getLocalizedMessage(),
947
                    + command + "\nReceived error: " + e.getLocalizedMessage(),
950
                    "Cannot run command", JOptionPane.ERROR_MESSAGE);
948
                    "Cannot run command", JOptionPane.ERROR_MESSAGE);
951
        }
949
        }
952
    }
950
    }
953
951
954
    private JPanel createCommentBar() {
952
    private JPanel createCommentBar() {
955
        JPanel commentBar = new JPanel(new GridBagLayout());
953
        JPanel commentBar = new JPanel(new GridBagLayout());
956
        GridBagConstraints gbc = new GridBagConstraints();
954
        GridBagConstraints gbc = new GridBagConstraints();
957
        gbc.gridx = 0;
955
        gbc.gridx = 0;
958
        gbc.gridy = 0;
956
        gbc.gridy = 0;
959
        gbc.gridheight = 1;
957
        gbc.gridheight = 1;
960
        gbc.gridwidth = 1;
958
        gbc.gridwidth = 1;
961
959
962
        gbc.fill = GridBagConstraints.BOTH;
960
        gbc.fill = GridBagConstraints.BOTH;
963
        gbc.weightx = 1.0;
961
        gbc.weightx = 1.0;
964
        commentBar.add(Box.createGlue(), gbc);
962
        commentBar.add(Box.createGlue(), gbc);
965
        gbc.gridx++;
963
        gbc.gridx++;
966
964
967
        gbc.weightx = 0.0;
965
        gbc.weightx = 0.0;
968
        gbc.insets = new Insets(2, 2, 2, 2);
966
        gbc.insets = new Insets(2, 2, 2, 2);
969
967
970
        commentBar.add(new JSeparator(JSeparator.VERTICAL), gbc);
968
        commentBar.add(new JSeparator(JSeparator.VERTICAL), gbc);
971
        gbc.gridx++;
969
        gbc.gridx++;
972
970
973
        gbc.insets = new Insets(2, 10, 2, 20);
971
        gbc.insets = new Insets(2, 10, 2, 20);
974
972
975
        commentLabel = new JLabel();
973
        commentLabel = new JLabel();
976
        commentBar.add(commentLabel, gbc);
974
        commentBar.add(commentLabel, gbc);
977
        return commentBar;
975
        return commentBar;
978
    }
976
    }
979
977
980
    public void setCommentLabel(String text) {
978
    public void setCommentLabel(String text) {
981
979
982
        commentLabel.setText(text);
980
        commentLabel.setText(text);
983
    }
981
    }
984
982
985
    private void showMidiThruFilter() {
983
    private void showMidiThruFilter() {
986
        if (thruFilterProperties == null) {
984
        if (thruFilterProperties == null) {
987
            final MidiFilterGUI midiFilterGUI = new MidiFilterGUI(miosStudio
985
            final MidiFilterGUI midiFilterGUI = new MidiFilterGUI(miosStudio
988
                    .getMidiThruFilterDevice().getMidiFilter());
986
                    .getMidiThruFilterDevice().getMidiFilter());
989
987
990
            thruFilterProperties = new JDialog(DialogOwner.getFrame(),
988
            thruFilterProperties = new JDialog(DialogOwner.getFrame(),
991
                    "MIDI Thru Filter", false);
989
                    "MIDI Thru Filter", false);
992
            thruFilterProperties.setContentPane(midiFilterGUI);
990
            thruFilterProperties.setContentPane(midiFilterGUI);
993
            thruFilterProperties.pack();
991
            thruFilterProperties.pack();
994
            thruFilterProperties.setLocationRelativeTo(this);
992
            thruFilterProperties.setLocationRelativeTo(this);
995
            thruFilterProperties.setVisible(true);
993
            thruFilterProperties.setVisible(true);
996
994
997
            thruFilterProperties.addWindowListener(new WindowAdapter() {
995
            thruFilterProperties.addWindowListener(new WindowAdapter() {
998
                public void windowClosing(WindowEvent we) {
996
                public void windowClosing(WindowEvent we) {
999
                    miosStudio.getMidiThruFilterDevice().deleteObserver(
997
                    miosStudio.getMidiThruFilterDevice().deleteObserver(
1000
                            midiFilterGUI);
998
                            midiFilterGUI);
1001
                    thruFilterProperties = null;
999
                    thruFilterProperties = null;
1002
                }
1000
                }
1003
            });
1001
            });
1004
        }
1002
        }
1005
        thruFilterProperties.requestFocus();
1003
        thruFilterProperties.requestFocus();
1006
    }
1004
    }
1007
1005
1008
    /*
1006
    /*
1009
     * private void showMidiThruMap() { if (thruMapProperties == null) { final
1007
     * private void showMidiThruMap() { if (thruMapProperties == null) { final
1010
     * MidiMapGUI midiMapGUI = new MidiMapGUI(miosStudio
1008
     * MidiMapGUI midiMapGUI = new MidiMapGUI(miosStudio
1011
     * .getMidiThruMapDevice().getMidiMap());
1009
     * .getMidiThruMapDevice().getMidiMap());
1012
     *
1010
     *
1013
     * thruMapProperties = new JDialog();
1011
     * thruMapProperties = new JDialog();
1014
     * thruMapProperties.setContentPane(midiMapGUI);
1012
     * thruMapProperties.setContentPane(midiMapGUI);
1015
     * thruMapProperties.setModal(false); thruMapProperties.setTitle("MIDI Thru
1013
     * thruMapProperties.setModal(false); thruMapProperties.setTitle("MIDI Thru
1016
     * Map"); thruMapProperties.pack();
1014
     * Map"); thruMapProperties.pack();
1017
     * thruMapProperties.setLocationRelativeTo(this);
1015
     * thruMapProperties.setLocationRelativeTo(this);
1018
     * thruMapProperties.setVisible(true);
1016
     * thruMapProperties.setVisible(true);
1019
     *
1017
     *
1020
     * thruMapProperties.addWindowListener(new WindowAdapter() { public void
1018
     * thruMapProperties.addWindowListener(new WindowAdapter() { public void
1021
     * windowClosing(WindowEvent we) { miosStudio.getMidiThruMapDevice()
1019
     * windowClosing(WindowEvent we) { miosStudio.getMidiThruMapDevice()
1022
     * .deleteObserver(midiMapGUI); thruMapProperties = null; } }); }
1020
     * .deleteObserver(midiMapGUI); thruMapProperties = null; } }); }
1023
     * thruMapProperties.requestFocus(); }
1021
     * thruMapProperties.requestFocus(); }
1024
     */
1022
     */
1025
1023
1026
    protected void onHelpIndex() {
1024
    protected void onHelpIndex() {
1027
        URL currentURL = helpPane.getCurrentURL();
1025
        URL currentURL = helpPane.getCurrentURL();
1028
        if (currentURL != null) {
1026
        if (currentURL != null) {
1029
            if (!currentURL.equals(ResourceLoader
1027
            if (!currentURL.equals(ResourceLoader
1030
                    .getResource("help/index.html"))) {
1028
                    .getResource("help/index.html"))) {
1031
                helpPane.goToURL(ResourceLoader.getResource("help/index.html"));
1029
                helpPane.goToURL(ResourceLoader.getResource("help/index.html"));
1032
            } else {
1030
            } else {
1033
                showFrame(helpWindow);
1031
                showFrame(helpWindow);
1034
            }
1032
            }
1035
        } else {
1033
        } else {
1036
            helpPane.goToURL(ResourceLoader.getResource("help/index.html"));
1034
            helpPane.goToURL(ResourceLoader.getResource("help/index.html"));
1037
        }
1035
        }
1038
    }
1036
    }
1039
1037
1040
    protected void onMiosFun() {
1038
    protected void onMiosFun() {
1041
        helpPane.goToURL(ResourceLoader.getResource("help/mios_fun.html"));
1039
        helpPane.goToURL(ResourceLoader.getResource("help/mios_fun.html"));
1042
    }
1040
    }
1043
1041
1044
    public void showFrame(JInternalFrame frame) {
1042
    public void showFrame(JInternalFrame frame) {
1045
        try {
1043
        try {
1046
            if (!frame.isVisible()) {
1044
            if (!frame.isVisible()) {
1047
                frame.setVisible(true);
1045
                frame.setVisible(true);
1048
                desktop.add(frame);
1046
                desktop.add(frame);
1049
                frame.moveToFront();
1047
                frame.moveToFront();
1050
                frame.setSelected(true);
1048
                frame.setSelected(true);
1051
            } else if (frame.isIcon()) {
1049
            } else if (frame.isIcon()) {
1052
                frame.setIcon(false);
1050
                frame.setIcon(false);
1053
                frame.moveToFront();
1051
                frame.moveToFront();
1054
                frame.setSelected(true);
1052
                frame.setSelected(true);
1055
            } else {
1053
            } else {
1056
                frame.moveToFront();
1054
                frame.moveToFront();
1057
                frame.setSelected(true);
1055
                frame.setSelected(true);
1058
            }
1056
            }
1059
        } catch (java.beans.PropertyVetoException e) {
1057
        } catch (java.beans.PropertyVetoException e) {
1060
            System.out.println(e.toString());
1058
            System.out.println(e.toString());
1061
        }
1059
        }
1062
    }
1060
    }
1063
1061
1064
    private void showMidiDeviceManagerDialog() {
1062
    private void showMidiDeviceManagerDialog() {
1065
        if (midiDeviceManagerDialog == null) {
1063
        if (midiDeviceManagerDialog == null) {
1066
            final MidiDeviceManagerGUI midiDeviceManagerGUI = new MidiDeviceManagerGUI(
1064
            final MidiDeviceManagerGUI midiDeviceManagerGUI = new MidiDeviceManagerGUI(
1067
                    miosStudio.getMidiDeviceManager());
1065
                    miosStudio.getMidiDeviceManager());
1068
1066
1069
            midiDeviceManagerDialog = new JDialog(DialogOwner.getFrame(),
1067
            midiDeviceManagerDialog = new JDialog(DialogOwner.getFrame(),
1070
                    "MIDI Devices", false);
1068
                    "MIDI Devices", false);
1071
            midiDeviceManagerDialog.setContentPane(midiDeviceManagerGUI);
1069
            midiDeviceManagerDialog.setContentPane(midiDeviceManagerGUI);
1072
            midiDeviceManagerDialog.pack();
1070
            midiDeviceManagerDialog.pack();
1073
            midiDeviceManagerDialog.setLocationRelativeTo(this);
1071
            midiDeviceManagerDialog.setLocationRelativeTo(this);
1074
            midiDeviceManagerDialog.setVisible(true);
1072
            midiDeviceManagerDialog.setVisible(true);
1075
1073
1076
            midiDeviceManagerDialog.addWindowListener(new WindowAdapter() {
1074
            midiDeviceManagerDialog.addWindowListener(new WindowAdapter() {
1077
                public void windowClosing(WindowEvent we) {
1075
                public void windowClosing(WindowEvent we) {
1078
                    miosStudio.getMidiDeviceManager().deleteObserver(
1076
                    miosStudio.getMidiDeviceManager().deleteObserver(
1079
                            midiDeviceManagerGUI);
1077
                            midiDeviceManagerGUI);
1080
                    midiDeviceManagerDialog = null;
1078
                    midiDeviceManagerDialog = null;
1081
                }
1079
                }
1082
            });
1080
            });
1083
        }
1081
        }
1084
        midiDeviceManagerDialog.requestFocus();
1082
        midiDeviceManagerDialog.requestFocus();
1085
    }
1083
    }
1086
1084
1087
    private void showMidiFilterManagerDialog() {
1085
    private void showMidiFilterManagerDialog() {
1088
        if (midiFilterManagerDialog == null) {
1086
        if (midiFilterManagerDialog == null) {
1089
            final MidiFilterDeviceManagerGUI midiFilterManagerGUI = new MidiFilterDeviceManagerGUI(
1087
            final MidiFilterDeviceManagerGUI midiFilterManagerGUI = new MidiFilterDeviceManagerGUI(
1090
                    miosStudio.getMidiFilterManager());
1088
                    miosStudio.getMidiFilterManager());
1091
1089
1092
            midiFilterManagerDialog = new JDialog(DialogOwner.getFrame(),
1090
            midiFilterManagerDialog = new JDialog(DialogOwner.getFrame(),
1093
                    "Filters", false);
1091
                    "Filters", false);
1094
            midiFilterManagerDialog.setContentPane(midiFilterManagerGUI);
1092
            midiFilterManagerDialog.setContentPane(midiFilterManagerGUI);
1095
            midiFilterManagerDialog.pack();
1093
            midiFilterManagerDialog.pack();
1096
            midiFilterManagerDialog.setLocationRelativeTo(this);
1094
            midiFilterManagerDialog.setLocationRelativeTo(this);
1097
            midiFilterManagerDialog.setVisible(true);
1095
            midiFilterManagerDialog.setVisible(true);
1098
1096
1099
            midiFilterManagerDialog.addWindowListener(new WindowAdapter() {
1097
            midiFilterManagerDialog.addWindowListener(new WindowAdapter() {
1100
                public void windowClosing(WindowEvent we) {
1098
                public void windowClosing(WindowEvent we) {
1101
                    miosStudio.getMidiFilterManager().deleteObserver(
1099
                    miosStudio.getMidiFilterManager().deleteObserver(
1102
                            midiFilterManagerGUI);
1100
                            midiFilterManagerGUI);
1103
                    midiFilterManagerDialog = null;
1101
                    midiFilterManagerDialog = null;
1104
                }
1102
                }
1105
            });
1103
            });
1106
        }
1104
        }
1107
        midiFilterManagerDialog.requestFocus();
1105
        midiFilterManagerDialog.requestFocus();
1108
    }
1106
    }
1109
1107
1110
    /*
1108
    /*
1111
     * private void showMapManagerDialog() { if (midiMapManagerDialog == null) {
1109
     * private void showMapManagerDialog() { if (midiMapManagerDialog == null) {
1112
     * final MidiMapDeviceManagerGUI midiMapManagerGUI = new
1110
     * final MidiMapDeviceManagerGUI midiMapManagerGUI = new
1113
     * MidiMapDeviceManagerGUI( midiDeviceRouting.getMidiMapManager());
1111
     * MidiMapDeviceManagerGUI( midiDeviceRouting.getMidiMapManager());
1114
     *
1112
     *
1115
     * midiMapManagerDialog = new JDialog();
1113
     * midiMapManagerDialog = new JDialog();
1116
     * midiMapManagerDialog.setModal(false);
1114
     * midiMapManagerDialog.setModal(false);
1117
     * midiMapManagerDialog.setTitle("Maps");
1115
     * midiMapManagerDialog.setTitle("Maps");
1118
     * midiMapManagerDialog.setContentPane(midiMapManagerGUI);
1116
     * midiMapManagerDialog.setContentPane(midiMapManagerGUI);
1119
     * midiMapManagerDialog.pack();
1117
     * midiMapManagerDialog.pack();
1120
     * midiMapManagerDialog.setLocationRelativeTo(this);
1118
     * midiMapManagerDialog.setLocationRelativeTo(this);
1121
     * midiMapManagerDialog.setVisible(true);
1119
     * midiMapManagerDialog.setVisible(true);
1122
     *
1120
     *
1123
     * midiMapManagerDialog.addWindowListener(new WindowAdapter() { public void
1121
     * midiMapManagerDialog.addWindowListener(new WindowAdapter() { public void
1124
     * windowClosing(WindowEvent we) {
1122
     * windowClosing(WindowEvent we) {
1125
     * midiDeviceRouting.getMidiMapManager().deleteObserver( midiMapManagerGUI);
1123
     * midiDeviceRouting.getMidiMapManager().deleteObserver( midiMapManagerGUI);
1126
     * midiMapManagerDialog = null; } }); } midiMapManagerDialog.requestFocus();
1124
     * midiMapManagerDialog = null; } }); } midiMapManagerDialog.requestFocus();
1127
     * }
1125
     * }
1128
     */
1126
     */
1129
1127
1130
    private void buildMRUMenu(JComponent menu) {
1128
    private void buildMRUMenu(JComponent menu) {
1131
1129
1132
        menu.removeAll();
1130
        menu.removeAll();
1133
1131
1134
        Iterator it = MRU.iterator();
1132
        Iterator it = MRU.iterator();
1135
1133
1136
        while (it.hasNext()) {
1134
        while (it.hasNext()) {
1137
1135
1138
            final JMenuItem menuItem = new JMenuItem((String) it.next());
1136
            final JMenuItem menuItem = new JMenuItem((String) it.next());
1139
1137
1140
            menuItem.addActionListener(new ActionListener() {
1138
            menuItem.addActionListener(new ActionListener() {
1141
1139
1142
                public void actionPerformed(ActionEvent ae) {
1140
                public void actionPerformed(ActionEvent ae) {
1143
1141
1144
                    File file = new File(menuItem.getText());
1142
                    File file = new File(menuItem.getText());
1145
1143
1146
                    openWorkspace(file);
1144
                    openWorkspace(file);
1147
                }
1145
                }
1148
            });
1146
            });
1149
1147
1150
            menu.add(menuItem, 0);
1148
            menu.add(menuItem, 0);
1151
        }
1149
        }
1152
    }
1150
    }
1153
1151
1154
    private void buildLookAndFeel() {
1152
    private void buildLookAndFeel() {
1155
1153
1156
        JCheckBoxMenuItem item;
1154
        JCheckBoxMenuItem item;
1157
1155
1158
        for (int i = 0; i < UIManager.getInstalledLookAndFeels().length; i++) {
1156
        for (int i = 0; i < UIManager.getInstalledLookAndFeels().length; i++) {
1159
            final int l = i;
1157
            final int l = i;
1160
            item = new JCheckBoxMenuItem(
1158
            item = new JCheckBoxMenuItem(
1161
                    UIManager.getInstalledLookAndFeels()[i].getName());
1159
                    UIManager.getInstalledLookAndFeels()[i].getName());
1162
            lookAndFeelMenu.add(item);
1160
            lookAndFeelMenu.add(item);
1163
            if (UIManager.getInstalledLookAndFeels()[i].getClassName().equals(
1161
            if (UIManager.getInstalledLookAndFeels()[i].getClassName().equals(
1164
                    lookAndFeel)) {
1162
                    lookAndFeel)) {
1165
                item.setSelected(true);
1163
                item.setSelected(true);
1166
            }
1164
            }
1167
            item.addActionListener(new ActionListener() {
1165
            item.addActionListener(new ActionListener() {
1168
                public void actionPerformed(ActionEvent ae) {
1166
                public void actionPerformed(ActionEvent ae) {
1169
                    try {
1167
                    try {
1170
1168
1171
                        setLookAndFeel(UIManager.getInstalledLookAndFeels()[l]
1169
                        setLookAndFeel(UIManager.getInstalledLookAndFeels()[l]
1172
                                .getClassName());
1170
                                .getClassName());
1173
1171
1174
                    } catch (Exception e) {
1172
                    } catch (Exception e) {
1175
                        System.out.println(e.toString());
1173
                        System.out.println(e.toString());
1176
                    }
1174
                    }
1177
                }
1175
                }
1178
            });
1176
            });
1179
        }
1177
        }
1180
    }
1178
    }
1181
1179
1182
    public JMenu getFileMenu() {
1180
    public JMenu getFileMenu() {
1183
        return fileMenu;
1181
        return fileMenu;
1184
    }
1182
    }
1185
1183
1186
    public MIOSStudio getMiosStudio() {
1184
    public MIOSStudio getMiosStudio() {
1187
        return miosStudio;
1185
        return miosStudio;
1188
    }
1186
    }
1189
1187
1190
    public Vector getExternalCommands() {
1188
    public Vector getExternalCommands() {
1191
        return externalCommands;
1189
        return externalCommands;
1192
    }
1190
    }
1193
1191
1194
    public String getLookAndFeel() {
1192
    public String getLookAndFeel() {
1195
        return lookAndFeel;
1193
        return lookAndFeel;
1196
    }
1194
    }
1197
1195
1198
    public JDesktopPane getDesktop() {
1196
    public JDesktopPane getDesktop() {
1199
        return desktop;
1197
        return desktop;
1200
    }
1198
    }
1201
1199
1202
    public MIOSStudioInternalFrame getMidiDeviceRoutingWindow() {
1200
    public MIOSStudioInternalFrame getMidiDeviceRoutingWindow() {
1203
        return midiDeviceRoutingWindow;
1201
        return midiDeviceRoutingWindow;
1204
    }
1202
    }
1205
1203
1206
    public MIOSStudioInternalFrame getMidiOutPortMonitorWindow() {
1204
    public MIOSStudioInternalFrame getMidiOutPortMonitorWindow() {
1207
        return midiOutPortMonitorWindow;
1205
        return midiOutPortMonitorWindow;
1208
    }
1206
    }
1209
1207
1210
    public MIOSStudioInternalFrame getMidiInPortMonitorWindow() {
1208
    public MIOSStudioInternalFrame getMidiInPortMonitorWindow() {
1211
        return midiInPortMonitorWindow;
1209
        return midiInPortMonitorWindow;
1212
    }
1210
    }
1213
1211
1214
    public MIOSStudioInternalFrame getMidiKeyboardControllerWindow() {
1212
    public MIOSStudioInternalFrame getMidiKeyboardControllerWindow() {
1215
        return midiKeyboardControllerWindow;
1213
        return midiKeyboardControllerWindow;
1216
    }
1214
    }
1217
1215
1218
    public MIOSStudioInternalFrame getHexFileUploadDeviceManagerWindow() {
1216
    public MIOSStudioInternalFrame getHexFileUploadDeviceManagerWindow() {
1219
        return hexFileUploadDeviceManagerWindow;
1217
        return hexFileUploadDeviceManagerWindow;
1220
    }
1218
    }
1221
1219
1222
    public MIOSStudioInternalFrame getLcdMessageWindow() {
1220
    public MIOSStudioInternalFrame getLcdMessageWindow() {
1223
        return lcdMessageWindow;
1221
        return lcdMessageWindow;
1224
    }
1222
    }
1225
1223
1226
    public MIOSStudioInternalFrame getDebugFunctionWindow() {
1224
    public MIOSStudioInternalFrame getDebugFunctionWindow() {
1227
        return debugFunctionWindow;
1225
        return debugFunctionWindow;
1228
    }
1226
    }
1229
1227
1230
    public MIOSStudioInternalFrame getMIOSTerminalWindow() {
1228
    public MIOSStudioInternalFrame getMIOSTerminalWindow() {
1231
        return miosTerminalWindow;
1229
        return miosTerminalWindow;
1232
    }
1230
    }
1233
1231
1234
    public MIOSStudioInternalFrame getHelpWindow() {
1232
    public MIOSStudioInternalFrame getHelpWindow() {
1235
        return helpWindow;
1233
        return helpWindow;
1236
    }
1234
    }
1237
1235
1238
    protected void openWorkspace() {
1236
    protected void openWorkspace() {
1239
1237
1240
        if (fc == null) {
1238
        if (fc == null) {
1241
            fc = new JFileChooser(currentDirectory);
1239
            fc = new JFileChooser(currentDirectory);
1242
            SimpleFileChooserFilter fileFilter = new SimpleFileChooserFilter(
1240
            SimpleFileChooserFilter fileFilter = new SimpleFileChooserFilter(
1243
                    "XML files", "xml", "XML Workspace Definition");
1241
                    "XML files", "xml", "XML Workspace Definition");
1244
            fc.addChoosableFileFilter(fileFilter);
1242
            fc.addChoosableFileFilter(fileFilter);
1245
            fc.setAcceptAllFileFilterUsed(false);
1243
            fc.setAcceptAllFileFilterUsed(false);
1246
        }
1244
        }
1247
1245
1248
        File noFile = new File("");
1246
        File noFile = new File("");
1249
        File noFiles[] = { noFile };
1247
        File noFiles[] = { noFile };
1250
        fc.setSelectedFile(noFile);
1248
        fc.setSelectedFile(noFile);
1251
        fc.setSelectedFiles(noFiles);
1249
        fc.setSelectedFiles(noFiles);
1252
1250
1253
        int nRetVal = fc.showOpenDialog(this);
1251
        int nRetVal = fc.showOpenDialog(this);
1254
1252
1255
        if (nRetVal == JFileChooser.APPROVE_OPTION) {
1253
        if (nRetVal == JFileChooser.APPROVE_OPTION) {
1256
1254
1257
            final File file = fc.getSelectedFile();
1255
            final File file = fc.getSelectedFile();
1258
1256
1259
            openWorkspace(file);
1257
            openWorkspace(file);
1260
1258
1261
            currentDirectory = fc.getCurrentDirectory().toString();
1259
            currentDirectory = fc.getCurrentDirectory().toString();
1262
        }
1260
        }
1263
    }
1261
    }
1264
1262
1265
    protected void openWorkspace(File workspaceFile) {
1263
    protected void openWorkspace(File workspaceFile) {
1266
1264
1267
        final File file = workspaceFile;
1265
        final File file = workspaceFile;
1268
1266
1269
        if (file.exists()) {
1267
        if (file.exists()) {
1270
1268
1271
            final WorkspaceOptionDialog workspaceOptionDialog = new WorkspaceOptionDialog();
1269
            final WorkspaceOptionDialog workspaceOptionDialog = new WorkspaceOptionDialog();
1272
1270
1273
            Boolean bool = MIOSStudioGUIXML.containsTag(file,
1271
            Boolean bool = MIOSStudioGUIXML.containsTag(file,
1274
                    MIOSStudioXML.TAG_ROOT_ELEMENT);
1272
                    MIOSStudioXML.TAG_ROOT_ELEMENT);
1275
            workspaceOptionDialog.modelCheckBox.setEnabled(bool);
1273
            workspaceOptionDialog.modelCheckBox.setEnabled(bool);
1276
            workspaceOptionDialog.modelCheckBox.setSelected(bool);
1274
            workspaceOptionDialog.modelCheckBox.setSelected(bool);
1277
1275
1278
            bool = MIOSStudioGUIXML.containsTag(file,
1276
            bool = MIOSStudioGUIXML.containsTag(file,
1279
                    MIOSStudioGUIXML.TAG_INTERNAL_FRAMES);
1277
                    MIOSStudioGUIXML.TAG_INTERNAL_FRAMES);
1280
            workspaceOptionDialog.guiCheckBox.setEnabled(bool);
1278
            workspaceOptionDialog.guiCheckBox.setEnabled(bool);
1281
            workspaceOptionDialog.guiCheckBox.setSelected(bool);
1279
            workspaceOptionDialog.guiCheckBox.setSelected(bool);
1282
1280
1283
            bool = MIOSStudioGUIXML.containsTag(file,
1281
            bool = MIOSStudioGUIXML.containsTag(file,
1284
                    MIOSStudioGUIXML.TAG_EXTERNAL_COMMANDS);
1282
                    MIOSStudioGUIXML.TAG_EXTERNAL_COMMANDS);
1285
            workspaceOptionDialog.externalCommandsCheckBox.setEnabled(bool);
1283
            workspaceOptionDialog.externalCommandsCheckBox.setEnabled(bool);
1286
            workspaceOptionDialog.externalCommandsCheckBox.setSelected(bool);
1284
            workspaceOptionDialog.externalCommandsCheckBox.setSelected(bool);
1287
1285
1288
            bool = MIOSStudioGUIXML.containsTag(file,
1286
            bool = MIOSStudioGUIXML.containsTag(file,
1289
                    MIOSStudioGUIXML.TAG_LOOK_AND_FEEL);
1287
                    MIOSStudioGUIXML.TAG_LOOK_AND_FEEL);
1290
            workspaceOptionDialog.lookAndFeelCheckBox.setEnabled(bool);
1288
            workspaceOptionDialog.lookAndFeelCheckBox.setEnabled(bool);
1291
            workspaceOptionDialog.lookAndFeelCheckBox.setSelected(bool);
1289
            workspaceOptionDialog.lookAndFeelCheckBox.setSelected(bool);
1292
1290
1293
            workspaceOptionDialog.pack();
1291
            workspaceOptionDialog.pack();
1294
1292
1295
            workspaceOptionDialog.okButton
1293
            workspaceOptionDialog.okButton
1296
                    .addActionListener(new ActionListener() {
1294
                    .addActionListener(new ActionListener() {
1297
1295
1298
                        public void actionPerformed(ActionEvent ae) {
1296
                        public void actionPerformed(ActionEvent ae) {
1299
1297
1300
                            workspaceOptionDialog.setVisible(false);
1298
                            workspaceOptionDialog.setVisible(false);
1301
1299
1302
                            MIOSStudioGUIXML miosStudioGUIXML = new MIOSStudioGUIXML(
1300
                            MIOSStudioGUIXML miosStudioGUIXML = new MIOSStudioGUIXML(
1303
                                    MIOSStudioGUI.this,
1301
                                    MIOSStudioGUI.this,
1304
                                    MIOSStudioGUIXML.TAG_ROOT_ELEMENT,
1302
                                    MIOSStudioGUIXML.TAG_ROOT_ELEMENT,
1305
                                    workspaceOptionDialog.modelCheckBox
1303
                                    workspaceOptionDialog.modelCheckBox
1306
                                            .isSelected(),
1304
                                            .isSelected(),
1307
                                    workspaceOptionDialog.guiCheckBox
1305
                                    workspaceOptionDialog.guiCheckBox
1308
                                            .isSelected(),
1306
                                            .isSelected(),
1309
                                    workspaceOptionDialog.externalCommandsCheckBox
1307
                                    workspaceOptionDialog.externalCommandsCheckBox
1310
                                            .isSelected(),
1308
                                            .isSelected(),
1311
                                    workspaceOptionDialog.lookAndFeelCheckBox
1309
                                    workspaceOptionDialog.lookAndFeelCheckBox
1312
                                            .isSelected(), false);
1310
                                            .isSelected(), false);
1313
1311
1314
                            miosStudioGUIXML.loadXML(file);
1312
                            miosStudioGUIXML.loadXML(file);
1315
1313
1316
                        }
1314
                        }
1317
                    });
1315
                    });
1318
1316
1319
            workspaceOptionDialog.setLocationRelativeTo(this);
1317
            workspaceOptionDialog.setLocationRelativeTo(this);
1320
1318
1321
            workspaceOptionDialog.setVisible(true);
1319
            workspaceOptionDialog.setVisible(true);
1322
1320
1323
            saveMRU(file.getPath());
1321
            saveMRU(file.getPath());
1324
1322
1325
        } else {
1323
        } else {
1326
1324
1327
            JOptionPane.showMessageDialog(this,
1325
            JOptionPane.showMessageDialog(this,
1328
                    "Workspace configuration file no longer exists",
1326
                    "Workspace configuration file no longer exists",
1329
                    "File does not exist", JOptionPane.ERROR_MESSAGE);
1327
                    "File does not exist", JOptionPane.ERROR_MESSAGE);
1330
        }
1328
        }
1331
    }
1329
    }
1332
1330
1333
    public void saveMRU(String file) {
1331
    public void saveMRU(String file) {
1334
1332
1335
        MRU.remove(file);
1333
        MRU.remove(file);
1336
1334
1337
        MRU.add(file);
1335
        MRU.add(file);
1338
1336
1339
        for (int i = MRU.size() - maxMRU; i > 0; i--) {
1337
        for (int i = MRU.size() - maxMRU; i > 0; i--) {
1340
1338
1341
            MRU.removeElementAt(i - 1);
1339
            MRU.removeElementAt(i - 1);
1342
        }
1340
        }
1343
    }
1341
    }
1344
1342
1345
    protected void saveWorkspace() {
1343
    protected void saveWorkspace() {
1346
1344
1347
        if (fc == null) {
1345
        if (fc == null) {
1348
            fc = new JFileChooser(currentDirectory);
1346
            fc = new JFileChooser(currentDirectory);
1349
            SimpleFileChooserFilter fileFilter = new SimpleFileChooserFilter(
1347
            SimpleFileChooserFilter fileFilter = new SimpleFileChooserFilter(
1350
                    "XML files", "xml", "XML Workspace Definition");
1348
                    "XML files", "xml", "XML Workspace Definition");
1351
            fc.addChoosableFileFilter(fileFilter);
1349
            fc.addChoosableFileFilter(fileFilter);
1352
            fc.setAcceptAllFileFilterUsed(false);
1350
            fc.setAcceptAllFileFilterUsed(false);
1353
        }
1351
        }
1354
1352
1355
        File noFile = new File("");
1353
        File noFile = new File("");
1356
        File noFiles[] = { noFile };
1354
        File noFiles[] = { noFile };
1357
        fc.setSelectedFile(noFile);
1355
        fc.setSelectedFile(noFile);
1358
        fc.setSelectedFiles(noFiles);
1356
        fc.setSelectedFiles(noFiles);
1359
1357
1360
        int nRetVal = fc.showSaveDialog(this);
1358
        int nRetVal = fc.showSaveDialog(this);
1361
1359
1362
        if (nRetVal == JFileChooser.APPROVE_OPTION) {
1360
        if (nRetVal == JFileChooser.APPROVE_OPTION) {
1363
1361
1364
            final File file = fc.getSelectedFile();
1362
            final File file = fc.getSelectedFile();
1365
1363
1366
            final WorkspaceOptionDialog workspaceOptionDialog = new WorkspaceOptionDialog();
1364
            final WorkspaceOptionDialog workspaceOptionDialog = new WorkspaceOptionDialog();
1367
1365
1368
            workspaceOptionDialog.pack();
1366
            workspaceOptionDialog.pack();
1369
1367
1370
            workspaceOptionDialog.okButton
1368
            workspaceOptionDialog.okButton
1371
                    .addActionListener(new ActionListener() {
1369
                    .addActionListener(new ActionListener() {
1372
1370
1373
                        public void actionPerformed(ActionEvent ae) {
1371
                        public void actionPerformed(ActionEvent ae) {
1374
1372
1375
                            workspaceOptionDialog.setVisible(false);
1373
                            workspaceOptionDialog.setVisible(false);
1376
1374
1377
                            MIOSStudioGUIXML miosStudioGUIXML = new MIOSStudioGUIXML(
1375
                            MIOSStudioGUIXML miosStudioGUIXML = new MIOSStudioGUIXML(
1378
                                    MIOSStudioGUI.this,
1376
                                    MIOSStudioGUI.this,
1379
                                    MIOSStudioGUIXML.TAG_ROOT_ELEMENT,
1377
                                    MIOSStudioGUIXML.TAG_ROOT_ELEMENT,
1380
                                    workspaceOptionDialog.modelCheckBox
1378
                                    workspaceOptionDialog.modelCheckBox
1381
                                            .isSelected(),
1379
                                            .isSelected(),
1382
                                    workspaceOptionDialog.guiCheckBox
1380
                                    workspaceOptionDialog.guiCheckBox
1383
                                            .isSelected(),
1381
                                            .isSelected(),
1384
                                    workspaceOptionDialog.externalCommandsCheckBox
1382
                                    workspaceOptionDialog.externalCommandsCheckBox
1385
                                            .isSelected(),
1383
                                            .isSelected(),
1386
                                    workspaceOptionDialog.lookAndFeelCheckBox
1384
                                    workspaceOptionDialog.lookAndFeelCheckBox
1387
                                            .isSelected(), false);
1385
                                            .isSelected(), false);
1388
1386
1389
                            miosStudioGUIXML.saveXML(file);
1387
                            miosStudioGUIXML.saveXML(file);
1390
1388
1391
                            currentDirectory = fc.getCurrentDirectory()
1389
                            currentDirectory = fc.getCurrentDirectory()
1392
                                    .toString();
1390
                                    .toString();
1393
                        }
1391
                        }
1394
                    });
1392
                    });
1395
1393
1396
            workspaceOptionDialog.setLocationRelativeTo(this);
1394
            workspaceOptionDialog.setLocationRelativeTo(this);
1397
1395
1398
            workspaceOptionDialog.setVisible(true);
1396
            workspaceOptionDialog.setVisible(true);
1399
1397
1400
            saveMRU(file.getPath());
1398
            saveMRU(file.getPath());
1401
        }
1399
        }
1402
    }
1400
    }
1403
1401
1404
    /*
1402
    /*
1405
     * public MIOSStudioInternalFrame getSysexSendReceiveDeviceManagerWindow() {
1403
     * public MIOSStudioInternalFrame getSysexSendReceiveDeviceManagerWindow() {
1406
     * return sysexSendReceiveDeviceManagerWindow; }
1404
     * return sysexSendReceiveDeviceManagerWindow; }
1407
     */
1405
     */
1408
    public void mousePressed(MouseEvent me) {
1406
    public void mousePressed(MouseEvent me) {
1409
        Object source = me.getSource();
1407
        Object source = me.getSource();
1410
1408
1411
        if (source == toolBar) {
1409
        if (source == toolBar) {
1412
            if (me.getButton() == MouseEvent.BUTTON3) {
1410
            if (me.getButton() == MouseEvent.BUTTON3) {
1413
                toolBarMenu.show(toolBar, me.getX(), me.getY());
1411
                toolBarMenu.show(toolBar, me.getX(), me.getY());
1414
            }
1412
            }
1415
        } else if (source instanceof ExternalCommandButton) {
1413
        } else if (source instanceof ExternalCommandButton) {
1416
            if (me.getButton() == MouseEvent.BUTTON3) {
1414
            if (me.getButton() == MouseEvent.BUTTON3) {
1417
                ((ExternalCommandButton) source).popMenu.show(
1415
                ((ExternalCommandButton) source).popMenu.show(
1418
                        ((ExternalCommandButton) source), me.getX(), me.getY());
1416
                        ((ExternalCommandButton) source), me.getX(), me.getY());
1419
            }
1417
            }
1420
        }
1418
        }
1421
    }
1419
    }
1422
1420
1423
    public void mouseReleased(MouseEvent me) {
1421
    public void mouseReleased(MouseEvent me) {
1424
1422
1425
    }
1423
    }
1426
1424
1427
    public void mouseClicked(MouseEvent me) {
1425
    public void mouseClicked(MouseEvent me) {
1428
1426
1429
    }
1427
    }
1430
1428
1431
    public void mouseEntered(MouseEvent me) {
1429
    public void mouseEntered(MouseEvent me) {
1432
1430
1433
    }
1431
    }
1434
1432
1435
    public void mouseExited(MouseEvent me) {
1433
    public void mouseExited(MouseEvent me) {
1436
1434
1437
    }
1435
    }
1438
1436
1439
    public void propertyChange(PropertyChangeEvent pce) {
1437
    public void propertyChange(PropertyChangeEvent pce) {
1440
        showFrame(helpWindow);
1438
        showFrame(helpWindow);
1441
    }
1439
    }
1442
1440
1443
    public void menuCanceled(MenuEvent e) {
1441
    public void menuCanceled(MenuEvent e) {
1444
    }
1442
    }
1445
1443
1446
    public void menuDeselected(MenuEvent e) {
1444
    public void menuDeselected(MenuEvent e) {
1447
        Object source = e.getSource();
1445
        Object source = e.getSource();
1448
1446
1449
        if (source == windowMenu) {
1447
        if (source == windowMenu) {
1450
            windowMenu.removeAll();
1448
            windowMenu.removeAll();
1451
        } else if (source == lookAndFeelMenu) {
1449
        } else if (source == lookAndFeelMenu) {
1452
            lookAndFeelMenu.removeAll();
1450
            lookAndFeelMenu.removeAll();
1453
        }
1451
        }
1454
    }
1452
    }
1455
1453
1456
    public void menuSelected(MenuEvent e) {
1454
    public void menuSelected(MenuEvent e) {
1457
        Object source = e.getSource();
1455
        Object source = e.getSource();
1458
1456
1459
        if (source == windowMenu) {
1457
        if (source == windowMenu) {
1460
            windowMenu.buildChildMenus();
1458
            windowMenu.buildChildMenus();
1461
        } else if (source == lookAndFeelMenu) {
1459
        } else if (source == lookAndFeelMenu) {
1462
            buildLookAndFeel();
1460
            buildLookAndFeel();
1463
        } else if (source == MRUMenu) {
1461
        } else if (source == MRUMenu) {
1464
            buildMRUMenu(MRUMenu);
1462
            buildMRUMenu(MRUMenu);
1465
        }
1463
        }
1466
    }
1464
    }
1467
1465
1468
    public void update(Observable observable, Object object) {
1466
    public void update(Observable observable, Object object) {
1469
1467
1470
        if (object == MIOSStudio.ROUTE_INDIVIDUAL_DEVICES) {
1468
        if (object == MIOSStudio.ROUTE_INDIVIDUAL_DEVICES) {
1471
1469
1472
            showInternalMenuItem.setSelected(miosStudio
1470
            showInternalMenuItem.setSelected(miosStudio
1473
                    .isRouteIndividualDevices());
1471
                    .isRouteIndividualDevices());
1474
1472
1475
        } else if (object == MIOSStudio.MIDI_THRU_OUT_PORT) {
1473
        } else if (object == MIOSStudio.MIDI_THRU_OUT_PORT) {
1476
1474
1477
            midiThruMenuItem.setSelected(miosStudio.isMidiThruOutPort());
1475
            midiThruMenuItem.setSelected(miosStudio.isMidiThruOutPort());
1478
        }
1476
        }
1479
    }
1477
    }
1480
1478
1481
    public void actionPerformed(ActionEvent ae) {
1479
    public void actionPerformed(ActionEvent ae) {
1482
1480
1483
        if (ae.getActionCommand().equals("midi_devices")) {
1481
        if (ae.getActionCommand().equals("midi_devices")) {
1484
            showMidiDeviceManagerDialog();
1482
            showMidiDeviceManagerDialog();
1485
1483
1486
        } else if (ae.getActionCommand().equals("midi_filters")) {
1484
        } else if (ae.getActionCommand().equals("midi_filters")) {
1487
            showMidiFilterManagerDialog();
1485
            showMidiFilterManagerDialog();
1488
1486
1489
        } else if (ae.getActionCommand().equals("midi_routing")) {
1487
        } else if (ae.getActionCommand().equals("midi_routing")) {
1490
            showFrame(midiDeviceRoutingWindow);
1488
            showFrame(midiDeviceRoutingWindow);
1491
1489
1492
        } else if (ae.getActionCommand().equals("midi_out_port_monitor")) {
1490
        } else if (ae.getActionCommand().equals("midi_out_port_monitor")) {
1493
            showFrame(midiOutPortMonitorWindow);
1491
            showFrame(midiOutPortMonitorWindow);
1494
1492
1495
        } else if (ae.getActionCommand().equals("midi_in_port_monitor")) {
1493
        } else if (ae.getActionCommand().equals("midi_in_port_monitor")) {
1496
            showFrame(midiInPortMonitorWindow);
1494
            showFrame(midiInPortMonitorWindow);
1497
1495
1498
        } else if (ae.getActionCommand().equals("piano_controller")) {
1496
        } else if (ae.getActionCommand().equals("piano_controller")) {
1499
            showFrame(midiKeyboardControllerWindow);
1497
            showFrame(midiKeyboardControllerWindow);
1500
1498
1501
        } else if (ae.getActionCommand().equals("open_hex_file")) {
1499
        } else if (ae.getActionCommand().equals("open_hex_file")) {
1502
            showFrame(hexFileUploadDeviceManagerWindow);
1500
            showFrame(hexFileUploadDeviceManagerWindow);
1503
1501
1504
        } else if (ae.getActionCommand().equals("lcd_message")) {
1502
        } else if (ae.getActionCommand().equals("lcd_message")) {
1505
            showFrame(lcdMessageWindow);
1503
            showFrame(lcdMessageWindow);
1506
1504
1507
        } else if (ae.getActionCommand().equals("debug_functions")) {
1505
        } else if (ae.getActionCommand().equals("debug_functions")) {
1508
            showFrame(debugFunctionWindow);
1506
            showFrame(debugFunctionWindow);
1509
1507
1510
        } else if (ae.getActionCommand().equals("mios_terminal")) {
1508
        } else if (ae.getActionCommand().equals("mios_terminal")) {
1511
            showFrame(miosTerminalWindow);
1509
            showFrame(miosTerminalWindow);
1512
1510
1513
        } else if (ae.getActionCommand().equals("route_internal")) {
1511
        } else if (ae.getActionCommand().equals("route_internal")) {
1514
            showFrame(midiDeviceRoutingWindow);
1512
            showFrame(midiDeviceRoutingWindow);
1515
            miosStudio.setRouteIndividualDevices(showInternalMenuItem
1513
            miosStudio.setRouteIndividualDevices(showInternalMenuItem
1516
                    .isSelected());
1514
                    .isSelected());
1517
1515
1518
        } else if (ae.getActionCommand().equals("restore_default")) {
1516
        } else if (ae.getActionCommand().equals("restore_default")) {
1519
            miosStudio.connectDevices();
1517
            miosStudio.connectDevices();
1520
1518
1521
        } else if (ae.getActionCommand().equals("midi_thru_filter")) {
1519
        } else if (ae.getActionCommand().equals("midi_thru_filter")) {
1522
            showMidiThruFilter();
1520
            showMidiThruFilter();
1523
1521
1524
        } else if (ae.getActionCommand().equals("midi_thru")) {
1522
        } else if (ae.getActionCommand().equals("midi_thru")) {
1525
            miosStudio.setMidiThruOutPort(midiThruMenuItem.isSelected());
1523
            miosStudio.setMidiThruOutPort(midiThruMenuItem.isSelected());
1526
1524
1527
        } else if (ae.getActionCommand().equals("help_window")) {
1525
        } else if (ae.getActionCommand().equals("help_window")) {
1528
            showFrame(helpWindow);
1526
            showFrame(helpWindow);
1529
1527
1530
        } else if (ae.getActionCommand().equals("help_index")) {
1528
        } else if (ae.getActionCommand().equals("help_index")) {
1531
            onHelpIndex();
1529
            onHelpIndex();
1532
1530
1533
        } else if (ae.getActionCommand().equals("mios_fun")) {
1531
        } else if (ae.getActionCommand().equals("mios_fun")) {
1534
            onMiosFun();
1532
            onMiosFun();
1535
1533
1536
        } else if (ae.getActionCommand().equals("externalCommand")) {
1534
        } else if (ae.getActionCommand().equals("externalCommand")) {
1537
            runExternalCommand(((ExternalCommandButton) ae.getSource()).externalCommand);
1535
            runExternalCommand(((ExternalCommandButton) ae.getSource()).externalCommand);
1538
1536
1539
        } else if (ae.getActionCommand().equals("add_command_button")) {
1537
        } else if (ae.getActionCommand().equals("add_command_button")) {
1540
            addExternalCommandButton("[empty]", "");
1538
            addExternalCommandButton("[empty]", "");
1541
1539
1542
        } else if (ae.getActionCommand().equals("open_workspace")) {
1540
        } else if (ae.getActionCommand().equals("open_workspace")) {
1543
            openWorkspace();
1541
            openWorkspace();
1544
1542
1545
        } else if (ae.getActionCommand().equals("save_workspace")) {
1543
        } else if (ae.getActionCommand().equals("save_workspace")) {
1546
            saveWorkspace();
1544
            saveWorkspace();
1547
        }
1545
        }
1548
    }
1546
    }
1549
1547
1550
    public class MIOSStudioInternalFrame extends JInternalFrame {
1548
    public class MIOSStudioInternalFrame extends JInternalFrame {
1551
        public MIOSStudioInternalFrame(String name, boolean resizeable,
1549
        public MIOSStudioInternalFrame(String name, boolean resizeable,
1552
                boolean closeable, boolean maximizeable, boolean iconifiable,
1550
                boolean closeable, boolean maximizeable, boolean iconifiable,
1553
                Icon icon, JComponent contentPane) {
1551
                Icon icon, JComponent contentPane) {
1554
            super(name, resizeable, closeable, maximizeable, iconifiable);
1552
            super(name, resizeable, closeable, maximizeable, iconifiable);
1555
            setFrameIcon(icon);
1553
            setFrameIcon(icon);
1556
            setContentPane(contentPane);
1554
            setContentPane(contentPane);
1557
        }
1555
        }
1558
1556
1559
        public Dimension getMinimumSize() {
1557
        public Dimension getMinimumSize() {
1560
            return getPreferredSize();
1558
            return getPreferredSize();
1561
        }
1559
        }
1562
    }
1560
    }
1563
1561
1564
    public class ExternalCommandButton extends JButton implements
1562
    public class ExternalCommandButton extends JButton implements
1565
            ActionListener {
1563
            ActionListener {
1566
1564
1567
        public String externalCommand = "";
1565
        public String externalCommand = "";
1568
1566
1569
        public String commandName = "";
1567
        public String commandName = "";
1570
1568
1571
        public JPopupMenu popMenu;
1569
        public JPopupMenu popMenu;
1572
1570
1573
        public ExternalCommandButton() {
1571
        public ExternalCommandButton() {
1574
            super(ImageLoader.getImageIcon("external.png"));
1572
            super(ImageLoader.getImageIcon("external.png"));
1575
1573
1576
            Insets insets = new Insets(2, 2, 2, 2);
1574
            Insets insets = new Insets(2, 2, 2, 2);
1577
1575
1578
            setMargin(insets);
1576
            setMargin(insets);
1579
            setActionCommand("externalCommand");
1577
            setActionCommand("externalCommand");
1580
            addActionListener(MIOSStudioGUI.this);
1578
            addActionListener(MIOSStudioGUI.this);
1581
            setToolTipText(commandName);
1579
            setToolTipText(commandName);
1582
1580
1583
            popMenu = new JPopupMenu();
1581
            popMenu = new JPopupMenu();
1584
1582
1585
            JMenuItem item = new JMenuItem("Properties");
1583
            JMenuItem item = new JMenuItem("Properties");
1586
            item.setActionCommand("show_properties");
1584
            item.setActionCommand("show_properties");
1587
            item.addActionListener(this);
1585
            item.addActionListener(this);
1588
            popMenu.add(item);
1586
            popMenu.add(item);
1589
1587
1590
            item = new JMenuItem("Remove Button");
1588
            item = new JMenuItem("Remove Button");
1591
            item.setActionCommand("remove_command_button");
1589
            item.setActionCommand("remove_command_button");
1592
            item.addActionListener(this);
1590
            item.addActionListener(this);
1593
            popMenu.add(item);
1591
            popMenu.add(item);
1594
1592
1595
            addMouseListener(MIOSStudioGUI.this);
1593
            addMouseListener(MIOSStudioGUI.this);
1596
        }
1594
        }
1597
1595
1598
        public void actionPerformed(ActionEvent ae) {
1596
        public void actionPerformed(ActionEvent ae) {
1599
            if (ae.getActionCommand().equals("remove_command_button")) {
1597
            if (ae.getActionCommand().equals("remove_command_button")) {
1600
                removeExternalCommandButton(this);
1598
                removeExternalCommandButton(this);
1601
            } else {
1599
            } else {
1602
                externalButtonProperties = new ExternalButtonProperties(this);
1600
                externalButtonProperties = new ExternalButtonProperties(this);
1603
                externalButtonProperties.setSize(500, 150);
1601
                externalButtonProperties.setSize(500, 150);
1604
                externalButtonProperties
1602
                externalButtonProperties
1605
                        .setLocationRelativeTo(MIOSStudioGUI.this);
1603
                        .setLocationRelativeTo(MIOSStudioGUI.this);
1606
                externalButtonProperties.setVisible(true);
1604
                externalButtonProperties.setVisible(true);
1607
            }
1605
            }
1608
        }
1606
        }
1609
1607
1610
        public void setExternalCommand(String externalCommand) {
1608
        public void setExternalCommand(String externalCommand) {
1611
            this.externalCommand = externalCommand;
1609
            this.externalCommand = externalCommand;
1612
        }
1610
        }
1613
1611
1614
        public void setCommandName(String commandName) {
1612
        public void setCommandName(String commandName) {
1615
            this.commandName = commandName;
1613
            this.commandName = commandName;
1616
            setToolTipText(commandName);
1614
            setToolTipText(commandName);
1617
        }
1615
        }
1618
1616
1619
        public void paintComponent(Graphics g) {
1617
        public void paintComponent(Graphics g) {
1620
            super.paintComponent(g);
1618
            super.paintComponent(g);
1621
            Graphics2D g2d = (Graphics2D) g;
1619
            Graphics2D g2d = (Graphics2D) g;
1622
            g.setFont(FontLoader.getFont("uni05_53.ttf", 8f));
1620
            g.setFont(FontLoader.getFont("uni05_53.ttf", 8f));
1623
            String number = "" + (externalCommands.indexOf(this) + 1);
1621
            String number = "" + (externalCommands.indexOf(this) + 1);
1624
            FontMetrics fm = g2d.getFontMetrics();
1622
            FontMetrics fm = g2d.getFontMetrics();
1625
            int offsetX = fm.stringWidth(number);
1623
            int offsetX = fm.stringWidth(number);
1626
            g.drawString(number, getWidth() - offsetX - 4, getHeight() - 4);
1624
            g.drawString(number, getWidth() - offsetX - 4, getHeight() - 4);
1627
        }
1625
        }
1628
    }
1626
    }
1629
1627
1630
    public class ExternalButtonProperties extends JDialog implements
1628
    public class ExternalButtonProperties extends JDialog implements
1631
            ActionListener {
1629
            ActionListener {
1632
        public ExternalCommandButton externalCommandButton;
1630
        public ExternalCommandButton externalCommandButton;
1633
1631
1634
        public JTextField commandName;
1632
        public JTextField commandName;
1635
1633
1636
        public JTextField commandString;
1634
        public JTextField commandString;
1637
1635
1638
        public JButton okButton;
1636
        public JButton okButton;
1639
1637
1640
        public ExternalButtonProperties(
1638
        public ExternalButtonProperties(
1641
                ExternalCommandButton externalCommandButton) {
1639
                ExternalCommandButton externalCommandButton) {
1642
1640
1643
            super(DialogOwner.getFrame(), "External Command Button "
1641
            super(DialogOwner.getFrame(), "External Command Button "
1644
                    + (externalCommands.indexOf(externalCommandButton) + 1),
1642
                    + (externalCommands.indexOf(externalCommandButton) + 1),
1645
                    false);
1643
                    false);
1646
1644
1647
            this.externalCommandButton = externalCommandButton;
1645
            this.externalCommandButton = externalCommandButton;
1648
1646
1649
            setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
1647
            setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
1650
1648
1651
            setLayout(new GridBagLayout());
1649
            setLayout(new GridBagLayout());
1652
            GridBagConstraints gbc = new GridBagConstraints();
1650
            GridBagConstraints gbc = new GridBagConstraints();
1653
            gbc.gridx = 0;
1651
            gbc.gridx = 0;
1654
            gbc.gridy = 0;
1652
            gbc.gridy = 0;
1655
            gbc.gridwidth = 1;
1653
            gbc.gridwidth = 1;
1656
            gbc.gridheight = 1;
1654
            gbc.gridheight = 1;
1657
1655
1658
            gbc.insets = new Insets(4, 4, 4, 4);
1656
            gbc.insets = new Insets(4, 4, 4, 4);
1659
1657
1660
            gbc.anchor = GridBagConstraints.WEST;
1658
            gbc.anchor = GridBagConstraints.WEST;
1661
            JLabel label = new JLabel("Command Name: ");
1659
            JLabel label = new JLabel("Command Name: ");
1662
            add(label, gbc);
1660
            add(label, gbc);
1663
            gbc.gridx++;
1661
            gbc.gridx++;
1664
1662
1665
            gbc.anchor = GridBagConstraints.EAST;
1663
            gbc.anchor = GridBagConstraints.EAST;
1666
            commandName = new JTextField(externalCommandButton.commandName, 30);
1664
            commandName = new JTextField(externalCommandButton.commandName, 30);
1667
            add(commandName, gbc);
1665
            add(commandName, gbc);
1668
            gbc.gridx--;
1666
            gbc.gridx--;
1669
            gbc.gridy++;
1667
            gbc.gridy++;
1670
1668
1671
            gbc.anchor = GridBagConstraints.WEST;
1669
            gbc.anchor = GridBagConstraints.WEST;
1672
            label = new JLabel("Command String: ");
1670
            label = new JLabel("Command String: ");
1673
            add(label, gbc);
1671
            add(label, gbc);
1674
            gbc.gridx++;
1672
            gbc.gridx++;
1675
1673
1676
            gbc.anchor = GridBagConstraints.EAST;
1674
            gbc.anchor = GridBagConstraints.EAST;
1677
            commandString = new JTextField(
1675
            commandString = new JTextField(
1678
                    externalCommandButton.externalCommand, 30);
1676
                    externalCommandButton.externalCommand, 30);
1679
            add(commandString, gbc);
1677
            add(commandString, gbc);
1680
            gbc.gridx--;
1678
            gbc.gridx--;
1681
            gbc.gridy++;
1679
            gbc.gridy++;
1682
1680
1683
            okButton = new JButton("OK");
1681
            okButton = new JButton("OK");
1684
            okButton.addActionListener(this);
1682
            okButton.addActionListener(this);
1685
            gbc.gridwidth = 2;
1683
            gbc.gridwidth = 2;
1686
            gbc.fill = GridBagConstraints.NONE;
1684
            gbc.fill = GridBagConstraints.NONE;
1687
            gbc.anchor = GridBagConstraints.CENTER;
1685
            gbc.anchor = GridBagConstraints.CENTER;
1688
            add(okButton, gbc);
1686
            add(okButton, gbc);
1689
        }
1687
        }
1690
1688
1691
        public void actionPerformed(ActionEvent ae) {
1689
        public void actionPerformed(ActionEvent ae) {
1692
            externalCommandButton.setCommandName(commandName.getText());
1690
            externalCommandButton.setCommandName(commandName.getText());
1693
            externalCommandButton.setExternalCommand(commandString.getText());
1691
            externalCommandButton.setExternalCommand(commandString.getText());
1694
            this.dispose();
1692
            this.dispose();
1695
        }
1693
        }
1696
    }
1694
    }
1697
1695
1698
    public class WindowMenu extends JMenu {
1696
    public class WindowMenu extends JMenu {
1699
1697
1700
        private MIOSStudioGUI miosStudio;
1698
        private MIOSStudioGUI miosStudio;
1701
1699
1702
        private JDesktopPane desktop;
1700
        private JDesktopPane desktop;
1703
1701
1704
        private JMenuItem cascadeMenuItem;
1702
        private JMenuItem cascadeMenuItem;
1705
1703
1706
        public WindowMenu(MIOSStudioGUI miosStudio) {
1704
        public WindowMenu(MIOSStudioGUI miosStudio) {
1707
            this.miosStudio = miosStudio;
1705
            this.miosStudio = miosStudio;
1708
            this.desktop = miosStudio.desktop;
1706
            this.desktop = miosStudio.desktop;
1709
            setText("Window");
1707
            setText("Window");
1710
            addMenuListener(MIOSStudioGUI.this);
1708
            addMenuListener(MIOSStudioGUI.this);
1711
        }
1709
        }
1712
1710
1713
        private JInternalFrame[] getFrames() {
1711
        private JInternalFrame[] getFrames() {
1714
            return desktop.getAllFrames();
1712
            return desktop.getAllFrames();
1715
        }
1713
        }
1716
1714
1717
        private void buildChildMenus() {
1715
        private void buildChildMenus() {
1718
            int i;
1716
            int i;
1719
            ChildMenuItem menuItem;
1717
            ChildMenuItem menuItem;
1720
            JInternalFrame[] frames = getFrames();
1718
            JInternalFrame[] frames = getFrames();
1721
1719
1722
            cascadeMenuItem = new JMenuItem("Cascade Windows");
1720
            cascadeMenuItem = new JMenuItem("Cascade Windows");
1723
1721
1724
            cascadeMenuItem.addActionListener(new ActionListener() {
1722
            cascadeMenuItem.addActionListener(new ActionListener() {
1725
1723
1726
                public void actionPerformed(ActionEvent ae) {
1724
                public void actionPerformed(ActionEvent ae) {
1727
1725
1728
                    JInternalFrame[] frames = getFrames();
1726
                    JInternalFrame[] frames = getFrames();
1729
1727
1730
                    for (int x = 0; x < frames.length; x++) {
1728
                    for (int x = 0; x < frames.length; x++) {
1731
                        frames[frames.length - 1 - x].setLocation(x * 20,
1729
                        frames[frames.length - 1 - x].setLocation(x * 20,
1732
                                x * 20);
1730
                                x * 20);
1733
                    }
1731
                    }
1734
                }
1732
                }
1735
            });
1733
            });
1736
1734
1737
            cascadeMenuItem.setEnabled(frames.length > 0);
1735
            cascadeMenuItem.setEnabled(frames.length > 0);
1738
1736
1739
            add(cascadeMenuItem);
1737
            add(cascadeMenuItem);
1740
1738
1741
            addSeparator();
1739
            addSeparator();
1742
1740
1743
            for (i = 0; i < frames.length; i++) {
1741
            for (i = 0; i < frames.length; i++) {