Client.java

/*
 * Created on Apr 29, 2004
 */
package org.nees.rbnb;

import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;

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

import javax.swing.BorderFactory;
import javax.swing.Timer;

import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeNode;
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 java.awt.Component;
import java.awt.Container;
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.Dimension;
import java.awt.Button;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import java.util.Properties;

import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import java.util.Hashtable;
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 Client
extends JPanel
{
    private static final String SERVER_NAME = "localhost";
    private static final String SERVER_PORT = "3333";
    private static final String SOURCE_NAME = "neesPopClient";
    private static final String SOURCE_CHANNEL_NAME = "command";
    private static final String SINK_NAME = "nessPopClient_commandFeedback";
    private static final String CHANNEL_LIST_SINK_NAME = "nessPopClient_channelList";
    private static final String SINK_SOURCE_PATH = "neesPop/commandFeedback";

    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 static final String TOP_CARD = "TopCard";
    private static final String CHANNEL_CARD = "ChannelCard";
    private static final String LINK_CARD = "LinkCard";
    private static final String TEMPLATE_CARD = "TemplateCard";
    private static final String INSTANCE_CARD = "InstanceCard";
    private static final String PARAMETER_CARD = "ParameterCard";

    private static final String CHANNELS_TREE_LABEL = "Channels";
    
    private JFrame itsFrame;
    private JTree tree;
    private JEditorPane displayPane;
    private JPanel cardPanel;
    
    private Hashtable buttonTable = new Hashtable();
    
    private static final boolean SHOW_HIDDEN = false;
    
    private Source source = null;
    private String sourceName = SOURCE_NAME;
    private String sourceChannelName = SOURCE_CHANNEL_NAME;
    private int sourceChannelIndex;
    private ChannelMap sourceMap;
    private Thread sourceCommandThread;
    private boolean sourceConnected = false;
    private boolean sourceCommandRunning = false;

    private Sink sink = null;
    private String sinkName = SINK_NAME;
    private ChannelMap sinkMap;
    private int sinkIndex;
    private String sinkRequestPath = SINK_SOURCE_PATH;
    private Thread sinkCommandThread;
    private boolean sinkConnected = false;
    private boolean sinkCommandRunning = false;

    private Sink channelListSink = null;
    private String channelListSinkName = CHANNEL_LIST_SINK_NAME; 
    private ChannelMap channelListSinkMap;
    private Thread channelListSinkThread;
    private boolean channelListSinkConnected = false;
    private boolean channelListSinkRunning = false;
    
    private ChannelTree latestChannelTree;
    private boolean showHidden = SHOW_HIDDEN;
    
    private MetaDataPropertyList pList = new MetaDataPropertyList();
    private Vector commands = new Vector();
    
    private String propertiesFilePath = null;
//  private String propertiesFilePath = DEBUG_PARAMETER_FILE_PATH;
    private Properties prop = new Properties();

    private NeesControlMetadata metadata = new NeesControlMetadata();
    
    private String templateSelection;
    private JLabel templateSelectionLabel;
    private String instanceSelection;
    private JLabel instanceSelectionLabel;
    private String parameterSelection;
    private JLabel parameterSelectionLabel;
    
    public Client()
    {
        super();
    }
    
    private static void createAndShowGUI(String[] args) {
        //Make sure we have nice window decorations.
        JFrame.setDefaultLookAndFeelDecorated(true);
       
        //Create and set up the window.
        JFrame frame = new JFrame("NEES RBNB Control Client");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

        //Establish Client
        Client c = new Client();
        c.exec(args);
        c.initGraphics();
        c.executeCommand(Command.GET_METADATA);

        //Set up the content pane.
        Container contentPane = frame.getContentPane();
        contentPane.add(c);

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

    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        final String[] a = args;
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI(a);
            }
        });
    }
    
    private void exec(String[] args)
    {
        if (setArgs(args))
        {
            log("Args set");    
            if (connect())
            {
                log("Starting threads...");
                start();
                log("Connected...and started");
            }
            else
                log("Failed to connect.");
        }
        else
            log("Set args failed");
    }

    private void printUsage()
    {
        //TODO: print usage
        System.out.println("Print Usage Place holder");
    } // printUsage
    
    private boolean setArgs(String[] args)
    {
        try {
            ArgHandler ah=new ArgHandler(args);
            if (ah.checkFlag('h')) {
                printUsage();
                return false;
            }
            if (ah.checkFlag('f')) {
                String a=ah.getOption('f');
                if (a!=null) propertiesFilePath=a;
            }
        } catch (Exception e) {
            log("Failed to process command line args: " + e);
            return false;
        }
        
        return 
            processPropertiesFile(propertiesFilePath)
            && setPropertiesFromArgs(args)
            && setVarablesFromProperties();
    } // setArgs
    
    private boolean processPropertiesFile(String propertiesFilePath)
    {
        if (propertiesFilePath == null) return true;
        if (propertiesFilePath.length() == 0) return true;
        File f = new File(propertiesFilePath);
        if (!f.exists())
        {
            log("Properties file does not exist: " + propertiesFilePath);
            return true;
        }
        
        try
        {
            prop.load(new FileInputStream(f));
            log("Sucessfully loaded properties file: " + propertiesFilePath);
        }
        catch (IOException e)
        {
            log("Can not process properties file, " + propertiesFilePath
                + ", exception = " + e);
            return false;
        }
        return true;
    } // processPropertiesFile

    private boolean setPropertiesFromArgs(String[] args) {
        // TODO setPropertiesFromArgs
        return true;
    } // setPropertiesFromArgs

    private boolean setVarablesFromProperties() {
        // TODO setVarablesFromProperties
        return true;
    } // setVarablesFromProperties
    
    protected void initGraphics() {
        log ("initializing graphics");
        setLayout(new BorderLayout());
        setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

        //Create the nodes.
        DefaultMutableTreeNode top = initObjectTree();

        //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(
            new TreeSelectionListener() {
                public void valueChanged(TreeSelectionEvent e)
                {
                    handleObjectSelection(e);
                }
            }
        );

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

        JPanel commandPanel = setupCommandButtons();
        
        // Create the status display pane.
        displayPane = new JEditorPane();
        displayPane.setEditable(false);
        JScrollPane displayView = new JScrollPane(displayPane);

        //Add the scroll panes to a split pane.
