Initial checkin of nutridb.org and basic subversion directory structure

46 files changed, 5485 insertions, 0 deletions

diff --git a/lib/config.class.php b/lib/config.class.php
new file mode 100644
index 0000000..7a2782d
--- /dev/null
+++ b/lib/config.class.php
@@ -0,0 +1,35 @@
+<?php

+

+# define a class for general site configuration

+class siteConfig {

+

+	# predefined variables

+	# to change the database type see lib/database.class.php

+	public $_dbHost;		# db host

+	public $_dbName;		# name of the database

+	public $_dbUser;		# database user

+	public $_dbPass;		# database password

+

+	public $_rootDir;		# root of the site from the perspective of the filesystem

+	public $_rootURL;		# root URL of the site

+	public $_adodbDir;	# where the ADOBD libraries live - adodb.sourceforge.net

+	var $_imgDir;			# images directory

+	var $_cssDir;			# css files directory

+	var $_jsDir;			# javascript files directory

+

+	# class constructor

+	function __construct() {

+

+		# nothing to do at the moment

+

+	}

+

+	##------------------------------------------------------------------##

+	

+	# add functions here

+	

+	##------------------------------------------------------------------##

+

+}

+

+?>

diff --git a/lib/database.class.php b/lib/database.class.php
new file mode 100644
index 0000000..f72bdab
--- /dev/null
+++ b/lib/database.class.php
@@ -0,0 +1,239 @@
+<?php
+		
+# include the ADODB library for abstracting the underlying database
+require(ADODBDIR . "/adodb.inc.php");
+
+# define a class for connecting to, extracting and modifying data from a database
+
+class Database {
+
+	# predefine various variables
+	protected $_dbType			= "mysql";
+	public $_rows;			# holder for multiple records
+	public $_row;			# holder for a single record
+	public $_result;
+	public $_rowCount;
+	public $_fieldCount;
+	public $_affectedRows;
+	public $_insertId;
+	public $_error;
+	public $_dbConn;
+
+	# class constructor
+	function Database() {
+
+		# connect to the database
+		$this->Connect(
+			DBHOST,
+			DBUSER,
+			DBPASS,
+			DBNAME
+		);
+
+	}
+
+	##------------------------------------------------------------------##
+
+	# connect to the database
+	function Connect($dbHost, $dbUser, $dbPass, $dbName) {
+		$this->_dbConn = &ADONewConnection($this->_dbType);
+		if	(
+				$this->_dbConn->Connect
+					(
+						$dbHost,
+						$dbUser,
+						$dbPass,
+						$dbName
+					)
+			)
+		{
+			return true;
+		} else {
+			# grab error if the connection fails
+			$this->_error = $this->_dbConn->ErrorMsg();
+			if ( DBDEBUG == "true" ) {
+				$this->PrintError();
+			}
+			return false;
+		}
+
+	}
+	
+	##------------------------------------------------------------------##
+
+	# close the connection to the database
+	function Close() {
+
+		if ( isset($this->_dbConn) ) {
+			if ( $this->_dbConn->Close() ) {
+				return true;
+			} else {
+				# grab error if the connection fails
+				$this->_error = $this->_dbConn->ErrorMsg();
+				if ( DBDEBUG == "true" ) {
+					$this->PrintError();
+				}
+				return false;
+			}
+		}
+
+	}
+
+	##------------------------------------------------------------------##
+
+	# handles select queries where multiple rows are expected
+	function Select($sql) {
+
+		$this->_result = $this->_dbConn->Execute($sql);
+
+		if ( $this->_result ) {
+			$this->_rowCount = $this->_result->RecordCount();
+			$this->_fieldCount = $this->_result->FieldCount();
+			$this->_rows = $this->_result->GetRows();
+			return true;
+		} else {
+			$this->_error = $this->_dbConn->ErrorMsg();
+			if ( DBDEBUG == "true" ) {
+				$this->PrintError($sql);
+			}
+			return false;
+		}
+
+	}
+
+	##------------------------------------------------------------------##
+
+	# handles select queries where only one record is expected
+	function SelectOne($sql) {
+
+		$this->_result = $this->_dbConn->Execute($sql);
+
+		if ( $this->_result ) {
+			$this->_fieldCount = $this->_result->FieldCount();
+			$this->_rowCount = $this->_result->RecordCount();
+			$this->_row = $this->_result->FetchRow();
+			return true;
+		} else {
+			$this->_error = $this->_dbConn->ErrorMsg();
+			if ( DBDEBUG == "true" ) {
+				$this->PrintError($sql);
+			}
+			return false;
+		}
+
+	}
+
+	##------------------------------------------------------------------##
+
+	# handles select queries that need to return a restricted record set
+	function SelectLimit($sql, $rows, $offset) {
+
+		$this->_result = $this->_dbConn->SelectLimit($sql, $rows, $offset);
+
+		if ( $this->_result ) {
+			$this->_rowCount = $this->_result->RecordCount();
+			$this->_fieldCount = $this->_result->FieldCount();
+			$this->_rows = $this->_result->GetRows();
+			return true;
+		} else {
+			$this->_error = $this->_dbConn->ErrorMsg();
+			if ( DBDEBUG == "true" ) {
+				$this->PrintError($sql);
+			}
+			return false;
+		}
+
+	}
+
+	##------------------------------------------------------------------##
+
+	# handles queries that will alter data
+	function Modify($sql) {
+		
+		$this->_result = $this->_dbConn->Execute($sql);
+
+		if ( $this->_result ) {
+			$this->_affectedRows = $this->_dbConn->Affected_Rows();
+			return true;
+		} else {
+			$this->_error = $this->_dbConn->ErrorMsg();
+			if ( DBDEBUG == "true" ) {
+				$this->PrintError($sql);
+			}
+			return false;
+		}
+	
+	}
+
+	##------------------------------------------------------------------##
+
+	# get auto_incremented ID of last insert statement
+	function InsertId() {
+
+		$this->_result = $this->_dbConn->Insert_ID();
+
+		if ( $this->_result ) {
+			$this->_insertId = $this->_result;
+			return $this->_insertId;
+		} else {
+			$this->_error = $this->_dbConn->ErrorMsg();
+			if ( DBDEBUG == "true" ) {
+				$this->PrintError();
+			}
+			return false;
+		}
+
+	}
+
+	##------------------------------------------------------------------##
+
+	# clean up and escape strings to be inserted into database
+	function EscapeString($string) {
+
+		$string = trim($string);
+
+		if ( ! is_numeric($string) ) {
+			$string = $this->_dbConn->qstr( $string, get_magic_quotes_gpc() );
+		}
+
+		# the ADODB function above seems to add single quotes around the
+		# submitted string.  i like to add those myself at the time of
+		# the query, so strip them off here
+		$string = trim($string, "'");
+
+		return $string;
+
+	}
+
+	##------------------------------------------------------------------##
+
+	# print an error to the screen and then exit the script
+	function PrintError($sql = "") {
+
+		$thisScript = basename($_SERVER['PHP_SELF']);
+		echo <<<HTML
+<html>
+<head>
+	<title>Database Error</title>
+</head>
+<body>
+	<div>
+		<p>There was a database error.</p>
+		<p><strong>Script</strong>: $thisScript</p>
+		<p><strong>SQL</strong>: $sql</p>
+		<p><strong>Error</strong>: <span style='color: red;'>$this->_error</span></p>
+	</div>
+</body>
+</html>
+
+HTML;
+
+		exit;
+
+		return true;
+
+	}
+
+	##------------------------------------------------------------------##
+
+}
diff --git a/lib/site.lib.php b/lib/site.lib.php
new file mode 100644
index 0000000..d581cdb
--- /dev/null
+++ b/lib/site.lib.php
@@ -0,0 +1,657 @@
+<?php
+
+# determine if the user exists in the database and if so then
+# set a few session variables indicating such
+function validateUser($user, $pass) {
+
+	global $db;
+	
+	# make sure that these variables are empty and even unset
+	if ( isset($_SESSION['auth']) ) {
+		unset($_SESSION['auth']);
+	}
+
+	# encrypt password with a simple md5 hash
+	$md5Password = md5($pass);
+
+	$sql = "
+		SELECT * FROM users
+		WHERE username = '$user'
+			AND password = '$md5Password'
+	";
+	$db->SelectOne($sql);
+	if ( $db->_rowCount == 1 ) {
+		# if one record was returned then a user matching the credentials they
+		# supplied was found in the database.  give them access.
+		$_SESSION['auth']['status'] = "access_granted";
+		$_SESSION['auth']['ipaddress'] = $_SERVER['REMOTE_ADDR'];
+		
+		# dump all the users info into a session var, but unset the
+		# value of the password field
+		$_SESSION['user'] = $db->_row;
+		unset($_SESSION['user']['password']);
+
+		# determine the users age and put it in the session so that we don't have
+		# to calculate it over and over again as they view things. 31536000 is the 
+		# number of seconds in a year.
+		$_SESSION['user']['age'] = floor((time() - $db->_row['birthday'])/31536000);
+		return true;
+	} else {
+		# not a valid user (not found in db)
+		$_SESSION['systemMsg'] = "<span class='msgError'>Login incorrect.</span>";
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# a simple function to check if a user is logged in which also verifies
+# that the request came from the same IP address as the original login
+function isLoggedIn() {
+
+	if (
+		isset($_SESSION['auth']) &&
+		($_SESSION['auth']['status'] == "access_granted") &&
+		($_SESSION['auth']['ipaddress'] == $_SERVER['REMOTE_ADDR'])
+	) {
+		return true;
+	} else {
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# this function will check to see if a user is logged in, and if not will
+# redirect the user to the index page with an error.  we could use the
+# isLoggedIn() function above directly, but that would require some if/thens
+# on the top of each script that required a login and then a rediction too.
+# this function just bundles all that into a neat package
+function loginRequired() {
+
+	global $config;
+
+	if ( isLoggedIn() ) {
+		return true;
+	} else {
+		header("Location: {$config->_rootUri}/");
+		exit;
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# get a food category's name based on that categories id in the database
+function getFoodCategoryName($category) {
+
+	global $db;
+
+	$sql = "
+		SELECT fdgrp_desc
+		FROM foodCats
+		WHERE fdgrp_cd = '$category'
+	";
+	$db->SelectOne($sql);
+	if ( $db->_rowCount == 1 ) {
+		return $db->_row['fdgrp_desc'];
+	} else {
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# get a nutrients description based on that nutrients nutr_no in the database
+function getNutrientName($nutrient) {
+
+	global $db;
+
+	$sql = "
+		SELECT nutrdesc
+		FROM nutrientDefs
+		WHERE nutr_no = '$nutrient'
+	";
+	$db->SelectOne($sql);
+	if ( $db->_rowCount == 1 ) {
+		return $db->_row['nutrdesc'];
+	} else {
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# get any favorite foods based on user id
+function getFavoriteFoods($user) {
+
+	global $db;
+
+	# if the user hasn't marked any foods as favorites to
+	# show in the left sidebar dropdown, then just grab the
+	# first 15, else grab just their favorites
+	$sql = "
+		SELECT count(*) AS favCount
+		FROM userFoods
+		WHERE favorite = '1'
+	";
+	$db->SelectOne($sql);
+
+	if ( $db->_row['favCount'] == "0" ) {
+		$sql = "
+			SELECT * FROM userFoods
+			WHERE user = '$user'
+			ORDER BY description
+			LIMIT 15
+		";
+	} else {
+		$sql = "
+			SELECT * FROM userFoods
+			WHERE user = '$user'
+				AND favorite = '1'
+			ORDER BY description
+		";
+	}
+
+	$db->Select($sql);
+	if ( $db->_rowCount > 0 ) { 
+		return $db->_rows;
+	} else {
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# get any favorite meals based on user id
+function getFavoriteMeals($user) {
+
+	global $db;
+
+	# if the user hasn't marked any meals as favorites to
+	# show in the left sidebar dropdown, then just grab the
+	# first 15, else grab just their favorites
+	$sql = "
+		SELECT count(*) AS favCount
+		FROM userMeals
+		WHERE favorite = '1'
+	";
+	$db->SelectOne($sql);
+
+	if ( $db->_row['favCount'] == "0" ) {
+		$sql = "
+			SELECT * FROM userMeals
+			WHERE user = '$user'
+			ORDER BY description
+			LIMIT 15
+		";
+	} else {
+		$sql = "
+			SELECT * FROM userMeals
+			WHERE user = '$user'
+			ORDER BY description
+		";
+	}
+
+	$db->Select($sql);
+	if ( $db->_rowCount > 0 ) { 
+		return $db->_rows;
+	} else {
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# get all meals based on user id
+function getUserMeals($user) {
+
+	global $db;
+
+	$sql = "
+		SELECT * FROM userMeals
+		WHERE user = '$user'
+		ORDER BY description
+	";
+
+	$db->Select($sql);
+	if ( $db->_rowCount > 0 ) { 
+		return $db->_rows;
+	} else {
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# get all diaries based on user id
+function getUserDiaries($user) {
+
+	global $db;
+
+	$sql = "
+		SELECT * FROM userDiaries
+		WHERE user = '$user'
+		ORDER BY description
+	";
+
+	$db->Select($sql);
+	if ( $db->_rowCount > 0 ) { 
+		return $db->_rows;
+	} else {
+		return false;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# removes an item from the current meal in $_SESSION['currentMeal']
+function removeCurrentMealItem($mealItem) {
+
+    $objResponse = new xajaxResponse();
+
+	# remove the selected meal item from the session
+	if ( array_key_exists($mealItem, $_SESSION['currentMeal']) ) {
+		unset($_SESSION['currentMeal'][$mealItem]);
+    	$objResponse->addRemove("currentMealItem-$mealItem");
+		$objResponse->addAssign("systemMsgs", "innerHTML", "<span class='msgOkay'>The meal item was successfully removed.</span>");
+		# if the session is empty then let the user know and remove
+		# anything like links to "View meal", "Clear meal", etc.
+		if ( count($_SESSION['currentMeal']) == 0 ) {
+    		$objResponse->addAssign("divCurrentMeal", "innerHTML", "No items in meal.");
+		}
+	} else {
+		$objResponse->addAssign("systemMsgs", "innerHTML", "<span class='msgError'>The specified meal item doesn't exist.</span>");
+	}
+
+	return $objResponse;
+
+}
+
+	##------------------------------------------------------------------##
+
+# removes all meal items from the current meal ($_SESSION['currentMeal'])
+function clearCurrentMeal() {
+
+    $objResponse = new xajaxResponse();
+
+	# unset the current meal session variable
+	if ( isset($_SESSION['currentMeal']) ) {
+		unset($_SESSION['currentMeal']);
+	}
+
+	# if it's still set here, then something went terribly wrong, otherwise
+	# clear the div and let the user know.
+	if ( isset($_SESSION['currentMeal']) ) {
+		$objResponse->addAssign("systemMsgs", "innerHTML", "<span class='msgError'>There was an error. The current meal was not cleared.</span>");
+	} else {
+    	$objResponse->addAssign("divCurrentMeal", "innerHTML", "No items in meal.");
+		$objResponse->addAssign("systemMsgs", "innerHTML", "<span class='msgOkay'>The current meal was successfully cleared.</span>");
+	}
+
+	return $objResponse;
+
+}
+
+	##------------------------------------------------------------------##
+
+# create form for editing a meal
+function loadMealToEdit($meal) {
+
+	global $config, $db;
+
+	$objResponse = new xajaxResponse();
+
+	$mealToEdit = "";
+
+	$sql = sprintf ("
+		SELECT userMeals.*, userMeals.id AS mealId, userMeals.description as mealDesc,
+			userMealItems.*, userMealItems.id as itemId, userMealItems.description as itemDesc
+		FROM userMeals LEFT JOIN userMealItems
+			ON userMeals.id = userMealItems.meal
+		WHERE userMeals.id = '%s' AND user = '%s'
+		",
+		$meal,
+		$_SESSION['user']['id']
+	);
+	$db->Select($sql);
+
+	if ( $db->_rowCount == 0 ) {
+		$mealToEdit = "<span class='msgError'>The selected saved meal doesn't exist.</span><br />\n&lt;= Select a meal to edit.";
+		$objResponse->addAssign("editMeal","innerHTML", $mealToEdit);
+		return $objResponse;
+	} else {
+		$mealItems = $db->_rows;
+		$mealDesc = htmlspecialchars($mealItems[0]['mealDesc'], ENT_QUOTES);
+		$mealToEdit .= <<<HTML
+			<div>
+				<strong>Meal name</strong>: <input type='text' name='mealDesc' value='$mealDesc' size='25' />
+			</div>
+			<div id='editMealItems' style='margin-bottom: 1ex; overflow: hidden;'>
+
+HTML;
+		# here we grab and add all the possible predefined quantites
+		# so that the user can change the quantity from, for example,
+		# '1 large banana (7")' to '2 medium banana (5")' or something
+		# to that effect
+		foreach ( $mealItems as $key => $mealItem ) {
+			$sql = sprintf ("
+				SELECT seq AS weight, msre_desc
+				FROM weights
+				WHERE ndb_no = '%s'
+				",
+				$mealItem['food']
+			);
+			$db->Select($sql);
+			$itemQuantities = $db->_rows;
+			$mealItems[$key]['quantities'] = $itemQuantities;
+
+			# we will use this array later, in the Modify action below
+			# to identify which meal items we need to update.
+			$itemIds[] = $mealItem['itemId'];
+
+			$mealItemDesc = htmlspecialchars($mealItem['itemDesc'], ENT_QUOTES);
+			$mealToEdit .= <<<HTML
+			<div id='mealItem-{$mealItem['id']}'>
+				<div>
+					<a href='{$_SERVER['REQUEST_URI']}' onclick='verifyRemoveMealItem("{$mealItem['id']}"); return false;'><img src='{$config->_imgUri}/remove.png' alt='Del' title='Remove: $mealItemDesc' /></a>
+					=&gt; <strong>Meal item</strong>: <input type='text' name='mealItemDesc-{$mealItem['id']}' id='mealItemDesc-{$mealItem['id']}' value='$mealItemDesc' size='25' />
+				</div>
+				<div style='margin-top: 1ex; margin-left: 3ex;'>
+					<div style='margin-left: 2ex; margin-bottom: 1ex;'>
+						=&gt; <strong>Amount</strong>: <input type='text' name='mealItemQuantity-{$mealItem['id']}' id='mealItemQuantity-{$mealItem['id']}' value='{$mealItem['quantity']}' size='2' />
+						<select name='mealItemWeight-{$mealItem['id']}'>
+
+HTML;
+
+			foreach ( $itemQuantities as $itemQuantity ) {
+				if ( $itemQuantity['weight'] == $mealItem['weight'] ) {
+					$mealToEdit .= "							<option value='{$itemQuantity['weight']}' selected='selected'>{$itemQuantity['msre_desc']}</option>\n";
+				} else {
+					$mealToEdit .= "							<option value='{$itemQuantity['weight']}'>{$itemQuantity['msre_desc']}</option>\n";
+				}
+			}
+
+			$mealToEdit .= <<<HTML
+						</select>
+					</div>
+				</div>
+			</div>
+
+HTML;
+		}
+
+		if ( $mealItem['favorite'] == "1" ) {
+			$mealToEdit .= "					<div><strong>Favorite</strong>: <input type='checkbox' name='favorite' id='favorite' checked='checked' /></div>\n";
+		} else {
+			$mealToEdit .= "					<div><strong>Favorite</strong>: <input type='checkbox' name='favorite' id='favorite' /></div>\n";
+		}
+
+		# separate itemIds with a comma
+		$mealItemIds = implode(",",$itemIds);
+		$mealToEdit .= <<<HTML
+		</div>
+		<div style='margin-top: 2ex;'>
+			<input type='hidden' name='meal' value='$meal' />
+			<input type='hidden' name='mealItemIds' value='$mealItemIds' />
+			<input type='hidden' name='action' value='' />
+			<input type='submit' name='doModifyMeal' value='Modify' onclick='document.formEditMeal.action.value = "Modify";' />
+			<input type='submit' name='doDeleteMeal' value='Delete' onclick='document.formEditMeal.action.value = "Delete";' />
+		</div>
+
+HTML;
+	}
+
+    $objResponse->addAssign("editMeal","innerHTML", $mealToEdit);
+
+	return $objResponse;
+
+}
+
+	##------------------------------------------------------------------##
+
+# create form for editing a food
+function loadFoodToEdit($food) {
+
+	global $config, $db;
+
+    $objResponse = new xajaxResponse();
+	$foodToEdit = "";
+
+	$sql = sprintf ("
+		SELECT * FROM userFoods
+		WHERE id = '%s' AND user = '%s'
+		",
+		$food,
+		$_SESSION['user']['id']
+	);
+	$db->SelectOne($sql);
+
+	if ( $db->_rowCount == 0 ) {
+		$foodToEdit = "<span class='msgError'>The selected saved food doesn't exist.</span><br />\n&lt;= Select a food to edit.";
+    	$objResponse->addAssign("editFood","innerHTML", $foodToEdit);
+		return $objResponse;
+	} else {
+		$foodItem = $db->_row;
+		# here we grab and add all the possible predefined quantites
+		# so that the user can change the quantity from, for example,
+		# '1 large banana (7")' to '2 medium banana (5")' or something
+		# to that effect
+		$sql = sprintf ("
+			SELECT seq AS weight, msre_desc
+			FROM weights
+			WHERE ndb_no = '%s'
+			",
+			$foodItem['food']
+		);
+		$db->Select($sql);
+		$itemQuantities = $db->_rows;
+		$foodItem['quantities'] = $itemQuantities;
+
+		$foodDesc = htmlspecialchars($foodItem['description'], ENT_QUOTES);
+		$foodToEdit .= <<<HTML
+					<form action='edit_food.php' method='post' name='formEditFood' id='formEditFood' onsubmit='return validateEditFood("formEditFood");'>
+						<div><strong>Food name</strong>: <input type='text' name='foodDesc' id='foodDesc' value='$foodDesc' size='25' /></div>
+						<div style='margin-left: 3ex; margin-bottom: 1ex;'>
+							=&gt; <strong>Amount</strong>: <input type='text' name='quantity' value='{$foodItem['quantity']}' size='2' />
+							<select name='weight'>
+
+HTML;
+
+		foreach ( $itemQuantities as $itemQuantity ) {
+			if ( $itemQuantity['weight'] == $foodItem['weight'] ) {
+				$foodToEdit .= "								<option value='{$itemQuantity['weight']}' selected='selected'>{$itemQuantity['msre_desc']}</option>\n";
+			} else {
+				$foodToEdit .= "								<option value='{$itemQuantity['weight']}'>{$itemQuantity['msre_desc']}</option>\n";
+			}
+		}
+
+		$foodToEdit .= <<<HTML
+							</select>
+						</div>
+HTML;
+		if ( $foodItem['favorite'] == "1" ) {
+			$foodToEdit .= "					<div><strong>Favorite</strong>: <input type='checkbox' name='favorite' id='favorite' checked='checked' /></div>\n";
+		} else {
+			$foodToEdit .= "					<div><strong>Favorite</strong>: <input type='checkbox' name='favorite' id='favorite' /></div>\n";
+		}
+		$foodToEdit .= <<<HTML
+						<div style='margin-top: 2ex;'>
+							<input type='hidden' name='food' value='$food' />
+							<input type='hidden' name='action' value='' />
+							<input type='submit' name='doModifyFood' value='Modify' onclick='document.formEditFood.action.value = "Modify";' />
+							<input type='submit' name='doDeleteFood' value='Delete' onclick='document.formEditFood.action.value = "Delete";' />
+						</div>
+					</form>
+
+HTML;
+	}
+
+    $objResponse->addAssign("editFood","innerHTML", $foodToEdit);
+
+	return $objResponse;
+
+}
+
+	##------------------------------------------------------------------##
+
+# removes an item from a saved meal
+function removeMealItem($mealItem) {
+
+	global $db;
+
+	$objResponse = new xajaxResponse();
+
+	$sql = sprintf ("
+		DELETE userMealItems.*
+		FROM userMealItems INNER JOIN userMeals
+			ON userMealItems.meal = userMeals.id
+		INNER JOIN users
+			ON userMeals.user = users.id
+		WHERE users.id = '%s' AND userMealItems.id = '%s'
+		",
+		$_SESSION['user']['id'],
+		$mealItem
+	);
+	$db->Modify($sql);
+
+	if ( $db->_affectedRows == "1" ) {
+		$objResponse->addRemove("mealItem-$mealItem");
+		$objResponse->addAssign("systemMsgs", "innerHTML", "<span class='msgOkay'>The meal item was successfully removed.</span>");
+		return $objResponse;
+	} else {
+		$objResponse->addAssign("systemMsgs", "innerHTML", "<span class='msgError'>There was an error.  The meal item was not meal.</span>");
+		return $objResponse;
+	}
+
+}
+	##------------------------------------------------------------------##
+
+# removes an item from a diary
+function removeDiaryItem($diaryItem) {
+
+	global $db;
+
+	$objResponse = new xajaxResponse();
+
+	$sql = sprintf ("
+		DELETE userDiaryItems.*
+		FROM userDiaryItems INNER JOIN userDiaries
+			ON userDiaryItems.diary = userDiaries.id
+		WHERE userDiaries.user = '%s'
+			AND userDiaryItems.id = '%s'
+		",
+		$_SESSION['user']['id'],
+		$diaryItem
+	);
+	$db->Modify($sql);
+
+	if ( $db->_affectedRows == "1" ) {
+		$objResponse->addRemove("itemRow-$diaryItem");
+		$objResponse->addAssign("systemMsgs", "innerHTML", "<span class='msgOkay'>The diary item was successfully deleted.</span>");
+		return $objResponse;
+	} else {
+		$objResponse->addAssign("systemMsgs", "innerHTML", "<span class='msgError'>There was an error.  The diary item was not deleted.</span>");
+		return $objResponse;
+	}
+
+}
+
+	##------------------------------------------------------------------##
+
+# checks to see if a username already exists in the db during the registration process
+function usernameExists($username) {
+
+	global $db;
+
+	$objResponse = new xajaxResponse();
+
+	$sql = sprintf ("
+		SELECT username FROM users
+		WHERE username = '%s'
+		",
+		trim($username)
+	);
+	$db->Select($sql);
+	if ( $db->_rowCount > 0 ) {
+		$alert = "The login name you selected is already in use.  Please select another.";
+		$objResponse->addAlert($alert);
+		$objResponse->addScript("xajax.$('formRegisterUser').username.focus();");
+		$objResponse->addScript("return false;");
+	} else {
+		$objResponse->addScript("xajax.$('formRegisterUser').submit();");
+	}
+
+	return $objResponse;
+
+}
+
+	##------------------------------------------------------------------##
+
+# increment the "popularity" counter for the supplied ndb_no.
+# table will be: foodDesc, userFoods, or userMeals ... we use it to determine
+# which counter to increment.  the name corresponds to the relevant table
+# so we can just plug it into the query directly
+
+function incrementPopularityCounter($id, $table) {
+
+	global $db;
+
+	# we keep track of which items a user has selected during a given
+	# session and we only allow a popularity counter to be incremented
+	# for a given item once per session.  this isn't fool-proof, but it
+	# should help to stem someone repeatedly clicking on the same item
+	# in order to raise it's popularity artificially .. at least it will
+	# be more of a hassle for someone to do it.
+	if ( ! empty($_SESSION['popularity']) && in_array("$id{$table}", $_SESSION['popularity']) ) {
+		# this user has already selected this item during this session
+		# so don't increment the popularity counter
+		return false;
+	}
+
+	switch ( $table ) {
+		case "foodDescs":
+			$idField = "ndb_no";
+			break;
+		case "userFoods":
+			$idField = "id";
+			break;
+		case "userMeals":
+			$idField = "id";
+			break;
+		default:
+			# the table isn't valid
+			return false;
+	}
+
+	$sql = sprintf ("
+		UPDATE %s
+			SET popularity = (popularity + 1)
+		WHERE %s = '%s'
+		",
+		$table,
+		$idField,
+		$id
+	);
+	$db->Modify($sql);
+
+	# add this food to the list so that this user can't trigger another
+	# popularity increment for this food during this session.
+	$_SESSION['popularity'][] = "$id{$table}"; 
+
+	return true;
+
+}
+
+	##------------------------------------------------------------------##
+
+?>
diff --git a/lib/standard.lib.php b/lib/standard.lib.php
new file mode 100644
index 0000000..503052e
--- /dev/null
+++ b/lib/standard.lib.php
@@ -0,0 +1,112 @@
+<?php
+
+# this function will simply initialize a variable to
+# an empty string unless it already has a value, in
+# which case it will simply return the existing value
+function initVar($var) {
+	
+	$var = empty($var) ? "" : $var;
+	return $var;
+
+}
+
+# this function will initialize a variable to an empty
+# string unless it already has a value, in which case
+# it will simply return the existing value ... the only
+# diff. between this function and initVar() is that this
+# fuction encodes HTML special characters and then echos
+# the variable ... useful for initializing and printing
+# a variable all in one step
+function printVar($var) {
+	
+	$var = empty($var) ? "" : htmlspecialchars($var,ENT_QUOTES);
+	echo $var;
+	return true;
+
+}
+
+# create pagination, including a page navigation bar.  the
+# output should be fairly generic, enclosed in a div with 
+# a css class of 'paginationNav', and more or less suitable
+# to be dropped into just about any page.
+function getPagination($page = 1, $pageOffset, $uri , $paginationSql) {
+
+	global $config, $db;
+
+	# start with a blank page navigation menu
+	$pageNav = "";
+
+	# change special chars, particularly the & to the HTML entity
+	# so that browsers don't confuse it with an HTML entity.
+	$uri = htmlspecialchars($uri);
+
+	# determine total number of records and pages
+	$db->SelectOne($paginationSql);
+	$totalRecords = $db->_row['rowCount'];
+	$totalPages = ceil($totalRecords / $config->_recordsPerPage);
+
+	# if the total records are less than what we show per page, then
+	# just skip everything else below
+	if ( $totalRecords <= $config->_recordsPerPage ) {
+		$fromRecord = ($pageOffset + 1);
+		$pageNav .= <<<HTML
+	<br />
+	<span style='font-size: xx-small;'>Displaying: $fromRecord to $totalRecords of $totalRecords results.</span>
+HTML;
+
+		return $pageNav;
+	}
+
+	# either append the proper page with & or ? depending
+	# on whether the submitted URI already has a query
+	# string or not
+	if ( preg_match("/\?.+/", $uri) ) {
+		$uri = "$uri&amp;";
+	} else {
+		$uri = "$uri?";
+	}
+
+	# create the navigation menu
+	if ( $page > 1 ) { 
+		$pagePrev = ($page - 1);
+		# if the previous page isn't also the first page, show a link for first page.
+		if ( $pagePrev != 1 ) {
+			$pageNav .= "	<a href='{$uri}page=1' title='First Page'>[First] </a>\n";
+		}
+		$pageNav .= "	<a href='{$uri}page=$pagePrev' title='Page $pagePrev'>Prev</a>\n";
+	}
+
+	for ( $idx = 1; $idx <= $totalPages; $idx++ ) {
+		if ( $idx == $page ) {
+			$pageNav .= "	<strong>$idx</strong> \n";
+		} else {
+			$pageNav .= "	<a href='{$uri}page=$idx' title='Page $idx'>$idx</a> \n"; 
+		}
+	}
+
+	if ( ($totalRecords - ($config->_recordsPerPage * $page)) > 0 ) {
+		$pageNext = ($page + 1);
+		$pageNav .= "	<a href='{$uri}page=$pageNext' title='Page $pageNext'>Next</a>\n";
+		# if the previous page isn't also the first page, show a link for first page.
+		if ( $pageNext != $totalPages ) {
+			$pageNav .= "<a href='{$uri}page=$totalPages' title='Last page'> [Last]</a> \n";  
+		}
+	}
+
+	$fromRecord = ($pageOffset + 1);
+	if ( $page == $totalPages ) {
+		$toRecord = $totalRecords;
+	} else {
+		$toRecord = ($pageOffset + $config->_recordsPerPage);
+	}
+
+	$pageNav .= <<<HTML
+	<br />
+	<span style='font-size: xx-small;'>Displaying: $fromRecord to $toRecord of $totalRecords results.</span>
+HTML;
+
+	return $pageNav;
+
+}
+
+?>
diff --git a/lib/xajax_0.2.4/LICENSE.txt b/lib/xajax_0.2.4/LICENSE.txt
new file mode 100755
index 0000000..54905a6
--- /dev/null
+++ b/lib/xajax_0.2.4/LICENSE.txt
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE

+		       Version 2.1, February 1999

+

+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.

+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

+ Everyone is permitted to copy and distribute verbatim copies

+ of this license document, but changing it is not allowed.

+

+[This is the first released version of the Lesser GPL.  It also counts

+ as the successor of the GNU Library Public License, version 2, hence

+ the version number 2.1.]

+

+			    Preamble

+

+  The licenses for most software are designed to take away your

+freedom to share and change it.  By contrast, the GNU General Public

+Licenses are intended to guarantee your freedom to share and change

+free software--to make sure the software is free for all its users.

+

+  This license, the Lesser General Public License, applies to some

+specially designated software packages--typically libraries--of the

+Free Software Foundation and other authors who decide to use it.  You

+can use it too, but we suggest you first think carefully about whether

+this license or the ordinary General Public License is the better

+strategy to use in any particular case, based on the explanations below.

+

+  When we speak of free software, we are referring to freedom of use,

+not price.  Our General Public Licenses are designed to make sure that

+you have the freedom to distribute copies of free software (and charge

+for this service if you wish); that you receive source code or can get

+it if you want it; that you can change the software and use pieces of

+it in new free programs; and that you are informed that you can do

+these things.

+

+  To protect your rights, we need to make restrictions that forbid

+distributors to deny you these rights or to ask you to surrender these

+rights.  These restrictions translate to certain responsibilities for

+you if you distribute copies of the library or if you modify it.

+

+  For example, if you distribute copies of the library, whether gratis

+or for a fee, you must give the recipients all the rights that we gave

+you.  You must make sure that they, too, receive or can get the source

+code.  If you link other code with the library, you must provide

+complete object files to the recipients, so that they can relink them

+with the library after making changes to the library and recompiling

+it.  And you must show them these terms so they know their rights.

+

+  We protect your rights with a two-step method: (1) we copyright the

+library, and (2) we offer you this license, which gives you legal

+permission to copy, distribute and/or modify the library.

+

+  To protect each distributor, we want to make it very clear that

+there is no warranty for the free library.  Also, if the library is

+modified by someone else and passed on, the recipients should know

+that what they have is not the original version, so that the original

+author's reputation will not be affected by problems that might be

+introduced by others.

+

+  Finally, software patents pose a constant threat to the existence of

+any free program.  We wish to make sure that a company cannot

+effectively restrict the users of a free program by obtaining a

+restrictive license from a patent holder.  Therefore, we insist that

+any patent license obtained for a version of the library must be

+consistent with the full freedom of use specified in this license.

+

+  Most GNU software, including some libraries, is covered by the

+ordinary GNU General Public License.  This license, the GNU Lesser

+General Public License, applies to certain designated libraries, and

+is quite different from the ordinary General Public License.  We use

+this license for certain libraries in order to permit linking those

+libraries into non-free programs.

+

+  When a program is linked with a library, whether statically or using

+a shared library, the combination of the two is legally speaking a

+combined work, a derivative of the original library.  The ordinary

+General Public License therefore permits such linking only if the

+entire combination fits its criteria of freedom.  The Lesser General

+Public License permits more lax criteria for linking other code with

+the library.

+

+  We call this license the "Lesser" General Public License because it

+does Less to protect the user's freedom than the ordinary General

+Public License.  It also provides other free software developers Less

+of an advantage over competing non-free programs.  These disadvantages

+are the reason we use the ordinary General Public License for many

+libraries.  However, the Lesser license provides advantages in certain

+special circumstances.

+

+  For example, on rare occasions, there may be a special need to

+encourage the widest possible use of a certain library, so that it becomes

+a de-facto standard.  To achieve this, non-free programs must be

+allowed to use the library.  A more frequent case is that a free

+library does the same job as widely used non-free libraries.  In this

+case, there is little to gain by limiting the free library to free

+software only, so we use the Lesser General Public License.

+

+  In other cases, permission to use a particular library in non-free

+programs enables a greater number of people to use a large body of

+free software.  For example, permission to use the GNU C Library in

+non-free programs enables many more people to use the whole GNU

+operating system, as well as its variant, the GNU/Linux operating

+system.

+

+  Although the Lesser General Public License is Less protective of the

+users' freedom, it does ensure that the user of a program that is

+linked with the Library has the freedom and the wherewithal to run

+that program using a modified version of the Library.

+

+  The precise terms and conditions for copying, distribution and

+modification follow.  Pay close attention to the difference between a

+"work based on the library" and a "work that uses the library".  The

+former contains code derived from the library, whereas the latter must

+be combined with the library in order to run.

+

+		  GNU LESSER GENERAL PUBLIC LICENSE

+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

+

+  0. This License Agreement applies to any software library or other

+program which contains a notice placed by the copyright holder or

+other authorized party saying it may be distributed under the terms of

+this Lesser General Public License (also called "this License").

+Each licensee is addressed as "you".

+

+  A "library" means a collection of software functions and/or data

+prepared so as to be conveniently linked with application programs

+(which use some of those functions and data) to form executables.

+

+  The "Library", below, refers to any such software library or work

+which has been distributed under these terms.  A "work based on the

+Library" means either the Library or any derivative work under

+copyright law: that is to say, a work containing the Library or a

+portion of it, either verbatim or with modifications and/or translated

+straightforwardly into another language.  (Hereinafter, translation is

+included without limitation in the term "modification".)

+

+  "Source code" for a work means the preferred form of the work for

+making modifications to it.  For a library, complete source code means

+all the source code for all modules it contains, plus any associated

+interface definition files, plus the scripts used to control compilation

+and installation of the library.

+

+  Activities other than copying, distribution and modification are not

+covered by this License; they are outside its scope.  The act of

+running a program using the Library is not restricted, and output from

+such a program is covered only if its contents constitute a work based

+on the Library (independent of the use of the Library in a tool for

+writing it).  Whether that is true depends on what the Library does

+and what the program that uses the Library does.

+  

+  1. You may copy and distribute verbatim copies of the Library's

+complete source code as you receive it, in any medium, provided that

+you conspicuously and appropriately publish on each copy an

+appropriate copyright notice and disclaimer of warranty; keep intact

+all the notices that refer to this License and to the absence of any

+warranty; and distribute a copy of this License along with the

+Library.

+

+  You may charge a fee for the physical act of transferring a copy,

+and you may at your option offer warranty protection in exchange for a

+fee.

+

+  2. You may modify your copy or copies of the Library or any portion

+of it, thus forming a work based on the Library, and copy and

+distribute such modifications or work under the terms of Section 1

+above, provided that you also meet all of these conditions:

+

+    a) The modified work must itself be a software library.

+

+    b) You must cause the files modified to carry prominent notices

+    stating that you changed the files and the date of any change.

+

+    c) You must cause the whole of the work to be licensed at no

+    charge to all third parties under the terms of this License.

+

+    d) If a facility in the modified Library refers to a function or a

+    table of data to be supplied by an application program that uses

+    the facility, other than as an argument passed when the facility

+    is invoked, then you must make a good faith effort to ensure that,

+    in the event an application does not supply such function or

+    table, the facility still operates, and performs whatever part of

+    its purpose remains meaningful.

+

+    (For example, a function in a library to compute square roots has

+    a purpose that is entirely well-defined independent of the

+    application.  Therefore, Subsection 2d requires that any

+    application-supplied function or table used by this function must

+    be optional: if the application does not supply it, the square

+    root function must still compute square roots.)

+

+These requirements apply to the modified work as a whole.  If

+identifiable sections of that work are not derived from the Library,

+and can be reasonably considered independent and separate works in

+themselves, then this License, and its terms, do not apply to those

+sections when you distribute them as separate works.  But when you

+distribute the same sections as part of a whole which is a work based

+on the Library, the distribution of the whole must be on the terms of

+this License, whose permissions for other licensees extend to the

+entire whole, and thus to each and every part regardless of who wrote

+it.

+

+Thus, it is not the intent of this section to claim rights or contest

+your rights to work written entirely by you; rather, the intent is to

+exercise the right to control the distribution of derivative or

+collective works based on the Library.

+

+In addition, mere aggregation of another work not based on the Library

+with the Library (or with a work based on the Library) on a volume of

+a storage or distribution medium does not bring the other work under

+the scope of this License.

+

+  3. You may opt to apply the terms of the ordinary GNU General Public

+License instead of this License to a given copy of the Library.  To do

+this, you must alter all the notices that refer to this License, so

+that they refer to the ordinary GNU General Public License, version 2,

+instead of to this License.  (If a newer version than version 2 of the

+ordinary GNU General Public License has appeared, then you can specify

+that version instead if you wish.)  Do not make any other change in

+these notices.

+

+  Once this change is made in a given copy, it is irreversible for

+that copy, so the ordinary GNU General Public License applies to all

+subsequent copies and derivative works made from that copy.

+

+  This option is useful when you wish to copy part of the code of

+the Library into a program that is not a library.

+

+  4. You may copy and distribute the Library (or a portion or

+derivative of it, under Section 2) in object code or executable form

+under the terms of Sections 1 and 2 above provided that you accompany

+it with the complete corresponding machine-readable source code, which

+must be distributed under the terms of Sections 1 and 2 above on a

+medium customarily used for software interchange.

+

+  If distribution of object code is made by offering access to copy

+from a designated place, then offering equivalent access to copy the

+source code from the same place satisfies the requirement to

+distribute the source code, even though third parties are not

+compelled to copy the source along with the object code.

+

+  5. A program that contains no derivative of any portion of the

+Library, but is designed to work with the Library by being compiled or

+linked with it, is called a "work that uses the Library".  Such a

+work, in isolation, is not a derivative work of the Library, and

+therefore falls outside the scope of this License.

+

+  However, linking a "work that uses the Library" with the Library

+creates an executable that is a derivative of the Library (because it

+contains portions of the Library), rather than a "work that uses the

+library".  The executable is therefore covered by this License.

+Section 6 states terms for distribution of such executables.

+

+  When a "work that uses the Library" uses material from a header file

+that is part of the Library, the object code for the work may be a

+derivative work of the Library even though the source code is not.

+Whether this is true is especially significant if the work can be

+linked without the Library, or if the work is itself a library.  The

+threshold for this to be true is not precisely defined by law.

+

+  If such an object file uses only numerical parameters, data

+structure layouts and accessors, and small macros and small inline

+functions (ten lines or less in length), then the use of the object

+file is unrestricted, regardless of whether it is legally a derivative

+work.  (Executables containing this object code plus portions of the

+Library will still fall under Section 6.)

+

+  Otherwise, if the work is a derivative of the Library, you may

+distribute the object code for the work under the terms of Section 6.

+Any executables containing that work also fall under Section 6,

+whether or not they are linked directly with the Library itself.

+

+  6. As an exception to the Sections above, you may also combine or

+link a "work that uses the Library" with the Library to produce a

+work containing portions of the Library, and distribute that work

+under terms of your choice, provided that the terms permit

+modification of the work for the customer's own use and reverse

+engineering for debugging such modifications.

+

+  You must give prominent notice with each copy of the work that the

+Library is used in it and that the Library and its use are covered by

+this License.  You must supply a copy of this License.  If the work

+during execution displays copyright notices, you must include the

+copyright notice for the Library among them, as well as a reference

+directing the user to the copy of this License.  Also, you must do one

+of these things:

+

+    a) Accompany the work with the complete corresponding

+    machine-readable source code for the Library including whatever

+    changes were used in the work (which must be distributed under

+    Sections 1 and 2 above); and, if the work is an executable linked

+    with the Library, with the complete machine-readable "work that

+    uses the Library", as object code and/or source code, so that the

+    user can modify the Library and then relink to produce a modified

+    executable containing the modified Library.  (It is understood

+    that the user who changes the contents of definitions files in the

+    Library will not necessarily be able to recompile the application

+    to use the modified definitions.)

+

+    b) Use a suitable shared library mechanism for linking with the

+    Library.  A suitable mechanism is one that (1) uses at run time a

+    copy of the library already present on the user's computer system,

+    rather than copying library functions into the executable, and (2)

+    will operate properly with a modified version of the library, if

+    the user installs one, as long as the modified version is

+    interface-compatible with the version that the work was made with.

+

+    c) Accompany the work with a written offer, valid for at

+    least three years, to give the same user the materials

+    specified in Subsection 6a, above, for a charge no more

+    than the cost of performing this distribution.

+

+    d) If distribution of the work is made by offering access to copy

+    from a designated place, offer equivalent access to copy the above

+    specified materials from the same place.

+

+    e) Verify that the user has already received a copy of these

+    materials or that you have already sent this user a copy.

+

+  For an executable, the required form of the "work that uses the

+Library" must include any data and utility programs needed for

+reproducing the executable from it.  However, as a special exception,

+the materials to be distributed need not include anything that is

+normally distributed (in either source or binary form) with the major

+components (compiler, kernel, and so on) of the operating system on

+which the executable runs, unless that component itself accompanies

+the executable.

+

+  It may happen that this requirement contradicts the license

+restrictions of other proprietary libraries that do not normally

+accompany the operating system.  Such a contradiction means you cannot

+use both them and the Library together in an executable that you

+distribute.

+

+  7. You may place library facilities that are a work based on the

+Library side-by-side in a single library together with other library

+facilities not covered by this License, and distribute such a combined

+library, provided that the separate distribution of the work based on

+the Library and of the other library facilities is otherwise

+permitted, and provided that you do these two things:

+

+    a) Accompany the combined library with a copy of the same work

+    based on the Library, uncombined with any other library

+    facilities.  This must be distributed under the terms of the

+    Sections above.

+

+    b) Give prominent notice with the combined library of the fact

+    that part of it is a work based on the Library, and explaining

+    where to find the accompanying uncombined form of the same work.

+

+  8. You may not copy, modify, sublicense, link with, or distribute

+the Library except as expressly provided under this License.  Any

+attempt otherwise to copy, modify, sublicense, link with, or

+distribute the Library is void, and will automatically terminate your

+rights under this License.  However, parties who have received copies,

+or rights, from you under this License will not have their licenses

+terminated so long as such parties remain in full compliance.

+

+  9. You are not required to accept this License, since you have not

+signed it.  However, nothing else grants you permission to modify or

+distribute the Library or its derivative works.  These actions are

+prohibited by law if you do not accept this License.  Therefore, by

+modifying or distributing the Library (or any work based on the

+Library), you indicate your acceptance of this License to do so, and

+all its terms and conditions for copying, distributing or modifying

+the Library or works based on it.

+

+  10. Each time you redistribute the Library (or any work based on the

+Library), the recipient automatically receives a license from the

+original licensor to copy, distribute, link with or modify the Library

+subject to these terms and conditions.  You may not impose any further

+restrictions on the recipients' exercise of the rights granted herein.

+You are not responsible for enforcing compliance by third parties with

+this License.

+

+  11. If, as a consequence of a court judgment or allegation of patent

+infringement or for any other reason (not limited to patent issues),

+conditions are imposed on you (whether by court order, agreement or

+otherwise) that contradict the conditions of this License, they do not

+excuse you from the conditions of this License.  If you cannot

+distribute so as to satisfy simultaneously your obligations under this

+License and any other pertinent obligations, then as a consequence you

+may not distribute the Library at all.  For example, if a patent

+license would not permit royalty-free redistribution of the Library by

+all those who receive copies directly or indirectly through you, then

+the only way you could satisfy both it and this License would be to

+refrain entirely from distribution of the Library.

+

+If any portion of this section is held invalid or unenforceable under any

+particular circumstance, the balance of the section is intended to apply,

+and the section as a whole is intended to apply in other circumstances.

+

+It is not the purpose of this section to induce you to infringe any

+patents or other property right claims or to contest validity of any

+such claims; this section has the sole purpose of protecting the

+integrity of the free software distribution system which is

+implemented by public license practices.  Many people have made

+generous contributions to the wide range of software distributed

+through that system in reliance on consistent application of that

+system; it is up to the author/donor to decide if he or she is willing

+to distribute software through any other system and a licensee cannot

+impose that choice.

+

+This section is intended to make thoroughly clear what is believed to

+be a consequence of the rest of this License.

+

+  12. If the distribution and/or use of the Library is restricted in

+certain countries either by patents or by copyrighted interfaces, the

+original copyright holder who places the Library under this License may add

+an explicit geographical distribution limitation excluding those countries,

+so that distribution is permitted only in or among countries not thus

+excluded.  In such case, this License incorporates the limitation as if

+written in the body of this License.

+

+  13. The Free Software Foundation may publish revised and/or new

+versions of the Lesser General Public License from time to time.

+Such new versions will be similar in spirit to the present version,

+but may differ in detail to address new problems or concerns.

+

+Each version is given a distinguishing version number.  If the Library

+specifies a version number of this License which applies to it and

+"any later version", you have the option of following the terms and

+conditions either of that version or of any later version published by

+the Free Software Foundation.  If the Library does not specify a

+license version number, you may choose any version ever published by

+the Free Software Foundation.

+

+  14. If you wish to incorporate parts of the Library into other free

+programs whose distribution conditions are incompatible with these,

+write to the author to ask for permission.  For software which is

+copyrighted by the Free Software Foundation, write to the Free

+Software Foundation; we sometimes make exceptions for this.  Our

+decision will be guided by the two goals of preserving the free status

+of all derivatives of our free software and of promoting the sharing

+and reuse of software generally.

+

+			    NO WARRANTY

+

+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO

+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.

+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR

+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY

+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE

+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE

+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME

+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

+

+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN

+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY

+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU

+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR

+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE

+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING

+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A

+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF

+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

+DAMAGES.

+

+		     END OF TERMS AND CONDITIONS

+

+           How to Apply These Terms to Your New Libraries

+

+  If you develop a new library, and you want it to be of the greatest

+possible use to the public, we recommend making it free software that

+everyone can redistribute and change.  You can do so by permitting

+redistribution under these terms (or, alternatively, under the terms of the

+ordinary General Public License).

+

+  To apply these terms, attach the following notices to the library.  It is

+safest to attach them to the start of each source file to most effectively

+convey the exclusion of warranty; and each file should have at least the

+"copyright" line and a pointer to where the full notice is found.

+

+    <one line to give the library's name and a brief idea of what it does.>

+    Copyright (C) <year>  <name of author>

+

+    This library is free software; you can redistribute it and/or

+    modify it under the terms of the GNU Lesser General Public

+    License as published by the Free Software Foundation; either

+    version 2.1 of the License, or (at your option) any later version.

+

+    This library is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+    Lesser General Public License for more details.

+

+    You should have received a copy of the GNU Lesser General Public

+    License along with this library; if not, write to the Free Software

+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

+

+Also add information on how to contact you by electronic and paper mail.

+

+You should also get your employer (if you work as a programmer) or your

+school, if any, to sign a "copyright disclaimer" for the library, if

+necessary.  Here is a sample; alter the names:

+

+  Yoyodyne, Inc., hereby disclaims all copyright interest in the

+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.

+

+  <signature of Ty Coon>, 1 April 1990

+  Ty Coon, President of Vice

+

+That's all there is to it!

+

+

diff --git a/lib/xajax_0.2.4/README.txt b/lib/xajax_0.2.4/README.txt
new file mode 100644
index 0000000..c14ad80
--- /dev/null
+++ b/lib/xajax_0.2.4/README.txt
@@ -0,0 +1,106 @@
+====================================================================

+ xajax PHP Class Library

+ The easiest way to develop asynchronous Ajax applications with PHP

+

+ Version 0.2.4 (stable release)

+ README Text File

+

+ ------------------------------------------------------

+ | Release Notes:                                     |

+ | http://wiki.xajaxproject.org/0.2.4_Release_Notes   |

+ |                                                    |

+ | Lead Developers:                                   |

+ | Jared White (jared@intuitivefuture.com)            |

+ | J. Max Wilson (jmaxwilson@users.sourceforge.net)   |

+ | Eion Robb (eion@bigfoot.com)                       |

+ ------------------------------------------------------

+====================================================================

+

+ :: To find out what's changed since the 0.2.3 release of xajax, ::

+ :: view the Release Notes in the link above.                    ::

+

+1. Introduction

+

+xajax is a PHP library that you can include in your PHP scripts

+to provide an easy way for Web pages to call PHP functions or

+object methods using Ajax (Asynchronous Javascript And XML). Simply

+register one or more functions/methods with the xajax object that

+return a proper XML response using the supplied response class, add

+a statement in your HTML header to print the Javascript include,

+and run a request processor prior to outputting any HTML. Then add

+some simple Javascript function calls to your HTML, and xajax takes

+care of the rest!

+

+xajax includes a Javascript object to facilitate the communication

+between the browser and the server, and it can also be used as a

+Javascript library directly to simplify certain DOM and event

+manipulations. However, you can definitely choose to use a

+dedicated Javascript "engine" of your liking and integrate it with

+xajax's client/server communication features in a number of ways.

+More tightly-coupled integration will be forthcoming in a future

+version of xajax.

+

+2. For More Information

+

+The official xajax Web site is located at:

+http://www.xajaxproject.org

+

+Visit the xajax Forums at:

+http://community.xajaxproject.org

+to keep track of the latest news and participate in the community

+discussion.

+

+There is also a wiki with documentation, tips & tricks, and other

+information located at:

+http://wiki.xajaxproject.org

+

+3. Installation

+

+To run xajax, you need:

+* Apache Web Server or IIS for Windows XP/2003 Server

+   (other servers may or may not work and are not supported at this

+   time)

+* PHP 4.3.x or PHP 5.x

+* Minimum supported browsers: Internet Explorer 5.5, Firefox 1.0 (or

+   equivalent Gecko-based browser), Safari 1.3, Opera 8.5 (older

+   versions only work with GET requests)

+

+To install xajax:

+Unpack the contents of this archive and copy them to your main Web

+site folder. Or if you wish, you can put all of the files in a

+dedicated "xajax" folder on your Web server (make sure that you

+know what that URL is relative your site pages so you can provide

+xajax with the correct installed folder URL). Note that the

+
+"thewall" folder in the "examples" folder needs to be writable by
+

+the Web server for that example to function.

+

+Within the main xajax folder there are two folders: "examples"

+and "tests". You should be able to view these PHP pages from your

+Web browser and see xajax working in action. If you can view the

+pages but the AJAX calls are not working, there may be something

+wrong with your server setup or perhaps your browser is not

+supported or configured correctly. If worst comes to worst, post

+a message in our forums and someone may be able to help you.

+

+4. Documentation

+

+Detailed documentation for the xajax PHP classes is available on

+our wiki (URL listed above in section 2), and more is on the way

+(particularly in regards to the Javascript component of xajax).

+Another good way of learning xajax is to look at the code for the

+examples and tests. If you need any help, pop in the forums and

+ask for assistance (and the more specific your questions are,

+the better the answers will be).

+

+5. Contributing to xajax

+

+xajax is released under the LGPL open source license. If you wish

+to contribute to the project or suggest new features, introduce

+yourself on the forums or you can e-mail the lead developers at

+the addresses listed at the top of this README.

+

+6. Good luck and enjoy!

+

+====================================================================

diff --git a/lib/xajax_0.2.4/examples/helloworld.php b/lib/xajax_0.2.4/examples/helloworld.php
new file mode 100644
index 0000000..5b422ba
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/helloworld.php
@@ -0,0 +1,65 @@
+<?php
+// helloworld.php demonstrates a very basic xajax implementation
+// using xajax version 0.1 beta4
+// http://xajax.sourceforge.net
+
+require ('../xajax.inc.php');
+
+function helloWorld($isCaps)
+{
+	if ($isCaps)
+		$text = "HELLO WORLD!";
+	else
+		$text = "Hello World!";
+		
+	$objResponse = new xajaxResponse();
+	$objResponse->addAssign("div1","innerHTML",$text);
+	
+	return $objResponse;
+}
+
+function setColor($sColor)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAssign("div1","style.color", $sColor);
+	
+	return $objResponse;
+}
+
+// Instantiate the xajax object.  No parameters defaults requestURI to this page, method to POST, and debug to off
+$xajax = new xajax(); 
+
+//$xajax->debugOn(); // Uncomment this line to turn debugging on
+
+// Specify the PHP functions to wrap. The JavaScript wrappers will be named xajax_functionname
+$xajax->registerFunction("helloWorld");
+$xajax->registerFunction("setColor");
+
+// Process any requests.  Because our requestURI is the same as our html page,
+// this must be called before any headers or HTML output have been sent
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+	<title>xajax example</title>
+	<?php $xajax->printJavascript('../'); // output the xajax javascript. This must be called between the head tags ?>
+</head>
+<body style="text-align:center;">
+	<div id="div1" name="div1">&#160;</div>
+	<br/>
+	
+	<button onclick="xajax_helloWorld(0)" >Click Me</button>
+	<button onclick="xajax_helloWorld(1)" >CLICK ME</button>
+	<select id="colorselect" name="colorselect" onchange="xajax_setColor(document.getElementById('colorselect').value);">
+		<option value="black" selected="selected">Black</option>
+		<option value="red">Red</option>
+		<option value="green">Green</option>
+		<option value="blue">Blue</option>
+	</select>
+	<script type="text/javascript">
+	xajax_helloWorld(0); // call the helloWorld function to populate the div on load
+	xajax_setColor(document.getElementById('colorselect').value); // call the setColor function on load
+	</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/multiply/multiply.common.php b/lib/xajax_0.2.4/examples/multiply/multiply.common.php
new file mode 100644
index 0000000..59b6209
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/multiply/multiply.common.php
@@ -0,0 +1,11 @@
+<?php
+// multiply.php, multiply.common.php, multiply.server.php
+// demonstrate a very basic xajax implementation
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require_once ("../../xajax.inc.php");
+
+$xajax = new xajax("multiply.server.php");
+$xajax->registerFunction("multiply");
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/multiply/multiply.php b/lib/xajax_0.2.4/examples/multiply/multiply.php
new file mode 100644
index 0000000..f38b979
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/multiply/multiply.php
@@ -0,0 +1,22 @@
+<?php
+// multiply.php, multiply.common.php, multiply.server.php
+// demonstrate a very basic xajax implementation
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require("multiply.common.php");
+
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html> 
+	<head>
+		<title>xajax Multiplier</title> 
+		<?php $xajax->printJavascript('../../'); ?> 
+	</head> 
+	<body> 
+		<input type="text" name="x" id="x" value="2" size="3" /> * 
+		<input type="text" name="y" id="y" value="3" size="3" /> = 
+		<input type="text" name="z" id="z" value="" size="3" /> 
+		<input type="button" value="Calculate" onclick="xajax_multiply(document.getElementById('x').value,document.getElementById('y').value);return false;" />
+	</body> 
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/multiply/multiply.server.php b/lib/xajax_0.2.4/examples/multiply/multiply.server.php
new file mode 100644
index 0000000..0934cce
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/multiply/multiply.server.php
@@ -0,0 +1,16 @@
+<?php
+// multiply.php, multiply.common.php, multiply.server.php
+// demonstrate a very basic xajax implementation
+// using xajax version 0.2
+// http://xajaxproject.org
+
+function multiply($x, $y)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAssign("z", "value", $x*$y);
+	return $objResponse;
+}
+
+require("multiply.common.php");
+$xajax->processRequests();
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/signup/signup.common.php b/lib/xajax_0.2.4/examples/signup/signup.common.php
new file mode 100644
index 0000000..b6cc340
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/signup/signup.common.php
@@ -0,0 +1,13 @@
+<?php
+// signup.php, signup.common.php, signup.server.php
+// demonstrate a a simple implementation of a multipage signup form
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require_once ("../../xajax.inc.php");
+
+session_start();
+
+$xajax = new xajax("signup.server.php");
+$xajax->registerFunction("processForm");
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/signup/signup.php b/lib/xajax_0.2.4/examples/signup/signup.php
new file mode 100644
index 0000000..3c9674e
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/signup/signup.php
@@ -0,0 +1,60 @@
+<?php
+// signup.php, signup.common.php, signup.server.php
+// demonstrate a a simple implementation of a multipage signup form
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require_once('signup.common.php');
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+	<head>
+		<?php $xajax->printJavascript('../../'); ?>
+		<style type="text/css">
+		#formWrapper{
+			color: rgb(255,255,255);
+			background-color: rgb(149,67,97);
+			width: 200px;
+		}
+		#title{
+			text-align: center;
+			background-color: rgb(0,0,0);
+		}
+		#formDiv{
+			padding: 25px;
+		}
+		.submitDiv{
+			margin-top: 10px;
+			text-align: center;
+		}
+		</style>
+		<script type="text/javascript">
+		function submitSignup()
+		{
+			xajax.$('submitButton').disabled=true;
+			xajax.$('submitButton').value="please wait...";
+			xajax_processForm(xajax.getFormValues("signupForm"));
+			return false;
+		}
+		</script>
+	</head>
+	<body>
+		<div id="formWrapper">
+		
+			<div id="title">Create a New Account</div>
+			
+			<div id="formDiv">
+				<form id="signupForm" action="javascript:void(null);" onsubmit="submitSignup();">
+					<div>Username:</div><div><input type="text" name="username" /></div>
+					<div>Password:</div><div><input type="password" name="newPass1" /></div>
+					<div>Confirm Password:</div><div><input type="password" name="newPass2" /></div>
+					<div class="submitDiv"><input id="submitButton" type="submit" value="continue ->"/></div>
+				</form>
+			</div>
+			
+		</div>
+		
+		<div id="outputDiv">
+		</div>
+	</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/signup/signup.server.php b/lib/xajax_0.2.4/examples/signup/signup.server.php
new file mode 100644
index 0000000..4eda094
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/signup/signup.server.php
@@ -0,0 +1,111 @@
+<?php
+// signup.php, signup.common.php, signup.server.php
+// demonstrate a a simple implementation of a multipage signup form
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require_once ("signup.common.php");
+
+function processForm($aFormValues)
+{
+	if (array_key_exists("username",$aFormValues))
+	{
+		return processAccountData($aFormValues);
+	}
+	else if (array_key_exists("firstName",$aFormValues))
+	{
+		return processPersonalData($aFormValues);
+	}
+}
+
+function processAccountData($aFormValues)
+{
+	$objResponse = new xajaxResponse();
+	
+	$bError = false;
+	
+	if (trim($aFormValues['username']) == "")
+	{
+		$objResponse->addAlert("Please enter a username.");
+		$bError = true;
+	}
+	if (trim($aFormValues['newPass1']) == "")
+	{
+		$objResponse->addAlert("You may not have a blank password.");
+		$bError = true;
+	}
+	if ($aFormValues['newPass1'] != $aFormValues['newPass2'])
+	{
+		$objResponse->addAlert("Passwords do not match.  Try again.");
+		$bError = true;
+	}
+
+	if (!$bError)
+	{
+		$_SESSION = array();
+		$_SESSION['newaccount']['username'] = trim($aFormValues['username']);
+		$_SESSION['newaccount']['password'] = trim($aFormValues['newPass1']);
+		
+		$sForm = "<form id=\"signupForm\" action=\"javascript:void(null);\" onsubmit=\"submitSignup();\">";
+		$sForm .="<div>First Name:</div><div><input type=\"text\" name=\"firstName\" /></div>";
+		$sForm .="<div>Last Name:</div><div><input type=\"text\" name=\"lastName\" /></div>";
+		$sForm .="<div>Email:</div><div><input type=\"text\" name=\"email\" /></div>";
+		$sForm .="<div class=\"submitDiv\"><input id=\"submitButton\" type=\"submit\" value=\"done\"/></div>";
+		$sForm .="</form>";
+		$objResponse->addAssign("formDiv","innerHTML",$sForm);
+		$objResponse->addAssign("formWrapper","style.backgroundColor", "rgb(67,149,97)");
+		$objResponse->addAssign("outputDiv","innerHTML","\$_SESSION:<pre>".var_export($_SESSION,true)."</pre>");
+	}
+	else
+	{
+		$objResponse->addAssign("submitButton","value","continue ->");
+		$objResponse->addAssign("submitButton","disabled",false);
+	}
+	
+	return $objResponse;
+}
+
+function processPersonalData($aFormValues)
+{
+	$objResponse = new xajaxResponse();
+	
+	$bError = false;
+	if (trim($aFormValues['firstName']) == "")
+	{
+		$objResponse->addAlert("Please enter your first name.");
+		$bError = true;
+	}
+	if (trim($aFormValues['lastName']) == "")
+	{
+		$objResponse->addAlert("Please enter your last name.");
+		$bError = true;
+	}
+	if (!eregi("^[a-zA-Z0-9]+[_a-zA-Z0-9-]*(\.[_a-z0-9-]+)*@[a-z??????0-9]+(-[a-z??????0-9]+)*(\.[a-z??????0-9-]+)*(\.[a-z]{2,4})$", $aFormValues['email']))
+	{
+		$objResponse->addAlert("Please enter a valid email address.");
+		$bError = true;
+	}
+
+	if (!$bError)
+	{
+		$_SESSION['newaccount']['firstname'] = $aFormValues['firstName'];
+		$_SESSION['newaccount']['lastname'] = $aFormValues['lastName'];
+		$_SESSION['newaccount']['email'] = $aFormValues['email'];
+		
+		$objResponse->addAssign("formDiv","style.textAlign","center");
+		$sForm = "Account created.<br />Thank you.";
+		$objResponse->addAssign("formDiv","innerHTML",$sForm);
+		$objResponse->addAssign("formWrapper","style.backgroundColor", "rgb(67,97,149)");
+		$objResponse->addAssign("outputDiv","innerHTML","\$_SESSION:<pre>".var_export($_SESSION,true)."</pre>");
+	}
+	else
+	{
+		$objResponse->addAssign("submitButton","value","done");
+		$objResponse->addAssign("submitButton","disabled",false);
+	}
+	
+	return $objResponse;
+}
+
+$xajax->processRequests();
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/thewall/brick.jpg b/lib/xajax_0.2.4/examples/thewall/brick.jpg
new file mode 100644
index 0000000..6cb2509
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/thewall/brick.jpg
diff --git a/lib/xajax_0.2.4/examples/thewall/thewall.common.php b/lib/xajax_0.2.4/examples/thewall/thewall.common.php
new file mode 100644
index 0000000..0704206
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/thewall/thewall.common.php
@@ -0,0 +1,12 @@
+<?php
+// thewall.php, thewall.common.php, thewall.server.php
+// demonstrate a demonstrates a xajax implementation of a graffiti wall
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require_once ("../../xajax.inc.php");
+
+$xajax = new xajax("thewall.server.php");
+$xajax->registerFunction("scribble");
+$xajax->registerFunction("updateWall");
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/thewall/thewall.php b/lib/xajax_0.2.4/examples/thewall/thewall.php
new file mode 100644
index 0000000..3516013
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/thewall/thewall.php
@@ -0,0 +1,70 @@
+<?php
+// thewall.php, thewall.common.php, thewall.server.php
+// demonstrate a demonstrates a xajax implementation of a graffiti wall
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require_once("thewall.common.php");
+
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+	<head>
+		<title>The Graffiti Wall</title>
+		<?php $xajax->printJavascript('../../'); ?>
+		<script>
+		function update()
+		{
+			xajax_updateWall();
+			setTimeout("update()", 30000);
+		}
+		</script>
+		<style type="text/css">
+		div.label{
+			clear: both;
+			float:left;
+			width:60px;
+			text-align:right;
+			font-size: small;
+		}
+		#handle{
+			font-size: x-small;
+			width: 100px;
+		}
+		#words{
+			font-size: x-small;
+			width: 400px;
+		}
+		#post{
+			font-size: small;
+			margin-left: 390px;
+		}
+		#theWall{
+			background-image: url('brick.jpg');
+			height: 300px;
+			padding: 50px;
+			border: 3px outset black;
+			overflow: auto;
+		}
+		.notice{
+			font-size: small;
+		}
+		</style>
+	</head>
+	<body>
+		<form id="scribbleForm" onsubmit="return false;">
+			<div class="label">Handle:</div><input id="handle" name="handle" type="text" /><div></div>
+			<div class="label">Graffiti:</div><input id="words" name="words"type="text" maxlength="75"/><div></div>
+			<input id="post" type="submit" value="scribble" onclick="xajax_scribble(xajax.getFormValues('scribbleForm'));" />
+		</form>
+		<div class="notice">To see xajax's UTF-8 support, try posting words in other languages.  You can copy and paste from <a href="http://www.unicode.org/iuc/iuc10/x-utf8.html" target="_new">here</a></div>
+		<div id="theWall">
+		</div>
+		<div style="text-align:center;">
+		powered by <a href="http://www.xajaxproject.org">xajax</a>
+		</div>
+		<script>
+			update();
+		</script>
+	</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/thewall/thewall.server.php b/lib/xajax_0.2.4/examples/thewall/thewall.server.php
new file mode 100644
index 0000000..0a4a912
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/thewall/thewall.server.php
@@ -0,0 +1,144 @@
+<?php
+// thewall.php, thewall.common.php, thewall.server.php
+// demonstrate a demonstrates a xajax implementation of a graffiti wall
+// using xajax version 0.2
+// http://xajaxproject.org
+
+if (!defined ('MAX_SCRIBBLES'))
+{
+	define ('MAX_SCRIBBLES', 5);
+}
+
+if (!defined ('DATA_FILE'))
+{
+	define ('DATA_FILE', "thewall.dta");
+}
+
+class graffiti
+{
+	var $html;
+	var $isValid = false;
+	
+	function graffiti($sHandle, $sWords)
+	{
+		if (trim($sHandle) == "" || trim($sWords) == "")
+		{
+			return;
+		}
+		$this->html  = "\n<div style=\"font-weight: bold;text-align:".$this->getRandomAlignment();
+		$this->html .= ";color:".$this->getRandomColor().";\">";
+		$this->html .= "<span style=\"font-size:".$this->getRandomFontSize()."%;\">";
+		$this->html .= strip_tags(stripslashes($sWords));
+		$this->html .= "</span><br/><span style=\"font-size: small;\">";
+		$this->html .= " ~ ".strip_tags(stripslashes($sHandle))." ".date("m/d/Y H:i:s")."</span></div>";
+		
+		$this->isValid = true;
+	}
+	
+	function getRandomFontSize()
+	{
+		srand((double)microtime()*1000003);
+		return rand(100,300);
+	}
+	
+	function getRandomColor()
+	{
+		$sColor = "rgb(";
+		srand((double)microtime()*1000003);
+		$sColor .= rand(0,255).",";
+		srand((double)microtime()*1000003);
+		$sColor .= rand(0,255).",";
+		$sColor .= rand(0,255).")";
+		
+		return $sColor;
+	}
+	
+	function getRandomAlignment()
+	{
+		$sAlign = "";
+		srand((double)microtime()*1000003);
+		$textAlign = rand(0,2);
+		switch($textAlign)
+		{
+			case 0: $sAlign = "left"; break;
+			case 1: $sAlign = "right"; break;
+			case 2: $sAlign = "center"; break;
+			
+		}
+		return $sAlign;
+	}
+	
+	function save()
+	{
+		if ($this->isValid)
+		{
+			$rFile = @fopen(DATA_FILE,"a+");
+			if (!$rFile) {
+				return "ERROR: the graffiti data file could not be written to the " . dirname(realpath(DATA_FILE)) . " folder.";
+			}
+			fwrite($rFile, $this->html);
+			fclose($rFile);
+			return null;
+		}
+		else
+		{
+			return "Please supply both a handle and some graffiti to scribble on the wall.";
+		}
+	}
+}
+
+function scribble($aFormValues)
+{
+	$sHandle = $aFormValues['handle'];
+	$sWords = $aFormValues['words'];
+	$objResponse = new xajaxResponse();
+	
+	$objGraffiti = new graffiti($sHandle,$sWords);
+	$sErrMsg = $objGraffiti->save();
+	if (!$sErrMsg)
+	{
+		$objResponse->addScript("xajax_updateWall();");
+		$objResponse->addClear("words","value");
+	}
+	else
+		$objResponse->addAlert($sErrMsg);
+	
+	return $objResponse;
+}
+
+function updateWall()
+{
+	$objResponse = new xajaxResponse();
+	
+	if (file_exists(DATA_FILE)) {
+		$aFile = @file(DATA_FILE);
+		if (!$aFile) {
+			$objResponse->addAlert("ERROR: the graffiti data file could not be written to the " . dirname(realpath(DATA_FILE)) . " folder.");
+			return $objResponse;
+		}
+		
+		$sHtmlSave = implode("\n",array_slice($aFile, -MAX_SCRIBBLES));
+		$sHtmlSave=str_replace("\n\n","\n",$sHtmlSave);
+	}
+	else {
+		$sHtmlSave = "";
+		$aFile = array();
+	}
+	$rFile = @fopen(DATA_FILE,"w+");
+	if (!$rFile) {
+		$objResponse->addAlert("ERROR: the graffiti data file could not be written to the " . dirname(realpath(DATA_FILE)) . " folder.");
+		return $objResponse;
+	}
+	fwrite($rFile, $sHtmlSave);
+	fclose($rFile);
+	
+	$sHtml = implode("\n",array_reverse(array_slice($aFile, -MAX_SCRIBBLES)));
+	
+	$objResponse->addAssign("theWall","innerHTML",$sHtml);
+
+	return $objResponse;
+}
+
+require("thewall.common.php");
+$xajax->processRequests();
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/xul/xulApplication.php b/lib/xajax_0.2.4/examples/xul/xulApplication.php
new file mode 100644
index 0000000..3026089
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/xul/xulApplication.php
@@ -0,0 +1,36 @@
+<?php
+// xulApplication.php demonstrates a XUL application with xajax
+// XUL will only work in Mozilla based browsers like Firefox
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require_once("../../xajax.inc.php");
+
+function test() {
+        $objResponse = new xajaxResponse();
+        $objResponse->addAlert("hallo");
+        $objResponse->addAssign('testButton','label','Success!');
+        return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+$xajax->registerFunction("test");
+$xajax->processRequests();
+
+header("Content-Type: application/vnd.mozilla.xul+xml");
+?>
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
+<window id="example-window" title="Exemple 2.2.1"
+        xmlns:html="http://www.w3.org/1999/xhtml"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+    <script type="application/x-javascript">
+		var xajaxRequestUri="xulServer.php";
+		var xajaxDebug=false;
+		var xajaxStatusMessages=false;
+		var xajaxDefinedGet=0;
+		var xajaxDefinedPost=1;
+	</script>
+	<script type="application/x-javascript" src="../../xajax_js/xajax.js"></script>
+    <button id="testButton" oncommand="xajax.call('test',[]);" label="Test" />
+</window>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/examples/xul/xulClient.xul b/lib/xajax_0.2.4/examples/xul/xulClient.xul
new file mode 100644
index 0000000..5f9eff9
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/xul/xulClient.xul
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
+<window id="example-window" title="Exemple 2.2.1"
+        xmlns:html="http://www.w3.org/1999/xhtml"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+    <script type="application/x-javascript">
+		var xajaxRequestUri="xulServer.php";
+		var xajaxDebug=false;
+		var xajaxStatusMessages=false;
+		var xajaxDefinedGet=0;
+		var xajaxDefinedPost=1;
+	</script>
+	<script type="application/x-javascript" src="../../xajax_js/xajax.js"></script>
+    <button id="testButton" oncommand="xajax.call('test',[]);" label="Test" />
+</window>
diff --git a/lib/xajax_0.2.4/examples/xul/xulServer.php b/lib/xajax_0.2.4/examples/xul/xulServer.php
new file mode 100644
index 0000000..7ea7a7e
--- /dev/null
+++ b/lib/xajax_0.2.4/examples/xul/xulServer.php
@@ -0,0 +1,19 @@
+<?php
+// xulServer.php demonstrates a XUL application with xajax
+// XUL will only work in Mozilla based browsers like Firefox
+// using xajax version 0.2
+// http://xajaxproject.org
+
+require_once("../../xajax.inc.php");
+
+function test() {
+        $objResponse = new xajaxResponse();
+        $objResponse->addAlert("hallo");
+        $objResponse->addAssign('testButton','label','Success!');
+        return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+$xajax->registerFunction("test");
+$xajax->processRequests();
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/HTTPStatusTest.php b/lib/xajax_0.2.4/tests/HTTPStatusTest.php
new file mode 100644
index 0000000..59aee14
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/HTTPStatusTest.php
@@ -0,0 +1,41 @@
+<?php
+require_once("../xajax.inc.php");
+
+function returnStatus($number)
+{
+	if ($number == 500) {
+		header("HTTP/1.1 500 Internal Server Error");
+		echo "Testing a server error...";
+	}
+	if ($number == 404) {
+		header("HTTP/1.1 404 Not Found");
+		echo "Testing an unknown URL...";
+	}
+	exit;
+}
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("returnStatus");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>HTTP Status Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>HTTP Status Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="submit" value="Return a 500 Internal Server Error" onclick="xajax_returnStatus(500); return false;" /></p>
+<p><input type="submit" value="Return a 404 Not Found Error" onclick="xajax_returnStatus(404); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/catchAllFunctionTest.php b/lib/xajax_0.2.4/tests/catchAllFunctionTest.php
new file mode 100644
index 0000000..8d103f2
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/catchAllFunctionTest.php
@@ -0,0 +1,50 @@
+<?php
+require_once("../xajax.inc.php");
+
+function test2ndFunction($formData, $objResponse)
+{
+	$objResponse->addAlert("formData: " . print_r($formData, true));
+	$objResponse->addAssign("submittedDiv", "innerHTML", nl2br(print_r($formData, true)));
+	return $objResponse->getXML();
+}
+
+function myCatchAllFunction($funcName, $args)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("This is from the catch all function");
+//	return $objResponse;
+	return test2ndFunction($args[0], $objResponse);
+}
+
+function testForm($formData)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("This is from the regular function");
+	return test2ndFunction($formData, $objResponse);
+}
+$xajax = new xajax();
+$xajax->registerCatchAllFunction("myCatchAllFunction");
+//$xajax->registerFunction("testForm");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Catch-all Function Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Catch-all Function Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="text" id="textBox1" name="textBox1" value="This is some text" /></p>
+<p><input type="submit" value="Submit Normal" onclick="xajax.call('testForm', [xajax.getFormValues('testForm1')]); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/changeEventTest.php b/lib/xajax_0.2.4/tests/changeEventTest.php
new file mode 100644
index 0000000..8fb8269
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/changeEventTest.php
@@ -0,0 +1,38 @@
+<?php
+require_once("../xajax.inc.php");
+
+function addEvent($sId,$sCode)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addEvent($sId, "onclick", $sCode);
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("addEvent");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Change Event Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Change Event Test </h1>
+
+<div id="myDiv"" style="padding: 3px; display: table; border: 1px outset black; font-size: large; margin-bottom: 10px;">Click Me</div>
+
+<form id="testForm1" onsubmit="return false;">
+<div><input type="submit" value="Set onclick to something" onclick="xajax_addEvent('myDiv','alert(\'Something\');'); return false;" /></div>
+<div><input type="submit" value="Set onclick to something else" onclick="xajax_addEvent('myDiv','alert(\'Something Else\');'); return false;" /></div>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/charEncodingTest.php b/lib/xajax_0.2.4/tests/charEncodingTest.php
new file mode 100644
index 0000000..e2a4c8c
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/charEncodingTest.php
@@ -0,0 +1,130 @@
+<?php
+require_once("../xajax.inc.php");
+
+function setOptions($formData)
+{
+	$_SESSION['useEncoding'] = $formData['useEncoding'];
+	$_SESSION['htmlEntities'] = (boolean)$formData['htmlEntities'];
+	$_SESSION['decodeUTF8'] = (boolean)$formData['decodeUTF8'];
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("Your options have been saved.");
+	return $objResponse;
+}
+
+function testForm($strText, $formData, $arrArray)
+{
+	global $useEncoding, $htmlEntities;
+	$objResponse = new xajaxResponse($useEncoding, $htmlEntities);
+	$data = "Text:\n" . $strText;
+	$data .= "\n\nFormData:\n" . print_r($formData, true);
+	$data .= "\n\nArray:\n" .print_r($arrArray, true); 
+	$objResponse->addAlert($data);
+	$objResponse->addAssign("submittedDiv", "innerHTML", "<pre>".$data."</pre>");
+	return $objResponse->getXML();
+}
+
+$useEncoding = "UTF-8";
+$htmlEntities = false;
+$decodeUTF8 = false;
+
+session_start();
+session_name("xajaxCharEncodingTest");
+
+if (@$_GET['refresh'] == "yes") {
+	session_destroy();
+	header("location: charEncodingTest.php");
+	exit();
+}
+
+if (isset($_SESSION['useEncoding'])) {
+	$useEncoding = $_SESSION['useEncoding'];	
+}
+if (isset($_SESSION['htmlEntities'])) {
+	$htmlEntities = $_SESSION['htmlEntities'];	
+}
+if (isset($_SESSION['decodeUTF8'])) {
+	$decodeUTF8 = $_SESSION['decodeUTF8'];	
+}
+
+$xajax = new xajax();
+$xajax->setCharEncoding($useEncoding);
+if ($htmlEntities) {
+	$xajax->outputEntitiesOn();	
+}
+if ($decodeUTF8) {
+	$xajax->decodeUTF8InputOn();
+}
+//$xajax->debugOn();
+$xajax->registerFunction("setOptions");
+$xajax->registerFunction("testForm");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Character Encoding Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+<script type="text/javascript">
+function getTestArray()
+{
+	var text = xajax.$('textField1').value;
+	var testArray = new Array();
+	testArray[0] = text;
+	testArray[1] = text;
+	testArray[2] = new Array();
+	testArray[2][0] = text;
+	testArray[2][1] = text; 
+	testArray[3] = new Array();
+	testArray[3][0] = text;
+	testArray[3][1] = text;
+	testArray[3][2] = new Array();
+	testArray[3][2][0] = text;
+	testArray[3][2][1] = text;
+	
+	return testArray;
+}
+
+function callXajax()
+{
+	var txt = xajax.$('textField1').value;
+	var frm = xajax.getFormValues('testForm1');
+	var arr = getTestArray();
+	xajax_testForm(txt,frm,arr);
+}
+</script>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Character Encoding Test</h1>
+
+<h2>Options Form</h2>
+
+<p><strong>NOTE:</strong> if you change these options, make sure you click the Save Options button or the options won't be used.</p>
+
+<form id="optionsForm" onsubmit="return false;">
+<p>Encoding: <input type="text" value="<?php echo $useEncoding ?>" name="useEncoding" /><br />
+Output HTML Entities? <input type="radio" name="htmlEntities" value="1" <?php if ($htmlEntities) echo ' checked="checked"' ?>/> Yes
+ <input type="radio" name="htmlEntities" value="0" <?php if (!$htmlEntities) echo ' checked="checked"' ?>/> No<br />
+Decode UTF-8 Input? <input type="radio" name="decodeUTF8" value="1" <?php if ($decodeUTF8) echo ' checked="checked"' ?>/> Yes
+ <input type="radio" name="decodeUTF8" value="0" <?php if (!$decodeUTF8) echo ' checked="checked"' ?>/> No<br />
+<p><input type="submit" value="Save Options" onclick="xajax_setOptions(xajax.getFormValues('optionsForm')); return false;" /></p>
+</form>
+
+<p><a href="charEncodingTest.php?refresh=yes">Clear and Refresh</a></p>
+
+<h2>Text Test Form</h2>
+
+<p><a href="http://www.i18nguy.com/unicode-example.html" target="_blank">Here are some Unicode examples</a> you can paste into the text box below. You can see <a href="http://www.unicode.org/iuc/iuc10/languages.html" target="_blank">more examples and a list of standard encoding schemes here</a>.</p>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="text" value="Enter test text here" id="textField1" name="textField1" size="60" /></p>
+<p><input type="submit" value="Submit Text" onclick="callXajax(); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+<div id="debugDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/confirmTest.php b/lib/xajax_0.2.4/tests/confirmTest.php
new file mode 100644
index 0000000..c61637f
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/confirmTest.php
@@ -0,0 +1,37 @@
+<?php
+require_once("../xajax.inc.php");
+
+function confirmTest()
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("Here is an alert.");
+	$objResponse->addConfirmCommands(2, "Are you sure you want to show two (2) more alerts?");
+	$objResponse->addAlert("This will only happen if the user presses OK.");
+	$objResponse->addAlert("This also will only happen if the user presses OK.");
+	$objResponse->addAlert("This will always happen.");
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("confirmTest");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Confirm Commands Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Confirm Commands Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="submit" value="Perform Test" onclick="xajax_confirmTest(); return false;" /></p>
+</form>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/createFormInputTest.php b/lib/xajax_0.2.4/tests/createFormInputTest.php
new file mode 100644
index 0000000..0284260
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/createFormInputTest.php
@@ -0,0 +1,129 @@
+<?php
+require_once("../xajax.inc.php");
+
+// tests the select form
+function testForm($formData)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("formData: " . print_r($formData, true));
+	$objResponse->addAssign("submittedDiv", "innerHTML", nl2br(print_r($formData, true)));
+	return $objResponse->getXML();
+}
+
+// adds an option to the select 
+function addInput($aInputData)
+{
+	$sId = $aInputData['inputId'];
+	$sName = $aInputData['inputName'];
+	$sType = $aInputData['inputType'];
+	$sValue = $aInputData['inputValue'];
+	
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("inputData: " . print_r($aInputData, true));
+	$objResponse->addCreateInput("testForm1", $sType, $sName, $sId);
+	$objResponse->addAssign($sId, "value", $sValue);
+	return $objResponse->getXML();
+}
+
+// adds an option to the select 
+function insertInput($aInputData)
+{
+	$sId = $aInputData['inputId'];
+	$sName = $aInputData['inputName'];
+	$sType = $aInputData['inputType'];
+	$sValue = $aInputData['inputValue'];
+	$sBefore = $aInputData['inputBefore'];
+	
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("inputData: " . print_r($aInputData, true));
+	$objResponse->addInsertInput($sBefore, $sType, $sName, $sId);
+	$objResponse->addAssign($sId, "value", $sValue);
+	return $objResponse->getXML();
+}
+
+// adds an option to the select 
+function insertInputAfter($aInputData)
+{
+	$sId = $aInputData['inputId'];
+	$sName = $aInputData['inputName'];
+	$sType = $aInputData['inputType'];
+	$sValue = $aInputData['inputValue'];
+	$sAfter = $aInputData['inputAfter'];
+	
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("inputData: " . print_r($aInputData, true));
+	$objResponse->addInsertInputAfter($sAfter, $sType, $sName, $sId);
+	$objResponse->addAssign($sId, "value", $sValue);
+	return $objResponse->getXML();
+}
+
+function removeInput($aInputData)
+{
+	$sId = $aInputData['inputId'];
+	
+	$objResponse = new xajaxResponse();
+	
+	$objResponse->addRemove($sId);
+
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("testForm");
+$xajax->registerFunction("addInput");
+$xajax->registerFunction("insertInput");
+$xajax->registerFunction("insertInputAfter");
+$xajax->registerFunction("removeInput");
+
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+	<head>
+		<title>Create Form Input Test| xajax Tests</title>
+		<?php $xajax->printJavascript("../", "xajax_js/xajax_uncompressed.js") ?>
+	</head>
+	<body>
+		<h2><a href="index.php">xajax Tests</a></h2>
+		<h1>Create Form Input Test</h1>
+		
+		<div>
+			<form id="testForm1" onsubmit="return false;">
+				<div><input type="submit" value="submit" onclick="xajax_testForm(xajax.getFormValues('testForm1')); return false;" /></div>
+			</form>
+		</div>
+
+		<div style="margin-top: 20px;">
+			<form id="testForm2" onsubmit="return false;">
+				<div>type:</div>
+				<select id="inputType" name="inputType">
+					<option value="text" selected="selected">text</option>
+					<option value="password">password</option>
+					<option value="hidden">hidden</option>
+					<option value="radio">radio</option>
+					<option value="checkbox">checkbox</option>
+				</select>
+				<div>Id:</div>
+				<input type="text" id="inputId" name="inputId" value="input1" />
+				<div>Name:</div>
+				<input type="text" id="inputName" name="inputName" value="input1" />
+				<div>Value:</div>
+				<input type="text" id="inputValue" name="inputValue" value="1" />
+				
+				<div>
+				<input type="submit" value="Add" onclick="xajax_addInput(xajax.getFormValues('testForm2')); return false;" />
+				<input type="submit" value="Remove" onclick="xajax_removeInput(xajax.getFormValues('testForm2')); return false;" />
+				<br />
+				<input type="submit" value="Insert Before:" onclick="xajax_insertInput(xajax.getFormValues('testForm2')); return false;" /><input type="text" id="inputBefore" name="inputBefore" value="" />
+				<br />
+				<input type="submit" value="Insert After:" onclick="xajax_insertInputAfter(xajax.getFormValues('testForm2')); return false;" /><input type="text" id="inputAfter" name="inputAfter" value="" />				
+				</div>
+			</form>
+		</div>
+
+		<div id="submittedDiv" style="margin: 3px;"></div>
+		
+	</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/customResponseClassTest.php b/lib/xajax_0.2.4/tests/customResponseClassTest.php
new file mode 100644
index 0000000..09036ea
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/customResponseClassTest.php
@@ -0,0 +1,87 @@
+<?php
+require_once("../xajax.inc.php");
+
+// Custom Response Class extends xajaxResponse
+class customXajaxResponse extends xajaxResponse
+{  
+    function addCreateOption($sSelectId, $sOptionId, $sOptionText, $sOptionValue)  
+    {  
+        $this->addScript("addOption('".$sSelectId."','".$sOptionId."','".$sOptionText."','".$sOptionValue."');");
+    }
+}
+
+// tests the select form
+function testForm($formData)
+{
+	$objResponse = new customXajaxResponse();
+	$objResponse->addAlert("formData: " . print_r($formData, true));
+	$objResponse->addAssign("submittedDiv", "innerHTML", nl2br(print_r($formData, true)));
+	return $objResponse->getXML();
+}
+
+// adds an option to the select 
+function addOption($selectId, $optionData)
+{
+	$objResponse = new customXajaxResponse();
+	$objResponse->addCreateOption($selectId, $optionData['optionId'], $optionData['optionText'], $optionData['optionValue']);
+	$objResponse->addAssign("submittedDiv", "innerHTML", nl2br(print_r($optionData, true)));
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("testForm");
+$xajax->registerFunction("addOption");
+
+
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+	<head>
+		<title>Custom Response Class Test| xajax Tests</title>
+		<script type="text/javascript">
+		//javascript function to add an option to a select box
+		function addOption(selectId,optionId,txt,val)
+		{
+		    var objOption = new Option(txt,val);
+		    objOption.id = optionId;
+		    document.getElementById(selectId).options.add(objOption);
+		}
+		</script>
+
+		<?php $xajax->printJavascript("../") ?>
+	</head>
+	<body>
+		<h2><a href="index.php">xajax Tests</a></h2>
+		<h1>Custom Response Class Test</h1>
+
+		<div>
+			<form id="testForm1" onsubmit="return false;">
+				<div>Select</div>
+				<select id="selectBox" name="selectBox">
+				</select>
+				<div><input type="submit" value="submit" onclick="xajax_testForm(xajax.getFormValues('testForm1')); return false;" /></div>
+			</form>
+		</div>
+
+		<div style="margin-top: 20px;">
+			<form id="testForm2" onsubmit="return false;">
+				<fieldset style="display:inline; background-color: rgb(230,230,230);">
+					<legend>New Option</legend>
+					<div>Id:</div>
+					<input type="text" id="optionId" name="optionId" value="option1" />
+					<div>Text:</div>
+					<input type="text" id="optionText" name="optionText" value="One" />
+					<div>Value:</div>
+					<input type="text" id="optionValue" name="optionValue" value="1" />
+					<div><input type="submit" value="Add" onclick="xajax_addOption('selectBox',xajax.getFormValues('testForm2')); return false;" />					</div>
+				</fieldset>
+			</form>
+		</div>
+
+		<div id="submittedDiv" style="margin: 3px;"></div>
+		
+	</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/disabledFormElementsTest.php b/lib/xajax_0.2.4/tests/disabledFormElementsTest.php
new file mode 100644
index 0000000..9c4ba7e
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/disabledFormElementsTest.php
@@ -0,0 +1,39 @@
+<?php
+require_once("../xajax.inc.php");
+
+function testForm($formData)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("formData: " . print_r($formData, true));
+	$objResponse->addAssign("submittedDiv", "innerHTML", nl2br(print_r($formData, true)));
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("testForm");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Disabled Form Elements Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Disabled Form Elements Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="text" id="textBox1" name="textBox1" value="This is enabled" /></p>
+<p><input type="text" id="textBox2" name="textBox2" disabled="true" value="This is disabled" /></p>
+<p><input type="submit" value="Submit Normal" onclick="xajax_testForm(xajax.getFormValues('testForm1')); return false;" /></p>
+<p><input type="submit" value="Submit Everything" onclick="xajax_testForm(xajax.getFormValues('testForm1', true)); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/errorHandlingTest.php b/lib/xajax_0.2.4/tests/errorHandlingTest.php
new file mode 100644
index 0000000..ec8b002
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/errorHandlingTest.php
@@ -0,0 +1,40 @@
+<?php
+require_once("../xajax.inc.php");
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->errorHandlerOn();
+$xajax->setLogFile("xajax_error_log.log");
+
+function myErrorRiddenFunction()
+{
+	$value = $silly['nuts'];
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("Bad array value: $value");
+	include("file_doesnt_exist.php");
+	return $objResponse->getXML();
+}
+
+$xajax->registerFunction("myErrorRiddenFunction");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Error Handling Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Error Handling Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="submit" value="Call Error Ridden Function" onclick="xajax_myErrorRiddenFunction(); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/eventHandlerTest.php b/lib/xajax_0.2.4/tests/eventHandlerTest.php
new file mode 100644
index 0000000..89a25ed
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/eventHandlerTest.php
@@ -0,0 +1,64 @@
+<?php
+require_once("../xajax.inc.php");
+
+function addHandler($sId,$sHandler)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addHandler($sId, "click", $sHandler);
+	return $objResponse->getXML();
+}
+
+function removeHandler($sId,$sHandler)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addRemoveHandler($sId, "click", $sHandler);
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("addHandler");
+$xajax->registerFunction("removeHandler");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Event Handler Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+<script type="text/javascript">
+function clickHandler1()
+{
+	alert('Click Handler 1');
+}
+function clickHandler2()
+{
+	alert('Click Handler 2');
+}
+</script>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Event Handler Test</h1>
+
+
+<div id="myDiv" style="padding: 3px; display: table; border: 1px outset black; font-size: large; margin-bottom: 10px;">Click Me</div>
+
+<form id="testForm1" onsubmit="return false;">
+<div>
+<input type="submit" value="Add Handler1 to Div" onclick="xajax_addHandler('myDiv','clickHandler1'); return false;" />
+<input type="submit" value="Remove Handler1 from Div" onclick="xajax_removeHandler('myDiv','clickHandler1'); return false;" />
+</div>
+<div>
+<input type="submit" value="Add Handler2 to Div" onclick="xajax_addHandler('myDiv','clickHandler2'); return false;" />
+<input type="submit" value="Remove Handler2 from Div" onclick="xajax_removeHandler('myDiv','clickHandler2'); return false;" />
+</div>
+
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/formSubmissionTest.php b/lib/xajax_0.2.4/tests/formSubmissionTest.php
new file mode 100644
index 0000000..c91216c
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/formSubmissionTest.php
@@ -0,0 +1,107 @@
+<?php
+require_once("../xajax.inc.php");
+
+function testForm($formData)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("formData: " . print_r($formData, true));
+	$objResponse->addAssign("submittedDiv", "innerHTML", nl2br(print_r($formData, true)));
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("testForm");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Form Submission Test| xajax Tests</title>
+<style type="text/css">
+fieldset > div
+{
+	border: 1px solid gray;
+	padding: 5px;
+	background-color: white;
+}
+</style>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Form Submission Test</h1>
+
+<div>
+<form id="testForm1" onsubmit="return false;">
+<fieldset style="display:inline; background-color: rgb(230,230,230);">
+<legend>Test Form</legend>
+<div style="margin: 3px;">
+<div>Text Input</div>
+<input type="text" id="textInput" name="textInput" value="text" />
+</div>
+
+<div style="margin: 3px;">
+<div>Password Input</div>
+<input type="password" id="textInput" name="passwordInput" value="2br!2b" />
+</div>
+
+<div style="margin: 3px;">
+<div>Textarea</div>
+<textarea id="textarea" name="textarea">text text</textarea>
+</div>
+
+<div style="margin: 3px;">
+<div>
+<input type="checkbox" id="checkboxInput1" name="checkboxInput[]" value="true" checked="checked" />
+<label for="checkboxInput1">Checkbox Input 1</label>
+</div>
+<div>
+<input type="checkbox" id="checkboxInput2" name="checkboxInput[]" value="true" checked="checked" />
+<label for="checkboxInput2">Checkbox Input 2</label>
+</div>
+</div>
+
+<div style="margin: 3px;">
+<div>Radio Input</div>
+<div>
+<input type="radio" id="radioInput1" name="radioInput" value="1" checked="checked" />
+<label for="radioInput1">One</label>
+</div>
+<div>
+<input type="radio" id="radioInput2" name="radioInput" value="2" />
+<label for="radioInput2">Two</label>
+</div>
+</div>
+
+<div style="margin: 3px;">
+<div>Select</div>
+<select id="select" name="select">
+<option value="1">One</option>
+<option value="2">Two</option>
+<option value="3">Three</option>
+<option value="4">Four</option>
+</select>
+</div>
+
+<div style="margin: 3px;">
+<div>Multiple Select</div>
+<select id="multipleSelect" name="multipleSelect[]" multiple="multiple" size=4>
+<option value="1" selected="selected">One</option>
+<option value="2">Two</option>
+<option value="3">Three</option>
+<option value="4">Four</option>
+</select>
+</div>
+<span style="margin: 3px;">
+<input type="submit" value="submit through xajax" onclick="xajax_testForm(xajax.getFormValues('testForm1')); return false;" />
+</span>
+</fieldset>
+</form>
+</div>
+
+<div id="submittedDiv" style=" margin: 3px;"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/includeExternalScriptTest.php b/lib/xajax_0.2.4/tests/includeExternalScriptTest.php
new file mode 100644
index 0000000..12addb6
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/includeExternalScriptTest.php
@@ -0,0 +1,46 @@
+<?php
+require_once("../xajax.inc.php");
+
+function includeScript($sFilename)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addIncludeScript($sFilename);
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("includeScript");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Include External Javascript Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+<script type="text/javascript">
+function externalFunction()
+{
+	try
+	{
+		myFunction();
+	}
+	catch(e)
+	{
+		alert(e);
+	}
+}
+</script>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Include External Javascript Test</h1>
+
+<div id="myDiv"" style="padding: 3px; display: table; border: 1px outset black; font-size: large; margin-bottom: 10px;" onclick="externalFunction()">Click Me</div>
+
+<form id="testForm1" onsubmit="return false;">
+<input type="submit" value="Include myFunction.js" onclick="xajax_includeScript('myExternalFunction.js'); return false;" />
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/index.php b/lib/xajax_0.2.4/tests/index.php
new file mode 100644
index 0000000..5503e3f
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/index.php
@@ -0,0 +1,42 @@
+<?php
+/*
+ * Created on Oct 31, 2005
+ *
+ * To change the template for this generated file go to
+ * Window - Preferences - PHPeclipse - PHP - Code Templates
+ */
+?>
+<html>
+<head>
+<title>xajax Tests</title>
+</head>
+<body>
+
+<h1>xajax Tests</h1>
+
+<ul>
+<li><a href="xajaxResponseTest.php">xajaxResponse Test</a> (<b>generates a new xajax.js file if missing</b>)<br />&nbsp;</li>
+
+<li><a href="catchAllFunctionTest.php">Catch-all Function Test</a></li>
+<li><a href="changeEventTest.php">Change Event Test</a></li>
+<li><a href="charEncodingTest.php">Character Encoding Test</a></li>
+<li><a href="confirmTest.php">Confirm Commands Test</a></li>
+<li><a href="createFormInputTest.php">Create Form Input Test</a></li>
+<li><a href="customResponseClassTest.php">Custom Response Class Test</a></li>
+<li><a href="disabledFormElementsTest.php">Disabled Form Elements Test</a></li>
+<li><a href="eventHandlerTest.php">Event Handler Test</a></li>
+<li><a href="errorHandlingTest.php">Error Handling Test</a></li>
+<li><a href="formSubmissionTest.php">Form Submission Test</a></li>
+<li><a href="HTTPStatusTest.php">HTTP Status Test</a></li>
+<li><a href="includeExternalScriptTest.php">Include External Script Test</a></li>
+<li><a href="largeResponseTest.php">Large Response Test</a></li>
+<li><a href="phpWhitespaceTest.php">PHP Whitespace Test</a></li>
+<li><a href="preFunctionTest.php">Pre-function Test</a></li>
+<li><a href="redirectTest.php">Redirect Test</a></li>
+<li><a href="registerExternalFunctionTest.php">registerExternalFunction Test</a></li>
+<li><a href="searchReplaceTest.php">Search and Replace Test</a></li>
+<li><a href="scriptCallTest.php">addScriptCall Test</a></li>
+</ul>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/largeResponseTest.php b/lib/xajax_0.2.4/tests/largeResponseTest.php
new file mode 100644
index 0000000..233dd32
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/largeResponseTest.php
@@ -0,0 +1,39 @@
+<?php
+require_once("../xajax.inc.php");
+
+function largeResponse()
+{
+	$objResponse = new xajaxResponse();
+	$myResponse = "";
+	for ($i=0;$i<8000;$i++) {
+		$myResponse .= "<p>Here is paragraph $i for your reading pleasure.</p>\n";
+	}
+	$objResponse->addAssign("submittedDiv", "innerHTML", $myResponse);
+	return $objResponse;
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("largeResponse");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Large Response Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Large Response Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="submit" value="Get Large Response" onclick="xajax_largeResponse(); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/myExternalFunction.js b/lib/xajax_0.2.4/tests/myExternalFunction.js
new file mode 100644
index 0000000..b35b810
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/myExternalFunction.js
@@ -0,0 +1,4 @@
+function myFunction()
+{
+	alert('Congratulations!\n  You have successfully included the\n myExternalFunction.js without reloading the page.');
+}
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/myExternalFunction.php b/lib/xajax_0.2.4/tests/myExternalFunction.php
new file mode 100644
index 0000000..6d465e2
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/myExternalFunction.php
@@ -0,0 +1,20 @@
+<?php
+function myExternalFunction()
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert('External function successfully included and executed');
+	return $objResponse;
+}
+
+class myExternalClass
+{
+	function myMethod()	// static (can't hardwire that in because of PHP 4)
+	{
+		$objResponse = new xajaxResponse();
+		$objResponse->addAlert('External class successfully included and method executed');
+		return $objResponse;
+	}
+}
+?>
+<p> This is some content that should be ignored by an asynchronous request
+ through xajax, but will show up if the file is otherwise included into the script. </p>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/phpWhitespaceTest.php b/lib/xajax_0.2.4/tests/phpWhitespaceTest.php
new file mode 100644
index 0000000..75bb9c5
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/phpWhitespaceTest.php
@@ -0,0 +1,39 @@
+
+
+
+<?php
+require_once("../xajax.inc.php");
+
+function showOutput()
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("Hello");
+	return $objResponse;
+}
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("showOutput");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>PHP Whitespace Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>PHP Whitespace Test</h1>
+
+<p><em>This tests what happens when there's whitespace before the &lt;?php token in the PHP file (thus possibly causing the XML response to be invalid).</p>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="submit" value="Test Whitespace" onclick="xajax_showOutput(); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/preFunctionTest.php b/lib/xajax_0.2.4/tests/preFunctionTest.php
new file mode 100644
index 0000000..e72d903
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/preFunctionTest.php
@@ -0,0 +1,74 @@
+<?php
+require_once("../xajax.inc.php");
+
+function testRegularFunction($formData)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addAlert("formData: " . print_r($formData, true));
+	$objResponse->addAssign("submittedDiv", "innerHTML", nl2br(print_r($formData, true)));
+	return $objResponse->getXML();
+}
+
+function myPreFunction($funcName, $args)
+{
+	$objResponse = new xajaxResponse();
+	if ($args[1] == 0) {
+		$objResponse->addAlert("This is from the pre-function, which will now call " . $funcName);
+		return $objResponse;
+	}
+	$objResponse->addAlert("This is from the pre-function, which will now end the request.");
+	return array(false, $objResponse);
+}
+
+class myPreObject
+{
+	var $message = "This is from the pre-function object method";
+	
+	function preMethod($funcName, $args)
+	{
+		$objResponse = new xajaxResponse();
+		if ($args[1] == 0) {
+			$objResponse->addAlert($this->message . ", which will now call " . $funcName);
+			return $objResponse;
+		}
+		$objResponse->addAlert($this->message . ", which will now end the request.");
+		return array(false, $objResponse);		
+	}
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+if (@$_GET['useObjects'] == "true") {
+	$preObj = new myPreObject();
+	$xajax->registerPreFunction(array("myPreFunction", &$preObj, "preMethod"));
+}
+else {
+	$xajax->registerPreFunction("myPreFunction");
+}
+$xajax->registerFunction("testRegularFunction");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Pre-function Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Pre-function Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="text" id="textBox1" name="textBox1" value="This is some text" /></p>
+<p><input type="submit" value="Normal request" onclick="xajax_testRegularFunction(xajax.getFormValues('testForm1'), 0); return false;" /></p>
+<p><input type="submit" value="Pre-function should end request" onclick="xajax_testRegularFunction(xajax.getFormValues('testForm1'), 1); return false;" /></p>
+</form>
+
+<p><a href="preFunctionTest.php?useObjects=true">Reload using object</a></p>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/redirectTest.php b/lib/xajax_0.2.4/tests/redirectTest.php
new file mode 100644
index 0000000..1851e95
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/redirectTest.php
@@ -0,0 +1,34 @@
+<?php
+require_once("../xajax.inc.php");
+
+function redirect()
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addRedirect("http://www.xajaxproject.org");
+	return $objResponse;
+}
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("redirect");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Redirect Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Redirect Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="submit" value="Test xajax redirect" onclick="xajax_redirect(); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/registerExternalFunctionTest.php b/lib/xajax_0.2.4/tests/registerExternalFunctionTest.php
new file mode 100644
index 0000000..1eaf74e
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/registerExternalFunctionTest.php
@@ -0,0 +1,30 @@
+<?php
+require_once("../xajax.inc.php");
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerExternalFunction("myExternalFunction","tests/myExternalFunction.php");
+$xajax->registerExternalFunction(array("myFunction", "myExternalClass","myMethod"),"tests/myExternalFunction.php");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>registerExternalFunction Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>registerExternalFunction Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="submit" value="Call External Function" onclick="xajax_myExternalFunction(); return false;" /></p>
+<p><input type="submit" value="Call External Class Method" onclick="xajax_myFunction(); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/scriptCallTest.php b/lib/xajax_0.2.4/tests/scriptCallTest.php
new file mode 100644
index 0000000..ccbd250
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/scriptCallTest.php
@@ -0,0 +1,50 @@
+<?php
+require("../xajax.inc.php");
+
+function callScript()
+{
+	$response = new xajaxResponse();
+	$value2 = "this is a string";
+	$response->addScriptCall("myJSFunction", "arg1", 9432.12, array("myKey" => "some value", "key2" => $value2));
+	return $response;
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("callScript");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+	<title>addScriptCall Test | xajax Tests</title>
+	<?php $xajax->printJavascript("../") ?>
+	<script type="text/javascript">
+function myJSFunction(firstArg, numberArg, myArrayArg)
+{
+    var newString = firstArg + " and " + (+numberArg + 100) + "\n";
+    newString += myArrayArg["myKey"] + " | " + myArrayArg.key2;
+    alert(newString);
+    xajax.$('myDiv').innerHTML = newString;
+}
+	</script>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>addScriptCall Test</h1>
+
+<p>Howdy. <input type="button" value="Click Me" onclick="xajax_callScript()" /></p>
+
+<p>Result:</p>
+
+<pre id="myDiv">[blank]</pre>
+
+<p>Expecting:</p>
+
+<pre>arg1 and 9532.12
+some value | this is a string</pre>
+
+</body>
+</html>
diff --git a/lib/xajax_0.2.4/tests/searchReplaceTest.php b/lib/xajax_0.2.4/tests/searchReplaceTest.php
new file mode 100644
index 0000000..386f9ec
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/searchReplaceTest.php
@@ -0,0 +1,53 @@
+<?php
+require_once("../xajax.inc.php");
+
+function replace($aForm)
+{
+	$objResponse = new xajaxResponse();
+	$objResponse->addReplace('content', "innerHTML", $aForm['search'], $aForm['replace']);
+	return $objResponse->getXML();
+}
+
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("replace");
+$xajax->processRequests();
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Search and Replace Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>Search and Replace Test</h1>
+
+<div id="content"" style="border: 1px solid gray">
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Morbi fermentum. 
+Phasellus non nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. 
+Nulla id ligula sit amet purus tristique dictum. Fusce at arcu. Maecenas ipsum leo, tincidunt eu, vehicula id, 
+elementum feugiat, enim. Nam fringilla mi ac ligula. Quisque tempus, 
+lacus ut molestie dignissim, massa ipsum sodales arcu, eget rhoncus sapien diam at velit. 
+Morbi fermentum, dui vel tempus vestibulum, diam metus nonummy ligula, ac ultrices lacus est ac sapien. 
+Pellentesque luctus dictum massa. Cras ullamcorper ullamcorper massa. Etiam erat odio, gravida eget, ornare vitae, 
+dapibus nec, nunc. Phasellus ligula arcu, rutrum at, pellentesque et, varius feugiat, velit. 
+Etiam erat magna, eleifend vel, vulputate eget, dignissim non, lectus. Nam at metus. Aenean mollis ligula viverra ipsum.
+</div>
+
+<form id="testForm1" onsubmit="return false;">
+<div>
+Search:<input id="search" name="search" value="" />
+</div>
+<div>
+Replace:<input id="replace" name="replace" value="" />
+</div>
+<div><input type="submit" value="Search & Replace" onclick="xajax_replace(xajax.getFormValues('testForm1')); return false;" /></div>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/tests/xajaxResponseTest.php b/lib/xajax_0.2.4/tests/xajaxResponseTest.php
new file mode 100644
index 0000000..7952000
--- /dev/null
+++ b/lib/xajax_0.2.4/tests/xajaxResponseTest.php
@@ -0,0 +1,44 @@
+<?php
+require_once("../xajax.inc.php");
+
+function showOutput()
+{
+	$testResponse = new xajaxResponse();
+	$testResponse->addAlert("Hello");
+//	$testResponseOutput = htmlspecialchars($testResponse->getXML());
+	
+	$testResponse2 = new xajaxResponse();
+	$testResponse2->loadXML($testResponse->getXML());
+	$testResponse2->addReplace("this", "is", "a", "replacement");
+	$testResponseOutput = htmlspecialchars($testResponse2->getXML());	
+	
+	$objResponse = new xajaxResponse();
+	$objResponse->addAssign("submittedDiv", "innerHTML", $testResponseOutput);
+	return $objResponse;
+}
+$xajax = new xajax();
+//$xajax->debugOn();
+$xajax->registerFunction("showOutput");
+$xajax->processRequests();
+$xajax->autoCompressJavascript("../xajax_js/xajax.js");
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>xajaxResponse Test | xajax Tests</title>
+<?php $xajax->printJavascript("../") ?>
+</head>
+<body>
+
+<h2><a href="index.php">xajax Tests</a></h2>
+<h1>xajaxResponse Test</h1>
+
+<form id="testForm1" onsubmit="return false;">
+<p><input type="submit" value="Show Response XML" onclick="xajax_showOutput(); return false;" /></p>
+</form>
+
+<div id="submittedDiv"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/xajax.inc.php b/lib/xajax_0.2.4/xajax.inc.php
new file mode 100644
index 0000000..602a049
--- /dev/null
+++ b/lib/xajax_0.2.4/xajax.inc.php
@@ -0,0 +1,1239 @@
+<?php
+/**
+ * xajax.inc.php :: Main xajax class and setup file
+ *
+ * xajax version 0.2.4
+ * copyright (c) 2005 by Jared White & J. Max Wilson
+ * http://www.xajaxproject.org
+ *
+ * xajax is an open source PHP class library for easily creating powerful
+ * PHP-driven, web-based Ajax Applications. Using xajax, you can asynchronously
+ * call PHP functions and update the content of your your webpage without
+ * reloading the page.
+ *
+ * xajax is released under the terms of the LGPL license
+ * http://www.gnu.org/copyleft/lesser.html#SEC3
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * @package xajax
+ * @version $Id$
+ * @copyright Copyright (c) 2005-2006  by Jared White & J. Max Wilson
+ * @license http://www.gnu.org/copyleft/lesser.html#SEC3 LGPL License
+ */
+
+/*
+   ----------------------------------------------------------------------------
+   | Online documentation for this class is available on the xajax wiki at:   |
+   | http://wiki.xajaxproject.org/Documentation:xajax.inc.php                 |
+   ----------------------------------------------------------------------------
+*/
+
+/**
+ * Define XAJAX_DEFAULT_CHAR_ENCODING that is used by both
+ * the xajax and xajaxResponse classes
+ */
+if (!defined ('XAJAX_DEFAULT_CHAR_ENCODING'))
+{
+	define ('XAJAX_DEFAULT_CHAR_ENCODING', 'utf-8' );
+}
+
+require_once(dirname(__FILE__)."/xajaxResponse.inc.php");
+
+/**
+ * Communication Method Defines
+ */
+if (!defined ('XAJAX_GET'))
+{
+	define ('XAJAX_GET', 0);
+}
+if (!defined ('XAJAX_POST'))
+{
+	define ('XAJAX_POST', 1);
+}
+
+/**
+ * The xajax class generates the xajax javascript for your page including the 
+ * Javascript wrappers for the PHP functions that you want to call from your page.
+ * It also handles processing and executing the command messages in the XML responses
+ * sent back to your page from your PHP functions.
+ * 
+ * @package xajax
+ */ 
+class xajax
+{
+	/**#@+
+	 * @access protected
+	 */
+	/**
+	 * @var array Array of PHP functions that will be callable through javascript wrappers
+	 */
+	var $aFunctions;
+	/**
+	 * @var array Array of object callbacks that will allow Javascript to call PHP methods (key=function name)
+	 */
+	var $aObjects;
+	/**
+	 * @var array Array of RequestTypes to be used with each function (key=function name)
+	 */
+	var $aFunctionRequestTypes;
+	/**
+	 * @var array Array of Include Files for any external functions (key=function name)
+	 */
+	var $aFunctionIncludeFiles;
+	/**
+	 * @var string Name of the PHP function to call if no callable function was found
+	 */
+	var $sCatchAllFunction;
+	/**
+	 * @var string Name of the PHP function to call before any other function
+	 */
+	var $sPreFunction;
+	/**
+	 * @var string The URI for making requests to the xajax object
+	 */
+	var $sRequestURI;
+	/**
+	 * @var string The prefix to prepend to the javascript wraper function name
+	 */
+	var $sWrapperPrefix;
+	/**
+	 * @var boolean Show debug messages (default false)
+	 */
+	var $bDebug;
+	/**
+	 * @var boolean Show messages in the client browser's status bar (default false)
+	 */
+	var $bStatusMessages;	
+	/**
+	 * @var boolean Allow xajax to exit after processing a request (default true)
+	 */
+	var $bExitAllowed;
+	/**
+	 * @var boolean Use wait cursor in browser (default true)
+	 */
+	var $bWaitCursor;
+	/**
+	 * @var boolean Use an special xajax error handler so the errors are sent to the browser properly (default false)
+	 */
+	var $bErrorHandler;
+	/**
+	 * @var string Specify what, if any, file xajax should log errors to (and more information in a future release)
+	 */
+	var $sLogFile;
+	/**
+	 * @var boolean Clean all output buffers before outputting response (default false)
+	 */
+	var $bCleanBuffer;
+	/**
+	 * @var string String containing the character encoding used
+	 */
+	var $sEncoding;
+	/**
+	 * @var boolean Decode input request args from UTF-8 (default false)
+	 */
+	var $bDecodeUTF8Input;
+	/**
+	 * @var boolean Convert special characters to HTML entities (default false)
+	 */
+	var $bOutputEntities;
+	/**
+	 * @var array Array for parsing complex objects
+	 */
+	var $aObjArray;
+	/**
+	 * @var integer Position in $aObjArray
+	 */
+	var $iPos;
+	
+	/**#@-*/
+	
+	/**
+	 * Constructor. You can set some extra xajax options right away or use
+	 * individual methods later to set options.
+	 * 
+	 * @param string  defaults to the current browser URI
+	 * @param string  defaults to "xajax_";
+	 * @param string  defaults to XAJAX_DEFAULT_CHAR_ENCODING defined above
+	 * @param boolean defaults to false
+	 */
+	function xajax($sRequestURI="",$sWrapperPrefix="xajax_",$sEncoding=XAJAX_DEFAULT_CHAR_ENCODING,$bDebug=false)
+	{
+		$this->aFunctions = array();
+		$this->aObjects = array();
+		$this->aFunctionIncludeFiles = array();
+		$this->sRequestURI = $sRequestURI;
+		if ($this->sRequestURI == "")
+			$this->sRequestURI = $this->_detectURI();
+		$this->sWrapperPrefix = $sWrapperPrefix;
+		$this->bDebug = $bDebug;
+		$this->bStatusMessages = false;
+		$this->bWaitCursor = true;
+		$this->bExitAllowed = true;
+		$this->bErrorHandler = false;
+		$this->sLogFile = "";
+		$this->bCleanBuffer = false;
+		$this->setCharEncoding($sEncoding);
+		$this->bDecodeUTF8Input = false;
+		$this->bOutputEntities = false;
+	}
+		
+	/**
+	 * Sets the URI to which requests will be made.
+	 * <i>Usage:</i> <kbd>$xajax->setRequestURI("http://www.xajaxproject.org");</kbd>
+	 * 
+	 * @param string the URI (can be absolute or relative) of the PHP script
+	 *               that will be accessed when an xajax request occurs
+	 */
+	function setRequestURI($sRequestURI)
+	{
+		$this->sRequestURI = $sRequestURI;
+	}
+
+	/**
+	 * Sets the prefix that will be appended to the Javascript wrapper
+	 * functions (default is "xajax_").
+	 * 
+	 * @param string
+	 */ 
+	// 
+	function setWrapperPrefix($sPrefix)
+	{
+		$this->sWrapperPrefix = $sPrefix;
+	}
+	
+	/**
+	 * Enables debug messages for xajax.
+	 * */
+	function debugOn()
+	{
+		$this->bDebug = true;
+	}
+	
+	/**
+	 * Disables debug messages for xajax (default behavior).
+	 */
+	function debugOff()
+	{
+		$this->bDebug = false;
+	}
+		
+	/**
+	 * Enables messages in the browser's status bar for xajax.
+	 */
+	function statusMessagesOn()
+	{
+		$this->bStatusMessages = true;
+	}
+	
+	/**
+	 * Disables messages in the browser's status bar for xajax (default behavior).
+	 */
+	function statusMessagesOff()
+	{
+		$this->bStatusMessages = false;
+	}
+	
+	/**
+	 * Enables the wait cursor to be displayed in the browser (default behavior).
+	 */
+	function waitCursorOn()
+	{
+		$this->bWaitCursor = true;
+	}
+	
+	/**
+	 * Disables the wait cursor to be displayed in the browser.
+	 */
+	function waitCursorOff()
+	{
+		$this->bWaitCursor = false;
+	}	
+	
+	/**
+	 * Enables xajax to exit immediately after processing a request and
+	 * sending the response back to the browser (default behavior).
+	 */
+	function exitAllowedOn()
+	{
+		$this->bExitAllowed = true;
+	}
+	
+	/**
+	 * Disables xajax's default behavior of exiting immediately after
+	 * processing a request and sending the response back to the browser.
+	 */
+	function exitAllowedOff()
+	{
+		$this->bExitAllowed = false;
+	}
+	
+	/**
+	 * Turns on xajax's error handling system so that PHP errors that occur
+	 * during a request are trapped and pushed to the browser in the form of
+	 * a Javascript alert.
+	 */
+	function errorHandlerOn()
+	{
+		$this->bErrorHandler = true;
+	}
+
+	/**
+	 * Turns off xajax's error handling system (default behavior).
+	 */
+	function errorHandlerOff()
+	{
+		$this->bErrorHandler = false;
+	}
+	
+	/**
+	 * Specifies a log file that will be written to by xajax during a request
+	 * (used only by the error handling system at present). If you don't invoke
+	 * this method, or you pass in "", then no log file will be written to.
+	 * <i>Usage:</i> <kbd>$xajax->setLogFile("/xajax_logs/errors.log");</kbd>
+	 */
+	function setLogFile($sFilename)
+	{
+		$this->sLogFile = $sFilename;
+	}
+
+	/**
+	 * Causes xajax to clean out all output buffers before outputting a
+	 * response (default behavior).
+	 */
+	function cleanBufferOn()
+	{
+		$this->bCleanBuffer = true;
+	}
+	/**
+	 * Turns off xajax's output buffer cleaning.
+	 */
+	function cleanBufferOff()
+	{
+		$this->bCleanBuffer = false;
+	}
+	
+	/**
+	 * Sets the character encoding for the HTTP output based on
+	 * <kbd>$sEncoding</kbd>, which is a string containing the character
+	 * encoding to use. You don't need to use this method normally, since the
+	 * character encoding for the response gets set automatically based on the
+	 * <kbd>XAJAX_DEFAULT_CHAR_ENCODING</kbd> constant.
+	 * <i>Usage:</i> <kbd>$xajax->setCharEncoding("utf-8");</kbd>
+	 *
+	 * @param string the encoding type to use (utf-8, iso-8859-1, etc.)
+	 */
+	function setCharEncoding($sEncoding)
+	{
+		$this->sEncoding = $sEncoding;
+	}
+
+	/**
+	 * Causes xajax to decode the input request args from UTF-8 to the current
+	 * encoding if possible. Either the iconv or mb_string extension must be
+	 * present for optimal functionality.
+	 */
+	function decodeUTF8InputOn()
+	{
+		$this->bDecodeUTF8Input = true;
+	}
+
+	/**
+	 * Turns off decoding the input request args from UTF-8 (default behavior).
+	 */
+	function decodeUTF8InputOff()
+	{
+		$this->bDecodeUTF8Input = false;
+	}
+	
+	/**
+	 * Tells the response object to convert special characters to HTML entities
+	 * automatically (only works if the mb_string extension is available).
+	 */
+	function outputEntitiesOn()
+	{
+		$this->bOutputEntities = true;
+	}
+	
+	/**
+	 * Tells the response object to output special characters intact. (default
+	 * behavior).
+	 */
+	function outputEntitiesOff()
+	{
+		$this->bOutputEntities = false;
+	}
+				
+	/**
+	 * Registers a PHP function or method to be callable through xajax in your
+	 * Javascript. If you want to register a function, pass in the name of that
+	 * function. If you want to register a static class method, pass in an
+	 * array like so:
+	 * <kbd>array("myFunctionName", "myClass", "myMethod")</kbd>
+	 * For an object instance method, use an object variable for the second
+	 * array element (and in PHP 4 make sure you put an & before the variable
+	 * to pass the object by reference). Note: the function name is what you
+	 * call via Javascript, so it can be anything as long as it doesn't
+	 * conflict with any other registered function name.
+	 * 
+	 * <i>Usage:</i> <kbd>$xajax->registerFunction("myFunction");</kbd>
+	 * or: <kbd>$xajax->registerFunction(array("myFunctionName", &$myObject, "myMethod"));</kbd>
+	 * 
+	 * @param mixed  contains the function name or an object callback array
+	 * @param mixed  request type (XAJAX_GET/XAJAX_POST) that should be used 
+	 *               for this function.  Defaults to XAJAX_POST.
+	 */
+	function registerFunction($mFunction,$sRequestType=XAJAX_POST)
+	{
+		if (is_array($mFunction)) {
+			$this->aFunctions[$mFunction[0]] = 1;
+			$this->aFunctionRequestTypes[$mFunction[0]] = $sRequestType;
+			$this->aObjects[$mFunction[0]] = array_slice($mFunction, 1);
+		}	
+		else {
+			$this->aFunctions[$mFunction] = 1;
+			$this->aFunctionRequestTypes[$mFunction] = $sRequestType;
+		}
+	}
+	
+	/**
+	 * Registers a PHP function to be callable through xajax which is located
+	 * in some other file.  If the function is requested the external file will
+	 * be included to define the function before the function is called.
+	 * 
+	 * <i>Usage:</i> <kbd>$xajax->registerExternalFunction("myFunction","myFunction.inc.php",XAJAX_POST);</kbd>
+	 * 
+	 * @param string contains the function name or an object callback array
+	 *               ({@link xajax::registerFunction() see registerFunction} for
+	 *               more info on object callback arrays)
+	 * @param string contains the path and filename of the include file
+	 * @param mixed  the RequestType (XAJAX_GET/XAJAX_POST) that should be used 
+	 *		          for this function. Defaults to XAJAX_POST.
+	 */
+	function registerExternalFunction($mFunction,$sIncludeFile,$sRequestType=XAJAX_POST)
+	{
+		$this->registerFunction($mFunction, $sRequestType);
+		
+		if (is_array($mFunction)) {
+			$this->aFunctionIncludeFiles[$mFunction[0]] = $sIncludeFile;
+		}
+		else {
+			$this->aFunctionIncludeFiles[$mFunction] = $sIncludeFile;
+		}
+	}
+	
+	/**
+	 * Registers a PHP function to be called when xajax cannot find the
+	 * function being called via Javascript. Because this is technically
+	 * impossible when using "wrapped" functions, the catch-all feature is
+	 * only useful when you're directly using the xajax.call() Javascript
+	 * method. Use the catch-all feature when you want more dynamic ability to
+	 * intercept unknown calls and handle them in a custom way.
+	 * 
+	 * <i>Usage:</i> <kbd>$xajax->registerCatchAllFunction("myCatchAllFunction");</kbd>
+	 * 
+	 * @param string contains the function name or an object callback array
+	 *               ({@link xajax::registerFunction() see registerFunction} for
+	 *               more info on object callback arrays)
+	 */
+	function registerCatchAllFunction($mFunction)
+	{
+		if (is_array($mFunction)) {
+			$this->sCatchAllFunction = $mFunction[0];
+			$this->aObjects[$mFunction[0]] = array_slice($mFunction, 1);
+		}
+		else {
+			$this->sCatchAllFunction = $mFunction;
+		}
+	}
+	
+	/**
+	 * Registers a PHP function to be called before xajax calls the requested
+	 * function. xajax will automatically add the request function's response
+	 * to the pre-function's response to create a single response. Another
+	 * feature is the ability to return not just a response, but an array with
+	 * the first element being false (a boolean) and the second being the
+	 * response. In this case, the pre-function's response will be returned to
+	 * the browser without xajax calling the requested function.
+	 * 
+	 * <i>Usage:</i> <kbd>$xajax->registerPreFunction("myPreFunction");</kbd>
+	 * 
+	 * @param string contains the function name or an object callback array
+	 *               ({@link xajax::registerFunction() see registerFunction} for
+	 *               more info on object callback arrays)
+	 */
+	function registerPreFunction($mFunction)
+	{
+		if (is_array($mFunction)) {
+			$this->sPreFunction = $mFunction[0];
+			$this->aObjects[$mFunction[0]] = array_slice($mFunction, 1);
+		}
+		else {
+			$this->sPreFunction = $mFunction;
+		}
+	}
+	
+	/**
+	 * Returns true if xajax can process the request, false if otherwise.
+	 * You can use this to determine if xajax needs to process the request or
+	 * not.
+	 * 
+	 * @return boolean
+	 */ 
+	function canProcessRequests()
+	{
+		if ($this->getRequestMode() != -1) return true;
+		return false;
+	}
+	
+	/**
+	 * Returns the current request mode (XAJAX_GET or XAJAX_POST), or -1 if
+	 * there is none.
+	 * 
+	 * @return mixed
+	 */
+	function getRequestMode()
+	{
+		if (!empty($_GET["xajax"]))
+			return XAJAX_GET;
+		
+		if (!empty($_POST["xajax"]))
+			return XAJAX_POST;
+			
+		return -1;
+	}
+	
+	/**
+	 * This is the main communications engine of xajax. The engine handles all
+	 * incoming xajax requests, calls the apporiate PHP functions (or
+	 * class/object methods) and passes the XML responses back to the
+	 * Javascript response handler. If your RequestURI is the same as your Web
+	 * page then this function should be called before any headers or HTML has
+	 * been sent.
+	 */
+	function processRequests()
+	{	
+		
+		$requestMode = -1;
+		$sFunctionName = "";
+		$bFoundFunction = true;
+		$bFunctionIsCatchAll = false;
+		$sFunctionNameForSpecial = "";
+		$aArgs = array();
+		$sPreResponse = "";
+		$bEndRequest = false;
+		$sResponse = "";
+		
+		$requestMode = $this->getRequestMode();
+		if ($requestMode == -1) return;
+	
+		if ($requestMode == XAJAX_POST)
+		{
+			$sFunctionName = $_POST["xajax"];
+			
+			if (!empty($_POST["xajaxargs"])) 
+				$aArgs = $_POST["xajaxargs"];
+		}
+		else
+		{	
+			header ("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
+			header ("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
+			header ("Cache-Control: no-cache, must-revalidate");
+			header ("Pragma: no-cache");
+			
+			$sFunctionName = $_GET["xajax"];
+			
+			if (!empty($_GET["xajaxargs"])) 
+				$aArgs = $_GET["xajaxargs"];
+		}
+		
+		// Use xajax error handler if necessary
+		if ($this->bErrorHandler) {
+			$GLOBALS['xajaxErrorHandlerText'] = "";
+			set_error_handler("xajaxErrorHandler");
+		}
+		
+		if ($this->sPreFunction) {
+			if (!$this->_isFunctionCallable($this->sPreFunction)) {
+				$bFoundFunction = false;
+				$objResponse = new xajaxResponse();
+				$objResponse->addAlert("Unknown Pre-Function ". $this->sPreFunction);
+				$sResponse = $objResponse->getXML();
+			}
+		}
+		//include any external dependencies associated with this function name
+		if (array_key_exists($sFunctionName,$this->aFunctionIncludeFiles))
+		{
+			ob_start();
+			include_once($this->aFunctionIncludeFiles[$sFunctionName]);
+			ob_end_clean();
+		}
+		
+		if ($bFoundFunction) {
+			$sFunctionNameForSpecial = $sFunctionName;
+			if (!array_key_exists($sFunctionName, $this->aFunctions))
+			{
+				if ($this->sCatchAllFunction) {
+					$sFunctionName = $this->sCatchAllFunction;
+					$bFunctionIsCatchAll = true;
+				}
+				else {
+					$bFoundFunction = false;
+					$objResponse = new xajaxResponse();
+					$objResponse->addAlert("Unknown Function $sFunctionName.");
+					$sResponse = $objResponse->getXML();
+				}
+			}
+			else if ($this->aFunctionRequestTypes[$sFunctionName] != $requestMode)
+			{
+				$bFoundFunction = false;
+				$objResponse = new xajaxResponse();
+				$objResponse->addAlert("Incorrect Request Type.");
+				$sResponse = $objResponse->getXML();
+			}
+		}
+		
+		if ($bFoundFunction)
+		{
+			for ($i = 0; $i < sizeof($aArgs); $i++)
+			{
+				// If magic quotes is on, then we need to strip the slashes from the args
+				if (get_magic_quotes_gpc() == 1 && is_string($aArgs[$i])) {
+				
+					$aArgs[$i] = stripslashes($aArgs[$i]);
+				}
+				if (stristr($aArgs[$i],"<xjxobj>") != false)
+				{
+					$aArgs[$i] = $this->_xmlToArray("xjxobj",$aArgs[$i]);	
+				}
+				else if (stristr($aArgs[$i],"<xjxquery>") != false)
+				{
+					$aArgs[$i] = $this->_xmlToArray("xjxquery",$aArgs[$i]);	
+				}
+				else if ($this->bDecodeUTF8Input)
+				{
+					$aArgs[$i] = $this->_decodeUTF8Data($aArgs[$i]);	
+				}
+			}
+
+			if ($this->sPreFunction) {
+				$mPreResponse = $this->_callFunction($this->sPreFunction, array($sFunctionNameForSpecial, $aArgs));
+				if (is_array($mPreResponse) && $mPreResponse[0] === false) {
+					$bEndRequest = true;
+					$sPreResponse = $mPreResponse[1];
+				}
+				else {
+					$sPreResponse = $mPreResponse;
+				}
+				if (is_a($sPreResponse, "xajaxResponse")) {
+					$sPreResponse = $sPreResponse->getXML();
+				}
+				if ($bEndRequest) $sResponse = $sPreResponse;
+			}
+			
+			if (!$bEndRequest) {
+				if (!$this->_isFunctionCallable($sFunctionName)) {
+					$objResponse = new xajaxResponse();
+					$objResponse->addAlert("The Registered Function $sFunctionName Could Not Be Found.");
+					$sResponse = $objResponse->getXML();
+				}
+				else {
+					if ($bFunctionIsCatchAll) {
+						$aArgs = array($sFunctionNameForSpecial, $aArgs);
+					}
+					$sResponse = $this->_callFunction($sFunctionName, $aArgs);
+				}
+				if (is_a($sResponse, "xajaxResponse")) {
+					$sResponse = $sResponse->getXML();
+				}
+				if (!is_string($sResponse) || strpos($sResponse, "<xjx>") === FALSE) {
+					$objResponse = new xajaxResponse();
+					$objResponse->addAlert("No XML Response Was Returned By Function $sFunctionName.");
+					$sResponse = $objResponse->getXML();
+				}
+				else if ($sPreResponse != "") {
+					$sNewResponse = new xajaxResponse($this->sEncoding, $this->bOutputEntities);
+					$sNewResponse->loadXML($sPreResponse);
+					$sNewResponse->loadXML($sResponse);
+					$sResponse = $sNewResponse->getXML();
+				}
+			}
+		}
+		
+		$sContentHeader = "Content-type: text/xml;";
+		if ($this->sEncoding && strlen(trim($this->sEncoding)) > 0)
+			$sContentHeader .= " charset=".$this->sEncoding;
+		header($sContentHeader);
+		if ($this->bErrorHandler && !empty( $GLOBALS['xajaxErrorHandlerText'] )) {
+			$sErrorResponse = new xajaxResponse();
+			$sErrorResponse->addAlert("** PHP Error Messages: **" . $GLOBALS['xajaxErrorHandlerText']);
+			if ($this->sLogFile) {
+				$fH = @fopen($this->sLogFile, "a");
+				if (!$fH) {
+					$sErrorResponse->addAlert("** Logging Error **\n\nxajax was unable to write to the error log file:\n" . $this->sLogFile);
+				}
+				else {
+					fwrite($fH, "** xajax Error Log - " . strftime("%b %e %Y %I:%M:%S %p") . " **" . $GLOBALS['xajaxErrorHandlerText'] . "\n\n\n");
+					fclose($fH);
+				}
+			}
+
+			$sErrorResponse->loadXML($sResponse);
+			$sResponse = $sErrorResponse->getXML();
+			
+		}
+		if ($this->bCleanBuffer) while (@ob_end_clean());
+		print $sResponse;
+		if ($this->bErrorHandler) restore_error_handler();
+		
+		if ($this->bExitAllowed)
+			exit();
+	}
+
+	/**			
+	 * Prints the xajax Javascript header and wrapper code into your page by
+	 * printing the output of the getJavascript() method. It should only be
+	 * called between the <pre><head> </head></pre> tags in your HTML page.
+	 * Remember, if you only want to obtain the result of this function, use
+	 * {@link xajax::getJavascript()} instead.
+	 * 
+	 * <i>Usage:</i>
+	 * <code>
+	 *  <head>
+	 *		...
+	 *		< ?php $xajax->printJavascript(); ? >
+	 * </code>
+	 * 
+	 * @param string the relative address of the folder where xajax has been
+	 *               installed. For instance, if your PHP file is
+	 *               "http://www.myserver.com/myfolder/mypage.php"
+	 *               and xajax was installed in
+	 *               "http://www.myserver.com/anotherfolder", then $sJsURI
+	 *               should be set to "../anotherfolder". Defaults to assuming
+	 *               xajax is in the same folder as your PHP file.
+	 * @param string the relative folder/file pair of the xajax Javascript
+	 *               engine located within the xajax installation folder.
+	 *               Defaults to xajax_js/xajax.js.
+	 */
+	function printJavascript($sJsURI="", $sJsFile=NULL)
+	{
+		print $this->getJavascript($sJsURI, $sJsFile);
+	}
+	
+	/**
+	 * Returns the xajax Javascript code that should be added to your HTML page
+	 * between the <kbd><head> </head></kbd> tags.
+	 * 
+	 * <i>Usage:</i>
+	 * <code>
+	 *  < ?php $xajaxJSHead = $xajax->getJavascript(); ? >
+	 *	<head>
+	 *		...
+	 *		< ?php echo $xajaxJSHead; ? >
+	 * </code>
+	 * 
+	 * @param string the relative address of the folder where xajax has been
+	 *               installed. For instance, if your PHP file is
+	 *               "http://www.myserver.com/myfolder/mypage.php"
+	 *               and xajax was installed in
+	 *               "http://www.myserver.com/anotherfolder", then $sJsURI
+	 *               should be set to "../anotherfolder". Defaults to assuming
+	 *               xajax is in the same folder as your PHP file.
+	 * @param string the relative folder/file pair of the xajax Javascript
+	 *               engine located within the xajax installation folder.
+	 *               Defaults to xajax_js/xajax.js.
+	 * @return string
+	 */
+	function getJavascript($sJsURI="", $sJsFile=NULL)
+	{	
+		$html = $this->getJavascriptConfig();
+		$html .= $this->getJavascriptInclude($sJsURI, $sJsFile);
+		
+		return $html;
+	}
+	
+	/**
+	 * Returns a string containing inline Javascript that sets up the xajax
+	 * runtime (typically called internally by xajax from get/printJavascript).
+	 * 
+	 * @return string
+	 */
+	function getJavascriptConfig()
+	{
+		$html  = "\t<script type=\"text/javascript\">\n";
+		$html .= "var xajaxRequestUri=\"".$this->sRequestURI."\";\n";
+		$html .= "var xajaxDebug=".($this->bDebug?"true":"false").";\n";
+		$html .= "var xajaxStatusMessages=".($this->bStatusMessages?"true":"false").";\n";
+		$html .= "var xajaxWaitCursor=".($this->bWaitCursor?"true":"false").";\n";
+		$html .= "var xajaxDefinedGet=".XAJAX_GET.";\n";
+		$html .= "var xajaxDefinedPost=".XAJAX_POST.";\n";
+		$html .= "var xajaxLoaded=false;\n";
+
+		foreach($this->aFunctions as $sFunction => $bExists) {
+			$html .= $this->_wrap($sFunction,$this->aFunctionRequestTypes[$sFunction]);
+		}
+
+		$html .= "\t</script>\n";
+		return $html;		
+	}
+	
+	/**
+	 * Returns a string containing a Javascript include of the xajax.js file
+	 * along with a check to see if the file loaded after six seconds
+	 * (typically called internally by xajax from get/printJavascript).
+	 * 
+	 * @param string the relative address of the folder where xajax has been
+	 *               installed. For instance, if your PHP file is
+	 *               "http://www.myserver.com/myfolder/mypage.php"
+	 *               and xajax was installed in
+	 *               "http://www.myserver.com/anotherfolder", then $sJsURI
+	 *               should be set to "../anotherfolder". Defaults to assuming
+	 *               xajax is in the same folder as your PHP file.
+	 * @param string the relative folder/file pair of the xajax Javascript
+	 *               engine located within the xajax installation folder.
+	 *               Defaults to xajax_js/xajax.js.
+	 * @return string
+	 */
+	function getJavascriptInclude($sJsURI="", $sJsFile=NULL)
+	{
+		if ($sJsFile == NULL) $sJsFile = "xajax_js/xajax.js";
+			
+		if ($sJsURI != "" && substr($sJsURI, -1) != "/") $sJsURI .= "/";
+		
+		$html = "\t<script type=\"text/javascript\" src=\"" . $sJsURI . $sJsFile . "\"></script>\n";	
+		$html .= "\t<script type=\"text/javascript\">\n";
+		$html .= "window.setTimeout(function () { if (!xajaxLoaded) { alert('Error: the xajax Javascript file could not be included. Perhaps the URL is incorrect?\\nURL: {$sJsURI}{$sJsFile}'); } }, 6000);\n";
+		$html .= "\t</script>\n";
+		return $html;
+	}
+
+	/**
+	 * This method can be used to create a new xajax.js file out of the
+	 * xajax_uncompressed.js file (which will only happen if xajax.js doesn't
+	 * already exist on the filesystem).
+	 * 
+	 * @param string an optional argument containing the full server file path
+	 *               of xajax.js.
+	 */
+	function autoCompressJavascript($sJsFullFilename=NULL)
+	{	
+		$sJsFile = "xajax_js/xajax.js";
+		
+		if ($sJsFullFilename) {
+			$realJsFile = $sJsFullFilename;
+		}
+		else {
+			$realPath = realpath(dirname(__FILE__));
+			$realJsFile = $realPath . "/". $sJsFile;
+		}
+
+		// Create a compressed file if necessary
+		if (!file_exists($realJsFile)) {
+			$srcFile = str_replace(".js", "_uncompressed.js", $realJsFile);
+			if (!file_exists($srcFile)) {
+				trigger_error("The xajax uncompressed Javascript file could not be found in the <b>" . dirname($realJsFile) . "</b> folder. Error ", E_USER_ERROR);	
+			}
+			require(dirname(__FILE__)."/xajaxCompress.php");
+			$javaScript = implode('', file($srcFile));
+			$compressedScript = xajaxCompressJavascript($javaScript);
+			$fH = @fopen($realJsFile, "w");
+			if (!$fH) {
+				trigger_error("The xajax compressed javascript file could not be written in the <b>" . dirname($realJsFile) . "</b> folder. Error ", E_USER_ERROR);
+			}
+			else {
+				fwrite($fH, $compressedScript);
+				fclose($fH);
+			}
+		}
+	}
+	
+	/**
+	 * Returns the current URL based upon the SERVER vars.
+	 * 
+	 * @access private
+	 * @return string
+	 */
+	function _detectURI() {
+		$aURL = array();
+
+		// Try to get the request URL
+		if (!empty($_SERVER['REQUEST_URI'])) {
+			$aURL = parse_url($_SERVER['REQUEST_URI']);
+		}
+
+		// Fill in the empty values
+		if (empty($aURL['scheme'])) {
+			if (!empty($_SERVER['HTTP_SCHEME'])) {
+				$aURL['scheme'] = $_SERVER['HTTP_SCHEME'];
+			} else {
+				$aURL['scheme'] = (!empty($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) != 'off') ? 'https' : 'http';
+			}
+		}
+
+		if (empty($aURL['host'])) {
+			if (!empty($_SERVER['HTTP_HOST'])) {
+				if (strpos($_SERVER['HTTP_HOST'], ':') > 0) {
+					list($aURL['host'], $aURL['port']) = explode(':', $_SERVER['HTTP_HOST']);
+				} else {
+					$aURL['host'] = $_SERVER['HTTP_HOST'];
+				}
+			} else if (!empty($_SERVER['SERVER_NAME'])) {
+				$aURL['host'] = $_SERVER['SERVER_NAME'];
+			} else {
+				print "xajax Error: xajax failed to automatically identify your Request URI.";
+				print "Please set the Request URI explicitly when you instantiate the xajax object.";
+				exit();
+			}
+		}
+
+		if (empty($aURL['port']) && !empty($_SERVER['SERVER_PORT'])) {
+			$aURL['port'] = $_SERVER['SERVER_PORT'];
+		}
+
+		if (empty($aURL['path'])) {
+			if (!empty($_SERVER['PATH_INFO'])) {
+				$sPath = parse_url($_SERVER['PATH_INFO']);
+			} else {
+				$sPath = parse_url($_SERVER['PHP_SELF']);
+			}
+			$aURL['path'] = $sPath['path'];
+			unset($sPath);
+		}
+
+		if (!empty($aURL['query'])) {
+			$aURL['query'] = '?'.$aURL['query'];
+		}
+
+		// Build the URL: Start with scheme, user and pass
+		$sURL = $aURL['scheme'].'://';
+		if (!empty($aURL['user'])) {
+			$sURL.= $aURL['user'];
+			if (!empty($aURL['pass'])) {
+				$sURL.= ':'.$aURL['pass'];
+			}
+			$sURL.= '@';
+		}
+
+		// Add the host
+		$sURL.= $aURL['host'];
+
+		// Add the port if needed
+		if (!empty($aURL['port']) && (($aURL['scheme'] == 'http' && $aURL['port'] != 80) || ($aURL['scheme'] == 'https' && $aURL['port'] != 443))) {
+			$sURL.= ':'.$aURL['port'];
+		}
+
+		// Add the path and the query string
+		$sURL.= $aURL['path'].@$aURL['query'];
+
+		// Clean up
+		unset($aURL);
+		return $sURL;
+	}
+	
+	/**
+	 * Returns true if the function name is associated with an object callback,
+	 * false if not.
+	 * 
+	 * @param string the name of the function
+	 * @access private
+	 * @return boolean
+	 */
+	function _isObjectCallback($sFunction)
+	{
+		if (array_key_exists($sFunction, $this->aObjects)) return true;
+		return false;
+	}
+	
+	/**
+	 * Returns true if the function or object callback can be called, false if
+	 * not.
+	 * 
+	 * @param string the name of the function
+	 * @access private
+	 * @return boolean
+	 */
+	function _isFunctionCallable($sFunction)
+	{
+		if ($this->_isObjectCallback($sFunction)) {
+			if (is_object($this->aObjects[$sFunction][0])) {
+				return method_exists($this->aObjects[$sFunction][0], $this->aObjects[$sFunction][1]);
+			}
+			else {
+				return is_callable($this->aObjects[$sFunction]);
+			}
+		}
+		else {
+			return function_exists($sFunction);
+		}	
+	}
+	
+	/**
+	 * Calls the function, class method, or object method with the supplied
+	 * arguments.
+	 * 
+	 * @param string the name of the function
+	 * @param array  arguments to pass to the function
+	 * @access private
+	 * @return mixed the output of the called function or method
+	 */
+	function _callFunction($sFunction, $aArgs)
+	{
+		if ($this->_isObjectCallback($sFunction)) {
+			$mReturn = call_user_func_array($this->aObjects[$sFunction], $aArgs);
+		}
+		else {
+			$mReturn = call_user_func_array($sFunction, $aArgs);
+		}
+		return $mReturn;
+	}
+	
+	/**
+	 * Generates the Javascript wrapper for the specified PHP function.
+	 * 
+	 * @param string the name of the function
+	 * @param mixed  the request type
+	 * @access private
+	 * @return string
+	 */
+	function _wrap($sFunction,$sRequestType=XAJAX_POST)
+	{
+		$js = "function ".$this->sWrapperPrefix."$sFunction(){return xajax.call(\"$sFunction\", arguments, ".$sRequestType.");}\n";		
+		return $js;
+	}
+
+	/**
+	 * Takes a string containing xajax xjxobj XML or xjxquery XML and builds an
+	 * array representation of it to pass as an argument to the PHP function
+	 * being called.
+	 * 
+	 * @param string the root tag of the XML
+	 * @param string XML to convert
+	 * @access private
+	 * @return array
+	 */
+	function _xmlToArray($rootTag, $sXml)
+	{
+		$aArray = array();
+		$sXml = str_replace("<$rootTag>","<$rootTag>|~|",$sXml);
+		$sXml = str_replace("</$rootTag>","</$rootTag>|~|",$sXml);
+		$sXml = str_replace("<e>","<e>|~|",$sXml);
+		$sXml = str_replace("</e>","</e>|~|",$sXml);
+		$sXml = str_replace("<k>","<k>|~|",$sXml);
+		$sXml = str_replace("</k>","|~|</k>|~|",$sXml);
+		$sXml = str_replace("<v>","<v>|~|",$sXml);
+		$sXml = str_replace("</v>","|~|</v>|~|",$sXml);
+		$sXml = str_replace("<q>","<q>|~|",$sXml);
+		$sXml = str_replace("</q>","|~|</q>|~|",$sXml);
+		
+		$this->aObjArray = explode("|~|",$sXml);
+		
+		$this->iPos = 0;
+		$aArray = $this->_parseObjXml($rootTag);
+        
+		return $aArray;
+	}
+	
+	/**
+	 * A recursive function that generates an array from the contents of
+	 * $this->aObjArray.
+	 * 
+	 * @param string the root tag of the XML
+	 * @access private
+	 * @return array
+	 */
+	function _parseObjXml($rootTag)
+	{
+		$aArray = array();
+		
+		if ($rootTag == "xjxobj")
+		{
+			while(!stristr($this->aObjArray[$this->iPos],"</xjxobj>"))
+			{
+				$this->iPos++;
+				if(stristr($this->aObjArray[$this->iPos],"<e>"))
+				{
+					$key = "";
+					$value = null;
+						
+					$this->iPos++;
+					while(!stristr($this->aObjArray[$this->iPos],"</e>"))
+					{
+						if(stristr($this->aObjArray[$this->iPos],"<k>"))
+						{
+							$this->iPos++;
+							while(!stristr($this->aObjArray[$this->iPos],"</k>"))
+							{
+								$key .= $this->aObjArray[$this->iPos];
+								$this->iPos++;
+							}
+						}
+						if(stristr($this->aObjArray[$this->iPos],"<v>"))
+						{
+							$this->iPos++;
+							while(!stristr($this->aObjArray[$this->iPos],"</v>"))
+							{
+								if(stristr($this->aObjArray[$this->iPos],"<xjxobj>"))
+								{
+									$value = $this->_parseObjXml("xjxobj");
+									$this->iPos++;
+								}
+								else
+								{
+									$value .= $this->aObjArray[$this->iPos];
+									if ($this->bDecodeUTF8Input)
+									{
+										$value = $this->_decodeUTF8Data($value);
+									}
+								}
+								$this->iPos++;
+							}
+						}
+						$this->iPos++;
+					}
+					
+					$aArray[$key]=$value;
+				}
+			}
+		}
+		
+		if ($rootTag == "xjxquery")
+		{
+			$sQuery = "";
+			$this->iPos++;
+			while(!stristr($this->aObjArray[$this->iPos],"</xjxquery>"))
+			{
+				if (stristr($this->aObjArray[$this->iPos],"<q>") || stristr($this->aObjArray[$this->iPos],"</q>"))
+				{
+					$this->iPos++;
+					continue;
+				}
+				$sQuery	.= $this->aObjArray[$this->iPos];
+				$this->iPos++;
+			}
+			
+			parse_str($sQuery, $aArray);
+			if ($this->bDecodeUTF8Input)
+			{
+				foreach($aArray as $key => $value)
+				{
+					$aArray[$key] = $this->_decodeUTF8Data($value);
+				}
+			}
+			// If magic quotes is on, then we need to strip the slashes from the
+			// array values because of the parse_str pass which adds slashes
+			if (get_magic_quotes_gpc() == 1) {
+				$newArray = array();
+				foreach ($aArray as $sKey => $sValue) {
+					if (is_string($sValue))
+						$newArray[$sKey] = stripslashes($sValue);
+					else
+						$newArray[$sKey] = $sValue;
+				}
+				$aArray = $newArray;
+			}
+		}
+		
+		return $aArray;
+	}
+	
+	/**
+	 * Decodes string data from UTF-8 to the current xajax encoding.
+	 * 
+	 * @param string data to convert
+	 * @access private
+	 * @return string converted data
+	 */
+	function _decodeUTF8Data($sData)
+	{
+		$sValue = $sData;
+		if ($this->bDecodeUTF8Input)
+		{
+			$sFuncToUse = NULL;
+			
+			if (function_exists('iconv'))
+			{
+				$sFuncToUse = "iconv";
+			}
+			else if (function_exists('mb_convert_encoding'))
+			{
+				$sFuncToUse = "mb_convert_encoding";
+			}
+			else if ($this->sEncoding == "ISO-8859-1")
+			{
+				$sFuncToUse = "utf8_decode";
+			}
+			else
+			{
+				trigger_error("The incoming xajax data could not be converted from UTF-8", E_USER_NOTICE);
+			}
+			
+			if ($sFuncToUse)
+			{
+				if (is_string($sValue))
+				{
+					if ($sFuncToUse == "iconv")
+					{
+						$sValue = iconv("UTF-8", $this->sEncoding.'//TRANSLIT', $sValue);
+					}
+					else if ($sFuncToUse == "mb_convert_encoding")
+					{
+						$sValue = mb_convert_encoding($sValue, $this->sEncoding, "UTF-8");
+					}
+					else
+					{
+						$sValue = utf8_decode($sValue);
+					}
+				}
+			}
+		}
+		return $sValue;	
+	}
+		
+}// end class xajax 
+
+/**
+ * This function is registered with PHP's set_error_handler() function if
+ * the xajax error handling system is turned on.
+ */
+function xajaxErrorHandler($errno, $errstr, $errfile, $errline)
+{
+	$errorReporting = error_reporting();
+	if (($errno & $errorReporting) == 0) return;
+	
+	if ($errno == E_NOTICE) {
+		$errTypeStr = "NOTICE";
+	}
+	else if ($errno == E_WARNING) {
+		$errTypeStr = "WARNING";
+	}
+	else if ($errno == E_USER_NOTICE) {
+		$errTypeStr = "USER NOTICE";
+	}
+	else if ($errno == E_USER_WARNING) {
+		$errTypeStr = "USER WARNING";
+	}
+	else if ($errno == E_USER_ERROR) {
+		$errTypeStr = "USER FATAL ERROR";
+	}
+	else if ($errno == E_STRICT) {
+		return;
+	}
+	else {
+		$errTypeStr = "UNKNOWN: $errno";
+	}
+	$GLOBALS['xajaxErrorHandlerText'] .= "\n----\n[$errTypeStr] $errstr\nerror in line $errline of file $errfile";
+}
+
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/xajaxCompress.php b/lib/xajax_0.2.4/xajaxCompress.php
new file mode 100644
index 0000000..327a92d
--- /dev/null
+++ b/lib/xajax_0.2.4/xajaxCompress.php
@@ -0,0 +1,182 @@
+<?php
+/**
+ * xajaxCompress.php :: function to compress Javascript
+ *
+ * xajax version 0.2.4
+ * copyright (c) 2005 by Jared White & J. Max Wilson
+ * http://www.xajaxproject.org
+ *
+ * xajax is an open source PHP class library for easily creating powerful
+ * PHP-driven, web-based Ajax Applications. Using xajax, you can asynchronously
+ * call PHP functions and update the content of your your webpage without
+ * reloading the page.
+ *
+ * xajax is released under the terms of the LGPL license
+ * http://www.gnu.org/copyleft/lesser.html#SEC3
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * @package xajax
+ * @version $Id$
+ * @copyright Copyright (c) 2005-2006  by Jared White & J. Max Wilson
+ * @license http://www.gnu.org/copyleft/lesser.html#SEC3 LGPL License
+ */
+
+/**
+ * Compresses the Javascript code for more efficient delivery.
+ * (used internally)
+ * 
+ * @param string contains the Javascript code to compress
+ */
+function xajaxCompressJavascript($sJS)
+{
+	//remove windows cariage returns
+	$sJS = str_replace("\r","",$sJS);
+	
+	//array to store replaced literal strings
+	$literal_strings = array();
+	
+	//explode the string into lines
+	$lines = explode("\n",$sJS);
+	//loop through all the lines, building a new string at the same time as removing literal strings
+	$clean = "";
+	$inComment = false;
+	$literal = "";
+	$inQuote = false;
+	$escaped = false;
+	$quoteChar = "";
+	
+	for($i=0;$i<count($lines);$i++)
+	{
+		$line = $lines[$i];
+		$inNormalComment = false;
+	
+		//loop through line's characters and take out any literal strings, replace them with ___i___ where i is the index of this string
+		for($j=0;$j<strlen($line);$j++)
+		{
+			$c = substr($line,$j,1);
+			$d = substr($line,$j,2);
+	
+			//look for start of quote
+			if(!$inQuote && !$inComment)
+			{
+				//is this character a quote or a comment
+				if(($c=="\"" || $c=="'") && !$inComment && !$inNormalComment)
+				{
+					$inQuote = true;
+					$inComment = false;
+					$escaped = false;
+					$quoteChar = $c;
+					$literal = $c;
+				}
+				else if($d=="/*" && !$inNormalComment)
+				{
+					$inQuote = false;
+					$inComment = true;
+					$escaped = false;
+					$quoteChar = $d;
+					$literal = $d;	
+					$j++;	
+				}
+				else if($d=="//") //ignore string markers that are found inside comments
+				{
+					$inNormalComment = true;
+					$clean .= $c;
+				}
+				else
+				{
+					$clean .= $c;
+				}
+			}
+			else //allready in a string so find end quote
+			{
+				if($c == $quoteChar && !$escaped && !$inComment)
+				{
+					$inQuote = false;
+					$literal .= $c;
+	
+					//subsitute in a marker for the string
+					$clean .= "___" . count($literal_strings) . "___";
+	
+					//push the string onto our array
+					array_push($literal_strings,$literal);
+	
+				}
+				else if($inComment && $d=="*/")
+				{
+					$inComment = false;
+					$literal .= $d;
+	
+					//subsitute in a marker for the string
+					$clean .= "___" . count($literal_strings) . "___";
+	
+					//push the string onto our array
+					array_push($literal_strings,$literal);
+	
+					$j++;
+				}
+				else if($c == "\\" && !$escaped)
+					$escaped = true;
+				else
+					$escaped = false;
+	
+				$literal .= $c;
+			}
+		}
+		if($inComment) $literal .= "\n";
+		$clean .= "\n";
+	}
+	//explode the clean string into lines again
+	$lines = explode("\n",$clean);
+	
+	//now process each line at a time
+	for($i=0;$i<count($lines);$i++)
+	{
+		$line = $lines[$i];
+	
+		//remove comments
+		$line = preg_replace("/\/\/(.*)/","",$line);
+	
+		//strip leading and trailing whitespace
+		$line = trim($line);
+	
+		//remove all whitespace with a single space
+		$line = preg_replace("/\s+/"," ",$line);
+	
+		//remove any whitespace that occurs after/before an operator
+		$line = preg_replace("/\s*([!\}\{;,&=\|\-\+\*\/\)\(:])\s*/","\\1",$line);
+	
+		$lines[$i] = $line;
+	}
+	
+	//implode the lines
+	$sJS = implode("\n",$lines);
+	
+	//make sure there is a max of 1 \n after each line
+	$sJS = preg_replace("/[\n]+/","\n",$sJS);
+	
+	//strip out line breaks that immediately follow a semi-colon
+	$sJS = preg_replace("/;\n/",";",$sJS);
+	
+	//curly brackets aren't on their own
+	$sJS = preg_replace("/[\n]*\{[\n]*/","{",$sJS);
+	
+	//finally loop through and replace all the literal strings:
+	for($i=0;$i<count($literal_strings);$i++)
+		$sJS = str_replace("___".$i."___",$literal_strings[$i],$sJS);
+	
+	return $sJS;
+}
+?>
\ No newline at end of file
diff --git a/lib/xajax_0.2.4/xajaxResponse.inc.php b/lib/xajax_0.2.4/xajaxResponse.inc.php
new file mode 100644
index 0000000..1c0aeb6
--- /dev/null
+++ b/lib/xajax_0.2.4/xajaxResponse.inc.php
@@ -0,0 +1,580 @@
+<?php
+/**
+ * xajaxResponse.inc.php :: xajax XML response class
+ *
+ * xajax version 0.2.4
+ * copyright (c) 2005 by Jared White & J. Max Wilson
+ * http://www.xajaxproject.org
+ *
+ * xajax is an open source PHP class library for easily creating powerful
+ * PHP-driven, web-based Ajax Applications. Using xajax, you can asynchronously
+ * call PHP functions and update the content of your your webpage without
+ * reloading the page.
+ *
+ * xajax is released under the terms of the LGPL license
+ * http://www.gnu.org/copyleft/lesser.html#SEC3
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * @package xajax
+ * @version $Id$
+ * @copyright Copyright (c) 2005-2006  by Jared White & J. Max Wilson
+ * @license http://www.gnu.org/copyleft/lesser.html#SEC3 LGPL License
+ */
+
+/*
+   ----------------------------------------------------------------------------
+   | Online documentation for this class is available on the xajax wiki at:   |
+   | http://wiki.xajaxproject.org/Documentation:xajaxResponse.inc.php         |
+   ----------------------------------------------------------------------------
+*/
+
+/**
+ * The xajaxResponse class is used to create responses to be sent back to your
+ * Web page.  A response contains one or more command messages for updating
+ * your page.
+ * Currently xajax supports 21 kinds of command messages, including some common
+ * ones such as:
+ * <ul>
+ * <li>Assign - sets the specified attribute of an element in your page</li>
+ * <li>Append - appends data to the end of the specified attribute of an
+ * element in your page</li>
+ * <li>Prepend - prepends data to the beginning of the specified attribute of
+ * an element in your page</li>
+ * <li>Replace - searches for and replaces data in the specified attribute of
+ * an element in your page</li>
+ * <li>Script - runs the supplied JavaScript code</li>
+ * <li>Alert - shows an alert box with the supplied message text</li>
+ * </ul>
+ *
+ * <i>Note:</i> elements are identified by their HTML id, so if you don't see
+ * your browser HTML display changing from the request, make sure you're using
+ * the right id names in your response.
+ * 
+ * @package xajax
+ */
+class xajaxResponse
+{
+	/**#@+
+	 * @access protected
+	 */
+	/**
+	 * @var string internal XML storage
+	 */	
+	var $xml;
+	/**
+	 * @var string the encoding type to use
+	 */
+	var $sEncoding;
+	/**
+	 * @var boolean if special characters in the XML should be converted to
+	 *              entities
+	 */
+	var $bOutputEntities;
+
+	/**#@-*/
+	
+	/**
+	 * The constructor's main job is to set the character encoding for the
+	 * response.
+	 * 
+	 * <i>Note:</i> to change the character encoding for all of the
+	 * responses, set the XAJAX_DEFAULT_ENCODING constant before you
+	 * instantiate xajax.
+	 * 
+	 * @param string  contains the character encoding string to use
+	 * @param boolean lets you set if you want special characters in the output
+	 *                converted to HTML entities
+	 * 
+	 */
+	function xajaxResponse($sEncoding=XAJAX_DEFAULT_CHAR_ENCODING, $bOutputEntities=false)
+	{
+		$this->setCharEncoding($sEncoding);
+		$this->bOutputEntities = $bOutputEntities;
+	}
+	
+	/**
+	 * Sets the character encoding for the response based on $sEncoding, which
+	 * is a string containing the character encoding to use. You don't need to
+	 * use this method normally, since the character encoding for the response
+	 * gets set automatically based on the XAJAX_DEFAULT_CHAR_ENCODING
+	 * constant.
+	 * 
+	 * @param string
+	 */
+	function setCharEncoding($sEncoding)
+	{
+		$this->sEncoding = $sEncoding;
+	}
+	
+	/**
+	 * Tells the response object to convert special characters to HTML entities
+	 * automatically (only works if the mb_string extension is available).
+	 */
+	function outputEntitiesOn()
+	{
+		$this->bOutputEntities = true;
+	}
+	
+	/**
+	 * Tells the response object to output special characters intact. (default
+	 * behavior)
+	 */
+	function outputEntitiesOff()
+	{
+		$this->bOutputEntities = false;
+	}
+
+	/**
+	 * Adds a confirm commands command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addConfirmCommands(1, "Do you want to preview the new data?");</kbd>
+	 *
+	 * @param integer the number of commands to skip if the user presses
+	 *                Cancel in the browsers's confirm dialog
+	 * @param string  the message to show in the browser's confirm dialog
+	 */
+	function addConfirmCommands($iCmdNumber, $sMessage)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"cc","t"=>$iCmdNumber),$sMessage);
+	}
+	
+	/**
+	 * Adds an assign command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addAssign("contentDiv", "innerHTML", "Some Text");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element
+	 * @param string the part of the element you wish to modify ("innerHTML",
+	 *               "value", etc.)
+	 * @param string the data you want to set the attribute to
+	 */
+	function addAssign($sTarget,$sAttribute,$sData)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"as","t"=>$sTarget,"p"=>$sAttribute),$sData);
+	}
+
+	/**
+	 * Adds an append command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addAppend("contentDiv", "innerHTML", "Some New Text");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element
+	 * @param string the part of the element you wish to modify ("innerHTML",
+	 *               "value", etc.)
+	 * @param string the data you want to append to the end of the attribute
+	 */
+	function addAppend($sTarget,$sAttribute,$sData)
+	{	
+		$this->xml .= $this->_cmdXML(array("n"=>"ap","t"=>$sTarget,"p"=>$sAttribute),$sData);
+	}
+
+	/**
+	 * Adds an prepend command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addPrepend("contentDiv", "innerHTML", "Some Starting Text");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element
+	 * @param string the part of the element you wish to modify ("innerHTML",
+	 *               "value", etc.)
+	 * @param string the data you want to prepend to the beginning of the
+	 *               attribute
+	 */
+	function addPrepend($sTarget,$sAttribute,$sData)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"pp","t"=>$sTarget,"p"=>$sAttribute),$sData);
+	}
+
+	/**
+	 * Adds a replace command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addReplace("contentDiv", "innerHTML", "text", "<b>text</b>");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element
+	 * @param string the part of the element you wish to modify ("innerHTML",
+	 *               "value", etc.)
+	 * @param string the string to search for
+	 * @param string the string to replace the search string when found in the
+	 *               attribute
+	 */
+	function addReplace($sTarget,$sAttribute,$sSearch,$sData)
+	{
+		$sDta = "<s><![CDATA[$sSearch]]></s><r><![CDATA[$sData]]></r>";
+		$this->xml .= $this->_cmdXML(array("n"=>"rp","t"=>$sTarget,"p"=>$sAttribute),$sDta);
+	}
+
+	/**
+	 * Adds a clear command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addClear("contentDiv", "innerHTML");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element
+	 * @param string the part of the element you wish to clear ("innerHTML",
+	 *               "value", etc.)
+	 */	
+	function addClear($sTarget,$sAttribute)
+	{
+		$this->addAssign($sTarget,$sAttribute,'');
+	}
+	
+	/**
+	 * Adds an alert command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addAlert("This is important information");</kbd>
+	 * 
+	 * @param string the text to be displayed in the Javascript alert box
+	 */
+	function addAlert($sMsg)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"al"),$sMsg);
+	}
+
+	/**
+	 * Uses the addScript() method to add a Javascript redirect to another URL.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addRedirect("http://www.xajaxproject.org");</kbd>
+	 * 
+	 * @param string the URL to redirect the client browser to
+	 */	
+	function addRedirect($sURL)
+	{
+		//we need to parse the query part so that the values are rawurlencode()'ed
+		//can't just use parse_url() cos we could be dealing with a relative URL which
+		//  parse_url() can't deal with.
+		$queryStart = strpos($sURL, '?', strrpos($sURL, '/'));
+		if ($queryStart !== FALSE)
+		{
+			$queryStart++;
+			$queryEnd = strpos($sURL, '#', $queryStart);
+			if ($queryEnd === FALSE)
+				$queryEnd = strlen($sURL);
+			$queryPart = substr($sURL, $queryStart, $queryEnd-$queryStart);
+			parse_str($queryPart, $queryParts);
+			$newQueryPart = "";
+			foreach($queryParts as $key => $value)
+			{
+				$newQueryPart .= rawurlencode($key).'='.rawurlencode($value).ini_get('arg_separator.output');
+			}
+			$sURL = str_replace($queryPart, $newQueryPart, $sURL);
+		}
+		$this->addScript('window.location = "'.$sURL.'";');
+	}
+
+	/**
+	 * Adds a Javascript command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addScript("var x = prompt('get some text');");</kbd>
+	 * 
+	 * @param string contains Javascript code to be executed
+	 */
+	function addScript($sJS)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"js"),$sJS);
+	}
+
+	/**
+	 * Adds a Javascript function call command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addScriptCall("myJSFunction", "arg 1", "arg 2", 12345);</kbd>
+	 * 
+	 * @param string $sFunc the name of a Javascript function
+	 * @param mixed $args,... optional arguments to pass to the Javascript function
+	 */
+	function addScriptCall() {
+		$arguments = func_get_args();
+		$sFunc = array_shift($arguments);
+		$sData = $this->_buildObjXml($arguments);
+		$this->xml .= $this->_cmdXML(array("n"=>"jc","t"=>$sFunc),$sData);
+	}
+
+	/**
+	 * Adds a remove element command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addRemove("Div2");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element to be removed
+	 */
+	function addRemove($sTarget)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"rm","t"=>$sTarget),'');
+	}
+
+	/**
+	 * Adds a create element command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addCreate("parentDiv", "h3", "myid");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element to to which the new
+	 *               element will be appended.
+	 * @param string the tag to be added
+	 * @param string the id to be assigned to the new element
+	 * @param string deprecated, use the addCreateInput() method instead
+	 */
+	function addCreate($sParent, $sTag, $sId, $sType="")
+	{
+		if ($sType)
+		{
+			trigger_error("The \$sType parameter of addCreate has been deprecated.  Use the addCreateInput() method instead.", E_USER_WARNING);
+			return;
+		}
+		$this->xml .= $this->_cmdXML(array("n"=>"ce","t"=>$sParent,"p"=>$sId),$sTag);
+	}
+
+	/**
+	 * Adds a insert element command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addInsert("childDiv", "h3", "myid");</kbd>
+	 * 
+	 * @param string contains the id of the child before which the new element
+	 *               will be inserted
+	 * @param string the tag to be added
+	 * @param string the id to be assigned to the new element
+	 */
+	function addInsert($sBefore, $sTag, $sId)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"ie","t"=>$sBefore,"p"=>$sId),$sTag);
+	}
+
+	/**
+	 * Adds a insert element command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addInsertAfter("childDiv", "h3", "myid");</kbd>
+	 * 
+	 * @param string contains the id of the child after which the new element
+	 *               will be inserted
+	 * @param string the tag to be added
+	 * @param string the id to be assigned to the new element
+	 */
+	function addInsertAfter($sAfter, $sTag, $sId)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"ia","t"=>$sAfter,"p"=>$sId),$sTag);
+	}
+	
+	/**
+	 * Adds a create input command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addCreateInput("form1", "text", "username", "input1");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element to which the new input
+	 *               will be appended
+	 * @param string the type of input to be created (text, radio, checkbox,
+	 *               etc.)
+	 * @param string the name to be assigned to the new input and the variable
+	 *               name when it is submitted
+	 * @param string the id to be assigned to the new input
+	 */
+	function addCreateInput($sParent, $sType, $sName, $sId)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"ci","t"=>$sParent,"p"=>$sId,"c"=>$sType),$sName);
+	}
+
+	/**
+	 * Adds an insert input command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addInsertInput("input5", "text", "username", "input1");</kbd>
+	 * 
+	 * @param string contains the id of the child before which the new element
+	 *               will be inserted
+	 * @param string the type of input to be created (text, radio, checkbox,
+	 *               etc.)
+	 * @param string the name to be assigned to the new input and the variable
+	 *               name when it is submitted
+	 * @param string the id to be assigned to the new input
+	 */
+	function addInsertInput($sBefore, $sType, $sName, $sId)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"ii","t"=>$sBefore,"p"=>$sId,"c"=>$sType),$sName);
+	}
+
+	/**
+	 * Adds an insert input command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addInsertInputAfter("input7", "text", "email", "input2");</kbd>
+	 * 
+	 * @param string contains the id of the child after which the new element
+	 *               will be inserted
+	 * @param string the type of input to be created (text, radio, checkbox,
+	 *               etc.)
+	 * @param string the name to be assigned to the new input and the variable
+	 *               name when it is submitted
+	 * @param string the id to be assigned to the new input
+	 */
+	function addInsertInputAfter($sAfter, $sType, $sName, $sId)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"iia","t"=>$sAfter,"p"=>$sId,"c"=>$sType),$sName);
+	}
+
+	/**
+	 * Adds an event command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addEvent("contentDiv", "onclick", "alert(\'Hello World\');");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element
+	 * @param string the event you wish to set ("onclick", "onmouseover", etc.)
+	 * @param string the Javascript string you want the event to invoke
+	 */
+	function addEvent($sTarget,$sEvent,$sScript)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"ev","t"=>$sTarget,"p"=>$sEvent),$sScript);
+	}
+
+	/**
+	 * Adds a handler command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addHandler("contentDiv", "onclick", "content_click");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element
+	 * @param string the event you wish to set ("onclick", "onmouseover", etc.)
+	 * @param string the name of a Javascript function that will handle the
+	 *               event. Multiple handlers can be added for the same event
+	 */
+	function addHandler($sTarget,$sEvent,$sHandler)
+	{	
+		$this->xml .= $this->_cmdXML(array("n"=>"ah","t"=>$sTarget,"p"=>$sEvent),$sHandler);
+	}
+
+	/**
+	 * Adds a remove handler command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addRemoveHandler("contentDiv", "onclick", "content_click");</kbd>
+	 * 
+	 * @param string contains the id of an HTML element
+	 * @param string the event you wish to remove ("onclick", "onmouseover",
+	 *               etc.)
+	 * @param string the name of a Javascript handler function that you want to
+	 *               remove
+	 */
+	function addRemoveHandler($sTarget,$sEvent,$sHandler)
+	{	
+		$this->xml .= $this->_cmdXML(array("n"=>"rh","t"=>$sTarget,"p"=>$sEvent),$sHandler);
+	}
+
+	/**
+	 * Adds an include script command message to the XML response.
+	 * 
+	 * <i>Usage:</i> <kbd>$objResponse->addIncludeScript("functions.js");</kbd>
+	 * 
+	 * @param string URL of the Javascript file to include
+	 */
+	function addIncludeScript($sFileName)
+	{
+		$this->xml .= $this->_cmdXML(array("n"=>"in"),$sFileName);
+	}
+
+	/**	
+	 * Returns the XML to be returned from your function to the xajax processor
+	 * on your page. Since xajax 0.2, you can also return an xajaxResponse
+	 * object from your function directly, and xajax will automatically request
+	 * the XML using this method call.
+	 * 
+	 * <i>Usage:</i> <kbd>return $objResponse->getXML();</kbd>
+	 * 
+	 * @return string response XML data
+	 */
+	function getXML()
+	{
+		$sXML = "<?xml version=\"1.0\"";
+		if ($this->sEncoding && strlen(trim($this->sEncoding)) > 0)
+			$sXML .= " encoding=\"".$this->sEncoding."\"";
+		$sXML .= " ?"."><xjx>" . $this->xml . "</xjx>";
+		
+		return $sXML;
+	}
+	
+	/**
+	 * Adds the commands of the provided response XML output to this response
+	 * object
+	 * 
+	 * <i>Usage:</i>
+	 * <code>$r1 = $objResponse1->getXML();
+	 * $objResponse2->loadXML($r1);
+	 * return $objResponse2->getXML();</code>
+	 * 
+	 * @param string the response XML (returned from a getXML() method) to add
+	 *               to the end of this response object
+	 */
+	function loadXML($mXML)
+	{
+		if (is_a($mXML, "xajaxResponse")) {
+			$mXML = $mXML->getXML();
+		}
+		$sNewXML = "";
+		$iStartPos = strpos($mXML, "<xjx>") + 5;
+		$sNewXML = substr($mXML, $iStartPos);
+		$iEndPos = strpos($sNewXML, "</xjx>");
+		$sNewXML = substr($sNewXML, 0, $iEndPos);
+		$this->xml .= $sNewXML;
+	}
+
+	/**
+	 * Generates XML from command data
+	 * 
+	 * @access private
+	 * @param array associative array of attributes
+	 * @param string data
+	 * @return string XML command
+	 */
+	function _cmdXML($aAttributes, $sData)
+	{
+		if ($this->bOutputEntities) {
+			if (function_exists('mb_convert_encoding')) {
+				$sData = call_user_func_array('mb_convert_encoding', array(&$sData, 'HTML-ENTITIES', $this->sEncoding));
+			}
+			else {
+				trigger_error("The xajax XML response output could not be converted to HTML entities because the mb_convert_encoding function is not available", E_USER_NOTICE);
+			}
+		}
+		$xml = "<cmd";
+		foreach($aAttributes as $sAttribute => $sValue)
+			$xml .= " $sAttribute=\"$sValue\"";
+		if ($sData !== null && !stristr($sData,'<![CDATA['))
+			$xml .= "><![CDATA[$sData]]></cmd>";
+		else if ($sData !== null)
+			$xml .= ">$sData</cmd>";
+		else
+			$xml .= "></cmd>";
+		
+		return $xml;
+	}
+
+	/**
+	 * Recursively serializes a data structure in XML so it can be sent to
+	 * the client. It could be thought of as the opposite of
+	 * {@link xajax::_parseObjXml()}.
+	 * 
+	 * @access private
+	 * @param mixed data structure to serialize to XML
+	 * @return string serialized XML
+	 */
+	function _buildObjXml($var) {
+		if (gettype($var) == "object") $var = get_object_vars($var);
+		if (!is_array($var)) {
+			return "<![CDATA[$var]]>";
+		}
+		else {
+			$data = "<xjxobj>";
+			foreach ($var as $key => $value) {
+				$data .= "<e>";
+				$data .= "<k>" . htmlspecialchars($key) . "</k>";
+				$data .= "<v>" . $this->_buildObjXml($value) . "</v>";
+				$data .= "</e>";
+			}
+			$data .= "</xjxobj>";
+			return $data;
+		}
+	}
+	
+}// end class xajaxResponse
+?>