Subversion Repositories svn.mios

Rev

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