Colony

import javax.swing.*;

import javax.swing.event.*;

import javax.imageio.*;

import java.awt.*;

import java.awt.image.*;

import java.awt.event.*;

import java.net.*;

import java.io.*;

import java.util.*;

/**

* The Colonet Graphical User Interface Applet for use locally and over an internet connection.

* @author Gregory Tress

*

* To generate javadoc on this file or other java files, use javadoc *.java -d doc, where doc

* is the name of the folder into which the files should be written.

*/

public class Colonet extends JApplet implements ActionListener, MouseInputListener, KeyListener {

        // Connection

        JTextField txtHost;

        JTextField txtPort;

        JButton btnConnect;

        JButton btnGetXBeeIDs;

        JLabel lblConnectionStatus;

        JTextArea txtInfo;

        JPanel panelConnect;

        JPanel panelServerInterface;

        Socket socket;

        DataUpdater dataUpdater;

        // Control

        JTabbedPane tabPaneControl;

        JPanel panelRobotControl;

        JPanel panelRobotDirection;

        JPanel panelRobotDirectionButtons;

        JPanel panelRobotCommands;

        JButton btnF, btnB, btnL, btnR, btnActivate;

        JLabel lblBattery;

        JLabel lblSelected;

        BatteryIcon batteryIcon;

        JPanel panelBattery;

        VectorController vectorController;

        BufferedImage imageVectorControl;

        JButton btnAssignID;

        JButton btnLocateStation;

        boolean setStation;

        ChargingStation station;

        boolean setWaypoint;

        int setWaypointID;

        JButton btnSetBounds;

        JButton btnClearBounds;

        RobotBoundary boundary;

        JButton btnCommand_MoveTo;

        JButton btnCommand_MoveAll;

        JButton btnCommand_StopTask;

        JButton btnCommand_ResumeTask;

        JButton btnCommand_ChargeNow;

        JButton btnCommand_StopCharging;

        // Task Manager

        JPanel panelTaskManager;

        JScrollPane spTaskManager;

        JPanel panelTaskManagerControls;

        JPanel panelTaskManagerControlsPriority;

        DefaultListModel taskListModel;

        JList taskList;

        JButton btnAddTask;

        JButton btnRemoveTask;

        JButton btnMoveTaskUp;

        JButton btnMoveTaskDown;

        JButton btnUpdateTasks;

        TaskAddWindow taskAddWindow;

        // Webcam

        WebcamPanel panelWebcam;

        GraphicsConfiguration gc;

        JTabbedPane tabPaneMain;

        WebcamLoader webcamLoader;

        // Robots

        volatile int selectedBot;         //the user has selected this bot graphically

        volatile RobotList robotIcons;         //contains boundary shapes around bots for click detection

        volatile int[] xbeeID;

        Colonet self = this;

        volatile ColonetServerInterface csi;

        public void init () {

                // Set the default look and feel

                String laf = ColonetConstants.LOOK_AND_FEEL;

                try {

                        UIManager.setLookAndFeel(laf);

                } catch (UnsupportedLookAndFeelException exc) {

                        System.err.println ("Warning: UnsupportedLookAndFeel: " + laf);

                } catch (Exception exc) {

                        System.err.println ("Error loading " + laf + ": " + exc);

                }

                // We should invoke and wait to avoid browser display difficulties

                Runnable r = new Runnable() {

                        public void run() {

                                createAndShowGUI();

                        }

                };

                try {

                        SwingUtilities.invokeAndWait(r);

                } catch (InterruptedException e) {

                        //Not really sure why we would be in this situation

                        System.out.println("InterruptedException in init: " + e);

                } catch (java.lang.reflect.InvocationTargetException e) {

                        //This could happen for various reasons if there is a problem in createAndShowGUI

                        e.printStackTrace();

                }

        }

        public void destroy () {

                if (csi != null) {

                        csi.disconnect();

                }

        }

