package com.hydrotik.make {
 
	import flash.display.Shape;
	import flash.display.Sprite;
	import flash.events.MouseEvent;
	import flash.utils.Timer;
	import flash.events.Event;
	import flash.events.TimerEvent;
	import flash.net.URLRequest;
	import flash.media.Sound;
	import flash.media.SoundChannel;
 
	import flash.text.*;
 
 
 
	import org.fwiidom.osc.*;
 
	public class MakeSerialLCD extends Sprite {
 
		private static const STR_LOCAL_IP:String = "169.254.73.165";
 
		private static const STR_REMOTE_IP:String = "192.168.0.200";
 
		private static const NUM_PORT:Number = 10000;
 
		private var oscConn:OSCConnection;
 
		private var tf:TextField;
 
		public function MakeSerialLCD() {
			//Initialize connection to the FLOSC server
			oscConn = new OSCConnection(STR_LOCAL_IP, NUM_PORT);
			oscConn.addEventListener(OSCConnectionEvent.ON_CONNECT, onConnect);
			oscConn.addEventListener(OSCConnectionEvent.ON_CONNECT_ERROR, onConnectError);
			oscConn.addEventListener(OSCConnectionEvent.ON_PACKET_IN, onPacketIn);
			oscConn.addEventListener(OSCConnectionEvent.ON_PACKET_OUT, onPacketOut);
			oscConn.addEventListener(OSCConnectionEvent.ON_CLOSE, onClose);
			oscConn.connect();
		}
 
		private function onConnect(evtEvent:OSCConnectionEvent):void {
			trace("FLOSC Connection established");
 
			oscConn.sendOSCPacket(new OSCPacket("/serial/baud", [9600], STR_REMOTE_IP, NUM_PORT));
 
			var button1:Sprite = new Sprite();
			button1.graphics.beginFill(0xCC6666);
			button1.graphics.drawRect(20, 10, 40, 20);
			button1.buttonMode = true;
			button1.addEventListener(MouseEvent.CLICK, onClick1Handler);
			addChild(button1);
 
			tf = new TextField();
			tf.background = true;
			tf.border = true;
			tf.backgroundColor = 0x00FF66;
			tf.maxChars = 32;
			tf.multiline = true;
			tf.width = 120;
			tf.height = 32;
			tf.wordWrap = true;
			tf.x = 80;
			tf.y = 10;
			tf.type = TextFieldType.INPUT;
			tf.restrict = "A-Z 0-9!.\"\'?";
			tf.tabEnabled = true;
			tf.tabIndex = 0;
 
			addChild(tf);
		}
 
		private function onConnectError(evtEvent:OSCConnectionEvent):void {
			trace("FLOSC Connection error");
		}
 
		private function onClose(evtEvent:OSCConnectionEvent):void {
			trace("FLOSC Connection closed");
		}
 
 
		private function onPacketIn(evtOSC:OSCConnectionEvent):void {
			trace("\t>> data received: " + evtOSC.data.name + " " + evtOSC.data.data);	
		}
 
		private function onPacketOut(evtOSC:OSCConnectionEvent):void {
			trace("\t>> data sent: " + evtOSC.data.name + " " + evtOSC.data.data);	
		}
 
		private function onClick1Handler(event:MouseEvent):void {
			parseString(tf.text);
			tf.text = "";
		}
 
 
		private function parseString(str:String):void {
			//Initialize LCD
			oscConn.sendOSCPacket(
				new OSCPacket("/serial/char", [254], STR_REMOTE_IP, NUM_PORT)
			);
			//Clears LCD
			oscConn.sendOSCPacket(
				new OSCPacket("/serial/char", [1], STR_REMOTE_IP, NUM_PORT)
			);
			//Loop and send ascii dec
			for(var i:int = 0; i<str.length ; i++){
				oscConn.sendOSCPacket(
					new OSCPacket("/serial/char", [str.charCodeAt(i)], STR_REMOTE_IP, NUM_PORT)
				);
			}
		}
 
	}
 
}

