STS Handbuch

Wie schon gesagt, von PluginClient abgeleitet, kümmert sich diese Klasse um die Daten, die vom Sim kommen.

Primär legt sie alles in Listen ab, die dann von der wand-Klasse abgeholt werden können. Weiteres inline in dem Kommentaren.

connection.java

/*
 */
package js.java.plugins.monitorWand;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.TreeMap;
import java.util.TreeSet;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JMenu;
import js.java.stspluginlib.PluginClient;
 
/**
 *
 * @author js
 */
public class connection extends PluginClient
{
 
    /**
     * Behälter für die Züge und ihren Fahrplan
     */
    private static class ZugDetailFahrplan
    {
 
        final public int zid;
        final public String name;
        public int verspaetung;
        public String gleis;
        public String plangleis;
        final public String von;
        final public String nach;
        public boolean sichtbar;
        public LinkedList<ZugFahrplanZeile> plan = null;
 
        public ZugDetailFahrplan(ZugDetails reference)
        {
            zid = reference.zid;
            name = reference.name;
            verspaetung = reference.verspaetung;
            gleis = reference.gleis;
            plangleis = reference.plangleis;
            von = reference.von;
            nach = reference.nach;
            sichtbar = reference.sichtbar;
        }
 
        public String getFormattedAn()
        {
            try
            {
                return plan.getFirst().getFormattedAn();
            }
            catch (NullPointerException e)
            {
                return "";
            }
            catch (NoSuchElementException e)
            {
                return "";
            }
        }
 
        public String getFormattedAb()
        {
            try
            {
                return plan.getFirst().getFormattedAb();
            }
            catch (NullPointerException e)
            {
                return "";
            }
            catch (NoSuchElementException e)
            {
                return "";
            }
        }
 
        public long getAb()
        {
            try
            {
                return plan.getFirst().ab;
            }
            catch (NullPointerException e)
            {
                return 0;
            }
            catch (NoSuchElementException e)
            {
                return 0;
            }
        }
 
        public boolean update(ZugDetails other)
        {
            boolean ret = !(plangleis.equals(other.plangleis));
            verspaetung = other.verspaetung;
            sichtbar = other.sichtbar;
            gleis = other.gleis;
            plangleis = other.plangleis;
            return ret;
        }
    }
    /**
     * das Menü für die Bahnsteigliste
     */
    private final JMenu menu;
    /**
     * die Bahnsteigliste
     */
    private final TreeMap<String, JCheckBoxMenuItem> bahnsteige = new TreeMap<String, JCheckBoxMenuItem>();
    /**
     * Name des Stellwerks
     */
    private String name = "";
    /**
     * Listener für die Menu-Auswahl
     */
    private ActionListener menuListener = new ActionListener()
    {
 
        @Override
        public void actionPerformed(ActionEvent e)
        {
            repaint();
        }
    };
    /**
     * Timer-Listener, um alle 30 Sekunden die Zugdaten zu aktualisieren
     */
    private ActionListener refreshListener = new ActionListener()
    {
 
        @Override
        public void actionPerformed(ActionEvent e)
        {
            request_zugliste();
        }
    };
    /**
     * der Timer zum refreshListener
     */
    private javax.swing.Timer refreshTimer = new javax.swing.Timer(1000 * 30, refreshListener);
    /**
     * Liste der Züge und ihrer Fahrpläne
     */
    private HashMap<Integer, ZugDetailFahrplan> zuglist = new HashMap<Integer, ZugDetailFahrplan>();
 
    connection(JMenu m)
    {
        /**
         * PluginClient verlangt 4 Parameter im Konstruktor:
         * - Name des Plugins (MonitorWand)
         * - Autor (JS)
         * - Version des Plugins (0.9)
         * - eine kurze Beschreibung des Plugins (Demo-Abfahrtwand)
         */
        super("MonitorWand", "JS", "0.9", "Demo-Abfahrtwand");
        this.menu = m;
    }
 
    /**
     * Wird von PluginClient aufgerufen, wenn die Verbindung zum Sim erfolgreich hergestellt
     * wurde. Zu dem Zeitpunkt wurde sich auch schon registriert. 
     * Die Simzeit ist erst nach diesem Aufruf verfügbar!
     */
    @Override
    protected void connected()
    {
        this.request_setdebug(true);    // Debugmeldungen in der Sim-Console ein
        this.request_anlageninfo();
        this.request_bahnsteigliste();
        refreshTimer.setInitialDelay(1000);
        refreshTimer.start();
    }
 
