Source code

001package jmri.jmrit.operations.trains.gui;
002
003import java.awt.*;
004import java.util.ArrayList;
005import java.util.List;
006
007import javax.swing.*;
008
009import jmri.InstanceManager;
010import jmri.jmrit.operations.*;
011import jmri.jmrit.operations.locations.Location;
012import jmri.jmrit.operations.locations.LocationManager;
013import jmri.jmrit.operations.rollingstock.RollingStock;
014import jmri.jmrit.operations.rollingstock.cars.*;
015import jmri.jmrit.operations.rollingstock.engines.*;
016import jmri.jmrit.operations.routes.*;
017import jmri.jmrit.operations.routes.gui.RouteEditFrame;
018import jmri.jmrit.operations.setup.Control;
019import jmri.jmrit.operations.setup.Setup;
020import jmri.jmrit.operations.trains.*;
021import jmri.jmrit.operations.trains.tools.*;
022import jmri.util.swing.JmriJOptionPane;
023
024/**
025 * Frame for user edit of a train
026 *
027 * @author Dan Boudreau Copyright (C) 2008, 2011, 2012, 2013, 2014
028 */
029public class TrainEditFrame extends OperationsFrame implements java.beans.PropertyChangeListener {
030
031    TrainManager trainManager = InstanceManager.getDefault(TrainManager.class);
032    RouteManager routeManager = InstanceManager.getDefault(RouteManager.class);
033
034    public Train _train = null;
035    List<JCheckBox> typeCarCheckBoxes = new ArrayList<>();
036    List<JCheckBox> typeEngineCheckBoxes = new ArrayList<>();
037    List<JCheckBox> locationCheckBoxes = new ArrayList<>();
038    JPanel typeCarPanelCheckBoxes = new JPanel();
039    JPanel typeEnginePanelCheckBoxes = new JPanel();
040    JPanel roadAndLoadStatusPanel = new JPanel();
041    JPanel locationPanelCheckBoxes = new JPanel();
042    JScrollPane typeCarPane;
043    JScrollPane typeEnginePane;
044    JScrollPane locationsPane;
045
046    // labels
047    JLabel textRouteStatus = new JLabel();
048    JLabel textModel = new JLabel(Bundle.getMessage("Model"));
049    JLabel textRoad2 = new JLabel(Bundle.getMessage("Road"));
050    JLabel textRoad3 = new JLabel(Bundle.getMessage("Road"));
051    JLabel textEngine = new JLabel(Bundle.getMessage("Engines"));
052
053    // major buttons
054    JButton editButton = new JButton(Bundle.getMessage("ButtonEdit")); // edit route
055    JButton clearButton = new JButton(Bundle.getMessage("ClearAll"));
056    JButton setButton = new JButton(Bundle.getMessage("SelectAll"));
057    JButton resetButton = new JButton(Bundle.getMessage("ResetTrain"));
058    JButton saveTrainButton = new JButton(Bundle.getMessage("SaveTrain"));
059    JButton deleteTrainButton = new JButton(Bundle.getMessage("DeleteTrain"));
060    JButton addTrainButton = new JButton(Bundle.getMessage("AddTrain"));
061
062    // alternate buttons
063    JButton loadOptionButton = new JButton(Bundle.getMessage("AcceptAll"));
064    JButton roadOptionButton = new JButton(Bundle.getMessage("AcceptAll"));
065
066    // radio buttons
067    JRadioButton noneRadioButton = new JRadioButton(Bundle.getMessage("None"));
068    JRadioButton cabooseRadioButton = new JRadioButton(Bundle.getMessage("Caboose"));
069    JRadioButton fredRadioButton = new JRadioButton(Bundle.getMessage("FRED"));
070    ButtonGroup group = new ButtonGroup();
071
072    // text field
073    JTextField trainNameTextField = new JTextField(Control.max_len_string_train_name);
074    JTextField trainDescriptionTextField = new JTextField(30);
075
076    // text area
077    JTextArea commentTextArea = new JTextArea(2, 70);
078    JScrollPane commentScroller = new JScrollPane(commentTextArea);
079    JColorChooser commentColorChooser = new JColorChooser(Color.black);
080
081    // for padding out panel
082    JLabel space1 = new JLabel(" "); // before hour
083    JLabel space2 = new JLabel(" "); // between hour and minute
084    JLabel space3 = new JLabel(" "); // after minute
085    JLabel space4 = new JLabel(" "); // between route and edit
086    JLabel space5 = new JLabel(" "); // after edit
087
088    // combo boxes
089    JComboBox<String> hourBox = new JComboBox<>();
090    JComboBox<String> minuteBox = new JComboBox<>();
091    JComboBox<Route> routeBox = routeManager.getComboBox();
092    JComboBox<String> roadCabooseBox = new JComboBox<>();
093    JComboBox<String> roadEngineBox = new JComboBox<>();
094    JComboBox<String> modelEngineBox = InstanceManager.getDefault(EngineModels.class).getComboBox();
095    JComboBox<String> numEnginesBox = new JComboBox<>();
096
097    JMenu toolMenu = new JMenu(Bundle.getMessage("MenuTools"));
098
099    public static final String DISPOSE = "dispose"; // NOI18N
100
101    public TrainEditFrame(Train train) {
102        super(Bundle.getMessage("TitleTrainEdit"));
103        // Set up the jtable in a Scroll Pane..
104        locationsPane = new JScrollPane(locationPanelCheckBoxes);
105        locationsPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
106        locationsPane.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("Stops")));
107
108        typeCarPane = new JScrollPane(typeCarPanelCheckBoxes);
109        typeCarPane.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("TypesCar")));
110        typeCarPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
111
112        typeEnginePane = new JScrollPane(typeEnginePanelCheckBoxes);
113        typeEnginePane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
114        typeEnginePane.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("TypesEngine")));
115
116        _train = train;
117
118        getContentPane().setLayout(new BoxLayout(getContentPane(), BoxLayout.Y_AXIS));
119
120        // Set up the panels
121        JPanel p = new JPanel();
122        p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
123        JScrollPane pPane = new JScrollPane(p);
124        pPane.setMinimumSize(new Dimension(300, 5 * trainNameTextField.getPreferredSize().height));
125        pPane.setBorder(BorderFactory.createTitledBorder(""));
126
127        // Layout the panel by rows
128        // row 1
129        JPanel p1 = new JPanel();
130        p1.setLayout(new BoxLayout(p1, BoxLayout.X_AXIS));
131        // row 1a
132        JPanel pName = new JPanel();
133        pName.setLayout(new GridBagLayout());
134        pName.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("Name")));
135        addItem(pName, trainNameTextField, 0, 0);
136        // row 1b
137        JPanel pDesc = new JPanel();
138        pDesc.setLayout(new GridBagLayout());
139        pDesc.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("Description")));
140        trainDescriptionTextField.setToolTipText(Bundle.getMessage("TipTrainDescription"));
141        addItem(pDesc, trainDescriptionTextField, 0, 0);
142
143        p1.add(pName);
144        p1.add(pDesc);
145
146        // row 2
147        JPanel p2 = new JPanel();
148        p2.setLayout(new BoxLayout(p2, BoxLayout.X_AXIS));
149        // row 2a
150        JPanel pdt = new JPanel();
151        pdt.setLayout(new GridBagLayout());
152        pdt.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("DepartTime")));
153
154        // build hour and minute menus
155        hourBox.setPrototypeDisplayValue("0000"); // needed for font size 9
156        minuteBox.setPrototypeDisplayValue("0000");
157        for (int i = 0; i < 24; i++) {
158            if (i < 10) {
159                hourBox.addItem("0" + Integer.toString(i));
160            } else {
161                hourBox.addItem(Integer.toString(i));
162            }
163        }
164        for (int i = 0; i < 60; i += 1) {
165            if (i < 10) {
166                minuteBox.addItem("0" + Integer.toString(i));
167            } else {
168                minuteBox.addItem(Integer.toString(i));
169            }
170        }
171
172        addItem(pdt, space1, 0, 5);
173        addItem(pdt, hourBox, 1, 5);
174        addItem(pdt, space2, 2, 5);
175        addItem(pdt, minuteBox, 3, 5);
176        addItem(pdt, space3, 4, 5);
177        // row 2b
178        // BUG! routeBox needs its own panel when resizing frame!
179        JPanel pr = new JPanel();
180        pr.setLayout(new GridBagLayout());
181        pr.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("Route")));
182        addItem(pr, routeBox, 0, 5);
183        addItem(pr, space4, 1, 5);
184        addItem(pr, editButton, 2, 5);
185        addItem(pr, space5, 3, 5);
186        addItem(pr, textRouteStatus, 4, 5);
187
188        p2.add(pdt);
189        p2.add(pr);
190
191        p.add(p1);
192        p.add(p2);
193
194        // row 5
195        locationPanelCheckBoxes.setLayout(new GridBagLayout());
196
197        // row 6
198        typeCarPanelCheckBoxes.setLayout(new GridBagLayout());
199
200        // row 8
201        typeEnginePanelCheckBoxes.setLayout(new GridBagLayout());
202
203        // status panel for roads and loads
204        roadAndLoadStatusPanel.setLayout(new BoxLayout(roadAndLoadStatusPanel, BoxLayout.X_AXIS));
205        JPanel pRoadOption = new JPanel();
206        pRoadOption.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("RoadOption")));
207        pRoadOption.add(roadOptionButton);
208        roadOptionButton.addActionListener(new TrainRoadOptionsAction(this));
209
210        JPanel pLoadOption = new JPanel();
211        pLoadOption.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("LoadOption")));
212        pLoadOption.add(loadOptionButton);
213        loadOptionButton.addActionListener(new TrainLoadOptionsAction(this));
214
215        roadAndLoadStatusPanel.add(pRoadOption);
216        roadAndLoadStatusPanel.add(pLoadOption);
217        roadAndLoadStatusPanel.setVisible(false); // don't show unless there's a restriction
218
219        // row 10
220        JPanel trainReq = new JPanel();
221        trainReq.setLayout(new GridBagLayout());
222        trainReq.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("TrainRequires")));
223
224        for (int i = 0; i < Setup.getMaxNumberEngines() + 1; i++) {
225            numEnginesBox.addItem(Integer.toString(i));
226        }
227        numEnginesBox.addItem(Train.AUTO);
228        numEnginesBox.setMinimumSize(new Dimension(100, 20));
229        numEnginesBox.setToolTipText(Bundle.getMessage("TipNumberOfLocos"));
230        addItem(trainReq, textEngine, 1, 1);
231        addItem(trainReq, numEnginesBox, 2, 1);
232        addItem(trainReq, textModel, 3, 1);
233        modelEngineBox.insertItemAt(NONE, 0);
234        modelEngineBox.setSelectedIndex(0);
235        modelEngineBox.setMinimumSize(new Dimension(120, 20));
236        modelEngineBox.setToolTipText(Bundle.getMessage("ModelEngineTip"));
237        addItem(trainReq, modelEngineBox, 4, 1);
238        addItem(trainReq, textRoad2, 5, 1);
239        roadEngineBox.insertItemAt(NONE, 0);
240        roadEngineBox.setSelectedIndex(0);
241        roadEngineBox.setMinimumSize(new Dimension(120, 20));
242        roadEngineBox.setToolTipText(Bundle.getMessage("RoadEngineTip"));
243        addItem(trainReq, roadEngineBox, 6, 1);
244
245        JPanel trainLastCar = new JPanel();
246        trainLastCar.setLayout(new GridBagLayout());
247        trainLastCar.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("TrainLastCar")));
248
249        addItem(trainLastCar, noneRadioButton, 2, 2);
250        noneRadioButton.setToolTipText(Bundle.getMessage("TipNoCabooseOrFRED"));
251        addItem(trainLastCar, fredRadioButton, 3, 2);
252        fredRadioButton.setToolTipText(Bundle.getMessage("TipFRED"));
253        addItem(trainLastCar, cabooseRadioButton, 4, 2);
254        cabooseRadioButton.setToolTipText(Bundle.getMessage("TipCaboose"));
255        addItem(trainLastCar, textRoad3, 5, 2);
256        roadCabooseBox.setMinimumSize(new Dimension(120, 20));
257        roadCabooseBox.setToolTipText(Bundle.getMessage("RoadCabooseTip"));
258        addItem(trainLastCar, roadCabooseBox, 6, 2);
259        group.add(noneRadioButton);
260        group.add(cabooseRadioButton);
261        group.add(fredRadioButton);
262        noneRadioButton.setSelected(true);
263
264        // row 13 comment
265        JPanel pC = new JPanel();
266        pC.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("Comment")));
267        pC.setLayout(new GridBagLayout());
268        addItem(pC, commentScroller, 1, 0);
269        if (_train != null) {
270            addItem(pC, OperationsPanel.getColorChooserPanel(_train.getCommentWithColor(), commentColorChooser), 2, 0);
271        } else {
272            addItem(pC, OperationsPanel.getColorChooserPanel("", commentColorChooser), 2, 0);
273        }
274
275        // adjust text area width based on window size less color chooser
276        Dimension d = new Dimension(getPreferredSize().width - 100, getPreferredSize().height);
277        adjustTextAreaColumnWidth(commentScroller, commentTextArea, d);
278
279        // row 15 buttons
280        JPanel pB = new JPanel();
281        pB.setLayout(new GridBagLayout());
282        addItem(pB, deleteTrainButton, 0, 0);
283        addItem(pB, resetButton, 1, 0);
284        addItem(pB, addTrainButton, 2, 0);
285        addItem(pB, saveTrainButton, 3, 0);
286
287        getContentPane().add(pPane);
288        getContentPane().add(locationsPane);
289        getContentPane().add(typeCarPane);
290        getContentPane().add(typeEnginePane);
291        getContentPane().add(roadAndLoadStatusPanel);
292        getContentPane().add(trainReq);
293        getContentPane().add(trainLastCar);
294        getContentPane().add(pC);
295        getContentPane().add(pB);
296
297        // setup buttons
298        addButtonAction(editButton);
299        addButtonAction(setButton);
300        addButtonAction(clearButton);
301        addButtonAction(resetButton);
302        addButtonAction(deleteTrainButton);
303        addButtonAction(addTrainButton);
304        addButtonAction(saveTrainButton);
305
306        addRadioButtonAction(noneRadioButton);
307        addRadioButtonAction(cabooseRadioButton);
308        addRadioButtonAction(fredRadioButton);
309
310        // tool tips
311        resetButton.setToolTipText(Bundle.getMessage("TipTrainReset"));
312
313        // build menu
314        JMenuBar menuBar = new JMenuBar();
315        menuBar.add(toolMenu);
316        loadToolMenu(toolMenu);
317        setJMenuBar(menuBar);
318        addHelpMenu("package.jmri.jmrit.operations.Operations_TrainEdit", true); // NOI18N
319
320        if (_train != null) {
321            trainNameTextField.setText(_train.getName());
322            trainDescriptionTextField.setText(_train.getRawDescription());
323            routeBox.setSelectedItem(_train.getRoute());
324            modelEngineBox.setSelectedItem(_train.getEngineModel());
325            commentTextArea.setText(TrainCommon.getTextColorString(_train.getCommentWithColor()));
326            cabooseRadioButton.setSelected(_train.isCabooseNeeded());
327            fredRadioButton.setSelected(_train.isFredNeeded());
328            updateDepartureTime();
329            enableButtons(true);
330            // listen for train changes
331            _train.addPropertyChangeListener(this);
332
333            Route route = _train.getRoute();
334            if (route != null) {
335                if (_train.getTrainDepartsRouteLocation() != null &&
336                        _train.getTrainDepartsRouteLocation().getLocation() != null &&
337                        !_train.getTrainDepartsRouteLocation().getLocation().isStaging())
338                    numEnginesBox.addItem(Train.AUTO_HPT);
339            }
340            numEnginesBox.setSelectedItem(_train.getNumberEngines());
341        } else {
342            setTitle(Bundle.getMessage("TitleTrainAdd"));
343            enableButtons(false);
344        }
345
346        modelEngineBox.setEnabled(!numEnginesBox.getSelectedItem().equals("0"));
347        roadEngineBox.setEnabled(!numEnginesBox.getSelectedItem().equals("0"));
348
349        // load route location checkboxes
350        updateLocationCheckboxes();
351        updateCarTypeCheckboxes();
352        updateEngineTypeCheckboxes();
353        updateRoadAndLoadStatus();
354        updateCabooseRoadComboBox();
355        updateEngineRoadComboBox();
356
357        // setup combobox
358        addComboBoxAction(numEnginesBox);
359        addComboBoxAction(routeBox);
360        addComboBoxAction(modelEngineBox);
361
362        // get notified if combo box gets modified
363        routeManager.addPropertyChangeListener(this);
364        // get notified if car types or roads gets modified
365        InstanceManager.getDefault(CarTypes.class).addPropertyChangeListener(this);
366        InstanceManager.getDefault(CarRoads.class).addPropertyChangeListener(this);
367        InstanceManager.getDefault(EngineTypes.class).addPropertyChangeListener(this);
368        InstanceManager.getDefault(EngineModels.class).addPropertyChangeListener(this);
369        InstanceManager.getDefault(LocationManager.class).addPropertyChangeListener(this);
370
371        initMinimumSize(new Dimension(Control.panelWidth600, Control.panelHeight600));
372    }
373
374    private void loadToolMenu(JMenu toolMenu) {
375        toolMenu.removeAll();
376        // first 5 menu items will also close when the edit train window closes
377        toolMenu.add(new TrainEditBuildOptionsAction(this));
378        toolMenu.add(new TrainLoadOptionsAction(this));
379        toolMenu.add(new TrainRoadOptionsAction(this));
380        toolMenu.add(new TrainManifestOptionAction(this));
381        toolMenu.add(new TrainCopyAction(_train));
382        toolMenu.addSeparator();
383        toolMenu.add(new TrainScriptAction(this));
384        toolMenu.add(new TrainConductorAction(_train));
385        toolMenu.addSeparator();
386        toolMenu.add(new TrainByCarTypeAction(_train));
387        toolMenu.addSeparator();
388        toolMenu.add(new PrintTrainAction(false, _train));
389        toolMenu.add(new PrintTrainAction(true, _train));
390        toolMenu.add(new PrintTrainManifestAction(false, _train));
391        toolMenu.add(new PrintTrainManifestAction(true, _train));
392        toolMenu.add(new PrintShowCarsInTrainRouteAction(false, _train));
393        toolMenu.add(new PrintShowCarsInTrainRouteAction(true, _train));
394        toolMenu.add(new PrintTrainBuildReportAction(false, _train));
395        toolMenu.add(new PrintTrainBuildReportAction(true, _train));
396        toolMenu.add(new PrintSavedTrainManifestAction(false, _train));
397        toolMenu.add(new PrintSavedTrainManifestAction(true, _train));
398        toolMenu.add(new PrintSavedBuildReportAction(false, _train));
399        toolMenu.add(new PrintSavedBuildReportAction(true, _train));
400    }
401
402    // Save, Delete, Add, Edit, Reset, Set, Clear
403    @Override
404    public void buttonActionPerformed(java.awt.event.ActionEvent ae) {
405        Train train = trainManager.getTrainByName(trainNameTextField.getText().trim());
406        if (ae.getSource() == saveTrainButton) {
407            log.debug("train save button activated");
408            if (_train == null && train == null) {
409                saveNewTrain(); // this can't happen, Save button is disabled
410            } else {
411                if (train != null && train != _train) {
412                    reportTrainExists(Bundle.getMessage("save"));
413                    return;
414                }
415                // check to see if user supplied a route
416                if (!checkRoute() || !saveTrain()) {
417                    return;
418                }
419            }
420            if (Setup.isCloseWindowOnSaveEnabled()) {
421                dispose();
422            }
423        }
424        if (ae.getSource() == deleteTrainButton) {
425            log.debug("train delete button activated");
426            if (train == null) {
427                return;
428            }
429            if (!_train.reset()) {
430                JmriJOptionPane.showMessageDialog(this,
431                        Bundle.getMessage("TrainIsInRoute",
432                                train.getTrainTerminatesName()),
433                        Bundle.getMessage("CanNotDeleteTrain"), JmriJOptionPane.ERROR_MESSAGE);
434                return;
435            }
436            if (JmriJOptionPane.showConfirmDialog(this,
437                    Bundle.getMessage("deleteMsg", train.getName()),
438                    Bundle.getMessage("deleteTrain"), JmriJOptionPane.YES_NO_OPTION) != JmriJOptionPane.YES_OPTION) {
439                return;
440            }
441            routeBox.setSelectedItem(null);
442            trainManager.deregister(train);
443            for (Frame frame : children) {
444                frame.dispose();
445            }
446            _train = null;
447            enableButtons(false);
448            // save train file
449            OperationsXml.save();
450        }
451        if (ae.getSource() == addTrainButton) {
452            if (train != null) {
453                reportTrainExists(Bundle.getMessage("add"));
454                return;
455            }
456            saveNewTrain();
457        }
458        if (ae.getSource() == editButton) {
459            editAddRoute();
460        }
461        if (ae.getSource() == setButton) {
462            selectCheckboxes(true);
463        }
464        if (ae.getSource() == clearButton) {
465            selectCheckboxes(false);
466        }
467        if (ae.getSource() == resetButton) {
468            if (_train != null) {
469                if (!_train.reset()) {
470                    JmriJOptionPane.showMessageDialog(this,
471                            Bundle.getMessage("TrainIsInRoute",
472                                    _train.getTrainTerminatesName()),
473                            Bundle.getMessage("CanNotResetTrain"), JmriJOptionPane.ERROR_MESSAGE);
474                }
475            }
476        }
477    }
478
479    @Override
480    public void radioButtonActionPerformed(java.awt.event.ActionEvent ae) {
481        log.debug("radio button activated");
482        if (_train != null) {
483            if (ae.getSource() == noneRadioButton ||
484                    ae.getSource() == cabooseRadioButton ||
485                    ae.getSource() == fredRadioButton) {
486                updateCabooseRoadComboBox();
487            }
488        }
489    }
490
491    private void saveNewTrain() {
492        if (!checkName(Bundle.getMessage("add"))) {
493            return;
494        }
495        Train train = trainManager.newTrain(trainNameTextField.getText());
496        _train = train;
497        _train.addPropertyChangeListener(this);
498
499        // update check boxes
500        updateCarTypeCheckboxes();
501        updateEngineTypeCheckboxes();
502        // enable check boxes and buttons
503        enableButtons(true);
504        saveTrain();
505        loadToolMenu(toolMenu);
506    }
507
508    private boolean saveTrain() {
509        if (!checkName(Bundle.getMessage("save"))) {
510            return false;
511        }
512        if (!checkModel() || !checkEngineRoad() || !checkCabooseRoad()) {
513            return false;
514        }
515        if (!_train.getName().equals(trainNameTextField.getText().trim()) ||
516                !_train.getRawDescription().equals(trainDescriptionTextField.getText()) ||
517                !_train.getCommentWithColor().equals(
518                        TrainCommon.formatColorString(commentTextArea.getText(), commentColorChooser.getColor()))) {
519            _train.setModified(true);
520        }
521        _train.setDepartureTime(hourBox.getSelectedItem().toString(), minuteBox.getSelectedItem().toString());
522        _train.setNumberEngines((String) numEnginesBox.getSelectedItem());
523        if (_train.getNumberEngines().equals("0")) {
524            modelEngineBox.setSelectedIndex(0);
525            roadEngineBox.setSelectedIndex(0);
526        }
527        _train.setEngineRoad((String) roadEngineBox.getSelectedItem());
528        _train.setEngineModel((String) modelEngineBox.getSelectedItem());
529        if (cabooseRadioButton.isSelected()) {
530            _train.setRequirements(Train.CABOOSE);
531        }
532        if (fredRadioButton.isSelected()) {
533            _train.setRequirements(Train.FRED);
534        }
535        if (noneRadioButton.isSelected()) {
536            _train.setRequirements(Train.NO_CABOOSE_OR_FRED);
537        }
538        _train.setCabooseRoad((String) roadCabooseBox.getSelectedItem());
539        _train.setName(trainNameTextField.getText().trim());
540        _train.setDescription(trainDescriptionTextField.getText());
541        _train.setComment(TrainCommon.formatColorString(commentTextArea.getText(), commentColorChooser.getColor()));
542        // save train file
543        OperationsXml.save();
544        return true;
545    }
546
547    /**
548     *
549     * @return true if name isn't too long and is at least one character
550     */
551    private boolean checkName(String s) {
552        String trainName = trainNameTextField.getText().trim();
553        if (trainName.isEmpty()) {
554            log.debug("Must enter a train name");
555            JmriJOptionPane.showMessageDialog(this, Bundle.getMessage("MustEnterName"),
556                    Bundle.getMessage("CanNot", s), JmriJOptionPane.ERROR_MESSAGE);
557            return false;
558        }
559        if (trainName.length() > Control.max_len_string_train_name) {
560            JmriJOptionPane.showMessageDialog(this,
561                    Bundle.getMessage("TrainNameLess",
562                            Control.max_len_string_train_name + 1),
563                    Bundle.getMessage("CanNot", s), JmriJOptionPane.ERROR_MESSAGE);
564            return false;
565        }
566        if (!OperationsXml.checkFileName(trainName)) { // NOI18N
567            log.error("Train name must not contain reserved characters");
568            JmriJOptionPane.showMessageDialog(this,
569                    Bundle.getMessage("NameResChar") + NEW_LINE + Bundle.getMessage("ReservedChar"),
570                    Bundle.getMessage("CanNot", s), JmriJOptionPane.ERROR_MESSAGE);
571            return false;
572        }
573
574        return true;
575    }
576
577    private boolean checkModel() {
578        String model = (String) modelEngineBox.getSelectedItem();
579        if (numEnginesBox.getSelectedItem().equals("0") || model.equals(NONE)) {
580            return true;
581        }
582        String type = InstanceManager.getDefault(EngineModels.class).getModelType(model);
583        if (!_train.isTypeNameAccepted(type)) {
584            JmriJOptionPane.showMessageDialog(this,
585                    Bundle.getMessage("TrainModelService", model, type),
586                    Bundle.getMessage("CanNot", Bundle.getMessage("save")),
587                    JmriJOptionPane.ERROR_MESSAGE);
588            return false;
589        }
590        if (roadEngineBox.getItemCount() == 1) {
591            log.debug("No locos available that match the model selected!");
592            JmriJOptionPane.showMessageDialog(this,
593                    Bundle.getMessage("NoLocosModel", model),
594                    Bundle.getMessage("TrainWillNotBuild", _train.getName()),
595                    JmriJOptionPane.WARNING_MESSAGE);
596        }
597        return true;
598    }
599
600    private boolean checkEngineRoad() {
601        String road = (String) roadEngineBox.getSelectedItem();
602        if (numEnginesBox.getSelectedItem().equals("0") || road.equals(NONE)) {
603            return true;
604        }
605        if (!road.equals(NONE) && !_train.isLocoRoadNameAccepted(road)) {
606            JmriJOptionPane.showMessageDialog(this,
607                    Bundle.getMessage("TrainNotThisRoad", _train.getName(), road),
608                    Bundle.getMessage("TrainWillNotBuild", _train.getName()),
609                    JmriJOptionPane.WARNING_MESSAGE);
610            return false;
611        }
612        for (RollingStock rs : InstanceManager.getDefault(EngineManager.class).getList()) {
613            if (!_train.isTypeNameAccepted(rs.getTypeName())) {
614                continue;
615            }
616            if (rs.getRoadName().equals(road)) {
617                return true;
618            }
619        }
620        JmriJOptionPane.showMessageDialog(this,
621                Bundle.getMessage("NoLocoRoad", road),
622                Bundle.getMessage("TrainWillNotBuild", _train.getName()),
623                JmriJOptionPane.WARNING_MESSAGE);
624        return false; // couldn't find a loco with the selected road
625    }
626
627    private boolean checkCabooseRoad() {
628        String road = (String) roadCabooseBox.getSelectedItem();
629        if (!road.equals(NONE) && cabooseRadioButton.isSelected() && !_train.isCabooseRoadNameAccepted(road)) {
630            JmriJOptionPane.showMessageDialog(this,
631                    Bundle.getMessage("TrainNotCabooseRoad", _train.getName(), road),
632                    Bundle.getMessage("TrainWillNotBuild", _train.getName()),
633                    JmriJOptionPane.WARNING_MESSAGE);
634            return false;
635        }
636        return true;
637    }
638
639    private boolean checkRoute() {
640        if (_train.getRoute() == null) {
641            JmriJOptionPane.showMessageDialog(this, Bundle.getMessage("TrainNeedsRoute"), Bundle.getMessage("TrainNoRoute"),
642                    JmriJOptionPane.WARNING_MESSAGE);
643            return false;
644        }
645        return true;
646
647    }
648
649    private void reportTrainExists(String s) {
650        log.debug("Can not {}, train already exists", s);
651        JmriJOptionPane.showMessageDialog(this, Bundle.getMessage("TrainNameExists"),
652                Bundle.getMessage("CanNot", s), JmriJOptionPane.ERROR_MESSAGE);
653    }
654
655    private void enableButtons(boolean enabled) {
656        toolMenu.setEnabled(enabled);
657        editButton.setEnabled(enabled);
658        routeBox.setEnabled(enabled && _train != null && !_train.isBuilt());
659        clearButton.setEnabled(enabled);
660        resetButton.setEnabled(enabled);
661        setButton.setEnabled(enabled);
662        saveTrainButton.setEnabled(enabled);
663        deleteTrainButton.setEnabled(enabled);
664        numEnginesBox.setEnabled(enabled);
665        enableCheckboxes(enabled);
666        noneRadioButton.setEnabled(enabled);
667        fredRadioButton.setEnabled(enabled);
668        cabooseRadioButton.setEnabled(enabled);
669        roadOptionButton.setEnabled(enabled);
670        loadOptionButton.setEnabled(enabled);
671        // the inverse!
672        addTrainButton.setEnabled(!enabled);
673    }
674
675    private void selectCheckboxes(boolean enable) {
676        for (int i = 0; i < typeCarCheckBoxes.size(); i++) {
677            JCheckBox checkBox = typeCarCheckBoxes.get(i);
678            checkBox.setSelected(enable);
679            if (_train != null) {
680                _train.removePropertyChangeListener(this);
681                if (enable) {
682                    _train.addTypeName(checkBox.getText());
683                } else {
684                    _train.deleteTypeName(checkBox.getText());
685                }
686                _train.addPropertyChangeListener(this);
687            }
688        }
689    }
690
691    @Override
692    public void comboBoxActionPerformed(java.awt.event.ActionEvent ae) {
693        if (_train == null) {
694            return;
695        }
696        if (ae.getSource() == numEnginesBox) {
697            modelEngineBox.setEnabled(!numEnginesBox.getSelectedItem().equals("0"));
698            roadEngineBox.setEnabled(!numEnginesBox.getSelectedItem().equals("0"));
699        }
700        if (ae.getSource() == modelEngineBox) {
701            updateEngineRoadComboBox();
702        }
703        if (ae.getSource() == routeBox) {
704            if (routeBox.isEnabled()) {
705                Route route = _train.getRoute();
706                if (route != null) {
707                    route.removePropertyChangeListener(this);
708                }
709                Object selected = routeBox.getSelectedItem();
710                if (selected != null) {
711                    route = (Route) selected;
712                    _train.setRoute(route);
713                    route.addPropertyChangeListener(this);
714                } else {
715                    _train.setRoute(null);
716                }
717                updateLocationCheckboxes();
718                updateDepartureTime();
719                pack();
720                repaint();
721            }
722        }
723    }
724
725    private void enableCheckboxes(boolean enable) {
726        for (int i = 0; i < typeCarCheckBoxes.size(); i++) {
727            typeCarCheckBoxes.get(i).setEnabled(enable);
728        }
729        for (int i = 0; i < typeEngineCheckBoxes.size(); i++) {
730            typeEngineCheckBoxes.get(i).setEnabled(enable);
731        }
732    }
733
734    private void addLocationCheckBoxAction(JCheckBox b) {
735        b.addActionListener(new java.awt.event.ActionListener() {
736            @Override
737            public void actionPerformed(java.awt.event.ActionEvent e) {
738                locationCheckBoxActionPerformed(e);
739            }
740        });
741    }
742
743    public void locationCheckBoxActionPerformed(java.awt.event.ActionEvent ae) {
744        JCheckBox b = (JCheckBox) ae.getSource();
745        log.debug("checkbox change {}", b.getText());
746        if (_train == null) {
747            return;
748        }
749        String id = b.getName();
750        RouteLocation rl = _train.getRoute().getRouteLocationById(id);
751        if (b.isSelected()) {
752            _train.deleteTrainSkipsLocation(rl);
753        } else {
754            // check to see if skipped location is staging
755            if (_train.getRoute().getRouteLocationById(id).getLocation().isStaging()) {
756                int result = JmriJOptionPane.showConfirmDialog(this,
757                        Bundle.getMessage("TrainRouteStaging",
758                                _train.getName(), _train.getRoute().getRouteLocationById(id).getName()),
759                        Bundle.getMessage("TrainRouteNotStaging"), JmriJOptionPane.OK_CANCEL_OPTION);
760                if (result != JmriJOptionPane.OK_OPTION ) {
761                    b.setSelected(true);
762                    return; // don't skip staging
763                }
764            }
765            _train.addTrainSkipsLocation(rl);
766        }
767    }
768
769    private void updateRouteComboBox() {
770        routeBox.setEnabled(false);
771        routeManager.updateComboBox(routeBox);
772        if (_train != null) {
773            routeBox.setSelectedItem(_train.getRoute());
774        }
775        routeBox.setEnabled(true);
776    }
777
778    private void updateCarTypeCheckboxes() {
779        typeCarCheckBoxes.clear();
780        typeCarPanelCheckBoxes.removeAll();
781        loadCarTypes();
782        enableCheckboxes(_train != null);
783        typeCarPanelCheckBoxes.revalidate();
784        repaint();
785    }
786
787    private void loadCarTypes() {
788        int numberOfCheckboxes = getNumberOfCheckboxesPerLine(); // number per line
789        int x = 0;
790        int y = 1; // vertical position in panel
791        for (String type : InstanceManager.getDefault(CarTypes.class).getNames()) {
792            JCheckBox checkBox = new javax.swing.JCheckBox();
793            typeCarCheckBoxes.add(checkBox);
794            checkBox.setText(type);
795            addTypeCheckBoxAction(checkBox);
796            addItemLeft(typeCarPanelCheckBoxes, checkBox, x++, y);
797            if (_train != null && _train.isTypeNameAccepted(type)) {
798                checkBox.setSelected(true);
799            }
800            if (x > numberOfCheckboxes) {
801                y++;
802                x = 0;
803            }
804        }
805
806        JPanel p = new JPanel();
807        p.add(clearButton);
808        p.add(setButton);
809        GridBagConstraints gc = new GridBagConstraints();
810        gc.gridwidth = getNumberOfCheckboxesPerLine() + 1;
811        gc.gridy = ++y;
812        typeCarPanelCheckBoxes.add(p, gc);
813
814    }
815
816    private void updateEngineTypeCheckboxes() {
817        typeEngineCheckBoxes.clear();
818        typeEnginePanelCheckBoxes.removeAll();
819        loadEngineTypes();
820        enableCheckboxes(_train != null);
821        typeEnginePanelCheckBoxes.revalidate();
822        repaint();
823    }
824
825    private void loadEngineTypes() {
826        int numberOfCheckboxes = getNumberOfCheckboxesPerLine(); // number per line
827        int x = 0;
828        int y = 1;
829        for (String type : InstanceManager.getDefault(EngineTypes.class).getNames()) {
830            JCheckBox checkBox = new javax.swing.JCheckBox();
831            typeEngineCheckBoxes.add(checkBox);
832            checkBox.setText(type);
833            addTypeCheckBoxAction(checkBox);
834            addItemLeft(typeEnginePanelCheckBoxes, checkBox, x++, y);
835            if (_train != null && _train.isTypeNameAccepted(type)) {
836                checkBox.setSelected(true);
837            }
838            if (x > numberOfCheckboxes) {
839                y++;
840                x = 0;
841            }
842        }
843    }
844
845    private void updateRoadComboBoxes() {
846        updateCabooseRoadComboBox();
847        updateEngineRoadComboBox();
848    }
849
850    // update caboose road box based on radio selection
851    private void updateCabooseRoadComboBox() {
852        roadCabooseBox.removeAllItems();
853        roadCabooseBox.addItem(NONE);
854        if (noneRadioButton.isSelected()) {
855            roadCabooseBox.setEnabled(false);
856            return;
857        }
858        roadCabooseBox.setEnabled(true);
859        List<String> roads;
860        if (cabooseRadioButton.isSelected()) {
861            roads = InstanceManager.getDefault(CarManager.class).getCabooseRoadNames();
862        } else {
863            roads = InstanceManager.getDefault(CarManager.class).getFredRoadNames();
864        }
865        for (String road : roads) {
866            roadCabooseBox.addItem(road);
867        }
868        if (_train != null) {
869            roadCabooseBox.setSelectedItem(_train.getCabooseRoad());
870        }
871        OperationsPanel.padComboBox(roadCabooseBox);
872    }
873
874    private void updateEngineRoadComboBox() {
875        String engineModel = (String) modelEngineBox.getSelectedItem();
876        if (engineModel == null) {
877            return;
878        }
879        InstanceManager.getDefault(EngineManager.class).updateEngineRoadComboBox(engineModel, roadEngineBox);
880        if (_train != null) {
881            roadEngineBox.setSelectedItem(_train.getEngineRoad());
882        }
883    }
884
885    private void addTypeCheckBoxAction(JCheckBox b) {
886        b.addActionListener(new java.awt.event.ActionListener() {
887            @Override
888            public void actionPerformed(java.awt.event.ActionEvent e) {
889                typeCheckBoxActionPerformed(e);
890            }
891        });
892    }
893
894    public void typeCheckBoxActionPerformed(java.awt.event.ActionEvent ae) {
895        JCheckBox b = (JCheckBox) ae.getSource();
896        log.debug("checkbox change {}", b.getText());
897        if (_train == null) {
898            return;
899        }
900        if (b.isSelected()) {
901            _train.addTypeName(b.getText());
902        } else {
903            _train.deleteTypeName(b.getText());
904        }
905    }
906
907    // the train's route shown as locations with checkboxes
908    private void updateLocationCheckboxes() {
909        updateRouteStatus();
910        locationCheckBoxes.clear();
911        locationPanelCheckBoxes.removeAll();
912        int y = 0; // vertical position in panel
913        Route route = null;
914        if (_train != null) {
915            route = _train.getRoute();
916        }
917        if (route != null) {
918            List<RouteLocation> routeList = route.getLocationsBySequenceList();
919            for (RouteLocation rl : routeList) {
920                JCheckBox checkBox = new javax.swing.JCheckBox();
921                locationCheckBoxes.add(checkBox);
922                checkBox.setText(rl.toString());
923                checkBox.setName(rl.getId());
924                addItemLeft(locationPanelCheckBoxes, checkBox, 0, y++);
925                Location loc = InstanceManager.getDefault(LocationManager.class).getLocationByName(rl.getName());
926                // does the location exist?
927                if (loc != null) {
928                    // need to listen for name and direction changes
929                    loc.removePropertyChangeListener(this);
930                    loc.addPropertyChangeListener(this);
931                    boolean services = false;
932                    // does train direction service location?
933                    if ((rl.getTrainDirection() & loc.getTrainDirections()) != 0) {
934                        services = true;
935                    } // train must service last location or single location
936                    else if (_train.isLocalSwitcher() || rl == _train.getTrainTerminatesRouteLocation()) {
937                        services = true;
938                    }
939                    // check can drop and pick up, and moves > 0
940                    if (services &&
941                            (rl.isDropAllowed() || rl.isPickUpAllowed() || rl.isLocalMovesAllowed()) &&
942                            rl.getMaxCarMoves() > 0) {
943                        checkBox.setSelected(!_train.isLocationSkipped(rl));
944                    } else {
945                        checkBox.setEnabled(false);
946                    }
947                    addLocationCheckBoxAction(checkBox);
948                } else {
949                    checkBox.setEnabled(false);
950                }
951            }
952        }
953        locationPanelCheckBoxes.revalidate();
954    }
955
956    private void updateRouteStatus() {
957        Route route = null;
958        textRouteStatus.setText(NONE); // clear out previous status
959        if (_train != null) {
960            route = _train.getRoute();
961        }
962        if (route != null) {
963            if (!route.getStatus().equals(Route.OKAY)) {
964                textRouteStatus.setText(route.getStatus());
965                textRouteStatus.setForeground(Color.RED);
966            }
967        }
968    }
969
970    RouteEditFrame ref;
971
972    private void editAddRoute() {
973        log.debug("Edit/add route");
974        if (ref != null) {
975            ref.dispose();
976        }
977        ref = new RouteEditFrame();
978        setChildFrame(ref);
979        Route route = null;
980        Object selected = routeBox.getSelectedItem();
981        if (selected != null) {
982            route = (Route) selected;
983        }
984        // warn user if train is built that they shouldn't edit the train's route
985        if (route != null && route.getStatus().equals(Route.TRAIN_BUILT)) {
986            // list the built trains for this route
987            StringBuffer buf = new StringBuffer(Bundle.getMessage("DoNotModifyRoute"));
988            for (Train train : InstanceManager.getDefault(TrainManager.class).getTrainsByIdList()) {
989                if (train.getRoute() == route && train.isBuilt()) {
990                    buf.append(NEW_LINE +
991                            Bundle.getMessage("TrainIsBuilt",
992                                    train.getName(), route.getName()));
993                }
994            }
995            JmriJOptionPane.showMessageDialog(this, buf.toString(), Bundle.getMessage("BuiltTrain"),
996                    JmriJOptionPane.WARNING_MESSAGE);
997        }
998        ref.initComponents(route, _train);
999    }
1000
1001    private void updateDepartureTime() {
1002        hourBox.setSelectedItem(_train.getDepartureTimeHour());
1003        minuteBox.setSelectedItem(_train.getDepartureTimeMinute());
1004        // check to see if route has a departure time from the 1st location
1005        RouteLocation rl = _train.getTrainDepartsRouteLocation();
1006        if (rl != null && !rl.getDepartureTime().equals(NONE)) {
1007            hourBox.setEnabled(false);
1008            minuteBox.setEnabled(false);
1009        } else {
1010            hourBox.setEnabled(true);
1011            minuteBox.setEnabled(true);
1012        }
1013    }
1014
1015    private void updateRoadAndLoadStatus() {
1016        if (_train != null) {
1017            // road options
1018            if (_train.getCarRoadOption().equals(Train.INCLUDE_ROADS)) {
1019                roadOptionButton.setText(Bundle.getMessage(
1020                        "AcceptOnly") + " " + _train.getCarRoadNames().length + " " + Bundle.getMessage("RoadsCar"));
1021            } else if (_train.getCarRoadOption().equals(Train.EXCLUDE_ROADS)) {
1022                roadOptionButton.setText(Bundle.getMessage(
1023                        "Exclude") + " " + _train.getCarRoadNames().length + " " + Bundle.getMessage("RoadsCar"));
1024            } else if (_train.getCabooseRoadOption().equals(Train.INCLUDE_ROADS)) {
1025                roadOptionButton.setText(Bundle.getMessage(
1026                        "AcceptOnly") +
1027                        " " +
1028                        _train.getCabooseRoadNames().length +
1029                        " " +
1030                        Bundle.getMessage("RoadsCaboose"));
1031            } else if (_train.getCabooseRoadOption().equals(Train.EXCLUDE_ROADS)) {
1032                roadOptionButton.setText(Bundle.getMessage(
1033                        "Exclude") +
1034                        " " +
1035                        _train.getCabooseRoadNames().length +
1036                        " " +
1037                        Bundle.getMessage("RoadsCaboose"));
1038            } else if (_train.getLocoRoadOption().equals(Train.INCLUDE_ROADS)) {
1039                roadOptionButton.setText(Bundle.getMessage(
1040                        "AcceptOnly") + " " + _train.getLocoRoadNames().length + " " + Bundle.getMessage("RoadsLoco"));
1041            } else if (_train.getLocoRoadOption().equals(Train.EXCLUDE_ROADS)) {
1042                roadOptionButton.setText(Bundle.getMessage(
1043                        "Exclude") + " " + _train.getLocoRoadNames().length + " " + Bundle.getMessage("RoadsLoco"));
1044            } else {
1045                roadOptionButton.setText(Bundle.getMessage("AcceptAll"));
1046            }
1047            // load options
1048            if (_train.getLoadOption().equals(Train.ALL_LOADS)) {
1049                loadOptionButton.setText(Bundle.getMessage("AcceptAll"));
1050            } else if (_train.getLoadOption().equals(Train.INCLUDE_LOADS)) {
1051                loadOptionButton.setText(Bundle.getMessage(
1052                        "AcceptOnly") + " " + _train.getLoadNames().length + " " + Bundle.getMessage("Loads"));
1053            } else {
1054                loadOptionButton.setText(Bundle.getMessage(
1055                        "Exclude") + " " + _train.getLoadNames().length + " " + Bundle.getMessage("Loads"));
1056            }
1057            if (!_train.getCarRoadOption().equals(Train.ALL_ROADS) ||
1058                    !_train.getCabooseRoadOption().equals(Train.ALL_ROADS) ||
1059                    !_train.getLocoRoadOption().equals(Train.ALL_ROADS) ||
1060                    !_train.getLoadOption().equals(Train.ALL_LOADS)) {
1061                roadAndLoadStatusPanel.setVisible(true);
1062            }
1063        }
1064    }
1065
1066    List<Frame> children = new ArrayList<>();
1067
1068    public void setChildFrame(Frame frame) {
1069        if (children.contains(frame)) {
1070            return;
1071        }
1072        children.add(frame);
1073    }
1074
1075    @Override
1076    public void dispose() {
1077        InstanceManager.getDefault(LocationManager.class).removePropertyChangeListener(this);
1078        InstanceManager.getDefault(EngineTypes.class).removePropertyChangeListener(this);
1079        InstanceManager.getDefault(EngineModels.class).removePropertyChangeListener(this);
1080        InstanceManager.getDefault(CarTypes.class).removePropertyChangeListener(this);
1081        InstanceManager.getDefault(CarRoads.class).removePropertyChangeListener(this);
1082        routeManager.removePropertyChangeListener(this);
1083        for (Frame frame : children) {
1084            frame.dispose();
1085        }
1086        if (_train != null) {
1087            _train.removePropertyChangeListener(this);
1088            Route route = _train.getRoute();
1089            if (route != null) {
1090                for (RouteLocation rl : route.getLocationsBySequenceList()) {
1091                    Location loc = rl.getLocation();
1092                    if (loc != null) {
1093                        loc.removePropertyChangeListener(this);
1094                    }
1095                }
1096            }
1097        }
1098        super.dispose();
1099    }
1100
1101    @Override
1102    public void propertyChange(java.beans.PropertyChangeEvent e) {
1103        if (Control.SHOW_PROPERTY) {
1104            log.debug("Property change ({}) old: ({}) new: ({})", e.getPropertyName(), e.getOldValue(),
1105                    e.getNewValue()); // NOI18N
1106        }
1107        if (e.getPropertyName().equals(CarTypes.CARTYPES_CHANGED_PROPERTY) ||
1108                e.getPropertyName().equals(Train.TYPES_CHANGED_PROPERTY)) {
1109            updateCarTypeCheckboxes();
1110        }
1111        if (e.getPropertyName().equals(EngineTypes.ENGINETYPES_CHANGED_PROPERTY)) {
1112            updateEngineTypeCheckboxes();
1113        }
1114        if (e.getPropertyName().equals(RouteManager.LISTLENGTH_CHANGED_PROPERTY)) {
1115            updateRouteComboBox();
1116        }
1117        if (e.getPropertyName().equals(Route.LISTCHANGE_CHANGED_PROPERTY) ||
1118                e.getPropertyName().equals(LocationManager.LISTLENGTH_CHANGED_PROPERTY) ||
1119                e.getPropertyName().equals(Location.NAME_CHANGED_PROPERTY) ||
1120                e.getPropertyName().equals(Location.TRAIN_DIRECTION_CHANGED_PROPERTY)) {
1121            updateLocationCheckboxes();
1122            pack();
1123            repaint();
1124        }
1125        if (e.getPropertyName().equals(CarRoads.CARROADS_CHANGED_PROPERTY)) {
1126            updateRoadComboBoxes();
1127        }
1128        if (e.getPropertyName().equals(EngineModels.ENGINEMODELS_CHANGED_PROPERTY)) {
1129            InstanceManager.getDefault(EngineModels.class).updateComboBox(modelEngineBox);
1130            modelEngineBox.insertItemAt(NONE, 0);
1131            modelEngineBox.setSelectedIndex(0);
1132            if (_train != null) {
1133                modelEngineBox.setSelectedItem(_train.getEngineModel());
1134            }
1135        }
1136        if (e.getPropertyName().equals(Train.DEPARTURETIME_CHANGED_PROPERTY)) {
1137            updateDepartureTime();
1138        }
1139        if (e.getPropertyName().equals(Train.TRAIN_ROUTE_CHANGED_PROPERTY) && _train != null) {
1140            routeBox.setSelectedItem(_train.getRoute());
1141        }
1142        if (e.getPropertyName().equals(Route.ROUTE_STATUS_CHANGED_PROPERTY)) {
1143            enableButtons(_train != null);
1144            updateRouteStatus();
1145        }
1146        if (e.getPropertyName().equals(Train.ROADS_CHANGED_PROPERTY) ||
1147                e.getPropertyName().equals(Train.LOADS_CHANGED_PROPERTY)) {
1148            updateRoadAndLoadStatus();
1149        }
1150    }
1151
1152    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(TrainEditFrame.class);
1153}