        private synchronized void createAndShowGUI () {

                // Webcam

                gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();

                panelWebcam = new WebcamPanel();

                tabPaneMain = new JTabbedPane();

                tabPaneMain.setFont(new Font("arial", Font.PLAIN, 14));

                tabPaneMain.add(panelWebcam, "Webcam");

                // Robots

                selectedBot = -1;

                robotIcons = new RobotList();

                // Connection area

                txtInfo = new JTextArea();

                txtInfo.setBorder(BorderFactory.createTitledBorder("Info"));

                txtHost = new JTextField(this.getDocumentBase().getHost());

                txtHost.setBorder(BorderFactory.createTitledBorder("Host"));

                txtPort = new JTextField("10123");

                txtPort.setBorder(BorderFactory.createTitledBorder("Port"));

                btnConnect = new JButton("Connect");

                btnConnect.setFont(new Font("arial", Font.BOLD, 16));

                btnGetXBeeIDs = new JButton("Get XBee IDs");

                getRootPane().setDefaultButton(btnConnect);

                lblConnectionStatus = new JLabel("Status: Offline");

                panelConnect = new JPanel();

                panelConnect.setLayout(new GridLayout(6,1));

                panelConnect.add(lblConnectionStatus);

                panelConnect.add(txtHost);

                panelConnect.add(txtPort);

                panelConnect.add(btnConnect);

                panelServerInterface = new JPanel();

                panelServerInterface.setLayout(new GridLayout(2,1));

                panelServerInterface.add(panelConnect);

                panelServerInterface.add(txtInfo);

                // Robot direction panel

                panelRobotDirection = new JPanel();

                panelRobotDirectionButtons = new JPanel();

                Font f = new Font(null, Font.PLAIN, 16);

                btnF = new JButton("\u2191");

                btnF.setFont(f);

                btnB = new JButton("\u2193");

                btnB.setFont(f);

                btnL = new JButton("\u2190");

                btnL.setFont(f);

                btnR = new JButton("\u2192");

                btnR.setFont(f);

                btnActivate = new JButton("\u25A0");

                btnActivate.setFont(new Font(null, Font.BOLD, 24));

                panelRobotDirectionButtons.setLayout(new GridLayout(1,5));

                panelRobotDirectionButtons.add(btnActivate);

                panelRobotDirectionButtons.add(btnF);

                panelRobotDirectionButtons.add(btnB);

                panelRobotDirectionButtons.add(btnL);

                panelRobotDirectionButtons.add(btnR);

                imageVectorControl = gc.createCompatibleImage(ColonetConstants.VECTOR_CONTROLLER_WIDTH, ColonetConstants.VECTOR_CONTROLLER_HEIGHT);

                vectorController = new VectorController(imageVectorControl, self);

                panelRobotDirection.setLayout(new BorderLayout());

                panelRobotDirection.add(vectorController, BorderLayout.CENTER);

                panelRobotDirection.add(panelRobotDirectionButtons, BorderLayout.SOUTH);

                // Robot Control and Commands

                panelRobotCommands = new JPanel();

                panelRobotCommands.setLayout(new GridLayout(6,2));

                // Battery subset

                batteryIcon = new BatteryIcon(0);

                lblBattery = new JLabel(batteryIcon);

                lblSelected = new JLabel("None");

                // Management subset

                setStation = false;

                setWaypoint = false;

                setWaypointID = -1;

                btnAssignID = new JButton("Assign ID");

                btnLocateStation = new JButton("Identify Station");

                boundary = new RobotBoundary();

                btnSetBounds = new JButton("Set Boundary");

                btnClearBounds = new JButton("Clear Boundary");

                // Control subset

                btnCommand_MoveTo = new JButton("Move to ...");

                btnCommand_MoveAll = new JButton("Move all ...");

                btnCommand_StopTask = new JButton("Stop Current Task");

                btnCommand_ResumeTask = new JButton("Resume Current Task");

                btnCommand_ChargeNow = new JButton("Recharge Now");

                btnCommand_StopCharging = new JButton("Stop Recharging");

                panelRobotCommands.add(new JLabel("Battery Level: "));

                panelRobotCommands.add(lblBattery);

                panelRobotCommands.add(new JLabel("Selected Icon: "));

                panelRobotCommands.add(lblSelected);

                panelRobotCommands.add(btnAssignID);

    panelRobotCommands.add(btnLocateStation);

                panelRobotCommands.add(btnCommand_ChargeNow);

                panelRobotCommands.add(btnCommand_StopCharging);

                panelRobotCommands.add(btnSetBounds);

    panelRobotCommands.add(btnClearBounds);

                panelRobotCommands.add(btnCommand_MoveTo);

                panelRobotCommands.add(btnCommand_MoveAll);

                //panelRobotCommands.add(btnCommand_StopTask);

                //panelRobotCommands.add(btnCommand_ResumeTask);

                panelRobotControl = new JPanel();

                panelRobotControl.setLayout(new GridLayout(2,1));

                panelRobotControl.add(panelRobotDirection);

                panelRobotControl.add(panelRobotCommands);

                // Task Manager

                panelTaskManager = new JPanel();

                panelTaskManager.setLayout(new BorderLayout());

                taskListModel = new DefaultListModel();

                taskList = new JList(taskListModel);

                taskList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

                taskList.setSelectedIndex(0);

                spTaskManager = new JScrollPane(taskList);

                panelTaskManagerControls = new JPanel();

                panelTaskManagerControls.setLayout(new GridLayout(1,4));

                panelTaskManagerControlsPriority = new JPanel();

                panelTaskManagerControlsPriority.setLayout(new GridLayout(1,2));

                btnAddTask = new JButton("Add...");

                btnRemoveTask = new JButton("Remove");

                btnMoveTaskUp = new JButton("^");

                btnMoveTaskDown = new JButton("v");

                btnUpdateTasks = new JButton("Update");

                panelTaskManagerControlsPriority.add(btnMoveTaskUp);

                panelTaskManagerControlsPriority.add(btnMoveTaskDown);

                panelTaskManagerControls.add(btnAddTask);

                panelTaskManagerControls.add(btnRemoveTask);

                panelTaskManagerControls.add(btnUpdateTasks);

                panelTaskManagerControls.add(panelTaskManagerControlsPriority);

                panelTaskManager.add(spTaskManager, BorderLayout.CENTER);

                panelTaskManager.add(panelTaskManagerControls, BorderLayout.SOUTH);

                panelTaskManager.add(new JLabel("Current Task Queue"), BorderLayout.NORTH);

                taskAddWindow = new TaskAddWindow();

                // Main control mechanism

                tabPaneControl = new JTabbedPane(JTabbedPane.TOP);

                tabPaneControl.setFont(new Font("arial", Font.PLAIN, 14));

                tabPaneControl.setPreferredSize(new Dimension(ColonetConstants.VECTOR_CONTROLLER_WIDTH, 0));

                tabPaneControl.addTab("Connection", panelServerInterface);

                tabPaneControl.addTab("Robots", panelRobotControl);

                //tabPaneControl.addTab("Tasks", panelTaskManager);

                // Put all elements in the ContentPane

                this.getContentPane().setLayout(new BorderLayout());

                this.getContentPane().add(tabPaneMain, BorderLayout.CENTER);

                this.getContentPane().add(tabPaneControl, BorderLayout.EAST);

                this.setVisible(true);

                // Disable components before connecting

                btnConnect.setText("Connect");

    lblConnectionStatus.setText("Status: Disconnected");

    setComponentsEnabled(false);

                /* Add all listeners here */

                // Task Management

                btnAddTask.addActionListener(this);

                btnRemoveTask.addActionListener(this);

                btnMoveTaskUp.addActionListener(this);

                btnMoveTaskDown.addActionListener(this);

                btnUpdateTasks.addActionListener(this);

                // Robot Control

                btnF.addActionListener(this);

                btnB.addActionListener(this);

                btnL.addActionListener(this);

                btnR.addActionListener(this);

                btnF.addKeyListener(this);

                btnB.addKeyListener(this);

                btnL.addKeyListener(this);

                btnR.addKeyListener(this);

                btnActivate.addActionListener(this);

                btnActivate.addKeyListener(this);

                btnCommand_MoveTo.addActionListener(this);

                btnCommand_MoveAll.addActionListener(this);

                btnCommand_StopTask.addActionListener(this);

                btnCommand_ResumeTask.addActionListener(this);

                btnCommand_ChargeNow.addActionListener(this);

                btnCommand_StopCharging.addActionListener(this);

                // Other

                btnConnect.addActionListener(this);

                btnGetXBeeIDs.addActionListener(this);

                btnAssignID.addActionListener(this);

                btnLocateStation.addActionListener(this);

    btnSetBounds.addActionListener(this);

    btnClearBounds.addActionListener(this);

                panelWebcam.addMouseListener(this);

                panelWebcam.addMouseMotionListener(this);

        }