    protected void repaint()
    { // tut nichts
    }
 
    /**
     * Wird vom PluginClient aufgerufen, wenn die Verbindung beendet wurde. Die Ursache ist dabei egal.
     */
    @Override
    protected void closed()
    {
        System.exit(100);
    }
 
    /**
     * Antwort vom <anlageninfo>
     * @param aid
     * @param name
     * @param build
     */
    @Override
    protected void response_anlageninfo(int aid, String name, String build)
    {
        this.name = name;
        repaint();
    }
 
    /**
     * Antwort vom <bahnsteigliste>
     * @param bl <Bahnsteigname,Set<Nachbar>>
     *
     * Baut das Menü mit den Bahnsteigen (neu) auf
     */
    @Override
    protected void response_bahnsteigliste(final HashMap<String, HashSet<String>> bl)
    {
        synchronized (bahnsteige)
        {
            bahnsteige.clear();
            for (String s : bl.keySet())
            {
                bahnsteige.put(s, null);
            }
        }
        javax.swing.SwingUtilities.invokeLater(new Runnable()
        {
 
            @Override
            public void run()
            {
                menu.removeAll();
                synchronized (bahnsteige)
                {
                    for (Map.Entry<String, JCheckBoxMenuItem> s : bahnsteige.entrySet())
                    {
                        JCheckBoxMenuItem m = new JCheckBoxMenuItem(s.getKey());
                        m.setSelected(true);
                        m.addActionListener(menuListener);
                        menu.add(m);
                        s.setValue(m);
                    }
                }
                repaint();
            }
        });
    }
 
    /**
     * Antwort vom <zugliste>
     * @param zl <zid,name>
     *
     * speichert neue Züge in einer Liste, fragt für jeden Zug die Details ab
     */
    @Override
    protected void response_zugliste(HashMap<Integer, String> zl)
    {
        for (Integer zid : zl.keySet())
        {
            if (!zuglist.containsKey(zid))
            {
                zuglist.put(zid, null); // noch unbekannter ZID, neu aufnehmen
            }
            this.request_zugdetails(zid); // Details immer abfragen, Verspätungen, Gleisänderung ändern sich ständig
        }
        Iterator<Integer> it = zuglist.keySet().iterator();
        while (it.hasNext())
        {
            int zid = it.next();
            if (!zl.containsKey(zid))
            {
                it.remove(); // aufräumen, ZIDs, die nicht mehr mitgeschickt wurden, gibt es nicht mehr
            }
        }
    }
 
    /**
     * Antwort vom <zugdetails zid>
     * @param zid
     * @param details
     */
    @Override
    protected void response_zugdetails(int zid, ZugDetails details)
    {
        ZugDetailFahrplan zd = zuglist.get(zid);
        if (zd == null)
        { // Zug völlig neue, noch keine Details da
            zd = new ZugDetailFahrplan(details);
            zuglist.put(zid, zd);
            this.request_zugfahrplan(zid); // Fahrplan abfragen
        }
        else
        {
            zd.update(details);
            this.request_zugfahrplan(zid);
        }
        repaint();
    }
 
    /**
     * Antwort vom <zugfahrplan zid>
     * @param zid
     * @param plan
     */
    @Override
    protected void response_zugfahrplan(int zid, LinkedList<ZugFahrplanZeile> plan)
    {
        System.out.println("Fahrplan für " + zid);
        ZugDetailFahrplan zd = zuglist.get(zid);
        if (zd != null)
        {
            zd.plan = plan; // Fahrplan so speichern
        }
        else
        {
            System.out.println("Fehler: Für " + zid + " fehlen die Details!");
        }
    }
 
    /**
     * @return name des Stellwerks
     */
    public String getName()
    {
        return name;
    }
 
    /**
     * enthält jeweils einen Zug für die Abfahrtwand
     */
    public class Abfahrten implements Comparable
    {
 
