Subversion Repositories svn.mios

Rev

Rev 800 | Rev 852 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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