Subversion Repositories svn.mios

Rev

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