Subversion Repositories svn.mios

Rev

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