001package jmri.jmrit.operations.rollingstock.cars.gui;
002
003import java.awt.Dimension;
004import java.awt.GridBagLayout;
005import java.util.List;
006import java.util.ResourceBundle;
007
008import javax.swing.*;
009
010import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
011import jmri.InstanceManager;
012import jmri.jmrit.operations.OperationsXml;
013import jmri.jmrit.operations.locations.*;
014import jmri.jmrit.operations.locations.divisions.*;
015import jmri.jmrit.operations.rollingstock.*;
016import jmri.jmrit.operations.rollingstock.cars.*;
017import jmri.jmrit.operations.rollingstock.cars.tools.*;
018import jmri.jmrit.operations.router.Router;
019import jmri.jmrit.operations.setup.Control;
020import jmri.jmrit.operations.setup.Setup;
021import jmri.jmrit.operations.trains.Train;
022import jmri.jmrit.operations.trains.tools.TrainByCarTypeFrame;
023import jmri.util.swing.JmriJOptionPane;
024
025/**
026 * Frame for user to place car on the layout
027 *
028 * @author Dan Boudreau Copyright (C) 2008, 2010, 2011, 2013, 2014, 2021
029 */
030public class CarSetFrame extends RollingStockSetFrame<Car> {
031
032    protected static final ResourceBundle rb = ResourceBundle
033            .getBundle("jmri.jmrit.operations.rollingstock.cars.JmritOperationsCarsBundle");
034    private static final String IGNORE = "Ignore";
035    private static final String KERNEL = "Kernel";
036    private static final String TIP_IGNORE = "TipIgnore";
037
038    CarManager carManager = InstanceManager.getDefault(CarManager.class);
039    CarLoads carLoads = InstanceManager.getDefault(CarLoads.class);
040
041    public Car _car;
042
043    // combo boxes
044    protected JComboBox<Division> divisionComboBox = InstanceManager.getDefault(DivisionManager.class).getComboBox();
045    protected JComboBox<Location> destReturnWhenEmptyBox = InstanceManager.getDefault(LocationManager.class)
046            .getComboBox();
047    protected JComboBox<Track> trackReturnWhenEmptyBox = new JComboBox<>();
048    protected JComboBox<String> loadReturnWhenEmptyBox = carLoads.getComboBox(null);
049    protected JComboBox<Location> destReturnWhenLoadedBox = InstanceManager.getDefault(LocationManager.class)
050            .getComboBox();
051    protected JComboBox<Track> trackReturnWhenLoadedBox = new JComboBox<>();
052    protected JComboBox<String> loadReturnWhenLoadedBox = carLoads.getComboBox(null);
053    protected JComboBox<String> loadComboBox = carLoads.getComboBox(null);
054    protected JComboBox<String> kernelComboBox = InstanceManager.getDefault(KernelManager.class).getComboBox();
055
056    // buttons
057    protected JButton editDivisionButton = new JButton(Bundle.getMessage("ButtonEdit"));
058    protected JButton editLoadButton = new JButton(Bundle.getMessage("ButtonEdit"));
059    protected JButton editKernelButton = new JButton(Bundle.getMessage("ButtonEdit"));
060
061    // check boxes
062    public JCheckBox ignoreDivisionCheckBox = new JCheckBox(Bundle.getMessage(IGNORE));
063    public JCheckBox ignoreRWECheckBox = new JCheckBox(Bundle.getMessage(IGNORE));
064    protected JCheckBox autoReturnWhenEmptyTrackCheckBox = new JCheckBox(Bundle.getMessage("Auto"));
065    public JCheckBox ignoreRWLCheckBox = new JCheckBox(Bundle.getMessage(IGNORE));
066    protected JCheckBox autoReturnWhenLoadedTrackCheckBox = new JCheckBox(Bundle.getMessage("Auto"));
067    public JCheckBox ignoreLoadCheckBox = new JCheckBox(Bundle.getMessage(IGNORE));
068    public JCheckBox ignoreKernelCheckBox = new JCheckBox(Bundle.getMessage(IGNORE));
069
070    // Auto checkbox state
071    private static boolean autoReturnWhenEmptyTrackCheckBoxSelected = false;
072    private static boolean autoReturnWhenLoadedTrackCheckBoxSelected = false;
073
074    private static boolean enableDestination = false;
075    
076    private String _help = "package.jmri.jmrit.operations.Operations_CarsSet";
077
078    public CarSetFrame() {
079        super(Bundle.getMessage("TitleCarSet"));
080    }
081    
082    public void initComponents(String help) {
083        _help = help;
084        initComponents();
085    }
086
087    @Override
088    public void initComponents() {
089        super.initComponents();
090
091        // build menu
092        JMenuBar menuBar = new JMenuBar();
093        JMenu toolMenu = new JMenu(Bundle.getMessage("MenuTools"));
094        toolMenu.add(new EnableDestinationAction(this));
095        toolMenu.add(new CarRoutingReportAction(this, true)); // preview
096        toolMenu.add(new CarRoutingReportAction(this, false)); // print
097        menuBar.add(toolMenu);
098        setJMenuBar(menuBar);
099        addHelpMenu(_help, true); // NOI18N
100
101        // initial caps for some languages i.e. German
102        editLoadButton.setToolTipText(
103                Bundle.getMessage("TipAddDeleteReplace", Bundle.getMessage("load")));
104        editKernelButton.setToolTipText(Bundle.getMessage("TipAddDeleteReplace",
105                Bundle.getMessage(KERNEL).toLowerCase()));
106
107        // optional panel load, return when empty, return when loaded, division, and
108        // kernel
109        paneOptional.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("BorderLayoutOptional")));
110        pOptional.setLayout(new BoxLayout(pOptional, BoxLayout.Y_AXIS));
111
112        // add load fields
113        JPanel pLoad = new JPanel();
114        pLoad.setLayout(new GridBagLayout());
115        pLoad.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("Load")));
116        addItemLeft(pLoad, ignoreLoadCheckBox, 1, 0);
117        loadComboBox.setName("loadComboBox");
118        addItem(pLoad, loadComboBox, 2, 0);
119        addItem(pLoad, editLoadButton, 3, 0);
120        pOptional.add(pLoad);
121
122        // row 5
123        JPanel pReturnWhenEmpty = new JPanel();
124        pReturnWhenEmpty.setLayout(new GridBagLayout());
125        pReturnWhenEmpty.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("BorderLayoutReturnWhenEmpty")));
126        addItem(pReturnWhenEmpty, new JLabel(Bundle.getMessage("Location")), 1, 0);
127        addItem(pReturnWhenEmpty, new JLabel(Bundle.getMessage("Track")), 2, 0);
128        addItem(pReturnWhenEmpty, new JLabel(Bundle.getMessage("Load")), 3, 0);
129        addItemLeft(pReturnWhenEmpty, ignoreRWECheckBox, 0, 1);
130        addItem(pReturnWhenEmpty, destReturnWhenEmptyBox, 1, 1);
131        addItem(pReturnWhenEmpty, trackReturnWhenEmptyBox, 2, 1);
132        addItem(pReturnWhenEmpty, loadReturnWhenEmptyBox, 3, 1);
133        addItem(pReturnWhenEmpty, autoReturnWhenEmptyTrackCheckBox, 4, 1);
134        pOptional.add(pReturnWhenEmpty);
135
136        // row 6
137        JPanel pReturnWhenLoaded = new JPanel();
138        pReturnWhenLoaded.setLayout(new GridBagLayout());
139        pReturnWhenLoaded
140                .setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("BorderLayoutReturnWhenLoaded")));
141        addItem(pReturnWhenLoaded, new JLabel(Bundle.getMessage("Location")), 1, 0);
142        addItem(pReturnWhenLoaded, new JLabel(Bundle.getMessage("Track")), 2, 0);
143        addItem(pReturnWhenLoaded, new JLabel(Bundle.getMessage("Load")), 3, 0);
144        addItemLeft(pReturnWhenLoaded, ignoreRWLCheckBox, 0, 1);
145        addItem(pReturnWhenLoaded, destReturnWhenLoadedBox, 1, 1);
146        addItem(pReturnWhenLoaded, trackReturnWhenLoadedBox, 2, 1);
147        addItem(pReturnWhenLoaded, loadReturnWhenLoadedBox, 3, 1);
148        addItem(pReturnWhenLoaded, autoReturnWhenLoadedTrackCheckBox, 4, 1);
149        pOptional.add(pReturnWhenLoaded);
150
151        // division field
152        JPanel pDivision = new JPanel();
153        pDivision.setLayout(new GridBagLayout());
154        pDivision.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage("HomeDivision")));
155        addItemLeft(pDivision, ignoreDivisionCheckBox, 1, 0);
156        addItem(pDivision, divisionComboBox, 2, 0);
157        addItem(pDivision, editDivisionButton, 3, 0);
158        pOptional.add(pDivision);
159
160        // add kernel fields
161        JPanel pKernel = new JPanel();
162        pKernel.setLayout(new GridBagLayout());
163        pKernel.setBorder(BorderFactory.createTitledBorder(Bundle.getMessage(KERNEL)));
164        addItemLeft(pKernel, ignoreKernelCheckBox, 1, 0);
165        kernelComboBox.setName("kernelComboBox"); // NOI18N for UI Test
166        addItem(pKernel, kernelComboBox, 2, 0);
167        addItem(pKernel, editKernelButton, 3, 0);
168        pOptional.add(pKernel);
169
170        // don't show ignore checkboxes
171        ignoreDivisionCheckBox.setVisible(false);
172        ignoreRWECheckBox.setVisible(false);
173        ignoreRWLCheckBox.setVisible(false);
174        ignoreLoadCheckBox.setVisible(false);
175        ignoreKernelCheckBox.setVisible(false);
176
177        autoReturnWhenEmptyTrackCheckBox.setSelected(autoReturnWhenEmptyTrackCheckBoxSelected);
178        autoReturnWhenLoadedTrackCheckBox.setSelected(autoReturnWhenLoadedTrackCheckBoxSelected);
179
180        // setup combobox
181        addComboBoxAction(destReturnWhenEmptyBox);
182        addComboBoxAction(destReturnWhenLoadedBox);
183        addComboBoxAction(loadComboBox);
184        addComboBoxAction(divisionComboBox);
185
186        // setup button
187        addButtonAction(editLoadButton);
188        addButtonAction(editDivisionButton);
189        addButtonAction(editKernelButton);
190
191        // setup checkboxes
192        addCheckBoxAction(ignoreRWECheckBox);
193        addCheckBoxAction(ignoreRWLCheckBox);
194        addCheckBoxAction(autoReturnWhenEmptyTrackCheckBox);
195        addCheckBoxAction(autoReturnWhenLoadedTrackCheckBox);
196        addCheckBoxAction(ignoreLoadCheckBox);
197        addCheckBoxAction(ignoreDivisionCheckBox);
198        addCheckBoxAction(ignoreKernelCheckBox);
199
200        // tool tips
201        ignoreRWECheckBox.setToolTipText(Bundle.getMessage(TIP_IGNORE));
202        ignoreRWLCheckBox.setToolTipText(Bundle.getMessage(TIP_IGNORE));
203        ignoreLoadCheckBox.setToolTipText(Bundle.getMessage(TIP_IGNORE));
204        ignoreDivisionCheckBox.setToolTipText(Bundle.getMessage(TIP_IGNORE));
205        ignoreKernelCheckBox.setToolTipText(Bundle.getMessage(TIP_IGNORE));
206        outOfServiceCheckBox.setToolTipText(Bundle.getMessage("TipCarOutOfService"));
207        autoReturnWhenEmptyTrackCheckBox.setToolTipText(Bundle.getMessage("rsTipAutoTrack"));
208        autoReturnWhenLoadedTrackCheckBox.setToolTipText(Bundle.getMessage("rsTipAutoTrack"));
209
210        // get notified if combo box gets modified
211        carLoads.addPropertyChangeListener(this);
212        carManager.addPropertyChangeListener(this);
213        InstanceManager.getDefault(KernelManager.class).addPropertyChangeListener(this);
214        InstanceManager.getDefault(DivisionManager.class).addPropertyChangeListener(this);
215
216        initMinimumSize(new Dimension(Control.panelWidth500, Control.panelHeight500));
217    }
218
219    public void load(Car car) {
220        _car = car;
221        super.load(car);
222        updateLoadComboBox();
223        updateRweLoadComboBox();
224        updateRwlLoadComboBox();
225        updateDivisionComboBox();
226        updateKernelComboBox();
227    }
228
229    @Override
230    protected ResourceBundle getRb() {
231        return rb;
232    }
233
234    @Override
235    protected void updateComboBoxes() {
236        super.updateComboBoxes();
237
238        locationManager.updateComboBox(destReturnWhenEmptyBox);
239        locationManager.updateComboBox(destReturnWhenLoadedBox);
240
241        updateFinalDestinationComboBoxes();
242        updateReturnWhenEmptyComboBoxes();
243        updateReturnWhenLoadedComboBoxes();
244    }
245
246    @Override
247    protected void enableComponents(boolean enabled) {
248        // If routing is disabled, the RWE and Final Destination fields do not work
249        if (!Setup.isCarRoutingEnabled()) {
250            ignoreRWECheckBox.setSelected(true);
251            ignoreRWLCheckBox.setSelected(true);
252            ignoreFinalDestinationCheckBox.setSelected(true);
253            ignoreDivisionCheckBox.setSelected(true);
254        }
255
256        super.enableComponents(enabled);
257
258        ignoreRWECheckBox.setEnabled(Setup.isCarRoutingEnabled() && enabled);
259        destReturnWhenEmptyBox.setEnabled(!ignoreRWECheckBox.isSelected() && enabled);
260        trackReturnWhenEmptyBox.setEnabled(!ignoreRWECheckBox.isSelected() && enabled);
261        loadReturnWhenEmptyBox.setEnabled(!ignoreRWECheckBox.isSelected() && enabled);
262        autoReturnWhenEmptyTrackCheckBox.setEnabled(!ignoreRWECheckBox.isSelected() && enabled);
263
264        ignoreRWLCheckBox.setEnabled(Setup.isCarRoutingEnabled() && enabled);
265        destReturnWhenLoadedBox.setEnabled(!ignoreRWLCheckBox.isSelected() && enabled);
266        trackReturnWhenLoadedBox.setEnabled(!ignoreRWLCheckBox.isSelected() && enabled);
267        loadReturnWhenLoadedBox.setEnabled(!ignoreRWLCheckBox.isSelected() && enabled);
268        autoReturnWhenLoadedTrackCheckBox.setEnabled(!ignoreRWLCheckBox.isSelected() && enabled);
269
270        ignoreLoadCheckBox.setEnabled(enabled);
271        loadComboBox.setEnabled(!ignoreLoadCheckBox.isSelected() && enabled);
272        editLoadButton.setEnabled(!ignoreLoadCheckBox.isSelected() && enabled && _car != null);
273        
274        ignoreDivisionCheckBox.setEnabled(Setup.isCarRoutingEnabled() && enabled);
275        divisionComboBox.setEnabled(!ignoreDivisionCheckBox.isSelected() && enabled);
276        editDivisionButton.setEnabled(!ignoreDivisionCheckBox.isSelected() && enabled && _car != null);
277
278        ignoreKernelCheckBox.setEnabled(enabled);
279        kernelComboBox.setEnabled(!ignoreKernelCheckBox.isSelected() && enabled);
280        editKernelButton.setEnabled(!ignoreKernelCheckBox.isSelected() && enabled && _car != null);
281
282        enableDestinationFields(enabled);
283    }
284
285    private void enableDestinationFields(boolean enabled) {
286        // if car in a built train, enable destination fields
287        boolean enableDest = enableDestination ||
288                destinationBox.getSelectedItem() != null ||
289                (_car != null && _car.getTrain() != null && _car.getTrain().isBuilt());
290
291        destinationBox.setEnabled(!ignoreDestinationCheckBox.isSelected() && enableDest && enabled);
292        trackDestinationBox.setEnabled(!ignoreDestinationCheckBox.isSelected() && enableDest && enabled);
293        autoDestinationTrackCheckBox.setEnabled(!ignoreDestinationCheckBox.isSelected() && enableDest && enabled);
294    }
295
296    // combo boxes
297    @Override
298    public void comboBoxActionPerformed(java.awt.event.ActionEvent ae) {
299        super.comboBoxActionPerformed(ae);
300        if (ae.getSource() == finalDestinationBox) {
301            updateFinalDestinationTrack();
302        }
303        if (ae.getSource() == destReturnWhenEmptyBox) {
304            updateReturnWhenEmptyTrack();
305        }
306        if (ae.getSource() == destReturnWhenLoadedBox) {
307            updateReturnWhenLoadedTrack();
308        }
309    }
310
311    CarLoadEditFrame lef;
312    CarAttributeEditFrame cef;
313    DivisionEditFrame def;    
314
315    @Override
316    public void buttonActionPerformed(java.awt.event.ActionEvent ae) {
317        super.buttonActionPerformed(ae);
318        if (ae.getSource() == editLoadButton && _car != null) {
319            if (lef != null) {
320                lef.dispose();
321            }
322            lef = new CarLoadEditFrame();
323            lef.initComponents(_car.getTypeName(), (String) loadComboBox.getSelectedItem());
324        }
325        if (ae.getSource() == editKernelButton) {
326            if (cef != null) {
327                cef.dispose();
328            }
329            cef = new CarAttributeEditFrame();
330            cef.addPropertyChangeListener(this);
331            cef.initComponents(CarAttributeEditFrame.KERNEL, (String) kernelComboBox.getSelectedItem());
332        }
333        if (ae.getSource() == editDivisionButton) {
334            if (def != null) {
335                def.dispose();
336            }
337            def = new DivisionEditFrame((Division) divisionComboBox.getSelectedItem());
338        }
339    }
340
341    @Override
342    protected boolean save() {
343        if (change(_car)) {
344            OperationsXml.save();
345            return true;
346        }
347        return false;
348    }
349
350    protected boolean askKernelChange = true;
351
352    @SuppressFBWarnings(value = "ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD", justification = "GUI ease of use")
353    protected boolean change(Car car) {
354        // save the auto button
355        autoReturnWhenEmptyTrackCheckBoxSelected = autoReturnWhenEmptyTrackCheckBox.isSelected();
356        autoReturnWhenLoadedTrackCheckBoxSelected = autoReturnWhenLoadedTrackCheckBox.isSelected();
357
358        // save car's track in case there's a schedule
359        Track saveTrack = car.getTrack();
360        // update location
361        if (!changeLocation(car)) {
362            return false;
363        }
364        // car load
365        setCarLoad(car);
366        // set final destination fields before destination in case there's a schedule at
367        // destination
368        if (!setCarFinalDestination(car)) {
369            return false;
370        }
371        // division
372        if (!ignoreDivisionCheckBox.isSelected()) {
373            car.setDivision((Division) divisionComboBox.getSelectedItem());
374        }
375        // kernel
376        setCarKernel(car);
377        if (!super.change(car)) {
378            return false;
379        }
380        // return when empty fields
381        if (!setCarRWE(car)) {
382            return false;
383        }
384        // return when loaded fields
385        if (!setCarRWL(car)) {
386            return false;
387        }
388        // check to see if there's a schedule when placing the car at a spur
389        if (!applySchedule(car, saveTrack)) {
390            return false;
391        }
392        // determine if train services this car's load
393        if (!checkTrainLoad(car)) {
394            return false;
395        }
396        // determine if train's route can service car
397        if (!checkTrainRoute(car)) {
398            return false;
399        }
400        checkTrain(car);
401        // is this car part of a kernel?
402        if (askKernelChange && car.getKernel() != null) {
403            List<Car> list = car.getKernel().getCars();
404            if (list.size() > 1) {
405                if (JmriJOptionPane.showConfirmDialog(this,
406                        Bundle.getMessage("carInKernel", car.toString()),
407                        Bundle.getMessage("carPartKernel", car.getKernelName()),
408                        JmriJOptionPane.YES_NO_OPTION) == JmriJOptionPane.YES_OPTION) {
409                    if (!updateGroup(list)) {
410                        return false;
411                    }
412                } else if (outOfServiceCheckBox.isSelected()) {
413                    car.setKernel(null); // don't leave car in kernel if out of service
414                }
415            }
416        }
417        return true;
418    }
419    
420    private void setCarLoad(Car car) {
421        if (!ignoreLoadCheckBox.isSelected() && loadComboBox.getSelectedItem() != null) {
422            String load = (String) loadComboBox.getSelectedItem();
423            if (!car.getLoadName().equals(load)) {
424                if (carLoads.containsName(car.getTypeName(), load)) {
425                    car.setLoadName(load);
426                    car.setWait(0); // car could be at spur with schedule
427                    car.setScheduleItemId(Car.NONE);
428                    updateComboBoxesLoadChange();
429                } else {
430                    JmriJOptionPane.showMessageDialog(this,
431                            Bundle.getMessage("carLoadNotValid", load, car.getTypeName()),
432                            Bundle.getMessage("carCanNotChangeLoad"), JmriJOptionPane.WARNING_MESSAGE);
433                }
434            }
435        }
436    }
437    
438    private boolean setCarFinalDestination(Car car) {
439        if (!ignoreFinalDestinationCheckBox.isSelected()) {
440            if (finalDestinationBox.getSelectedItem() == null) {
441                car.setFinalDestination(null);
442                car.setFinalDestinationTrack(null);
443            } else {
444                Track finalDestTrack = null;
445                if (finalDestTrackBox.getSelectedItem() != null) {
446                    finalDestTrack = (Track) finalDestTrackBox.getSelectedItem();
447                }
448                if (finalDestTrack != null &&
449                        car.getFinalDestinationTrack() != finalDestTrack &&
450                        finalDestTrack.isStaging()) {
451                    log.debug("Destination track ({}) is staging", finalDestTrack.getName());
452                    JmriJOptionPane.showMessageDialog(this, Bundle.getMessage("rsDoNotSelectStaging"),
453                            Bundle.getMessage("rsCanNotFinal"), JmriJOptionPane.ERROR_MESSAGE);
454                    return false;
455                }
456                car.setFinalDestination((Location) finalDestinationBox.getSelectedItem());
457                car.setFinalDestinationTrack(finalDestTrack);
458                String status = getTestCar(car, car.getLoadName())
459                        .checkDestination(car.getFinalDestination(), finalDestTrack);
460                // ignore custom load warning
461                if (!status.equals(Track.OKAY) && !status.contains(Track.CUSTOM)) {
462                    JmriJOptionPane.showMessageDialog(this,
463                            Bundle.getMessage("rsCanNotFinalMsg", car.toString(), status),
464                            Bundle.getMessage("rsCanNotFinal"), JmriJOptionPane.WARNING_MESSAGE);
465                    return false;
466                } else {
467                    // check to see if car can be routed to final destination
468                    Router router = InstanceManager.getDefault(Router.class);
469                    if (!router.isCarRouteable(car, null, car.getFinalDestination(), finalDestTrack, null)) {
470                        JmriJOptionPane.showMessageDialog(this,
471                                Bundle.getMessage("rsCanNotRouteMsg", car.toString(),
472                                        car.getLocationName(), car.getTrackName(), car.getFinalDestinationName(),
473                                        car.getFinalDestinationTrackName()),
474                                Bundle.getMessage("rsCanNotFinal"), JmriJOptionPane.WARNING_MESSAGE);
475                        return false;
476                    }
477                }
478            }
479        }
480        return true;
481    }
482    
483    private void setCarKernel(Car car) {
484        if (!ignoreKernelCheckBox.isSelected() && kernelComboBox.getSelectedItem() != null) {
485            if (kernelComboBox.getSelectedItem().equals(RollingStockManager.NONE)) {
486                car.setKernel(null);
487                if (!car.isPassenger()) {
488                    car.setBlocking(Car.DEFAULT_BLOCKING_ORDER);
489                }
490            } else if (!car.getKernelName().equals(kernelComboBox.getSelectedItem())) {
491                car.setKernel(InstanceManager.getDefault(KernelManager.class).getKernelByName((String) kernelComboBox.getSelectedItem()));
492                // if car has FRED or is caboose make lead
493                if (car.hasFred() || car.isCaboose()) {
494                    car.getKernel().setLead(car);
495                }
496                car.setBlocking(car.getKernel().getSize());
497            }
498        }
499    }
500    
501    private boolean setCarRWE(Car car) {
502        if (!ignoreRWECheckBox.isSelected()) {
503            // check that RWE load is valid for this car's type
504            if (carLoads.getNames(car.getTypeName()).contains(loadReturnWhenEmptyBox.getSelectedItem())) {
505                car.setReturnWhenEmptyLoadName((String) loadReturnWhenEmptyBox.getSelectedItem());
506            } else {
507                log.debug("Car ({}) type ({}) doesn't support RWE load ({})", car, car.getTypeName(),
508                        loadReturnWhenEmptyBox.getSelectedItem());
509                JmriJOptionPane.showMessageDialog(this,
510                        Bundle.getMessage("carLoadNotValid",
511                                loadReturnWhenEmptyBox.getSelectedItem(), car.getTypeName()),
512                        Bundle.getMessage("carCanNotChangeRweLoad"), JmriJOptionPane.WARNING_MESSAGE);
513            }
514            if (destReturnWhenEmptyBox.getSelectedItem() == null) {
515                car.setReturnWhenEmptyDestination(null);
516                car.setReturnWhenEmptyDestTrack(null);
517            } else {
518                Location locationRWE = (Location) destReturnWhenEmptyBox.getSelectedItem();
519                if (trackReturnWhenEmptyBox.getSelectedItem() != null) {
520                    Track trackRWE = (Track) trackReturnWhenEmptyBox.getSelectedItem();
521                    // warn user if they selected a staging track
522                    if (trackRWE != null && trackRWE.isStaging()) {
523                        log.debug("Return when empty track ({}) is staging", trackRWE.getName());
524                        JmriJOptionPane.showMessageDialog(this, Bundle.getMessage("rsDoNotSelectStaging"),
525                                Bundle.getMessage("carCanNotRWE"), JmriJOptionPane.ERROR_MESSAGE);
526                        return false;
527                    }
528                    // use a test car with a load of "RWE" and no length
529                    String status = getTestCar(car, car.getReturnWhenEmptyLoadName()).checkDestination(locationRWE,
530                            trackRWE);
531                    if (!status.equals(Track.OKAY)) {
532                        JmriJOptionPane.showMessageDialog(this,
533                                Bundle.getMessage("carCanNotRWEMsg", car.toString(), locationRWE,
534                                        trackRWE, status),
535                                Bundle.getMessage("carCanNotRWE"), JmriJOptionPane.WARNING_MESSAGE);
536                    }
537                    car.setReturnWhenEmptyDestTrack(trackRWE);
538                } else {
539                    car.setReturnWhenEmptyDestTrack(null);
540                }
541                car.setReturnWhenEmptyDestination(locationRWE);
542            }
543        }
544        return true;
545    }
546    
547    private boolean setCarRWL(Car car) {
548        if (!ignoreRWLCheckBox.isSelected()) {
549            // check that RWL load is valid for this car's type
550            if (carLoads.getNames(car.getTypeName()).contains(loadReturnWhenLoadedBox.getSelectedItem())) {
551                car.setReturnWhenLoadedLoadName((String) loadReturnWhenLoadedBox.getSelectedItem());
552            } else {
553                log.debug("Car ({}) type ({}) doesn't support RWL load ({})", car, car.getTypeName(),
554                        loadReturnWhenLoadedBox.getSelectedItem());
555                JmriJOptionPane.showMessageDialog(this,
556                        Bundle.getMessage("carLoadNotValid",
557                                loadReturnWhenEmptyBox.getSelectedItem(), car.getTypeName()),
558                        Bundle.getMessage("carCanNotChangeRwlLoad"), JmriJOptionPane.WARNING_MESSAGE);
559            }
560            if (destReturnWhenLoadedBox.getSelectedItem() == null) {
561                car.setReturnWhenLoadedDestination(null);
562                car.setReturnWhenLoadedDestTrack(null);
563            } else {
564                Location locationRWL = (Location) destReturnWhenLoadedBox.getSelectedItem();
565                if (trackReturnWhenLoadedBox.getSelectedItem() != null) {
566                    Track trackRWL = (Track) trackReturnWhenLoadedBox.getSelectedItem();
567                    // warn user if they selected a staging track
568                    if (trackRWL != null && trackRWL.isStaging()) {
569                        log.debug("Return when loaded track ({}) is staging", trackRWL.getName());
570                        JmriJOptionPane.showMessageDialog(this, Bundle.getMessage("rsDoNotSelectStaging"),
571                                Bundle.getMessage("carCanNotRWL"), JmriJOptionPane.ERROR_MESSAGE);
572                        return false;
573                    }
574                    // use a test car with a load of "RWL" and no length
575                    String status = getTestCar(car, car.getReturnWhenLoadedLoadName()).checkDestination(locationRWL,
576                            trackRWL);
577                    if (!status.equals(Track.OKAY)) {
578                        JmriJOptionPane.showMessageDialog(this,
579                                Bundle.getMessage("carCanNotRWLMsg", car.toString(), locationRWL,
580                                        trackRWL, status),
581                                Bundle.getMessage("carCanNotRWL"), JmriJOptionPane.WARNING_MESSAGE);
582                    }
583                    car.setReturnWhenLoadedDestTrack(trackRWL);
584                } else {
585                    car.setReturnWhenLoadedDestTrack(null);
586                }
587                car.setReturnWhenLoadedDestination(locationRWL);
588            }
589        }
590        return true;
591    }
592    
593    private boolean applySchedule(Car car, Track saveTrack) {
594        if (!ignoreLocationCheckBox.isSelected() &&
595                trackLocationBox.getSelectedItem() != null &&
596                saveTrack != trackLocationBox.getSelectedItem()) {
597            Track track = (Track) trackLocationBox.getSelectedItem();
598            if (track.getSchedule() != null) {
599                if (JmriJOptionPane
600                        .showConfirmDialog(this,
601                                Bundle.getMessage("rsDoYouWantSchedule", car.toString()),
602                                Bundle.getMessage("rsSpurHasSchedule", track.getName(),
603                                        track.getScheduleName()),
604                                JmriJOptionPane.YES_NO_OPTION) == JmriJOptionPane.YES_OPTION) {
605                    String results = track.checkSchedule(car);
606                    if (!results.equals(Track.OKAY)) {
607                        JmriJOptionPane.showMessageDialog(this,
608                                Bundle.getMessage("rsNotAbleToApplySchedule", results),
609                                Bundle.getMessage("rsApplyingScheduleFailed"), JmriJOptionPane.ERROR_MESSAGE);
610                        // restore previous location and track so we'll ask to test schedule again
611                        if (saveTrack != null) {
612                            car.setLocation(saveTrack.getLocation(), saveTrack);
613                        } else {
614                            car.setLocation(null, null);
615                        }
616                        return false;
617                    }
618                    // now apply schedule to car
619                    track.scheduleNext(car);
620                    car.loadNext(track);
621                }
622            }
623        }
624        return true;
625    }
626    
627    private boolean checkTrainLoad(Car car) {
628        if (car.getTrain() != null) {
629            Train train = car.getTrain();
630            if (!train.isLoadNameAccepted(car.getLoadName(), car.getTypeName())) {
631                JmriJOptionPane.showMessageDialog(this, Bundle.getMessage("carTrainNotServLoad",
632                        car.getLoadName(), train.getName()), Bundle.getMessage("rsNotMove"), JmriJOptionPane.ERROR_MESSAGE);
633                // prevent rs from being picked up and delivered
634                setRouteLocationAndDestination(car, train, null, null);
635                return false;
636            }
637        }
638        return true;
639    }
640
641    TrainByCarTypeFrame tctf = null;
642    
643    private boolean checkTrainRoute(Car car) {
644        if (car.getTrain() != null) {
645            Train train = car.getTrain();
646            if (car.getLocation() != null && car.getDestination() != null && !train.isServiceable(car)) {
647                JmriJOptionPane.showMessageDialog(this,
648                        Bundle.getMessage("carTrainNotService", car.toString(), train.getName()),
649                        Bundle.getMessage("rsNotMove"), JmriJOptionPane.ERROR_MESSAGE);
650                // show the train's route and car location
651                if (tctf != null) {
652                    tctf.dispose();
653                }
654                tctf = new TrainByCarTypeFrame(car);
655                // prevent rs from being picked up and delivered
656                setRouteLocationAndDestination(car, train, null, null);
657                return false;
658            }
659        }
660        return true;
661    }
662
663    /**
664     * Update locations if load changes. New load could change which track are
665     * allowed if auto selected.
666     */
667    protected void updateComboBoxesLoadChange() {
668        if (autoTrackCheckBox.isSelected()) {
669            updateLocationTrackComboBox();
670        }
671        if (autoDestinationTrackCheckBox.isSelected()) {
672            updateDestinationTrackComboBox();
673        }
674        if (autoFinalDestTrackCheckBox.isSelected()) {
675            updateFinalDestinationTrack();
676        }
677    }
678
679    @Override
680    protected boolean updateGroup(List<Car> list) {
681        for (Car car : list) {
682            if (car == _car) {
683                continue;
684            }
685            // make all cars in kernel the same
686            if (!ignoreRWECheckBox.isSelected()) {
687                car.setReturnWhenEmptyDestination(_car.getReturnWhenEmptyDestination());
688                car.setReturnWhenEmptyDestTrack(_car.getReturnWhenEmptyDestTrack());
689            }
690            if (!ignoreRWLCheckBox.isSelected()) {
691                car.setReturnWhenLoadedDestination(_car.getReturnWhenLoadedDestination());
692                car.setReturnWhenLoadedDestTrack(_car.getReturnWhenLoadedDestTrack());
693            }
694            if (!ignoreFinalDestinationCheckBox.isSelected()) {
695                car.setFinalDestination(_car.getFinalDestination());
696                car.setFinalDestinationTrack(_car.getFinalDestinationTrack());
697                car.setRoutePath(_car.getRoutePath());
698            }
699            // update car load
700            if (!ignoreLoadCheckBox.isSelected() && carLoads.containsName(car.getTypeName(), _car.getLoadName())) {
701                car.setLoadName(_car.getLoadName());
702                car.setWait(0); // car could be at spur with schedule
703                car.setScheduleItemId(Car.NONE);
704            }
705            // update kernel
706            if (!ignoreKernelCheckBox.isSelected()) {
707                car.setKernel(_car.getKernel());
708            }
709            // update division
710            if (!ignoreDivisionCheckBox.isSelected()) {
711                car.setDivision(_car.getDivision());
712            }
713        }
714        return super.updateGroup(list);
715    }
716
717    @Override
718    public void checkBoxActionPerformed(java.awt.event.ActionEvent ae) {
719        super.checkBoxActionPerformed(ae);
720        if (ae.getSource() == autoFinalDestTrackCheckBox) {
721            updateFinalDestinationTrack();
722        }
723        if (ae.getSource() == autoReturnWhenEmptyTrackCheckBox) {
724            updateReturnWhenEmptyTrack();
725        }
726        if (ae.getSource() == autoReturnWhenLoadedTrackCheckBox) {
727            updateReturnWhenLoadedTrack();
728        }
729        if (ae.getSource() == autoTrainCheckBox) {
730            updateTrainComboBox();
731        }
732        if (ae.getSource() == ignoreRWECheckBox) {
733            destReturnWhenEmptyBox.setEnabled(!ignoreRWECheckBox.isSelected());
734            trackReturnWhenEmptyBox.setEnabled(!ignoreRWECheckBox.isSelected());
735            loadReturnWhenEmptyBox.setEnabled(!ignoreRWECheckBox.isSelected());
736            autoReturnWhenEmptyTrackCheckBox.setEnabled(!ignoreRWECheckBox.isSelected());
737        }
738        if (ae.getSource() == ignoreRWLCheckBox) {
739            destReturnWhenLoadedBox.setEnabled(!ignoreRWLCheckBox.isSelected());
740            trackReturnWhenLoadedBox.setEnabled(!ignoreRWLCheckBox.isSelected());
741            loadReturnWhenLoadedBox.setEnabled(!ignoreRWLCheckBox.isSelected());
742            autoReturnWhenLoadedTrackCheckBox.setEnabled(!ignoreRWLCheckBox.isSelected());
743        }
744        if (ae.getSource() == ignoreLoadCheckBox) {
745            loadComboBox.setEnabled(!ignoreLoadCheckBox.isSelected());
746            editLoadButton.setEnabled(!ignoreLoadCheckBox.isSelected() && _car != null);
747        }
748        if (ae.getSource() == ignoreDivisionCheckBox) {
749            divisionComboBox.setEnabled(!ignoreDivisionCheckBox.isSelected());
750            editDivisionButton.setEnabled(!ignoreDivisionCheckBox.isSelected());
751        }
752        if (ae.getSource() == ignoreKernelCheckBox) {
753            kernelComboBox.setEnabled(!ignoreKernelCheckBox.isSelected());
754            editKernelButton.setEnabled(!ignoreKernelCheckBox.isSelected());
755        }
756    }
757
758    protected void updateReturnWhenEmptyComboBoxes() {
759        if (_car != null) {
760            log.debug("Updating return when empty for car ({})", _car);
761            destReturnWhenEmptyBox.setSelectedItem(_car.getReturnWhenEmptyDestination());
762        }
763        updateReturnWhenEmptyTrack();
764    }
765
766    protected void updateReturnWhenEmptyTrack() {
767        if (destReturnWhenEmptyBox.getSelectedItem() == null) {
768            trackReturnWhenEmptyBox.removeAllItems();
769        } else {
770            log.debug("CarSetFrame sees return when empty: {}", destReturnWhenEmptyBox.getSelectedItem());
771            Location loc = (Location) destReturnWhenEmptyBox.getSelectedItem();
772            loc.updateComboBox(trackReturnWhenEmptyBox, getTestCar(_car, _car.getReturnWhenEmptyLoadName()),
773                    autoReturnWhenEmptyTrackCheckBox.isSelected(), true);
774            if (_car != null &&
775                    _car.getReturnWhenEmptyDestination() != null &&
776                    _car.getReturnWhenEmptyDestination().equals(loc) &&
777                    _car.getReturnWhenEmptyDestTrack() != null) {
778                trackReturnWhenEmptyBox.setSelectedItem(_car.getReturnWhenEmptyDestTrack());
779            }
780        }
781    }
782
783    protected void updateReturnWhenLoadedComboBoxes() {
784        if (_car != null) {
785            log.debug("Updating return when loaded for car ({})", _car);
786            destReturnWhenLoadedBox.setSelectedItem(_car.getReturnWhenLoadedDestination());
787        }
788        updateReturnWhenLoadedTrack();
789    }
790
791    protected void updateReturnWhenLoadedTrack() {
792        if (destReturnWhenLoadedBox.getSelectedItem() == null) {
793            trackReturnWhenLoadedBox.removeAllItems();
794        } else {
795            log.debug("CarSetFrame sees return when empty: {}", destReturnWhenLoadedBox.getSelectedItem());
796            Location loc = (Location) destReturnWhenLoadedBox.getSelectedItem();
797            loc.updateComboBox(trackReturnWhenLoadedBox, getTestCar(_car, _car.getReturnWhenLoadedLoadName()),
798                    autoReturnWhenLoadedTrackCheckBox.isSelected(), true);
799            if (_car != null &&
800                    _car.getReturnWhenLoadedDestination() != null &&
801                    _car.getReturnWhenLoadedDestination().equals(loc) &&
802                    _car.getReturnWhenLoadedDestTrack() != null) {
803                trackReturnWhenLoadedBox.setSelectedItem(_car.getReturnWhenLoadedDestTrack());
804            }
805        }
806    }
807
808    protected void updateFinalDestinationComboBoxes() {
809        if (_car != null) {
810            log.debug("Updating final destinations for car ({})", _car);
811            finalDestinationBox.setSelectedItem(_car.getFinalDestination());
812        }
813        updateFinalDestinationTrack();
814    }
815
816    protected void updateFinalDestinationTrack() {
817        if (finalDestinationBox.getSelectedItem() == null) {
818            finalDestTrackBox.removeAllItems();
819        } else {
820            log.debug("CarSetFrame sees final destination: {}", finalDestinationBox.getSelectedItem());
821            Location l = (Location) finalDestinationBox.getSelectedItem();
822            l.updateComboBox(finalDestTrackBox, _car, autoFinalDestTrackCheckBox.isSelected(), true);
823            if (_car != null &&
824                    _car.getFinalDestination() != null &&
825                    _car.getFinalDestination().equals(l) &&
826                    _car.getFinalDestinationTrack() != null) {
827                finalDestTrackBox.setSelectedItem(_car.getFinalDestinationTrack());
828            }
829        }
830    }
831
832    protected void updateLoadComboBox() {
833        if (_car != null) {
834            log.debug("Updating load box for car ({})", _car);
835            carLoads.updateComboBox(_car.getTypeName(), loadComboBox);
836            loadComboBox.setSelectedItem(_car.getLoadName());
837        }
838    }
839
840    protected void updateRweLoadComboBox() {
841        if (_car != null) {
842            log.debug("Updating RWE load box for car ({})", _car);
843            carLoads.updateRweComboBox(_car.getTypeName(), loadReturnWhenEmptyBox);
844            loadReturnWhenEmptyBox.setSelectedItem(_car.getReturnWhenEmptyLoadName());
845        }
846    }
847
848    protected void updateRwlLoadComboBox() {
849        if (_car != null) {
850            log.debug("Updating RWL load box for car ({})", _car);
851            carLoads.updateRwlComboBox(_car.getTypeName(), loadReturnWhenLoadedBox);
852            loadReturnWhenLoadedBox.setSelectedItem(_car.getReturnWhenLoadedLoadName());
853        }
854    }
855
856    protected void updateKernelComboBox() {
857        InstanceManager.getDefault(KernelManager.class).updateComboBox(kernelComboBox);
858        if (_car != null) {
859            kernelComboBox.setSelectedItem(_car.getKernelName());
860        }
861    }
862    
863    protected void updateDivisionComboBox() {
864        InstanceManager.getDefault(DivisionManager.class).updateComboBox(divisionComboBox);
865        if (_car != null) {
866            divisionComboBox.setSelectedItem(_car.getDivision());
867        }
868    }
869
870    @Override
871    protected void updateTrainComboBox() {
872        log.debug("update train combo box");
873        if (_car != null && autoTrainCheckBox.isSelected()) {
874            log.debug("Updating train box for car ({})", _car);
875            trainManager.updateTrainComboBox(trainBox, _car);
876        } else {
877            trainManager.updateTrainComboBox(trainBox);
878        }
879        if (_car != null) {
880            trainBox.setSelectedItem(_car.getTrain());
881        }
882    }
883
884    private Car getTestCar(Car car, String loadName) {
885        Car c = car;
886        // clone car and set the load and a length of zero
887        if (car != null) {
888            c = car.copy();
889            c.setLoadName(loadName);
890            c.setLength(Integer.toString(-RollingStock.COUPLERS)); // ignore car length
891        }
892        return c;
893    }
894
895    @SuppressFBWarnings(value = "ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD", justification = "GUI ease of use")
896    public void setDestinationEnabled(boolean enable) {
897        enableDestination = !enableDestination;
898        enableDestinationFields(!locationUnknownCheckBox.isSelected());
899    }
900
901    @Override
902    public void dispose() {
903        if (lef != null) {
904            lef.dispose();
905        }
906        if (cef != null) {
907            cef.removePropertyChangeListener(this);
908            cef.dispose();
909        }
910        if (def != null) {
911            def.dispose();
912        }
913        if (tctf != null) {
914            tctf.dispose();
915        }
916        InstanceManager.getDefault(CarLoads.class).removePropertyChangeListener(this);
917        InstanceManager.getDefault(KernelManager.class).removePropertyChangeListener(this);
918        InstanceManager.getDefault(DivisionManager.class).removePropertyChangeListener(this);
919        carManager.removePropertyChangeListener(this);
920        super.dispose();
921    }
922
923    @Override
924    public void propertyChange(java.beans.PropertyChangeEvent e) {
925        log.debug("PropertyChange ({}) new ({})", e.getPropertyName(), e.getNewValue());
926        super.propertyChange(e);
927        if (e.getPropertyName().equals(Car.FINAL_DESTINATION_CHANGED_PROPERTY) ||
928                e.getPropertyName().equals(Car.FINAL_DESTINATION_TRACK_CHANGED_PROPERTY)) {
929            updateFinalDestinationComboBoxes();
930        }
931        if (e.getPropertyName().equals(CarLoads.LOAD_CHANGED_PROPERTY) ||
932                e.getPropertyName().equals(Car.LOAD_CHANGED_PROPERTY)) {
933            updateLoadComboBox();
934        }
935        if (e.getPropertyName().equals(CarLoads.LOAD_CHANGED_PROPERTY) ||
936                e.getPropertyName().equals(CarLoads.LOAD_TYPE_CHANGED_PROPERTY) ||
937                e.getPropertyName().equals(Car.RWE_LOAD_CHANGED_PROPERTY)) {
938            updateRweLoadComboBox();
939        }
940        if (e.getPropertyName().equals(CarLoads.LOAD_CHANGED_PROPERTY) ||
941                e.getPropertyName().equals(CarLoads.LOAD_TYPE_CHANGED_PROPERTY) ||
942                e.getPropertyName().equals(Car.RWL_LOAD_CHANGED_PROPERTY)) {
943            updateRwlLoadComboBox();
944        }
945        if (e.getPropertyName().equals(Car.RETURN_WHEN_EMPTY_CHANGED_PROPERTY)) {
946            updateReturnWhenEmptyComboBoxes();
947        }
948        if (e.getPropertyName().equals(Car.RETURN_WHEN_LOADED_CHANGED_PROPERTY)) {
949            updateReturnWhenLoadedComboBoxes();
950        }
951        if (e.getPropertyName().equals(KernelManager.LISTLENGTH_CHANGED_PROPERTY) ||
952                e.getPropertyName().equals(Car.KERNEL_NAME_CHANGED_PROPERTY)) {
953            updateKernelComboBox();
954        }
955        if (e.getPropertyName().equals(DivisionManager.LISTLENGTH_CHANGED_PROPERTY)) {
956            updateDivisionComboBox();
957        }
958        if (e.getPropertyName().equals(RollingStock.TRAIN_CHANGED_PROPERTY)) {
959            enableDestinationFields(!locationUnknownCheckBox.isSelected());
960        }
961        if (e.getPropertyName().equals(CarAttributeEditFrame.DISPOSE)) {
962            cef = null;
963        }
964    }
965
966    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(CarSetFrame.class);
967}