        public ColonetServerInterface getCSI () {

          return csi;

        }

        public void paint (Graphics g) {

                super.paint(g);

        }

        public void update (Graphics g) {

                paint(g);

        }

        /**

        * Gets the JTextArea used for displaying debugging information. 

        *

        * @return the JTextArea where debugging information can be displayed.

        */

        public JTextArea getInfoPanel () {

                return txtInfo;

        }

        /**

        * Parses a String containing BOM matrix information.

        * The ColonetServerInterface receives lines of the BOM matrix.        (For encoding

        * information, see the ColonetServerInterface documentation.)         The entire matrix is passed

        * to the client when requested. This method takes a string of the form

        * "[command code] [command code] [number of robots] [data0] [data1] ..."

        * with tokens separated by spaces and containing no brackets.

        * The [command code]s are predefined values identifying this String as a BOM data

        * String, [number of robots] is an integer, and the values that follow are

        * the sensor readings of the robots in order, starting with robot 0.        Only [number of robots]^2

        * data entries will be read.        The matrix values are saved locally until the next String is parsed.

        *

        *

        * @param line the String containing BOM matrix information.

        * @throws ArrayIndexOutOfBoundsException if there are fewer than [number of robots]^2 data entries in the String

        */

        public void parseMatrix (String line) {

                txtInfo.setText("");

                String [] str = line.split(" ");

                int num = Integer.parseInt(str[2]);

                for (int i = 0; i < num; i++) {

                        for (int j = 0; j < num; j++) {

                                String next = str[3 + i*num + j];

                                if (next.equals("-1")) {

                                        txtInfo.append("-");

                                } else {

                                        txtInfo.append(next);

                                }

                                if (j < num - 1) {

                                        txtInfo.append(" ");

                                }

                        }

                        if (i < num - 1) {

                                txtInfo.append("\n");

                        }

                }

                repaint();

        }

        public void connect () {

    if (csi != null)

      return;

    csi = new ColonetServerInterface(self);

    csi.connect(txtHost.getText(), txtPort.getText());

    if (!csi.isReady()) {

      csi = null;

      return;

    }

    webcamLoader = new WebcamLoader(self);

    dataUpdater = new DataUpdater();

    dataUpdater.start();

    webcamLoader.start();

    Runnable r = new Runnable() {

      public void run () {

        btnConnect.setText("Disconnect");

        lblConnectionStatus.setText("Status: Connected");

        setComponentsEnabled(true);

      }

    };

    SwingUtilities.invokeLater(r);

        }

        public void disconnect () {

    try {

        dataUpdater.interrupt();

    } catch (Exception e) {

    }

    csi = null;

                Runnable r = new Runnable() {

      public void run () {

                    btnConnect.setText("Connect");

              lblConnectionStatus.setText("Status: Disconnected");

        setComponentsEnabled(false);

        boundary = null;

        station = null;

            }

                };

                SwingUtilities.invokeLater(r);

        }

        private void setComponentsEnabled (boolean enabled) {

    btnF.setEnabled(enabled);

    btnB.setEnabled(enabled);

    btnL.setEnabled(enabled);

    btnR.setEnabled(enabled);

    btnActivate.setEnabled(enabled);

    btnAssignID.setEnabled(enabled);

    btnLocateStation.setEnabled(enabled);

    btnSetBounds.setEnabled(enabled);

    btnClearBounds.setEnabled(enabled);

    btnCommand_ChargeNow.setEnabled(enabled);

    btnCommand_StopCharging.setEnabled(enabled);

    btnCommand_MoveTo.setEnabled(enabled);

    btnCommand_MoveAll.setEnabled(enabled);

        }

