Subversion Repositories svn.mios

Rev

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