Subversion Repositories svn.mios

Rev

Rev 873 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
628 adamjking 1
/*
2
 * @(#)DebugFunctionGUI.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.mios.gui;
22
 
23
import java.awt.BorderLayout;
24
import java.awt.Color;
25
import java.awt.Component;
26
import java.awt.Dimension;
27
import java.awt.Font;
28
import java.awt.GridBagConstraints;
29
import java.awt.GridBagLayout;
30
import java.awt.GridLayout;
31
import java.awt.Insets;
32
import java.awt.Toolkit;
33
import java.awt.datatransfer.Clipboard;
34
import java.awt.datatransfer.DataFlavor;
35
import java.awt.datatransfer.Transferable;
36
import java.awt.event.ActionEvent;
37
import java.awt.event.ActionListener;
38
import java.awt.event.FocusEvent;
39
import java.awt.event.FocusListener;
40
import java.awt.event.KeyAdapter;
41
import java.awt.event.KeyEvent;
42
import java.awt.event.MouseAdapter;
43
import java.awt.event.MouseEvent;
44
import java.net.MalformedURLException;
45
import java.net.URL;
46
import java.util.Arrays;
47
import java.util.EventObject;
48
import java.util.Observable;
49
import java.util.Observer;
50
import java.util.Vector;
51
import java.util.regex.Matcher;
52
import java.util.regex.Pattern;
53
 
54
import javax.swing.AbstractCellEditor;
55
import javax.swing.BorderFactory;
56
import javax.swing.Box;
57
import javax.swing.BoxLayout;
58
import javax.swing.ButtonGroup;
59
import javax.swing.JButton;
60
import javax.swing.JComboBox;
61
import javax.swing.JComponent;
62
import javax.swing.JFormattedTextField;
63
import javax.swing.JLabel;
64
import javax.swing.JMenuItem;
65
import javax.swing.JOptionPane;
66
import javax.swing.JPanel;
67
import javax.swing.JPopupMenu;
68
import javax.swing.JRadioButton;
69
import javax.swing.JScrollPane;
70
import javax.swing.JSpinner;
71
import javax.swing.JTable;
72
import javax.swing.JTextArea;
73
import javax.swing.JTextField;
74
import javax.swing.KeyStroke;
75
import javax.swing.SpinnerNumberModel;
76
import javax.swing.TransferHandler;
77
import javax.swing.border.BevelBorder;
78
import javax.swing.event.ChangeEvent;
79
import javax.swing.event.ChangeListener;
80
import javax.swing.table.DefaultTableCellRenderer;
81
import javax.swing.table.DefaultTableModel;
82
import javax.swing.table.TableCellEditor;
83
 
84
import org.midibox.midi.MidiUtils;
85
import org.midibox.mios.DebugFunction;
86
import org.midibox.mios.DebugFunctionParameters;
87
import org.midibox.utils.ResourceLoader;
88
import org.midibox.utils.gui.HelpPane;
89
import org.midibox.utils.gui.HexFormatterFactory;
90
import org.midibox.utils.gui.ImageLoader;
91
import org.midibox.utils.gui.SimpleTransferHandler;
92
 
93
public class DebugFunctionGUI extends JPanel implements ActionListener,
94
        ChangeListener, FocusListener, Observer {
95
 
96
    private DebugFunction debugFunction;
97
 
98
    private JPanel deviceIDPanel;
99
 
100
    private JLabel deviceIDLabel;
101
 
102
    private JSpinner deviceIDSpinner;
103
 
104
    private boolean showHex = true;
105
 
106
    private JTable debugFunctionsTable;
107
 
108
    private DebugFunctionParametersTransferHandler transferHandler;
109
 
110
    private DefaultTableModel debugFunctionsDataModel;
111
 
112
    private JComboBox debugFunctionsComboBox;
113
 
114
    private JRadioButton debugFunctionsRadio;
115
 
116
    private JRadioButton sramReadRadio;
117
 
118
    private JRadioButton sramWriteRadio;
119
 
120
    private JRadioButton displayHexButton;
121
 
122
    private JRadioButton displayDecButton;
123
 
124
    private JButton startDebugMessage;
125
 
126
    private JButton stopDebugMessage;
127
 
128
    private JLabel delayTimeLabel;
129
 
130
    private JSpinner delayTimeSpinner;
131
 
132
    private JButton cutButton;
133
 
134
    private JButton copyButton;
135
 
136
    private JButton pasteButton;
137
 
138
    private JButton upButton;
139
 
140
    private JButton downButton;
141
 
142
    private JButton deleteButton;
143
 
144
    private JButton helpButton;
145
 
146
    private JPopupMenu popMenu;
147
 
148
    private JLabel sramReadAddressLabel;
149
 
150
    private JLabel sramWriteAddressLabel;
151
 
152
    private JLabel sramReadCounterLabel;
153
 
154
    private JLabel sramWriteDataLabel;
155
 
156
    private JTextField sramReadAddress;
157
 
158
    private JTextField sramWriteAddress;
159
 
160
    private JTextField sramReadCounter;
161
 
162
    private JTextField sramWriteData;
163
 
164
    private JTextArea returnValuesText;
165
 
166
    // private Clipboard systemClipboard;
167
 
168
    private HelpPane helpPane;
169
 
170
    public DebugFunctionGUI(DebugFunction debugTask) {
171
 
172
        super(new BorderLayout());
173
 
174
        this.debugFunction = debugTask;
175
        debugTask.addObserver(this);
176
 
177
        helpPane = HelpPane.createSingleton(ResourceLoader
178
                .getResource("help/mios_debug.html"));
179
 
180
        add(createIDPanel(), BorderLayout.NORTH);
181
        add(createDebugPanel(), BorderLayout.CENTER);
182
 
183
        checkRows();
184
    }
185
 
186
    private JPanel createIDPanel() {
187
        deviceIDPanel = new JPanel();
188
        deviceIDPanel.setLayout(new GridBagLayout());
189
        GridBagConstraints gbc = new GridBagConstraints();
190
 
191
        gbc.gridx = 0;
192
        gbc.gridy = 0;
193
        gbc.gridwidth = 1;
194
        gbc.gridheight = 1;
195
 
196
        gbc.insets = new Insets(2, 5, 2, 5);
197
 
198
        deviceIDLabel = new JLabel("Device ID:");
199
        deviceIDPanel.add(deviceIDLabel, gbc);
200
        gbc.gridx++;
201
 
738 adamjking 202
        deviceIDSpinner = new JSpinner(new SpinnerNumberModel(debugFunction
203
                .getDeviceID(), 0, 127, 1));
628 adamjking 204
        deviceIDSpinner.addChangeListener(this);
205
        JSpinner.DefaultEditor editor = (JSpinner.DefaultEditor) deviceIDSpinner
206
                .getEditor();
207
        JFormattedTextField tf = editor.getTextField();
208
        tf.setFormatterFactory(new HexFormatterFactory());
209
        deviceIDPanel.add(deviceIDSpinner, gbc);
210
        gbc.gridx++;
211
 
212
        gbc.insets = new Insets(2, 5, 2, 5);
213
 
214
        gbc.weightx = 1.0;
215
        deviceIDPanel.add(new JPanel(), gbc);
216
        gbc.gridx++;
217
 
218
        gbc.weightx = 0.0;
219
 
220
        ButtonGroup bg2 = new ButtonGroup();
221
 
222
        displayHexButton = new JRadioButton("Hex", true);
223
        displayHexButton.setToolTipText("Hexidecimal Format");
224
        displayHexButton.addActionListener(this);
225
        bg2.add(displayHexButton);
226
        deviceIDPanel.add(displayHexButton, gbc);
227
        gbc.gridx++;
228
 
229
        displayDecButton = new JRadioButton("Dec", false);
230
        displayDecButton.setToolTipText("Decimal Format");
231
        displayDecButton.addActionListener(this);
232
        bg2.add(displayDecButton);
233
        deviceIDPanel.add(displayDecButton, gbc);
234
        gbc.gridx++;
235
 
236
        return deviceIDPanel;
237
    }
238
 
239
    private JPanel createDebugPanel() {
240
        JPanel debugPanel = new JPanel();
241
 
242
        debugPanel.setLayout(new BoxLayout(debugPanel, BoxLayout.Y_AXIS));
243
        debugPanel.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
244
 
245
        JPanel inputPanel = new JPanel(new BorderLayout());
246
 
247
        JPanel functionBuilder = new JPanel(new BorderLayout());
248
        functionBuilder.setBorder(BorderFactory.createCompoundBorder(
249
                BorderFactory.createEmptyBorder(5, 5, 5, 5), BorderFactory
250
                        .createTitledBorder("Function Builder")));
251
 
252
        JPanel toolBar = new JPanel();
253
        toolBar.setLayout(new GridBagLayout());
254
 
255
        GridBagConstraints gbc = new GridBagConstraints();
256
        gbc.gridx = 0;
257
        gbc.gridy = 0;
258
        gbc.gridwidth = 1;
259
        gbc.gridheight = 1;
260
 
261
        gbc.insets = new Insets(2, 2, 0, 2);
262
 
263
        cutButton = new JButton(ImageLoader.getImageIcon("cut.png"));
264
        cutButton.setToolTipText("Cut row(s)");
265
        cutButton.addActionListener(this);
266
        cutButton.setActionCommand("cut");
267
        cutButton.setMargin(new Insets(2, 2, 2, 2));
268
        toolBar.add(cutButton, gbc);
269
        gbc.gridx++;
270
 
271
        gbc.insets = new Insets(2, 1, 0, 2);
272
 
273
        copyButton = new JButton(ImageLoader.getImageIcon("copy.png"));
274
        copyButton.setToolTipText("Copy row(s)");
275
        copyButton.addActionListener(this);
276
        copyButton.setActionCommand("copy");
277
        copyButton.setMargin(new Insets(2, 2, 2, 2));
278
        toolBar.add(copyButton, gbc);
279
        gbc.gridx++;
280
 
281
        pasteButton = new JButton(ImageLoader.getImageIcon("paste.png"));
282
        pasteButton.setToolTipText("Paste row(s)");
283
        pasteButton.addActionListener(this);
284
        pasteButton.setActionCommand("paste");
285
        pasteButton.setMargin(new Insets(2, 2, 2, 2));
286
        toolBar.add(pasteButton, gbc);
287
        gbc.gridx++;
288
 
289
        gbc.insets = new Insets(2, 5, 0, 2);
290
 
291
        upButton = new JButton(ImageLoader.getImageIcon("up.png"));
292
        upButton.setToolTipText("Move row(s) up");
293
        upButton.addActionListener(this);
294
        upButton.setActionCommand("up");
295
        upButton.setMargin(new Insets(2, 2, 2, 2));
296
        toolBar.add(upButton, gbc);
297
        gbc.gridx++;
298
 
299
        gbc.insets = new Insets(2, 1, 0, 2);
300
 
301
        downButton = new JButton(ImageLoader.getImageIcon("down.png"));
302
        downButton.setToolTipText("Move row(s) down");
303
        downButton.addActionListener(this);
304
        downButton.setActionCommand("down");
305
        downButton.setMargin(new Insets(2, 2, 2, 2));
306
        toolBar.add(downButton, gbc);
307
        gbc.gridx++;
308
 
309
        gbc.insets = new Insets(2, 5, 0, 2);
310
 
311
        deleteButton = new JButton(ImageLoader.getImageIcon("delete.png"));
312
        deleteButton.setToolTipText("Delete row(s)");
313
        deleteButton.addActionListener(this);
314
        deleteButton.setActionCommand("delete");
315
        deleteButton.setMargin(new Insets(2, 2, 2, 2));
316
        toolBar.add(deleteButton, gbc);
317
        gbc.gridx++;
318
 
319
        helpButton = new JButton(ImageLoader.getImageIcon("help.png"));
320
        helpButton.setToolTipText("Lookup MIOS Functions reference");
321
        helpButton.addActionListener(this);
322
        helpButton.setActionCommand("help");
323
        helpButton.setMargin(new Insets(2, 2, 2, 2));
324
        toolBar.add(helpButton, gbc);
325
        gbc.gridx++;
326
 
327
        gbc.insets = new Insets(2, 2, 2, 2);
328
        gbc.weightx = 1.0;
329
        toolBar.add(new JLabel(), gbc);
330
        gbc.gridx++;
331
        gbc.weightx = 0.0;
332
 
333
        delayTimeLabel = new JLabel("Delay (ms):");
334
        toolBar.add(delayTimeLabel, gbc);
335
        gbc.gridx++;
336
 
738 adamjking 337
        delayTimeSpinner = new JSpinner(new SpinnerNumberModel(debugFunction
338
                .getDelayTime(), 0, 2000, 1));
628 adamjking 339
        delayTimeSpinner.addChangeListener(this);
340
        toolBar.add(delayTimeSpinner, gbc);
341
 
342
        functionBuilder.add(toolBar, BorderLayout.NORTH);
343
 
344
        Object[] functionNames = debugFunction.getMiosVectorNames().toArray();
345
        Arrays.sort(functionNames);
346
 
347
        debugFunctionsComboBox = new JComboBox(functionNames);
348
 
349
        debugFunctionsDataModel = new DebugFunctionParametersTableModel(
350
                debugFunction.getDebugFunctionParameters());
351
 
352
        debugFunctionsTable = new JTable(debugFunctionsDataModel);
353
 
354
        debugFunctionsTable.setDefaultRenderer(Integer.class,
355
                new DebugFunctionParametersTableCellRenderer());
356
 
357
        debugFunctionsTable.setDefaultEditor(Integer.class,
358
                new DebugFunctionParametersDefaultCellEditor());
359
 
360
        debugFunctionsTable.getColumnModel().getColumn(0).setCellEditor(
361
                new DebugFunctionParametersDropDownCellEditor());
362
 
363
        debugFunctionsTable.getColumnModel().getColumn(0).setPreferredWidth(
364
                debugFunctionsComboBox.getPreferredSize().width);
365
 
366
        debugFunctionsTable.setPreferredScrollableViewportSize(new Dimension(
367
                debugFunctionsTable.getPreferredScrollableViewportSize().width,
368
                debugFunctionsComboBox.getPreferredSize().height * 3));
369
 
370
        debugFunctionsTable.setRowHeight(debugFunctionsComboBox
371
                .getPreferredSize().height);
372
 
373
        debugFunctionsTable.setRowSelectionAllowed(true);
374
 
375
        debugFunctionsTable.setColumnSelectionAllowed(false);
376
 
377
        transferHandler = new DebugFunctionParametersTransferHandler();
378
 
379
        popMenu = new JPopupMenu();
380
 
381
        JMenuItem menuItem = new JMenuItem("Cut");
382
        menuItem.addActionListener(this);
383
        menuItem.setActionCommand("cut");
384
        popMenu.add(menuItem);
385
 
386
        menuItem = new JMenuItem("Copy");
387
        menuItem.addActionListener(this);
388
        menuItem.setActionCommand("copy");
389
        popMenu.add(menuItem);
390
 
391
        menuItem = new JMenuItem("Paste");
392
        menuItem.addActionListener(this);
393
        menuItem.setActionCommand("paste");
394
        popMenu.add(menuItem);
395
 
396
        popMenu.addSeparator();
397
 
398
        menuItem = new JMenuItem("Move Up");
399
        menuItem.addActionListener(this);
400
        menuItem.setActionCommand("up");
401
        popMenu.add(menuItem);
402
 
403
        menuItem = new JMenuItem("Move Down");
404
        menuItem.addActionListener(this);
405
        menuItem.setActionCommand("down");
406
        popMenu.add(menuItem);
407
 
408
        popMenu.addSeparator();
409
 
410
        menuItem = new JMenuItem("Delete");
411
        menuItem.addActionListener(this);
412
        menuItem.setActionCommand("delete");
413
        popMenu.add(menuItem);
414
 
415
        popMenu.addSeparator();
416
 
417
        menuItem = new JMenuItem("Help");
418
        menuItem.addActionListener(this);
419
        menuItem.setActionCommand("help");
420
        popMenu.add(menuItem);
421
 
422
        debugFunctionsTable.addMouseListener(new MouseAdapter() {
423
            public void mouseReleased(MouseEvent me) {
424
                if (debugFunctionsRadio.isSelected()
425
                        && (debugFunction.isCancelled() || debugFunction
426
                                .isDone())) {
427
                    if (me.getButton() == MouseEvent.BUTTON3) {
428
                        int index = debugFunctionsTable.rowAtPoint(me
429
                                .getPoint());
430
                        int[] selectedRows = debugFunctionsTable
431
                                .getSelectedRows();
432
                        boolean currentRowSelected = false;
433
                        for (int r = 0; r < selectedRows.length; r++) {
434
                            if (selectedRows[r] == index) {
435
                                currentRowSelected = true;
436
                            }
437
                        }
438
                        if (!currentRowSelected) {
439
                            debugFunctionsTable.setRowSelectionInterval(index,
440
                                    index);
441
                        }
442
                        popMenu.show(debugFunctionsTable, me.getX(), me.getY());
443
                    }
444
                }
445
            }
446
        });
447
 
448
        debugFunctionsTable.addKeyListener(new KeyAdapter() {
449
            KeyStroke cut = KeyStroke.getKeyStroke(KeyEvent.VK_X,
450
                    ActionEvent.CTRL_MASK, true);
451
 
452
            KeyStroke copy = KeyStroke.getKeyStroke(KeyEvent.VK_C,
453
                    ActionEvent.CTRL_MASK, true);
454
 
455
            // KeyStroke paste =
456
            // KeyStroke.getKeyStroke(KeyEvent.VK_V,ActionEvent.CTRL_MASK,false);
457
 
458
            public void keyReleased(KeyEvent ke) {
459
                if (debugFunctionsRadio.isSelected()
460
                        && (debugFunction.isCancelled() || debugFunction
461
                                .isDone())) {
462
                    int keyCode = ke.getKeyCode();
463
 
464
                    if (keyCode == KeyEvent.VK_DELETE) {
465
                        deleteRows();
466
                    } else if (keyCode == cut.getKeyCode()) {
467
                        // cutRows();
468
                    } else if (keyCode == copy.getKeyCode()) {
469
                        copyRows();
470
                    }// else if (keyCode == paste.getKeyCode()) {
471
                    // pasteRows();
472
                    // }
473
                }
474
            }
475
        });
476
 
477
        JScrollPane fbscrollPane = new JScrollPane(debugFunctionsTable);
478
        fbscrollPane
479
                .setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
480
        fbscrollPane.setBorder(BorderFactory.createCompoundBorder(BorderFactory
481
                .createEmptyBorder(2, 2, 2, 2), new BevelBorder(
482
                BevelBorder.LOWERED)));
483
 
484
        debugFunctionsTable.setBackground(Color.WHITE);
485
        fbscrollPane.getViewport().setBackground(Color.WHITE);
486
        functionBuilder.add(fbscrollPane);
487
 
488
        inputPanel.add(functionBuilder, BorderLayout.CENTER);
489
 
490
        JPanel sram = new JPanel(new GridLayout(2, 1));
491
 
492
        JPanel sramRead = new JPanel(new GridBagLayout());
493
        gbc = new GridBagConstraints();
494
        gbc.gridx = 0;
495
        gbc.gridy = 0;
496
        gbc.gridwidth = 1;
497
        gbc.gridheight = 1;
498
        gbc.insets = new Insets(2, 2, 2, 2);
499
 
500
        sramRead.setBorder(BorderFactory.createCompoundBorder(BorderFactory
501
                .createEmptyBorder(5, 5, 5, 5), BorderFactory
502
                .createTitledBorder("SRAM Read")));
503
 
504
        sramReadAddressLabel = new JLabel("Address:");
505
        gbc.anchor = GridBagConstraints.WEST;
506
        sramRead.add(sramReadAddressLabel, gbc);
507
        gbc.gridx++;
508
 
509
        gbc.anchor = GridBagConstraints.EAST;
510
        sramReadAddress = new JTextField(changeBase(debugFunction
511
                .getSramReadAddress(), showHex), 6);
512
        sramReadAddress.addActionListener(this);
513
        sramReadAddress.setHorizontalAlignment(JTextField.RIGHT);
514
        sramReadAddress.addFocusListener(this);
515
        sramRead.add(sramReadAddress, gbc);
516
        gbc.gridx = 0;
517
        gbc.gridy++;
518
 
519
        gbc.anchor = GridBagConstraints.WEST;
520
        sramReadCounterLabel = new JLabel("No. Bytes:");
521
        sramRead.add(sramReadCounterLabel, gbc);
522
        gbc.gridx++;
523
 
524
        gbc.anchor = GridBagConstraints.EAST;
525
        sramReadCounter = new JTextField(changeBase(debugFunction
526
                .getSramReadCounter(), showHex), 6);
527
        sramReadCounter.addActionListener(this);
528
        sramReadCounter.setHorizontalAlignment(JTextField.RIGHT);
529
        sramReadCounter.addFocusListener(this);
530
        sramRead.add(sramReadCounter, gbc);
531
 
532
        gbc.gridy++;
533
        gbc.weighty = 1.0;
534
        gbc.fill = GridBagConstraints.VERTICAL;
535
        sramRead.add(Box.createVerticalGlue(), gbc);
536
 
537
        JPanel sramWrite = new JPanel(new GridBagLayout());
538
 
539
        sramWrite.setBorder(BorderFactory.createCompoundBorder(BorderFactory
540
                .createEmptyBorder(5, 5, 5, 5), BorderFactory
541
                .createTitledBorder("SRAM Write")));
542
 
543
        gbc = new GridBagConstraints();
544
        gbc.gridx = 0;
545
        gbc.gridy = 0;
546
        gbc.gridwidth = 1;
547
        gbc.gridheight = 1;
548
        gbc.insets = new Insets(2, 2, 2, 2);
549
 
550
        gbc.anchor = GridBagConstraints.WEST;
551
        sramWriteAddressLabel = new JLabel("Address:");
552
        sramWrite.add(sramWriteAddressLabel, gbc);
553
        gbc.gridx++;
554
 
555
        gbc.anchor = GridBagConstraints.EAST;
556
        sramWriteAddress = new JTextField(changeBase(debugFunction
557
                .getSramWriteAddress(), showHex), 6);
558
        sramWriteAddress.addActionListener(this);
559
        sramWriteAddress.setHorizontalAlignment(JTextField.RIGHT);
560
        sramWriteAddress.addFocusListener(this);
561
        sramWrite.add(sramWriteAddress, gbc);
562
        gbc.gridx = 0;
563
        gbc.gridy++;
564
 
565
        gbc.anchor = GridBagConstraints.WEST;
566
        sramWriteDataLabel = new JLabel("Data:");
567
        sramWrite.add(sramWriteDataLabel, gbc);
568
        gbc.gridx++;
569
 
570
        gbc.anchor = GridBagConstraints.EAST;
571
        sramWriteData = new JTextField(changeBase(debugFunction
572
                .getSramWriteData(), showHex), 6);
573
        sramWriteData.addActionListener(this);
574
        sramWriteData.setHorizontalAlignment(JTextField.RIGHT);
575
        sramWriteData.addFocusListener(this);
576
        sramWrite.add(sramWriteData, gbc);
577
 
578
        gbc.gridy++;
579
        gbc.weighty = 1.0;
580
        gbc.fill = GridBagConstraints.VERTICAL;
581
        sramWrite.add(Box.createVerticalGlue(), gbc);
582
 
583
        sram.add(sramRead);
584
        sram.add(sramWrite);
585
 
586
        inputPanel.add(sram, BorderLayout.EAST);
587
 
588
        JPanel returnValues = new JPanel(new BorderLayout());
589
        returnValues.setBorder(BorderFactory.createCompoundBorder(BorderFactory
590
                .createEmptyBorder(5, 5, 5, 5), BorderFactory
591
                .createTitledBorder("Return Values")));
592
        returnValuesText = new JTextArea();
593
        returnValuesText.setLineWrap(true);
594
        returnValuesText.setWrapStyleWord(true);
595
        returnValuesText.setEditable(false);
596
        returnValuesText.setBackground(Color.WHITE);
597
        returnValuesText.setFont(new Font("Monospaced", Font.PLAIN, 12));
598
        JScrollPane returnValuesScrollPane = new JScrollPane(returnValuesText);
599
        returnValuesScrollPane
600
                .setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
601
        returnValuesScrollPane.setPreferredSize(debugFunctionsTable
602
                .getPreferredScrollableViewportSize());
603
        returnValues.add(returnValuesScrollPane);
604
 
605
        JPanel buttonPanel = new JPanel();
606
        buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
607
 
608
        startDebugMessage = new JButton("Start");
609
        startDebugMessage.addActionListener(this);
610
        buttonPanel.add(startDebugMessage);
611
 
612
        buttonPanel.add(Box.createHorizontalStrut(4));
613
 
614
        stopDebugMessage = new JButton("Stop");
615
        stopDebugMessage.addActionListener(this);
616
        buttonPanel.add(stopDebugMessage);
617
 
618
        buttonPanel.add(Box.createHorizontalStrut(4));
619
 
620
        ButtonGroup bg = new ButtonGroup();
621
 
622
        debugFunctionsRadio = new JRadioButton("Function Builder", true);
623
        bg.add(debugFunctionsRadio);
624
        debugFunctionsRadio.addActionListener(this);
625
        buttonPanel.add(debugFunctionsRadio);
626
 
627
        buttonPanel.add(Box.createHorizontalStrut(4));
628
 
629
        sramReadRadio = new JRadioButton("SRAM Read ", false);
630
        bg.add(sramReadRadio);
631
        sramReadRadio.addActionListener(this);
632
        buttonPanel.add(sramReadRadio);
633
 
634
        buttonPanel.add(Box.createHorizontalStrut(4));
635
 
636
        sramWriteRadio = new JRadioButton("SRAM Write", false);
637
        bg.add(sramWriteRadio);
638
        sramWriteRadio.addActionListener(this);
639
        buttonPanel.add(sramWriteRadio);
640
 
641
        buttonPanel.add(Box.createHorizontalGlue());
642
 
643
        buttonPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
644
 
645
        debugPanel.add(buttonPanel);
646
        debugPanel.add(inputPanel);
647
        debugPanel.add(returnValues);
648
 
649
        updateDebugControls();
650
        return debugPanel;
651
    }
652
 
653
    private void changeBaseValues(boolean toHex) {
654
 
655
        updateDebugControls();
656
 
657
        sramReadAddress.setText(changeBase(debugFunction.getSramReadAddress(),
658
                showHex));
659
 
660
        sramReadCounter.setText(changeBase(debugFunction.getSramReadCounter(),
661
                showHex));
662
 
663
        sramWriteAddress.setText(changeBase(
664
                debugFunction.getSramWriteAddress(), showHex));
665
 
666
        sramWriteData.setText(changeBase(debugFunction.getSramWriteData(),
667
                showHex));
668
 
669
        debugFunctionsDataModel.fireTableDataChanged();
670
 
671
        StringBuffer buffer = new StringBuffer(returnValuesText.getText());
672
        Pattern p1, p2;
673
 
674
        if (!toHex) {
675
            p1 = Pattern.compile("(\\s|^+)([0-9A-F]+)(\\s|$+)");
676
            p2 = Pattern.compile("(\n|^+)([0-9A-F]+)(:+)");
677
 
678
        } else {
679
            p1 = Pattern.compile("(\\s|^+)([0-9]+)(\\s|$+)");
680
            p2 = Pattern.compile("(\n|^+)([0-9]+)(:+)");
681
        }
682
 
683
        Matcher m = p1.matcher(buffer.toString());
684
 
685
        int pos = 0;
686
        int offset = 0;
687
        int length1 = buffer.length();
688
 
689
        while (m.find(pos)) {
690
            pos = m.end() - 1;
691
            buffer.delete(m.start() + offset, m.end() + offset);
692
            buffer.insert(m.start() + offset, m.group(1)
693
                    + changeBaseByte(decodeString(m.group(2), !toHex), toHex)
694
                    + m.group(3));
695
            offset = buffer.length() - length1;
696
        }
697
 
698
        Matcher m2 = p2.matcher(buffer.toString());
699
 
700
        pos = 0;
701
        offset = 0;
702
        length1 = buffer.length();
703
 
704
        while (m2.find(pos)) {
705
            StringBuffer tempBuffer = new StringBuffer(m2.group(2).replaceAll(
706
                    ".", "0"));
707
            String tempValue = changeBase(decodeString(m2.group(2), !toHex),
708
                    toHex);
709
 
710
            tempBuffer.replace(tempBuffer.length() - tempValue.length(),
711
                    tempBuffer.length(), tempValue);
712
 
713
            pos = m2.end() - 1;
714
            buffer.delete(m2.start() + offset, m2.end() + offset);
715
            buffer.insert(m2.start() + offset, m2.group(1)
716
                    + tempBuffer.toString() + m2.group(3));
717
            offset = buffer.length() - length1;
718
        }
719
 
720
        returnValuesText.setText(buffer.toString());
721
    }
722
 
723
    private String changeBase(int val, boolean toHex) {
724
        if (toHex) {
725
            return Integer.toHexString(val).toUpperCase();
726
        } else {
727
            return Integer.toString(val);
728
        }
729
    }
730
 
731
    private String changeBaseByte(int val, boolean toHex) {
732
        if (toHex) {
733
            return MidiUtils.getHexString(val);
734
        } else {
735
            return MidiUtils.getDecimalString(val);
736
        }
737
    }
738
 
739
    private int decodeString(String string, boolean toHex) {
740
        if (string == null) {
741
            return 0;
742
        } else {
743
            try {
744
                if (toHex) {
745
                    string = string.replaceAll("^[0Oo][Xx]{1}", "");
746
                    string = string.replaceAll("^#{1}", "");
747
                    return Integer.parseInt(string, 16);
748
                } else {
749
                    string = string.replaceAll("^0+", "");
750
                    string = string.replaceAll("^[x|X]{1}", "0x");
751
                    return Integer.decode(string).intValue();
752
                }
753
            } catch (NumberFormatException e) {
754
                return 0;
755
            }
756
        }
757
    }
758
 
759
    private void updateDebugControls() {
760
 
761
        boolean isRunning = (!debugFunction.isCancelled() && !debugFunction
762
                .isDone());
763
 
764
        deviceIDLabel.setEnabled(!isRunning);
765
        deviceIDSpinner.setEnabled(!isRunning);
766
 
767
        displayHexButton.setEnabled(!isRunning);
768
        displayDecButton.setEnabled(!isRunning);
769
 
770
        debugFunctionsTable.setEnabled(debugFunctionsRadio.isSelected()
771
                && !isRunning);
772
        debugFunctionsTable.setDragEnabled(debugFunctionsRadio.isSelected()
773
                && !isRunning);
774
        debugFunctionsTable.setTransferHandler((debugFunctionsRadio
775
                .isSelected() && !isRunning) ? transferHandler : null);
776
 
777
        debugFunctionsComboBox.setEnabled(debugFunctionsRadio.isSelected()
778
                && !isRunning);
779
 
780
        cutButton.setEnabled(debugFunctionsRadio.isSelected() && !isRunning);
781
        copyButton.setEnabled(debugFunctionsRadio.isSelected() && !isRunning);
782
        pasteButton.setEnabled(debugFunctionsRadio.isSelected() && !isRunning);
783
        upButton.setEnabled(debugFunctionsRadio.isSelected() && !isRunning);
784
        downButton.setEnabled(debugFunctionsRadio.isSelected() && !isRunning);
785
        deleteButton.setEnabled(debugFunctionsRadio.isSelected() && !isRunning);
786
        helpButton.setEnabled(debugFunctionsRadio.isSelected() && !isRunning);
787
        delayTimeLabel.setEnabled(debugFunctionsRadio.isSelected()
788
                && !isRunning);
789
        delayTimeLabel.setEnabled(debugFunctionsRadio.isSelected()
790
                && !isRunning);
791
        delayTimeSpinner.setEnabled(debugFunctionsRadio.isSelected()
792
                && !isRunning);
793
 
794
        sramReadAddressLabel.setEnabled(sramReadRadio.isSelected()
795
                && !isRunning);
796
        sramReadAddress.setEnabled(sramReadRadio.isSelected() && !isRunning);
797
        sramReadCounterLabel.setEnabled(sramReadRadio.isSelected()
798
                && !isRunning);
799
        sramReadCounter.setEnabled(sramReadRadio.isSelected() && !isRunning);
800
 
801
        sramWriteAddressLabel.setEnabled(sramWriteRadio.isSelected()
802
                && !isRunning);
803
        sramWriteAddress.setEnabled(sramWriteRadio.isSelected() && !isRunning);
804
        sramWriteDataLabel
805
                .setEnabled(sramWriteRadio.isSelected() && !isRunning);
806
        sramWriteData.setEnabled(sramWriteRadio.isSelected() && !isRunning);
807
 
808
        startDebugMessage.setEnabled(!isRunning);
809
        stopDebugMessage.setEnabled(isRunning);
810
        debugFunctionsRadio.setEnabled(!isRunning);
811
        sramReadRadio.setEnabled(!isRunning);
812
        sramWriteRadio.setEnabled(!isRunning);
813
    }
814
 
815
    private void cutRows() {
816
        Clipboard systemClipboard = Toolkit.getDefaultToolkit()
817
                .getSystemClipboard();
818
        transferHandler.exportToClipboard(debugFunctionsTable, systemClipboard,
819
                TransferHandler.MOVE);
820
    }
821
 
822
    private void copyRows() {
823
        Clipboard systemClipboard = Toolkit.getDefaultToolkit()
824
                .getSystemClipboard();
825
        transferHandler.exportToClipboard(debugFunctionsTable, systemClipboard,
826
                TransferHandler.COPY);
827
    }
828
 
829
    private void pasteRows() {
830
        Clipboard systemClipboard = Toolkit.getDefaultToolkit()
831
                .getSystemClipboard();
832
        transferHandler.importData(debugFunctionsTable, systemClipboard
833
                .getContents(this));
834
    }
835
 
836
    private void moveRowsUp() {
837
        moveRows(true);
838
    }
839
 
840
    private void moveRowsDown() {
841
        moveRows(false);
842
    }
843
 
844
    private void moveRows(boolean up) {
845
        int[] selectedRows = debugFunctionsTable.getSelectedRows();
846
        int numRows = selectedRows.length;
847
 
848
        if (numRows > 0) {
849
 
850
            DebugFunctionParameters[] params = new DebugFunctionParameters[numRows];
851
 
852
            for (int r = 0; r < numRows; r++) {
853
                params[r] = (DebugFunctionParameters) debugFunction
854
                        .getDebugFunctionParameters()
855
                        .elementAt(selectedRows[r]);
856
            }
857
 
858
            int addIndex;
859
            int insertIndex;
860
 
861
            if (up) {
862
                addIndex = (selectedRows[0] - 1);
863
                insertIndex = Math.max(addIndex, 0);
864
            } else {
865
                addIndex = (selectedRows[numRows - 1] + 2);
866
                insertIndex = Math.min(addIndex, debugFunctionsTable
867
                        .getRowCount());
868
            }
869
 
870
            int addCount = numRows;
871
 
872
            for (int r = numRows - 1; r >= 0; r--) {
873
                debugFunction.insertDebugFunctionParameters(params[r], Math
874
                        .max(insertIndex, 0));
875
            }
876
 
877
            if (addCount > 0) {
878
                for (int i = 0; i < selectedRows.length; i++) {
879
                    if (selectedRows[i] > addIndex) {
880
                        selectedRows[i] += addCount;
881
                    }
882
                }
883
            }
884
 
885
            debugFunction.removeDebugFunctionParameters(selectedRows);
886
 
887
            if (up) {
888
                debugFunctionsTable.setRowSelectionInterval(insertIndex,
889
                        insertIndex + (selectedRows.length - 1));
890
            } else {
891
                debugFunctionsTable.setRowSelectionInterval(insertIndex - 1,
892
                        insertIndex - 1 - (selectedRows.length - 1));
893
            }
894
        }
895
    }
896
 
897
    private void deleteRows() {
898
        int[] selectedRows = debugFunctionsTable.getSelectedRows();
899
 
900
        for (int r = selectedRows.length - 1; r >= 0; r--) {
901
            debugFunction.removeDebugFunctionParameters(selectedRows[r]);
902
        }
903
    }
904
 
905
    public void showHelp() {
906
        String filename = ResourceLoader.getResource("help/mios_fun.html")
907
                .toString();
908
 
909
        int[] rows = debugFunctionsTable.getSelectedRows();
910
        if (rows.length > 0) {
911
            Integer value = (Integer) debugFunctionsTable.getModel()
912
                    .getValueAt(rows[0], 0);
913
            if (value != null) {
914
                if (debugFunction.getMiosVectorValues().contains(value)) {
915
                    filename += ("#" + debugFunction.getMiosVectorNames()
916
                            .elementAt(
917
                                    debugFunction.getMiosVectorValues()
918
                                            .indexOf(value)));
919
                } else {
920
                    filename += "#top";
921
                }
922
            }
923
        } else {
924
            filename += "#top";
925
        }
926
        URL url;
927
        try {
928
            url = new URL(filename);
929
        } catch (MalformedURLException murle) {
930
            url = ResourceLoader.getResource("help/mios_fun.html");
931
        }
932
        helpPane.goToURL(url);
933
    }
934
 
935
    private void checkRows() {
936
 
937
        int rowCount = debugFunctionsTable.getModel().getRowCount();
938
 
939
        if (rowCount < 1) {
940
            debugFunction.createDebugFunctionParameters();
941
        } else {
942
            int value = ((Integer) debugFunctionsTable.getModel().getValueAt(
943
                    rowCount - 1, 0)).intValue();
944
            if (value != 0) {
945
                debugFunction.createDebugFunctionParameters();
946
            }
947
        }
948
    }
949
 
950
    public void stateChanged(ChangeEvent ce) {
951
 
952
        Object source = ce.getSource();
953
 
954
        if (source == deviceIDSpinner) {
955
            debugFunction.setDeviceID(((Integer) deviceIDSpinner.getValue())
956
                    .intValue());
957
        } else if (source == delayTimeSpinner) {
958
            debugFunction.setDelayTime(((Integer) delayTimeSpinner.getValue())
959
                    .intValue());
960
        }
961
    }
962
 
963
    public void actionPerformed(ActionEvent ae) {
964
        Object source = ae.getSource();
965
 
966
        if ((source == displayDecButton && showHex)
967
                || (source == displayHexButton && !showHex)) {
968
 
969
            showHex = displayHexButton.isSelected();
970
            changeBaseValues(showHex);
971
 
972
        } else if (source == debugFunctionsRadio || source == sramReadRadio
973
                || source == sramWriteRadio) {
974
 
975
            if (debugFunctionsRadio.isSelected()) {
976
                debugFunction.setMode(DebugFunction.DEBUG_FUNCTIONS_MODE);
977
 
978
            } else if (sramReadRadio.isSelected()) {
979
                debugFunction.setMode(DebugFunction.SRAM_READ_MODE);
980
 
981
            } else if (sramWriteRadio.isSelected()) {
982
                debugFunction.setMode(DebugFunction.SRAM_WRITE_MODE);
983
            }
984
 
985
        } else if (source == startDebugMessage) {
986
 
987
            if (debugFunction.getMode() != DebugFunction.SRAM_READ_MODE
988
                    || (debugFunction.getMode() == DebugFunction.SRAM_READ_MODE && debugFunction
989
                            .getSramReadCounter() > 0)) {
990
                returnValuesText.setText("");
991
 
992
                Thread t = new Thread() {
993
                    public void run() {
994
                        debugFunction.createDebugFunctionsTask(showHex);
995
                    }
996
                };
871 adamjking 997
 
874 adamjking 998
                // t.setDaemon(true);
628 adamjking 999
                t.start();
1000
 
1001
            } else {
1002
                JOptionPane.showMessageDialog(this,
1003
                        "Number of bytes to read has to be greater than 0",
1004
                        "SRAM Read Error", JOptionPane.ERROR_MESSAGE);
1005
                return;
1006
            }
1007
 
1008
        } else if (source == stopDebugMessage) {
1009
 
1010
            debugFunction.cancel();
1011
 
1012
        } else if (ae.getActionCommand().equals("cut")) {
1013
            cutRows();
1014
        } else if (ae.getActionCommand().equals("copy")) {
1015
            copyRows();
1016
        } else if (ae.getActionCommand().equals("paste")) {
1017
            pasteRows();
1018
        } else if (ae.getActionCommand().equals("up")) {
1019
            moveRowsUp();
1020
        } else if (ae.getActionCommand().equals("down")) {
1021
            moveRowsDown();
1022
        } else if (ae.getActionCommand().equals("delete")) {
1023
            deleteRows();
1024
        } else if (ae.getActionCommand().equals("help")) {
1025
            showHelp();
1026
 
1027
        } else if (source == sramReadAddress) {
738 adamjking 1028
            debugFunction.setSramReadAddress(decodeString(sramReadAddress
1029
                    .getText(), displayHexButton.isSelected()));
628 adamjking 1030
 
1031
        } else if (source == sramReadCounter) {
738 adamjking 1032
            debugFunction.setSramReadCounter(decodeString(sramReadCounter
1033
                    .getText(), displayHexButton.isSelected()));
628 adamjking 1034
 
1035
        } else if (source == sramWriteAddress) {
727 adamjking 1036
            debugFunction.setSramWriteAddress(decodeString(sramWriteAddress
628 adamjking 1037
                    .getText(), displayHexButton.isSelected()));
1038
 
1039
        } else if (source == sramWriteData) {
738 adamjking 1040
            debugFunction.setSramWriteData(decodeString(
1041
                    sramWriteData.getText(), displayHexButton.isSelected()));
628 adamjking 1042
        }
1043
    }
1044
 
1045
    public void focusGained(FocusEvent fe) {
1046
 
1047
    }
1048
 
1049
    public void focusLost(FocusEvent fe) {
1050
 
1051
        Object source = fe.getSource();
1052
 
1053
        if (source == sramReadAddress) {
738 adamjking 1054
            debugFunction.setSramReadAddress(decodeString(sramReadAddress
1055
                    .getText(), displayHexButton.isSelected()));
628 adamjking 1056
 
1057
        } else if (source == sramReadCounter) {
738 adamjking 1058
            debugFunction.setSramReadCounter(decodeString(sramReadCounter
1059
                    .getText(), displayHexButton.isSelected()));
628 adamjking 1060
 
1061
        } else if (source == sramWriteAddress) {
727 adamjking 1062
            debugFunction.setSramWriteAddress(decodeString(sramWriteAddress
628 adamjking 1063
                    .getText(), displayHexButton.isSelected()));
1064
 
1065
        } else if (source == sramWriteData) {
738 adamjking 1066
            debugFunction.setSramWriteData(decodeString(
1067
                    sramWriteData.getText(), displayHexButton.isSelected()));
628 adamjking 1068
        }
1069
    }
1070
 
1071
    public void update(Observable observable, Object object) {
1072
 
1073
        if (object == DebugFunction.MESSAGES || object == DebugFunction.WORKER) {
1074
            while (!debugFunction.getMessages().isEmpty()) {
1075
                returnValuesText.append(debugFunction.getMessages()
1076
                        .removeFirst()
1077
                        + "\n");
1078
                returnValuesText.setCaretPosition(returnValuesText
1079
                        .getDocument().getLength());
1080
            }
1081
            updateDebugControls();
1082
 
1083
        } else if (object == DebugFunction.DEVICE_ID) {
738 adamjking 1084
 
628 adamjking 1085
            deviceIDSpinner.setValue(new Integer(debugFunction.getDeviceID()));
1086
 
1087
        } else if (object == DebugFunction.DELAY_TIME) {
1088
            delayTimeSpinner
1089
                    .setValue(new Integer(debugFunction.getDelayTime()));
1090
 
1091
        } else if (object == DebugFunction.MODE) {
1092
            debugFunctionsRadio
1093
                    .setSelected(debugFunction.getMode() == DebugFunction.DEBUG_FUNCTIONS_MODE);
1094
 
1095
            sramReadRadio
1096
                    .setSelected(debugFunction.getMode() == DebugFunction.SRAM_READ_MODE);
1097
 
1098
            sramWriteRadio
1099
                    .setSelected(debugFunction.getMode() == DebugFunction.SRAM_WRITE_MODE);
1100
 
1101
            updateDebugControls();
1102
 
1103
        } else if (object == DebugFunction.SRAM_READ_ADDRESS) {
1104
            sramReadAddress.setText(changeBase(debugFunction
1105
                    .getSramReadAddress(), showHex));
1106
 
1107
        } else if (object == DebugFunction.SRAM_READ_COUNTER) {
1108
            sramReadCounter.setText(changeBase(debugFunction
1109
                    .getSramReadCounter(), showHex));
1110
 
1111
        } else if (object == DebugFunction.SRAM_WRITE_ADDRESS) {
1112
            sramWriteAddress.setText(changeBase(debugFunction
1113
                    .getSramWriteAddress(), showHex));
1114
 
1115
        } else if (object == DebugFunction.SRAM_WRITE_DATA) {
1116
            sramWriteData.setText(changeBase(debugFunction.getSramWriteData(),
1117
                    showHex));
738 adamjking 1118
 
628 adamjking 1119
        } else if (object == DebugFunction.DEBUG_FUNCTION_PARAMETERS) {
1120
            debugFunctionsDataModel.fireTableDataChanged();
1121
            checkRows();
1122
        }
1123
    }
1124
 
1125
    private class DebugFunctionParametersTableCellRenderer extends
1126
            DefaultTableCellRenderer {
1127
 
1128
        public Component getTableCellRendererComponent(JTable table,
1129
                Object value, boolean isSelected, boolean hasFocus, int row,
1130
                int column) {
1131
 
1132
            JLabel label = (JLabel) super.getTableCellRendererComponent(table,
1133
                    value, isSelected, hasFocus, row, column);
1134
 
1135
            if (column == 0) {
1136
 
1137
                if (debugFunction.getMiosVectorValues().contains(value)) {
1138
 
1139
                    label.setText(debugFunction.getMiosVectorNames().elementAt(
1140
                            debugFunction.getMiosVectorValues().indexOf(value))
1141
                            .toString());
1142
                } else {
1143
                    label.setText("");
1144
                }
1145
                label.setHorizontalAlignment(JLabel.LEFT);
1146
            } else {
1147
                if (showHex) {
1148
                    label.setText(Integer.toHexString(
1149
                            ((Integer) value).intValue()).toUpperCase());
1150
                }
1151
                label.setHorizontalAlignment(JLabel.RIGHT);
1152
            }
1153
 
1154
            return label;
1155
        }
1156
    }
1157
 
1158
    private class DebugFunctionParametersDefaultCellEditor extends
1159
            AbstractCellEditor implements TableCellEditor {
1160
 
1161
        private JTextField textField;
1162
 
1163
        public DebugFunctionParametersDefaultCellEditor() {
1164
            textField = new JTextField();
1165
            textField.setBorder(null);
1166
            textField.setHorizontalAlignment(JTextField.RIGHT);
1167
        }
1168
 
1169
        public boolean isCellEditable(EventObject anEvent) {
1170
            if (anEvent instanceof MouseEvent) {
1171
                return ((MouseEvent) anEvent).getClickCount() >= 2;
1172
            }
1173
            return true;
1174
        }
1175
 
1176
        public Component getTableCellEditorComponent(JTable table,
1177
                Object value, boolean isSelected, int row, int column) {
1178
 
1179
            if (column > 0 && column < 5) {
1180
                textField.setText((showHex) ? Integer.toHexString(
1181
                        ((Integer) value).intValue()).toUpperCase()
1182
                        : ((Integer) value).toString());
1183
 
1184
                return textField;
1185
 
1186
            } else {
1187
                return null;
1188
            }
1189
        }
1190
 
1191
        public Object getCellEditorValue() {
1192
            return new Integer(decodeString(textField.getText(), showHex));
1193
        }
1194
    }
1195
 
1196
    private class DebugFunctionParametersDropDownCellEditor extends
1197
            AbstractCellEditor implements TableCellEditor {
1198
 
1199
        public DebugFunctionParametersDropDownCellEditor() {
1200
            debugFunctionsComboBox.addActionListener(new ActionListener() {
1201
                public void actionPerformed(ActionEvent ae) {
1202
                    fireEditingStopped();
1203
                }
1204
            });
1205
        }
1206
 
1207
        public Object getCellEditorValue() {
1208
            return debugFunction.getMiosVectorValues().elementAt(
1209
                    debugFunction.getMiosVectorNames().indexOf(
1210
                            debugFunctionsComboBox.getSelectedItem()));
1211
        }
1212
 
1213
        protected void fireEditingCanceled() {
1214
            super.fireEditingCanceled();
1215
            checkRows();
1216
        }
1217
 
1218
        protected void fireEditingStopped() {
1219
            super.fireEditingStopped();
1220
            checkRows();
1221
        }
1222
 
1223
        public Component getTableCellEditorComponent(JTable table,
1224
                Object value, boolean isSelected, int row, int column) {
1225
 
1226
            if (column == 0) {
1227
 
1228
                if (debugFunction.getMiosVectorValues().contains(value)) {
1229
 
1230
                    debugFunctionsComboBox.setSelectedItem(debugFunction
1231
                            .getMiosVectorNames().elementAt(
1232
                                    debugFunction.getMiosVectorValues()
1233
                                            .indexOf(value)));
1234
                } else {
1235
                    debugFunctionsComboBox.setSelectedIndex(0);
1236
                }
1237
 
1238
                return debugFunctionsComboBox;
1239
            } else {
1240
                return null;
1241
            }
1242
        }
1243
    }
1244
 
1245
    private class DebugFunctionParametersTableModel extends DefaultTableModel {
1246
 
1247
        private String[] headers = { "Function", "WREG", "MIOS_PARAM1",
1248
                "MIOS_PARAM2", "MIOS_PARAM3" };
1249
 
1250
        private Vector debugFunctionParameters;
1251
 
1252
        public DebugFunctionParametersTableModel(Vector debugFunctionParameters) {
1253
            this.debugFunctionParameters = debugFunctionParameters;
1254
        }
1255
 
1256
        public int getColumnCount() {
1257
            return headers.length;
1258
        }
1259
 
1260
        public int getRowCount() {
1261
            if (debugFunctionParameters != null) {
1262
                return debugFunctionParameters.size();
1263
            } else {
1264
                return 0;
1265
            }
1266
        }
1267
 
1268
        public String getColumnName(int col) {
1269
            return headers[col];
1270
        }
1271
 
1272
        public Object getValueAt(int row, int col) {
1273
 
1274
            DebugFunctionParameters params = (DebugFunctionParameters) debugFunctionParameters
1275
                    .elementAt(row);
1276
 
1277
            if (col == 0) {
1278
                return new Integer(params.getAddress());
1279
            } else if (col == 1) {
1280
                return new Integer(params.getWreg());
1281
            } else if (col == 2) {
1282
                return new Integer(params.getParam1());
1283
            } else if (col == 3) {
1284
                return new Integer(params.getParam2());
1285
            } else if (col == 4) {
1286
                return new Integer(params.getParam3());
1287
            } else {
1288
                return null;
1289
            }
1290
        }
1291
 
1292
        public void setValueAt(Object value, int row, int col) {
1293
 
1294
            DebugFunctionParameters params = (DebugFunctionParameters) debugFunctionParameters
1295
                    .elementAt(row);
1296
 
1297
            if (col == 0) {
1298
                params.setAddress(((Integer) value).intValue());
1299
            } else if (col == 1) {
1300
                params.setWreg(((Integer) value).intValue());
1301
            } else if (col == 2) {
1302
                params.setParam1(((Integer) value).intValue());
1303
            } else if (col == 3) {
1304
                params.setParam2(((Integer) value).intValue());
1305
            } else if (col == 4) {
1306
                params.setParam3(((Integer) value).intValue());
1307
            }
1308
        }
1309
 
1310
        public Class getColumnClass(int c) {
1311
            return getValueAt(0, c).getClass();
1312
        }
1313
 
1314
        public boolean isCellEditable(int row, int col) {
1315
            return true;
1316
        }
1317
    }
1318
 
1319
    private class DebugFunctionParametersTransferHandler extends
1320
            SimpleTransferHandler {
1321
        private int[] rowNos = null;
1322
 
1323
        private JTable target;
1324
 
1325
        protected int addIndex = -1; // Location where items were added
1326
 
1327
        protected int addCount = 0; // Number of items added.
1328
 
1329
        public DebugFunctionParametersTransferHandler() {
1330
            super();
1331
            supportedDataFlavors = new DataFlavor[] { DataFlavor.stringFlavor };
1332
 
1333
            dropOnSelf = true;
1334
        }
1335
 
1336
        public int getSourceActions(JComponent c) {
1337
            return COPY_OR_MOVE;
1338
        }
1339
 
1340
        public boolean importData(JComponent c, Transferable t) {
1341
            target = (JTable) c;
1342
            int index = target.getSelectedRow();
1343
            if (index < 0)
1344
                index = target.getRowCount();
1345
 
1346
            if (rowNos != null && index >= rowNos[0]
1347
                    && index <= rowNos[rowNos.length - 1]) {
1348
                rowNos = null;
1349
                return false;
1350
            }
1351
 
1352
            if (canImport(c, t.getTransferDataFlavors())) {
1353
 
1354
                if (hasFlavor(t.getTransferDataFlavors(),
1355
                        DataFlavor.stringFlavor)) {
1356
                    String[] rows = null;
1357
 
1358
                    try {
1359
                        rows = ((String) t
1360
                                .getTransferData(DataFlavor.stringFlavor))
1361
                                .split("\n");
1362
                    } catch (Exception e) {
1363
                        e.printStackTrace();
1364
                    }
1365
 
1366
                    for (int i = rows.length - 1; i >= 0; i--) {
1367
 
1368
                        DebugFunctionParameters params = new DebugFunctionParameters();
1369
 
1370
                        addCount = rows.length;
1371
                        addIndex = index;
1372
 
1373
                        String[] cols = new String[5];
1374
                        String imports[] = rows[i].split(",");
1375
 
1376
                        System.arraycopy(imports, 0, cols, 0, Math.min(
1377
                                cols.length, imports.length));
1378
 
1379
                        try {
1380
 
1381
                            params.setAddress(Integer.parseInt(cols[0]));
1382
                            params.setWreg(Integer.parseInt(cols[1]));
1383
                            params.setParam1(Integer.parseInt(cols[2]));
1384
                            params.setParam2(Integer.parseInt(cols[3]));
1385
                            params.setParam3(Integer.parseInt(cols[4]));
1386
 
1387
                        } catch (NumberFormatException nfe) {
1388
                            return false;
1389
                        }
1390
                        debugFunction.insertDebugFunctionParameters(params,
1391
                                index);
1392
                    }
1393
                } else {
1394
                    justImported = false;
1395
                    return false;
1396
                }
1397
                justImported = true;
1398
                return true;
1399
            }
1400
            return false;
1401
        }
1402
 
1403
        protected Transferable createTransferable(JComponent c) {
1404
            justImported = false;
1405
            justExported = true;
1406
            JTable table = (JTable) c;
1407
            rowNos = table.getSelectedRows();
1408
 
1409
            DebugFunctionParameters[] params = new DebugFunctionParameters[rowNos.length];
1410
 
1411
            for (int t = 0; t < rowNos.length; t++) {
1412
                params[t] = (DebugFunctionParameters) debugFunction
1413
                        .getDebugFunctionParameters().elementAt(rowNos[t]);
1414
            }
1415
 
1416
            return new DebugFunctionParametersTransferable(params);
1417
        }
1418
 
1419
        protected void exportDone(JComponent c, Transferable data, int action) {
1420
            if (action == MOVE) {
1421
                if (justImported) {
1422
                    if (addCount > 0) {
1423
                        for (int i = 0; i < rowNos.length; i++) {
1424
                            if (rowNos[i] > addIndex) {
1425
                                rowNos[i] += addCount;
1426
                            }
1427
                        }
1428
                    }
1429
                }
1430
                if (rowNos != null) {
1431
                    for (int i = rowNos.length - 1; i >= 0; i--) {
1432
                        debugFunction.removeDebugFunctionParameters(rowNos[i]);
1433
                    }
1434
                }
1435
            }
1436
            rowNos = null;
1437
            target = null;
1438
            addCount = 0;
1439
            addIndex = -1;
1440
            justExported = false;
1441
        }
1442
    }
1443
}