        /**

        * Parses a String containing a task queue update.

        * Format is currently not specified.

        * This method currently does nothing.

        *

        * @param line the String containing task queue update information.

        */

        public void parseQueue (String line) {

        }

        /**

        * Parses a String containing XBee ID values.

        * The ColonetServerInterface receives Strings of XBee information.        (For encoding

        * information, see the ColonetServerInterface documentation.)         This method takes

        * a string of the form "[command code] [command code] [number of robots] [id0] [id1] ..."

        * with tokens separated by spaces and containing no brackets.

        * The [command code]s are predefined values identifying this String as an XBee

        * ID String, [number of robots] is an integer, and the values that follow are

        * the IDs of the robots in order, starting with robot 0.        Only [number of robots]

        * will be read.         The ID values are saved locally until the next String is parsed.

        * The purpose of having this list is to ensure that robots are properly identified for control purposes.

        * This keeps robot identification consistent between sessions and prevents arbitrary assignment.

        *

        * @param line the String containing XBee ID information.

        * @throws ArrayIndexOutOfBoundsException if there are fewer than [number of robots] IDs in the String

        * @see ColonetServerInterface#sendXBeeIDRequest()

        */

        public void parseXBeeIDs (String line) {

                String [] str = line.split(" ");

                int num = Integer.parseInt(str[2]);

                xbeeID = new int[num];

                for (int i = 0; i < num; i++) {

                        xbeeID[i] = Integer.parseInt(str[i+3]);

                }

        }

        /**

        * Parses a String containing battery information.

        * The ColonetServerInterface receives Strings of battery information.         (For encoding

        * information, see the ColonetServerInterface documentation.)         This method takes

        * a string of the form "[command code] [command code] [robot ID] [value]"

        * with tokens separated by spaces and containing no brackets.

        * The [command code]s are predefined values identifying this String as a battery

        * information String, [robot ID] is an integer, and [value] is a battery measurement.

        * This updates the batery information for a single robot.

        *

        *

        * @param line the String containing battery information.

        * @see ColonetServerInterface#sendBatteryRequest(int)

        */

        public void parseBattery (String line) {

          int botNum, level;

          try {

                    String [] str = line.split(" ");

                    botNum = Integer.parseInt(str[2]);

                    level = Integer.parseInt(str[3]);

                } catch (NumberFormatException e) {

                    System.out.println("Could not parse battery update");

                    return;

                }

                RobotIcon r = robotIcons.get(botNum);

                if (r != null) {

                    r.setBattery(batteryIcon.convert(level));  // set contextual battery meter

                    batteryIcon.setLevel(level);             // set solo battery meter

                }

                super.repaint();

        }

        /**

        * Parses a String containing visual robot position information along with

        * canonical ID assignments.

        */

        public void parsePositions (String line) {

                String [] str = line.split(" ");

                RobotList newList = new RobotList();

                for (int i = 2; i < str.length; i+=3) {

                        int id = Integer.parseInt(str[i]);

                        int x = Integer.parseInt(str[i+1]);

                        int y = Integer.parseInt(str[i+2]);

                        RobotIcon newIcon = new RobotIcon(id, x, y);

                        // Save previous robot information

                        RobotIcon oldIcon = robotIcons.get(id);

                        if (oldIcon != null) {

                    newIcon.setBattery(oldIcon.getBattery());

                                newIcon.setDestination(oldIcon.getDestination());

                        }

                        if (newIcon.getID() >= 0) {

                                newIcon.setColor(Color.GREEN);

                        }

                        newList.put(id, newIcon);

                }

                robotIcons = newList;

                repaint();

        }

  /**

    * Parses a message that indicates a robot has reached its destination

   */

  public void parseMoveUpdate (String line) {

    System.out.println("Got move update: " + line);

    String [] str = line.split(" ");

    int id = Integer.parseInt(str[1]);

    robotIcons.get(id).clearDestination();

  }

        /**

        * Set the ID of the selected robot

        */

        public void setSelectedBot (int id) {

            this.selectedBot = id;

        }

        /**

        * Returns the ID of the selected robot

        */

        public int getSelectedBot () {

            return this.selectedBot;

        }

        //

        // MouseListener methods

        //

        public void mousePressed(MouseEvent e) {

                //Start a new Thread to handle the MouseEvent

                (new MouseHandler(e)).start();

        }

        public void mouseExited(MouseEvent e) {

        }

        public void mouseEntered(MouseEvent e) {

        }

        public void mouseReleased(MouseEvent e) {

    (new MouseHandler(e)).start();

        }

        public void mouseClicked(MouseEvent e) {

        }

        public void mouseDragged(MouseEvent e) {

    (new MouseHandler(e)).start();

        }

        public void mouseMoved(MouseEvent e) {

        }

        //

        // KeyListener methods

        //

        public void keyPressed (KeyEvent e) {

                //Start a new Thread to handle the KeyEvent

                (new KeyHandler(e)).start();

                repaint();

        }

        public void keyReleased (KeyEvent e) {

        }

        public void keyTyped (KeyEvent e) {

        }

        //

        // ActionListener method

        //

        public void actionPerformed (ActionEvent e) {

                // Start a new Thread to handle the ActionEvent

                (new ActionHandler(e)).start();

                repaint();

        }

        class MouseHandler extends Thread {

                MouseEvent e;

                public MouseHandler (MouseEvent event) {

                        super("MouseHandler");

                        this.e = event;

                }

