Source code

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