//      JSplitPane commandSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
//      commandSplitPane.setTopComponent(commandPanel);
//      commandSplitPane.setBottomComponent(displayView);

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

//      commandSplitPane.setPreferredSize(new Dimension(500, 300));

        //Add the scroll panes to a split pane.
        JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
        splitPane.setLeftComponent(treeView);
//      splitPane.setRightComponent(commandSplitPane);
        splitPane.setRightComponent(displayView);
        splitPane.setDividerLocation(200); //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,BorderLayout.CENTER);
        add(commandPanel,BorderLayout.SOUTH);
        
        log ("initializing graphics.... done");

    } // initGraphics
    
    
    private JPanel setupCommandButtons()
    {
        return setupCommandButtonsWithFlat();
    }
    
    private JPanel setupCommandButtonsWithFlat() {
        // Create the command button panel with cards.
        JPanel flatPanel = new JPanel();
        flatPanel.setLayout(new GridLayout(0,3));
        makeButtonWithLister(flatPanel, Command.GET_METADATA, Command.GET_METADATA_LABEL);
        makeButtonWithLister(flatPanel, Command.CLEAR_COMMAND, Command.CLEAR_COMMAND_LABEL);
        makeButtonWithLister(flatPanel, Command.REFRESH_TREE, Command.REFRESH_TREE_LABEL);
        makeButtonWithLister(flatPanel, Command.TEST_COMMAND, Command.TEST_COMMAND_LABEL);
        makeButtonWithLister(flatPanel, Command.RESTART_COMMAND, Command.RESTART_COMMAND_LABEL);
        makeButtonWithLister(flatPanel, Command.ADD_LINK, Command.ADD_LINK_LABEL);
        makeButtonWithLister(flatPanel, Command.REMOVE_LINK, Command.REMOVE_LINK_LABEL);
        makeButtonWithLister(flatPanel, Command.FOCUS_TO_LINK, Command.FOCUS_TO_LINK_LABEL);
        makeButtonWithLister(flatPanel, Command.CREATE_INSTANCE, Command.CREATE_INSTANCE_LABEL);
        makeButtonWithLister(flatPanel, Command.DELETE_INSTANCE, Command.DELETE_INSTANCE_LABEL);
        makeButtonWithLister(flatPanel, Command.START_INSTANCE, Command.START_INSTANCE_LABEL);
        makeButtonWithLister(flatPanel, Command.STOP_INSTANCE, Command.STOP_INSTANCE_LABEL);
        makeButtonWithLister(flatPanel, Command.SET_PARAMETER, Command.SET_PARAMETER_LABEL);
        makeButtonWithLister(flatPanel, Command.RESET_PARAMETER, Command.RESET_PARAMETER_LABEL);
        
        JPanel commands = new JPanel();
        commands.setLayout(new BorderLayout());
        commands.add(flatPanel,BorderLayout.CENTER);
        
        JPanel labelPanel = new JPanel();
        labelPanel.setLayout(new GridLayout(0,1));
        JPanel p = new JPanel();
        JLabel l = new JLabel("Selected Template: ");
        templateSelectionLabel = new JLabel("*************************");
        p.add(l);
        p.add(templateSelectionLabel);
        labelPanel.add(p);
        
        p = new JPanel();
        l = new JLabel("Selected Instance: ");
        instanceSelectionLabel = new JLabel("*************************");
        p.add(l);
        p.add(instanceSelectionLabel);
        labelPanel.add(p);

        p = new JPanel();
        l = new JLabel("Selected Instance Parameter: ");
        parameterSelectionLabel = new JLabel("*************************");
        p.add(l);
        p.add(parameterSelectionLabel);
        labelPanel.add(p);

        commands.add(labelPanel,BorderLayout.SOUTH);
        
        disableAllButtons();
        
        enableButton(Command.CLEAR_COMMAND);
        enableButton(Command.GET_METADATA);
        enableButton(Command.RESTART_COMMAND);
        enableButton(Command.TEST_COMMAND);
        enableButton(Command.REFRESH_TREE);

        return commands;
    }

    private JPanel setupCommandButtonsWithCards()
    {
        // Create the command button panel with cards.
        cardPanel = new JPanel();
        cardPanel.setLayout(new CardLayout());

        // top card
        JPanel card = new JPanel();     
        card.setLayout(new FlowLayout());
        card.setOpaque(true);
        makeButtonWithLister(card, Command.GET_METADATA, Command.GET_METADATA_LABEL);
        makeButtonWithLister(card, Command.CLEAR_COMMAND, Command.CLEAR_COMMAND_LABEL);
        makeButtonWithLister(card, Command.REFRESH_TREE, Command.REFRESH_TREE_LABEL);
        makeButtonWithLister(card, Command.TEST_COMMAND, Command.TEST_COMMAND_LABEL);
        makeButtonWithLister(card, Command.RESTART_COMMAND, Command.RESTART_COMMAND_LABEL);
        cardPanel.add(card,TOP_CARD);
        
        // channel card
        card = new JPanel();        
        card.setLayout(new FlowLayout());
        makeButtonWithLister(card, Command.REFRESH_TREE, Command.REFRESH_TREE_LABEL);
        makeButtonWithLister(card, Command.SWITCH_TO_TOP, Command.SWITCH_TO_TOP_LABEL);
        cardPanel.add(card,CHANNEL_CARD);

        // link card
        card = new JPanel();        
        card.setLayout(new FlowLayout());
        makeButtonWithLister(card, Command.ADD_LINK, Command.ADD_LINK_LABEL);
        makeButtonWithLister(card, Command.REMOVE_LINK, Command.REMOVE_LINK_LABEL);
        makeButtonWithLister(card, Command.FOCUS_TO_LINK, Command.FOCUS_TO_LINK_LABEL);
        makeButtonWithLister(card, Command.SWITCH_TO_TOP, Command.SWITCH_TO_TOP_LABEL);
        cardPanel.add(card,LINK_CARD);

        // template card
        card = new JPanel();        
        card.setLayout(new FlowLayout());
        JPanel p = new JPanel();
        JLabel l = new JLabel("Selected Template: ");
        templateSelectionLabel = new JLabel("                     ");
        p.add(l);
        p.add(templateSelectionLabel);
        card.add(p);
        makeButtonWithLister(card, Command.CREATE_INSTANCE, Command.CREATE_INSTANCE_LABEL);
        makeButtonWithLister(card, Command.SWITCH_TO_TOP, Command.SWITCH_TO_TOP_LABEL);
        cardPanel.add(card,TEMPLATE_CARD);

        // instance card
        card = new JPanel();        
        card.setLayout(new FlowLayout());
        p = new JPanel();
        l = new JLabel("Selected Instance: ");
        instanceSelectionLabel = new JLabel("                     ");
        p.add(l);
        p.add(instanceSelectionLabel);
        card.add(p);
        makeButtonWithLister(card, Command.START_INSTANCE, Command.START_INSTANCE_LABEL);
        makeButtonWithLister(card, Command.STOP_INSTANCE, Command.STOP_INSTANCE_LABEL);
        makeButtonWithLister(card, Command.SWITCH_TO_TOP, Command.SWITCH_TO_TOP_LABEL);
        cardPanel.add(card,INSTANCE_CARD);

        // parameter card
        card = new JPanel();        
        card.setLayout(new FlowLayout());
        p = new JPanel();
        l = new JLabel("Selected Instance: ");
        parameterSelectionLabel = new JLabel("                     ");
        p.add(l);
        p.add(parameterSelectionLabel);
        card.add(p);
        makeButtonWithLister(card, Command.SET_PARAMETER, Command.SET_PARAMETER_LABEL);
        makeButtonWithLister(card, Command.RESET_PARAMETER, Command.RESET_PARAMETER_LABEL);
        makeButtonWithLister(card, Command.SWITCH_TO_TOP, Command.SWITCH_TO_TOP_LABEL);
        cardPanel.add(card,PARAMETER_CARD);
        
        return cardPanel;
    }

    private void makeButtonWithLister(JPanel p, String command,  String label) {
        Button b = new Button(label);
        buttonTable.put(command, b);
        final String c = new String(command);
        b.addActionListener(
            new ActionListener(){
                public void actionPerformed(ActionEvent arg0) {
                    executeCommand(new String(c));
                }
            }
        );
        p.add(b);       
    }
    
    private void disableAllButtons()
    {
        Enumeration e = buttonTable.elements();
        while (e.hasMoreElements())
        {
            Button b = (Button)e.nextElement();
            b.setEnabled(false);
        }
    }
    
    private void enableButton(String key)
    {
        Button b = (Button)buttonTable.get(key);
        if (b != null) b.setEnabled(true);
    }

    private void disableButton(String key)
    {
        Button b = (Button)buttonTable.get(key);
        if (b != null) b.setEnabled(false);
    }

    protected void switchToCard(String cardLabel)
    {
//      if () 
//      {
//          CardLayout c = (CardLayout) cardPanel.getLayout();
//          c.show(cardPanel,cardLabel);
//          invalidate();
//      }
    }

    protected boolean connect()
    {
        try {
            // Create a source and connect:
            source=new Source();
            source.OpenRBNBConnection(server,sourceName);
            sourceMap = new ChannelMap();
            sourceChannelIndex = sourceMap.Add(sourceChannelName);
            sourceMap.PutTimeAuto("timeofday");
            sourceConnected = true;
            log("Client: Source connection made to server = "
                + server + " as " + sourceName + ".");
        }
        catch (SAPIException se)
        {
            log("Client: Cannot connect source to "
            + server + " as " + sourceName + ": " + se);
        }

        try {
            // Create sinkd and connect:
            sink=new Sink();
            sink.OpenRBNBConnection(server,sinkName);
            sinkMap = new ChannelMap();
            sinkIndex = sinkMap.Add(sinkRequestPath);
            sink.Subscribe(sinkMap,"newest");
            sinkConnected = true;
            log("Client: Sink connection made to server = "
                + server + " as " + sinkName + ".");
        }
        catch (SAPIException se)
        {
            log("Client: Cannot connect sink to "
            + server + " as " + sinkName + ": " + se);
        }
        
        try {
            // Create sinkd and connect:
            channelListSink = new Sink();
            channelListSink.OpenRBNBConnection(server,channelListSinkName);
            channelListSinkConnected = true;
            log("Client: Channel List Sink connection made to server = "
                + server + " as " + channelListSinkName + ".");
        }
        catch (SAPIException se)
        {
            log("Client: Cannot connect sink to "
            + server + " as " + sinkName + ": " + se);
        }

        return sourceConnected && sinkConnected && channelListSinkConnected;
    }

    protected void executeCommand(String command)
    {
        // process and send any command that is done remotly
        if (command.equals(Command.GET_METADATA)
            || command.equals(Command.RESTART_COMMAND)
            || command.equals(Command.ADD_LINK)
            || command.equals(Command.REMOVE_LINK)
            || command.equals(Command.FOCUS_TO_LINK)
            || command.equals(Command.CREATE_INSTANCE)
            || command.equals(Command.DELETE_INSTANCE)
            || command.equals(Command.START_INSTANCE)
            || command.equals(Command.STOP_INSTANCE)
            || command.equals(Command.SET_PARAMETER)
            || command.equals(Command.RESET_PARAMETER)
            )
        {
            String toSend = makeCommand(command);
            if (toSend != null)
            {
                synchronized (commands)
                {
                    commands.add(toSend);
                    sourceCommandThread.interrupt();
                }
            }
            else log("Problems with command: " + command);
        }
        else
        if (command.equals(Command.TEST_COMMAND))
        {
            log("Execute Test Command");
        }
        else
        if (command.equals(Command.CLEAR_COMMAND))
        {
            log("Execute Clear Command");
            displayPane.setText("");
            invalidate();
        }
        else
        if (command.equals(Command.SWITCH_TO_TOP))
        {
            log("Execute Switch to Top Command");
            switchToCard(TOP_CARD);
        }
        else
        if (command.equals(Command.REFRESH_TREE))
        {
            // local
            log("Unimplemented command = " + command);
        }
        else
        {
            log("Request to execurte unrecognized command = " + command);
        }
    } // ececuteCommand

    private String makeCommand(String command)
    {
        Document doc = Xml.createDocument();
        Node node, root = doc.createElement(NeesControlMetadata.XML_TAG_FOR_COMMAND);
        node = doc.createElement(NeesControlMetadata.XML_TAG_FOR_COMMAND);
        node.appendChild(doc.createTextNode(command));
        root.appendChild(node);
        doc.appendChild(root);

        // commands that require no parameters...   
        // GET_METADATA, RESTART_COMMAND
        
        if (command.equals(Command.ADD_LINK) || command.equals(Command.REMOVE_LINK)
            || command.equals(Command.FOCUS_TO_LINK))
        {
            // add link name to command
            // TODO: fix link name
//          node = doc.createElement(NeesControlMetadata.XML_TAG_FOR_LINK);
//          node.appendChild(doc.createTextNode("UnknownLink"));
//          root.appendChild(node);
            return null;
        }
        else
        if (command.equals(Command.CREATE_INSTANCE))
        {
            // requires a template
            if (templateSelection == null) return null;
            node = doc.createElement(NeesControlMetadata.XML_TAG_FOR_TEMPLATE);
            node.appendChild(doc.createTextNode(templateSelection));
            root.appendChild(node);
        }
        else if (command.equals(Command.START_INSTANCE)
            || command.equals(Command.STOP_INSTANCE)
            || command.equals(Command.DELETE_INSTANCE))
        {
            // requires an instance
            if (instanceSelection == null) return null;
            node = doc.createElement(NeesControlMetadata.XML_TAG_FOR_INSTANCE);
            node.appendChild(doc.createTextNode(instanceSelection));
            root.appendChild(node);
        }
        else
        if (command.equals(Command.SET_PARAMETER)
            || command.equals(Command.RESET_PARAMETER))
        {
            //requires an instance and a parameter
            if ((instanceSelection == null) 
                || (parameterSelection == null))
                return null;
            
            InstanceDescription i = metadata.getInstance(instanceSelection);
            if (i == null) return null;
            
            RBNBBaseParameterHolder p = i.getParameter(parameterSelection);
            if (p == null) return null;

            if (command.equals(Command.SET_PARAMETER))
            {
                String s = (String)JOptionPane.showInputDialog(
                                    (Component)this,
                                    "Enter New Value for Parameter\n"
                                    + p.getName() + " of \n"
                                    + i.getName(),
                                    "" + ((p.getValue() != null)?p.getValue().toString():""));
                if (s == null) return null;
                p.setValueFromString(s);                
            }
            else // command is reset use default value
            {
                p.setValue(p.getDefaultValue());
            }
            
            node = doc.createElement(NeesControlMetadata.XML_TAG_FOR_INSTANCE);
            node.appendChild(doc.createTextNode(instanceSelection));
            root.appendChild(node);
            root.appendChild(p.createXmlNode(doc));
        }
        try {
            return Xml.writeDocumentToString(doc);
        } catch (IOException e) {
            // Failed to generate Command
            log ("Failed to generate Command (" + command + "): " + e.toString());
            return null;
        }
    } // makeCommand

    protected void start()
    {
        startSourceThread();
        startSinkThread();
        startChannelListSinkThread();
    }

    protected void startSourceThread()
    {
        
        if (!sourceConnected) return;
        
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
              runSourceWork();
            }
        };
        sourceCommandRunning = true;
        sourceCommandThread = new Thread(r, "Command");
        sourceCommandThread.start();
        log("Client: Started Command Send thread.");
    }

    protected void stopSourceThread()
    {
        sourceCommandRunning = false;
        sourceCommandThread.interrupt();
        log("Client: Stopped Command Send thread.");
    }
    
    protected void runSourceWork ()
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        try {
            while(sourceIsRunning())
            {
                String commandString = null;
                synchronized (commands)
                {
                    if (commands.size() > 0)
                    {
                        commandString = (String)commands.firstElement();
                        commands.removeElementAt(0);
                    }
                }
                
                if (commandString != null)
                {
                    log("Posting command: " + commandString);
                    
                    // send command
                    sourceMap.PutDataAsString(sourceChannelIndex,commandString);
                    source.Flush(sourceMap);
                }
                try{Thread.sleep(1000);} catch (Exception ignore){}
            }
        } catch (SAPIException se) {
            se.printStackTrace(); 
//      } catch (IOException e) {
//          e.printStackTrace();
        }
        source.CloseRBNBConnection();
        sourceCommandThread = null;
    }
    
    protected boolean sourceIsRunning()
    {
        return (sourceConnected && sourceCommandRunning);
    }

    protected void startSinkThread()
    {
        
        if (!sinkConnected) return;
        
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
              runSinkWork();
            }
        };
        sinkCommandRunning = true;
        sinkCommandThread = new Thread(r, "Listen");
        sinkCommandThread.start();
        log("Client: Started Command Listen thread.");
    }

    protected void stopSinkThread()
    {
        sinkCommandRunning = false;
        sinkCommandThread.interrupt();
        log("Client: Stopped Command Listen thread.");
    }
    
    protected void runSinkWork()
    {
        try {
            while(sinkIsRunning())
            {
                ChannelMap m = sink.Fetch(-1);
                String[] st = m.GetDataAsString(0);
                for (int i = 0; i < st.length; i++)
                {
                    processCommandFeedback(st[i]);
                }
            }
        } catch (SAPIException se) {
            se.printStackTrace(); 
        }
        sinkCommandThread = null;
    }

    protected boolean sinkIsRunning()
    {
        return (sinkConnected && sinkCommandRunning);
    }

    protected void startChannelListSinkThread()
    {
        
        if (!channelListSinkConnected) return;
        
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
              runChannelListSinkWork();
            }
        };
        channelListSinkRunning = true;
        channelListSinkThread = new Thread(r, "Listen");
        channelListSinkThread.start();
        log("Client: Started Channel List Listen thread.");
    }

    protected void stopChannelListSinkThread()
    {
        channelListSinkRunning = false;
        channelListSinkThread.interrupt();
        log("Client: Stopped Channel List Listen thread.");
    }
    
    protected void runChannelListSinkWork()
    {
        try {
            while(channelListSinkIsRunning())
            {
                channelListSink.RequestRegistration();      
                ChannelMap m = channelListSink.Fetch(-1);
                latestChannelTree = ChannelTree.createFromChannelMap(m);
                try {Thread.sleep(1000);} catch (Exception ignore) {}
            }
        } catch (SAPIException se) {
            se.printStackTrace(); 
        }
        sinkCommandThread = null;
    }

    protected boolean channelListSinkIsRunning()
    {
        return (channelListSinkConnected && channelListSinkRunning);
    }

    protected void processCommandFeedback(String feedback)
    {
        Document doc = null;
        try{
            doc = Xml.readDocumentFromString(feedback);
        } catch (Throwable ignore) {}
        if (doc == null)
            log("Message Unrecognized (not XML): " + feedback);
        else
        {
            Element root = doc.getDocumentElement();
            log("Feedback Message type = " + root.getTagName());
            if (root.getTagName().equals(
                    NeesControlMetadata.XML_TAG_FOR_METADATA))
            {
                // this is a metadata xml bundle
                try
                {
                    setMetatdataFromXML(feedback);
                } catch (Throwable t)
                {
                    t.printStackTrace();
                    log("Message parse failed on metadata: " + t);
                }
            }
            else
            if (root.getTagName().equals(Xml.XML_TAG_FOR_STATUS_MESSAGE))
            {
                logStatusMessage(doc);
            }
            else
            if (root.getTagName().equals(Xml.XML_TAG_FOR_ERROR_MESSAGE))
            {
                logErrorMessage(doc);
            }
            else
                log("Message type unrecognized " + root.getTagName());
        }
    }
    
    private void logStatusMessage(Document doc) {
        // TODO Auto-generated method stub
        try {
            log(Xml.writeDocumentToString(doc));
        } catch (IOException ignore) {
        }
    }

    private void logErrorMessage(Document doc) {
        // TODO Auto-generated method stub
        try {
            log(Xml.writeDocumentToString(doc));
        } catch (IOException ignore) {
        }
    }

    private void setMetatdataFromXML(String feedback) 
        throws Throwable
    {
        metadata.setFromXml(feedback);
        updateTree();
    }

    private void updateTree() {
        DefaultMutableTreeNode top = initObjectTree();
        DefaultTreeModel model = new DefaultTreeModel(top);
        tree.setModel(model);
        invalidate();
    }

    protected void handleObjectSelection(TreeSelectionEvent e)
    {
        // TODO: handleObjectSelection(e);
        DefaultMutableTreeNode node = (DefaultMutableTreeNode)
                           tree.getLastSelectedPathComponent();

        if (node == null) return;
        Object nodeInfo = node.getUserObject();
        String type = nodeInfo.getClass().getName();
        log("Tree Selection is: " + nodeInfo.toString() + " (" + type + ")");

        instanceSelection = null;
        templateSelection = null;
        parameterSelection = null;
        
        String label = "";
        if (type.equals("java.lang.String"))
        {
            label = (String)nodeInfo;
        }
        
        // determine if a template or instance parameter is selected
        if (type.endsWith("TemplateDescription"))
            templateSelection =
                ((TemplateDescription)nodeInfo).getName();
        if (type.endsWith("InstanceDescription"))
            instanceSelection =
                ((InstanceDescription)nodeInfo).getName();
        if (type.endsWith("ParameterHolder"))
        {       
            parameterSelection = ((RBNBBaseParameterHolder)nodeInfo).getName();
            DefaultMutableTreeNode probe = 
                (DefaultMutableTreeNode)(node.getParent().getParent());
            Object probeInfo = probe.getUserObject();
            String probeType = probeInfo.getClass().getName();
            if (probeType.endsWith("TemplateDescription"))
            {
                templateSelection =
                    ((TemplateDescription)probeInfo).getName();
            }
            else
            if (probeType.endsWith("InstanceDescription"))
            {
                instanceSelection =
                    ((InstanceDescription)probeInfo).getName();
            }
        }
/*      
        // determine which card
        if (label.startsWith("Connected") || label.startsWith("NeesPOP"))
            switchToCard(TOP_CARD);
        else
        if (label.equals("Channels") || type.endsWith("ChannelNodeCover"))
            switchToCard(CHANNEL_CARD);
        else
        if (label.equals("Links"))
            switchToCard(LINK_CARD);
        else
        if (parameterSelection != null)
            switchToCard(PARAMETER_CARD);
        else
        if (label.equals("Templates") || (templateSelection != null))
            switchToCard(TEMPLATE_CARD);
        else
        if (label.equals("Instances") || (instanceSelection != null))
            switchToCard(INSTANCE_CARD);
        else
            switchToCard(TOP_CARD);
*/      
        // determine which buttons to enable
        disableAllButtons();
        
        enableButton(Command.CLEAR_COMMAND);
        enableButton(Command.GET_METADATA);
        enableButton(Command.RESTART_COMMAND);
        enableButton(Command.TEST_COMMAND);
        enableButton(Command.REFRESH_TREE);

        if (label.equals("Links"))
        {
            enableButton(Command.ADD_LINK);
            enableButton(Command.REMOVE_LINK);
            enableButton(Command.FOCUS_TO_LINK);
        }
        else
        if ((instanceSelection != null) && (parameterSelection != null))
        {
            enableButton(Command.RESET_PARAMETER);
            enableButton(Command.SET_PARAMETER);
        }
        else
        if (templateSelection != null)
        {
            enableButton(Command.CREATE_INSTANCE);
        }
        else
        if (instanceSelection != null)
        {
            enableButton(Command.START_INSTANCE);
            enableButton(Command.STOP_INSTANCE);
            enableButton(Command.DELETE_INSTANCE);
        }
        
        // set text fileds      
        if (instanceSelection == null)
            instanceSelectionLabel.setText("No Instance Selected");
        else
            instanceSelectionLabel.setText(instanceSelection);

        if (templateSelection == null)
            templateSelectionLabel.setText("No Template Selected");
        else
            templateSelectionLabel.setText(templateSelection);

        if (parameterSelection == null)
            parameterSelectionLabel.setText("No Parameter Selected");
        else
        {
            if (instanceSelection != null)
                parameterSelectionLabel.setText(parameterSelection + " of " 
                + instanceSelection);
            else            
            if (templateSelection != null)
                parameterSelectionLabel.setText("Template Parameter Selected.");
        }
    }
    
    protected void log(String message)
    {
        System.out.println("Log: " + message);
        final String m = new String(message);
        if (displayPane != null)
        {
            displayPane.setText(displayPane.getText() + "\n" + m);
        }
    }

    private DefaultMutableTreeNode initObjectTree() {
        DefaultMutableTreeNode top;
        top = new DefaultMutableTreeNode("Connected to " + server);
        if (!sinkConnected)
            top = new DefaultMutableTreeNode("Not connected to " + server);
        top.add(createChannelNodes());
        if (metadata != null)
            top = metadata.insertIntoSwingTree(top);
        return top;
    }
    
    private DefaultMutableTreeNode createChannelNodes() {
        DefaultMutableTreeNode root
            = new DefaultMutableTreeNode(CHANNELS_TREE_LABEL);
        ChannelTree ct = latestChannelTree;
        if (ct == null)
        {
            root = new DefaultMutableTreeNode("No Channel Tree (refresh?)");
        }
        else
        {
            Iterator i = ct.rootIterator();
            while (i.hasNext())
            {
                ChannelTree.Node n = (ChannelTree.Node)i.next();
                if (n.getName().startsWith("_"))
                {
                    if (showHidden)
                        root.add(makeChannelNodes(n));
                }
                else
                    root.add(makeChannelNodes(n));
            }
        }
                
        return root;
    }
    
    private DefaultMutableTreeNode makeChannelNodes(ChannelTree.Node node)
    {
        DefaultMutableTreeNode root = new DefaultMutableTreeNode(new ChannelNodeCover(node));
        List l = node.getChildren();
        Iterator i = l.iterator();
        while (i.hasNext())
        {
            root.add(makeChannelNodes((ChannelTree.Node)i.next()));
        }

        return root; 
    }

    private class ChannelNodeCover
    {
        ChannelTree.Node node;
        
        ChannelNodeCover(ChannelTree.Node node)
        {
            this.node = node;
        }
        
        public String toString()
        {
            return node.getName();
        }
    }

} // Client
/*
 * $Header: /disks/cvs/neesgrid/turbine/src/org/nees/rbnb/Client.java,v 1.10 2004/07/22 18:50:27 hubbard Exp $
 */

---