                public void run () {

                        Point pt = panelWebcam.convertClick(e);

                        // If we are selecting a waypoint (destination) for a specific bot

                        if (setWaypoint && setWaypointID >= 0 && e.getID() == MouseEvent.MOUSE_PRESSED) {

                          // If the user clicks outside the boundary, do nothing

                          if (boundary.isActive() && !boundary.contains(e.getX(), e.getY())) {

                            return;

                          }

                                setWaypoint = false;

                                panelWebcam.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                                if (selectedBot < 0) {

                                        return;

                                }

                                RobotIcon r = robotIcons.get(selectedBot);

                                if (r != null) {

                                        r.setDestination(pt);

                                        if (csi != null) {

                                                csi.sendAbsoluteMove(r.getID(), pt.x, pt.y);

                                        }

                                }

                                return;

                        }

                        // If we are ordering a charge (right-click on a station)

                        if ((e.getButton() == MouseEvent.BUTTON2 || e.getButton() == MouseEvent.BUTTON3)  

          && e.getID() == MouseEvent.MOUSE_PRESSED

          && station != null && station.contains(e.getX(), e.getY())) {

        if (selectedBot >= 0) {

          RobotIcon r = robotIcons.get(selectedBot);

          if (r != null) {

            Point p = panelWebcam.convertPoint(station.getX(), station.getY());

            r.setDestination(p);

          }

          csi.sendRecharge(selectedBot);

        }

                                return;

                        }

                        // Right-click also means we are moving a robot

                        if ((e.getButton() == MouseEvent.BUTTON2 || e.getButton() == MouseEvent.BUTTON3)  

          && e.getID() == MouseEvent.MOUSE_PRESSED) {

        // If the user clicks outside the boundary, do nothing

                          if (boundary.isActive() && !boundary.contains(e.getX(), e.getY())) {

                            return;

                          }

                                if (selectedBot < 0) {

                                        return;

                                }

                                RobotIcon r = robotIcons.get(selectedBot);

                                if (r != null) {

                                        r.setDestination(pt);

                                        if (csi != null) {

                                                csi.sendAbsoluteMove(r.getID(), pt.x, pt.y);

                                        }

                                }

                                return;

                        }

                        // If we are setting all waypoints

                        if (setWaypoint && e.getID() == MouseEvent.MOUSE_PRESSED) {

                          // If the user clicks outside the boundary, do nothing

                          if (boundary.isActive() && !boundary.contains(e.getX(), e.getY())) {

                            return;

                          }

                                setWaypoint = false;

                                panelWebcam.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                                for (Map.Entry<Integer,RobotIcon> entry : robotIcons.entrySet()) {

                                        RobotIcon r = entry.getValue();

                                        r.setDestination(pt);

          //TODO: send absolute move commands

                                }

                                return;

                        }

      // If we are drawing a boundary rectangle

      if (boundary != null && boundary.isSetting()) {

        // Begin 

        if (e.getID() == MouseEvent.MOUSE_PRESSED) {

          boundary.panel_p1 = new Point(e.getX(), e.getY());

          boundary.panel_p2 = new Point(e.getX(), e.getY());

          boundary.img_p1 = new Point(pt.x, pt.y);

        }

        // Resize

        else if (e.getID() == MouseEvent.MOUSE_DRAGGED){

          boundary.panel_p2 = new Point(e.getX(), e.getY());

        }

        // Finish

        else if (e.getID() == MouseEvent.MOUSE_RELEASED){

          boundary.panel_p2 = new Point(e.getX(), e.getY());

          boundary.img_p2 = new Point(pt.x, pt.y);

          panelWebcam.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

          boundary.set = false;

          boundary.active = true;

          boundary.sendToServer();

        }

        return;

      }

      // If we are locating a charging station

      if (setStation) {

        setStation = false;

        station = new ChargingStation(e.getX(), e.getY());

        station.setActive(true);

        return;

      }

                        // Otherwise, we are selecting a bot, or doing nothing

                        RobotIcon r = robotIcons.getBoundingIcon(pt);

      if (r != null)

        selectedBot = r.getID();

                }

        }

        class KeyHandler extends Thread {

                KeyEvent e;

                public KeyHandler (KeyEvent event) {

                        super("KeyHandler");

                        this.e = event;

                }

                public void run () {

                        int code = e.getKeyCode();

                        if (code == KeyEvent.VK_UP) {

                                vectorController.setMaxForward();

                                vectorController.sendToServer();

                        } else if (code == KeyEvent.VK_DOWN) {

                                vectorController.setMaxReverse();

                                vectorController.sendToServer();

                        } else if (code == KeyEvent.VK_LEFT) {

                                vectorController.setMaxLeft();

                                vectorController.sendToServer();

                        } else if (code == KeyEvent.VK_RIGHT) {

                                vectorController.setMaxRight();

                                vectorController.sendToServer();

                        } else if (code == KeyEvent.VK_S) {

                                vectorController.setZero();

                                vectorController.sendToServer();

                        }

                }

        }

        class ActionHandler extends Thread {

                ActionEvent e;

                public ActionHandler (ActionEvent event) {

                        super("ActionHandler");

                        this.e = event;

                }

