ChannelListSwing.java

/*
 * Created on Mar 25, 2004
 */
package org.nees.rbnb;

import javax.swing.JPanel;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JEditorPane;
import javax.swing.JSplitPane;

import javax.swing.BorderFactory;

import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeSelectionModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;

import javax.swing.Timer;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import java.util.Enumeration;
import java.util.Date;
import java.util.TimeZone;
import java.text.SimpleDateFormat;

import com.rbnb.sapi.*;
import com.rbnb.utility.ArgHandler; //for argument parsing
//import COM.Creare.Utility.ArgHandler; //for argument parsing

public class ChannelListSwing extends JPanel
                              implements TreeSelectionListener
{
    private static final String SERVER_NAME = "localhost";
    private static final String SERVER_PORT = "3333";

    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("MMM d, yyyy h:mm aa");
    private static final TimeZone TZ = TimeZone.getTimeZone("GMT");

    private String server = SERVER_NAME + ":" + SERVER_PORT;
     
    private Sink sink = null;
    private ChannelMap sMap;
    private boolean connected = false;
    
    private JTree tree;
    private JEditorPane htmlPane;
    private boolean needsRefresh = false;
    private Timer checkRefresh;
    private Thread timerThread;
    private boolean runit = false;
    
    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI and start the applicaiton
        final String[] a = args;
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                ChannelListSwing c = new ChannelListSwing();
                if (c.setArgs(a))
                {
                    c.connect();
                    c.createAndShowGUI();
                    c.setTimer();
                    c.startCheckThread();
                }
            }
        });
    }
    
    private void printUsage() {
        System.out.println("ChannelListSwing: usage is...");        
        System.out.print("ChannelListSwing ");
        System.out.print("[-s Server Name *" + SERVER_NAME + "] ");
        System.out.print("[-p Server Port *" + SERVER_PORT + "] ");     
        System.out.println();
    }
    
    public boolean setArgs(String[] args) {
        String serverName = SERVER_NAME;
        String serverPort = SERVER_PORT;
        //parse args
        try {
            ArgHandler ah=new ArgHandler(args);
            if (ah.checkFlag('h')) {
                printUsage();
                return false;
            }
            if (ah.checkFlag('s')) {
                String a=ah.getOption('s');
                if (a!=null) serverName=a;
            }
            if (ah.checkFlag('p')) {
                String a=ah.getOption('p');
                if (a!=null) serverPort=a;
            }
        } catch (Exception e) {
            System.err.println("ChannelList argument exception "+e.getMessage());
            e.printStackTrace();
            return false;
        }
        
        setArgs(serverName,serverPort);
        
        System.out.println("Starting ChannelList on " + server);
        System.out.println("  Use ChannelList -h to see optional parameters");
        
        return true;
    }
    
    public ChannelListSwing()
    {
        setArgs(SERVER_NAME,SERVER_PORT);
    }
    
    public void setArgs(String serverName, String serverPort)
    {
        server = serverName + ":" + serverPort;
    }
    
    protected void createAndShowGUI() {
        
        //Make sure we have nice window decorations.
        //JFrame.setDefaultLookAndFeelDecorated(true);

        //Create and set up the window.
        JFrame frame = new JFrame("Channel List");
        //frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        initGraphics();
        setOpaque(true); //content panes must be opaque
        frame.setContentPane(this);

        //Display the window.
        frame.pack();
        frame.setVisible(true);
    }
    
    protected void initGraphics() {
        setLayout(new BorderLayout());
        setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
        
        //Create the nodes.
        DefaultMutableTreeNode top = createNodes();

        //Create a tree that allows one selection at a time.
        tree = new JTree(top);
        tree.getSelectionModel().setSelectionMode
                (TreeSelectionModel.SINGLE_TREE_SELECTION);

        //Listen for when the selection changes.
        tree.addTreeSelectionListener(this);

        //Create the scroll pane and add the tree to it. 
        JScrollPane treeView = new JScrollPane(tree);

        //Create the HTML viewing pane.
        htmlPane = new JEditorPane();
        htmlPane.setEditable(false);
        JScrollPane htmlView = new JScrollPane(htmlPane);

        //Add the scroll panes to a split pane.
        JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
        splitPane.setTopComponent(treeView);
        splitPane.setBottomComponent(htmlView);

        Dimension minimumSize = new Dimension(100, 50);
        htmlView.setMinimumSize(minimumSize);
        treeView.setMinimumSize(minimumSize);
        splitPane.setDividerLocation(100); //XXX: ignored in some releases
                                           //of Swing. bug 4101306
        //workaround for bug 4101306:
        //treeView.setPreferredSize(new Dimension(100, 100)); 

        splitPane.setPreferredSize(new Dimension(500, 300));

        //Add the split pane to this panel.
        add(splitPane);

        //root and frame
        JFrame itsFrame = new JFrame("ChannelList");
        itsFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        itsFrame.setSize(new Dimension(120, 40));
        itsFrame.getContentPane().add(this, BorderLayout.CENTER);

        //Display the window.
        itsFrame.pack();
        itsFrame.setVisible(true);
    }

    protected void setTimer()
    {
        int delay = 100; //milliseconds; 1/10 second
        ActionListener taskPerformer = new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                if (needsRefresh)
                {
                    //recreate the nodes.
                    DefaultMutableTreeNode top = createNodes();
                    DefaultTreeModel model = new DefaultTreeModel(top);
                    tree.setModel(model);
                    invalidate();
                    needsRefresh = false;
                }
            }
        };
        checkRefresh = new Timer(delay, taskPerformer);
        checkRefresh.start();
    }


    private DefaultMutableTreeNode createNodes() {
        DefaultMutableTreeNode top;
        if (!connected)
            top = new DefaultMutableTreeNode("UNCONNECTED (attempting to connect to "
                + server + ")");
        else
        {
            top = new DefaultMutableTreeNode("Connected to " + server);
            ChannelTree ct = getChannelTree();
            if (ct == null)
            {
                top = new DefaultMutableTreeNode("No Channel Tree (connection dropped?)");
            }
            else
            {
                Iterator i = ct.rootIterator();
                while (i.hasNext())
                {
                    top.add(makeNodes((ChannelTree.Node)i.next()));
                }
            }
        }
        
        return top;
    }
    
    private DefaultMutableTreeNode makeNodes(ChannelTree.Node node)
    {
        DefaultMutableTreeNode root = new DefaultMutableTreeNode(new NodeCover(node));
        List l = node.getChildren();
        Iterator i = l.iterator();
        while (i.hasNext())
        {
            root.add(makeNodes((ChannelTree.Node)i.next()));
        }

        return root; 
    }

    public void valueChanged(TreeSelectionEvent e) {
        DefaultMutableTreeNode node = (DefaultMutableTreeNode)
                           tree.getLastSelectedPathComponent();

        if (node == null) return;
        Object nodeInfo = node.getUserObject();
        if (nodeInfo instanceof NodeCover)
        {
            NodeCover nc = (NodeCover)nodeInfo; 
            ChannelTree.Node ctNode = nc.node;
            displayMetaData(ctNode);
        }
        else
        {
            htmlPane.setText(nodeInfo.toString());
        }
    }

    protected void connect()
    {
        try {
            // Create a sink and connect:
            sink=new Sink();
            sink.OpenRBNBConnection(server,"ChannelListRequest");
            connected = true;
            System.out.println("ChannelList: Connection made to server = "
                + server + " requesting channel list.");
        }
        catch (SAPIException se)
        {
            System.out.println("ChannelList: Cannot connect to "
                + server + "; exception = " + se);
        }
    }

    private ChannelTree getChannelTree() {
        try {
            sMap = new ChannelMap();
            sink.RequestRegistration();     
            sMap = sink.Fetch(-1,sMap);
            return ChannelTree.createFromChannelMap(sMap);
        }
        catch (SAPIException se)
        {
            System.out.println("ChannelList: get channel tree failed. Reconnect?");
            System.out.println("Exception = " + se);
            connected = false;
        }
        return null;
    }

    private void displayMetaData(ChannelTree.Node node) {
        double start = node.getStart();
        double duration = node.getDuration();
        double end = start + duration;
        
        long unixTime = (long)(start * 1000.0); // convert sec to millisec
        String startTime = DATE_FORMAT.format(new Date(unixTime));
        unixTime = (long)(end * 1000.0);
        String endTime = DATE_FORMAT.format(new Date(unixTime));

        if (((node.getType()).toString()).equals("Channel"))
            htmlPane.setText(
                "FullName = " + node.getFullName() + "\n" +
                "Time (start, duration) = " + start + ", " + duration + "\n" +
                "[Assuming \"standard\" time:" + "\n" +
                "    from " + startTime + "\n" + 
                "    to " + endTime + "]\n" +
                "Type = " + node.getType() + "\n" +
                "Mime type = " + node.getMime() + "\n" +
                "Size = " + node.getSize()
            );
        else
        htmlPane.setText(
            "FullName = " + node.getFullName() + "\n" +
            "Type = " + node.getType() + "\n"
            );
    }
    
    protected void startCheckThread()
    {
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
              runWork();
            }
        };
        runit = true;
        timerThread = new Thread(r, "Timer");
        timerThread.start();
        System.out.println("Started checker thread.");
    }

    private void stopThread()
    {
        runit = false;
        timerThread.interrupt();
        System.out.println("Stopped checker thread.");
    }
    
    private void runWork ()
    {
        int delay = 10000; // 10 seconds
        while(runit)
        {
            if (!connected)
            {
                delay = 10000; // 10 seconds
                // try connecting
                connect();
                if (connected) delay = 1000; // one second
            }
            else if (!sameTree(tree)) 
            {
                System.out.println("Found mismatched tree");
                needsRefresh = true;
            } 
            try {Thread.sleep(delay);} catch (InterruptedException ignore) {}
        }
        timerThread = null;
    }
    
    private boolean sameTree(JTree tree)
    {
        TreeModel m = tree.getModel();
        ChannelTree ct = getChannelTree();
        if (ct == null) return false;
        return sameTreeNodes(ct.rootIterator(),(DefaultMutableTreeNode)m.getRoot());
    }
    
    private boolean sameTreeNodes(Iterator i, DefaultMutableTreeNode tree)
    {
        // its the Iterator of the ChannelTree.Node's of this level of the tree
        
        // if all the ChannelTree.Node's in the iterator are in the children of this tree
        // and all the decendent trees match, then the trees match.
        // (name equivalance is good enough)

        if (tree.isLeaf() && !i.hasNext())
        {
            // expected leaf node
            return true;
        }

        if (tree.isLeaf() && i.hasNext())
        {
            // unexpected leaf node
            return false;
        }

        if (!tree.isLeaf() && !i.hasNext())
        {
            // unexpected empty itereator
            return false;           
        }
        
        // not a leaf node...

        // make a vector of all the names at this level
        Vector nodeList = new Vector();
        int count = tree.getChildCount();
        for (int k = 0; k < count; k++)
        {
            nodeList.add(tree.getChildAt(k));
        }

        while (i.hasNext())
        {
            ChannelTree.Node n = (ChannelTree.Node)i.next();
            Enumeration e = nodeList.elements();
            DefaultMutableTreeNode found = null;
            while(e.hasMoreElements())
            {
                DefaultMutableTreeNode test = (DefaultMutableTreeNode)e.nextElement();
                Object nodeInfo = test.getUserObject();
                NodeCover nc = (NodeCover)nodeInfo; 
                ChannelTree.Node ctNode = nc.node;
                if (n.getName().equals(ctNode.getName()))
                {
                    found = test;
                    break;
                }
            }
            if (found == null) return false;
            nodeList.remove(found);
            if (!sameTreeNodes(n.getChildren().iterator(),found)) return false;
        }
        if (nodeList.size() > 0)
        {
            // extra nodes at this level
            return false;           
        }
        return true;
    }
    
    private class NodeCover
    {
        ChannelTree.Node node;
        
        NodeCover(ChannelTree.Node node)
        {
            this.node = node;
        }
        
        public String toString()
        {
            return node.getName();
        }
    }
}

---