Subversion Repositories svn.mios

Rev

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