                public void run () {

                        Object source = e.getSource();

                        // General Actions

                        if (source == btnConnect) {

                                if (csi == null) {

                                        connect();

                                } else {

                                        disconnect();

                                }

                        } else if (source == btnGetXBeeIDs) {

                                csi.sendXBeeIDRequest();

                        } else if (source == btnAssignID) {

                                String message;

                                if (selectedBot < 0) {

                                        message = "That robot is unidentified. Please specify its ID.";

                                } else {

                                        message = "That robot has ID " + selectedBot + ". You may reassign it now.";

                                }

                                String result = JOptionPane.showInputDialog(self, message, "Robot Identification", JOptionPane.QUESTION_MESSAGE);

                                if (result == null) {

                                        return;

                                }

                                int newID = -1;

                                try {

                                        newID = Integer.parseInt(result);

                                } catch (Exception ex) {

                                        csi.warn("Invalid ID.");

                                        return;

                                }

                                // Assign new ID and update display

                                if (csi != null) {

                                        csi.sendIDAssignment(selectedBot, newID);

                                }

                                selectedBot = newID;

                                lblSelected.setText("" + newID);

                  } else if (source == btnLocateStation) {

                    setStation = true;

                        } else if (source == btnF) { // Robot Movement Controls

                                vectorController.setMaxForward();

                                vectorController.sendToServer();

                                robotIcons.get(selectedBot).clearDestination();

                        } else if (source == btnB) {

                                vectorController.setMaxReverse();

                                vectorController.sendToServer();

                                robotIcons.get(selectedBot).clearDestination();

                        } else if (source == btnL) {

                                vectorController.setMaxLeft();

                                vectorController.sendToServer();

                                robotIcons.get(selectedBot).clearDestination();

                        } else if (source == btnR) {

                                vectorController.setMaxRight();

                                vectorController.sendToServer();

                                robotIcons.get(selectedBot).clearDestination();

                        } else if (source == btnActivate) {

                                vectorController.setZero();

                                vectorController.sendToServer();

                                robotIcons.get(selectedBot).clearDestination();

      } else if (source == btnSetBounds) {

        boundary.set = true;

        panelWebcam.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));

      } else if (source == btnClearBounds) {

        boundary.active = false;

        boundary.set = false;

        boundary.img_p1 = new Point(-1, -1);

        boundary.img_p2 = new Point(-1, -1);

        boundary.panel_p1 = new Point(-1, -1);

        boundary.panel_p2 = new Point(-1, -1);

        boundary.sendToServer();

                        } else if (source == btnCommand_MoveTo) {

                                if (selectedBot < 0) {

                                        return;

                                }

                                panelWebcam.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));

                                setWaypoint = true;

                                setWaypointID = selectedBot;

                        } else if (source == btnCommand_MoveAll) {

                                panelWebcam.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));

                                setWaypoint = true;

                                setWaypointID = -1;

                        } else if (source == btnCommand_StopTask) {

                        } else if (source == btnCommand_ResumeTask) {

                        } else if (source == btnCommand_ChargeNow) {

                          if (selectedBot >= 0)

                            csi.sendRecharge(selectedBot);

                          else

          csi.sendRecharge(2);

                        } else if (source == btnCommand_StopCharging) {

                          if (selectedBot >= 0) {

                            robotIcons.get(selectedBot).clearDestination();

                            csi.sendRechargeStop(selectedBot);

                          } else {

                            robotIcons.get(2).clearDestination();

          csi.sendRechargeStop(2);

        }

                        } else if (source == btnAddTask) { // Queue Management

                                taskAddWindow.prompt();

                        } else if (source == btnRemoveTask) {

                                if (taskList.getSelectedIndex() >= 0) {

                                        csi.sendQueueRemove(taskList.getSelectedIndex());

                                }

                                csi.sendQueueUpdate();

                        } else if (source == btnMoveTaskUp) {

                                csi.sendQueueReorder(taskList.getSelectedIndex(), taskList.getSelectedIndex() - 1);

                                csi.sendQueueUpdate();

                        } else if (source == btnMoveTaskDown) {

                                csi.sendQueueReorder(taskList.getSelectedIndex(), taskList.getSelectedIndex() + 1);

                                csi.sendQueueUpdate();

                        } else if (source == btnUpdateTasks) {

                                csi.sendQueueUpdate();

                        }

                }

        }

        /*

        * DataUpdater thread.

        *        The purpose of this thread is to request data from the server at regular intervals.

        *        Types of data requested: XBee IDs, robot positions, battery levels.

        *

        */

        class DataUpdater extends Thread {

                final int DATAUPDATER_DELAY = 500;

                int count;

                public DataUpdater () {

                        super("Colonet DataUpdater");

                        count = 0;

                }

                public synchronized void run () {

                        while (true) {

                                try {

                                        if (csi != null && csi.isReady()) {

                                                // XBee ID Request

                                                if (count % 5 == 0) {

                                                        csi.sendXBeeIDRequest();

                                                }

                                                // Robot Position Request

                                                if (count % 1 == 0) {

                                                        csi.sendPositionRequest();

                                                }

                                                // Battery Request

                                                if (count % 30 == 0) {

                                                        for (Map.Entry<Integer,RobotIcon> entry : robotIcons.entrySet()) {

                                                                RobotIcon r = entry.getValue();

                                                                        int id = r.getID();

                                                                                if (id >= 0) {

                                                                                csi.sendBatteryRequest(id);

                                                                        }

                                                        }

                                                }

                                        }

                                        count++;

                                        if (count > 1000)

                                                count = 0;

                                        Thread.sleep(DATAUPDATER_DELAY);

                                } catch (InterruptedException e) {

                                        return;

                                } catch (NullPointerException e) {

                                    // This probably indicates that an object was destroyed by shutdown.

                                    return;

                                }

                        }

                }

        }

        /*

        * WebcamPanel class

        * Contains the webcam image

        */

        class WebcamPanel extends JPanel {

                volatile BufferedImage img;

                BufferedImage buffer;

                public WebcamPanel () {

                        super(true);

                }

                public synchronized void setImage (BufferedImage newimg) {

                        if (img != null) {

                                img.flush();

                        }

                        System.gc();

                        img = newimg;

                        repaint();

                }

                public synchronized void paint (Graphics g) {

                        if (img == null) {

                                return;

                        }

                        // Calculate scaling

                        int maxWidth = getWidth() - 2*ColonetConstants.WEBCAM_BORDER;

                        int maxHeight = getHeight() - 2*ColonetConstants.WEBCAM_BORDER;

                        double widthRatio = 1.0 * maxWidth / img.getWidth();

                        double heightRatio = 1.0 * maxHeight / img.getHeight();

                        double scale = 0;

                        int newWidth = 0;

                        int newHeight = 0;

                        int x = 0;

                        int y = 0;

                        if (widthRatio > heightRatio) {         //height is the limiting factor

                                scale = heightRatio;

                                newHeight = maxHeight;

                                newWidth = (int) (img.getWidth() * scale);

                                y = ColonetConstants.WEBCAM_BORDER;

                                x = (maxWidth - newWidth) / 2 + ColonetConstants.WEBCAM_BORDER;

                        } else {        //width is the limiting factor

                                scale = widthRatio;

                                newWidth = maxWidth;

                                newHeight = (int) (img.getHeight() * scale);

                                x = ColonetConstants.WEBCAM_BORDER;

                                y = (maxHeight - newHeight) / 2 + ColonetConstants.WEBCAM_BORDER;

                        }

                        // Draw image onto the buffer

                        buffer = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);

                        Graphics2D bufferedGraphics = (Graphics2D)buffer.getGraphics();

                        bufferedGraphics.setColor(Color.GRAY);

                        bufferedGraphics.fillRect(0, 0, this.getWidth(), this.getHeight());

                        Image imgScaled = img.getScaledInstance(newWidth, newHeight, Image.SCALE_FAST);

                        bufferedGraphics.drawImage(imgScaled, x, y, this);

      // Draw boundary

      if (boundary != null && (boundary.isSetting() || boundary.isActive())) {

         bufferedGraphics.setColor(Color.BLUE);

         int width = boundary.panel_p2.x - boundary.panel_p1.x;

         int height = boundary.panel_p2.y - boundary.panel_p1.y;

         bufferedGraphics.drawRect(boundary.panel_p1.x, boundary.panel_p1.y, width, height);

      }

      // Draw charging station

      if (station != null && station.isActive()) {

        bufferedGraphics.setStroke(new BasicStroke(2));

        bufferedGraphics.setColor(Color.ORANGE);

        int width = ColonetConstants.STATION_SIZE;

        bufferedGraphics.drawRect(station.getX() - width/2, station.getY() - width/2, width, width);

      }

                        // Draw Identifiers and battery levels

                        if (robotIcons != null) {

                                bufferedGraphics.setStroke(new BasicStroke(2));

                                for (Map.Entry<Integer,RobotIcon> entry : robotIcons.entrySet()) {

                                        RobotIcon r = entry.getValue();

                                        bufferedGraphics.setColor(r.getColor());

                                        // Identifier circle

                                        int px = (int) (x + r.getLocation().x * scale);

                                        int py = (int) (y + r.getLocation().y * scale);

                                        int radius = ColonetConstants.ROBOT_RADIUS;

                                        bufferedGraphics.drawOval(px-radius, py-radius, 2*radius, 2*radius);

                                        // ID, if applicable

                                        if (r.getID() > 0) {

                                            bufferedGraphics.setFont(new Font("arial", Font.PLAIN, 36));

                                            bufferedGraphics.drawString("" + r.getID(), px-10, py+10);

                                        }

                                        // Battery

                                        if (r.getBattery() >= 0) {

                                            int pixels = r.getBattery() * ColonetConstants.BATTERY_WIDTH / 100;

                                                if (r.getBattery() > 50)

                                                    bufferedGraphics.setColor(Color.GREEN);

                                                else if (r.getBattery() > 25)

                                                    bufferedGraphics.setColor(Color.YELLOW);

                                                else

                                                    bufferedGraphics.setColor(Color.RED);

                                                bufferedGraphics.fillRect(px+20, py+20, pixels, ColonetConstants.BATTERY_HEIGHT);

                                                bufferedGraphics.setColor(Color.BLACK);

                                                bufferedGraphics.drawRect(px+20, py+20, ColonetConstants.BATTERY_WIDTH, ColonetConstants.BATTERY_HEIGHT);

                                        }

                                        // If the robot has a destination, draw the vector

                                        if (r.hasDestination()) {

                                                bufferedGraphics.drawLine(px, py, (int)(x + r.getDestination().x * scale), (int)(y + r.getDestination().y * scale));

                                        }

                                }

                        }

                        // Identify currently-selected robot

                        RobotIcon r = robotIcons.get(selectedBot);

                        if (r != null) {

                                int px = (int) (x + r.getLocation().x * scale);

                                int py = (int) (y + r.getLocation().y * scale);

                                int radius = ColonetConstants.ROBOT_RADIUS;

                                bufferedGraphics.setColor(Color.BLACK);

                                bufferedGraphics.drawOval(px-radius-6, py-radius-6, 2*radius+12, 2*radius+12);

                        }

                        //Display buffered content

                        g.drawImage(buffer, 0, 0, this);

                }

                /**

                * Convert a click on the webcam panel to a coordinate that is consistent with the

                * original size of the image that the panel contains.

                */

                public Point convertClick (MouseEvent e) {

                        if (img == null) {

                                return new Point(e.getX(), e.getY());

                        }

                        return convertPoint(e.getX(), e.getY());

                }

                /**

                * Convert a point on the webcam panel to a coordinate that is consistent with the

                * original size of the image that the panel contains.

                */

                public Point convertPoint (int panelx, int panely) {

                        // Calculate scaling

                        int border = ColonetConstants.WEBCAM_BORDER;

                        int clickx = panelx;

                        int clicky = panely;

                        int maxWidth = getWidth() - 2*border;

                        int maxHeight = getHeight() - 2*border;

                        double widthRatio = 1.0 * maxWidth / img.getWidth();

                        double heightRatio = 1.0 * maxHeight / img.getHeight();

                        double scale = 0;

                        int newWidth = 0;

                        int newHeight = 0;

                        int px = 0;

                        int py = 0;

                        if (widthRatio > heightRatio) {         //height is the limiting factor

                                scale = heightRatio;

                                newHeight = maxHeight;

                                newWidth = (int) (img.getWidth() * scale);

                                py = clicky - border;

                                px = clickx - border - (maxWidth - newWidth) / 2;

                        } else {        //width is the limiting factor

                                scale = widthRatio;

                                newWidth = maxWidth;

                                newHeight = (int) (img.getHeight() * scale);

                                px = clickx - border;

                                py = clicky - border - (maxHeight - newHeight) / 2;

                        }

                        py = (int) (py / scale);

                        px = (int) (px / scale);

                        return new Point(px, py);

                }

        }

        /*

        * WebcamLoader class

        * Handles the loading of the webcam image.

        */

        class WebcamLoader extends Thread

        {

                URL imagePath;

                MediaTracker mt;

                BufferedImage image;

                Random rand;

                public WebcamLoader (JApplet applet)

                {

                        super("ColonetWebcamLoader");

                        mt = new MediaTracker(applet);

                        ImageIO.setUseCache(false);

                        rand = new Random();

                }

                public void run ()

                {

                        while (true) {

                                try {

                                        Thread.sleep(ColonetConstants.WEBCAM_DELAY);

                                        if (image != null)

                                                image.flush();

                                        System.gc();

                                        try {

                                                imagePath = new URL(ColonetConstants.WEBCAM_PATH + "?rand=" + rand.nextInt(100000));

                                        } catch (MalformedURLException e) {

                                                System.out.println("Malformed URL: could not form URL from: [" + ColonetConstants.WEBCAM_PATH + "]\n");

                                        }

                                        image = ImageIO.read(imagePath);

                                        // The MediaTracker waitForID pauses the thread until the image is loaded.

                                        // We don't want to display a half-downloaded image.

                                        mt.addImage(image, 1);

                                        while(!mt.checkID(1))

                                                Thread.sleep(20);

                                        mt.removeImage(image);

                                        // Save

                                        panelWebcam.setImage(image);

                                } catch (InterruptedException e) {

                                        return;

                                } catch (java.security.AccessControlException e) {

                                        csi.warn("Could not load webcam.\n" + e);

                                        return;

                                } catch (IOException e) {

                                        getInfoPanel().append("IOException while trying to load image.");

                                }

                        }

                }

        }

  class RobotBoundary {

    public volatile boolean active, set;

    public volatile Point img_p1, img_p2;

    public volatile Point panel_p1, panel_p2;

    public RobotBoundary () {

      active = false;

      set = false;

      img_p1 = new Point(-1,-1);

      img_p2 = new Point(-1,-1);

      panel_p1 = new Point(-1,-1); 

      panel_p2 = new Point(-1,-1);

    }

    public void sendToServer () {

      if (csi != null) {

        if (img_p1.x == -1 || img_p1.y == -1)

          csi.sendBoundaryClear();

        else

          csi.sendBoundary(img_p1.x, img_p1.y, img_p2.x, img_p2.y);

      }

    }

    public boolean isActive () {

      return active;

    }

    public boolean isSetting () {

      return set;

    }

    /**

    *  Returns a Rectangle designating the active area 

    *  in the coordinate system of the JPanel.

    *  Returns null if the boundary is not active.

    */

    public Rectangle toRectangle () {

      if (!active)

        return null;

      return new Rectangle (panel_p1.x, panel_p1.y, (panel_p2.x-panel_p1.x), (panel_p2.y-panel_p1.y));

    }

    /** 

    *  Determines whether a coordinate in the coordinate

    *  system of the JPanel is contained within the boundary.

    *  If the boundary is not active, then this method 

    *  returns false.

    */

    public boolean contains (int px, int py) {

      Rectangle rect = this.toRectangle();

      if (rect == null || !this.active)

        return false;

      return rect.contains(px, py);

    }

  }

  class ChargingStation {

    private int x, y;

    private boolean active;

    public ChargingStation () {

      super();

    }

    public ChargingStation (int x, int y) {

      this();

      setLocation(x, y);

    }

    public int getX () {

      return x;

    }

    public int getY () {

      return y;

    }

    /**

    *  Sets the center of the charging station to

    *  the specified coordinate point.

    */

    public void setLocation (int x, int y) {

      this.x = x;

      this.y = y;

    }

    public boolean isActive () {

      return active;

    }

    public void setActive (boolean status) {

      this.active = status;

    }

    /**

    *  Determines whether a coordinate is contained within

    *  the graphical area of the charging station.

    *  Returns false if the charging station is not active.

    */