Blowing Through Lines

	var tabs:RegExp = /\\t/g;
	var newlines:RegExp = /\\n/g;
	txt.htmlText = unescape(wagerText).replace(tabs, "\t").replace(newlines, "\n");

/**
 * Code is a mix of ps2mouse from the Arduino playground
 * and mousewheel code from "a world in dk" modified to
 * work with Arduino Decimilia and 0017, and run a PS2
 * Microsoft Intellimouse.
 * 
 * Collin Reidorf collin@paperclipped.com 
 * Repaired http://blowingthroughlines.com
 
 */
 
/*
 * an arduino sketch to interface with a ps/2 mouse.
 * Also uses serial protocol to talk back to the host
 * and report what it finds.
 */
 
/*
 * Pin 5 is the mouse data pin, pin 6 is the clock pin
 * Feel free to use whatever pins are convenient.
 */
#define MDATA 5
#define MCLK 6
 
/*
 * according to some code I saw, these functions will
 * correctly set the mouse clock and data pins for
 * various conditions.
 */
void gohi(int pin)
{
	pinMode(pin, INPUT);
	digitalWrite(pin, HIGH);
}
 
void golo(int pin)
{
	pinMode(pin, OUTPUT);
	digitalWrite(pin, LOW);
}
 
/* PRECONDITION : clock is HIGH */
/* sends a single bit and returns with clock high */
void sendBit(char bit)
{
	if (bit) {
		gohi(MDATA);
	} 
	else {
		golo(MDATA);
	}
	/* wait for clock cycle */
	while (digitalRead(MCLK) == LOW)
		;
	while (digitalRead(MCLK) == HIGH)
		;
}
 
/* reads a single bit and returns with clock low */
char readBit()
{
	char tmp = 0x00;
	while (digitalRead(MCLK) == HIGH)
		;
	if (digitalRead(MDATA) == HIGH) 
		tmp = 0x01;
 
	while (digitalRead(MCLK) == LOW)
		;
 
	return tmp;
}
 
void mouse_write(char data)
{
	char i;
	char parity = 1;
 
	/* put pins in output mode */
	gohi(MDATA);
	gohi(MCLK);
	delayMicroseconds(300);
	golo(MCLK);
	delayMicroseconds(300);
	golo(MDATA);
	delayMicroseconds(10);
	/* start bit */
	gohi(MCLK);
	/* wait for mouse to take control of clock); */
	sendBit(0);
 
	/* clock is low, and we are clear to send data */
	for (i=0; i < 8; i++) {
 
		sendBit(data & 0x01);
 
		parity = parity ^ (data & 0x01); // might not need this anymore but too lazy to test...
 
		data = data >> 1;
	}  
	/* parity */
	sendBit(parity);
 
	/* stop bit */
	sendBit(1);
 
	/* wait for mouse to switch modes */
	while ((digitalRead(MCLK) == LOW) || (digitalRead(MDATA) == LOW))
		;
	/* put a hold on the incoming data. */
	golo(MCLK);
}
 
/*
 * Get a byte of data from the mouse
 */
char mouse_read(void)
{
	char data = 0x00;
	int i;
	char bit = 0x01;
 
	//	Serial.print("reading byte from mouse\n");
	/* start the clock */
	gohi(MCLK);
	gohi(MDATA);
	delayMicroseconds(50);
	readBit();
 
	// delayMicroseconds(5);  /* not sure why */ // and not evidently needed
 
	for (i=0; i < 8; i++) { // read the bits
		data = data | (readBit()<<i);
	}
 
	/* eat parity bit, which we ignore */
	readBit();
 
	/* eat stop bit */
	readBit(); 
 
	/* put a hold on the incoming data. */
	golo(MCLK);
 
	return data;
}
 
// for the mousewheel
// #define verbose // for verbose output
unsigned char msInitSequence[7]; // should go up on top when ready
 
char writeAndGetResponse(char data) {
	// #ifdef verbose
		// Serial.print("sending :	 ");
		// Serial.print((unsigned char)data, HEX);
		// Serial.print("\t");
	// #endif	
 
	mouse_write( data );
	return response();
}
 
char response() {
	char data = mouse_read();
	// #ifdef verbose
		// Serial.print("echo ");
		// Serial.print((unsigned char)data, HEX);
		// Serial.print(" from mouse\n");
	// #endif
	return data;
}
// 
void msMode() {
	// sequence for ms mode (3 button + scroll)
	// this is a entering procedure and i guess it will
	// work with other mice/ICs as its problably stadard ps2
	// And using an array were just a quick way to handle them
	msInitSequence[0] =0xF3;
	msInitSequence[1] =0xC8;
	msInitSequence[2] =0xF3;
	msInitSequence[3] =0x64;
	msInitSequence[4] =0xF3;
	msInitSequence[5] =0x50;
	msInitSequence[6] =0xF2;
 
 
	int i;
	for(i=0;i<7;i++) 
		writeAndGetResponse(msInitSequence[i]);
}
 
// end of mousewheel stuff
 
 
void showMStat(char mstat)
{
	int i;
	char bit = 0x01;
	for(i = 0; i<8; i++)
	{
		if(mstat&bit)
		{
			Serial.print("\t");
			switch(i)
			{
				case 0:
					Serial.print("L");
					break;
				case 1:
					Serial.print("R");
					break;
				case 2:
					Serial.print("M");
					break;
				case 3:
					// Serial.print(" Reserve ...\t");
					break;
				case 4:
					// Serial.print(" X data negative \t");
					break;
				case 5:
					// Serial.print("Y data negative \t");
					break;
				case 6:
					Serial.print("X data overflow");
					break;
				case 7:
					Serial.print("Y data overflow");
					break;
			}
		}
		bit = bit<<1;
	} 
}
 
void mouse_init()
{
	gohi(MCLK);
	gohi(MDATA);
	//	Serial.print("Sending reset to mouse\n");
	mouse_write(0xff);
	mouse_read();  /* ack byte */
	//	Serial.print("Read ack byte1\n");
	mouse_read();  /* blank */
	mouse_read();  /* blank */
 
	msMode(); // mousewheel code
 
	//	Serial.print("Sending remote mode code\n");
	mouse_write(0xf0);	/* remote mode */
	mouse_read();  /* ack */
	//	Serial.print("Read ack byte2\n");
 
	delayMicroseconds(100);
}
 
void setup()
{
	Serial.begin(9600);
	mouse_init();
}
 
/*
 * get a reading from the mouse and report it back to the
 * host via the serial line.
 */
void loop()
{
	char mstat;
	char mx;
	char my;
	char mz;
 
	/* get a reading from the mouse */
	writeAndGetResponse(0xEB); /* give me data! */ 
 
	mstat = mouse_read();
	mx = mouse_read();
	my = mouse_read();
	mz = mouse_read();
 
	/* send the data back up */
 
	Serial.print("\tmouse status=");
	Serial.print(mstat, BIN);
	Serial.print("\tX=");
	Serial.print(mx, DEC);
	Serial.print("\tY=");
	Serial.print(my, DEC);
	Serial.print("\tZ=");
	Serial.print(mz, DEC);
	showMStat(mstat); // print buttons that are down
	Serial.println();
	delay(20);	/* twiddle */
}

// some code
function test() {
	flashID.ner("hello"); // BAAAAAAD!
}

// some code
function test() {
	var flashMovie = $('#flashID');
	flashMovie.ner("hello"); // ALSO BAAAAAAD!
}

function test() {
	var flashMovie = document.getElementByID("flashID");
	flashMovie.ner("hello"); // FINALLY! It worked.
}