        static private final String SPACER = "     ";
        public final String name;       /// Zugname
        public final String gleis;      /// Gleisname (ggf. nach Gleisänderung)
        public final String ab;         /// Abfahrtzeit (formatiert HH:MM)
        public final String nach;       /// Zugziel (Ausfahrt)
        public final String infotext;   /// ein Info-Text mit Verspätung, Gleisänderung, etc.
        private final long abLong;      /// Abfahrtzeit in Millis, zum Sortieren
 
        Abfahrten(ZugDetailFahrplan z, ZugFahrplanZeile f)
        {
            String t = "";
            if (z.verspaetung > 5)
            {
                t += "ca. " + ((z.verspaetung / 5) * 5) + " Min später" + SPACER;
            }
 
            name = z.name;
            gleis = cleverGleis(f.gleis);
            if (!f.plan.equals(f.gleis))
            {
                t += "Gleisänderung von Gleis " + cleverGleis(f.plan) + SPACER;
            }
            else if (z.gleis != null && z.plangleis != null && f.plan.equals(z.plangleis) && !z.plangleis.equals(z.gleis))
            {
                t += "Gleisänderung von Gleis " + cleverGleis(z.plangleis) + SPACER;
            }
            abLong = f.ab;
            ab = f.getFormattedAb();
            nach = z.nach;
            if (f.flags.hasFlag('R'))
            {
                t += "Zug ändert Fahrtrichtung" + SPACER;
            }
            if (f.flags.hasFlag('F'))
            {
                int fzid = f.flags.dataOfFlag('F');
                ZugDetailFahrplan fz = zuglist.get(fzid);
                if (fz == null || fz.nach.isEmpty())
                {
                    t += "Zug wird geteilt" + SPACER;
                }
                else
                {
                    t += "Zug wird geteilt, vorderer Zugteil nach " + nach + ", hinterer Zugteil als " + fz.name + " nach " + fz.nach + SPACER;
                }
            }
            infotext = t;
        }
 
        /**
         * führende Buchstaben im Gleisnamen entfernen
         * @param g
         * @return
         */
        private String cleverGleis(String g)
        {
            StringBuilder ret = new StringBuilder(g);
            while (ret.length() > 0 && !Character.isDigit(ret.charAt(0)))
            {
                ret.deleteCharAt(0);
            }
            return ret.toString();
        }
 
        @Override
        public int compareTo(Object o)
        {
            Abfahrten oo = (Abfahrten) o;
            int r = (int) (abLong - oo.abLong);
            if (r == 0)
            {
                r = name.compareToIgnoreCase(oo.name);
            }
            if (r == 0)
            {
                r = gleis.compareToIgnoreCase(oo.gleis);
            }
            return r;
        }
    }
 
    /**
     * liefert eine sortierte Liste der noch ausstehenden Abfahrten für die
     * ausgewählten Bahnsteige
     *
     * Ablauf ist der simpel: Züge, deren Ist- oder Soll-Gleis im Menü ausgewählt ist,
     * werden in die Liste aufgenommen. Die Sortierung macht diese für uns automatisch.
     * Die Wand gibt später alle Züge der Reihe nach aus, bis die Wand voll ist.
     * Weggelassen werden endende Züge (E-Flag und K-Flag), denn die haben keine Abfahrt.
     * @return
     */
    public TreeSet<Abfahrten> getAbfahrten()
    {
        TreeSet<Abfahrten> ret = new TreeSet<connection.Abfahrten>();
 
        for (ZugDetailFahrplan z : zuglist.values())
        {
            if (z.gleis != null)
            {
                try
                {
                    System.out.println("Zug: " + z.name + " von " + z.von + " ab " + z.getFormattedAb());
                    for (ZugFahrplanZeile g : z.plan)
                    {
                        if (!g.flags.hasFlag('E') && !g.flags.hasFlag('K') && !g.flags.hasFlag('D'))
                        {
                            JCheckBoxMenuItem cb = bahnsteige.get(g.gleis);
                            boolean add = (cb != null && cb.isSelected());
                            cb = bahnsteige.get(g.plan);
                            add |= (cb != null && cb.isSelected());
                            if (add)
                            {
                                System.out.println("zeigen");
                                ret.add(new Abfahrten(z, g));
                            }
                        }
                        else
                        {
                            System.out.println("Flag");
                        }
                    }
                }
                catch (NullPointerException ex)
                {
                    System.out.println("Unvollständig: " + z.name + "(" + z.zid + ")");
                }
            }
        }
        return ret;
    }
}