package org.fwiidom.osc { 
	/**
	 * @author adam
	 *(based originally on demo code included with Flosc)
	 * 
	 * (c) 2007 Fwiidom.org
	 */
 
	import flash.events.DataEvent;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.net.XMLSocket;
	import flash.xml.XMLDocument;
	import flash.xml.XMLNode;
 
	public class OSCConnection extends EventDispatcher {		
 
		protected var mSocket:XMLSocket;
		protected var mPort:Number;
		protected var mIp:String;
 
		protected var mDefaultSendPort:Number  = 10000;
		protected var mDefaultSendIp:String = "192.168.5.210";
 
		protected var mConnected:Boolean;
 
		public function OSCConnection(inIp:String, inPort:Number) {
			super();
			mIp = inIp;
			mPort = inPort;			
		}
 
		public function connect () : void {
			trace("OSCConnection.connect()");
			mSocket = new XMLSocket();
			mSocket.addEventListener(Event.CONNECT,onConnect);
			mSocket.addEventListener(Event.CLOSE,onClose);
			mSocket.addEventListener(DataEvent.DATA,onXml);
 
			mSocket.connect(mIp,mPort);
 
			//if (!mSocket.connect(mIp,mPort)) onConnectError();
		}
 
		public function disconnect () : void {
			mSocket.close();
			mConnected = false;
		}
 
 
		// *** event handler for incoming XMLDocument-encoded OSC packets
		protected function onXml (e:DataEvent) : void {
			var inXml:XMLDocument = new XMLDocument(e.data);
			trace("OSCConnection.onXml---"+inXml);
			// parse out the packet information
			var n:XMLNode = inXml.firstChild;
			if (n != null && n.nodeName == "OSCPACKET") {
				parseXml(n);
			}	
		}
 
 
		// *** event handler to respond to successful connection attempt
		protected function onConnect (succeeded:Boolean) : void {
			trace("OSCConnection.onConnect(succeeded)");
			if(succeeded) {
				trace ("success");
				mConnected = true;
				dispatchEvent(new OSCConnectionEvent(OSCConnectionEvent.ON_CONNECT,null));
			} else {
				trace ("fail");
				onConnectError();
			}		
		}
 
 
		// *** event handler called when server kills the connection
		protected function onClose (e:Event) : void {
			trace("OSCConnection.onClose()");
			mConnected = false;
			dispatchEvent(new OSCConnectionEvent(OSCConnectionEvent.ON_CLOSE));
		}
 
 
		protected function onConnectError() : void {
			trace("OSCConnection.onConnectError()");
			mConnected = false;		
			dispatchEvent(new OSCConnectionEvent(OSCConnectionEvent.ON_CONNECT_ERROR));
		}
 
		// *** parse the messages from some XMLDocument-encoded OSC packet	
		protected function parseXml(node:XMLNode) : void {
			trace("/------------------- OSCConnection.parseXml(node) ");
			trace (node);
			trace("------------------- /");
			if (node.firstChild.nodeName == "MESSAGE") {
				var message:XMLNode = node.firstChild;
 
				var name:String = message.attributes.NAME;			
				var data:Array = [];
				for (var child:XMLNode = message.firstChild; child != null; child=child.nextSibling) {
					if (child.nodeName == "ARGUMENT") {
						var type:String = child.attributes.TYPE;
						//boolean
						if (type=="T" || type=="F") {
							data.push((type=="T")?true:false);	
						} else if (type=="f") {
							//float
							data.push(parseFloat(child.attributes.VALUE));
//////------------------------------------------------------------------------///////////////////////////////////////////////////
//////	Added new type "i", as "f" is not a type in the Make Controller
//////------------------------------------------------------------------------///////////////////////////////////////////////////
						} else if (type=="i" || type=="I") {
							//float
							data.push(parseInt(child.attributes.VALUE));
						} else
						//string
						if (type=="s") {
							data.push(child.attributes.VALUE);
						}	
					}
				}
 
				var packet:OSCPacket = new OSCPacket(name, data, node.attributes.address, node.attributes.port);
				packet.time = node.attributes.time; 	
				dispatchEvent(new OSCConnectionEvent(OSCConnectionEvent.ON_PACKET_IN,packet));					
			}
			else { 
				// look recursively for a message node
				for (var subchild:XMLNode = node.firstChild; subchild != null; subchild=subchild.nextSibling) {
					parseXml(subchild);
				}
			}
		}
 
 
 
		// *** build and send XMLDocument-encoded OSC
 
		public function sendOSCPacket(outPacket:OSCPacket) : void {
			var xmlOut:XMLDocument = new XMLDocument();
 
			var osc:XMLNode = xmlOut.createElement("OSCPACKET");
			osc.attributes.TIME = 0;
			osc.attributes.PORT = outPacket.port;
			osc.attributes.ADDRESS = outPacket.address;
 
			var message:XMLNode = xmlOut.createElement("MESSAGE");
			message.attributes.NAME = outPacket.name;
 
			for (var i:Number=0;i<outPacket.data.length; i++) {
				// send everything as a string
				// NOTE : the server expects all strings to be encoded
				// with the escape function.
				var argument:XMLNode = xmlOut.createElement("ARGUMENT");			
				setType(argument, "i"); //argument.attributes.TYPE = "s";
				setValue(argument, escape(outPacket.data[i])); //argument.attributes.VALUE = escape(outPacket.data[i]);
				message.appendChild(argument);
			}
 
			osc.appendChild(message);
			xmlOut.appendChild(osc);
 
 
 
			if (mSocket && mConnected) {
				//trace ("XMLDocument SEND - ");
				trace (xmlOut);
				mSocket.send(xmlOut);
				dispatchEvent(new OSCConnectionEvent(OSCConnectionEvent.ON_PACKET_OUT,outPacket));
			}
		}
 
 
		private function setType(arg:XMLNode, str:String):void{
			arg.attributes.TYPE = str;
		}
 
		private function setValue(arg:XMLNode, str:String):void{
			arg.attributes.VALUE = str;
		}
 
	}
}