001package jmri.jmrix.loconet.ds64;
002
003import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
004
005import java.awt.Color;
006import java.awt.Component;
007import java.awt.Container;
008import java.awt.FlowLayout;
009import java.awt.Window;
010import java.awt.event.ActionEvent;
011import java.awt.event.ActionListener;
012import java.awt.event.ItemEvent;
013import java.util.ArrayList;
014import java.util.Collections;
015
016import javax.swing.BoxLayout;
017import javax.swing.ButtonGroup;
018import javax.swing.JCheckBox;
019import javax.swing.JComboBox;
020import javax.swing.JComponent;
021import javax.swing.JLabel;
022import javax.swing.JPanel;
023import javax.swing.JRadioButton;
024import javax.swing.JScrollPane;
025import javax.swing.JSeparator;
026import javax.swing.JTabbedPane;
027import javax.swing.JToggleButton;
028import javax.swing.event.ChangeEvent;
029import javax.swing.event.ChangeListener;
030
031import jmri.jmrix.loconet.AbstractBoardProgPanel;
032import jmri.jmrix.loconet.LnConstants;
033import jmri.jmrix.loconet.LocoNetMessage;
034import jmri.jmrix.loconet.LocoNetSystemConnectionMemo;
035import jmri.util.swing.JmriJOptionPane;
036import jmri.util.swing.ValidatedTextField;
037
038/**
039 * A "tabbed" swing panel to display and modify Digitrax DS64 board
040 * configuration.
041 * <p>
042 * The read and write operations require a sequence of operations, which are
043 * handled with a state variable.
044 * <p>
045 * Programming of the DS64 is done via LocoNet configuration messages, so the
046 * DS64 should not be manually put into its programming mode via the DS64
047 * built-in pushbutton while this tool is in use.
048 * <p>
049 * Some of the message formats used in this class are Copyright Digitrax, Inc.
050 * and used with permission as part of the JMRI project. That permission does
051 * not extend to uses in other software products. If you wish to use this code,
052 * algorithm or these message formats outside of JMRI, please contact Digitrax
053 * Inc for separate permission.
054 * <p>
055 * Extensions to include read/write of turnout output addresses and routes are
056 * based on reverse-engineering of DS64 operating characteristics by B.
057 * Milhaupt. As such, this tool may not be compatible with all DS64 devices.
058 * <hr>
059 * This file is part of JMRI.
060 * <p>
061 * JMRI is free software; you can redistribute it and/or modify it under the
062 * terms of version 2 of the GNU General Public License as published by the Free
063 * Software Foundation. See the "COPYING" file for a copy of this license.
064 * <p>
065 * JMRI is distributed in the hope that it will be useful, but WITHOUT ANY
066 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
067 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
068 * <p>
069 * Based on Revision 1.1 of DS64Panel.java by Bob Jacobsen
070 *
071 * @author Bob Jacobsen Copyright (C) 2002, 2004, 2005, 2007, 2010
072 * @author B. Milhaupt Copyright (C) 2011, 2012, 2013, 2014, 2015, 2016, 2017
073 */
074public class Ds64TabbedPanel extends AbstractBoardProgPanel {
075
076    /**
077     * Ds64TabbedPanel constructor when the boardNum is already known. Allows
078     * the instantiating method to specify whether the basic feature
079     * configuration information will be read upon instantiation.
080     *
081     * @param boardNum   initial BoardID number
082     * @param readOnInit true to automatically read the basic configuration
083     *                   info.
084     */
085    public Ds64TabbedPanel(int boardNum, boolean readOnInit) {
086        super(boardNum, readOnInit, "DS64"); // NOI18N
087        origAccessBoardNum = boardNum;
088        boardNumsEntryValue.add(boardNum);
089    }
090
091    /**
092     * Ds64TabbedPanel constructor when the boardNum is not already known.
093     * <p>
094     * At instantiation, the object will automatically assume BoardID 1 and will
095     * not pre-read the basic board configuration information.
096     */
097    public Ds64TabbedPanel() {
098        // this is a constructor which is in-place to support legacy applications.
099        this(1, false);
100    }
101
102    /**
103     * Ds64TabbedPanel constructor when the boardNum is already known.
104     * <p>
105     * When instantiated, the object will not automatically read the basic
106     * configuration information.
107     *
108     * @param boardNum initial BoardID number
109     */
110    public Ds64TabbedPanel(int boardNum) {
111        this(boardNum, false);
112        origAccessBoardNum = boardNum;
113    }
114    int[] boardNumbers;
115    int origAccessBoardNum = 0;
116    ArrayList<Integer> boardNumsEntryValue = new ArrayList<>();
117
118    /**
119     * Ds64TabbedPanel constructor which may be used when the instantiating
120     * method already has an array of DS64 BoardID numbers; this array is used
121     * to pre-populate the GUI combobox showing BoardID numbers. The first
122     * BoardID number in the array will automatically be selected upon
123     * instantiation.
124     * <p>
125     * When instantiated, the object will automatically read the basic
126     * configuration information if readOnInit is true.
127     *
128     * @param readOnInit true to automatically read the basic configuration info
129     *                   from the DS64 with BoardID equal to the first value in
130     *                   the boardNums array
131     * @param boardNums  Array of known DS64 BoardID numbers
132     */
133    public Ds64TabbedPanel(boolean readOnInit, Integer[] boardNums) {
134        this(boardNums[0], readOnInit);
135        log.debug("into DS64 tabbed panel with list of boards of length {}", boardNums.length); // NOI18N
136        log.debug("boardNums[0] = {}", boardNums[0]); // NOI18N
137        origAccessBoardNum = boardNums[0];
138        boardNumsEntryValue.remove(0);  // remove the entry  added by Ds64TabbedPanel(int boardNum, boolean readOnInit)
139        for (int boardNum : boardNums) {
140            log.debug("board {}", boardNum); // NOI18N
141            boardNumsEntryValue.add(boardNum);
142        }
143        Collections.sort(boardNumsEntryValue);
144    }
145
146    /**
147     * Ds64TabbedPanel constructor when the boardNum is not known; BoardID 1 is
148     * assumed.
149     * <p>
150     * Allows the instantiating method to specify whether the basic feature
151     * configuration information will be read upon instantiation.
152     *
153     * @param readBoardOnInit true to automatically read the basic configuration
154     *                        info.
155     */
156    public Ds64TabbedPanel(boolean readBoardOnInit) {
157        this(1, readBoardOnInit);
158    }
159
160    JPanel generalPanel = null;
161    JPanel opswsPanel = null;
162    JScrollPane opswsScrollPane = null;
163    JTabbedPane generalTabbedPane = null;
164    JTabbedPane routesTabbedPane;
165    JPanel opswsValues = null;
166    JPanel outputAddrsPanel = null;
167    ValidatedTextField outAddr1 = null;
168    JLabel outState1 = null;
169    ValidatedTextField outAddr2 = null;
170    JLabel outState2 = null;
171    ValidatedTextField outAddr3 = null;
172    JLabel outState3 = null;
173    ValidatedTextField outAddr4 = null;
174    JLabel outState4 = null;
175    JPanel[] routePanel;
176    SimpleTurnoutStateEntry[] routeTop;
177    SimpleTurnoutStateEntry[] routeA2;
178    SimpleTurnoutStateEntry[] routeA3;
179    SimpleTurnoutStateEntry[] routeA4;
180    SimpleTurnoutStateEntry[] routeA5;
181    SimpleTurnoutStateEntry[] routeA6;
182    SimpleTurnoutStateEntry[] routeA7;
183    SimpleTurnoutStateEntry[] routeA8;
184    JToggleButton resetRouteButton = null;
185
186    JComboBox<Integer> addressComboBox;
187
188    // output controls
189    JLabel outputTypeLabel;
190    JComboBox<String> outputType;
191
192    JLabel delayTimeLabel;
193    JComboBox<String> delayTime;
194
195    JLabel outputStatesLabel;
196    JComboBox<String> outputStates;
197
198    JLabel startupDelayLabel;
199    JComboBox<String> startupDelay;
200
201    JLabel staticOutputShutoffLabel;
202    JComboBox<String> staticOutputShutoff;
203
204    // command sources
205    JLabel commandTypeLabel;
206    JComboBox<String> commandType;
207
208    JLabel commandSourceLabel;
209    JComboBox<String> commandSource;
210
211    // Crossbuck Flasher controls
212    JCheckBox output1CrossbuckFlasherCheckBox;
213    JCheckBox output2CrossbuckFlasherCheckBox;
214    JCheckBox output3CrossbuckFlasherCheckBox;
215    JCheckBox output4CrossbuckFlasherCheckBox;
216
217    // DS64 routes
218    JLabel routesControlLabel;
219    JComboBox<String> routesControl;
220
221    // local input controls
222    JLabel localControlOfOutputsStyleLabel;
223    JComboBox<String> localControlOfOutputsStyle;
224
225    JLabel sensorMessageTriggerLabel;
226    JComboBox<String> sensorMessageTrigger;
227
228    JComboBox<String> localSensorType;
229
230    JToggleButton factoryResetButton;
231
232    JRadioButtonWithInteger[] opswThrown = new JRadioButtonWithInteger[21];
233    JRadioButtonWithInteger[] opswClosed = new JRadioButtonWithInteger[21];
234
235    JPanel sensorMessageTriggerPanel;
236    JPanel localInputControlsPanel;
237
238    @Override
239    public String getHelpTarget() {
240        return "package.jmri.jmrix.loconet.ds64.DS64TabbedPanel"; // NOI18N
241    }
242
243    @Override
244    public String getTitle() {
245        return getTitle(Bundle.getMessage("MenuItemDS64Programmer"));
246    }
247
248    public javax.swing.Timer boardResetResponseTimer = null;
249
250    public void updateGuiBasicOpSw(int index) {
251        if ((index < 1) || (index == 7) || (index > 21)) {
252            return;
253        }
254        if (opsw[index]) {
255            opswThrown[index].setSelected(false);
256            opswClosed[index].setSelected(true);
257        } else {
258            opswThrown[index].setSelected(true);
259            opswClosed[index].setSelected(false);
260        }
261        opswThrown[index].updateUI();
262        opswClosed[index].updateUI();
263    }
264
265    /**
266     * Copy from the GUI to the opsw array.
267     * <p>
268     * Used before write operations start.
269     */
270    @Override
271    protected void copyToOpsw() {
272        // copy over the display
273        opsw[1] = (outputType.getSelectedIndex() == 1);
274        updateGuiBasicOpSw(1);
275        int selection = delayTime.getSelectedIndex();
276        opsw[2] = ((selection & 0x1) == 1);
277        opsw[3] = ((selection & 0x2) == 2);
278        opsw[4] = ((selection & 0x4) == 4);
279        opsw[5] = ((selection & 0x8) == 8);
280        updateGuiBasicOpSw(2);
281        updateGuiBasicOpSw(3);
282        updateGuiBasicOpSw(4);
283        updateGuiBasicOpSw(5);
284        opsw[6] = (outputStates.getSelectedIndex() == 1);
285        updateGuiBasicOpSw(6);
286        opsw[7] = (isWritingResetOpSw ? resetOpSwVal : false);
287        updateGuiBasicOpSw(7);
288        opsw[8] = startupDelay.getSelectedIndex() == 1;
289        updateGuiBasicOpSw(8);
290        opsw[9] = staticOutputShutoff.getSelectedIndex() == 1;
291        updateGuiBasicOpSw(9);
292        opsw[10] = commandType.getSelectedIndex() == 1;
293        updateGuiBasicOpSw(10);
294        opsw[11] = (routesControl.getSelectedIndex() == 1) || (routesControl.getSelectedIndex() == 3);
295        updateGuiBasicOpSw(11);
296        opsw[12] = (localControlOfOutputsStyle.getSelectedIndex() & 1) == 1;  //2 -> OpSw12="c"
297        updateGuiBasicOpSw(12);
298        opsw[13] = (sensorMessageTrigger.getSelectedIndex() == 1);
299        updateGuiBasicOpSw(13);
300        opsw[14] = commandSource.getSelectedIndex() == 1;
301        updateGuiBasicOpSw(14);
302        opsw[15] = (localControlOfOutputsStyle.getSelectedIndex() >= 2);  //0 -> OpSw15="c"
303        updateGuiBasicOpSw(15);
304        opsw[16] = routesControl.getSelectedIndex() >= 2;
305        updateGuiBasicOpSw(16);
306        opsw[17] = output1CrossbuckFlasherCheckBox.isSelected();
307        updateGuiBasicOpSw(17);
308        opsw[18] = output2CrossbuckFlasherCheckBox.isSelected();
309        updateGuiBasicOpSw(18);
310        opsw[19] = output3CrossbuckFlasherCheckBox.isSelected();
311        updateGuiBasicOpSw(19);
312        opsw[20] = output4CrossbuckFlasherCheckBox.isSelected();
313        updateGuiBasicOpSw(20);
314        opsw[21] = localSensorType.getSelectedIndex() == 1;
315        updateGuiBasicOpSw(21);
316    }
317    java.awt.Component colorizedObject;
318
319    @Override
320    protected void updateDisplay() {
321        switch (state) {
322            case 1:
323                outputType.setSelectedIndex((opsw[1] == true) ? 1 : 0);
324                break;
325            case 2:
326            case 3:
327            case 4:
328            case 5:
329                delayTime.setSelectedIndex(
330                        ((opsw[2] == true) ? 1 : 0)
331                        + ((opsw[3] == true) ? 2 : 0)
332                        + ((opsw[4] == true) ? 4 : 0)
333                        + ((opsw[5] == true) ? 8 : 0));
334                break;
335            case 6:
336                outputStates.setSelectedIndex((opsw[6] == true) ? 1 : 0);
337                break;
338            case 8:
339                startupDelay.setSelectedIndex((opsw[8] == true) ? 1 : 0);
340                break;
341            case 9:
342                staticOutputShutoff.setSelectedIndex((opsw[9] == true) ? 1 : 0);
343                break;
344            case 10:
345                commandType.setSelectedIndex((opsw[10] == true) ? 1 : 0);
346                break;
347            case 11:
348            case 16:
349                routesControl.setSelectedIndex((((opsw[16] == true) ? 2 : 0) + (opsw[11] ? 1 : 0)));
350                break;
351            case 15:
352            case 12:
353                localControlOfOutputsStyle.setSelectedIndex(((opsw[15] == true) ? 2 : 0) + (opsw[12] ? 1 : 0));
354                break;
355            case 13:
356                sensorMessageTrigger.setSelectedIndex((opsw[13] == true) ? 1 : 0);   // selection 0 - only for A inputs; 1 - both A and S inputs
357                break;
358            case 14:
359                commandSource.setSelectedIndex((opsw[14] == true) ? 1 : 0);
360                break;
361            case 17:
362                output1CrossbuckFlasherCheckBox.setSelected(opsw[17]);
363                break;
364            case 18:
365                output2CrossbuckFlasherCheckBox.setSelected(opsw[18]);
366                break;
367            case 19:
368                output3CrossbuckFlasherCheckBox.setSelected(opsw[19]);
369                break;
370            case 20:
371                output4CrossbuckFlasherCheckBox.setSelected(opsw[20]);
372
373                break;
374            case 21:
375                localSensorType.setSelectedIndex(opsw[21] ? 1 : 0);
376                break;
377            default:
378                // we are only interested in the states above. Ignore the rest
379                log.debug("Unhandled state code: {}", state);
380                break;
381        }
382        updateUI();
383    }
384
385    @Override
386    @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "DLS_DEAD_LOCAL_STORE", justification = "Cannot catch an exception without grabbing the exception, but we don't do anything with the exception details.")
387    protected int nextState(int state) {
388        if (isWritingResetOpSw) {
389            if ((state == 7) && (opsw[7] == true)) {
390                opsw[7] = false;
391                return 7;
392            } else if (state == 7) {
393                return 0;
394            }
395        }
396
397        if (onlyOneOperation == true) {
398            onlyOneOperation = false;
399            return 0;
400        }
401        if ((state > 1)
402                && (((isRead == true) && (readAllButton.isSelected() == false))
403                || ((isRead == false)
404                && ((writeAllButton.isSelected() == false)
405                && (resetRouteButton.isSelected() == false))))) {
406            // handle case where a button is de-selected by the user during the operation
407
408            Color noAccessColor = ValidatedTextField.COLOR_BG_UNEDITED;
409            if ((operationType == OpSwOpType.BasicsRead)
410                    || (operationType == OpSwOpType.BasicsWrite)) {
411                unhighlightAllBasicOpSws();
412                unhighlightAllOutputEntryFields();
413                unhighlightAllRouteEntryFields();
414                return 0;
415            } else if ((operationType == OpSwOpType.OutputsRead)
416                    || (operationType == OpSwOpType.OutputsWrite)
417                    || (operationType == OpSwOpType.Route1Read)
418                    || (operationType == OpSwOpType.Route1Write)
419                    || (operationType == OpSwOpType.Route2Read)
420                    || (operationType == OpSwOpType.Route2Write)
421                    || (operationType == OpSwOpType.Route3Read)
422                    || (operationType == OpSwOpType.Route3Write)
423                    || (operationType == OpSwOpType.Route4Read)
424                    || (operationType == OpSwOpType.Route4Write)
425                    || (operationType == OpSwOpType.Route5Read)
426                    || (operationType == OpSwOpType.Route5Write)
427                    || (operationType == OpSwOpType.Route6Read)
428                    || (operationType == OpSwOpType.Route6Write)
429                    || (operationType == OpSwOpType.Route7Read)
430                    || (operationType == OpSwOpType.Route7Write)
431                    || (operationType == OpSwOpType.Route8Read)
432                    || (operationType == OpSwOpType.Route8Write)) {
433                // handle stopping of indirect access operations
434                if (state == 48) {
435                    // for DS64, indirect operations for output addresses or route entries can be
436                    // aborted after the first 16 indirect bits are accessed
437                    changeComponentBgColor(whichComponent(33, indexToRead), noAccessColor);
438                    log.debug("Decided to stop read/write after OpSw 48 because no read/write button selected."); // NOI18N
439                    return 0;
440                } else if (state == 64) {
441                    // for DS64, indirect operations for output addresses or route entries can be
442                    // aborted after the second 16 indirect bits are accessed
443                    changeComponentBgColor(whichComponent(49, indexToRead), noAccessColor);
444                    log.debug("Decided to stop read/write after OpSw 64 because no read/write button selected."); // NOI18N
445                    return 0;
446                }
447            }
448        }
449
450        switch (state) {
451            case 1: {
452                if (colorizedObject == null) {
453                    colorizedObject = outputType;
454                }
455                colorizedObject.setBackground(null);
456                isRead = read;
457                indexToRead = 0;
458                if ((operationType == null)
459                        || (operationType == OpSwOpType.BasicsRead)
460                        || (operationType == OpSwOpType.BasicsWrite)) {
461                    colorizedObject = delayTime;
462                    colorizedObject.setBackground(Color.blue.brighter());
463                    return 2;
464                } else if ((operationType == OpSwOpType.OutputsRead)
465                        || (operationType == OpSwOpType.OutputsWrite)) {
466                    indexToRead = 0;
467                    read = false;               // want to write opSw 25 thru 32
468                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
469                    return 25;
470                } else if ((operationType == OpSwOpType.Route1Read) || (operationType == OpSwOpType.Route1Write)) {
471                    indexToRead = 16;
472                    read = false;               // want to write opSw 25 thru 32
473                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
474                    return 25;
475                } else if ((operationType == OpSwOpType.Route2Read) || (operationType == OpSwOpType.Route2Write)) {
476                    indexToRead = 20;
477                    read = false;               // want to write opSw 25 thru 32
478                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
479                    return 25;
480                } else if ((operationType == OpSwOpType.Route3Read) || (operationType == OpSwOpType.Route3Write)) {
481                    indexToRead = 24;
482                    read = false;               // want to write opSw 25 thru 32
483                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
484                    return 25;
485                } else if ((operationType == OpSwOpType.Route4Read) || (operationType == OpSwOpType.Route4Write)) {
486                    indexToRead = 28;
487                    read = false;               // want to write opSw 25 thru 32
488                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
489                    return 25;
490                } else if ((operationType == OpSwOpType.Route5Read) || (operationType == OpSwOpType.Route5Write)) {
491                    indexToRead = 32;
492                    read = false;               // want to write opSw 25 thru 32
493                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
494                    return 25;
495                } else if ((operationType == OpSwOpType.Route6Read) || (operationType == OpSwOpType.Route6Write)) {
496                    indexToRead = 36;
497                    read = false;               // want to write opSw 25 thru 32
498                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
499                    return 25;
500                } else if ((operationType == OpSwOpType.Route7Read) || (operationType == OpSwOpType.Route7Write)) {
501                    indexToRead = 40;
502                    read = false;               // want to write opSw 25 thru 32
503                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
504                    return 25;
505                } else if ((operationType == OpSwOpType.Route8Read) || (operationType == OpSwOpType.Route8Write)) {
506                    indexToRead = 44;
507                    read = false;               // want to write opSw 25 thru 32
508                    setOpSwIndex(indexToRead);  //set values for opSw25 thru 32 to point to correct index
509                    return 25;
510                }
511                return 0;
512            }
513            case 2: {
514                if (colorizedObject != null) {
515                    colorizedObject.setBackground(null);
516                }
517                colorizedObject = delayTime;
518                colorizedObject.setBackground(Color.blue.brighter());
519                return 3;
520            }
521            case 3: {
522                if (colorizedObject != null) {
523                    colorizedObject.setBackground(null);
524                }
525                colorizedObject = delayTime;
526                colorizedObject.setBackground(Color.blue.brighter());
527                return 4;
528            }
529            case 4: {
530                if (colorizedObject != null) {
531                    colorizedObject.setBackground(null);
532                }
533                colorizedObject = delayTime;
534                colorizedObject.setBackground(Color.blue.brighter());
535                return 5;
536            }
537            case 5: {
538                if (colorizedObject != null) {
539                    colorizedObject.setBackground(null);
540                }
541                colorizedObject = outputStates;
542                colorizedObject.setBackground(Color.blue.brighter());
543                return 6;
544            }
545            case 6: {
546                if (colorizedObject != null) {
547                    colorizedObject.setBackground(null);
548                }
549                colorizedObject = startupDelay;
550                colorizedObject.setBackground(Color.blue.brighter());
551                return 8;// 7 has to be done last, as it's reset
552            }
553            case 8: {
554                if (colorizedObject != null) {
555                    colorizedObject.setBackground(null);
556                }
557                colorizedObject = staticOutputShutoff;
558                colorizedObject.setBackground(Color.blue.brighter());
559                return 9;
560            }
561            case 9: {
562                if (colorizedObject != null) {
563                    colorizedObject.setBackground(null);
564                }
565                colorizedObject = commandType;
566                colorizedObject.setBackground(Color.blue.brighter());
567                return 10;
568            }
569            case 10: {
570                if (colorizedObject != null) {
571                    colorizedObject.setBackground(null);
572                }
573                colorizedObject = routesControl;
574                colorizedObject.setBackground(Color.blue.brighter());
575                return 11;
576            }
577            case 11: {
578                if (colorizedObject != null) {
579                    colorizedObject.setBackground(null);
580                }
581                colorizedObject = localControlOfOutputsStyle;
582                colorizedObject.setBackground(Color.blue.brighter());
583                return 12;
584            }
585            case 12: {
586                if (colorizedObject != null) {
587                    colorizedObject.setBackground(null);
588                }
589                colorizedObject = sensorMessageTrigger;
590                colorizedObject.setBackground(Color.blue.brighter());
591                return 13;
592            }
593            case 13: {
594                if (colorizedObject != null) {
595                    colorizedObject.setBackground(null);
596                }
597                colorizedObject = commandSource;
598                colorizedObject.setBackground(Color.blue.brighter());
599                return 14;
600            }
601            case 14: {
602                if (colorizedObject != null) {
603                    colorizedObject.setBackground(null);
604                }
605                colorizedObject = localControlOfOutputsStyle;
606                colorizedObject.setBackground(Color.blue.brighter());
607                return 15;
608            }
609            case 15: {
610                if (colorizedObject != null) {
611                    colorizedObject.setBackground(null);
612                }
613                colorizedObject = routesControl;
614                colorizedObject.setBackground(Color.blue.brighter());
615                return 16;
616            }
617            case 16: {
618                if (colorizedObject != null) {
619                    colorizedObject.setBackground(null);
620                }
621                colorizedObject = output1CrossbuckFlasherCheckBox;
622                colorizedObject.setBackground(Color.blue.brighter());
623                return 17;
624            }
625            case 17: {
626                if (colorizedObject != null) {
627                    colorizedObject.setBackground(null);
628                }
629                colorizedObject = output2CrossbuckFlasherCheckBox;
630                colorizedObject.setBackground(Color.blue.brighter());
631                return 18;
632            }
633            case 18: {
634                if (colorizedObject != null) {
635                    colorizedObject.setBackground(null);
636                }
637                colorizedObject = output3CrossbuckFlasherCheckBox;
638                colorizedObject.setBackground(Color.blue.brighter());
639                return 19;
640            }
641            case 19: {
642                if (colorizedObject != null) {
643                    colorizedObject.setBackground(null);
644                }
645                colorizedObject = output4CrossbuckFlasherCheckBox;
646                colorizedObject.setBackground(Color.blue.brighter());
647                return 20;
648            }
649            case 20: {
650                if (colorizedObject != null) {
651                    colorizedObject.setBackground(null);
652                }
653                colorizedObject = localSensorType;
654                colorizedObject.setBackground(Color.blue.brighter());
655                return 21;
656            }
657            case 21: {
658                if (colorizedObject != null) {
659                    colorizedObject.setBackground(null);
660                }
661                this.readAllButton.setEnabled(true);
662                this.writeAllButton.setEnabled(true);
663                return 0;
664            }
665            case 22: {
666                return 0;
667            }
668            case 25:
669            case 26:
670            case 27:
671            case 28:
672            case 29:
673            case 30:
674            case 31: {
675                // handle indirect index bits
676                return state + 1;
677            }
678            case 32: {
679                read = isRead;               // go back to original mode of operation
680                log.debug("Dealing with index {}", indexToRead);
681                changeGuiElementHighlight(33, indexToRead);
682                if (isRead == true) {
683                    return 46;  // want to read "out-of-turn" to speed up reads when
684                    // a route entry is disabled
685                } else {
686                    // prepare values in opsw[] from appropriate write values
687                    updateOpswForWrite(indexToRead);
688                    return 33;
689                }
690            }
691            case 33:
692            case 34:
693            case 35:
694            case 36:
695            case 37:
696            case 38:
697            case 39:
698            case 40:
699            case 41:
700            case 42:
701            case 43:
702            case 44:
703            case 46:
704            case 47:
705                return state + 1;
706            case 45:
707                if (isRead) {
708                    // Have already read OpSws 64-48 and determined that there is
709                    // a valid value in bits 33-45.  Deal with that velue, then
710                    // go to the validity bits for the other half.
711                    int extractedDataValue = 0;
712                    for (int i = 48; i >= 33; i--) {
713                        extractedDataValue = (extractedDataValue << 1) + (opsw[i] ? 1 : 0);
714                    }
715                    log.debug("Read Index {} value (OpSws 33-48) = 0x{}", indexToRead + 1, Integer.toHexString(extractedDataValue));
716                    updateGuiFromOpSws33_48();
717                    changeGuiElementHighlight(48, indexToRead); // clear the highlighted GUI element
718
719                    return 62;  // because OpSws 46, 47, and 48 were read "out-
720                    // of-turn" for speediness, and also want to read OpSws
721                    // 62-64 "out-of-turn" for speediness
722                } else {
723                    return 46;
724                }
725            case 48: {
726                changeGuiElementHighlight(48, indexToRead);
727                if (isRead == true) {
728                    // For reads, check the upper bits of this "half" to determine
729                    // whether or not to read the remaining bits in the "half"
730
731                    if ((opsw[47] == false) && (opsw[48] == false)) {
732                        // entry is valid, so need to read all opSw bits in [46:33]
733                        log.debug("Read of low value in index {} is a valid entry.", indexToRead); // NOI18N
734                        return 33;
735                    } else {
736                        log.debug("Read of low value in index {} is an invalid entry.", indexToRead); // NOI18N
737                        // entry is not valid, so do not need to read opSw bits in [46:33]
738                        // Do need to update internal opSw bits so that they imply an unused
739                        // entry
740                        changeGuiElementUnHighlight(48, indexToRead);
741                        for (int i = 33; i < 46; ++i) {
742                            opsw[i] = true;
743                        }
744                        opsw[40] = false;
745
746                        // need to update the GUI
747                        updateGuiFromOpSws33_48();
748                        changeGuiElementHighlight(48, indexToRead); // clear the highlighted GUI element
749
750                        return 62; // need to skip ahead to the validity bits of the
751                        // next entry
752                    }
753                } else {
754                    // handle the case for writes
755
756                    int extractedDataValue = 0;
757                    for (int i = 48; i >= 33; i--) {
758                        extractedDataValue = (extractedDataValue << 1) + (opsw[i] ? 1 : 0);
759                    }
760                    log.debug("Wrote Index {} value (OpSws 33-48) = 0x{}", indexToRead + 1, Integer.toHexString(extractedDataValue));
761                    updateGuiFromOpSws33_48();
762                    switch (indexToRead) {
763                        case 0: {
764                            // have written a value for output1 - update GUI
765                            outAddr1.setLastQueriedValue(outAddr1.getText());
766                            break;
767                        }
768                        case 1: {
769                            // have written a value for output3 - update GUI
770                            outAddr3.setLastQueriedValue(outAddr3.getText());
771                            break;
772                        }
773                        case 16:
774                        case 20:
775                        case 24:
776                        case 28:
777                        case 32:
778                        case 36:
779                        case 40:
780                        case 44: {
781                            // have written value for Route[n] Top entry - update GUI
782                            Integer effectiveIndex = (indexToRead - 12) / 4;
783                            routeTop[effectiveIndex].addressField.setLastQueriedValue(routeTop[effectiveIndex].addressField.getText());
784                            try {
785                                routeTop[effectiveIndex].setAddress(Integer.parseInt(routeTop[effectiveIndex].addressField.getText()));
786                            } catch (NumberFormatException e) {
787                                routeTop[effectiveIndex].setIsUnused();
788                            }
789                            break;
790                        }
791                        case 17:
792                        case 21:
793                        case 25:
794                        case 29:
795                        case 33:
796                        case 37:
797                        case 41:
798                        case 45: {
799                            // have written a value for Route n - update GUI
800                            Integer effectiveIndex = (indexToRead - 13) / 4;
801                            routeA3[effectiveIndex].addressField.setLastQueriedValue(routeA3[effectiveIndex].addressField.getText());
802                            try {
803                                routeA3[effectiveIndex].setAddress(Integer.parseInt(routeA3[effectiveIndex].addressField.getText()));
804                            } catch (NumberFormatException e) {
805                                routeA3[effectiveIndex].setIsUnused();
806
807                            }
808                            break;
809                        }
810                        case 18:
811                        case 22:
812                        case 26:
813                        case 30:
814                        case 34:
815                        case 38:
816                        case 42:
817                        case 46: {
818                            // have written a value for Route n - update GUI
819                            Integer effectiveIndex = (indexToRead - 14) / 4;
820                            routeA5[effectiveIndex].addressField.setLastQueriedValue(routeA5[effectiveIndex].addressField.getText());
821                            try {
822                                routeA5[effectiveIndex].setAddress(Integer.parseInt(routeA5[effectiveIndex].addressField.getText()));
823                            } catch (NumberFormatException e) {
824                                routeA5[effectiveIndex].setIsUnused();
825                            }
826                            break;
827                        }
828                        case 19:
829                        case 23:
830                        case 27:
831                        case 31:
832                        case 35:
833                        case 39:
834                        case 43:
835                        case 47: {
836                            // have written a value for Route n - update GUI
837                            Integer effectiveIndex = (indexToRead - 15) / 4;
838                            routeA7[effectiveIndex].addressField.setLastQueriedValue(routeA7[effectiveIndex].addressField.getText());
839                            try {
840                                routeA7[effectiveIndex].setAddress(Integer.parseInt(routeA7[effectiveIndex].addressField.getText()));
841                            } catch (NumberFormatException e) {
842                                routeA7[effectiveIndex].setIsUnused();
843                            }
844                            break;
845                        }
846                        default:
847                            log.error("invalid indirectIndex for write: {}", indexToRead); // NOI18N
848                            return 0;
849                    }
850                    return 49;
851                }
852            }
853            case 49:
854            case 50:
855            case 51:
856            case 52:
857            case 53:
858            case 54:
859            case 56:
860            case 57:
861            case 58:
862            case 59:
863            case 60:
864            case 62:
865            case 63:
866                return (state + 1);
867            case 55:
868                return 57; // skip apparantly-unused bit to see if this reduces amount of output state disruption during read
869            case 61:
870                if (isRead) {
871                    int extractedDataValue = 0;
872                    for (int i = 64; i >= 49; i--) {
873                        extractedDataValue = (extractedDataValue << 1) + (opsw[i] ? 1 : 0);
874                    }
875                    log.debug("Read Index {} value (OpSws 49-64) = 0x{}", indexToRead + 1, Integer.toHexString(extractedDataValue));
876                    updateGuiFromOpSws49_64();
877                    changeGuiElementHighlight(61, indexToRead);
878                    return determineNextStateForRead();
879                } else {
880                    return 62;
881                }
882            case 64: {
883                if (isRead == true) {
884                    // For reads, check the upper bits of this "half" to determine
885                    // whether or not to read the remaining bits in the "half"
886
887                    if ((opsw[63] == false) && (opsw[64] == false)) {
888                        // entry is valid, so need to read all opSw bits in [62:49]
889                        log.debug("Read of high value in index {} is a valid entry.", indexToRead); // NOI18N
890                        changeGuiElementUnHighlight(64, indexToRead);
891                        return 49;
892                    } else {
893                        // entry is not valid, so do not need to read opSw bits in [46:33]
894                        // Do need to update internal opSw bits so that they imply an unused
895                        // entry
896                        log.debug("Read of high value in index {} is an invalid entry.", indexToRead); // NOI18N
897                        for (int i = 49; i < 62; ++i) {
898                            opsw[i] = true;
899                        }
900                        opsw[56] = false;
901
902                        // need to update GUI to show unused value
903                        updateGuiFromOpSws49_64();
904                        changeGuiElementHighlight(64, indexToRead); // clear the highlighted GUI element
905
906                        return determineNextStateForRead();
907                    }
908                } // end handling of read operation
909                else {
910                    //handle write operation
911                    // skip to next index, or, if done with indexables,
912                    // go to end.
913                    changeGuiElementHighlight(64, indexToRead); // clear the highlighted GUI element
914                    switch (indexToRead) {
915                        case 0: {
916                            // have written a value for output2 - update GUI
917                            outAddr2.setLastQueriedValue(outAddr2.getText());
918                            outAddr2.repaint();
919                            indexToRead++;
920                            read = false;
921                            setOpSwIndex(indexToRead);
922                            return 25;
923                        }
924                        case 1: {
925                            // have written a value for output4 - update GUI
926                            outAddr4.setLastQueriedValue(outAddr4.getText());
927                            outAddr4.repaint();
928                            this.readAllButton.setEnabled(true);
929                            this.writeAllButton.setEnabled(true);
930                            return 0;
931                        }
932                        case 16:
933                        case 20:
934                        case 24:
935                        case 28:
936                        case 32:
937                        case 36:
938                        case 40:
939                        case 44: {
940                            // have written a value for Route n - update GUI
941                            Integer effectiveIndex = (indexToRead - 12) / 4;
942                            routeA2[effectiveIndex].addressField.setLastQueriedValue(routeA2[effectiveIndex].addressField.getText());
943                            try {
944                                routeA2[effectiveIndex].setAddress(Integer.parseInt(routeA2[effectiveIndex].addressField.getText()));
945                            } catch (NumberFormatException e) {
946                                routeA2[effectiveIndex].setIsUnused();
947                            }
948                            indexToRead++;
949                            read = false;
950                            setOpSwIndex(indexToRead);
951                            return 25;
952                        }
953                        case 17:
954                        case 21:
955                        case 25:
956                        case 29:
957                        case 33:
958                        case 37:
959                        case 41:
960                        case 45: {
961                            // have written a value for Route n - update GUI
962                            Integer effectiveIndex = (indexToRead - 13) / 4;
963                            routeA4[effectiveIndex].addressField.setLastQueriedValue(routeA4[effectiveIndex].addressField.getText());
964                            try {
965                                routeA4[effectiveIndex].setAddress(Integer.parseInt(routeA4[effectiveIndex].addressField.getText()));
966                            } catch (NumberFormatException e) {
967                                routeA4[effectiveIndex].setIsUnused();
968                            }
969                            indexToRead++;
970                            read = false;
971                            setOpSwIndex(indexToRead);
972                            return 25;
973                        }
974                        case 18:
975                        case 22:
976                        case 26:
977                        case 30:
978                        case 34:
979                        case 38:
980                        case 42:
981                        case 46: {
982                            // have written a value for Route n - update GUI
983                            Integer effectiveIndex = (indexToRead - 14) / 4;
984                            routeA6[effectiveIndex].addressField.setLastQueriedValue(routeA6[effectiveIndex].addressField.getText());
985                            try {
986                                routeA6[effectiveIndex].setAddress(Integer.parseInt(routeA6[effectiveIndex].addressField.getText()));
987                            } catch (NumberFormatException e) {
988                                routeA6[effectiveIndex].setIsUnused();
989                            }
990                            indexToRead++;
991                            read = false;
992                            setOpSwIndex(indexToRead);
993                            return 25;
994                        }
995                        case 19:
996                        case 23:
997                        case 27:
998                        case 31:
999                        case 35:
1000                        case 39:
1001                        case 43:
1002                        case 47: {
1003                            // have written a value for Route n - update GUI
1004                            Integer effectiveIndex = (indexToRead - 15) / 4;
1005                            routeA8[effectiveIndex].addressField.setLastQueriedValue(routeA8[effectiveIndex].addressField.getText());
1006                            try {
1007                                routeA8[effectiveIndex].setAddress(Integer.parseInt(routeA8[effectiveIndex].addressField.getText()));
1008                            } catch (NumberFormatException e) {
1009                                routeA8[effectiveIndex].setIsUnused();
1010                            }
1011                            indexToRead++;
1012                            read = false;
1013                            setOpSwIndex(indexToRead);
1014                            return 0;
1015                        }
1016                        default: {
1017                            return 0;
1018                        }
1019                    }
1020                } // end handling for write operations
1021            }
1022
1023            case 7: {
1024                this.readAllButton.setEnabled(true);
1025                this.writeAllButton.setEnabled(true);
1026                log.warn("Board has been reset.  The board will now respond at Address 1."); // NOI18N
1027                return 0;
1028            }       // done!
1029            default:
1030                log.error("unexpected state {}", state); // NOI18N
1031                this.readAllButton.setEnabled(true);
1032                this.writeAllButton.setEnabled(true);
1033                return 0;
1034        }
1035    }
1036
1037    @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "DLS_DEAD_LOCAL_STORE",
1038                justification = "False positive on the implied local variable in indexToRead++")
1039    private int determineNextStateForRead() {
1040        switch (indexToRead) {
1041            case 1: {
1042                // have read output addresses 1, 2, 3, and 4.  No more to
1043                // read (for this tab of the GUI).
1044                this.readAllButton.setEnabled(true);
1045                this.writeAllButton.setEnabled(true);
1046                return 0;
1047            }
1048            case 0:
1049            case 16:
1050            case 20:
1051            case 24:
1052            case 28:
1053            case 32:
1054            case 36:
1055            case 40:
1056            case 44:
1057            case 17:
1058            case 21:
1059            case 25:
1060            case 29:
1061            case 33:
1062            case 37:
1063            case 41:
1064            case 45:
1065            case 18:
1066            case 22:
1067            case 26:
1068            case 30:
1069            case 34:
1070            case 38:
1071            case 42:
1072            case 46: {
1073                // have read a value for Route n.  go to next value if necessary
1074                indexToRead++;
1075                read = false;
1076                setOpSwIndex(indexToRead);
1077                return 25;
1078            }
1079            case 19:
1080            case 23:
1081            case 27:
1082            case 31:
1083            case 35:
1084            case 39:
1085            case 43:
1086            case 47: {
1087                // have read last values for Route n.  No next value so stop.
1088                indexToRead++;
1089                read = false;
1090                setOpSwIndex(indexToRead);
1091                return 0;
1092            }
1093            default:
1094                return 0;
1095        }
1096    }
1097
1098    private void changeComponentBgColor(JComponent comp, Color color) {
1099        comp.setBackground(color);
1100    }
1101
1102    private JComponent whichComponent(Integer reportedState, Integer reportedIndexToRead) {
1103        if (reportedState == 33) {
1104            switch (reportedIndexToRead) {
1105                case 0:
1106                    return outAddr1;
1107
1108                case 1:
1109                    return outAddr3;
1110
1111                case 16:
1112                case 20:
1113                case 24:
1114                case 28:
1115                case 32:
1116                case 36:
1117                case 40:
1118                case 44:
1119                    return routeTop[(reportedIndexToRead - 12) / 4].addressField;
1120
1121                case 17:
1122                case 21:
1123                case 25:
1124                case 29:
1125                case 33:
1126                case 37:
1127                case 41:
1128                case 45:
1129                    return routeA3[(reportedIndexToRead - 13) / 4].addressField;
1130
1131                case 18:
1132                case 22:
1133                case 26:
1134                case 30:
1135                case 34:
1136                case 38:
1137                case 42:
1138                case 46:
1139                    return routeA5[(reportedIndexToRead - 14) / 4].addressField;
1140
1141                case 19:
1142                case 23:
1143                case 27:
1144                case 31:
1145                case 35:
1146                case 39:
1147                case 43:
1148                case 47:
1149                    return routeA7[(reportedIndexToRead - 15) / 4].addressField;
1150
1151                default:
1152                    return null;
1153            }
1154        } else if (reportedState == 49) {
1155            switch (reportedIndexToRead) {
1156                case 0:
1157                    return outAddr2;
1158
1159                case 1:
1160                    return outAddr4;
1161
1162                case 16:
1163                case 20:
1164                case 24:
1165                case 28:
1166                case 32:
1167                case 36:
1168                case 40:
1169                case 44:
1170                    return routeA2[(reportedIndexToRead - 12) / 4].addressField;
1171
1172                case 17:
1173                case 21:
1174                case 25:
1175                case 29:
1176                case 33:
1177                case 37:
1178                case 41:
1179                case 45:
1180                    return routeA4[(reportedIndexToRead - 13) / 4].addressField;
1181
1182                case 18:
1183                case 22:
1184                case 26:
1185                case 30:
1186                case 34:
1187                case 38:
1188                case 42:
1189                case 46:
1190                    return routeA6[(reportedIndexToRead - 14) / 4].addressField;
1191
1192                case 19:
1193                case 23:
1194                case 27:
1195                case 31:
1196                case 35:
1197                case 39:
1198                case 43:
1199                case 47:
1200                    return routeA8[(reportedIndexToRead - 15) / 4].addressField;
1201
1202                default:
1203                    return null;
1204            }
1205        }
1206        return null;
1207    }
1208
1209    private void changeGuiElementUnHighlight(Integer reportedState, Integer reportedIndexToRead) {
1210        log.debug("changedGuiElementUnHiglight st={} index={}", reportedState, reportedIndexToRead);
1211        JComponent jc;
1212        switch (reportedState) {
1213            case 33:
1214                return;
1215            case 45:
1216            case 48:
1217                jc = whichComponent(33, reportedIndexToRead);
1218                if (jc != null) {
1219                    changeComponentBgColor(jc, null); // inherit from parent
1220                }
1221                return;
1222            case 61:
1223            case 64:
1224                jc = whichComponent(49, reportedIndexToRead);
1225                if (jc != null) {
1226                    changeComponentBgColor(jc, null); // inherit from parent
1227                }
1228                break;
1229            default:
1230                // nothing to do in this case
1231                break;
1232        }
1233    }
1234
1235    private void changeGuiElementHighlight(Integer reportedState, Integer reportedIndexToRead) {
1236        log.debug("changedGuiElementHiglight st={} index={}", reportedState, reportedIndexToRead);
1237        Color accessColor = Color.blue.brighter();
1238        JComponent jc;
1239        if (reportedState == 33) {
1240            jc = whichComponent(reportedState, reportedIndexToRead);
1241            changeComponentBgColor(jc, accessColor);
1242        }
1243        if (reportedState == 48) {
1244            changeGuiElementUnHighlight(33, reportedIndexToRead);
1245            jc = whichComponent(49, reportedIndexToRead);
1246            if (jc != null) {
1247                changeComponentBgColor(jc, accessColor);
1248            }
1249        }
1250        if (reportedState == 64) {
1251            jc = whichComponent(49, reportedIndexToRead);
1252            changeComponentBgColor(jc, null); // inherit from parent component
1253        }
1254    }
1255
1256    private boolean alreadyKnowThisBoardId(Integer id) {
1257        return (boardNumsEntryValue.contains(id));
1258    }
1259
1260    private Integer addBoardIdToList(Integer id) {
1261        boardNumsEntryValue.add(boardNumsEntryValue.size(), id);
1262        addressComboBox.removeAllItems();
1263        Collections.sort(boardNumsEntryValue);
1264        Integer indexOfTargetBoardAddress = 0;
1265        for (Integer index = 0; index < boardNumsEntryValue.size(); ++index) {
1266            if (boardNumsEntryValue.get(index).equals(id)) {
1267                indexOfTargetBoardAddress = index;
1268            }
1269            addressComboBox.addItem(boardNumsEntryValue.get(index));
1270        }
1271        return indexOfTargetBoardAddress;
1272    }
1273
1274    private void selectBoardIdByIndex(Integer index) {
1275        addressComboBox.setSelectedIndex(index);
1276    }
1277
1278    @Override
1279    public void readAll() {
1280        addrField.setText(addressComboBox.getSelectedItem().toString());
1281
1282        Integer curAddr = Integer.parseInt(addrField.getText());
1283
1284        // If a new board address is specified, add it (and sort it) into the current list.
1285        if (!alreadyKnowThisBoardId(curAddr)) {
1286            Integer index = addBoardIdToList(curAddr);
1287            selectBoardIdByIndex(index);
1288        }
1289        if (generalTabbedPane.getSelectedComponent().getClass() == JPanel.class) {
1290            if (((JPanel) generalTabbedPane.getSelectedComponent()) == generalPanel) {
1291                operationType = OpSwOpType.BasicsRead;
1292            } else if (((JPanel) generalTabbedPane.getSelectedComponent()) == outputAddrsPanel) {
1293                operationType = OpSwOpType.OutputsRead;
1294            }
1295        } else if (generalTabbedPane.getSelectedComponent().getClass() == JScrollPane.class) {
1296            if (((JScrollPane) generalTabbedPane.getSelectedComponent()) == opswsScrollPane) {
1297                operationType = OpSwOpType.BasicsRead;
1298            }
1299        } else if (generalTabbedPane.getSelectedComponent().getClass() == JTabbedPane.class) {
1300            if (((JTabbedPane) generalTabbedPane.getSelectedComponent() == routesTabbedPane)) {
1301                if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[1]) {
1302                    operationType = OpSwOpType.Route1Read;
1303                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[2]) {
1304                    operationType = OpSwOpType.Route2Read;
1305                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[3]) {
1306                    operationType = OpSwOpType.Route3Read;
1307                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[4]) {
1308                    operationType = OpSwOpType.Route4Read;
1309                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[5]) {
1310                    operationType = OpSwOpType.Route5Read;
1311                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[6]) {
1312                    operationType = OpSwOpType.Route6Read;
1313                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[7]) {
1314                    operationType = OpSwOpType.Route7Read;
1315                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[8]) {
1316                    operationType = OpSwOpType.Route8Read;
1317                } else {
1318                    log.error("DS64 TabbedPanel into readAll(): no known Route[n] tab selected.");
1319                    return;
1320                }
1321            } else {
1322                log.error("DS64 TabbedPanel into ReadAll(): no selected tab group");
1323                return;
1324            }
1325        } else {
1326            return;
1327        }
1328        super.readAll();
1329    }
1330
1331    public void updateBoardAddress() {
1332        addrField.setText(addressComboBox.getSelectedItem().toString());
1333    }
1334
1335    @Override
1336    public void writeAll() {
1337        addrField.setText(addressComboBox.getSelectedItem().toString());
1338
1339        Integer curAddr = Integer.parseInt(addrField.getText());
1340
1341        // If a new board address is specified, add it (and sort it) into the current list.
1342        if (!boardNumsEntryValue.contains(curAddr)) {
1343            boardNumsEntryValue.add(boardNumsEntryValue.size(), curAddr);
1344            addressComboBox.removeAllItems();
1345            Collections.sort(boardNumsEntryValue);
1346            Integer indexOfTargetBoardAddress = 0;
1347            for (Integer index = 0; index < boardNumsEntryValue.size(); ++index) {
1348                if (boardNumsEntryValue.get(index).equals(curAddr)) {
1349                    indexOfTargetBoardAddress = index;
1350                }
1351                addressComboBox.addItem(boardNumsEntryValue.get(index));
1352            }
1353            addressComboBox.setSelectedIndex(indexOfTargetBoardAddress);
1354        }
1355
1356        if (generalTabbedPane.getSelectedComponent().getClass() == JPanel.class) {
1357            if (((JPanel) generalTabbedPane.getSelectedComponent()) == generalPanel) {
1358                operationType = OpSwOpType.BasicsWrite;
1359            } else if (((JPanel) generalTabbedPane.getSelectedComponent()) == outputAddrsPanel) {
1360                operationType = OpSwOpType.OutputsWrite;
1361            }
1362        } else if (generalTabbedPane.getSelectedComponent().getClass() == JScrollPane.class) {
1363            if (((JScrollPane) generalTabbedPane.getSelectedComponent()) == opswsScrollPane) {
1364                operationType = OpSwOpType.BasicsWrite;
1365            }
1366
1367        } else if (generalTabbedPane.getSelectedComponent().getClass() == JTabbedPane.class) {
1368            if (((JTabbedPane) generalTabbedPane.getSelectedComponent()) == routesTabbedPane) {
1369
1370                if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[1]) {
1371                    operationType = OpSwOpType.Route1Write;
1372                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[2]) {
1373                    operationType = OpSwOpType.Route2Write;
1374                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[3]) {
1375                    operationType = OpSwOpType.Route3Write;
1376                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[4]) {
1377                    operationType = OpSwOpType.Route4Write;
1378                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[5]) {
1379                    operationType = OpSwOpType.Route5Write;
1380                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[6]) {
1381                    operationType = OpSwOpType.Route6Write;
1382                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[7]) {
1383                    operationType = OpSwOpType.Route7Write;
1384                } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[8]) {
1385                    operationType = OpSwOpType.Route8Write;
1386                } else {
1387                    return;
1388                }
1389            } else {
1390                return;
1391            }
1392        } else {
1393            return;
1394        }
1395
1396        super.writeAll();
1397    }
1398
1399    private enum OpSwOpType {
1400        OutputsRead, OutputsWrite,
1401        Route1Read, Route1Write,
1402        Route2Read, Route2Write,
1403        Route3Read, Route3Write,
1404        Route4Read, Route4Write,
1405        Route5Read, Route5Write,
1406        Route6Read, Route6Write,
1407        Route7Read, Route7Write,
1408        Route8Read, Route8Write,
1409        BasicsRead, BasicsWrite
1410    }
1411
1412    private OpSwOpType operationType = null;
1413    Boolean isRead;
1414    Boolean isWritingResetOpSw = false;
1415    Integer indexToRead = 0;
1416    Boolean resetOpSwVal = false;
1417
1418    /**
1419     * Set index into OpSw table
1420     *
1421     * @param index  the indirect address
1422     */
1423    protected void setOpSwIndex(int index) {
1424        opsw[25] = (index & 1) == 1;
1425        opsw[26] = (index & 2) == 2;
1426        opsw[27] = (index & 4) == 4;
1427        opsw[28] = (index & 8) == 8;
1428        opsw[29] = (index & 16) == 16;
1429        opsw[30] = (index & 32) == 32;
1430        opsw[31] = (index & 64) == 64;
1431        opsw[32] = (index & 128) == 128;
1432    }
1433
1434    /**
1435     * Updates data register to reflect address, state, and enable for two
1436     * turnouts.
1437     *
1438     * @param address1   first turnout address
1439     * @param state1     first turnout's state
1440     * @param is1Unused  true if first turnout entry is to be "unused"
1441     * @param address2   second turnout address
1442     * @param state2     second turnout's state
1443     * @param is2Unused  true if second turnout entry is to be "unused"
1444     */
1445    protected void updateOpSwsOutAddr(int address1, boolean state1, boolean is1Unused, int address2, boolean state2, boolean is2Unused) {
1446        int addr1 = address1 - 1;
1447        int addr2 = address2 - 1;
1448        if ((address1 == 0) || (is1Unused)) {
1449            addr1 = 2047;
1450            is1Unused = true;
1451        }
1452        if ((address2 == 0) || (is2Unused)) {
1453            addr2 = 2047;
1454            is2Unused = true;
1455        }
1456        opsw[33] = ((addr1 & 1) == 1);
1457        opsw[34] = ((addr1 & 2) == 2);
1458        opsw[35] = ((addr1 & 4) == 4);
1459        opsw[36] = ((addr1 & 8) == 8);
1460        opsw[37] = ((addr1 & 16) == 16);
1461        opsw[38] = ((addr1 & 32) == 32);
1462        opsw[39] = ((addr1 & 64) == 64);
1463        opsw[40] = false;
1464        opsw[41] = ((addr1 & 128) == 128);
1465        opsw[42] = ((addr1 & 256) == 256);
1466        opsw[43] = ((addr1 & 512) == 512);
1467        opsw[44] = ((addr1 & 1024) == 1024);
1468        opsw[45] = true;
1469        opsw[46] = state1;
1470        if (!is1Unused) {
1471            opsw[47] = false;
1472            opsw[48] = false;
1473        } else {
1474            opsw[47] = true;
1475            opsw[48] = true;
1476        }
1477
1478        opsw[49] = ((addr2 & 1) == 1);
1479        opsw[50] = ((addr2 & 2) == 2);
1480        opsw[51] = ((addr2 & 4) == 4);
1481        opsw[52] = ((addr2 & 8) == 8);
1482        opsw[53] = ((addr2 & 16) == 16);
1483        opsw[54] = ((addr2 & 32) == 32);
1484        opsw[55] = ((addr2 & 64) == 64);
1485        opsw[56] = false;
1486        opsw[57] = ((addr2 & 128) == 128);
1487        opsw[58] = ((addr2 & 256) == 256);
1488        opsw[59] = ((addr2 & 512) == 512);
1489        opsw[60] = ((addr2 & 1024) == 1024);
1490        opsw[61] = true;
1491        opsw[62] = state2;
1492        if (!is2Unused) {
1493            opsw[63] = false;
1494            opsw[64] = false;
1495        } else {
1496            opsw[63] = true;
1497            opsw[64] = true;
1498        }
1499    }
1500
1501    /**
1502     * Updates OpSw values for a given index into the data array
1503     *
1504     * @param index  indirect address
1505     */
1506    protected void updateOpswForWrite(int index) {
1507        Integer value1Address;
1508        Integer value2Address;
1509        boolean value1IsUnused;
1510        boolean value2IsUnused;
1511        boolean value1DirectionIsClosed;
1512        boolean value2DirectionIsClosed;
1513
1514        switch (index) {
1515            case 0: {
1516                try {
1517                    value1Address = Integer.parseInt(outAddr1.getText());
1518                } catch (NumberFormatException e) {
1519                    value1Address = 2048;
1520                }
1521
1522                try {
1523                    value2Address = Integer.parseInt(outAddr2.getText());
1524                } catch (NumberFormatException e) {
1525                    value2Address = 2048;
1526                }
1527
1528                updateOpSwsOutAddr(value1Address, false, false, value2Address, false, false);
1529                break;
1530            }
1531            case 1: {
1532                try {
1533                    value1Address = Integer.parseInt(outAddr3.getText());
1534                } catch (NumberFormatException e) {
1535                    value1Address = 2048;
1536                }
1537
1538                try {
1539                    value2Address = Integer.parseInt(outAddr4.getText());
1540                } catch (NumberFormatException e) {
1541                    value2Address = 2048;
1542                }
1543
1544                updateOpSwsOutAddr(value1Address, false, false, value2Address, false, false);
1545                break;
1546            }
1547            case 16:
1548            case 20:
1549            case 24:
1550            case 28:
1551            case 32:
1552            case 36:
1553            case 40:
1554            case 44: {
1555                Integer extractedIndex = (index - 12) / 4;
1556
1557                opsw[47] = false;
1558                opsw[48] = false; // assume valid turnout address entry
1559                opsw[63] = false;
1560                opsw[64] = false; // assume valid turnout address entry
1561
1562                if (routeTop[extractedIndex].getIsUnused()) {
1563                    log.warn("updateOpswForWrite - routetop[{}] is unused.", extractedIndex); // NOI18N
1564                    value1Address = 2048;
1565                    value1IsUnused = true;
1566                    value1DirectionIsClosed = true;
1567                } else {
1568                    value1DirectionIsClosed = routeTop[extractedIndex].closedRadioButton.isSelected();
1569                    value1IsUnused = false;
1570                    try {
1571                        value1Address = Integer.parseInt(routeTop[extractedIndex].addressField.getText());
1572                    } catch (NumberFormatException e) {
1573                        value1Address = 2048;
1574                        value1IsUnused = true;
1575                        value1DirectionIsClosed = true;
1576                    }
1577                }
1578
1579                if (routeA2[extractedIndex].getIsUnused()) {
1580                    log.warn("updateOpswForWrite - routeA2[{}] is unused.", extractedIndex); // NOI18N
1581                    value2Address = 2048;
1582                    value2IsUnused = true;
1583                    value2DirectionIsClosed = true;
1584                } else {
1585                    value2DirectionIsClosed = routeA2[extractedIndex].closedRadioButton.isSelected();
1586                    value2IsUnused = false;
1587                    try {
1588                        value2Address = Integer.parseInt(routeA2[extractedIndex].addressField.getText());
1589                    } catch (NumberFormatException e) {
1590                        value2Address = 2048;
1591                        value2IsUnused = true;
1592                        value2DirectionIsClosed = true;
1593                    }
1594                }
1595
1596                updateOpSwsOutAddr(value1Address, value1DirectionIsClosed, value1IsUnused,
1597                        value2Address, value2DirectionIsClosed, value2IsUnused);
1598                if (value1IsUnused) {
1599                    opsw[46] = true;
1600                    opsw[47] = true;
1601                    opsw[48] = true; // mark entry as invalid
1602                    routeTop[extractedIndex].unusedRadioButton.setSelected(true);
1603                    routeTop[extractedIndex].unusedRadioButton.repaint();
1604                    routeTop[extractedIndex].setAddress(2048);
1605                    routeTop[extractedIndex].addressField.setText("");
1606                }
1607                if (value2IsUnused) {
1608                    opsw[62] = true;
1609                    opsw[63] = true;
1610                    opsw[64] = true; // mark entry as invalid
1611                    routeA2[extractedIndex].unusedRadioButton.setSelected(true);
1612                    routeA2[extractedIndex].unusedRadioButton.repaint();
1613                    routeA2[extractedIndex].setAddress(2048);
1614                    routeA2[extractedIndex].addressField.setText("");
1615                }
1616                break;
1617            }
1618            case 17:
1619            case 21:
1620            case 25:
1621            case 29:
1622            case 33:
1623            case 37:
1624            case 41:
1625            case 45: {
1626                Integer extractedIndex = (index - 13) / 4;
1627
1628                opsw[47] = false;
1629                opsw[48] = false; // assume valid turnout address entry
1630                opsw[63] = false;
1631                opsw[64] = false; // assume valid turnout address entry
1632
1633                if (routeA3[extractedIndex].getIsUnused()) {
1634                    value1Address = 2048;
1635                    value1IsUnused = true;
1636                    value1DirectionIsClosed = true;
1637                } else {
1638                    value1DirectionIsClosed = routeA3[extractedIndex].closedRadioButton.isSelected();
1639                    value1IsUnused = false;
1640                    try {
1641                        value1Address = Integer.parseInt(routeA3[extractedIndex].addressField.getText());
1642                    } catch (NumberFormatException e) {
1643                        value1Address = 2048;
1644                        value1IsUnused = true;
1645                    }
1646                }
1647
1648                if (routeA4[extractedIndex].getIsUnused()) {
1649                    value2Address = 2048;
1650                    value2IsUnused = true;
1651                    value2DirectionIsClosed = true;
1652                } else {
1653                    value2DirectionIsClosed = routeA4[extractedIndex].closedRadioButton.isSelected();
1654                    value2IsUnused = false;
1655                    try {
1656                        value2Address = Integer.parseInt(routeA4[extractedIndex].addressField.getText());
1657                    } catch (NumberFormatException e) {
1658                        value2Address = 2048;
1659                        value2IsUnused = true;
1660                    }
1661                }
1662
1663                updateOpSwsOutAddr(value1Address, value1DirectionIsClosed, value1IsUnused,
1664                        value2Address, value2DirectionIsClosed, value2IsUnused);
1665                if (value1IsUnused) {
1666                    opsw[46] = true;
1667                    opsw[47] = true;
1668                    opsw[48] = true; // mark entry as invalid
1669                    routeA3[extractedIndex].unusedRadioButton.setSelected(true);
1670                    routeA3[extractedIndex].unusedRadioButton.repaint();
1671                    routeA3[extractedIndex].setAddress(2048);
1672                    routeA3[extractedIndex].addressField.setText("");
1673                }
1674                if (value2IsUnused) {
1675                    opsw[62] = true;
1676                    opsw[63] = true;
1677                    opsw[64] = true; // mark entry as invalid
1678                    routeA4[extractedIndex].unusedRadioButton.setSelected(true);
1679                    routeA4[extractedIndex].unusedRadioButton.repaint();
1680                    routeA4[extractedIndex].setAddress(2048);
1681                    routeA4[extractedIndex].addressField.setText("");
1682                }
1683                break;
1684            }
1685            case 18:
1686            case 22:
1687            case 26:
1688            case 30:
1689            case 34:
1690            case 38:
1691            case 42:
1692            case 46: {
1693                Integer extractedIndex = (index - 14) / 4;
1694                opsw[47] = false;
1695                opsw[48] = false; // assume valid turnout address entry
1696                opsw[63] = false;
1697                opsw[64] = false; // assume valid turnout address entry
1698
1699                if (routeA5[extractedIndex].getIsUnused()) {
1700                    value1Address = 2048;
1701                    value1IsUnused = true;
1702                    value1DirectionIsClosed = true;
1703                } else {
1704                    value1DirectionIsClosed = routeA5[extractedIndex].closedRadioButton.isSelected();
1705                    value1IsUnused = false;
1706                    try {
1707                        value1Address = Integer.parseInt(routeA5[extractedIndex].addressField.getText());
1708                    } catch (NumberFormatException e) {
1709                        value1Address = 2048;
1710                        value1IsUnused = true;
1711                    }
1712                }
1713
1714                if (routeA6[extractedIndex].getIsUnused()) {
1715                    value2Address = 2048;
1716                    value2IsUnused = true;
1717                    value2DirectionIsClosed = true;
1718                } else {
1719                    value2DirectionIsClosed = routeA6[extractedIndex].closedRadioButton.isSelected();
1720                    value2IsUnused = false;
1721                    try {
1722                        value2Address = Integer.parseInt(routeA6[extractedIndex].addressField.getText());
1723                    } catch (NumberFormatException e) {
1724                        value2Address = 2048;
1725                        value2IsUnused = true;
1726                    }
1727                }
1728
1729                updateOpSwsOutAddr(value1Address, value1DirectionIsClosed, value1IsUnused,
1730                        value2Address, value2DirectionIsClosed, value2IsUnused);
1731                if (value1IsUnused) {
1732                    opsw[46] = true;
1733                    opsw[47] = true;
1734                    opsw[48] = true; // mark entry as invalid
1735                    routeA5[extractedIndex].unusedRadioButton.setSelected(true);
1736                    routeA5[extractedIndex].unusedRadioButton.repaint();
1737                    routeA5[extractedIndex].setAddress(2048);
1738                    routeA5[extractedIndex].addressField.setText("");
1739                }
1740                if (value2IsUnused) {
1741                    opsw[62] = true;
1742                    opsw[63] = true;
1743                    opsw[64] = true; // mark entry as invalid
1744                    routeA6[extractedIndex].unusedRadioButton.setSelected(true);
1745                    routeA6[extractedIndex].unusedRadioButton.repaint();
1746                    routeA6[extractedIndex].setAddress(2048);
1747                    routeA6[extractedIndex].addressField.setText("");
1748                }
1749                break;
1750            }
1751            case 19:
1752            case 23:
1753            case 27:
1754            case 31:
1755            case 35:
1756            case 39:
1757            case 43:
1758            case 47: {
1759                Integer extractedIndex = (index - 15) / 4;
1760
1761                opsw[47] = false;
1762                opsw[48] = false; // assume valid turnout address entry
1763                opsw[63] = false;
1764                opsw[64] = false; // assume valid turnout address entry
1765
1766                if (routeA7[extractedIndex].getIsUnused()) {
1767                    value1Address = 2048;
1768                    value1IsUnused = true;
1769                    value1DirectionIsClosed = true;
1770                } else {
1771                    value1DirectionIsClosed = routeA7[extractedIndex].closedRadioButton.isSelected();
1772                    value1IsUnused = false;
1773                    try {
1774                        value1Address = Integer.parseInt(routeA7[extractedIndex].addressField.getText());
1775                    } catch (NumberFormatException e) {
1776                        value1Address = 2048;
1777                        value1IsUnused = true;
1778                    }
1779                }
1780
1781                if (routeA8[extractedIndex].getIsUnused()) {
1782                    value2Address = 2048;
1783                    value2IsUnused = true;
1784                    value2DirectionIsClosed = true;
1785                } else {
1786                    value2DirectionIsClosed = routeA8[extractedIndex].closedRadioButton.isSelected();
1787                    value2IsUnused = false;
1788                    try {
1789                        value2Address = Integer.parseInt(routeA8[extractedIndex].addressField.getText());
1790                    } catch (NumberFormatException e) {
1791                        value2Address = 2048;
1792                        value2IsUnused = true;
1793                    }
1794                }
1795
1796                updateOpSwsOutAddr(value1Address, value1DirectionIsClosed, value1IsUnused,
1797                        value2Address, value2DirectionIsClosed, value2IsUnused);
1798                if (value1IsUnused) {
1799                    opsw[46] = true;
1800                    opsw[47] = true;
1801                    opsw[48] = true; // mark entry as invalid
1802                    routeA7[extractedIndex].unusedRadioButton.setSelected(true);
1803                    routeA7[extractedIndex].unusedRadioButton.repaint();
1804                    routeA7[extractedIndex].setAddress(2048);
1805                    routeA7[extractedIndex].addressField.setText("");
1806                }
1807                if (value2IsUnused) {
1808                    opsw[62] = true;
1809                    opsw[63] = true;
1810                    opsw[64] = true; // mark entry as invalid
1811                    routeA8[extractedIndex].unusedRadioButton.setSelected(true);
1812                    routeA8[extractedIndex].unusedRadioButton.repaint();
1813                    routeA8[extractedIndex].setAddress(2048);
1814                    routeA8[extractedIndex].addressField.setText("");
1815                }
1816                break;
1817            }
1818            case 48: {
1819                break;
1820            }
1821            default: {
1822                break;
1823            }
1824        }
1825    }
1826
1827    private void resetRouteOperation(Integer routeNumber) {
1828        if ((routeNumber < 1) || (routeNumber > 8)) {
1829            return;
1830        }
1831        routeTop[routeNumber].unusedRadioButton.setSelected(true);
1832        routeTop[routeNumber].setIsUnused();
1833        routeTop[routeNumber].addressField.setText("");
1834
1835        routeA2[routeNumber].setIsUnused();
1836        routeA2[routeNumber].unusedRadioButton.setSelected(true);
1837        routeA2[routeNumber].addressField.setText("");
1838
1839        routeA3[routeNumber].setIsUnused();
1840        routeA3[routeNumber].unusedRadioButton.setSelected(true);
1841        routeA3[routeNumber].addressField.setText("");
1842
1843        routeA4[routeNumber].setIsUnused();
1844        routeA4[routeNumber].unusedRadioButton.setSelected(true);
1845        routeA4[routeNumber].addressField.setText("");
1846
1847        routeA5[routeNumber].setIsUnused();
1848        routeA5[routeNumber].unusedRadioButton.setSelected(true);
1849        routeA5[routeNumber].addressField.setText("");
1850
1851        routeA6[routeNumber].setIsUnused();
1852        routeA6[routeNumber].unusedRadioButton.setSelected(true);
1853        routeA6[routeNumber].addressField.setText("");
1854
1855        routeA7[routeNumber].setIsUnused();
1856        routeA7[routeNumber].unusedRadioButton.setSelected(true);
1857        routeA7[routeNumber].addressField.setText("");
1858
1859        routeA8[routeNumber].setIsUnused();
1860        routeA8[routeNumber].unusedRadioButton.setSelected(true);
1861        routeA8[routeNumber].addressField.setText("");
1862
1863        writeAll();
1864    }
1865
1866    private void unhighlightAllBasicOpSws() {
1867
1868        outputType.setBackground(null);
1869        delayTime.setBackground(null);
1870        outputStates.setBackground(null);
1871        startupDelay.setBackground(null);
1872        staticOutputShutoff.setBackground(null);
1873        commandType.setBackground(null);
1874        routesControl.setBackground(null);
1875        localControlOfOutputsStyle.setBackground(null);
1876        sensorMessageTrigger.setBackground(null);
1877        commandSource.setBackground(null);
1878        output1CrossbuckFlasherCheckBox.setBackground(null);
1879        output2CrossbuckFlasherCheckBox.setBackground(null);
1880        output3CrossbuckFlasherCheckBox.setBackground(null);
1881        output4CrossbuckFlasherCheckBox.setBackground(null);
1882        localSensorType.setBackground(null);
1883    }
1884
1885    private void unhighlightAllRouteEntryFields() {
1886        for (int i = 1; i < 9; ++i) {
1887            routeTop[i].addressField.setBackground(null);
1888            routeA2[i].addressField.setBackground(null);
1889            routeA3[i].addressField.setBackground(null);
1890            routeA4[i].addressField.setBackground(null);
1891            routeA5[i].addressField.setBackground(null);
1892            routeA6[i].addressField.setBackground(null);
1893            routeA7[i].addressField.setBackground(null);
1894            routeA8[i].addressField.setBackground(null);
1895            updateUI();
1896        }
1897    }
1898
1899    private void unhighlightAllOutputEntryFields() {
1900        outAddr1.setBackground(null);
1901        outAddr2.setBackground(null);
1902        outAddr3.setBackground(null);
1903        outAddr4.setBackground(null);
1904    }
1905
1906    @Override
1907    public void message(LocoNetMessage m) {
1908        super.message(m);
1909
1910        if (m.getOpCode() == LnConstants.OPC_LONG_ACK) {
1911            if (((m.getElement(1) == LnConstants.RE_LACK_SPEC_CASE1)
1912                    || (m.getElement(1) == LnConstants.RE_LACK_SPEC_CASE2))
1913                    && (state == 0) && resetRouteButton.isSelected()) {
1914                // Handle DS64 confirmation of OpSw write when action is a DS64
1915                // Board Factory Reset
1916                resetRouteButton.setSelected(false);
1917                resetRouteButton.updateUI();
1918            }
1919        }
1920        if (m.getOpCode() == LnConstants.OPC_SW_REQ) {
1921            int swAddr = (((m.getElement(2) & 0x0f) * 128) + (m.getElement(1) & 0x7f)) + 1;
1922            boolean dir = ((m.getElement(2) & 0x20) == 0x20);
1923            if (swAddr == Integer.parseInt(outAddr1.getText())) {
1924                outState1.setText(dir ? Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateClosed"))
1925                        : Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateThrown")));
1926                outState1.updateUI();
1927            }
1928            if (swAddr == Integer.parseInt(outAddr2.getText())) {
1929                outState2.setText(dir ? Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateClosed"))
1930                        : Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateThrown")));
1931                outState2.updateUI();
1932            }
1933            if (swAddr == Integer.parseInt(outAddr3.getText())) {
1934                outState3.setText(dir ? Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateClosed"))
1935                        : Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateThrown")));
1936                outState3.updateUI();
1937            }
1938            if (swAddr == Integer.parseInt(outAddr4.getText())) {
1939                outState4.setText(dir ? Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateClosed"))
1940                        : Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateThrown")));
1941                outState4.updateUI();
1942            }
1943        } else if ((m.getOpCode() == LnConstants.OPC_MULTI_SENSE) && ((m.getElement(1) & 0x7E) == 0x62)) {
1944            // device identity report
1945            if (m.getElement(3) == 0x03) {
1946                Integer extractedBoardId = 1 + ((m.getElement(1) & 0x1) << 7)
1947                        + (m.getElement(2) & 0x7F);
1948                if (!alreadyKnowThisBoardId(extractedBoardId)) {
1949                    addBoardIdToList(extractedBoardId);
1950                }
1951            }
1952        }
1953    }
1954
1955    /**
1956     * Reset the DS64 board
1957     */
1958    @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD", justification = "Functionality not yet confirmed with hardware; may be useful at a future date.")
1959    private void boardFactoryReset() {
1960
1961        // before proceeding, make sure that the user really wants to go forward
1962        Object[] dialogBoxButtonOptions = {
1963            Bundle.getMessage("ButtonResetToFactoryDefault"),
1964            Bundle.getMessage("ButtonCancel")};
1965        int userReply = JmriJOptionPane.showOptionDialog(this,
1966                Bundle.getMessage("DialogTextBoardResetWarning"),
1967                Bundle.getMessage("WarningTitle"),
1968                JmriJOptionPane.YES_NO_OPTION, JmriJOptionPane.QUESTION_MESSAGE,
1969                null, dialogBoxButtonOptions, dialogBoxButtonOptions[1]);
1970        if ( userReply != JmriJOptionPane.YES_OPTION ) {
1971            factoryResetButton.setSelected(false);
1972            return; // compare only to exactly the value for executing the reset!
1973        }
1974        readAllButton.setEnabled(false);
1975        writeAllButton.setEnabled(false);
1976        resetRouteButton.setEnabled(false);
1977        factoryResetButton.setEnabled(false);
1978
1979        // send OpSw 7 = Closed to this boardId to reset the DS64
1980        //to its factory default settings
1981        // then want to read all OpSws to update the display.
1982        read = false;
1983        isWritingResetOpSw = true;
1984        resetOpSwVal = true;
1985        opsw[7] = true;
1986        updateBoardAddress();
1987        writeOne(7);
1988        boardResetResponseTimer = new javax.swing.Timer(750,
1989                event -> {
1990                    factoryResetButton.setSelected(false);
1991                    factoryResetButton.setEnabled(true);
1992                    readAllButton.setEnabled(true);
1993                    writeAllButton.setEnabled(true);
1994                    resetRouteButton.setEnabled(true);
1995                    updateUI();
1996                }
1997        );
1998        boardResetResponseTimer.start();
1999    }
2000
2001    private final ActionListener routeResetResponseTimerListener = new ActionListener() {
2002        @Override
2003        public void actionPerformed(ActionEvent e) {
2004            log.debug("routeresetresponsetimerlistener state={}, indextoread{}", state, indexToRead);
2005            resetRouteButton.setSelected(false);
2006            readAllButton.setEnabled(true);
2007            writeAllButton.setEnabled(true);
2008            factoryResetButton.setEnabled(true);
2009        }
2010    };
2011
2012    @Override
2013    public void initComponents(LocoNetSystemConnectionMemo memo) {
2014        super.initComponents(memo);
2015        LocoNetMessage m = new LocoNetMessage(6);
2016        m.setElement(0, LnConstants.OPC_MULTI_SENSE);
2017        m.setElement(1, 0x62);
2018        m.setElement(2, 0);
2019        m.setElement(3, 0x70);
2020        m.setElement(4, 0);
2021        memo.getLnTrafficController().sendLocoNetMessage(m);
2022    }
2023
2024    @Override
2025    public void initComponents() {
2026        super.initComponents();
2027        // implements an AbstractBoardProgPanel with three tabs:
2028        //      Outputs tab - configure features most related to DS64 outputs
2029        //      Inputs tab - configure features most related to DS64 inputs
2030        //      Routes tab - configure features related to routes
2031        //          Routes tab has (left side, vertical) sub-tabs, one for each of the 8 routes
2032
2033
2034//        JLabel addrFieldLabel = new JTextLabel(Bundle.getMessage("LabelBoardID"));
2035//        addrField = addressComboBox(getSelectedItem);
2036
2037        String[] outputTypes = {Bundle.getMessage("ComboBoxOutputType0"),
2038            Bundle.getMessage("ComboBoxOutputType1")};
2039        outputTypeLabel = new JLabel(Bundle.getMessage("LabelOutputType"));
2040        outputType = new JComboBox<>(outputTypes); // opSw 1
2041        outputType.setToolTipText(Bundle.getMessage("ToolTipOutputType"));
2042        outputType.addActionListener(basicConfigChangeActionListener);
2043        outputType.setName("1"); // NOI18N
2044
2045        String[] availableDelayTimes = new String[16];
2046        availableDelayTimes[0] = Bundle.getMessage("ComboBoxPulseTime0point1");
2047        availableDelayTimes[1] = Bundle.getMessage("ComboBoxPulseTime0point2");
2048        availableDelayTimes[2] = Bundle.getMessage("ComboBoxPulseTime0point4");
2049        availableDelayTimes[3] = Bundle.getMessage("ComboBoxPulseTime0point6");
2050        availableDelayTimes[4] = Bundle.getMessage("ComboBoxPulseTime0point8");
2051        availableDelayTimes[5] = Bundle.getMessage("ComboBoxPulseTime1point0");
2052        availableDelayTimes[6] = Bundle.getMessage("ComboBoxPulseTime1point2");
2053        availableDelayTimes[7] = Bundle.getMessage("ComboBoxPulseTime1point4");
2054        availableDelayTimes[8] = Bundle.getMessage("ComboBoxPulseTime1point6");
2055        availableDelayTimes[9] = Bundle.getMessage("ComboBoxPulseTime1point8");
2056        availableDelayTimes[10] = Bundle.getMessage("ComboBoxPulseTime2point0");
2057        availableDelayTimes[11] = Bundle.getMessage("ComboBoxPulseTime2point2");
2058        availableDelayTimes[12] = Bundle.getMessage("ComboBoxPulseTime2point4");
2059        availableDelayTimes[13] = Bundle.getMessage("ComboBoxPulseTime2point6");
2060        availableDelayTimes[14] = Bundle.getMessage("ComboBoxPulseTime2point8");
2061        availableDelayTimes[15] = Bundle.getMessage("ComboBoxPulseTime3point0");
2062
2063        delayTimeLabel = new JLabel(Bundle.getMessage("LabelPulseTimeout")); // opSws 2-5
2064        delayTime = new JComboBox<>(availableDelayTimes);
2065        delayTime.setToolTipText(Bundle.getMessage("ToolTipPulseTimeout"));
2066        delayTime.setName("2345"); // NOI18N
2067        delayTime.addActionListener(basicConfigChangeActionListener);
2068
2069        String[] initialOutputStates = {Bundle.getMessage("ComboBoxOutputPowerupType0"),
2070            Bundle.getMessage("ComboBoxOutputPowerupType1")};
2071        outputStatesLabel = new JLabel(Bundle.getMessage("LabelPowerUpOutputActivity"));
2072        outputStates = new JComboBox<>(initialOutputStates);    // opsw 6
2073        outputStates.setToolTipText(Bundle.getMessage("ToolTipOutputStates"));
2074        outputStates.setName("6"); // NOI18N
2075        outputStates.addActionListener(basicConfigChangeActionListener);
2076
2077        String[] startupDelays = {Bundle.getMessage("ComboBoxOutputPowerupDelayType0"),
2078            Bundle.getMessage("ComboBoxOutputPowerupDelayType1")};
2079        startupDelayLabel = new JLabel(Bundle.getMessage("LabelInitialPowerUpDelay"));
2080        startupDelay = new JComboBox<>(startupDelays);  // opsw 8
2081        startupDelay.setToolTipText(Bundle.getMessage("ToolTipStartupDelay"));
2082        startupDelay.setName("8"); // NOI18N
2083        startupDelay.addActionListener(basicConfigChangeActionListener);
2084
2085        String[] staticOutputShutoffs = {Bundle.getMessage("ComboBoxOutputPowerManagementType0"),
2086            Bundle.getMessage("ComboBoxOutputPowerManagementType1")};
2087        staticOutputShutoffLabel = new JLabel(Bundle.getMessage("LabelOutputPowerManagementStyle"));
2088        staticOutputShutoff = new JComboBox<>(staticOutputShutoffs); // opSw 9
2089        staticOutputShutoff.setToolTipText(Bundle.getMessage("ToolTipLabelOutputPowerManagementStyle"));
2090        staticOutputShutoff.setName("9"); // NOI18N
2091        staticOutputShutoff.addActionListener(basicConfigChangeActionListener);
2092
2093        // command sources
2094        String[] commandTypes = {Bundle.getMessage("ComboBoxCommandsRecognizedFromType0"),
2095            Bundle.getMessage("ComboBoxCommandsRecognizedFromType1")};
2096        commandTypeLabel = new JLabel(Bundle.getMessage("LabelAcceptedSwitchCommandTypes"));
2097        commandType = new JComboBox<>(commandTypes); //opSw 10
2098        commandType.setToolTipText(Bundle.getMessage("ToolTipLabelAcceptedSwitchCommandTypes"));
2099        commandType.setName("10"); // NOI18N
2100        commandType.addActionListener(basicConfigChangeActionListener);
2101
2102        String[] commandSources = {Bundle.getMessage("ComboBoxCommandSourceType0"),
2103            Bundle.getMessage("ComboBoxCommandSourceType1")};
2104        commandSourceLabel = new JLabel(Bundle.getMessage("LabelAcceptSwitchCommandsFrom"));
2105        commandSource = new JComboBox<>(commandSources); // opSw14
2106        commandSource.setToolTipText(Bundle.getMessage("ToolTipCommandSource"));
2107        commandSource.setName("14"); // NOI18N
2108        commandSource.addActionListener(basicConfigChangeActionListener);
2109
2110        // Crossbuck Flasher controls
2111        output1CrossbuckFlasherCheckBox = new JCheckBox(Bundle.getMessage("CheckBoxOutputXCrossbuck", 1));
2112        output1CrossbuckFlasherCheckBox.setToolTipText(Bundle.getMessage("ToolTipCheckBoxOutput1Crossbuck"));
2113        output1CrossbuckFlasherCheckBox.setName("17"); // NOI18N
2114        output1CrossbuckFlasherCheckBox.addActionListener(basicConfigChangeActionListener);
2115        // output 2
2116        output2CrossbuckFlasherCheckBox = new JCheckBox(Bundle.getMessage("CheckBoxOutputXCrossbuck", 2));
2117        output2CrossbuckFlasherCheckBox.setToolTipText(Bundle.getMessage("ToolTipCheckBoxOutput2Crossbuck"));
2118        output2CrossbuckFlasherCheckBox.setName("18"); // NOI18N
2119        output2CrossbuckFlasherCheckBox.addActionListener(basicConfigChangeActionListener);
2120        // output 3
2121        output3CrossbuckFlasherCheckBox = new JCheckBox(Bundle.getMessage("CheckBoxOutputXCrossbuck", 3));
2122        output3CrossbuckFlasherCheckBox.setToolTipText(Bundle.getMessage("ToolTipCheckBoxOutput3Crossbuck"));
2123        output3CrossbuckFlasherCheckBox.setName("19"); // NOI18N
2124        output3CrossbuckFlasherCheckBox.addActionListener(basicConfigChangeActionListener);
2125        // output 4
2126        output4CrossbuckFlasherCheckBox = new JCheckBox(Bundle.getMessage("CheckBoxOutputXCrossbuck", 4));
2127        output4CrossbuckFlasherCheckBox.setToolTipText(Bundle.getMessage("ToolTipCheckBoxOutput4Crossbuck"));
2128        output4CrossbuckFlasherCheckBox.setName("20"); // NOI18N
2129        output4CrossbuckFlasherCheckBox.addActionListener(basicConfigChangeActionListener);
2130
2131        // DS64 routes
2132        String[] routesControls = {Bundle.getMessage("ComboBoxEntryRoutesOption0"),
2133            Bundle.getMessage("ComboBoxEntryRoutesOption1"),
2134            Bundle.getMessage("ComboBoxEntryRoutesOption2"),
2135            Bundle.getMessage("ComboBoxEntryRoutesOption3")};
2136        routesControlLabel = new JLabel(Bundle.getMessage("LabelTriggerDs64Routes"));
2137        routesControl = new JComboBox<>(routesControls);    // opSws 11, 16
2138        routesControl.setToolTipText(Bundle.getMessage("ToolTipLabelRouteControlOptions"));
2139        routesControl.setName("1116"); // NOI18N
2140        routesControl.addActionListener(basicConfigChangeActionListener);
2141
2142        // local input controls
2143        String[] localControlOfOutputsStyles = {
2144            Bundle.getMessage("ComboBoxInputsControlOutputsType0"),
2145            Bundle.getMessage("ComboBoxInputsControlOutputsType1"),
2146            Bundle.getMessage("ComboBoxInputsControlOutputsType2"),
2147            Bundle.getMessage("comboboxInputsControlOutputsType3")};
2148        localControlOfOutputsStyleLabel = new JLabel(Bundle.getMessage("LabelLocalInputsControlOutputs"));
2149        localControlOfOutputsStyle = new JComboBox<>(localControlOfOutputsStyles); // opSw12
2150        localControlOfOutputsStyle.setToolTipText(Bundle.getMessage("ToolTipLocalInputsControl"));
2151        localControlOfOutputsStyle.setName("1215"); // NOI18N
2152        localControlOfOutputsStyle.addActionListener(basicConfigChangeActionListener);
2153
2154        String[] sensorMessageTriggers = {Bundle.getMessage("ComboBoxInputsCauseMessagesType0"),
2155            Bundle.getMessage("ComboBoxInputsCauseMessagesType1")};
2156        sensorMessageTriggerLabel = new JLabel(Bundle.getMessage("LabelBetweenForMessageTypeSent"));
2157        sensorMessageTrigger = new JComboBox<>(sensorMessageTriggers); // opSw13
2158        sensorMessageTrigger.setToolTipText(Bundle.getMessage("ToolTipSensorMessageTrigger"));
2159        sensorMessageTrigger.setName("13"); // NOI18N
2160        sensorMessageTrigger.addActionListener(basicConfigChangeActionListener);
2161
2162        String[] localSensorTypes = {Bundle.getMessage("ComboBoxSensorMessageTypeSentType0"),
2163            Bundle.getMessage("ComboBoxSensorMessageTypeSentType1")};
2164        localSensorType = new JComboBox<>(localSensorTypes); // opSw21
2165        localSensorType.setToolTipText(Bundle.getMessage("ToolTipLocalSensorsType"));
2166        localSensorType.setName("21"); // NOI18N
2167        localSensorType.addActionListener(basicConfigChangeActionListener);
2168
2169        factoryResetButton = new JToggleButton(Bundle.getMessage("ButtonResetToFactoryDefault"));
2170        factoryResetButton.setToolTipText(Bundle.getMessage("ToolTipButtonResetToFactoryDefault"));
2171        factoryResetButton.addActionListener(
2172                event -> {
2173                    readAllButton.setEnabled(false);
2174                    writeAllButton.setEnabled(false);
2175                    resetRouteButton.setEnabled(false);
2176                    boardFactoryReset();
2177                }
2178        );
2179        routesTabbedPane = new JTabbedPane();
2180
2181        routePanel = new JPanel[9];
2182        routeTop = new SimpleTurnoutStateEntry[9];
2183        routeA2 = new SimpleTurnoutStateEntry[9];
2184        routeA3 = new SimpleTurnoutStateEntry[9];
2185        routeA4 = new SimpleTurnoutStateEntry[9];
2186        routeA5 = new SimpleTurnoutStateEntry[9];
2187        routeA6 = new SimpleTurnoutStateEntry[9];
2188        routeA7 = new SimpleTurnoutStateEntry[9];
2189        routeA8 = new SimpleTurnoutStateEntry[9];
2190
2191        resetRouteButton = new JToggleButton(Bundle.getMessage("ButtonResetRoute"));
2192        resetRouteButton.setToolTipText(Bundle.getMessage("ToolTipButtonResetRoute"));
2193        resetRouteButton.setEnabled(false);
2194        resetRouteButton.setVisible(false);
2195
2196        JPanel addressingPanel = provideAddressing(" "); // create read/write buttons, address
2197        readAllButton.setPreferredSize(null);
2198        readAllButton.setText(Bundle.getMessage("ButtonReadFullSheet"));
2199        readAllButton.setToolTipText(Bundle.getMessage("ToolTipButtonReadFullSheet"));
2200
2201        writeAllButton.setPreferredSize(null);
2202        writeAllButton.setText(Bundle.getMessage("ButtonWriteFullSheet"));
2203        writeAllButton.setToolTipText(Bundle.getMessage("ToolTipButtonWriteFullSheet"));
2204
2205        // make both buttons a little bit bigger, with identical (preferred) sizes
2206        // (width increased because some computers/displays trim the button text)
2207        java.awt.Dimension d = writeAllButton.getPreferredSize();
2208        int w = d.width;
2209        d = readAllButton.getPreferredSize();
2210        if (d.width > w) {
2211            w = d.width;
2212        }
2213        writeAllButton.setPreferredSize(new java.awt.Dimension((int) (w * 1.1), d.height));
2214        readAllButton.setPreferredSize(new java.awt.Dimension((int) (w * 1.1), d.height));
2215
2216        addressingPanel.add(resetRouteButton);
2217        int indexOfTargetBoardAddress = 0;
2218
2219        addressComboBox = new JComboBox<>();
2220        for (Integer index = 0; index < boardNumsEntryValue.size(); ++index) {
2221            if (boardNumsEntryValue.get(index) == origAccessBoardNum) {
2222                origAccessBoardNum = -1;
2223                indexOfTargetBoardAddress = index;
2224            }
2225            addressComboBox.addItem(boardNumsEntryValue.get(index));
2226        }
2227
2228        addressComboBox.setSelectedIndex(indexOfTargetBoardAddress);
2229        addressingPanel.add(addressComboBox, 1);
2230        addressingPanel.getComponent(2).setVisible(false);
2231        addressComboBox.setEditable(true);
2232
2233        appendLine(addressingPanel);  // add read/write buttons, address
2234
2235        generalTabbedPane = new JTabbedPane();
2236        generalPanel = new JPanel();
2237        generalPanel.setLayout(new BoxLayout(generalPanel, BoxLayout.Y_AXIS));
2238        generalPanel.setName("Basic Settings"); // NOI18N
2239
2240        JPanel allOutputControls = new JPanel();
2241        allOutputControls.setLayout(new BoxLayout(allOutputControls, BoxLayout.Y_AXIS));
2242        javax.swing.border.TitledBorder allOutputControlsTitleBorder;
2243        javax.swing.border.Border blackline;
2244        blackline = javax.swing.BorderFactory.createLineBorder(java.awt.Color.black);
2245        allOutputControlsTitleBorder = javax.swing.BorderFactory.createTitledBorder(blackline,
2246                Bundle.getMessage("TitledBorderLabelOutputControls"));
2247        allOutputControls.setBorder(allOutputControlsTitleBorder);
2248
2249        JPanel outputTypePanel = new JPanel();
2250        outputTypePanel.setLayout(new FlowLayout());
2251        outputTypePanel.add(outputTypeLabel);
2252        outputTypePanel.add(outputType);
2253        allOutputControls.add(outputTypePanel);
2254
2255        JPanel delayTimePanel = new JPanel();
2256        delayTimePanel.setLayout(new FlowLayout());
2257        delayTimePanel.add(delayTimeLabel);
2258        delayTimePanel.add(delayTime);
2259        allOutputControls.add(delayTimePanel);
2260
2261        JPanel outputStatePanel = new JPanel();
2262        outputStatePanel.setLayout(new FlowLayout());
2263        outputStatePanel.add(outputStatesLabel);
2264        outputStatePanel.add(outputStates);
2265        allOutputControls.add(outputStatePanel);
2266
2267        JPanel startupDelayPanel = new JPanel();
2268        startupDelayPanel.setLayout(new FlowLayout());
2269        startupDelayPanel.add(startupDelayLabel);
2270        startupDelayPanel.add(startupDelay);
2271        allOutputControls.add(startupDelayPanel);
2272
2273        JPanel staticOutputShutoffPanel = new JPanel();
2274        staticOutputShutoffPanel.setLayout(new FlowLayout());
2275        staticOutputShutoffPanel.add(staticOutputShutoffLabel);
2276        staticOutputShutoffPanel.add(staticOutputShutoff);
2277        allOutputControls.add(staticOutputShutoffPanel);
2278
2279        JPanel crossingGateControls = new JPanel(new java.awt.GridLayout(2, 2));
2280        crossingGateControls.add(output1CrossbuckFlasherCheckBox);
2281        crossingGateControls.add(output3CrossbuckFlasherCheckBox); // display output 3 box to the right of output 1 box
2282        crossingGateControls.add(output2CrossbuckFlasherCheckBox); // display output 2 box below output 1 box
2283        crossingGateControls.add(output4CrossbuckFlasherCheckBox);
2284        allOutputControls.add(crossingGateControls);
2285
2286        generalPanel.add(allOutputControls);
2287
2288        // command sources
2289        JPanel ds64CommandSourcesPanel = new JPanel();
2290        ds64CommandSourcesPanel.setLayout(new BoxLayout(ds64CommandSourcesPanel, BoxLayout.Y_AXIS));
2291        javax.swing.border.TitledBorder ds64CommandSourcesTitleBorder;
2292        ds64CommandSourcesTitleBorder = javax.swing.BorderFactory.createTitledBorder(blackline,
2293                Bundle.getMessage("TitledBorderLabelCommandSources"));
2294        ds64CommandSourcesPanel.setBorder(ds64CommandSourcesTitleBorder);
2295
2296        JPanel commandTypePanel = new JPanel();
2297        commandTypePanel.setLayout(new FlowLayout());
2298        commandTypePanel.add(commandTypeLabel);
2299        commandTypePanel.add(commandType);
2300        ds64CommandSourcesPanel.add(commandTypePanel);
2301
2302        JPanel commandSourcePanel = new JPanel();
2303        commandSourcePanel.setLayout(new FlowLayout());
2304        commandSourcePanel.add(commandSourceLabel);
2305        commandSourcePanel.add(commandSource);
2306        ds64CommandSourcesPanel.add(commandSourcePanel);
2307
2308        generalPanel.add(ds64CommandSourcesPanel);
2309
2310        // DS64 routes
2311        JPanel localRoutesPanel = new JPanel();
2312        localRoutesPanel.setLayout(new BoxLayout(localRoutesPanel, BoxLayout.Y_AXIS));
2313        javax.swing.border.TitledBorder localRoutesTitleBorder;
2314        localRoutesTitleBorder = javax.swing.BorderFactory.createTitledBorder(blackline,
2315                Bundle.getMessage("TitledBorderLabelRoutes"));
2316        localRoutesPanel.setBorder(localRoutesTitleBorder);
2317
2318        JPanel routesControlPanel = new JPanel();
2319        routesControlPanel.setLayout(new FlowLayout());
2320        routesControlPanel.add(routesControlLabel);
2321        routesControlPanel.add(routesControl);
2322        localRoutesPanel.add(routesControlPanel);
2323
2324        generalPanel.add(localRoutesPanel);
2325
2326        // local input controls
2327        localInputControlsPanel = new JPanel();
2328        localInputControlsPanel.setLayout(new BoxLayout(localInputControlsPanel, BoxLayout.Y_AXIS));
2329        javax.swing.border.TitledBorder localInputControlsTitleBorder;
2330        localInputControlsTitleBorder = javax.swing.BorderFactory.createTitledBorder(blackline,
2331                Bundle.getMessage("TitledBorderLabelLocalInputControls"));
2332        localInputControlsPanel.setBorder(localInputControlsTitleBorder);
2333
2334        JPanel localControlOfOutputsStylePanel = new JPanel(new FlowLayout());
2335        localControlOfOutputsStylePanel.add(localControlOfOutputsStyleLabel);
2336        localControlOfOutputsStylePanel.add(localControlOfOutputsStyle);
2337        localInputControlsPanel.add(localControlOfOutputsStylePanel);
2338
2339        sensorMessageTriggerPanel = new JPanel(new FlowLayout());
2340        sensorMessageTriggerPanel.add(localSensorType);
2341        sensorMessageTriggerPanel.add(sensorMessageTriggerLabel);
2342        sensorMessageTriggerPanel.add(sensorMessageTrigger);
2343        localInputControlsPanel.add(sensorMessageTriggerPanel);
2344
2345        generalPanel.add(localInputControlsPanel);
2346
2347        generalPanel.add(new JSeparator());
2348        JPanel factoryResetButtonPanel = new JPanel();
2349        factoryResetButtonPanel.add(factoryResetButton);
2350        generalPanel.add(factoryResetButtonPanel);
2351
2352        generalTabbedPane.addTab(Bundle.getMessage("TabTextBasicSettings"), null,
2353                generalPanel, Bundle.getMessage("TabToolTipBasicSettings"));
2354
2355        // opsws panel
2356        opswsPanel = new JPanel();
2357
2358        opswsValues = new JPanel();
2359        opswsValues.setLayout(new BoxLayout(opswsValues, BoxLayout.Y_AXIS));
2360        javax.swing.border.TitledBorder opswsValuesTitleBorder;
2361        opswsValuesTitleBorder = javax.swing.BorderFactory.createTitledBorder(blackline,
2362                Bundle.getMessage("TitledBorderLabelOpSws"));
2363        opswsValues.setBorder(opswsValuesTitleBorder);
2364
2365        opswsPanel.setLayout(new BoxLayout(opswsPanel, BoxLayout.Y_AXIS));
2366        JPanel innerPanel;
2367        ButtonGroup[] g = new ButtonGroup[22];
2368        opswThrown = new JRadioButtonWithInteger[22];
2369        opswClosed = new JRadioButtonWithInteger[22];
2370        for (int i = 1; i <= 21; i++) {
2371            if (i != 7) {
2372                log.debug("Creating entry for OpSw {}", i);
2373                innerPanel = new JPanel(new FlowLayout());
2374                innerPanel.add(new JLabel("OpSw " + i)); // NOI18N
2375                opswThrown[i] = new JRadioButtonWithInteger(i, Bundle.getMessage("TurnoutStateThrown"));
2376                opswClosed[i] = new JRadioButtonWithInteger(i, Bundle.getMessage("TurnoutStateClosed"));
2377                g[i] = new ButtonGroup();
2378                g[i].add(opswThrown[i]);
2379                g[i].add(opswClosed[i]);
2380                innerPanel.add(opswThrown[i]);
2381                innerPanel.add(opswClosed[i]);
2382                opswsPanel.add(innerPanel);
2383//                opswsPanel.add(new JSeparator());
2384                opswThrown[i].addItemListener(event -> {
2385                    if (event.getSource().getClass() == JRadioButtonWithInteger.class) {
2386                        JRadioButtonWithInteger source = ((JRadioButtonWithInteger) (event.getSource()));
2387                        int ind = source.index;
2388                        boolean st = (event.getStateChange() == ItemEvent.DESELECTED);
2389                        log.debug("ItemEventListener Opsw values: {} thrown radio button event: {} {}.", ind, st, st ? "Closed" : "Thrown"); // NOI18N
2390                        opsw[ind] = st;
2391                        copyOpswToBasic();
2392                    }
2393                });
2394            }
2395        }
2396        opswsValues.add(opswsPanel);
2397        opswsScrollPane = new JScrollPane(opswsValues);
2398        opswsScrollPane.setPreferredSize(new java.awt.Dimension(180, 200));
2399        opswsScrollPane.setName("Simple OpSws"); // NOI18N
2400
2401        generalTabbedPane.addTab(Bundle.getMessage("TabTextOpSwValues"), null,
2402                opswsScrollPane, Bundle.getMessage("TabToolTipOpSwValues"));
2403
2404        outputAddrsPanel = new JPanel();
2405        outputAddrsPanel.setLayout(new BoxLayout(outputAddrsPanel, BoxLayout.Y_AXIS));
2406
2407        JPanel p = new JPanel();
2408
2409        p.setLayout(new FlowLayout());
2410        p.add(new JLabel(Bundle.getMessage("LabelCautionReadingWritingCanCauseOutputChanges")));
2411        outputAddrsPanel.add(p);
2412
2413        p = new JPanel();
2414        p.setLayout(new FlowLayout());
2415        p.add(new JLabel(Bundle.getMessage("LabelTextOutputX", 1)));
2416        outAddr1 = new ValidatedTextField(5, false, 1, 2048, Bundle.getMessage("ErrorTextNonBlankAddressInvalid"));
2417        outState1 = new JLabel(Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateUnknown")));
2418        p.add(outAddr1);
2419        p.add(outState1);
2420        outputAddrsPanel.add(p);
2421
2422        p = new JPanel();
2423        p.setLayout(new FlowLayout());
2424        p.add(new JLabel(Bundle.getMessage("LabelTextOutputX", 2)));
2425        outAddr2 = new ValidatedTextField(5, false, 1, 2048, Bundle.getMessage("ErrorTextNonBlankAddressInvalid"));
2426        outState2 = new JLabel(Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateUnknown")));
2427        p.add(outAddr2);
2428        p.add(outState2);
2429        outputAddrsPanel.add(p);
2430
2431        p = new JPanel();
2432        p.setLayout(new FlowLayout());
2433        p.add(new JLabel(Bundle.getMessage("LabelTextOutputX", 3)));
2434        outAddr3 = new ValidatedTextField(5, false, 1, 2048, Bundle.getMessage("ErrorTextNonBlankAddressInvalid"));
2435        outState3 = new JLabel(Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateUnknown")));
2436        p.add(outAddr3);
2437        p.add(outState3);
2438        outputAddrsPanel.add(p);
2439
2440        p = new JPanel();
2441        p.setLayout(new FlowLayout());
2442        p.add(new JLabel(Bundle.getMessage("LabelTextOutputX", 4)));
2443        outAddr4 = new ValidatedTextField(5, false, 1, 2048, Bundle.getMessage("ErrorTextNonBlankAddressInvalid"));
2444        outState4 = new JLabel(Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateUnknown")));
2445        p.add(outAddr4);
2446        p.add(outState4);
2447        outputAddrsPanel.add(p);
2448        outputAddrsPanel.add(new JSeparator());
2449
2450        p = new JPanel();
2451        p.setLayout(new FlowLayout());
2452        p.add(new JLabel(Bundle.getMessage("LabelOutputsTabSensorNotes")));
2453        outputAddrsPanel.add(p);
2454
2455        generalTabbedPane.addTab(Bundle.getMessage("TabTextOutputAddrs"), null,
2456                outputAddrsPanel, Bundle.getMessage("TabToolTipOutputAddrs"));
2457
2458        routePanel[0] = new JPanel();
2459
2460        routesTabbedPane.setTabPlacement(JTabbedPane.LEFT);
2461        // create route panels (one tab each for each of 8 routes)
2462        for (int i = 1; i <= 8; ++i) {
2463            routePanel[i] = new JPanel();
2464            routePanel[i].setLayout(new BoxLayout(routePanel[i], BoxLayout.Y_AXIS));
2465
2466            routePanel[i].add(new JLabel(Bundle.getMessage("TabTextSpecificRoute",
2467                    Integer.toString(i))));
2468            routePanel[i].add(new JSeparator());
2469            JPanel q = new JPanel(new FlowLayout());
2470            q.add(new JLabel(Bundle.getMessage("LabelCautionReadingWritingCanCauseOutputChanges")));
2471            routePanel[i].add(q);
2472            routePanel[i].add(new JSeparator());
2473            routeTop[i] = new SimpleTurnoutStateEntry(2048, false, true);
2474            routeA2[i] = new SimpleTurnoutStateEntry(2048, false, true);
2475            routeA3[i] = new SimpleTurnoutStateEntry(2048, false, true);
2476            routeA4[i] = new SimpleTurnoutStateEntry(2048, false, true);
2477            routeA5[i] = new SimpleTurnoutStateEntry(2048, false, true);
2478            routeA6[i] = new SimpleTurnoutStateEntry(2048, false, true);
2479            routeA7[i] = new SimpleTurnoutStateEntry(2048, false, true);
2480            routeA8[i] = new SimpleTurnoutStateEntry(2048, false, true);
2481
2482            routePanel[i].add(routeTop[i].createEntryPanel(Bundle.getMessage("LabelTextRouteXSpecificTurnout",
2483                    Bundle.getMessage("LabelTextRouteXTopTurnout"))));
2484            routePanel[i].add(routeA2[i].createEntryPanel(Bundle.getMessage("LabelTextRouteXSpecificTurnout", 2)));
2485            routePanel[i].add(routeA3[i].createEntryPanel(Bundle.getMessage("LabelTextRouteXSpecificTurnout", 3)));
2486            routePanel[i].add(routeA4[i].createEntryPanel(Bundle.getMessage("LabelTextRouteXSpecificTurnout", 4)));
2487            routePanel[i].add(routeA5[i].createEntryPanel(Bundle.getMessage("LabelTextRouteXSpecificTurnout", 5)));
2488            routePanel[i].add(routeA6[i].createEntryPanel(Bundle.getMessage("LabelTextRouteXSpecificTurnout", 6)));
2489            routePanel[i].add(routeA7[i].createEntryPanel(Bundle.getMessage("LabelTextRouteXSpecificTurnout", 7)));
2490            routePanel[i].add(routeA8[i].createEntryPanel(Bundle.getMessage("LabelTextRouteXSpecificTurnout", 8)));
2491
2492            routesTabbedPane.addTab(
2493                    Bundle.getMessage("TabTextSpecificRoute", Integer.toString(i)),
2494                    null,
2495                    routePanel[i],
2496                    Bundle.getMessage("TabToolTipSpecificRoute", Integer.toString(i))
2497            );
2498        }
2499
2500        generalTabbedPane.addTab(Bundle.getMessage("TabTextRoutes"),
2501                null, routesTabbedPane,
2502                Bundle.getMessage("ToolTipTabTextRoutes"));
2503        resetRouteButton.addActionListener(
2504                event -> {
2505                    readAllButton.setEnabled(false);
2506                    writeAllButton.setEnabled(false);
2507                    factoryResetButton.setEnabled(false);
2508
2509                    Integer routeNumber = 0;
2510                    if (((JTabbedPane) generalTabbedPane.getSelectedComponent()) != routesTabbedPane) {
2511                        return;
2512                    }
2513                    if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[1]) {
2514                        routeNumber = 1;
2515                    } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[2]) {
2516                        routeNumber = 2;
2517                    } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[3]) {
2518                        routeNumber = 3;
2519                    } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[4]) {
2520                        routeNumber = 4;
2521                    } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[5]) {
2522                        routeNumber = 5;
2523                    } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[6]) {
2524                        routeNumber = 6;
2525                    } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[7]) {
2526                        routeNumber = 7;
2527                    } else if (((JPanel) routesTabbedPane.getSelectedComponent()) == routePanel[8]) {
2528                        routeNumber = 8;
2529                    }
2530                    if (routeNumber != 0) {
2531                        // before proceeding, make sure that the user really wants to go forward
2532                        Object[] dialogBoxButtonOptions = {
2533                            Bundle.getMessage("ButtonResetRouteN", routeNumber),
2534                            Bundle.getMessage("ButtonCancel")};
2535                        int userReply = JmriJOptionPane.showOptionDialog(this,
2536                                Bundle.getMessage("DialogTextClearRouteWarning", routeNumber),
2537                                Bundle.getMessage("WarningTitle"),
2538                                JmriJOptionPane.YES_NO_OPTION, JmriJOptionPane.QUESTION_MESSAGE,
2539                                null, dialogBoxButtonOptions, dialogBoxButtonOptions[1]);
2540                        if ( userReply != JmriJOptionPane.YES_OPTION ) {
2541                            resetRouteButton.setSelected(false);
2542                            return; // compare only to exactly the value for executing the "clear route" operation!
2543                        }
2544
2545                        resetRouteOperation(routeNumber);
2546                    }
2547                    readAllButton.setEnabled(true);
2548                    writeAllButton.setEnabled(true);
2549                    factoryResetButton.setEnabled(true);
2550                    resetRouteButton.setSelected(false);
2551                }
2552        );
2553
2554        appendLine(generalTabbedPane);
2555        JPanel statusPanel = new JPanel();
2556        setStatus(" ");
2557        statusPanel.add(new JSeparator());
2558        statusPanel.add(provideStatusLine());
2559        statusPanel.add(new JSeparator());
2560        appendLine(statusPanel);
2561
2562        setTypeWord(0x73);  // configure DS64 message type
2563        opsw[7] = false;
2564        operationType = OpSwOpType.BasicsRead;
2565
2566        routesTabbedPane.addChangeListener(new ChangeListener() {
2567            // This method is called whenever the selected tab changes
2568
2569            String route1TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(1));
2570            String route2TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(2));
2571            String route3TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(3));
2572            String route4TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(4));
2573            String route5TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(5));
2574            String route6TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(6));
2575            String route7TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(7));
2576            String route8TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(8));
2577
2578            @Override
2579            public void stateChanged(ChangeEvent evt) {
2580                unhighlightAllBasicOpSws();
2581                unhighlightAllOutputEntryFields();
2582                unhighlightAllRouteEntryFields();
2583
2584                String activeTabTitle = routesTabbedPane.getTitleAt(routesTabbedPane.getSelectedIndex());
2585
2586                if ((activeTabTitle.equals(route1TabText))
2587                        || (activeTabTitle.equals(route2TabText))
2588                        || (activeTabTitle.equals(route3TabText))
2589                        || (activeTabTitle.equals(route4TabText))
2590                        || (activeTabTitle.equals(route5TabText))
2591                        || (activeTabTitle.equals(route6TabText))
2592                        || (activeTabTitle.equals(route7TabText))
2593                        || (activeTabTitle.equals(route8TabText))) {
2594                    resetRouteButton.setVisible(true);
2595                    resetRouteButton.setEnabled(true);
2596                    resetRouteButton.updateUI();
2597                    readAllButton.setSelected(false);
2598                    readAllButton.updateUI();
2599                    updateUI();
2600                }
2601            }
2602
2603        });
2604
2605        generalTabbedPane.addChangeListener(new ChangeListener() {
2606            // This method is called whenever the selected tab changes
2607            String route1TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(1));
2608            String route2TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(2));
2609            String route3TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(3));
2610            String route4TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(4));
2611            String route5TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(5));
2612            String route6TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(6));
2613            String route7TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(7));
2614            String route8TabText = Bundle.getMessage("TabTextSpecificRoute", Integer.toString(8));
2615            String outputsTabText = Bundle.getMessage("TabTextOutputAddrs");
2616
2617            @Override
2618            public void stateChanged(ChangeEvent evt) {
2619                String activeTabTitle;
2620                unhighlightAllBasicOpSws();
2621                unhighlightAllOutputEntryFields();
2622                unhighlightAllRouteEntryFields();
2623
2624                activeTabTitle = generalTabbedPane.getTitleAt(generalTabbedPane.getSelectedIndex());
2625                JTabbedPane pane = (JTabbedPane) evt.getSource();
2626
2627                // Get current tab
2628                if ((activeTabTitle.equals(Bundle.getMessage("TabTextRoutes")))) {
2629                    activeTabTitle = routesTabbedPane.getTitleAt(routesTabbedPane.getSelectedIndex());
2630                    if ((activeTabTitle.equals(route1TabText))
2631                            || (activeTabTitle.equals(route2TabText))
2632                            || (activeTabTitle.equals(route3TabText))
2633                            || (activeTabTitle.equals(route4TabText))
2634                            || (activeTabTitle.equals(route5TabText))
2635                            || (activeTabTitle.equals(route6TabText))
2636                            || (activeTabTitle.equals(route7TabText))
2637                            || (activeTabTitle.equals(route8TabText))) {
2638                        resetRouteButton.setEnabled(true);
2639                        resetRouteButton.setVisible(true);
2640                        readAllButton.setEnabled(true);
2641                        writeAllButton.setSelected(false);
2642                        readAllButton.setSelected(false);
2643                        writeAllButton.setEnabled(true);
2644                        factoryResetButton.setEnabled(true);
2645                        routesTabbedPane.updateUI();
2646                        updateUI();
2647                    } else {
2648                        routesTabbedPane.setSelectedIndex(0);
2649                        routesTabbedPane.updateUI();
2650                    }
2651                } else if (activeTabTitle.equals(outputsTabText)) {
2652                    resetRouteButton.setEnabled(false);
2653                    resetRouteButton.setVisible(false);
2654                    readAllButton.setEnabled(true);
2655                    writeAllButton.setSelected(false);
2656                    readAllButton.setSelected(false);
2657                    writeAllButton.setEnabled(true);
2658                    readAllButton.updateUI();
2659                    updateUI();
2660                } else {
2661                    readAllButton.setEnabled(true);
2662                    writeAllButton.setEnabled(true);
2663                    writeAllButton.setSelected(false);
2664                    readAllButton.setSelected(false);
2665                    resetRouteButton.setVisible(false);
2666                    resetRouteButton.setEnabled(false);
2667                    readAllButton.updateUI();
2668                    updateUI();
2669                }
2670                Container c = pane.getRootPane().getParent();
2671                c.setPreferredSize(null);
2672                if (c instanceof Window) {
2673                    ((Window) c).pack();
2674                }
2675            }
2676
2677        });
2678
2679        responseTimer.addActionListener(routeResetResponseTimerListener);
2680        commandType.setToolTipText(Bundle.getMessage("ToolTipLabelAcceptedSwitchCommandTypes"));
2681        updateBasicOpSwTab();
2682
2683        panelToScroll();
2684
2685    }
2686
2687    @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "DLS_DEAD_LOCAL_STORE", justification = "Cannot catch an exception without grabbing the exception, but we don't do anything with the exception details.")
2688    private void updateGuiFromOpSws49_64() {
2689        Integer readValue;
2690        boolean isUsed = true;
2691
2692        readValue = 0;
2693        for (int i = 60; i >= 49; i--) {
2694            if (i != 56) {
2695                readValue = (readValue << 1) + (opsw[i] ? 1 : 0);
2696            }
2697        }
2698        readValue++; // account for physical/user numbering difference
2699
2700        String readValueString = readValue.toString();
2701        if ((opsw[63] == true) && (opsw[64] == true)) {
2702            readValueString = "";
2703            isUsed = false;
2704        }
2705        boolean direction = opsw[62];
2706
2707        switch (indexToRead) {
2708            case 0: {
2709                // have read value for output2 - update local storage
2710                outAddr2.setText(Integer.toString(readValue));
2711                outAddr2.setLastQueriedValue(outAddr2.getText());
2712                outState2.setText(direction
2713                        ? Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateClosed"))
2714                        : Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateThrown")));
2715                break;
2716            }
2717            case 1: {
2718                // have read value for output4 - update local storage
2719                outAddr4.setText(Integer.toString(readValue));
2720                outAddr4.setLastQueriedValue(outAddr4.getText());
2721                outState4.setText(direction
2722                        ? Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateClosed"))
2723                        : Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateThrown")));
2724                break;
2725            }
2726            case 16:
2727            case 20:
2728            case 24:
2729            case 28:
2730            case 32:
2731            case 36:
2732            case 40:
2733            case 44: {
2734                // have a read value for Route n - update local storage
2735                Integer effectiveIndex = (indexToRead - 12) / 4;
2736
2737                if (isUsed == false) {
2738                    routeA2[effectiveIndex].setIsUnused();
2739                    routeA2[effectiveIndex].addressField.setText("");
2740                    routeA2[effectiveIndex].unusedRadioButton.setSelected(true);
2741                } else {
2742                    routeA2[effectiveIndex].setAddress(readValue);
2743                    routeA2[effectiveIndex].addressField.setText(readValueString);
2744                    routeA2[effectiveIndex].addressField.setLastQueriedValue(readValueString);
2745                    if (opsw[62] == true) {
2746                        routeA2[effectiveIndex].closedRadioButton.setSelected(true);
2747                    } else {
2748                        routeA2[effectiveIndex].thrownRadioButton.setSelected(true);
2749                    }
2750                }
2751                break;
2752            }
2753            case 17:
2754            case 21:
2755            case 25:
2756            case 29:
2757            case 33:
2758            case 37:
2759            case 41:
2760            case 45: {
2761                // have a read value for Route n - update local storage
2762                Integer effectiveIndex = (indexToRead - 13) / 4;
2763                if (isUsed == false) {
2764                    routeA4[effectiveIndex].setIsUnused();
2765                    routeA4[effectiveIndex].addressField.setText("");
2766                    routeA4[effectiveIndex].unusedRadioButton.setSelected(true);
2767                } else {
2768                    routeA4[effectiveIndex].setAddress(readValue);
2769                    routeA4[effectiveIndex].addressField.setText(readValueString);
2770                    routeA4[effectiveIndex].addressField.setLastQueriedValue(readValueString);
2771                    if (opsw[62] == true) {
2772                        routeA4[effectiveIndex].closedRadioButton.setSelected(true);
2773                    } else {
2774                        routeA4[effectiveIndex].thrownRadioButton.setSelected(true);
2775                    }
2776                }
2777                break;
2778            }
2779            case 18:
2780            case 22:
2781            case 26:
2782            case 30:
2783            case 34:
2784            case 38:
2785            case 42:
2786            case 46: {
2787                // have a read value for Route n - update local storage
2788                Integer effectiveIndex = (indexToRead - 14) / 4;
2789                if (isUsed == false) {
2790                    routeA6[effectiveIndex].setIsUnused();
2791                    routeA6[effectiveIndex].addressField.setText("");
2792                    routeA6[effectiveIndex].unusedRadioButton.setSelected(true);
2793                } else {
2794                    routeA6[effectiveIndex].setAddress(readValue);
2795                    routeA6[effectiveIndex].addressField.setText(readValueString);
2796                    routeA6[effectiveIndex].addressField.setLastQueriedValue(readValueString);
2797                    if (opsw[62] == true) {
2798                        routeA6[effectiveIndex].closedRadioButton.setSelected(true);
2799                    } else {
2800                        routeA6[effectiveIndex].thrownRadioButton.setSelected(true);
2801                    }
2802                }
2803                break;
2804            }
2805            case 19:
2806            case 23:
2807            case 27:
2808            case 31:
2809            case 35:
2810            case 39:
2811            case 43:
2812            case 47: {
2813                // have a read value for Route n - update local storage
2814                Integer effectiveIndex = (indexToRead - 15) / 4;
2815                if (isUsed == false) {
2816                    routeA8[effectiveIndex].setIsUnused();
2817                    routeA8[effectiveIndex].addressField.setText("");
2818                    routeA8[effectiveIndex].unusedRadioButton.setSelected(true);
2819                } else {
2820                    routeA8[effectiveIndex].setAddress(readValue);
2821                    routeA8[effectiveIndex].addressField.setText(readValueString);
2822                    routeA8[effectiveIndex].addressField.setLastQueriedValue(readValueString);
2823                    if (opsw[62] == true) {
2824                        routeA8[effectiveIndex].closedRadioButton.setSelected(true);
2825                    } else {
2826                        routeA8[effectiveIndex].thrownRadioButton.setSelected(true);
2827                    }
2828                }
2829                break;
2830            }
2831            default:
2832                break;
2833        }
2834    }
2835
2836    @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "DLS_DEAD_LOCAL_STORE", justification = "Cannot catch an exception without grabbing the exception, but we don't do anything with the exception details.")
2837    void updateGuiFromOpSws33_48() {
2838        Integer readValue;
2839        boolean isUsed = true;
2840
2841        readValue = 0;
2842        for (int i = 44; i >= 33; i--) {
2843            if (i != 40) {
2844                readValue = (readValue << 1) + (opsw[i] ? 1 : 0);
2845            }
2846        }
2847        readValue++; // account for physical/user numbering difference
2848
2849        String readValueString = readValue.toString();
2850        if ((opsw[47] == true) && (opsw[48] == true)) {
2851            readValueString = "";
2852            isUsed = false;
2853        }
2854        boolean direction = opsw[46];
2855
2856        switch (indexToRead) {
2857            case 0: {
2858                // have read value for output1 - update local storage
2859                outAddr1.setText(readValueString);
2860                outAddr1.setLastQueriedValue(readValueString);
2861                outAddr1.isValid();
2862                outState1.setText(direction
2863                        ? Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateClosed"))
2864                        : Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateThrown")));
2865                break;
2866            }
2867            case 1: {
2868                // have read value for output3 - update local storage
2869                outAddr3.setText(readValueString);
2870                outAddr3.setLastQueriedValue(readValueString);
2871                outState3.setText(direction
2872                        ? Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateClosed"))
2873                        : Bundle.getMessage("LabelTurnoutCurrentStateX", Bundle.getMessage("BeanStateThrown")));
2874                break;
2875            }
2876            case 16:
2877            case 20:
2878            case 24:
2879            case 28:
2880            case 32:
2881            case 36:
2882            case 40:
2883            case 44: {
2884                // have read value for Route n Top - update local storage
2885                Integer effectiveIndex = (indexToRead - 12) / 4;
2886                if (isUsed == false) {
2887                    routeTop[effectiveIndex].setIsUnused();
2888                    routeTop[effectiveIndex].addressField.setText("");
2889                    routeTop[effectiveIndex].unusedRadioButton.setSelected(true);
2890                } else {
2891                    routeTop[effectiveIndex].setAddress(readValue);
2892                    routeTop[effectiveIndex].addressField.setText(readValueString);
2893                    routeTop[effectiveIndex].addressField.setLastQueriedValue(readValueString);
2894                    if (opsw[46] == true) {
2895                        routeTop[effectiveIndex].closedRadioButton.setSelected(true);
2896                    } else {
2897                        routeTop[effectiveIndex].thrownRadioButton.setSelected(true);
2898                    }
2899                }
2900                break;
2901            }
2902            case 17:
2903            case 21:
2904            case 25:
2905            case 29:
2906            case 33:
2907            case 37:
2908            case 41:
2909            case 45: {
2910                // have a read value for Route n - update local storage
2911                Integer effectiveIndex = (indexToRead - 13) / 4;
2912                if (isUsed == false) {
2913                    routeA3[effectiveIndex].setIsUnused();
2914                    routeA3[effectiveIndex].addressField.setText("");
2915                    routeA3[effectiveIndex].unusedRadioButton.setSelected(true);
2916                } else {
2917                    routeA3[effectiveIndex].setAddress(readValue);
2918                    routeA3[effectiveIndex].addressField.setText(readValueString);
2919                    routeA3[effectiveIndex].addressField.setLastQueriedValue(readValueString);
2920                    if (opsw[46] == true) {
2921                        routeA3[effectiveIndex].closedRadioButton.setSelected(true);
2922                    } else {
2923                        routeA3[effectiveIndex].thrownRadioButton.setSelected(true);
2924                    }
2925                }
2926                break;
2927            }
2928            case 18:
2929            case 22:
2930            case 26:
2931            case 30:
2932            case 34:
2933            case 38:
2934            case 42:
2935            case 46: {
2936                // have a read value for Route n - update local storage
2937                Integer effectiveIndex = (indexToRead - 14) / 4;
2938                if (isUsed == false) {
2939                    routeA5[effectiveIndex].setIsUnused();
2940                    routeA5[effectiveIndex].addressField.setText("");
2941                    routeA5[effectiveIndex].unusedRadioButton.setSelected(true);
2942                } else {
2943                    routeA5[effectiveIndex].setAddress(readValue);
2944                    routeA5[effectiveIndex].addressField.setText(readValueString);
2945                    routeA5[effectiveIndex].addressField.setLastQueriedValue(readValueString);
2946                    if (opsw[46] == true) {
2947                        routeA5[effectiveIndex].closedRadioButton.setSelected(true);
2948                    } else {
2949                        routeA5[effectiveIndex].thrownRadioButton.setSelected(true);
2950                    }
2951                }
2952                break;
2953            }
2954            case 19:
2955            case 23:
2956            case 27:
2957            case 31:
2958            case 35:
2959            case 39:
2960            case 43:
2961            case 47: {
2962                // have a read value for Route n - update local storage
2963                Integer effectiveIndex = (indexToRead - 15) / 4;
2964                if (isUsed == false) {
2965                    routeA7[effectiveIndex].setIsUnused();
2966                    routeA7[effectiveIndex].addressField.setText("");
2967                    routeA7[effectiveIndex].unusedRadioButton.setSelected(true);
2968                } else {
2969                    routeA7[effectiveIndex].setAddress(readValue);
2970                    routeA7[effectiveIndex].addressField.setText(readValueString);
2971                    routeA7[effectiveIndex].addressField.setLastQueriedValue(readValueString);
2972                    if (opsw[46] == true) {
2973                        routeA7[effectiveIndex].closedRadioButton.setSelected(true);
2974                    } else {
2975                        routeA7[effectiveIndex].thrownRadioButton.setSelected(true);
2976                    }
2977                }
2978                break;
2979            }
2980            default: {
2981                break;
2982            }
2983        }
2984    }
2985
2986    private final ActionListener basicConfigChangeActionListener = new ActionListener() {
2987        @Override
2988        public void actionPerformed(ActionEvent e) {
2989            if (e.getSource().getClass() == JComboBox.class) {
2990                switch (((Component) e.getSource()).getName()) {
2991                    case "1": // NOI18N
2992                        opsw[1] = (outputType.getSelectedIndex() == 1);
2993                        updateGuiBasicOpSw(1);
2994                        break;
2995                    case "2345": // NOI18N
2996                        int selection = delayTime.getSelectedIndex();
2997                        opsw[2] = ((selection & 0x1) == 1);
2998                        opsw[3] = ((selection & 0x2) == 2);
2999                        opsw[4] = ((selection & 0x4) == 4);
3000                        opsw[5] = ((selection & 0x8) == 8);
3001                        updateGuiBasicOpSw(2);
3002                        updateGuiBasicOpSw(3);
3003                        updateGuiBasicOpSw(4);
3004                        updateGuiBasicOpSw(5);
3005                        break;
3006                    case "6": // NOI18N
3007                        opsw[6] = (outputStates.getSelectedIndex() == 1);
3008                        updateGuiBasicOpSw(6);
3009                        break;
3010                    case "8": // NOI18N
3011                        opsw[8] = startupDelay.getSelectedIndex() == 1;
3012                        updateGuiBasicOpSw(8);
3013                        break;
3014                    case "9": // NOI18N
3015                        opsw[9] = staticOutputShutoff.getSelectedIndex() == 1;
3016                        updateGuiBasicOpSw(9);
3017                        break;
3018                    case "10": // NOI18N
3019                        opsw[10] = commandType.getSelectedIndex() == 1;
3020                        updateGuiBasicOpSw(10);
3021                        break;
3022                    case "13": // NOI18N
3023                        opsw[13] = (sensorMessageTrigger.getSelectedIndex() == 1);
3024                        updateGuiBasicOpSw(13);
3025                        break;
3026                    case "14": // NOI18N
3027                        opsw[14] = commandSource.getSelectedIndex() == 1;
3028                        updateGuiBasicOpSw(14);
3029                        break;
3030                    case "21": // NOI18N
3031                        opsw[21] = localSensorType.getSelectedIndex() == 1;
3032                        updateGuiBasicOpSw(21);
3033                        break;
3034
3035                    case "1116": // NOI18N
3036                        opsw[11] = (routesControl.getSelectedIndex() == 1) || (routesControl.getSelectedIndex() == 3);
3037                        opsw[16] = routesControl.getSelectedIndex() >= 2;
3038                        updateGuiBasicOpSw(11);
3039                        updateGuiBasicOpSw(16);
3040                        break;
3041                    case "1215": // NOI18N
3042                        opsw[12] = (localControlOfOutputsStyle.getSelectedIndex() & 1) == 1;  //2 -> OpSw12="c"
3043                        opsw[15] = (localControlOfOutputsStyle.getSelectedIndex() >= 2);  //0 -> OpSw15="c"
3044                        updateGuiBasicOpSw(12);
3045                        updateGuiBasicOpSw(15);
3046                        break;
3047                    default:
3048                }
3049            } else if (e.getSource().getClass() == JCheckBox.class) {
3050                switch (((Component) e.getSource()).getName()) {
3051                    case "17": // NOI18N
3052                        opsw[17] = output1CrossbuckFlasherCheckBox.isSelected();
3053                        updateGuiBasicOpSw(17);
3054                        break;
3055                    case "18": // NOI18N
3056                        opsw[18] = output2CrossbuckFlasherCheckBox.isSelected();
3057                        updateGuiBasicOpSw(18);
3058                        break;
3059                    case "19": // NOI18N
3060                        opsw[19] = output3CrossbuckFlasherCheckBox.isSelected();
3061                        updateGuiBasicOpSw(19);
3062                        break;
3063                    case "20": // NOI18N
3064                        opsw[20] = output4CrossbuckFlasherCheckBox.isSelected();
3065                        updateGuiBasicOpSw(20);
3066                        break;
3067                    default:
3068                        break;
3069                }
3070
3071            }
3072        }
3073    };
3074
3075    private void updateBasicOpSwTab() {
3076        for (int i = 1; i <= 21; ++i) {
3077            if (i != 7) {
3078                opswThrown[i].setSelected(!opsw[i]);
3079                opswClosed[i].setSelected(opsw[i]);
3080            }
3081        }
3082    }
3083
3084    private static class JRadioButtonWithInteger extends JRadioButton {
3085
3086        public int index;
3087
3088        JRadioButtonWithInteger(int i, String s) {
3089            super(s);
3090            index = i;
3091        }
3092    }
3093
3094
3095    /**
3096     * Copy from the GUI OpSw tab to the GUI Basics tab
3097     */
3098    protected void copyOpswToBasic() {
3099        // copy over values from OpSw tab to the Basics tab
3100        outputType.setSelectedIndex(opsw[1]?1:0);
3101
3102        delayTime.setSelectedIndex(
3103            (opsw[2]?1:0) + (opsw[3]?2:0) + (opsw[4]?4:0) + (opsw[5]?8:0));
3104
3105        outputStates.setSelectedIndex(opsw[6]?1:0);
3106        isWritingResetOpSw = opsw[7];
3107        startupDelay.setSelectedIndex(opsw[8]?1:0);
3108        staticOutputShutoff.setSelectedIndex(opsw[9]?1:0);
3109        commandType.setSelectedIndex(opsw[10]?1:0);
3110        routesControl.setSelectedIndex((opsw[11]?1:0) + (opsw[16]?2:0));
3111        localControlOfOutputsStyle.setSelectedIndex((opsw[12]?1:0) + (opsw[15]?2:0));
3112        sensorMessageTrigger.setSelectedIndex(opsw[13]?1:0);
3113        commandSource.setSelectedIndex(opsw[14]?1:0);
3114        output1CrossbuckFlasherCheckBox.setSelected(opsw[17]);
3115        output2CrossbuckFlasherCheckBox.setSelected(opsw[18]);
3116        output3CrossbuckFlasherCheckBox.setSelected(opsw[19]);
3117        output4CrossbuckFlasherCheckBox.setSelected(opsw[20]);
3118        localSensorType.setSelectedIndex(opsw[21]?1:0);
3119    }
3120
3121    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Ds64TabbedPanel.class);
3122
3123}