Subversion Repositories svn.mios

Rev

Rev 738 | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 738 Rev 808
1
/*
1
/*
2
 * @(#)SIDV2librarian.java  beta1   2008/01/21
2
 * @(#)SIDV2librarian.java  beta1   2008/01/21
3
 *
3
 *
4
 * Copyright (C) 2008    Rutger Vlek (rutgervlek@hotmail.com)
4
 * Copyright (C) 2008    Rutger Vlek (rutgervlek@hotmail.com)
5
 *
5
 *
6
 * This application is free software; you can redistribute it and/or modify
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
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
8
 * the Free Software Foundation; either version 2 of the License, or
9
 * (at your option) any later version.
9
 * (at your option) any later version.
10
 *
10
 *
11
 * This application is distributed in the hope that it will be useful,
11
 * This application is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 * GNU General Public License for more details.
14
 * GNU General Public License for more details.
15
 *
15
 *
16
 * You should have received a copy of the GNU General Public License
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
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
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 */
19
 */
20
20
21
package org.midibox.sidlibr;
21
package org.midibox.sidlibr;
22
22
23
import java.awt.event.ActionEvent;
23
import java.awt.event.ActionEvent;
24
import java.awt.event.ActionListener;
24
import java.awt.event.ActionListener;
25
import java.util.Observable;
25
import java.util.Observable;
26
26
27
import javax.sound.midi.MidiMessage;
27
import javax.sound.midi.MidiMessage;
28
import javax.sound.midi.Receiver;
28
import javax.sound.midi.Receiver;
29
import javax.sound.midi.SysexMessage;
29
import javax.sound.midi.SysexMessage;
30
import javax.swing.JOptionPane;
30
import javax.swing.JOptionPane;
31
import javax.swing.ProgressMonitor;
31
import javax.swing.ProgressMonitor;
32
import javax.swing.Timer;
32
import javax.swing.Timer;
33
33
34
import org.midibox.midi.MidiUtils;
34
import org.midibox.midi.MidiUtils;
35
import org.midibox.sidedit.SIDSysexInfo;
35
import org.midibox.sidedit.SIDSysexInfo;
36
36
37
public class SysExController extends Observable implements Receiver,
37
public class SysExController extends Observable implements Receiver,
38
        ActionListener {
38
        ActionListener {
39
    public static Object PATCH = new Object();
39
    public static Object PATCH = new Object();
40
    public static Object ENSEMBLE = new Object();
40
    public static Object ENSEMBLE = new Object();
41
    public Object pickMeUp;
41
    public Object pickMeUp;
42
42
43
    private InitPatches initPatches;
43
    private InitPatches initPatches;
44
44
45
    private Timer timer;
45
    private Timer timer;
46
    private int timeOut = 2000;
46
    private int timeOut = 2000;
47
47
48
    private ProgressMonitor progress;
48
    private ProgressMonitor progress;
49
49
50
    private static String IDLE = "IDLE";
50
    private static String IDLE = "IDLE";
51
    private static String COLLECTING = "COLLECTING";
51
    private static String COLLECTING = "COLLECTING";
52
    private static String DUMPING = "DUMPING";
52
    private static String DUMPING = "DUMPING";
53
    private static String SCANNING = "SCANNING";
53
    private static String SCANNING = "SCANNING";
54
    private static String FORWARDING = "FORWARDING";
54
    private static String FORWARDING = "FORWARDING";
55
    private String STATE;
55
    private String STATE;
56
56
57
    private Object tempSyxType;
57
    private Object tempSyxType;
58
    private String tempSyx = new String();
58
    private String tempSyx = new String();
59
    private String[] dumpStack;
59
    private String[] dumpStack;
60
    private int dumpCount;
60
    private int dumpCount;
61
61
62
    private String tempResponse;
62
    private String tempResponse;
63
    private boolean syxErrorChk = true;
63
    private boolean syxErrorChk = true;
64
    private Receiver receiver;
64
    private Receiver receiver;
65
    private int masterCore = 0;
65
    private int masterCore = 0;
66
66
67
    public int[] requestPatch;
67
    public int[] requestPatch;
68
    public int requestBank;
68
    public int requestBank;
69
    public int requestCount;
69
    public int requestCount;
70
70
71
    public SysExController(Receiver receiver) {
71
    public SysExController(Receiver receiver) {
72
        this.receiver = receiver;
72
        this.receiver = receiver;
73
        timer = new Timer(timeOut, this);
73
        timer = new Timer(timeOut, this);
74
        timer.setInitialDelay(timeOut);
74
        timer.setInitialDelay(timeOut);
75
        STATE = IDLE;
75
        STATE = IDLE;
76
    }
76
    }
77
77
78
    public void setInitPatches(InitPatches initPatches) {
78
    public void setInitPatches(InitPatches initPatches) {
79
        this.initPatches = initPatches;
79
        this.initPatches = initPatches;
80
    }
80
    }
81
81
82
    public Receiver getReceiver() {
82
    public Receiver getReceiver() {
83
        return receiver;
83
        return receiver;
84
    }
84
    }
85
85
86
    public boolean isDone() {
86
    public boolean isDone() {
87
        return (STATE == IDLE);
87
        return (STATE == IDLE);
88
    }
88
    }
89
89
90
    public void close() {
90
    public void close() {
91
    }
91
    }
92
92
93
    // ****************** Forwarding functions ***********************
93
    // ****************** Forwarding functions ***********************
94
    public void resetForwarding() {
94
    public void resetForwarding() {
95
        String init = getForwardSyx(0);
95
        String init = getForwardSyx(0);
96
        sendSyx(init);
96
        sendSyx(init);
97
    }
97
    }
98
98
99
    public void setForwarding(int cores) {
99
    public void setForwarding(int cores) {
100
        sendSyx(getForwardSyx(cores));
100
        sendSyx(getForwardSyx(cores));
101
    }
101
    }
102
102
103
    private String getForwardSyx(int cores) {
103
    private String getForwardSyx(int cores) {
104
        String s = SIDSysexInfo.forwardSysex;
104
        String s = SIDSysexInfo.forwardSysex;
105
        s = s.replace("<device>", zeroPadToHex(masterCore));
105
        s = s.replace("<device>", zeroPadToHex(masterCore));
106
        s = s.replace("<sids>", zeroPadToHex(cores));
106
        s = s.replace("<sids>", zeroPadToHex(cores));
107
        return s;
107
        return s;
108
    }
108
    }
109
109
110
    // ****************** Hardware scan functions ***********************
110
    // ****************** Hardware scan functions ***********************
111
    public void scanHardware() {
111
    public void scanHardware() {
112
        if (isDone()) {
112
        if (isDone()) {
113
            setForwarding(15);
113
            setForwarding(15);
114
            String message = SIDSysexInfo.pingSysex;
114
            String message = SIDSysexInfo.pingSysex;
115
            message = message.replace("<device>", zeroPadToHex(masterCore));
115
            message = message.replace("<device>", zeroPadToHex(masterCore));
116
            progress = new ProgressMonitor(null, "", "Receiving SysEx data...",
116
            progress = new ProgressMonitor(null, "", "Receiving SysEx data...",
117
                    0, 1);
117
                    0, 1);
118
            timer.start();
118
            timer.start();
119
            STATE = SCANNING;
119
            STATE = SCANNING;
120
            sendSyx(message);
120
            sendSyx(message);
121
        }
121
        }
122
    }
122
    }
123
123
124
    private void stopScan() {
124
    private void stopScan() {
125
        timer.stop();
125
        timer.stop();
126
        STATE = IDLE;
126
        STATE = IDLE;
127
        if (progress != null) {
127
        if (progress != null) {
128
            progress.close();
128
            progress.close();
129
        }
129
        }
130
    }
130
    }
131
131
132
    // ****************** Receive functions ***********************
132
    // ****************** Receive functions ***********************
133
    public void requestPatch(int[] patchNumber, int bankNumber) {
133
    public void requestPatch(int[] patchNumber, int bankNumber) {
134
        if (isDone()) {
134
        if (isDone()) {
135
            resetForwarding();
135
            resetForwarding();
136
            requestPatch = patchNumber;
136
            requestPatch = patchNumber;
137
            if (bankNumber == -1) {
137
            if (bankNumber == -1) {
138
                requestBank = bankNumber;
138
                requestBank = bankNumber;
139
                startRequest(ENSEMBLE);
139
                startRequest(ENSEMBLE);
140
            } else {
140
            } else {
141
                requestBank = bankNumber;
141
                requestBank = bankNumber;
142
                startRequest(PATCH);
142
                startRequest(PATCH);
143
            }
143
            }
144
        }
144
        }
145
    }
145
    }
146
146
147
    public void requestPatchBuffer(int coreNumber, int patch, int bank) {
147
    public void requestPatchBuffer(int coreNumber, int patch, int bank) {
148
        if (isDone()) {
148
        if (isDone()) {
149
            resetForwarding();
149
            resetForwarding();
150
            requestPatch = new int[] { patch };
150
            requestPatch = new int[] { patch };
151
            progress = new ProgressMonitor(null, "", "Receiving SysEx data...",
151
            progress = new ProgressMonitor(null, "", "Receiving SysEx data...",
152
                    0, requestPatch.length);
152
                    0, requestPatch.length);
153
            STATE = COLLECTING;
153
            STATE = COLLECTING;
154
            timer.start();
154
            timer.start();
155
            requestCount = 0;
155
            requestCount = 0;
156
            String message;
156
            String message;
157
            if (bank == -1) {
157
            if (bank == -1) {
158
                requestBank = bank;
158
                requestBank = bank;
159
                tempSyxType = ENSEMBLE;
159
                tempSyxType = ENSEMBLE;
160
                message = SIDSysexInfo.editEnsembleRequestSysex;
160
                message = SIDSysexInfo.editEnsembleRequestSysex;
161
            } else {
161
            } else {
162
                requestBank = bank;
162
                requestBank = bank;
163
                tempSyxType = PATCH;
163
                tempSyxType = PATCH;
164
                message = SIDSysexInfo.editPatchRequestSysex;
164
                message = SIDSysexInfo.editPatchRequestSysex;
165
            }
165
            }
166
            message = message.replace("<device>", zeroPadToHex(coreNumber));
166
            message = message.replace("<device>", zeroPadToHex(coreNumber));
167
            sendSyx(message);
167
            sendSyx(message);
168
        }
168
        }
169
    }
169
    }
170
170
171
    private void requestNext() {
171
    private void requestNext() {
172
        requestCount++;
172
        requestCount++;
173
        if (requestCount < requestPatch.length) {
173
        if (requestCount < requestPatch.length) {
174
            timer.restart();
174
            timer.restart();
175
            String message = "";
175
            String message = "";
176
            if (tempSyxType == ENSEMBLE) {
176
            if (tempSyxType == ENSEMBLE) {
177
                message = SIDSysexInfo.hardEnsembleRequestSysex;
177
                message = SIDSysexInfo.hardEnsembleRequestSysex;
178
                message = message.replace("<ensemble>",
178
                message = message.replace("<ensemble>",
179
                        zeroPadToHex(requestPatch[requestCount]));
179
                        zeroPadToHex(requestPatch[requestCount]));
180
            } else if (tempSyxType == PATCH) {
180
            } else if (tempSyxType == PATCH) {
181
                message = SIDSysexInfo.hardPatchRequestSysex;
181
                message = SIDSysexInfo.hardPatchRequestSysex;
182
                message = message.replace("<bank>", zeroPadToHex(requestBank));
182
                message = message.replace("<bank>", zeroPadToHex(requestBank));
183
                message = message.replace("<patch>",
183
                message = message.replace("<patch>",
184
                        zeroPadToHex(requestPatch[requestCount]));
184
                        zeroPadToHex(requestPatch[requestCount]));
185
            }
185
            }
186
            message = message.replace("<device>", "00");
186
            message = message.replace("<device>", "00");
187
            sendSyx(message);
187
            sendSyx(message);
188
        } else {
188
        } else {
189
            stopRequest();
189
            stopRequest();
190
        }
190
        }
191
    }
191
    }
192
192
193
    private void startRequest(Object type) {
193
    private void startRequest(Object type) {
194
        timer.start();
194
        timer.start();
195
        requestCount = -1;
195
        requestCount = -1;
196
        tempSyxType = type;
196
        tempSyxType = type;
197
        progress = new ProgressMonitor(null, "", "Receiving SysEx data...", 0,
197
        progress = new ProgressMonitor(null, "", "Receiving SysEx data...", 0,
198
                requestPatch.length);
198
                requestPatch.length);
199
        STATE = COLLECTING;
199
        STATE = COLLECTING;
200
        requestNext();
200
        requestNext();
201
    }
201
    }
202
202
203
    private void stopRequest() {
203
    private void stopRequest() {
204
        STATE = IDLE;
204
        STATE = IDLE;
205
        timer.stop();
205
        timer.stop();
206
        if (progress != null) {
206
        if (progress != null) {
207
            progress.close();
207
            progress.close();
208
        }
208
        }
209
    }
209
    }
210
210
211
    private void scanSyx(String m) {
211
    private void scanSyx(String m) {
212
        if (progress.isCanceled()
212
        if (progress.isCanceled()
213
                || (tempResponse.substring(0, 5).equals("ERROR"))) {
213
                || (tempResponse.substring(0, 5).equals("ERROR"))) {
214
            stopScan();
214
            stopScan();
215
        } else if (tempResponse.substring(0, 12).equals("ACKNOWLEDGED")) {
215
        } else if (tempResponse.substring(0, 12).equals("ACKNOWLEDGED")) {
216
            stopScan();
216
            stopScan();
217
            pickMeUp = Integer.parseInt(m.substring(14, 16), 16);
217
            pickMeUp = Integer.parseInt(m.substring(14, 16), 16);
218
            setChanged();
218
            setChanged();
219
            notifyObservers("Hardware scan");
219
            notifyObservers("Hardware scan");
220
            clearChanged();
220
            clearChanged();
221
        }
221
        }
222
    }
222
    }
223
223
224
    protected void collectSyx(String m) {
224
    protected void collectSyx(String m) {
225
        if (progress.isCanceled()) {
225
        if (progress.isCanceled()) {
226
            stopRequest();
226
            stopRequest();
227
        } else {
227
        } else {
228
            if (!(m.indexOf(SIDSysexInfo.acknowledgedSysex.replace("<device>",
228
            if (!(m.indexOf(SIDSysexInfo.acknowledgedSysex.replace("<device>",
229
                    "00")) == 0)) {
229
                    "00")) == 0)) {
230
                if (m.substring(0, 2).equalsIgnoreCase("F0")) { // select next
230
                if (m.substring(0, 2).equalsIgnoreCase("F0")) { // select next
231
                                                                // array item
231
                    // array item
232
                                                                // with each F0
232
                    // with each F0
233
                    tempSyx = m;
233
                    tempSyx = m;
234
                } else {
234
                } else {
235
                    if (m.substring(0, 2).equalsIgnoreCase("F7")) { // for
235
                    if (m.substring(0, 2).equalsIgnoreCase("F7")) { // for
236
                                                                    // windows
236
                        // windows
237
                                                                    // (1024
237
                        // (1024
238
                                                                    // byte
238
                        // byte
239
                                                                    // limit, F7
239
                        // limit, F7
240
                                                                    // added at
240
                        // added at
241
                                                                    // beginning
241
                        // beginning
242
                                                                    // of next
242
                        // of next
243
                                                                    // chunk)
243
                        // chunk)
244
                        m = m.substring(2);
244
                        m = m.substring(2);
245
                    }
245
                    }
246
                    tempSyx += m;
246
                    tempSyx += m;
247
                }
247
                }
248
                timer.restart();
248
                timer.restart();
249
                progress.setProgress(requestCount);
249
                progress.setProgress(requestCount);
250
                if (m.substring(m.length() - 2).equalsIgnoreCase("F7")) {
250
                if (m.substring(m.length() - 2).equalsIgnoreCase("F7")) {
251
                    parseSysex();
251
                    parseSysex();
252
                }
252
                }
253
            }
253
            }
254
        }
254
        }
255
    }
255
    }
256
256
257
    private void parseSysex() {
257
    private void parseSysex() {
258
        if (tempSyxType == PATCH) {
258
        if (tempSyxType == PATCH) {
259
            Patch tempPatch = new Patch(receiver, 512, initPatches);
259
            Patch tempPatch = new Patch(receiver, 512, initPatches);
260
            String status = tempPatch.parsePatch(tempSyx);
260
            String status = tempPatch.parsePatch(tempSyx);
261
            if (statusCheck(status)) {
261
            if (statusCheck(status)) {
262
                pickMeUp = tempPatch;
262
                pickMeUp = tempPatch;
263
                setChanged();
263
                setChanged();
264
                notifyObservers("Patch ready");
264
                notifyObservers("Patch ready");
265
                clearChanged();
265
                clearChanged();
266
                requestNext();
266
                requestNext();
267
            } else {
267
            } else {
268
                stopRequest();
268
                stopRequest();
269
            }
269
            }
270
        } else if (tempSyxType == ENSEMBLE) {
270
        } else if (tempSyxType == ENSEMBLE) {
271
            Patch tempEnsemble = new Patch(receiver, 256, initPatches);
271
            Patch tempEnsemble = new Patch(receiver, 256, initPatches);
272
            String status = tempEnsemble.parsePatch(tempSyx);
272
            String status = tempEnsemble.parsePatch(tempSyx);
273
            if (statusCheck(status)) {
273
            if (statusCheck(status)) {
274
                pickMeUp = tempEnsemble;
274
                pickMeUp = tempEnsemble;
275
                setChanged();
275
                setChanged();
276
                notifyObservers("Patch ready");
276
                notifyObservers("Patch ready");
277
                clearChanged();
277
                clearChanged();
278
                requestNext();
278
                requestNext();
279
            } else {
279
            } else {
280
                stopRequest();
280
                stopRequest();
281
            }
281
            }
282
        }
282
        }
283
    }
283
    }
284
284
285
    public boolean statusCheck(String status) {
285
    public boolean statusCheck(String status) {
286
        boolean b = false;
286
        boolean b = false;
287
        if (status == "succesful") {
287
        if (status == "succesful") {
288
            b = true;
288
            b = true;
289
        } else if (status == "checksum error") {
289
        } else if (status == "checksum error") {
290
            JOptionPane.showMessageDialog(null, "Checksum error!", "Error",
290
            JOptionPane.showMessageDialog(null, "Checksum error!", "Error",
291
                    JOptionPane.ERROR_MESSAGE);
291
                    JOptionPane.ERROR_MESSAGE);
292
        } else if (status == "parse error error") {
292
        } else if (status == "parse error error") {
293
            JOptionPane.showMessageDialog(null,
293
            JOptionPane.showMessageDialog(null,
294
                    "An error occured while parsing a patch!", "Error",
294
                    "An error occured while parsing a patch!", "Error",
295
                    JOptionPane.ERROR_MESSAGE);
295
                    JOptionPane.ERROR_MESSAGE);
296
        }
296
        }
297
        return b;
297
        return b;
298
    }
298
    }
299
299
300
    // ****************** Transmit functions ***********************
300
    // ****************** Transmit functions ***********************
301
    public void dumpPatch(Patch[] p, int[] patchNumber, int bankNumber) {
301
    public void dumpPatch(Patch[] p, int[] patchNumber, int bankNumber) {
302
        if (isDone()) {
302
        if (isDone()) {
303
            String[] s = new String[p.length + 1];
303
            String[] s = new String[p.length + 1];
304
            s[0] = getForwardSyx(0);
304
            s[0] = getForwardSyx(0);
305
            for (int i = 0; i < p.length; i++) {
305
            for (int i = 0; i < p.length; i++) {
306
                String dataStr = p[i].getSysexString();
306
                String dataStr = p[i].getSysexString();
307
                String strMessage;
307
                String strMessage;
308
                if (p[0].isEnsemble()) {
308
                if (p[0].isEnsemble()) {
309
                    strMessage = SIDSysexInfo.hardEnsembleDumpSysex;
309
                    strMessage = SIDSysexInfo.hardEnsembleDumpSysex;
310
                    strMessage = strMessage.replace("<ensemble>",
310
                    strMessage = strMessage.replace("<ensemble>",
311
                            zeroPadToHex(patchNumber[i]));
311
                            zeroPadToHex(patchNumber[i]));
312
                } else {
312
                } else {
313
                    strMessage = SIDSysexInfo.hardPatchDumpSysex;
313
                    strMessage = SIDSysexInfo.hardPatchDumpSysex;
314
                    strMessage = strMessage.replace("<bank>",
314
                    strMessage = strMessage.replace("<bank>",
315
                            zeroPadToHex(bankNumber));
315
                            zeroPadToHex(bankNumber));
316
                    strMessage = strMessage.replace("<patch>",
316
                    strMessage = strMessage.replace("<patch>",
317
                            zeroPadToHex(patchNumber[i]));
317
                            zeroPadToHex(patchNumber[i]));
318
                }
318
                }
319
                strMessage = strMessage.replace("<device>",
319
                strMessage = strMessage.replace("<device>",
320
                        zeroPadToHex(masterCore));
320
                        zeroPadToHex(masterCore));
321
                strMessage = strMessage.replace("<data><checksum>", dataStr);
321
                strMessage = strMessage.replace("<data><checksum>", dataStr);
322
                s[i + 1] = strMessage;
322
                s[i + 1] = strMessage;
323
            }
323
            }
324
            startDump(s);
324
            startDump(s);
325
        }
325
        }
326
    }
326
    }
327
327
328
    public void dumpPatchToBuffer(Patch p, int cores) {
328
    public void dumpPatchToBuffer(Patch p, int cores) {
329
        if (isDone() && cores != 0) {
329
        if (isDone() && cores != 0) {
330
            String strMessage;
330
            String strMessage;
331
            if (p.isEnsemble()) {
331
            if (p.isEnsemble()) {
332
                strMessage = SIDSysexInfo.editEnsembleDumpSysex;
332
                strMessage = SIDSysexInfo.editEnsembleDumpSysex;
333
            } else {
333
            } else {
334
                strMessage = SIDSysexInfo.editPatchDumpSysex;
334
                strMessage = SIDSysexInfo.editPatchDumpSysex;
335
            }
335
            }
336
            strMessage = strMessage.replace("<device>",
336
            strMessage = strMessage.replace("<device>",
337
                    zeroPadToHex(masterCore));
337
                    zeroPadToHex(masterCore));
338
            strMessage = strMessage.replace("<data><checksum>", p
338
            strMessage = strMessage.replace("<data><checksum>", p
339
                    .getSysexString());
339
                    .getSysexString());
340
            startDump(new String[] { getForwardSyx(cores), strMessage });
340
            startDump(new String[] { getForwardSyx(cores), strMessage });
341
        }
341
        }
342
    }
342
    }
343
343
344
    public void dumpPatchBank(Bank b, int bankNumber) {
344
    public void dumpPatchBank(Bank b, int bankNumber) {
345
        if (isDone()) {
345
        if (isDone()) {
346
            Patch[] p = new Patch[b.bankSize - 1];
346
            Patch[] p = new Patch[b.bankSize - 1];
347
            int[] pNr = new int[b.bankSize - 1];
347
            int[] pNr = new int[b.bankSize - 1];
348
            for (int i = 1; i < b.bankSize; i++) {
348
            for (int i = 1; i < b.bankSize; i++) {
349
                p[i - 1] = b.getPatchAt(i);
349
                p[i - 1] = b.getPatchAt(i);
350
                pNr[i - 1] = i;
350
                pNr[i - 1] = i;
351
            }
351
            }
352
            dumpPatch(p, pNr, bankNumber);
352
            dumpPatch(p, pNr, bankNumber);
353
        }
353
        }
354
    }
354
    }
355
355
356
    private void startDump(String[] s) {
356
    private void startDump(String[] s) {
357
        dumpStack = s;
357
        dumpStack = s;
358
        dumpCount = 0;
358
        dumpCount = 0;
359
        System.out.println("Transmitting SysEx data...");
359
        System.out.println("Transmitting SysEx data...");
360
        progress = new ProgressMonitor(null, "", "Transmitting SysEx data...",
360
        progress = new ProgressMonitor(null, "", "Transmitting SysEx data...",
361
                0, dumpStack.length);
361
                0, dumpStack.length);
362
        timer.start();
362
        timer.start();
363
        STATE = DUMPING;
363
        STATE = DUMPING;
364
        tempResponse = "";
364
        tempResponse = "";
365
        sendNext();
365
        sendNext();
366
    }
366
    }
367
367
368
    private void stopDump() {
368
    private void stopDump() {
369
        STATE = IDLE;
369
        STATE = IDLE;
370
        timer.stop();
370
        timer.stop();
371
        if (progress != null) {
371
        if (progress != null) {
372
            progress.close();
372
            progress.close();
373
        }
373
        }
374
    }
374
    }
375
375
376
    private void sendNext() {
376
    private void sendNext() {
377
        if (dumpCount == dumpStack.length) { // If no more to send then finish
377
        if (dumpCount == dumpStack.length) { // If no more to send then finish
378
            stopDump();
378
            stopDump();
379
            setChanged();
379
            setChanged();
380
            notifyObservers("Dump completed");
380
            notifyObservers("Dump completed");
381
            clearChanged();
381
            clearChanged();
382
        } else { // send Syx and wait for next call of ()
382
        } else { // send Syx and wait for next call of ()
383
            sendSyx(dumpStack[dumpCount++]);
383
            sendSyx(dumpStack[dumpCount++]);
384
            progress.setProgress(dumpCount);
384
            progress.setProgress(dumpCount);
385
            timer.restart();
385
            timer.restart();
386
        }
386
        }
387
    }
387
    }
388
388
389
    protected void dumpSyx(String m) {
389
    protected void dumpSyx(String m) {
390
        if (progress.isCanceled()
390
        if (progress.isCanceled()
391
                || (tempResponse.substring(0, 5).equals("ERROR"))) {
391
                || (tempResponse.substring(0, 5).equals("ERROR"))) {
392
            stopDump();
392
            stopDump();
393
        } else if (tempResponse.substring(0, 12).equals("ACKNOWLEDGED")) {
393
        } else if (tempResponse.substring(0, 12).equals("ACKNOWLEDGED")) {
394
            tempResponse = "";
394
            tempResponse = "";
395
            sendNext();
395
            sendNext();
396
        }
396
        }
397
    }
397
    }
398
398
399
    // ****************** General functions ***********************
399
    // ****************** General functions ***********************
400
    public void send(MidiMessage message, long timestamp) {
400
    public void send(MidiMessage message, long timestamp) {
401
        String m = MidiUtils.getHexString(message.getMessage())
401
        String m = MidiUtils.getHexString(message.getMessage())
402
                .replace(" ", "");
402
                .replace(" ", "");
403
403
404
        if (syxErrorChk) {
404
        if (syxErrorChk) {
405
            checkError(m);
405
            checkError(m);
406
        }
406
        }
407
407
408
        if (STATE == COLLECTING) {
408
        if (STATE == COLLECTING) {
409
            collectSyx(m);
409
            collectSyx(m);
410
        }
410
        }
411
411
412
        if (STATE == DUMPING) {
412
        if (STATE == DUMPING) {
413
            dumpSyx(m);
413
            dumpSyx(m);
414
        }
414
        }
415
415
416
        if (STATE == SCANNING) {
416
        if (STATE == SCANNING) {
417
            scanSyx(m);
417
            scanSyx(m);
418
        }
418
        }
419
    }
419
    }
420
420
421
    public void actionPerformed(ActionEvent ae) {
421
    public void actionPerformed(ActionEvent ae) {
422
        if (ae.getSource() == timer) {
422
        if (ae.getSource() == timer) {
423
            if (STATE == COLLECTING) {
423
            if (STATE == COLLECTING) {
424
                stopRequest();
424
                stopRequest();
425
            }
425
            }
426
            if (STATE == DUMPING) {
426
            if (STATE == DUMPING) {
427
                stopDump();
427
                stopDump();
428
            }
428
            }
429
429
430
            if (STATE == SCANNING) {
430
            if (STATE == SCANNING) {
431
                stopScan();
431
                stopScan();
432
            }
432
            }
433
            JOptionPane
433
            JOptionPane
434
                    .showMessageDialog(
434
                    .showMessageDialog(
435
                            null,
435
                            null,
436
                            "The MBSID V2 is not responding. Please check all connections!",
436
                            "The MBSID V2 is not responding. Please check all connections!",
437
                            "Error", JOptionPane.ERROR_MESSAGE);
437
                            "Error", JOptionPane.ERROR_MESSAGE);
438
        }
438
        }
439
    }
439
    }
440
440
441
    protected void checkError(String m) {
441
    protected void checkError(String m) {
442
        if (m.indexOf(SIDSysexInfo.acknowledgedSysex.replace("<device>", "00")) == 0) {
442
        if (m.indexOf(SIDSysexInfo.acknowledgedSysex.replace("<device>", "00")) == 0) {
443
            tempResponse = "ACKNOWLEDGED" + m.substring(14, 16);
443
            tempResponse = "ACKNOWLEDGED" + m.substring(14, 16);
444
        } else if (m.equals(SIDSysexInfo.error1Sysex.replace("<device>", "00"))) {
444
        } else if (m.equals(SIDSysexInfo.error1Sysex.replace("<device>", "00"))) {
445
            tempResponse = "ERROR1";
445
            tempResponse = "ERROR1";
446
            JOptionPane.showMessageDialog(null,
446
            JOptionPane.showMessageDialog(null,
447
                    "MBSID says: Received less bytes then expected!", "Error",
447
                    "MBSID says: Received less bytes then expected!", "Error",
448
                    JOptionPane.ERROR_MESSAGE);
448
                    JOptionPane.ERROR_MESSAGE);
449
        } else if (m.equals(SIDSysexInfo.error2Sysex.replace("<device>", "00"))) {
449
        } else if (m.equals(SIDSysexInfo.error2Sysex.replace("<device>", "00"))) {
450
            tempResponse = "ERROR2";
450
            tempResponse = "ERROR2";
451
            JOptionPane.showMessageDialog(null, "MBSID says: Wrong checksum!",
451
            JOptionPane.showMessageDialog(null, "MBSID says: Wrong checksum!",
452
                    "Error", JOptionPane.ERROR_MESSAGE);
452
                    "Error", JOptionPane.ERROR_MESSAGE);
453
        } else if (m.equals(SIDSysexInfo.error3Sysex.replace("<device>", "00"))) {
453
        } else if (m.equals(SIDSysexInfo.error3Sysex.replace("<device>", "00"))) {
454
            tempResponse = "ERROR3";
454
            tempResponse = "ERROR3";
455
            JOptionPane
455
            JOptionPane
456
                    .showMessageDialog(
456
                    .showMessageDialog(
457
                            null,
457
                            null,
458
                            "MBSID says: Bankstick or patch/drumset/ensemble not available!",
458
                            "MBSID says: Bankstick or patch/drumset/ensemble not available!",
459
                            "Error", JOptionPane.ERROR_MESSAGE);
459
                            "Error", JOptionPane.ERROR_MESSAGE);
460
        } else if (m.equals(SIDSysexInfo.error4Sysex.replace("<device>", "00"))) {
460
        } else if (m.equals(SIDSysexInfo.error4Sysex.replace("<device>", "00"))) {
461
            tempResponse = "ERROR4";
461
            tempResponse = "ERROR4";
462
            JOptionPane.showMessageDialog(null,
462
            JOptionPane.showMessageDialog(null,
463
                    "MBSID says: Parameter not available!", "Error",
463
                    "MBSID says: Parameter not available!", "Error",
464
                    JOptionPane.ERROR_MESSAGE);
464
                    JOptionPane.ERROR_MESSAGE);
465
        } else if (m.equals(SIDSysexInfo.error5Sysex.replace("<device>", "00"))) {
465
        } else if (m.equals(SIDSysexInfo.error5Sysex.replace("<device>", "00"))) {
466
            tempResponse = "ERROR5";
466
            tempResponse = "ERROR5";
467
            JOptionPane.showMessageDialog(null,
467
            JOptionPane.showMessageDialog(null,
468
                    "MBSID says: RAM access not supported!", "Error",
468
                    "MBSID says: RAM access not supported!", "Error",
469
                    JOptionPane.ERROR_MESSAGE);
469
                    JOptionPane.ERROR_MESSAGE);
470
        } else if (m.equals(SIDSysexInfo.error6Sysex.replace("<device>", "00"))) {
470
        } else if (m.equals(SIDSysexInfo.error6Sysex.replace("<device>", "00"))) {
471
            tempResponse = "ERROR6";
471
            tempResponse = "ERROR6";
472
            JOptionPane.showMessageDialog(null,
472
            JOptionPane.showMessageDialog(null,
473
                    "MBSID says: BankStick too small for 128 patches!",
473
                    "MBSID says: BankStick too small for 128 patches!",
474
                    "Error", JOptionPane.ERROR_MESSAGE);
474
                    "Error", JOptionPane.ERROR_MESSAGE);
475
        } else {
475
        } else {
476
            // System.out.println("MBSID: " + m);
476
            // System.out.println("MBSID: " + m);
477
        }
477
        }
478
    }
478
    }
479
479
480
    protected void sendSyx(String s) {
480
    protected void sendSyx(String s) {
481
        SysexMessage sysexMessage = new SysexMessage();
481
        SysexMessage sysexMessage = new SysexMessage();
482
        try {
482
        try {
483
            byte[] abMessage = toByteArray(s);
483
            byte[] abMessage = toByteArray(s);
484
            sysexMessage.setMessage(abMessage, abMessage.length);
484
            sysexMessage.setMessage(abMessage, abMessage.length);
485
        } catch (Exception e) {
485
        } catch (Exception e) {
486
            JOptionPane.showMessageDialog(null,
486
            JOptionPane.showMessageDialog(null,
487
                    "The System Exclusive data could not be sent!", "Error",
487
                    "The System Exclusive data could not be sent!", "Error",
488
                    JOptionPane.ERROR_MESSAGE);
488
                    JOptionPane.ERROR_MESSAGE);
489
        }
489
        }
490
        receiver.send(sysexMessage, -1);
490
        receiver.send(sysexMessage, -1);
491
    }
491
    }
492
492
493
    protected byte[] toByteArray(String s) {
493
    protected byte[] toByteArray(String s) {
494
        int nLengthInBytes = s.length() / 2;
494
        int nLengthInBytes = s.length() / 2;
495
        byte[] abMessage = new byte[nLengthInBytes];
495
        byte[] abMessage = new byte[nLengthInBytes];
496
        for (int i = 0; i < nLengthInBytes; i++) {
496
        for (int i = 0; i < nLengthInBytes; i++) {
497
            abMessage[i] = (byte) Integer.parseInt(s
497
            abMessage[i] = (byte) Integer.parseInt(s
498
                    .substring(i * 2, i * 2 + 2), 16);
498
                    .substring(i * 2, i * 2 + 2), 16);
499
        }
499
        }
500
        return abMessage;
500
        return abMessage;
501
    }
501
    }
502
502
503
    protected String zeroPadToHex(int i) {
503
    protected String zeroPadToHex(int i) {
504
        String s = "00" + Integer.toHexString(i);
504
        String s = "00" + Integer.toHexString(i);
505
        s = s.substring(s.length() - 2);
505
        s = s.substring(s.length() - 2);
506
        return s;
506
        return s;
507
    }
507
    }
508
508
509
}
509
}