001package jmri.jmrit.dispatcher; 002 003import java.awt.BorderLayout; 004import java.awt.Component; 005import java.awt.Container; 006import java.awt.Dimension; 007import java.awt.FlowLayout; 008import java.awt.event.ActionEvent; 009import java.awt.event.ActionListener; 010import java.awt.event.ItemEvent; 011import java.util.ArrayList; 012import java.util.HashSet; 013import java.util.List; 014import java.util.Locale; 015import java.util.Set; 016 017import javax.swing.BorderFactory; 018import javax.swing.BoxLayout; 019import javax.swing.ButtonGroup; 020import javax.swing.JButton; 021import javax.swing.JCheckBox; 022import javax.swing.JComboBox; 023import javax.swing.JLabel; 024import javax.swing.JPanel; 025import javax.swing.JRadioButton; 026import javax.swing.JScrollPane; 027import javax.swing.JSeparator; 028import javax.swing.JSpinner; 029import javax.swing.JTable; 030import javax.swing.JTextField; 031import javax.swing.ScrollPaneConstants; 032import javax.swing.SpinnerNumberModel; 033import javax.swing.table.DefaultTableModel; 034import javax.swing.table.TableCellRenderer; 035import javax.swing.table.TableColumnModel; 036 037import jmri.Block; 038import jmri.jmrit.display.layoutEditor.LayoutBlock; 039import jmri.jmrit.display.layoutEditor.LayoutBlockManager; 040import jmri.InstanceManager; 041import jmri.Sensor; 042import jmri.Transit; 043import jmri.TransitManager; 044import jmri.jmrit.dispatcher.ActiveTrain.TrainDetection; 045import jmri.jmrit.dispatcher.ActiveTrain.TrainLengthUnits; 046import jmri.jmrit.dispatcher.DispatcherFrame.TrainsFrom; 047import jmri.jmrit.operations.trains.Train; 048import jmri.jmrit.operations.trains.TrainManager; 049import jmri.jmrit.roster.RosterEntry; 050import jmri.jmrit.roster.swing.RosterEntryComboBox; 051import jmri.swing.NamedBeanComboBox; 052import jmri.util.JmriJFrame; 053import jmri.util.swing.JComboBoxUtil; 054import jmri.util.swing.JmriJOptionPane; 055 056/** 057 * Displays the Activate New Train dialog and processes information entered 058 * there. 059 * <p> 060 * This module works with Dispatcher, which initiates the display of the dialog. 061 * Dispatcher also creates the ActiveTrain. 062 * <p> 063 * This file is part of JMRI. 064 * <p> 065 * JMRI is open source software; you can redistribute it and/or modify it under 066 * the terms of version 2 of the GNU General Public License as published by the 067 * Free Software Foundation. See the "COPYING" file for a copy of this license. 068 * <p> 069 * JMRI is distributed in the hope that it will be useful, but WITHOUT ANY 070 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR 071 * A PARTICULAR PURPOSE. See the GNU General Public License for more details. 072 * 073 * @author Dave Duchamp Copyright (C) 2009 074 */ 075public class ActivateTrainFrame extends JmriJFrame { 076 077 public ActivateTrainFrame(DispatcherFrame d) { 078 super(true,true); 079 _dispatcher = d; 080 _tiFile = new TrainInfoFile(); 081 } 082 083 // operational instance variables 084 private DispatcherFrame _dispatcher = null; 085 private TrainInfoFile _tiFile = null; 086 private final TransitManager _TransitManager = InstanceManager.getDefault(jmri.TransitManager.class); 087 private String _trainInfoName = ""; 088 089 // initiate train window variables 090 private Transit selectedTransit = null; 091 //private String selectedTrain = ""; 092 private JmriJFrame initiateFrame = null; 093 private Container initiatePane = null; 094 private final jmri.swing.NamedBeanComboBox<Transit> transitSelectBox = new jmri.swing.NamedBeanComboBox<>(_TransitManager); 095 private final JComboBox<Object> trainSelectBox = new JComboBox<>(); 096 // private final List<RosterEntry> trainBoxList = new ArrayList<>(); 097 private RosterEntryComboBox rosterComboBox = null; 098 private final JLabel trainFieldLabel = new JLabel(Bundle.getMessage("TrainBoxLabel") + ":"); 099 private final JTextField trainNameField = new JTextField(10); 100 private final JLabel dccAddressFieldLabel = new JLabel(" " + Bundle.getMessage("DccAddressFieldLabel") + ":"); 101 private final JSpinner dccAddressSpinner = new JSpinner(new SpinnerNumberModel(3, 1, 9999, 1)); 102 private final JCheckBox inTransitBox = new JCheckBox(Bundle.getMessage("TrainInTransit")); 103 private final JComboBox<String> startingBlockBox = new JComboBox<>(); 104 private final JComboBox<String> viaBlockBox = new JComboBox<>(); 105 private final JLabel viaBlockBoxLabel = new JLabel(Bundle.getMessage("ViaBlockBoxLabel")); 106 private List<Block> startingBlockBoxList = new ArrayList<>(); 107 private final List<Block> viaBlockBoxList = new ArrayList<>(); 108 private List<Integer> startingBlockSeqList = new ArrayList<>(); 109 private final JComboBox<String> destinationBlockBox = new JComboBox<>(); 110 111 private List<Block> destinationBlockBoxList = new ArrayList<>(); 112 private List<Integer> destinationBlockSeqList = new ArrayList<>(); 113 private JButton addNewTrainButton = null; 114 private JButton loadButton = null; 115 private JButton saveButton = null; 116 private JButton saveAsTemplateButton = null; 117 private JButton deleteButton = null; 118 private final JCheckBox autoRunBox = new JCheckBox(Bundle.getMessage("AutoRun")); 119 private final JCheckBox loadAtStartupBox = new JCheckBox(Bundle.getMessage("LoadAtStartup")); 120 121 private final JRadioButton radioTrainsFromRoster = new JRadioButton(Bundle.getMessage("TrainsFromRoster")); 122 private final JRadioButton radioTrainsFromOps = new JRadioButton(Bundle.getMessage("TrainsFromTrains")); 123 private final JRadioButton radioTrainsFromUser = new JRadioButton(Bundle.getMessage("TrainsFromUser")); 124 private final JRadioButton radioTrainsFromSetLater = new JRadioButton(Bundle.getMessage("TrainsFromSetLater")); 125 private final ButtonGroup trainsFromButtonGroup = new ButtonGroup(); 126 127 private final JRadioButton radioTransitsPredefined = new JRadioButton(Bundle.getMessage("TransitsPredefined")); 128 private final JRadioButton radioTransitsAdHoc = new JRadioButton(Bundle.getMessage("TransitsAdHoc")); 129 private final ButtonGroup transitsFromButtonGroup = new ButtonGroup(); 130 //private final JCheckBox adHocCloseLoop = new JCheckBox(Bundle.getMessage("TransitCloseLoop")); 131 132 private final JRadioButton allocateBySafeRadioButton = new JRadioButton(Bundle.getMessage("ToSafeSections")); 133 private final JRadioButton allocateAllTheWayRadioButton = new JRadioButton(Bundle.getMessage("AsFarAsPos")); 134 private final JRadioButton allocateNumberOfBlocks = new JRadioButton(Bundle.getMessage("NumberOfBlocks") + ":"); 135 private final ButtonGroup allocateMethodButtonGroup = new ButtonGroup(); 136 private final JSpinner allocateCustomSpinner = new JSpinner(new SpinnerNumberModel(3, 1, 100, 1)); 137 private final JCheckBox terminateWhenDoneBox = new JCheckBox(Bundle.getMessage("TerminateWhenDone")); 138 private final JPanel terminateWhenDoneDetails = new JPanel(); 139 private final JComboBox<String> nextTrain = new JComboBox<>(); 140 private final JLabel nextTrainLabel = new JLabel(Bundle.getMessage("TerminateWhenDoneNextTrain")); 141 private final JSpinner prioritySpinner = new JSpinner(new SpinnerNumberModel(5, 0, 100, 1)); 142 private final JCheckBox resetWhenDoneBox = new JCheckBox(Bundle.getMessage("ResetWhenDone")); 143 private final JCheckBox reverseAtEndBox = new JCheckBox(Bundle.getMessage("ReverseAtEnd")); 144 145 int[] delayedStartInt = new int[]{ActiveTrain.NODELAY, ActiveTrain.TIMEDDELAY, ActiveTrain.SENSORDELAY}; 146 String[] delayedStartString = new String[]{Bundle.getMessage("DelayedStartNone"), Bundle.getMessage("DelayedStartTimed"), Bundle.getMessage("DelayedStartSensor")}; 147 148 private final JComboBox<String> reverseDelayedRestartType = new JComboBox<>(delayedStartString); 149 private final JLabel delayReverseReStartLabel = new JLabel(Bundle.getMessage("DelayRestart")); 150 private final JLabel delayReverseReStartSensorLabel = new JLabel(Bundle.getMessage("RestartSensor")); 151 private final JCheckBox delayReverseResetSensorBox = new JCheckBox(Bundle.getMessage("ResetRestartSensor")); 152 private final NamedBeanComboBox<Sensor> delayReverseReStartSensor = new NamedBeanComboBox<>(jmri.InstanceManager.sensorManagerInstance()); 153 private final JSpinner delayReverseMinSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 1000, 1)); 154 private final JLabel delayReverseMinLabel = new JLabel(Bundle.getMessage("RestartTimed")); 155 156 private final JCheckBox resetStartSensorBox = new JCheckBox(Bundle.getMessage("ResetStartSensor")); 157 private final JComboBox<String> delayedStartBox = new JComboBox<>(delayedStartString); 158 private final JLabel delayedReStartLabel = new JLabel(Bundle.getMessage("DelayRestart")); 159 private final JLabel delayReStartSensorLabel = new JLabel(Bundle.getMessage("RestartSensor")); 160 private final JCheckBox resetRestartSensorBox = new JCheckBox(Bundle.getMessage("ResetRestartSensor")); 161 private final JComboBox<String> delayedReStartBox = new JComboBox<>(delayedStartString); 162 private final NamedBeanComboBox<Sensor> delaySensor = new NamedBeanComboBox<>(jmri.InstanceManager.sensorManagerInstance()); 163 private final NamedBeanComboBox<Sensor> delayReStartSensor = new NamedBeanComboBox<>(jmri.InstanceManager.sensorManagerInstance()); 164 165 private final JSpinner departureHrSpinner = new JSpinner(new SpinnerNumberModel(8, 0, 23, 1)); 166 private final JSpinner departureMinSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 59, 1)); 167 private final JLabel departureTimeLabel = new JLabel(Bundle.getMessage("DepartureTime")); 168 private final JLabel departureSepLabel = new JLabel(":"); 169 170 private final JSpinner delayMinSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 1000, 1)); 171 private final JLabel delayMinLabel = new JLabel(Bundle.getMessage("RestartTimed")); 172 173 private final JComboBox<String> trainTypeBox = new JComboBox<>(); 174 // Note: See also items related to automatically running trains near the end of this module 175 176 boolean transitsFromSpecificBlock = false; 177 178 private TrainInfo trainInfo; 179 180 private final String nameOfTemplateFile="TrainInfoDefaultTemplate.xml"; 181 // to be added and removed. 182 private final ActionListener viaBlockBoxListener = e -> handleViaBlockSelectionChanged(); 183 184 /** 185 * Open up a new train window for a given roster entry located in a specific 186 * block. 187 * 188 * @param e the action event triggering the new window 189 * @param re the roster entry to open the new window for 190 * @param b the block where the train is located 191 */ 192 public void initiateTrain(ActionEvent e, RosterEntry re, Block b) { 193 initiateTrain(e); 194 if (trainInfo.getTrainsFrom() == TrainsFrom.TRAINSFROMROSTER && re != null) { 195 setRosterComboBox(rosterComboBox, re.getId()); 196 //Add in some bits of code as some point to filter down the transits that can be used. 197 } 198 if (b != null && selectedTransit != null) { 199 List<Transit> transitList = _TransitManager.getListUsingBlock(b); 200 List<Transit> transitEntryList = _TransitManager.getListEntryBlock(b); 201 for (Transit t : transitEntryList) { 202 if (!transitList.contains(t)) { 203 transitList.add(t); 204 } 205 } 206 transitsFromSpecificBlock = true; 207 initializeFreeTransitsCombo(transitList); 208 List<Block> tmpBlkList = new ArrayList<>(); 209 if (selectedTransit.getEntryBlocksList().contains(b)) { 210 tmpBlkList = selectedTransit.getEntryBlocksList(); 211 inTransitBox.setSelected(false); 212 } else if (selectedTransit.containsBlock(b)) { 213 tmpBlkList = selectedTransit.getInternalBlocksList(); 214 inTransitBox.setSelected(true); 215 } 216 List<Integer> tmpSeqList = selectedTransit.getBlockSeqList(); 217 for (int i = 0; i < tmpBlkList.size(); i++) { 218 if (tmpBlkList.get(i) == b) { 219 setComboBox(startingBlockBox, getBlockName(b) + "-" + tmpSeqList.get(i)); 220 break; 221 } 222 } 223 } 224 } 225 226 /** 227 * Displays a window that allows a new ActiveTrain to be activated. 228 * <p> 229 * Called by Dispatcher in response to the dispatcher clicking the New Train 230 * button. 231 * 232 * @param e the action event triggering the window display 233 */ 234 protected void initiateTrain(ActionEvent e) { 235 // set Dispatcher defaults 236 // create window if needed 237 // if template exists open it 238 try { 239 trainInfo = _tiFile.readTrainInfo(nameOfTemplateFile); 240 if (trainInfo == null) { 241 trainInfo = new TrainInfo(); 242 } 243 } catch (java.io.IOException ioe) { 244 log.error("IO Exception when reading train info file", ioe); 245 return; 246 } catch (org.jdom2.JDOMException jde) { 247 log.error("JDOM Exception when reading train info file", jde); 248 return; 249 } 250 251 if (initiateFrame == null) { 252 initiateFrame = this; 253 initiateFrame.setTitle(Bundle.getMessage("AddTrainTitle")); 254 initiateFrame.addHelpMenu("package.jmri.jmrit.dispatcher.NewTrain", true); 255 initiatePane = initiateFrame.getContentPane(); 256 initiatePane.setLayout(new BoxLayout(initiatePane, BoxLayout.Y_AXIS)); 257 258 // add buttons to load and save train information 259 JPanel hdr = new JPanel(); 260 hdr.add(loadButton = new JButton(Bundle.getMessage("LoadButton"))); 261 loadButton.addActionListener(this::loadTrainInfo); 262 loadButton.setToolTipText(Bundle.getMessage("LoadButtonHint")); 263 hdr.add(saveButton = new JButton(Bundle.getMessage("SaveButton"))); 264 saveButton.addActionListener( ev -> saveTrainInfo()); 265 saveButton.setToolTipText(Bundle.getMessage("SaveButtonHint")); 266 hdr.add(saveAsTemplateButton = new JButton(Bundle.getMessage("SaveAsTemplateButton"))); 267 saveAsTemplateButton.addActionListener( ev -> saveTrainInfoAsTemplate()); 268 saveAsTemplateButton.setToolTipText(Bundle.getMessage("SaveAsTemplateButtonHint")); 269 hdr.add(deleteButton = new JButton(Bundle.getMessage("DeleteButton"))); 270 deleteButton.addActionListener( ev -> deleteTrainInfo()); 271 deleteButton.setToolTipText(Bundle.getMessage("DeleteButtonHint")); 272 273 // add items relating to both manually run and automatic trains. 274 275 // Trains From choices. 276 JPanel p1 = new JPanel(); 277 p1.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("TrainsFrom"))); 278 radioTrainsFromRoster.setActionCommand("TRAINSFROMROSTER"); 279 trainsFromButtonGroup.add(radioTrainsFromRoster); 280 radioTrainsFromOps.setActionCommand("TRAINSFROMOPS"); 281 trainsFromButtonGroup.add(radioTrainsFromOps); 282 radioTrainsFromUser.setActionCommand("TRAINSFROMUSER"); 283 trainsFromButtonGroup.add(radioTrainsFromUser); 284 radioTrainsFromSetLater.setActionCommand("TRAINSFROMSETLATER"); 285 trainsFromButtonGroup.add(radioTrainsFromSetLater); 286 p1.add(radioTrainsFromRoster); 287 radioTrainsFromRoster.setToolTipText(Bundle.getMessage("TrainsFromRosterHint")); 288 p1.add(radioTrainsFromOps); 289 radioTrainsFromOps.setToolTipText(Bundle.getMessage("TrainsFromTrainsHint")); 290 p1.add(radioTrainsFromUser); 291 radioTrainsFromUser.setToolTipText(Bundle.getMessage("TrainsFromUserHint")); 292 p1.add(radioTrainsFromSetLater); 293 radioTrainsFromSetLater.setToolTipText(Bundle.getMessage("TrainsFromSetLaterHint")); 294 295 radioTrainsFromOps.addItemListener( e1 -> { 296 if (e1.getStateChange() == ItemEvent.SELECTED) { 297 setTrainsFromOptions(TrainsFrom.TRAINSFROMOPS); 298 } 299 }); 300 radioTrainsFromRoster.addItemListener( e1 -> { 301 if (e1.getStateChange() == ItemEvent.SELECTED) { 302 setTrainsFromOptions(TrainsFrom.TRAINSFROMROSTER); 303 } 304 }); 305 radioTrainsFromUser.addItemListener( e1 -> { 306 if (e1.getStateChange() == ItemEvent.SELECTED) { 307 setTrainsFromOptions(TrainsFrom.TRAINSFROMUSER); 308 } 309 }); 310 radioTrainsFromSetLater.addItemListener( e1 -> { 311 if (e1.getStateChange() == ItemEvent.SELECTED) { 312 setTrainsFromOptions(TrainsFrom.TRAINSFROMSETLATER); 313 } 314 }); 315 initiatePane.add(p1); 316 317 // Select train 318 JPanel p2 = new JPanel(); 319 320 // Dispatcher train name 321 p2.add(trainFieldLabel); 322 p2.add(trainNameField); 323 trainNameField.setToolTipText(Bundle.getMessage("TrainFieldHint")); 324 325 // Roster combo box 326 rosterComboBox = new RosterEntryComboBox(); 327 initializeFreeRosterEntriesCombo(); 328 rosterComboBox.addActionListener(this::handleRosterSelectionChanged); 329 p2.add(rosterComboBox); 330 331 // Operations combo box 332 p2.add(trainSelectBox); 333 trainSelectBox.addActionListener( e1 -> handleTrainSelectionChanged()); 334 trainSelectBox.setToolTipText(Bundle.getMessage("TrainBoxHint")); 335 336 // DCC address selector 337 p2.add(dccAddressFieldLabel); 338 p2.add(dccAddressSpinner); 339 dccAddressSpinner.setToolTipText(Bundle.getMessage("DccAddressFieldHint")); 340 341 initiatePane.add(p2); 342 343 // Select transit type 344 JPanel p3 = new JPanel(); 345 p3.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("TransitsFrom"))); 346 radioTransitsPredefined.setActionCommand("USETRANSITS"); 347 transitsFromButtonGroup.add(radioTransitsPredefined); 348 radioTransitsAdHoc.setActionCommand("USEADHOC"); 349 transitsFromButtonGroup.add(radioTransitsAdHoc); 350 p3.add(radioTransitsPredefined); 351 radioTransitsPredefined.setToolTipText(Bundle.getMessage("TransitsPredefinedHint")); 352 p3.add(radioTransitsAdHoc); 353 radioTransitsAdHoc.setToolTipText(Bundle.getMessage("TransitsAdHocHint")); 354 radioTransitsPredefined.addItemListener( e1 -> { 355 if (e1.getStateChange() == ItemEvent.SELECTED) { 356 transitSelectBox.setEnabled(true); 357 //adHocCloseLoop.setEnabled(false); 358 inTransitBox.setEnabled(true); 359 handleInTransitClick(); 360 viaBlockBox.setVisible(false); 361 viaBlockBoxLabel.setVisible(false); 362 } 363 }); 364 radioTransitsAdHoc.addItemListener( e1 -> { 365 if (e1.getStateChange() == ItemEvent.SELECTED) { 366 checkAdvancedRouting(); 367 transitSelectBox.setEnabled(false); 368 //adHocCloseLoop.setEnabled(true); 369 inTransitBox.setEnabled(false); 370 inTransitBox.setSelected(true); 371 initializeStartingBlockComboDynamic(); 372 viaBlockBox.setVisible(true); 373 viaBlockBoxLabel.setVisible(true); 374 } 375 }); 376 377 //p3.add(adHocCloseLoop); 378 //adHocCloseLoop.setToolTipText(Bundle.getMessage("TransitCloseLoopHint")); 379 380 p3.add(new JLabel(Bundle.getMessage("TransitBoxLabel") + " :")); 381 p3.add(transitSelectBox); 382 transitSelectBox.addActionListener(this::handleTransitSelectionChanged); 383 transitSelectBox.setToolTipText(Bundle.getMessage("TransitBoxHint")); 384 initiatePane.add(p3); 385 386 // Train in transit 387 JPanel p4 = new JPanel(); 388 p4.add(inTransitBox); 389 inTransitBox.addActionListener( ev -> handleInTransitClick()); 390 inTransitBox.setToolTipText(Bundle.getMessage("InTransitBoxHint")); 391 initiatePane.add(p4); 392 393 // Starting block, add Via for adhoc transits 394 JPanel p5 = new JPanel(); 395 p5.add(new JLabel(Bundle.getMessage("StartingBlockBoxLabel") + " :")); 396 p5.add(startingBlockBox); 397 startingBlockBox.setToolTipText(Bundle.getMessage("StartingBlockBoxHint")); 398 startingBlockBox.addActionListener( ev -> handleStartingBlockSelectionChanged()); 399 p5.add(viaBlockBoxLabel); 400 p5.add(viaBlockBox); 401 viaBlockBox.setToolTipText(Bundle.getMessage("ViaBlockBoxHint")); 402 viaBlockBox.addActionListener(viaBlockBoxListener); 403 initiatePane.add(p5); 404 405 // Destination block 406 JPanel p6 = new JPanel(); 407 p6.add(new JLabel(Bundle.getMessage("DestinationBlockBoxLabel") + ":")); 408 p6.add(destinationBlockBox); 409 destinationBlockBox.setToolTipText(Bundle.getMessage("DestinationBlockBoxHint")); 410 initiatePane.add(p6); 411 412 // Train detection scope 413 JPanel p7 = new JPanel(); 414 p7.add(trainDetectionLabel); 415 initializeTrainDetectionBox(); 416 p7.add(trainDetectionComboBox); 417 trainDetectionComboBox.setToolTipText(Bundle.getMessage("TrainDetectionBoxHint")); 418 initiatePane.add(p7); 419 420 // Allocation method 421 JPanel p8 = new JPanel(); 422 p8.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("AllocateMethodLabel"))); 423 allocateMethodButtonGroup.add(allocateAllTheWayRadioButton); 424 allocateMethodButtonGroup.add(allocateBySafeRadioButton); 425 allocateMethodButtonGroup.add(allocateNumberOfBlocks); 426 p8.add(allocateAllTheWayRadioButton); 427 allocateAllTheWayRadioButton.setToolTipText(Bundle.getMessage("AllocateAllTheWayHint")); 428 p8.add(allocateBySafeRadioButton); 429 allocateBySafeRadioButton.setToolTipText(Bundle.getMessage("AllocateSafeHint")); 430 p8.add(allocateNumberOfBlocks); 431 allocateNumberOfBlocks.setToolTipText(Bundle.getMessage("AllocateMethodHint")); 432 allocateAllTheWayRadioButton.addActionListener( ev -> handleAllocateAllTheWayButtonChanged()); 433 allocateBySafeRadioButton.addActionListener( ev -> handleAllocateBySafeButtonChanged()); 434 allocateNumberOfBlocks.addActionListener( ev -> handleAllocateNumberOfBlocksButtonChanged()); 435 p8.add(allocateCustomSpinner); 436 allocateCustomSpinner.setToolTipText(Bundle.getMessage("AllocateMethodHint")); 437 initiatePane.add(p8); 438 439 // Restart at end 440 JPanel p9 = new JPanel(); 441 p9.add(resetWhenDoneBox); 442 resetWhenDoneBox.addActionListener( ev -> handleResetWhenDoneClick()); 443 resetWhenDoneBox.setToolTipText(Bundle.getMessage("ResetWhenDoneBoxHint")); 444 initiatePane.add(p9); 445 446 // Restart using sensor 447 JPanel p9a = new JPanel(); 448 ((FlowLayout) p9a.getLayout()).setVgap(1); 449 p9a.add(delayedReStartLabel); 450 p9a.add(delayedReStartBox); 451 p9a.add(resetRestartSensorBox); 452 resetRestartSensorBox.setToolTipText(Bundle.getMessage("ResetRestartSensorHint")); 453 resetRestartSensorBox.setSelected(true); 454 delayedReStartBox.addActionListener( ev -> handleResetWhenDoneClick()); 455 delayedReStartBox.setToolTipText(Bundle.getMessage("DelayedReStartHint")); 456 initiatePane.add(p9a); 457 458 // Restart using timer 459 JPanel p9b = new JPanel(); 460 ((FlowLayout) p9b.getLayout()).setVgap(1); 461 p9b.add(delayMinLabel); 462 p9b.add(delayMinSpinner); // already set to 0 463 delayMinSpinner.setToolTipText(Bundle.getMessage("RestartTimedHint")); 464 p9b.add(delayReStartSensorLabel); 465 p9b.add(delayReStartSensor); 466 delayReStartSensor.setAllowNull(true); 467 handleResetWhenDoneClick(); 468 initiatePane.add(p9b); 469 470 initiatePane.add(new JSeparator()); 471 472 // Reverse at end 473 JPanel p10 = new JPanel(); 474 p10.add(reverseAtEndBox); 475 reverseAtEndBox.setToolTipText(Bundle.getMessage("ReverseAtEndBoxHint")); 476 initiatePane.add(p10); 477 reverseAtEndBox.addActionListener( ev -> handleReverseAtEndBoxClick()); 478 479 // Reverse using sensor 480 JPanel pDelayReverseRestartDetails = new JPanel(); 481 ((FlowLayout) pDelayReverseRestartDetails.getLayout()).setVgap(1); 482 pDelayReverseRestartDetails.add(delayReverseReStartLabel); 483 pDelayReverseRestartDetails.add(reverseDelayedRestartType); 484 pDelayReverseRestartDetails.add(delayReverseResetSensorBox); 485 delayReverseResetSensorBox.setToolTipText(Bundle.getMessage("ReverseResetRestartSensorHint")); 486 delayReverseResetSensorBox.setSelected(true); 487 reverseDelayedRestartType.addActionListener( ev -> handleReverseAtEndBoxClick()); 488 reverseDelayedRestartType.setToolTipText(Bundle.getMessage("ReverseDelayedReStartHint")); 489 initiatePane.add(pDelayReverseRestartDetails); 490 491 // Reverse using timer 492 JPanel pDelayReverseRestartDetails2 = new JPanel(); 493 ((FlowLayout) pDelayReverseRestartDetails2.getLayout()).setVgap(1); 494 pDelayReverseRestartDetails2.add(delayReverseMinLabel); 495 pDelayReverseRestartDetails2.add(delayReverseMinSpinner); // already set to 0 496 delayReverseMinSpinner.setToolTipText(Bundle.getMessage("ReverseRestartTimedHint")); 497 pDelayReverseRestartDetails2.add(delayReverseReStartSensorLabel); 498 pDelayReverseRestartDetails2.add(delayReverseReStartSensor); 499 delayReverseReStartSensor.setAllowNull(true); 500 handleReverseAtEndBoxClick(); 501 initiatePane.add(pDelayReverseRestartDetails2); 502 503 initiatePane.add(new JSeparator()); 504 505 // Terminate when done option 506 JPanel p11 = new JPanel(); 507 p11.setLayout(new FlowLayout()); 508 p11.add(terminateWhenDoneBox); 509 terminateWhenDoneBox.addActionListener( ev -> handleTerminateWhenDoneBoxClick()); 510 initiatePane.add(p11); 511 512 // Optional next train, tied to terminate when done. 513 terminateWhenDoneDetails.setLayout(new FlowLayout()); 514 terminateWhenDoneDetails.add(nextTrainLabel); 515 terminateWhenDoneDetails.add(nextTrain); 516 nextTrain.setToolTipText(Bundle.getMessage("TerminateWhenDoneNextTrainHint")); 517 initiatePane.add(terminateWhenDoneDetails); 518 handleTerminateWhenDoneBoxClick(); 519 520 initiatePane.add(new JSeparator()); 521 522 // Priority and train type. 523 JPanel p12 = new JPanel(); 524 p12.setLayout(new FlowLayout()); 525 p12.add(new JLabel(Bundle.getMessage("PriorityLabel") + ":")); 526 p12.add(prioritySpinner); // already set to 5 527 prioritySpinner.setToolTipText(Bundle.getMessage("PriorityHint")); 528 p12.add(new JLabel(" ")); 529 p12.add(new JLabel(Bundle.getMessage("TrainTypeBoxLabel"))); 530 initializeTrainTypeBox(); 531 p12.add(trainTypeBox); 532 trainTypeBox.setSelectedIndex(1); 533 trainTypeBox.setToolTipText(Bundle.getMessage("TrainTypeBoxHint")); 534 initiatePane.add(p12); 535 536 // Delayed start option 537 JPanel p13 = new JPanel(); 538 p13.add(new JLabel(Bundle.getMessage("DelayedStart"))); 539 p13.add(delayedStartBox); 540 delayedStartBox.setToolTipText(Bundle.getMessage("DelayedStartHint")); 541 delayedStartBox.addActionListener(this::handleDelayStartClick); 542 p13.add(departureTimeLabel); 543 departureHrSpinner.setEditor(new JSpinner.NumberEditor(departureHrSpinner, "00")); 544 p13.add(departureHrSpinner); 545 departureHrSpinner.setValue(8); 546 departureHrSpinner.setToolTipText(Bundle.getMessage("DepartureTimeHrHint")); 547 p13.add(departureSepLabel); 548 departureMinSpinner.setEditor(new JSpinner.NumberEditor(departureMinSpinner, "00")); 549 p13.add(departureMinSpinner); 550 departureMinSpinner.setValue(0); 551 departureMinSpinner.setToolTipText(Bundle.getMessage("DepartureTimeMinHint")); 552 p13.add(delaySensor); 553 delaySensor.setAllowNull(true); 554 p13.add(resetStartSensorBox); 555 resetStartSensorBox.setToolTipText(Bundle.getMessage("ResetStartSensorHint")); 556 resetStartSensorBox.setSelected(true); 557 handleDelayStartClick(null); 558 initiatePane.add(p13); 559 560 // Load at startup option 561 JPanel p14 = new JPanel(); 562 p14.setLayout(new FlowLayout()); 563 p14.add(loadAtStartupBox); 564 loadAtStartupBox.setToolTipText(Bundle.getMessage("LoadAtStartupBoxHint")); 565 loadAtStartupBox.setSelected(false); 566 initiatePane.add(p14); 567 568 // Auto run option 569 initiatePane.add(new JSeparator()); 570 JPanel p15 = new JPanel(); 571 p15.add(autoRunBox); 572 autoRunBox.addActionListener( ev -> handleAutoRunClick()); 573 autoRunBox.setToolTipText(Bundle.getMessage("AutoRunBoxHint")); 574 autoRunBox.setSelected(false); 575 initiatePane.add(p15); 576 initializeAutoRunItems(); 577 578 // Footer buttons 579 JPanel ftr = new JPanel(); 580 JButton cancelButton = new JButton(Bundle.getMessage("ButtonCancel")); 581 ftr.add(cancelButton); 582 cancelButton.addActionListener( ev -> cancelInitiateTrain()); 583 cancelButton.setToolTipText(Bundle.getMessage("CancelButtonHint")); 584 ftr.add(addNewTrainButton = new JButton(Bundle.getMessage("ButtonCreate"))); 585 addNewTrainButton.addActionListener( e1 -> addNewTrain()); 586 addNewTrainButton.setToolTipText(Bundle.getMessage("AddNewTrainButtonHint")); 587 588 JPanel mainPane = new JPanel(new BorderLayout()); 589 JScrollPane scrPane = new JScrollPane(initiatePane); 590 mainPane.add(hdr, BorderLayout.NORTH); 591 mainPane.add(scrPane, BorderLayout.CENTER); 592 mainPane.add(ftr, BorderLayout.SOUTH); 593 initiateFrame.setContentPane(mainPane); 594 switch (trainInfo.getTrainsFrom()) { 595 case TRAINSFROMROSTER: 596 radioTrainsFromRoster.setSelected(true); 597 break; 598 case TRAINSFROMOPS: 599 radioTrainsFromOps.setSelected(true); 600 break; 601 case TRAINSFROMUSER: 602 radioTrainsFromUser.setSelected(true); 603 break; 604 case TRAINSFROMSETLATER: 605 default: 606 radioTrainsFromSetLater.setSelected(true); 607 } 608 609 } 610 autoRunBox.setSelected(false); 611 loadAtStartupBox.setSelected(false); 612 initializeFreeTransitsCombo(new ArrayList<>()); 613 refreshNextTrainCombo(); 614 setTrainsFromOptions(trainInfo.getTrainsFrom()); 615 initiateFrame.pack(); 616 initiateFrame.setVisible(true); 617 618 trainInfoToDialog(trainInfo); 619 } 620 621 private void refreshNextTrainCombo() { 622 Object saveEntry = null; 623 if (nextTrain.getSelectedIndex() > 0) { 624 saveEntry=nextTrain.getSelectedItem(); 625 } 626 nextTrain.removeAllItems(); 627 nextTrain.addItem(" "); 628 for (String file: _tiFile.getTrainInfoFileNames()) { 629 nextTrain.addItem(file); 630 } 631 if (saveEntry != null) { 632 nextTrain.setSelectedItem(saveEntry); 633 } 634 } 635 private void setTrainsFromOptions(TrainsFrom transFrom) { 636 switch (transFrom) { 637 case TRAINSFROMROSTER: 638 initializeFreeRosterEntriesCombo(); 639 rosterComboBox.setVisible(true); 640 trainSelectBox.setVisible(false); 641 trainFieldLabel.setVisible(true); 642 trainNameField.setVisible(true); 643 dccAddressFieldLabel.setVisible(false); 644 dccAddressSpinner.setVisible(false); 645 break; 646 case TRAINSFROMOPS: 647 initializeFreeTrainsCombo(); 648 trainSelectBox.setVisible(true); 649 rosterComboBox.setVisible(false); 650 trainFieldLabel.setVisible(true); 651 trainNameField.setVisible(true); 652 dccAddressFieldLabel.setVisible(true); 653 dccAddressSpinner.setVisible(true); 654 setSpeedProfileOptions(trainInfo,false); 655 break; 656 case TRAINSFROMUSER: 657 trainNameField.setText(""); 658 trainSelectBox.setVisible(false); 659 rosterComboBox.setVisible(false); 660 trainFieldLabel.setVisible(true); 661 trainNameField.setVisible(true); 662 dccAddressFieldLabel.setVisible(true); 663 dccAddressSpinner.setVisible(true); 664 dccAddressSpinner.setEnabled(true); 665 setSpeedProfileOptions(trainInfo,false); 666 break; 667 case TRAINSFROMSETLATER: 668 default: 669 rosterComboBox.setVisible(false); 670 trainSelectBox.setVisible(false); 671 trainFieldLabel.setVisible(true); 672 trainNameField.setVisible(true); 673 dccAddressFieldLabel.setVisible(false); 674 dccAddressSpinner.setVisible(false); 675 } 676 } 677 678 private void initializeTrainTypeBox() { 679 trainTypeBox.removeAllItems(); 680 trainTypeBox.addItem("<" + Bundle.getMessage("None").toLowerCase() + ">"); // <none> 681 trainTypeBox.addItem(Bundle.getMessage("LOCAL_PASSENGER")); 682 trainTypeBox.addItem(Bundle.getMessage("LOCAL_FREIGHT")); 683 trainTypeBox.addItem(Bundle.getMessage("THROUGH_PASSENGER")); 684 trainTypeBox.addItem(Bundle.getMessage("THROUGH_FREIGHT")); 685 trainTypeBox.addItem(Bundle.getMessage("EXPRESS_PASSENGER")); 686 trainTypeBox.addItem(Bundle.getMessage("EXPRESS_FREIGHT")); 687 trainTypeBox.addItem(Bundle.getMessage("MOW")); 688 // NOTE: The above must correspond in order and name to definitions in ActiveTrain.java. 689 } 690 691 private void initializeTrainDetectionBox() { 692 trainDetectionComboBox.addItem(new TrainDetectionItem(Bundle.getMessage("TrainDetectionWholeTrain"),TrainDetection.TRAINDETECTION_WHOLETRAIN)); 693 trainDetectionComboBox.addItem(new TrainDetectionItem(Bundle.getMessage("TrainDetectionHeadAndTail"),TrainDetection.TRAINDETECTION_HEADANDTAIL)); 694 trainDetectionComboBox.addItem(new TrainDetectionItem(Bundle.getMessage("TrainDetectionHeadOnly"),TrainDetection.TRAINDETECTION_HEADONLY)); 695 } 696 697 private void initializeScaleLengthBox() { 698 trainLengthUnitsComboBox.addItem(new TrainLengthUnitsItem(Bundle.getMessage("TrainLengthInScaleFeet"), TrainLengthUnits.TRAINLENGTH_SCALEFEET)); 699 trainLengthUnitsComboBox.addItem(new TrainLengthUnitsItem(Bundle.getMessage("TrainLengthInScaleMeters"), TrainLengthUnits.TRAINLENGTH_SCALEMETERS)); 700 trainLengthUnitsComboBox.addItem(new TrainLengthUnitsItem(Bundle.getMessage("TrainLengthInActualInchs"), TrainLengthUnits.TRAINLENGTH_ACTUALINCHS)); 701 trainLengthUnitsComboBox.addItem(new TrainLengthUnitsItem(Bundle.getMessage("TrainLengthInActualcm"), TrainLengthUnits.TRAINLENGTH_ACTUALCM)); 702 } 703 704 private void handleTransitSelectionChanged(ActionEvent e) { 705 int index = transitSelectBox.getSelectedIndex(); 706 if (index < 0) { 707 return; 708 } 709 Transit t = transitSelectBox.getSelectedItem(); 710 if ((t != null) && (t != selectedTransit)) { 711 selectedTransit = t; 712 initializeStartingBlockCombo(); 713 initializeDestinationBlockCombo(); 714 initiateFrame.pack(); 715 } 716 } 717 718 private void handleInTransitClick() { 719 if (!inTransitBox.isSelected() && selectedTransit.getEntryBlocksList().isEmpty()) { 720 JmriJOptionPane.showMessageDialog(initiateFrame, Bundle 721 .getMessage("NoEntryBlocks"), Bundle.getMessage("MessageTitle"), 722 JmriJOptionPane.INFORMATION_MESSAGE); 723 inTransitBox.setSelected(true); 724 } 725 initializeStartingBlockCombo(); 726 initializeDestinationBlockCombo(); 727 initiateFrame.pack(); 728 } 729 730 private void handleTrainSelectionChanged() { 731 if (!trainsFromButtonGroup.getSelection().getActionCommand().equals("TRAINSFROMOPS")) { 732 return; 733 } 734 int ix = trainSelectBox.getSelectedIndex(); 735 if (ix < 1) { // no train selected 736 dccAddressSpinner.setEnabled(false); 737 return; 738 } 739 dccAddressSpinner.setEnabled(true); 740 int dccAddress; 741 try { 742 dccAddress = Integer.parseInt((((Train) trainSelectBox.getSelectedItem()).getLeadEngineDccAddress())); 743 } catch (NumberFormatException ex) { 744 JmriJOptionPane.showMessageDialog(initiateFrame, Bundle.getMessage("Error43"), 745 Bundle.getMessage("ErrorTitle"), JmriJOptionPane.ERROR_MESSAGE); 746 return; 747 } 748 dccAddressSpinner.setValue (dccAddress); 749 trainNameField.setText(((Train) trainSelectBox.getSelectedItem()).getName()); 750 } 751 752 private void handleRosterSelectionChanged(ActionEvent e) { 753 if (!trainsFromButtonGroup.getSelection().getActionCommand().equals("TRAINSFROMROSTER")) { 754 return; 755 } 756 int ix = rosterComboBox.getSelectedIndex(); 757 if (ix > 0) { // first item is "Select Loco" string 758 RosterEntry r = (RosterEntry) rosterComboBox.getItemAt(ix); 759 // check to see if speed profile exists and is not empty 760 if (r.getSpeedProfile() == null || r.getSpeedProfile().getProfileSize() < 1) { 761 // disable profile boxes etc. 762 setSpeedProfileOptions(trainInfo,false); 763 } else { 764 // enable profile boxes 765 setSpeedProfileOptions(trainInfo,true); 766 } 767 maxSpeedSpinner.setValue(r.getMaxSpeedPCT()/100.0f); 768 trainNameField.setText(r.titleString()); 769 if (r.getAttribute("DispatcherTrainType") != null && !r.getAttribute("DispatcherTrainType").equals("")) { 770 trainTypeBox.setSelectedItem(r.getAttribute("DispatcherTrainType")); 771 } 772 } else { 773 setSpeedProfileOptions(trainInfo,false); 774 } 775 } 776 777 private void handleDelayStartClick(ActionEvent e) { 778 departureHrSpinner.setVisible(false); 779 departureMinSpinner.setVisible(false); 780 departureTimeLabel.setVisible(false); 781 departureSepLabel.setVisible(false); 782 delaySensor.setVisible(false); 783 resetStartSensorBox.setVisible(false); 784 if (delayedStartBox.getSelectedItem().equals(Bundle.getMessage("DelayedStartTimed"))) { 785 departureHrSpinner.setVisible(true); 786 departureMinSpinner.setVisible(true); 787 departureTimeLabel.setVisible(true); 788 departureSepLabel.setVisible(true); 789 } else if (delayedStartBox.getSelectedItem().equals(Bundle.getMessage("DelayedStartSensor"))) { 790 delaySensor.setVisible(true); 791 resetStartSensorBox.setVisible(true); 792 } 793 initiateFrame.pack(); // to fit extra hh:mm in window 794 } 795 796 private void handleResetWhenDoneClick() { 797 delayMinSpinner.setVisible(false); 798 delayMinLabel.setVisible(false); 799 delayedReStartLabel.setVisible(false); 800 delayedReStartBox.setVisible(false); 801 delayReStartSensorLabel.setVisible(false); 802 delayReStartSensor.setVisible(false); 803 resetRestartSensorBox.setVisible(false); 804 if (resetWhenDoneBox.isSelected()) { 805 delayedReStartLabel.setVisible(true); 806 delayedReStartBox.setVisible(true); 807 terminateWhenDoneBox.setSelected(false); 808 if (delayedReStartBox.getSelectedItem().equals(Bundle.getMessage("DelayedStartTimed"))) { 809 delayMinSpinner.setVisible(true); 810 delayMinLabel.setVisible(true); 811 } else if (delayedReStartBox.getSelectedItem().equals(Bundle.getMessage("DelayedStartSensor"))) { 812 delayReStartSensor.setVisible(true); 813 delayReStartSensorLabel.setVisible(true); 814 resetRestartSensorBox.setVisible(true); 815 } 816 } else { 817 terminateWhenDoneBox.setEnabled(true); 818 } 819 initiateFrame.pack(); 820 } 821 822 private void handleTerminateWhenDoneBoxClick() { 823 if (terminateWhenDoneBox.isSelected()) { 824 refreshNextTrainCombo(); 825 resetWhenDoneBox.setSelected(false); 826 terminateWhenDoneDetails.setVisible(true); 827 } else { 828 terminateWhenDoneDetails.setVisible(false); 829 } 830 } 831 832 private void handleReverseAtEndBoxClick() { 833 delayReverseMinSpinner.setVisible(false); 834 delayReverseMinLabel.setVisible(false); 835 delayReverseReStartLabel.setVisible(false); 836 reverseDelayedRestartType.setVisible(false); 837 delayReverseReStartSensorLabel.setVisible(false); 838 delayReverseReStartSensor.setVisible(false); 839 delayReverseResetSensorBox.setVisible(false); 840 if (reverseAtEndBox.isSelected()) { 841 delayReverseReStartLabel.setVisible(true); 842 reverseDelayedRestartType.setVisible(true); 843 if (reverseDelayedRestartType.getSelectedItem().equals(Bundle.getMessage("DelayedStartTimed"))) { 844 delayReverseMinSpinner.setVisible(true); 845 delayReverseMinLabel.setVisible(true); 846 } else if (reverseDelayedRestartType.getSelectedItem().equals(Bundle.getMessage("DelayedStartSensor"))) { 847 delayReverseReStartSensor.setVisible(true); 848 delayReStartSensorLabel.setVisible(true); 849 delayReverseResetSensorBox.setVisible(true); 850 } 851 } 852 initiateFrame.pack(); 853 854 if (resetWhenDoneBox.isSelected()) { 855 terminateWhenDoneBox.setSelected(false); 856 terminateWhenDoneBox.setEnabled(false); 857 } else { 858 terminateWhenDoneBox.setEnabled(true); 859 } 860 } 861 862 private void handleAutoRunClick() { 863 if (autoRunBox.isSelected()) { 864 showAutoRunItems(); 865 } else { 866 hideAutoRunItems(); 867 } 868 initiateFrame.pack(); 869 } 870 871 private void handleStartingBlockSelectionChanged() { 872 if (radioTransitsAdHoc.isSelected() ) { 873 initializeViaBlockDynamicCombo(); 874 initializeDestinationBlockDynamicCombo(); 875 } else { 876 initializeDestinationBlockCombo(); 877 } 878 initiateFrame.pack(); 879 } 880 881 private void handleViaBlockSelectionChanged() { 882 if (radioTransitsAdHoc.isSelected() ) { 883 initializeDestinationBlockDynamicCombo(); 884 } else { 885 initializeDestinationBlockCombo(); 886 } 887 initiateFrame.pack(); 888 } 889 890 private void handleAllocateAllTheWayButtonChanged() { 891 allocateCustomSpinner.setVisible(false); 892 } 893 894 private void handleAllocateBySafeButtonChanged() { 895 allocateCustomSpinner.setVisible(false); 896 } 897 898 private void handleAllocateNumberOfBlocksButtonChanged() { 899 allocateCustomSpinner.setVisible(true); 900 } 901 902 private void cancelInitiateTrain() { 903 _dispatcher.newTrainDone(null); 904 } 905 906 /* 907 * Handles press of "Add New Train" button. 908 * Move data to TrainInfo validating basic information 909 * Call dispatcher to start the train from traininfo which 910 * completes validation. 911 */ 912 private void addNewTrain() { 913 try { 914 validateDialog(); 915 trainInfo = new TrainInfo(); 916 dialogToTrainInfo(trainInfo); 917 if (radioTransitsAdHoc.isSelected()) { 918 int ixStart, ixEnd, ixVia; 919 ixStart = startingBlockBox.getSelectedIndex(); 920 ixEnd = destinationBlockBox.getSelectedIndex(); 921 ixVia = viaBlockBox.getSelectedIndex(); 922 // search for a transit if ones available. 923 Transit tmpTransit = null; 924 int routeCount = 9999; 925 int startBlockSeq = 0; 926 int endBlockSeq = 0; 927 log.debug("Start[{}]Via[{}]Dest[{}}]", 928 startingBlockBoxList.get(ixStart).getDisplayName(), 929 viaBlockBoxList.get(ixVia).getDisplayName(), 930 destinationBlockBoxList.get(ixEnd).getDisplayName()); 931 for (Transit tr : InstanceManager.getDefault(jmri.TransitManager.class) 932 .getListUsingBlock(startingBlockBoxList.get(ixStart))) { 933 if (tr.getState() == Transit.IDLE 934 && tr.containsBlock(startingBlockBoxList.get(ixStart)) 935 && tr.containsBlock(viaBlockBoxList.get(ixVia)) && 936 tr.containsBlock(destinationBlockBoxList.get(ixEnd))) { 937 log.debug("[{}] contains all blocks", tr.getDisplayName()); 938 int ixCountStart = -1, ixCountVia = -1, ixCountDest = -1, ixCount = 0; 939 List<Block> transitBlocks = tr.getInternalBlocksList(); 940 List<Integer> transitBlockSeq = tr.getBlockSeqList(); 941 for (Block blk : transitBlocks) { 942 log.debug("Checking Block[{}] t[{}] BlockSequ[{}]", 943 blk.getDisplayName(), 944 ixCount, 945 transitBlockSeq.get(ixCount)); 946 if (ixCountStart == -1 && blk == startingBlockBoxList.get(ixStart)) { 947 log.trace("ixOne[{}]block[{}]",ixCount,blk.getDisplayName()); 948 ixCountStart = ixCount; 949 } else if (ixCountStart != -1 && ixCountVia == -1 && blk == viaBlockBoxList.get(ixVia)) { 950 log.trace("ixTwo[{}]block[{}]",ixCount,blk.getDisplayName()); 951 if (ixCount != ixCountStart + 1) { 952 log.debug("AdHoc {}:via and start not ajacent",tr.getDisplayName()); 953 break; 954 } 955 ixCountVia = ixCount; 956 } else if (ixCountStart != -1 && ixCountVia != -1 && ixCountDest == -1 && blk == destinationBlockBoxList.get(ixEnd)) { 957 ixCountDest = ixCount; 958 log.trace("ixThree[{}]block[{}]",ixCountDest,blk.getDisplayName()); 959 break; 960 } 961 ixCount++; 962 } 963 if (ixCountVia == (ixCountStart + 1) && ixCountDest > ixCountStart) { 964 log.debug("Canuse [{}", tr.getDisplayName()); 965 Integer routeBlockLength = 966 transitBlockSeq.get(ixCountDest) - transitBlockSeq.get(ixCountStart); 967 if (routeBlockLength < routeCount) { 968 routeCount = ixCountDest - ixCountStart; 969 tmpTransit = tr; 970 startBlockSeq = transitBlockSeq.get(ixCountStart).intValue(); 971 endBlockSeq = transitBlockSeq.get(ixCountDest).intValue(); 972 } 973 } 974 } 975 } 976 if (tmpTransit != null && 977 (JmriJOptionPane.showConfirmDialog(this, Bundle.getMessage("Question6",tmpTransit.getDisplayName()), 978 "Question", 979 JmriJOptionPane.YES_NO_OPTION, 980 JmriJOptionPane.QUESTION_MESSAGE) == JmriJOptionPane.YES_OPTION)) { 981 // use transit found 982 trainInfo.setDynamicTransit(false); 983 trainInfo.setTransitName(tmpTransit.getDisplayName()); 984 trainInfo.setTransitId(tmpTransit.getDisplayName()); 985 trainInfo.setStartBlockSeq(startBlockSeq); 986 trainInfo.setStartBlockName(getBlockName(startingBlockBoxList.get(ixStart)) + "-" + startBlockSeq); 987 trainInfo.setDestinationBlockSeq(endBlockSeq); 988 trainInfo.setDestinationBlockName(getBlockName(destinationBlockBoxList.get(ixEnd)) + "-" + endBlockSeq); 989 trainInfoToDialog(trainInfo); 990 } else { 991 // use a true ad-hoc 992 List<LayoutBlock> blockList = _dispatcher.getAdHocRoute(startingBlockBoxList.get(ixStart), 993 destinationBlockBoxList.get(ixEnd), 994 viaBlockBoxList.get(ixVia)); 995 if (blockList == null) { 996 JmriJOptionPane.showMessageDialog(initiateFrame, Bundle.getMessage("Error51"), 997 Bundle.getMessage("ErrorTitle"), JmriJOptionPane.ERROR_MESSAGE); 998 return; 999 } 1000 } 1001 } 1002 _dispatcher.loadTrainFromTrainInfoThrowsException(trainInfo,"NONE",""); 1003 } catch (IllegalArgumentException ex) { 1004 JmriJOptionPane.showMessageDialog(initiateFrame, ex.getMessage(), 1005 Bundle.getMessage("ErrorTitle"), JmriJOptionPane.ERROR_MESSAGE); 1006 } 1007 } 1008 1009 private void initializeFreeTransitsCombo(List<Transit> transitList) { 1010 Set<Transit> excludeTransits = new HashSet<>(); 1011 for (Transit t : _TransitManager.getNamedBeanSet()) { 1012 if (t.getState() != Transit.IDLE) { 1013 excludeTransits.add(t); 1014 } 1015 } 1016 transitSelectBox.setExcludedItems(excludeTransits); 1017 JComboBoxUtil.setupComboBoxMaxRows(transitSelectBox); 1018 1019 if (transitSelectBox.getItemCount() > 0) { 1020 transitSelectBox.setSelectedIndex(0); 1021 selectedTransit = transitSelectBox.getItemAt(0); 1022 } else { 1023 selectedTransit = null; 1024 } 1025 } 1026 1027 private void initializeFreeRosterEntriesCombo() { 1028 rosterComboBox.update(); 1029 // remove used entries 1030 for (int ix = rosterComboBox.getItemCount() - 1; ix > 1; ix--) { // remove from back first item is the "select loco" message 1031 if ( !_dispatcher.isAddressFree( ((RosterEntry)rosterComboBox.getItemAt(ix)).getDccLocoAddress().getNumber() ) ) { 1032 rosterComboBox.removeItemAt(ix); 1033 } 1034 } 1035 } 1036 1037 private void initializeFreeTrainsCombo() { 1038 Train prevValue = null; 1039 if (trainSelectBox.getSelectedIndex() > 0) { 1040 // item zero is a string 1041 prevValue = (Train)trainSelectBox.getSelectedItem(); 1042 } 1043 ActionListener[] als = trainSelectBox.getActionListeners(); 1044 for ( ActionListener al: als) { 1045 trainSelectBox.removeActionListener(al); 1046 } 1047 trainSelectBox.removeAllItems(); 1048 trainSelectBox.addItem("Select Train"); 1049 // initialize free trains from operations 1050 List<Train> trains = jmri.InstanceManager.getDefault(TrainManager.class).getTrainsByNameList(); 1051 if (trains.size() > 0) { 1052 for (int i = 0; i < trains.size(); i++) { 1053 Train t = trains.get(i); 1054 if (t != null) { 1055 String tName = t.getName(); 1056 if (_dispatcher.isTrainFree(tName)) { 1057 trainSelectBox.addItem(t); 1058 } 1059 } 1060 } 1061 } 1062 if (prevValue != null) { 1063 trainSelectBox.setSelectedItem(prevValue); 1064 } 1065 for ( ActionListener al: als) { 1066 trainSelectBox.addActionListener(al); 1067 } 1068 } 1069 1070 /** 1071 * Sets the labels and inputs for speed profile running 1072 * @param b True if the roster entry has valid speed profile else false 1073 */ 1074 private void setSpeedProfileOptions(TrainInfo info,boolean b) { 1075 useSpeedProfileLabel.setEnabled(b); 1076 useSpeedProfileCheckBox.setEnabled(b); 1077 stopBySpeedProfileLabel.setEnabled(b); 1078 stopBySpeedProfileCheckBox.setEnabled(b); 1079 stopBySpeedProfileAdjustLabel.setEnabled(b); 1080 stopBySpeedProfileAdjustSpinner.setEnabled(b); 1081 if (!b) { 1082 useSpeedProfileCheckBox.setSelected(false); 1083 stopBySpeedProfileCheckBox.setSelected(false); 1084 1085 } 1086 } 1087 1088 private void initializeStartingBlockCombo() { 1089 String prevValue = (String)startingBlockBox.getSelectedItem(); 1090 startingBlockBox.removeAllItems(); 1091 startingBlockBoxList.clear(); 1092 if (!inTransitBox.isSelected() && selectedTransit.getEntryBlocksList().isEmpty()) { 1093 inTransitBox.setSelected(true); 1094 } 1095 if (inTransitBox.isSelected()) { 1096 startingBlockBoxList = selectedTransit.getInternalBlocksList(); 1097 } else { 1098 startingBlockBoxList = selectedTransit.getEntryBlocksList(); 1099 } 1100 startingBlockSeqList = selectedTransit.getBlockSeqList(); 1101 boolean found = false; 1102 for (int i = 0; i < startingBlockBoxList.size(); i++) { 1103 Block b = startingBlockBoxList.get(i); 1104 int seq = startingBlockSeqList.get(i).intValue(); 1105 startingBlockBox.addItem(getBlockName(b) + "-" + seq); 1106 if (!found && b.getState() == Block.OCCUPIED) { 1107 startingBlockBox.setSelectedItem(getBlockName(b) + "-" + seq); 1108 found = true; 1109 } 1110 } 1111 if (prevValue != null) { 1112 startingBlockBox.setSelectedItem(prevValue); 1113 } 1114 JComboBoxUtil.setupComboBoxMaxRows(startingBlockBox); 1115 } 1116 1117 private void initializeDestinationBlockCombo() { 1118 String prevValue = (String)destinationBlockBox.getSelectedItem(); 1119 destinationBlockBox.removeAllItems(); 1120 destinationBlockBoxList.clear(); 1121 int index = startingBlockBox.getSelectedIndex(); 1122 if (index < 0) { 1123 return; 1124 } 1125 Block startBlock = startingBlockBoxList.get(index); 1126 destinationBlockBoxList = selectedTransit.getDestinationBlocksList( 1127 startBlock, inTransitBox.isSelected()); 1128 destinationBlockSeqList = selectedTransit.getDestBlocksSeqList(); 1129 for (int i = 0; i < destinationBlockBoxList.size(); i++) { 1130 Block b = destinationBlockBoxList.get(i); 1131 String bName = getBlockName(b); 1132 if (selectedTransit.getBlockCount(b) > 1) { 1133 int seq = destinationBlockSeqList.get(i).intValue(); 1134 bName = bName + "-" + seq; 1135 } 1136 destinationBlockBox.addItem(bName); 1137 } 1138 if (prevValue != null) { 1139 destinationBlockBox.setSelectedItem(prevValue); 1140 } 1141 JComboBoxUtil.setupComboBoxMaxRows(destinationBlockBox); 1142 } 1143 1144 private String getBlockName(Block b) { 1145 if (b != null) { 1146 return b.getDisplayName(); 1147 } 1148 return " "; 1149 } 1150 1151 protected void showActivateFrame() { 1152 if (initiateFrame != null) { 1153 initializeFreeTransitsCombo(new ArrayList<>()); 1154 initiateFrame.setVisible(true); 1155 } else { 1156 _dispatcher.newTrainDone(null); 1157 } 1158 } 1159 1160 public void showActivateFrame(RosterEntry re) { 1161 showActivateFrame(); 1162 } 1163 1164 protected void loadTrainInfo(ActionEvent e) { 1165 List<TrainInfoFileSummary> names = _tiFile.getTrainInfoFileSummaries(); 1166 if (!names.isEmpty()) { 1167 JTable table = new JTable(){ 1168 @Override 1169 public Dimension getPreferredScrollableViewportSize() { 1170 return new Dimension(super.getPreferredSize().width, 1171 super.getPreferredScrollableViewportSize().height); 1172 } 1173 }; 1174 DefaultTableModel tm = new DefaultTableModel( 1175 new Object[]{ 1176 Bundle.getMessage("FileNameColumnTitle"), 1177 Bundle.getMessage("TrainColumnTitle"), 1178 Bundle.getMessage("TransitColumnTitle"), 1179 Bundle.getMessage("StartBlockColumnTitle"), 1180 Bundle.getMessage("EndBlockColumnTitle"), 1181 Bundle.getMessage("DccColumnTitleColumnTitle") 1182 }, 0) { 1183 @Override 1184 public boolean isCellEditable(int row, int column) { 1185 //all cells false 1186 return false; 1187 } 1188 }; 1189 1190 table.setModel(tm); 1191 for (TrainInfoFileSummary fs: names) { 1192 tm.addRow(new Object[] {fs.getFileName(),fs.getTrainName(), 1193 fs.getTransitName(),fs.getStartBlockName() 1194 ,fs.getEndBlockName(),fs.getDccAddress()}); 1195 } 1196 JPanel jp = new JPanel(new BorderLayout()); 1197 TableColumnModel columnModel = table.getColumnModel(); 1198 table.setAutoResizeMode( JTable.AUTO_RESIZE_OFF ); 1199 for (int column = 0; column < table.getColumnCount(); column++) { 1200 int width = 30; // Min width 1201 for (int row = 0; row < table.getRowCount(); row++) { 1202 TableCellRenderer renderer = table.getCellRenderer(row, column); 1203 Component comp = table.prepareRenderer(renderer, row, column); 1204 width = Math.max(comp.getPreferredSize().width +1 , width); 1205 } 1206 if(width > 300) 1207 width=300; 1208 columnModel.getColumn(column).setPreferredWidth(width); 1209 } 1210 //jp.setPreferredSize(table.getPreferredSize()); 1211 jp.add(table); 1212 JScrollPane sp = new JScrollPane(table, 1213 ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED, 1214 ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED); 1215 int optionSelected = JmriJOptionPane.showOptionDialog(initiateFrame, 1216 sp, Bundle.getMessage("LoadTrainTitle"), JmriJOptionPane.OK_CANCEL_OPTION, JmriJOptionPane.PLAIN_MESSAGE, 1217 null,null,null); 1218 if (optionSelected != JmriJOptionPane.OK_OPTION) { 1219 //Canceled 1220 return; 1221 } 1222 if (table.getSelectedRow() < 0) { 1223 return; 1224 } 1225 String selName = (String)table.getModel().getValueAt(table.getSelectedRow(),0); 1226 if ((selName == null) || (selName.isEmpty())) { 1227 return; 1228 } 1229 //read xml data from selected filename and move it into the new train dialog box 1230 _trainInfoName = selName; 1231 try { 1232 trainInfo = _tiFile.readTrainInfo( selName); 1233 if (trainInfo != null) { 1234 // process the information just read 1235 trainInfoToDialog(trainInfo); 1236 } 1237 } catch (java.io.IOException ioe) { 1238 log.error("IO Exception when reading train info file", ioe); 1239 } catch (org.jdom2.JDOMException jde) { 1240 log.error("JDOM Exception when reading train info file", jde); 1241 } 1242 handleDelayStartClick(null); 1243 handleReverseAtEndBoxClick(); 1244 } 1245 } 1246 1247 private void saveTrainInfo() { 1248 saveTrainInfo(false); 1249 refreshNextTrainCombo(); 1250 } 1251 1252 private void saveTrainInfoAsTemplate() { 1253 saveTrainInfo(true); 1254 } 1255 1256 private void saveTrainInfo(boolean asTemplate) { 1257 try { 1258 dialogToTrainInfo(trainInfo); 1259 } catch (IllegalArgumentException ide) { 1260 JmriJOptionPane.showMessageDialog(initiateFrame, ide.getMessage(), 1261 Bundle.getMessage("ErrorTitle"), JmriJOptionPane.ERROR_MESSAGE); 1262 return; 1263 } 1264 // get file name 1265 String fileName; 1266 if (asTemplate) { 1267 fileName = normalizeXmlFileName(nameOfTemplateFile); 1268 } else { 1269 String eName = JmriJOptionPane.showInputDialog(initiateFrame, 1270 Bundle.getMessage("EnterFileName") + " :", _trainInfoName); 1271 if (eName == null) { //Cancel pressed 1272 return; 1273 } 1274 if (eName.length() < 1) { 1275 JmriJOptionPane.showMessageDialog(initiateFrame, Bundle.getMessage("Error25"), 1276 Bundle.getMessage("ErrorTitle"), JmriJOptionPane.ERROR_MESSAGE); 1277 return; 1278 } 1279 fileName = normalizeXmlFileName(eName); 1280 _trainInfoName = fileName; 1281 } 1282 // check if train info file name is in use 1283 String[] names = _tiFile.getTrainInfoFileNames(); 1284 if (names.length > 0) { 1285 boolean found = false; 1286 for (int i = 0; i < names.length; i++) { 1287 if (fileName.equals(names[i])) { 1288 found = true; 1289 } 1290 } 1291 if (found) { 1292 // file by that name is already present 1293 int selectedValue = JmriJOptionPane.showOptionDialog(initiateFrame, 1294 Bundle.getMessage("Question3", fileName), 1295 Bundle.getMessage("WarningTitle"), JmriJOptionPane.DEFAULT_OPTION, 1296 JmriJOptionPane.QUESTION_MESSAGE, null, 1297 new Object[]{Bundle.getMessage("ButtonReplace"),Bundle.getMessage("ButtonNo")}, 1298 Bundle.getMessage("ButtonNo")); 1299 if (selectedValue != 0 ) { // array position 0 , replace not selected 1300 return; // return without writing if "No" response 1301 } 1302 } 1303 } 1304 // write the Train Info file 1305 try { 1306 _tiFile.writeTrainInfo(trainInfo, fileName); 1307 } //catch (org.jdom2.JDOMException jde) { 1308 // log.error("JDOM exception writing Train Info: "+jde); 1309 //} 1310 catch (java.io.IOException ioe) { 1311 log.error("IO exception writing Train Info", ioe); 1312 } 1313 } 1314 1315 private void deleteTrainInfo() { 1316 String[] names = _tiFile.getTrainInfoFileNames(); 1317 if (names.length > 0) { 1318 Object selName = JmriJOptionPane.showInputDialog(initiateFrame, 1319 Bundle.getMessage("DeleteTrainChoice"), Bundle.getMessage("DeleteTrainTitle"), 1320 JmriJOptionPane.QUESTION_MESSAGE, null, names, names[0]); 1321 if ((selName == null) || (((String) selName).isEmpty())) { 1322 return; 1323 } 1324 _tiFile.deleteTrainInfoFile((String) selName); 1325 } 1326 } 1327 1328 private void trainInfoToDialog(TrainInfo info) { 1329 if (!info.getDynamicTransit()) { 1330 radioTransitsPredefined.setSelected(true); 1331 if (!info.getTransitName().isEmpty()) { 1332 try { 1333 transitSelectBox.setSelectedItemByName(info.getTransitName()); 1334 } catch (Exception ex) { 1335 log.warn("Transit {} from file not in Transit menu", info.getTransitName()); 1336 JmriJOptionPane.showMessageDialog(initiateFrame, 1337 Bundle.getMessage("TransitWarn", info.getTransitName()), 1338 null, JmriJOptionPane.WARNING_MESSAGE); 1339 } 1340 } 1341 } else { 1342 radioTransitsAdHoc.setSelected(true); 1343 } 1344 switch (info.getTrainsFrom()) { 1345 case TRAINSFROMROSTER: 1346 radioTrainsFromRoster.setSelected(true); 1347 if (!info.getRosterId().isEmpty()) { 1348 if (!setRosterComboBox(rosterComboBox, info.getRosterId())) { 1349 log.warn("Roster {} from file not in Roster Combo", info.getRosterId()); 1350 JmriJOptionPane.showMessageDialog(initiateFrame, 1351 Bundle.getMessage("TrainWarn", info.getRosterId()), 1352 null, JmriJOptionPane.WARNING_MESSAGE); 1353 } 1354 } 1355 break; 1356 case TRAINSFROMOPS: 1357 radioTrainsFromOps.setSelected(true); 1358 if (!info.getTrainName().isEmpty()) { 1359 if (!setTrainComboBox(trainSelectBox, info.getTrainName())) { 1360 log.warn("Train {} from file not in Train Combo", info.getTrainName()); 1361 JmriJOptionPane.showMessageDialog(initiateFrame, 1362 Bundle.getMessage("TrainWarn", info.getTrainName()), 1363 null, JmriJOptionPane.WARNING_MESSAGE); 1364 } 1365 } 1366 break; 1367 case TRAINSFROMUSER: 1368 radioTrainsFromUser.setSelected(true); 1369 dccAddressSpinner.setValue(Integer.valueOf(info.getDccAddress())); 1370 break; 1371 case TRAINSFROMSETLATER: 1372 default: 1373 radioTrainsFromSetLater.setSelected(true); 1374 } 1375 trainNameField.setText(info.getTrainUserName()); 1376 trainDetectionComboBox.setSelectedItemByValue(info.getTrainDetection()); 1377 inTransitBox.setSelected(info.getTrainInTransit()); 1378 if (radioTransitsAdHoc.isSelected()) { 1379 initializeStartingBlockComboDynamic(); 1380 } else { 1381 initializeStartingBlockCombo(); 1382 } 1383 setComboBox(startingBlockBox, info.getStartBlockName()); 1384 if (radioTransitsAdHoc.isSelected()) { 1385 initializeViaBlockDynamicCombo(); 1386 setComboBox(viaBlockBox, info.getViaBlockName()); 1387 } 1388 if (radioTransitsAdHoc.isSelected()) { 1389 initializeDestinationBlockDynamicCombo(); 1390 } else { 1391 initializeDestinationBlockCombo(); 1392 } 1393 setComboBox(destinationBlockBox, info.getDestinationBlockName()); 1394 1395 setAllocateMethodButtons(info.getAllocationMethod()); 1396 prioritySpinner.setValue(info.getPriority()); 1397 resetWhenDoneBox.setSelected(info.getResetWhenDone()); 1398 reverseAtEndBox.setSelected(info.getReverseAtEnd()); 1399 setDelayModeBox(info.getDelayedStart(), delayedStartBox); 1400 //delayedStartBox.setSelected(info.getDelayedStart()); 1401 departureHrSpinner.setValue(info.getDepartureTimeHr()); 1402 departureMinSpinner.setValue(info.getDepartureTimeMin()); 1403 delaySensor.setSelectedItem(info.getDelaySensor()); 1404 resetStartSensorBox.setSelected(info.getResetStartSensor()); 1405 setDelayModeBox(info.getDelayedRestart(), delayedReStartBox); 1406 delayMinSpinner.setValue(info.getRestartDelayMin()); 1407 delayReStartSensor.setSelectedItem(info.getRestartSensor()); 1408 resetRestartSensorBox.setSelected(info.getResetRestartSensor()); 1409 1410 resetStartSensorBox.setSelected(info.getResetStartSensor()); 1411 setDelayModeBox(info.getReverseDelayedRestart(), reverseDelayedRestartType); 1412 delayReverseMinSpinner.setValue(info.getReverseRestartDelayMin()); 1413 delayReverseReStartSensor.setSelectedItem(info.getReverseRestartSensor()); 1414 delayReverseResetSensorBox.setSelected(info.getReverseResetRestartSensor()); 1415 1416 terminateWhenDoneBox.setSelected(info.getTerminateWhenDone()); 1417 nextTrain.setSelectedIndex(-1); 1418 try { 1419 nextTrain.setSelectedItem(info.getNextTrain()); 1420 } catch (Exception ex){ 1421 nextTrain.setSelectedIndex(-1); 1422 } 1423 handleTerminateWhenDoneBoxClick(); 1424 setComboBox(trainTypeBox, info.getTrainType()); 1425 autoRunBox.setSelected(info.getAutoRun()); 1426 loadAtStartupBox.setSelected(info.getLoadAtStartup()); 1427 setAllocateMethodButtons(info.getAllocationMethod()); 1428 autoTrainInfoToDialog(info); 1429 } 1430 1431 private boolean validateDialog() throws IllegalArgumentException { 1432 int index = transitSelectBox.getSelectedIndex(); 1433 if (index < 0) { 1434 throw new IllegalArgumentException(Bundle.getMessage("Error44")); 1435 } 1436 switch (trainsFromButtonGroup.getSelection().getActionCommand()) { 1437 case "TRAINSFROMROSTER": 1438 if (rosterComboBox.getSelectedIndex() < 1 ) { 1439 throw new IllegalArgumentException(Bundle.getMessage("Error41")); 1440 } 1441 break; 1442 case "TRAINSFROMOPS": 1443 if (trainSelectBox.getSelectedIndex() < 1) { 1444 throw new IllegalArgumentException(Bundle.getMessage("Error42")); 1445 } 1446 break; 1447 case "TRAINSFROMUSER": 1448 if (trainNameField.getText().isEmpty()) { 1449 throw new IllegalArgumentException(Bundle.getMessage("Error22")); 1450 } 1451 break; 1452 case "TRAINSFROMSETLATER": 1453 default: 1454 } 1455 index = startingBlockBox.getSelectedIndex(); 1456 if (index < 0) { 1457 throw new IllegalArgumentException(Bundle.getMessage("Error13")); 1458 } 1459 index = destinationBlockBox.getSelectedIndex(); 1460 if (index < 0) { 1461 throw new IllegalArgumentException(Bundle.getMessage("Error8")); 1462 } 1463 if (radioTransitsAdHoc.isSelected()) { 1464 index = viaBlockBox.getSelectedIndex(); 1465 if (index < 0) { 1466 throw new IllegalArgumentException(Bundle.getMessage("Error8")); 1467 } 1468 } 1469 if ((!reverseAtEndBox.isSelected()) && resetWhenDoneBox.isSelected() 1470 && (!selectedTransit.canBeResetWhenDone())) { 1471 resetWhenDoneBox.setSelected(false); 1472 throw new IllegalArgumentException(Bundle.getMessage("NoResetMessage")); 1473 } 1474 int max = Math.round((float) maxSpeedSpinner.getValue()*100.0f); 1475 int min = Math.round((float) minReliableOperatingSpeedSpinner.getValue()*100.0f); 1476 if ((max-min) < 10) { 1477 throw new IllegalArgumentException(Bundle.getMessage("Error49", 1478 maxSpeedSpinner.getValue(), minReliableOperatingSpeedSpinner.getValue())); 1479 } 1480 return true; 1481 } 1482 1483 private boolean dialogToTrainInfo(TrainInfo info) { 1484 int index = transitSelectBox.getSelectedIndex(); 1485 info.setDynamicTransit(radioTransitsAdHoc.isSelected()); 1486 if (!info.getDynamicTransit() && index >= 0 ) { 1487 info.setTransitName(transitSelectBox.getSelectedItem().getDisplayName()); 1488 info.setTransitId(transitSelectBox.getSelectedItem().getDisplayName()); 1489 } 1490 switch (trainsFromButtonGroup.getSelection().getActionCommand()) { 1491 case "TRAINSFROMROSTER": 1492 info.setRosterId(((RosterEntry) rosterComboBox.getSelectedItem()).getId()); 1493 info.setDccAddress(((RosterEntry) rosterComboBox.getSelectedItem()).getDccAddress()); 1494 trainInfo.setTrainsFrom(TrainsFrom.TRAINSFROMROSTER); 1495 setTrainsFromOptions(trainInfo.getTrainsFrom()); 1496 break; 1497 case "TRAINSFROMOPS": 1498 info.setTrainName(((Train) trainSelectBox.getSelectedItem()).toString()); 1499 info.setDccAddress(String.valueOf(dccAddressSpinner.getValue())); 1500 trainInfo.setTrainsFrom(TrainsFrom.TRAINSFROMOPS); 1501 setTrainsFromOptions(trainInfo.getTrainsFrom()); 1502 break; 1503 case "TRAINSFROMUSER": 1504 trainInfo.setTrainsFrom(TrainsFrom.TRAINSFROMUSER); 1505 info.setDccAddress(String.valueOf(dccAddressSpinner.getValue())); 1506 break; 1507 case "TRAINSFROMSETLATER": 1508 default: 1509 trainInfo.setTrainsFrom(TrainsFrom.TRAINSFROMSETLATER); 1510 info.setTrainName(""); 1511 info.setDccAddress(""); 1512 } 1513 info.setTrainUserName(trainNameField.getText()); 1514 info.setTrainInTransit(inTransitBox.isSelected()); 1515 info.setStartBlockName((String) startingBlockBox.getSelectedItem()); 1516 index = startingBlockBox.getSelectedIndex(); 1517 info.setStartBlockId(startingBlockBoxList.get(index).getDisplayName()); 1518 if (info.getDynamicTransit()) { 1519 info.setStartBlockSeq(1); 1520 } else { 1521 info.setStartBlockSeq(startingBlockSeqList.get(index).intValue()); 1522 } 1523 index = destinationBlockBox.getSelectedIndex(); 1524 info.setDestinationBlockId(destinationBlockBoxList.get(index).getDisplayName()); 1525 info.setDestinationBlockName(destinationBlockBoxList.get(index).getDisplayName()); 1526 if (info.getDynamicTransit()) { 1527 info.setViaBlockName(viaBlockBoxList.get(viaBlockBox.getSelectedIndex()).getDisplayName()); 1528 } else { 1529 info.setDestinationBlockSeq(destinationBlockSeqList.get(index).intValue()); 1530 } 1531 info.setPriority((Integer) prioritySpinner.getValue()); 1532 info.setTrainDetection(((TrainDetectionItem)trainDetectionComboBox.getSelectedItem()).value); 1533 info.setResetWhenDone(resetWhenDoneBox.isSelected()); 1534 info.setReverseAtEnd(reverseAtEndBox.isSelected()); 1535 info.setDelayedStart(delayModeFromBox(delayedStartBox)); 1536 info.setDelaySensorName(delaySensor.getSelectedItemDisplayName()); 1537 info.setResetStartSensor(resetStartSensorBox.isSelected()); 1538 info.setDepartureTimeHr((Integer) departureHrSpinner.getValue()); 1539 info.setDepartureTimeMin((Integer) departureMinSpinner.getValue()); 1540 info.setTrainType((String) trainTypeBox.getSelectedItem()); 1541 info.setAutoRun(autoRunBox.isSelected()); 1542 info.setLoadAtStartup(loadAtStartupBox.isSelected()); 1543 info.setAllocateAllTheWay(false); // force to false next field is now used. 1544 if (allocateAllTheWayRadioButton.isSelected()) { 1545 info.setAllocationMethod(ActiveTrain.ALLOCATE_AS_FAR_AS_IT_CAN); 1546 } else if (allocateBySafeRadioButton.isSelected()) { 1547 info.setAllocationMethod(ActiveTrain.ALLOCATE_BY_SAFE_SECTIONS); 1548 } else { 1549 info.setAllocationMethod((Integer) allocateCustomSpinner.getValue()); 1550 } 1551 info.setDelayedRestart(delayModeFromBox(delayedReStartBox)); 1552 info.setRestartSensorName(delayReStartSensor.getSelectedItemDisplayName()); 1553 info.setResetRestartSensor(resetRestartSensorBox.isSelected()); 1554 info.setRestartDelayMin((Integer) delayMinSpinner.getValue()); 1555 1556 info.setReverseDelayedRestart(delayModeFromBox(reverseDelayedRestartType)); 1557 info.setReverseRestartSensorName(delayReverseReStartSensor.getSelectedItemDisplayName()); 1558 info.setReverseResetRestartSensor(delayReverseResetSensorBox.isSelected()); 1559 info.setReverseRestartDelayMin((Integer) delayReverseMinSpinner.getValue()); 1560 1561 info.setTerminateWhenDone(terminateWhenDoneBox.isSelected()); 1562 if (nextTrain.getSelectedIndex() > 0 ) { 1563 info.setNextTrain((String)nextTrain.getSelectedItem()); 1564 } else { 1565 info.setNextTrain("None"); 1566 } 1567 autoRunItemsToTrainInfo(info); 1568 return true; 1569 } 1570 1571 private boolean setRosterComboBox(RosterEntryComboBox box, String txt) { 1572 boolean found = false; 1573 for (int i = 1; i < box.getItemCount(); i++) { 1574 if (txt.equals(((RosterEntry) box.getItemAt(i)).getId())) { 1575 box.setSelectedIndex(i); 1576 found = true; 1577 break; 1578 } 1579 } 1580 if (!found && box.getItemCount() > 0) { 1581 box.setSelectedIndex(0); 1582 } 1583 return found; 1584 } 1585 1586 // Normalizes a suggested xml file name. Returns null string if a valid name cannot be assembled 1587 private String normalizeXmlFileName(String name) { 1588 if (name.length() < 1) { 1589 return ""; 1590 } 1591 String newName = name; 1592 // strip off .xml or .XML if present 1593 if ((name.endsWith(".xml")) || (name.endsWith(".XML"))) { 1594 newName = name.substring(0, name.length() - 4); 1595 if (newName.length() < 1) { 1596 return ""; 1597 } 1598 } 1599 // replace all non-alphanumeric characters with underscore 1600 newName = newName.replaceAll("[\\W]", "_"); 1601 return (newName + ".xml"); 1602 } 1603 1604 private boolean setTrainComboBox(JComboBox<Object> box, String txt) { 1605 boolean found = false; 1606 for (int i = 1; i < box.getItemCount(); i++) { //skip the select train item 1607 if (txt.equals(box.getItemAt(i).toString())) { 1608 box.setSelectedIndex(i); 1609 found = true; 1610 break; 1611 } 1612 } 1613 if (!found && box.getItemCount() > 0) { 1614 box.setSelectedIndex(0); 1615 } 1616 return found; 1617 } 1618 1619 private boolean setComboBox(JComboBox<String> box, String txt) { 1620 boolean found = false; 1621 for (int i = 0; i < box.getItemCount(); i++) { 1622 if (txt.equals(box.getItemAt(i))) { 1623 box.setSelectedIndex(i); 1624 found = true; 1625 break; 1626 } 1627 } 1628 if (!found && box.getItemCount() > 0) { 1629 box.setSelectedIndex(0); 1630 } 1631 return found; 1632 } 1633 1634 int delayModeFromBox(JComboBox<String> box) { 1635 String mode = (String) box.getSelectedItem(); 1636 int result = jmri.util.StringUtil.getStateFromName(mode, delayedStartInt, delayedStartString); 1637 1638 if (result < 0) { 1639 log.warn("unexpected mode string in turnoutMode: {}", mode); 1640 throw new IllegalArgumentException(); 1641 } 1642 return result; 1643 } 1644 1645 void setDelayModeBox(int mode, JComboBox<String> box) { 1646 String result = jmri.util.StringUtil.getNameFromState(mode, delayedStartInt, delayedStartString); 1647 box.setSelectedItem(result); 1648 } 1649 1650 /** 1651 * The following are for items that are only for automatic running of 1652 * ActiveTrains They are isolated here to simplify changing them in the 1653 * future. 1654 * <ul> 1655 * <li>initializeAutoRunItems - initializes the display of auto run items in 1656 * this window 1657 * <li>initializeAutoRunValues - initializes the values of auto run items 1658 * from values in a saved train info file hideAutoRunItems - hides all auto 1659 * run items in this window showAutoRunItems - shows all auto run items in 1660 * this window 1661 * <li>autoTrainInfoToDialog - gets auto run items from a train info, puts 1662 * values in items, and initializes auto run dialog items 1663 * <li>autoTrainItemsToTrainInfo - copies values of auto run items to train 1664 * info for saving to a file 1665 * <li>readAutoRunItems - reads and checks values of all auto run items. 1666 * returns true if OK, sends appropriate messages and returns false if not 1667 * OK 1668 * <li>setAutoRunItems - sets the user entered auto run items in the new 1669 * AutoActiveTrain 1670 * </ul> 1671 */ 1672 // auto run items in ActivateTrainFrame 1673 private final JPanel pa1 = new JPanel(); 1674 private final JLabel speedFactorLabel = new JLabel(Bundle.getMessage("SpeedFactorLabel")); 1675 private final JSpinner speedFactorSpinner = new JSpinner(); 1676 private final JLabel minReliableOperatingSpeedLabel = new JLabel(Bundle.getMessage("MinReliableOperatingSpeedLabel")); 1677 private final JSpinner minReliableOperatingSpeedSpinner = new JSpinner(); 1678 private final JLabel maxSpeedLabel = new JLabel(Bundle.getMessage("MaxSpeedLabel")); 1679 private final JSpinner maxSpeedSpinner = new JSpinner(); 1680 private final JPanel pa2 = new JPanel(); 1681 private final JLabel rampRateLabel = new JLabel(Bundle.getMessage("RampRateBoxLabel")); 1682 private final JComboBox<String> rampRateBox = new JComboBox<>(); 1683 private final JPanel pa2a = new JPanel(); 1684 private final JLabel useSpeedProfileLabel = new JLabel(Bundle.getMessage("UseSpeedProfileLabel")); 1685 private final JCheckBox useSpeedProfileCheckBox = new JCheckBox( ); 1686 private final JLabel stopBySpeedProfileLabel = new JLabel(Bundle.getMessage("StopBySpeedProfileLabel")); 1687 private final JCheckBox stopBySpeedProfileCheckBox = new JCheckBox( ); 1688 private final JLabel stopBySpeedProfileAdjustLabel = new JLabel(Bundle.getMessage("StopBySpeedProfileAdjustLabel")); 1689 private final JSpinner stopBySpeedProfileAdjustSpinner = new JSpinner(); 1690 private final JPanel pa3 = new JPanel(); 1691 private final JCheckBox soundDecoderBox = new JCheckBox(Bundle.getMessage("SoundDecoder")); 1692 private final JCheckBox runInReverseBox = new JCheckBox(Bundle.getMessage("RunInReverse")); 1693 private final JPanel pa4 = new JPanel(); 1694 1695 protected static class TrainDetectionJCombo extends JComboBox<TrainDetectionItem> { 1696 public void setSelectedItemByValue(TrainDetection trainDetVar) { 1697 for ( int ix = 0; ix < getItemCount() ; ix ++ ) { 1698 if (getItemAt(ix).value == trainDetVar) { 1699 this.setSelectedIndex(ix); 1700 break; 1701 } 1702 } 1703 } 1704 } 1705 1706 private final JLabel trainDetectionLabel = new JLabel(Bundle.getMessage("TrainDetection")); 1707 public final TrainDetectionJCombo trainDetectionComboBox = new TrainDetectionJCombo(); 1708 1709 protected static class TrainLengthUnitsJCombo extends JComboBox<TrainLengthUnitsItem> { 1710 public void setSelectedItemByValue(TrainLengthUnits var) { 1711 for ( int ix = 0; ix < getItemCount() ; ix ++ ) { 1712 if (getItemAt(ix).value == var) { 1713 this.setSelectedIndex(ix); 1714 break; 1715 } 1716 } 1717 } 1718 } 1719 1720 public final TrainLengthUnitsJCombo trainLengthUnitsComboBox = new TrainLengthUnitsJCombo(); 1721 private final JLabel trainLengthLabel = new JLabel(Bundle.getMessage("MaxTrainLengthLabel")); 1722 private JLabel trainLengthAltLengthLabel; // I18N Label 1723 private final JSpinner maxTrainLengthSpinner = new JSpinner(); // initialized later 1724 1725 private void initializeAutoRunItems() { 1726 initializeRampCombo(); 1727 initializeScaleLengthBox(); 1728 pa1.setLayout(new FlowLayout()); 1729 pa1.add(speedFactorLabel); 1730 speedFactorSpinner.setModel(new SpinnerNumberModel(1.0f, 0.1f, 2.0f, 0.01f)); 1731 speedFactorSpinner.setEditor(new JSpinner.NumberEditor(speedFactorSpinner, "# %")); 1732 pa1.add(speedFactorSpinner); 1733 speedFactorSpinner.setToolTipText(Bundle.getMessage("SpeedFactorHint")); 1734 pa1.add(new JLabel(" ")); 1735 pa1.add(maxSpeedLabel); 1736 maxSpeedSpinner.setModel(new SpinnerNumberModel(1.0f, 0.1f, 1.0f, 0.01f)); 1737 maxSpeedSpinner.setEditor(new JSpinner.NumberEditor(maxSpeedSpinner, "# %")); 1738 pa1.add(maxSpeedSpinner); 1739 maxSpeedSpinner.setToolTipText(Bundle.getMessage("MaxSpeedHint")); 1740 pa1.add(minReliableOperatingSpeedLabel); 1741 minReliableOperatingSpeedSpinner.setModel(new SpinnerNumberModel(0.0f, 0.0f, 1.0f, 0.01f)); 1742 minReliableOperatingSpeedSpinner.setEditor(new JSpinner.NumberEditor(minReliableOperatingSpeedSpinner, "# %")); 1743 pa1.add(minReliableOperatingSpeedSpinner); 1744 minReliableOperatingSpeedSpinner.setToolTipText(Bundle.getMessage("MinReliableOperatingSpeedHint")); 1745 initiatePane.add(pa1); 1746 pa2.setLayout(new FlowLayout()); 1747 pa2.add(rampRateLabel); 1748 pa2.add(rampRateBox); 1749 rampRateBox.setToolTipText(Bundle.getMessage("RampRateBoxHint")); 1750 pa2.add(useSpeedProfileLabel); 1751 pa2.add(useSpeedProfileCheckBox); 1752 useSpeedProfileCheckBox.setToolTipText(Bundle.getMessage("UseSpeedProfileHint")); 1753 initiatePane.add(pa2); 1754 pa2a.setLayout(new FlowLayout()); 1755 pa2a.add(stopBySpeedProfileLabel); 1756 pa2a.add(stopBySpeedProfileCheckBox); 1757 stopBySpeedProfileCheckBox.setToolTipText(Bundle.getMessage("UseSpeedProfileHint")); // reuse identical hint for Stop 1758 pa2a.add(stopBySpeedProfileAdjustLabel); 1759 stopBySpeedProfileAdjustSpinner.setModel(new SpinnerNumberModel( 1.0f, 0.1f, 5.0f, 0.01f)); 1760 stopBySpeedProfileAdjustSpinner.setEditor(new JSpinner.NumberEditor(stopBySpeedProfileAdjustSpinner, "# %")); 1761 pa2a.add(stopBySpeedProfileAdjustSpinner); 1762 stopBySpeedProfileAdjustSpinner.setToolTipText(Bundle.getMessage("StopBySpeedProfileAdjustHint")); 1763 initiatePane.add(pa2a); 1764 pa3.setLayout(new FlowLayout()); 1765 pa3.add(soundDecoderBox); 1766 soundDecoderBox.setToolTipText(Bundle.getMessage("SoundDecoderBoxHint")); 1767 pa3.add(new JLabel(" ")); 1768 pa3.add(runInReverseBox); 1769 runInReverseBox.setToolTipText(Bundle.getMessage("RunInReverseBoxHint")); 1770 initiatePane.add(pa3); 1771 maxTrainLengthSpinner.setModel(new SpinnerNumberModel(18.0f, 0.0f, 10000.0f, 0.5f)); 1772 maxTrainLengthSpinner.setEditor(new JSpinner.NumberEditor(maxTrainLengthSpinner, "###0.0")); 1773 maxTrainLengthSpinner.setToolTipText(Bundle.getMessage("MaxTrainLengthHint")); // won't be updated while Dispatcher is open 1774 maxTrainLengthSpinner.addChangeListener( e -> handlemaxTrainLengthChangeUnitsLength()); 1775 trainLengthUnitsComboBox.addActionListener( e -> handlemaxTrainLengthChangeUnitsLength()); 1776 trainLengthAltLengthLabel=new JLabel(); 1777 pa4.setLayout(new FlowLayout()); 1778 pa4.add(trainLengthLabel); 1779 pa4.add(maxTrainLengthSpinner); 1780 pa4.add(trainLengthUnitsComboBox); 1781 pa4.add(trainLengthAltLengthLabel); 1782 initiatePane.add(pa4); 1783 hideAutoRunItems(); // initialize with auto run items hidden 1784 } 1785 1786 private void handlemaxTrainLengthChangeUnitsLength() { 1787 trainLengthAltLengthLabel.setText(maxTrainLengthCalculateAltFormatted( 1788 ((TrainLengthUnitsItem) trainLengthUnitsComboBox.getSelectedItem()).getValue(), 1789 (float) maxTrainLengthSpinner.getValue())); 1790 } 1791 1792 /** 1793 * Get an I18N String of the max TrainLength. 1794 * @param fromUnits the Length Unit. 1795 * @param fromValue the length. 1796 * @return String format of the length. 1797 */ 1798 private String maxTrainLengthCalculateAltFormatted(TrainLengthUnits fromUnits, float fromValue) { 1799 float value = maxTrainLengthCalculateAlt(fromUnits, fromValue); 1800 switch (fromUnits) { 1801 case TRAINLENGTH_ACTUALINCHS: 1802 return String.format(Locale.getDefault(), "%.2f %s", 1803 value, Bundle.getMessage("TrainLengthInScaleFeet")); 1804 case TRAINLENGTH_ACTUALCM: 1805 return String.format(Locale.getDefault(), "%.1f %s", 1806 value, Bundle.getMessage("TrainLengthInScaleMeters")); 1807 case TRAINLENGTH_SCALEFEET: 1808 return String.format(Locale.getDefault(), "%.1f %s", 1809 value, Bundle.getMessage("TrainLengthInActualInchs")); 1810 case TRAINLENGTH_SCALEMETERS: 1811 return String.format(Locale.getDefault(), "%.0f %s", 1812 value, Bundle.getMessage("TrainLengthInActualcm")); 1813 default: 1814 log.error("Invalid TrainLengthUnits must have been updated, fix maxTrainLengthCalculateAltFormatted"); 1815 } 1816 return ""; 1817 } 1818 1819 private float maxTrainLengthToScaleMeters(TrainLengthUnits fromUnits, float fromValue) { 1820 float value; 1821 // convert to meters. 1822 switch (fromUnits) { 1823 case TRAINLENGTH_ACTUALINCHS: 1824 value = fromValue / 12.0f * (float) _dispatcher.getScale().getScaleRatio(); 1825 value = value / 3.28084f; 1826 break; 1827 case TRAINLENGTH_ACTUALCM: 1828 value = fromValue / 100.0f * (float) _dispatcher.getScale().getScaleRatio(); 1829 break; 1830 case TRAINLENGTH_SCALEFEET: 1831 value = fromValue / 3.28084f; 1832 break; 1833 case TRAINLENGTH_SCALEMETERS: 1834 value = fromValue; 1835 break; 1836 default: 1837 value = 0; 1838 log.error("Invalid TrainLengthUnits has been updated, fix me"); 1839 } 1840 return value; 1841 } 1842 1843 /* 1844 * Calculates the reciprocal unit. Actual to Scale and vice versa 1845 */ 1846 private float maxTrainLengthCalculateAlt(TrainLengthUnits fromUnits, float fromValue) { 1847 switch (fromUnits) { 1848 case TRAINLENGTH_ACTUALINCHS: 1849 // calc scale feet 1850 return (float) jmri.util.MathUtil.granulize(fromValue / 12 * (float) _dispatcher.getScale().getScaleRatio(),0.1f); 1851 case TRAINLENGTH_ACTUALCM: 1852 // calc scale meter 1853 return fromValue / 100 * (float) _dispatcher.getScale().getScaleRatio(); 1854 case TRAINLENGTH_SCALEFEET: 1855 // calc actual inchs 1856 return fromValue * 12 * (float) _dispatcher.getScale().getScaleFactor(); 1857 case TRAINLENGTH_SCALEMETERS: 1858 // calc actual cm. 1859 return fromValue * 100 * (float) _dispatcher.getScale().getScaleFactor(); 1860 default: 1861 log.error("Invalid TrainLengthUnits has been updated, fix me"); 1862 } 1863 return 0; 1864 } 1865 1866 private void hideAutoRunItems() { 1867 pa1.setVisible(false); 1868 pa2.setVisible(false); 1869 pa2a.setVisible(false); 1870 pa3.setVisible(false); 1871 pa4.setVisible(false); 1872 } 1873 1874 private void showAutoRunItems() { 1875 pa1.setVisible(true); 1876 pa2.setVisible(true); 1877 pa2a.setVisible(true); 1878 pa3.setVisible(true); 1879 pa4.setVisible(true); 1880 } 1881 1882 private void autoTrainInfoToDialog(TrainInfo info) { 1883 speedFactorSpinner.setValue(info.getSpeedFactor()); 1884 maxSpeedSpinner.setValue(info.getMaxSpeed()); 1885 minReliableOperatingSpeedSpinner.setValue(info.getMinReliableOperatingSpeed()); 1886 setComboBox(rampRateBox, info.getRampRate()); 1887 trainDetectionComboBox.setSelectedItemByValue(info.getTrainDetection()); 1888 runInReverseBox.setSelected(info.getRunInReverse()); 1889 soundDecoderBox.setSelected(info.getSoundDecoder()); 1890 trainLengthUnitsComboBox.setSelectedItemByValue(info.getTrainLengthUnits()); 1891 switch (info.getTrainLengthUnits()) { 1892 case TRAINLENGTH_SCALEFEET: 1893 maxTrainLengthSpinner.setValue(info.getMaxTrainLengthScaleFeet()); 1894 break; 1895 case TRAINLENGTH_SCALEMETERS: 1896 maxTrainLengthSpinner.setValue(info.getMaxTrainLengthScaleMeters()); 1897 break; 1898 case TRAINLENGTH_ACTUALINCHS: 1899 maxTrainLengthSpinner.setValue(info.getMaxTrainLengthScaleFeet() * 12.0f * (float)_dispatcher.getScale().getScaleFactor()); 1900 break; 1901 case TRAINLENGTH_ACTUALCM: 1902 maxTrainLengthSpinner.setValue(info.getMaxTrainLengthScaleMeters() * 100.0f * (float)_dispatcher.getScale().getScaleFactor()); 1903 break; 1904 default: 1905 maxTrainLengthSpinner.setValue(0.0f); 1906 } 1907 useSpeedProfileCheckBox.setSelected(info.getUseSpeedProfile()); 1908 stopBySpeedProfileCheckBox.setSelected(info.getStopBySpeedProfile()); 1909 stopBySpeedProfileAdjustSpinner.setValue(info.getStopBySpeedProfileAdjust()); 1910 if (autoRunBox.isSelected()) { 1911 showAutoRunItems(); 1912 } else { 1913 hideAutoRunItems(); 1914 } 1915 initiateFrame.pack(); 1916 } 1917 1918 private void autoRunItemsToTrainInfo(TrainInfo info) { 1919 info.setSpeedFactor((float) speedFactorSpinner.getValue()); 1920 info.setMaxSpeed((float) maxSpeedSpinner.getValue()); 1921 info.setMinReliableOperatingSpeed((float) minReliableOperatingSpeedSpinner.getValue()); 1922 info.setRampRate((String) rampRateBox.getSelectedItem()); 1923 info.setRunInReverse(runInReverseBox.isSelected()); 1924 info.setSoundDecoder(soundDecoderBox.isSelected()); 1925 info.setTrainLengthUnits(((TrainLengthUnitsItem) trainLengthUnitsComboBox.getSelectedItem()).getValue()); 1926 info.setMaxTrainLengthScaleMeters(maxTrainLengthToScaleMeters( info.getTrainLengthUnits(), (float) maxTrainLengthSpinner.getValue())); 1927 1928 // Only use speed profile values if enabled 1929 if (useSpeedProfileCheckBox.isEnabled()) { 1930 info.setUseSpeedProfile(useSpeedProfileCheckBox.isSelected()); 1931 info.setStopBySpeedProfile(stopBySpeedProfileCheckBox.isSelected()); 1932 info.setStopBySpeedProfileAdjust((float) stopBySpeedProfileAdjustSpinner.getValue()); 1933 } else { 1934 info.setUseSpeedProfile(false); 1935 info.setStopBySpeedProfile(false); 1936 info.setStopBySpeedProfileAdjust(1.0f); 1937 } 1938 } 1939 1940 private void initializeRampCombo() { 1941 rampRateBox.removeAllItems(); 1942 rampRateBox.addItem(Bundle.getMessage("RAMP_NONE")); 1943 rampRateBox.addItem(Bundle.getMessage("RAMP_FAST")); 1944 rampRateBox.addItem(Bundle.getMessage("RAMP_MEDIUM")); 1945 rampRateBox.addItem(Bundle.getMessage("RAMP_MED_SLOW")); 1946 rampRateBox.addItem(Bundle.getMessage("RAMP_SLOW")); 1947 rampRateBox.addItem(Bundle.getMessage("RAMP_SPEEDPROFILE")); 1948 // Note: the order above must correspond to the numbers in AutoActiveTrain.java 1949 } 1950 1951 /** 1952 * Sets up the RadioButtons and visability of spinner for the allocation method 1953 * 1954 * @param value 0, Allocate by Safe spots, -1, allocate as far as possible Any 1955 * other value the number of sections to allocate 1956 */ 1957 private void setAllocateMethodButtons(int value) { 1958 switch (value) { 1959 case ActiveTrain.ALLOCATE_BY_SAFE_SECTIONS: 1960 allocateBySafeRadioButton.setSelected(true); 1961 allocateCustomSpinner.setVisible(false); 1962 break; 1963 case ActiveTrain.ALLOCATE_AS_FAR_AS_IT_CAN: 1964 allocateAllTheWayRadioButton.setSelected(true); 1965 allocateCustomSpinner.setVisible(false); 1966 break; 1967 default: 1968 allocateNumberOfBlocks.setSelected(true); 1969 allocateCustomSpinner.setVisible(true); 1970 allocateCustomSpinner.setValue(value); 1971 } 1972 } 1973 1974 /* 1975 * Layout block stuff 1976 */ 1977 private ArrayList<LayoutBlock> getOccupiedBlockList() { 1978 LayoutBlockManager lBM = jmri.InstanceManager.getDefault(LayoutBlockManager.class); 1979 ArrayList<LayoutBlock> lBlocks = new ArrayList<>(); 1980 for (LayoutBlock lB : lBM.getNamedBeanSet()) { 1981 if (lB.getBlock().getState() == Block.OCCUPIED) { 1982 lBlocks.add(lB); 1983 } 1984 } 1985 return lBlocks; 1986 } 1987 1988 private void initializeStartingBlockComboDynamic() { 1989 startingBlockBox.removeAllItems(); 1990 startingBlockBoxList.clear(); 1991 for (LayoutBlock lB: getOccupiedBlockList()) { 1992 if (!startingBlockBoxList.contains(lB.getBlock())) { 1993 startingBlockBoxList.add(lB.getBlock()); 1994 startingBlockBox.addItem(getBlockName(lB.getBlock())); 1995 } 1996 } 1997 JComboBoxUtil.setupComboBoxMaxRows(startingBlockBox); 1998 } 1999 2000 private void initializeViaBlockDynamicCombo() { 2001 String prevValue = (String) viaBlockBox.getSelectedItem(); 2002 viaBlockBox.removeActionListener(viaBlockBoxListener); 2003 viaBlockBox.removeAllItems(); 2004 viaBlockBoxList.clear(); 2005 LayoutBlockManager lBM = jmri.InstanceManager.getDefault(LayoutBlockManager.class); 2006 if (startingBlockBox.getSelectedItem() != null) { 2007 LayoutBlock lBSrc; 2008 if (startingBlockBox.getSelectedIndex() >= 0) { 2009 lBSrc = lBM.getByUserName((String) startingBlockBox.getSelectedItem()); 2010 if (lBSrc != null) { 2011 int rX = lBSrc.getNumberOfNeighbours() - 1; 2012 for (; rX > -1; rX--) { 2013 viaBlockBox.addItem(lBSrc.getNeighbourAtIndex(rX).getDisplayName()); 2014 viaBlockBoxList.add(lBSrc.getNeighbourAtIndex(rX)); 2015 } 2016 } 2017 } 2018 } 2019 if (prevValue != null) { 2020 viaBlockBox.setSelectedItem(prevValue); 2021 } 2022 viaBlockBox.addActionListener(viaBlockBoxListener); 2023 } 2024 2025 private void initializeDestinationBlockDynamicCombo() { 2026 destinationBlockBox.removeAllItems(); 2027 destinationBlockBoxList.clear(); 2028 LayoutBlockManager lBM = jmri.InstanceManager.getDefault(LayoutBlockManager.class); 2029 if (startingBlockBox.getSelectedItem() != null) { 2030 LayoutBlock lBSrc; 2031 if (startingBlockBox.getSelectedIndex() >= 0 2032 && viaBlockBox.getSelectedIndex() >= 0) { 2033 lBSrc = lBM.getByUserName((String) startingBlockBox.getSelectedItem()); 2034 Block b = viaBlockBoxList.get(viaBlockBox.getSelectedIndex()); 2035 if (lBSrc != null) { 2036 int rX = lBSrc.getNumberOfRoutes() - 1; 2037 for (; rX > -1; rX--) { 2038 if (lBSrc.getRouteNextBlockAtIndex(rX) == b) { 2039 destinationBlockBox.addItem(lBSrc.getRouteDestBlockAtIndex(rX).getDisplayName()); 2040 destinationBlockBoxList.add(lBSrc.getRouteDestBlockAtIndex(rX)); 2041 } 2042 } 2043 } 2044 } 2045 } 2046 } 2047 2048 /* 2049 * Check Advanced routing 2050 */ 2051 private boolean checkAdvancedRouting() { 2052 if (!InstanceManager.getDefault(LayoutBlockManager.class).isAdvancedRoutingEnabled()) { 2053 int response = JmriJOptionPane.showConfirmDialog(this, Bundle.getMessage("AdHocNeedsEnableBlockRouting"), 2054 Bundle.getMessage("AdHocNeedsBlockRouting"), JmriJOptionPane.YES_NO_OPTION); 2055 if (response == 0) { 2056 InstanceManager.getDefault(LayoutBlockManager.class).enableAdvancedRouting(true); 2057 JmriJOptionPane.showMessageDialog(this, Bundle.getMessage("AdhocNeedsBlockRoutingEnabled")); 2058 } else { 2059 return false; 2060 } 2061 } 2062 return true; 2063 } 2064 2065 /* 2066 * ComboBox item. 2067 */ 2068 protected static class TrainDetectionItem { 2069 2070 private final String key; 2071 private TrainDetection value; 2072 2073 public TrainDetectionItem(String text, TrainDetection trainDetection ) { 2074 this.key = text; 2075 this.value = trainDetection; 2076 } 2077 2078 @Override 2079 public String toString() { 2080 return key; 2081 } 2082 2083 public String getKey() { 2084 return key; 2085 } 2086 2087 public TrainDetection getValue() { 2088 return value; 2089 } 2090 } 2091 2092 /* 2093 * ComboBox item. 2094 */ 2095 protected static class TrainLengthUnitsItem { 2096 2097 private final String key; 2098 private TrainLengthUnits value; 2099 2100 public TrainLengthUnitsItem(String text, TrainLengthUnits trainLength ) { 2101 this.key = text; 2102 this.value = trainLength; 2103 } 2104 2105 @Override 2106 public String toString() { 2107 return key; 2108 } 2109 2110 public String getKey() { 2111 return key; 2112 } 2113 2114 public TrainLengthUnits getValue() { 2115 return value; 2116 } 2117 } 2118 2119 private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(ActivateTrainFrame.class); 2120 2121}