30 files changed, 2768 insertions, 1436 deletions
diff --git a/js/classes/ElggPriorityList.js b/js/classes/ElggPriorityList.js
index 521fbbb64..b4cec5044 100644
--- a/js/classes/ElggPriorityList.js
+++ b/js/classes/ElggPriorityList.js
@@ -1,60 +1,92 @@
+/**
+ * Priority lists allow you to create an indexed list that can be iterated through in a specific
+ * order.
+ */
 elgg.ElggPriorityList = function() {
 	this.length = 0;
 	this.priorities_ = [];
 };
 
+/**
+ * Inserts an element into the priority list at the priority specified.
+ *
+ * @param {Object} obj          The object to insert
+ * @param {Number} opt_priority An optional priority to insert at.
+ * 
+ * @return {Void}
+ */
 elgg.ElggPriorityList.prototype.insert = function(obj, opt_priority) {
-	if (opt_priority == undefined) {
-		opt_priority = 500;
-	} 
-
-	opt_priority = parseInt(opt_priority);
-	if (opt_priority < 0) {
-		opt_priority = 0;
+	var priority = 500;
+	if (arguments.length == 2 && opt_priority != undefined) {
+		priority = parseInt(opt_priority, 10);
 	}
-	
-	if (this.priorities_[opt_priority] == undefined) {
-		this.priorities_[opt_priority] = [];
+
+	priority = Math.max(priority, 0);
+
+	if (elgg.isUndefined(this.priorities_[priority])) {
+		this.priorities_[priority] = [];
 	}
-	
-	this.priorities_[opt_priority].push(obj);
+
+	this.priorities_[priority].push(obj);
 	this.length++;
 };
 
+/**
+ * Iterates through each element in order.
+ *
+ * Unlike every, this ignores the return value of the callback.
+ *
+ * @param {Function} callback The callback function to pass each element through. See
+ *                            Array.prototype.every() for details.
+ * @return {Object}
+ */
 elgg.ElggPriorityList.prototype.forEach = function(callback) {
 	elgg.assertTypeOf('function', callback);
 
 	var index = 0;
-	for (var p in this.priorities_) {
-		var elems = this.priorities_[p];
-		for (var i in elems) {
-			callback(elems[i], index);
-			index++;
-		}
-	}
+
+	this.priorities_.forEach(function(elems) {
+		elems.forEach(function(elem) {
+			callback(elem, index++);
+		});
+	});
+
+	return this;
 };
 
+/**
+ * Iterates through each element in order.
+ *
+ * Unlike forEach, this returns the value of the callback and will break on false.
+ *
+ * @param {Function} callback The callback function to pass each element through. See
+ *                            Array.prototype.every() for details.
+ * @return {Object}
+ */
 elgg.ElggPriorityList.prototype.every = function(callback) {
 	elgg.assertTypeOf('function', callback);
-	
+
 	var index = 0;
-	for (var p in this.priorities_) {
-		var elems = this.priorities_[p];
-		for (var i in elems) {
-			if (!callback(elems[i], index)) {
-				return false;
-			};
-		}
-	}
-	
-	return true;
+
+	return this.priorities_.every(function(elems) {
+		return elems.every(function(elem) {
+			return callback(elem, index++);
+		});
+	});
 };
 
+/**
+ * Removes an element from the priority list
+ *
+ * @param {Object} obj The object to remove.
+ * @return {Void}
+ */
 elgg.ElggPriorityList.prototype.remove = function(obj) {
-	this.priorities_.forEach(function(elems, priority) {
+	this.priorities_.forEach(function(elems) {
 		var index;
-		while ((index = elems.indexOf(obj)) != -1) {
+		while ((index = elems.indexOf(obj)) !== -1) {
 			elems.splice(index, 1);
+			this.length--;
 		}
 	});
 };
 \ No newline at end of file
diff --git a/js/classes/ElggUser.js b/js/classes/ElggUser.js
index 8a7a8b7eb..b8a976fba 100644
--- a/js/classes/ElggUser.js
+++ b/js/classes/ElggUser.js
@@ -6,9 +6,23 @@
  * @class Represents an ElggUser
  * @property {string} name
  * @property {string} username
+ * @property {string} language
+ * @property {boolean} admin
  */
 elgg.ElggUser = function(o) {
 	elgg.ElggEntity.call(this, o);
 };
 
-elgg.inherit(elgg.ElggUser, elgg.ElggEntity);
-\ No newline at end of file
+elgg.inherit(elgg.ElggUser, elgg.ElggEntity);
+
+/**
+ * Is this user an admin?
+ *
+ * @warning The admin state of the user should be checked on the server for any
+ * actions taken that require admin privileges.
+ *
+ * @return {boolean}
+ */
+elgg.ElggUser.prototype.isAdmin = function() {
+	return this.admin;
+};
+\ No newline at end of file
diff --git a/js/lib/ajax.js b/js/lib/ajax.js
index 184fd0da3..b3f39cc42 100644
--- a/js/lib/ajax.js
+++ b/js/lib/ajax.js
@@ -1,252 +1,242 @@
-elgg.provide('elgg.ajax');
-
-/**
- * @author Evan Winslow
- * Provides a bunch of useful shortcut functions for making ajax calls
- */
-
-/**
- * Wrapper function for jQuery.ajax which ensures that the url being called
- * is relative to the elgg site root.
- * 
- * You would most likely use elgg.get or elgg.post, rather than this function
- * 
- * @param {string} url Optionally specify the url as the first argument
- * @param {Object} options Optional. {@see jQuery#ajax}
- * @return {XmlHttpRequest}
- */
-elgg.ajax = function(url, options) {
-	options = elgg.ajax.handleOptions(url, options);
-	
-	options.url = elgg.normalize_url(options.url);
-	return $.ajax(options);
-};
-/**
- * @const
- */
-elgg.ajax.SUCCESS = 0;
-
-/**
- * @const
- */
-elgg.ajax.ERROR = -1;
-
-/**
- * Handle optional arguments and return the resulting options object
- * 
- * @param url
- * @param options
- * @return {Object}
- * @private
- */
-elgg.ajax.handleOptions = function(url, options) {
-	//elgg.ajax('example/file.php', {...});
-	if(typeof url == 'string') {
-		options = options || {};
-	
-	//elgg.ajax({...});
-	} else {
-		options = url || {};
-		url = options.url;
-	}
-	
-	var data_only = true;
-
-	//elgg.ajax('example/file.php', function() {...});
-	if (typeof options == 'function') {
-		data_only = false;
-		options = {success: options};
-	}
-	
-	//elgg.ajax('example/file.php', {data:{...}});
-	if(options.data) {
-		data_only = false;
-	} else {
-		for (var member in options) {
-			//elgg.ajax('example/file.php', {callback:function(){...}});
-			if(typeof options[member] == 'function') {
-				data_only = false;
-			}
-		}
-	}
-
-	//elgg.ajax('example/file.php', {notdata:notfunc});
-	if (data_only) {
-		var data = options;
-		options = {data: data};
-	}
-	
-	if (url) {
-		options.url = url;
-	}
-	
-	return options;
-};
-
-/**
- * Wrapper function for elgg.ajax which forces the request type to 'get.'
- * 
- * @param {string} url Optionally specify the url as the first argument
- * @param {Object} options {@see jQuery#ajax}
- * @return {XmlHttpRequest}
- */
-elgg.get = function(url, options) {
-	options = elgg.ajax.handleOptions(url, options);
-	
-	options.type = 'get';
-	return elgg.ajax(options);
-};
-
-/**
- * Wrapper function for elgg.get which forces the dataType to 'json.'
- * 
- * @param {string} url Optionally specify the url as the first argument
- * @param {Object} options {@see jQuery#ajax}
- * @return {XmlHttpRequest}
- */
-elgg.getJSON = function(url, options) {
-	options = elgg.ajax.handleOptions(url, options);
-	
-	options.dataType = 'json';
-	return elgg.get(options);
-};
-
-/**
- * Wrapper function for elgg.ajax which forces the request type to 'post.'
- * 
- * @param {string} url Optionally specify the url as the first argument
- * @param {Object} options {@see jQuery#ajax}
- * @return {XmlHttpRequest}
- */
-elgg.post = function(url, options) {
-	options = elgg.ajax.handleOptions(url, options);
-	
-	options.type = 'post';
-	return elgg.ajax(options);
-};
-
-/**
- * Perform an action via ajax
- * 
- * @example Usage 1:
- * At its simplest, only the action name is required (and anything more than the
- * action name will be invalid).
- * <pre>
- * elgg.action('name/of/action');
- * </pre>
- * Note that it will *not* love you if you specify the full url as the action
- * (i.e. elgg.yoursite.com/action/name/of/action), but why would you want to do
- * that anyway, when you can just specify the action name?
- * 
- * @example Usage 2:
- * If you want to pass some data along with it, use the second parameter
- * <pre>
- * elgg.action('friend/add', { friend: some_guid });
- * </pre>
- * 
- * @example Usage 3:
- * Of course, you will have no control over what happens when the request
- * completes if you do it like that, so there's also the most verbose method
- * <pre>
- * elgg.action('friend/add', {
- *     data: {
- *         friend: some_guid
- *     },
- *     success: function(json) {
- *         //do something
- *     },
- * }
- * </pre>
- * You can pass any of your favorite $.ajax arguments into this second parameter.
- * 
- * Note: If you intend to use the second field in the "verbose" way, you must
- * specify a callback method or the data parameter.  If you do not, elgg.action
- * will think you mean to send the second parameter as data.
- * 
- * @param {String} action The action to call.
- * @param {Object} options {@see jQuery#ajax}
- * @return {XMLHttpRequest}
- */
-elgg.action = function(action, options) {
-	if(!action) {
-		throw new TypeError("action must be specified");
-	} else if (typeof action != 'string') {
-		throw new TypeError("action must be a string");
-	}
-	
-	options = elgg.ajax.handleOptions('action/' + action, options);
-	
-	options.data = elgg.security.addToken(options.data);
-	options.dataType = 'json';
-	
-	//Always display system messages after actions
-	var custom_success = options.success || function(){};
-	options.success = function(json, two, three, four) {
-		if (json.system_messages) {
-			elgg.register_error(json.system_messages.errors);
-			elgg.system_message(json.system_messages.messages);
-		}
-		custom_success(json, two, three, four);
-	};
-	
-	return elgg.post(options);
-};
-
-/**
- * Make an API call
- * 
- * @example Usage:
- * <pre>
- * elgg.api('system.api.list', {
- *     success: function(data) {
- *         console.log(data);
- *     }
- * });
- * </pre>
- * 
- * @param {String} method The API method to be called
- * @param {Object} options {@see jQuery#ajax}
- * @return {XmlHttpRequest}
- */
-elgg.api = function(method, options) {
-	if (!method) {
-		throw new TypeError("method must be specified");
-	} else if (typeof method != 'string') {
-		throw new TypeError("method must be a string");
-	}
-	
-	var defaults = {
-		dataType: 'json',
-		data: {}
-	};
-	
-	options = elgg.ajax.handleOptions(method, options);
-	options = $.extend(defaults, options);
-	
-	options.url = 'services/api/rest/' + options.dataType + '/';
-	options.data.method = method;
-	
-	return elgg.ajax(options);
-};
-
-/**
- * @param {string} selector a jQuery selector
- * @param {Function} complete A function to execute when the refresh is done
- * @return {XMLHttpRequest}
- */
-elgg.refresh = function(selector, complete) {
-	$(selector).html('<div align="center" class="ajax_loader"></div>');
-	return $(selector).load(location.href + ' ' + selector + ' > *', complete);
-};
-
-/**
- * @param {string} selector a jQuery selector (usually an #id)
- * @param {number} interval The refresh interval in seconds
- * @param {Function} complete A function to execute when the refresh is done
- * @return {number} The interval identifier
- */
-elgg.feed = function(selector, interval, complete) {
-	return setInterval(function() {
-		elgg.refresh(selector, complete);
-	}, interval);
-};
-\ No newline at end of file
+/*globals elgg, $*/
+elgg.provide('elgg.ajax');
+
+/**
+ * @author Evan Winslow
+ * Provides a bunch of useful shortcut functions for making ajax calls
+ */
+
+/**
+ * Wrapper function for jQuery.ajax which ensures that the url being called
+ * is relative to the elgg site root.
+ *
+ * You would most likely use elgg.get or elgg.post, rather than this function
+ *
+ * @param {string} url Optionally specify the url as the first argument
+ * @param {Object} options Optional. {@see jQuery#ajax}
+ * @return {XmlHttpRequest}
+ */
+elgg.ajax = function(url, options) {
+	options = elgg.ajax.handleOptions(url, options);
+
+	options.url = elgg.normalize_url(options.url);
+	return $.ajax(options);
+};
+/**
+ * @const
+ */
+elgg.ajax.SUCCESS = 0;
+
+/**
+ * @const
+ */
+elgg.ajax.ERROR = -1;
+
+/**
+ * Handle optional arguments and return the resulting options object
+ *
+ * @param url
+ * @param options
+ * @return {Object}
+ * @private
+ */
+elgg.ajax.handleOptions = function(url, options) {
+	var data_only = true,
+		data,
+		member;
+
+	//elgg.ajax('example/file.php', {...});
+	if (elgg.isString(url)) {
+		options = options || {};
+
+	//elgg.ajax({...});
+	} else {
+		options = url || {};
+		url = options.url;
+	}
+
+	//elgg.ajax('example/file.php', function() {...});
+	if (elgg.isFunction(options)) {
+		data_only = false;
+		options = {success: options};
+	}
+
+	//elgg.ajax('example/file.php', {data:{...}});
+	if (options.data) {
+		data_only = false;
+	} else {
+		for (member in options) {
+			//elgg.ajax('example/file.php', {callback:function(){...}});
+			if (elgg.isFunction(options[member])) {
+				data_only = false;
+			}
+		}
+	}
+
+	//elgg.ajax('example/file.php', {notdata:notfunc});
+	if (data_only) {
+		data = options;
+		options = {data: data};
+	}
+
+	if (url) {
+		options.url = url;
+	}
+
+	return options;
+};
+
+/**
+ * Wrapper function for elgg.ajax which forces the request type to 'get.'
+ *
+ * @param {string} url Optionally specify the url as the first argument
+ * @param {Object} options {@see jQuery#ajax}
+ * @return {XmlHttpRequest}
+ */
+elgg.get = function(url, options) {
+	options = elgg.ajax.handleOptions(url, options);
+
+	options.type = 'get';
+	return elgg.ajax(options);
+};
+
+/**
+ * Wrapper function for elgg.get which forces the dataType to 'json.'
+ *
+ * @param {string} url Optionally specify the url as the first argument
+ * @param {Object} options {@see jQuery#ajax}
+ * @return {XmlHttpRequest}
+ */
+elgg.getJSON = function(url, options) {
+	options = elgg.ajax.handleOptions(url, options);
+
+	options.dataType = 'json';
+	return elgg.get(options);
+};
+
+/**
+ * Wrapper function for elgg.ajax which forces the request type to 'post.'
+ *
+ * @param {string} url Optionally specify the url as the first argument
+ * @param {Object} options {@see jQuery#ajax}
+ * @return {XmlHttpRequest}
+ */
+elgg.post = function(url, options) {
+	options = elgg.ajax.handleOptions(url, options);
+
+	options.type = 'post';
+	return elgg.ajax(options);
+};
+
+/**
+ * Perform an action via ajax
+ *
+ * @example Usage 1:
+ * At its simplest, only the action name is required (and anything more than the
+ * action name will be invalid).
+ * <pre>
+ * elgg.action('name/of/action');
+ * </pre>
+ *
+ * The action can be relative to the current site ('name/of/action') or
+ * the full URL of the action ('http://elgg.org/action/name/of/action').
+ *
+ * @example Usage 2:
+ * If you want to pass some data along with it, use the second parameter
+ * <pre>
+ * elgg.action('friend/add', { friend: some_guid });
+ * </pre>
+ *
+ * @example Usage 3:
+ * Of course, you will have no control over what happens when the request
+ * completes if you do it like that, so there's also the most verbose method
+ * <pre>
+ * elgg.action('friend/add', {
+ *     data: {
+ *         friend: some_guid
+ *     },
+ *     success: function(json) {
+ *         //do something
+ *     },
+ * }
+ * </pre>
+ * You can pass any of your favorite $.ajax arguments into this second parameter.
+ *
+ * @note If you intend to use the second field in the "verbose" way, you must
+ * specify a callback method or the data parameter.  If you do not, elgg.action
+ * will think you mean to send the second parameter as data.
+ *
+ * @note You do not have to add security tokens to this request.  Elgg does that
+ * for you automatically.
+ *
+ * @see jQuery.ajax
+ *
+ * @param {String} action The action to call.
+ * @param {Object} options
+ * @return {XMLHttpRequest}
+ */
+elgg.action = function(action, options) {
+	elgg.assertTypeOf('string', action);
+
+	// support shortcut and full URLs
+	// this will mangle URLs that aren't elgg actions.
+	// Use post, get, or ajax for those.
+	if (action.indexOf('action/') < 0) {
+		action = 'action/' + action;
+	}
+
+	options = elgg.ajax.handleOptions(action, options);
+
+	// This is a misuse of elgg.security.addToken() because it is not always a
+	// full query string with a ?. As such we need a special check for the tokens.
+	if (!elgg.isString(options.data) || options.data.indexOf('__elgg_ts') == -1) {
+		options.data = elgg.security.addToken(options.data);
+	}
+	options.dataType = 'json';
+
+	//Always display system messages after actions
+	var custom_success = options.success || elgg.nullFunction;
+	options.success = function(json, two, three, four) {
+		if (json && json.system_messages) {
+			elgg.register_error(json.system_messages.error);
+			elgg.system_message(json.system_messages.success);
+		}
+
+		custom_success(json, two, three, four);
+	};
+
+	return elgg.post(options);
+};
+
+/**
+ * Make an API call
+ *
+ * @example Usage:
+ * <pre>
+ * elgg.api('system.api.list', {
+ *     success: function(data) {
+ *         console.log(data);
+ *     }
+ * });
+ * </pre>
+ *
+ * @param {String} method The API method to be called
+ * @param {Object} options {@see jQuery#ajax}
+ * @return {XmlHttpRequest}
+ */
+elgg.api = function (method, options) {
+	elgg.assertTypeOf('string', method);
+
+	var defaults = {
+		dataType: 'json',
+		data: {}
+	};
+
+	options = elgg.ajax.handleOptions(method, options);
+	options = $.extend(defaults, options);
+
+	options.url = 'services/api/rest/' + options.dataType + '/';
+	options.data.method = method;
+
+	return elgg.ajax(options);
+};
diff --git a/js/lib/configuration.js b/js/lib/configuration.js
index 8ed326116..6e221c957 100644
--- a/js/lib/configuration.js
+++ b/js/lib/configuration.js
@@ -1,3 +1,10 @@
 elgg.provide('elgg.config');
 
-elgg.config.wwwroot = '/';
-\ No newline at end of file
+/**
+ * Returns the current site URL
+ *
+ * @return {String} The site URL.
+ */
+elgg.get_site_url = function() {
+	return elgg.config.wwwroot;
+};
+\ No newline at end of file
diff --git a/js/lib/elgglib.js b/js/lib/elgglib.js
index 5f1edf812..a8e187f1d 100644
--- a/js/lib/elgglib.js
+++ b/js/lib/elgglib.js
@@ -1,187 +1,563 @@
-/**
- * 
- * 
- */
-
-/**
- * @namespace Namespace for elgg javascript functions
- */
-var elgg = elgg || {};
-
-elgg.assertTypeOf = function(type, param) {
-	if (typeof param !== type) {
-		throw new TypeError("Expecting param to be a(n) " + type + ".  Was a(n) " + typeof param + ".");
-	}
-};
-
-/**
- * Pointer to the global context
- * {@see elgg.require} and {@see elgg.provide}
- */
-elgg.global = this;
-
-/**
- * Throw an error if the required package isn't present
- * 
- * @param {String} pkg The required package (e.g., 'elgg.package')
- */
-elgg.require = function(pkg) {
-	elgg.assertTypeOf('string', pkg);
-	
-	var parts = pkg.split('.'),
-		cur = elgg.global,
-		part;
-
-	for (var i = 0; i < parts.length; i++) {
-		part = parts[i];
-		cur = cur[part];
-		if(typeof cur == 'undefined') {
-			throw new Error("Missing package: " + pkg);
-		}
-	}
-};
-
-/**
- * Generate the skeleton for a package.
- * 
- * <pre>
- * elgg.provide('elgg.package.subpackage');
- * </pre>
- * 
- * is equivalent to
- * 
- * <pre>
- * elgg = elgg || {};
- * elgg.package = elgg.package || {};
- * elgg.package.subpackage = elgg.package.subpackage || {};
- * </pre>
- * 
- * @example elgg.provide('elgg.config.translations')
- * 
- * @param {string} pkg The package name.
- */
-elgg.provide = function(pkg) {
-	elgg.assertTypeOf('string', pkg);
-	
-	var parts = pkg.split('.'),
-		cur = elgg.global,
-		part;
-	
-	for (var i = 0; i < parts.length; i++) {
-		part = parts[i];
-		cur[part] = cur[part] || {};
-		cur = cur[part];
-	}
-};
-
-/**
- * Inherit the prototype methods from one constructor into another.
- * 
- * @example
- * <pre>
- * function ParentClass(a, b) { }
- * 
- * ParentClass.prototype.foo = function(a) { alert(a); }
- *
- * function ChildClass(a, b, c) {
- *     //equivalent of parent::__construct(a, b); in PHP
- *     ParentClass.call(this, a, b);
- * }
- *
- * elgg.inherit(ChildClass, ParentClass);
- *
- * var child = new ChildClass('a', 'b', 'see');
- * child.foo('boo!'); // alert('boo!');
- * </pre>
- *
- * @param {Function} childCtor Child class.
- * @param {Function} parentCtor Parent class.
- */
-elgg.inherit = function(Child, Parent) {
-	Child.prototype = new Parent();
-	Child.prototype.constructor = Child;
-};
-
-/**
- * Prepend elgg.config.wwwroot to a url if the url doesn't already have it.
- * 
- * @param {String} url The url to extend
- * @return {String} The extended url
- * @private
- */
-elgg.normalize_url = function(url) {
-	url = url || '';
-	elgg.assertTypeOf('string', url);
-	
-	if(/(^(https?:)?\/\/)/.test(url)) {
-		return url;
-	}
-	
-	return elgg.config.wwwroot + url;
-};
-
-/**
- * Displays system messages via javascript rather than php.
- * 
- * @param {String} msgs The message we want to display
- * @param {Number} delay The amount of time to display the message in milliseconds. Defaults to 6 seconds.
- * @param {String} type The type of message (typically 'error' or 'message')
- * @private
- */
-elgg.system_messages = function(msgs, delay, type) {
-	if (msgs == undefined) {
-		return;
-	}
-	
-	//validate delay.  Must be a positive integer. 
-	delay = parseInt(delay);
-	if (isNaN(delay) || delay <= 0) {
-		delay = 6000;
-	}
-	
-	classes = ['elgg_system_message', 'radius8'];
-	if (type == 'error') {
-		classes.push('messages_error');
-	}
-
-	//Handle non-arrays
-	if (msgs.constructor.toString().indexOf("Array") == -1) {
-		msgs = [msgs];
-	}
-	
-	var messages_html = [];
-	
-	for (var i in msgs) {
-		messages_html.push('<div class="' + classes.join(' ') + '"><p>' + msgs[i] + '</p></div>');
-	}
-	
-	$(messages_html.join('')).appendTo('#elgg_system_messages').animate({opacity:'1.0'},delay).fadeOut('slow');
-};
-
-/**
- * Wrapper function for system_messages. Specifies "messages" as the type of message
- * @param {String} msg The message to display
- * @param {Number} delay How long to display the message (milliseconds)
- */
-elgg.system_message = function(msgs, delay) {
-	elgg.system_messages(msgs, delay, "message");
-};
-
-/**
- * Wrapper function for system_messages.  Specifies "errors" as the type of message
- * @param {String} error The error message to display
- * @param {Number} delay How long to dispaly the error message (milliseconds)
- */
-elgg.register_error = function(errors, delay) {
-	elgg.system_messages(errors, delay, "error");
-};
-
-/**
- * Meant to mimic the php forward() function by simply redirecting the
- * user to another page.
- * 
- * @param {String} url The url to forward to
- */
-elgg.forward = function(url) {
-	location.href = elgg.normalize_url(url);
-};
-\ No newline at end of file
+/**
+ * @namespace Singleton object for holding the Elgg javascript library
+ */
+var elgg = elgg || {};
+
+/**
+ * Pointer to the global context
+ *
+ * @see elgg.require
+ * @see elgg.provide
+ */
+elgg.global = this;
+
+/**
+ * Convenience reference to an empty function.
+ *
+ * Save memory by not generating multiple empty functions.
+ */
+elgg.nullFunction = function() {};
+
+/**
+ * This forces an inheriting class to implement the method or
+ * it will throw an error.
+ *
+ * @example
+ * AbstractClass.prototype.toBeImplemented = elgg.abstractMethod;
+ */
+elgg.abstractMethod = function() {
+	throw new Error("Oops... you forgot to implement an abstract method!");
+};
+
+/**
+ * Merges two or more objects together and returns the result.
+ */
+elgg.extend = jQuery.extend;
+
+/**
+ * Check if the value is an array.
+ *
+ * No sense in reinventing the wheel!
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isArray = jQuery.isArray;
+
+/**
+ * Check if the value is a function.
+ *
+ * No sense in reinventing the wheel!
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isFunction = jQuery.isFunction;
+
+/**
+ * Check if the value is a "plain" object (i.e., created by {} or new Object())
+ *
+ * No sense in reinventing the wheel!
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isPlainObject = jQuery.isPlainObject;
+
+/**
+ * Check if the value is a string
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isString = function(val) {
+	return typeof val === 'string';
+};
+
+/**
+ * Check if the value is a number
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isNumber = function(val) {
+	return typeof val === 'number';
+};
+
+/**
+ * Check if the value is an object
+ *
+ * @note This returns true for functions and arrays!  If you want to return true only
+ * for "plain" objects (created using {} or new Object()) use elgg.isPlainObject.
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isObject = function(val) {
+	return typeof val === 'object';
+};
+
+/**
+ * Check if the value is undefined
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isUndefined = function(val) {
+	return val === undefined;
+};
+
+/**
+ * Check if the value is null
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isNull = function(val) {
+	return val === null;
+};
+
+/**
+ * Check if the value is either null or undefined
+ *
+ * @param {*} val
+ *
+ * @return boolean
+ */
+elgg.isNullOrUndefined = function(val) {
+	return val == null;
+};
+
+/**
+ * Throw an exception of the type doesn't match
+ *
+ * @todo Might be more appropriate for debug mode only?
+ */
+elgg.assertTypeOf = function(type, val) {
+	if (typeof val !== type) {
+		throw new TypeError("Expecting param of " +
+							arguments.caller + "to be a(n) " + type + "." +
+							"  Was actually a(n) " + typeof val + ".");
+	}
+};
+
+/**
+ * Throw an error if the required package isn't present
+ *
+ * @param {String} pkg The required package (e.g., 'elgg.package')
+ */
+elgg.require = function(pkg) {
+	elgg.assertTypeOf('string', pkg);
+
+	var parts = pkg.split('.'),
+		cur = elgg.global,
+		part, i;
+
+	for (i = 0; i < parts.length; i += 1) {
+		part = parts[i];
+		cur = cur[part];
+		if (elgg.isUndefined(cur)) {
+			throw new Error("Missing package: " + pkg);
+		}
+	}
+};
+
+/**
+ * Generate the skeleton for a package.
+ *
+ * <pre>
+ * elgg.provide('elgg.package.subpackage');
+ * </pre>
+ *
+ * is equivalent to
+ *
+ * <pre>
+ * elgg = elgg || {};
+ * elgg.package = elgg.package || {};
+ * elgg.package.subpackage = elgg.package.subpackage || {};
+ * </pre>
+ *
+ * @example elgg.provide('elgg.config.translations')
+ *
+ * @param {string} pkg The package name.
+ */
+elgg.provide = function(pkg, opt_context) {
+	elgg.assertTypeOf('string', pkg);
+
+	var parts = pkg.split('.'),
+		context = opt_context || elgg.global,
+		part, i;
+
+
+	for (i = 0; i < parts.length; i += 1) {
+		part = parts[i];
+		context[part] = context[part] || {};
+		context = context[part];
+	}
+};
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * @example
+ * <pre>
+ * function ParentClass(a, b) { }
+ *
+ * ParentClass.prototype.foo = function(a) { alert(a); }
+ *
+ * function ChildClass(a, b, c) {
+ *     //equivalent of parent::__construct(a, b); in PHP
+ *     ParentClass.call(this, a, b);
+ * }
+ *
+ * elgg.inherit(ChildClass, ParentClass);
+ *
+ * var child = new ChildClass('a', 'b', 'see');
+ * child.foo('boo!'); // alert('boo!');
+ * </pre>
+ *
+ * @param {Function} Child Child class constructor.
+ * @param {Function} Parent Parent class constructor.
+ */
+elgg.inherit = function(Child, Parent) {
+	Child.prototype = new Parent();
+	Child.prototype.constructor = Child;
+};
+
+/**
+ * Converts shorthand urls to absolute urls.
+ *
+ * If the url is already absolute or protocol-relative, no change is made.
+ *
+ * elgg.normalize_url('');                   // 'http://my.site.com/'
+ * elgg.normalize_url('dashboard');          // 'http://my.site.com/dashboard'
+ * elgg.normalize_url('http://google.com/'); // no change
+ * elgg.normalize_url('//google.com/');      // no change
+ *
+ * @param {String} url The url to normalize
+ * @return {String} The extended url
+ * @private
+ */
+elgg.normalize_url = function(url) {
+	url = url || '';
+	elgg.assertTypeOf('string', url);
+
+	validated = (function(url) {
+		url = elgg.parse_url(url);
+		if (url.scheme){
+			url.scheme = url.scheme.toLowerCase();
+		}
+		if (url.scheme == 'http' || url.scheme == 'https') {
+			if (!url.host) {
+				return false;
+			}
+			/* hostname labels may contain only alphanumeric characters, dots and hypens. */
+			if (!(new RegExp("^([a-zA-Z0-9][a-zA-Z0-9\\-\\.]*)$", "i")).test(url.host) || url.host.charAt(-1) == '.') {
+				return false;
+			}
+		}
+		/* some schemas allow the host to be empty */
+		if (!url.scheme || !url.host && url.scheme != 'mailto' && url.scheme != 'news' && url.scheme != 'file') {
+			return false;
+		}
+		return true;
+	})(url);
+
+	// all normal URLs including mailto:
+	if (validated) {		
+		return url;
+	}
+
+	// '//example.com' (Shortcut for protocol.)
+	// '?query=test', #target
+	else if ((new RegExp("^(\\#|\\?|//)", "i")).test(url)) {
+		return url;
+	}
+
+	// 'javascript:'
+	else if (url.indexOf('javascript:') === 0 || url.indexOf('mailto:') === 0 ) {
+		return url;
+	}
+
+	// watch those double escapes in JS.
+
+	// 'install.php', 'install.php?step=step'
+	else if ((new RegExp("^[^\/]*\\.php(\\?.*)?$", "i")).test(url)) {
+		return elgg.config.wwwroot + url.ltrim('/');
+	}
+
+	// 'example.com', 'example.com/subpage'
+	else if ((new RegExp("^[^/]*\\.", "i")).test(url)) {
+		return 'http://' + url;
+	}
+
+	// 'page/handler', 'mod/plugin/file.php'
+	else {
+		// trim off any leading / because the site URL is stored
+		// with a trailing /
+		return elgg.config.wwwroot + url.ltrim('/');
+	}
+};
+
+/**
+ * Displays system messages via javascript rather than php.
+ *
+ * @param {String} msgs The message we want to display
+ * @param {Number} delay The amount of time to display the message in milliseconds. Defaults to 6 seconds.
+ * @param {String} type The type of message (typically 'error' or 'message')
+ * @private
+ */
+elgg.system_messages = function(msgs, delay, type) {
+	if (elgg.isUndefined(msgs)) {
+		return;
+	}
+
+	var classes = ['elgg-message'],
+		messages_html = [],
+		appendMessage = function(msg) {
+			messages_html.push('<li class="' + classes.join(' ') + '"><p>' + msg + '</p></li>');
+		},
+		systemMessages = $('ul.elgg-system-messages'),
+		i;
+
+	//validate delay.  Must be a positive integer.
+	delay = parseInt(delay || 6000, 10);
+	if (isNaN(delay) || delay <= 0) {
+		delay = 6000;
+	}
+
+	//Handle non-arrays
+	if (!elgg.isArray(msgs)) {
+		msgs = [msgs];
+	}
+
+	if (type === 'error') {
+		classes.push('elgg-state-error');
+	} else {
+		classes.push('elgg-state-success');
+	}
+
+	msgs.forEach(appendMessage);
+
+	if (type != 'error') {
+		$(messages_html.join('')).appendTo(systemMessages)
+			.animate({opacity: '1.0'}, delay).fadeOut('slow');
+	} else {
+		$(messages_html.join('')).appendTo(systemMessages);
+	}
+};
+
+/**
+ * Wrapper function for system_messages. Specifies "messages" as the type of message
+ * @param {String} msgs  The message to display
+ * @param {Number} delay How long to display the message (milliseconds)
+ */
+elgg.system_message = function(msgs, delay) {
+	elgg.system_messages(msgs, delay, "message");
+};
+
+/**
+ * Wrapper function for system_messages.  Specifies "errors" as the type of message
+ * @param {String} errors The error message to display
+ * @param {Number} delay  How long to dispaly the error message (milliseconds)
+ */
+elgg.register_error = function(errors, delay) {
+	elgg.system_messages(errors, delay, "error");
+};
+
+/**
+ * Meant to mimic the php forward() function by simply redirecting the
+ * user to another page.
+ *
+ * @param {String} url The url to forward to
+ */
+elgg.forward = function(url) {
+	location.href = elgg.normalize_url(url);
+};
+
+/**
+ * Parse a URL into its parts. Mimicks http://php.net/parse_url
+ *
+ * @param {String} url       The URL to parse
+ * @param {Int}    component A component to return
+ * @param {Bool}   expand    Expand the query into an object? Else it's a string.
+ *
+ * @return {Object} The parsed URL
+ */
+elgg.parse_url = function(url, component, expand) {
+	// Adapted from http://blog.stevenlevithan.com/archives/parseuri
+	// which was release under the MIT
+	// It was modified to fix mailto: and javascript: support.
+	var
+	expand = expand || false,
+	component = component || false,
+	
+	re_str =
+		// scheme (and user@ testing)
+		'^(?:(?![^:@]+:[^:@/]*@)([^:/?#.]+):)?(?://)?'
+		// possibly a user[:password]@
+		+ '((?:(([^:@]*)(?::([^:@]*))?)?@)?'
+		// host and port
+		+ '([^:/?#]*)(?::(\\d*))?)'
+		// path
+		+ '(((/(?:[^?#](?![^?#/]*\\.[^?#/.]+(?:[?#]|$)))*/?)?([^?#/]*))'
+		// query string
+		+ '(?:\\?([^#]*))?'
+		// fragment
+		+ '(?:#(.*))?)',
+	keys = {
+			1: "scheme",
+			4: "user",
+			5: "pass",
+			6: "host",
+			7: "port",
+			9: "path",
+			12: "query",
+			13: "fragment"
+	},
+	results = {};
+
+	if (url.indexOf('mailto:') === 0) {
+		results['scheme'] = 'mailto';
+		results['path'] = url.replace('mailto:', '');
+		return results;
+	}
+
+	if (url.indexOf('javascript:') === 0) {
+		results['scheme'] = 'javascript';
+		results['path'] = url.replace('javascript:', '');
+		return results;
+	}
+
+	var re = new RegExp(re_str);
+	var matches = re.exec(url);
+
+	for (var i in keys) {
+		if (matches[i]) {
+			results[keys[i]] = matches[i];
+		}
+	}
+
+	if (expand && typeof(results['query']) != 'undefined') {
+		results['query'] = elgg.parse_str(results['query']);
+	}
+
+	if (component) {
+		if (typeof(results[component]) != 'undefined') {
+			return results[component];
+		} else {
+			return false;
+		}
+	}
+	return results;
+};
+
+/**
+ * Returns an object with key/values of the parsed query string.
+ *
+ * @param  {String} string The string to parse
+ * @return {Object} The parsed object string
+ */
+elgg.parse_str = function(string) {
+	var params = {};
+	var result,
+		key,
+		value,
+		re = /([^&=]+)=?([^&]*)/g;
+
+	while (result = re.exec(string)) {
+		key = decodeURIComponent(result[1].replace(/\+/g, ' '));
+		value = decodeURIComponent(result[2].replace(/\+/g, ' '));
+		params[key] = value;
+	}
+	
+	return params;
+};
+
+/**
+ * Returns a jQuery selector from a URL's fragement.  Defaults to expecting an ID.
+ *
+ * Examples:
+ *  http://elgg.org/download.php returns ''
+ *	http://elgg.org/download.php#id returns #id
+ *	http://elgg.org/download.php#.class-name return .class-name
+ *	http://elgg.org/download.php#a.class-name return a.class-name
+ *
+ * @param {String} url The URL
+ * @return {String} The selector
+ */
+elgg.getSelectorFromUrlFragment = function(url) {
+	var fragment = url.split('#')[1];
+
+	if (fragment) {
+		// this is a .class or a tag.class
+		if (fragment.indexOf('.') > -1) {
+			return fragment;
+		}
+
+		// this is an id
+		else {
+			return '#' + fragment;
+		}
+	}
+	return '';
+};
+
+/**
+ * Adds child to object[parent] array.
+ *
+ * @param {Object} object The object to add to
+ * @param {String} parent The parent array to add to.
+ * @param {Mixed}  value  The value
+ */
+elgg.push_to_object_array = function(object, parent, value) {
+	elgg.assertTypeOf('object', object);
+	elgg.assertTypeOf('string', parent);
+
+	if (!(object[parent] instanceof Array)) {
+		object[parent] = []
+	}
+
+	if ($.inArray(value, object[parent]) < 0) {
+		return object[parent].push(value);
+	}
+
+	return false;
+};
+
+/**
+ * Tests if object[parent] contains child
+ *
+ * @param {Object} object The object to add to
+ * @param {String} parent The parent array to add to.
+ * @param {Mixed}  value  The value
+ */
+elgg.is_in_object_array = function(object, parent, value) {
+	elgg.assertTypeOf('object', object);
+	elgg.assertTypeOf('string', parent);
+
+	return typeof(object[parent]) != 'undefined' && $.inArray(value, object[parent]) >= 0;
+};
+
+/**
+ * Triggers the init hook when the library is ready
+ *
+ * Current requirements:
+ * - DOM is ready
+ * - languages loaded
+ *
+ */
+elgg.initWhenReady = function() {
+	if (elgg.config.languageReady && elgg.config.domReady) {
+		elgg.trigger_hook('init', 'system');
+		elgg.trigger_hook('ready', 'system');
+	}
+};
diff --git a/js/lib/events.js b/js/lib/events.js
deleted file mode 100644
index 358dd6280..000000000
--- a/js/lib/events.js
+++ /dev/null
@@ -1,65 +0,0 @@
-elgg.provide('elgg.config.events');
-elgg.provide('elgg.config.events.all');
-elgg.provide('elgg.config.events.all.all');
-
-elgg.register_event_handler = function(event, type, callback, priority) {
-	elgg.assertTypeOf('string', event);
-	elgg.assertTypeOf('string', event);
-	elgg.assertTypeOf('function', callback);
-	
-	if (!event || !type) {
-		return false;
-	}
-	
-	elgg.provide('elgg.config.events.' + event + '.' + type);
-
-	var events = elgg.config.events;
-	
-	if (!(events[event][type] instanceof elgg.ElggPriorityList)) {
-		events[event][type] = new elgg.ElggPriorityList();
-	}
-
-	return events[event][type].insert(callback, priority);
-};
-
-elgg.trigger_event = function(event, type, object) {
-	elgg.assertTypeOf('string', event);
-	elgg.assertTypeOf('string', event);
-
-	elgg.provide('elgg.config.events.' + event + '.' + type);
-	elgg.provide('elgg.config.events.all.' + type);
-	elgg.provide('elgg.config.events.' + event + '.all');
-	elgg.provide('elgg.config.events.all.all');
-	
-	var events = elgg.config.events;
-	
-	var callEventHandler = function(handler) { 
-		return handler(event, type, object) !== false; 
-	};
-	
-	if (events[event][type] instanceof elgg.ElggPriorityList) {
-		if (!events[event][type].every(callEventHandler)) {
-			return false;
-		}
-	}
-	
-	if (events['all'][type] instanceof elgg.ElggPriorityList) {
-		if (!events['all'][type].every(callEventHandler)) {
-			return false;
-		}
-	}
-	
-	if (events[event]['all'] instanceof elgg.ElggPriorityList) {
-		if (!events[event]['all'].every(callEventHandler)) {
-			return false;
-		}
-	}
-	
-	if (events['all']['all'] instanceof elgg.ElggPriorityList) {
-		if (!events['all']['all'].every(callEventHandler)) {
-			return false;
-		}
-	}
-		
-	return true;
-};
-\ No newline at end of file
diff --git a/js/lib/hooks.js b/js/lib/hooks.js
new file mode 100644
index 000000000..5e1808e22
--- /dev/null
+++ b/js/lib/hooks.js
@@ -0,0 +1,173 @@
+/*
+ * Javascript hook interface
+ */
+
+elgg.provide('elgg.config.hooks');
+elgg.provide('elgg.config.instant_hooks');
+elgg.provide('elgg.config.triggered_hooks');
+
+/**
+ * Registers a hook handler with the event system.
+ *
+ * The special keyword "all" can be used for either the name or the type or both
+ * and means to call that handler for all of those hooks.
+ *
+ * Note that handlers registering for instant hooks will be executed immediately if the instant
+ * hook has been previously triggered.
+ *
+ * @param {String}   name     Name of the plugin hook to register for
+ * @param {String}   type     Type of the event to register for
+ * @param {Function} handler  Handle to call
+ * @param {Number}   priority Priority to call the event handler
+ * @return {Bool}
+ */
+elgg.register_hook_handler = function(name, type, handler, priority) {
+	elgg.assertTypeOf('string', name);
+	elgg.assertTypeOf('string', type);
+	elgg.assertTypeOf('function', handler);
+
+	if (!name || !type) {
+		return false;
+	}
+
+	var priorities =  elgg.config.hooks;
+
+	elgg.provide(name + '.' + type, priorities);
+
+	if (!(priorities[name][type] instanceof elgg.ElggPriorityList)) {
+		priorities[name][type] = new elgg.ElggPriorityList();
+	}
+
+	// call if instant and already triggered.
+	if (elgg.is_instant_hook(name, type) && elgg.is_triggered_hook(name, type)) {
+		handler(name, type, null, null);
+	}
+
+	return priorities[name][type].insert(handler, priority);
+};
+
+/**
+ * Emits a hook.
+ *
+ * Loops through all registered hooks and calls the handler functions in order.
+ * Every handler function will always be called, regardless of the return value.
+ *
+ * @warning Handlers take the same 4 arguments in the same order as when calling this function.
+ * This is different from the PHP version!
+ *
+ * @note Instant hooks do not support params or values.
+ *
+ * Hooks are called in this order:
+ *	specifically registered (event_name and event_type match)
+ *	all names, specific type
+ *	specific name, all types
+ *	all names, all types
+ *
+ * @param {String} name   Name of the hook to emit
+ * @param {String} type   Type of the hook to emit
+ * @param {Object} params Optional parameters to pass to the handlers
+ * @param {Object} value  Initial value of the return. Can be mangled by handlers
+ *
+ * @return {Bool}
+ */
+elgg.trigger_hook = function(name, type, params, value) {
+	elgg.assertTypeOf('string', name);
+	elgg.assertTypeOf('string', type);
+
+	// mark as triggered
+	elgg.set_triggered_hook(name, type);
+
+	// default to true if unpassed
+	value = value || true;
+
+	var hooks = elgg.config.hooks,
+		tempReturnValue = null,
+		returnValue = value,
+		callHookHandler = function(handler) {
+			tempReturnValue = handler(name, type, params, value);
+		};
+
+	elgg.provide(name + '.' + type, hooks);
+	elgg.provide('all.' + type, hooks);
+	elgg.provide(name + '.all', hooks);
+	elgg.provide('all.all', hooks);
+
+	var hooksList = [];
+	
+	if (name != 'all' && type != 'all') {
+		hooksList.push(hooks[name][type]);
+	}
+
+	if (type != 'all') {
+		hooksList.push(hooks['all'][type]);
+	}
+
+	if (name != 'all') {
+		hooksList.push(hooks[name]['all']);
+	}
+
+	hooksList.push(hooks['all']['all']);
+
+	hooksList.every(function(handlers) {
+		if (handlers instanceof elgg.ElggPriorityList) {
+			handlers.forEach(callHookHandler);
+		}
+		return true;
+	});
+
+	return (tempReturnValue != null) ? tempReturnValue : returnValue;
+};
+
+/**
+ * Registers a hook as an instant hook.
+ *
+ * After being trigger once, registration of a handler to an instant hook will cause the
+ * handle to be executed immediately.
+ *
+ * @note Instant hooks must be triggered without params or defaults. Any params or default
+ * passed will *not* be passed to handlers executed upon registration.
+ *
+ * @param {String} name The hook name.
+ * @param {String} type The hook type.
+ * @return {Int}
+ */
+elgg.register_instant_hook = function(name, type) {
+	elgg.assertTypeOf('string', name);
+	elgg.assertTypeOf('string', type);
+
+	return elgg.push_to_object_array(elgg.config.instant_hooks, name, type);
+};
+
+/**
+ * Is this hook registered as an instant hook?
+ *
+ * @param {String} name The hook name.
+ * @param {String} type The hook type.
+ */
+elgg.is_instant_hook = function(name, type) {
+	return elgg.is_in_object_array(elgg.config.instant_hooks, name, type);
+};
+
+/**
+ * Records that a hook has been triggered.
+ *
+ * @param {String} name The hook name.
+ * @param {String} type The hook type.
+ */
+elgg.set_triggered_hook = function(name, type) {
+	return elgg.push_to_object_array(elgg.config.triggered_hooks, name, type);
+};
+
+/**
+ * Has this hook been triggered yet?
+ *
+ * @param {String} name The hook name.
+ * @param {String} type The hook type.
+ */
+elgg.is_triggered_hook = function(name, type) {
+	return elgg.is_in_object_array(elgg.config.triggered_hooks, name, type);
+};
+
+elgg.register_instant_hook('init', 'system');
+elgg.register_instant_hook('ready', 'system');
+elgg.register_instant_hook('boot', 'system');
diff --git a/js/lib/languages.js b/js/lib/languages.js
index 3231cf77d..d218cbc4f 100644
--- a/js/lib/languages.js
+++ b/js/lib/languages.js
@@ -1,83 +1,96 @@
-/**
- * Provides language-related functionality
- */
-elgg.provide('elgg.config.translations');
-
-elgg.config.language = 'en';
-
-elgg.add_translation = function(lang, translations) {
-	elgg.provide('elgg.config.translations.' + lang);
-	
-	$.extend(elgg.config.translations[lang], translations);
-}
-
-/**
- * Load the translations for the given language.
- * 
- * If no language is specified, the default language is used.
- * @param {string} language
- * @return {XMLHttpRequest}
- */
-elgg.reload_all_translations = function(language) {
-	var lang = language || elgg.get_language();
-	elgg.getJSON('_css/js.php', {
-		data: {
-			'js': 'languages/'+lang,
-			'viewtype': 'default',
-			'lastcache': elgg.config.lastcache
-		},
-		success: function(json) {
-			elgg.add_translation(lang, json);
-		}
-	});
-};
-
-/**
- * Get the current language
- * @return {String}
- */
-elgg.get_language = function() {
-	var user = elgg.get_loggedin_user();
-	
-	if (user && user.language) {
-		return user.language;
-	}
-	
-	return elgg.config.language;
-};
-
-/**
- * Translates a string
- * 
- * @param {String} key The string to translate
- * @param {String} language The language to display it in
- * @return {String} The translation
- */
-elgg.echo = function(key, language) {
-	var translations,
-		dlang = elgg.get_language();
-	
-	language = language || dlang;
-	
-	translations = elgg.config.translations[language];
-	if (translations && translations[key]) {
-		return translations[key];
-	}
-	
-	if (language == dlang) {
-		return undefined;
-	}
-	
-	translations = elgg.config.translations[dlang];
-	if (translations && translations[key]) {
-		return translations[key];
-	}
-	
-	return undefined;
-};
-
-elgg.config.translations.init = function() {
-	elgg.reload_all_translations();
-};
-
-elgg.register_event_handler('boot', 'system', elgg.config.translations.init);
-\ No newline at end of file
+/*globals vsprintf*/
+/**
+ * Provides language-related functionality
+ */
+elgg.provide('elgg.config.translations');
+
+// default language - required by unit tests
+elgg.config.language = 'en';
+
+/**
+ * Analagous to the php version.  Merges translations for a
+ * given language into the current translations map.
+ */
+elgg.add_translation = function(lang, translations) {
+	elgg.provide('elgg.config.translations.' + lang);
+
+	elgg.extend(elgg.config.translations[lang], translations);
+};
+
+/**
+ * Load the translations for the given language.
+ *
+ * If no language is specified, the default language is used.
+ * @param {string} language
+ * @return {XMLHttpRequest}
+ */
+elgg.reload_all_translations = function(language) {
+	var lang = language || elgg.get_language();
+
+	var url, options;
+	url = 'ajax/view/js/languages';
+	options = {data: {language: lang}};
+    if (elgg.config.simplecache_enabled) {
+        options.data.lc = elgg.config.lastcache;
+    }
+
+	options['success'] = function(json) {
+		elgg.add_translation(lang, json);
+		elgg.config.languageReady = true;
+		elgg.initWhenReady();
+	};
+
+	elgg.getJSON(url, options);
+};
+
+/**
+ * Get the current language
+ * @return {String}
+ */
+elgg.get_language = function() {
+	var user = elgg.get_logged_in_user_entity();
+
+	if (user && user.language) {
+		return user.language;
+	}
+
+	return elgg.config.language;
+};
+
+/**
+ * Translates a string
+ *
+ * @param {String} key      The string to translate
+ * @param {Array}  argv     vsprintf support
+ * @param {String} language The language to display it in
+ *
+ * @return {String} The translation
+ */
+elgg.echo = function(key, argv, language) {
+	//elgg.echo('str', 'en')
+	if (elgg.isString(argv)) {
+		language = argv;
+		argv = [];
+	}
+
+	//elgg.echo('str', [...], 'en')
+	var translations = elgg.config.translations,
+		dlang = elgg.get_language(),
+		map;
+
+	language = language || dlang;
+	argv = argv || [];
+
+	map = translations[language] || translations[dlang];
+	if (map && map[key]) {
+		return vsprintf(map[key], argv);
+	}
+
+	return key;
+};
+
+elgg.config.translations.init = function() {
+	elgg.reload_all_translations();
+};
+
+elgg.register_hook_handler('boot', 'system', elgg.config.translations.init);
+\ No newline at end of file
diff --git a/js/lib/pageowner.js b/js/lib/pageowner.js
new file mode 100644
index 000000000..c695c41c3
--- /dev/null
+++ b/js/lib/pageowner.js
@@ -0,0 +1,18 @@
+/**
+ * Provides page owner and context functions
+ *
+ * @todo This is a stub. Page owners can't be fully implemented until
+ * the 4 types are finished.
+ */
+
+/**
+ * @return {number} The GUID of the page owner entity or 0 for no owner
+ */
+elgg.get_page_owner_guid = function() {
+	if (elgg.page_owner !== undefined) {
+		return elgg.page_owner.guid;
+	} else {
+		return 0;
+	}
+};
+
diff --git a/js/lib/prototypes.js b/js/lib/prototypes.js
new file mode 100644
index 000000000..cb6184097
--- /dev/null
+++ b/js/lib/prototypes.js
@@ -0,0 +1,66 @@
+/**
+ * Interates through each element of an array and calls a callback function.
+ * The callback should accept the following arguments:
+ *	element - The current element
+ *	index	- The current index
+ *
+ * This is different to Array.forEach in that if the callback returns false, the loop returns
+ * immediately without processing the remaining elements.
+ *
+ *	@param {Function} callback
+ *	@return {Bool}
+ */
+if (!Array.prototype.every) {
+	Array.prototype.every = function(callback) {
+		var len = this.length, i;
+
+		for (i = 0; i < len; i++) {
+			if (i in this && !callback.call(null, this[i], i)) {
+				return false;
+			}
+		}
+
+		return true;
+	};
+}
+
+/**
+ * Interates through each element of an array and calls callback a function.
+ * The callback should accept the following arguments:
+ *	element - The current element
+ *	index	- The current index
+ *
+ * This is different to Array.every in that the callback's return value is ignored and every
+ * element of the array will be parsed.
+ *
+ *	@param {Function} callback
+ *	@return {Void}
+ */
+if (!Array.prototype.forEach) {
+	Array.prototype.forEach = function(callback) {
+		var len = this.length, i;
+
+		for (i = 0; i < len; i++) {
+			if (i in this) {
+				callback.call(null, this[i], i);
+			}
+		}
+	};
+}
+
+/**
+ * Left trim
+ *
+ * Removes a character from the left side of a string.
+ * @param {String} str The character to remove
+ * @return {String}
+ */
+if (!String.prototype.ltrim) {
+	String.prototype.ltrim = function(str) {
+		if (this.indexOf(str) === 0) {
+			return this.substring(str.length);
+		} else {
+			return this;
+		}
+	};
+}
+\ No newline at end of file
diff --git a/js/lib/security.js b/js/lib/security.js
index bdd762560..9c12f8586 100644
--- a/js/lib/security.js
+++ b/js/lib/security.js
@@ -1,70 +1,107 @@
-/**
- * Hold security-related data here
- */
-elgg.provide('elgg.security');
-
-elgg.security.token = {};
-
-elgg.security.setToken = function(json) {
-	//update the convenience object
-	elgg.security.token = json;
-	
-	//also update all forms
-	$('[name=__elgg_ts]').val(json.__elgg_ts);
-	$('[name=__elgg_token]').val(json.__elgg_token);
-	
-	//also update all links
-	$('[href]').each(function() {
-		this.href = this.href
-			.replace(/__elgg_ts=\d*/, '__elgg_ts=' + json.__elgg_ts)
-			.replace(/__elgg_token=[0-9a-f]*/, '__elgg_token=' + json.__elgg_token);
-	});
-};
-
-/**
- * Security tokens time out, so lets refresh those every so often
- * @todo handle error and bad return data
- */
-elgg.security.refreshToken = function() {
-	elgg.action('ajax/securitytoken', function(data) {
-		elgg.security.setToken(data.output);
-	});
-};
-
-
-/**
- * Add elgg action tokens to an object or string (assumed to be url data)
- * 
- * @param {Object|string} data
- * @return {Object} The new data object including action tokens
- * @private
- */
-elgg.security.addToken = function(data) {
-
-	//addToken('data=sofar')
-	if (typeof data == 'string') {
-		var args = [];
-		if(data) {
-			args.push(data);
-		}
-		args.push("__elgg_ts=" + elgg.security.token.__elgg_ts);
-		args.push("__elgg_token=" + elgg.security.token.__elgg_token)
-		
-		return args.join('&');
-	}
-	
-	//addToken({...})
-	if (typeof data == 'object' || typeof data == 'undefined') {
-		return $.extend(data, elgg.security.token);
-	}
-
-	//addToken(???)
-	throw new TypeError("elgg.security.addToken not implemented for " + (typeof data) + "s");
-};
-
-elgg.security.init = function() {
-	//refresh security token every 5 minutes
-	setInterval(elgg.security.refreshToken, elgg.security.interval);
-};
-
-elgg.register_event_handler('boot', 'system', elgg.security.init);
-\ No newline at end of file
+/**
+ * Hold security-related data here
+ */
+elgg.provide('elgg.security');
+
+elgg.security.token = {};
+
+elgg.security.tokenRefreshFailed = false;
+
+elgg.security.tokenRefreshTimer = null;
+
+/**
+ * Sets the currently active security token and updates all forms and links on the current page.
+ *
+ * @param {Object} json The json representation of a token containing __elgg_ts and __elgg_token
+ * @return {Void}
+ */
+elgg.security.setToken = function(json) {	
+	//update the convenience object
+	elgg.security.token = json;
+
+	//also update all forms
+	$('[name=__elgg_ts]').val(json.__elgg_ts);
+	$('[name=__elgg_token]').val(json.__elgg_token);
+
+	// also update all links that contain tokens and time stamps
+	$('[href*="__elgg_ts"][href*="__elgg_token"]').each(function() {
+		this.href = this.href
+			.replace(/__elgg_ts=\d*/, '__elgg_ts=' + json.__elgg_ts)
+			.replace(/__elgg_token=[0-9a-f]*/, '__elgg_token=' + json.__elgg_token);
+	});
+};
+
+/**
+ * Security tokens time out so we refresh those every so often.
+ * 
+ * @private
+ */
+elgg.security.refreshToken = function() {
+	elgg.action('security/refreshtoken', function(data) {
+		if (data && data.output.__elgg_ts && data.output.__elgg_token) {
+			elgg.security.setToken(data.output);
+		} else {
+			clearInterval(elgg.security.tokenRefreshTimer);
+		}
+	});
+};
+
+
+/**
+ * Add elgg action tokens to an object, URL, or query string (with a ?).
+ *
+ * @param {Object|string} data
+ * @return {Object} The new data object including action tokens
+ * @private
+ */
+elgg.security.addToken = function(data) {
+
+	// 'http://example.com?data=sofar'
+	if (elgg.isString(data)) {
+		// is this a full URL, relative URL, or just the query string?
+		var parts = elgg.parse_url(data),
+			args = {},
+			base = '';
+		
+		if (parts['host'] == undefined) {
+			if (data.indexOf('?') === 0) {
+				// query string
+				base = '?';
+				args = elgg.parse_str(parts['query']);
+			}
+		} else {
+			// full or relative URL
+
+			if (parts['query'] != undefined) {
+				// with query string
+				args = elgg.parse_str(parts['query']);
+			}
+			var split = data.split('?');
+			base = split[0] + '?';
+		}
+		args["__elgg_ts"] = elgg.security.token.__elgg_ts;
+		args["__elgg_token"] = elgg.security.token.__elgg_token;
+
+		return base + jQuery.param(args);
+	}
+
+	// no input!  acts like a getter
+	if (elgg.isUndefined(data)) {
+		return elgg.security.token;
+	}
+
+	// {...}
+	if (elgg.isPlainObject(data)) {
+		return elgg.extend(data, elgg.security.token);
+	}
+
+	// oops, don't recognize that!
+	throw new TypeError("elgg.security.addToken not implemented for " + (typeof data) + "s");
+};
+
+elgg.security.init = function() {
+	// elgg.security.interval is set in the js/elgg PHP view.
+	elgg.security.tokenRefreshTimer = setInterval(elgg.security.refreshToken, elgg.security.interval);
+};
+
+elgg.register_hook_handler('boot', 'system', elgg.security.init);
+\ No newline at end of file
diff --git a/js/lib/session.js b/js/lib/session.js
index 227c607eb..a8d52733c 100644
--- a/js/lib/session.js
+++ b/js/lib/session.js
@@ -1,116 +1,123 @@
-/**
- * @todo comment
- */
-elgg.provide('elgg.session');
-
-/**
- * Helper function for setting cookies
- * @param {string} name
- * @param {string} value
- * @param {Object} options
- *  {number|Date} options[expires]
- * 	{string} options[path]
- * 	{string} options[domain]
- * 	{boolean} options[secure]
- * 
- * @return {string} The value of the cookie, if only name is specified
- */
-elgg.session.cookie = function(name, value, options) {
-	//elgg.session.cookie()
-	if(typeof name == 'undefined') {
-		return document.cookie;
-	}
-	
-	//elgg.session.cookie(name)
-	if (typeof value == 'undefined') {
-		if (document.cookie && document.cookie != '') {
-			var cookies = document.cookie.split(';');
-			for (var i = 0; i < cookies.length; i++) {
-				var cookie = jQuery.trim(cookies[i]).split('=');
-				if (cookie[0] == name) {
-					return decodeURIComponent(cookie[1]);
-				}
-			}
-		}
-		return undefined;
-	}
-	
-	// elgg.session.cookie(name, value[, opts])
-	var cookies = [];
-
-	options = options || {};
-	
-	if (value === null) {
-		value = '';
-		options.expires = -1;
-	}
-	
-	cookies.push(name + '=' + value);
-	
-	if (typeof options.expires == 'number') {
-		var date, valid = true;
-		
-		if (typeof options.expires == 'number') {
-			date = new Date();
-			date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
-		} else if(options.expires.toUTCString) {
-			date = options.expires;
-		} else {
-			valid = false;
-		}
-		
-		valid ? cookies.push('expires=' + date.toUTCString()) : 0;
-	}
-	
-	// CAUTION: Needed to parenthesize options.path and options.domain
-	// in the following expressions, otherwise they evaluate to undefined
-	// in the packed version for some reason.
-	if (options.path) {
-		cookies.push('path=' + (options.path));
-	}
-
-	if (options.domain) {
-		cookies.push('domain=' + (options.domain));
-	}
-	
-	if (options.secure) {
-		cookies.push('secure');
-	}
-	
-	document.cookie = cookies.join('; ');
-};
-
-/**
- * @return {ElggUser} The logged in user
- */
-elgg.get_loggedin_user = function() {
-	return elgg.session.user;
-};
-
-/**
- * @return {number} The GUID of the logged in user
- */
-elgg.get_loggedin_userid = function() {
-	var user = elgg.get_loggedin_user();
-	return user ? user.guid : 0;
-};
-
-/**
- * @return {boolean} Whether there is a user logged in
- */
-elgg.isloggedin = function() {
-	return (elgg.get_loggedin_user() instanceof elgg.ElggUser);
-};
-
-/**
- * @return {boolean} Whether there is an admin logged in
- */
-elgg.isadminloggedin = function() {
-	var user = elgg.get_loggedin_user();
-	return (user instanceof ElggUser) && user.isAdmin();
-};
-
-/**
- * @deprecated Use elgg.session.cookie instead
- */
-$.cookie = elgg.session.cookie;
-\ No newline at end of file
+/**
+ * Provides session methods.
+ */
+elgg.provide('elgg.session');
+
+/**
+ * Helper function for setting cookies
+ * @param {string} name
+ * @param {string} value
+ * @param {Object} options
+ * 
+ *  {number|Date} options[expires]
+ * 	{string} options[path]
+ * 	{string} options[domain]
+ * 	{boolean} options[secure]
+ * 
+ * @return {string|undefined} The value of the cookie, if only name is specified. Undefined if no value set
+ */
+elgg.session.cookie = function(name, value, options) {
+	var cookies = [], cookie = [], i = 0, date, valid = true;
+	
+	//elgg.session.cookie()
+	if (elgg.isUndefined(name)) {
+		return document.cookie;
+	}
+	
+	//elgg.session.cookie(name)
+	if (elgg.isUndefined(value)) {
+		if (document.cookie && document.cookie !== '') {
+			cookies = document.cookie.split(';');
+			for (i = 0; i < cookies.length; i += 1) {
+				cookie = jQuery.trim(cookies[i]).split('=');
+				if (cookie[0] === name) {
+					return decodeURIComponent(cookie[1]);
+				}
+			}
+		}
+		return undefined;
+	}
+	
+	// elgg.session.cookie(name, value[, opts])
+	options = options || {};
+	
+	if (elgg.isNull(value)) {
+		value = '';
+		options.expires = -1;
+	}
+	
+	cookies.push(name + '=' + value);
+
+    if (options.expires) {
+        if (elgg.isNumber(options.expires)) {
+            date = new Date();
+            date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
+        } else if (options.expires.toUTCString) {
+            date = options.expires;
+        }
+
+        if (date) {
+            cookies.push('expires=' + date.toUTCString());
+        }
+    }
+	
+	// CAUTION: Needed to parenthesize options.path and options.domain
+	// in the following expressions, otherwise they evaluate to undefined
+	// in the packed version for some reason.
+	if (options.path) {
+		cookies.push('path=' + (options.path));
+	}
+
+	if (options.domain) {
+		cookies.push('domain=' + (options.domain));
+	}
+	
+	if (options.secure) {
+		cookies.push('secure');
+	}
+	
+	document.cookie = cookies.join('; ');
+};
+
+/**
+ * Returns the object of the user logged in.
+ *
+ * @return {ElggUser} The logged in user
+ */
+elgg.get_logged_in_user_entity = function() {
+	return elgg.session.user;
+};
+
+/**
+ * Returns the GUID of the logged in user or 0.
+ *
+ * @return {number} The GUID of the logged in user
+ */
+elgg.get_logged_in_user_guid = function() {
+	var user = elgg.get_logged_in_user_entity();
+	return user ? user.guid : 0;
+};
+
+/**
+ * Returns if a user is logged in.
+ *
+ * @return {boolean} Whether there is a user logged in
+ */
+elgg.is_logged_in = function() {
+	return (elgg.get_logged_in_user_entity() instanceof elgg.ElggUser);
+};
+
+/**
+ * Returns if the currently logged in user is an admin.
+ *
+ * @return {boolean} Whether there is an admin logged in
+ */
+elgg.is_admin_logged_in = function() {
+	var user = elgg.get_logged_in_user_entity();
+	return (user instanceof elgg.ElggUser) && user.isAdmin();
+};
+
+/**
+ * @deprecated Use elgg.session.cookie instead
+ */
+jQuery.cookie = elgg.session.cookie;
+\ No newline at end of file
diff --git a/js/lib/ui.autocomplete.js b/js/lib/ui.autocomplete.js
new file mode 100644
index 000000000..46d72d146
--- /dev/null
+++ b/js/lib/ui.autocomplete.js
@@ -0,0 +1,14 @@
+/**
+ * 
+ */
+elgg.provide('elgg.autocomplete');
+
+elgg.autocomplete.init = function() {
+	$('.elgg-input-autocomplete').autocomplete({
+		source: elgg.autocomplete.url, //gets set by input/autocomplete view
+		minLength: 2,
+		html: "html"
+	})
+};
+
+elgg.register_hook_handler('init', 'system', elgg.autocomplete.init);
+\ No newline at end of file
diff --git a/js/lib/ui.avatar_cropper.js b/js/lib/ui.avatar_cropper.js
new file mode 100644
index 000000000..fc32a0832
--- /dev/null
+++ b/js/lib/ui.avatar_cropper.js
@@ -0,0 +1,76 @@
+/**
+ * Avatar cropping
+ */
+
+elgg.provide('elgg.avatarCropper');
+
+/**
+ * Register the avatar cropper.
+ *
+ * If the hidden inputs have the coordinates from a previous cropping, begin
+ * the selection and preview with that displayed.
+ */
+elgg.avatarCropper.init = function() {
+	var params = {
+		selectionOpacity: 0,
+		aspectRatio: '1:1',
+		onSelectEnd: elgg.avatarCropper.selectChange,
+		onSelectChange: elgg.avatarCropper.preview
+	};
+
+	if ($('input[name=x2]').val()) {
+		params.x1 = $('input[name=x1]').val();
+		params.x2 = $('input[name=x2]').val();
+		params.y1 = $('input[name=y1]').val();
+		params.y2 = $('input[name=y2]').val();
+	}
+
+	$('#user-avatar-cropper').imgAreaSelect(params);
+
+	if ($('input[name=x2]').val()) {
+		var ias = $('#user-avatar-cropper').imgAreaSelect({instance: true});
+		var selection = ias.getSelection();
+		elgg.avatarCropper.preview($('#user-avatar-cropper'), selection);
+	}
+};
+
+/**
+ * Handler for changing select area.
+ *
+ * @param {Object} reference to the image
+ * @param {Object} imgareaselect selection object
+ * @return void
+ */
+elgg.avatarCropper.preview = function(img, selection) {
+	// catch for the first click on the image
+	if (selection.width == 0 || selection.height == 0) {
+		return;
+	}
+
+	var origWidth = $("#user-avatar-cropper").width();
+	var origHeight = $("#user-avatar-cropper").height();
+	var scaleX = 100 / selection.width;
+	var scaleY = 100 / selection.height;
+	$('#user-avatar-preview > img').css({
+		width: Math.round(scaleX * origWidth) + 'px',
+		height: Math.round(scaleY * origHeight) + 'px',
+		marginLeft: '-' + Math.round(scaleX * selection.x1) + 'px',
+		marginTop: '-' + Math.round(scaleY * selection.y1) + 'px'
+	});
+};
+
+/**
+ * Handler for updating the form inputs after select ends
+ *
+ * @param {Object} reference to the image
+ * @param {Object} imgareaselect selection object
+ * @return void
+ */
+elgg.avatarCropper.selectChange = function(img, selection) {
+	$('input[name=x1]').val(selection.x1);
+	$('input[name=x2]').val(selection.x2);
+	$('input[name=y1]').val(selection.y1);
+	$('input[name=y2]').val(selection.y2);
+};
+
+elgg.register_hook_handler('init', 'system', elgg.avatarCropper.init);
+\ No newline at end of file
diff --git a/js/lib/ui.friends_picker.js b/js/lib/ui.friends_picker.js
new file mode 100644
index 000000000..9257c40fc
--- /dev/null
+++ b/js/lib/ui.friends_picker.js
@@ -0,0 +1,91 @@
+/*
+	elgg friendsPicker plugin
+	adapted from Niall Doherty's excellent Coda-Slider - http://www.ndoherty.com/coda-slider
+ */
+
+
+jQuery.fn.friendsPicker = function(iterator) {
+
+	var settings; 
+	settings = $.extend({ easeFunc: "easeOutExpo", easeTime: 1000, toolTip: false }, settings);
+
+	return this.each(function() {
+
+		var container = $(this);
+		container.addClass("friends-picker");
+		// set panelwidth manually as it's hidden initially - adjust this value for different themes/pagewidths 
+		var panelWidth = 730;
+
+		// count the panels in the container
+		var panelCount = container.find("div.panel").size();
+		// calculate the width of all the panels lined up end-to-end
+		var friendsPicker_containerWidth = panelWidth*panelCount;
+		// specify width for the friendsPicker_container
+		container.find("div.friends-picker-container").css("width" , friendsPicker_containerWidth);
+
+		// global variables for container.each function below
+		var friendsPickerNavigationWidth = 0;
+		var currentPanel = 1;
+
+		// generate appropriate nav for each container
+		container.each(function(i) {
+			// generate Left and Right arrows
+			$(this).before("<div class='friends-picker-navigation-l' id='friends-picker-navigation-l" + iterator + "'><a href='#'>Left</a><\/div>");
+			$(this).after("<div class='friends-picker-navigation-r' id='friends-picker-navigation-r" + iterator + "'><a href='#'>Right</a><\/div>");
+
+			// generate a-z tabs
+			$(this).before("<div class='friends-picker-navigation' id='friends-picker-navigation" + iterator + "'><ul><\/ul><\/div>");
+			$(this).find("div.panel").each(function(individualTabItemNumber) {
+				$("div#friends-picker-navigation" + iterator + " ul").append("<li class='tab" + (individualTabItemNumber+1) + "'><a href='#" + (individualTabItemNumber+1) + "'>" + $(this).attr("title") + "<\/a><\/li>");		
+			});
+
+			// tabs navigation
+			$("div#friends-picker-navigation" + iterator + " a").each(function(individualTabItemNumber) {
+				// calc friendsPickerNavigationWidth by summing width of each li
+				friendsPickerNavigationWidth += $(this).parent().width();
+				// set-up individual tab clicks
+				$(this).bind("click", function() {
+					$(this).addClass("current").parent().parent().find("a").not($(this)).removeClass("current"); 
+					var distanceToMoveFriendsPicker_container = - (panelWidth*individualTabItemNumber);
+					currentPanel = individualTabItemNumber + 1;
+					$(this).parent().parent().parent().next().find("div.friends-picker-container").animate({ left: distanceToMoveFriendsPicker_container}, settings.easeTime, settings.easeFunc);
+				});
+			});
+
+			// Right arow click function
+			$("div#friends-picker-navigation-r" + iterator + " a").click(function() {
+				if (currentPanel == panelCount) {
+					var distanceToMoveFriendsPicker_container = 0;
+					currentPanel = 1; 
+					$(this).parent().parent().find("div.friends-picker-navigation a.current").removeClass("current").parent().parent().find("a:eq(0)").addClass("current");
+				} else {
+					var distanceToMoveFriendsPicker_container = - (panelWidth*currentPanel);
+					currentPanel += 1;
+					$(this).parent().parent().find("div.friends-picker-navigation a.current").removeClass("current").parent().next().find("a").addClass("current");
+				};
+				$(this).parent().parent().find("div.friends-picker-container").animate({ left: distanceToMoveFriendsPicker_container}, settings.easeTime, settings.easeFunc);
+				return false;
+			});
+
+			// Left arrow click function
+			$("div#friends-picker-navigation-l" + iterator + " a").click(function() {
+				if (currentPanel == 1) {
+					var distanceToMoveFriendsPicker_container = - (panelWidth*(panelCount - 1));
+					currentPanel = panelCount;
+					$(this).parent().parent().find("div.friends-picker-navigation a.current").removeClass("current").parent().parent().find("li:last a").addClass("current");
+				} else {
+					currentPanel -= 1;
+					var distanceToMoveFriendsPicker_container = - (panelWidth*(currentPanel - 1));
+					$(this).parent().parent().find("div.friends-picker-navigation a.current").removeClass("current").parent().prev().find("a").addClass("current");
+				};
+				$(this).parent().parent().find("div.friends-picker-container").animate({ left: distanceToMoveFriendsPicker_container}, settings.easeTime, settings.easeFunc);
+				return false;
+			});
+
+			// apply 'current' class to currently selected tab link
+			$("div#friends-picker-navigation" + iterator + " a:eq(0)").addClass("current");
+		});
+
+		$("div#friends-picker-navigation" + iterator).append("<br />");		
+	});
+};
+\ No newline at end of file
diff --git a/js/lib/ui.js b/js/lib/ui.js
index 4a9c64e70..413078b4f 100644
--- a/js/lib/ui.js
+++ b/js/lib/ui.js
@@ -1,121 +1,293 @@
-elgg.provide('elgg.ui');
-
-elgg.ui.init = function () {
-	//if the user clicks a system message, make it disappear
-	$('.elgg_system_message').live('click', function() {
-		$(this).stop().fadeOut('fast');
-	});
-	
-	$('a.collapsibleboxlink').click(elgg.ui.toggleCollapsibleBox);
-
-	// set-up hover class for dragged widgets
-	var cols = [
-		"#rightcolumn_widgets",
-		"#middlecolumn_widgets",
-		"#leftcolumn_widgets"
-	].join(',');
-	
-	$(cols).droppable({
-		accept: ".draggable_widget",
-		hoverClass: 'droppable-hover'
-	});
-};
-
-// reusable generic hidden panel
-elgg.ui.toggleCollapsibleBox = function () {
-	$(this.parentNode.parentNode).children(".collapsible_box").slideToggle("fast");
-	return false;
-};
-
-//define some helper jquery plugins
-(function($) {
-	
-	// ELGG TOOLBAR MENU
-	$.fn.elgg_topbardropdownmenu = function(options) {
-		var defaults = {
-			speed: 350
-		};
-		
-		options = $.extend(defaults, options || {});
-	
-		this.each(function() {
-		
-			var root = this, zIndex = 5000;
-		
-			function getSubnav(ele) {
-				if (ele.nodeName.toLowerCase() == 'li') {
-					var subnav = $('> ul', ele);
-					return subnav.length ? subnav[0] : null;
-				} else {
-					return ele;
-				}
-			}
-		
-			function getActuator(ele) {
-				if (ele.nodeName.toLowerCase() == 'ul') {
-					return $(ele).parents('li')[0];
-				} else {
-					return ele;
-				}
-			}
-		
-			function hide() {
-				var subnav = getSubnav(this);
-				if (!subnav) {
-					return;
-				}
-			
-				$.data(subnav, 'cancelHide', false);
-				setTimeout(function() {
-					if (!$.data(subnav, 'cancelHide')) {
-						$(subnav).slideUp(100);
-					}
-				}, 250);
-			}
-		
-			function show() {
-				var subnav = getSubnav(this);
-				if (!subnav) {
-					return;
-				}
-				
-				$.data(subnav, 'cancelHide', true);
-				
-				$(subnav).css({zIndex: zIndex++}).slideDown(options.speed);
-				
-				if (this.nodeName.toLowerCase() == 'ul') {
-					var li = getActuator(this);
-					$(li).addClass('hover');
-					$('> a', li).addClass('hover');
-				}
-			}
-		
-			$('ul, li', this).hover(show, hide);
-			$('li', this).hover(
-				function() { $(this).addClass('hover'); $('> a', this).addClass('hover'); },
-				function() { $(this).removeClass('hover'); $('> a', this).removeClass('hover'); }
-			);
-		
-		});
-	};
-	
-	//Make delimited list
-	$.fn.makeDelimitedList = function(elementAttribute) {
-	
-		var delimitedListArray = [];
-		var listDelimiter = "::";
-	
-		// Loop over each element in the stack and add the elementAttribute to the array
-		this.each(function(e) {
-				var listElement = $(this);
-				// Add the attribute value to our values array
-				delimitedListArray[delimitedListArray.length] = listElement.attr(elementAttribute);
-			}
-		);
-	
-		// Return value list by joining the array
-		return(delimitedListArray.join(listDelimiter));
-	};
-})(jQuery);
-
-elgg.register_event_handler('init', 'system', elgg.ui.init);
-\ No newline at end of file
+elgg.provide('elgg.ui');
+
+elgg.ui.init = function () {
+	// add user hover menus
+	elgg.ui.initHoverMenu();
+
+	//if the user clicks a system message, make it disappear
+	$('.elgg-system-messages li').live('click', function() {
+		$(this).stop().fadeOut('fast');
+	});
+
+	$('.elgg-system-messages li').animate({opacity: 0.9}, 6000);
+	$('.elgg-system-messages li.elgg-state-success').fadeOut('slow');
+
+	$('[rel=toggle]').live('click', elgg.ui.toggles);
+
+	$('[rel=popup]').live('click', elgg.ui.popupOpen);
+
+	$('.elgg-menu-page .elgg-menu-parent').live('click', elgg.ui.toggleMenu);
+
+	$('.elgg-requires-confirmation').live('click', elgg.ui.requiresConfirmation);
+
+	$('.elgg-autofocus').focus();
+};
+
+/**
+ * Toggles an element based on clicking a separate element
+ *
+ * Use rel="toggle" on the toggler element
+ * Set the href to target the item you want to toggle (<a rel="toggle" href="#id-of-target">)
+ *
+ * @param {Object} event
+ * @return void
+ */
+elgg.ui.toggles = function(event) {
+	event.preventDefault();
+
+	// @todo might want to switch this to elgg.getSelectorFromUrlFragment().
+	var target = $(this).toggleClass('elgg-state-active').attr('href');
+
+	$(target).slideToggle('medium');
+};
+
+/**
+ * Pops up an element based on clicking a separate element
+ *
+ * Set the rel="popup" on the popper and set the href to target the
+ * item you want to toggle (<a rel="popup" href="#id-of-target">)
+ *
+ * This function emits the getOptions, ui.popup hook that plugins can register for to provide custom
+ * positioning for elements.  The handler is passed the following params:
+ *	targetSelector: The selector used to find the popup
+ *	target:         The popup jQuery element as found by the selector
+ *	source:         The jquery element whose click event initiated a popup.
+ *
+ * The return value of the function is used as the options object to .position().
+ * Handles can also return false to abort the default behvior and override it with their own.
+ *
+ * @param {Object} event
+ * @return void
+ */
+elgg.ui.popupOpen = function(event) {
+	event.preventDefault();
+	event.stopPropagation();
+
+	var target = elgg.getSelectorFromUrlFragment($(this).toggleClass('elgg-state-active').attr('href'));
+	var $target = $(target);
+
+	// emit a hook to allow plugins to position and control popups
+	var params = {
+		targetSelector: target,
+		target: $target,
+		source: $(this)
+	};
+
+	var options = {
+		my: 'center top',
+		at: 'center bottom',
+		of: $(this),
+		collision: 'fit fit'
+	}
+
+	options = elgg.trigger_hook('getOptions', 'ui.popup', params, options);
+
+	// allow plugins to cancel event
+	if (!options) {
+		return;
+	}
+
+	// hide if already open
+	if ($target.is(':visible')) {
+		$target.fadeOut();
+		$('body').die('click', elgg.ui.popupClose);
+		return;
+	}
+
+	$target.appendTo('body')
+		.fadeIn()
+		.position(options);
+
+	$('body')
+		.die('click', elgg.ui.popupClose)
+		.live('click', elgg.ui.popupClose);
+};
+
+/**
+ * Catches clicks that aren't in a popup and closes all popups.
+ */
+elgg.ui.popupClose = function(event) {
+	$eventTarget = $(event.target);
+	var inTarget = false;
+	var $popups = $('[rel=popup]');
+
+	// if the click event target isn't in a popup target, fade all of them out.
+	$popups.each(function(i, e) {
+		var target = elgg.getSelectorFromUrlFragment($(e).attr('href')) + ':visible';
+		var $target = $(target);
+
+		if (!$target.is(':visible')) {
+			return;
+		}
+
+		// didn't click inside the target
+		if ($eventTarget.closest(target).length > 0) {
+			inTarget = true;
+			return false;
+		}
+	});
+
+	if (!inTarget) {
+		$popups.each(function(i, e) {
+			var $e = $(e);
+			var $target = $(elgg.getSelectorFromUrlFragment($e.attr('href')) + ':visible');
+			if ($target.length > 0) {
+				$target.fadeOut();
+				$e.removeClass('elgg-state-active');
+			}
+		});
+
+		$('body').die('click', elgg.ui.popClose);
+	}
+};
+
+/**
+ * Toggles a child menu when the parent is clicked
+ *
+ * @param {Object} event
+ * @return void
+ */
+elgg.ui.toggleMenu = function(event) {
+	$(this).siblings().slideToggle('medium');
+	$(this).toggleClass('elgg-menu-closed elgg-menu-opened');
+	event.preventDefault();
+};
+
+/**
+ * Initialize the hover menu
+ *
+ * @param {Object} parent
+ * @return void
+ */
+elgg.ui.initHoverMenu = function(parent) {
+	if (!parent) {
+		parent = document;
+	}
+
+	// avatar image menu link
+	$(parent).find(".elgg-avatar").live('mouseover', function() {
+		$(this).children(".elgg-icon-hover-menu").show();
+	})
+	.live('mouseout', function() {
+		$(this).children(".elgg-icon-hover-menu").hide();
+	});
+
+
+	// avatar contextual menu
+	$(".elgg-avatar > .elgg-icon-hover-menu").live('click', function(e) {
+		// check if we've attached the menu to this element already
+		var $hovermenu = $(this).data('hovermenu') || null;
+
+		if (!$hovermenu) {
+			$hovermenu = $(this).parent().find(".elgg-menu-hover");
+			$(this).data('hovermenu', $hovermenu);
+		}
+
+		// close hovermenu if arrow is clicked & menu already open
+		if ($hovermenu.css('display') == "block") {
+			$hovermenu.fadeOut();
+		} else {
+			$avatar = $(this).closest(".elgg-avatar");
+
+			// @todo Use jQuery-ui position library instead -- much simpler
+			var offset = $avatar.offset();
+			var top = $avatar.height() + offset.top + 'px';
+			var left = $avatar.width() - 15 + offset.left + 'px';
+
+			$hovermenu.appendTo('body')
+					.css('position', 'absolute')
+					.css("top", top)
+					.css("left", left)
+					.fadeIn('normal');
+		}
+
+		// hide any other open hover menus
+		$(".elgg-menu-hover:visible").not($hovermenu).fadeOut();
+	});
+
+	// hide avatar menu when user clicks elsewhere
+	$(document).click(function(event) {
+		if ($(event.target).parents(".elgg-avatar").length == 0) {
+			$(".elgg-menu-hover").fadeOut();
+		}
+	});
+};
+
+/**
+ * Calls a confirm() and prevents default if denied.
+ *
+ * @param {Object} e
+ * @return void
+ */
+elgg.ui.requiresConfirmation = function(e) {
+	var confirmText = $(this).attr('rel') || elgg.echo('question:areyousure');
+	if (!confirm(confirmText)) {
+		e.preventDefault();
+	}
+};
+
+/**
+ * Repositions the login popup
+ *
+ * @param {String} hook    'getOptions'
+ * @param {String} type    'ui.popup'
+ * @param {Object} params  An array of info about the target and source.
+ * @param {Object} options Options to pass to
+ *
+ * @return {Object}
+ */
+elgg.ui.loginHandler = function(hook, type, params, options) {
+	if (params.target.attr('id') == 'login-dropdown-box') {
+		options.my = 'right top';
+		options.at = 'right bottom';
+		return options;
+	}
+	return null;
+};
+
+/**
+ * Initialize the date picker
+ *
+ * Uses the class .elgg-input-date as the selector.
+ *
+ * If the class .elgg-input-timestamp is set on the input element, the onSelect
+ * method converts the date text to a unix timestamp in seconds. That value is
+ * stored in a hidden element indicated by the id on the input field.
+ *
+ * @return void
+ */
+elgg.ui.initDatePicker = function() {
+	var loadDatePicker = function() {
+		$('.elgg-input-date').datepicker({
+			// ISO-8601
+			dateFormat: 'yy-mm-dd',
+			onSelect: function(dateText) {
+				if ($(this).is('.elgg-input-timestamp')) {
+					// convert to unix timestamp
+					var dateParts = dateText.split("-");
+					var timestamp = Date.UTC(dateParts[0], dateParts[1] - 1, dateParts[2]);
+					timestamp = timestamp / 1000;
+
+					var id = $(this).attr('id');
+					$('input[name="' + id + '"]').val(timestamp);
+				}
+			}
+		});
+	};
+	
+	if ($('.elgg-input-date').length && elgg.get_language() == 'en') {
+		loadDatePicker();
+	} else if ($('.elgg-input-date').length) {
+		elgg.get({
+			url: elgg.config.wwwroot + 'vendors/jquery/i18n/jquery.ui.datepicker-'+ elgg.get_language() +'.js',
+			dataType: "script",
+			cache: true,
+			success: loadDatePicker,
+			error: loadDatePicker // english language is already loaded.
+		});
+	}
+};
+
+elgg.register_hook_handler('init', 'system', elgg.ui.init);
+elgg.register_hook_handler('init', 'system', elgg.ui.initDatePicker);
+elgg.register_hook_handler('getOptions', 'ui.popup', elgg.ui.loginHandler);
diff --git a/js/lib/ui.river.js b/js/lib/ui.river.js
new file mode 100644
index 000000000..c103fabb3
--- /dev/null
+++ b/js/lib/ui.river.js
@@ -0,0 +1,14 @@
+elgg.provide('elgg.ui.river');
+
+elgg.ui.river.init = function() {
+	$('#elgg-river-selector').change(function() {
+		var url = window.location.href;
+		if (window.location.search.length) {
+			url = url.substring(0, url.indexOf('?'));
+		}
+		url += '?' + $(this).val();
+		elgg.forward(url);
+	});
+};
+
+elgg.register_hook_handler('init', 'system', elgg.ui.river.init);
+\ No newline at end of file
diff --git a/js/lib/ui.userpicker.js b/js/lib/ui.userpicker.js
new file mode 100644
index 000000000..669b84cdb
--- /dev/null
+++ b/js/lib/ui.userpicker.js
@@ -0,0 +1,117 @@
+elgg.provide('elgg.userpicker');
+
+/**
+ * Userpicker initialization
+ *
+ * The userpicker is an autocomplete library for selecting multiple users or
+ * friends. It works in concert with the view input/userpicker.
+ *
+ * @return void
+ */
+elgg.userpicker.init = function() {
+	
+	// binding autocomplete.
+	// doing this as an each so we can pass this to functions.
+	$('.elgg-input-user-picker').each(function() {
+
+		$(this).autocomplete({
+			source: function(request, response) {
+
+				var params = elgg.userpicker.getSearchParams(this);
+				
+				elgg.get('livesearch', {
+					data: params,
+					dataType: 'json',
+					success: function(data) {
+						response(data);
+					}
+				});
+			},
+			minLength: 2,
+			html: "html",
+			select: elgg.userpicker.addUser
+		})
+	});
+
+	$('.elgg-userpicker-remove').live('click', elgg.userpicker.removeUser);
+};
+
+/**
+ * Adds a user to the select user list
+ *
+ * elgg.userpicker.userList is defined in the input/userpicker view
+ *
+ * @param {Object} event
+ * @param {Object} ui    The object returned by the autocomplete endpoint
+ * @return void
+ */
+elgg.userpicker.addUser = function(event, ui) {
+	var info = ui.item;
+
+	// do not allow users to be added multiple times
+	if (!(info.guid in elgg.userpicker.userList)) {
+		elgg.userpicker.userList[info.guid] = true;
+		var users = $(this).siblings('.elgg-user-picker-list');
+		var li = '<input type="hidden" name="members[]" value="' + info.guid + '" />';
+		li += elgg.userpicker.viewUser(info);
+		$('<li>').html(li).appendTo(users);
+	}
+
+	$(this).val('');
+	event.preventDefault();
+};
+
+/**
+ * Remove a user from the selected user list
+ *
+ * @param {Object} event
+ * @return void
+ */
+elgg.userpicker.removeUser = function(event) {
+	var item = $(this).closest('.elgg-user-picker-list > li');
+	
+	var guid = item.find('[name="members[]"]').val();
+	delete elgg.userpicker.userList[guid];
+
+	item.remove();
+	event.preventDefault();
+};
+
+/**
+ * Render the list item for insertion into the selected user list
+ *
+ * The html in this method has to remain synced with the input/userpicker view
+ *
+ * @param {Object} info  The object returned by the autocomplete endpoint
+ * @return string
+ */
+elgg.userpicker.viewUser = function(info) {
+
+	var deleteLink = "<a href='#' class='elgg-userpicker-remove'>X</a>";
+
+	var html = "<div class='elgg-image-block'>";
+	html += "<div class='elgg-image'>" + info.icon + "</div>";
+	html += "<div class='elgg-image-alt'>" + deleteLink + "</div>";
+	html += "<div class='elgg-body'>" + info.name + "</div>";
+	html += "</div>";
+	
+	return html;
+};
+
+/**
+ * Get the parameters to use for autocomplete
+ *
+ * This grabs the value of the friends checkbox.
+ *
+ * @param {Object} obj  Object for the autocomplete callback
+ * @return Object
+ */
+elgg.userpicker.getSearchParams = function(obj) {
+	if (obj.element.parent('.elgg-user-picker').find('input[name=match_on]').attr('checked')) {
+		return {'match_on[]': 'friends', 'term' : obj.term};
+	} else {
+		return {'match_on[]': 'users', 'term' : obj.term};
+	}
+};
+
+elgg.register_hook_handler('init', 'system', elgg.userpicker.init);
diff --git a/js/lib/ui.widgets.js b/js/lib/ui.widgets.js
index 1e3163709..26020bb4b 100644
--- a/js/lib/ui.widgets.js
+++ b/js/lib/ui.widgets.js
@@ -1,131 +1,209 @@
-elgg.provide('elgg.ui.widgets');
-
-elgg.ui.widgets.init = function() {
-	// COLLAPSABLE WIDGETS (on Dashboard & Profile pages)
-	$('a.toggle_box_contents').live('click', elgg.ui.widgets.toggleContent);
-	$('a.toggle_box_edit_panel').live('click', elgg.ui.widgets.toggleEditPanel);
-	$('a.toggle_customise_edit_panel').live('click', elgg.ui.widgets.toggleCustomizeEditPanel);
-	
-	// WIDGET GALLERY EDIT PANEL
-	// Sortable widgets
-	var els = [
-		'#leftcolumn_widgets',
-		'#middlecolumn_widgets',
-		'#rightcolumn_widgets',
-		'#widget_picker_gallery'
-	].join(',');
-	
-	$(els).sortable({
-		items: '.draggable_widget',
-		handle: '.drag_handle',
-		forcePlaceholderSize: true,
-		placeholder: 'ui-state-highlight',
-		cursor: 'move',
-		opacity: 0.9,
-		appendTo: 'body',
-		connectWith: els,
-		stop: function(e,ui) {
-			// refresh list before updating hidden fields with new widget order
-			$(this).sortable("refresh");
-
-			var widgetNamesLeft = outputWidgetList('#leftcolumn_widgets');
-			var widgetNamesMiddle = outputWidgetList('#middlecolumn_widgets');
-			var widgetNamesRight = outputWidgetList('#rightcolumn_widgets');
-
-			$('#debugField1').val(widgetNamesLeft);
-			$('#debugField2').val(widgetNamesMiddle);
-			$('#debugField3').val(widgetNamesRight);
-		}
-	});
-
-	// bind more info buttons - called when new widgets are created
-	elgg.ui.widgets.moreinfo();
-};
-
-//List active widgets for each page column
-elgg.ui.widgets.outputList = function(forElement) {
-	return( $("input[name='handler'], input[name='guid']", forElement ).makeDelimitedList("value") );
-};
-
-//Read each widgets collapsed/expanded state from cookie and apply
-elgg.ui.widgets.state = function(forWidget) {
-
-	var thisWidgetState = elgg.session.cookie(forWidget);
-
-	if (thisWidgetState == 'collapsed') {
-		forWidget = "#" + forWidget;
-		$(forWidget).find("div.collapsable_box_content").hide();
-		$(forWidget).find("a.toggle_box_contents").html('+');
-		$(forWidget).find("a.toggle_box_edit_panel").fadeOut('medium');
-	}
-};
-
-//More info tooltip in widget gallery edit panel
-elgg.ui.widgets.moreinfo = function() {
-	$("img.more_info").hover(function(e) {
-		var widgetdescription = $("input[name='description']", this.parentNode.parentNode.parentNode).val();
-		$("body").append("<p id='widget_moreinfo'><b>"+ widgetdescription +" </b></p>");
-
-		if (e.pageX < 900) {
-			$("#widget_moreinfo")
-				.css("top",(e.pageY + 10) + "px")
-				.css("left",(e.pageX + 10) + "px")
-				.fadeIn("medium");
-		} else {
-			$("#widget_moreinfo")
-				.css("top",(e.pageY + 10) + "px")
-				.css("left",(e.pageX - 210) + "px")
-				.fadeIn("medium");
-		}
-	}, function() {
-		$("#widget_moreinfo").remove();
-	});
-};
-
-//Toggle widgets contents and save to a cookie
-elgg.ui.widgets.toggleContent = function(e) {
-	var targetContent = $('div.collapsable_box_content', this.parentNode.parentNode);
-	if (targetContent.css('display') == 'none') {
-		targetContent.slideDown(400);
-		$(this).html('-');
-		$(this.parentNode).children(".toggle_box_edit_panel").fadeIn('medium');
-
-		// set cookie for widget panel open-state
-		var thisWidgetName = $(this.parentNode.parentNode.parentNode).attr('id');
-		$.cookie(thisWidgetName, 'expanded', { expires: 365 });
-
-	} else {
-		targetContent.slideUp(400);
-		$(this).html('+');
-		$(this.parentNode).children(".toggle_box_edit_panel").fadeOut('medium');
-		// make sure edit pane is closed
-		$(this.parentNode.parentNode).children(".collapsable_box_editpanel").hide();
-
-		// set cookie for widget panel closed-state
-		var thisWidgetName = $(this.parentNode.parentNode.parentNode).attr('id');
-		$.cookie(thisWidgetName, 'collapsed', { expires: 365 });
-	}
-	return false;
-};
-
-// toggle widget box edit panel
-elgg.ui.widgets.toggleEditPanel = function () {
-	$(this.parentNode.parentNode).children(".collapsable_box_editpanel").slideToggle("fast");
-	return false;
-};
-
-// toggle customise edit panel
-elgg.ui.widgets.toggleCustomizeEditPanel = function () {
-	$('#customise_editpanel').slideToggle("fast");
-	return false;
-};
-
-/**
- * @deprecated Use elgg.ui.widgets.*
- */
-var toggleContent =    elgg.ui.widgets.toggleContent,
-    widget_moreinfo =  elgg.ui.widgets.moreinfo,
-    widget_state =     elgg.ui.widgets.state,
-    outputWidgetList = elgg.ui.widgets.outputList;
-
-elgg.register_event_handler('init', 'system', elgg.ui.widgets.init);
-\ No newline at end of file
+elgg.provide('elgg.ui.widgets');
+
+/**
+ * Widgets initialization
+ *
+ * @return void
+ */
+elgg.ui.widgets.init = function() {
+
+	// widget layout?
+	if ($(".elgg-widgets").length == 0) {
+		return;
+	}
+
+	$(".elgg-widgets").sortable({
+		items:                'div.elgg-module-widget.elgg-state-draggable',
+		connectWith:          '.elgg-widgets',
+		handle:               '.elgg-widget-handle',
+		forcePlaceholderSize: true,
+		placeholder:          'elgg-widget-placeholder',
+		opacity:              0.8,
+		revert:               500,
+		stop:                 elgg.ui.widgets.move
+	});
+
+	$('.elgg-widgets-add-panel li.elgg-state-available').click(elgg.ui.widgets.add);
+
+	$('a.elgg-widget-delete-button').live('click', elgg.ui.widgets.remove);
+	$('.elgg-widget-edit > form ').live('submit', elgg.ui.widgets.saveSettings);
+	$('a.elgg-widget-collapse-button').live('click', elgg.ui.widgets.collapseToggle);
+
+	elgg.ui.widgets.setMinHeight(".elgg-widgets");
+};
+
+/**
+ * Adds a new widget
+ *
+ * Makes Ajax call to persist new widget and inserts the widget html
+ *
+ * @param {Object} event
+ * @return void
+ */
+elgg.ui.widgets.add = function(event) {
+	// elgg-widget-type-<type>
+	var type = $(this).attr('id');
+	type = type.substr(type.indexOf('elgg-widget-type-') + "elgg-widget-type-".length);
+
+	// if multiple instances not allow, disable this widget type add button
+	var multiple = $(this).attr('class').indexOf('elgg-widget-multiple') != -1;
+	if (multiple == false) {
+		$(this).addClass('elgg-state-unavailable');
+		$(this).removeClass('elgg-state-available');
+		$(this).unbind('click', elgg.ui.widgets.add);
+	}
+
+	elgg.action('widgets/add', {
+		data: {
+			handler: type,
+			owner_guid: elgg.get_page_owner_guid(),
+			context: $("input[name='widget_context']").val(),
+			show_access: $("input[name='show_access']").val(),
+			default_widgets: $("input[name='default_widgets']").val() || 0
+		},
+		success: function(json) {
+			$('#elgg-widget-col-1').prepend(json.output);
+		}
+	});
+	event.preventDefault();
+};
+
+/**
+ * Persist the widget's new position
+ *
+ * @param {Object} event
+ * @param {Object} ui
+ *
+ * @return void
+ */
+elgg.ui.widgets.move = function(event, ui) {
+
+	// elgg-widget-<guid>
+	var guidString = ui.item.attr('id');
+	guidString = guidString.substr(guidString.indexOf('elgg-widget-') + "elgg-widget-".length);
+
+	// elgg-widget-col-<column>
+	var col = ui.item.parent().attr('id');
+	col = col.substr(col.indexOf('elgg-widget-col-') + "elgg-widget-col-".length);
+
+	elgg.action('widgets/move', {
+		data: {
+			widget_guid: guidString,
+			column: col,
+			position: ui.item.index()
+		}
+	});
+
+	// @hack fixes jquery-ui/opera bug where draggable elements jump
+	ui.item.css('top', 0);
+	ui.item.css('left', 0);
+};
+
+/**
+ * Removes a widget from the layout
+ *
+ * Event callback the uses Ajax to delete the widget and removes its HTML
+ *
+ * @param {Object} event
+ * @return void
+ */
+elgg.ui.widgets.remove = function(event) {
+	if (confirm(elgg.echo('deleteconfirm')) == false) {
+		event.preventDefault();
+		return;
+	}
+	
+	var $widget = $(this).closest('.elgg-module-widget');
+
+	// if widget type is single instance type, enable the add buton
+	var type = $widget.attr('class');
+	// elgg-widget-instance-<type>
+	type = type.substr(type.indexOf('elgg-widget-instance-') + "elgg-widget-instance-".length);
+	$button = $('#elgg-widget-type-' + type);
+	var multiple = $button.attr('class').indexOf('elgg-widget-multiple') != -1;
+	if (multiple == false) {
+		$button.addClass('elgg-state-available');
+		$button.removeClass('elgg-state-unavailable');
+		$button.unbind('click', elgg.ui.widgets.add); // make sure we don't bind twice
+		$button.click(elgg.ui.widgets.add);
+	}
+
+	$widget.remove();
+
+	// delete the widget through ajax
+	elgg.action($(this).attr('href'));
+
+	event.preventDefault();
+};
+
+/**
+ * Toggle the collapse state of the widget
+ *
+ * @param {Object} event
+ * @return void
+ */
+elgg.ui.widgets.collapseToggle = function(event) {
+	$(this).toggleClass('elgg-widget-collapsed');
+	$(this).parent().parent().find('.elgg-body').slideToggle('medium');
+	event.preventDefault();
+};
+
+/**
+ * Save a widget's settings
+ *
+ * Uses Ajax to save the settings and updates the HTML.
+ *
+ * @param {Object} event
+ * @return void
+ */
+elgg.ui.widgets.saveSettings = function(event) {
+	$(this).parent().slideToggle('medium');
+	var $widgetContent = $(this).parent().parent().children('.elgg-widget-content');
+
+	// stick the ajax loader in there
+	var $loader = $('#elgg-widget-loader').clone();
+	$loader.attr('id', '#elgg-widget-active-loader');
+	$loader.removeClass('hidden');
+	$widgetContent.html($loader);
+
+	var default_widgets = $("input[name='default_widgets']").val() || 0;
+	if (default_widgets) {
+		$(this).append('<input type="hidden" name="default_widgets" value="1">');
+	}
+
+	elgg.action('widgets/save', {
+		data: $(this).serialize(),
+		success: function(json) {
+			$widgetContent.html(json.output);
+		}
+	});
+	event.preventDefault();
+};
+
+/**
+ * Set the min-height so that all widget column bottoms are the same
+ *
+ * This addresses the issue of trying to drag a widget into a column that does
+ * not have any widgets or many fewer widgets than other columns.
+ *
+ * @param {String} selector
+ * @return void
+ */
+elgg.ui.widgets.setMinHeight = function(selector) {
+	var maxBottom = 0;
+	$(selector).each(function() {
+		var bottom = parseInt($(this).offset().top + $(this).height());
+		if (bottom > maxBottom) {
+			maxBottom = bottom;
+		}
+	})
+	$(selector).each(function() {
+		var bottom = parseInt($(this).offset().top + $(this).height());
+		if (bottom < maxBottom) {
+			var newMinHeight = parseInt($(this).height() + (maxBottom - bottom));
+			$(this).css('min-height', newMinHeight + 'px');
+		}
+	})
+};
+
+elgg.register_hook_handler('init', 'system', elgg.ui.widgets.init);
diff --git a/js/tests/ElggAjaxOptionsTest.js b/js/tests/ElggAjaxOptionsTest.js
index 8a2b7f574..a6b40d439 100644
--- a/js/tests/ElggAjaxOptionsTest.js
+++ b/js/tests/ElggAjaxOptionsTest.js
@@ -1,62 +1,61 @@
-/**
- * Tests elgg.ajax.handleOptions() with all of the possible valid inputs
- */
-ElggAjaxOptionsTest = TestCase("ElggAjaxOptionsTest");
-
-ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsNoArgs = function() {
-	assertNotUndefined(elgg.ajax.handleOptions());
-};
-
-ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsUrl = function() {
-	var url = 'url',
-		result = elgg.ajax.handleOptions(url);
-	
-	assertEquals(url, result.url);
-};
-
-ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsDataOnly = function() {
-	var options = {},
-		result = elgg.ajax.handleOptions(options);
-	
-	assertEquals(options, result.data);
-};
-
-ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsOptions = function() {
-	var options = {data:{arg:1}},
-		result = elgg.ajax.handleOptions(options);
-	
-	assertEquals(options, result);
-	
-	function func() {}
-	options = {success: func};
-	result = elgg.ajax.handleOptions(options);
-	
-	assertEquals(options, result);
-};
-
-ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsUrlThenDataOnly = function() {
-	var url = 'url',
-		options = {arg:1},
-		result = elgg.ajax.handleOptions(url, options);
-	
-	assertEquals(url, result.url);
-	assertEquals(options, result.data);
-};
-
-ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsUrlThenSuccessOnly = function() {
-	var url = 'url',
-	success = function() {},
-	result = elgg.ajax.handleOptions(url, success);
-	
-	assertEquals(url, result.url);
-	assertEquals(success, result.success);
-};
-
-ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsUrlThenOptions = function() {
-	var url = 'url',
-	options = {data:{arg:1}},
-	result = elgg.ajax.handleOptions(url, options);
-	
-	assertEquals(url, result.url);
-	assertEquals(options.data, result.data);
+/**
+ * Tests elgg.ajax.handleOptions() with all of the possible valid inputs
+ */
+ElggAjaxOptionsTest = TestCase("ElggAjaxOptionsTest");
+
+ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsNoArgs = function() {
+	assertNotUndefined(elgg.ajax.handleOptions());
+};
+
+ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsUrl = function() {
+	var url = 'url',
+		result = elgg.ajax.handleOptions(url);
+	
+	assertEquals(url, result.url);
+};
+
+ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsDataOnly = function() {
+	var options = {},
+		result = elgg.ajax.handleOptions(options);
+	
+	assertEquals(options, result.data);
+};
+
+ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsOptions = function() {
+	var options = {data:{arg:1}},
+		result = elgg.ajax.handleOptions(options);
+	
+	assertEquals(options, result);
+	
+	function func() {}
+	options = {success: func};
+	result = elgg.ajax.handleOptions(options);
+	
+	assertEquals(options, result);
+};
+
+ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsUrlThenDataOnly = function() {
+	var url = 'url',
+		options = {arg:1},
+		result = elgg.ajax.handleOptions(url, options);
+	
+	assertEquals(url, result.url);
+	assertEquals(options, result.data);
+};
+
+ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsUrlThenSuccessOnly = function() {
+	var url = 'url',
+	result = elgg.ajax.handleOptions(url, elgg.nullFunction);
+	
+	assertEquals(url, result.url);
+	assertEquals(elgg.nullFunction, result.success);
+};
+
+ElggAjaxOptionsTest.prototype.testHandleOptionsAcceptsUrlThenOptions = function() {
+	var url = 'url',
+	options = {data:{arg:1}},
+	result = elgg.ajax.handleOptions(url, options);
+	
+	assertEquals(url, result.url);
+	assertEquals(options.data, result.data);
 };
 \ No newline at end of file
diff --git a/js/tests/ElggAjaxTest.js b/js/tests/ElggAjaxTest.js
index 1fa5daca5..a683415fc 100644
--- a/js/tests/ElggAjaxTest.js
+++ b/js/tests/ElggAjaxTest.js
@@ -1,59 +1,59 @@
-/**
- * Makes sure that each of the helper ajax functions ends up calling $.ajax
- * with the right options.
- */
-ElggAjaxTest = TestCase("ElggAjaxTest");
-
-ElggAjaxTest.prototype.setUp = function() {
-	
-	this.wwwroot = elgg.config.wwwroot;
-	this.ajax = $.ajax;
-	
-	elgg.config.wwwroot = 'http://www.elgg.org/';
-	
-	$.ajax = function(options) {
-		return options;
-	};
-};
-
-ElggAjaxTest.prototype.tearDown = function() {
-	$.ajax = this.ajax;
-	elgg.config.wwwroot = this.wwwroot;
-};
-
-ElggAjaxTest.prototype.testElggAjax = function() {
-	assertEquals(elgg.config.wwwroot, elgg.ajax().url);
-};
-
-ElggAjaxTest.prototype.testElggGet = function() {
-	assertEquals('get', elgg.get().type);
-};
-
-ElggAjaxTest.prototype.testElggGetJSON = function() {
-	assertEquals('json', elgg.getJSON().dataType);
-};
-
-ElggAjaxTest.prototype.testElggPost = function() {
-	assertEquals('post', elgg.post().type);
-};
-
-ElggAjaxTest.prototype.testElggAction = function() {
-	assertException(function() { elgg.action(); });
-	assertException(function() { elgg.action({}); });
-	
-	var result = elgg.action('action');
-	assertEquals('post', result.type);
-	assertEquals('json', result.dataType);
-	assertEquals(elgg.config.wwwroot + 'action/action', result.url);
-	assertEquals(elgg.security.token.__elgg_ts, result.data.__elgg_ts);
-};
-
-ElggAjaxTest.prototype.testElggAPI = function() {
-	assertException(function() { elgg.api(); });
-	assertException(function() { elgg.api({}); });
-	
-	var result = elgg.api('method');
-	assertEquals('json', result.dataType);
-	assertEquals('method', result.data.method);
-	assertEquals(elgg.config.wwwroot + 'services/api/rest/json/', result.url);
-};
+/**
+ * Makes sure that each of the helper ajax functions ends up calling $.ajax
+ * with the right options.
+ */
+ElggAjaxTest = TestCase("ElggAjaxTest");
+
+ElggAjaxTest.prototype.setUp = function() {
+	
+	this.wwwroot = elgg.config.wwwroot;
+	this.ajax = $.ajax;
+	
+	elgg.config.wwwroot = 'http://www.elgg.org/';
+	
+	$.ajax = function(options) {
+		return options;
+	};
+};
+
+ElggAjaxTest.prototype.tearDown = function() {
+	$.ajax = this.ajax;
+	elgg.config.wwwroot = this.wwwroot;
+};
+
+ElggAjaxTest.prototype.testElggAjax = function() {
+	assertEquals(elgg.config.wwwroot, elgg.ajax().url);
+};
+
+ElggAjaxTest.prototype.testElggGet = function() {
+	assertEquals('get', elgg.get().type);
+};
+
+ElggAjaxTest.prototype.testElggGetJSON = function() {
+	assertEquals('json', elgg.getJSON().dataType);
+};
+
+ElggAjaxTest.prototype.testElggPost = function() {
+	assertEquals('post', elgg.post().type);
+};
+
+ElggAjaxTest.prototype.testElggAction = function() {
+	assertException(function() { elgg.action(); });
+	assertException(function() { elgg.action({}); });
+	
+	var result = elgg.action('action');
+	assertEquals('post', result.type);
+	assertEquals('json', result.dataType);
+	assertEquals(elgg.config.wwwroot + 'action/action', result.url);
+	assertEquals(elgg.security.token.__elgg_ts, result.data.__elgg_ts);
+};
+
+ElggAjaxTest.prototype.testElggAPI = function() {
+	assertException(function() { elgg.api(); });
+	assertException(function() { elgg.api({}); });
+	
+	var result = elgg.api('method');
+	assertEquals('json', result.dataType);
+	assertEquals('method', result.data.method);
+	assertEquals(elgg.config.wwwroot + 'services/api/rest/json/', result.url);
+};
diff --git a/js/tests/ElggEventsTest.js b/js/tests/ElggEventsTest.js
deleted file mode 100644
index cc30e8418..000000000
--- a/js/tests/ElggEventsTest.js
+++ /dev/null
@@ -1,28 +0,0 @@
-ElggEventsTest = TestCase("ElggEventsTest");
-
-ElggEventsTest.prototype.setUp = function() {
-	elgg.config.events = {};
-	elgg.provide('elgg.config.events.all.all');
-};
-
-ElggEventsTest.prototype.testEventHandlersMustBeFunctions = function() {
-	assertException(function() { elgg.register_event_handler('str', 'str', 'oops'); });
-};
-
-ElggEventsTest.prototype.testReturnValueDefaultsToTrue = function() {
-	assertTrue(elgg.trigger_event('fee', 'fum'));
-	
-	elgg.register_event_handler('fee', 'fum', function() {});
-	assertTrue(elgg.trigger_event('fee', 'fum'));
-};
-
-ElggEventsTest.prototype.testCanGlomEventsWithAll = function() {
-	elgg.register_event_handler('all', 'bar', function() { throw new Error(); });
-	assertException("all,bar", function() { elgg.trigger_event('foo', 'bar'); });
-	
-	elgg.register_event_handler('foo', 'all', function() { throw new Error(); });
-	assertException("foo,all", function() { elgg.trigger_event('foo', 'baz'); });
-	
-	elgg.register_event_handler('all', 'all', function() { throw new Error(); });	
-	assertException("all,all", function() { elgg.trigger_event('pinky', 'winky'); });
-};
-\ No newline at end of file
diff --git a/js/tests/ElggHooksTest.js b/js/tests/ElggHooksTest.js
new file mode 100644
index 000000000..e7a2440e7
--- /dev/null
+++ b/js/tests/ElggHooksTest.js
@@ -0,0 +1,28 @@
+ElggHooksTest = TestCase("ElggHooksTest");
+
+ElggHooksTest.prototype.setUp = function() {
+	elgg.config.hooks = {};
+	elgg.provide('elgg.config.hooks.all.all');
+};
+
+ElggHooksTest.prototype.testHookHandlersMustBeFunctions = function () {
+	assertException(function() { elgg.register_hook_handler('str', 'str', 'oops'); });
+};
+
+ElggHooksTest.prototype.testReturnValueDefaultsToTrue = function () {
+	assertTrue(elgg.trigger_hook('fee', 'fum'));
+
+	elgg.register_hook_handler('fee', 'fum', elgg.nullFunction);
+	assertTrue(elgg.trigger_hook('fee', 'fum'));
+};
+
+ElggHooksTest.prototype.testCanGlomHooksWithAll = function () {
+	elgg.register_hook_handler('all', 'bar', elgg.abstractMethod);
+	assertException("all,bar", function() { elgg.trigger_hook('foo', 'bar'); });
+
+	elgg.register_hook_handler('foo', 'all', elgg.abstractMethod);
+	assertException("foo,all", function() { elgg.trigger_hook('foo', 'baz'); });
+
+	elgg.register_hook_handler('all', 'all', elgg.abstractMethod);
+	assertException("all,all", function() { elgg.trigger_hook('pinky', 'winky'); });
+};
+\ No newline at end of file
diff --git a/js/tests/ElggLanguagesTest.js b/js/tests/ElggLanguagesTest.js
index 950d5d3b8..9186ff5bb 100644
--- a/js/tests/ElggLanguagesTest.js
+++ b/js/tests/ElggLanguagesTest.js
@@ -1,45 +1,45 @@
-ElggLanguagesTest = TestCase("ElggLanguagesTest");
-
-ElggLanguagesTest.prototype.setUp = function() {
-	this.ajax = $.ajax;
-	
-	//Immediately execute some dummy "returned" javascript instead of sending
-	//an actual ajax request
-	$.ajax = function(settings) {
-		var lang = settings.data.js.split('/')[1];
-		elgg.config.translations[lang] = {'language':lang};
-	};
-};
-
-ElggLanguagesTest.prototype.tearDown = function() {
-	$.ajax = this.ajax;
-	
-	//clear translations
-	elgg.config.translations['en'] = undefined;
-	elgg.config.translations['aa'] = undefined;
-};
-
-ElggLanguagesTest.prototype.testLoadTranslations = function() {
-	assertUndefined(elgg.config.translations['en']);
-	assertUndefined(elgg.config.translations['aa']);
-	
-	elgg.reload_all_translations();
-	elgg.reload_all_translations('aa');
-	
-	assertNotUndefined(elgg.config.translations['en']['language']);
-	assertNotUndefined(elgg.config.translations['aa']['language']);
-};
-
-ElggLanguagesTest.prototype.testElggEchoTranslates = function() {
-	elgg.reload_all_translations('en');
-	elgg.reload_all_translations('aa');
-	
-	assertEquals('en', elgg.echo('language'));
-	assertEquals('aa', elgg.echo('language', 'aa'));
-};
-
-ElggLanguagesTest.prototype.testElggEchoFallsBackToDefaultLanguage = function() {
-	elgg.reload_all_translations('en');
-	assertEquals('en', elgg.echo('language', 'aa'));
-};
-
+ElggLanguagesTest = TestCase("ElggLanguagesTest");
+
+ElggLanguagesTest.prototype.setUp = function() {
+	this.ajax = $.ajax;
+	
+	//Immediately execute some dummy "returned" javascript instead of sending
+	//an actual ajax request
+	$.ajax = function(settings) {
+		var lang = settings.data.language;
+		elgg.config.translations[lang] = {'language':lang};
+	};
+};
+
+ElggLanguagesTest.prototype.tearDown = function() {
+	$.ajax = this.ajax;
+	
+	//clear translations
+	elgg.config.translations['en'] = undefined;
+	elgg.config.translations['aa'] = undefined;
+};
+
+ElggLanguagesTest.prototype.testLoadTranslations = function() {
+	assertUndefined(elgg.config.translations['en']);
+	assertUndefined(elgg.config.translations['aa']);
+	
+	elgg.reload_all_translations();
+	elgg.reload_all_translations('aa');
+	
+	assertNotUndefined(elgg.config.translations['en']['language']);
+	assertNotUndefined(elgg.config.translations['aa']['language']);
+};
+
+ElggLanguagesTest.prototype.testElggEchoTranslates = function() {
+	elgg.reload_all_translations('en');
+	elgg.reload_all_translations('aa');
+	
+	assertEquals('en', elgg.echo('language'));
+	assertEquals('aa', elgg.echo('language', 'aa'));
+};
+
+ElggLanguagesTest.prototype.testElggEchoFallsBackToDefaultLanguage = function() {
+	elgg.reload_all_translations('en');
+	assertEquals('en', elgg.echo('language', 'aa'));
+};
+
diff --git a/js/tests/ElggLibTest.js b/js/tests/ElggLibTest.js
index 035b60325..bd39e7fb3 100644
--- a/js/tests/ElggLibTest.js
+++ b/js/tests/ElggLibTest.js
@@ -1,88 +1,140 @@
-/**
- * Test basic elgg library functions
- */
-ElggLibTest = TestCase("ElggLibTest");
-
-ElggLibTest.prototype.testGlobal = function() {
-	assertTrue(window === elgg.global);
-};
-
-ElggLibTest.prototype.testAssertTypeOf = function() {
-	var noexceptions = [
-	    ['string', ''],
-        ['object', {}],
-        ['boolean', true],          
-        ['boolean', false],         
-        ['undefined', undefined],   
-        ['number', 0],             
-        ['function', function() {}],
-    ];
-	
-	for (var i in noexceptions) {
-		assertNoException(function() { 
-			elgg.assertTypeOf.apply(elgg, noexceptions[i]); 
-		});
-	}
-	
-	var exceptions = [
-        ['function', {}],
-        ['object', function() {}],
-    ];
-	
-	for (var i in exceptions) {
-		assertException(function() {
-			elgg.assertTypeOf.apply(elgg, exceptions[i]);
-		});
-	}
-};
-
-ElggLibTest.prototype.testProvide = function() {
-	elgg.provide('foo.bar.baz');
-	
-	assertNotUndefined(foo);
-	assertNotUndefined(foo.bar);
-	assertNotUndefined(foo.bar.baz);
-	
-	var str = foo.bar.baz.oof = "don't overwrite me";
-	
-	elgg.provide('foo.bar.baz');
-	
-	assertEquals(str, foo.bar.baz.oof);
-};
-
-ElggLibTest.prototype.testRequire = function() {
-	/* Try requiring bogus input */
-	assertException(function(){ elgg.require(''); });
-	assertException(function(){ elgg.require('garbage'); });
-	assertException(function(){ elgg.require('gar.ba.ge'); });
-
-	assertNoException(function(){ elgg.require('jQuery'); });
-	assertNoException(function(){ elgg.require('elgg'); });
-	assertNoException(function(){ elgg.require('elgg.config'); });
-	assertNoException(function(){ elgg.require('elgg.security'); });
-};
-
-ElggLibTest.prototype.testInherit = function() {
-	function Base() {}
-	function Child() {}
-	
-	elgg.inherit(Child, Base);
-	
-	assertInstanceOf(Base, new Child());
-	assertEquals(Child, Child.prototype.constructor);
-};
-
-ElggLibTest.prototype.testExtendUrl = function() {
-	elgg.config.wwwroot = "http://elgg.org/";
-	
-	var inputs = [
-	    [elgg.config.wwwroot, ''],
-	    [elgg.config.wwwroot + 'pg/test', 'pg/test'],
-	    ['http://google.com', 'http://google.com'],
-	    ['//example.com', '//example.com'],
-	];
-
-	for (var i in inputs) {
-		assertEquals(inputs[i][0], elgg.normalize_url(inputs[i][1]));
-	}
-};
-\ No newline at end of file
+/**
+ * Test basic elgg library functions
+ */
+ElggLibTest = TestCase("ElggLibTest");
+
+ElggLibTest.prototype.testGlobal = function() {
+	assertTrue(window === elgg.global);
+};
+
+ElggLibTest.prototype.testAssertTypeOf = function() {
+	[//Valid inputs
+	    ['string', ''],
+        ['object', {}],
+        ['boolean', true],
+        ['boolean', false],
+        ['undefined', undefined],
+        ['number', 0],
+        ['function', elgg.nullFunction]
+    ].forEach(function(args) {
+		assertNoException(function() {
+			elgg.assertTypeOf.apply(undefined, args);
+		});
+	});
+
+	[//Invalid inputs
+        ['function', {}],
+        ['object', elgg.nullFunction]
+    ].forEach(function() {
+		assertException(function(args) {
+			elgg.assertTypeOf.apply(undefined, args);
+		});
+	});
+};
+
+ElggLibTest.prototype.testProvideDoesntClobber = function() {
+	elgg.provide('foo.bar.baz');
+
+	foo.bar.baz.oof = "test";
+
+	elgg.provide('foo.bar.baz');
+
+	assertEquals("test", foo.bar.baz.oof);
+};
+
+/**
+ * Try requiring bogus input
+ */
+ElggLibTest.prototype.testRequire = function () {
+	assertException(function(){ elgg.require(''); });
+	assertException(function(){ elgg.require('garbage'); });
+	assertException(function(){ elgg.require('gar.ba.ge'); });
+
+	assertNoException(function(){
+		elgg.require('jQuery');
+		elgg.require('elgg');
+		elgg.require('elgg.config');
+		elgg.require('elgg.security');
+	});
+};
+
+ElggLibTest.prototype.testInherit = function () {
+	function Base() {}
+	function Child() {}
+
+	elgg.inherit(Child, Base);
+
+	assertInstanceOf(Base, new Child());
+	assertEquals(Child, Child.prototype.constructor);
+};
+
+ElggLibTest.prototype.testNormalizeUrl = function() {
+	elgg.config.wwwroot = "http://elgg.org/";
+
+	[
+		['', elgg.config.wwwroot],
+		['test', elgg.config.wwwroot + 'test'],
+		['http://example.com', 'http://example.com'],
+		['https://example.com', 'https://example.com'],
+		['http://example-time.com', 'http://example-time.com'],
+		['//example.com', '//example.com'],
+		['mod/my_plugin/graphics/image.jpg', elgg.config.wwwroot + 'mod/my_plugin/graphics/image.jpg'],
+
+		['ftp://example.com/file', 'ftp://example.com/file'],
+		['mailto:brett@elgg.org', 'mailto:brett@elgg.org'],
+		['javascript:alert("test")', 'javascript:alert("test")'],
+		['app://endpoint', 'app://endpoint'],
+
+		['example.com', 'http://example.com'],
+		['example.com/subpage', 'http://example.com/subpage'],
+
+		['page/handler', elgg.config.wwwroot + 'page/handler'],
+		['page/handler?p=v&p2=v2', elgg.config.wwwroot + 'page/handler?p=v&p2=v2'],
+		['mod/plugin/file.php', elgg.config.wwwroot + 'mod/plugin/file.php'],
+		['mod/plugin/file.php?p=v&p2=v2', elgg.config.wwwroot + 'mod/plugin/file.php?p=v&p2=v2'],
+		['rootfile.php', elgg.config.wwwroot + 'rootfile.php'],
+		['rootfile.php?p=v&p2=v2', elgg.config.wwwroot + 'rootfile.php?p=v&p2=v2'],
+
+		['/page/handler', elgg.config.wwwroot + 'page/handler'],
+		['/page/handler?p=v&p2=v2', elgg.config.wwwroot + 'page/handler?p=v&p2=v2'],
+		['/mod/plugin/file.php', elgg.config.wwwroot + 'mod/plugin/file.php'],
+		['/mod/plugin/file.php?p=v&p2=v2', elgg.config.wwwroot + 'mod/plugin/file.php?p=v&p2=v2'],
+		['/rootfile.php', elgg.config.wwwroot + 'rootfile.php'],
+		['/rootfile.php?p=v&p2=v2', elgg.config.wwwroot + 'rootfile.php?p=v&p2=v2']
+
+	].forEach(function(args) {
+		assertEquals(args[1], elgg.normalize_url(args[0]));
+	});
+};
+
+ElggLibTest.prototype.testParseUrl = function() {
+
+	[
+		["http://www.elgg.org/test/", {'scheme': 'http', 'host': 'www.elgg.org', 'path': '/test/'}],
+		["https://www.elgg.org/test/", {'scheme': 'https', 'host': 'www.elgg.org', 'path': '/test/'}],
+		["ftp://www.elgg.org/test/", {'scheme': 'ftp', 'host': 'www.elgg.org', 'path': '/test/'}],
+		["http://elgg.org/test?val1=one&val2=two", {'scheme': 'http', 'host': 'elgg.org', 'path': '/test', 'query': 'val1=one&val2=two'}],
+		["http://elgg.org:8080/", {'scheme': 'http', 'host': 'elgg.org', 'port': 8080, 'path': '/'}],
+		["http://elgg.org/test#there", {'scheme': 'http', 'host': 'elgg.org', 'path': '/test', 'fragment': 'there'}],
+		
+		["test?val=one", {'host': 'test', 'query': 'val=one'}],
+		["?val=one", {'query': 'val=one'}],
+
+		["mailto:joe@elgg.org", {'scheme': 'mailto', 'path': 'joe@elgg.org'}],
+		["javascript:load()", {'scheme': 'javascript', 'path': 'load()'}]
+
+	].forEach(function(args) {
+		assertEquals(args[1], elgg.parse_url(args[0]));
+	});
+};
+
+ElggLibTest.prototype.testParseStr = function() {
+
+	[
+		["A+%2B+B=A+%2B+B", {"A + B": "A + B"}]
+
+	].forEach(function(args) {
+		assertEquals(args[1], elgg.parse_str(args[0]));
+	});
+};
+
diff --git a/js/tests/ElggPriorityListTest.js b/js/tests/ElggPriorityListTest.js
index 2549e0ee0..2329a8490 100644
--- a/js/tests/ElggPriorityListTest.js
+++ b/js/tests/ElggPriorityListTest.js
@@ -15,7 +15,7 @@ ElggPriorityListTest.prototype.testInsert = function() {
 
 	this.list.insert('bar', 501);
 
-	assertEquals('foo', this.list.priorities_[501][0]);
+	assertEquals('bar', this.list.priorities_[501][0]);
 };
 
 ElggPriorityListTest.prototype.testInsertRespectsPriority = function() {
@@ -25,9 +25,9 @@ ElggPriorityListTest.prototype.testInsertRespectsPriority = function() {
 		this.list.insert(values[i], values[i]);
 	}
 
-	this.list.forEach(function(elem, idx)) {
+	this.list.forEach(function(elem, idx) {
 		assertEquals(elem, idx);
-	}
+	})
 };
 
 ElggPriorityListTest.prototype.testInsertHandlesDuplicatePriorities = function() {
diff --git a/js/tests/ElggSecurityTest.js b/js/tests/ElggSecurityTest.js
index 4324f5671..107c0adbd 100644
--- a/js/tests/ElggSecurityTest.js
+++ b/js/tests/ElggSecurityTest.js
@@ -1,51 +1,75 @@
-ElggSecurityTest = TestCase("ElggSecurityTest");
-
-ElggSecurityTest.prototype.setUp = function() {
-	//fill with fake, but reasonable, values for testing
-	this.ts = elgg.security.token.__elgg_ts = 12345;
-	this.token = elgg.security.token.__elgg_token = 'abcdef';
-};
-
-ElggSecurityTest.prototype.testAddTokenAcceptsUndefined = function() {
-	var input,
-		expected = {
-			__elgg_ts: this.ts,
-			__elgg_token: this.token
-		};
-	
-	assertEquals(expected, elgg.security.addToken(input));
-};
-
-ElggSecurityTest.prototype.testAddTokenAcceptsObject = function() {
-	var input = {},
-		expected = {
-			__elgg_ts: this.ts,
-			__elgg_token: this.token
-		};
-	
-	assertEquals(expected, elgg.security.addToken(input));
-};
-
-ElggSecurityTest.prototype.testAddTokenAcceptsString = function() {
-	var input,
-		str = "__elgg_ts=" + this.ts + "&__elgg_token=" + this.token;
-	
-	input = "";
-	assertEquals(str, elgg.security.addToken(input));
-	
-	input = "data=sofar";
-	assertEquals(input+'&'+str, elgg.security.addToken(input));
-	
-};
-
-ElggSecurityTest.prototype.testSetTokenSetsElggSecurityToken = function() {
-	var json = {
-		__elgg_ts: 4567,
-		__elgg_token: 'abcdef'
-	};
-	
-	elgg.security.setToken(json);
-	assertEquals(json, elgg.security.token);
-};
-
-
+ElggSecurityTest = TestCase("ElggSecurityTest");
+
+ElggSecurityTest.prototype.setUp = function() {
+	//fill with fake, but reasonable, values for testing
+	this.ts = elgg.security.token.__elgg_ts = 12345;
+	this.token = elgg.security.token.__elgg_token = 'abcdef';
+};
+
+ElggSecurityTest.prototype.testAddTokenAcceptsUndefined = function() {
+	var input,
+		expected = {
+			__elgg_ts: this.ts,
+			__elgg_token: this.token
+		};
+	
+	assertEquals(expected, elgg.security.addToken(input));
+};
+
+ElggSecurityTest.prototype.testAddTokenAcceptsObject = function() {
+	var input = {},
+		expected = {
+			__elgg_ts: this.ts,
+			__elgg_token: this.token
+		};
+	
+	assertEquals(expected, elgg.security.addToken(input));
+};
+
+ElggSecurityTest.prototype.testAddTokenAcceptsRelativeUrl = function() {
+	var input,
+		str = "__elgg_ts=" + this.ts + "&__elgg_token=" + this.token;
+
+	input = "test";
+	assertEquals(input + '?' + str, elgg.security.addToken(input));
+};
+
+ElggSecurityTest.prototype.testAddTokenAcceptsFullUrl = function() {
+	var input,
+		str = "__elgg_ts=" + this.ts + "&__elgg_token=" + this.token;
+
+	input = "http://elgg.org/";
+	assertEquals(input + '?' + str, elgg.security.addToken(input));
+};
+
+ElggSecurityTest.prototype.testAddTokenAcceptsQueryString = function() {
+	var input,
+		str = "__elgg_ts=" + this.ts + "&__elgg_token=" + this.token;
+
+	input = "?data=sofar";
+	assertEquals(input + '&' + str, elgg.security.addToken(input));
+
+	input = "test?data=sofar";
+	assertEquals(input + '&' + str, elgg.security.addToken(input));
+
+	input = "http://elgg.org/?data=sofar";
+	assertEquals(input + '&' + str, elgg.security.addToken(input));
+};
+
+ElggSecurityTest.prototype.testAddTokenAlreadyAdded = function() {
+	var input,
+		str = "__elgg_ts=" + this.ts + "&__elgg_token=" + this.token;
+
+	input = "http://elgg.org/?" + str + "&data=sofar";
+	assertEquals(input, elgg.security.addToken(input));
+};
+
+ElggSecurityTest.prototype.testSetTokenSetsElggSecurityToken = function() {
+	var json = {
+		__elgg_ts: 4567,
+		__elgg_token: 'abcdef'
+	};
+	
+	elgg.security.setToken(json);
+	assertEquals(json, elgg.security.token);
+};
diff --git a/js/tests/ElggSessionTest.js b/js/tests/ElggSessionTest.js
index 0245e9e90..5ff8ca13e 100644
--- a/js/tests/ElggSessionTest.js
+++ b/js/tests/ElggSessionTest.js
@@ -1,36 +1,36 @@
-ElggSessionTest = TestCase("ElggSessionTest");
-
-ElggSessionTest.prototype.testGetCookie = function() {
-	assertEquals(document.cookie, elgg.session.cookie());
-};
-
-ElggSessionTest.prototype.testGetCookieKey = function() {
-	document.cookie = "name=value";
-	assertEquals('value', elgg.session.cookie('name'));
-	
-	document.cookie = "name=value2";
-	assertEquals('value2', elgg.session.cookie('name'));
-	
-	document.cookie = "name=value";
-	document.cookie = "name2=value2";
-	assertEquals('value', elgg.session.cookie('name'));
-	assertEquals('value2', elgg.session.cookie('name2'));
-};
-
-ElggSessionTest.prototype.testSetCookieKey = function() {
-	elgg.session.cookie('name', 'value');
-	assertEquals('value', elgg.session.cookie('name'));
-
-	elgg.session.cookie('name', 'value2');
-	assertEquals('value2', elgg.session.cookie('name'));
-	
-	elgg.session.cookie('name', 'value');
-	elgg.session.cookie('name2', 'value2');
-	assertEquals('value', elgg.session.cookie('name'));
-	assertEquals('value2', elgg.session.cookie('name2'));
-	
-	elgg.session.cookie('name', null);
-	elgg.session.cookie('name2', null);
-	assertUndefined(elgg.session.cookie('name'));
-	assertUndefined(elgg.session.cookie('name2'));
+ElggSessionTest = TestCase("ElggSessionTest");
+
+ElggSessionTest.prototype.testGetCookie = function() {
+	assertEquals(document.cookie, elgg.session.cookie());
+};
+
+ElggSessionTest.prototype.testGetCookieKey = function() {
+	document.cookie = "name=value";
+	assertEquals('value', elgg.session.cookie('name'));
+	
+	document.cookie = "name=value2";
+	assertEquals('value2', elgg.session.cookie('name'));
+	
+	document.cookie = "name=value";
+	document.cookie = "name2=value2";
+	assertEquals('value', elgg.session.cookie('name'));
+	assertEquals('value2', elgg.session.cookie('name2'));
+};
+
+ElggSessionTest.prototype.testSetCookieKey = function() {
+	elgg.session.cookie('name', 'value');
+	assertEquals('value', elgg.session.cookie('name'));
+
+	elgg.session.cookie('name', 'value2');
+	assertEquals('value2', elgg.session.cookie('name'));
+	
+	elgg.session.cookie('name', 'value');
+	elgg.session.cookie('name2', 'value2');
+	assertEquals('value', elgg.session.cookie('name'));
+	assertEquals('value2', elgg.session.cookie('name2'));
+	
+	elgg.session.cookie('name', null);
+	elgg.session.cookie('name2', null);
+	assertUndefined(elgg.session.cookie('name'));
+	assertUndefined(elgg.session.cookie('name2'));
 };
 \ No newline at end of file
diff --git a/js/tests/README b/js/tests/README
new file mode 100644
index 000000000..f43c0c89d
--- /dev/null
+++ b/js/tests/README
@@ -0,0 +1,25 @@
+Elgg JavaScript Unit Tests
+--------------------------
+
+Introduction
+============
+Elgg uses js-test-driver to run its unit tests. Instructions on obtaining,
+configuring, and using it are at http://code.google.com/p/js-test-driver/. It
+supports running the test in multiple browsers and debugging using web browser
+based debuggers. Visit its wiki at the Google Code site for more information.
+
+
+Sample Usage
+============
+ 1. Put jar file in the base directory of Elgg
+ 2. Run the server: java -jar JsTestDriver-1.3.5.jar --port 4224
+ 3. Point a web browser at http://localhost:4224
+ 4. Click "Capture this browser"
+ 5. Run the tests: java -jar JsTestDriver-1.3.5.jar --config js/tests/jsTestDriver.conf --basePath . --tests all
+
+
+Configuration Hints
+===================
+ * The port when running the server must be the same as listed in the 
+   configuration file. If that port is being used, change the configuration file.
+ * The basePath must be the base directory of Elgg.
+\ No newline at end of file
diff --git a/js/tests/jsTestDriver.conf b/js/tests/jsTestDriver.conf
index 2f732da7b..cc0b5d373 100644
--- a/js/tests/jsTestDriver.conf
+++ b/js/tests/jsTestDriver.conf
@@ -1,8 +1,10 @@
-server: http://localhost:42442
-
-load:
- - vendors/jquery/jquery-1.4.2.min.js
- - js/lib/elgglib.js
- - js/classes/*.js
- - js/lib/*.js
+server: http://localhost:4224
+
+load:
+ - vendors/jquery/jquery-1.6.4.min.js
+ - vendors/sprintf.js
+ - js/lib/elgglib.js
+ - js/lib/hooks.js
+ - js/classes/*.js
+ - js/lib/*.js
  - js/tests/*.js
 \ No newline at end of file