Colony

	SelectionIndicator indicator;

		try { indicator.interrupt(); } catch (Exception e) { }

		txtMatrix.setBorder(BorderFactory.createTitledBorder("Input Matrix"));

		// Set up animation threads

		indicator = new SelectionIndicator(canvas);

		indicator.setRadius(RADIUS+3, 15);  //a tad more than the bot radius

		try { indicator.interrupt(); } catch (Exception e) { }

	public void mousePressed(MouseEvent e) {

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

	    if (setWaypoint && setWaypointID  >= 0) {

	        setWaypoint = false;

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

	        if (selectedBot < 0)

	            return;

	        RobotIcon r = robotIcons.get(selectedBot);

	        r.destx = e.getX();

	        r.desty = e.getY();

	        if (csi != null)

	            csi.sendAbsoluteMove(r.id, r.destx, r.desty);

	        return;

	    }

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

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

	        if (selectedBot < 0)

	            return;

	        RobotIcon r = robotIcons.get(selectedBot);

	        r.destx = e.getX();

	        r.desty = e.getY();

	        if (csi != null)

	            csi.sendAbsoluteMove(r.id, r.destx, r.desty);

	        return;

	    }

	    // If we are setting all waypoints

	    if (setWaypoint) {

	        setWaypoint = false;

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

	        for (int i = 0; i < robotIcons.size(); i++) {

	            RobotIcon r = robotIcons.get(i);

	            r.destx = e.getX();

	            r.desty = e.getY();

	        }

	        return;

	    }

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

		for (int i = 0; i < robotIcons.size(); i++) {

		    RobotIcon r = robotIcons.get(i);

		    if (r.contains(e.getX(), e.getY())) {

		        selectedBot = i;

		        lblSelected.setText(" " + r.id);

		    }

		}

		repaint();

	}

		Object source = e.getSource();

		// General Actions

		if (source == btnConnect) {

			connect();

		} else if (source == btnGetXBeeIDs) {

			csi.sendXBeeIDRequest();

		} else if (source == btnAssignID) {

		    String message;

		    if (selectedBot < 0)

		        return;

		    int curID = robotIcons.get(selectedBot).id;

		    if (curID < 0)

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

		    else

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

		    String result = JOptionPane.showInputDialog(this, 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  

			csi.sendIDAssignment(curID, newID);

		    robotIcons.get(selectedBot).id = newID;

		    robotIcons.get(selectedBot).color = Color.GREEN;

		    lblSelected.setText(" " + newID);

		}

		// Robot Movement Controls

		else if (source == btnF) {

			vectorController.setMaxForward();

			vectorController.sendToServer();

		} else if (source == btnB) {

			vectorController.setMaxReverse();

			vectorController.sendToServer();

		} else if (source == btnL) {

			vectorController.setMaxLeft();

			vectorController.sendToServer();

		} else if (source == btnR) {

			vectorController.setMaxRight();

			vectorController.sendToServer();

		} else if (source == btnActivate) {

			vectorController.setZero();

			vectorController.sendToServer();

		}

		// Robot Commands (non-movement)

		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) {

		} else if (source == btnCommand_StopCharging) {

		}

		// Queue Management

		else if (source == btnAddTask) {

			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();

		}

	/*

	*	SelectionIndicator thread.

	*	Graphical representation of the selection marker

	*

	*	step() and draw() are synchronized methods. step() is private and 

	*	used to update the position of the crosshairs. draw() is called 

	*	externally and should only run if all calculations in step() have

	*	been completed.

	*/

	private class SelectionIndicator extends Thread {

		final int INDICATOR_DELAY = 180;

		final double DTHETA = 0.4;    //larger values make the marker rotate faster

		Graphics2D g;   //canvas to draw on

		boolean running;

		int sx, sy;		//center

		int r, dr;		//radius and width of marker

		double theta;   //current angle

		volatile Polygon poly1, poly2, poly3, poly4;

		int px1, py1;

		int rx1, ry1;

		int px2, py2;

		int rx2, ry2;

		int px3, py3;

		int rx3, ry3;

		int px4, py4;

		int rx4, ry4;

		int steps;

		public SelectionIndicator (Graphics2D g) {

			super("SelectionIndicator");

			this.g = g;

			running = false;

			steps = 0;

			theta = 0;

			rx1 = 0; ry1 = 0;

			px1 = 0; py1 = 0;

			rx2 = 0; ry2 = 0;

			px2 = 0; py2 = 0;

			rx3 = 0; ry3 = 0;

			px3 = 0; py3 = 0;

			rx4 = 0; ry4 = 0;

			px4 = 0; py4 = 0;

		}

		public synchronized void setCenter (int sx, int sy) {

			if (sx == this.sx && sy == this.sy) return;

			this.sx = sx;

			this.sy = sy;

			steps = 0;

		}

		public synchronized void setRadius (int r, int dr) {

			this.r = r;

			this.dr = dr;

			steps = 0;

		}

		public void run () {

			running = true;

			while (running) {

				step();

				try { 

					Thread.sleep(INDICATOR_DELAY);

				} catch (InterruptedException e) {

					running = false;

					return;

				}

			}

		}

		private synchronized void step () {

			Polygon poly1_new = new Polygon();

			Polygon poly2_new = new Polygon();

			Polygon poly3_new = new Polygon();

			Polygon poly4_new = new Polygon();

			//the step

			theta = (theta + DTHETA/Math.PI) % (Math.PI);

			//the calculation

			//let p be the point of the pointy thing toward the center

			//let r be the point at the opposite side

			//recalculate radius, if it will look cool, lolz

			int newr = r;

			if (steps < 100)

			newr = (int)( r + 200/(steps+1) );

			//precompute values for dx and dy

			int dx_inner = (int)(newr * Math.cos(theta));

			int dy_inner = (int)(newr * Math.sin(theta));

			int dx_outer = (int)((newr+dr) * Math.cos(theta));

			int dy_outer = (int)((newr+dr) * Math.sin(theta));

			//calculate polygon constants

			int dy_poly = (int)(dr/2 * Math.cos(theta));

			int dx_poly = (int)(dr/2 * Math.sin(theta));

			//determine critical points

			//kansas city shuffle!

			px1 = sx + dx_inner;

			py1 = sy - dy_inner;

			rx1 = sx + dx_outer;

			ry1 = sy - dy_outer;

			px2 = sx - dx_inner;

			py2 = sy + dy_inner;

			rx2 = sx - dx_outer;

			ry2 = sy + dy_outer;

			px3 = sx - dy_inner;

			py3 = sy - dx_inner;

			rx3 = sx - dy_outer;

			ry3 = sy - dx_outer;

			px4 = sx + dy_inner;

			py4 = sy + dx_inner;

			rx4 = sx + dy_outer;

			ry4 = sy + dx_outer;

			//create polygons

			poly1_new.addPoint(px1, py1);

			poly1_new.addPoint(rx1+dx_poly, ry1+dy_poly);

			poly1_new.addPoint(rx1-dx_poly, ry1-dy_poly);

			poly2_new.addPoint(px2, py2);

			poly2_new.addPoint(rx2+dx_poly, ry2+dy_poly);

			poly2_new.addPoint(rx2-dx_poly, ry2-dy_poly);

			poly3_new.addPoint(px3, py3);

			poly3_new.addPoint(rx3-dy_poly, ry3+dx_poly);

			poly3_new.addPoint(rx3+dy_poly, ry3-dx_poly);

			poly4_new.addPoint(px4, py4);

			poly4_new.addPoint(rx4-dy_poly, ry4+dx_poly);

			poly4_new.addPoint(rx4+dy_poly, ry4-dx_poly);

			//reassign updated polygons

			poly1 = poly1_new;

			poly2 = poly2_new;

			poly3 = poly3_new;

			poly4 = poly4_new;

			if (steps < 300) steps++;

		}

		public synchronized void draw () {

			if (!running) return;

			g.setColor(Color.GRAY);

			//draw polygons

			g.fillPolygon(poly1);

			g.fillPolygon(poly2);

			g.fillPolygon(poly3);

			g.fillPolygon(poly4);

		}

		final int DATAUPDATER_DELAY = 2200;

		final int WEBCAMLOADER_DELAY = 300;