Source code

001package jmri.jmrit.picker;
002
003import java.util.ArrayList;
004import java.util.HashMap;
005import java.util.List;
006import java.util.ResourceBundle;
007import java.util.TreeSet;
008import javax.annotation.CheckForNull;
009import javax.annotation.Nonnull;
010import javax.swing.JTable;
011import javax.swing.ListSelectionModel;
012import javax.swing.SortOrder;
013import javax.swing.table.TableColumn;
014import javax.swing.table.TableColumnModel;
015import javax.swing.table.TableRowSorter;
016import jmri.*;
017import jmri.jmrit.beantable.BeanTableDataModel;
018import jmri.jmrit.entryexit.*;
019import jmri.jmrit.logix.*;
020import jmri.swing.RowSorterUtil;
021import jmri.util.*;
022import jmri.util.swing.XTableColumnModel;
023import org.slf4j.Logger;
024import org.slf4j.LoggerFactory;
025
026/**
027 * Abstract class to make pick lists for NamedBeans; Table model for pick lists
028 * in IconAdder
029 * <p>
030 * Concrete pick list class for many beans are include at the end of this file.
031 * This class also has instantiation methods serve as a factory for those
032 * classes.
033 * <p>
034 * Note: Extensions of this class must call init() after instantiation.
035 *
036 * <hr>
037 * This file is part of JMRI.
038 * <p>
039 * JMRI is free software; you can redistribute it and/or modify it under the
040 * terms of version 2 of the GNU General Public License as published by the Free
041 * Software Foundation. See the "COPYING" file for a copy of this license.
042 * <p>
043 * JMRI is distributed in the hope that it will be useful, but WITHOUT ANY
044 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
045 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
046 *
047 * @param <E> the supported type of NamedBean
048 * @author Pete Cressman Copyright (C) 2009, 2010
049 */
050public abstract class PickListModel<E extends NamedBean> extends BeanTableDataModel<E> {
051
052    protected ArrayList<E> _pickList;
053    protected String _name;
054    private JTable _table;       // table using this model
055    protected TableRowSorter<PickListModel<E>> _sorter;
056
057    public static final int SNAME_COLUMN = 0;
058    public static final int UNAME_COLUMN = 1;
059    public static final int POSITION_COL = 2;
060    public static final ResourceBundle rb = ResourceBundle.getBundle("jmri.jmrit.beantable.BeanTableBundle");
061
062    static HashMap<String, Integer> _listMap = new HashMap<String, Integer>();
063
064    static public int getNumInstances(@Nonnull String type) {
065        Integer num = _listMap.get(type.toLowerCase());
066        log.debug("getNumInstances of {} num={}", type, num);
067        if (num != null) {
068            return num;
069        }
070        return 0;
071    }
072
073    /**
074     * Default constructor makes a table sorted by System Name.
075     */
076    public PickListModel() {
077        super();
078    }
079
080    /**
081     * If table has been sorted table row no longer is the same as array index.
082     *
083     * @param index row of table
084     * @return bean at index or null if index is out of range
085     */
086    @CheckForNull
087    public E getBeanAt(int index) {
088        if (index >= _pickList.size()) {
089            return null;
090        }
091        return _pickList.get(index);
092    }
093
094    public int getIndexOf(@Nonnull E bean) {
095        for (int i = 0; i < _pickList.size(); i++) {
096            if (_pickList.get(i).equals(bean)) {
097                return i;
098            }
099        }
100        return -1;
101    }
102
103    @Nonnull
104    public List<E> getBeanList() {
105        return _pickList;
106    }
107
108    /**
109     * override BeanTableDataModel only lists SystemName
110     */
111    @Override
112    protected synchronized void updateNameList() {
113        makePickList();
114    }
115
116    private void makePickList() {
117        // Don't know who is added or deleted so remove all name change listeners
118        if (_pickList != null) {
119            for (E e : _pickList) {
120                e.removePropertyChangeListener(this);
121            }
122        }
123        TreeSet<E> ts = new TreeSet<>(new NamedBeanComparator<>());
124        ts.addAll(getManager().getNamedBeanSet());
125
126        _pickList = new ArrayList<>(getManager().getNamedBeanSet().size());
127
128        _pickList.addAll(ts);
129        // add name change listeners
130        for (E e : _pickList) {
131            e.addPropertyChangeListener(this);
132        }
133        log.debug("_pickList has {} beans", _pickList.size());
134    }
135
136    /** {@inheritDoc} */
137    @Override
138    @CheckForNull
139    public E getBySystemName(@Nonnull String name) {
140        return getManager().getBySystemName(name);
141    }
142
143    /** {@inheritDoc} */
144    @Override
145    @CheckForNull
146    protected E getByUserName(@Nonnull String name) {
147        return getManager().getByUserName(name);
148    }
149
150    /** {@inheritDoc} */
151    @Override
152    @Nonnull
153    abstract public Manager<E> getManager();
154
155    /**
156     * Return bean with name given in parameter. Create if needed and possible.
157     *
158     * @param name the System name for the Bean.
159     * @return the Bean or null if not made.
160     * @throws IllegalArgumentException with reason why Bean cannot be created.
161     */
162    @CheckForNull
163    abstract public E addBean(@Nonnull String name) throws IllegalArgumentException;
164
165    @CheckForNull
166    abstract public E addBean(@Nonnull String sysName, String userName) throws IllegalArgumentException;
167
168    /**
169     * Check if beans can be added by this model.
170     *
171     * @return true if model can create beans; false otherwise
172     */
173    abstract public boolean canAddBean();
174
175    // these BeanTableDataModel abstract methods not needed
176    /** {@inheritDoc} */
177    @Override
178    protected String getMasterClassName() {
179        return "PickListModel";
180    }
181
182    /** {@inheritDoc} */
183    @Override
184    public void clickOn(E t) {
185    }
186
187    /** {@inheritDoc} */
188    @Override
189    public Class<?> getColumnClass(int c) {
190        return String.class;
191    }
192
193    /** {@inheritDoc} */
194    @Override
195    public int getColumnCount() {
196        return 2;
197    }
198
199    /** {@inheritDoc} */
200    @Override
201    public String getColumnName(int c) {
202        if (c == SNAME_COLUMN) {
203            return Bundle.getMessage("ColumnSystemName");
204        } else if (c == UNAME_COLUMN) {
205            return Bundle.getMessage("ColumnUserName");
206        }
207        return "";
208    }
209
210    /** {@inheritDoc} */
211    @Override
212    public boolean isCellEditable(int r, int c) {
213        return false;
214    }
215
216    /** {@inheritDoc} */
217    @Override
218    public int getRowCount() {
219        return _pickList.size();
220    }
221
222    /** {@inheritDoc} */
223    @Override
224    public Object getValueAt(int r, int c) {
225        // some error checking
226        if (r >= _pickList.size()) {
227            log.debug("row is greater than picklist size");
228            return null;
229        }
230        if (c == SNAME_COLUMN) {
231            return _pickList.get(r).getSystemName();
232        } else if (c == UNAME_COLUMN) {
233            return _pickList.get(r).getUserName();
234        }
235        return null;
236    }
237
238    /** {@inheritDoc} */
239    @Override
240    public void setValueAt(Object type, int r, int c) {
241    }
242
243    // these BeanTableDataModel abstract methods not needed
244    /** {@inheritDoc} */
245    @Override
246    public String getValue(String systemName) {
247        return systemName;
248    }
249
250    public String getName() {
251        return _name;
252    }
253
254    /** {@inheritDoc} */
255    @Override
256    protected String getBeanType() {
257        return _name;
258    }
259
260    /**
261     * Handle additions and deletions in the table and changes to beans within
262     * the table.
263     *
264     * @param e the change
265     */
266    @Override
267    public void propertyChange(java.beans.PropertyChangeEvent e) {
268        if (e.getPropertyName().equals("length")) {
269            // a NamedBean added or deleted
270            makePickList();
271            fireTableDataChanged();
272        }
273        if (e.getSource() instanceof NamedBean) {
274            NamedBean bean = (NamedBean) e.getSource();
275            for (int i = 0; i < _pickList.size(); i++) {
276                if (bean.equals(_pickList.get(i))) {
277                    fireTableRowsUpdated(i, i);
278                    break;
279                }
280            }
281        }
282        if (log.isDebugEnabled()) {
283            log.debug("propertyChange of \"{}\" for {}", e.getPropertyName(), e.getSource().toString());
284        }
285    }
286
287    /**
288     * Make pick table, DND enabled.
289     * @return the table
290     */
291    public JTable makePickTable() {
292        _sorter = new TableRowSorter<>(this);
293        _table = new JTable(this) {
294            /**
295             * Overridden to prevent empty cells from being selected
296             */
297            @Override
298            public void changeSelection(int row, int col, boolean toggle, boolean extend) {
299                if (super.getValueAt(row, col) != null) {
300                    super.changeSelection(row, col, toggle, extend);
301                }
302            }
303        };
304        _sorter.setComparator(SNAME_COLUMN, new jmri.util.AlphanumComparator());
305        _sorter.setComparator(UNAME_COLUMN, new jmri.util.AlphanumComparator());
306        RowSorterUtil.setSortOrder(_sorter, SNAME_COLUMN, SortOrder.ASCENDING);
307        _table.setRowSorter(_sorter);
308
309        _table.setRowSelectionAllowed(true);
310        _table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
311        _table.setPreferredScrollableViewportSize(new java.awt.Dimension(250, _table.getRowHeight() * 7));
312        _table.setDragEnabled(true);
313        _table.setTransferHandler(new DnDTableExportHandler());
314
315        _table.getTableHeader().setReorderingAllowed(true);
316        _table.setColumnModel(new XTableColumnModel());
317        _table.createDefaultColumnsFromModel();
318        TableColumnModel columnModel = _table.getColumnModel();
319
320        TableColumn sNameColumnT = columnModel.getColumn(SNAME_COLUMN);
321        sNameColumnT.setResizable(true);
322        sNameColumnT.setMinWidth(50);
323        //sNameColumnT.setMaxWidth(200);
324
325        TableColumn uNameColumnT = columnModel.getColumn(UNAME_COLUMN);
326        uNameColumnT.setResizable(true);
327        uNameColumnT.setMinWidth(100);
328        //uNameColumnT.setMaxWidth(300);
329
330        addMouseListenerToHeader(_table);
331        _table.setAutoCreateColumnsFromModel(false);
332
333        return _table;
334    }
335
336    public void makeSorter(@Nonnull JTable table) {
337        _sorter = new TableRowSorter<>(this);
338        _sorter.setComparator(SNAME_COLUMN, new jmri.util.AlphanumComparator());
339        _sorter.setComparator(UNAME_COLUMN, new jmri.util.AlphanumComparator());
340        RowSorterUtil.setSortOrder(_sorter, SNAME_COLUMN, SortOrder.ASCENDING);
341        table.setRowSorter(_sorter);
342    }
343
344    @Nonnull
345    public JTable getTable() {
346        return _table;
347    }
348
349    /** {@inheritDoc} */
350    @Override
351    public void dispose() {
352        getManager().removePropertyChangeListener(this);
353    }
354
355    @Nonnull
356    public static PickListModel<Turnout> turnoutPickModelInstance() {
357        Integer num = _listMap.get("turnout");
358        if (num != null) {
359            _listMap.put("turnout", num + 1);
360        } else {
361            _listMap.put("turnout", 1);
362        }
363        return new TurnoutPickModel();
364    }
365
366    @Nonnull
367    public static PickListModel<Sensor> sensorPickModelInstance() {
368        Integer num = _listMap.get("sensor");
369        if (num != null) {
370            _listMap.put("sensor", num + 1);
371        } else {
372            _listMap.put("sensor", 1);
373        }
374        return new SensorPickModel();
375    }
376
377    @Nonnull
378    public static PickListModel<Sensor> multiSensorPickModelInstance() {
379        Integer num = _listMap.get("multisensor");
380        if (num != null) {
381            _listMap.put("multisensor", num + 1);
382        } else {
383            _listMap.put("multisensor", 1);
384        }
385        return new MultiSensorPickModel();
386    }
387
388    @Nonnull
389    public static PickListModel<SignalHead> signalHeadPickModelInstance() {
390        Integer num = _listMap.get("signalhead");
391        if (num != null) {
392            _listMap.put("signalhead", num + 1);
393        } else {
394            _listMap.put("signalhead", 1);
395        }
396        return new SignalHeadPickModel();
397    }
398
399    @Nonnull
400    public static PickListModel<SignalMast> signalMastPickModelInstance() {
401        Integer num = _listMap.get("signalmast");
402        if (num != null) {
403            _listMap.put("signalmast", num + 1);
404        } else {
405            _listMap.put("signalmast", 1);
406        }
407        return new SignalMastPickModel();
408    }
409
410    @Nonnull
411    public static PickListModel<Memory> memoryPickModelInstance() {
412        Integer num = _listMap.get("memory");
413        if (num != null) {
414            _listMap.put("memory", num + 1);
415        } else {
416            _listMap.put("memory", 1);
417        }
418        return new MemoryPickModel();
419    }
420
421    @Nonnull
422    public static PickListModel<Block> blockPickModelInstance() {
423        Integer num = _listMap.get("block");
424        if (num != null) {
425            _listMap.put("block", num + 1);
426        } else {
427            _listMap.put("block", 1);
428        }
429        return new BlockPickModel();
430    }
431
432    @Nonnull
433    public static PickListModel<Reporter> reporterPickModelInstance() {
434        Integer num = _listMap.get("reporter");
435        if (num != null) {
436            _listMap.put("reporter", num + 1);
437        } else {
438            _listMap.put("reporter", 1);
439        }
440        return new ReporterPickModel();
441    }
442
443    @Nonnull
444    public static PickListModel<Light> lightPickModelInstance() {
445        Integer num = _listMap.get("light");
446        if (num != null) {
447            _listMap.put("light", num + 1);
448        } else {
449            _listMap.put("light", 1);
450        }
451        return new LightPickModel();
452    }
453
454    @Nonnull
455    public static PickListModel<OBlock> oBlockPickModelInstance() {
456        Integer num = _listMap.get("oBlock");
457        if (num != null) {
458            _listMap.put("oBlock", num + 1);
459        } else {
460            _listMap.put("oBlock", 1);
461        }
462        return new OBlockPickModel();
463    }
464
465    @Nonnull
466    public static PickListModel<Warrant> warrantPickModelInstance() {
467        Integer num = _listMap.get("warrant");
468        if (num != null) {
469            _listMap.put("warrant", num + 1);
470        } else {
471            _listMap.put("warrant", 1);
472        }
473        return new WarrantPickModel();
474    }
475
476    @Nonnull
477    public static PickListModel<DestinationPoints> entryExitPickModelInstance() {
478        Integer num = _listMap.get("entryExit");
479        if (num != null) {
480            _listMap.put("entryExit", num + 1);
481        } else {
482            _listMap.put("entryExit", 1);
483        }
484        return new EntryExitPickModel();
485    }
486
487    public static PickListModel<Logix> logixPickModelInstance() {
488        Integer num = _listMap.get("logix");
489        if (num != null) {
490            _listMap.put("logix", num + 1);
491        } else {
492            _listMap.put("logix", 1);
493        }
494        return new LogixPickModel();
495    }
496
497    private final static Logger log = LoggerFactory.getLogger(PickListModel.class);
498
499    static class TurnoutPickModel extends PickListModel<Turnout> {
500
501        TurnoutManager manager = InstanceManager.turnoutManagerInstance();
502
503        TurnoutPickModel() {
504            _name = rb.getString("TitleTurnoutTable");
505        }
506
507        /** {@inheritDoc} */
508        @Override
509        @Nonnull
510        public Manager<Turnout> getManager() {
511            manager = InstanceManager.turnoutManagerInstance();
512            return manager;
513        }
514
515        /** {@inheritDoc} */
516        @Override
517        public Turnout addBean(@Nonnull String name) throws IllegalArgumentException {
518            return manager.provideTurnout(name);
519        }
520
521        /** {@inheritDoc} */
522        @Override
523        public Turnout addBean(@Nonnull String sysName, String userName) throws IllegalArgumentException {
524            return manager.newTurnout(sysName, userName);
525        }
526
527        /** {@inheritDoc} */
528        @Override
529        public boolean canAddBean() {
530            return true;
531        }
532    }
533
534    static class SensorPickModel extends PickListModel<Sensor> {
535
536        SensorManager manager = InstanceManager.getDefault(SensorManager.class);
537
538        SensorPickModel() {
539            _name = rb.getString("TitleSensorTable");
540        }
541
542        /** {@inheritDoc} */
543        @Override
544        @Nonnull
545        public Manager<Sensor> getManager() {
546            manager = InstanceManager.sensorManagerInstance();
547            return manager;
548        }
549
550        /** {@inheritDoc} */
551        @Override
552        public Sensor addBean(@Nonnull String name) throws IllegalArgumentException {
553            return manager.provideSensor(name);
554        }
555
556        /** {@inheritDoc} */
557        @Override
558        public Sensor addBean(@Nonnull String sysName, String userName) throws IllegalArgumentException {
559            return manager.newSensor(sysName, userName);
560        }
561
562        /** {@inheritDoc} */
563        @Override
564        public boolean canAddBean() {
565            return true;
566        }
567    }
568
569    static class MultiSensorPickModel extends SensorPickModel {
570
571        private final HashMap<Integer, String> _position = new HashMap<>();
572
573        MultiSensorPickModel() {
574            super();
575        }
576
577        /** {@inheritDoc} */
578        @Override
579        public Object getValueAt(int r, int c) {
580            if (c == POSITION_COL) {
581                return _position.get(r);
582            }
583            return super.getValueAt(r, c);
584        }
585
586        /** {@inheritDoc} */
587        @Override
588        public void setValueAt(Object type, int r, int c) {
589            if (c == POSITION_COL) {
590                _position.put(r, (String) type);
591            }
592        }
593    }
594
595    static class SignalHeadPickModel extends PickListModel<SignalHead> {
596
597        SignalHeadManager manager = InstanceManager.getDefault(SignalHeadManager.class);
598
599        SignalHeadPickModel() {
600            _name = rb.getString("TitleSignalTable");
601        }
602
603        /** {@inheritDoc} */
604        @Override
605        @Nonnull
606        public Manager<SignalHead> getManager() {
607            manager = InstanceManager.getDefault(SignalHeadManager.class);
608            return manager;
609        }
610
611        /** {@inheritDoc} */
612        @Override
613        public SignalHead addBean(@Nonnull String name) {
614            return manager.getSignalHead(name);
615        }
616
617        /** {@inheritDoc} */
618        @Override
619        public SignalHead addBean(@Nonnull String sysName, String userName) {
620            SignalHead sh = manager.getSignalHead(userName);
621            if (sh == null) {
622                sh = manager.getSignalHead(sysName);
623            }
624            return sh;
625        }
626
627        /** {@inheritDoc} */
628        @Override
629        public boolean canAddBean() {
630            return false;
631        }
632    }
633
634    static class SignalMastPickModel extends PickListModel<SignalMast> {
635
636        SignalMastManager manager = InstanceManager.getDefault(SignalMastManager.class);
637
638        SignalMastPickModel() {
639            _name = rb.getString("TitleSignalMastTable");
640        }
641
642        /** {@inheritDoc} */
643        @Override
644        @Nonnull
645        public Manager<SignalMast> getManager() {
646            manager = InstanceManager.getDefault(SignalMastManager.class);
647            return manager;
648        }
649
650        /** {@inheritDoc} */
651        @Override
652        public SignalMast addBean(@Nonnull String name) throws IllegalArgumentException {
653            return manager.provideSignalMast(name);
654        }
655
656        /** {@inheritDoc} */
657        @Override
658        public SignalMast addBean(@Nonnull String sysName, String userName) throws IllegalArgumentException {
659            SignalMast sm = manager.getSignalMast(userName);
660            if (sm == null) {
661                sm = manager.provideSignalMast(sysName);
662            }
663            return sm;
664        }
665
666        /** {@inheritDoc} */
667        @Override
668        public boolean canAddBean() {
669            return false;
670        }
671    }
672
673    static class MemoryPickModel extends PickListModel<Memory> {
674
675        MemoryManager manager = InstanceManager.memoryManagerInstance();
676
677        MemoryPickModel() {
678            _name = rb.getString("TitleMemoryTable");
679        }
680
681        /** {@inheritDoc} */
682        @Override
683        @Nonnull
684        public Manager<Memory> getManager() {
685            manager = InstanceManager.memoryManagerInstance();
686            return manager;
687        }
688
689        /** {@inheritDoc} */
690        @Override
691        public Memory addBean(@Nonnull String name) throws IllegalArgumentException {
692            return manager.provideMemory(name);
693        }
694
695        /** {@inheritDoc} */
696        @Override
697        public Memory addBean(@Nonnull String sysName, String userName) throws IllegalArgumentException {
698            return manager.newMemory(sysName, userName);
699        }
700
701        /** {@inheritDoc} */
702        @Override
703        public boolean canAddBean() {
704            return true;
705        }
706    }
707
708    static class BlockPickModel extends PickListModel<Block> {
709
710        BlockManager manager = InstanceManager.getDefault(BlockManager.class);
711
712        BlockPickModel() {
713            _name = rb.getString("TitleBlockTable");
714        }
715
716        /** {@inheritDoc} */
717        @Override
718        @Nonnull
719        public Manager<Block> getManager() {
720            manager = InstanceManager.getDefault(BlockManager.class);
721            return manager;
722        }
723
724        /** {@inheritDoc} */
725        @Override
726        public Block addBean(@Nonnull String name) throws IllegalArgumentException {
727            return manager.provideBlock(name);
728        }
729
730        /** {@inheritDoc} */
731        @Override
732        public Block addBean(@Nonnull String sysName, String userName) throws IllegalArgumentException {
733            return manager.createNewBlock(sysName, userName);
734        }
735
736        /** {@inheritDoc} */
737        @Override
738        public boolean canAddBean() {
739            return true;
740        }
741    }
742
743    static class ReporterPickModel extends PickListModel<Reporter> {
744
745        ReporterManager manager = InstanceManager.getDefault(ReporterManager.class);
746
747        ReporterPickModel() {
748            _name = rb.getString("TitleReporterTable");
749        }
750
751        /** {@inheritDoc} */
752        @Override
753        @Nonnull
754        public Manager<Reporter> getManager() {
755            manager = InstanceManager.getDefault(ReporterManager.class);
756            return manager;
757        }
758
759        /** {@inheritDoc} */
760        @Override
761        public Reporter addBean(@Nonnull String name) throws IllegalArgumentException {
762            return manager.provideReporter(name);
763        }
764
765        /** {@inheritDoc} */
766        @Override
767        public Reporter addBean(@Nonnull String sysName, String userName) throws IllegalArgumentException {
768            return manager.newReporter(sysName, userName);
769        }
770
771        /** {@inheritDoc} */
772        @Override
773        public boolean canAddBean() {
774            return true;
775        }
776    }
777
778    static class LightPickModel extends PickListModel<Light> {
779
780        LightManager manager = InstanceManager.lightManagerInstance();
781
782        LightPickModel() {
783            _name = rb.getString("TitleLightTable");
784        }
785
786        /** {@inheritDoc} */
787        @Override
788        @Nonnull
789        public Manager<Light> getManager() {
790            manager = InstanceManager.lightManagerInstance();
791            return manager;
792        }
793
794        /** {@inheritDoc} */
795        @Override
796        public Light addBean(@Nonnull String name) throws IllegalArgumentException {
797            return manager.provideLight(name);
798        }
799
800        /** {@inheritDoc} */
801        @Override
802        public Light addBean(@Nonnull String sysName, String userName) throws IllegalArgumentException {
803            return manager.newLight(sysName, userName);
804        }
805
806        /** {@inheritDoc} */
807        @Override
808        public boolean canAddBean() {
809            return true;
810        }
811    }
812
813    static class OBlockPickModel extends PickListModel<OBlock> {
814
815        OBlockManager manager = InstanceManager.getDefault(OBlockManager.class);
816
817        OBlockPickModel() {
818            _name = rb.getString("TitleBlockTable");
819        }
820
821        /** {@inheritDoc} */
822        @Override
823        @Nonnull
824        public Manager<OBlock> getManager() {
825            manager = InstanceManager.getDefault(OBlockManager.class);
826            return manager;
827        }
828
829        /** {@inheritDoc} */
830        @Override
831        public OBlock addBean(@Nonnull String name) throws IllegalArgumentException {
832            return manager.provideOBlock(name);
833        }
834
835        /** {@inheritDoc} */
836        @Override
837        public OBlock addBean(@Nonnull String sysName, String userName) {
838            return manager.createNewOBlock(sysName, userName);
839        }
840
841        /** {@inheritDoc} */
842        @Override
843        public boolean canAddBean() {
844            return true;
845        }
846    }
847
848    static class WarrantPickModel extends PickListModel<Warrant> {
849
850        WarrantManager manager = InstanceManager.getDefault(WarrantManager.class);
851
852        WarrantPickModel() {
853            _name = rb.getString("TitleWarrantTable");
854        }
855
856        /** {@inheritDoc} */
857        @Override
858        @Nonnull
859        public Manager<Warrant> getManager() {
860            manager = InstanceManager.getDefault(WarrantManager.class);
861            return manager;
862        }
863
864        /** {@inheritDoc} */
865        @Override
866        public Warrant addBean(@Nonnull String name) throws IllegalArgumentException {
867            return manager.provideWarrant(name);
868        }
869
870        /** {@inheritDoc} */
871        @Override
872        public Warrant addBean(@Nonnull String sysName, String userName) {
873            return manager.createNewWarrant(sysName, userName, false, 0);
874        }
875
876        /** {@inheritDoc} */
877        @Override
878        public boolean canAddBean() {
879            return false;
880        }
881    }
882
883    static class EntryExitPickModel extends PickListModel<DestinationPoints> {
884
885        EntryExitPairs manager = InstanceManager.getDefault(EntryExitPairs.class);
886
887        EntryExitPickModel() {
888            _name = rb.getString("TitleEntryExitTable");
889        }
890
891        /** {@inheritDoc} */
892        @Override
893        @Nonnull
894        public Manager<DestinationPoints> getManager() {
895            manager = InstanceManager.getDefault(EntryExitPairs.class);
896            return manager;
897        }
898
899        /** {@inheritDoc} */
900        @Override
901        public DestinationPoints addBean(@Nonnull String name) {
902            return null;
903        }
904
905        /** {@inheritDoc} */
906        @Override
907        public DestinationPoints addBean(@Nonnull String sysName, String userName) {
908            return null;
909        }
910
911        /** {@inheritDoc} */
912        @Override
913        public boolean canAddBean() {
914            return false;
915        }
916
917        /** {@inheritDoc} */
918        @Override
919        public String getColumnName(int c) {
920            if (c == SNAME_COLUMN) {
921                return "Unique Id";
922            } else if (c == UNAME_COLUMN) {
923                return Bundle.getMessage("ColumnUserName");
924            }
925            return "";
926        }
927    }
928
929    static class LogixPickModel extends PickListModel<Logix> {
930
931        LogixManager manager;
932
933        LogixPickModel() {
934           _name = rb.getString("TitleLogixTable");
935        }
936
937        /** {@inheritDoc} */
938        @Override
939        @Nonnull
940        public Manager<Logix> getManager() {
941            manager = InstanceManager.getDefault(LogixManager.class);
942            return manager;
943        }
944
945        /** {@inheritDoc} */
946        @Override
947        public Logix addBean(@Nonnull String name) {
948            return null;
949        }
950
951        /** {@inheritDoc} */
952        @Override
953        public Logix addBean(@Nonnull String sysName, String userName) {
954            return null;
955        }
956
957        /** {@inheritDoc} */
958        @Override
959        public boolean canAddBean() {
960            return false;
961        }
962    }
963
964}