Source code

001package jmri.jmrit.operations.trains.gui;
002
003import java.awt.*;
004import java.beans.PropertyChangeEvent;
005import java.beans.PropertyChangeListener;
006import java.util.Hashtable;
007import java.util.List;
008
009import javax.swing.*;
010import javax.swing.table.DefaultTableCellRenderer;
011import javax.swing.table.TableCellEditor;
012
013import jmri.InstanceManager;
014import jmri.jmrit.beantable.EnablingCheckboxRenderer;
015import jmri.jmrit.operations.locations.Track;
016import jmri.jmrit.operations.setup.Control;
017import jmri.jmrit.operations.setup.Setup;
018import jmri.jmrit.operations.trains.*;
019import jmri.util.swing.JmriJOptionPane;
020import jmri.util.swing.XTableColumnModel;
021import jmri.util.table.ButtonEditor;
022import jmri.util.table.ButtonRenderer;
023
024/**
025 * Table Model for edit of trains used by operations
026 *
027 * @author Daniel Boudreau Copyright (C) 2008, 2012
028 */
029public class TrainsTableModel extends javax.swing.table.AbstractTableModel implements PropertyChangeListener {
030
031    TrainManager trainManager = InstanceManager.getDefault(TrainManager.class); // There is only one manager
032    volatile List<Train> sysList = trainManager.getTrainsByTimeList();
033    JTable _table = null;
034    TrainsTableFrame _frame = null;
035    
036    // Defines the columns
037    private static final int ID_COLUMN = 0;
038    private static final int TIME_COLUMN = ID_COLUMN + 1;
039    private static final int BUILDBOX_COLUMN = TIME_COLUMN + 1;
040    private static final int BUILD_COLUMN = BUILDBOX_COLUMN + 1;
041    private static final int NAME_COLUMN = BUILD_COLUMN + 1;
042    private static final int DESCRIPTION_COLUMN = NAME_COLUMN + 1;
043    private static final int BUILT_COLUMN = DESCRIPTION_COLUMN + 1;
044    private static final int CAR_ROAD_COLUMN = BUILT_COLUMN + 1;
045    private static final int CABOOSE_ROAD_COLUMN = CAR_ROAD_COLUMN + 1;
046    private static final int LOCO_ROAD_COLUMN = CABOOSE_ROAD_COLUMN + 1;
047    private static final int LOAD_COLUMN = LOCO_ROAD_COLUMN + 1;
048    private static final int OWNER_COLUMN = LOAD_COLUMN + 1;
049    private static final int ROUTE_COLUMN = OWNER_COLUMN + 1;
050    private static final int DEPARTS_COLUMN = ROUTE_COLUMN + 1;
051    private static final int TERMINATES_COLUMN = DEPARTS_COLUMN + 1;
052    private static final int CURRENT_COLUMN = TERMINATES_COLUMN + 1;
053    private static final int CARS_COLUMN = CURRENT_COLUMN + 1;
054    private static final int STATUS_COLUMN = CARS_COLUMN + 1;
055    private static final int ACTION_COLUMN = STATUS_COLUMN + 1;
056    private static final int EDIT_COLUMN = ACTION_COLUMN + 1;
057
058    private static final int HIGHESTCOLUMN = EDIT_COLUMN + 1;
059
060    public TrainsTableModel() {
061        super();
062        trainManager.addPropertyChangeListener(this);
063        Setup.getDefault().addPropertyChangeListener(this);
064        updateList();
065    }
066
067    public final int SORTBYTIME = 2;
068    public final int SORTBYID = 7;
069
070    private int _sort = SORTBYTIME;
071
072    public void setSort(int sort) {
073        _sort = sort;
074        updateList();
075        updateColumnVisible();
076    }
077
078    private boolean _showAll = true;
079
080    public void setShowAll(boolean showAll) {
081        _showAll = showAll;
082        updateList();
083        fireTableDataChanged();
084    }
085
086    public boolean isShowAll() {
087        return _showAll;
088    }
089
090    private void updateList() {
091        // first, remove listeners from the individual objects
092        removePropertyChangeTrains();
093
094        List<Train> tempList;
095        if (_sort == SORTBYID) {
096            tempList = trainManager.getTrainsByIdList();
097        } else {
098            tempList = trainManager.getTrainsByTimeList();
099        }
100
101        if (!isShowAll()) {
102            // filter out trains not checked
103            for (int i = tempList.size() - 1; i >= 0; i--) {
104                if (!tempList.get(i).isBuildEnabled()) {
105                    tempList.remove(i);
106                }
107            }
108        }
109        sysList = tempList;
110
111        // and add listeners back in
112        addPropertyChangeTrains();
113    }
114
115    private Train getTrainByRow(int row) {
116        return sysList.get(row);
117    }
118
119    void initTable(JTable table, TrainsTableFrame frame) {
120        _table = table;
121        _frame = frame;
122        // allow row color to be controlled
123        table.setDefaultRenderer(Object.class, new MyTableCellRenderer());
124        table.setDefaultRenderer(Integer.class, new MyTableCellRenderer());
125        initTable();
126    }
127
128    // Train frame table column widths, starts with id column and ends with edit
129    private final int[] _tableColumnWidths =
130            {50, 50, 50, 72, 100, 140, 50, 50, 50, 50, 50, 50, 120, 120, 120, 120, 50, 120, 90,
131            70};
132
133    void initTable() {
134        // Use XTableColumnModel so we can control which columns are visible
135        XTableColumnModel tcm = new XTableColumnModel();
136        _table.setColumnModel(tcm);
137        _table.createDefaultColumnsFromModel();
138
139        // Install the button handlers
140        ButtonRenderer buttonRenderer = new ButtonRenderer();
141        ButtonRenderer buttonRenderer2 = new ButtonRenderer(); // for tool tips
142        TableCellEditor buttonEditor = new ButtonEditor(new javax.swing.JButton());
143        tcm.getColumn(EDIT_COLUMN).setCellRenderer(buttonRenderer);
144        tcm.getColumn(EDIT_COLUMN).setCellEditor(buttonEditor);
145        tcm.getColumn(ACTION_COLUMN).setCellRenderer(buttonRenderer);
146        tcm.getColumn(ACTION_COLUMN).setCellEditor(buttonEditor);
147        tcm.getColumn(BUILD_COLUMN).setCellRenderer(buttonRenderer2);
148        tcm.getColumn(BUILD_COLUMN).setCellEditor(buttonEditor);
149        _table.setDefaultRenderer(Boolean.class, new EnablingCheckboxRenderer());
150
151        // set column preferred widths
152        for (int i = 0; i < tcm.getColumnCount(); i++) {
153            tcm.getColumn(i).setPreferredWidth(_tableColumnWidths[i]);
154        }
155        _frame.loadTableDetails(_table);
156
157        // turn off column
158        updateColumnVisible();
159    }
160
161    private void updateColumnVisible() {
162        XTableColumnModel tcm = (XTableColumnModel) _table.getColumnModel();
163        tcm.setColumnVisible(tcm.getColumnByModelIndex(ID_COLUMN), _sort == SORTBYID);
164        tcm.setColumnVisible(tcm.getColumnByModelIndex(TIME_COLUMN), _sort == SORTBYTIME);
165        tcm.setColumnVisible(tcm.getColumnByModelIndex(BUILT_COLUMN), trainManager.isBuiltRestricted());
166        tcm.setColumnVisible(tcm.getColumnByModelIndex(CAR_ROAD_COLUMN), trainManager.isCarRoadRestricted());
167        tcm.setColumnVisible(tcm.getColumnByModelIndex(CABOOSE_ROAD_COLUMN), trainManager.isCabooseRoadRestricted());
168        tcm.setColumnVisible(tcm.getColumnByModelIndex(LOCO_ROAD_COLUMN), trainManager.isLocoRoadRestricted());
169        tcm.setColumnVisible(tcm.getColumnByModelIndex(LOAD_COLUMN), trainManager.isLoadRestricted());
170        tcm.setColumnVisible(tcm.getColumnByModelIndex(OWNER_COLUMN), trainManager.isOwnerRestricted());
171    }
172
173    @Override
174    public int getRowCount() {
175        return sysList.size();
176    }
177
178    @Override
179    public int getColumnCount() {
180        return HIGHESTCOLUMN;
181    }
182
183    public static final String IDCOLUMNNAME = Bundle.getMessage("Id");
184    public static final String TIMECOLUMNNAME = Bundle.getMessage("Time");
185    public static final String BUILDBOXCOLUMNNAME = Bundle.getMessage("Build");
186    public static final String BUILDCOLUMNNAME = Bundle.getMessage("Function");
187    public static final String NAMECOLUMNNAME = Bundle.getMessage("Name");
188    public static final String DESCRIPTIONCOLUMNNAME = Bundle.getMessage("Description");
189    public static final String ROUTECOLUMNNAME = Bundle.getMessage("Route");
190    public static final String DEPARTSCOLUMNNAME = Bundle.getMessage("Departs");
191    public static final String CURRENTCOLUMNNAME = Bundle.getMessage("Current");
192    public static final String TERMINATESCOLUMNNAME = Bundle.getMessage("Terminates");
193    public static final String STATUSCOLUMNNAME = Bundle.getMessage("Status");
194    public static final String ACTIONCOLUMNNAME = Bundle.getMessage("Action");
195    public static final String EDITCOLUMNNAME = Bundle.getMessage("ButtonEdit");
196
197    @Override
198    public String getColumnName(int col) {
199        switch (col) {
200            case ID_COLUMN:
201                return IDCOLUMNNAME;
202            case TIME_COLUMN:
203                return TIMECOLUMNNAME;
204            case BUILDBOX_COLUMN:
205                return BUILDBOXCOLUMNNAME;
206            case BUILD_COLUMN:
207                return BUILDCOLUMNNAME;
208            case NAME_COLUMN:
209                return NAMECOLUMNNAME;
210            case DESCRIPTION_COLUMN:
211                return DESCRIPTIONCOLUMNNAME;
212            case BUILT_COLUMN:
213                return Bundle.getMessage("Built");
214            case CAR_ROAD_COLUMN:
215                return Bundle.getMessage("RoadsCar");
216            case CABOOSE_ROAD_COLUMN:
217                return Bundle.getMessage("RoadsCaboose");
218            case LOCO_ROAD_COLUMN:
219                return Bundle.getMessage("RoadsLoco");
220            case LOAD_COLUMN:
221                return Bundle.getMessage("Load");
222            case OWNER_COLUMN:
223                return Bundle.getMessage("Owner");
224            case ROUTE_COLUMN:
225                return ROUTECOLUMNNAME;
226            case DEPARTS_COLUMN:
227                return DEPARTSCOLUMNNAME;
228            case CURRENT_COLUMN:
229                return CURRENTCOLUMNNAME;
230            case TERMINATES_COLUMN:
231                return TERMINATESCOLUMNNAME;
232            case CARS_COLUMN:
233                return Bundle.getMessage("Cars");
234            case STATUS_COLUMN:
235                return STATUSCOLUMNNAME;
236            case ACTION_COLUMN:
237                return ACTIONCOLUMNNAME;
238            case EDIT_COLUMN:
239                return EDITCOLUMNNAME;
240            default:
241                return "unknown"; // NOI18N
242        }
243    }
244
245    @Override
246    public Class<?> getColumnClass(int col) {
247        switch (col) {
248            case BUILDBOX_COLUMN:
249                return Boolean.class;
250            case ID_COLUMN:
251            case CARS_COLUMN:
252                return Integer.class;
253            case TIME_COLUMN:
254            case NAME_COLUMN:
255            case DESCRIPTION_COLUMN:
256            case BUILT_COLUMN:
257            case CAR_ROAD_COLUMN:
258            case CABOOSE_ROAD_COLUMN:
259            case LOCO_ROAD_COLUMN:
260            case LOAD_COLUMN:
261            case OWNER_COLUMN:
262            case ROUTE_COLUMN:
263            case DEPARTS_COLUMN:
264            case CURRENT_COLUMN:
265            case TERMINATES_COLUMN:
266            case STATUS_COLUMN:
267                return String.class;
268            case BUILD_COLUMN:
269            case ACTION_COLUMN:
270            case EDIT_COLUMN:
271                return JButton.class;
272            default:
273                return null;
274        }
275    }
276
277    @Override
278    public boolean isCellEditable(int row, int col) {
279        switch (col) {
280            case BUILD_COLUMN:
281            case BUILDBOX_COLUMN:
282            case ACTION_COLUMN:
283            case EDIT_COLUMN:
284                return true;
285            default:
286                return false;
287        }
288    }
289
290    @Override
291    public Object getValueAt(int row, int col) {
292        if (row >= getRowCount()) {
293            return "ERROR row " + row; // NOI18N
294        }
295        Train train = getTrainByRow(row);
296        if (train == null) {
297            return "ERROR train unknown " + row; // NOI18N
298        }
299        switch (col) {
300            case ID_COLUMN:
301                return Integer.parseInt(train.getId());
302            case TIME_COLUMN:
303                return train.getDepartureTime();
304            case NAME_COLUMN:
305                return train.getIconName();
306            case DESCRIPTION_COLUMN:
307                return train.getDescription();
308            case BUILDBOX_COLUMN:
309                return Boolean.valueOf(train.isBuildEnabled());
310            case BUILT_COLUMN:
311                return getBuiltString(train);
312            case CAR_ROAD_COLUMN:
313                return getModifiedString(train.getCarRoadNames().length, train.getCarRoadOption().equals(Train.ALL_ROADS),
314                        train.getCarRoadOption().equals(Train.INCLUDE_ROADS));
315            case CABOOSE_ROAD_COLUMN:
316                return getModifiedString(train.getCabooseRoadNames().length,
317                        train.getCabooseRoadOption().equals(Train.ALL_ROADS),
318                        train.getCabooseRoadOption().equals(Train.INCLUDE_ROADS));
319            case LOCO_ROAD_COLUMN:
320                return getModifiedString(train.getLocoRoadNames().length, train.getLocoRoadOption().equals(Train.ALL_ROADS),
321                        train.getLocoRoadOption().equals(Train.INCLUDE_ROADS));
322            case LOAD_COLUMN:
323                return getModifiedString(train.getLoadNames().length, train.getLoadOption().equals(Train.ALL_LOADS),
324                        train.getLoadOption().equals(Train.INCLUDE_LOADS));
325            case OWNER_COLUMN:
326                return getModifiedString(train.getOwnerNames().length, train.getOwnerOption().equals(Train.ALL_OWNERS),
327                        train.getOwnerOption().equals(Train.INCLUDE_OWNERS));
328            case ROUTE_COLUMN:
329                return train.getTrainRouteName();
330            case DEPARTS_COLUMN: {
331                if (train.getDepartureTrack() == null) {
332                    return train.getTrainDepartsName();
333                } else {
334                    return train.getTrainDepartsName() + " (" + train.getDepartureTrack().getName() + ")";
335                }
336            }
337            case CURRENT_COLUMN:
338                return train.getCurrentLocationName();
339            case TERMINATES_COLUMN: {
340                if (train.getTerminationTrack() == null) {
341                    return train.getTrainTerminatesName();
342                } else {
343                    return train.getTrainTerminatesName() + " (" + train.getTerminationTrack().getName() + ")";
344                }
345            }
346            case CARS_COLUMN:
347                return train.getNumberCarsInTrain();
348            case STATUS_COLUMN:
349                return train.getStatus();
350            case BUILD_COLUMN: {
351                if (train.isBuilt()) {
352                    if (Setup.isGenerateCsvManifestEnabled() && trainManager.isOpenFileEnabled()) {
353                        setToolTip(Bundle.getMessage("OpenTrainTip",
354                                train.getName()), row, col);
355                        return Bundle.getMessage("OpenFile");
356                    }
357                    if (Setup.isGenerateCsvManifestEnabled() && trainManager.isRunFileEnabled()) {
358                        setToolTip(Bundle.getMessage("RunTrainTip",
359                                train.getName()), row, col);
360                        return Bundle.getMessage("RunFile");
361                    }
362                    setToolTip(Bundle.getMessage("PrintTrainTip"), row, col);
363                    if (trainManager.isPrintPreviewEnabled()) {
364                        return Bundle.getMessage("Preview");
365                    } else if (train.isPrinted()) {
366                        return Bundle.getMessage("Printed");
367                    } else {
368                        return Bundle.getMessage("Print");
369                    }
370                }
371                setToolTip(Bundle.getMessage("BuildTrainTip", train.getName()),
372                        row, col);
373                return Bundle.getMessage("Build");
374            }
375            case ACTION_COLUMN: {
376                if (train.isBuildFailed()) {
377                    return Bundle.getMessage("Report");
378                }
379                if (train.getCurrentRouteLocation() == train.getTrainTerminatesRouteLocation() &&
380                        trainManager.getTrainsFrameTrainAction().equals(TrainsTableFrame.MOVE)) {
381                    return Bundle.getMessage("Terminate");
382                }
383                return trainManager.getTrainsFrameTrainAction();
384            }
385            case EDIT_COLUMN:
386                return Bundle.getMessage("ButtonEdit");
387            default:
388                return "unknown " + col; // NOI18N
389        }
390    }
391
392    private void setToolTip(String text, int row, int col) {
393        XTableColumnModel tcm = (XTableColumnModel) _table.getColumnModel();
394        ButtonRenderer buttonRenderer = (ButtonRenderer) tcm.getColumnByModelIndex(col).getCellRenderer();
395        if (buttonRenderer != null) {
396            buttonRenderer.setToolTipText(text);
397        }
398    }
399
400    private String getBuiltString(Train train) {
401        if (!train.getBuiltStartYear().equals(Train.NONE) && train.getBuiltEndYear().equals(Train.NONE)) {
402            return "A " + train.getBuiltStartYear();
403        }
404        if (train.getBuiltStartYear().equals(Train.NONE) && !train.getBuiltEndYear().equals(Train.NONE)) {
405            return "B " + train.getBuiltEndYear();
406        }
407        if (!train.getBuiltStartYear().equals(Train.NONE) && !train.getBuiltEndYear().equals(Train.NONE)) {
408            return "R " + train.getBuiltStartYear() + ":" + train.getBuiltEndYear();
409        }
410        return "";
411    }
412
413    private String getModifiedString(int number, boolean all, boolean accept) {
414        if (all) {
415            return "";
416        }
417        if (accept) {
418            return "A " + Integer.toString(number); // NOI18N
419        }
420        return "E " + Integer.toString(number); // NOI18N
421    }
422
423    @Override
424    public void setValueAt(Object value, int row, int col) {
425        switch (col) {
426            case EDIT_COLUMN:
427                editTrain(row);
428                break;
429            case BUILD_COLUMN:
430                buildTrain(row);
431                break;
432            case ACTION_COLUMN:
433                actionTrain(row);
434                break;
435            case BUILDBOX_COLUMN: {
436                Train train = getTrainByRow(row);
437                train.setBuildEnabled(((Boolean) value).booleanValue());
438                break;
439            }
440            default:
441                break;
442        }
443    }
444
445    public Color getRowColor(int row) {
446        Train train = getTrainByRow(row);
447        return train.getTableRowColor();
448    }
449
450    TrainEditFrame tef = null;
451
452    private void editTrain(int row) {
453        if (tef != null) {
454            tef.dispose();
455        }
456        // use invokeLater so new window appears on top
457        SwingUtilities.invokeLater(() -> {
458            Train train = getTrainByRow(row);
459            log.debug("Edit train ({})", train.getName());
460            tef = new TrainEditFrame(train);
461        });
462    }
463
464    Thread build;
465
466    private void buildTrain(int row) {
467        final Train train = getTrainByRow(row);
468        if (!train.isBuilt()) {
469            // only one train build at a time
470            if (build != null && build.isAlive()) {
471                return;
472            }
473            // use a thread to allow table updates during build
474            build = jmri.util.ThreadingUtil.newThread(new Runnable() {
475                @Override
476                public void run() {
477                    train.build();
478                }
479            });
480            build.setName("Build Train (" + train.getName() + ")"); // NOI18N
481            build.start();
482            // print build report, print manifest, run or open file
483        } else {
484            if (trainManager.isBuildReportEnabled()) {
485                train.printBuildReport();
486            }
487            if (Setup.isGenerateCsvManifestEnabled() && trainManager.isOpenFileEnabled()) {
488                train.openFile();
489            } else if (Setup.isGenerateCsvManifestEnabled() && trainManager.isRunFileEnabled()) {
490                train.runFile();
491            } else {
492                if (!train.printManifestIfBuilt()) {
493                    log.debug("Manifest file for train ({}) not found", train.getName());
494                    int result = JmriJOptionPane.showConfirmDialog(null,
495                            Bundle.getMessage("TrainManifestFileMissing",
496                                    train.getName()),
497                            Bundle.getMessage("TrainManifestFileError"), JmriJOptionPane.YES_NO_OPTION);
498                    if (result == JmriJOptionPane.YES_OPTION) {
499                        train.setModified(true);
500                        if (!train.printManifestIfBuilt()) {
501                            log.error("Unable to create manifest for train ({})", train.getName());
502                        }
503                    }
504                }
505            }
506        }
507    }
508
509    // one of five buttons: Report, Move, Reset, Conductor or Terminate
510    private void actionTrain(int row) {
511        // no actions while a train is being built
512        if (build != null && build.isAlive()) {
513            return;
514        }
515        Train train = getTrainByRow(row);
516        // move button becomes report if failure
517        if (train.isBuildFailed()) {
518            train.printBuildReport();
519        } else if (trainManager.getTrainsFrameTrainAction().equals(TrainsTableFrame.RESET)) {
520            log.debug("Reset train ({})", train.getName());
521            // check to see if departure track was reused
522            if (checkDepartureTrack(train)) {
523                log.debug("Train is departing staging that already has inbound cars");
524                JmriJOptionPane.showMessageDialog(null,
525                        Bundle.getMessage("StagingTrackUsed",
526                                train.getDepartureTrack().getName()),
527                        Bundle.getMessage("CanNotResetTrain"), JmriJOptionPane.INFORMATION_MESSAGE);
528            } else if (!train.reset()) {
529                JmriJOptionPane.showMessageDialog(null,
530                        Bundle.getMessage("TrainIsInRoute",
531                                train.getTrainTerminatesName()),
532                        Bundle.getMessage("CanNotResetTrain"), JmriJOptionPane.ERROR_MESSAGE);
533            }
534        } else if (!train.isBuilt()) {
535            int reply = JmriJOptionPane.showOptionDialog(null,
536                    Bundle.getMessage("TrainNeedsBuild", train.getName()),
537                    Bundle.getMessage("CanNotPerformAction"), JmriJOptionPane.NO_OPTION,
538                    JmriJOptionPane.INFORMATION_MESSAGE, null,
539                    new Object[]{Bundle.getMessage("ButtonOK"), Bundle.getMessage("Build")}, null);
540            if (reply == 1) {
541                train.build();
542            }
543        } else if (train.isBuilt() && trainManager.getTrainsFrameTrainAction().equals(TrainsTableFrame.MOVE)) {
544            log.debug("Move train ({})", train.getName());
545            train.move();
546        } else if (train.isBuilt() && trainManager.getTrainsFrameTrainAction().equals(TrainsTableFrame.TERMINATE)) {
547            log.debug("Terminate train ({})", train.getName());
548            int status = JmriJOptionPane.showConfirmDialog(null,
549                    Bundle.getMessage("TerminateTrain",
550                            train.getName(), train.getDescription()),
551                    Bundle.getMessage("DoYouWantToTermiate", train.getName()),
552                    JmriJOptionPane.YES_NO_OPTION);
553            if (status == JmriJOptionPane.YES_OPTION) {
554                train.terminate();
555            }
556        } else if (train.isBuilt() && trainManager.getTrainsFrameTrainAction().equals(TrainsTableFrame.CONDUCTOR)) {
557            log.debug("Enable conductor for train ({})", train.getName());
558            launchConductor(train);
559        }
560    }
561
562    /*
563     * Check to see if the departure track in staging has been taken by another
564     * train. return true if track has been allocated to another train.
565     */
566    private boolean checkDepartureTrack(Train train) {
567        return (Setup.isStagingTrackImmediatelyAvail() &&
568                !train.isTrainEnRoute() &&
569                train.getDepartureTrack() != null &&
570                train.getDepartureTrack().isStaging() &&
571                train.getDepartureTrack() != train.getTerminationTrack() &&
572                train.getDepartureTrack().getIgnoreUsedLengthPercentage() == Track.IGNORE_0 &&
573                train.getDepartureTrack().getDropRS() > 0);
574    }
575
576    private static Hashtable<String, TrainConductorFrame> _trainConductorHashTable = new Hashtable<>();
577
578    private void launchConductor(Train train) {
579        // use invokeLater so new window appears on top
580        SwingUtilities.invokeLater(() -> {
581            TrainConductorFrame f = _trainConductorHashTable.get(train.getId());
582            // create a copy train frame
583            if (f == null || !f.isVisible()) {
584                f = new TrainConductorFrame(train);
585                _trainConductorHashTable.put(train.getId(), f);
586            } else {
587                f.setExtendedState(Frame.NORMAL);
588            }
589            f.setVisible(true); // this also brings the frame into focus
590        });
591    }
592
593    @Override
594    public void propertyChange(PropertyChangeEvent e) {
595        if (Control.SHOW_PROPERTY) {
596            log.debug("Property change {} old: {} new: {}", e.getPropertyName(), e.getOldValue(), e.getNewValue()); // NOI18N
597        }
598        if (e.getPropertyName().equals(Train.BUILT_YEAR_CHANGED_PROPERTY) ||
599                e.getPropertyName().equals(Train.ROADS_CHANGED_PROPERTY) ||
600                e.getPropertyName().equals(Train.LOADS_CHANGED_PROPERTY) ||
601                e.getPropertyName().equals(Train.OWNERS_CHANGED_PROPERTY)) {
602            updateColumnVisible();
603        }
604        if (e.getPropertyName().equals(TrainManager.LISTLENGTH_CHANGED_PROPERTY) ||
605                e.getPropertyName().equals(TrainManager.PRINTPREVIEW_CHANGED_PROPERTY) ||
606                e.getPropertyName().equals(TrainManager.OPEN_FILE_CHANGED_PROPERTY) ||
607                e.getPropertyName().equals(TrainManager.RUN_FILE_CHANGED_PROPERTY) ||
608                e.getPropertyName().equals(Setup.MANIFEST_CSV_PROPERTY_CHANGE) ||
609                e.getPropertyName().equals(TrainManager.TRAIN_ACTION_CHANGED_PROPERTY) ||
610                e.getPropertyName().equals(Train.DEPARTURETIME_CHANGED_PROPERTY) ||
611                (e.getPropertyName().equals(Train.BUILD_CHANGED_PROPERTY) && !isShowAll())) {
612            SwingUtilities.invokeLater(() -> {
613                updateList();
614                fireTableDataChanged();
615            });
616        } else if (e.getSource().getClass().equals(Train.class)) {
617            Train train = ((Train) e.getSource());
618            SwingUtilities.invokeLater(() -> {
619                int row = sysList.indexOf(train);
620                if (row >= 0 && _table != null) {
621                    fireTableRowsUpdated(row, row);
622                    int viewRow = _table.convertRowIndexToView(row);
623                    log.debug("Scroll table to row: {}, property: {}", viewRow, e.getPropertyName());
624                    _table.scrollRectToVisible(_table.getCellRect(viewRow, 0, true));
625                }
626            });
627        }
628    }
629
630    private void removePropertyChangeTrains() {
631        for (Train train : trainManager.getTrainsByIdList()) {
632            train.removePropertyChangeListener(this);
633        }
634    }
635
636    private void addPropertyChangeTrains() {
637        for (Train train : trainManager.getTrainsByIdList()) {
638            train.addPropertyChangeListener(this);
639        }
640    }
641
642    public void dispose() {
643        if (tef != null) {
644            tef.dispose();
645        }
646        trainManager.removePropertyChangeListener(this);
647        Setup.getDefault().removePropertyChangeListener(this);
648        removePropertyChangeTrains();
649    }
650
651    class MyTableCellRenderer extends DefaultTableCellRenderer {
652
653        @Override
654        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
655                int row, int column) {
656            Component component = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
657            if (!isSelected) {
658                int modelRow = table.convertRowIndexToModel(row);
659                // log.debug("View row: {} Column: {} Model row: {}", row, column, modelRow);
660                Color background = getRowColor(modelRow);
661                component.setBackground(background);
662                component.setForeground(getForegroundColor(background));
663            }
664            return component;
665        }
666
667        Color[] darkColors = { Color.BLACK, Color.BLUE, Color.GRAY, Color.RED, Color.MAGENTA };
668
669        /**
670         * Dark colors need white lettering
671         *
672         */
673        private Color getForegroundColor(Color background) {
674            if (background == null) {
675                return null;
676            }
677            for (Color color : darkColors) {
678                if (background == color) {
679                    return Color.WHITE;
680                }
681            }
682            return Color.BLACK; // all others get black lettering
683        }
684    }
685
686    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(TrainsTableModel.class);
687}