if(typeof(Packages) == 'undefined') Packages = {$i: {}, $: {}};var pPackagePath = '/System/Software/JS/';/***************************************************************
 * Accounts - singleton - contains the tools to communicate with a WEB server
 *
 * The Accounts Singleton does 3 distinctly different tasks
 * 1. Allows an ordinary user to log into their webspace
 * 		Initialised by the WEB server, so that the url is the path to their webspace
 * 2. Allows a restricted user to log into their sub account
 * 		A parent URL contains the url to the parent account, instead of asking for username, it asks for account name
 * 		and logs into to the account as <parenturl>/Accounts/<accountname>/.admin?user=User&pass=<password>.
 * 3. Allows a non user, to sign up and become a restricted user
 * 		Automated account sign up works by having a template user on the server.
 * 		A template user is defined as an ordinary user, except the template account flag is set (also disabled is recommended)
 * 		The new user account is created in the Accounts folder, and a dummy Admin (disabled) is created
 * 		During account creation, the template user's permissions are copied to the restricted user of the new account
 *
 * singleFieldLogin:
 * 	When enabled, a password field will not be shown.
 * 	Instead the username will be split on the hyphen '-' character
 * 	The section before the hyphen is the username, and the section after the password
 **************************************************************/
Package("Library").Accounts = function() {
	this.textVar = GetTextRef(this);
	var LOGGEDIN = 1; // Verified
	var LOGGEDOUT = 2; // Verified
	var LOGGINGIN = 3; // In process of
	var LOGINFAIL = 4; // Server said no
	var LOGINCREATE = 5;
	this.status = LOGGEDOUT;
	this.folders;
	this.reloadOnLogin = 0;
	this.login = {username: "", password: "", confirmpassword: "", accountname: ""};
	this.url = Packages.Library.$.GetMasterpath({});
	if(!this.url.match(/\/$/)) this.url += "/";
	this.singleFieldLogin = 0;
	
	
	// Set up onload subscriber event
	Packages.Library.$.EventSubscribe({eventname: "GetGlobalReplacements", callback: Packages.Library.$.GetGlobalReplacementUsername});

	/*******************************
	 * UpdateScreen - displays the appropriate form for logging in / out
	 * depending on current state
	 *
	 * Also used for updating the state
	 *
	 * param - status : (optional) status to set to
	 * param - message : (optional) message to display
	 *
	 * returns the HTML markup for the form
	 ******************************/
	this.UpdateScreen = function(status, message) {
		if(status != null) this.status = status;
		var html = "Login status unknown";
		if(this.status == LOGGEDIN ) html = this.ScreenLoggedIn();
		if(this.status == LOGGEDOUT) html = this.ScreenLoginForm();
		if(this.status == LOGGINGIN) html = "Logging in ...";
		if(this.status == LOGINFAIL) html = this.ScreenLoginForm("Failed to log on<br>Please check your login and try again");
		if(this.status == LOGINCREATE) html = this.ScreenCreateAccount();
		
		// Prefix with message
		if(message != null) html = "<h2>" + message + "<\/h2>" + html;
		
		// Put HTML in sensible place
		if(Packages.Library.$c.IsNode != 1) {
			var elem = document.getElementById('account_signform');
			if(elem) elem.innerHTML = html;
		}
		return html;
	};
	/*****************************
	 * ScreenLoggedIn - called to display logged in screen
	 ****************************/
	this.ScreenLoggedIn = function() {
		var html = "";
		
		html += "<div class='richtextnotice'>Logged in as " + this.genericname + "<\/div>";
		html += "<button onclick=\"" + this.textVar + ".LogOut()" + "\">Log Out<\/button>";
		
		return html;
	};
	/*******************************
	 * ScreenLoginForm - creates a login form with optional signup
	 *
	 * Allows a user to login to a specified account
	 *
	 * param - message : (optional) message to display above form
	 *
	 * returns the HTML markup for the form
	 ******************************/
	this.ScreenLoginForm = function(message) {
		var items = [
			{
				type: "Label",
				label: "Log in" + (this.title != null ? " to " + this.title : "")
			}
		];
		if(message != null) {
			items.push({
				type: "Label",
				label: message
			})
		}
		// Decide which type of form we are displaying (login user, or login account)
		if(this.accountLogon == 1) {
			// Account login, so username will default to User
			items.push({
				name: "Account Name",
				type: "Text",
				value: this.login.accountname,
				id: "accountname",
				required: 1
			});
			this.login.username = "User";
		} else {
			// User login
			items.push(
				{
					name: "Username",
					description: (this.singleFieldLogin == 1 ? "This is a single login field, please enter your secure username.\nThis will be in the format: v{username-xxxx}\nEg: v{fred-abc123}\nThe entire secure username, including the hyphen must be entered into the f{Username} field.\nOnce you have entered your secure username, click b{Log In}" : null),
					type: "Text",
					id: "username",
					required: 1
				}
			);
		}
		if(this.singleFieldLogin != 1) {
			items.push({
				name: "Password",
				type: "Text",
				password: 1,
				value: this.login.password,
				id: "password",
				required: 1
			});
		}
		if(this.login.username == "guest") this.login.username = "";
		this.loginform = new Packages.Form.Form({
			type: "Form",
			object: this.login,
			submit: this.LoginSubmit.bind(this),
			submittext: "Log in",
			idprefix: "loginform",
			items: items,
			allowUndo: 0
		});
		var html = this.loginform.MakeForm();
		if(this.signupTemplate != null && this.signupTemplate != "") {
			html += "<button onclick=\"" + this.textVar + ".UpdateScreen(" + LOGINCREATE + ")" + "\">Create an account<\/button>";;
		}
		return html;
	};
	/*****************************
	 * LoginSubmit - called when login form submitted
	 ****************************/
	this.LoginSubmit = function() {
		this.status = LOGGINGIN;
		
		// Get generic account name, either account or user name
		// Find url if using parenturl
		if(this.accountLogon == 1) {
			this.url = this.parenturl + "/Accounts/" + this.login.accountname;
			this.genericname = this.login.accountname;
		} else {
			this.url = this.parenturl;
			this.genericname = this.login.username;
		}
		// Was there a password, or is this a single login field?
		if(this.singleFieldLogin == 1) {
			if(this.login.username.match(/(.*?)-(.*)/)) {
				this.login.username = RegExp.$1;
				this.login.password = RegExp.$2;
			}
		}
		
		// Update form
		this.UpdateScreen();
		
		// Connect to server with login details
		this.serverRequest = new Packages.Library.ServerRequest();
		this.serverRequest.ServerRequest({
			page: this.url + ".admin",
			query: {
				"req-ignorefile": 1,
				"req-files": 1
			},
			post: {
				user: this.login.username,
				pass: this.login.password
			},
			callback: this.LoginConfirm.bind(this)
		});
	};
	/************************************************************************************************
	 * LoginConfirm - called when server request completes - verifies if server agrees user exists and access available
	 *
	 * Called by ServerRequest
	 *
	 * param - options : hash of options, must contain:
	 * 			serverReqElem : elem containing content
	 *
	 * returns 1 if ok, or 0 if something missing in which case another callback will be scheduled
	 ************************************************************************************************/
	this.LoginConfirm = function(options) {
		var elem = options.serverReqElem;
		// Was this sucessful?
		if(elem == null) {
			this.status = LOGINFAIL;
		} else {
			// Get file list if returned
			var content = "";
			var folderElem = document.getElementById('pJSData');
			if(folderElem != null) {
				content = folderElem.innerHTML;
			}
			
			// Replace all 'var ' so that global variables are affected
			content = content.replace(/^var /g, "");
			eval(content);
			
			if(pUser == "guest") {
				this.status = LOGINFAIL;
			} else {
				this.status = LOGGEDIN;
			}
			this.UpdateStatus();
			
			if(this.status == LOGGEDIN && this.reloadOnLogin == 1) {
				// Reload page on login
				location.reload(1);
			}
		}
		
		// Callback to say logged in
		if(this.callback != null) this.callback(this.status, this.login.username);
		
		this.UpdateScreen();
		
		return 1;
	};
	/*****************************
	 * UpdateStatus - updates the status if logged in to guest
	 ****************************/
	this.UpdateStatus = function() {
		if(this.status != LOGGEDIN) return;
		if(this.login.username == "guest") this.status = LOGGEDOUT;
	}
	/*****************************
	 * ScreenCreateAccount - called when create account clicked
	 ****************************/
	this.ScreenCreateAccount = function() {
		this.loginform = new Packages.Form.Form({
			type: "Form",
			object: this.login,
			submit: this.CreateAccountSubmit.bind(this),
			submittext: "Create " + (this.accountLogon == 1 ? "Account" : "User"),
			idprefix: "loginform",
			items: [
				{
					type: "Label",
					label: "Create a new account" + (this.title != null ? " at " + this.title : "")
				},
				{
					type: "Text",
					name: "Name",
					value: this.login.name,
					id: "name",
					required: 1
				},
				{
					type: "Text",
					name: "Email",
					value: this.login.email,
					id: "email",
					required: 1
				},
				{
					type: "Text",
					name: "Password",
					value: "",
					id: "password",
					required: 1
				},
				{
					type: "Text",
					name: "Confirm Password",
					value: "",
					id: "confirmpassword",
					required: 1
				}
			]
		});
		this.login.username = "User";
		var html = this.loginform.MakeForm();
		html += "<button onclick=\"" + this.textVar + ".UpdateScreen(" + LOGGEDOUT + ")" + "\">Close<\/button>";;
		return html;
	};
	/*****************************
	 * CreateAccountSubmit - called when when create account form submitted
	 ****************************/
	this.CreateAccountSubmit = function() {
		// Ensure passwords match
		if(this.login.password != this.login.confirmpassword) {
			this.UpdateScreen(LOGINCREATE, "Passwords did not match");
			return;
		}
		
		if(this.accountLogon == 1) {
			// Create account
			this.serverRequest = new Packages.Library.ServerRequest();
			this.serverRequest.ServerRequest({
				page: this.parenturl + ".admin",
				query: {
					createAutomatedAccount: this.signupTemplate,
					createName: this.login.name,
					createPassword: this.login.password,
					createEmail: this.login.email,
					"req-ignorefile": 1
				},
				callback: this.CreateAccountConfirm.bind(this)
			});
		} else {
			// Create user
			this.serverRequest = new Packages.Library.ServerRequest();
			this.serverRequest.ServerRequest({
				page: this.parenturl + ".admin",
				query: {
					createAutomatedUser: this.signupTemplate,
					createName: this.login.name,
					createPassword: this.login.password,
					createEmail: this.login.email,
					"req-ignorefile": 1
				},
				callback: this.CreateAccountConfirm.bind(this)
			});
		}
	};
	/*****************************
	 * CreateAccountConfirm - called when server calls back from create account
	 ****************************/
	this.CreateAccountConfirm = function() {
		// Try to log in now
		if(this.accountLogon == 1) {
			this.login.username = "User";
		} else {
			this.login.username = this.login.name;
		}
		// Attempt a login in 1 second (give server a chance)
		setTimeout(this.LoginSubmit.bind(this), 1000);
	};
	/*****************************
	 * LogOut - called when log out clicked
	 ****************************/
	this.LogOut = function() {
		this.status = LOGGEDOUT;
		this.login.password = "";
		
		// Connect to server and send log out message
		this.serverRequest = new Packages.Library.ServerRequest();
		this.serverRequest.ServerRequest({
			page: this.parenturl + ".admin",
			query: {
				"req-logoff": 1
			},
			callback: this.LogOutConfirm.bind(this)
		});
		
		this.UpdateScreen();
	};
	/*****************************
	 * LogOutConfirm - called when server confirms log out
	 ****************************/
	this.LogOutConfirm = function() {
		if(this.reloadOnLogin == 1) {
			// Reload page on logout - GET request, not a POST (strip anchor)
			window.location.assign(window.location.href.replace(/#.+/, ""));
		}
	}
};

/*************************
 * SetLogin - initialises singleton with login data
 *
 * param - options : hash of options, must contain:
 * 				username : username
 ************************/
Packages.Library.$.SetLogin = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SetLogin",
		options: options,
		specification: {
			username: {type: "string", required: 1}
		}
	})) return;
	
	var accountObject = GetSingleton(Packages.Library, "Accounts");
	accountObject.login.username = options.username;
	accountObject.parenturl = Packages.Library.$.GetMasterpath({});
	accountObject.status = 1;
	accountObject.genericname = options.username;
	accountObject.UpdateStatus();
};
/*************************
 * CreateAccountForm - calls in to singleton to get login form
 *
 * param - options : hash of options, may contain:
 * 			accountLogon : 1 account logon, 0 (default) user logon
 * 			title : site title to display
 * 			callback : callback to run once logged in
 * 			templateUser : user to use as a template when signing up
 * 			reloadOnLogin : 1 reload the page on login, 0 (default) don't
 * 			signupTemplate : the template user / account to base this on
 * 			singleFieldLogin : 1 display login as a single field, 0 (default) don't
 * 			wrap : 1 wrap in div with id, 0 don't (for callback from nodelive only)
 *
 * returns the HTML markup for the form
 ************************/
Packages.Library.$.CreateAccountForm = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateAccountForm",
		options: options,
		specification: {
			accountLogon: {type: "number"},
			title: {type: "string"},
			callback: {type: "function"},
			templateUser: {type: "string"},
			reloadOnLogin: {type: "number"},
			signupTemplate: {type: "string"},
			singleFieldLogin: {type: "boolean"},
			wrap: {type: "boolean"}
		}
	})) return null;
	
	if(options == null) options = {};
	var accountObject = GetSingleton(Packages.Library, "Accounts");
	
	for(var key in options) {
		if(options[key] == null) continue;
		accountObject[key] = options[key];
	}
	
	var nodeLiveData = Packages.Library.$.NodeStoreData({data: options, type: "accountform"});
	
	var html = accountObject.UpdateScreen();
	
	if(options.wrap != 0) {
		html = "<div id='account_signform' class='account_signform" + nodeLiveData + "'>" + html + "<\/div>";
	}
	return html;
};

/*********************************************************************
 * AccountFormNodeLive - Node Live Callback, used to perform live rendering of
 * Account Form, where placeholder created by Node
 ********************************************************************/
Packages.Library.$.AccountFormNodeLive = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.AccountFormNodeLive",
		options: options,
		specification: {}
	})) return;
	if(options.type != "accountform") return;
	options.properties.wrap = 0; // Don't wrap this time
	options.elem.innerHTML = Packages.Library.$.CreateAccountForm(options.properties);
};
// Subscriber in Library.Init

/*************************
 * GetAccountData - calls in to singleton and returns a hash of
 * information about the current account
 *
 * returns hash of data as follow or empty hash if not logged in:
 * 		username : the username for the current user
 * 		password : the password for the current user
 * 		status : login status
 * 		url : url to send requests to
 * 		folders : list of folders available to this user
 ************************/
Packages.Library.$.GetAccountData = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetAccountData",
		options: options,
		specification: {}
	})) return null;
	
	var accountObject = GetSingleton(Packages.Library, "Accounts");
	if(accountObject.status != 1) return {};
	return {
		username: accountObject.login.username,
		password: accountObject.login.password,
		status: accountObject.status,
		url: accountObject.url,
		folders: accountObject.folders
	}
};

/*************************************************************************************************
 * GetPermissionOptions - [recursive] Gets the options for the list of permissions
 * Also highlights those already selected
 *
 * param - options : hash of options, may contain:
 * 				folder : list of available permissions
 * 				path : the permission path
 * 				vpermissions : permissions this user has
 * 				showall : 1 show all permissions, 0 (default) show only those set to be listed
 *
 * returns an array of options for a select box
 ************************************************************************************************/
Packages.Library.$.GetPermissionOptions = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPermissionOptions",
		options: options,
		specification: {
			folder: {type: "array"},
			path: {type: "string"},
			vpermissions: {type: "array"},
			showall: {type: "boolean"}
		}
	})) return null;
	
	if(options == null) options = {};
	if(options.folder == null) options.folder = qPermissions;
	if(options.path == null) options.path = "";
	if(options.vpermissions == null) options.vpermissions = [];
	if(options.showall == null) options.showall = 0;
	var permissions = [];
	for(var i = 0; i < options.folder.length; i++) {
		if(options.folder[i].type == 'file') {
			var filename = options.folder[i].name.replace(/\.permission$/, "");
			var selected = null;
			for(var j = 0; j < options.vpermissions.length; j++) {
				if(options.vpermissions[j] == options.path + filename) selected = 1;
			}
			
			// Skip non listable permissions
			if(!options.showall && options.folder[i].params.list != "list") continue;
			
			permissions.push({
				name: options.folder[i].params.name,
				description: options.folder[i].params.description,
				value: options.path + filename,
				selected: selected
			});
		} else {
			permissions = permissions.concat(Packages.Library.$.GetPermissionOptions({
				folder: options.folder[i].subfolders,
				path: options.path + options.folder[i].name + ".",
				vpermission: options.vpermissions,
				showall: options.showall
			}));
		}
	}
	return permissions;
};

/*********************************************************************
 * IsPermission - Finds if the specified permissions exists for the current user
 *
 * This is to aid the user interface only, server side checks are also performed
 *
 * param - options : hash of options, must include
 * 			May include:
 * 				permission : the permission required
 *
 * returns 1 if the permission is allowed, otherwise 0
 ********************************************************************/
Packages.Library.$.IsPermission = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.IsPermission",
		options: options,
		specification: {
			permission: {type: "string"}
		}
	})) return 0;
	if(options.permission == null) return 1;
	if(typeof(pPermissions) == "undefined" || pPermissions == null) return 0;
	for(var i = 0; i < pPermissions.length; i++){
		if(pPermissions[i] == options.permission || pPermissions[i] == "ADMIN") return 1;
	}
	return 0;
};

/*********************************************************************
 * GetUsers - returns an array of all registered usernames
 *
 * returns an array of all usernames, or null if inaccessible
 ********************************************************************/
Packages.Library.$.GetUsers = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetUsers",
		options: options,
		specification: {}
	})) return null;
	
	var folder = Packages.Library.$.GetSubFolder({
		container: pFolders,
		offset: "System/Access"
	});
	
	if(folder == null) return null;
	
	if(Packages.Library.$v.testing == 1) {
		folder = Packages.Library.$.GetTestSampleFolderList({});
	}
	
	var users = [];
	for(var i = 0; i < folder.length; i++) {
		var username = folder[i].name;
		
		// Strip .username.user
		if(!username.match(/\.(.+?)\.user/)) continue;
		username = RegExp.$1;
		
		users.push(username);
	}
	
	return users;
}

/********************************************************************
 * GetGlobalReplacementUsername - Subscriber Callback - GetGlobalReplacements
 *
 * Returns the username for the currently logged on user
 *******************************************************************/
Packages.Library.$.GetGlobalReplacementUsername = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetGlobalReplacementUsername",
		options: options,
		specification: {}
	})) return null;
	
    var accountObject = GetSingleton(Packages.Library, "Accounts");
	if(accountObject.status != 1) return {
		key: "username",
		value: "guest"
	};
	return {
		key: "username",
		value: accountObject.login.username
	};
};

/********************************************************************
 * GetPasswordForUser - gets the password for the specified user
 *
 * Will only work if the currently logged in user has the permission
 * to view user files
 *
 * param - options : hash of options, must contain:
 * 				username : the username to fetch the password for
 *
 * return - password : the password for this user or null
 * if not found or not accessible
 *******************************************************************/
Packages.Library.$.GetPasswordForUser = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPasswordForUser",
		options: options,
		specification: {
			username: {type: "string", required: 1}
		}
	})) return null;
	
	var username = options.username;
	
	var response = Packages.Library.$.GetFile({filepath: Packages.Library.$.GetMasterpath({}) + "System/Access/." + username + ".user", plain: 1});
	// You may get blacklisted if you keep doing this - but thats not a bad thing
	if(response.status == 404) return null;
	
	var content = response.content;
	var value = Packages.Library.$.GetAttribute({text: content, attr: "pass"});
	return value;
};

/********************************************************************
 * GetSingleLogonForUser - see GetPasswordForUser
 *
 * param - options : hash of options, must contain:
 * 			username : the username to fetch the password for
 *
 * return - singleLogon : single logon in the form
 * 				username-password
 * 			or null if not found or inaccessible
 *******************************************************************/
Packages.Library.$.GetSingleLogonForUser = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetSingleLogonForUser",
		options: options,
		specification: {
			username: {type: "string", required: 1}
		}
	})) return null;
	
	var password = Packages.Library.$.GetPasswordForUser({username: options.username});
	return options.username + "-" + password;
};/**********************************
 * CSV - controls a CSV file by describing each column
 *
 * Saves / Loads settings to an XML file
 *
 * Other classes at this level provide methods for viewing data
 *
 * Primarily this class is concerned with providing API type methods
 * for the CSV data, and holding the data in its CSV object
 *
 * Once instantiated, one of the LoadData methods must be executed
 * to get the data, or SetCSVFile must be used if creating a new XML file
 *
 * The entire csv file may be loaded into this.csvdata, however, only if
 * the user has view permissions on the CSV data. Otherwise a request for
 * just the CSV data they can see will be made.
 *
 * Do not assume the csvdata is a directly copy of the actual CSV file
 *
 * this.csvComplete will be 1 only if the entire csv file is loaded
 *
 * The CSV file path is stored only relative to itself, however a basepath
 * may be included to offset this. By default it will use:
 * 	<basepath>path/file.csv
 *
 * Internally the rowid is 1 based, however the csvdata array extracts the
 * header row, and so is 0 based
 *
 * rowId throughout the JavaScript is 1 based rowId (and is the first value of csvdata)
 *
 * absRowId is the 0 based rowId, this is the id of the row in csvdata
 *
 * 	absRowId = rowId - 1
 * 
 * primary key values refer to the primary key column - this is used for all
 * client - server communication. The primary key is whatever value the user
 * chooses for a field
 *
 * param - settings : hash of settings, containing (optionally)
 * 			basepath : path to place before CSV file
 * 			preloadFilters : 1 (default) loads filters from cookies or query string, 0 ignores
 * 			viewConditions : array of conditions to be added to every viewdef conditions
 *********************************/
Package("Library.CSV").CSV = function(settings) {
	this.settings = settings;
	if(this.settings == null) this.settings = {};
	if(this.settings.basepath == null) this.settings.basepath = "";
	this.textVar = GetTextRef(this);
	this.callbacks = {};
	this.initialViewRow = 1;
	this.interactive = 1;
	this.forceReload = 0;
	// Create 'blank' data
	this.data = {
		csvfile: "",
		columndefs: [],
		viewdefs: [],
		drilldown: [],
		text: {
			filterby: "Filter By",
			sortby: "Order By",
			groupby: "Group By",
			search: "Search",
			compare: "Compare",
			filterMore: "More...",
			groupnone: "No grouping",
			requiredFieldText: "This field is required"
		}
	};
	
	this.csvpath = Packages.Library.$v.GlobalQueries.gq_appfile;
	if(this.csvpath != null) this.csvpath = Packages.Library.$.GetMasterpath({}) + this.csvpath + "/";
	this.csvfile = ""; // Will be assigned to actual cvs file used (may be overridden)
	
	// Create a unique ID prefix for all HTML elements
	Packages.Library.CSV.$v.ObjectCounter ++;
	this.idPrefix = "xcsv_o" + Packages.Library.CSV.$v.ObjectCounter + "_";
	
	// Generic cache, for use by anything
	this.cache = {};
	
	// Store received messages - to be processed by whoever needs them
	this.messages = [];
	
	// Log state
	this.ready = 0;
	
	// Instatiate sub objects that do specific tasks
	this.View = new Packages.Library.CSV.View(this);
	this.XMLRPC = new Packages.Library.CSV.XMLRPC(this);
	
	// Load all controls
	this.controls = {};
	for(var controlclass in Packages.Library.CSV.Controls) {
		if(controlclass.match(/^\$/)) continue;
		var control = new Packages.Library.CSV.Controls[controlclass](this);
		this.controls[control.GetDetails().name] = control;
	}
    /*********************************************************************
	 * LoadDataFromFile - requests the XML file from the server
	 *
	 * param - xmlFile : the path to an XML file containing the definitions for this object
	 * param - callback : callback to execute once data loaded and ready for actions
	 ********************************************************************/
	this.LoadDataFromFile = function(xmlFile, callback) {
		this.xmlFile = xmlFile;
		this.callbacks.onReady = callback;
		
		// Determine xmlFilePath
		var offset = pOffset;
		if(offset.length > 1) offset += "/";
		this.xmlFilePath = offset + this.xmlFile;
		
		Packages.Library.$.LogInfo({mesg: "Loading XCSV file [" + this.xmlFile + "]", location: "XCSV CSV.LoadDataFromFile", type: "Tracking", level: 8});
		
		// Request XML file from server
		this.xmlfileloader = new Packages.Library.DynamicLoad({
			callback: this.LoadDataFromFileCallback.bind(this)
		});
		this.xmlfileloader.Request([{filepath: this.xmlFile, mode: "LT_TEXT"}]);
	};
	/*********************************************************************
	 * LoadDataFromFileCallback - called by DynamicLoad once XML file loaded
	 *
	 * Requests the CSV file if present
	 ********************************************************************/
	this.LoadDataFromFileCallback = function() {
		this.xmlfilecontent = this.xmlfileloader.GetFileContent();
		
		// Get the actual data for the object
		this.LoadDataFromXMLContent(this.xmlfilecontent, this.callbacks.onReady);
	};
	/*********************************************************************
	 * LoadDataFromXMLContent - loads the data from the XML file content
	 *
	 * param - xmlfilecontent : xml file content to load from
	 * param - callback : callback to execute when ready
	 ********************************************************************/
	this.LoadDataFromXMLContent = function(xmlfilecontent, callback) {
		if(xmlfilecontent == "") {
			Packages.Library.$.LogInfo({mesg: "XCSV blank", location: "XCSV CSV.LoadDataFromFileCallback", type: "Warning", level: 5});
		}
		
		if(this.xmlFile == null) this.xmlFile = pOffset + '/' + pFileName;
		if(this.xmlFilePath == null) this.xmlFilePath = this.xmlFile;
		this.safeXCSVName = this.SafeEncodeText(this.xmlFile);
		this.xmlfilecontent = xmlfilecontent;
		var xmldefs = Packages.Library.$.ReadXML({xml: this.xmlfilecontent});
		var data = null;
		if(xmldefs.length > 0) {
			data = Packages.Library.$.ConvertXMLDefToJS({xmldef: xmldefs[0]});
		}
		if(data == null || Packages.Library.$.GetKeys({object: data}).length == 0) {
			// Blank XML file - default defined at top already
			// Upgrade as necessary
			this.UpgradeXCSV(this.data);
			// Fire callback
			if(callback != null) callback();
			return;
		}
		
		// Upgrade as necessary
		this.UpgradeXCSV(data);
		
		// Store this XCSV file object in the loaded objects area, only if it isn't already there
		if(Packages.Library.CSV.$o.CSV[this.safeXCSVName] == null) {
			Packages.Library.CSV.$o.CSV[this.safeXCSVName] = this;
		}
		
		// Setup messenger listener for this XCSV file
		Packages.Library.$o.General.messenger.SetReciever({
			recipient: "XCSV_" + this.safeXCSVName,
			callback: this.ReceiveMessages.bind(this)
		});
		
		this.data = data;
		
		this.callbacks.onReady = callback;
        
		this.LoadCSVFile(this.data.csvfile, callback);
	};
    /*********************************************************************
	 * LoadCSVFile - loads a different CSV file, will use same XML def
	 *
	 * param - csvfile : csv file to load
	 * param - callback : callback to execute when ready
	 ********************************************************************/
	this.LoadCSVFile = function(csvfile, callback) {
		if(csvfile == "") {
			// Fire callback now
			if(callback != null) callback();
			return;
		}
		if(this.csvpath != null) {
			csvfile = this.csvpath + csvfile;
			this.basecsvfile = csvfile;
			this.abscsvfile = csvfile;
		} else {
			this.basecsvfile = this.settings.basepath + csvfile;
			this.abscsvfile = pOffset + this.settings.basepath + "/" + csvfile;
		}
		this.csvfile = csvfile; // Internal name
		this.callbacks.onReady = callback;
        
		// Request the CSV file from the server
		this.csvfileloader = new Packages.Library.DynamicLoad({
			callback: this.CSVLoadedCallback.bind(this)
		});
		if(this.settings.basepath == null) this.settings.basepath = "";
		this.csvfileloader.Request([{
			filepath: this.basecsvfile,
			mode: "LT_TEXT"
		}]);
	};
    /*********************************************************************
	 * CSVLoadedCallback - loads CSV data into object, and initialise types
	 ********************************************************************/
	this.CSVLoadedCallback = function() {
        this.csvfilecontent = this.csvfileloader.GetFileContent();
		
		// Does this csvfilecontent contain our CSV file, or a 404 (signifying we do not have view permissions?)
		if(this.csvfilecontent.match(/^\/\/404/)) {
			if(this.csvpath != null) {
				this.csvfilecontent = " ";
			} else {
				this.LoadPartialCSV();
				return;
			}
		}
		
		// Get array of data
		this.csvdata = Packages.Library.$.GetArrayFromCSV({csvtext: this.csvfilecontent});
		
		// Check we have csvdata ... this may be because the file has moved, but it is not good.
		
		if(this.csvdata != null) {
			// Extract header row
			this.headerrow = this.csvdata.shift();
			
			// We have loaded the entire CSV file
			this.csvComplete = 1;
		}
		
		// Start the reload checker - note, does not run in partial CSV mode
		if(Packages.Library.$.GetQuery({attr: "autoReload"}) != 0) this.CSVCheckReloader();
		
		this.CSVLoaded();
	};
	/*********************************************************************
	 * LoadPartialCSV - loads the part of the CSV file accessible to the
	 * current user
	 ********************************************************************/
	this.LoadPartialCSV = function() {
		var methods = [];
		methods.push({
			classname: "XCSV",
			method: "GetUserRows",
			params: [this.xmlFilePath],
			callback: this.LoadPartialCSVCallback.bind(this)
		});
		Packages.Library.$.CreateXMLRPCMethodCall({methods: methods});
    };
	/*********************************************************************
	 * LoadPartialCSVCallback - callback after LoadPartialCSV
	 *
	 * param - response : the array of response values from the server
	 ********************************************************************/
	this.LoadPartialCSVCallback = function(response) {
		if(response == null || response.length == 0) {
			// Bad response, file missing?
			
			Packages.Library.$.LogInfo({
				mesg: "The CSV file did not load",
				location: "CSV.LoadPartialCSVCallback",
				type: "Error",
				level: 1
			});
			
			// Do the best you can without a CSV file
			this.csvdata = [];
			this.CSVLoaded();
			
			return;
		}
		
		var rows = response[0];
		if(rows == null || rows[0] == null) return; // Invalid
		
		// Build up csvdata
		
		this.csvdata = [];
		
		// Copy in the data into csvdata
		for(var i = 0; i < rows.length; i++) {
			this.csvdata[i] = [i + 1]; // Store rowid
			for(var j = 0; j < rows[i].length; j++) {
				this.csvdata[i][j + 1] = rows[i][j];
			}
		}
		
		this.CSVLoaded();
    };
	/*********************************************************************
	 * CSVLoaded - called after the CSV is loaded (or part loaded)
	 ********************************************************************/
	this.CSVLoaded = function() {
		// Check for preset settings
		this.GetInitialSettings();
		
		// Initialise everything
		this.InitialiseAllDefs(this.FireCallback.bind(this));
    };
	/*********************************************************************
	 * FireCallback - after everything has loaded, fires the callback
	 ********************************************************************/
	this.FireCallback = function() {
		// Fire callback
		this.ready = 1;
		if(this.callbacks.onReady != null) this.callbacks.onReady();
    };
	/*********************************************************************
	 * GetXMLSettings - saves the data to XML and returns the XML
	 *
	 * returns the XML settings
	 ********************************************************************/
	this.GetXMLSettings = function() {
		var xmldef = Packages.Library.$.ConvertJSToXMLDef({object: this.data});
		return Packages.Library.$.WriteXML({xmldefs: [xmldef]});
	};
	/*********************************************************************
	 * GetVariations - Gets all of the variations on this column
	 *
	 * param - column : column to sort by
	 * param - filterby : (optional) filterby to apply before getting variations
	 *
	 * returns the hash of variations - each variation is of the form:
	 *      text : the variation
	 *      count : how many of this variation there are
	 *      encoded : safe name for this variation
	 ********************************************************************/
	this.GetVariations = function(columnid, filterby) {
		// Try and find a columndef for this column
		var columndef = Packages.Library.$.FindArrayItem({array: this.data.columndefs, path: "id", value: columnid});
		if(columndef == null) columndef = {text_filter_none: "None", text_filter_some: ""};
		
		var array = this.csvdata;
		if(filterby != null) array = this.GetFilteredArray(array, filterby);
		
		var variations = {};
		// Iterate through each row, looking for variations
        for(var i = 0; i < array.length; i++) {
			var rowdata = array[i];
			if(rowdata == null) continue;
            var currentcell = rowdata[columnid];
            if(currentcell == null) continue;
			if(typeof(currentcell) == "number") currentcell = "" + currentcell; // Force to string
			
			// A cell may contain a comma separated list of filters
			var subfilters = currentcell.split(",");
			for(var j = 0; j < subfilters.length; j++) {
				// For each filter, see if we've seen it before, if so increment our count.
				// If not, add it as a new filter
				var currentfilter = subfilters[j];
				var encoded = this.SafeEncodeText(currentfilter);
				if(currentfilter == "") {
					currentfilter = columndef.text_filter_none;
				} else {
					if(columndef.text_filter_some != null && columndef.text_filter_some != "") {
						currentfilter = columndef.text_filter_some;
						encoded = "xcsv_somefield";
					}
				}
				var variation = variations[encoded];
				if(variation == null) variation = {count: 0};
				
				// Get formatted text
				var formattedText = currentfilter;
				if(columndef.filterformat == 1) formattedText = this.View.GetCellView(columndef, currentfilter);
				
				variations[encoded] = {text: formattedText, count: variation.count + 1, encoded: encoded};
            }
        }
        return variations;
    };
	
	/*********************************************************************
	 * GetSortedArray - Sorts the data by the current this.sortby
	 *
	 * If the sort column contains cells with multiple filters, these rows will
	 * appear multiple times in their correct place in the sort
	 *
	 * param - array : optional array to filter, if not specified use this.csvdata
	 * param - sortby : column number to sort by
	 *
	 * returns the sorted array
	 ********************************************************************/
	this.GetSortedArray = function(array, sortby) {
		if(array == null) array = this.csvdata;
		
		if(sortby == null) return array;
		
		var variations = this.GetVariations(sortby);
        var tosort = [];
        for(var item in variations) {
            // Use standard normaliser to make numbers more rounded etc
			standard = Packages.Library.$.TidyValueForEval({value: variations[item].text});
			
			tosort.push({
				encoded: item,
				val: standard,
				raw: variations[item].text
			});
        }
		
		// Call JS sort method on array of strings
		var sorter = function(a, b) {
			if(a.val == b.val) return 0;
			// Empty values go last
			if(a.raw == null || a.raw == "") return 1;
			if(b.raw == null || b.raw == "") return 0;
			if(parseFloat(a.val) == a.val && parseFloat(b.val) == b.val) return parseFloat(a.val) > parseFloat(b.val) ? 1 : -1;
			try {
				return a.val > b.val;
			} catch(e) {
				return 1;
			}
		}
        tosort.sort(sorter);
		
        var sorted = [];
        for(var i = 0; i < tosort.length; i++) {
            for(var j = 0; j < array.length; j++) {
                var cell = array[j][sortby];
				if(cell == null) continue; // Skip missing cells
				if(typeof(cell) == "number") cell = "" + cell; // Force to string
				
				// Get subfilters in this cell - only sort by first one
				var subfilters = cell.split(",");
				var encoded = this.SafeEncodeText(subfilters[0]);
				if(encoded == tosort[i].encoded) sorted.push(array[j]);
            }
        }
        return sorted;
    };
	
	/*********************************************************************
	 * GetSearchedArray - Searches the current array of data and returns a new
	 * array containing only those rows that contain the search text
	 *
	 * param - array : optional array to filter, if not specified use this.csvdata
	 * param - searchby : string to search by
	 *
	 * returns the searched array
	 ********************************************************************/
	this.GetSearchedArray = function(array, searchby) {
		if(array == null) array = this.csvdata;
		if(searchby == "") return array;
		
		var searched = [];
        for(var y = 0; y < array.length; y++) {
            var show = 0; // Records whether this row should be shown or not
            for(var x = 0; x < array[y].length; x++) {
                // Try and find a mention of the current search in this cell
				if(array[y][x].match(new RegExp(searchby, "i"))) show = 1;
            }
            if(show) {
                searched.push(array[y]);
            }
        }
        return searched;
    };
	/*********************************************************************
	 * GetComparesArray - gets an array containing only the elements chosen
	 * to be compared
	 *
	 * param - compareRows : array of row ids to compare
	 *
	 * returns the compares array
	 ********************************************************************/
	this.GetComparesArray = function(compareRows) {
		var array = this.csvdata;
		
		var compares = [];
        for(var y = 0; y < array.length; y++) {
            if(Packages.Library.$.Contains({array: compareRows, item: array[y][0]})) {
                compares.push(array[y]);
            }
        }
        return compares;
    };
	
	/*********************************************************************
	 * GetFilteredArray - Filters the data by filterby and returns
	 * the filtered array
	 *
	 * param - array : optional array to filter, if not specified use this.csvdata
	 * param - filterby : array of filter def hashes for each columnid, of the form
	 * 				<encoded> = 1
	 * 			Where <endoded> is the SafeEncodeText version of the cell value
	 *
	 * returns the filtered array
	 ********************************************************************/
	this.GetFilteredArray = function(array, filterby) {
		if(array == null) array = this.csvdata;
		
		if(filterby == null) return array;
		
		var filtered = [];
        for(var y = 0; y < array.length; y++) {
            var show = 1; // Records whether this row should be shown or not
            for(var x = 0; x < array[y].length; x++) {
				// Ensure we have some filters defined
                if(filterby[x] != null && Packages.Library.$.GetKeys({object: filterby[x]}).length != 0) {
					var currentcell = array[y][x];
					var subfilters = currentcell.split(",");
					var matchedFilter = 0; // Records whether this filter was found in the array of filters
					for(j = 0; j < subfilters.length; j++) {
						// Get the specific filter from the comma separated list
						var encoded = this.SafeEncodeText(subfilters[j]);
						if(filterby[x][encoded] != null) matchedFilter = 1;
						if(subfilters[j] != "" && filterby[x]["xcsv_somefield"] == 1) matchedFilter = 1;
					}
					if(matchedFilter == 0) show = 0;
                }
            }
            if(show) {
                filtered.push(array[y]);
            }
        }
        return filtered;
    };
	
	/*********************************************************************
	 * ControlAlterArray - allows all controls to alter array
	 *
	 * param - viewType : type of view def
	 ********************************************************************/
	this.ControlAlterArray = function(viewType) {
		
		// It is important that controls can order themselves to ensure that
		// controls are used in a sensible order, Eg paging after filtering
		
		// First determine the order number for each control
		
		var ordering = [];
		
		for(var controlname in this.controls) {
			if(this.controls[controlname].ControlAlterArray != null) {
				// Get viewTypes supported
				var details = this.controls[controlname].GetDetails();
				var viewTypes = details.viewTypes;
				if(viewTypes[viewType] == 1) {
					// viewType supported
					
					if(details.order == null) details.order = 0;
					if(ordering[details.order] == null) ordering[details.order] = {}; // Empty hash
					
					ordering[details.order][controlname] = details;
				}
			}
		}
		
		// Now apply the controls in order
		var array = this.csvdata;
		for(var order = 0; order < ordering.length; order ++) {
			if(ordering[order] == null) continue;
			for(var controlname in ordering[order]) {
				array = this.controls[controlname].ControlAlterArray(array, viewType);
			}
		}
		
		return array;
	}
	
	/*********************************************************************
	 * GetControlInitialSettings - calls each control after init complete
	 * to initialise themselves
	 ********************************************************************/
	this.GetControlInitialSettings = function() {
		for(var controlname in this.controls) {
			if(this.controls[controlname].GetControlInitialSettings != null) {
				this.controls[controlname].GetControlInitialSettings();
			}
		}
	}
	
	/*********************************************************************
	 * GetInitialSettings - reads the initial settings from query string
	 ********************************************************************/
	this.GetInitialSettings = function() {
		// Are we using this feature?
		if(this.settings.preloadFilters == 0) return;
		
		// Check for a selected id field
		var selectedId = Packages.Library.$.GetQuery({attr: "xcsvid"});
		var selectedViewRef = Packages.Library.$.GetQuery({attr: "xcsvviewref"});
		if(selectedId != null) {
			this.View.current.initialviewref = selectedViewRef;
			this.View.current.rowId = selectedId;
		}
		
		// Call InitialiseSettings on all controls
		this.GetControlInitialSettings();
	};
	/*********************************************************************
	 * SafeEncodeText - encodes the text to be alphanumerics and underscores
	 * only so it is safe to use as a key
	 *
	 * param - text : the text to encode
	 *
	 * returns the safe string
	 ********************************************************************/
	this.SafeEncodeText = function(text) {
		if(text == "") text = "emptyfield";
		
		// Remove non alpha numerics
		return "_" + text.replace(/[^A-Z|a-z|0-9]/g, '_');
	};
	/*********************************************************************
	 * GetSafeXCSVName - gets a safe encoded name for this XCSV file
	 *
	 * returns the safe string
	 ********************************************************************/
	this.GetSafeXCSVName = function() {
		var csvfile = this.csvfile;
		var paths = csvfile.split(/\//);
		csvfile = paths[paths.length - 1];
		
		return "xcsv_" + this.SafeEncodeText(csvfile);
	};
	/*********************************************************************
	 * GetViewDefOptions - gets the available view defs in option format
	 * suitable to be fed into a form item
	 *
	 * returns the options
	 ********************************************************************/
	this.GetViewDefOptions = function() {
		var viewoptions = [];
		for(var i = 0; i < this.data.viewdefs.length; i++) {
			var viewdef = this.data.viewdefs[i];
			viewoptions.push ({
				name: viewdef.refcode,
				value: viewdef.refcode
			});
		}
		return viewoptions;
	};
	/*********************************************************************
	 * GetWrapperDefOptions - gets the available wrapper defs in option format
	 * suitable to be fed into a form item
	 *
	 * returns the options
	 ********************************************************************/
	this.GetWrapperDefOptions = function() {
		var wrapperoptions = [];
		for(var i = 0; i < this.data.wrapperdefs.length; i++) {
			var wrapperdef = this.data.wrapperdefs[i];
			wrapperoptions.push ({
				name: wrapperdef.refcode,
				value: wrapperdef.refcode
			});
		}
		return wrapperoptions;
	};
	/*********************************************************************
	 * GetColumnDefOptions - gets the available column defs in option format
	 * suitable to be fed into a form item
	 *
	 * returns the options
	 ********************************************************************/
	this.GetColumnDefOptions = function() {
		var columnoptions = [];
        for(var i = 0; i < this.data.columndefs.length; i++) {
            columnoptions.push({
                name: this.data.columndefs[i].refcode,
                value: this.data.columndefs[i].refcode
            });
        }
		return columnoptions;
	};
	/*********************************************************************
	 * GetPrimaryKey - gets the primary key for this row
	 *
	 * param - rowid : row id
	 *
	 * returns the primary key or 0 if no primary key column
	 ********************************************************************/
	this.GetPrimaryKey = function(rowid) {
		if(rowid == null) return 0;
		// Get column def
		var columndef = this.GetPrimaryKeyColumnDef();
		if(columndef == null) return 0;
		
		return this.GetRowData(rowid)[columndef.id];
	};
	/*********************************************************************
	 * GetRowName - gets the default name column value for the specified row
	 *
	 * param - rowid : absolute row id
	 *
	 * returns the name
	 ********************************************************************/
	this.GetRowName = function(rowid) {
		if(rowid == null) return "Unknown Item Name";
		var defaultName = this.data.defaultName;
		
		// Get column def
		var columndef = Packages.Library.$.FindArrayItem({array: this.data.columndefs, path: "refcode", value: defaultName});
		if(columndef == null) return "";
		
		return this.GetRowData(rowid)[columndef.id];
	};
	/*********************************************************************
	 * GetRowIdForPrimaryKey - gets the actual rowid from the primary key
	 * Searches for a row with this primary key and returns the rowid
	 *
	 * param - primarykey : primary key rowid
	 *
	 * returns the rowid or null if not found
	 ********************************************************************/
	this.GetRowIdForPrimaryKey = function(primarykey) {
		if(primarykey == null) return null;
		
		// Get columndef for the primary key
		var columndef = this.GetPrimaryKeyColumnDef();
		if(columndef == null) return null;
		
		var rowdata = Packages.Library.$.FindArrayItem({array: this.csvdata, path: Packages.Library.$.ToNumber({str: columndef.id}), value: primarykey});
		if(rowdata == null) return null;
		
		return rowdata[0]; // The rowId
	};
	
	/*********************************************************************
	 * GetFirstUserRow - gets the first row owned by the current user
	 *
	 * returns the rowId or null if not found
	 ********************************************************************/
	this.GetFirstUserRow = function() {
		// Get columndef for the user
		var columndef = this.GetUserColumnDef();
		if(columndef == null) return null;
		
		var rowdata = Packages.Library.$.FindArrayItem({array: this.csvdata, path: Packages.Library.$.ToNumber({str: columndef.id}), value: pUser, inCommas: 1});
		if(rowdata == null) return null;
		
		return rowdata[0]; // The rowId
	};
	
	/*********************************************************************
	 * GetUserColumnDef - gets the user type column
	 *
	 * returns the user columndef or null if not found
	 ********************************************************************/
	this.GetUserColumnDef = function() {
		return Packages.Library.$.FindArrayItem({array: this.data.columndefs, path: "format", value: "User"});
	};
	
	/*********************************************************************
	 * GetPrimaryKeyColumnDef - gets the primary key columndef
	 *
	 * returns the columndef or null if not found
	 ********************************************************************/
	this.GetPrimaryKeyColumnDef = function() {
		var columndef = Packages.Library.$.FindArrayItem({array: this.data.columndefs, path: "format", value: "PrimaryKey"});
		if(columndef == null) return null;
		if(columndef.active == 0) return null;
		return columndef;
	};
	
	/*********************************************************************
	 * GetColumnDefMap - gets a map of all column defs to their ref code
	 *
	 * returns the columndef map
	 ********************************************************************/
	this.GetColumnDefMap = function() {
		var columndefMap = {};
		for(var c = 0; c < this.data.columndefs.length; c++) {
			var columndef = this.data.columndefs[c];
			if(columndef == null) return null;
			if(columndef.active == 0) return null;
			
			columndefMap[columndef.refcode] = columndef;
		}
		return columndefMap;
	};
	
	/*******************************************************************************
	 * GetUserState - gets the state for the current user
	 *
	 * param - rowId : current row
	 * param - dummyrow : (optional) when provided, uses this rather than fetching its own
	 *
	 * Returns user state, see XCSV.h
	 ******************************************************************************/
	this.GetUserState = function(rowId, dummyrow) {
		// Get user columndef
		var userDef = this.GetUserColumnDef();
		
		// Get dummy row if we haven't been provided one
		if(dummyrow == null) dummyrow = this.GetDummyRow(rowId);
		if(dummyrow == null) {
			return 0;
		}
		
		var celldata = dummyrow[userDef.refcode];
		if(celldata == null) celldata = "";
		
		// Determine user state
		var state = 0;
		
		var wrappedCelldata = "," + celldata + ",";
		if(wrappedCelldata.match(new RegExp("," + pUser + ","))) state |= Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_SELFOWNED;
		
		if(state & Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_SELFOWNED) {
			if(userDef.giveupOwnership == 1) state |= Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_GIVEUPABLE;
			if(userDef.ownerDeleteRow  == 1) state |= Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_DELETABLE;
		} else {
			if(userDef.takeOwnership == 1) {
				var owners = celldata.split(/,/);
				if(celldata.length == 0) owners = [];
				if(owners.length < userDef.maxowners) state |= Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_OWNABLE;
			}
		}
		
		return state;
	};
	
	/*********************************************************************
	 * GetRowData - gets the rowdata from the specified row
	 *
	 * param - rowId : row id
	 *
	 * returns the row data or null if not found
	 ********************************************************************/
	this.GetRowData = function(rowId) {
		var absRowId = this.GetAbsoluteRowId(rowId);
		if(absRowId == null) return null;
		
		return this.csvdata[absRowId];
	};
	
	/*********************************************************************
	 * GetAbsoluteRowId - gets the absolute row in the csvdata array from
	 * the rowId
	 *
	 * param - rowId : the row id
	 *
	 * returns the absolute row id or null if not found
	 ********************************************************************/
	this.GetAbsoluteRowId = function(rowId) {
		if(rowId == null) return null;
		return Packages.Library.$.FindArrayItemIndex({array: this.csvdata, path: 0, value: rowId});
	};
	
	/*********************************************************************
	 * GetFieldValue - gets the value of a field in the dummyrow
	 *
	 * param - options : hash of options, must contain:
	 * 			dummyrow : the dummyrow
	 * 			columndef : the current columndef
	 * 		may contain:
	 * 			applyNoneSomeDefaults : 1 (default) apply the none / some defaults, 0 don't
	 * 			asCell : 1 return value as a cell, 0 (default) return as raw data
	 * 			getCellViewOptions : options for GetCellView if asCell = 1
	 *
	 * returns the value
	 ********************************************************************/
	this.GetFieldValue = function(options) {
		var value = options.dummyrow[options.columndef.refcode];
		
		if(options.applyNoneSomeDefaults == 1) {
			if(options.columndef.text_view_none != "" && value == "") value = options.columndef.text_view_none;
			if(options.columndef.text_view_some != "" && value != "") value = options.columndef.text_view_some;
		}
		
		if(options.asCell == 1) {
			value = this.View.GetCellView(options.columndef, value, options.getCellViewOptions);
		}
		
		return value;
	};
	
	/*********************************************************************
	 * GetDummyRow - gets a dummy hash that represents a row
	 *
	 * param - rowId : (optional) absolute row id, if null creates a default dummyrow (used for adding new data)
	 * param - options : hash of options, may contain
	 * 			updateServer - see SetDummyRow, except default is 0
	 *
	 * returns the hash of data where refcode is the key or null if an error occured
	 ********************************************************************/
	this.GetDummyRow = function(rowId, options) {
		if(options == null) options = {};
		var absRowId = this.GetAbsoluteRowId(rowId);
		
		if(absRowId != null) {
			// Check row is within range
			if(this.csvdata[absRowId] == null) return null;
		}
		
		// Cache dummyrows to save processing time,
		if(this.cache.dummyrows == null) this.cache.dummyrows = [];
		if(this.cache.dummyrows[absRowId] != null) return this.cache.dummyrows[absRowId];
		
		// Create dummy object to hold a row
		var dummyrow = {};
		dummyrow.$absRowId = absRowId;
		dummyrow.$rowId = rowId;
		for(var i = 0; i < this.data.columndefs.length; i++) {
			
			var columndef = this.data.columndefs[i];
			var value = null;
			if(absRowId != null) value = this.csvdata[absRowId][columndef.id];
			
			// Ask columndef for a version for GetDummyRow
			if(Packages.Library.CSV.ColumnTypes[columndef.format].$.GetDummyValue != null) {
				value = Packages.Library.CSV.ColumnTypes[columndef.format].$.GetDummyValue(columndef, value, this);
			}
			
			// Check columndef within range
			if(value == null) value = columndef.defaultvalue;
			if(value == null) value = "";
			
			// Active?
			if(columndef.active == 0) value = "";
			
			dummyrow[columndef.refcode] = value;
		}
		
		// Are any fields to be calculated?
		var save = 0;
		var changes = 0;
		var counter = 0; // Prevent infinity being reached by recursive changes
		do {
			changes = 0;
			counter ++;
			for(var i = 0; i < this.data.columndefs.length; i++) {
				var columndef = this.data.columndefs[i];
				// Does the columndef type have a specific generation method?
				if(Packages.Library.CSV.ColumnTypes[columndef.format].$.GetValue != null) {
					var res = Packages.Library.CSV.ColumnTypes[columndef.format].$.GetValue(columndef, this, dummyrow);
					res += ""; // Force string
					if(dummyrow[columndef.refcode] != res) {
						changes = 1;
						save = 1;
						dummyrow[columndef.refcode] = res;
						
						// Update CSV data as well
						if(absRowId != null) this.csvdata[absRowId][columndef.id] = res;
					}
				}
			}
		} while(changes == 1 && counter < 10);
		
		if(save == 1 && counter != 10 && Packages.Library.$.IsPermission({permission: "csv.edit"})) {
			// Save these changes, as long as we have not reached 'infinity'
			// And we have permission to blindly edit the CSV file
			if(options.updateServer == null) options.updateServer = 0;
			// At present, this will NEVER save back to the server - as it is very slow, and results in hundreds of emails
			// this.SetDummyRow(rowId, dummyrow, {validate: 0, updateServer: 0, editOnly: 1});
		}
		
		this.cache.dummyrows[absRowId] = dummyrow;
		
		return dummyrow;
	};
	
	/*********************************************************************
	 * SetDummyRow - updates a row with the fields in dummyrow
	 *
	 * Any 'null' fields will be skipped
	 *
	 * param - rowId : (optional) absolute row id, if null adds a new row
	 * param - dummyrow : dummyrow
	 * param - options : optional hash of options, may include:
	 * 				updateServer : 1 (default) send XMLRPC call to server to update, 0 don't
	 * 				validate : 0 will not validate the field, 1 (default) will
	 * 				editOnly : 1 will only allow edit, 0 can either edit or add
	 ********************************************************************/
	this.SetDummyRow = function(rowId, dummyrow, options) {
		var absRowId = this.GetAbsoluteRowId(rowId);
		if(options == null) options = {};
		
		var addrow = 0;
		var rowcopy;
		if(absRowId != null) {
			// Check row is within range
			if(this.csvdata[absRowId] == null) return;
			rowcopy = Packages.Library.$.Clone({oldObj: this.csvdata[absRowId]});
		} else {
			// Add new row
			if(options.editOnly == 1) return; // Do not add
			addrow = 1;
			absRowId = this.csvdata.length;
			if(this.data.singleRow == 1) {
				// Only a single row is allowed in the table, so the add action replaces it
				absRowId = 0;
			}
			rowcopy = [];
			rowcopy.unshift(absRowId + 1);
			
			rowId = absRowId + 1;
		}
		
		var validationErrors = [];
		// Iterate through each column and update those that exist
		for(var i = 0; i < this.data.columndefs.length; i++) {
			var columndef = this.data.columndefs[i];
			
			// Do type specific validation if supported
			if(options.validate != 0) {
				if(Packages.Library.CSV.ColumnTypes[columndef.format].$.Validate != null) {
					var error = Packages.Library.CSV.ColumnTypes[columndef.format].$.Validate(columndef, this, dummyrow);
					if(error) validationErrors.push(error);
				}
				
				if((dummyrow[columndef.refcode] == null || dummyrow[columndef.refcode] == "") && columndef.defaultvalue != null && columndef.defaultvalue != "") {
					dummyrow[columndef.refcode] = columndef.defaultvalue;
				}
			}
			
			// Skip nulls
			if(dummyrow[columndef.refcode] == null) continue;
			
			// Update field
			rowcopy[columndef.id] = dummyrow[columndef.refcode];
			
			// Validate field
			if(options.validate != 0
			&& (
				rowcopy[columndef.id] == null
				|| rowcopy[columndef.id] == ""
			)
			&& columndef.required == 1) validationErrors.push("Column '" + columndef.refcode + "' is required");
		}
		
		// Did any errors occur?
		if(validationErrors.length > 0) {
			Packages.Library.$.CreatePopupQuery({
				title: "Failed to save new item",
				message: "The following errors occured during validation\n -> " + validationErrors.join("\n -> ")
			});
			return;
		}
		
		// Save row
		this.csvdata[absRowId] = rowcopy;
		
		// Invalidate dummyrow cache of this row
		if(this.cache.dummyrows != null) this.cache.dummyrows[absRowId] = null;
		
		// Call GetDummyRow to calculate any fields that need recalculating
		this.GetDummyRow(rowId);
		
		// Call redraw
		this.View.Redraw();
		
		// Send XMLRPC call to server to update
		if(options.updateServer != 0 && this.data.updateCSV != 0) {
			var methods = [];
			if(addrow == 0) {
				methods = methods.concat(this.XMLRPC.SetFields(rowId, this.csvdata[absRowId]));
			} else {
				methods = methods.concat(this.XMLRPC.AddRow(this.csvdata[absRowId]));
			}
			// Add a load method to check it loaded
			methods = methods.concat(this.XMLRPC.LoadFields(rowId));
			Packages.Library.$.CreateXMLRPCMethodCall({methods: methods});
		}
		
		// If we have added a row, set this as a newly selected row
		if(addrow == 1) {
			this.View.UpdateRowId(rowId);
		}
	};
	
	/*********************************************************************
	 * RecalculateAllRows - runs GetDummyRow on all rows to recalculate values
	 ********************************************************************/
	this.RecalculateAllRows = function() {
		// Fetch every row to recalculate values
		for(var i = 0; i < this.csvdata.length; i++) {
			this.GetDummyRow(this.csvdata[i][0], {updateServer: 0});
		}
	};
	
	/*********************************************************************
	 * DeleteRow - deletes the specified row from the csv data
	 *
	 * param - rowId : the rowid
	 ********************************************************************/
	this.DeleteRow = function(rowId) {
		var absRowId = this.GetAbsoluteRowId(rowId);
		
		// Check row is within range
		if(this.csvdata[absRowId] == null) return;
		
		// Send request to server
		var primaryKey = this.GetPrimaryKey(rowId);
		var methods = [];
		methods.push({classname: "XCSV", method: "DeleteRow", params: [this.xmlFilePath, Packages.Library.$.ToNumber({str: primaryKey})]});
		Packages.Library.$.CreateXMLRPCMethodCall({methods: methods});
		
		// Splice out row
		this.csvdata.splice(absRowId, 1);
		
		this.ResetAllAbsRowId();
		
		this.View.UpdateRowId(null);
		
		// Call redraw
		this.View.Redraw();
	};
	
	/*********************************************************************
	 * ResetRowCaching - resets all row caching
	 *
	 * Also fixes the rowIds stored in the front of the CSV file
	 *
	 * Used to reset the row cache after a delete (or move)
	 ********************************************************************/
	this.ResetAllAbsRowId = function() {
		for(var i = 0; i < this.csvdata.length; i++) {
			this.csvdata[i][0] = (i + 1) + "";
		}
		
		// Clear the dummyrows cache
		this.cache.dummyrows = null;
	};
	
	/*********************************************************************
	 * InitialiseAllDefs - initialises all columndef types
	 *
	 * param - extCallback : function to call once everything initialised
	 ********************************************************************/
	this.InitialiseAllDefs = function(extCallback) {
		// Call initialise on all columndefs
		for(var i = 0; i < this.data.columndefs.length; i++) {
			var columndef = this.data.columndefs[i];
			
			// Ensure columndef has type set
			columndef.type = "xcsv_columndef";
			if(columndef.$noDump == null) columndef.$noDump = {};
			
			// Skip types that do not support Initialisation
			if(Packages.Library.CSV.ColumnTypes[columndef.format].$.Initialise == null) continue;
			
			// Call initialise
			Packages.Library.CSV.ColumnTypes[columndef.format].$.Initialise(columndef, this);
		}
		
		// Initialise viewdefs
		for(var i = 0; i < this.data.viewdefs.length; i++) {
			var viewdef = this.data.viewdefs[i];
			
			if(viewdef.$noDump == null) viewdef.$noDump = {};
			
			// Ensure viewdef has type set
			viewdef.type = "xcsv_viewdef";
		}
		
		// Are all columndefs ready?
		var _this = this;
		var checkColumnDefsReady = {};
		checkColumnDefsReady.fn = function() {
			var ready = 1;
			for(var i = 0; i < _this.data.columndefs.length; i++) {
				var columndef = _this.data.columndefs[i];
				
				if(columndef.$noDump.ready == 0) ready = 0;
			}
			if(ready) {
				// Fire the callback
				extCallback();
			} else {
				setTimeout(checkColumnDefsReady.fn, 10);
			}
		}
		checkColumnDefsReady.fn();
	};
	
	/*********************************************************************
	 * GetSelectBoxListOfData - gets an array of items ready for a SelectBox
	 *
	 * param - options : hashref of options, may contain:
	 * 			viewRef : viewRef to use rather than the name
	 * 			selectedItems : array of selected rowids, only these will be used
	 * 			disableOnClick : 1 to disable onclick, 0 (default) to allow
	 *
	 * return - values : array of options for a selectbox
	 ********************************************************************/
	this.GetSelectBoxListOfData = function(options) {
		if(options == null) options = {};
		var values = [];
		
		var array = this.csvdata;
		if(options.filterBy != null) array = this.GetFilteredArray(array, options.filterBy);
		
		// Cache current View options
		var currentRowId = this.View.current.rowId;
		
		for(var i = 0; i < array.length; i++) {
			var rowid = array[i][0];
			
			if(options.selectedItems != null && !Packages.Library.$.Contains({array: options.selectedItems, item: this.GetPrimaryKey(rowid)})) continue;
			options.rowId = rowid;
			values.push({
				name: this.View.GetViewRowByViewRef(options),
				value: this.GetPrimaryKey(rowid)
			})
		}
		
		// Restore current View options
		this.View.current.rowId = currentRowId;
		
		return values;
	};
	
	/*********************************************************************
	 * ReceiveMessages - callback for received messages
	 *
	 * param - message : the message sent
	 *
	 * return - result : 1 received, 0 send it again
	 ********************************************************************/
	this.ReceiveMessages = function(message) {
		this.messages.push(message);
		
		// Call redraw
		this.View.Redraw();
		
		return 1;
	};
	
	/*********************************************************************
	 * SaveCSVFile - saves the CSV file to the server
	 ********************************************************************/
	this.SaveCSVFile = function() {
		if(this.csvComplete != 1) {
			// The complete CSV file is not loaded, so do not allow an overwrite save
			Packages.Library.$.LogInfo({
				mesg: "The entire CSV file is not loaded, and so this action can not be performed and saved to the server",
				location: "CSV.SaveCSVFile",
				type: "Warning",
				alert: 1,
				level: 4
			});
			return;
		}
		
		// Create CSV content, and re-append header row
		var csvdata = Packages.Library.$.Clone({oldObj: this.csvdata});
		csvdata.unshift(this.headerrow);
		
		var csvContent = Packages.Library.$.MakeCSV({
			array: csvdata
		});
        
		// Save the CSV file to the server
		Packages.Library.$.SetFile({
			filepath: this.abscsvfile,
			content: csvContent,
			overwrite: 1,
			reqFiles: 0,
			callback: function() {
				Packages.Library.$.LogInfo({
					alert: 1,
					mesg: "CSV File Updated",
					location: "CSV.SaveCSVFile",
					type: "Save Complete",
					level: 5
				});
			}
		});
	};
	
	/*********************************************************************
	 * GetConditionalFormDefs - gets the form item to display conditional
	 * view defs
	 *
	 * return - formItem : the form item
	 ********************************************************************/
	this.GetConditionalFormDefs = function() {
		// Create the var defs for the Condition Form in the ViewDef
		var conditionalVarDefs = [];
		for(var i = 0; i < this.data.columndefs.length; i++) {
			var columndef = this.data.columndefs[i];
			var format = columndef.format;
			// Get varDef for columndef format
			
			if(Packages.Library.CSV.ColumnTypes[format].$.GetConditionalItemDef == null) continue; // Unsupported
			
			// Create the entry
            conditionalVarDefs.push({
				name: columndef.refcode,
				ref: columndef.refcode,
                itemdef: Packages.Library.CSV.ColumnTypes[format].$.GetConditionalItemDef(this, columndef)
            });
        }
		
		return conditionalVarDefs;
	}
	
	/*********************************************************************
	 * CSVCheckReloader - called once a second to see if the CSV file on
	 * the server has changed, if so, reloads
	 ********************************************************************/
	this.CSVCheckReloader = function() {
		if(this.csvComplete != 1) return; // Does not work in partial mode
		if(this.data.syncCSV == 0 && this.forceReload == 0) {
			// Don't do anything if sync is disabled, unless it has been forced
			this.CSVCheckReloaderCallback(); // Do nothing
			return;
		}
		
		// Request the CSV file from the server
		this.csvfilecheckreloader = new Packages.Library.DynamicLoad({
			callback: this.CSVCheckReloaderCallback.bind(this)
		});
		this.csvfilecheckreloader.Request([{
			filepath: this.basecsvfile,
			mode: "LT_TEXT",
			ForceReload: 1
		}]);
	};
    /*********************************************************************
	 * CSVCheckReloaderCallback - loads CSV data into object, and initialise types
	 ********************************************************************/
	this.CSVCheckReloaderCallback = function() {
		clearInterval(this.reloaderInterval);
		
		// Is data sync enabled?
		if(this.data.syncCSV != 0 || this.forceReload == 1) {
			// If it has been forced, only do it once
			this.forceReload = 0;
			
			var csvfilecontent = this.csvfilecheckreloader.GetFileContent();
			var csvfilestatus = this.csvfilecheckreloader.GetFileStatus();
			if(this.csvfilecontent != csvfilecontent
			&& csvfilestatus == 200) {
				// Something has changed, so reload
				this.csvfilecontent = csvfilecontent;
				
				// Get array of data
				this.csvdata = Packages.Library.$.GetArrayFromCSV({csvtext: this.csvfilecontent});
				
				// Check we have csvdata ... this may be because the file has moved, but it is not good.
				
				if(this.csvdata != null) {
					// Extract header row
					this.headerrow = this.csvdata.shift();
				}
				
				this.ResetAllAbsRowId();
				
				this.View.Redraw();
			}
		}
		
		this.reloaderInterval = setInterval(this.CSVCheckReloader.bind(this), 1000);
	};
	
	/*********************************************************************
	 * CheckXCSV - tests the integrity of the XCSV and finds user mistakes
	 *
	 * returns markup explaining the errors or null if no errors
	 ********************************************************************/
	this.CheckXCSV = function() {
		var errors = [];
		var warnings = [];
		
		if(this.data.updateCSV != 0) {
			// Check there is a primary key
			var primaryKeyColDef = this.GetPrimaryKeyColumnDef();
			if(primaryKeyColDef == null) {
				errors.push({
					heading: "Primary Key",
					name: "No Active Primary Key Column",
					description: "A primary key column is required for all server communication, and compatibility with future software versions"
				});
			}
		} else {
			warnings.push({
				heading: "Persistance",
				name: "This file is set to not be persistent",
				description: "This will prevent the CSV file from being updated to the server"
			});
		}
		
		// Iterate through all columndefs and ask them if they have any checking they'd like to do
		var _this = this;
		var columnIds = {};
		foreach(this.data.columndefs, function(columndef) {
			// Do general checking
			if(columnIds[columndef.id] != null) {
				warnings.push({
					heading: "Duplicate columndef id",
					name: "You are using the same column id for multiple columndefs",
					description: "When the same columnid is used by two columndefs, the information in each cell of the column is shared.\n"
							+	"This can be useful for reading data in multiple formats, but can cause undefined effects when editing both columndefs at the same time."
				});
			}
			columnIds[columndef.id] = 1; // Remember
			
			// Ask the specific format for each
			if(Packages.Library.CSV.ColumnTypes[columndef.format].$.CheckSettings != null) {
				var res = Packages.Library.CSV.ColumnTypes[columndef.format].$.CheckSettings({columndef: columndef, xcsv: _this});
				if(res != null && res.length > 0) {
					res[0].heading = "Column Definition [" + columndef.refcode + "]";
					errors = errors.concat(res);
				}
			}
		});
		
		// Iterate through all viewdefs and ask them if they have any checking they'd like to do
		foreach(this.data.viewdefs, function(viewdef) {
			if(Packages.Library.CSV.ViewTypes[viewdef.viewtype].$.CheckSettings != null) {
				var res = Packages.Library.CSV.ViewTypes[viewdef.viewtype].$.CheckSettings({viewdef: viewdef, xcsv: _this});
				if(res != null && res.length > 0) {
					res[0].heading = "View Definition [" + viewdef.refcode + "]";
					errors = errors.concat(res);
				}
			}
		});
		
		if(warnings.length > 0) {
			errors.push({
				heading: "Warnings",
				name: "Hover over the help to see warnings about this XCSV file",
				description: Packages.Library.$.LogReport({report: warnings, location: "XCSV Check Settings"})
			});
		}
		
		if(errors.length == 0) return null;
		
		var html = "<h3>XCSV Check Settings Report<\/h3>";
		html += Packages.Library.$.LogReport({report: errors, location: "XCSV Check Settings"});
		html += "<p>These issues may cause unwanted side effects and should be fixed before using the system.<\/p>";
		return html;
	};
	
	/*********************************************************************
	 * EnhanceFormFieldsInSettings - for the settings form, where there
	 * are form items that have the useColumnValue option set, the item
	 * will have an additional item added that displays a drop down
	 * of all columndefs. This allows a value to be taken from there.
	 *
	 * The original value can still be customised
	 *
	 * param - items : the array of items
	 *
	 * No return, the array of items is altered
	 ********************************************************************/
	this.EnhanceFormFieldsInSettings = function(items) {
		var columndefOptions = this.GetColumnDefOptions();
		
		for(var i = 0; i < items.length; i++) {
			var item = items[i];
			if(item.useColumnValue == 1) {
				// Add new item immediatly before current item
				items.splice(i, 0, {
					name: item.name,
					description: item.description,
					id: item.id + "_field",
					value: "",
					none: "Use custom value",
					type: "SelectBox",
					options: columndefOptions,
					complexity: item.complexity
				});
				
				// Ammend original item
				item.name = "Custom value";
				item.description = null;
				item.conditions = [
					{
						condition: "equals",
						variable: item.id + "_field",
						value: null
					}
				];
				
				i++; // Skip next item, as it's actually this one again
			}
			
			if(item.form != null) {
				// Item has a child form, recurse
				this.EnhanceFormFieldsInSettings(item.form.items);
			}
		}
	};
	
	/*********************************************************************
	 * ProcessEnhancedFormFieldsInSettings - see EnhanceFormFieldsInSettings
	 *
	 * Gets the actual value for this field
	 *
	 * param - def : the def containing items
	 * param - id : the id in that def
	 *
	 * return - value : the value after processing
	 ********************************************************************/
	this.ProcessEnhancedFormFieldsInSettings = function(def, id) {
		// Skip values that have no _field value
		if(def[id + "_field"] == null) return def[id];
		
		var columnref = def[id + "_field"];
		var dummyrow = this.View.current.dummyrow;
		return dummyrow[columnref];
	};
	
	/*********************************************************************
	 * GetFieldsInColumn - gets an array of every field in the specified
	 * column
	 *
	 * param - columndef : the column def
	 *
	 * return - data : an array of every field in this column
	 ********************************************************************/
	this.GetFieldsInColumn = function(columndef) {
		var colid = columndef.id;
		
		var data = [];
		foreach(this.csvdata, function(row) {
			var value = row[colid];
			if(value == null) value = "";
			data.push(value);
		});
		
		return data;
	};
	
	/*********************************************************************
	 * UpgradeXCSV - upgrades the XCSV data file to the latest version
	 *
	 * param - data : the current data
	 ********************************************************************/
	this.UpgradeXCSV = function(data) {
		var version = data.version;
		if(version == null) version = 1;
		
		if(version == 1) {
			// Upgrade to version 2
			
			// Iterate through the viewdefs, and update the view type and view formats
			var viewDefs = data.viewdefs;
			for(var v = 0; v < viewDefs.length; v++) {
				viewdef = viewDefs[v];
				if(viewdef.mode == "SystemTable") {
					viewdef.viewtype = "Listing";
					viewdef.format = "SystemTable";
				}
				if(viewdef.mode == "SystemDetail") {
					viewdef.viewtype = "Single";
					viewdef.format = "SystemDetail";
				}
				if(viewdef.mode == "Custom") {
					viewdef.viewtype = "Listing";
					viewdef.format = "Custom";
				}
				if(viewdef.mode == "SystemEdit") {
					viewdef.viewtype = "Edit";
				}
				viewdef.viewdefRowLinks = [];
				viewdef.viewdefGeneralLinks = [];
				delete viewdef.mode;
			}
			
			version = 2;
		}
		if(version == 2) {
			if(data.wrapperdefs == null) data.wrapperdefs = [];
			version = 2.1;
		}
		
		if(version == 2.1) {
			// Fix bugs
			// Remove key 'undefined' that will have been added when editing forms during 2.1
			var viewDefs = data.viewdefs;
			for(var v = 0; v < viewDefs.length; v++) {
				delete viewDefs[v]["undefined"];
			}
			var columnDefs = data.columndefs;
			for(var c = 0; c < columnDefs.length; c++) {
				delete columnDefs[c]["undefined"];
				
				// Add filterformat to columndefs
				if(columnDefs[c].filterformat == null) columnDefs[c].filterformat = 0;
			}
			delete data["undefined"];
		}
		
		
		data.version = version;
	};
};

Packages.Library.CSV.$c.CSV = {};
Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_NONE = 1;
Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_OWNED = 2;
Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_SELFOWNED = 4;
Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_OWNABLE = 8;
Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_GIVEUPABLE = 16;
Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_ADDABLE = 32;
Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_DELETABLE = 64;
Packages.Library.CSV.$o.CSV = {};
Packages.Library.CSV.$v.ObjectCounter = 0;Package("Library.CSV.ColumnTypes.Calculation").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Calculation.$.GetEditForm = function() {
	return [
		{
			name: "Calculation",
			description: "Enter the calculation, using &lt;%refcode%&gt; to represent other fields in the same row.\n"
					+	"Note: Fields are always represented in plain format, i.e. Exactly as they are stored in the CSV file. They have no formatting applied, and do not have the default 'None' values.\n"
					+	"Numeric Eg. &lt;%ref1%&gt; and &lt;%ref2%&gt;\n"
					+	"String Eg. ( &lt;%ref1%&gt; - &lt;%ref2%&gt; ) + \" items\"",
			value: "",
			type: "TextArea",
			rows: 2,
			id: "calculation",
			complexity: 1
		},
		{
			name: "Numeric calculation",
			description: "Unchecked: Use the replacements to create a string of text\n"
					+	"Checked: Evaluates the string of text mathematically\n"
					+	"Eg. ( &lt;%ref1%&gt; - &lt;%ref2%&gt; ) + \" items\"",
			defaultvalue: 1,
			type: "Checkbox",
			id: "numeric",
			complexity: 1
		}
	]
};

/*******************************************************************************
 * GetConditionalItemDef - gets the conditional itemdef for this type
 *
 * param - editor : ref to the editor
 * param - columndef : current columndef
 *
 * Returns the conditional form
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Calculation.$.GetConditionalItemDef = function(editor, columndef) {
	return {
		type: "Text",
		numeric: 1
		// Values can be compared to this calculated field
	}
};Package("Library.CSV.ColumnTypes.Calculation").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Calculation.$.GetDetails = function() {
	return {
		name: "Calculation",
		description: "A customisable calculation for the current row"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Calculation.$.Display = function(columndef, celldata, xcsv) {
	return celldata;
}

/*******************************************************************************
 * GetValue - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Calculation.$.GetValue = function(columndef, xcsv, dummyrow) {
	// The cell data will be evaled (in a try catch)
	
	// Do the replacements now
	var calculation = xcsv.View.DoReplacements({
		html: columndef.calculation,
		tidyValueForEval: (columndef.numeric == 0 ? 0 : 1),
		plain: 1,
		dummyrow: dummyrow
	});
	
	// Numeric, or plain?
	if(columndef.numeric == 0) return calculation;
	
	var result;
	try{
		result = eval(calculation);
	} catch(e) {
		Packages.Library.$.LogInfo({
			mesg: "Calculation failed whilst processing [" + calculation + "] for column [" + columndef.refcode + "]. Error: " + e.message,
			location: "Packages.Library.CSV.ColumnTypes.Calculation.$.Display",
			type: "Calculation Error",
			level: 1
		});
		result = "Error";
	}
	
	return result;
};

/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Calculation.$.EndUserEdit = function(columndef, celldata, xcsv) {
	return {
		type: "Label",
		// Just output the value
		size: 3,
		label: Packages.Library.CSV.ColumnTypes.Calculation.$.Display(columndef, celldata, xcsv)
	}
};Package("Library.CSV.ColumnTypes.Date").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Date.$.GetEditForm = function() {
	return []
};

/*******************************************************************************
 * GetConditionalItemDef - gets the conditional itemdef for this type
 *
 * param - editor : ref to the editor
 * param - columndef : current columndef
 *
 * Returns the conditional form
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Date.$.GetConditionalItemDef = function(editor, columndef) {
	return {
		type: "Date",
		numeric: 1
	}
};Package("Library.CSV.ColumnTypes.Date").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Date.$.GetDetails = function() {
	return {
		name: "Date",
		description: "Date Field"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Date.$.Display = function(columndef, celldata, xcsv) {
	var html = "";
	html += celldata;
	return html;
};
/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Date.$.EndUserEdit = function(columndef, celldata, xcsv) {
	return {
		type: "Date"
	}
};
/*******************************************************************************
 * GetDummyValue - gets the default value when a value is ""
 *
 * Returns a better value for GetDummyRow
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Date.$.GetDummyValue = function(columndef, celldata, xcsv) {
	if(celldata == null || celldata == "") return columndef.defaultvalue;
	return celldata;
};Package("Library.CSV.ColumnTypes.ForeignKey.Methods.Inline").edit = function(){};
/*******************************************************************************
 * GetDetails - gets information about this edit type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.Methods.Inline.$.GetDetails = function() {
	return {
		name: "Inline",
		description: "Places the all of the Foreign Table elements into the form for selection.\n" +
					"When displayed, each item can be clicked to select / unselect it. It will be highlighted when selected"
	}
};

/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.Methods.Inline.$.EndUserEdit = function(columndef, xcsv, options) {
	var celldata = options.celldata;
	var foreignXCSV = Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignXCSV(columndef, xcsv);
	if(foreignXCSV == null) return null;
	
	var foreignColumnDefMap = foreignXCSV.GetColumnDefMap();
	
	var manipulate = function(item) {
		// Assemble filterBy's
		var filterBy = [];
		var conditions = [];
		if(columndef.filteringFields == null) columndef.filteringFields = [];
		for(var i = 0; i < columndef.filteringFields.length; i++) {
			var filter = columndef.filteringFields[i];
			var value = options.dummyrow[filter.refcode];
			var safeValue = xcsv.SafeEncodeText(value);
			
			var foreignColumnDef = foreignColumnDefMap[filter.foreignRefCode];
			if(foreignColumnDef == null) continue;
			var foreignColumnId = foreignColumnDef.id;
			if(filterBy[foreignColumnId] == null) filterBy[foreignColumnId] = {};
			filterBy[foreignColumnId][safeValue] = 1;
			
			// Add dummy conditions to force refresh when changed
			conditions.push({
				condition: "notequals",
				variable: filter.refcode,
				value: "-dummyvalue-"
			});
		}
		
		// Create the options
		var selectOptions = foreignXCSV.GetSelectBoxListOfData({
			viewRef: columndef.editViewRef,
			disableOnClick: 1,
			filterBy: filterBy
		});
		
		// For radio buttons, add a none options if not required
		// Note, uses "" for none value, not null
		if(columndef.required != 1 && columndef.multiselect != 1) {
			selectOptions.unshift({
				name: "None",
				value: ""
			})
		}
		item.conditions = conditions;
		item.options = selectOptions;
		
	};
	
	var item = {
		type: columndef.multiselect == 1 ? "Options" : "RadioButtons",
		className: "xcsv_foreign_select",
		commaString: 1,
		manipulate: manipulate
	};
	
	// Do initial manipulate
	manipulate(item);
	
	return item;
};Package("Library.CSV.ColumnTypes.ForeignKey.Methods.Subscriber").edit = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.Methods.Subscriber.$.GetDetails = function() {
	return {
		name: "Basket (Subscriber)",
		description: "This method works in two ways.\n" +
						"Selection Mode: Requires the foreign XCSV file to be displayed independantly on the page.\n" +
						"A select button is added to each item in the foreign XCSV listing. When this select button is pressed, it stores the item in this XCSV file.\n" +
						"The select button appear in the 'action buttons' type viewdef.\n" +
						"Update Mode: Requires this XCSV file to be viewed without the foreign XCSV file on the same page.\n" +
						"Only the selected items are displayed, an option is given to remove the items.\n" +
						"This is similar to a basket of items."
	}
};

/*******************************************************************************
 * Initialise - see if the Foreign XCSV item exists on this page ... if it does then
 * link to it, and set up the additional actions we need to send it
 *
 * param - columndef : the columndef
 * param - xcsv : xcvs ref
 * param - options : hash of options:
 *
 * return 1 if OK, null if failed and callback will never be called
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.Methods.Subscriber.$.Initialise = function(columndef, xcsv, options) {
	// Find the Foreign XCSV item
	var filename = xcsv.settings.basepath + columndef.xcsvfile;
	var safeForeignXCSV = xcsv.SafeEncodeText(filename);
	
	// Create a callback function (in scope)
	var callback = function(foreignId) {
		// Work out which of our local rows we should be editing
		var rowId = xcsv.GetFirstUserRow();
		if(rowId == null) return;
		
		// Update dummy row
		var dummyrow = xcsv.GetDummyRow(rowId);
		var cell = dummyrow[columndef.refcode];
		
		// Fetch items, unless cell is empty or multiselect is disabled
		var currentItems = [];
		if(columndef.multiselect == 1 && cell.length > 0) currentItems = cell.split(",");
		
		// Add new item
		currentItems.push(foreignId);
		
		// Save
		dummyrow[columndef.refcode] = currentItems.join(",");
		
		// Save it
		xcsv.SetDummyRow(rowId, dummyrow);
	}
	
	// Send a message to the other XCSV, it may not have loaded yet, but the
	// messaging system will notify it when it does.
	// Send the action button with it, and send it our callback to fire
	Packages.Library.$o.General.messenger.Send({
		recipient: "XCSV_" + safeForeignXCSV,
		message: {
			type: "ActionButton",
			buttonText: "Select",
			callback: callback
		}
	});
	
	return null; // Parent please call callback for me
};

/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.Methods.Subscriber.$.EndUserEdit = function(columndef, xcsv, options) {
	var foreignXCSV = Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignXCSV(columndef, xcsv);
	if(foreignXCSV == null) return null;
	
	// Create the options
	var selectOptions = foreignXCSV.GetSelectBoxListOfData({
		viewRef: columndef.editViewRef,
		selectedItems: options.celldata.split(","),
		disableOnClick: 1
	});
	
	return {
		type: "Options",
		commaString: 1,
		options: selectOptions,
		className: "xcsv_foreign_basket",
		removeOnly: 1
	};
};Package("Library.CSV.ColumnTypes.ForeignKey.Methods.UserSpace").edit = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.Methods.UserSpace.$.GetDetails = function() {
	return {
		name: "Memory (UserSpace)",
		description: "Use the item stored in the users user space.\n" +
						"If a user has selected and stored an item from the foreign table in their user space, it will be used when they edit this form.\n" +
						"If they have not selected an item, no items will be selected." +
						"The 'Edit View Def' for the selected item will be displayed if there is one."
	}
};

/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.Methods.UserSpace.$.EndUserEdit = function(columndef, xcsv, options) {
	var celldata = options.celldata;
	var foreignXCSV = Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignXCSV(columndef, xcsv);
	if(foreignXCSV == null) return null;
	
	var filename = xcsv.settings.basepath + columndef.xcsvfile;
	var safeForeignXCSV = xcsv.SafeEncodeText(filename);
	
	// Get the user space selected item from the cache
	var userSpace = Packages.Library.$.CreateUserspace();
	var selectedItem = userSpace.GetCache({key: safeForeignXCSV});
	
	// Get the view of this item
	var html = foreignXCSV.View.GetViewForForeignXCSVCall({
		rowId: selectedItem,
		viewRef: columndef.editViewRef,
		disableOnClick: 1
	});
	
	// Create a non editable HTML form showing just the selected item
	return {
		type: "HTML",
		html : html,
		defaultvalue: selectedItem
	};
};Package("Library.CSV.ColumnTypes.ForeignKey").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetEditForm = function(editor) {
	var xcsv = editor.view.xcsv;
	// Get a list of methods available
	var methods = [];
	for(var method in Packages.Library.CSV.ColumnTypes.ForeignKey.Methods) {
		if(method.match(/^\$/)) continue; // Skip $i, $c etc
		var methodDetails = Packages.Library.CSV.ColumnTypes.ForeignKey.Methods[method].$.GetDetails();
		methods.push({
			name: methodDetails.name,
			description: methodDetails.description,
			value: method
		});
	}
	
	var GetForeignXCSVFromFormObject = function(form) {
		// Get the columndef
		var columndef = form.object;
		
		// Check foreign XCSV file is loaded
		return Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignXCSV(columndef, xcsv);
	}
	
	var GetForeignXCSVViewDefsFromFormObject = function(form) {
		var foreignXCSV = GetForeignXCSVFromFormObject(form);
		
		if(foreignXCSV == null) return [];
		
		return foreignXCSV.GetViewDefOptions();
	}
	
	var GetForeignXCSVColumnDefsFromFormObject = function(form) {
		var foreignXCSV = GetForeignXCSVFromFormObject(form);
		
		if(foreignXCSV == null) return [];
		
		return foreignXCSV.GetColumnDefOptions();
	}
	
	return [
		{
			name: "Use this file",
			description: "The foreign table can be itself, uncheck to select an alternative file",
			checked: 0,
			type: "Checkbox",
			id: "useself"
		},
		{
			name: "Other table",
			subtitle: "XCSV file",
			description: "Select the XCSV file for the other table",
			type: "FileMgr",
			select: 1,
			pathPrefix: "",
			folder : Packages.Library.$.GetSubFolder({container: pFolders, offset: pOffset}),
			id: "xcsvfile",
			extensionFilter: ['xcsv'],
			foldable: 1,
			folded: 1,
			conditions: [
				{
					condition: "equals",
					variable: "useself",
					value: 0
				}
			]
		},
		{
			name: "Display View Def",
			description: "Select the View Def in the foreign XCSV file to display when viewing this column, or 'Name Only' for just the name field.",
			type: "HTML",
			id: "displayViewRef",
			html: "Once you have selected a foreign XCSV file, you must save and reload this XCSV file to retrieve this list",
			manipulate: function(item) {
				if(GetForeignXCSVFromFormObject(item.parentform) != null) {
					item.none = "Name Only";
					item.options = GetForeignXCSVViewDefsFromFormObject(item.parentform);
					item.type = "SelectBox";
				}
			}
		},
		{
			name: "Edit View Def",
			description: "Select the View Def in the foreign XCSV file to display when editing this column, or 'Name Only' for just the name field.",
			type: "HTML",
			id: "editViewRef",
			html: "",
			manipulate: function(item) {
				if(GetForeignXCSVFromFormObject(item.parentform) != null) {
					item.none = "Name Only";
					item.options = GetForeignXCSVViewDefsFromFormObject(item.parentform);
					item.type = "SelectBox";
				}
			}
		},
		{
			name: "Multi Select",
			description: "Multi Select allows multiple items to be selected. Otherwise only one item is allowed.",
			checked: 0,
			type: "Checkbox",
			id: "multiselect"
		},
		{
			name: "Edit Method",
			description: "The method for editing the selected item(s).\n" +
						"This controls the way the other table is loaded, and how it is displayed for editing\n" +
						"This method has no effect when simply viewing",
			value: "Inline",
			type: "RadioButtons",
			id: "method",
			options: methods
		},
		{
			name: "Filtering Fields",
			description: "Select fields in this table that filter rows in the other table.",
			type: "MultiForm",
			id: "filteringFields",
			titleRef: "local.<%refcode%> = foreign.<%foreignRefCode%>",
			form: {
				type: "Form",
				items: [
					{
						type: "SelectBox",
						name: "Local Column",
						description: "Choose the column in this table.",
						options: editor.currentRowsList,
						value: "",
						id: "refcode"
					},
					{
						type: "Label",
						name: "link to",
						label: ""
					},
					{
						name: "Foreign Column",
						description: "Choose the column in the other table.",
						value: "",
						id: "foreignRefCode",
						type: "HTML",
						html: "Once you have selected a foreign XCSV file, you must save and reload this XCSV file to retrieve this list",
						manipulate: function(item) {
							if(GetForeignXCSVFromFormObject(item.parentform.parentform) != null) {
								item.options = GetForeignXCSVColumnDefsFromFormObject(item.parentform.parentform);
								item.type = "SelectBox";
							}
						}
					}
				]
			},
			conditions: [
				{
					condition: "equals",
					variable: "method",
					value: "Inline"
				}
			],
			complexity: 3
		},
		{
			name: "Linking Select Button Text",
			description: "The text to display on the select button.",
			value: "Select",
			type: "Text",
			id: "selectText"
		}
	]
};

/*******************************************************************************
 * CheckSettings - checks the current set of options are sensible for PrimaryKey
 *
 * param - options : hash of options, contains columndef, xcsv
 *
 * return - errors : array of errors, or null if none
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.CheckSettings = function(options) {
	var columndef = options.columndef;
	var xcsv = options.xcsv;
	
	// Get columnid
	var columnid = columndef.id;
	
	var errors = [];
	
	var foreignXCSV = Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignXCSV(columndef, xcsv);
	
	if(foreignXCSV == null) {
		errors.push({
			name: "The other table is not loaded.",
			description: "Try saving and refreshing this page to force a reload.\n" +
						"If that does not work, ensure the other XCSV file exists."
		});
	} else {
		// Check Display Viewdef exists
		if(columndef.displayViewRef != null) {
			var foreignViewDefId = Packages.Library.$.FindArrayItemIndex({
				array: foreignXCSV.data.viewdefs,
				path: "refcode",
				value: columndef.displayViewRef
			});
			if(foreignViewDefId == null) {
				errors.push({
					name: "Display Viewdef [" + columndef.displayViewRef + "] not found in other XCSV file"
				});
			}
		}
		
		// Check Edit Viewdef exists
		if(columndef.editViewRef != null) {
			var foreignViewDefId = Packages.Library.$.FindArrayItemIndex({
				array: foreignXCSV.data.viewdefs,
				path: "refcode",
				value: columndef.editViewRef
			});
			if(foreignViewDefId == null) {
				errors.push({
					name: "Edit Viewdef [" + columndef.editViewRef + "] not found in other XCSV file"
				});
			}
		}
		
		// Check other table has a rpimary key
		var foreignPrimaryKeyColumnId = foreignXCSV.GetPrimaryKeyColumnDef();
		if(foreignPrimaryKeyColumnId == null) {
			errors.push({
				name: "Primary Key not found in other XCSV file"
			});
		}
	}
	
	if(errors.length == 0) return null;
	return errors;
};Package("Library.CSV.ColumnTypes.ForeignKey").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetDetails = function() {
	return {
		name: "Other Table",
		description: "Foreign Key, reference to the primary key of another table"
	}
};

/*******************************************************************************
 * DelegateMethod - delegates the specified function to the method handling it
 * see 'Methods' sub folder
 *
 * Method refers to the method of handling inline or subscriber editing
 *
 * param - methodName : the method name
 * param - columndef : the columndef
 * param - xcsv : xcsv ref
 * param - options : other data to pass through
 *
 * return - return value to pass back to caller, or null if not found
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.DelegateMethod = function(methodName, columndef, xcsv, options) {
	// Get the method
	var method = columndef.method;
	if(method == null) return null;
	
	var methodMethod = Packages.Library.CSV.ColumnTypes.ForeignKey.Methods[method].$[methodName];
	if(methodMethod == null) return null;
	
	return methodMethod(columndef, xcsv, options);
};

/*******************************************************************************
 * Initialise - calls initialise on the method implementation
 *
 * param - columndef : the columndef
 * param - xcsv : xcvs ref
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.Initialise = function(columndef, xcsv) {
	columndef.$noDump.ready = 0;
	// Deletegate so our current method can use this
	Packages.Library.CSV.ColumnTypes.ForeignKey.$.DelegateMethod("Initialise", columndef, xcsv, {});
	
	// If using ourselves, set columndef.xcsvfile to ourself
	if(columndef.useself == 1) {
		columndef.xcsvfile = Packages.Library.$.GetFileName({filepath: xcsv.xmlFile, keepExtension: 1});
	}
	
	// Load the Foreign XCSV table
	var filename = xcsv.settings.basepath + columndef.xcsvfile;
	// Return if the filename doesn't exist
	if(filename == null || filename == "" || filename.length == 0) {
		columndef.$noDump.ready = 1;
		return;
	}
	
	// Get safe XCSV filename
	var safename = xcsv.SafeEncodeText(filename);
	if(safename == xcsv.safeXCSVName) {
		// The foreign XCSV file is ourself
		columndef.$noDump.ready = 1;
		return;
	}
	
	// Check if we have already loaded it, if so return now
	if(Packages.Library.CSV.$o.CSV[safename] != null) {
		// Create a function to check if loaded, if loaded fire callback, else wait and try again
		var checkLoaded;
		checkLoaded = function() {
			// Either ready, or it is ourself
			if(Packages.Library.CSV.$o.CSV[safename].ready == 1) {
				columndef.$noDump.ready = 1;
			} else {
				setTimeout(checkLoaded, 10);
			}
		}
		checkLoaded();
		return;
	}
	
	// XCSV file not loaded yet ... load
	// Note, the object is stored in the Packages.Library.CSV.$o.CSV in XCSV.LoadDataFromXMLContent
	var foreignXCSV = new Packages.Library.CSV.CSV({basepath: xcsv.settings.basepath});
	foreignXCSV.LoadDataFromFile(filename, function() {
		columndef.$noDump.ready = 1
	});
};

/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.Display = function(columndef, celldata, xcsv) {
	// Display the currently selected items
	if(celldata == null || celldata == "") return "";
	var foreignXCSV = Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignXCSV(columndef, xcsv);
	if(foreignXCSV == null) return null;
	
	// Get the list of objects
	var html = "";
	var items = celldata.split(",");
	for(var i = 0; i < items.length; i++) {
		if(items[i] == "") continue;
		var itemHtml = Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignRowViewDef(columndef, items[i], xcsv, foreignXCSV, columndef.displayViewRef);
		if(columndef.displayViewRef == "") itemHtml = "<div class='xcsv_foreign_list'>" + itemHtml + "<\/div>";
		html += itemHtml;
	}
	
	return html;
};

/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.EndUserEdit = function(columndef, celldata, xcsv, options) {
	return Packages.Library.CSV.ColumnTypes.ForeignKey.$.DelegateMethod("EndUserEdit", columndef, xcsv,  {celldata: celldata, dummyrow: options.dummyrow});
};

// Utility methods
/*******************************************************************************
 * GetForeignXCSV - gets the foreign XCSV ref from the cache
 *
 * param - columndef : the columndef
 * param - xcsv : xcsv ref
 *
 * return - foreignxcsv : the foreign xcsv ref, or null if not found
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignXCSV = function(columndef, xcsv) {
	// Get safe XCSV filename
	var filename = xcsv.settings.basepath + columndef.xcsvfile;
	var safename = xcsv.SafeEncodeText(filename);
	
	return Packages.Library.CSV.$o.CSV[safename];
};

/*******************************************************************************
 * GetForeignRowViewDef - gets the markup for the foreign row
 *
 * param - columndef : the columndef
 * param - celldata : cell data
 * param - xcsv : xcvs ref
 * param - foreignXCSV : foreign XCSV ref
 * param - viewRef : the name of the foreign view ref, or "" to use just the name
 *
 * Returns the html or "" if not found
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.ForeignKey.$.GetForeignRowViewDef = function(columndef, celldata, xcsv, foreignXCSV, viewRef) {
	// Get the row to which this primary key refers
	var foreignRowId = foreignXCSV.GetRowIdForPrimaryKey(celldata);
	if(foreignRowId == null) return "";
	
	var html = foreignXCSV.View.GetViewForForeignXCSVCall({
		rowId: foreignRowId,
		viewRef: viewRef,
		disableOnClick: 1
	});
	
	return html;
};Package("Library.CSV.ColumnTypes.Image").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Image.$.GetEditForm = function() {
	return [
		{
			name: "Image width",
			value: 100,
			type: "Text",
			id: "formatWidth",
			suffix: "px",
			numeric: 1,
			min: 0,
			size: 4
		},
		{
			name: "Path prefix",
			description: "Enter the relative path between the XCSV file and the images.",
			value: "",
			type: "Text",
			id: "formatPath",
			complexity: 3
		}
	]
};Package("Library.CSV.ColumnTypes.Image").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Image.$.GetDetails = function() {
	return {
		name: "Image",
		description: "Image Field"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Image.$.Display = function(columndef, celldata, xcsv) {
	var html = "";
	if(celldata == "") return "";
	html += "<img src='" + xcsv.settings.basepath + columndef.formatPath + celldata + "' style='width:" + columndef.formatWidth + "px;'>";
	return html;
};Package("Library.CSV.ColumnTypes.Number").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Number.$.GetEditForm = function() {
	return [
		{
			name: "Field prefix",
			description: "Text to place before field, Eg a currency symbol.",
			value: "",
			type: "Text",
			id: "formatPrefix",
			complexity: 3
		},
		{
			name: "Field suffix",
			description: "Text to place after field, Eg a unit of measurement.",
			value: "",
			type: "Text",
			id: "formatSuffix",
			complexity: 3
		},
		{
			name: "Min Value",
			description: "The minimum value, or blank for no minimum",
			value: "",
			type: "Text",
			numeric: 1,
			id: "minValue",
			complexity: 2,
			useColumnValue: 1
		},
		{
			name: "Max Value",
			description: "The maximum value, or blank for no maximum",
			value: "",
			type: "Text",
			numeric: 1,
			id: "maxValue",
			complexity: 2,
			useColumnValue: 1
		},
		{
			name: "Step Value",
			description: "The step value, or blank for no step. A step is the increment used, ie to force value to be entered in increments of 10, enter a value of 10. This forces numbers to be 10, 20, 30, 40 etc.",
			value: "",
			type: "Text",
			numeric: 1,
			id: "stepValue",
			complexity: 3,
			useColumnValue: 1
		}
	]
};

/*******************************************************************************
 * GetConditionalItemDef - gets the conditional itemdef for this type
 *
 * param - editor : ref to the editor
 * param - columndef : current columndef
 *
 * Returns the conditional form
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Number.$.GetConditionalItemDef = function(editor, columndef) {
	return {
		type: "Text",
		numeric: 1
	}
};Package("Library.CSV.ColumnTypes.Number").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Number.$.GetDetails = function() {
	return {
		name: "Number",
		description: "Numeric Field"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Number.$.Display = function(columndef, celldata, xcsv) {
	var html = "";
	if(columndef.formatPrefix != null) html += columndef.formatPrefix;
	html += celldata;
	if(columndef.formatSuffix != null) html += columndef.formatSuffix;
	return html;
};
/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Number.$.EndUserEdit = function(columndef, celldata, xcsv) {
	return {
		type: "Text",
		numeric: 1,
		min: xcsv.ProcessEnhancedFormFieldsInSettings(columndef, "minValue"),
		max: xcsv.ProcessEnhancedFormFieldsInSettings(columndef, "maxValue"),
		step: xcsv.ProcessEnhancedFormFieldsInSettings(columndef, "stepValue")
	}
};
/*******************************************************************************
 * GetDummyValue - gets the default value when a value is ""
 *
 * Returns a better value for GetDummyRow
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Number.$.GetDummyValue = function(columndef, celldata, xcsv) {
	if(celldata == null || celldata == "") return columndef.defaultvalue;
	return celldata;
};Package("Library.CSV.ColumnTypes.Options").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Options.$.GetEditForm = function(editor) {
	var xcsv = editor.view.xcsv;
	/*******************************************************************************
	 * AutoPopulateOptions - Action for Auto Fill - automatically populates the options
	 * with those in the column
	 *
	 * param - form : the parent form, in this case the columndef form
	 ******************************************************************************/
	var AutoPopulateOptions = function(form) {
		// Get the columndef
		var columndef = form.object;
		
		// Get columnid
		var columnid = columndef.id;
		
		// Get variations
		var variations = xcsv.GetVariations(columnid);
		
		// Get variations in the correct format for options
		var options = [];
		for(var variation in variations) {
			if(variation == "_emptyfield") continue; // Skip empty field option
			options.push({
				value: variations[variation].text
			});
		}
		
		// Store
		columndef.options = options;
	};
	
	return [
		{
			name: "Available Options",
			description: "The list of options available",
			type: "MultiForm",
			id: "options",
			title: "value",
			form: {
				type: "Form",
				items: [
					{
						type: "Text",
						name: "Value",
						description: "The option value. This will be displayed.",
						value: "",
						id: "value"
					},
					{
						type: "RichText",
						name: "Content Description",
						description: "When this option is selected, this content will be displayed a category description",
						value: "",
						id: "content",
						complexity: 3
					},
					Packages.Library.$.MakeComplexConditionFormItem({
						itemid: "conditions",
						item: {
							name: "Conditions",
							description: "Specify conditions that control when this option is displayed",
							complexity: 4
						},
						varDefs: editor.conditionalVarDefs
					})
				]
			}
		},
		{
			name: "Auto fill",
			description: "Resets all of the options to only those that currently exist.",
			type: "Button",
			id: "autofill",
			action: AutoPopulateOptions
			//actionForm: use this current form
		},
		{
			name: "Multi select",
			description: "When checked, a series of checkboxes will be displayed and multiple options may be chosen.\n"
						+"When unchecked, a series of radio buttons will be displayed, and only one option may be selected",
			type: "Checkbox",
			id: "multiselect"
		}
	]
};

/*******************************************************************************
 * GetConditionalItemDef - gets the conditional itemdef for this type
 *
 * param - editor : ref to the editor
 * param - columndef : current columndef
 *
 * Returns the conditional form
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Options.$.GetConditionalItemDef = function(editor, columndef) {
	var options = [];
	
	if(columndef.required == 0) {
		options.push({
			name: "None (blank)",
			value: ""
		});
	}
	
	for(var i = 0; i < columndef.options.length; i++) {
		options.push({
			name: columndef.options[i].value,
			value: columndef.options[i].value
		});
	}
	
	return {
		type: "SelectBox",
		options: options
	}
};

/*******************************************************************************
 * CheckSettings - checks the options are valid
 *
 * Checks the default is a valid option
 * Checks each value is a valid option
 *
 * param - options : hash of options, contains columndef, xcsv
 *
 * return - errors : array of errors, or null if none
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Options.$.CheckSettings = function(options) {
	var columndef = options.columndef;
	var xcsv = options.xcsv;
	
	var found = 0; // So prove me wrong
	
	// If not required, a blank is allowed
	if(columndef.defaultvalue == "" && columndef.required == 0) found = 1;
	
	for(var i = 0; i < columndef.options.length; i++) {
		if(columndef.options[i].value == columndef.defaultvalue) found = 1;
	}
	
	var errors = [];
	if(found == 0) {
		errors.push({
			name: "Default Value [" + columndef.defaultvalue + "] was not in the list of values",
			description: "The default value must appear in the list of values"
		});
	}
	
	// Start at row 0, ignore header row
	for(var i = 0; i < xcsv.csvdata.length; i++) {
		var value = xcsv.csvdata[i][columndef.id];
		if(value == null) value = "";
		value += ""; // Force string
		
		var values = [];
		// Multi-select?
		if(columndef.multiselect == 1) {
			values = value.split(/,/);
		} else {
			values = [value];
		}
		foreach(values, function(value) {
			var found = 0;
			if(columndef.required == 0 && value == "") found = 1;
			if(found == 0) {
				for(var o = 0; o < columndef.options.length; o++) {
					if(columndef.options[o].value == value) found = 1;
				}
			}
			if(found == 0) {
				errors.push({
					name: "Value [" + value + "] on row [" + xcsv.GetPrimaryKey(xcsv.csvdata[i][0]) + "] was not in the list of values"
				});
			}
		})
	}
	
	if(errors.length == 0) return null;
	return errors;
};Package("Library.CSV.ColumnTypes.Options").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Options.$.GetDetails = function() {
	return {
		name: "Options",
		description: "List of Options"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Options.$.Display = function(columndef, celldata, xcsv) {
	return celldata;
};
/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Options.$.EndUserEdit = function(columndef, celldata, xcsv) {
	var options = [];
	for(var i = 0; i < columndef.options.length; i++) {
		var option = columndef.options[i];
		
		if(option.conditions != null && option.conditions.length > 0) {
			if(Packages.Library.$.EvaluateComplexCondition({
				data: xcsv.View.current.dummyrow,
				conditions: option.conditions
			}) == 0) {
				// Should be hidden
				continue;
			}
		}
		
		options.push({
			name: option.value,
			value: option.value
		});
	}
	
	if(columndef.multiselect == null) columndef.multiselect = 1;
	
	// For radio buttons, add a none options if not required
	// Note, uses "" for none value, not null
	if(columndef.required != 1 && columndef.multiselect != 1) {
		options.unshift({
			name: (columndef.text_view_none != null ? columndef.text_view_none : "None"),
			value: ""
		})
	}
	
	return {
		type: (columndef.multiselect == 1 ? "Options" : "RadioButtons"),
		commaString: 1,
		options: options
	}
};Package("Library.CSV.ColumnTypes.PrimaryKey").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.PrimaryKey.$.GetEditForm = function(editor) {
	var xcsv = editor.view.xcsv;
	/*******************************************************************************
	 * AutoAddPrimaryKey - Action for AutoAddPrimaryKey - automatically add primary
	 * keys to rows without them
	 *
	 * param - form : the parent form, in this case the columndef form
	 ******************************************************************************/
	var AutoAddPrimaryKey = function(form) {
		form.parentform.Form.Submit();
		// Get the columndef
		var columndef = form.object;
		
		// Get columnid
		var columnid = columndef.id;
		
		// Find highest used primary key id
		var lastId = 0;
		for(var i = 0; i < xcsv.csvdata.length; i++) {
			var id = xcsv.csvdata[i][columnid] * 1;
			if(id != null && id > lastId) lastId = id;
		}
		
		// Increase last id by 1
		lastId ++;
		
		// Iterate through, and assign id's to items without id's
		for(var i = 0; i < xcsv.csvdata.length; i++) {
			if(xcsv.csvdata[i][columnid] == null || xcsv.csvdata[i][columnid].match(/^\s*$/)) {
				// No primary key, or only whitespace, so assign lastId
				xcsv.csvdata[i][columnid] = lastId;
				lastId ++;
			}
		}
		
		// Finally save to server
		xcsv.SaveCSVFile();
	};
	
	return [
		{
			name: "Auto add primary keys",
			description: "Adds an incremental primary key to any item that doesn't have one.",
			type: "Button",
			id: "autoadd",
			action: AutoAddPrimaryKey
			//actionForm: use this current form
		}
	];
};

/*******************************************************************************
 * CheckSettings - checks the current set of options are sensible for PrimaryKey
 *
 * param - options : hash of options, contains columndef, xcsv
 *
 * return - errors : array of errors, or null if none
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.PrimaryKey.$.CheckSettings = function(options) {
	var columndef = options.columndef;
	var xcsv = options.xcsv;
	
	// Get columnid
	var columnid = columndef.id;
	
	var errors = [];
	
	var records = {};
	
	// Start at row 0, ignore header row
	for(var i = 0; i < xcsv.csvdata.length; i++) {
		var id = xcsv.csvdata[i][columnid] + "";
		
		// Check for non numeric keys
		if(!id.match(/^\d+$/)) errors.push({
			name: "Primary Key Validation. ID [" + id + "] is not numeric",
			description: "A numeric primary key column is required for all rows"
		});
		
		// Check for duplicate entries
		if(records[id] == 1) errors.push({
			name: "Primary Key Validation. ID [" + id + "] is not unique",
			description: "A unique primary key column is required for all rows"
		});
		records[id] = 1; // Record
	}
	
	if(errors.length == 0) return null;
	return errors;
};Package("Library.CSV.ColumnTypes.PrimaryKey").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.PrimaryKey.$.GetDetails = function() {
	return {
		name: "ID",
		description: "Primary Key, a unique value for every item (row) of data"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.PrimaryKey.$.Display = function(columndef, celldata, xcsv) {
	var html = "";
	html += celldata;
	return html;
};Package("Library.CSV.ColumnTypes.Text").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Text.$.GetEditForm = function() {
	return [
		{
			name: "Field prefix",
			description: "Text to place before field, Eg a currency symbol.",
			value: "",
			type: "Text",
			id: "formatPrefix",
			complexity: 3
		},
		{
			name: "Field suffix",
			description: "Text to place after field, Eg a unit of measurement.",
			value: "",
			type: "Text",
			id: "formatSuffix",
			complexity: 3
		},
		{
			name: "Multilines",
			description: "Number of lines to provide, when 1 a single line text input will be provided. When more than 1, the user will be able to scroll",
			value: "",
			type: "Text",
			numeric: 1,
			min: 1,
			id: "multiline",
			complexity: 2
		},
		{
			name: "Rich Text",
			description: "When checked and multline enabled, the rich text editor will be presented",
			checked: 0,
			type: "Checkbox",
			id: "richtext",
			complexity: 3
		},
		{
			name: "Use non breaking spaces",
			description: "When checked, spaces will be replaced with non breaking spaces, so that the text never wraps.",
			checked: 0,
			type: "Checkbox",
			id: "nbsp",
			complexity: 3
		}
	]
};

/*******************************************************************************
 * GetConditionalItemDef - gets the conditional itemdef for this type
 *
 * param - editor : ref to the editor
 * param - columndef : current columndef
 *
 * Returns the conditional form
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Text.$.GetConditionalItemDef = function(editor, columndef) {
	return {
		type: "Text"
	}
};Package("Library.CSV.ColumnTypes.Text").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Text.$.GetDetails = function() {
	return {
		name: "Text",
		description: "Plain Text Field"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Text.$.Display = function(columndef, celldata, xcsv) {
	
	celldata = celldata.replace(/\n/g, "<br>")
	if(columndef.nbsp == 1) celldata = celldata.replace(/ /g, "&nbsp;");
	
	var html = "";
	if(columndef.formatPrefix != null) html += columndef.formatPrefix;
	html += celldata;
	if(columndef.formatSuffix != null) html += columndef.formatSuffix;
	return html;
};
/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Text.$.EndUserEdit = function(columndef, celldata, xcsv) {
	if(columndef.multiline == 1 || columndef.multiline == null || columndef.multiline == "") {
		return {
			type: "Text"
		}
	}
	if(columndef.richtext == 1) {
		return {
			type: "RichText",
			rows: columndef.multiline
		}
	}
	return {
		type: "TextArea",
		rows: columndef.multiline
	}
};Package("Library.CSV.ColumnTypes.Upload").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Upload.$.GetEditForm = function() {
	return [
		{
			id: "path",
			name: "Path to upload to",
			description: "Specify the folder to upload to",
			type: "FileMgr",
            selectfolder: 1,
            pathPrefix: "",
            folder : pFolders,
			foldable: 1,
			folded: 1
		},
		{
			id: "finishedtitle",
			name: "Finished Message Title",
			description: "Title of message to display when upload finished",
			type: "Text"
		},
		{
			id: "finishedmessage",
			name: "Finished Message",
			description: "Message to display when upload finished",
			type: "RichText"
		}
	]
};

/*******************************************************************************
 * GetConditionalItemDef - gets the conditional itemdef for this type
 *
 * param - editor : ref to the editor
 * param - columndef : current columndef
 *
 * Returns the conditional form
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Upload.$.GetConditionalItemDef = function(editor, columndef) {
	return {
		type: "Upload"
	}
};Package("Library.CSV.ColumnTypes.Upload").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Upload.$.GetDetails = function() {
	return {
		name: "Upload",
		description: "File Upload Field"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Upload.$.Display = function(columndef, celldata, xcsv) {
	// Provide a URL to download from
	return "<a href='" + celldata + "'>" + Packages.Library.$.GetFileName({filepath: celldata}) + "</a>";
};
/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.Upload.$.EndUserEdit = function(columndef, celldata, xcsv) {
	return {
		type: "Upload",
		path: "$masterpath/" + columndef.path,
		finishedMessage: {
			title: columndef.finishedtitle,
			message: columndef.finishedmessage
		}
	}
};Package("Library.CSV.ColumnTypes.User").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.GetEditForm = function(editor) {
	var xcsv = editor.view.xcsv;
	
	/*******************************************************************************
	 * AutoCreateUsers - Action for AutoCreateUsers - aautomatically creates users
	 * from the data in this column
	 *
	 * param - form : the parent form, in this case the columndef form
	 ******************************************************************************/
	var AutoCreateUsers = function(form) {
		form.parentform.Form.Submit();
		// Get the columndef
		var columndef = form.object;
		
		// Get columnid
		var columnid = columndef.id;
		
		// Start at row 1, ignore header row
		for(var i = 0; i < xcsv.csvdata.length; i++) {
			var user = xcsv.csvdata[i][columnid];
			
			// Calculate a password, 4 (lowercase) letters, 2 numbers
			var pass = "";
			for(var s = 0; s < 4; s++) {
				pass += String.fromCharCode(97 + Math.floor(Math.random() * 26))
			}
			pass += (Math.floor(Math.random() * 100));
			
			// Create user
			this.serverRequest = new Packages.Library.ServerRequest();
			this.serverRequest.ServerRequest({
				page: Packages.Library.$.GetMasterpath({}) + ".admin",
				query: {
					createAutomatedUser: "guest",
					createName: user,
					createPassword: pass,
					createEmail: "unknown",
					"req-ignorefile": 1
				}
			});
		}
	};
	
	return [
		{
			name: "Allow Take Ownership",
			description: "When checked, any user may take ownership of any item that is unowned, when unchecked the user must be assigned by an Admin.",
			checked: 0,
			type: "Checkbox",
			id: "takeOwnership"
		},
		{
			name: "Allow Giveup Ownership",
			description: "When checked, the owner user may giveup ownership of any item that they own, when unchecked only an Admin can unassign a user.",
			checked: 0,
			type: "Checkbox",
			id: "giveupOwnership"
		},
		{
			name: "Allow Create Row",
			description: "When checked, any user may add a new row (owned by them), when unchecked rows may only be added by an Admin.",
			checked: 0,
			type: "Checkbox",
			id: "ownerAddRow"
		},
		{
			name: "Allow Delete Row",
			description: "When checked, the owner user may delete the row, when unchecked only an Admin can delete a row.",
			checked: 0,
			type: "Checkbox",
			id: "ownerDeleteRow"
		},
		{
			name: "Automatically create a new users row",
			description: "When checked a new row will be automatically added for a user who does not already own a row.",
			checked: 0,
			type: "Checkbox",
			id: "autoAddUserRow"
		},
		{
			name: "Show current users row only",
			description: "When checked, only the row, when unchecked all rows will be listed.",
			checked: 0,
			type: "Checkbox",
			id: "showUserRowOnly"
		},
		{
			name: "Maximum owners per row",
			description: "The maximum number of owners a row can have",
			value: 1,
			type: "Text",
			numeric: 1,
			min: 1,
			id: "maxowners"
		},
		{
			name: "Owner Editable Fields",
			description: "The fields the owner can edit in its row",
			type: "Options",
			value: [],
			id: "ownerEditableFields",
			options: editor.currentRowsList
		},
		{
			name: "Auto generate users",
			description: "Looks for usernames in this column, and creates a real user for each one.\n"
					+	"For each user, a password will be generated",
			type: "Button",
			id: "autocreateuser",
			action: AutoCreateUsers
			//actionForm: use this current form
		}
	]
};
/*******************************************************************************
 * GetConditionalItemDef - gets the conditional itemdef for this type
 *
 * param - editor : ref to the editor
 * param - columndef : current columndef
 *
 * Returns the conditional form
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.GetConditionalItemDef = function(editor, columndef) {
	var options = [];
	options.push({
		name: "Currently logged in user",
		value: "<%username%>"
	});
	
	return {
		type: "SelectBox",
		options: options
	}
};Package("Library.CSV.ColumnTypes.User").view = function(){};
/*******************************************************************************
 * Initialise - initialises this columndef
 *
 * param - columndef : the columndef
 * param - xcsv : xcvs ref
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.Initialise = function(columndef, xcsv) {
	columndef.$noDump.ready = 0;
	// If the 'autoAddUserRow' option is enabled, and the user does not already
	// have a row create it now
	if(columndef.autoAddUserRow == 1) {
		if(xcsv.GetFirstUserRow() == null) {
			// No current user row found, so add a default row
			var dummyrow = {};
			dummyrow[columndef.refcode] = pUser;
			xcsv.SetDummyRow(null, dummyrow);
		}
	}
	
	// Set the currently selected row to this user row
	var rowId = xcsv.GetFirstUserRow();
	xcsv.View.current.rowId = rowId;
	
	columndef.$noDump.ready = 1;
};

/*******************************************************************************
 * Validate - validates changes to this field - ensures the current user is
 * assigned
 *
 * param - columndef : the columndef
 * param - xcsv : xcvs ref
 * param - dummyrow : current dummyrow
 *
 * returns an error string, or null if every thing was OK
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.Validate = function(columndef, xcsv, dummyrow) {
	if(dummyrow[columndef.refcode] == null) dummyrow[columndef.refcode] = "";
	
	// Do not edit the row and add the current user if we have csv.edit permission
	if(dummyrow[columndef.refcode] == "") {
		// Add
	} else {
		// Edit
		if(Packages.Library.$.IsPermission({permission: "csv.edit"})) return null;
	}
	
	var userState = xcsv.GetUserState(null, dummyrow);
	
	if(!(userState & Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_SELFOWNED)) {
		// Add comma if needed
		if(dummyrow[columndef.refcode].length > 0) dummyrow[columndef.refcode] += ",";
		
		// Add user to list
		dummyrow[columndef.refcode] += pUser;
	}
	
	return null;
}

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.GetDetails = function() {
	return {
		name: "User",
		description: "User Ownership field",
		singleton: 1, // Only one of these may exist in a table
		clicktosingle: 0 // Not clickable to enter single view
	}
};

/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.Display = function(columndef, celldata, xcsv, rowid, options) {
	if(options == null) options = {};
	
	if(options.display) return Packages.Library.CSV.ColumnTypes.User.$.DisplaySpecial(columndef, celldata, xcsv, rowid, options);
	
	var html = "";
	
	var state = xcsv.GetUserState(rowid);
	
	// csv.edit permission allows any changes to the file
	if(Packages.Library.$.IsPermission({permission: "csv.edit"})) {
		state |= Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_DELETABLE; // Set deletable option
		
		// Output the name of the user
		html += "[" + celldata + "]";
	}
	
	if(rowid != null) {
		// rowid is optional and will not exist for new rows
		if(state & Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_OWNABLE) {
			html += "<button onclick=\"Packages.Library.CSV.ColumnTypes.User.$.TakeOwnership(" + xcsv.textVar + ", '" + columndef.refcode + "', " + rowid + ")\">" + xcsv.data.text.takeOwnershipButtonText + "<\/button>";
		}
		
		if(state & Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_GIVEUPABLE) {
			html += "<button onclick=\"Packages.Library.CSV.ColumnTypes.User.$.GiveUpOwnership(" + xcsv.textVar + ", '" + columndef.refcode + "', " + rowid + ")\">" + xcsv.data.text.giveUpOwnershipButtonText + "<\/button>";
		}
		
		if(state & Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_DELETABLE) {
			html += "<button onclick=\"Packages.Library.CSV.ColumnTypes.User.$.DeleteRow(" + xcsv.textVar + ", '" + columndef.refcode + "', " + rowid + ")\">" + xcsv.data.text.deleteButtonText + "<\/button>";
		}
	}
	
	return html;
};

/*******************************************************************************
 * * AllActions - onclick event
 *
 * param - xcsv : XCSV
 * param - colref : the refcode for the column
 * param - rowId : the current row
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.TakeOwnership = function(xcsv, colref, rowId) {
	var primaryKey = xcsv.GetPrimaryKey(rowId);
	if(primaryKey == 0) return;
	
	var absRowId = xcsv.GetAbsoluteRowId(rowId);
	if(absRowId == null) return;
	var methods = [];
	methods.push({classname: "XCSV", method: "TakeOwnerShip", params: [xcsv.xmlFilePath, primaryKey]});
	methods = methods.concat(xcsv.XMLRPC.LoadField(rowId, colref));
	Packages.Library.$.CreateXMLRPCMethodCall({methods: methods});
};

Packages.Library.CSV.ColumnTypes.User.$.GiveUpOwnership = function(xcsv, colref, rowId) {
	var primaryKey = xcsv.GetPrimaryKey(rowId);
	if(primaryKey == 0) return;
	
	var absRowId = xcsv.GetAbsoluteRowId(rowId);
	if(absRowId == null) return;
	var methods = [];
	methods.push({classname: "XCSV", method: "GiveUpOwnerShip", params: [xcsv.xmlFilePath, primaryKey]});
	methods = methods.concat(xcsv.XMLRPC.LoadField(rowId, colref));
	Packages.Library.$.CreateXMLRPCMethodCall({methods: methods});
};

Packages.Library.CSV.ColumnTypes.User.$.DeleteRow = function(xcsv, colref, rowId) {
	var primaryKey = xcsv.GetPrimaryKey(rowId);
	if(primaryKey == 0) return;
	
	var absRowId = xcsv.GetAbsoluteRowId(rowId);
	if(absRowId == null) return;
	var res = confirm(xcsv.data.text.deleteConfirmBoxText);
	if(!res) {
		// Cancel pressed
		return;
	}
	
	// Remove row
	xcsv.DeleteRow(rowId);
};

/*******************************************************************************
 * EndUserEdit - gets the form field def to edit this value
 *
 * Returns the formfield
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.EndUserEdit = function(columndef, celldata, xcsv) {
	var users = Packages.Library.$.GetUsers();
	
	// Hide if we have no user list, or we do not have csv.edit permission
	if(users == null || !Packages.Library.$.IsPermission({permission: "csv.edit"})) return null;
	
	var options = [];
	for(var i = 0; i < users.length; i++) {
		options.push({
			name: users[i],
			value: users[i]
		});
	}
	
	return {
		type: "Options",
		commaString: 1,
		options: options
	}
};

/*******************************************************************************
 * DisplaySpecial - displays this data in a special format if required by a macro
 *
 * param - columndef : the columndef
 * param - celldata : cell content
 * param - xcsv : xcsv ref
 * param - rowid : current row id
 * param - options : options that were specified in the macro
 *
 * return - special format of the string, if it exists
 ******************************************************************************/
Packages.Library.CSV.ColumnTypes.User.$.DisplaySpecial = function(columndef, celldata, xcsv, rowid, options) {
	if(options.display == "singleLogon") {
		// Display as a single logon value, so it will display the users username-password
		
		var username = celldata;
		
		// Get the single logon value
		return Packages.Library.$.GetSingleLogonForUser({username: username});
	}
	return null;
};Package("Library.CSV.Controls").CategoryDescription = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	/*********************************************************************
	 * GetDetails - gets the details for this control
	 *
	 * returns a hash of details
	 ********************************************************************/
	this.GetDetails = function() {
		return {
			name: "categoryDescription",
			viewTypes: {"Listing": 1}
		}
	};
	
	/*********************************************************************
	 * GetControlHTML - creates the category description content for the current position
	 *
	 * returns the html for the locator
	 ********************************************************************/
	this.GetControlHTML = function(options) {
		var html = "";
		
		this.xcsv.View.elemIds.categoryDescriptionDiv = this.xcsv.idPrefix + "categorydescription";
		
		html += "<div id='" + this.xcsv.View.elemIds.categoryDescriptionDiv + "'>" + this.UpdateControl() + "<\/div>";
		
		return html;
	};
	/*********************************************************************
	 * UpdateControl - updates the locator for the current position
	 *
	 * Either updates the existing div (if there is one) or returns HTML for first time use
	 ********************************************************************/
	this.UpdateControl = function() {
		var html = "";
		
		for(var i = 0; i < this.xcsv.data.columndefs.length; i++) {
			var columndef = this.xcsv.data.columndefs[i];
			
			if(columndef.format != "Options") continue;
			
			// Find if a filter has been done for this column
			var filterby = this.xcsv.controls.filter.filterby[columndef.id];
			for(var filter in filterby) {
				// Find the option with this key
				var option = null;
				
				for(var o = 0; o < columndef.options.length; o++) {
					var safename = xcsv.SafeEncodeText(columndef.options[o].value);
					
					if(safename == filter) option = columndef.options[o];
				}
				
				if(option == null) continue;
				
				if(option.content != null) html += "<div class='xcsv_category_description'>" + option.content + "<\/div>";
			}
		}
		
		if(Packages.Library.$c.IsNode != 1) {
			// Update element
			var divelem = document.getElementById(this.xcsv.View.elemIds.categoryDescriptionDiv);
			if(divelem != null) divelem.innerHTML = html;
		}
		return html;
	};
};Package("Library.CSV.Controls").Compare = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	this.compares = [];
	/*********************************************************************
	 * GetDetails - gets the details for this control
	 *
	 * returns a hash of details
	 ********************************************************************/
	this.GetDetails = function() {
		return {
			name: "compare",
			viewTypes: {"Comparison": 1}
		}
	};
	
	/*********************************************************************
	 * GetControlHTML - creates the compare list area
	 *
	 * By default the area is completely empty, and only displays title etc when
	 * there is content in it
	 *
	 * returns the html for the comparelist
	 ********************************************************************/
	this.GetControlHTML = function() {
		var html = "";
		
		this.xcsv.View.elemIds.comparelistdiv = this.xcsv.idPrefix + "comparelist";
		
		html += "<div id='" + this.xcsv.View.elemIds.comparelistdiv + "'>" + this.UpdateCompareList() + "<\/div>";
		
		return html;
	};
	/*********************************************************************
	 * UpdateCompareList - updates the compare list for the current position
	 *
	 * Either updates the existing div (if there is one) or returns HTML for first time use
	 ********************************************************************/
	this.UpdateCompareList = function() {
		var html = "";
		
		if(this.compares.length != 0) {
			for(var i = 0; i < this.compares.length; i++) {
				html += "<div class='xcsv_compare_item'>";
				
				html += "<input type='checkbox' " +
							"checked='checked' " +
							"onchange=\"" + this.textvar + ".RemoveCompareItem(" + this.compares[i] + ")\"" +
						">";
				html += "<label>" + this.xcsv.GetRowName(this.compares[i]) + "<\/label>";
				
				html += "<\/div>";
			}
			
			// Finally, add a compare button
			html += "<button onclick=\"" + this.xcsv.View.textvar + ".SwitchView({viewref: '" + this.xcsv.data.defaultCompareView + "'})\">" +
						this.xcsv.data.text.compare +
					"<\/button>";
		}
		
		if(Packages.Library.$c.IsNode != 1) {
			// Update element
			var divelem = document.getElementById(this.xcsv.View.elemIds.comparelistdiv);
			if(divelem != null) divelem.innerHTML = html;
		}
		return html;
	};
	/*********************************************************************
	 * RemoveCompareItem - removes the specified item from the compares list
	 *
	 * param - rowid : rowid to remove
	 ********************************************************************/
	this.RemoveCompareItem = function(rowid) {
		// Remove item from list first, whether adding it or not
		for(var i = 0; i < this.compares.length; i++) {
			if(this.compares[i] == rowid) {
				this.compares.splice(i, 1);
				i--; // Correct for the fact we changed length of array
			}
		}
		
		// Update the compares box
		this.UpdateCompareList();
		
		// Update view, in case checkbox states changed
		this.xcsv.View.Redraw();
	};
	
	/*********************************************************************
	 * GetItemControl - gets the markup for the compare checkbox, can be called
	 * by a view to add to each row
	 *
	 * Although they look like checkboxes, their values are stored in this.compares
	 *
	 * When the checkboxes is selected their id is added to that array, and when
	 * deselected are removed from that array
	 *
	 * param - rowid : absolute row id
	 *
	 * returns the html for the compare box
	 ********************************************************************/
	this.GetItemControl = function(rowid) {
		var html = "";
		
		this.xcsv.View.elemIds.comparebox = this.xcsv.idPrefix + "comparebox";
		
		html += "<input " +
					"type='checkbox' " +
					"id='" + this.xcsv.View.elemIds.comparebox + rowid + "' " +
					(Packages.Library.$.Contains({array: this.compares, item: rowid}) ? "checked='checked' " : "") +
					"onchange=\"" + this.textvar + ".UpdateCompares(" + rowid + ")\" " +
				">";
		
		return html;
	};
	/*********************************************************************
	 * UpdateCompares - called when the state of a compare checkbox is changed
	 *
	 * param - rowid : absolute row id
	 ********************************************************************/
	this.UpdateCompares = function(rowid) {
		// Get the checkbox elem
		var elemid = this.xcsv.View.elemIds.comparebox + rowid;
		var elem = document.getElementById(elemid);
		if(elem == null) return;
		
		// Get state
		var state = elem.checked ? 1 : 0;
		
		// Remove item from list first, whether adding it or not
		for(var i = 0; i < this.compares.length; i++) {
			if(this.compares[i] == rowid) {
				this.compares.splice(i, 1);
				i--; // Correct for the fact we changed length of array
			}
		}
		
		if(state == 1) {
			// Add item to list
			this.compares.push(rowid);
		}
		
		this.UpdateCompareList();
	};
	
	/*********************************************************************
	 * ControlAlterArray - gets the items selected for compare
	 *
	 * param - array : array to work on (not used here)
	 *
	 * returns the filtered array
	 ********************************************************************/
	this.ControlAlterArray = function(array) {
		return this.xcsv.GetComparesArray(this.compares);
    };
};Package("Library.CSV.Controls").Filter = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	this.filterby = [];
	/*********************************************************************
	 * GetControlInitialSettings - sets up the initial filters
	 ********************************************************************/
	this.GetControlInitialSettings = function() {
		if(this.xcsv.settings.preloadFilters == 0) return;
		
		// Attempt to load previous filters from cookie
		var safeName = this.xcsv.GetSafeXCSVName();
		
		var cookieFilters = Packages.Library.$.GetCookies({})[safeName + "_filter"];
		if(Packages.Library.$.GetType({item: cookieFilters}) == "object") this.filterby = cookieFilters;
		
		// Create a temporary variable to store query filters
		var queryFilters = {};
		
		// Iterate through columns
		for(var i = 0; i < this.xcsv.data.columndefs.length; i++) {
			var columndef = this.xcsv.data.columndefs[i];
			
			// LEGACY: Read if there is a pre-selected filter in the query string
			var selected = Packages.Library.$.GetQuery({attr: "xcsv_filter_" + columndef.refcode});
			if(selected != null) {
				// There is, so set it to 1
				queryFilters[columndef.id] = {};
				queryFilters[columndef.id][selected] = 1;
			}
			
			// NEW: Check if each variation has been checked
			var variations = this.xcsv.GetVariations(columndef.id);
			for(var safevariationname in variations) {
				var checked = Packages.Library.$.GetQuery({attr: "xcsv_filter_" + columndef.refcode + "_" + safevariationname});
				if(checked == 1) {
					if(queryFilters[columndef.id] == null) queryFilters[columndef.id] = {};
					queryFilters[columndef.id][safevariationname] = 1;
				}
			}
		}
		
		// If we found some query filters, then use these filters
		if(Packages.Library.$.GetKeys({object: queryFilters}).length > 0) this.filterby = queryFilters;
	};
	/*********************************************************************
	 * GetDetails - gets the details for this control
	 *
	 * returns a hash of details
	 ********************************************************************/
	this.GetDetails = function() {
		return {
			name: "filter",
			viewTypes: {"Listing": 1}
		}
	};
	
	/*********************************************************************
	 * GetControlHTML - gets the markup for the filters area
	 *
	 * param - options : optional hash of options
	 *
	 * returns the html for the compare box
	 ********************************************************************/
	this.GetControlHTML = function(options) {
		var html = "";
		
		this.xcsv.View.elemIds.filterBox = this.xcsv.idPrefix + "filterbox";
		
		html += "<div id='" + this.xcsv.View.elemIds.filterBox + "'>" +
					this.UpdateControl() +
				"<\/div>";
		
		return html;
	};
	/*********************************************************************
	 * UpdateControl - Gets the filters for this table
	 * 
	 * Either updates the existing div (if there is one) or returns HTML for first time use
	 ********************************************************************/
	this.UpdateControl = function() {
		var table = this.xcsv.csvdata;
        if(table == null) return "";
        var filterhtml = "";
        filterhtml += "<h3>" + this.xcsv.data.text.filterby + "<\/h3>";
		
		// Count number of filters so that only first x are displayed
		this.unfilteredCounter = 0;
        
        // Get the filters available
        for(var i = 0; i < this.xcsv.data.columndefs.length; i++) {
            var columndef = this.xcsv.data.columndefs[i];
			if(columndef.filter == 0) continue; // Skip non filterable
			
			// Determine whether we have output our maximum number of filters
			if(this.xcsv.data.maxFilters != 0 && this.xcsv.data.maxFilters != null && this.unfilteredCounter > this.xcsv.data.maxFilters) continue;
			
			// Determine whether to show these filters or not.
			// Only show the filters, if they exist in the filteredVariations list
			
			var specificFilterHTML = this.GetSpecificFilter(columndef);
			if(specificFilterHTML != "") {
				filterhtml += specificFilterHTML;
			}
		}
		var html = "<div style='display:inline;'>";
        html += filterhtml;
		html += "<div class='xcsv_filter_base'><\/div>";
        html += "<\/div>";
		
        if(Packages.Library.$c.IsNode != 1) {
			// Update element
			var divelem = document.getElementById(this.xcsv.View.elemIds.filterBox);
			if(divelem != null) divelem.innerHTML = html;
		}
		return html;
	};
	
	/*********************************************************************
	 * GetSpecificFilter - Gets the specified filter
	 *
	 * param - columndef : the columndef
	 * param - options : (optional) hash of options, can contain:
	 * 				horizontal : 0 (default) display vertical, 1 display options horizontally (floated)
	 * 				single: 1 single selection only (radio), 0 (default) multi selection (checkbox)
	 * 				showTitle: 1 (default) show the filter category, 0 don't
	 * 				hideControl: 1 hide the radio / checkbox and highlight label when selected, 0 (default) show
	 * 				itemClass : class to place on each item
	 * 				unusedMore : 1 (default) display unused filters in 'More' section, 0 display inline
	 * 
	 * Returns the HTML containing the specific filter
	 ********************************************************************/
	this.GetSpecificFilter = function(columndef, options) {
		if(options == null) options = {};
		
		var filterhtml = "";
		
		// Get list of variations
		var allVariations = this.xcsv.GetVariations(columndef.id);
		var filteredVariations = this.xcsv.GetVariations(columndef.id, this.filterby);
		// Determine the complete set of options that would be available if no other filter was done on this column
		var _storeOwnFilters = this.filterby[columndef.id];
		this.filterby[columndef.id] = null;
		var otherGoodVariations = this.xcsv.GetVariations(columndef.id, this.filterby);
		// Restore own filters
		this.filterby[columndef.id] = _storeOwnFilters;
		
		// Does this specific filter group only contain empty fields, or no fields, in which case skip it
		if(Packages.Library.$.GetKeys({object: filteredVariations}).length == 0 ||
		   (Packages.Library.$.GetKeys({object: filteredVariations}).length == 1 && filteredVariations['_emptyfield'] != null)) {
			// Do not hide when no results match
			if(this.xcsv.ControlAlterArray(0).length > 0) {
				// Hides when the "None" is selected in a filter, so disabled, could not see why this code was added
				// return "";
			}
		}
		
		// Decide whether we are listing all variations (those selected and not selected)
		// Or just those variations available to us
		
		var variations;
		if(this.filterby[columndef.id] == null || Packages.Library.$.GetKeys({object: this.filterby[columndef.id]}).length == 0) {
			// Filter group not in use, display all available filters
			variations = filteredVariations;
		} else {
			// Filtering is done here, so show all options
			variations = otherGoodVariations;
		}
		
		// Do not show this filter if 1 option or less available
		if(Packages.Library.$.GetKeys({object: variations}).length <= 1) return "";
		
		// Display the filter group
		filterhtml += "<div class='xcsv_filter" +
						(options.hideControl == 1 ? " xcsv_filter_hide_control" : "") +
					"'>";
		
		if(options.showTitle != 0) filterhtml += "<span class='xcsv_filter_heading'>" + columndef.name + "<\/span>";
		
		// Create the options
		
		// Get the used and unused options
		var usedOptionsHTML = "";
		var unusedOptionsHTML = "";
		for(var safevariationname in variations) {
			var count = allVariations[safevariationname].count;
			var text = allVariations[safevariationname].text;
			
			// Skip if no text
			if(text == "") continue;
			
			var state = "";
			
			// Determine the filter state
			if(this.filterby[columndef.id] != null) {
				// Determine if this filter is already recorded as being on
				if(this.filterby[columndef.id][safevariationname] == 1) state = "checked='checked'";
				
				// Don't record ANY filter as being on, if all of the filters are on
				var allOff = 1;
				for(var variant in variations) {
					if(this.filterby[columndef.id][variant] != 1) allOff = 0;
				}
				if(allOff == 1) state = "";
			}
			
			var onChange = "";
			var href = null;
			if(Packages.Library.$c.IsNode == 1) {
				var ADQoptions = {localQueries: {}};
				var filterKey = "xcsv_filter_" + columndef.refcode + "_" + safevariationname;
				if(state == "") {
					ADQoptions.localQueries[filterKey] = 1;
				} else {
					ADQoptions.queryGroup = filterKey; // Remove it
				}
				href = Packages.Library.$.AddGlobalQueries(ADQoptions);
				onChange = "window.location = '" + href + "'";
			} else {
				onChange = this.xcsv.View.textvar + ".DoFilterSort()"
			}
			
			var optionHTML = "";
			
			var labelText = text;
			if(href != null) {
				labelText = "<a " +
								" " + (href != null ? "href=\"" + href + "\"" : "") +
								">" +
									labelText +
								"<\/a>";
			}
			
			optionHTML += "<span class='xcsv_filter_option " +
									(options.horizontal == 1 ? "xcsv_filter_option_horizontal" : "xcsv_filter_option_vertical") +
									(options.itemClass != null ? " " + options.itemClass : "") +
								"'" +
								(text == "" ? " style='display:none" : "") + // Do not display blank entries
							">";
								
			optionHTML += "<input type='" + (options.single == 1 ? "radio" : "checkbox") + "' " +
							"id='" + this.xcsv.idPrefix + "filter_" + columndef.id + "_" + safevariationname + "' " +
							"name='" + this.xcsv.idPrefix + "filter_" + columndef.id + "' " +
							"onchange=\"" + onChange + "\" " +
							state +
							">";
			optionHTML += "<label for='" + this.xcsv.idPrefix + "filter_" + columndef.id + "_" + safevariationname + "'>" + labelText + "<\/label>";
			optionHTML += "<\/span>";
			
			// Is option used?
			if(this.filterby[columndef.id] != null && this.filterby[columndef.id][safevariationname]) {
				usedOptionsHTML += optionHTML;
			} else {
				unusedOptionsHTML += optionHTML;
			}
		}
		
		if(usedOptionsHTML == "") this.unfilteredCounter++;
		
		// Add used options
		filterhtml += usedOptionsHTML;
		
		// Add unused options
		if(unusedOptionsHTML != "" && usedOptionsHTML != "" && options.unusedMore != 0) {
			filterhtml += Packages.Library.$.CreateFoldArea({
				title: this.xcsv.data.text.filterMore,
				content: unusedOptionsHTML,
				foldable: 1,
				folded: 1
			});
		} else {
			filterhtml += unusedOptionsHTML;
		}
		
		filterhtml += "<\/div>";
		
		return filterhtml;
	};
	
	/*********************************************************************
	 * GetControlState - gets the current state of the filters from elements
	 ********************************************************************/
	this.GetControlState = function() {
		var array = this.xcsv.csvdata;
        if (array == null) return;
		
		// Get the filters
		var filterby = [];
		for(var i = 0; i < this.xcsv.data.columndefs.length; i++) {
			var columndef = this.xcsv.data.columndefs[i];
			if(columndef.filter == 0) continue; // Skip non filterable
			
			// Store selected
			var selected = {};
			
			// Get list of checkboxes
			var filterVariations = this.xcsv.GetVariations(columndef.id);
			
			// Did stored filterby contains anything useful, or did it just have everything selected?
			// If it had everything selected, it means it was in default behaviour
			var previouslyFiltered = 0;
			if(this.filterby[columndef.id] != null &&
			   Packages.Library.$.GetKeys({object: this.filterby[columndef.id]}).length !=
			   Packages.Library.$.GetKeys({object: filterVariations}).length) previouslyFiltered = 1;
			
			// Create the options
			for(var safevariationname in filterVariations) {
				var count = filterVariations[safevariationname].count;
				var text = filterVariations[safevariationname].text;
				
				// Get the checkbox ... 'xcsv_filter_" + columndef.id + "_" + safevariationname + "'
				var checkboxelem = document.getElementById(this.xcsv.idPrefix + "filter_" + columndef.id + "_" + safevariationname);
				
				var state = 0;
				// Try and get state from the main filters object
				if(previouslyFiltered == 1) state = this.filterby[columndef.id][safevariationname];
				if(checkboxelem != null) {
					// We have a checkbox so use that
					state = checkboxelem.checked ? 1 : 0;
				}
				
				// Record this state
				if(state == 1) selected[safevariationname] = state;
			}
			
			filterby[columndef.id] = selected;
		}
		this.filterby = filterby;
		
		// Store in a cookie
		var safeName = this.xcsv.GetSafeXCSVName();
		var hash = {};
		hash[safeName + "_filter"] = filterby;
		Packages.Library.$.SetCookie({
			hash: hash
		});
	};
	
	/*********************************************************************
	 * ControlAlterArray - Filters the data by this.filterby and returns
	 * the filtered array
	 *
	 * param - array : array to work on
	 *
	 * returns the filtered array
	 ********************************************************************/
	this.ControlAlterArray = function(array) {
		return this.xcsv.GetFilteredArray(array, this.filterby);
    };
};Package("Library.CSV.Controls").Group = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	this.groupby = null;
	this.previousGroup = null;
	/*********************************************************************
	 * GetDetails - gets the details for this control
	 *
	 * returns a hash of details
	 ********************************************************************/
	this.GetDetails = function() {
		return {
			name: "group",
			viewTypes: {"Listing": 1}
		}
	};
	
	/*********************************************************************
	 * GetControlHTML - Gets the groupbox list for this table
	 *
	 * returns the HTML for the sorter
	 ********************************************************************/
	this.GetControlHTML = function() {
        var table = this.xcsv.csvdata;
        if (table == null) return "";
        
        // Create the groups
        var grouphtml = "";
		grouphtml += "<div class='xcsv_grouper'>" + this.xcsv.data.text.groupby + "&nbsp;";
        grouphtml += "<select id='" + this.xcsv.idPrefix + "grouper' onchange=\"" + this.xcsv.View.textvar + ".DoFilterSort()\">";
        
		var groupcount = 0;
		// Add 'none' option
		if(this.xcsv.data.text.groupnone != "") {
			grouphtml += "<option value='nogroup' " + (this.groupby == "nogroup" ? "selected='selected'" : "") + ">" + this.xcsv.data.text.groupnone + "<\/option>";
			groupcount++;
		}
        // Get the groups available
        for(var i = 0; i < this.xcsv.data.columndefs.length; i++) {
            var columndef = this.xcsv.data.columndefs[i];
			if(columndef.group == 0) continue; // Skip non groupable
			
			groupcount++;
			
            // Create the options
			grouphtml += "<option value='" + columndef.id + "' " + (this.groupby == columndef.id ? "selected='selected'" : "") + ">" + columndef.name + "<\/option>";
        }
		
        grouphtml += "<\/select>";
        grouphtml += "<\/div>";
		if(groupcount <= 1) return ""; // Whats the point!
        return grouphtml;
    };
	
	/*********************************************************************
	 * GetControlState - gets the current state of the groupbox from elements
	 ********************************************************************/
	this.GetControlState = function() {
		// Get the group by
        var grouperelem = document.getElementById(this.xcsv.idPrefix + "grouper");
		if(grouperelem != null) this.groupby = grouperelem.value;
	};
	
	/*********************************************************************
	 * ControlAlterArray - alters the array of data and spplies the grouping
	 *
	 * param - array : array to work on
	 *
	 * returns the sorted array
	 ********************************************************************/
	this.ControlAlterArray = function(array) {
		if(this.groupby == "nogroup") return array;
		
		return this.xcsv.GetSortedArray(array, this.groupby);
    };
	
	/*********************************************************************
	 * InitControlView - initialises group for this view
	 *
	 * returns the sorted array
	 ********************************************************************/
	this.InitControlView = function(viewdef) {
		if(this.groupby == null && viewdef.defaultgroup != null) {
			var col = Packages.Library.$.FindArrayItem({array: this.xcsv.data.columndefs, path: "refcode", value: viewdef.defaultgroup});
			if(col != null) this.groupby = col.id;
		}
    };
	
	/*********************************************************************
	 * GetItemControlHeading - initialises group for this view
	 *
	 * param - rowdata : the row data dummy object
	 *
	 * returns the heading, or null if not needed
	 ********************************************************************/
	this.GetItemControlHeading = function(rowdata) {
		if(rowdata[this.groupby] != this.previousGroup) {
			this.previousGroup = rowdata[this.groupby];
			return rowdata[this.groupby];
		}
		return null;
	}
};Package("Library.CSV.Controls").Locator = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	/*********************************************************************
	 * GetDetails - gets the details for this control
	 *
	 * returns a hash of details
	 ********************************************************************/
	this.GetDetails = function() {
		return {
			name: "locator",
			viewTypes: {"Listing": 1}
		}
	};
	
	/*********************************************************************
	 * GetControlHTML - creates the locator for the current position
	 *
	 * returns the html for the locator
	 ********************************************************************/
	this.GetControlHTML = function() {
		var html = "";
		
		this.xcsv.View.elemIds.locatordiv = this.xcsv.idPrefix + "locator";
		
		html += "<div id='" + this.xcsv.View.elemIds.locatordiv + "'>" + this.UpdateControl() + "<\/div>";
		
		return html;
	};
	/*********************************************************************
	 * UpdateControl - updates the locator for the current position
	 *
	 * Either updates the existing div (if there is one) or returns HTML for first time use
	 ********************************************************************/
	this.UpdateControl = function() {
		var html = "";
		
		for(var i = 0; i < this.xcsv.data.drilldown.length; i++) {
			var drilldowndef = this.xcsv.data.drilldown[i];
			
			var columnref = drilldowndef.refcode;
			
			// Get columndef
			var columndef = Packages.Library.$.FindArrayItem({array: this.xcsv.data.columndefs, path: "refcode", value: columnref});
			
			// Find if a filter has been done for this column
			var filterby = this.xcsv.controls.filter.filterby[columndef.id];
			if(filterby == null) continue;
			var keys = Packages.Library.$.GetKeys({object: filterby});
			
			// Do we have a single key? If not, locator ends here.
			if(keys.length != 1) break;
			
			// We want to display the filter, and not the name, so we
			// need to look up in the Variations for the matching filter
			// and gets its name.
			// Get variations
			var variations = this.xcsv.GetVariations(columndef.id);
			
			
			if(variations[keys[0]] != null) {
				html += (html != "" ? " &rarr; " : "") + variations[keys[0]].text;
			}
		}
		if(Packages.Library.$c.IsNode != 1) {
			// Update element
			var divelem = document.getElementById(this.xcsv.View.elemIds.locatordiv);
			if(divelem != null) divelem.innerHTML = html;
		}
		return html;
	};
};Package("Library.CSV.Controls").Pager = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	/*********************************************************************
	 * GetDetails - gets the details for this control
	 *
	 * returns a hash of details
	 ********************************************************************/
	this.GetDetails = function() {
		return {
			name: "pager",
			viewTypes: {"Listing": 1},
			order: 2
		}
	};
	
	/*********************************************************************
	 * GetControlInitialSettings - fetches selected page
	 ********************************************************************/
	this.GetControlInitialSettings = function() {
		var selectedPage = Packages.Library.$.GetQuery({attr: "xcsv_control_page"});
		if(selectedPage != null) this.currentPage = selectedPage;
	}
	
	/*********************************************************************
	 * GetControlHTML - Gets the sorter for this table
	 *
	 * returns the HTML for the sorter
	 ********************************************************************/
	this.GetControlHTML = function() {
		
		var html = "";
		
		this.xcsv.View.elemIds.pagerBox = this.xcsv.idPrefix + "pagerbox";
		
		html += "<div id='" + this.xcsv.View.elemIds.pagerBox + "'>" +
					this.UpdateControl() +
				"<\/div>";
		
		return html;
    };
	
	this.getPageAttributes = function(page) {
		var onClick = "";
		var href = null;
		if(Packages.Library.$c.IsNode == 1) {
			href = Packages.Library.$.AddGlobalQueries({
				localQueries: {
					xcsv_control_page: page
				}
			});
		} else {
			onClick = this.textvar + ".DoPage(" + page + ")"
		}
		
		return "onclick=\"" + onClick + "\" " + (href != null ? "href=\"" + href + "\"" : "");
	}
	
	/*********************************************************************
	 * UpdateControl - Gets the paging for this table
	 * 
	 * Either updates the existing div (if there is one) or returns HTML for first time use
	 ********************************************************************/
	this.UpdateControl = function() {
		// Get pager
		var html = "";
		if(this.pagesize == null || this.pagesize == "") return "";
		if(this.currentPage == null) return "";
		html += "<div class='xcsv_pager'>";
		html += "<a "
				+	(this.currentPage == 0 ? "style='visibility: hidden' " : "")
				+	"class='xcsv_page xcsv_page_previous' "
				+	this.getPageAttributes(this.currentPage - 1)
			+	">"
				+	this.text_previous
			+	"<\/a>&nbsp;&nbsp;";
		if(this.numberpages > 1) {
			for(var i = 0; i < this.numberpages; i++) {
			html += "<a " +
						"class='xcsv_page xcsv_page_number" + (this.currentPage == i ? " xcsv_page_number_selected" : "") + "' " +
							this.getPageAttributes(i) +
						">" +
							(i + 1) +
					"<\/a>&nbsp;&nbsp;";
			}
		}
		html += "<a "
				+	(this.currentPage == this.numberpages - 1 ? "style='visibility: hidden' " : "")
				+	"class='xcsv_page xcsv_page_next' "
				+	this.getPageAttributes(this.currentPage + 1)
			+	">"
				+	this.text_next
			+	"<\/a>&nbsp;&nbsp;";
		html += "<\/div>";
		
		if(Packages.Library.$c.IsNode != 1) {
			// Update element
			var divelem = document.getElementById(this.xcsv.View.elemIds.pagerBox);
			if(divelem != null) divelem.innerHTML = html;
		}
		return html;
	};
	
	/*********************************************************************
	 * DoPage - onchange event for pager
	 *
	 * param - page : new page to select
	 *
	 * Redraws the current view
	 ********************************************************************/
	this.DoPage = function(page) {
		this.currentPage = page;
		
		// Redraw current view
		this.xcsv.View.Redraw();
	};
	
	/*********************************************************************
	 * GetControlState - gets the current state of the sorts from elements
	 ********************************************************************/
	this.GetControlState = function() {};
	
	/*********************************************************************
	 * ControlAlterArray - alters the array of data to contain just the current page
	 *
	 * param - array : array to work on
	 *
	 * returns the current page of the array
	 ********************************************************************/
	this.ControlAlterArray = function(array) {
		if(array.length == 0 || this.pagesize == null || this.pagesize == "") return array;
		this.numberpages = Math.ceil(array.length / this.pagesize);
		if(this.currentPage == null || this.currentPage < 0) this.currentPage = 0;
		if(this.currentPage >= this.numberpages) this.currentPage = this.numberpages - 1;
		
		// Get first row
		var firstrow = this.currentPage * this.pagesize;
		var lastrow = firstrow + this.pagesize;
		if(lastrow >= array.length) lastrow = array.length;
		
		// Alter array
		var pageArray = [];
		for(var i = firstrow; i < lastrow; i++) {
			pageArray.push(array[i]);
		}
		
		return pageArray;
    };
	
	/*********************************************************************
	 * InitControlView - initialises this control
	 *
	 * returns the sorted array
	 ********************************************************************/
	this.InitControlView = function(viewdef) {
		if(viewdef.pagesize != null) this.pagesize = viewdef.pagesize * 1;
		
		if(this.text_previous == null) this.text_previous = viewdef.text_previous;
		if(this.text_previous == null) this.text_previous = "&lt;";
		if(this.text_next == null) this.text_next = viewdef.text_next;
		if(this.text_next == null) this.text_next = "&gt;";
    };
};Package("Library.CSV.Controls").Search = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	this.searchby = Packages.Library.$.GetQuery({attr: "xcsv_searchby"});
	if(this.searchby == null) this.searchby = "";
	/*********************************************************************
	 * GetDetails - gets the details for this control
	 *
	 * returns a hash of details
	 ********************************************************************/
	this.GetDetails = function() {
		return {
			name: "search",
			viewTypes: {"Listing": 1}
		}
	};
	
	/*********************************************************************
	 * GetControlHTML - creates the searchbox
	 *
	 * returns the html for the searchbox
	 ********************************************************************/
	this.GetControlHTML = function() {
		var html = "";
		
		this.xcsv.View.elemIds.searchboxdiv = this.xcsv.idPrefix + "searchbox";
		
		var onClick = "";
		var onChange = "";
		var href = "";
		if(Packages.Library.$c.IsNode == 1) {
			href = Packages.Library.$.AddGlobalQueries({});
			onClick = "return true;";
		} else {
			onChange = this.xcsv.View.textvar + ".DoSearch()";
			onClick = onChange + "; return false; window.event.stopPropagation();";
			href = null;
		}
		
		html += "<input " +
					"class='xcsv_searchbox' " +
					"type='text' " +
					"id='" + this.xcsv.View.elemIds.searchboxdiv + "' " +
					"name='xcsv_searchby' " +
					"value='" + this.searchby + "' " +
					"onkeyup=\"" + onChange + "\"" +
				">";
		
		if(href != null) {
			html += "<input type='submit' class='xcsv_searchbutton mbutton' onclick=\"" + onClick + "\" value='" + this.xcsv.data.text.search + "'>";
			
			html = "<form "
					+	(href != null ? "action='" + href + "' " : "")
				+	">"
					+	html
				+	"<\/form>";
		} else {
			html += "<button class='xcsv_searchbutton mbutton' onclick=\"" + onClick + "\">" + this.xcsv.data.text.search + "<\/button>";
		}
		
		return html;
	};
	/*********************************************************************
	 * DoSearch - onclick event for the search box
	 ********************************************************************/
	this.DoSearch = function() {
		this.searchby = document.getElementById(this.xcsv.View.elemIds.searchboxdiv).value;
		
		// Redraw current view
		this.xcsv.View.Redraw();
	};
	
	/*********************************************************************
	 * ControlAlterArray - alters the array of data and spplies the searching
	 *
	 * param - array : array to work on
	 *
	 * returns the sorted array
	 ********************************************************************/
	this.ControlAlterArray = function(array) {
		return this.xcsv.GetSearchedArray(array, this.searchby);
    };
};Package("Library.CSV.Controls").Sorter = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	this.sortby = null;
	/*********************************************************************
	 * GetControlInitialSettings - sets up the initial filters
	 ********************************************************************/
	this.GetControlInitialSettings = function() {
		if(this.xcsv.settings.preloadFilters == 0) return;
		
		var selectedSort = Packages.Library.$.GetQuery({attr: "xcsv_sort"});
		
		if(selectedSort != null) this.sortby = selectedSort;
	}
	/*********************************************************************
	 * GetDetails - gets the details for this control
	 *
	 * returns a hash of details
	 ********************************************************************/
	this.GetDetails = function() {
		return {
			name: "sort",
			viewTypes: {"Listing": 1},
			order: 1
		}
	};
	
	/*********************************************************************
	 * GetControlHTML - Gets the sorter for this table
	 *
	 * returns the HTML for the sorter
	 ********************************************************************/
	this.GetControlHTML = function() {
        var table = this.xcsv.csvdata;
        if (table == null) return "";
		
		var onChange = "";
		if(Packages.Library.$c.IsNode == 1) {
			var ADQoptions = {localQueries: {}};
			ADQoptions.localQueries["xcsv_sort"] = "<%sort%>";
			var href = Packages.Library.$.AddGlobalQueries(ADQoptions);
			onChange = "window.location = '" + href + "'.replace(/<%sort%>/, this.value)";
		} else {
			onChange = this.xcsv.View.textvar + ".DoFilterSort()";
		}
        
		// Create the sort
        var sorthtml = "";
		sorthtml += "<div class='xcsv_sorter'>" + this.xcsv.data.text.sortby + "&nbsp;";
        sorthtml += "<select id='" + this.xcsv.idPrefix + "sort' onchange=\"" + onChange + "\">";
        
		var sortcount = 0;
        // Get the sorts available
        for(var i = 0; i < this.xcsv.data.columndefs.length; i++) {
            var columndef = this.xcsv.data.columndefs[i];
			if(columndef.sort == 0) continue; // Skip non sortable
			
			sortcount++;
			
            // Create the options
			sorthtml += "<option value='" + columndef.id + "' " + (this.sortby == columndef.id ? "selected='selected'" : "") + ">" + columndef.name + "<\/option>";
        }
		
        sorthtml += "<\/select>";
        sorthtml += "<\/div>";
		if(sortcount <= 1) return ""; // Whats the point!
        return sorthtml;
    };
	
	/*********************************************************************
	 * GetControlState - gets the current state of the sorts from elements
	 ********************************************************************/
	this.GetControlState = function() {
		// Get the sort by
        var sorterelem = document.getElementById(this.xcsv.idPrefix + "sort");
		if(sorterelem != null) this.sortby = sorterelem.value;
	};
	
	/*********************************************************************
	 * ControlAlterArray - alters the array of data and spplies the sorting
	 *
	 * param - array : array to work on
	 *
	 * returns the sorted array
	 ********************************************************************/
	this.ControlAlterArray = function(array) {
		return this.xcsv.GetSortedArray(array, this.sortby);
    };
	
	/*********************************************************************
	 * InitControlView - initialises group for this view
	 *
	 * returns the sorted array
	 ********************************************************************/
	this.InitControlView = function(viewdef) {
		if(this.sortby == null && viewdef.defaultsort != null) {
			var col = Packages.Library.$.FindArrayItem({array: this.xcsv.data.columndefs, path: "refcode", value: viewdef.defaultsort});
			if(col != null && col.sort != 0) this.sortby = col.id;
		}
		if(this.sortby == null) {
			// Still not a vlaid sort order, so use first columndef that supports sorting
			for(var i = 0; i < this.xcsv.data.columndefs.length; i++) {
				var columndef = this.xcsv.data.columndefs[i];
				if(columndef.sort == 0) continue; // Skip non sortable
				this.sortby = columndef.id;
				break;
			}
		}
    };
};/**********************************
 * CSV View - contains additional API subroutines from a CSV object
 *
 * Accessed using the CSV object .View.<api subroutine name>
 *
 * param - xcsv - reference to parent object
 *********************************/
Package("Library.CSV").View = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	this.elemIds = {};
	this.xcsv.cache.view = {};
	this.current = {xcsv: xcsv};
	this.viewTypes = {};
	this.history = [];
	/*********************************************************************
	 * DoFilterSort - onchange event for all filters and sorts and grouping
	 *
	 * Reloads the state of all filters, and redraws the current view
	 ********************************************************************/
	this.DoFilterSort = function() {
		// Redraw current view
		this.Redraw();
	};
	/*********************************************************************
	 * Redraw - Redraws the current view
	 ********************************************************************/
	this.Redraw = function() {
		// Redraw current view
		var elem;
		if(Packages.Library.$c.IsNode != 1) elem = document.getElementById(this.xcsv.idPrefix + 'viewarea_' + this.currentAreaId);
		
		if(elem == null) return; // Called to early
		
		// Are we allowing this view to be refreshed? Usually disabled when editing as you loose changes
		if(this.current.viewdef != null && this.current.viewdef.reloadOnRedraw == 0) {
			// Do not redraw
			return;
		}
		this.GetView(elem);
	};
	/*********************************************************************
	 * GetViewArea - gets a view area that can display any view
	 * 
	 * param - options : hash of options, must contain:
	 * 		areaid : the unique name for this view area
	 * 	may contain
	 * 		rowId : (optional) the row in focus (ignored when viewing all rows)
	 * 		viewref : (optional) the view ref code, if not specified creates blank area
	 * 		interactive : (optional) 1 (default) interactive mode, 0 disable redirects and pop ups
	 * 		allowQuery : (optional) 1 allows query string to override view, 0 (default) don't
	 * 
	 * returns the HTML for view requested
	 ********************************************************************/
	this.GetViewArea = function(options) {
		this.currentAreaId = options.areaid;
		if(options.viewref != null) this.current.viewref = options.viewref;
		if(options.rowId != null) this.current.rowId = options.rowId;
		if(options.allowQuery != null) this.current.allowQuery = options.allowQuery;
		var html = "<div id='" + this.xcsv.idPrefix + "viewarea_" + options.areaid + "'>";
		html += this.GetView();
		html += "<\/div>";
		return html;
	};
	/*********************************************************************
	 * SwitchView - switches the view area to the specified view, anything
	 * not specified will use existing settings
	 * 
	 * param - options : hash of options, may contain:
	 * 			areaid : the unique name for this view area
	 * 			rowId : the current selected row, or null for none
	 * 			viewref : the current view def refcode
	 * 
	 * returns the HTML for view requested
	 ********************************************************************/
	this.SwitchView = function(options) {
		if(options.areaid == null) options.areaid = this.currentAreaId;
		
		if(options.viewref != null) this.current.viewref = options.viewref;
		if(options.rowId != null) this.current.rowId = options.rowId;
		
		var elem;
		if(Packages.Library.$c.IsNode != 1) elem = document.getElementById(this.xcsv.idPrefix + 'viewarea_' + options.areaid);
		if(elem == null) {
			Packages.Library.$.LogInfo({mesg: "Can not update element viewarea", location: "Packages.Library.CSV.View.SwitchView", type: "Error", level: 3});
			return null;
		} else {
			return this.GetView(elem);
		}
	};
	/*********************************************************************
	 * GetViewTypeObject - gets the object for the specified View Type
	 *
	 * param - options : hash of options, must contain:
	 * 			viewType : the view type
	 * 		may contain:
	 * 			setCurrent : 1 set as current, 0 (default) don't
	 *
	 * returns the object (will create or re-use) or null if not found
	 ********************************************************************/
	this.GetViewTypeObject = function(options) {
		var viewType = options.viewType;
		if(this.viewTypes[viewType] == null && Packages.Library.CSV.ViewTypes[viewType] != null) {
			this.viewTypes[viewType] = new Packages.Library.CSV.ViewTypes[viewType].view();
		}
		if(this.viewTypes[viewType] == null) return null;
		// This will cause all View Defs to essentially share the same this.current as a global variable
		this.viewTypes[viewType].SetOptions(this.current);
		if(options.setCurrent) this.current.viewType = this.viewTypes[viewType];
		return this.viewTypes[viewType];
	};
	/*********************************************************************
	 * UpdateRowId - updates the rowId
	 *
	 * param - rowId : new row id
	 * param - setAsCurrent : (optional) 1 (default) also sets this row as the currently selected row
	 * 									 0 leaves the currently select row alone
	 ********************************************************************/
	this.UpdateRowId = function(rowId, setAsCurrent) {
		this.current.rowId = rowId;
		this.current.rowdata = null;
		this.current.dummyrow = null;
		
		if(setAsCurrent != 0) this.current.selectedRowId = rowId;
		
		if(this.current.rowId != null) {
			// Get information
			this.current.dummyrow = xcsv.GetDummyRow(this.current.rowId);
			this.current.rowdata = this.xcsv.GetRowData(this.current.rowId);
		}
	}
	/*********************************************************************
	 * GetView - gets the specified view
	 *
	 * Renders the currently selected ViewDef with the current selection
	 *
	 * param - elem : (optional) elem to place content in on completion
	 * 
	 * returns the HTML for view requested
	 ********************************************************************/
	this.GetView = function(elem) {
		if(this.current.viewref == null) this.current.viewref = this.xcsv.data.defaultView;
		if(this.current.initialviewref != null && this.current.allowQuery == 1) {
			// Test if this view def exists
			if(Packages.Library.$.FindArrayItem({
				array: this.xcsv.data.viewdefs,
				path: "refcode",
				value: this.current.initialviewref}
			) != null) {
				// Forced initial view ref - used when query contains a view
				this.current.viewref = this.current.initialviewref;
			}
			this.current.initialviewref = null;
		}
		
		var setViewRefRes = this.SetViewDef();
		if(setViewRefRes != null) return setViewRefRes;
		
		// Clear some settings from this.current
		this.current.onClick = null;
		this.current.url = null;
		
		this.UpdateRowId(this.current.rowId);
		
		// Is this a history point?
		if(this.current.viewdef.historyPoint != 0) {
			// Ensure this item is not currently in the 'last' position
			if(this.history.length == 0
			|| this.history[this.history.length - 1] != this.current.viewref) {
				this.history.push(this.current.viewref);
			}
		}
		
		// Reset view cache
		this.xcsv.cache.view = {};
		
		// Initialise controls to this viewdef
		this.InitControlView();
		
		// Get control states
		this.GetControlStates();
		
		// Pre Process Data
		this.current.viewType.PreProcessData();
		
		// Update controls
		this.UpdateControls();
		
		// Call the view display for this ViewDef type
		var html = this.current.viewType.Display();
		
		if(html == null) {
			Packages.Library.$.LogInfo({mesg: "viewType.Display returned null in viewtype [" + this.current.viewdef.viewtype + "]", location: "Packages.Library.CSV.View.GetView", type: "Error", level: 2});
			html = this.xcsv.data.text.errorText;
		}
		
		if(!html.match(/<%Links%Gen%>/)) {
			html += "<%Links%Gen%>";
		}
		var genLinks = "";
		// Add general links to other views fields
		if(this.current.viewdef.viewdefGeneralLinks.length > 0) {
			genLinks += "<div class='xcsv_links xcsv_general_links'>";
			genLinks += this.GetViewLinksHTML(this.current.viewdef.viewdefGeneralLinks);
			genLinks += "<\/div>";
		}
		html = html.replace(/<%Links%Gen%>/g, genLinks);
		
		// Apply any wrappers
		html = this.ApplyWrappers({
			html: html,
			wrappers: this.current.viewdef.generalWrappers,
			wrapperDef: this.current.viewdef.generalWrapperDef
		});
		
		// Printer popup mode?
		if(this.current.viewdef.printPopup == 1) {
			Packages.Library.$.CreatePrintPopup({
				content: html,
				title: this.current.viewdef.title
			})
		}
		
		if(elem) {
			elem.innerHTML = html;
			
			// Now called PostAction if there is one
			if(this.current.viewType.PostAction != null) this.current.viewType.PostAction();
		}
		
		return html;
	}
	
	/*******************************************************************************
	 * SetViewDef - sets the current view def to the viewref specified
	 *
	 * param - viewRef : (optional) the name of the view ref, or this.current.viewref
	 *
	 * returns an error message if an error occurs, or null on success
	 ******************************************************************************/
	this.SetViewDef = function(viewRef) {
		if(viewRef != null) this.current.viewref = viewRef;
		if(this.current.viewref == null) return null; // Can not work until a view def exists
		
		// Determine ViewDef in use
		this.current.viewdef = Packages.Library.$.FindArrayItem({array: this.xcsv.data.viewdefs, path: "refcode", value: this.current.viewref});
		
		if(this.current.viewdef == null) return "View def [" + this.current.viewref + "] not found";
		
		// Do we need to check permissions?
		if(this.current.viewdef.permissionRedirects != null && this.current.viewdef.permissionRedirects.length > 0) {
			for(var i = 0; i < this.current.viewdef.permissionRedirects.length; i++) {
				var permissionRedirect = this.current.viewdef.permissionRedirects[i];
				if(!Packages.Library.$.IsPermission({
					permission: permissionRedirect.permission
				})) {
					// The user does not have this permission
					// Set the redirect viewdef as the current one, and return the call to SetViewDef
					return this.SetViewDef(permissionRedirect.viewRef);
				}
			}
		}
		
		if(Packages.Library.CSV.ViewTypes[this.current.viewdef.viewtype] == null) {
			Packages.Library.$.LogInfo({mesg: "Unable to load the current View Details [" + this.current.viewdef.viewtype + "]", location: "Packages.Library.CSV.View.GetView", type: "Bad View Def", level: 2});
			return "View error";
		}
		this.current.viewDetails = Packages.Library.CSV.ViewTypes[this.current.viewdef.viewtype].$.GetDetails();
		
		var viewType = this.GetViewTypeObject({viewType: this.current.viewdef.viewtype, setCurrent: 1});
		if(viewType == null) {
			Packages.Library.$.LogInfo({mesg: "Unable to load the current View Object [" + this.current.viewdef.viewtype + "]", location: "Packages.Library.CSV.Views.Custom.$.DoReplacements", type: "Bad View Def", level: 2});
			return "View error";
		}
		
		return null;
	}
	
	/*******************************************************************************
	 * GetViewForForeignXCSVCall - gets the view of this XCSV for a call fromm a Foreign XCSV
	 * table. Called from the ForeignXCSV column code
	 *
	 * param - options : hash of options, must contain:
	 * 			rowId : the rowId
	 * 		may contain:
	 * 			viewRef : the name of the foreign view ref, or null to use just the name
	 * 			disableOnClick : 1 to disable onclick, 0 (default) to allow
	 *
	 * Returns the html or "" if not found
	 ******************************************************************************/
	this.GetViewForForeignXCSVCall = function(options) {
		// Cache the current View.current data
		var _cachedViewCurrent = this.current;
		
		// Set View.current to a clone of itself
		this.current = {xcsv: this.xcsv};
		
		var html = this.GetViewRowByViewRef(options);
		
		// Restore View.current
		this.current = _cachedViewCurrent;
		
		return html;
	}
	
	/*******************************************************************************
	 * GetViewRowByViewRef - gets the view row by its view ref (called from Foreign XCSV)
	 *
	 * param - options : hash of options, must contain:
	 * 			rowId : the rowId
	 * 		may contain:
	 * 			viewRef : the name of the foreign view ref, or null to use just the name
	 * 			disableOnClick : 1 to disable onclick, 0 (default) to allow
	 *
	 * Returns the html or "" if not found
	 ******************************************************************************/
	this.GetViewRowByViewRef = function(options) {
		// Generate html
		var html = "";
		
		this.UpdateRowId(options.rowId);
		
		// Do we have a view?
		if(options.viewRef == "") options.viewRef = null;
		if(options.viewRef == null) {
			// No, just display the name
			html += this.xcsv.GetRowName(options.rowId);
		} else {
			// Set this viewRef
			var setViewRefRes = this.SetViewDef(options.viewRef);
			if(setViewRefRes != null) return setViewRefRes;
			
			this.current.disableOnClick = options.disableOnClick;
			
			// Display
			html += this.xcsv.View.GetViewRow();
		}
		return html;
	};
	
	/*********************************************************************
	 * GetViewRow - gets the specified view of a single row
	 * 
	 * returns the HTML for view requested or null if not allowed by conditions
	 ********************************************************************/
	this.GetViewRow = function() {
		if(this.current.viewdef == null) return null;
		if(this.current.dummyrow == null) {
			Packages.Library.$.LogInfo({mesg: "No Row Defined", location: "Packages.Library.CSV.View.GetViewRow", type: "Error", level: 3});
			return null; // Can not display no row
		}
		
		// Does the user have permission to see this row?
		// Get user column def
		var userColumnDef = this.xcsv.GetUserColumnDef();
		if(userColumnDef != null && Packages.Library.$.IsPermission({permission: "csv.edit"}) == 0) {
			if(userColumnDef.showUserRowOnly == 1) {
				// Show only the current users row, so return null if not the current users row
				var userState = this.xcsv.GetUserState(this.current.rowId);
				
				if(!(userState & Packages.Library.CSV.$c.CSV.ROW_OWNERSHIP_SELFOWNED)) {
					Packages.Library.$.LogInfo({mesg: "Row not self owned on rowid [" + this.current.rowId + "]", location: "Packages.Library.CSV.View.GetViewRow", type: "Permission", level: 2});
					return null;
				}
			}
		}
		
		// Apply view conditions, only show items that conditions apply to
		var conditions = this.current.viewdef.conditions;
		if(this.xcsv.settings.viewConditions != null) {
			if(conditions == null) conditions = [];
			conditions = conditions.concat(this.xcsv.settings.viewConditions);
		}
		if(conditions != null && conditions.length > 0) {
			if(Packages.Library.$.EvaluateComplexCondition({
				data: this.current.dummyrow,
				conditions: conditions
			}) == 0) {
				// Should be hidden
				Packages.Library.$.LogInfo({mesg: "Row did not satisfy conditions [" + this.current.rowId + "]", location: "Packages.Library.CSV.View.GetViewRow", type: "Conditions", level: 2});
				return null;
			}
		}
		
		// Create a formatted row that contains the HTML for each item in the dummy row
		var formattedrow = this.GetFormattedRow(null, 0);
		
		// Calculate heading (if we need one)
		this.rowHeading = this.GetItemControlHeadings();
		
		var html = "";
		
		// Add title?
		if(this.current.viewdef.title != null && this.current.viewdef.title != "") {
			html = "<h3>" + this.current.viewdef.title + "<\/h3>"
				+	html;
		}
		
		// Get the view for this mode
		var viewType = this.GetViewTypeObject({viewType: this.current.viewdef.viewtype, setCurrent: 1});
		if(viewType.DisplayRow != null) {
			html += viewType.DisplayRow();
			if(!html.match(/<%Links%Row%>/)) {
				html += "<%Links%Row%>";
			}
			var rowLinks = "";
			// Add general links to other views fields
			if(this.current.viewdef.viewdefRowLinks.length > 0) {
					rowLinks += "<div class='xcsv_links'>";
					rowLinks += this.GetViewLinksHTML(this.current.viewdef.viewdefRowLinks);
					rowLinks += "<\/div>";
				}
			html = html.replace(/<%Links%Row%>/g, rowLinks);
		} else {
			Packages.Library.$.LogInfo({mesg: "Unable to display row with DisplayRow for viewType", location: "Packages.Library.CSV.View.GetViewRow", type: "Conditions", level: 2});
			return null;
		}
		
		// Apply any wrappers
		html = this.ApplyWrappers({
			html: html,
			wrappers: this.current.viewdef.rowWrappers,
			wrapperDef: this.current.viewdef.rowWrapperDef
		});
		
		// Do all replacements for macros in this View Row
		html = this.DoReplacements({html: html});
		
		return html;
	};
	
	/*********************************************************************
	 * GetCellView - gets the view of the specified cell
	 *
	 * param - columndef : the column def
	 * param - originalcelldata : raw cell data
	 * param - displayOptions : (optional) hash of options to pass to column type display
	 *
	 * returns the html markup for this cell
	 ********************************************************************/
	this.GetCellView = function(columndef, originalcelldata, displayOptions) {
		// Do adjustments on celldata
		var celldata = originalcelldata;
		if(columndef.text_view_none != "" && originalcelldata == "") celldata = columndef.text_view_none;
		if(columndef.text_view_some != "" && originalcelldata != "") celldata = columndef.text_view_some;
		
		// Do not allow nulls
		if(celldata == null) celldata = "";
		
		// Process this view through the correct type
		var html;
		try {
			html = Packages.Library.CSV.ColumnTypes[columndef.format].$.Display(columndef, celldata, this.xcsv, this.current.rowId, displayOptions);
		} catch(e) {
			Packages.Library.$.LogInfo({mesg: e.message, location: "Packages.Library.CSV.View.GetCellView", type: "View Error", level: 2});
			return "Error [" + celldata + "]";
		}
		
		// Apply any wrappers
		html = this.ApplyWrappers({
			html: html,
			wrappers: columndef.wrappers,
			wrapperDef: columndef.wrapperDef
		});
		
		// Do we have a view to link this to?
		// Click? If onclick exists, and it is not forced to be disabled by the caller
		if(this.current.viewdef != null && this.current.viewdef.onClick != null && this.current.disableOnClick != 1 && html != "") {
			html = xcsv.View.GetViewLinkHTML({label: html, viewRef: this.current.viewdef.onClick, applyWrappers: 0});
		}
		
		return html;
	};
	
	/*********************************************************************
	 * GetFormattedRow - gets the formatted version of a dummyrow object
	 *
	 * param - dummyrow : (optional) dummyrow, or this.current.dummyrow if null
	 * param - usecache : (optional) 1 (default) use cache, 0 don't
	 *
	 * return - formattedrow : HTML formatted version of dummy row
	 ********************************************************************/
	this.GetFormattedRow = function(dummyrow, usecache) {
		
		if(dummyrow == null) dummyrow = this.current.dummyrow;
		
		if(this.xcsv.cache.view.formattedrows == null) this.xcsv.cache.view.formattedrows = [];
		if(this.xcsv.cache.view.formattedrows[dummyrow.$absRowId] != null && usecache != 0) return this.xcsv.cache.view.formattedrows[dummyrow.$absRowId];
		
		var formattedrow = {};
		for(var i = 0; i < this.xcsv.data.columndefs.length; i++) {
			var columndef = this.xcsv.data.columndefs[i];
			var value = dummyrow[columndef.refcode];
			
			// Use formatted cell?
			if(this.current.viewDetails.plainDummyRow != 1) value = this.xcsv.GetFieldValue({dummyrow: dummyrow, columndef: columndef, asCell: 1});
			
			// Active?
			if(columndef.active == 0) value = "";
			
			// Conditions satisfied ?
			if(columndef.conditions != null
			&& columndef.conditions.length > 0
			&& Packages.Library.$.EvaluateComplexCondition({
				data: dummyrow,
				conditions: columndef.conditions
			}) == 0) {
				// Should be hidden
				value = "";
			}
			
			if(value == null) value = "";
			
			formattedrow[columndef.refcode] = value;
		}
		
		this.xcsv.cache.view.formattedrows[dummyrow.$absRowId] = formattedrow;
		
		return formattedrow;
	};
	
	/*********************************************************************
	 * GetControlHTML - gets the markup for the specified control
	 *
	 * param - controlname : name of control to fetch
	 *
	 * returns the html markup for this control or null if not found
	 ********************************************************************/
	this.GetControlHTML = function(controlname) {
		if(this.xcsv.controls[controlname] != null && this.xcsv.controls[controlname].GetControlHTML != null) {
			return this.xcsv.controls[controlname].GetControlHTML();
		}
		return null;
	};
	
	/*********************************************************************
	 * UpdateControls - updates all controls
	 ********************************************************************/
	this.UpdateControls = function() {
		if(Packages.Library.$c.IsNode == 1) return;
		for(var controlname in this.xcsv.controls) {
			if(this.xcsv.controls[controlname].UpdateControl != null) {
				this.xcsv.controls[controlname].UpdateControl();
			}
		}
	};
	
	/*********************************************************************
	 * GetControlStates - loads all control states internally
	 ********************************************************************/
	this.GetControlStates = function() {
		if(Packages.Library.$c.IsNode == 1) return;
		for(var controlname in this.xcsv.controls) {
			if(this.xcsv.controls[controlname].GetControlState != null) {
				this.xcsv.controls[controlname].GetControlState();
			}
		}
	};
	
	/*********************************************************************
	 * InitControlView - called when the current view changes to initialise controls
	 ********************************************************************/
	this.InitControlView = function() {
		for(var controlname in this.xcsv.controls) {
			if(this.xcsv.controls[controlname].InitControlView != null) {
				this.xcsv.controls[controlname].InitControlView(this.current.viewdef);
			}
		}
	};
	
	/*********************************************************************
	 * GetItemControl - gets the control for an item
	 *
	 * param - controlname : name of control to fetch
	 * param - rowId : current row
	 *
	 * returns the html for this item or null if not found
	 ********************************************************************/
	this.GetItemControl = function(controlname, rowId) {
		if(rowId == null) return "";
		if(this.xcsv.controls[controlname] != null && this.xcsv.controls[controlname].GetItemControl != null) {
			return this.xcsv.controls[controlname].GetItemControl(rowId);
		}
		return null;
	};
	
	/*********************************************************************
	 * GetItemControlHeadings - gets the heading for an item required by a control
	 *
	 * returns the headings, or null if not needed
	 ********************************************************************/
	this.GetItemControlHeadings = function() {
		if(this.current.rowdata == null) return null;
		
		var headings = "";
		for(var controlname in this.xcsv.controls) {
			if(this.xcsv.controls[controlname] != null && this.xcsv.controls[controlname].GetItemControlHeading != null) {
				var heading = this.xcsv.controls[controlname].GetItemControlHeading(this.current.rowdata);
				if(heading != null) headings += heading;
			}
		}
		if(headings == "") return null;
		return headings;
	};
	
	/*********************************************************************
	 * GetViewLinksHTML - gets the view links
	 *
	 * param - links : array of links for this view
	 *
	 * returns the markup of links
	 ********************************************************************/
	this.GetViewLinksHTML = function(links) {
		var html = "";
		for(var l = 0; l < links.length; l++) {
			var link = links[l];
			var linkHtml = this.GetViewLinkHTML(link);
			if(linkHtml != null) html += linkHtml;
		}
		return html;
	};
	
	/*********************************************************************
	 * GetViewLinkHTML - gets the view link
	 *
	 * param - link : a link def to a view
	 * 	options:
	 * 		conditions
	 * 		label : label to show
	 * 		viewRef : link to view ref
	 * 		applyWrappers : 1 (default) apply link wrappers, 0 don't
	 *
	 * returns the markup for this link or null if it is hidden
	 ********************************************************************/
	this.GetViewLinkHTML = function(link) {
		
		// Determine whether conditions are satisfied
		if(this.current.dummyrow != null && link.conditions != null && link.conditions.length > 0) {
			if(Packages.Library.$.EvaluateComplexCondition({
				data: this.current.dummyrow,
				conditions: link.conditions
			}) == 0) {
				// Should be hidden
				return null;
			}
		}
		
		var linkViewdef = Packages.Library.$.FindArrayItem({array: this.xcsv.data.viewdefs, path: "refcode", value: link.viewRef});
		var label = link.label;
		if(label == null) label = linkViewdef.name;
		if(label == null || label == "") label = link.viewRef;
		
		var onClick = "";
		var href = null;
		if(Packages.Library.$c.IsNode == 1) {
			href = Packages.Library.$.AddGlobalQueries({
				queries: {
					xcsvid: this.current.rowId,
					xcsvviewref: link.viewRef
				}
			});
			
			// Ask the viewdef if it can provide a better href
			var linkViewType = this.GetViewTypeObject({viewType: linkViewdef.viewtype});
			if(linkViewType.GetHref != null) href = linkViewType.GetHref({
				rowId: this.current.rowId,
				viewdef: linkViewdef,
				xcsv: this.xcsv
			});
		} else {
			onClick = xcsv.textVar + ".View.SwitchView({viewref: '" + link.viewRef + "', rowId: " + this.current.rowId + "})";
		}
		
		var html = "<a " +
					(href != null ? "href=\"" + href + "\" " : "") +
					"onclick=\"" + onClick + "\"" +
				">" +
					label +
				"<\/a>";
		
		// Apply any wrappers
		if(link.applyWrappers != 0) {
			html = this.ApplyWrappers({
				html: html,
				wrappers: this.current.viewdef.linkWrappers,
				wrapperDef: this.current.viewdef.linkWrapperDef
			});
		}
		
		return html;
	};
	
	/*******************************************************************************
	 * ApplyWrappers - applies the wrappers
	 *
	 * param - options : hash of options, must contain
	 * 				html : the html to wrap
	 * 			may contain:
	 * 				wrappers : array of wrappers ready for Packages.Library.Wrappers.$.WrapHtml
	 * 				wrapperDef : a refcode for a wrapperDef to use to wrap this html
	 *
	 * Returns the html wrapped
	 ******************************************************************************/
	this.ApplyWrappers = function(options) {
		var html = options.html;
		
		// Apply wrappers
		if(options.wrappers != null) {
			html = Packages.Library.Wrappers.$.WrapHtml({
				wrappers: options.wrappers,
				html : html,
				subOptions: {
					interactivemode: this.xcsv.interactive
				}
			});
		}
		
		// Apply wrapper def
		if(options.wrapperDef != null) {
			// Get wrappers for this wrapper def
			var wrapper = Packages.Library.$.FindArrayItem({array: this.xcsv.data.wrapperdefs, path: "refcode", value: options.wrapperDef});
			
			if(wrapper != null) {
				html = Packages.Library.Wrappers.$.WrapHtml({
					wrappers: wrapper.wrappers,
					html : html,
					subOptions: {
						interactivemode: this.xcsv.interactive
					}
				});
			}
		}
		
		return html;
	};
	
	/*******************************************************************************
	 * DoReplacements - does all of the replacements on the specified html
	 *
	 * param - options : hash of options, must contain
	 * 				html : the row of html
	 * 			may contain:
	 * 				tidyValueForEval : 1 tidy each replaced value for an eval, 0 don't
	 * 				dummyrow : the dummyrow to use, otherwise uses current dummyrow
	 * 				plain : fetch plain replacements, no fancy formatting
	 *
	 * Returns the html with all replacements done
	 ******************************************************************************/
	this.DoReplacements = function(options) {
		
		var html = options.html;
		var xcsv = this.xcsv;
		var viewdef = this.current.viewdef;
		var dummyrow = options.dummyrow;
		if(dummyrow == null) dummyrow = xcsv.View.current.dummyrow;
		
		// Do replacements for option heading
		var heading = "";
		// Is a heading required?
		if(xcsv.View.rowHeading != null) {
			heading = xcsv.View.rowHeading;
		}
		html = html.replace(/<%heading%>/, heading);
		
		// Ensure cache is created for this (to prevent infinite loop if a view keeps requesting the same view)
		if(xcsv.cache.view.CustomDisplay == null) xcsv.cache.view.CustomDisplay = {};
		
		var cacheName = "unknown";
		if(viewdef != null) cacheName = viewdef.refcode;
		
		// Ensure we have not attempted to access this viewdef before, if so return HTML and exit
		if(xcsv.cache.view.CustomDisplay[cacheName] == 1) return html;
		
		// Record this entry in the cache
		xcsv.cache.view.CustomDisplay[cacheName] = 1;
		
		// Counter to ensure the following while loop does not run out of control
		var counter = 0;
		
		// Find and fulfill macros
		while(html.match(/<%(view_)?(.+?)%(.*?)>/) && counter < 100) {
			var type = RegExp.$1;
			var refcode = RegExp.$2;
			
			// Extract options into a hash
			var optionstring = RegExp.$3;
			var opts = {};
			if(optionstring != null) {
				var items = optionstring.split("%");
				for(var i = 0; i < items.length; i++) {
					// Items may either be a a string, or a key value pair
					var key = items[i];
					var val = 1; // default
					if(key.match(/(.+?)=(.+)/)) {
						key = RegExp.$1;
						val = RegExp.$2;
					}
					
					// Process
					opts[key] = val;
				}
			}
			
			// Create match html;
			var matchhtml = null;
			
			if(type == "") {
				var matchcolumndef = Packages.Library.$.FindArrayItem({array: xcsv.data.columndefs, path: "refcode", value: refcode});
				if(matchcolumndef != null) {
					matchhtml = this.xcsv.GetFieldValue({
						dummyrow: dummyrow,
						columndef: matchcolumndef,
						applyNoneSomeDefaults: (options.plain == 1 ? 0 : 1),
						asCell: (options.plain == 1 ? 0 : 1),
						getCellViewOptions: opts
					});
				}
			}
			
			if(type == "view_" && options.plain != 1) {
				// Find a matching view
				var matchviewdef = Packages.Library.$.FindArrayItem({array: xcsv.data.viewdefs, path: "refcode", value: refcode});
				if(matchviewdef == null) {
					matchhtml = xcsv.data.text.errorText;
					Packages.Library.$.LogInfo({mesg: "Unable to find view [" + refcode + "]", location: "Packages.Library.CSV.Views.Custom.$.DoReplacements", type: "Bad View Def", level: 2});
				} else {
					// Get the view html
					var _storeCurrentViewDef = xcsv.View.current.viewdef;
					xcsv.View.current.viewdef = matchviewdef;
					matchhtml = xcsv.View.GetViewRow();
					xcsv.View.current.viewdef = _storeCurrentViewDef;
					if(matchhtml == null) {
						matchhtml = xcsv.data.text.errorText;
						Packages.Library.$.LogInfo({mesg: "Unable to load content for view [" + refcode + "]", location: "Packages.Library.CSV.Views.Custom.$.DoReplacements", type: "Bad View Def", level: 2});
					}
				}
			}
			
			// Apply options
			if(opts.foldable == 1 && options.plain != 1) {
				var folded = opts.folded;	if(folded == null) folded = 0;
				var title  = opts.title ;	if(title  == null) title  = "";
				matchhtml = Packages.Library.$.CreateFoldArea({
					title: title,
					content: matchhtml,
					foldable: 1,
					folded: folded,
					border: 1
				});
			}
			if(opts.popup == 1 && options.plain != 1) {
				var title  = opts.title;	if(title  == null) title  = "";
				matchhtml = Packages.Library.$.CreatePopupArea({
					buttonText: title,
					content: matchhtml
				});
			}
			
			// Check user permissions
			if(opts.userState != null) {
				var state = xcsv.GetUserState(rowid);
				
				// Replace with blank if the state was not in the userState
				if((state & opts.userState) == 0) matchhtml = "";
			}
			
			// Do the replacement
			if(matchhtml == null) {
				// Add a $ before the % to stop further matches
				matchhtml = "<$%" + type + refcode + "%" + optionstring + ">";
			}
			
			// Tidy for eval?
			if(options.tidyValueForEval == 1) {
				matchhtml = Packages.Library.$.TidyValueForEval({value: matchhtml});
			}
			
			html = html.replace(new RegExp("<%" + type + refcode + "%" + optionstring + ">", "g"), matchhtml);
			
			// Increment counter to avoid infinite loop
			counter++;
		}
		
		// Remove the '$' prefix added to prevent recursion
		html = html.replace(/<\$%/g, "<%");
		
		// Reset our cache
		xcsv.cache.view.CustomDisplay[cacheName] = null;
		
		// Add extra 'clever' items
		while(html.match(/<%item_(.+?)%>/)) {
			var controlname = RegExp.$1;
			var rowid = null;
			var rowId = xcsv.View.current.rowId;
			html = html.replace(new RegExp("<%item_" + controlname + "%>", "g"), xcsv.View.GetItemControl(controlname, rowId));
		}
		
		// Add links to other views
		while(html.match(/<%link_([^>]+)>/)) {
			var link = RegExp.$1.replace(/%$/, "");
			var viewref;
			var label;
			if(link.match(/(.+?)%(.+?)/)) {
				viewref = RegExp.$1;
				label = RegExp.$2;
			} else {
				viewref = link;
			}
			
			// Find this viewref in the list of view links
			var linkHtml = xcsv.View.GetViewLinkHTML({label: label, viewRef: viewref});
			html = html.replace(new RegExp("<%link_" + link + "%>", "g"), linkHtml);
		}
		
		return html;
	};
	
	Packages.Library.$.MergeIn({_this: this, extra: new Packages.Library.CSV.View_MenuBox()});
};Package("Library.CSV.ViewFormats.Custom").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.Custom.$.GetEditForm = function(editor) {
	var helptext = "Markup can contain references to the cells in the row.\n" +
					"Reference a row by &lt;%refcode%&gt;<br>" +
					"Eg. You are <%age%> years old.\n" +
					"Reference another view by &lt;%view_refcode%&gt;<br>" +
					"Eg. Here are your stats <%view_Stats%>\n" +
					"Advanced view options can be placed inside the tag in the form &lt;%view_refcode%option1%option2%&gt;<br>" +
					"Advanced options include:<br>" +
					" | foldable : makes the view foldable.<br>" +
					" | - folded : makes the area initially folded.<br>" +
					" | - title=title : define the text to display on the fold.<br>" +
					" Eg. &lt;%view_Stats%foldable%folded%title=See Stats here%&gt;\n" +
					" | popup : makes the view into a popup.<br>" +
					" | - title=title : text to display on the popup button.<br>" +
					" Eg. &lt;%view_Stats%popup%title=Quick View%&gt;\n" +
					" | userState : specify the userstates this view will be shown for\n" +
					" | - userState=state : the sum of the userstates this will display for\n" +
					"Reference the compare checkbox by &lt;%item_compare%&gt;" +
					"Reference any system provided headings (such as group headings) by &lt;%heading%&gt;"
	return [
		{
			name: "Row View HTML",
			description: "The HTML markup that defines the appearance of each row.\n" +
						helptext,
			id: "html",
			value: "",
			type: "RichText",
			editPlain: 1
		},
		{
			name: "Container HTML",
			description: "The HTML markup that defines the appearance of the container.\n" +
						"Add Row Form: You can insert an 'Add row' form by referencing an 'Edit' view in the container. In the context of the container a default dummy row is created. If this dummyrow is saved, a new row will be added to the CSV file.\n" +
						"Add Row Button: You can insert and 'Add Row' button in the same way as an 'Add Row' form - place the popup option on the view.\n" +
						helptext + "\n" +
						"Reference the rows within this container by &lt;%rows%&gt;. You can hide the entire listing by removing &lt;%rows%&gt;.",
			id: "containerhtml",
			value: "<%rows%>",
			type: "RichText",
			editPlain: 1
		}
	]
};Package("Library.CSV.ViewFormats.Custom").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.Custom.$.GetDetails = function() {
	return {
		name: "Custom Template",
		description: "Create a custom template"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this view
 *
 * param - viewdef : the view def
 * param - dummyrow : hash containing values of the items in the row
 * param - rowdata : the actual row
 * param - xcsv : the xcsv object
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.Custom.$.Display = function(viewdef, dummyrow, rowdata, xcsv) {
	return viewdef.html;
};

/*******************************************************************************
 * DisplayWrapper - gets the HTML markup wrapper for the rows
 *
 * param - viewdef : the view def
 * param - dummyrow : formatted dummy row of data
 * param - rowshtml : html to place inside
 * param - xcsv : the xcsv object
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.Custom.$.DisplayWrapper = function(viewdef, dummyrow, rowshtml, xcsv) {
	var html = viewdef.containerhtml;
	if(html == null) html = "<%rows%>"; // Legacy support
	
	html = html.replace(/<%rows%>/, rowshtml);
	return html;
};Package("Library.CSV.ViewFormats.SystemDetail").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.SystemDetail.$.GetEditForm = function(editor) {
	return [
		{
			name: "Title Field",
			description: "This field will be shown as a heading above the other fields.",
			type: "SelectBox",
			value: 0,
			id: "titleField",
			options: editor.currentRowsList,
			none: "No title"
		},
		{
			name: "Fields to display under title",
			description: "These fields will be shown without heading underneath the title.",
			type: "Options",
			value: [],
			id: "fieldsToDisplay",
			options: editor.currentRowsList
		},
		{
			name: "Fields to display in summary table",
			description: "These fields will be shown at the bottom in a summary table.",
			type: "Options",
			value: [],
			id: "fieldsToSummarise",
			options: editor.currentRowsList
		},
		{
			name: "Display side by side",
			description: "When checked, multiple items will appear side by side",
			type: "Checkbox",
			checked: 0,
			id: "displayInline"
		}
	]
};Package("Library.CSV.ViewFormats.SystemDetail").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.SystemDetail.$.GetDetails = function() {
	return {
		name: "System Detail",
		description: "System generated detail"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * param - viewdef : the view def
 * param - dummyrow : hash containing values of the items in the row
 * param - rowdata : the actual row
 * param - xcsv : the xcsv object
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.SystemDetail.$.Display = function(viewdef, dummyrow, rowdata, xcsv) {
	var html = "";
	// Create system generated decent view
	// Create title
	if(viewdef.titleField != null) html += "<h3>" + dummyrow[viewdef.titleField] + "<\/h3>";
	
	// Add in description fields
	for(var i = 0; i < viewdef.fieldsToDisplay.length; i++) {
		var columndef = Packages.Library.$.FindArrayItem({array: xcsv.data.columndefs, path: "refcode", value: viewdef.fieldsToDisplay[i]});
		if(columndef != null) {
			html += "<div>";
			html += dummyrow[viewdef.fieldsToDisplay[i]];
			html += "<\/div>";
		}
	}
	
	// Create summary table
	html += "<table>";
	for(var i = 0; i < viewdef.fieldsToSummarise.length; i++) {
		var columndef = Packages.Library.$.FindArrayItem({array: xcsv.data.columndefs, path: "refcode", value: viewdef.fieldsToSummarise[i]});
		if(columndef != null) {
			var value = dummyrow[viewdef.fieldsToSummarise[i]];
			if(value != "") {
				html += "<tr>";
				html += "<td>" + columndef.name + "<\/td>";
				html += "<td>" + value + "<\/td>";
				html += "<\/tr>";
			}
		}
	}
	html += "<\/table>";
	
	// Add links to other views fields
	html += "<%Links%Row%>";
	
	html = "<div class='xcsv_detail_container' style='" + (viewdef.displayInline == 1 ? "display: inline-block;" : "") + "'>" + html + "<\/div>";
	
	return html;
};
/*******************************************************************************
 * DisplayWrapper - gets the HTML markup wrapper for the rows
 *
 * param - viewdef : the view def
 * param - dummyrow : formatted dummy row of data
 * param - rowshtml : html to place inside
 * param - xcsv : the xcsv object
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.SystemDetail.$.DisplayWrapper = function(viewdef, dummyrow, rowshtml, xcsv) {
	var html = "";
	html += rowshtml;
	
	// Add links to other views fields
	html += "<%Links%Gen%>";
	
	return html;
};Package("Library.CSV.ViewFormats.SystemTable").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.SystemTable.$.GetEditForm = function(editor) {
	return [
		{
			name: "Fields to display",
			description: "These fields will be shown in the listing, the will be in the order shown below.",
			type: "Options",
			value: [],
			id: "fieldsToDisplay",
			options: editor.currentRowsList
		},
		{
			name: "Show compare column",
			description: "When checked a 'compare' column will appear where the end user can select items to compare.",
			type: "Checkbox",
			value: 0,
			id: "showCompare"
		},
		{
			name: "Border thickness",
			description: "Thickness of border around table, or '0' for none.",
			type: "Text",
			numeric: 1,
			min: 0,
			value: 0,
			id: "borderThickness"
		},
		{
			name: "Highlight current row",
			description: "When the user has been working on a row, that row is stored as the last row worked on.\n"
					+	"When checked, the row will be highlighted as active",
			id: "highlightCurrentRow",
			checked: 1,
			type: "Checkbox",
			complexity: 1
		},
		{
			name: "Styles rows",
			description: "When checked, the rows will be styled in alternate colours",
			id: "styleRows",
			checked: 1,
			type: "Checkbox",
			complexity: 1
		}
	]
};Package("Library.CSV.ViewFormats.SystemTable").view = function(){};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.SystemTable.$.GetDetails = function() {
	return {
		name: "System Table",
		description: "System generated table"
	}
};
/*******************************************************************************
 * Display - gets the HTML markup for this cell
 *
 * param - viewdef : the view def
 * param - dummyrow : hash containing values of the items in the row
 * param - rowdata : the actual row
 * param - xcsv : the xcsv object
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.SystemTable.$.Display = function(viewdef, dummyrow, rowdata, xcsv) {
	var html = "";
	
	if(xcsv.cache.view.rowCounter == null) xcsv.cache.view.rowCounter = 0;
	xcsv.cache.view.rowCounter ++;
	
	var rowId = rowdata[0];
	
	// How many columns do we show
	var colsToDisplay = viewdef.fieldsToDisplay.length;
	if(viewdef.showCompare == 1) colsToDisplay += 1;
	
	// Is a heading row required?
	if(xcsv.View.rowHeading != null) {
		html += "<tr class='xcsv_heading_row'>";
		html += "<td colspan='" + colsToDisplay + "'>";
		html += "<h3>" + xcsv.View.rowHeading + "<\/h3>";
		html += "<\/td><\/tr>";
	}
	
	// Create table row
	html += "<tr "
			+	"class='xcsv_system_table_row"
				+ ((viewdef.highlightCurrentRow == 1 && rowId == xcsv.View.current.selectedRowId)? " xcsv_system_table_row_current" : "")
				+ ((viewdef.styleRows == 1 && xcsv.cache.view.rowCounter % 2 == 0) ? " xcsv_system_table_row_even" : "")
			+ "'"
		+	">";
	// Add manual fields
	if(viewdef.showCompare == 1) {
		html += "<td>";
		html += xcsv.View.GetItemControl("compare", rowId);
		html += "<\/td>";
	}
	
	// Add links to other views fields
	if(viewdef.viewdefRowLinks.length > 0) {
		html += "<td>";
		html += "<%Links%Row%>";
		html += "<\/td>";
	}
	for(var i = 0; i < viewdef.fieldsToDisplay.length; i++) {
		var columndef = Packages.Library.$.FindArrayItem({array: xcsv.data.columndefs, path: "refcode", value: viewdef.fieldsToDisplay[i]});
		if(columndef != null) {
			html += "<td>";
			html += dummyrow[viewdef.fieldsToDisplay[i]];
			html += "<\/td>";
		}
	}
	html += "<\/tr>";
	return html;
};
/*******************************************************************************
 * DisplayWrapper - gets the HTML markup wrapper for the rows
 *
 * param - viewdef : the view def
 * param - dummyrow : formatted dummy row of data
 * param - rowshtml : html to place inside
 * param - xcsv : the xcsv object
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ViewFormats.SystemTable.$.DisplayWrapper = function(viewdef, dummyrow, rowshtml, xcsv) {
	if(viewdef.borderThickness == null) viewdef.borderThickness = 0;
	var html = "";
	html += "<table "
			+	"class='xcsv_system_table' "
			+	"border='" + viewdef.borderThickness + "' "
			+ ">";
	// Add header
	html += "<tr>";
	// Add manual columns
	if(viewdef.showCompare == 1) html += "<th>Compare<\/th>";
	// Add links to other views fields
	if(viewdef.viewdefRowLinks.length > 0) html += "<th><\/th>";
	for(var i = 0; i < viewdef.fieldsToDisplay.length; i++) {
		var columndef = Packages.Library.$.FindArrayItem({array: xcsv.data.columndefs, path: "refcode", value: viewdef.fieldsToDisplay[i]});
		if(columndef != null) {
			html += "<th>" + columndef.name + "<\/th>"
		}
	}
	html += "<\/tr>";
	html += rowshtml;
	html += "<\/table>";
	
	return html;
};Package("Library.CSV.ViewTypes.AJAX").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.AJAX.$.GetEditForm = function(editor) {
	return [
		{
			name: "Query Parameters",
			description: "Add the parameters to the request (thse will be sent in the query string)",
			type: "MultiForm",
			id: "queryParams",
			titleRef: "<%attribute%>=<%columnref%>",
			form: {
				type: "Form",
				idprefix: "multichoice",
				items: [
					{
						name: "Attribute",
						id: "attribute",
						value: "",
						type: "Text",
						complexity: 1
					},
					{
						name: "Value",
						value: "",
						type: "Text",
						id: "value",
						useColumnValue: 1
					},
					{
						name: "Encode Base64",
						description: "When checked, the value will be encoded as base64",
						value: "",
						type: "Checkbox",
						id: "encodeBase64"
					}
				]
			}
		},
		{
			name: "Post Parameters",
			description: "Add the parameters to the request (these will be sent as a POST in the body of the content)",
			type: "MultiForm",
			id: "postParams",
			titleRef: "<%attribute%>=<%columnref%>",
			form: {
				type: "Form",
				idprefix: "multichoice",
				items: [
					{
						name: "Attribute",
						id: "attribute",
						value: "",
						type: "Text",
						complexity: 1
					},
					{
						name: "Value",
						value: "",
						type: "Text",
						id: "value",
						useColumnValue: 1
					},
					{
						name: "Encode Base64",
						description: "When checked, the value will be encoded as base64",
						value: "",
						type: "Checkbox",
						id: "encodeBase64"
					}
				]
			}
		},
		{
			name: "Next View",
			description: "This view will be displayed after the AJAX is sent and a response obtained from the server\n"
					+	"You should not select this view, as it will cause an infinite loop",
			type: "SelectBox",
			id: "submitView",
			options: editor.view.xcsv.GetViewDefOptions(),
			none: "None"
		},
		{
			name: "Mask Content",
			description: "Content to display whilst performing the request",
			type: "RichText",
			id: "maskContent",
			defaultvalue: "Sending Request . . ."
		}
	];
};/*******************************************************************************
 * Listing - displays just the currently selected item
 ******************************************************************************/
Package("Library.CSV.ViewTypes.AJAX").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		if(this.options.rowId == null) {
			return this.options.xcsv.data.text.noRowSelectedText; // Can not edit nothing
		}
		
		var xcsv = this.options.xcsv;
		var viewdef = this.options.viewdef;
		
		// Create the query string using the name / value pairs
		var query = {};
		var queryParams = viewdef.queryParams;
		foreach(queryParams, function(param) {
			var value = xcsv.ProcessEnhancedFormFieldsInSettings(param, "value");
			if(param.encodeBase64 == 1) value = btoa(value);
			query[param.attribute] = value;
		});
		var post = {};
		var postParams = viewdef.postParams;
		foreach(postParams, function(param) {
			var value = xcsv.ProcessEnhancedFormFieldsInSettings(param, "value");
			if(param.encodeBase64 == 1) value = btoa(value);
			post[param.attribute] = value;
		});
		
		var page = Packages.Library.$.GetMasterpath({}) + ".admin";
		
		// Do a server request
		new Packages.Library.ServerRequest().ServerRequest({
			page: page,
			query: query,
			post: post,
			callback: function() {
				if(viewdef.submitView != null) {
					xcsv.View.SwitchView({
						viewref: viewdef.submitView
					});
			   }
			},
			maskContent: this.options.viewdef.maskContent
		});
		
		// Display this controls content, or automatically move to next view
		return "";
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		return "";
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.AJAX.$.GetDetails = function() {
	return {
		name: "AJAX",
		description: "Allows a row to be sent to the server"
	}
};Package("Library.CSV.ViewTypes.Add").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Add.$.GetEditForm = function(editor) {
	return [
		{
			name: "Fields to add",
			description: "These fields will be shown in the listing, they will be in the order shown below.",
			type: "Options",
			value: [],
			id: "fieldsToDisplay",
			options: editor.currentRowsList
		},
		{
			name: "Add Button Submit Text",
			description: "The text on the submit button when in add mode",
			type: "Text",
			value: "Create",
			id: "addText"
		},
		{
			name: "Submit View",
			description: "This view will be displayed after the user submits the information",
			type: "SelectBox",
			id: "submitView",
			options: editor.view.xcsv.GetViewDefOptions(),
			none: "Reload current view"
		}
	]
};/*******************************************************************************
 * Add - creates a form to add data
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Add").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowid : the absolute rowid
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
	
	/******************************************************
	 * Display - creates the HTML for an Add Form
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		var html = Packages.Library.CSV.ViewTypes.Edit.$.GetForm({
			xcsv: this.options.xcsv,
			viewdef: this.options.viewdef
		});
		
		return html;
	};
	
	/******************************************************
	 * DisplayRow - should never be called
	 ****************************************************/
	this.DisplayRow = function() {
		return null;
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Add.$.GetDetails = function() {
	return {
		name: "Add",
		description: "Displays a form to Add a row",
		requiresViewFormat: 0
	}
};Package("Library.CSV.ViewTypes.Buttons").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Buttons.$.GetEditForm = function(editor) {
	return [
		{
			name: "Display 'action' buttons",
			description: "An 'action' button is a place holder for a third part table 'subscriber' button.\n" +
						"When foreign tables with subscribers are used, the 'Select' button will be placed here",
			id: "displayaction",
			checked: 1,
			type: "Checkbox"
		},
		{
			name: "Display 'cache selection' button",
			description: "An 'cache selection' button is a button that adds the current item to the selected items\n" +
						"This allows a user to globally select an item, and use it as a default.",
			id: "displaycache",
			checked: 1,
			type: "Checkbox"
		},
		{
			name: "Cache Selection Button Text",
			description: "Text to appear on a cache selection button.",
			id: "cachetext",
			value: "Remember",
			type: "Text"
		}
	];
};/*******************************************************************************
 * Buttons - displays additional buttons
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Buttons").view = function(){
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	};
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {
		if(this.options.rowId == null) this.options.rowId = this.options.xcsv.initialViewRow;
		
		this.array = this.options.xcsv.ControlAlterArray("Listing");
	};
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		if(this.options.rowId == null) {
			return this.options.xcsv.data.text.noRowSelectedText; // Can not edit nothing
		}
		
		return this.options.xcsv.View.GetViewRow();
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		// Get pure dummyrow
		var pureDummyRow = this.options.xcsv.GetDummyRow(this.options.rowId);
		
		// Get ID for this row
		var primaryKeyColumnDef = this.options.xcsv.GetPrimaryKeyColumnDef();
		if(primaryKeyColumnDef == null) {
			Packages.Library.$.LogInfo({mesg: "No primary key columndef found", location: "Packages.Library.CSV.Views.Buttons.$.Display", type: "Missing Columndef Type", level: 2});
			return "";
		}
		var primaryId = pureDummyRow[primaryKeyColumnDef.refcode];
		
		var html = "";
		
		// Do action buttons
		if(this.options.viewdef.displayaction != 0) {
			for(var i = 0; i < this.options.xcsv.messages.length; i++) {
				var message = this.options.xcsv.messages[i];
				if(message.type != "ActionButton") continue;
				
				html += "<div " +
							"class='mbutton' " +
							"onclick=\"" + this.options.xcsv.textVar + ".messages[" + i + "].callback(" + primaryId + ")\" " +
						">" +
							message.buttonText +
						"<\/div>";
			}
		}
		
		// Do 'cache selection' buttons
		if(this.options.viewdef.displaycache == 1) {
			html += "<div " +
						"class='mbutton' " +
						"onclick=\"Packages.Library.CSV.ViewTypes.Buttons.$.DoCacheSelection('" + this.options.xcsv.safeXCSVName + "', " + this.options.rowId + ")\" " +
					">" +
						this.options.viewdef.cachetext +
					"<\/div>";
		}
		
		return html;
	};
};
/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Buttons.$.GetDetails = function() {
	return {
		name: "Buttons",
		description: "Buttons registered by other tables"
	}
};

/*******************************************************************************
 * DoCacheSelection - selects the current item into the cache
 *
 * param - key : the cache key
 * param - rowid : the rowid
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Buttons.$.DoCacheSelection = function(key, rowid) {
	var userSpace = Packages.Library.$.CreateUserspace();
	userSpace.SetCache({key: key, value: rowid});
};Package("Library.CSV.ViewTypes.Comparison").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Comparison.$.GetEditForm = function(editor) {
	return [];
};Package("Library.CSV.ViewTypes.Comparison").$.InitPackage = function() {
    Packages.Library.CSV.ViewTypes.Comparison.view.prototype = new Packages.Library.CSV.ViewTypes.Listing.view();
};
/*******************************************************************************
 * Comparison - creates a list of items that match the search with paging
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Comparison").view = function() {
    var debug = 1;
    this.$super = new Packages.Library.CSV.ViewTypes.Listing.view();
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {
		if(this.options.rowid == null) this.options.rowid = this.options.xcsv.initialViewRow;
		
		this.array = this.options.xcsv.ControlAlterArray("Comparison");
	}
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Comparison.$.GetDetails = function() {
	return {
		name: "Comparison",
		description: "Displays the items currently selected to compare.",
		requiresViewFormat: 1
	}
};Package("Library.CSV.ViewTypes.Delete").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Delete.$.GetEditForm = function(editor) {
	return [
		{
			name: "Confirmation Text",
			description: "The text on the confirmation box",
			type: "Text",
			value: "Are you sure you want to delete this item?",
			id: "confirmText"
		},
		{
			name: "Next View",
			description: "This view will be displayed after the user confirms the deletion",
			type: "SelectBox",
			id: "submitView",
			options: editor.view.xcsv.GetViewDefOptions()
		}
	]
};/*******************************************************************************
 * Delete - creates a confirmation box to delete
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Delete").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowid : the absolute rowid
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {
		if(this.options.rowid == null) this.options.rowid = this.options.xcsv.initialViewRow;
		
		this.array = this.options.xcsv.ControlAlterArray("Listing");
	}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		if(this.options.rowId == null) {
			return this.options.xcsv.data.text.noRowSelectedText; // Can not edit nothing
		}
		
		var html = this.options.xcsv.View.GetViewRow();
		if(html == null) {
			return this.options.xcsv.data.text.noRowSelectedText; // Can not delete nothing
		}
		
		return html;
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		var html = "";
		
		var _this = this;
		this.options.xcsv.cache.deleteOnDelete = function() {
			// Function defined within scope for easy callback
			
			// Delete row
			_this.options.xcsv.DeleteRow(_this.options.rowId);
			
			if(_this.options.viewdef.submitView != null) {
				 _this.options.xcsv.View.SwitchView({
					 viewref: _this.options.viewdef.submitView
				 });
			}
		}
		
		html += this.options.viewdef.confirmText;
		
		html += "<div "
				+	"class='xcsv_delete mbutton' "
				+	"onclick=\"" + this.options.xcsv.textVar + ".cache.deleteOnDelete()\""
			+	">"
				+	"Confirm"
			+	"<\/div>";
		
		return html;
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Delete.$.GetDetails = function() {
	return {
		name: "Delete",
		description: "Displays a confirmation form to Delete a row",
		requiresViewFormat: 0
	}
};Package("Library.CSV.ViewTypes.Edit").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Edit.$.GetEditForm = function(editor) {
	return [
		{
			name: "Fields to edit",
			description: "These fields will be shown in the listing, they will be in the order shown below.",
			type: "Options",
			value: [],
			id: "fieldsToDisplay",
			options: editor.currentRowsList
		},
		{
			name: "Edit Button Submit Text",
			description: "The text on the submit button when in edit mode",
			type: "Text",
			value: "Save",
			id: "editText"
		},
		{
			name: "Submit View",
			description: "This view will be displayed after the user submits the information",
			type: "SelectBox",
			id: "submitView",
			options: editor.view.xcsv.GetViewDefOptions(),
			none: "Reload current view"
		}
	]
};/*******************************************************************************
 * Edit - creates a form to edit data
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Edit").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowid : the absolute rowid
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {
		if(this.options.rowid == null) this.options.rowid = this.options.xcsv.initialViewRow;
		
		this.array = this.options.xcsv.ControlAlterArray("Listing");
	}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		if(this.options.rowId == null) {
			return this.options.xcsv.data.text.noRowSelectedText; // Can not edit nothing
		}
		
		var html = this.options.xcsv.View.GetViewRow();
		if(html == null) {
			return this.options.xcsv.data.text.noRowSelectedText; // Can not edit nothing
		}
		
		return html;
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		var html = Packages.Library.CSV.ViewTypes.Edit.$.GetForm({
			xcsv: this.options.xcsv,
			viewdef: this.options.viewdef,
			dummyrow: this.options.dummyrow,
			rowId: this.options.rowId
		});
		
		return html;
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Edit.$.GetDetails = function() {
	return {
		name: "Edit",
		description: "Displays a form to Edit a row",
		requiresViewFormat: 0
	}
};

/*******************************************************************************
 * GetForm - gets the HTML markup for the Edit form
 *
 * param - options : hash of options, must contain:
 * 		xcsv : the xcsv ref
 * 		viewdef : the current view def
 * 	may contain:
 * 		dummyrow : the dummyrow
 * 		rowId : the rowId - if null, creates a new item
 *
 * Returns the html
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Edit.$.GetForm = function(options) {
	var viewdef = options.viewdef;
	var xcsv = options.xcsv;
	var dummyrow = options.dummyrow;
	var rowId = options.rowId;
	if(dummyrow == null) dummyrow = xcsv.GetDummyRow(null, {updateServer: 0}); // Get a blank dummy row, with defaults
	
	var formitems = [];
	for(var i = 0; i < viewdef.fieldsToDisplay.length; i++) {
		var columndef = Packages.Library.$.FindArrayItem({array: xcsv.data.columndefs, path: "refcode", value: viewdef.fieldsToDisplay[i]});
		if(columndef != null) {
			if(Packages.Library.CSV.ColumnTypes[columndef.format].$.EndUserEdit != null) {
				// Get formfield from EndUserEdit
				var value = dummyrow[viewdef.fieldsToDisplay[i]];
				if(value == null) value = "";
				var formfield = Packages.Library.CSV.ColumnTypes[columndef.format].$.EndUserEdit(columndef, value, xcsv, {dummyrow: dummyrow});
				
				// Skip fields that aren't given
				if(formfield == null) continue;
				
				// Add standard fields
				formfield.name = xcsv.View.DoReplacements({html: columndef.name});
				formfield.description = xcsv.View.DoReplacements({html: columndef.description});
				formfield.id = columndef.refcode;
				formfield.required = columndef.required;
				// Append conditions
				if(formfield.conditions == null) formfield.conditions = [];
				if(columndef.conditions != null) formfield.conditions = formfield.conditions.concat(columndef.conditions);
				
				formitems.push(formfield);
			}
		}
	}
	
	var onsubmit = function() {
		// Function defined within scope for easy callback
		xcsv.SetDummyRow(rowId, dummyrow);
		
		if(viewdef.submitView != null) {
			 xcsv.View.SwitchView({
				 viewref: viewdef.submitView
			 });
		}
	}
	
	var form = {
		type: "Form",
		object: dummyrow,
		submit: onsubmit,
		idprefix: xcsv.idPrefix + "enduser" + (rowId != null ? rowId : "_") + "xcsv",
		items: formitems,
		allowUndo: 0,
		submittext: (rowId != null ? viewdef.editText : viewdef.addText),
		requiredText: xcsv.data.text.requiredFieldText
	};
	form.Form = new Packages.Form.Form(form);
	return form.Form.MakeForm();
};Package("Library.CSV.ViewTypes.Email").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Email.$.GetEditForm = function(editor) {
	return [
		{
			name: " ",
			subtitle: "Use the 'Title' field for the subject line",
			label: "Email",
			type: "Label"
		},
		{
			name: "Custom Area",
			description: "Place macros in this area for fields, of the form:\n"
						+	"&lt;%column_ref_code%&gt;",
			id: "html",
			value: "",
			type: "TextArea"
		},
		{
			name: "List Fields",
			description: "Specify fields to appear under the 'Custom Area'",
			type: "Options",
			value: [],
			id: "fieldsToDisplay",
			options: editor.currentRowsList,
			commaString: 1
		}
	];
};/*******************************************************************************
 * Email - displays just the currently selected item
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Email").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		if(this.options.rowId == null) {
			return this.options.xcsv.data.text.noRowSelectedText; // Can not edit nothing
		}
		
		return this.options.xcsv.View.GetViewRow();
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		// For the current format, get the current view
		return Packages.Library.CSV.ViewFormats[this.options.viewdef.format].$.Display(this.options.viewdef, this.options.xcsv.View.GetFormattedRow(), this.options.rowdata, this.options.xcsv);
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Email.$.GetDetails = function() {
	return {
		name: "Email",
		description: "Define an email."
	}
};Package("Library.CSV.ViewTypes.FileRedirect").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.FileRedirect.$.GetEditForm = function(editor) {
	return [
		{
			name: "Target",
			description: "Target the user will be sent to, this XCSV file and current row are sent so that it may be selected on the target",
			type: "FileMgr",
			select: 1,
			pathPrefix: "",
			folder : pFolders,
			storeRelative: 1,
			id: "redirectFile"
		}
	];
};/*******************************************************************************
 * Listing - displays just the currently selected item
 ******************************************************************************/
Package("Library.CSV.ViewTypes.FileRedirect").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		
		var file = this.MakeURL(this.options);
		
		if(this.options.xcsv.interactive == 1) {
			window.location = file;
		} else {
			return "Interactive mode disabled. Otherwise would redirect to: " + file;
		}
		
		return null;
	};
	
	this.MakeURL = function(options) {
		var query = "";
		if(options.rowId != null) query += "xcsvid=" + options.rowId + "&";
		if(options.viewdef.onClick != null) query += "xcsvviewref=" + options.viewdef.onClick + "&";
		
		return options.xcsv.settings.basepath + options.viewdef.redirectFile + "?" + query;
	}
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {};
	
	this.GetHref = function(options) {
		return this.MakeURL(options)
	}
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.FileRedirect.$.GetDetails = function() {
	return {
		name: "File Redirect",
		description: "Redirects the viewer to the file specified. Also sends information to the file about the currently selected row."
	}
};Package("Library.CSV.ViewTypes.GanttChart").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.GanttChart.$.GetEditForm = function(editor) {
	return [
		{
			name: "Fields to Display",
			description: "The fields to display for each row",
			type: "Options",
			id: "fieldsToDisplay",
			options: editor.currentRowsList
		},
		{
			name: "Duration Field",
			description: "The field that stores the duration of the task.",
			type: "SelectBox",
			id: "durationField",
			options: editor.currentRowsList
		},
		{
			name: "Duration Unit",
			description: "The default is taken as weeks.",
			type: "SelectBox",
			id: "durationUnit",
			defaultvalue: 3600 * 24 * 7,
			options: [
				{name: "Hours", value: 3600},
				{name: "Days", value: 3600 * 24},
				{name: "Weeks", value: 3600 * 24 * 7}
			]
		},
		{
			name: "Dependancy Field",
			description: "The field that stores the dependancies of the task.",
			type: "SelectBox",
			id: "dependancyField",
			options: editor.currentRowsList
		},
		{
			name: "Start Date Field",
			description: "Optional field used to describe the project start date.",
			type: "SelectBox",
			id: "startDateField",
			none: "Not Used",
			options: editor.currentRowsList
		},
		{
			name: "Delay Field",
			description: "Optional field used to describe the delay a project is suffering.",
			type: "SelectBox",
			id: "delayField",
			none: "Not Used",
			options: editor.currentRowsList
		},
		{
			name: "Progress Field",
			description: "Optional field used to store the progress of the project.",
			type: "SelectBox",
			id: "progressField",
			none: "Not Used",
			options: editor.currentRowsList
		},
		{
			name: "Edit View",
			description: "The view to show to edit this task",
			type: "SelectBox",
			id: "editView",
			options: editor.view.xcsv.GetViewDefOptions()
		}
	];
};/*******************************************************************************
 * GanttChart - displays a gantt chart of data
 ******************************************************************************/
Package("Library.CSV.ViewTypes.GanttChart").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {
		if(this.options.rowId == null) this.options.rowId = this.options.xcsv.initialViewRow;
		
		this.array = this.options.xcsv.ControlAlterArray("Listing");
	}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		var viewdef = this.options.viewdef;
		
		// There are a lot of calculation taking place
		// There are a number of variables set up to record "global" information
		
		// Tasks may be collected by a project
		// A project is simply achieved by filtering the results in XCSV
		// However, internally projects are based on starting events
		// Any item with no dependancies becomes a start event
		// Start events define a project, and are recorded as the project
		
		var showDates = (viewdef.startDateField != null ? 1 : 0);
		var unit = viewdef.durationUnit;
		
		var earliestStartDate = null;
		var latestEndDate = 0;
		
		// Calculate useful information for each task from the dummyrow, so we then
		// have all the information in one place
		var tasks = [];
		// Projects are essentially the first task in a group, first tasks have no dependancies
		var projects = {};
		for(var absRowId = 0; absRowId < this.array.length; absRowId++) {
			var rowId = this.array[absRowId][0];
			var dummyrow = this.options.xcsv.GetDummyRow(rowId);
			var formattedRow = this.options.xcsv.View.GetFormattedRow(dummyrow);
			var start = 0; // Starting value
			var duration = dummyrow[viewdef.durationField] * 1;
			var delay = 0;
			if(viewdef.delayField != null) delay = dummyrow[viewdef.delayField] * 1;
			var startDate = null;
			if(showDates && dummyrow[viewdef.startDateField] != "" && dummyrow[viewdef.startDateField] != null) {
				startDate = Packages.Library.$.GetEpochFromDate({date: dummyrow[viewdef.startDateField]}) / unit;
				if(earliestStartDate == null || startDate < earliestStartDate) earliestStartDate = startDate * 1; // Store
				start += startDate;
			}
			var end = start + duration;
			var dependancies = Packages.Library.$.Split({value: dummyrow[viewdef.dependancyField], splitter: ","});
			var first = (dependancies.length > 0 ? 0 : 1);
			var progress = 0; // Assume progress 0% if not specified
			if(viewdef.progressField != null) {
				progress = dummyrow[viewdef.progressField];
				if(progress == "") progress = 0;
			}
			var task = {
				dummyrow: dummyrow,
				formattedRow: formattedRow,
				rowId: rowId,
				start: start,
				startDate: startDate,
				name: dummyrow[viewdef.nameField],
				duration: duration + delay,
				delay: delay,
				end: end,
				dependancies: dependancies,
				first: first,
				progress: progress
			};
			tasks[rowId] = task;
			
			if(first) {
				task.lastTaskEnd = 0;
				projects[rowId] = task;
			}
		}
		if(earliestStartDate == null) earliestStartDate = 0;
		
		// Check all dependancies, and remove dependancies that are implied
		// Implied dependancies occur when C depends on A and B, but B depends on A
		// C. Therefore C does not need to depend on A, it is implied by B.
		for(var i = 0; i < tasks.length; i++) {
			var task = tasks[i];
			if(task == null) continue; // Skipped row
			var dependancies = task.dependancies;
			
			// If we share any of the dependancies this task has, remove it
			var dependancyMap = {}; // Map of dependancies our dependant items have
			var counter = 0; // Stop infinity
			var firstTask = null;
			var searchFn = function(task, count) {
				if(task == null) return; // Skipped row
				counter ++;
				if(counter > 1000) return;
				if(count == null) count = 0;
				var dependancies = task.dependancies;
				if(dependancies == null) return;
				if(dependancies.length == 0) firstTask = task;
				for(var d = 0; d < dependancies.length; d++) {
					if(count > 0) dependancyMap[dependancies[d]] = 1; // Mark as implied if not self
					searchFn(tasks[dependancies[d]], count + 1);
				}
			};
			searchFn(task);
			
			if(firstTask == null) {
				// Did not find a first task, so this can not be
				// displayed. So skip.
				tasks[i] = null;
				continue;
			}
			
			// Record the first task as the project task
			task.project = firstTask;
			
			// Create a new list of the dependancies we really need
			var newDependancies = [];
			
			// Process dependancies
			for(var d = 0; d < dependancies.length; d++) {
				var dependancy = tasks[dependancies[d]];
				if(dependancy == null) continue; // Error, ignore
				
				// Do we need this dependancy, or is it implied?
				if(dependancyMap[dependancies[d]] == 1) {
					continue;
				} else {
					newDependancies.push(dependancies[d]);
				}
				
				// Tell the dependancy we need it
				if(dependancy.usedBy == null) dependancy.usedBy = {};
				dependancy.usedBy[task.rowId] = task;
			}
			
			task.dependancies = newDependancies; // Replace
		}
		
		// Calculate all dependancies
		// And determine earliest start times
		var finished = 0;
		var count = 0; // Infinite loop prevention
		// Keep going until all dependancies are calculated
		while(finished == 0 && count < 1000) {
			finished = 1; // So prove me wrong
			count ++; // No infinite loops allowed
			for(var i = 0; i < tasks.length; i++) {
				var task = tasks[i];
				if(task == null) continue; // Skipped row
				var project = task.project;
				var duration = task.duration;
				var start = task.start;
				var dependancies = task.dependancies;
				
				// Process dependancies
				for(var d = 0; d < dependancies.length; d++) {
					var dependancy = tasks[dependancies[d]];
					if(dependancy == null) continue; // Error, ignore
					
					var dependancyEnd = dependancy.end;
					if(dependancyEnd >= start) {
						// Dependancy will be finished after current start date, so update
						start = dependancyEnd;
						task.criticalDependancy = dependancy;
						finished = 0;
					}
				}
				// If the task has a startDate, it may not start any earlier than that
				if(task.startDate != null && task.startDate > start) start = task.startDate;
				
				// Record information
				var end = start + duration;
				if(project.lastTaskEnd <= end) {
					project.lastTaskEnd = end;
					project.lastTask = task;
					if(project.lastTaskEnd > latestEndDate) latestEndDate = project.lastTaskEnd;
				}
				task.start = start;
				task.end = end;
			}
		}
		
		// Sort out the ordering of all tasks
		// If there are multiple projects, there will be multiple critical paths (one for each)
		var ordered = [];
		var added = {}; // Record whats added
		for(var projectId in projects) {
			var project = projects[projectId];
			
			// Find critical path
			var criticalPath = [];
			var dependantOn = project.lastTask;
			while(dependantOn != null) {
				var task = dependantOn;
				task.critical = 1;
				criticalPath.unshift(task);
				dependantOn = task.criticalDependancy;
			}
			// Sort out the ordering
			// First add items from the critical path
			for(var c = 0; c < criticalPath.length; c++) {
				var task = criticalPath[c];
				ordered.push(task);
				added[task.rowId] = 1; // Added
			}
			
			// function to recursively add items that are dependant on a task
			var addItems = function(criticalTask) {
				// Find items that are dependant on this, that aren't added yet
				for(var i = 0; i < tasks.length; i++) {
					var task = tasks[i];
					if(task == null) continue; // Skipped row
					if(added[task.rowId] == 1) continue; // Added already
					if(Packages.Library.$.Contains({array: task.dependancies, item: criticalTask.rowId})) {
						// Found item
						ordered.push(task);
						added[task.rowId] = 1;
						
						// Now find items dependant on this item
						addItems(task);
					}
				}
			}
			
			// Now work our way backward from end, and add in all others
			for(var c = criticalPath.length - 1; c >= 0; c--) {
				var criticalTask = criticalPath[c];
				
				addItems(criticalTask);
			}
		}
		
		// Add all others that weren't found?
		for(var i = 0; i < tasks.length; i++) {
			var task = tasks[i];
			if(task == null) continue; // Skipped row
			if(added[task.rowId] == 1) continue; // Added already
			
			ordered.push(task);
			
			added[task.rowId] = 1; // Added
		}
		
		// Tell all ordered tasks what their ordered numbers were
		for(var i = 0; i < ordered.length; i++) {
			ordered[i].order = i;
		}
		
		// Calculate the following information
		var totals = []; // Totals for each column, number of tasks running at a point in time
		var fieldsTotals = []; // Total for the fieldsToDisplay
		var columndefMap = this.options.xcsv.GetColumnDefMap();
		var fieldsToDisplay = viewdef.fieldsToDisplay; // The fields to display
		var fields = []; // The 2D array of field data
		var bars = []; // Where to place dependancy bars
		for(var i = 0; i < ordered.length; i++) {
			var task = ordered[i];
			if(task == null) continue; // Skipped row
			var dummyrow = task.dummyrow;
			fields[i] = [];
			
			// Fields to Display
			for(var f = 0; f < fieldsToDisplay.length; f++) {
				var field = fieldsToDisplay[f];
				fields[i][f] = task.formattedRow[field].replace(/ /g, "&nbsp;");
				if(dummyrow[field] * 1 == dummyrow[field]) {
					// Purely Numeric
					if(fieldsTotals[f] == null) fieldsTotals[f] = 0;
					fieldsTotals[f] += (dummyrow[field] * 1);
				}
			}
			
			// Add to totals
			for(var x = Math.floor(task.start + 0.5); x < Math.floor(task.end + 0.5); x ++) {
				if(totals[x] == null) totals[x] = 0;
				totals[x]++;
			}
			
			// Calculate floaters to all dependancies
			if(task.usedBy != null) {
				for(var rowId in task.usedBy) {
					var usedBy = tasks[rowId];
					var a, b;
					if (task.order < usedBy.order) {
						a = task.order;
						b = usedBy.order;
					} else {
						b = task.order;
						a = usedBy.order;
					}
					// Mark dependancies
					for(var s = a; s <= b; s++) {
						if(bars[s] == null) bars[s] = [];
						bars[s].push(usedBy.start);
					}
					
					// Mark floaters
					var floatBy = usedBy.start - task.end;
					if(floatBy > 0) task.floatBy = floatBy;
				}
			}
		}
		
		// Align earliest / last dates
		earliestStartDate = Math.floor(earliestStartDate);
		latestEndDate = Math.ceil(latestEndDate);
		var range = latestEndDate - earliestStartDate;
		var increments = Math.ceil(range); // Force integer
		var now = (new Date().getTime() / 1000) / unit;
		
		// Create the HTML
		var rows = "";
		for(var i = 0; i < ordered.length; i++) {
			var task = ordered[i];
			var row = "";
			
			// Fields to Display
			for(var f = 0; f < fields[i].length; f++) {
				var field = fields[i][f];
				row += "<td "
						+	"class='xcsv_gantt_name' "
					+	">"
						+	field;
					+	"<\/td>";
			}
			
			// The bars
			var barHtml = "";
			if(bars[i] != null) {
				for(var b = 0; b < bars[i].length; b++) {
					barHtml += "<div "
								+	"class='xcsv_gantt_bar "
								+ 	"' "
								+	"style='"
									+	"margin-left:" + (((bars[i][b] - earliestStartDate) / range) * 100) + "%;"
								+	"' "
							+	">&nbsp;<\/div>";
				}
			}
			
			// Now Time bar
			var nowHtml = "<div "
							+	"class='xcsv_gantt_now_bar xcsv_gantt_bar"
							+ 	"' "
							+	"style='"
								+	"margin-left:" + (((now - earliestStartDate) / range) * 100) + "%;"
							+	"' "
						+	">&nbsp;<\/div>";
			
			// The duration
			row += "<td style='position: relative;'>"
					+	nowHtml
					+	barHtml
					// Delay
					+	"<div "
						+	"class='xcsv_gantt_cell "
							+ "xcsv_gantt_delay mColSilver "
						+ 	"' "
						+	"style='"
							+	"margin-left:" + (((task.start - earliestStartDate) / range) * 100) + "%;"
							+	"width:" + ((task.delay / range) * 100) + "%;"
						+	"' "
					+	">"
					+		"&nbsp;"
					+	"<\/div>"
					// The actual bar
					+	"<div "
						+	"class='xcsv_gantt_cell "
							+ "xcsv_gantt_duration "
							+ (task.critical == 1 ? "xcsv_gantt_duration_critical mColRed " : "mColYellow ")
						+ 	"' "
						+	"style='"
							+	"margin-left:" + (((task.start + task.delay - earliestStartDate) / range) * 100) + "%;"
							+	"width:" + (((task.duration - task.delay) / range) * 100) + "%;"
						+	"' "
					+	">"
					+		"<div class='xcsv_gantt_duration_progress mColGreen' style='width: " + task.progress + "%'>"
						+		"&nbsp;"
						+	"<\/div>"
					+	"<\/div>"
					// Float arrows
					+	(task.floatBy > 0
							?	"<div "
								+	"class='xcsv_gantt_cell "
									+ "xcsv_gantt_float "
								+ 	"' "
								+	"style='"
									+	"margin-left:" + (((task.start + task.duration - earliestStartDate) / range) * 100) + "%;"
									+	"width:" + ((task.floatBy / range) * 100) + "%;"
								+	"' "
							+	">"
								+	"<div class='xcsv_gantt_arrow'><\/div><div>&nbsp;<\/div>"
							+	"<\/div>"
							:	""
						)
				+	"<\/td>";
			
			rows += "<tr "
					+	"onclick=\"" + this.options.xcsv.textVar + ".View.SwitchView({rowId: " + task.rowId + ", viewref: '" + this.options.viewdef.editView + "'})\" "
				+	">" + row + "<\/tr>";
		}
		
		// Create header
		var header = "";
		for(var f = 0; f < fieldsToDisplay.length; f++) {
			var field = fieldsToDisplay[f];
			var name = columndefMap[field].name;
			header += "<th width='1%'>" + name + "<\/th>";
		}
		if(increments < 100) {
			var datesHtml = "";
			for(var x = earliestStartDate; x < latestEndDate; x++) {
				var date = new Date(x * 1000 * unit);
				datesHtml += "<div class='xcsv_gantt_time' style='margin-left: " + ((100 / increments) * (x - earliestStartDate)) + "%'><div>" + date.toLocaleDateString() + "<\/div><\/div>";
			}
			header += "<td class='xcsv_gantt_time_table'><div class='xcsv_gantt_time_table_offset'>" + datesHtml + "<\/div><\/td>";
		}
		rows = "<tr>" + header + "<\/tr>" + rows;
		
		// Create footer (totals)
		var footer = "";
		for(var f = 0; f < fieldsTotals.length; f++) {
			var field = fieldsTotals[f];
			footer += "<td class='xcsv_gantt_totals'>" + (field != null ? field : "") + "<\/td>";
		}
		if(increments < 100) {
			var totalsHtml = "";
			for(var x = earliestStartDate; x < latestEndDate; x++) {
				if(totals[x] == null) totals[x] = 0;
				totalsHtml += "<div class='xcsv_gantt_totals_total' style='margin-left: " + ((100 / increments) * (x - earliestStartDate)) + "%'><div>" + totals[x] + "<\/div><\/div>";
			}
			footer += "<td class='xcsv_gantt_totals'>" + totalsHtml + "<\/td>";
		}
		rows += "<tr>" + footer + "<\/tr>";
		
		var html = "<table class='xcsv_gantt_table'>" + rows + "<\/table>";
		
		return html;
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		return "";
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.GanttChart.$.GetDetails = function() {
	return {
		name: "Gantt Chart",
		description: "Displays a the data in a Gantt Chart format"
	}
};Package("Library.CSV.ViewTypes.GoBackHistory").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.GoBackHistory.$.GetEditForm = function(editor) {
	return [
		{
			name:	"Steps",
			description: "The number of history points to travel back\n"
					+	"A history point is added when a View has 'History point' enabled.\n"
					+	"Specifying [2] will take the user back to the history point before the last history point seen.\n"
					+	"If the number of steps exceeds the length of the history, the first history point will be returned to.",
			type:	"Text",
			numeric: 1,
			min:	0,
			step:	1,
			value:	1,
			id:		"steps"
		}
	];
};/*******************************************************************************
 * Listing - displays just the currently selected item
 ******************************************************************************/
Package("Library.CSV.ViewTypes.GoBackHistory").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
		
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		return "";
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		return "";
	};
	
	/******************************************************
	 * PostAction - called after rendering complete
	 ****************************************************/
	this.PostAction = function() {
		var steps = this.options.viewdef.steps;
		var history = this.options.xcsv.View.history;
		if(history.length < steps) steps = history.length; // Go back as far as possible
		
		var viewRef = history[history.length - steps];
		
		this.options.xcsv.View.SwitchView({
			viewref: viewRef
		});
	}
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.GoBackHistory.$.GetDetails = function() {
	return {
		name: "Go Back (History)",
		description: "Returns to a previous visited view"
	}
};Package("Library.CSV.ViewTypes.Listing").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Listing.$.GetEditForm = function(editor) {
	return [
		{
			name: "Page Size",
			description: "How many rows are displayed at a time.",
			id: "pagesize",
			value: 10,
			type: "Text",
			numeric: 1,
			complexity: 2
		}
	];
};/*******************************************************************************
 * Listing - creates a simple list of items that match the search
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Listing").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {
		if(this.options.rowId == null) this.options.rowId = this.options.xcsv.initialViewRow;
		
		this.array = this.options.xcsv.ControlAlterArray("Listing");
	}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		var htmlrows = "";
		if(this.array.length == 0) {
			// No matches, output no matches text
			htmlrows = this.options.viewdef.text_nomatches;
		} else {
			var storeRowId = this.options.rowId;
			
			for(var i = 0; i < this.array.length; i++) {
				var rowId = this.array[i][0];
				this.options.xcsv.View.UpdateRowId(rowId, 0); // Do not override currently selected rowId
				
				var htmlrow = this.options.xcsv.View.GetViewRow();
				if(htmlrow != null) htmlrows += htmlrow;
			}
			
			// Restore rowid
			this.options.rowId = storeRowId;
		}
		
		// For the current format, get the view container
		return Packages.Library.CSV.ViewFormats[this.options.viewdef.format].$.DisplayWrapper(this.options.viewdef, this.options.dummyrow, htmlrows, this.options.xcsv);
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		// For the current format, get the current view
		return Packages.Library.CSV.ViewFormats[this.options.viewdef.format].$.Display(this.options.viewdef, this.options.xcsv.View.GetFormattedRow(), this.options.rowdata, this.options.xcsv);
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Listing.$.GetDetails = function() {
	return {
		name: "Listing",
		description: "Lists the rows that match the filters.",
		requiresViewFormat: 1
	}
};Package("Library.CSV.ViewTypes.ListingWithGallery").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.ListingWithGallery.$.GetEditForm = function(editor) {
	// Get the list of effects
	var effects = [];
	for(var effect in Packages.Library.Gallery.Effects) {
		if(effect.match(/^\$/)) continue;
		effects.push({name: effect, value: effect});
	}
	
	return [
		{
			name: "Page Size",
			description: "How many rows are displayed at a time.",
			id: "pagesize",
			value: 10,
			type: "Text",
			numeric: 1,
			complexity: 2
		},
		{
			type: "Label",
			label: "Choose your effects",
			size: 4
		},
		{
			type: "SelectBox",
			options: effects,
			id: "sm_effect",
			name: "Inline effect"
		},
		{
			type: "Label",
			label: "Other Options",
			size: 4
		},
		{
			type: "Text",
			id: "delay",
			name: "Auto Delay (seconds)",
			description: "Enter -1 for no auto"
		},
		{
			type: "Text",
			id: "width",
			name: "Fixed inline width (pixels)",
			description: "Enter -1 for no fixed width",
			suffix: "px",
			numeric: 1,
			min: 0,
			size: 4
		},
		{
			type: "Text",
			id: "height",
			name: "Fixed inline height (pixels)",
			description: "Enter -1 for no fixed height",
			suffix: "px",
			numeric: 1,
			min: 0,
			size: 4
		},
		{
			type: "Checkbox",
			id: "preloadFilters",
			name: "Use global filters",
			description: "When enabled, the rows will be filtered by the filters applied by the user.\n" +
						"When disabled, user filtering will be ignored for this panel."
		}
	];
};Package("Library.CSV.ViewTypes.ListingWithGallery").$.InitPackage = function() {
    Packages.Library.CSV.ViewTypes.ListingWithGallery.view.prototype = new Packages.Library.CSV.ViewTypes.Listing.view();
}
/*******************************************************************************
 * ListingWithGallery - creates a list of items that match the search with paging
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.ListingWithGallery.view = function() {
	this.$super = new Packages.Library.CSV.ViewTypes.Listing.view();
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {
		if(this.options.rowid == null) this.options.rowid = this.options.xcsv.initialViewRow;
		
		this.array = this.options.xcsv.csvdata;
		if(this.options.viewdef.preloadFilters == 1) this.array = this.options.xcsv.ControlAlterArray("Listing");
	}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
        
        var htmlArray = [];
        for(var i = 0; i < this.array.length; i++) {
            this.options.xcsv.View.UpdateRowId(this.array[i][0]);
            
            var htmlrow = this.options.xcsv.View.GetViewRow();
            if(htmlrow != null) htmlArray.push(htmlrow);
        }
        
        this.gallery = {
            fs_effect: 	null,
			sm_effect: 	this.options.viewdef.sm_effect,
			width: 		this.options.viewdef.width,
			height: 	this.options.viewdef.height,
			delay: 		this.options.viewdef.delay
        };
        this.gallery.pages = htmlArray;
        
        // Get the object
        this.gallery.Gallery = new Packages.Library.Gallery.Gallery(this.gallery);
        return this.gallery.Gallery.Display();
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.ListingWithGallery.$.GetDetails = function() {
	return {
		name: "Listing With Gallery",
		description: "Lists the rows as a gallery.",
		requiresViewFormat: 1
	}
};Package("Library.CSV.ViewTypes.Logon").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Logon.$.GetEditForm = function(editor) {
	return [
		{
			name: "Template User",
			subtitle: "Or blank to disable sign up",
			description: "Used for User Sign Up.\n" +
							"The template user to clone to create a new user. Once the clone is complete the details are updated to those used during registration",
			type: "Text",
			value: "",
			id: "templateUser"
		},
		{
			name: "Single Field Logon",
			description: "Displays only a username field. The username entered also contains the password in the following format<br>"
						+"username-password",
			type: "Checkbox",
			checked: 0,
			id: "singleFieldLogin"
		}
	]
};/*******************************************************************************
 * Logon - displays a logon form
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Logon").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowid : the absolute rowid
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
	
	/******************************************************
	 * Display - creates the HTML for an Add Form
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		var html = Packages.Library.$.CreateAccountForm({
			reloadOnLogin: this.options.xcsv.interactive,
			signupTemplate: this.options.viewdef.templateUser,
			singleFieldLogin: this.options.viewdef.singleFieldLogin
		});
		
		return html;
	};
	
	/******************************************************
	 * DisplayRow - should never be called
	 ****************************************************/
	this.DisplayRow = function() {
		return null;
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Logon.$.GetDetails = function() {
	return {
		name: "Logon",
		description: "Displays a login form",
		requiresViewFormat: 0
	}
};Package("Library.CSV.ViewTypes.Message").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Message.$.GetEditForm = function(editor) {
	return [
		{
			name: "Message",
			description: "This message will appear in this view",
			type: "RichText",
			value: "Content",
			id: "content"
		}
	];
};/*******************************************************************************
 * Listing - displays just the currently selected item
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Message").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		var html = this.options.viewdef.content;
		
		return html;
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		return "";
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Message.$.GetDetails = function() {
	return {
		name: "Message",
		description: "Displays a message."
	}
};Package("Library.CSV.ViewTypes.Report").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Report.$.GetEditForm = function(editor) {
	return [
		{
			name: "Reports",
			description: "Add the items to the report",
			type: "MultiForm",
			id: "reports",
			titleRef: "<%columnref%> (<%StatAnalysis%>)",
			form: {
				type: "Form",
				idprefix: "multichoice",
				items: [
					{
						name: "Column to report on",
						id: "columnref",
						value: "",
						type: "SelectBox",
						options: editor.currentRowsList,
						complexity: 1
					},
					Packages.Library.StatisticalAnalysis.$.GetChoiceFormItem()
				]
			}
		}
	];
};/*******************************************************************************
 * Listing - displays just the currently selected item
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Report").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		// Force all fields to be ran through GetDummyRow and thus calculated first
		this.options.xcsv.RecalculateAllRows();
		
		var items = [];
		var _this = this;
		foreach(this.options.viewdef.reports, function(report) {
			// Get the data for all fields in the column
			var columndef = Packages.Library.$.FindArrayItem({array: _this.options.xcsv.data.columndefs, path: "refcode", value: report.columnref});
			if(columndef == null) return;
			var data = _this.options.xcsv.GetFieldsInColumn(columndef);
			
			items.push({
				name: columndef.name + " (" + report.StatAnalysis + ")",
				value: Packages.Library.StatisticalAnalysis.$.Analyse({
					statOptions: report,
					data: data
				})
			});
		});
		
		// Create the display of this data
		var rows = "";
		foreach(items, function(item) {
			rows += "<tr>"
					+	"<td>"
						+	item.name
					+	"<\/td><td>"
						+	item.value
					+	"<\/td>"
				+	"</tr>";
		})
		
		return "<table class='xcsv_report'>" + rows + "<\/table>";
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		return "";
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Report.$.GetDetails = function() {
	return {
		name: "Report",
		description: "Displays a collection of summary information about the data"
	}
};Package("Library.CSV.ViewTypes.Single").edit = function(){};
/*******************************************************************************
 * GetEditForm - gets the form to edit the specifics for this cell type
 *
 * param - editor : editor object
 *
 * Returns an array of form items
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Single.$.GetEditForm = function(editor) {
	return [];
};/*******************************************************************************
 * Listing - displays just the currently selected item
 ******************************************************************************/
Package("Library.CSV.ViewTypes.Single").view = function() {
	/******************************************************
	 * SetOptions - updates the options for this ViewType
	 *
	 * param - options : hash of options, always contain:
	 * 			viewdef : the view def
	 * 			xcsv : the xcsv object
	 * 		may contain:
	 * 			rowId : the absolute rowId
	 * 			dummyrow : the dummyrow
	 * 			rowdata : the row data for this row
	 ****************************************************/
	this.SetOptions = function(options) {
		this.options = options;
	}
	
	/******************************************************
	 * PreProcessData - processes data before creating view
	 ****************************************************/
	this.PreProcessData = function() {}
	
	/******************************************************
	 * Display - creates the HTML for this listing
	 *
	 * returns the html
	 ****************************************************/
	this.Display = function() {
		if(this.options.rowId == null) {
			return this.options.xcsv.data.text.noRowSelectedText; // Can not edit nothing
		}
		
		var htmlrows = this.options.xcsv.View.GetViewRow();
		
		// For the current format, get the view container
		return Packages.Library.CSV.ViewFormats[this.options.viewdef.format].$.DisplayWrapper(this.options.viewdef, this.options.dummyrow, htmlrows, this.options.xcsv);
	};
	
	/******************************************************
	 * DisplayRow - creates the HTML for the current row
	 *
	 * returns the html
	 ****************************************************/
	this.DisplayRow = function() {
		// For the current format, get the current view
		return Packages.Library.CSV.ViewFormats[this.options.viewdef.format].$.Display(this.options.viewdef, this.options.xcsv.View.GetFormattedRow(), this.options.rowdata, this.options.xcsv);
	};
};

/*******************************************************************************
 * GetDetails - gets information about this view type
 ******************************************************************************/
Packages.Library.CSV.ViewTypes.Single.$.GetDetails = function() {
	return {
		name: "Single",
		description: "Displays a single row.",
		requiresViewFormat: 1
	}
};Package("Library.CSV").View_MenuBox = function() {
	/*********************************************************************
	 * GetMenu - RECURSIVE - creates the interactive menu that will encode information
	 * into the query string
	 *
	 * param - options : options to describe this, containing:
	 * 			showOuterUL : (optional) 1 do not wrap in UL, 0 (default) do wrap
	 * 		and the options for this.GetMenu
	 * 		and the options for Packages.Library.$.CreateMenu
	 *
	 * returns the html for this item
	 ********************************************************************/
	this.GetMenuHTML = function(options) {
		if(options == null) options = {};
		var menuitems = this.GetMenu(options);
		
		if(menuitems == null) return "";
		
		options.menudata = menuitems;
		
		// Get HTML version
		return Packages.Library.$.CreateMenu(options);
	}
	/*********************************************************************
	 * GetMenu - RECURSIVE - creates the interactive menu that will encode information
	 * into the query string
	 *
	 * param - options : options to describe this, containing:
	 * 			pageurl : (optional) page url to use, or null for current page
	 * 			showOuterUL : (optional) 1 do not wrap in UL, 0 (default) do wrap
	 * 			classes : (optional) array of classnames for each container depth
	 * 			filterby : (optional) hash of filterby objects
	 * 			nestUL : (optional) if 1 (default) will nest ULs, otherwise will just list all of the LIs without container ULs
	 * param - depth : current depth of recursion
	 * param - queries : current queries
	 *
	 * returns the array of menu items or null if no menu
	 ********************************************************************/
	this.GetMenu = function(options, depth, queries) {
		if(options == null) options = {};
		if(options.pageurl == null) options.pageurl = "";
		if(options.classes == null) options.classes = [];
		if(options.filterby == null) options.filterby = {};
		if(depth == null) depth = 0;
		if(queries == null) queries = {};
		
		// Get columnref at this depth
		var drilldowndef = this.xcsv.data.drilldown[depth];
		if(drilldowndef == null) return null; // Reached end of drill down
		
		// Get columndef
		var columndef = Packages.Library.$.FindArrayItem({array: this.xcsv.data.columndefs, path: "refcode", value: drilldowndef.refcode});
		
		// Get variations
		var variations = this.xcsv.GetVariations(columndef.id, options.filterby);
		
		// Create a menuitems array
		var menuitems = [];
		
		// Get LIs for each variation
		for(var safevariationname in variations) {
			var queriesCopy = Packages.Library.$.Clone({oldObj: queries});
			var count = variations[safevariationname].count;
			var text = variations[safevariationname].text;
			
			queriesCopy["xcsv_filter_" + drilldowndef.refcode + "_" + safevariationname] = 1;
			
			// Get any children menus
			// Set up filterby
			options.filterby[columndef.id] = {};
			options.filterby[columndef.id][safevariationname] = 1;
			var submenu = this.GetMenu(options, depth + 1, queriesCopy);
			
			// Remove filter
			options.filterby[columndef.id] = null;
			
			// Create def
			menuitems.push({
				name: text,
				href: Packages.Library.$.AddGlobalQueries({
					url: options.pageurl,
					localQueries: queriesCopy,
					queryGroup: "xcsv_filter"
				}),
				hrefAddGlobals: 0,
				submenu: submenu
			});
		}
		
		if(menuitems.length == 0) return null;
		return menuitems;
	};
};/**********************************
 * XMLRPC - deals solely with communication back to the server
 *
 * param - xcsv : reference to primary xcsv object
 *********************************/
Package("Library.CSV").XMLRPC = function(xcsv) {
	this.xcsv = xcsv;
	this.textvar = GetTextRef(this);
	/*********************************************************************
	 * LoadFields - creates the method call to load the specified row
	 * from the server to the local CSV data in memory, and refresh
	 *
	 * param - rowId : the row id
	 *
	 * returns an array of xmlrpc method defs ready to be called
	 ********************************************************************/
	this.LoadFields = function(rowId) {
		
		var primaryKey = xcsv.GetPrimaryKey(rowId);
		if(primaryKey == 0) return [];
		
		var absRowId = xcsv.GetAbsoluteRowId(rowId);
		if(absRowId == null) return [];
		
		/*********************************************************************
		 * LoadFieldsCallback - callback when LoadFields returns, in scope
		 *
		 * param - response : the array of response values from the server
		 ********************************************************************/
		var LoadFieldsCallback = function(response) {
			
			if(response == null || response.length == 0) return;
			
			var dummyrow = xcsv.GetDummyRow(rowId);
			
			// Update dummy row
			for(var i = 0; i < xcsv.data.columndefs.length; i++) {
				var columndef = xcsv.data.columndefs[i];
				dummyrow[columndef.refcode] = response[0][columndef.id - 1];
			}
			
			xcsv.SetDummyRow(rowId, dummyrow, {updateServer: 0, validate: 0});
		};
		
		return [{
			classname: "XCSV",
			method: "GetFields",
			params: [this.xcsv.xmlFilePath, Packages.Library.$.ToNumber({str: primaryKey})],
			callback: LoadFieldsCallback
		}];
	};
	
	/*********************************************************************
	 * LoadField - creates the method call to load the specified field and row
	 * from the server to the local CSV data in memory, and refresh
	 *
	 * param - rowId : the row id
	 * param - columnref : column ref code
	 *
	 * returns an array of xmlrpc method defs ready to be called
	 ********************************************************************/
	this.LoadField = function(rowId, columnref) {
		
		var primaryKey = xcsv.GetPrimaryKey(rowId);
		if(primaryKey == 0) return [];
		
		var absRowId = xcsv.GetAbsoluteRowId(rowId);
		if(absRowId == null) return [];
		
		/*********************************************************************
		 * LoadFieldCallback - callback when LoadField returns, in scope
		 *
		 * param - response : the array of response values from the server
		 ********************************************************************/
		var LoadFieldCallback = function(response) {
			
			var dummyrow = xcsv.GetDummyRow(rowId);
			
			dummyrow[columnref] = response[0];
			
			xcsv.SetDummyRow(rowId, dummyrow, {updateServer: 0, validate: 0});
		};
		
		return [{
			classname: "XCSV",
			method: "GetField",
			params: [this.xcsv.xmlFilePath, Packages.Library.$.ToNumber({str: primaryKey}), columnref],
			callback: LoadFieldCallback
		}];
	};
	
	/*********************************************************************
	 * SetField - creates the method call to save the specified field
	 * to the server from the local CSV data in memory
	 *
	 * param - rowid : the row id
	 * param - columnref : the column refcode
	 * param - value : value to save
	 *
	 * returns an array of xmlrpc method defs ready to be called
	 ********************************************************************/
	this.SetField = function(rowid, columnref, value) {
		
		var primaryKey = xcsv.GetPrimaryKey(rowId);
		if(primaryKey == 0) return [];
		
		var absRowId = xcsv.GetAbsoluteRowId(rowId);
		if(absRowId == null) return [];
		
		// Force value to be a string
		value = value + "";
		
		/*********************************************************************
		 * SetFieldCallback - callback when SetField returns, in scope
		 *
		 * param - response : the array of response values from the server
		 ********************************************************************/
		var SetFieldCallback = function(response) {};
		
		return [{
			classname: "XCSV",
			method: "SetField",
			params: [this.xcsv.xmlFilePath, Packages.Library.$.ToNumber({str: primaryKey}), columnref, value],
			callback: SetFieldCallback
		}];
	};
	
	/*********************************************************************
	 * SetFields - creates the method call to save the specified row
	 * to the server from the local CSV data in memory
	 *
	 * param - rowId : the row id
	 * param - rowdata : the entire rowdata to save to the server
	 *
	 * returns an array of xmlrpc method defs ready to be called
	 ********************************************************************/
	this.SetFields = function(rowId, srcRowData) {
		
		var primaryKey = xcsv.GetPrimaryKey(rowId);
		if(primaryKey == 0) return [];
		
		var absRowId = xcsv.GetAbsoluteRowId(rowId);
		if(absRowId == null) return [];
		
		for(var i = 0; i < srcRowData.length; i++) {
			srcRowData[i] += ""; // Force to be a string
		}
		
		/*********************************************************************
		 * SetFieldsCallback - callback when SetField returns, in scope
		 *
		 * param - response : the array of response values from the server
		 ********************************************************************/
		var SetFieldsCallback = function(response) {};
		
		// Row Data is 1 based, convert to a zero based array
		rowdata = Packages.Library.$.Clone({oldObj: srcRowData});
		rowdata.splice(0,1);
		
		return [{
			classname: "XCSV",
			method: "SetFields",
			params: [this.xcsv.xmlFilePath, Packages.Library.$.ToNumber({str: primaryKey}), rowdata],
			callback: SetFieldsCallback
		}];
	};
	
	/*********************************************************************
	 * AddRow - creates the method call to add a new row
	 * to the server from the local CSV data in memory
	 *
	 * param - rowdata : the entire rowdata to add to the server
	 *
	 * returns an array of xmlrpc method defs ready to be called
	 ********************************************************************/
	this.AddRow = function(srcRowData) {
		var _this = this;
		/*********************************************************************
		 * AddRowCallback - callback when AddRow returns, in scope
		 *
		 * param - response : the array of response values from the server
		 ********************************************************************/
		var AddRowCallback = function(response) {
			_this.xcsv.forceReload = 1;
		};
		
		for(var i = 0; i < srcRowData.length; i++) {
			srcRowData[i] += ""; // Force to be a string
		}
		
		// Row Data is 1 based, convert to a zero based array
		rowdata = Packages.Library.$.Clone({oldObj: srcRowData});
		rowdata.splice(0,1);
		
		// Create method def
		var methods = [{
			classname: "XCSV",
			method: "AddRow",
			params: [this.xcsv.xmlFilePath, rowdata],
			callback: AddRowCallback
		}];
		
		return methods;
	};
};/**********
 * Cookie - provides API tools for setting and reading cookies
 *
 * Cookies are assumed to be limited to 4K, although there does not appear to be
 * a definitive limit. It is highly recommended to stay within 4K.
 *
 * Cookies are stored in a bizarre text form, each cookie is applied indepently
 * window.document.cookie = 'name=value; expires=Thu, 2 Aug 2001 20:47:11 UTC; path=/'
 * 
**********/
Package("Library").Cookie = function() {}
/**************************************************************************
 * SetCookie - takes the specified hash of name value pairs and applies them as cookies
 *
 * If a value is an object, the object gets converted to a text representation of the object and stored
 *
 * param - options : hash of options:
 * 	must contain:
 * 		hash : the hash of name value pairs to store
 * 	optionally contain:
 * 		days : days until expiry (default will not expire)
 *************************************************************************/
Packages.Library.$.SetCookie = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SetCookie",
		options: options,
		specification: {
			hash: 	{type: "object",	required: 1},
			days: 	{type: "number"}
		}
	})) return;

	var expires = "";
	if(options.days != null) {
		// Get expire date (if we need one)
		var date = new Date();
		date.setTime(date.getTime() + (options.days * 24 * 60 * 60 * 1000));
		expires = "; expires=" + date.toGMTString();
	}
	
	// Process the hash
	for(var key in options.hash) {
		// Get values, and convert all of the values to strings
		var value = Packages.Library.$.Dump({obj: options.hash[key]})
		
		// Make this string very safe
		var value64 = window.btoa(value);
		
		// Store cookie
		document.cookie = key + "=" + value64 + expires + "; path=/";
	}
};
/**************************************************************************
 * GetCookies - gets a hash of all of the current cookies associated with this path
 *
 * returns a hash of cookies, and re-objectises any child objects
 *************************************************************************/
Packages.Library.$.GetCookies = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetCookies",
		options: options,
		specification: {}
	})) return null;
	
	if(Packages.Library.$v.testing == 1) return {};
	
	// Get cookie string
	var cookieString;
	if(typeof(pCookieString) != "undefined") {
		cookieString = pCookieString
	} else {
		cookieString = document.cookie;
	}
	if(cookieString == null) return {}; // No cookies
	
	// Try to use cache
	if(cookieString == Packages.Library.$v.cacheCookieString) {
		return Packages.Library.$v.cacheCookieHash;
	}
	Packages.Library.$v.cacheCookieString = cookieString;
	var cookies = cookieString.split(';');
	
	// Get cookies
	var hash = {};
	
	for(var i = 0; i < cookies.length; i++) {
		var cookie = cookies[i];
		cookie = cookie.replace(/^ +/, ""); // Remove leading whitespace
		if(cookie.match(/^(.+?)=(.+)$/)) {
			var key = RegExp.$1;
			var value = RegExp.$2;
			
			// Restore original value back (make it unsafe)
			try {
				value = atob(value);
			} catch(e) {}
			
			// Attempt to re-objectise
			try{
				eval("value = " + value); // re-objectise
			} catch(e) {
				var debug = e.message;
			}
			hash[key] = value;
		}
	}
	
	Packages.Library.$v.cacheCookieHash = hash;
	
	return hash;
};

Packages.Library.$v.cacheCookieString;
Packages.Library.$v.cacheCookieHash;Package("Library").CrossBrowser = function() {};

if(typeof(window) == "undefined") window = {} // For node
if(typeof(document) == "undefined") document = {} // For node

// Cross Browser corrections
if(Function.prototype.bind == null || 1) {
	Function.prototype.bind = function() {
		var fn = this,
			args = [].slice.call( arguments ),
			object = args.shift();
		return function() {
			return fn.apply( object, args.concat( [].slice.call(arguments) ) );
		};
	};
}

// only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
	return Object.prototype.toString.call(obj) === '[object Array]';
  }
};
// from http://www.webdeveloper.com/forum/showpost.php?p=962653&postcount=23
if (!document.getElementsByClassName) {
	document.getElementsByClassName = function (cn) { 
		var rx = new RegExp("(?:^|\\s)" + cn+ "(?:$|\\s)");
		var allT = document.getElementsByTagName("*"), allCN = [],ac="", i = 0, a;
			while (a = allT[i=i+1]) {
			  ac=a.className;
			  if ( ac && ac.indexOf(cn) !==-1) {
				if(ac===cn){ allCN[allCN.length] = a; continue;   }
				rx.test(ac) ? (allCN[allCN.length] = a) : 0;
			  }
			}
		return allCN;
	}
}
/******************
 * Disabled Chrome security (add to target on icon): chrome.exe --disable-web-security
 *****************/


/**
*
*  Base64 encode / decode
*  http://www.webtoolkit.info/
*
**/
var Base64 = {
	// private property
	_keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
	// public method for encoding
	encode : function (input) {
		var output = "";
		var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
		var i = 0;
		input = Base64._utf8_encode(input);
		while (i < input.length) {
			chr1 = input.charCodeAt(i++);
			chr2 = input.charCodeAt(i++);
			chr3 = input.charCodeAt(i++);
			enc1 = chr1 >> 2;
			enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
			enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
			enc4 = chr3 & 63;
			if (isNaN(chr2)) {
				enc3 = enc4 = 64;
			} else if (isNaN(chr3)) {
				enc4 = 64;
			}
			output = output +
			this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
			this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
		}
		return output;
	},
	// public method for decoding
	decode : function (input) {
		var output = "";
		var chr1, chr2, chr3;
		var enc1, enc2, enc3, enc4;
		var i = 0;
		input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
		while (i < input.length) {
			enc1 = this._keyStr.indexOf(input.charAt(i++));
			enc2 = this._keyStr.indexOf(input.charAt(i++));
			enc3 = this._keyStr.indexOf(input.charAt(i++));
			enc4 = this._keyStr.indexOf(input.charAt(i++));
			chr1 = (enc1 << 2) | (enc2 >> 4);
			chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
			chr3 = ((enc3 & 3) << 6) | enc4;
			output = output + String.fromCharCode(chr1);
			if (enc3 != 64) {
				output = output + String.fromCharCode(chr2);
			}
			if (enc4 != 64) {
				output = output + String.fromCharCode(chr3);
			}
		}
		output = Base64._utf8_decode(output);
		return output;
	},
	// private method for UTF-8 encoding
	_utf8_encode : function (string) {
		if(typeof(string) != "string") return string;
		string = string.replace(/\r\n/g,"\n");
		var utftext = "";
		for (var n = 0; n < string.length; n++) {
			var c = string.charCodeAt(n);
			if (c < 128) {
				utftext += String.fromCharCode(c);
			}
			else if((c > 127) && (c < 2048)) {
				utftext += String.fromCharCode((c >> 6) | 192);
				utftext += String.fromCharCode((c & 63) | 128);
			}
			else {
				utftext += String.fromCharCode((c >> 12) | 224);
				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
				utftext += String.fromCharCode((c & 63) | 128);
			}
		}
		return utftext;
	},
	// private method for UTF-8 decoding
	_utf8_decode : function (utftext) {
		var string = "";
		var i = 0;
		var c = c1 = c2 = 0;
		while ( i < utftext.length ) {
			c = utftext.charCodeAt(i);
			if (c < 128) {
				string += String.fromCharCode(c);
				i++;
			}
			else if((c > 191) && (c < 224)) {
				c2 = utftext.charCodeAt(i+1);
				string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
				i += 2;
			}
			else {
				c2 = utftext.charCodeAt(i+1);
				c3 = utftext.charCodeAt(i+2);
				string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
				i += 3;
			}
		}
		return string;
	}
};
if(typeof(window.atob) == "undefined") {
	window.atob = Base64.decode.bind(Base64);
	atob = Base64.decode.bind(Base64);
}
if(typeof(window.btoa) == "undefined") {
	window.btoa = Base64.encode.bind(Base64);
	btoa = Base64.encode.bind(Base64);
}

/*********************************************************************
* InitCompatibility - called during General Init, allows cross browser
* changes to be made after Packages name space set up
********************************************************************/
Packages.Library.$.InitCompatibility = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.InitCompatibility",
		options: options,
		specification: {}
	})) return;
	
	if(Packages.Library.$v.testing == 1) return; // Do nothing in test mode
	
	// Stylesheet
	var ieVersion = Packages.Library.$.GetInternetExplorerVersion();
	if(Packages.Library.$.IsSupportedBrowser() == 0 || (ieVersion > 0 && ieVersion < 9)) {
		var el = document.createElement('link');
		el.rel = "stylesheet";
		el.type = 'text/css';
		el.media = 'screen';
		el.id = "compat_css";
		el.href = "/System/Software/JS/Libraries/Compatibility.css?req-plain=1&req-mime=1";
		var pa = document.getElementsByTagName('head')[0];
		pa.appendChild(el);
	}
};/***************************************************************
 * Constants
 **************************************************************/
Package("Library").$c.Debug = {};
/***************************************************************
 * Debug - creates a debug area of the page for diagnostics
 **************************************************************/
Package("Library").Debug = function() {
	this.textVar = GetTextRef(this);
	/***************************************************************
	 * Init - creates the small button that initialises the diagnostic page
	 **************************************************************/
	this.Init = function() {
		// Create button
		var buttonElem = document.createElement("div");
		buttonElem.innerHTML = "Debug";
		buttonElem.className = "debugButton";
		buttonElem.onclick = this.OpenWindow.bind(this);
		var bodyElem = document.getElementsByTagName('body')[0];
		bodyElem.appendChild(buttonElem);
		
		// Create diagnostic screen
		var diagElem = document.createElement("div");
		var html = "<div onclick='" + this.textVar + ".CloseWindow()' class='debugButton'>Close<\/div>";
		html += "<h1>Marlowe Packages Library Diagnostic Tool<\/h1>";
		
		// Load tools
		for(var tool in this.tools) {
			html += "<div class='debugTool'><h3>" + tool + "</h3><hr>" + this.tools[tool]() + "<\/div>";
		}
		
		diagElem.innerHTML = html;
		diagElem.className = "debugArea";
		bodyElem.appendChild(diagElem);
		this.diagElem = diagElem;
	};
	/***************************************************************
	 * OpenWindow - opens the diagnostic window
	 **************************************************************/
	this.OpenWindow = function() {
		this.diagElem.style.display = "block";
	};
	/***************************************************************
	 * CloseWindow - closes the diagnostic window
	 **************************************************************/
	this.CloseWindow = function() {
		this.diagElem.style.display = "none";
	};
	
	this.tools = {
		evalArea : function() {
			return "<textarea id='debugEvalArea' style='width:100%;padding:0px;'></textarea><div id='debugEvalRes' style='background-color:#cccccc;color:#000000;border:1px solid 888888;padding:5px;'><\/div><button onclick=\"document.getElementById('debugEvalRes').innerHTML = eval(document.getElementById('debugEvalArea').value)\">Eval<\/button>";
		},
		evalArea2 : function() {
			return "<textarea id='debugEvalArea2' style='width:100%;padding:0px;'></textarea><div id='debugEvalRes2' style='background-color:#cccccc;color:#000000;border:1px solid 888888;padding:5px;'><\/div><button onclick=\"document.getElementById('debugEvalRes2').innerHTML = eval(document.getElementById('debugEvalArea2').value)\">Eval<\/button>";
		},
		documenter : function() {
			return "<button onclick=\"var documenter = new Packages.Library.Documenter();document.getElementById('debugDocumenter').innerHTML = documenter.CreateDocument();\">Process</button><div id='debugDocumenter'><\/div>";
		},
		pageInfo : function() {
			return "<button onclick=\"document.getElementById('debugPageInfo').innerHTML = document.getElementById('pageinfo').innerHTML\">Update</button><div id='debugPageInfo'><\/div>";
		},
		packageTests : function() {
			return "<button onclick=\"var tester = new Packages.Library.Test(); tester.Start();\">Start</button><hr>This will take a while to run and save all results";
		},
		debugWindow : function() {
			return "<button onclick=\"Packages.Library.$.DisplayLoggedInfo()\">Popup</button>";
		},
		packageTestAll : function() {
			return "<button onclick=\"Packages.Library.$.PackageTestAll();\">Start</button><hr>Tests every filetype packages test";
		},
		speedTest : function() {
			return "<button onclick=\"Packages.Library.$.DebugSpeedTest();\">Start</button><hr>Tests Packages.Library.$.ToHex 1 million times";
		}
	}
};
/***************************************************************
 * PackageTestAll - opens a new tab for each file type, and runs
 * the tests for it
 **************************************************************/
Packages.Library.$.PackageTestAll = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.PackageTestAll",
		options: options,
		doNotTest: 1,
		specification: {}
	})) return;
	
	if(Packages.Library.$v.testing == 1) return; // Because this would be a terrible idea
	
	var filetypesFolder = Packages.Library.$.GetSubFolder({container: pFolders, offset: "/System/Software/JS/FileType"});
	for(var i = 0; i < filetypesFolder.length; i++) {
		var filetype = filetypesFolder[i].name;
		filetype = filetype.replace(/\.\$jscb.*/, ""); // Strip $jscb section
		window.open("/dummy." + filetype + "?req-createorget=1&runAction=PackageTest&req-mimeoff=1&req-enhanced=1");
	}
};

/***************************************************************
 * DebugSpeedTest - tests ToHex a million times
 **************************************************************/
Packages.Library.$.DebugSpeedTest = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.DebugSpeedTest",
		options: options,
		doNotTest: 1,
		specification: {}
	})) return;
	
	var data;

	for(var n = 0; n < 1000000; n++) {
		data = Packages.Library.$.ToHex({num: n})
	}
	
	return data;
};/***************************************************************
 * Constants
 **************************************************************/
Package("Library").$c.Documenter = {
	FN_HASH: 0,
	FN_CLASS: 1,
	FN_API: 2
};
/***************************************************************
 * Documenter - creates documentation for the Javascript source code, by
 * dynamically analysing the code
 **************************************************************/
Package("Library").Documenter = function() {
	this.textVar = GetTextRef(this);
	/***************************************************************
	 * CreateDocument - creates the documentation and returns the HTML
	 **************************************************************/
	this.CreateDocument = function() {
		// Get all of the JS source code for this page
		this.jsSrcCode = "";
		var scriptElems = document.getElementsByTagName("script");
		for(var i = 0; i < scriptElems.length; i++) {
			this.jsSrcCode += scriptElems[i].innerText;
		}
		var html = "";
		html += this.DocumentPackage(Packages, "Packages");
		html += this.AnalyseSubscribers();
		return html;
	};
	/***************************************************************
	 * DocumentPackage - creates the documentation about this
	 * package and returns the html - recursive
	 * 
	 * param - packs : the Package object
	 * param - packsname : the name of the package being examined
	 *
	 * returns the html for the documentation
	 **************************************************************/
	this.DocumentPackage = function(packs, packsname) {
		var html = "<h4 style='display:inline'>" + packsname + "<\/h4>";
		html += "<input type='checkbox' checked='checked'>";
		html += "<ul class='checkboxcollapsed'>";
		for(var packname in packs) {
			if(packname == '$i') continue;
			var fullpackname = packsname + (packname.match(/^[0-9]/) ? "[" + packname + "]" : "." + packname);
			var pack = eval(fullpackname);
			html += "<li>";
			switch (typeof(pack)) {
				case 'object': {
					if(packname == '$') {
						// The library public 'CLASS' .$. methods
						html += this.Document$Functions(pack, fullpackname);
					} else {
						// The class itself
						if(packname == 'view') {
							html += "Skipping: " + packname;
						} else {
							html += this.DocumentPackage(pack, fullpackname);
						}
					}
					break;
				}
				case 'function': {
					try{
						var obj = new pack();
						html += this.DocumentClass(obj, pack, packname);
					}catch(e) {html += "Error instantiating: " + packname}
					break;
				}
				default: {
					html += "Variable: " + packname + " = " + pack;
				}
			}
			html += "<\/li>";
		}
		html += "<\/ul>";
		return html;
	};
	/***************************************************************
	 * Document$Functions - creates the documentation about this
	 * packages .$. functions and returns the html
	 *
	 * param - packs : the hash containing the API functions
	 * param - classname : the name of this class
	 *
	 * returns the html markup for this documentation
	 **************************************************************/
	this.Document$Functions = function(packs, classname) {
		var html = "<h4 style='display:inline'>API Functions: " + classname + "<\/h4>";
		html += "<input type='checkbox' checked='checked'>";
		html += "<ul class='checkboxcollapsed'>";
		for(var packname in packs) {
			var fullpackname = "packs[\"" + packname + "\"]";
			var pack = eval(fullpackname);
			html += "<li>";
			html += this.ProcessItem(pack, packname, this.jsSrcCode, Package("Library").$c.Documenter.FN_API);
			html += "<\/li>";
		}
		html += "<\/ul>";
		return html;
	};
	/***************************************************************
	 * DocumentClass - creates the documentation about this class
	 *
	 * param - object : blank object
	 * param - packs : class reference
	 * param - classname : the class name
	 **************************************************************/
	this.DocumentClass = function(object, packs, classname) {
		var html = "<h4 style='display:inline'>Class: " + classname + "<\/h4>";
		html += "<input type='checkbox' checked='checked'>";
		html += "<ul class='checkboxcollapsed'>";
						//alert(this.Display.toString());
						//alert(Packages.FileType.mhtm.view.toString());
		var classJSsrc = packs.toString();
		for(var packname in object) {
			if(packname == '$i') continue;
			var fullpackname = "object[\"" + packname + "\"]";
			var pack = eval(fullpackname);
			html += "<li>";
			html += this.ProcessItem(pack, packname, classJSsrc, Package("Library").$c.Documenter.FN_CLASS);
			html += "<\/li>";
		}
		html += "<\/ul>";
		return html;
	};
	/***************************************************************
	 * DocumentHash - creates the documentation about this hash
	 *
	 * param - packs : the hash object
	 * param - hashname : the name of the hash
	 **************************************************************/
	this.DocumentHash = function(packs, hashname) {
		var html = "<h4 style='display:inline'>Hash: " + hashname + "<\/h4>";
		html += "<input type='checkbox' checked='checked'>";
		html += "<ul class='checkboxcollapsed'>";
		for(var packname in packs) {
			var fullpackname = "packs[\"" + packname + "\"]";
			var pack = eval(fullpackname);
			html += "<li>";
			html += this.ProcessItem(pack, packname, "", Package("Library").$c.Documenter.FN_HASH);
			html += "<\/li>";
		}
		html += "<\/ul>";
		return html;
	};
	/***************************************************************
	 * DocumentFunction - creates the documentation about a function
	 *
	 * param - func : the actual function
	 * param - functionname : the name of the function
	 * param - srcCode : the source code containing this method
	 * param - mode : see Package("Library").$c.Documenter.FN_
	 *
	 * returns the html for this function documentation
	 **************************************************************/
	this.DocumentFunction = function(func, functionname, srcCode, mode) {
		var html = "<h4 style='display:inline'>Function: " + functionname + "<\/h4>";
		if(srcCode == "" || mode == null) return html; // No comment available
		// Try and get help text (about method)
		var safefunctionname = functionname.replace(/\$/, "\\$");
		var re = new RegExp("\\/\\*+?\\n\\s*?\\* " + safefunctionname + " - ((.|\\n)*?)[\\s\\*]*?(param - |\\**?\\/)", "m");
		if(srcCode.match(re)) {
			html += Packages.Library.$.MakeHelp({help: RegExp.$1});
		} else {
			html += "<span style='color:#FF0000;font-weight:bold'>ERROR: No comment for method</span>";
		}
		// Try and get params
		html += "<input type='checkbox' checked='checked'>";
		html += "<ul class='checkboxcollapsed'>";
		var re;
		if(mode == Package("Library").$c.Documenter.FN_CLASS) {
			re = new RegExp("this\\." + safefunctionname + " = function\\((.*?)\\)", "m");
		}
		if(mode == Package("Library").$c.Documenter.FN_API) {
			re = new RegExp("Package.*?\\." + safefunctionname + " = function\\((.*?)\\) {", "m");
		}
		if(re != null) {
			html += "<li>";
			html += "Paramaters:";
			html += "<ul>";
			if(srcCode.match(re)) {
				var paramnames = RegExp.$1;
				if(paramnames.length > 0) {
					var params = paramnames.split(", ");
					for(var p = 0; p < params.length; p++) {
						// try and get the param comment
						var re = new RegExp("\\* " + safefunctionname + " - (.|\\n)*?param - " + params[p] + " : (.*)", "m");
						var description = "<span style='color:#FF0000;font-weight:bold'>ERROR: No Description for variable</span>";
						if(srcCode.match(re)) description = RegExp.$2;
						html += "<li>" + params[p] + ": " + description + "<\/li>";
					}
				}
			}
			html += "<\/ul>";
			html += "<\/li>";
		}
		html += "<li>";
		html += "Return value: ";
		if(functionname == "GetDetails") {
			try{
				var res = func();
				html += this.ProcessItem(res, "", this.jsSrcCode, Package("Library").$c.Documenter.FN_HASH);
			} catch (e) {
				html += Packages.Library.$.MakeHelp({help: "Failed to get return value with error '" + e.message + "'"});
			}
		}
		html += "<\/li>";
		html += "<\/ul>";
		return html;
	};
	/***************************************************************
	 * ProcessItem - processes the found item in a class or hash
	 *
	 * param - pack : the actual item object
	 * param - packname : the name of the item
	 * param - srcCode : the source code containing this method
	 * param - mode : see Package("Library").$c.Documenter.FN_
	 *
	 * returns the html returns by the documenter for this type
	 **************************************************************/
	this.ProcessItem = function(pack, packname, srcCode, mode) {
		var html = "";
		switch (typeof(pack)) {
			case 'function': {
				html += this.DocumentFunction(pack, packname, srcCode, mode);
				break;
			}
			case 'object': {
				html += this.DocumentHash(pack, packname);
				break;
			}
			default: {
				html += "Variable: " + packname + " = " + pack;
			}
		}
		return html;
	};
	/***************************************************************
	 * AnalyseSubscribers - processes all subscribers and the places
	 * that fire them
	 *
	 * returns the html to describe this subscriber
	 **************************************************************/
	this.AnalyseSubscribers = function() {
		var html = "<h3>Subscribe Events<\/h3>";
		var matches = this.jsSrcCode.match(/(.*?) = function(.|\n)+?Packages\.Library\.\$\.EventFire\("(.*?)"/g);
		if(matches == null) return "";
		// Empty hash for event names
		var matchkeys = {};
		for(var i = 0; i < matches.length; i++) {
			// Get the event name
			matches[i].match(/.*? = function(.|\n)+?Packages\.Library\.\$\.EventFire\("(.*?)"/g);
			var match = RegExp.$2;
			if(matchkeys[match] == null) matchkeys[match] = {fire: [], subscriber: []};
			// Get the last function name
			var functionmatches = matches[i].match(/(.*?) = function\(/g);
			if(functionmatches == null) continue;
			var funcname = functionmatches[functionmatches.length - 1];
			if(funcname.match(/\s(.*?) = function\(/)) {
				funcname = RegExp.$1;
			}
			matchkeys[match].fire.push(funcname);
		}
		matches = this.jsSrcCode.match(/(.*?) = function(.|\n)+?Packages\.Library\.\$\.EventSubscribe\("(.*?)", (.*?)\.bind\(/g);
		if(matches != null) {
			for(var i = 0; i < matches.length; i++) {
				// Get the event name
				matches[i].match(/.*? = function(.|\n)+?Packages\.Library\.\$\.EventSubscribe\("(.*?)", (.*?)\.bind\(/g);
				var match = RegExp.$2;
				var funcname = RegExp.$3;
				if(matchkeys[match] == null) matchkeys[match] = {fire: [], subscriber: []};
				matchkeys[match].subscriber.push(funcname);
			}
		}
		for(var item in matchkeys) {
			// Output details for this event
			var match = matchkeys[item];
			html += "<h4 style='display:inline'>Subscribe Event: " + item + "<\/h4>";
			html += "<input type='checkbox' checked='checked'>";
			html += "<ul class='checkboxcollapsed'>";
			// Try and get help about the event
			var re = new RegExp("\\* " + item + " - EVENT - ((.|\\n)*?)\\*+\\/", "");
			if(this.jsSrcCode.match(re)) {
				html += "<li><h4>About<\/h4>";
				var comment = RegExp.$1;
				html += comment.replace(/\n/g, "<br>");
				html += "<\/li>";
			}
			html += "<li><h4>Fires: [" + match.fire.length + "]<\/h4>";
			// List found fires
			html += "<ul>";
			for(var i = 0; i < match.fire.length; i++) {
				html += "<li>" + match.fire[i] + "<\/li>";
			}
			html += "<\/ul><\/li>";
			html += "<li><h4>Subscribers [" + match.subscriber.length + "]:<\/h4>";
			// List found subscriber
			html += "<ul>";
			for(var i = 0; i < match.subscriber.length; i++) {
				html += "<li>" + match.subscriber[i] + "<\/li>";
			}
			html += "<\/ul><\/li>";
			html += "<\/ul><br>";
		}
		return html;
	};
};/*
 Dynamic Load - the ability to request resources on the server in a hidden iframe, and then once loaded put its contents into the main page.
 
 This is also heavily used to allow JavaScript the 'special' ability to exceed the bounds of the client side. This is essential since
 in this case, JavaScript contains the specific actions for doing a specific task. The server itself only has generic commands to serve
 a number of different tasks.
 
 Before anything gets loaded, there is first a check to see if it has already been loaded. This can be overridden to force another load.
 
 Although this is an object, each object should be used only once.
 
 The system is used in the following ways
 LOAD TYPE
    LT_SCRIPT   : Used to load a JS file as a standard library file
    LT_CSS      : Used to load a CSS file as an ordinary style sheet (no callback supported)
    LT_TEXT     : Loads the content into a textarea (useful for getting plain text or HTML from the server)
    
 Optional properties
    ScriptPackage:(LT_SCRIPT only) checks this package exists before firing callback
    ForceReload : Skip the checking of existance, and load anyway
    UseTerminator : (optional) if 1 asks the server to print a terminator line at the end so we knows the output has finished
    queryParams : (optional) hash of query params to send with the request
    className : (optional) classname to place on loaded element tag (LT_SCRIPT only)
 
 CALLBACKS
    The callback subroutine is fired when all of the request files have been retrieved. This only applies to
    files that support callbacks (eg CSS does not).
    LT_SCRIPT is only partially supported, and requires a 'ScriptPackage' option to be defined to check the
    specified package exists
    
    Callbacks are a JS function, which is executed.
    If the callback returns a string, this will be loaded into the target element. If nothing is returned this does not apply.
    
 Use:
    Create an instance of this class with the following properties
        targetID : (optional) the element ID of the target to load response into
        callback : function to execute upon completion
        useContent : 1 put the loaded content into the TargetElement, 0 (default) do not
        displayLoadingIcon : 1 (default) display loading icon, 0 not to
        divParams : (optional) if specified includes a list of params to insert in the empty Div
    
    Call 'Request' with the following properties
        Files : an array of files entries, each of the type
            filepath : the complete filepath for this file
            mode : one of the LT_ LOAD TYPES
            (Optional properties) ScriptPackage, queryParams
    
    Wait, the callback will be executed once loaded (or never if something goes wrong)
*/


/*********************************************************************
 * Constructor - Create an instance of this class with the following properties
 * 
 * param - options : hash of options, may contain:
 * 			targetID : (optional) the element ID of the target to load response into
 * 			callback : function to execute upon completion
 * 			useContent : 1 put the loaded content into the TargetElement, 0 (default) do not
 * 			displayLoadingIcon : 1 (default) display loading icon, 0 not to
 * 			divParams : (optional) if specified includes a string of params to insert in the empty Div
 ********************************************************************/
Package("Library").DynamicLoad = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.DynamicLoad",
		options: options,
		specification: {
			targetID: {type: "string"},
			callback: {type: "function"},
			useContent: {type: "boolean"},
			displayLoadingIcon: {type: "boolean"},
			divParams: {type: "string"}
		}
	})) return;
	
	this.TargetID = options.targetID;
    this.Callback = options.callback;
    this.UseContent = options.useContent;
    this.DisplayLoadingIcon = options.displayLoadingIcon;
    this.DivParams = options.divParams;
    this.textVar = GetTextRef(this);
    if(this.TargetID == "") this.TargetID = null;
    /*********************************************************************
     * Request - Request a list of files
     * 
     * param - Files : an array of files entries, each of the type
     *       filepath : the complete filepath for this file
     *       mode : one of the LT_ LOAD TYPES
     *       (Optional properties) ScriptPackage, queryParams
     *       ForceReload
     *
     * returns an empty div HTML markup
     ********************************************************************/
    this.Request = function(Files) {
        this.Files = Files;
        // Get variables
        this.reqterminatorcode = "XXXX----TERMINATOR----XXXX---" + "TERMINATOR" + "---XXXX"; // Divided so that loading itself doesn't fail!
		
		if(Packages.Library.$v.testing == 1) return null; // Do nothing in test mode
        
        // Initialise our array of files we have loaded
        if(Packages.Library.DynamicLoad.$i == null) Packages.Library.DynamicLoad.$i = {};
        if(Packages.Library.DynamicLoad.$i.LoadedFiles == null) Packages.Library.DynamicLoad.$i.LoadedFiles = {};
        
        // Check our list and remove any entries we have already loaded
        for(var f = 0; f < Files.length; f++) {
            if(Files[f].ForceReload == 1) continue;
            // Is file loaded?
            if(Packages.Library.DynamicLoad.$i.LoadedFiles[Files[f].filepath + "_" + Files[f].mode]) {
                // File already loaded, skip
                Files[f] = Packages.Library.DynamicLoad.$i.LoadedFiles[Files[f].filepath + "_" + Files[f].mode];
            } else {
                // Log this file as loaded (as its about to be)
                Packages.Library.DynamicLoad.$i.LoadedFiles[Files[f].filepath + "_" + Files[f].mode] = Files[f];
            }
        }
        
        // Load the files
        for(var f = 0; f < Files.length; f++) {
            var filepath = Files[f].filepath;
            var mode = Files[f].mode;
			var getid = "getFile_" + mode + "_" + filepath.replace(/[\/\.\?&]/g, "_");
            if(Files[f].getid != null) continue; // Already loading
            Files[f].getid = getid;
            
            // Is this particular file already loaded?
            if(this.IsFileLoaded(Files[f])) continue;
            
            // Assemble additional query params
            var query = "";
            for(var parm in Files[f].queryParams) {
                query += parm + "=" + Files[f].queryParams[parm] + "&";
            }
            Files[f].querystring = query;
            
            // Load this file
            if(this.Methods[mode].Load != null) {
                this.Methods[mode].Load(Files[f], this);
            }
        }
        
        // Have we finished yet?
        this.ContinuousCheckIsLoaded();
		
		// Are we suppose to return empty DIV?
		if(this.TargetID == null) {
			// No, return nothing
			return null;
		} else {
			// Yes, return empty div
			return "<div id='" + this.TargetID + "' " + (this.DivParams != null ? this.DivParams : "") + ">" + (this.DisplayLoadingIcon == 1 ? Packages.Library.$.GetLoaderImg() : "") + "<\/div>";
		}
    };
    /*********************************************************************
     * GetFiles - Gets the list of files this object is requesting
     *
     * returns the list of files
     ********************************************************************/
    this.GetFiles = function() {
        return this.Files;
    };
    /*********************************************************************
     * IsLoaded - Checks if the files are loaded
     *
     * return 1 if loaded, 0 if not
     ********************************************************************/
    this.IsLoaded = function() {
        var loaded = 1; // so prove me wrong
        for(var f = 0; f < this.Files.length; f++) {
            var file = this.Files[f];
            if(!this.IsFileLoaded(file)) loaded = 0;
        }
        return loaded;
    };
    /*********************************************************************
     * ContinuousCheckIsLoaded - Checks if the files are loaded
     *
     * If everything has loaded, fires the callback, otherwise schedules another check
     *
     * return 1 if loaded, 0 if not
     ********************************************************************/
    this.ContinuousCheckIsLoaded = function() {
        var loaded = this.IsLoaded();
        
        var elem;
		if(Packages.Library.$c.IsNode != 1) elem = document.getElementById(this.TargetID);        
        
        // UseContent first, incase needed by callback
        if(loaded == 1 && this.UseContent == 1) {
            if(elem == null) {
                loaded = 0;
            } else {
                elem.innerHTML = this.GetFileContent(this.Files[0]);
            }
        }
        
        if(loaded == 1 && this.Callback != null) {
            if(elem == null && this.TargetID != null) {
                loaded = 0; // No element, fail and try again
            } else {
                // Load was successful, fire callback (if we have one)
                var res = this.Callback();
                if(res != null && elem != null) {
                    elem.innerHTML = res;
                }
            }
        }
        
        if(loaded == 0) {
			// No success yet, try again soon
            setTimeout(this.ContinuousCheckIsLoaded.bind(this), 50);
        }
        return loaded;
    };
    /*********************************************************************
     * IsFileLoaded - Checks if the specified file is loaded
     *
     * param - file : item from Files array
     *
     * return 1 if loaded, 0 if not
     ********************************************************************/
    this.IsFileLoaded = function(file) {
        if(this.Methods[file.mode].Check != null) {
            return this.Methods[file.mode].Check(file, this);
        }
        return 1; // Assume OK
    };
    /*********************************************************************
     * GetFileContent - Gets the content of the file
     *
     * param - file : (optional) entry from Files, if not specified returns the first file
     *
     * returns the content or null if not found / no Get
     ********************************************************************/
    this.GetFileContent = function(file) {
        if(file == null) file = this.Files[0];
    	if(this.Methods[file.mode].Get != null) {
            return this.Methods[file.mode].Get(file, this);
        }
        return null;
    };
    /*********************************************************************
     * GetFileStatus - Gets the HTTP status of the file
     *
     * param - file : (optional) entry from Files, if not specified returns the first file
     *
     * returns the content or null if not found / no Get
     ********************************************************************/
    this.GetFileStatus = function(file) {
        if(file == null) file = this.Files[0];
    	return file.status;
    };
    
    /******************************* MODE SPECIFIC OPTIONS *******************************************************/
    
    this.Methods = {};
        /*****************************************************
         * Load - does the work to load this type of data
         *
         * param - file : url of file to load
         * param - _this : reference to 'this' for the main object
         ****************************************************/
        /*****************************************************
         * Check - checks if the file has finished loading or not
         *
         * param - file : url of file to load
         * param - _this : reference to 'this' for the main object
         *
         * returns 1 if loaded, or 0 if not
         ****************************************************/
        /*****************************************************
         * Get - gets the data from the loaded file (some method only)
         *
         * param - file : url of file to load
         * param - _this : reference to 'this' for the main object
         *
         * returns the content
         ****************************************************/
        this.Methods.LT_SCRIPT = {};
            this.Methods.LT_SCRIPT.Load = function(file, _this) {
                var head = document.getElementsByTagName('head')[0];
    			var script = document.createElement('script');
    			script.type = 'text/javascript';
                var query = file.querystring;
                if(query.length > 0) query = "&" + query;
    			script.src = file.filepath + "?req-plain=1" + query;
                script.id = file.getid;
				script.className = file.className;
                script.onload = function() {
					file.ready = 1;
				}
    			head.appendChild(script);
            };
            this.Methods.LT_SCRIPT.Check = function(file, _this) {
                // Check onload has fired
                if(file.skip == 1) return 1;
                if(file.ready != 1) return 0;
                
                if(file.ScriptPackage != null) {                    
                    // Check if the package is loaded
                    try{
                        var elem = document.getElementById(file.getid);
                        if(elem != null) {
                            try{
                                eval(elem.text);
                            } catch(e){}
                        }
                        if(eval("Packages." + file.ScriptPackage) != null) return 1;
                    }catch(e){};
                } else {
                    // Check if script exists in src
					try {
						var scripts = document.getElementsByTagName('script');      
						for(var s = 0; s < scripts.length; s++) {
							if(scripts[s].src.match(file.filepath)) return 1;
						}
					} catch(e) {
						return 1; // DOM not formed yet
					}
                }
                
                return 0;
            };
    this.Methods.LT_CSS = {};
        this.Methods.LT_CSS.Load = function(file, _this) {
                var head = document.getElementsByTagName('head')[0];
    			var style = document.createElement('link');
    			style.rel = 'stylesheet'
    			style.type = 'text/css';
                var query = file.querystring;
                if(query.length > 0) query = "&" + query;
    			style.href = file.filepath + "?req-plain=1" + query;
    			head.appendChild(style);
            };
        this.Methods.LT_CSS.Check = function(file, _this) {
				try {
					var styles = document.getElementsByTagName('link');        
					for(var s = 0; s < styles.length; s++) {
						if(styles[s].href.match(file.filepath)) return 1;
					}
					return 0;
				} catch(e) {
					return 1; // DOM not formed yet
				}
            };
	this.Methods.LT_TEXT = {};
        this.Methods.LT_TEXT.Load = function(file, _this) {
				if(Packages.Library.$c.IsNode) {
					var path = pDocRootOffset;
					if(!path.match(/\/$/)) path += "/";
					//if(file.system) path = "/web"; // System file
					//if(file.filepath.match(/^\//)) path = pDocRoot; // absolute to doc root
					var execSync = require('exec-sync');
					file.filepath = file.filepath.replace(/^\//, ""); // Remove leading /
					
					var reqFilePath = path + file.filepath;
					reqFilePath = reqFilePath.replace(/\$/, "\\$"); // Escape $ for bash
					// Ensure reqFilePath starts with a leading '/'
					if(!reqFilePath.match(/^\//)) reqFilePath = "/" + reqFilePath;
					console.log(reqFilePath);
					var res = execSync('/web/System/Software/cmdline_integration.exe "' + pMasterPathAbs + '" FILE ' + reqFilePath);
					console.log(res);
					file.status = 200;
					file.ready = 1;
					file.content = res;
				} else if(Packages.Library.$c.HasDOM) {
					// Get an xmlhttp handle for this file
					if (window.XMLHttpRequest) { // code for IE7+, Firefox, Chrome, Opera, Safari
						file.xmlhttp = new XMLHttpRequest();
					} else { // code for IE6, IE5
						file.xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
					}
					var query = file.querystring;
					if(query.length > 0) query = "&" + query;
					if(file.plain != 0) query = "req-plain=1&req-mimeoff=1" + query;
					file.ready = 0;
					file.xmlhttp.open("GET", file.filepath + "?" + query, true);
					file.xmlhttp.onreadystatechange = function() {
						if (file.xmlhttp.readyState==4) {
							file.status = file.xmlhttp.status;
							file.ready = 1;
							file.content = file.xmlhttp.responseText;
						}
					}
					file.xmlhttp.send();
				} else {
					Packages.Library.$.LogInfo({
						mesg: "No method provided for LT_TEXT.Load",
						location: "DynamicLoad",
						level: 1
					});
				}
            };
        this.Methods.LT_TEXT.Check = function(file, _this) {
                // Check onload has fired
                if(file.skip == 1) return 1;
                if(file.ready == 1) return 1;
				return 0;
            };
        this.Methods.LT_TEXT.Get = function(file, _this) {
				// Get the response
				var response = file.content;
				return response;
    		};
};Package("Library").Extensions = function() {};

/*******************************************************************************
 * foreach - iterates through the items in the array, calling the callback
 * function for each one
 *
 * param - array : the array
 * param - callback : the callback to fire for each one
 ******************************************************************************/
var foreach = function(array, callback) {
	for(var i = 0; i < array.length; i++) {
		callback(array[i]);
	}
}

/*******************************************************************************
 * countLines - counts the lines in the specified text
 *
 * Essentially splits on the \n and counts them, but if the area is blank, will return 0
 *
 * param - text : text to count lines in
 *
 * return - lines : number of lines, or 0 if blank
 ******************************************************************************/
var countLines = function(lines) {
	if(lines.length == 0) return 0;
	return lines.split(/\n/).length;
}

Package("Library").File = function() {
};
/*********************************************************************
* Dump - Converts the specified object into text
*
* Skips keys $noDump
*
* param - options : hash of options, must contain:
* 				obj : the array/object to be saved
* 			may contain:
*				skiplist : array of 'keys' to skip in objects
*				prettyPrint : null (do not use), 1 use
*			internally
*				indent : internally used to count indents
*
* returns the JS code to recreate this object
********************************************************************/
Packages.Library.$.Dump = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Dump",
		options: options,
		specification: {
			obj: {type: "object,array,string,number,boolean,function,DOMobject,null"}, // Null allowed
			skiplist: {type: "array"},
			prettyPrint: {type: "boolean"},
			indent: {type: "number"}
		}
	})) return null;
	
	var arr = options.obj;
	var type = Packages.Library.$.GetType({item: arr});
	var skiplist = options.skiplist;
	var indents = options.indent;
	if(indents == null) indents = 0;
	indents++;
	var indent = "";
	if(options.prettyPrint == 1) {
		for(var i = 0; i < indents; i++) {
			indent += "    ";
		}
	}
	var indentless1 = indent.replace(/    $/, ""); // 1 tab less indent for closing braces / brackets
	if(skiplist == null) skiplist = [];
	if(type == 'function') return "null"; // Can't dump a function!
	if(type == 'DOMobject') return "null"; // Can't dump a DOMobject!
	if(type == 'null') return "null"; // Can't dump a DOMobject!
	if(arr == null) return "null";
	
	if(typeof(arr) == 'object') { //Array/Hashes/Objects
		if(arr.$recursing != null) {
			alert("Detected recursion from: " + arr.$recursion.from);
			return "null"; // Can not recurse into self
		}
		var type = Packages.Library.$.GetType({item: arr});
		if(type == "object") {
			// Prevent objects from recursing
			arr.$recursing = {from: "Packages.Library.$.Dump"};
		}
		var values = "";
		for(var item in arr) {
			if(item == "$noDump") continue; // Skip $noDump key
			if(item == "$id") continue; // Skip $id key
			if(item == "$recursing") continue; // Skip $recursing key
			if(Packages.Library.$.Contains({array: skiplist, item: item})) continue;
			var value = arr[item];
			values += indent;
			if(type == "array") { // array
				values += "";
			} else {				 // hash
				values += item + ":";
			}
			try {
				values += Packages.Library.$.Dump({obj: value, skiplist: skiplist, prettyPrint: options.prettyPrint, indent: indents});
			} catch(e) {}
			values += ",";
			if(indents != null) values += "\n";
		}
		if(arr.$recursing != null) delete arr.$recursing;
		if(values.length > 0 ) values = values.replace(/,\n?$/, ""); // Remove trailing comma and optionally line break
		if(indents != null) values = "\n" + values + "\n" + indentless1;
		if(type == "array") { // array
			return "[" + values + "]";
		} else {				 // hash
			return "{" + values + "}";
		}
	} else { //Stings/Chars/Numbers etc.
		if(typeof(arr) == "number") {
			// number
		} else if(typeof(arr) == "boolean") {
			arr = arr ? "true" : "false";
		} else if(typeof(arr) == null) {
			arr = "null";
		} else {
			// string
			arr = "\"" + Packages.Library.$.ConvertCRToNat({str: arr}) + "\"";
		}
		return arr;
	}
	return "null";
};
/*********************************************************************
* ConvertCRToNat - Converts the carriage return version of text into Nat standard (\escaped)
*
* [escapedbackslash] used as a unique value. Replaces the '\\' first, so that subsequent
* \\s are not confused as a \'. Finally the [escapedbackslash] is replaced with a '\\'
*
* param - options : hash of options, must contain:
* 			str : source string
*
* returns the Nat version of string
********************************************************************/
Packages.Library.$.ConvertCRToNat = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertCRToNat",
		options: options,
		specification: {
			str: {type: "string", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	if(str == null) str = "null";
	str = str.replace(/\\/g, "\\\\"); // Escape backslashes
	str = str.replace(/\n/g, "\\n");
	str = str.replace(/\r/g, "");
	str = str.replace(/\f/g, "");
	str = str.replace(/\"/g, "\\\"");
	return str;
};

/*********************************************************************
* ConvertCRToXML - Converts the text into the escaped and XML safe
* standard
*
* param - options : hash of options, must contain:
* 				str : source string
*
* returns the xml version of string
********************************************************************/
Packages.Library.$.ConvertCRToXML = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertCRToXML",
		options: options,
		specification: {
			str: {type: "string", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	str = str.replace(/\\n/g, "\\\\n");
	str = str.replace(/\n/g, "\\n");
	str = Packages.Library.$.ConvertCRToXMLContent({str: str});
	
	return str;
};

/*********************************************************************
* ConvertCRToXMLContent - Converts the text into the escaped and XML safe
* standard for the content
*
* param - options : hash of options, must contain:
* 			str : source string
*
* returns the xml version of string
********************************************************************/
Packages.Library.$.ConvertCRToXMLContent = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertCRToXMLContent",
		options: options,
		specification: {
			str: {type: "string", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	str = str.replace(/\r/g, "");
	str = str.replace(/\f/g, "");
	
	str = str.replace(/&/gi, "&amp;");
	str = str.replace(/\"/gi,"&#34;");
	str = str.replace(/</gi, "&lt;");
	str = str.replace(/>/gi, "&gt;");
	
	return str;
};

/*********************************************************************
* ConvertCRToPT - Converts the CR to P tags
*
* param - options : hash of options, must contain:
* 			str : source string
*
* returns the <p><\/p> version of string
********************************************************************/
Packages.Library.$.ConvertCRToPT = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertCRToPT",
		options: options,
		specification: {
			str: {type: "string", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	return "<p>" + str.replace(/\n/gi, "</p><p>") + "</p>";
};

/*********************************************************************
* ConvertCRToBR - Converts the Nat standard (\escaped) version of text into HTML safe <br>
*
* param - options : hash of options, must contain:
* 			str : source string (may be null, in which case returns "")
*
* returns the <br> version of string
********************************************************************/
Packages.Library.$.ConvertCRToBR = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertCRToBR",
		options: options,
		specification: {
			str: {type: "string"}
		}
	})) return null;
	if(options.str == null) return "";
	
	return options.str.replace(/\n/gi, "<br>");
};

/*********************************************************************
* ConvertLegacy - Converts the Legacy Nat standard (\escaped) version
* of text into CR version
*
* param - options : hash of options, must contain:
* 			str : source string (can be null)
*
* returns the CR version of string
********************************************************************/
Packages.Library.$.ConvertLegacy = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertLegacy",
		options: options,
		specification: {
			str: {type: "string"}
		}
	})) return null;
	
	var str = options.str;
	
	if(str == null) return "";
	if(typeof(str) == "number") str += "";
	// Legacy update
	str = str.replace(/&mlt;/g, "<");
	str = str.replace(/&mgt;/g, ">");
	str = str.replace(/&mbn;/g, "\n");
	str = str.replace(/\\\\/g, "[escapedbackslash]");
	str = str.replace(/\\n/g, "\n");
	str = str.replace(/\\q/gi, "\"").replace(/\\s/gi, "'").replace(/\\a/gi, "&").replace(/\\p/gi, "%").replace(/\\l/gi, "\/");
	str = str.replace(/\[escapedbackslash\]/g, "\\");
	return str;
};

/*********************************************************************
* ConvertXMLToCR - Converts the XML escaped standard version of text into CR
* version, this includes the < > escapes
*
* param - options : hash of options, must contain:
* 			str : source string
*
* returns the CR version of string
********************************************************************/
Packages.Library.$.ConvertXMLToCR = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertXMLToCR",
		options: options,
		specification: {
			str: {type: "string", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	// Do standard legacy update
	str = Packages.Library.$.ConvertLegacy({str: str});
	if(str == null) return null;
	
	// Decode <>&
	str = str.replace(/&lt;/g, "<");
	str = str.replace(/&gt;/g, ">");
	str = str.replace(/&#34;/g, "\"");
	str = str.replace(/&amp;/g, "&");
	return str;
};

/*********************************************************************
* EscapeString - escapes a string ready for text format
*
* param - options : hash of options, must contain:
* 			str : source string
*
* returns the escaped version of string
********************************************************************/
Packages.Library.$.EscapeString = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EscapeString",
		options: options,
		specification: {
			str: {type: "string,number", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	str = Packages.Library.$.ForceString({xValue: str});
	str = str.replace(/\\/g, "\\\\");
	str = str.replace(/\n/g, "\\n");
	return str;
};

/*********************************************************************
* UnEscapeString - unescapes a string ready for use
*
* param - options : hash of options, must contain:
* 			str : source string
*
* returns the unescaped version of string
********************************************************************/
Packages.Library.$.UnEscapeString = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.UnEscapeString",
		options: options,
		specification: {
			str: {type: "string", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	str = Packages.Library.$.ForceString({xValue: str});
	str = str.replace(/\\n/g, "\n");
	str = str.replace(/\\\\/g, "\\");
	return str;
};

/*********************************************************************
 * ConvertToHTML - escapes special HTML chars with HTML entities
 *
 * param - options : hash of options, must contain:
 * 			str : source string
 *
 * returns the escaped version of string
 ********************************************************************/
Packages.Library.$.ConvertToHTML = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertToHTML",
		options: options,
		specification: {
			str: {type: "string,number", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	str = Packages.Library.$.ForceString({xValue: str});
	str = str.replace(/£/g, "&pound;");
	return str;
};

/*********************************************************************
 * ConvertFromHTML - deescapes special HTML chars with HTML entities
 *
 * param - options : hash of options, must contain:
 * 			str : source string
 *
 * returns the deescaped version of string
 ********************************************************************/
Packages.Library.$.ConvertFromHTML = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertFromHTML",
		options: options,
		specification: {
			str: {type: "string,number", required: 1}
		}
	})) return null;
	
	var str = options.str;
	
	str = Packages.Library.$.ForceString({xValue: str});
	str = str.replace(/&pound;/g, "£");
	return str;
};

/*********************************************************************
* SetFile - Sets the contents of a file on the server
*
* param - options : hash of options, must contain:
* 			filepath : path + filename + extension
* 			content : content, may not be an empty string
* 		may contain:
* 			isBase64 : 1 if content is already in base64, 0 (default) if plain
* 			callback : callback to fire when file submitted
* 			overwrite : 1 (default) force overwrite, 0 do not overwrite
* 			reqFiles : 1 (default) request files, 0 do not
* 			page : the page to request if not masterpath/.admin
* 			async : (see ServerRequest)
*
* returns 1 if OK, 0 if not
********************************************************************/
Packages.Library.$.SetFile = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SetFile",
		options: options,
		specification: {
			filepath: {type: "string", required: 1},
			content: {type: "string,number,boolean", required: 1},
			isBase64: {type: "boolean"},
			callback: {type: "function"},
			overwrite: {type: "boolean"},
			reqFiles: {type: "boolean"},
			page: {type: "string"}
		}
	})) return 0;
	
	if(Packages.Library.$v.testing == 1) return 1; // Do nothing in test mode
	
	if(options.overwrite == null) options.overwrite = 1;
	if(options.reqFiles == null) options.reqFiles = 1;
	
	var query = {
		createFile64: options.filepath,
		"req-files": options.reqFiles,
		createFile64Overwrite: options.overwrite
	};
	var content = options.content;
	if(options.isBase64 != 1) content = btoa(content);
	var post = {
		contents64: content
	};
	if(options.page == null) options.page = Packages.Library.$.GetMasterpath({}) + ".admin";
	new Packages.Library.ServerRequest().ServerRequest({
		page: options.page,
		query: query,
		post: post,
		async: options.async,
		callback: options.callback,
		maskContent: "Saving file: " + options.filepath
	});
	
	return 1;
};

/*********************************************************************
 * GetFile - Gets the contents of a file on the server
 *
 * Syncronous, ie, this returns the content of the file
 *
 * param - options : hash of options, must contain:
 * 			filepath : path + filename + extension
 * 		may contain:
 * 			plain : 1 force plain response, 0 as it comes
 *
 * returns result : hash of result data, consisting of
 * 			status : status returned
 * 			content : content returned
 ********************************************************************/
Packages.Library.$.GetFile = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetFile",
		options: options,
		specification: {
			filepath: {type: "string", required: 1},
			plain: {type: "boolean"}
		}
	})) return {status: 0};
	
	var query = "";
	if(options.plain != 0) query = "req-plain=1&req-mimeoff=1" + query;
	
	// Get an xmlhttp handle for this file
	var xmlhttp;
	if (window.XMLHttpRequest) { // code for IE7+, Firefox, Chrome, Opera, Safari
		xmlhttp = new XMLHttpRequest();
	} else { // code for IE6, IE5
		xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
	}
	xmlhttp.open('GET', options.filepath + "?" + query, false);  // `false` makes the request synchronous
	xmlhttp.send(null);
	
	return {
		status: xmlhttp.status,
		content: xmlhttp.responseText
	};
};

/*********************************************************************
 * GetContentFromURL - Gets third party content from a URL via the server
 *
 * Avoids cross site scripting attack errors
 *
 * param - options : hash of options, must contain:
 * 			url : url to fetch from
 * 			callback : callback when loaded, passes in options containing
 * 				content : the content of the url
 * 				content64 : base64 version of content
 * 				callbackData : as callbackData
 * 			callbackData : data passed to callback
 * 			filepath : location to save the file from masterpath
 ********************************************************************/
Packages.Library.$.GetContentFromURL = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetContentFromURL",
		options: options,
		specification: {
			url: {type: "string", required: 1},
			callback: {type: "function"},
			callbackData: {type: "object"},
			filepath: {type: "string"}
		}
	})) return;
	
	var url = options.url;
	url = url.replace(/^http:\/\//, "");
	
	var getOptions = options;
	
	// Fetch
	new Packages.Library.ServerRequest().ServerRequest({
		page: Packages.Library.$.GetMasterpath({}) + ".admin",
		query: {
			getcontenturl: url,
			getcontenturlfilepath: options.filepath
		},
		callback: function(options) {
			var response = options.response;
			// getcontenturlResponse
			var openmatch = "<getcontenturlResponse>";
			var closematch = "</getcontenturlResponse>";
			response = response.substr(response.indexOf(openmatch) + openmatch.length, response.indexOf(closematch) - (response.indexOf(openmatch) + openmatch.length));
			
			if(getOptions.callback != null) getOptions.callback({
				content: atob(response),
				content64: response,
				callbackData: getOptions.callbackData
			});
		}
	});
};

/*********************************************************************
 * MakeFolder - Creates a folder, updates file mgr (if present) when done
 *
 * param - options : hash of options, must contain:
 * 			folderpath : the complete folder path from masterpath to create
 ********************************************************************/
Packages.Library.$.MakeFolder = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeFolder",
		options: options,
		specification: {
			folderpath: 	{type: "string",	required: 1}
		}
	})) return;
	
	var query = {
		"req-files": 1,
		createFolder: options.folderpath
	};
	new Packages.Library.ServerRequest().ServerRequest({
		page: "/.admin",
		query: query,
		callback: Packages.Library.$.ReloadFileMgr
	});
}

/*********************************************************************
* SetAttributes - creates a text file of attributes from the hash specified
*
* param - options, hash of options, must include:
* 				data : the hash of data, single tier
*
* returns the attributes as a text block
********************************************************************/
Packages.Library.$.SetAttributes = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SetAttributes",
		options: options,
		specification: {
			data: 	{type: "object",	required: 1}
		}
	})) return null;
	
	var lines = [];
	for(var key in options.data) {
		if(key.match(/^\$noDump$/)) continue; // Skip
		lines.push(key + "=" + Packages.Library.$.EscapeString({str: options.data[key]}));
	}
	return lines.join("\n");
};

/*********************************************************************
* GetAttributes - returns the attributes in 'text'
*
* param - options, hash of options, must include:
* 				text : the text to extract from
*
* returns the attributes as a hash
********************************************************************/
Packages.Library.$.GetAttributes = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetAttributes",
		options: options,
		specification: {
			text: 	{type: "string",	required: 1}
		}
	})) return null;
	
	var data = {};
	options.text = options.text.replace(/\r/g,""); // Remove unwanted line chars
	var lines = options.text.split(/\n/);
	for(var i = 0; i < lines.length; i++) {
		if(lines[i].match(/^([^\s]+?)=(.+)$/)) {
			data[RegExp.$1] = Packages.Library.$.UnEscapeString({str: RegExp.$2});
		}
	}
	return data;
};

/*********************************************************************
* GetAttribute - returns the value of the attribute from 'text'
*
* param - options, hash of options, must include:
* 				text : the text to extract from
* 				attr : the attribute to search for
*
* returns the value or null if not found
********************************************************************/
Packages.Library.$.GetAttribute = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetAttribute",
		options: options,
		specification: {
			text: 	{type: "string",	required: 1},
			attr: 	{type: "string",	required: 1, 	min: 1}
		}
	})) return null;
	
	var data = Packages.Library.$.GetAttributes(options)
	return data[options.attr];
};

/*********************************************************************
* MakeElemFileDropable - gets the attributes for an element to allow
* it to be a receiver of a drag and dropped file
*
* param - options, hash of options, must include:
* 				path : the path this element represents
*
* returns the attributes to be placed into the element as a string
* 		or null if an error occured
********************************************************************/
Packages.Library.$.MakeElemFileDropable = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeElemFileDropable",
		options: options,
		specification: {
			path: 	{type: "string",	required: 1}
		}
	})) return null;
	
	var attributes = "";
	
	attributes += "ondrop=\"e = event || window.event; Packages.Library.$._FileDrop(e, '" + options.path + "')\" ";
	attributes += "ondragover=\"e = event || window.event; if (e.preventDefault) { e.preventDefault(); } return false;\" ";
	attributes += "ondragenter=\"e = event || window.event; if (e.preventDefault) { e.preventDefault(); } return false;\" ";
	
	return attributes;
}
/*******************************************************************************
 * _FileDrop - callback when a file dropped into MakeElemFileDropable
 *
 * param - event : the event
 * param - path : the path of where the item was dropped
 ******************************************************************************/
Packages.Library.$._FileDrop = function(event, path) {
	event.preventDefault && event.preventDefault();
	
	// Lock, so only 3 processes can occur at once
	var lock = 0;
	
	var callback = function(evt, file) {
		if(path.length > 0) path += "/";
		
		Packages.Library.$.UploadFile({
			base64: evt.target.result.substr(evt.target.result.indexOf(',') + 1),
			filepath: path + file.name,
			filename: file.name,
			callback: function(options) {lock --; Packages.Library.$.ReloadFileMgr(options)}
		});
    };
	
	var files = event.dataTransfer.files;
	for(var i = 0; i < files.length; i++) {
		var file = files[i];
		var inScope = function(file) {
			if(lock >= 3) {
				setTimeout(function() {inScope(file)}, 50);
				return;
			}
			lock ++;
        
			var reader = new FileReader();
			
			//attach event handlers here...
			reader.onload = function(evt) {callback(evt, file)};
			reader.readAsDataURL(file);
		};
		inScope(file);
	}
	return false;
};

/*************************************************************************************************
 * ReloadFileMgr - callback when a file system altering ServerRequest is performed
 *
 * Called by ServerRequest
 *
 * param - options : hash of options, must contain
 * 			serverReqElem : element containing content
 * 			response : the content
 ************************************************************************************************/
Packages.Library.$.ReloadFileMgr = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ReloadFileMgr",
		options: options,
		specification: {
			serverReqElem: 	{type: "DOMobject",	required: 1},
			response: {type: "string", required: 1}
		}
	})) return null;
	
	var elem = options.serverReqElem;
	
	if(Packages.Library.$v.testing == 1) return 1; // Do nothing in test mode
	if(elem == null) return 1; // Logged out
	
	// Get file list if returned
	var content = "";
	var folderElem = document.getElementById('pJSData');
	if(folderElem != null) {
		content = folderElem.innerHTML;
	}
	
	// Replace all 'var ' so that global variables are affected
	// Be really specific, we only want to reload some vars
	content = content.replace(/var (qPermissions|qVersions|pApps|pFolders|pContainerFolders)/g, "$1");
	eval(content);
	
	Packages.Library.$.EventFire({eventname: "pFolderChanged", data: {}});
	
	return 1;
};

/*************************************************************************************************
 * FindInFolders - gets an array of files / folders matching a certain critera in the folder
 * specified
 *
 * RECURSIVE
 *
 * param - options : hash of options, must contain:
 * 				regExp : regExp to apply to filename
 * 			may contain:
 * 				type : either "file" or "folder", if null, finds either
 * 				folder : the starting folder, or pFolders if not specified
 * 				path : starting path
 *			internally:
 * 				recurse : 1 if recursing, else null
 *
 * returns an array of matching file hashes, each of the form:
 * 				name : the filename without extension
 * 				path : the file path
 * 		or null if an error occured
 ************************************************************************************************/
Packages.Library.$.FindInFolders = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.FindInFolders",
		options: options,
		specification: {
			regExp:		{type: "string",	required: 1},
			type:		{type: "string"},
			folder:		{type: "array"},
			path:		{type: "string"}
		}
	})) return null;
	
	var folder = options.folder;
	var path = options.path;
	if(folder == null) folder = pFolders;
	
	if(Packages.Library.$v.testing == 1 && options.recursing != 1) {
		// Set a standard set of folders
		folder = Packages.Library.$.GetTestSampleFolderList({});
	}
	
	if(path == null) path = "";
	var matches = [];
	var regExp = new RegExp(options.regExp);
	for(var i = 0; i < folder.length; i++) {
		var item = folder[i];
		var match = 1;
		if(!item.name.match(regExp)) match = 0;
		if(options.type != null && options.type != item.type) match = 0;
		if(match) {
			matches.push({
				name: Packages.Library.$.GetFileName({filepath: item.name}),
				path: path + item.name
			});
		}
		
		// Recurse
		if(item.type == "folder") {
			options.folder = item.subfolders;
			options.path = path + item.name + "/";
			options.recursing = 1;
			matches = matches.concat(Packages.Library.$.FindInFolders(options));
		}
	}
	
	return matches;
};

/*************************************************************************************************
 * GetSubFolder - gets the subfolder from the specified container folder offset by offset
 *
 * param - options : hash of options, must include:
 * 				container : the containining folder listing
 * 				offset : the path from the container to the sub folder with '/' separators
 *
 * returns the subfolder listing or null if an error occurs
 ************************************************************************************************/
Packages.Library.$.GetSubFolder = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetSubFolder",
		options: options,
		specification: {
			container: 	{type: "array",		required: 1},
			offset: 	{type: "string",	required: 1}
		}
	})) return null;
	
	var container = options.container;
	if(options.offset == "") return container;
    if(options.offset.match(/^\//)) options.offset = options.offset.substring(1);
    var offsets = options.offset.split("/");
    for(var i = 0; i < offsets.length; i++) {
		var found = 0;
		
		for(var j = 0; j < container.length; j++) {
			var entry = container[j].name;
			entry = entry.replace(/.\$jsc.*$/, "");
		    entry = entry.replace(/.\$jsc.*\//, "/");
		    if(entry == offsets[i]) {
				container = container[j].subfolders;
				found = 1;
				break;
		    }
		}
		
		if(found == 0) {
			Packages.Library.$.LogInfo({mesg: "Could not find [" + options.offset + "]", location: "Packages.Library.$.GetSubFolder", type: "Info", level: 3});
			return null;
		}
    }
    return container;
};

/*************************************************************************************************
 * GetFolderList - gets all of the files in the folders and subfolders in one array
 *
 * param - options : hash of options, including:
 * 				container : the container folder
 * 			may include:
 * 				extensions : array of valid file extensions, or null for all
 * 				prefix : path prefix
 *
 * returns the array
 ************************************************************************************************/
Packages.Library.$.GetFolderList = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetFolderList",
		options: options,
		specification: {
			container: 	{type: "array",	required: 1},
			extensions: {type: "array"},
			prefix: 	{type: "string"}
		}
	})) return null;

	if(options.prefix == null) options.prefix = "";
	var container = options.container;
    var listing = [];
    for(var i = 0; i < container.length; i++) {
		if(container[i].type == "folder") listing = listing.concat(Packages.Library.$.GetFolderList({
																		container: container[i].subfolders,
																		extensions: options.extensions,
																		prefix: options.prefix + container[i].name + "/"}
																	));
		if(container[i].type == "file") {
			var lastdot = container[i].name.lastIndexOf(".");
            var extension = lastdot != -1 ? container[i].name.substr(lastdot + 1) : "";
			if(extension == null || Packages.Library.$.Contains({array: options.extensions, item: extension})) listing.push(options.prefix + container[i].name);
		}
    }
    return listing;
};

/*************************************************************************************************
 * FileExist - tests if the specified file exists
 *
 * param - options : hash of options, must contain:
 * 				filepath : filepath to check
 * 			may contain:
 * 				folder : the starting folder, or pFolders if not specified
 *
 * returns 1 if file found, or 0 if not, or null if invalid arguments
 ************************************************************************************************/
Packages.Library.$.FileExist = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.FileExist",
		options: options,
		specification: {
			filepath:	{type: "string", required: 1},
			folder:		{type: "array"}
		}
	})) return 0;
	
	var folder = options.folder;
	if(folder == null) folder = pFolders;
	
	var filepath = options.filepath;
	var path = "";
	var file = filepath;
	if(filepath.match(/\//)) {
		path = filepath.substr(0, filepath.lastIndexOf("/"));
		file = filepath.substr(filepath.lastIndexOf("/") + 1);
	}
	
	folder = Packages.Library.$.GetSubFolder({container: folder, offset: path});
	
	for(var i = 0; i < folder.length; i++) {
		if(folder[i].name == file) return 1;
	}
	
	return 0;
};Package("Library").Font = function() {};

Packages.Library.$c.Font = {};
Packages.Library.$c.Font.Fonts = [
	"Sans", "Sans-Serif", "Monospace", "Condiment", "Chela One", "Give You Glory", "Sirin Stencil", "Petit Formal Script",
	"Jolly Lodger", "Fugaz One", "Paprika", "Mrs Saint Delafield",
	"Sanchez", "Playfair Display SC", "Cherry Swash", "Audiowide", "Montserrat",
	"Cutive", "Nunito",
	"Patrick Hand", "Pompiere", "Poiret One", "Henny Penny", "Kite One", "Crete Round",
	"Cinzel", "Diplomata", "Quando", "Handlee",
	"Asset", "Josefin Sans", "Josefin Slab", "Source Code Pro", "Exo", "Chango", "Cinzel Decorative"
];

/*********************************************************************
* GetFontOptions - gets an array of available fonts in the correct format
* to display in as radio buttons in a form
*
* returns array of font hashes, each of the form:
* 		name : name to display, wrapped in CSS to give correct appearance
* 		value : CSS font name
********************************************************************/
Packages.Library.$.GetFontOptions = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetFontOptions",
		options: options,
		specification: {}
	})) return null;
	
	var options = [];
	for(var i = 0; i < Packages.Library.$c.Font.Fonts.length; i++) {
		var font = Packages.Library.$c.Font.Fonts[i];
		options.push({
			name: "<span style=\"font-family: '" + font + "', " + font + ", sans-serif\">" + font + "<\/span>",
			value: font
		});
		
		// Request font
		Packages.Library.$.RequestFont({font: font});
	}
	return options;
};

/*********************************************************************
* RequestFont - requests the specified font be loaded into the browser
*
* If a DOM is available, the linktag will be loaded
*
* param - options : hash of options, must contain:
* 				font : name of font as in the constant array
*
* return - linktag : the link tag to place in the head
********************************************************************/
Packages.Library.$.RequestFont = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.RequestFont",
		options: options,
		specification: {
			font: 	{type: "string",	required: 1}
		}
	})) return "";
	
	// Test font is in our list
	var match = 0;
	for(var i = 0; i < Packages.Library.$c.Font.Fonts.length; i++) {
		if(options.font == Packages.Library.$c.Font.Fonts[i]) match = 1;
	}
	if(match == 0) return ""; // No match
	if(options.font.match(/^sans/i)) return ""; // Don't load Sans
	
	var familyname = options.font.replace(/ /, '+');
	var linktag = "<link href='http://fonts.googleapis.com/css?family=" + familyname + "' rel='stylesheet' type='text/css'>";
	if(Packages.Library.$c.HasDOM == 1) {
		var link = document.createElement('link');
		link.href = "http://fonts.googleapis.com/css?family=" + familyname;
		link.rel = 'stylesheet';
		link.type = 'text/css';
		var linkelem = document.getElementsByTagName('link')[0];
		if(linkelem == null) linkelem = document.getElementsByTagName('script')[0];
		linkelem.parentNode.insertBefore(link, linkelem);
	}
	return linktag;
};Package("Library.Gallery.Effects.Cut").view = function(parent, divid) {
	this.parent = parent;
    this.textVar = GetTextRef(this);
	this.currentpageid = -1;
    /************************************************
	 * Display - gets the html markup for this effect
	 *
	 * returns the html
	 ***********************************************/
    this.Display = function() {
        var html = "<span style='display:block;position:relative;overflow:hidden;height:100%'>";
        html += "<div style='width:100%' id='" + divid + "_galpage'></div>";
        html += "<\/span>"
        return html;
    };
    /************************************************
	 * Update - called on a timer to update the effect
	 ***********************************************/
    this.Update = function () {
        var node = parent.GetPageNode(parent.current + 0, divid);
        var elem = document.getElementById(divid + '_galpage');
        if(elem == null) return;
		if(node.parentNode != elem) {
			if(node.parentNode != null) node.parentNode.removeChild(node);
			Packages.Library.$.EmptyNode({node: elem});
			elem.appendChild(node);
		}
		
		// Preload
		node = parent.GetPageNode(parent.current + 1, divid);
    };
};
Packages.Library.Gallery.Effects.Cut.$.GetDetails = function() {
    return {
        name:       "Cut",
        description:"Cuts (without transition effect) between the images.",
        category:   "Effects"
    };
};Package("Library.Gallery.Effects.Fade").view = function(parent, divid) {
	this.parent = parent;
    this.textVar = GetTextRef(this);
	this.gal_back = -1;
	this.gal_front = -1;
	this.gal_preload = -1;
    /************************************************
	 * Display - gets the html markup for this effect
	 *
	 * returns the html
	 ***********************************************/
    this.Display = function() {
        var html = "<span style='" + (this.parent.data.height != '' ? "display:block;position:relative;overflow:hidden;height:100%;" : "") + "'>";
		html += "<div class='gallery_fadeitem' id='" + divid + "_gal_back'  style='position:absolute;width:100%;'><\/div>";
        html += "<div class='gallery_fadeitem' id='" + divid + "_gal_front' style='position:relative;opacity:1;width:100%;'><\/div>";
        html += "<\/span>"
        return html;
    };
    /************************************************
	 * Update - called on a timer to update the effect
	 ***********************************************/
    this.Update = function () {
		var progress = parent.current - Math.floor(parent.current);
        if(progress > parent.transitionStart) {
			fade = 1 - ((progress - parent.transitionStart) / parent.transitionLength);
        } else {
            fade = 1;
        }
        var node = parent.GetPageNode(parent.current + 1, divid);
        var elem = document.getElementById(divid + '_gal_back');
        if(elem == null) return;
		if(node.parentNode != elem) {
			if(node.parentNode != null) node.parentNode.removeChild(node);
			Packages.Library.$.EmptyNode({node: elem});
			elem.appendChild(node);
		}
        
        node = parent.GetPageNode(parent.current + 0, divid);
        elem = document.getElementById(divid + '_gal_front');
        if(elem == null) return;
		if(node.parentNode != elem) {
			if(node.parentNode != null) node.parentNode.removeChild(node);
			Packages.Library.$.EmptyNode({node: elem});
			elem.appendChild(node);
		}
		
		// Preload next
		node = parent.GetPageNode(parent.current + 2, divid);
        
		// Do the fade
        document.getElementById(divid + '_gal_front').style.opacity = fade;
    };
};
Packages.Library.Gallery.Effects.Fade.$.GetDetails = function() {
    return {
        name:       "Fade",
        description:"Fades between the images.",
        category:   "Effects"
    };
};Package("Library.Gallery.Effects.FadeCSS").view = function(parent, divid) {
	this.parent = parent;
    this.textVar = GetTextRef(this);
	this.currentpageid = -1;
    /************************************************
	 * Display - gets the html markup for this effect
	 *
	 * returns the html
	 ***********************************************/
    this.Display = function() {
        var html = "<span " +
						"style='" +
							"display:block;" +
							"position:relative;" +
							"height:100%;" +
						"'" +
						" class='gallery_fadecss'>";
		
		var duration = parent.data.pages.length;
		
		if(parent.data.delay == null) parent.data.delay = 0;
		if(parent.data.transitionTime == null) parent.data.transitionTime = 0;
		var eachItemDisplayTime = parseInt(parent.data.delay) + parseInt(parent.data.transitionTime);
		duration *= eachItemDisplayTime;
		
		// Put a background image so it always shows something
		html += "<div style='" +
						"position: absolute;" +
						"width:100%;" +
						"z-index:0;" +
						"height:100%;" +
					"'" +
				">" +
					parent.data.pages[0] +
				"</div>";
		
		// Create each page of html and set a delayed start
		for(var i = 0; i < parent.data.pages.length ; i++) {
			html += "<div style='" +
							"-webkit-animation-delay: " + (i * eachItemDisplayTime) +  "s;" +
							"animation-delay: " + (i * eachItemDisplayTime) + "s;" +
							"animation-duration: " + duration + "s;" +
							"-webkit-animation-duration: " + duration + "s;" +
							"width:100%;" +
							"position:absolute;" +
							"z-index:1;" +
						"'" +
						" class='gallery_fadecss_item'" +
					">" +
						parent.data.pages[i] +
					"</div>";
		}
        html += "<\/span>"
		
		// Create a constant frame, to hold open the size of the gallery
		if(parent.data.height == null || parent.data.height == '') {
			html += "<div style='" +
								"position: relative;" +
								"width:100%;" +
								"z-index:0;" +
							"'" +
						">" +
							parent.data.pages[0] +
						"</div>";
		}

        return html;
    };
    /************************************************
	 * Update - called on a timer to update the effect
	 *
	 * No update, all done via CSS
	 ***********************************************/
    this.Update = function () { };
};
Packages.Library.Gallery.Effects.FadeCSS.$.GetDetails = function() {
    return {
        name:       "Fade (pure CSS)",
        description:"Fades between the images.",
        category:   "Effects"
    };
};Package("Library.Gallery.Effects.Grid").view = function(parent, divid) {
	this.parent = parent;
    this.textVar = GetTextRef(this);
    /************************************************
	 * Display - gets the html markup for this effect
	 *
	 * returns the html
	 ***********************************************/
    this.Display = function() {
        var cols = Math.floor(Math.sqrt(this.parent.data.pages.length) + 0.5);
        var rows = cols;
        if(parent.data.pages.length > rows * cols) rows++;
        var html = "<table class='gallery_grid'>";
        for(var y = 0; y < rows; y++) {
            html += "<tr>";
            for(var x = 0; x < cols; x++) {
                html += "<td width='" + (Math.floor(100/cols)) + "%' style='padding:10px'>";
                var imgid = y * cols + x;
                html += "<div style='width:100%' id='" + divid + "_img_" + imgid + "'";
                html += "onclick=\"" + this.textVar + ".panel.current = " + imgid + ";" + this.textVar + ".panel.view.TogglePlayPause(0)\"";
                html += ">" + this.parent.GetNextPage(imgid) + "<\/div>";
                html += "<\/td>";
            }
            html += "<\/tr>";
        }
        html += "<\/table>";
        return html;
    };
    /************************************************
	 * Update - called on a timer to update the effect
	 ***********************************************/
    this.Update = function () {};
};
Packages.Library.Gallery.Effects.Grid.$.GetDetails = function() {
    return {
        name:       "Grid",
        description:"Displays all images in a grid.",
        category:   "Effects"
    };
};Package("Library.Gallery.Effects.Rotate").view = function(parent, divid) {
	this.parent = parent;
    this.textVar = GetTextRef(this);
    this.rid;
    this.pages = 5;
	this.currentIds = [];
    /************************************************
	 * Display - gets the html markup for this effect
	 *
	 * returns the html
	 ***********************************************/
    this.Display = function() {
        this.rid = divid + "_gal_";
        var html = "";
        for(var j =- ((this.pages - 1) / 2); j <= ((this.pages - 1) / 2); j++) {
            html += "<div id='" + this.rid + j + "' class='gallery_img" + j + "'>";
            html += "<\/div>";
        }
        return html;
    };
    /************************************************
	 * Update - called on a timer to update the effect
	 ***********************************************/
    this.Update = function () {
        for(var j = -((this.pages - 1) / 2); j <= ((this.pages - 1) / 2); j++) {
            var part = (this.parent.current - Math.floor(this.parent.current)) / this.pages + ((j + ((this.pages - 1) / 2)) / this.pages);
            var elem = document.getElementById(this.rid + j);
            if(elem == null) return;
            elem.style.position = "absolute";
            var size = 80;
            var x = Math.sin(part * 3.14159 * 2) * (size / 2) + 50;
            var t = Math.sin(part * 3.14159);
            var w = ((t * 0.25) + 0.25) * size;
			var f = 1;
			if(t < 0.5) f = t * 2.5 - 0.25
			if(f < 0) f = 0;
			
			var node = parent.GetPageNode(Math.floor(parent.current) - j, divid, 6);
			if(node.parentNode != elem) {
				if(node.parentNode != null) node.parentNode.removeChild(node);
				Packages.Library.$.EmptyNode({node: elem});
				elem.appendChild(node);
			}
            
			elem.style.left = (x - (w / 2)) + "%";
            elem.style.top = ((1 - Math.sin(part * 3.14159)) * size / 4 + (100 - size)) + "%";
            elem.style.height = "auto";
            elem.style.width = (w + 1) + "%";
            elem.style.opacity = f;
            elem.style.zIndex = Math.floor((Math.sin(part * 3.14159)) * size + 10)+"";
            elem.setAttribute("onclick", parent.textVar + ".target = " + Math.floor(parent.current - j));
            elem.className="gallery_img" + j;
        }
		
		// Preload
		var node = parent.GetPageNode(Math.floor(parent.current) + 3, divid, 6);
    };
};
Packages.Library.Gallery.Effects.Rotate.$.GetDetails = function() {
    return {
        name:       "Rotate",
        description:"Rotates the images.",
        category:   "Effects"
    };
};Package("Library.Gallery.Effects.Slide").view = function(parent, divid) {
	this.parent = parent;
    this.textVar = GetTextRef(this);
	this.gal_next = -1;
	this.gal_current = -1;
    /************************************************
	 * Display - gets the html markup for this effect
	 *
	 * returns the html
	 ***********************************************/
    this.Display = function() {
        var html = "<div style='overflow:hidden;width:100%;height:100%;position:relative;'>";
        html += "<div class='gal_slide_wide' style='white-space:nowrap;width:200%;height:100%;position:relative;'>";
        html += "<div id='" + divid + "_gal_current' style='position:relative;margin-left:-100%;float:left;width:50%;height:100%'><\/div>";
        html += "<div id='" + divid + "_gal_next' style='position:relative;float:left;width:50%;height:100%'><\/div>";
		html += "<\/div><\/div>";
        return html;
    };
    /************************************************
	 * Update - called on a timer to update the effect
	 ***********************************************/
    this.Update = function () {
        var slide = parent.current - Math.floor(parent.current);
        if(slide >= parent.transitionStart) {
            slide = ((slide - parent.transitionStart) / parent.transitionLength) * 50;
        }else{
            slide = 0;
        }
		
		var node = parent.GetPageNode(parent.current + 1, divid);
        var elem = document.getElementById(divid + '_gal_next');
        if(elem == null) return;
		if(node.parentNode != elem) {
			if(node.parentNode != null) node.parentNode.removeChild(node);
			Packages.Library.$.EmptyNode({node: elem});
			elem.appendChild(node);
		}
		
		document.getElementById(divid + '_gal_current').style.marginLeft = (0 - slide) + "%";
		
		node = parent.GetPageNode(parent.current + 0, divid);
        elem = document.getElementById(divid + '_gal_current');
        if(elem == null) return;
		if(node.parentNode != elem) {
			if(node.parentNode != null) node.parentNode.removeChild(node);
			Packages.Library.$.EmptyNode({node: elem});
			elem.appendChild(node);
		}
		
		// Preload
		node = parent.GetPageNode(parent.current + 2, divid);
    };
};
Packages.Library.Gallery.Effects.Slide.$.GetDetails = function() {
    return {
        name:       "Slide",
        description:"Slides between the images.",
        category:   "Effects"
    };
};Package("Library.Gallery").Gallery = function(data) {
	this.textVar = GetTextRef(this);
	this.data = data;
	this.current = 0;
	this.target = undefined;
	this.fullscreen = 0;
	this.play = 1;
	this.divid = "gallery_" + Packages.Library.$.GetUniqueId({});
	this.effectFS;
	this.effectSM;
	this.nodes = {};
	this.lastUsedNodes = {};
	/*******************************************************************************
	 * Display - Creates the markup for this gallery
	 *
	 * data : hash of options, may contain
	 * 		pages : array of pages, each is HTML to display
	 * 		sm_effect : inline effect, default Cut
	 * 		fs_effect : fullscreen effect, default disabled
	 * 		width : inline width in pixels, default image default
	 * 		height: inline height in pixels, default image default
	 * 		delay : time each image is displayed in seconds, default 5
	 * 		transitionTime : time spent transitioning from one effect to the next in seconds, default 1
	 * 		stretch : 1 (default) stretch image to width / height, 0 don't
	 * 		viewerControl : 1 (default) provide viewer settings in full screen, 0 don't
	 * 		useCookieData : 1 (default) read saved gallery data from cookie, 0 don't
	 * 		animate : 1 (default) animate, 0 do not animate at all
	 ******************************************************************************/
	this.Display = function() {
		// Create the objects for the small and fullscreen effects
		
		this.useMiniImagesSM = 0;
		if(data.miniImages != null && data.miniImages != 0) this.useMiniImagesSM = 1;
		
		// Load saved data stored in a ussers cookie for setting their galleries?
		if(this.data.useCookieData != 0) {
			var settings = Packages.Library.$.GetCookies().gallery_settings;
			if(settings != null) {
				Packages.Library.$.Merge({
					base: this.data,
					extra: settings
				});
			}
		}
		
		if(data.sm_effect == null) data.sm_effect = "Cut";
		if(data.width == null) data.width = "";
		if(data.height == null) data.height = "";
		if(data.delay == null) data.delay = 5;
		if(data.transitionTime == null) data.transitionTime = 1;
		if(data.stretch == null) data.stretch = 1; // Legacy
		if(data.miniImages == null) data.miniImages = 0;
		if(data.fs_effect != null && Packages.Library.Gallery.Effects[data.fs_effect] != null) {
			this.effectFS = new Packages.Library.Gallery.Effects[data.fs_effect].view(this, this.divid + "_fs");
		}
		
		var nodeLiveInfo = "";
		var nodeDataDump = "";
		
		// If using node to render the gallery, the nonJS image gallery must be used: FadeCSS
		if(Packages.Library.$c.IsNode == 1) {
			// Store info for live mode when page is rendered to upgrade the gallery to JS
			nodeLiveInfo = Packages.Library.$.NodeStoreData({data: data, type: "gallery"});
			// Create a full base64 dump of information
			nodeDataDump = btoa(Packages.Library.$.Dump({obj: data, skiplist: ["Gallery", "parent"]}));
			
			// Change effect to FadeCSS as the only one Node supports
			data.sm_effect = "FadeCSS";
		}
		
		if(Packages.Library.Gallery.Effects[data.sm_effect] == null) {
			Packages.Library.$.LogInfo({mesg: "Could not load effect [" + data.sm_effect + "]", location: "Gallery", type: "Bad Arguments", level: 2});
			return "";
		}
		this.effectSM = new Packages.Library.Gallery.Effects[data.sm_effect].view(this, this.divid + "_sm");
		
		// Do we have any pages to show?
		if(data.pages.length == 0) return "";
		
		var html = "";
		if(data.fs_effect != null) {
			// Fullscreen markup
			html += "<div id='" + this.divid + "_fs_outer' style='display:none' class='shadowsoff gallery_fs_outer" + (this.data.stretch == 1 ? " gallery_stretch" : "") + "'>";
			html += this.GetFullScreenContent();
			html += "<\/div>";
		}
		
		// Small markup
		html += "<div id='" + this.divid + "_sm' class='shadowsoff gallery_sm" + (this.data.stretch == 1 ? " gallery_stretch" : "") + "' onClick=\"" + this.textVar + ".EnableFullScreen()\" style='" +
						(this.data.width != '' ? "width:" + this.data.width + "px;" : "") +
						(this.data.height != '' ? "height:" + this.data.height + "px;" : "") +
					"'>";
		html += this.effectSM.Display();
		html += "<\/div>";
		html += this.MakeMiniImages(0);
		html += "<div style='display:none' class='gallerydata'>" + nodeDataDump + "<\/div>";
		
		html = "<div class='gallerycontainer " + nodeLiveInfo + "'>" + html + "<\/div>";
		
		if(Packages.Library.$c.IsNode != 1) this.StartTimer();
		return html;
	};
	/*******************************************************************************
	 * GetFullScreenContent - Gets the content for fullscreen
	 *
	 * return - content : the full screen content
	 ******************************************************************************/
	this.GetFullScreenContent = function() {
		var html = "";
		html += "   <div class='gallery_fs_background' onClick=\"" + this.textVar + ".CloseFullScreen()\"><\/div>";
		html += "   <div class='gallery_fs_inner'>";
		if(this.data.title != null) html += "<div id='" + this.divid + "_fs_title' class='styles_bar gallery_fs_title'>" + this.data.title + "<\/div><br>";
		html += "       <div class='gallery_fs_buttons'>"
		html += "           <div id='" + this.divid + "_fs_previous' class='styles_bar gallery_fs_button mbutton' onClick=\"" + this.textVar + ".Previous()\">&lArr;<div class='galbutton_subtitle'>Previous<\/div><\/div>";
		html += "           <div id='" + this.divid + "_fs_close' class='styles_bar gallery_fs_button mbutton' onClick=\"" + this.textVar + ".CloseFullScreen()\">X<div class='galbutton_subtitle'>Close<\/div><\/div>";
		html += "           <div id='" + this.divid + "_fs_super' class='styles_bar gallery_fs_button mbutton' onClick=\"" + this.textVar + ".ToggleSuperFullscreen()\">+<div class='galbutton_subtitle'>Full Screen<\/div><\/div>";
		if(this.data.viewerControl != 0) {
			html += "           <div id='" + this.divid + "_fs_settings' class='styles_bar gallery_fs_button mbutton' onClick=\"" + this.textVar + ".ShowSettings()\">*<div class='galbutton_subtitle'>Settings<\/div><\/div>";
		}
		html += "           <div id='" + this.divid + "_fs_playpause' class='styles_bar gallery_fs_button mbutton' onClick=\"" + this.textVar + ".TogglePlayPause()\">| |<div class='galbutton_subtitle'>Pause<\/div><\/div>";
		html += "           <div id='" + this.divid + "_fs_next' class='styles_bar gallery_fs_button mbutton' onClick=\"" + this.textVar + ".Next()\">&rArr;<div class='galbutton_subtitle'>Next<\/div><\/div>";
		html += "       <\/div>";
		html += "       <div id='" + this.divid + "_fs' class='gallery_fs' onclick='" + this.textVar + ".ToggleSuperFullscreen()'>"
		html += this.effectFS.Display();
		html += "       <\/div>";
		html += this.MakeMiniImages(1);
		html += "   <\/div>";
		
		return html;
	}
	/*******************************************************************************
	 * MakeMiniImages - creates the mini images under the effect
	 *
	 * param - key : unique key for these mini images
	 ******************************************************************************/
	this.MakeMiniImages = function(key) {
		if(this.data.miniImages == 0) return "";
		if(this.useMiniImagesSM == 0 && key == 0) return "";
		
		var html = "<div id='" + this.divid + "_mini_" + key + "' class='gallery_miniImages'><\/div>";
		
		return html;
	}
	/*******************************************************************************
	 * UpdateMiniImages - updates the mini images under the effect
	 *
	 * param - key : unique key for these mini images
	 ******************************************************************************/
	this.UpdateMiniImages = function(key) {
		if(this.data.miniImages == 0) return;
		
		var containerElem = document.getElementById(this.divid + "_mini_" + key);
		if(containerElem == null) return;
		
		var firstOffset = -Math.floor(this.data.miniImages / 2);
		
		// Check first image is right
		if(containerElem.firstChild != this.GetPageNode(this.current + firstOffset, "mini" + key, this.data.miniImages + 1)
		|| containerElem.childNodes.length != this.data.miniImages + 1) {
			// Images need updating, so reload
			Packages.Library.$.EmptyNode({node: containerElem});
			
			// Build new list, adding extra hidden item at the end
			for(var i = 0; i < this.data.miniImages + 1; i++) {
				var imgOffset = firstOffset + i;
				var imgNode = this.GetPageNode(this.current + imgOffset, "mini" + key, this.data.miniImages + 1);
				containerElem.appendChild(imgNode);
				imgNode.style.marginLeft = "0%";
				imgNode.style.width = (100 / this.data.miniImages) + "%";
				imgNode.setAttribute("onclick", this.textVar + ".SetTarget(" + Math.floor(imgOffset + this.current) + ")");
			};
		}
		
		// Move content to the left slightly to give illusion of sliding
		var slide = this.current - Math.floor(this.current);
        if(slide >= this.transitionStart) {
            slide = ((slide - this.transitionStart) / this.transitionLength);
        }else{
            slide = 0;
        }
		containerElem.firstChild.style.marginLeft = -((100 / this.data.miniImages) * slide) + "%";
	}
	/*******************************************************************************
	 * StartTimer - Waits for the elements to be ready then starts the timer
	 ******************************************************************************/
	this.StartTimer = function() {
		if(this.data.animate == 0) return;
		if(document.getElementById(this.divid + "_sm") == null) {
			// Schedule a re-visit
			var _this = this;
			setTimeout(function() {_this.StartTimer()}, 50);
			return;
		}
		// Ready
		this.Timer();
	};
	/*******************************************************************************
	 * Timer - Continuously goes around and updates the gallery
	 ******************************************************************************/
	this.Timer = function() {
		if(document.getElementById(this.divid + "_sm") == null) return; // in case gallery removed
		
		var delayAndTransition = (this.data.delay * 1) + (this.data.transitionTime * 1);
		if(this.target != null) delayAndTransition = this.data.transitionTime * 1;
		this.transitionStart = this.data.delay / delayAndTransition; // Point at which to start transition
		this.transitionLength = this.data.transitionTime / delayAndTransition; // Length of transition
		
		// Are we doing an update this time?
		var update = this.play;
		
		// Dom we have a target
		if(this.target != null) {
			update = 1;
			if(this.play == 0) {
				// Jump to target
				this.current = Math.floor(this.target);
				this.target = null;
			} else {
				// Animate to target
				var offset = 0.5;
				delayAndTransition = delayAndTransition / 8; // 8 x speed
				var w1 = this.target - this.current + offset;
				if(w1 < 0) w1 += this.data.pages.length;
				var w2 = this.data.pages.length - w1;
				if(w2 < w1) delayAndTransition = -delayAndTransition; // Invert (go backward)
				if(Math.floor(this.target) == Math.floor(this.current + offset)) {
					this.current = Math.floor(this.target);
					this.target = null;
				}
				// Prevent judder
				if(this.targetTransition != null && this.targetTransition != delayAndTransition) this.target = null;
				this.targetTransition = delayAndTransition;
			}
		}
		if(this.target == null) this.targetTransition = null;
		if(delayAndTransition == 0) delayAndTransition = 1;
		
		if(update) this.current += 0.04 / delayAndTransition;
		
		// Iterate through and create a gallery for each mode,
		// note the forloop runs to data.fullscreen
		// SM mode - update SM only
		// FS mode - update SM and FS
		
		for(var mode = 0; mode <= this.fullscreen; mode++) {
			var selectedEffect = (mode == 0 ? this.effectSM : this.effectFS);
			var selecteddiv = (mode == 0 ? this.divid + "_sm" : this.divid + "_fs");
			
			if(selectedEffect != null) {
			
				// Only update page when page changes
				if(update) {
					selectedEffect.Update();
					
					// Update mini images
					this.UpdateMiniImages(mode)
				}
			}
		}
		// Schedule a re-visit
		var _this = this;
		setTimeout(function() {_this.Timer()}, 40);
	};
	/*******************************************************************************
	 * SetTarget - Sets the target page to scroll to
	 *
	 * param - target : the target page ID
	 *
	 * returns the html markup for this page
	 ******************************************************************************/
	this.SetTarget = function(target) {
		this.target = target;
	};
	/*******************************************************************************
	 * GetNextPage - Gets the next pages markup
	 *
	 * param - n : offset, (next page would be 1, previous -1 etc)
	 *
	 * returns the html markup for this page
	 ******************************************************************************/
	this.GetNextPage = function(n) {
		return this.data.pages[this.GetNextPageID(n)];
	};
	/*******************************************************************************
	 * GetPageNode - Gets a DOM node for the page
	 *
	 * If an existing DOM node exists, it shall be used
	 *
	 * param - n : offset, (next page would be 1, previous -1 etc)
	 * param - key : unique key, so the same node may be requested more than once
	 * param - max : maximum nodes to store, default 3
	 *
	 * returns the DOM node
	 ******************************************************************************/
	this.GetPageNode = function(n, key, max) {
		if(max == null) max = 3;
		var pageid = this.GetNextPageID(n);
		if(this.nodes[key] == null) this.nodes[key] = [];
		
		// Restrict nodes to max
		if(this.lastUsedNodes[key] == null) this.lastUsedNodes[key] = [];
		// Find existing entry
		var entry = Packages.Library.$.FindArrayItemIndex({
			array: this.lastUsedNodes[key],
			value: pageid
		});
		// Remove if found
		if(entry != null) this.lastUsedNodes[key].splice(entry, 1);
		// Place pageid at end of the array as last requested
		this.lastUsedNodes[key].push(pageid);
		// Check length doesn't exceed max, if it does, reduce the list
		while(this.lastUsedNodes[key].length > max) {
			// Remove first entry
			var oldid = this.lastUsedNodes[key].shift();
			// Destroy all contents in the node - can't be used elsewhere
			Packages.Library.$.EmptyNode({node: this.nodes[key][oldid]});
			// Remove node from cache
			this.nodes[key][oldid] = null;
		}
		
		// Fetch page node if not already in cache
		if(this.nodes[key][pageid] == null) {
			var elem = document.createElement("div");
			elem.innerHTML = "\n" + this.data.pages[pageid] + "\n";
			elem.className = "gallery_pagenode";
			this.nodes[key][pageid] = elem;
		}
		return this.nodes[key][pageid];
	};
	/*******************************************************************************
	 * GetNextPageID - Gets the next page ID
	 *
	 * param - n : offset, (next page would be 1, previous -1 etc)
	 ******************************************************************************/
	this.GetNextPageID = function(n) {
		if(n == null) n = this.current;
		var max = this.data.pages.length;
		if(max == 0 || max == null) return 0;
		while(n < 0 || n >= max) {
			if(n < 0) n += max;
			if(n >= max) n -= max;
		}
		return Math.floor(n);
	};
	/*******************************************************************************
	 * EnableFullScreen - switches full screen gallery on
	 ******************************************************************************/
	this.EnableFullScreen = function() {
		if(Packages.Library.$.GetInternetExplorerVersion() < 9) return;
		if(data.fs_effect == null) return;
		
		this.fullscreen = 1;
		
		document.getElementById(this.divid + "_fs_outer").style.display = 'block';
		
		// Log this event
		Packages.Library.$.EventFire({eventname: "LogMessage", data: {type: "Info", heading: "Gallery", message: "Opened in full screen", caller: "Gallery"}});
	};
	/*******************************************************************************
	 * CloseFullScreen - switches full screen gallery off
	 ******************************************************************************/
	this.CloseFullScreen = function() {
		this.fullscreen = 0;
		document.getElementById(this.divid + "_fs_outer").style.display = 'none';
	};
	/*******************************************************************************
	 * ToggleSuperFullscreen - switches into full screen gallery mode (as in to the edge)
	 ******************************************************************************/
	this.ToggleSuperFullscreen = function() {
		if(Packages.Library.$.GetInternetExplorerVersion() < 9) return;
		
		if(this.superFullScreen == null) this.superFullScreen = 0;
		this.superFullScreen = this.superFullScreen == 1 ? 0 : 1; // Invert
		
		Packages.Library.$.ToggleBodyClass({
			className: "gallery_fs_super",
			state: this.superFullScreen
		});
	};
	/*******************************************************************************
	 * Previous - selects previous page
	 ******************************************************************************/
	this.Previous = function() {
		this.current = Math.floor(this.current - 1);
	};
	/*******************************************************************************
	 * Next - selects next page
	 ******************************************************************************/
	this.Next = function() {
		this.current = Math.floor(this.current + 1);
	};
	/*******************************************************************************
	 * TogglePlayPause - toggles play / pause button
	 *
	 * param - force : 1 pauses, 0 plays
	 ******************************************************************************/
	this.TogglePlayPause = function(force) {
		if(force != null) this.play = 1 - force;
		if(this.play == 1) {
			this.play = 0;
			document.getElementById(this.divid+"_fs_playpause").innerHTML = "><div class='galbutton_subtitle'>Play<\/div>";
		}else{
			this.play = 1;
			document.getElementById(this.divid+"_fs_playpause").innerHTML = "| |<div class='galbutton_subtitle'>Pause<\/div>";
		}
	};
	/*******************************************************************************
	 * ShowSettings - shows settings for this effect
	 ******************************************************************************/
	this.ShowSettings = function() {
		var effects = [];
        for(var effect in Packages.Library.Gallery.Effects) {
			if(effect.match(/^\$/)) continue;
            effects.push({name: effect, value: effect});
        }
		
		var form = {
            type: "Form",
			object: this.data,
			showSubmit: 0,
			allowUndo: 0,
			plainBackground: 1,
			action: function() {}, // Auto save and reload
            items: [
                {
					type: "Text",
					id: "delay",
					name: "Auto Delay",
					suffix: "seconds",
					description: "The time to display each image",
					numeric: 1,
					min: -1,
					size: 3
				},
				{
					type: "Text",
					id: "transitionTime",
					name: "Transition time",
					description: "The time to animate between one image and the next",
					suffix: "seconds",
					numeric: 1,
					min: 0,
					size: 3
				},
				{
					type: "Text",
					id: "miniImages",
					name: "Show",
					description: "Number of mini images to show below the effect, 0 to disable",
					suffix: "mini images",
					numeric: 1,
					min: 0,
					max: 20,
					size: 3
				},
				{
					type: "SelectBox",
					options: effects,
					id: "fs_effect",
					name: "Full Screen effect"
				}
			]
        };
        form.Form = new Packages.Form.Form(form);
		var _this = this;
		Packages.Library.$.CreatePopupQuery({
			title: "Image Gallery Settings",
			message: form.Form.MakeForm(),
			buttons: {
				OK: "OK"
			},
			callback: function() {
				form.Form.Submit();
				var fsEffectElem = document.getElementById(_this.divid + "_fs_outer");
				_this.effectFS = new Packages.Library.Gallery.Effects[data.fs_effect].view(_this, _this.divid + "_fs");
				if(fsEffectElem != null) {
					fsEffectElem.innerHTML = _this.GetFullScreenContent();
				}
				
				Packages.Library.$.SetCookie({
					hash: {
						gallery_settings: {
							delay: _this.data.delay,
							transitionTime: _this.data.transitionTime,
							fs_effect: _this.data.fs_effect,
							miniImages: _this.data.miniImages
						}
					}
				});
			}
		})
	};
};
/*********************************************************************
 * GalleryNodeLive - callback when cookie usage is requested
 *
 * returns information about this cookie
 ********************************************************************/
Packages.Library.Gallery.$.GalleryNodeLive = function(options) {
	if(options.type != "gallery") return;
	// Get base64 data dump
	var elems = options.elem.getElementsByClassName("gallerydata");
	if(elems[0] == null) return;
	var properties;
	eval("properties = " + atob(elems[0].innerHTML));
	// Create a new image gallery object
	var gallery = new Packages.Library.Gallery.Gallery(properties);
	options.elem.innerHTML = gallery.Display();
};
// Subscriber in Library.InitPackage("Library").General = function() {};

// Force initialisation
masterpath = typeof(masterpath) != "undefined" ? masterpath : ""

// vars for debugging
var timers = [];
var lostdivs = [];
var lostfiles = [];
/*********************************************************************
* Init - initialises the system - called from all boot loaders
*
* param - options : hash of options, may contain:
* 		offline : 1 if system is in offline mode, 0 (default) for online
********************************************************************/
Packages.Library.$.Init = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Init",
		options: options,
		specification: {
			offline:	{type: "boolean"}
		}
	})) return;
	
	if(Packages.Library.$v.testing == 1) {
		return;
		// Do nothing in test mode
	}
	
	// Is the DOM installed?
	if(document != null && document.getElementById != null) Packages.Library.$c.HasDOM = 1;
	
	if(options == null) options = {};
	if(Packages.Library.$v.RunningOptions == null) Packages.Library.$v.RunningOptions = {};
	Packages.Library.$.Merge({
		base: Packages.Library.$v.RunningOptions,
		extra: options
	});
	
	// Has the page finished loading? - Prevents Init running before page finished
	if(typeof(WebPageComplete) == "undefined") {
		// Try again in a second
		setTimeout(Packages.Library.$.Init, 10);
		return;
	}
	
	// Get global / local query string
	Packages.Library.$v.GlobalQueries = {};
	Packages.Library.$v.LocalQueries = {};
	var queries = Packages.Library.$.GetQueries({raw: 1});
	for(var query in queries) {
		if(query.match(/gq_/)) {
			Packages.Library.$v.GlobalQueries[query] = queries[query];
		}
		if(query.match(/lq_/)) {
			Packages.Library.$v.LocalQueries[query] = queries[query];
		}
	}
	
	if(Packages.Library.$c.IsNode != 1) {
		// Clear get files
		var bodyelem = document.getElementsByTagName("body")[0];
		var getFilesElem = document.getElementById('getFiles');
		if(getFilesElem != null) {
			getFilesElem.innerHTML = "";
		} else {
			// Add the getfiles div to the end of the page body
			getFilesElem = document.createElement('div');
			getFilesElem.style.display = 'none';
			getFilesElem.id = 'getFiles';
			bodyelem.appendChild(getFilesElem);
		}
		
		// Add pageinfo section
		var pageInfoElem = document.getElementById('pageinfo');
		if(pageInfoElem == null) {
			// Add the pageinfo div to the end of the page body
			pageInfoElem = document.createElement('div');
			pageInfoElem.style.display = 'none';
			pageInfoElem.id = 'pageinfo';
			bodyelem.appendChild(pageInfoElem);
		}
	}
	
	// Create a standard messenger so all objects can talk cleanly
	Packages.Library.$o.General.messenger = new Packages.Library.Messages();
	
	// Fire all Package .$.Init functions
	if(Packages.$i.registeredPackages != null) {
		for(var i = 0; i < Packages.$i.registeredPackages.length; i++) {
			var thePackage = Packages.$i.registeredPackages[i];
			if(thePackage.$.InitPackage != null) thePackage.$.InitPackage();
		}
	}
	
	if(typeof(pUser) != "undefined") Packages.Library.$.SetLogin({username: pUser});
	
	if(typeof(pDebugLevel) != "undefined" && Packages.Library.$c.DebugLevel == null) Packages.Library.$c.DebugLevel = pDebugLevel;
	
	if(Packages.Library.$c.DebugLevel > 0
	&& Packages.Library.$c.IsNode != 1) {
		// Create debug and diagnostic item
		var debugItem = new Packages.Library.Debug();
		debugItem.Init();
	}
	
	// Count the page views
	var pageviews = Packages.Library.$.GetPageViews();
	Packages.Library.$.SetCookie({hash: {pageviews: pageviews + 1}});
	
	if(options.offline != 1
	&& Packages.Library.$c.IsNode != 1) {
		// Initialise User Space - load data from server
		Packages.Library.$.CreateUserspace();
	}
	
	// Initialise compatability
	Packages.Library.$.InitCompatibility({});
	
	if(Packages.Library.$c.IsNode != 1) {
		// Store mouse x and y as it moves around the page
		document.body.onmousemove = function(eIn) {
			var e = eIn || window.event;
			Packages.Library.$v.Mouse.x = e.pageX;
			Packages.Library.$v.Mouse.y = e.pageY;
		}
		
		// Create a trigger event for body mouseup event
		document.body.onmouseup = function(eIn) {
			// Fire subscriber if anyone is interested
			Packages.Library.$.EventFire({eventname: "mouseup", data: {event: eIn}});
		}
		
		// Create the onexit event for anything to subscribe to
		window.onbeforeunload = function() {
			if(Packages.Library.$v.CheckClose == 0) return null;
			// Fire subscriber if anyone is interested
				/************************
				 * onexit - EVENT - fired before the page loads
				 *
				 * returns a hash of response data, containing
				 *		stop : 1 prevent the page from exiting, 0 (default) do nothing
				 *		message : message to display if stopping
				 *		id : unique id, to prevent the same message appearing twice
				 ***********************/
			var responses = Packages.Library.$.EventFire({eventname: "onexit", data: {}});
			var stop = 0;
			var messages = {};
			for(var i = 0; i < responses.length; i++) {
				if(responses[i] == null) continue;
				if(responses[i].stop == 1) {
					stop = 1;
					messages[responses[i].id] = responses[i].message;
				}
			}
			if(stop == 1) {
				var message = "";
				for(var id in messages) {
					message += " - " + messages[id] + "\n";
				}
				message = "You will loose any unsaved information you have entered into this page.\n\n"
						+	"Unsaved data:\n"
						+	message;
				return message;
			}
			return undefined; // Fine, must use undefined for IE
		}
	}
	
	// Check query string params that may cause a specific action to run
	var runAction = Packages.Library.$.GetQuery({attr: "runAction"});
	if(runAction != null) {
		if(runAction == "PackageTest") {
			Packages.Library.$v.testRun = 1;
			setTimeout(function() {
				var tester = new Packages.Library.Test();
				tester.Start();
				// When all tests are done, close the window
				var check = function() {
					if(Packages.Library.$.GetKeys({object: Packages.Library.$v.TestLocks}) != 0) {
						setTimeout(check, 100);
						return; // Try again later
					}
					Packages.Library.$.CloseWindow({force: 1}); // Close window when complete
				};
				check();
			}, 2000); // Load first, then do it
		}
	}
	
	// Enhance node generated page
	if(Packages.Library.Gallery) {
		Packages.Library.$.EventSubscribe({eventname: "NodeLive", callback: Packages.Library.Gallery.$.GalleryNodeLive});
	}
	Packages.Library.$.EventSubscribe({eventname: "NodeLive", callback: Packages.Library.$.AccountFormNodeLive});
	Packages.Library.$.LiveEnhanceNode({});
};

/*********************************************************************
 * CloseWindow - closes the window
 *
 * param - force : 1 does not check, (default) 0 checks if the user wants to close
 ********************************************************************/
Packages.Library.$.CloseWindow = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CloseWindow",
		options: options,
		specification: {
			force: {type: "boolean"}
		}
	})) return;
	
	if(Packages.Library.$v.testing == 1) return; // Because this would be a terrible idea
	
	if(options.force == 1) Packages.Library.$v.CheckClose = 0;
	
	window.close();
};

/*********************************************************************
* GetPageViews - Gets the number of page views
*
* When testing, uses: 1
*
* returns the number of page views
********************************************************************/
Packages.Library.$.GetPageViews = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPageViews",
		options: options,
		specification: {}
	})) return null;
	
	var cookies = Packages.Library.$.GetCookies({});
	if(cookies.pageviews == null) cookies.pageviews = 0;
	
	if(Packages.Library.$v.testing == 1) return 1;
	
	return cookies.pageviews;
}

/*********************************************************************
* RemoveElement - removes all of the tags from the selected owner of type tag
*
* param - options : hash of options, must contain:
* 				owner : the owner element
* 				tag : the tag name to remove
********************************************************************/
Packages.Library.$.RemoveElement = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.RemoveElement",
		options: options,
		specification: {
			owner: 	{type: "DOMobject",	required: 1},
			tag: 	{type: "string",	required: 1,	min: 1}
		}
	})) return;
	
	var elems = options.owner.getElementsByTagName(options.tag);
	for (var i = 0; i < elems.length; i++) {
		if(elems[i].parentNode != options.owner) continue;
		options.owner.removeChild(elems[i]);
	}
};

/*************************************************************************************************
 * EmptyNode - empties all elements from a specified node
 *
 * param - options : hash of options, must contain:
 * 			node : the DOM node to remove all elements from
 ************************************************************************************************/
Packages.Library.$.EmptyNode = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EmptyNode",
		options: options,
		specification: {
			node: 	{type: "DOMobject",	required: 1}
		}
	})) return;
	
	if(Packages.Library.$v.testing == 1) return; // Do not allow this to be tested, especially since this is tested on document.body
	
	while(options.node.firstChild != null) {
		options.node.removeChild(options.node.firstChild);
	}
};

/*********************************************************************
* MergeInheritedFolders - takes an array of folders listings, each folder listing contains
* a different version of the same file system.
*
* The array of listings is recursevely mashed into a single listing
*
* The first listing is the lowest level which inherits from everything above it.
*
* File listings use the standard JS file listing format
* 	name : file name
* 	type : 'file' or 'folder'
* 	subfolders : (if folder) array of subfolders
* 	
*
* param - options : hash of options, must include:
* 				listings : the array of listings
*
* returns the array of merged listings
********************************************************************/
Packages.Library.$.MergeInheritedFolders = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MergeInheritedFolders",
		options: options,
		specification: {
			listings: 	{type: "array",	required: 1}
		}
	})) return [];
	
	var listings = options.listings;
	if(listings.length==0) return [];
	var ret = listings[0];
	for(var i=0;i<ret.length;i++) {
		var match = ret[i].name;
		var type = ret[i].type;
		var matches = [];
		// Find duplicate entries, and merge
		for(var j=1;j<listings.length;j++) {
			for(var k=0;k<listings[j].length;k++) {
				if(listings[j][k].name == match && listings[j][k].type == type) {
					matches.push(listings[j][k]);
					// Remove entry
					listings[j].splice(k,1);
					k--;
				}
			}
		}
		if(type=='file') {
			for(var j=0;j<matches.length;j++) {
				matches[j].inherited = 2;
				ret.push(matches[j]);
			}
		}
		if(type=='folder') {
			// Merge subfolders
			var subfolders = [ret[i].subfolders];
			for(var j=0;j<matches.length;j++) {
				if(matches[j].subfolders != undefined) subfolders.push(matches[j].subfolders);
			}
			ret[i].subfolders = Packages.Library.$.MergeInheritedFolders({listings: subfolders});
		}
	}
	// Merge whatever wasn't removed above
	for(var i=1;i<listings.length;i++) {
		for(var j=0;j<listings[i].length;j++) {
			listings[i][j].inherited = 1;
			ret.push(listings[i][j]);
		}
	}
	return ret;
};

/*********************************************************************
* SelectSelectAll - selects all elements in a select box
*
* param - options : hash of options, must include:
* 				id : id of select box
* 				mode : 1 to select, 0 to deselect
********************************************************************/
Packages.Library.$.SelectSelectAll = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SelectSelectAll",
		options: options,
		specification: {
			id: 	{type: "string",	required: 1, 	min: 1},
			mode: 	{type: "boolean",	required: 1}
		}
	})) return;
	
	var elem = document.getElementById(options.id);
	if(elem == null) return;
	for(var i = 0; i < elem.options.length; i++) {
		elem.options[i].selected = options.mode;
	}
};

/*********************************************************************
 * GetMasterpath - gets the masterpath
 *
 * returns the masterpath
 ********************************************************************/
Packages.Library.$.GetMasterpath = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetMasterpath",
		options: options,
		specification: {}
	})) return null;
	
	if(Packages.Library.$v.testing == 1) return ""; // Do not allow this to be tested
	
	return masterpath;
};

/*********************************************************************
* GetQuery - gets the value of the specified attribute from the query string of the page
* 
* param - options : hash of options, must include:
* 				attr : the attribute name
*
* returns the value of the attribute or null if not found
********************************************************************/
Packages.Library.$.GetQuery = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetQuery",
		options: options,
		specification: {
			attr: 	{type: "string",	required: 1, 	min: 1}
		}
	})) return null;
	
	var queries = Packages.Library.$.GetQueries({});
	return queries[options.attr];
};

/*********************************************************************
* GetQueries - gets a hash of values in the query string
*
* param - options : hash of options, may contain:
* 			url : url to extract from, default to the page url
* 			raw : 1 do not strip of gq_ prefix, 0 (default) do
*
* returns the hash of attribute / value pairs
********************************************************************/
Packages.Library.$.GetQueries = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetQueries",
		options: options,
		specification: {
			url: {type: "string"}
		}
	})) return null;
	
	var url = options.url;
	if(url == null) url = Packages.Library.$.GetURL({});
	var query = url.substring(url.indexOf('?') + 1);
	var queries = query.split(/&/);
	var hash = {};
	foreach(queries, function(query) {
		if(query.match(/(.+?)=(.+)/)) {
			var key = RegExp.$1;
			var value = RegExp.$2;
			if(options.raw != 1) {
				key = key.replace(/^gq_/, ""); //  Strip gq_ prefix
				key = key.replace(/^lq_/, ""); //  Strip lq_ prefix
			}
			hash[key] = value;
		}
	});
	
	return hash;
};

/*********************************************************************
* ModifyGlobalQueries - modifies global queries
*
* Note, queries not prefixed by a gq_ will have a gq_ added
* Note, to remove a query, set its value to null
*
* param - options : hash of options, must contain
* 			queries : hash of queries to merge into global queries
********************************************************************/
Packages.Library.$.ModifyGlobalQueries = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ModifyGlobalQueries",
		options: options,
		specification: {
			queries: 	{type: "object",	required: 1}
		}
	})) return;
	
	for(var query in options.queries) {
		var correctedQuery = query
		if(!correctedQuery.match(/gq_/)) correctedQuery = "gq_" + correctedQuery;
		Packages.Library.$v.GlobalQueries[correctedQuery] = options.queries[query];
	}
};

/*********************************************************************
* AddGlobalQueries - adds global queries to the URL specified
*
* GlobalQueries
* 	Added to any URLs on the page, read from previous query string
*
* LocalQueries
* 	As for GlobalQueries but only applies to current page
*
* QueryGroup
* 	Global queries may already exist, eg xcsv_filter_a=1
* 	There is no way to remove this
* 	If the XCSV filters want to add filter links, they can specify
* 		xcsv_filter
* 	as the querygroup, and all global queries starting with that will be stripped out
*
* param - options : hash of options, may contain:
* 			url : the url, may contain query string, default: page url
* 			queries: hash of additional queries
* 			localQueries: hash of additional queries that will be marked as local
* 			globalQueries: hash of additional queries that will be marked as global
* 			queryGroup: a prefix for the group of queries this applies to
*
* returns the new URL with the global queries
********************************************************************/
Packages.Library.$.AddGlobalQueries = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.AddGlobalQueries",
		options: options,
		specification: {
			url: 	{type: "string"},
			queries:{type: "object"},
			localQueries:{type: "object"},
			globalQueries:{type: "object"},
			queryGroup: {type: "string"}
		}
	})) return null;
	
	// Get the queries from the passed in URL
	var newQueries = {};
	if(options.url != null) newQueries = Packages.Library.$.GetQueries({url: options.url, raw: 1});
	
	var extraQueries = options.queries;
	if(extraQueries == null) extraQueries = {};
	var globalQueries = options.globalQueries;
	if(globalQueries == null) globalQueries = {};
	var localQueries = options.localQueries;
	if(localQueries == null) localQueries = {};
	
	var queries = {};
	// Add the global queries, as long as they do not start with our queryGroup
	for(var query in Packages.Library.$v.GlobalQueries) {
		if(options.queryGroup != null && query.indexOf("gq_" + options.queryGroup) == 0) continue; // Starts with queryGroup
		var value = Packages.Library.$v.GlobalQueries[query];
		if(value == null) continue;
		queries[query] = value;
	}
	// Is the page url the same as the current page?
	if(options.url == null
	|| options.url == ""
	|| options.url == Packages.Library.$.GetURL({})) {
		// Add the local queries, as long as they do not start with our queryGroup
		for(var query in Packages.Library.$v.LocalQueries) {
			if(options.queryGroup != null && query.indexOf("lq_" + options.queryGroup) == 0) continue; // Starts with queryGroup
			var value = Packages.Library.$v.LocalQueries[query];
			if(value == null) continue;
			queries[query] = value;
		}
	}
	
	// Add the queries from the URL
	for(var query in newQueries) {
		queries[query] = newQueries[query];
	}
	
	// Add the queries from extraQueries
	for(var query in extraQueries) {
		queries[query] = extraQueries[query];
	}
	
	// Add the queries from globalQueries
	for(var query in globalQueries) {
		queries["gq_" + query] = globalQueries[query];
	}
	
	// Add the queries from globalQueries
	for(var query in localQueries) {
		queries["lq_" + query] = localQueries[query];
	}
	
	// Create the query string
	var queryList = [];
	for(var query in queries) {
		var value = queries[query];
		if(value == null) continue;
		queryList.push(query + "=" + value);
	}
	var queryString = queryList.join("&");
	
	var url = Packages.Library.$.StripQueries({url: options.url});
	
	// If no new queries, just return the base URL
	if(queryString.length == 0) return url;
	
	// URL has no queries, append
	return url + "?" + queryString;
};

/*********************************************************************
 * FixHrefs - fixes hrefs in html supplied
 *
 * param - options : hash of options, may contain:
 * 			content : content to fix
 *
 * return - content : the fixed content
 ********************************************************************/
Packages.Library.$.FixHrefs = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.FixHrefs",
		options: options,
		specification: {
			content: {type: "string", required: 1}
		}
	})) return null;
	
	// Now check for any hrefs, and replace the container path with
	// the actual container
	var content = options.content;
	while(content.match(/href="(.*?)\$containerpath\/(.*?)"/)) {
		var path = RegExp.$1 + "$containerpath/" + RegExp.$2;
		
		var fixedURL = Packages.Library.$.GetPathToBase({filepath: path})
		
		content = Packages.Library.$.Replace({
			content: content,
			search: "href=\"" + path,
			replacement: "href=\"" + fixedURL
		});
	}
	
	return content;
};

/*********************************************************************
 * GetURL - gets the full
 * 
 * URL http://domain.com/path/file.ext?x=y
 *
 * When in testmode, uses: http://www.testmode.com/path/path.2/file.extension
 *
 * param - options : hash of options, may contain:
 * 			url : url to use, null use page url
 * 			useParent : 1 uses top level page, when inside an iframe, 0 use current
 *
 * Return page name, Eg. 'Home'
 ********************************************************************/
Packages.Library.$.GetURL = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetURL",
		options: options,
		specification: {
			url: {type: "string"},
			useParent: {type: "boolean"}
		}
	})) return null;
	
	if(options.url != null) return options.url;
	
	if(Packages.Library.$v.testing == 1) {
		// Testing, so normalise the data returned
		return "http://www.testmode.com/path/path.2/file.extension?query=queryvalue&query2=2";
	}
	
	if(typeof(pRequestURI) != "undefined") return pRequestURI;
	
	if(Packages.Library.$c.IsNode == 1) return "";
	
	var doc = document;
	if(options.useParent == 1) doc = parent.document;
	
	return doc.URL;
};

/*********************************************************************
* GetDomain - gets the domain of this site
*
* Return domain.com
********************************************************************/
Packages.Library.$.GetDomain = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetDomain",
		options: options,
		specification: {},
		optionsPassedTo: [
			Packages.Library.$.GetURL
		]
	})) return null;
	
	var url = Packages.Library.$.GetURL(options).substring(7);
	var domain = url.substring(0, url.indexOf('/'));
	return domain;
};

/*********************************************************************
* StripQueries - gets the URL with query string removed
*
* param - options, hash of options. may contain:
* 			url : the url to use instead of page
*
* returns the url with query string removed
********************************************************************/
Packages.Library.$.StripQueries = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.StripQueries",
		options: options,
		specification: {},
		optionsPassedTo: [
			Packages.Library.$.GetURL
		]
	})) return null;
	
	var url = Packages.Library.$.GetURL(options);
	var queryStart = url.indexOf('?');
	if(queryStart == -1) return url;
	return url.substring(0, url.indexOf('?'));
};

/*********************************************************************
* GetPagePath - gets the full path of the current page
*
* param - options, hash of options. may contain:
* 			url : the url to use instead of page
*
* Returns /path/subfolder/
********************************************************************/
Packages.Library.$.GetPagePath = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPagePath",
		options: options,
		specification: {},
		optionsPassedTo: [
			Packages.Library.$.GetURL
		]
	})) return null;
	
	var url = Packages.Library.$.GetURL(options).substring(7);
	var page = url.substring(url.indexOf('/'));
	var path = page.substring(0, page.lastIndexOf('/') + 1);
	return path;
};
/*********************************************************************
* GetPageURL - gets the full path of the current page after the domain
*
* param - options, hash of options. may contain:
* 			url : the url to use instead of page
* 
* Return /path/pagename.ext
********************************************************************/
Packages.Library.$.GetPageURL = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPageURL",
		options: options,
		specification: {},
		optionsPassedTo: [
			Packages.Library.$.GetURL
		]
	})) return null;
	
	var url = Packages.Library.$.GetURL(options).substring(7);
	var page = url.substring(url.indexOf('/'));
	return page;
};
/*********************************************************************
* GetPageName - gets the name of the page without the extension
*
* param - options, hash of options. may contain:
* 			url : the url to use instead of page
*
* Return page name, Eg. 'Home'
********************************************************************/
Packages.Library.$.GetPageName = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPageName",
		options: options,
		specification: {},
		optionsPassedTo: [
			Packages.Library.$.GetURL
		]
	})) return null;
	
	var url = Packages.Library.$.GetURL(options);
	
	if(Packages.Library.$v.testing == 1) url = "";
	
	return Packages.Library.$.GetFileName({filepath: url});
};

/*************************************************************************************************
 * GetContainerPath - gets the container path from the path specified
 *
 * param - options : hash of options, must contain:
 * 				path : the path
 *
 * returns the path including $containerPath
 ************************************************************************************************/
Packages.Library.$.GetContainerPath = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetContainerPath",
		options: options,
		specification: {
			path:		{type: "string", required: 1}
		}
	})) return null;
	
	var path = options.path;
	// If this is relative, add the pOffset
	if(Packages.Library.$v.testing == 1) {
		// Don't do this in test mode
	} else {
		if(!path.match(/^\//)) path = pOffset + path;
	}
	
	// Does this path container 'HTML'
	if(path.match(/HTML\//)) {
		return "$containerpath/" + path.replace(/^.*?HTML\//, "");
	}
	
	// Return path to masterPath
	return "$containerpath/" + path;
};

/*********************************************************************
* IsMobile - detects if this is a mobile browser
*
* Return true if mobile, or false if not
********************************************************************/
Packages.Library.$.IsMobile = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.IsMobile",
		options: options,
		specification: {}
	})) return null;
	
	if(Packages.Library.$c.IsNode) return 0;
	
	if(navigator.platform.toLowerCase().match(/iphone|ipad|ipod|android|blackberry|mini|windows\sce|palm/i)) return true;
	if(navigator.appVersion.toLowerCase().match(/iphone|ipad|ipod|android|blackberry|mini|windows\sce|palm/i)) return true;
	return false;
};
/*********************************************************************
* GetFileName - gets the filename (without the extension and path)
*
* param - options : hash of options, must contain:
* 			filepath : filepath or filename
* 		may contain:
* 			keepExtension : 1 keep the extension, 0 (default) trim
*
* Return the filename without extension
********************************************************************/
Packages.Library.$.GetFileName = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetFileName",
		options: options,
		specification: {
			filepath: {type: "string", required: 1},
			keepExtension: {type: "boolean"}
		}
	})) return null;
	
	var filepath = options.filepath;
	
	if(filepath.match(/\//)) filepath = filepath.substring(filepath.lastIndexOf('/') + 1);
	if(options.keepExtension == 1) return filepath;
	return filepath.substring(0, filepath.lastIndexOf('.'));
};
/*********************************************************************
* GetFileExtension - gets the extension of the file
*
* param - options: hash of options, must contain:
* 			filepath : filepath or filename
*
* Return the file extension
********************************************************************/
Packages.Library.$.GetFileExtension = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetFileExtension",
		options: options,
		specification: {
			filepath: {type: "string", required: 1}
		}
	})) return null;
	
	var filepath = options.filepath;
	
	return filepath.substring(filepath.lastIndexOf('.') + 1);
};
/*********************************************************************
* CleanURL - Alters a path to prevent reversing up beyond the first / of domain 
*
* param - options : hash of options, must include:
* 				path to rectify
*
* returns fixed path
********************************************************************/
Packages.Library.$.CleanURL = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CleanURL",
		options: options,
		specification: {
			path: 	{type: "string",	required: 1}
		}
	})) return null;
	
	return options.path.replace(/\.\.\/HTML\//,"");
};

/*************************************************************************************************
 * GetPathToBase - Gets the relative path from this item, to the container folder
 *
 * param - options : hash of options, may include:
* 				filepath : filepath to correct
 * 
 * returns the path
 ************************************************************************************************/
Packages.Library.$.GetPathToBase = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPathToBase",
		options: options,
		specification: {
			filepath: 	{type: "string"}
		}
	})) return null;
	var filepath = options.filepath;
	if(filepath == null) filepath = "";
	
	if(filepath.match(/\$containerpath/)) {
		filepath = Packages.Library.$.GetPagePath({}) + filepath;
		if(filepath.match(/HTML\/.*?\$containerpath/)) {
			return filepath.replace(/HTML\/.*?\$containerpath\//, "HTML/"); // Calculate real request
		}
		return filepath; // Can not be clever
	}
	
	// Legacy, strip the 'HTML/' off the front, should not be there
	filepath = filepath.replace(/^HTML\//, "");
	// filepath is now everything after the HTML/ folder
	
	return filepath;
};

/*********************************************************************
* SafeExec - safely executes the specified method with params
*
* param - options : hash of options, must include:
* 				method : method to execute
* 			may include:
* 				params : params to use
*
* returns result of method, or null if failed
********************************************************************/
Packages.Library.$.SafeExec = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SafeExec",
		options: options,
		specification: {
			method: 	{type: "string",	required: 1, 	min: 1},
			params: 	{type: "string"}
		}
	})) return null;
	
	try {
		if(typeof(eval(options.method)) == "undefined") return null;
		if(options.params == null) options.params = "";
		return eval(options.method + "(" + options.params + ")");
	}catch(e) {}
	return null;
};
/*********************************************************************
* SafeLoadDiv - safely loads the html into the div with id specified
*
* param - options : hash of options, must include:
* 					id : id of elem to load
* 					html : content to load into it
********************************************************************/
Packages.Library.$.SafeLoadDiv = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SafeLoadDiv",
		options: options,
		specification: {
			id: 	{type: "string",	required: 1, 	min: 1},
			html: 	{type: "string",	required: 1}
		}
	})) return;

    var elem = document.getElementById(options.id);
    if(elem == null) {
        return;
    }
    elem.innerHTML = options.html;
};

/*************************************************************************************************
 * GetAuthFields - Gets the markup for two hidden field that contain the user and pass
 *
 * Returns the HTML markup for the form items
 ************************************************************************************************/
Packages.Library.$.GetAuthFields = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetAuthFields",
		options: options,
		specification: {}
	})) return null;
	
    return "<input type='hidden' name='user' value='" + Packages.Library.$.GetAccountData({}).username + "'><input type='hidden' name='pass' value='" + Packages.Library.$.GetAccountData({}).password + "'>";
};

/*************************************************************************************************
* GetElemPosition - Gets the position of the specified elem
*
* param - options : hash of options, must include:
* 				elem : the element
*
* returns left: left, top: top or null if an error occurs
************************************************************************************************/
Packages.Library.$.GetElemPosition = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetElemPosition",
		options: options,
		specification: {
			elem: 	{type: "DOMobject",	required: 1}
		}
	})) return null;
	
	var elem = options.elem;
    var topValue = 0, leftValue = 0;
    while(elem){
		leftValue += elem.offsetLeft;
		topValue += elem.offsetTop;
		elem = elem.offsetParent;
    }    
    return {left: leftValue, top: topValue};
};

/*********************************************************************
* IsSupportedBrowser - Returns the level of support for this browser
*
* Reasons:
* 	If a browser doesn'y have a debug option - it is almost impossible to
* 	fix its rendering when it displays a blank page
* 		Blackberry - displays a blank page
* 		GoogleBot - it executes some of our javascript, and then
* 			stops before its finished loading the page.
*
* FireFox is a supported browser, but 'Packages' is an internal javascript
* variable to give access to its Java Engine. Therefore this variable must
* be redefined before use by the BootLoader (either WEB or BootLoader)
*
* returns 0 if unsupported, 1 if supported for viewing, 2 if supported for editing
********************************************************************/
Packages.Library.$.IsSupportedBrowser = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.IsSupportedBrowser",
		options: options,
		specification: {}
	})) return null;
	
	if(Packages.Library.$c.IsNode) return 1;
	
    var ua = navigator.userAgent;
    if(ua.match(/BlackBerry/)) return 0;
	if(ua.match(/googlebot/i)) return 0;
	if(ua.match(/bot/i)) return 0;
    return 1;
};
/*********************************************************************
* GetInternetExplorerVersion - Gets the version of IE
*
* returns IE version or 99 if not IE
********************************************************************/
Packages.Library.$.GetInternetExplorerVersion = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetInternetExplorerVersion",
		options: options,
		specification: {}
	})) return null;
	
	if(Packages.Library.$c.IsNode) return 99;
	
    var rv = 99; // Return value assumes failure.
    if (navigator.appName == 'Microsoft Internet Explorer')
    {
        var ua = navigator.userAgent;
        var re  = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})");
        if (re.exec(ua) != null)
            rv = parseFloat( RegExp.$1 );
        }
    return rv;
};

/*********************************************************************
* GetBrowserName - Gets browser navigator string
*
* returns browser navigator string
********************************************************************/
Packages.Library.$.GetBrowserName = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetBrowserName",
		options: options,
		specification: {}
	})) return null;
	
	if(Packages.Library.$v.testing == 1
	|| Packages.Library.$c.IsNode) {
		return "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.125 Safari/537.36";
	}
	
    return navigator.userAgent;
};

/*******************************************************************************
 * Clone - clones the specified object and creates a new identical deep copy of
 * the object
 *
 * Always skips $noDump key
 *
 * param - options : hash of options, must include:
 * 				oldObj : the source (can be an array)
 * 			may include:
 * 				skiplist : array of 'keys' to skip in objects
 * 			internally:
 * 				newObj : the new object to add items to (if a reference is needed)
 *
 * returns the copy or null if an error occured
 ******************************************************************************/
Packages.Library.$.Clone = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Clone",
		options: options,
		specification: {
			oldObj: 	{type: "array,object,string,number,boolean",	required: 1},
			skiplist: 	{type: "array"},
			newObj:		{type: "array,object"}
		}
	})) return null;
	var type = Packages.Library.$.GetType({item: options.oldObj});
	if(type == "string" || type == "number" || type == "boolean") return options.oldObj;
	
	var oldObj = options.oldObj;
	if(oldObj == null) return null;
	var skiplist = options.skiplist;
	if(skiplist == null) skiplist = [];
	var newObj = options.newObj
	if(newObj == null) newObj = (oldObj instanceof Array) ? [] : {};
	for (var i in oldObj) {
		if (i == 'clone') continue;
		if (i == '$recursing') continue;
		if (i == '$noDump') continue;
		if (i == '$id') continue;
		if(Packages.Library.$.Contains({array: skiplist, item: i})) continue;
		var type = Packages.Library.$.GetType({item: oldObj[i]});
		if (oldObj[i] && typeof oldObj[i] == "object" && type != "DOMobject") {
			if (oldObj[i].$recursing != null) {
				// Already being cloned, so use cloned version
				newObj[i] = oldObj[i].$recursing.newObj;
				continue;
			}
			var nextObj = (oldObj[i] instanceof Array) ? [] : {};
			if(type == "object") {
				oldObj[i].$recursing = {from: "Packages.Library.$.Clone", newObj: nextObj};
			}
			newObj[i] = Packages.Library.$.Clone({oldObj: oldObj[i], newObj: nextObj});
			if(oldObj[i].$recursing != null) delete oldObj[i].$recursing;
		} else {
			newObj[i] = oldObj[i]
		}
	}
	return newObj;
};

/*******************************************************************************
 * AppendMessageToElement - appends the specified message to the element
 * specified by id, the message is wrapped in 'p' tags.
 *
 * param - options : hash of options, must include:
 * 				id : the element id
 * 				mesg : message to append
 ******************************************************************************/
Packages.Library.$.AppendMessageToElement = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.AppendMessageToElement",
		options: options,
		specification: {
			id: 	{type: "string",	required: 1,	min: 1},
			mesg: 	{type: "string",	required: 1}
		}
	})) return;

	Packages.Library.$.AppendHTMLToElement({elemid: options.id, html: options.mesg + '<br>'});
};

/*************************************************************************************************
 * LogInfo - Appends an error to the error box
 *
 * param - options : hash of options, must include:
 * 				mesg : the error message
 * 				location : where the error occured
 * 			may include:
 * 				type : type of message, defaults to 'Info'
 * 				alert : 1 pop up an alert box, 0 (default) don't
 * 				level : error level, 0 critical to 10 very minor
 ************************************************************************************************/
Packages.Library.$.LogInfo = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.LogInfo",
		options: options,
		specification: {
			mesg: 		{type: "string",	required: 1},
			location: 	{type: "string",	required: 1},
			type: 		{type: "string"},
			alert: 		{type: "boolean"},
			level:		{type: "number"}
		}
	})) return;
	
	if(options.type == null) options.type = 'Info';
	if(options.level == null) options.level = 0;
	var date = new Date();
	options.date = date;
	
	if(options.alert == 1
	&& Packages.Library.$v.testing != 1
	&& Packages.Library.$c.IsNode != 1) {
		alert(options.type + ": " + options.mesg + "\nOccured in: " + options.location);
	}
	
	Packages.Library.$v.LoggedErrors.push(options);
	
	options.mesg = options.mesg.replace(/</g, "&lt;").replace(/>/g, "&gt;");
	
	if(Packages.Library.$v.testing == 1) return; // Do nothing
	
	var mesg = date.toLocaleTimeString() + "." + date.getMilliseconds() + ": " + options.type + ": '" + options.mesg + "' occured in " + options.location;
	if(Packages.Library.$c.DebugLevel > 0) console.log(mesg);
	
	if(Packages.Library.$c.HasDOM == 1) Packages.Library.$.AppendMessageToElement({id: 'pageinfo', mesg: mesg});
};

/*************************************************************************************************
 * DisplayLoggedInfo - pops up a dialogue box displaying the logged messages
 *
 * Offers a selectbox to control the severity of messages displayed
 *
 * Offers a selectbox to control the types of messages displayed
 ************************************************************************************************/
Packages.Library.$.DisplayLoggedInfo = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.DisplayLoggedInfo",
		options: options,
		specification: {}
	})) return;
	
	// Determine the different messages
	var messageTypes = {};
	foreach(Packages.Library.$v.LoggedErrors, function(item) {
		if(messageTypes[item.type] == null) messageTypes[item.type] = 1;
	});
	
	var typeOptions = [{name: "Any", value: "Any"}];
	foreach(Packages.Library.$.GetKeys({object: messageTypes}), function(type) {
		typeOptions.push({
			name: type,
			value: type
		});
	});
	
	var complexityOptions = [];
	for(var i = 1; i <= 10; i++) {
		complexityOptions.push({name: i, value: i});
	}
	
	var html = "";
	html += "Severity: <select "
			+	"class='loginfo_select' "
			+	"id='loginfo_select_complexity' "
			+	"onchange='Packages.Library.$._RenderDisplayLoggedInfo()' "
			+ ">"
			+	Packages.Library.$.CreateSelectOptionsFromArray({items: complexityOptions})
			+ "<\/select>";
	html += "&nbsp;&nbsp;&nbsp;&nbsp;"
	html += "Type: <select "
			+	"class='loginfo_select' "
			+	"id='loginfo_select_type' "
			+	"onchange='Packages.Library.$._RenderDisplayLoggedInfo()' "
			+ ">"
			+	Packages.Library.$.CreateSelectOptionsFromArray({items: typeOptions})
			+ "<\/select>";
	html += "<div id='loginfo_content'><\/div>";
	
	Packages.Library.$.CreatePopupQuery({
		title: "Logged Information",
		message: html
	});
	
	// Update
	Packages.Library.$._RenderDisplayLoggedInfo();
}

/*************************************************************************************************
 * _RenderDisplayLoggedInfo - helper method for DisplayLoggedInfo, updates inner content
 ************************************************************************************************/
Packages.Library.$._RenderDisplayLoggedInfo = function() {
	var complexityLevel = 1;
	var elem = document.getElementById("loginfo_select_complexity");
	if(elem) complexityLevel = elem.value;
	var type = 1;
	var elem = document.getElementById("loginfo_select_type");
	if(elem) type = elem.value;
	
	var html = "";
	foreach(Packages.Library.$v.LoggedErrors, function(item) {
		if(type != "Any" && item.type != type) return;
		if(item.level > complexityLevel) return;
		
		html += "<li>" + item.level + ": " + item.date.toLocaleTimeString() + ": " + item.type + ": '" + item.mesg + "' occured in " + item.location + "<\/li>";
	});
	
	html = "<ul class='loginfo_items'>" + html + "<\/ul>";
	
	var elem = document.getElementById('loginfo_content');
	if(elem) elem.innerHTML = html;
}

/*************************************************************************************************
 * LogReport - Generates a report from the array of data
 *
 * param - options : hash of options, must include:
 * 				report : array of report hashes, as follows:
 * 					name: Content
 * 					description: (optional) help text information
 * 					heading : (optional) heading
 * 				location : location of where the report called from
 * 			may contain:
 * 				alert : 1 popup alert, 0 (default) don't
 *
 * return - html for the report
 ************************************************************************************************/
Packages.Library.$.LogReport = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.LogReport",
		options: options,
		specification: {
			report: 	{type: "array",	required: 1},
			location: 	{type: "string",	required: 1},
			alert: 		{type: "boolean"}
		}
	})) return null;
	
	// Produce report
	var html = "";
	foreach(options.report, function(report) {
		if(report.heading != null) html += "<h2>" + report.heading + "</h2>";
		html += report.name;
		if(report.description != null) html += Packages.Library.$.MakeHelp({help: report.description});
		html += "\n";
	});
	Packages.Library.$.LogInfo({
		alert: options.alert,
		mesg: html,
		location: options.location,
		type: "Report",
		level: 5
	});
	
	return html.replace(/\n/g, "<br>");
};

/*******************************************************************************
 * GetArrayFromObject - in the vary rare case where the objects keys are all numeric
 * it will return an array of values, otherwise returns null
 *
 * param - options : hash of options, must include:
 * 				object : the object
 *
 * returns the array or null if incompatable
 ******************************************************************************/
Packages.Library.$.GetArrayFromObject = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetArrayFromObject",
		options: options,
		specification: {
			object: 		{type: "object",	required: 1}
		}
	})) return null;
	
	var object = options.object;
    var keys = Packages.Library.$.GetKeys({object: object});
	var array = [];
	for(var i = 0; i < keys.length; i++) {
		var key = keys[i];
		if(key.match(/\D/)) return null;
		array[key] = object[key];
	}
	
	return array;
};

/*******************************************************************************
 * GetPath - extracts the path from the filepath specified
 *
 * param - options : hash of options, must include:
 * 				filepath : entire file path Eg /a/b/c.txt
 *
 * returns the path Eg /a/b/ or null if failed
 ******************************************************************************/
Packages.Library.$.GetPath = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPath",
		options: options,
		specification: {
			filepath: 		{type: "string",	required: 1}
		}
	})) return null;

	if(options.filepath.match(/\//)) {
		return options.filepath.substr(0, options.filepath.lastIndexOf('/') + 1);
	} else {
		if(options.filepath.match(/\./)) {
			return ""; // No path
		} else {
			return options.filepath; // Assumed all path
		}
	}
};

/*********************************************************************
 * ReplaceReferencesWithObjectValues - replaces all reference markers with their value
 * from the specified object
 *
 * param - options : hash of options, must include:
 * 				text : text to do replacements in
 * 				object : object to look up in
 *
 * returns the updated text
 ********************************************************************/
Packages.Library.$.ReplaceReferencesWithObjectValues = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ReplaceReferencesWithObjectValues",
		options: options,
		specification: {
			text: 		{type: "string",	required: 1},
			object: 	{type: "object",	required: 1}
		}
	})) return null;
	
	var text = options.text;
	for(var item in options.object) {
		// Search for this item in text of the form
		//		<%item%>
		text = text.replace(new RegExp("<%" + item + "%>", "g"), options.object[item]);
	}
	return text;
};

/*******************************************************************************
 * PerformGlobalReplacements - asks any subscribers for matches in the current
 * content
 *
 * param - options : hash of options, must contain:
 * 			content : the content
 *
 * returns the replaced content
 ******************************************************************************/
Packages.Library.$.PerformGlobalReplacements = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.PerformGlobalReplacements",
		options: options,
		specification: {
			content: 		{type: "string,number",	required: 1}
		}
	})) return null;
	
	var content = options.content;
	
	if(content == null) return null;
	content += ""; // Force string
    
	var replacements = Packages.Library.$.EventFire({eventname: "GetGlobalReplacements", data: {}});
	
	for(var i = 0; i < replacements.length; i++) {
		var key = replacements[i].key;
		// Search for this item in text of the form
		//		<%item%>
		content = content.replace(new RegExp("<%" + key + "%>", "g"), replacements[i].value);
	}
	return content;
};

/*********************************************************************
 * GetChoiceFormsItemFromFolderOfChoices
 *
 * Returns a form item definition for a Choice Form
 *
 * The choice form is assembled from the folder of items that represent
 * each of the choices
 *
 * param - options : hash of options, must include:
 * 				choices : Packages.ContainerFolder for the choices
 * 				choiceId : the id for the choice form item
 * 				choiceName : name for the form item
 * 				choiceDescription: description for the form item
 * 
 * Returns the form def
 ********************************************************************/
Packages.Library.$.GetChoiceFormsItemFromFolderOfChoices = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetChoiceFormsItemFromFolderOfChoices",
		options: options,
		specification: {
			choices: 			{type: "object",	required: 1},
			choiceId: 			{type: "string",	required: 1},
			choiceName: 		{type: "string"},
			choiceDescription: 	{type: "string"}
		}
	})) return null;
	
	var choices = options.choices;
	var formdefs = [];
	
	// Generate each of the forms for the choice form	
	for(var choiceName in choices) {
		var choice = choices[choiceName];
		if(choice.GetChoiceForm == null) continue;
		
		var choiceItems = choice.GetChoiceForm();
		if(choiceItems == null) continue;
		
		var name = choiceName;
		if(choice.GetChoiceInfo != null) {
			var info = choice.GetChoiceInfo();
			name = info.name;
		}
		
		formdefs.push({
			ref: choiceName,
			name: name,
			getFormItems: choice.GetChoiceForm.bind(choice)
		});
	}
	
	return {
		type: "ChoiceForm",
		formdefs: formdefs,
		id: options.choiceId,
		name: options.choiceName,
		description: options.choiceDescription
	};
}

/*********************************************************************
 * GetMultiFormWithChoicesItemFromFolderOfChoices
 *
 * Returns a form item definition for a MultiForm
 *
 * The Multiform contains a choice form
 *
 * The choice form is assembled from the folder of items that represent
 * each of the choices
 *
 * param - options : hash of options, must include:
 * 				name : (optional) name to place on the form item
 * 				description : (optional) description for the form item
 * 				id : the id for the form item
 * 				choiceId : the id for the choice form item
 * 			other options, see GetChoiceFormsItemFromFolderOfChoices
 * Returns the form def
 ********************************************************************/
Packages.Library.$.GetMultiFormWithChoicesItemFromFolderOfChoices = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetMultiFormWithChoicesItemFromFolderOfChoices",
		options: options,
		specification: {
			name: 			{type: "string"},
			description: 	{type: "string"},
			id: 			{type: "string",	required: 1},
			choiceId: 		{type: "string",	required: 1}
		},
		optionsPassedTo: [
			Packages.Library.$.GetChoiceFormsItemFromFolderOfChoices
		]
	})) return null;
	
	return {
		name: options.name,
		description: options.description,
		type: "MultiForm",
		id: options.id,
		title: options.choiceId,
		fullWidth: 1,
		form: {
			type: "Form",
			idprefix: "multichoice",
			items: [
				Packages.Library.$.GetChoiceFormsItemFromFolderOfChoices(options)
			]
		}
	};
};

/*********************************************************************
 * GetMenuDataFromFolderOfMenuDefs - gets an array of menudata for CreateMenu
 *
 * param : options - hash of options, must contain:
 * 		defs : Packages.container containing defs
 * 			Eg, Packages.FileType.mhtm.EditBarButtons (for .Preview.$k)
 * 	may contain:
 * 		baseDef : options to apply to all defs (def overrides baseDef)
 *
 * returns menudata ready for CreateMenu
 ********************************************************************/
Packages.Library.$.GetMenuDataFromFolderOfMenuDefs = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetMenuDataFromFolderOfMenuDefs",
		options: options,
		specification: {
			defs: {type: "object", required: 1},
			baseDef: {type: "object"}
		}
	})) return null;
	
	var menudata = [];
	for(var key in options.defs) {
		if(key.match(/\$/)) continue;
		// Get Def
		var object = new options.defs[key].$k();
		var def = object.GetMenuDef();
		if(options.baseDef != null) {
			var baseDef = Packages.Library.$.Clone({oldObj: options.baseDef});
			Packages.Library.$.Merge({
				base: baseDef,
				extra: def
			});
			def = baseDef;
		}
		
		menudata.push(def);
	}
	
	return menudata;
}

/*********************************************************************
 * GetActiveVersions - gets an array of all active versions
 *
 * returns an array of "default" if that is the only one
 *
 * returns the array of active versions
 ********************************************************************/
Packages.Library.$.GetActiveVersions = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetActiveVersions",
		options: options,
		specification: {}
	})) return null;
	
	if(typeof(qVersions) == "undefined") return [];
	var versions = [];
	for(var i = 0; i < qVersions.length; i++) {
		if(qVersions[i].params.active == 1) versions.push(qVersions[i].params);
	}
	return versions;
};

/*********************************************************************
 * GetDefaultVersion - gets the refcode for the default version
 *
 * returns the refcode or null if no default
 ********************************************************************/
Packages.Library.$.GetDefaultVersion = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetDefaultVersion",
		options: options,
		specification: {}
	})) return null;
	
	var fallbackDefault = null;
	for(var i = 0; i < qVersions.length; i++) {
		if(qVersions[i].params.active == 1) {
			fallbackDefault = qVersions[i].params.refcode;
			if(qVersions[i].params.defaultVersion == 1) {
				return qVersions[i].params.refcode;
			}
		}
	}
	return fallbackDefault;
};

/*********************************************************************
 * GetVersionOfData - gets the currently selected version of the data
 * specified
 *
 * If the current version does not exist, the default version will be
 * used
 *
 * If the data is a string, will return the string
 *
 * param - options, hash of options, must contain:
 * 			data : the data to process (can be null)
 *
 * returns a version of the data
 ********************************************************************/
Packages.Library.$.GetVersionOfData = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetVersionOfData",
		options: options,
		specification: {
			data: 		{type: "object,string"}
		}
	})) return null;
	
	if(options.data == null) return null;
	if(typeof(options.data) == "string") return options.data;
	
	// Get currently selected version
	var currentVersion = Packages.Library.$.GetCookies({}).currentVersion;
	var defaultVersion = Packages.Library.$.GetDefaultVersion();
	if(currentVersion == null) currentVersion = defaultVersion;
	
	// Get content for version
	var content = options.data[currentVersion];
	if(content == null) content = options.data[defaultVersion];
	
	return content;
};

/*********************************************************************
 * CreatePrintPopup - creates a popup window with content, and shows
 * the print dialogue for it
 *
 * The library.css style sheet is applied
 *
 * param - options : hash of options, must contain:
 * 			content : the content to display in the window
 * 		may contain:
 * 			title : window title
 * 			links : additional style sheets to place in header
 * 			styles : additional inline styles for header
 ********************************************************************/
Packages.Library.$.CreatePrintPopup = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreatePrintPopup",
		options: options,
		specification: {
			content: {type: "string", required: 1},
			title: {type: "string"},
			links: {type: "array"},
			styles: {type: "string"}
		}
	})) return;
	
	if(Packages.Library.$v.testing == 1) return; // Do not run in test mode
	
	if(options.title == null) options.title = "Print";
	if(options.links == null) options.links = [];
	
	var links = "";
	options.links.unshift("/System/Software/JS/Libraries/Library.css");
	options.links.unshift("/System/Software/JS/Libraries/Luxury.css");
	foreach(options.links, function(link) {
		links += "<link rel='stylesheet' type='text/css' href=\"" + link + "\">";
	});
	
	var win = window.open("", "_blank", "location=no,menubar=no");
	
	var html = "";
	html += "<!DOCTYPE HTML>"
			+	"<html>"
				+	"<head>"
					+	"<title>" + options.title + "<\/title>"
					+	"<style>" + (options.styles != null ? options.styles : "") + "<\/style>"
					+	links
				+	"<\/head>"
				+	"<body>"
					+	options.content
				+	"<\/body>"
			+	"<\/html>";
	
	win.document.write(html);
	win.window.print();
};

/*********************************************************************
 * ForceString - forces a value into a string
 *
 * param - options : hash of options, must contain:
 * 			xValue : the value
 *
 * returns the forced string
 ********************************************************************/
Packages.Library.$.ForceString = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ForceString",
		options: options,
		specification: {
			xValue: 		{type: "number,string,boolean",	required: 1}
		}
	})) return null;
	
	if(typeof(options.xValue) == "string") return options.xValue;
	return options.xValue.toString();
};

/*********************************************************************
 * EscapeForRegExp - escapes the specified content for regexp
 *
 * param - options : hash of options, must contain
 * 			content : the content to escape
 *
 * returns the escaped version
 ********************************************************************/
Packages.Library.$.EscapeForRegExp = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EscapeForRegExp",
		options: options,
		specification: {
			content: {type: "string", required: 1}
		}
	})) return null;
	
	return options.content.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/\[/g, "\\)").replace(/\]/g, "\\)").replace(/\+/g, "\\+").replace(/\*/g, "\\*").replace(/\//g, "\\/").replace(/\^/g, "\\^").replace(/\$/g, "\\$").replace(/\?/g, "\\?").replace(/\!/g, "\\!");
};

/*********************************************************************
 * Replace - replaces the match with the replacement in content
 *
 * Does not use RegExp to allow any char
 *
 * param - options : hash of options, must contain
 * 			content : the content
 * 			search : match
 * 			replacement : replacement
 *
 * returns replaced content
 ********************************************************************/
Packages.Library.$.Replace = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Replace",
		options: options,
		specification: {
			content: {type: "string", required: 1},
			search: {type: "string", required: 1},
			replacement: {type: "string", required: 1}
		}
	})) return null;
	
	var content = options.content;
	var length = options.search.length;
	var start = content.indexOf(options.search);
	if(start != -1) {
		return content.substr(0, start) + options.replacement + content.substr(start + length);
	}
	
	return content; // Not found
};

/*********************************************************************
 * WasPageBuiltWithNode - determines whether the page was built using node.js
 *
 * returns 1 if built with node and 0 otherwise
 ********************************************************************/
Packages.Library.$.WasPageBuiltWithNode = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.WasPageBuiltWithNode",
		options: options,
		specification: {}
	})) return 0;
	
	if(Packages.Library.$c.IsNode == 1) return 0; // It is currently node!
	
	var nodeElem = document.getElementById('isnode');
	if(nodeElem != null) {
		return (nodeElem.innerHTML == 1 ? 1 : 0);
	}
	return 0;
};

/*********************************************************************
 * LiveEnhanceNode - finds elements marked as nodelive and enhances them
 ********************************************************************/
Packages.Library.$.LiveEnhanceNode = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.LiveEnhanceNode",
		options: options,
		specification: {}
	})) return;
	
	if(Packages.Library.$c.IsNode == 1) return; // It is currently node!
	if(Packages.Library.$.WasPageBuiltWithNode() == 0) return; // Wasn't made in node
	
	var elems = document.getElementsByClassName("nodelive");
	for(var i = 0; i < elems.length; i++) {
		var classname = elems[i].className;
		var classes = classname.split(/ /);
		if(!classname.match(/nodelive_([^ ]+)/)) continue; // No type
		var type = RegExp.$1;
		var properties = {};
		foreach(classes, function(c) {
			var props = c.split(/__/);
			properties[props[0]] = props[1];
		});
		Packages.Library.$.EventFire({eventname: "NodeLive", data: {
			classname: classname,
			elem: elems[i],
			type: type,
			properties: properties
		}});
	}
	
	return;
};

/*********************************************************************
 * NodeStoreData - converts the data into a string of class data extracted
 * by LiveEnhanceNode
 *
 * param - options : hash of options, must contain:
 * 		data : data to store
 * 		type : the type of data
 *
 * returns a string of classname data
 ********************************************************************/
Packages.Library.$.NodeStoreData = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.NodeStoreData",
		options: options,
		specification: {
			data: {type: "object", required: 1},
			type: {type: "string", required: 1}
		}
	})) return "";
	
	if(Packages.Library.$c.IsNode != 1) return ""; // It is not currently node!
	
	var data = options.data;
	
	var nodeLiveInfo = "nodelive nodelive_" + options.type;
	for(var key in data) {
		var val = data[key];
		if(typeof(val) != "string" && typeof(val) != "number") continue;
		nodeLiveInfo += " " + key + "__" + val;
	}
	
	return nodeLiveInfo;
};

/*********************************************************************
 * GetNodeJSWarning - fetches a node JS warning (only if in Node mode)
 *
 * returns a warning if node, or "" otherwise
 ********************************************************************/
Packages.Library.$.GetNodeJSWarning = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetNodeJSWarning",
		options: options,
		specification: {}
	})) return null;
	
	if(Packages.Library.$c.IsNode != 1) return ""; // It is not currently node!
	
	return "<b>Warning<\/b> - JavaScript disabled" + Packages.Library.$.MakeHelp({help:
				"<p>This content requires JavaScript to be enabled in the browser<\/p>"
			+	"<p>Without JavaScript, a preview of the content will appear, but it will not be interactive<\/p>"
			});
};

/*********************************************************************
* GetClassesOptions - gets an array of available classes in the correct format
* to display in as radio buttons / selectbox / options in a form
*
* returns array of classes hashes, each of the form:
* 		name : name to display, wrapped in CSS to give correct appearance
* 		value : CSS font name
********************************************************************/
Packages.Library.$.GetClassesOptions = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetClassesOptions",
		options: options,
		specification: {}
	})) return null;
	
	for(var i = 0; i < Packages.Library.$c.Classes.length; i++) {
		var option = Packages.Library.$c.Classes[i];
		option.formattedName = "<span class='" + option.value + "'>" + option.name + "<\/span>";
	}
	return Packages.Library.$c.Classes;
};

/*********************************************************************
 * GetUniqueId - gets the next available unique id
 *
 * returns a unique string of the form uniqueid_49
 ********************************************************************/
Packages.Library.$.GetUniqueId = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetUniqueId",
		options: options,
		specification: {}
	})) return null;
	
	Packages.Library.$v.UniqueId ++;
	
	return "uniqueid_" + Packages.Library.$v.UniqueId;
};

Packages.Library.$o.General = {};
Packages.Library.$v.Mouse = {x: 0, y: 0};
Packages.Library.$v.UniqueId = 0;
Packages.Library.$v.LoggedErrors = [];
Packages.Library.$v.TestLocks = {};
Packages.Library.$c.Classes = [
	{name: "Button", value: "mbutton", description: "'mbutton' - will make this item appear as a standard button"},
	{name: "Button 2015", value: "mbutton15", description: "'mbutton15' - will make this item appear as a 2015 styled button"},
	{name: "No user select", value: "nouserselect", description: "'nouserselect' - will make this item non selectable by the user"},
	{name: "Clear Link Formatting", value: "clearlink", description: "'clearlink' - will remove the default link styles for 'a' tags"},
	{name: "Responsive Hide Always", value: "mresphide", description: "'mresphide' - this will always be hidden on screen sizes smaller than full size"},
	{name: "Responsive Hide Mobile", value: "mresphidemobile", description: "'mresphidemobile' - this will be hidden on mobile phones"}
];Package("Library").HTML = function() {};

/*********************************************************************
* CreateFoldArea - Creates a folding area, the title becomes the toggle button
* which decides whether the area beneath is shown or not
*
* (foldedn, n used as different variable name)
*
* param - options : optional hash of options, must contain:
* 				content : the content
* 			May contain:
* 				foldable : whether this content is foldable (if not, just returns the title followed by content)
* 				folded : 1 if starts folded, 0 to start unfolded
* 				title : the title
* 				noArrow : 1 do not display any arrows
* 				border : 0 (default) no border, otherwise border thickness
* 				direction : 0 (default) horizontal, 1 vertical
* 				foldid : id of this item, if this id already exists - will load the folded state
* 				classname : class to place on container
* 				groupName : a group name for the folded area, when used only one item in the group may be expanded
*
* returns the HTML markup
********************************************************************/
Packages.Library.$.CreateFoldArea = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateFoldArea",
		options: options,
		specification: {
			title: {type: "string"},
			noArrow: {type: "boolean"},
			content: {type: "string", required: 1},
			foldable: {type: "number,boolean"},
			folded: {type: "number,boolean"},
			border: {type: "number"},
			direction: {type: "number"},
			foldid: {type: "string"},
			classname: {type: "string"},
			groupName: {type: "string"}
		}
	})) return 0;
	
	if (options.foldable == null) options.foldable = 0;
	if(options.title == null) options.title = "";
	
	if(options.foldable == 0) {
		// Not foldable
		return options.title + options.content;
	}
	
	if (options.folded == null) options.folded = 0;
	if (options.direction == null) options.direction = 0;
	if(options.foldid == null) options.foldid = "foldedarea_" + Packages.Library.$.GetUniqueId();
	
	// Load former state - if already open and being refreshed
	var elem;
	if(Packages.Library.$c.IsNode != 1) elem = document.getElementById(options.foldid);
	if(elem != null) {
		// Exists
		options.folded = (elem.checked ? 0 : 1);
	}
	var html = "<input "
				+	"type='" + (options.groupName != null ? "radio" : "checkbox") + "' "
				+	(options.groupName != null ? "name='" + options.groupName + "' " : "")
				+	"style='display:none' "
				+	"class='foldableinput' "
				+	"id='" + options.foldid + "' "
				+	(options.folded == 0 ? "checked='checked' " : "")
			+	">";
	var arrowstyles = "";
	
	/* The Vertical version does not work, and requires a revisit to get this working */
	options.direction = 0;
	
	if(options.direction == 0) {
		// Horizontal bar
		arrowstyles += "height:16px;";
		html += "<label class='foldablepaneltitle' for='" + options.foldid + "'>"
				+	options.title
				+	(options.noArrow != 1 ? "<span class='foldablepanelopen styledarrowcontainer'><span class='styledarrow'>v<\/span><\/span>" : "")
			+	"<\/label>"
			+	"<span class='foldablepanelarea'>"
				+	options.content
				+	(options.groupName == null && options.noArrow != 1?
						"<label class='foldablepanelclose styledarrowcontainer' style='" + arrowstyles + "' for='" + options.foldid + "'>"
						+	"<span class='styledarrow'>^<\/span>"
					+	"<\/label>"
						: ""
					)
			+	"<\/span>";
	} else {
		// Vertical Bar
		arrowstyles += "height:100%;width:20px;";
		html += "<table><tr>";
		html += "<td><div class='styledarrowcontainer' id='foldor" + options.foldid + "' style='" + arrowstyles + "' " + onclick + "><span class='styledarrow'>&gt;<\/span><\/div><\/td>";
		html += "<td class='foldablepanelarea" + folded + "' id='foldarea" + options.foldid + "'>";
		html += options.content;
		html += "<\/td>";
		html += "<td class='styledarrowcontainer' id='foldhr" + options.foldid + "' style='" + arrowstyles + ( options.folded == 0 ? "display:none'" : "") + "><a " + onclick + "><span class='styledarrow'>&lt;<\/span><\/a><\/td>";
		html += "<td><div style='width:20px;overflow-x:hidden;'><div style='width:200px;height:200px;' class='deg90'  " + onclick + ">";
		html += "<div class='foldablepaneltitle" + folded + "' id='foldtitle" + options.foldid + "' style='width:100%,height:20px;padding-top:180px;margin-left:0px;'>" + options.title + "<\/div>";
		html += "<\/div><\/div><\/td>";
		html += "<\/tr><\/table>"
	}
	
	// Using border?
	if(options.border == null) options.border = 0;
	
	html = "<span " +
				"class='foldablepanelborder" + (options.classname != null ? " " + options.classname : "") + "' " +
				"style='border:" + options.border + "px solid black;'" +
			">" +
				html +
			"<\/span>";
	
	return html;
};

/*********************************************************************
* DisplayBriefMessage - displays a message briefly, and hides after a delay
*
* param - options : hash of options
* 			must contain:
* 				mesg : the message
* 			may optionally contain:
* 				delay : in seconds before it hides, default 5 seconds
********************************************************************/
Packages.Library.$.DisplayBriefMessage = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.DisplayBriefMessage",
		options: options,
		specification: {
			mesg: {type: "string", required: 1},
			delay: {type: "number", min: 0, max: 30}
		}
	})) return;
	
	if(options.delay == null) options.delay = 5;
	
	var briefMessage = document.createElement('div');
	briefMessage.innerHTML = options.mesg;
	briefMessage.className = "brief_message";
	var id = "briefmessage" + Packages.Library.$.GetUniqueId();
	briefMessage.id = id;
	briefMessage.onclick = function() {
		var briefMessage = document.getElementById(id);
		if(briefMessage) document.body.removeChild(briefMessage);
	}
	document.body.appendChild(briefMessage);
	
	setTimeout(function() {
		var briefMessage = document.getElementById(id);
		if(briefMessage != null) {
			briefMessage.className = "brief_message brief_message_close";
			setTimeout(function() {
				var briefMessage = document.getElementById(id);
				if(briefMessage != null) document.body.removeChild(briefMessage);
			}, 5000);
		}
	}, options.delay * 1000)
}

/*********************************************************************
* CreateMaskLayer - Creates a pop up mask layer
*
* param - options : hash of options
* 			must contain:
* 				content: the html content to show inside the mask
* 			may contain:
* 				opacity : the opacity, (default 0.6)
*
* returns a hash of control code, including a close function to close
* the mask. Call .Close()
********************************************************************/
Packages.Library.$.CreateMaskLayer = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateMaskLayer",
		options: options,
		specification: {
			content: {type: "string", required: 1}
		}
	})) return null;
	
	// Don't do this in node
	if(Packages.Library.$c.IsNode == 1) return {Close: function() {}};
	
	var divid = "mask_" + Packages.Library.$.GetUniqueId();

	var mask = {
		Close: function() {
			var elem = document.getElementById(divid);
			if(elem) document.body.removeChild(elem);
		}
	};
	
	var html = options.content;
	
	// Create the hidden pop up position area
	html = "<div " +
				"class='popup_content_position mask_content' " +
				"id='" + divid + "_item' " +
			">" +
				html +
			"<\/div>";
			
	// Create the background misty area
	html = "<div " +
				"class='popup_background_area' " +
			"><\/div>" +
			html;

	// Create the hidden container
	html = "<div " +
				"class='popup_container popup_container_open mask_container' " +
				"id='" + divid + "_container' " +
				(options.opacity != null ? "style='opacity:" + options.opacity + "'" : "") +
			">" +
				html +
			"<\/div>";
	
	var maskElem = document.createElement('div');
	maskElem.id = divid;
	maskElem.innerHTML = html;
	document.body.appendChild(maskElem);
	
	if(Packages.Library.$v.testing == 1) {
		// Do a clean up
		mask.Close();
	}
	
	return mask;
}

/*********************************************************************
* CreatePopupArea - Creates a popup area, the title becomes the pop up button
*
* param - options : hash of options
* 			must contain:
* 				content: the html content to show
* 			may optionally contain:
* 				buttonText : the pop up button title
* 				noButtonStyle : 1 disable title styles, 0 (default) use
* 				close : the close button text
* 				instant : 1 open instantly, 0 (default) don't
* 				onclose : method to call on close
* 				title : title to display at the top
* 				interactive : 1 the popup will be movable, and allow background items to be clicked
* 				popupNarrow : 1 display a narrow pop up, 0 (default) display at 80% width
* 				maxWidth : max width of popup, overrides popupNarrow, must include px or % suffix
*
* returns the HTML markup
********************************************************************/
Packages.Library.$.CreatePopupArea = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreatePopupArea",
		options: options,
		specification: {
			content: {type: "string", required: 1},
			buttonText: {type: "string"},
			noButtonStyle: {type: "number"},
			close: {type: "string"},
			instant: {type: "number"},
			onclose: {type: "function"},
			title: {type: "string"},
			interactive: {type: "number"},
			popupNarrow: {type: "number"},
			maxWidth: {type: "string"}
		}
	})) return null;
	
	var divid = "popup_" + Packages.Library.$.GetUniqueId();
	var textvar = GetTextRef(options);
	if(options.buttonText == null) options.buttonText = "Pop up";
	if(options.title != null) {
		options.title = "<h2 "
							+ "class='popup_title' "
							+ Packages.Library.$.MakeElemMovable({elemid: divid + "_item"}) + " "
						+ ">"
							+ options.title
						+ "</h2>";
	} else {
		options.title = "";
	}
	if(options.close == null) options.close = "X";
	
	// Add content
	var html = options.title + options.content;
	
	// Create the actual pop up area
	html = "<div " +
				"class='popup_content_area' " +
			">" +
				html +
			"<\/div>";
	
	// Create an area wrapper with borders
	html = "<div " +
				"class='popup_content_border' " +
			">" +
				html +
			"<\/div>";
	
	// Add the close button
	html += "<div " +
				"class='popup_close_button mbutton' " +
				"onclick=\"" +
					"var elem = document.getElementById('" + divid + "'); if(elem) {elem.className = 'popup_container';}" +
					(options.onclose != null ? textvar + ".onclose();" : "") +
				"\"" +
			">" +
				options.close +
			"<\/div>";
	
	if(options.interactive == 1) {
		// Force content to hug bottom
		html = "<div " +
					"class='popup_interactive" + (options.popupNarrow == 1 ? " popup_narrow" : "") + "' " +
					"id='" + divid + "_item' " +
					"style='" + (options.maxWidth != null ? "max-width:" + options.maxWidth : "") + "' " +
				">" +
					html +
				"<\/div>";
	} else {
		// Create the hidden pop up position area
		html = "<div " +
					"class='popup_content_position' " +
					"id='" + divid + "_item' " +
					"style='" + (options.maxWidth != null ? "max-width:" + options.maxWidth : "") + "' " +
				">" +
					html +
				"<\/div>";
				
		// Create the background misty area
		html = "<div " +
					"class='popup_background_area' " +
				"><\/div>" +
				html;
	
		// Create the hidden container
		html = "<div " +
					"class='popup_container" + (options.instant == 1 ? " popup_container_open" : "") + "' " +
					"id='" + divid + "' " +
				">" +
					html +
				"<\/div>";
	}
	
	if(options.instant != 1) {
		// Create pop up action button
		html += "<div " +
					"class='popup_open_button" + (options.noButtonStyle != 1 ? " mbutton" : "") + "' " +
					"onclick=\"var elem = document.getElementById('" + divid + "'); if(elem) {elem.className = 'popup_container popup_container_open';}\" " +
				">" +
					options.buttonText +
				"<\/div>";
	}
	
	
	return html;
};

/*********************************************************************
 * CreatePopupQuery - creates a popup query box, with a variety of buttons
 *
 * param - options : hash of options, may contain:
 * 			title : popup title
 * 			message : popup message
 * 			wrapMessage : 1 (default) wrap message with P tags, 0 don't
 * 			buttons : hash of buttons, in the following format
 * 				<key> : <text to display>
 * 				null : defaults to [OK]
 * 				{} : will display no buttons
 * 			callback : function to execute passing in the key of the button pressed
 * 						or 'CLOSE' if the close button was pressed
 * 						Callback can return 0 to prevent closure
 * 		Other options as for CreatePopupArea
 ********************************************************************/
Packages.Library.$.CreatePopupQuery = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreatePopupQuery",
		options: options,
		specification: {
			title: {type: "string"},
			message: {type: "string"},
			wrapMessage: {type: "number"},
			buttons: {type: "object"},
			callback: {type: "function"}
		}
	})) return;
	
	// Set defaults
	if(options.message == null) options.message = "";
	if(options.buttons == null) options.buttons = {OK: "OK"};
	
	if(options.wrapMessage != 0) options.message = "<p>" + options.message.replace(/\n/g, "<\/p><p>") + "<\/p>";
	
	var body = document.getElementsByTagName('body')[0];
	
	var callback = function(key) {
		if(key == null) key = "CLOSE";
		var res = 1;
		if(options.callback != null) res = options.callback(key);
		if(res == 0) return; // Do not close
		
		// Remove element
		if(popupElem.parentNode == body) body.removeChild(popupElem);
	}
	
	var textCallBack = GetTextRef(callback);
	var buttons = "";
	for(var button in options.buttons) {
		buttons += "<button " +
					"onclick=\"" + textCallBack + "('" + button + "')\" " +
					"class='querybutton' " +
				   ">" +
					options.buttons[button] +
				   "</button>"
	}
	if(buttons != "") buttons = "<hr><div class='querybuttoncontainer'>" + buttons + "<\/div>";
	
	options.content = "<div class='querymessagecontainer'>"
					+	options.message
					+ "</div>"
					+ buttons;
	options.onclose = callback;
	options.instant = 1;
	
	if(Packages.Library.$v.testing == 1) return;
	
	var html = Packages.Library.$.CreatePopupArea(options);
	
	var popupElem = document.createElement('div');
	popupElem.innerHTML = html;
	body.appendChild(popupElem);
};

/*********************************************************************
* CreateSpecTable - creates a simple spec table
*
* param - options : hash of options, must contain:
* 			data : the object containing data
* 			fields : array of defs to display, of the form:
* 				key : key in the data to display
* 				label : label to display
*
* returns the HTML markup for this spec table
********************************************************************/
Packages.Library.$.CreateSpecTable = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateSpecTable",
		options: options,
		specification: {
			data: {type: "object", required: 1},
			fields: {type: "array", required: 1}
		}
	})) return "";
	
	var html = "";
	
	foreach(options.fields, function(field) {
		html += "<tr><td class='mspectable_label'>"
				+	field.label
			+	"</td><td class='mspectable_value'>"
				+	options.data[field.key]
			+	"</td></tr>";
	});
	
	html = "<table class='mspectable'>" + html + "</table>";
	
	return html;
};

/*********************************************************************
* MakeHelp - Creates a help icon bubble containing the specified help text
*
* When hovered over, the icon enlarges to display a help bubble
*
* param - options : hash of options, must contain:
* 			help : text to display on hover (may be HTML)
* 		may contain:
* 			title : title to display above help
*
* returns the HTML markup for this icon or "" if the helpText was null
********************************************************************/
Packages.Library.$.MakeHelp = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeHelp",
		options: options,
		specification: {
			help: {type: "string", required: 1},
			title: {type: "string"}
		}
	})) return "";
	
	var helpText = options.help;
	var title = options.title;
	
	if(helpText == null) return "";
	var html = "";
	
	var helpDocId = Packages.Library.$.GetUniqueId({});
	
	// Replace shortcuts in helptext
	helpText = Packages.Library.$.ShortcutText({content: helpText});
	
	// Create help button as hover trigger for help doc, and label-for helpdoc toggle checkbox
	html += "<label class='helpbutton' for='helpdoc_" + helpDocId + "'> ? <\/label>";
	
	// Create help button toggle checkbox, when checked the CSS forces the helpdoc to go full screen
	html += "<input type='checkbox' class='helpbuttontoggle' id='helpdoc_" + helpDocId + "'>";
	
	// Create the help doc, also a label-for the checkbox, when clicked will uncheck and disable full screen
	html += "<label class='helpdoc' for='helpdoc_" + helpDocId + "'>" + (title != null ? "<h3>" + title + "<\/h3><hr>" : "") + helpText.replace(/\n/g, "<br><br>") + "<\/label>";
	
	// Finally wrap it in a span to keep it together
	html = "<span class='helpcontainer'>" + html + "<\/span>";
	
	return html;
};

/*********************************************************************
* GetLoaderImg - gets the image that displays a loading icon
********************************************************************/
Packages.Library.$.GetLoaderImg = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetLoaderImg",
		options: options,
		specification: {}
	})) return "";
	
	return "<img src='/System/Software/HTML/loading.gif?req-plain=1' style='width:64px' alt='Loading'/>";
};

/*************************************************************************************************
* ListPlugIns - Creates a list of plugins from the folder listing
*
* If a package is found that matches the plugin, it loads the name and description
*
* Callback(type) returns nothing
*
* param - options : hash of options, must contain:
* 			packageContainer : the package container
* 			callbackString : (string to execute) callback subroutine to callback when an item is clicked
* 			noCategory : the name to give a category of items with no name, Eg Misc
* 		may include:
* 			dragType : (optional) makes the item dragable, and applies this as the type
* 			dragCallback : (if using drag and drop) the callback when a drag occurs
*
* returns the html markup to create this list or null if an error occured
************************************************************************************************/
Packages.Library.$.ListPlugIns = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ListPlugIns",
		options: options,
		specification: {
			packageContainer: {type: "object", required: 1},
			callbackString: {type: "string", required: 1},
			noCategory: {type: "string", required: 1},
			dragType: {type: "string"},
			dragCallback: {type: "function"}
		}
	})) return null;
	
	var packageContainer = options.packageContainer;
	var callback = options.callbackString;
	var noCategory = options.noCategory;
	var dragType = options.dragType;
	var dragCallback = options.dragCallback;
	
	var html = "";
	html += "<div class = 'pluginlist'>";
	var plugins = [];
	for(var type in packageContainer) {
		if(type.match(/^\$/)) continue;
		var details = GetPackageClassDetails(packageContainer[type]);
		
		if(details == null) continue;
		
		// Fill in missing details
		if(details.category == null) details.category = noCategory;
		
		var div = "<div class='pluginitem mColLSilver mColVLSilverHover' onClick=\""+callback+"('"+type+"')\">" + Packages.Library.$.MakeHelp({help: details.description}) + "<div class='pluginname'>" + details.name + "<\/div><\/div>";
		
		if(dragType != null) {
			div = Packages.Library.$.CreateDragAndDropItem({
				item: {
					type: dragType
				},
				data: {
					type: type
				},
				typeCheck: 0,
				itemCallback: dragCallback,
				html: div,
				adjustDOM: 0,
				adjustArray: 0
			});
		}
			
		if(Packages.Library.$.IsPermission({permission: details.permission})) plugins.push({category: details.category, div: div});
	}
	//sort array by category
	for(var i=0;i<plugins.length;i++) {
		for(var j=i+1;j<plugins.length;j++) {
			if(plugins[i].category == plugins[j].category) {
				var x = plugins[i+1];
				plugins[i+1] = plugins[j];
				plugins[j] = x;
				//array.push(array.splice(i+1,1));
			}
		}
	}
	var category = "";
	for(var i=0;i<plugins.length;i++) {
		if(!plugins[i].category.match(/^[!?*]/)) {
			if(plugins[i].category != category) html += "<h3>" + plugins[i].category + "<\/h3>";
			html += plugins[i].div;
			category = plugins[i].category;
		}
	}
	html += "<\/div>";
	return html;
};

/*************************************************************************************************
* GetElemStyle - Gets the specified style property of the elem
*
* Looks in acting classes, and inline styles
*
* param - options : hash of options, must contain:
* 			elem : element to work on
* 			property : css property to obtain
*
* returns the value of this property or null if an error occured
************************************************************************************************/
Packages.Library.$.GetElemStyle = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetElemStyle",
		options: options,
		specification: {
			elem: {type: "DOMobject", required: 1},
			property: {type: "string", required: 1}
		}
	})) return null;
	
	var el = options.elem;
	var cssprop = options.property;
	
    var out = 0;
	if (el.currentStyle) //IE
		out= el.currentStyle[cssprop];
	else if (document.defaultView && document.defaultView.getComputedStyle) //Firefox
		out= document.defaultView.getComputedStyle(el, "")[cssprop];
	else //try and get inline style
		out= el.style[cssprop];
	if(out!=null) {
		if(out.match(/\dem$/)) {
			return out.substr(0,out.indexOf('em'));
		}
		if(out.match(/\dpx$/)) {
			return out.substr(0,out.indexOf('px'));
		}
	}
	return out;
};

/*************************************************************************************************
* GetElemPosition - Gets the position of the element specified
*
* From: http://stackoverflow.com/questions/5598743/finding-elements-position-relative-to-the-document
*
* param - options : hash of options, must contain:
* 			elem : element to work on
*
* returns a hash containing:
* 	x : the x coord
* 	y : the y coord
* Both including scrolls, from top of document
************************************************************************************************/
Packages.Library.$.GetElemPosition = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetElemStyle",
		options: options,
		specification: {
			elem: {type: "DOMobject", required: 1}
		}
	})) return null;
	
	var elem = options.elem;
	
    var box = elem.getBoundingClientRect();

    var body = document.body;
    var docEl = document.documentElement;

    var scrollTop = window.pageYOffset || docEl.scrollTop || body.scrollTop;
    var scrollLeft = window.pageXOffset || docEl.scrollLeft || body.scrollLeft;

    var clientTop = docEl.clientTop || body.clientTop || 0;
    var clientLeft = docEl.clientLeft || body.clientLeft || 0;

    var top  = box.top +  scrollTop - clientTop;
    var left = box.left + scrollLeft - clientLeft;

    return { x: Math.round(left), y: Math.round(top) };
}

/*********************************************************************
* SubmitForm - Submits the form specified by elemid
*
* param - options : hash of options, must contain:
* 			formid : the form elem id
* 		may contain:
* 			doc : (optional) doc, otherwise uses document
********************************************************************/
Packages.Library.$.SubmitForm = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SubmitForm",
		options: options,
		specification: {
			formid: {type: "string", required: 1},
			doc: {type: "DOMobject"}
		}
	})) return;
	
	var doc = options.doc;
	var elemid = options.formid;
	
	if(doc == null) doc = document;
	var elem = doc.getElementById(elemid);
	if(elem == null) return;
    if (elem.onsubmit()) {
        elem.submit();
    }
};

/*******************************************************************************
 * AppendHTMLToElement - appends the specified HTML to the element specified by
 * id
 *
 * CAUTION: The elements current content is converted to HTML in this process
 * loosing all bound handles (such as onclick registered with JS)
 *
 * param - options: hash of options, must contain:
 * 			elemid : the element id
 * 			html : html to append
 ******************************************************************************/
Packages.Library.$.AppendHTMLToElement = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.AppendHTMLToElement",
		options: options,
		specification: {
			elemid: {type: "string", required: 1},
			html: {type: "string", required: 1}
		}
	})) return;
	
	var elem = document.getElementById(options.elemid);
	if(elem == null) return;
	var currenthtml = elem.innerHTML;
	elem.innerHTML = currenthtml + options.html;
};

/********************************************************************
 * ButtonList - Make a list of radio buttons for the descriptions givens
 *
 * param - options : hash of options, must contain:
 * 			descs : array of hash descriptions for the buttons of the type:
 *            	id : unique id for this item - sent to callback
 *            	text : user facing text name
 *            	help : help to display in a MakeHelp
 *            	callback : callback (string) sub to be executed when clicked
 *            		(will send id as a param if there is no ')' suffix)
 *            	disabled : 1 show disabled, 0 (default) enabled
 *             may contain:
 *            	classname : classname to add to element
 *            	useMButton15 : 1 use mbutton15 styles, 0 (default) don't
 *            	useMButton15a: 1 use mbutton15a styles, 0 (default) don't
 *      may contain:
 *          showRadio : 1 show the radio buttons, 0 hide
 *
 * Returns the HTML for these buttons
 *******************************************************************/
Packages.Library.$.ButtonList = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ButtonList",
		options: options,
		specification: {
			descs: {type: "array", required: 1},
			showRadio: {type: "boolean"},
			classname: {type: "string"},
			useMButton15: {type: "boolean"},
			useMButton15a: {type: "boolean"}
		}
	})) return null;
	
	var descs = options.descs;
    var localcode = Packages.Library.$.GetUniqueId({});
    var html = "";
    for(var i = 0; i < descs.length; i++) {
        var desc = descs[i];
		var classes = "";
		if(desc.disabled == 1) classes += " mbutton_disabled"
        if(options.useMButton15a) {
			classes += " mbutton15a";
			if(desc.disabled == 1) classes += " mbutton15a_disabled"
		} else if(options.useMButton15) {
			classes += " mbutton15";
		} else {
			classes += " mbutton selector_item_legacy";
		}
		html += "<span "
				+	"class='selector_item " + classes + (desc.classname != null ? " " + desc.classname : "") + "' "
				+	"onclick=\"document.getElementById('" + localcode + desc.id + "').checked = true;" + desc.callback + (desc.callback.match(/\)$/) ? "" : "('" + desc.id + "')" ) + "\" "
			+">";
        if(desc.help != null) html += Packages.Library.$.MakeHelp({help: desc.help});
        html += "<input "
				+	"type='radio' "
				+	"style='" + (options.showRadio == 1 ? "" : "display:none;") + "' "
				+	"name='" + localcode + "' "
				+	"id='" + localcode + desc.id + "' "
				+	"onclick=\"" + desc.callback + "('" + desc.id + "')\" "
				+	(desc.disabled == 1 ? "disabled='disabled' " : "")
			+	"/>"
				+ desc.text
			+ "</span>";
    }
    return html;
};

/*******************************************************************************
 * BuildCheckbox - returns the html markup for a checkbox
 *
 * param - options : hash of options, must contain
 * 			elemid : the id of the checkbox
 * 		may contain:
 * 			checked : 1 checked, 0 (default) unchecked
 *
 * return- html : the markup for the checkbox or null if an error occured
 ******************************************************************************/
Packages.Library.$.BuildCheckbox = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.BuildCheckbox",
		options: options,
		specification: {
			elemid: {type: "string", required: 1},
			html: {type: "string", required: 1}
		}
	})) return null;
	
    return "<input type='checkbox' id='" + options.elemid + "'" + (options.checked == 1 ? " checked" : "") + ">";
};

/*******************************************************************************
 * GetCheckboxState - gets the value of a checkbox
 *
 * param - options : hash of options, must include:
 * 			elemid : the id of the checkbox
 * 		may include:
 * 			output : text to be returned only if checked, otherwise ""
 *
 * return- 1 if checked, or 0 if not checked or not found (or output text)
 ******************************************************************************/
Packages.Library.$.GetCheckboxState = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetCheckboxState",
		options: options,
		specification: {
			elemid: {type: "string", required: 1},
			output: {type: "string"}
		}
	})) return null;
	
    var elem = document.getElementById(options.elemid);
	// Determine if checked
	var checked = 0;
    if(elem != null) checked = elem.checked ? 1 : 0;
	// Decide output type
	if(options.output == null) return checked;
	if(checked == 1) return output;
	return "";
};

/*********************************************************************
 * MakeButton - creates the HTML for a button
 *
 * param - options : hash of options, may contain
 * 		imagepath : image path
 * 		text : text to display on button
 * 		width  : width  of button, default 64px
 * 		height : height of button, default 64px
 * 		tag : tag to surround text in, default 'div'
 * 		horizalign : either left / center / right (default center)
 * 		vertalign : either top / middle / bottom (default middle)
 * 		classname : classname to give button
 * 		button : 1 (default) display as a button, 0 do not apply button styles
 * 		styles : extra styles to apply to container
 * 		textstyles : extra styles to apply to text
 * 		textContainerStyles : extra style for the text container
 * 		imgstyles : extra styles to apply to images
 * 		onclick : onclick string to put into container
 * 		onmouseover : onmouseover string to put into container
 * 		onmouseout : onmouseout string to put into container
 * 		disabled: 1 disabled, 0 not (default not)
 * 		id: id for the element containing the onclick
 * 		conditions: conditions this button should be displayed for
 * 		conditionObject: object to load conditions values from
 *
 * returns the html for this button
 ********************************************************************/
Packages.Library.$.MakeButton = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeButton",
		options: options,
		specification: {
			imagepath: {type: "string"},
			text: {type: "string"},
			width: {type: "string"},
			height: {type: "string"},
			tag: {type: "string"},
			horizalign: {type: "string"},
			vertalign: {type: "string"},
			classname: {type: "string"},
			styles: {type: "string"},
			textstyles: {type: "string"},
			textContainerStyles: {type: "string"},
			imgstyles: {type: "string"},
			onclick: {type: "string"},
			onmouseover: {type: "string"},
			onmouseout: {type: "string"},
			disabled: {type: "number"},
			id: {type: "string"},
			conditions: {type: "array"},
			conditionObject: {type: "object"}
		}
	})) return null;
	
	if(options.text == null) options.text = "";
	if(options.tag == null) options.tag = "div";
	if(options.width == null) options.width = "64px";
	if(options.height == null) options.height = "64px";
	if(options.horizalign == null) options.horizalign = "center";
	if(options.vertalign == null) options.vertalign = "middle";
	if(options.classname == null) options.classname = "";
	if(options.styles == null) options.styles = "";
	if(options.textstyles == null) options.textstyles = "";
	if(options.textContainerStyles == null) options.textContainerStyles = "";
	if(options.imgstyles == null) options.imgstyles = "";
	if(options.onclick		== null) { options.onclick 		= ""; }
	if(options.onmouseover 	== null) { options.onmouseover 	= ""; }
	if(options.onmouseout 	== null) { options.onmouseout 	= ""; }
	if(options.disabled == null) options.disabled = 0;
	
	if(options.conditions != null && options.conditionObject != null) {
		// Test conditions
		if(options.conditions != null) {
			if(!Packages.Library.$.EvaluateComplexCondition({
				data: options.conditionObject,
				conditions: options.conditions
			})) return null;
		}
	}
	
	// Create container
	var classes = "mbutton_container ";
	classes += options.classname + " ";
	if(options.button != 0) classes += "mbutton";
	var html = "<div class='" + classes + "' " +
					"onclick=\"" + options.onclick + "\"" +
					"onmouseover=\"" + options.onmouseover + "\"" +
					"onmouseout=\"" + options.onmouseout + "\"" +
				"style=\"";
	html += 		options.styles;
	html +=     	"text-align:" + options.horizalign + ";" +
					"vertical-align:" + options.vertalign + ";" +
					"width:" + options.width + ";" +
					"height:" + options.height + ";" +
					"display: inline-block;" +
				"\" ";
	if(options.id != null) html += 	"id='" + options.id + "'";
	html +=	">";
	
	// Add background image
	if(options.imagepath != null) {
		html += 	"<img src='" + options.imagepath + "' " +
						"style='width: 100%;height:100%;position:relative;left:0px;" +
							options.imgstyles +
							(options.disabled == 1 ? "opacity:0.2;" : "") +
						"'" +
					">";
	}
	
	// Add text
	html += 	"<div class='mbutton_text' style='" + options.textContainerStyles +
						(options.vertalign == "bottom" ? "bottom:0px;position:absolute;" :
							(options.vertalign == "middle" ? "bottom:50%;margin:-10%;position:absolute;" :
								"top:0px;position:absolute;")) +
					"'>" +
					"<" + options.tag + " style='" + options.textstyles +
						"text-align:" + options.horizalign + ";" +
						"vertical-align:" + options.vertalign + ";" +
					"'>" + options.text + "<\/" + options.tag + ">";
	html += 	"<\/div>";
	html += "<\/div>";
	return html;
};
/*********************************************************************
 * CreateMenu - creates a HTML tiered menu, with multiple options to
 * customise the menu
 *
 * The menu data is an array of items, each of the form:
 * 	all optional:
 * 		name: text to display on the item, if not specified, a horizontal line is displayed
 * 		button: a button definition to use instead of the text
 * 		description: text to display in a help button on the item
 * 		img: src for an image to display rather than text
 * 		imgstyles : styles to add to image tag
 * 		onclick: method to execute when clicked (function)
 * 		ondblclick : method to execute when double clicked (function)
 * 		href: href for the item
 * 		hrefAddGlobals: 1 (default) add globals to href, 0 don't
 * 		target: target for href, eg "_blank"
 * 		disabled: 1 item is shown, but disabled, otherwise active
 * 		selected: whether this item is selected or not (1 selected, otherwise not)
 * 		classname: classname for this item
 * 		submenu: array of items of same form...
 * 		html: html to display in place of all of the above
 * 		order: an ordering number, if null, is treated as 0
 *
 * param - options : hash containing the following options
 * 		required:
 * 			menudata : see format above
 * 		optional:
 * 			horizontal : first menu tier is horizontal
 * 			leftopen : 1 open menus on the left, 0 (default) open on right
 * 			selectedclass : class to place on selected item
 * 			classes : array of classes used for each tier container UL
 * 			id : id to use for top level container UL
 * 			depth : internal counter of the tier (default 0)
 * 			hideSubMenus : 1 hide sub menus, 0 (default) show them
 * 			depthLimit : the maximum depth to go to, or null for all
 * 			disabled : 1 disable all items, 0 (default) enable
 * 			skipContainerUL : 1 do not wrap in container UL, 0 (default) wrap
 * 			disableStyles : disables all default provided styles
 * 			onclick : string or function to execute when clicked
 * 			dragAndDrop : parameters to make each menu item drag and dropable
 * 			manipulator : function called with all of the options just before
 * 				generating to allow for last moment changes:
 * 					passes in itemdata
 *
 * returns the html for this button or null on error
 ********************************************************************/
Packages.Library.$.CreateMenu = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateMenu",
		options: options,
		specification: {
			menudata: {type: "array", required: 1},
			horizontal: {type: "boolean"},
			selectedclass: {type: "string"},
			classes: {type: "array"},
			id: {type: "string"},
			depth: {type: "number"},
			hideSubMenus: {type: "boolean"},
			depthLimit: {type: "number"},
			disabled: {type: "boolean"},
			skipContainerUL: {type: "boolean"},
			disableStyles: {type: "boolean"},
			dragAndDrop: {type: "object"},
			manipulator: {type: "function"},
			conditionObject: {type: "object"}
		}
	})) return null;
	
	// Standardise options to defaults if null
	if(options.depth == null) options.depth = 0;
	if(options.classes == null) options.classes = [];
	if(options.depthLimit != null && options.depth > options.depthLimit) return "";
	
	// Get data from options, and initialise
	var menudata = options.menudata;
	
	// Do we need to sort?
	var needsSorting = 0;
	foreach(menudata, function(menuitem) {
		if(menuitem.order != null) needsSorting = 1;
	});
	if(needsSorting) {
		menudata.sort(function(a, b) {
			var ao = a.order != null ? a.order : 0;
			var bo = b.order != null ? b.order : 0;
			return ao - bo;
		});
	}
	
	var menuitemshtml = "";
	var textVar = GetTextRef(menudata);
	
	// Get all items - recursive
	for(var i = 0; i < menudata.length; i++) {
		var itemdata = menudata[i];
		
		if(options.manipulator != null) options.manipulator(itemdata);
		
		if(itemdata.html != null) {
			menuitemshtml += itemdata.html;
			continue; // Skip
		}
		
		if(itemdata.name == null && itemdata.img == null && itemdata.button == null) {
			// No text - horizontal line only
			menuitemshtml += "<hr>";
			continue; // Skip
		}
		
		// Skip submenus?
		if(itemdata.submenu != null && options.hideSubMenus == 1) continue;
		
		// Create menu item
		var menuitemhtml = "";
		if(itemdata.description != null) menuitemhtml += Packages.Library.$.MakeHelp({help: itemdata.description});
		
		// Display text or image
		if(itemdata.name != null) {
			menuitemhtml += itemdata.name;
		}
		if(itemdata.button != null) {
			if(itemdata.width == null) itemdata.width = itemdata.button.width;
			var buttonHtml = Packages.Library.$.MakeButton(itemdata.button);
			if(buttonHtml == null) {
				// Refused to create button, so skip
				continue;
			}
			menuitemhtml += buttonHtml;
		}
		if(itemdata.img != null) {
			menuitemhtml += "<img " +
								"style='" + (itemdata.imgstyles != null ? itemdata.imgstyles : "width:100%;display:block;") + "' " +
								"src='" + itemdata.img + "' " +
							">";
		}
		
		var href = itemdata.href;
		if(href != null && itemdata.hrefAddGlobals != 0) href = Packages.Library.$.AddGlobalQueries({url: href});
		
		// Add menu item to items and wrap in LI and A tags
		menuitemshtml += "<li";
		// Add options for LI
		var classname = "";
		if((itemdata.disabled == 1 || options.disabled == 1) && options.disableStyles != 1) classname += " menuitemdisabled";
		if(itemdata.selected == 1) {
			if(options.disableStyles != 1) classname += " menuitemselected"
			if(options.selectedclass != null) classname += " " + options.selectedclass;
		}
		// Add click events to LI as well as A tag if an item and not a menu container
		if(itemdata.disabled != 1 && options.disabled != 1) {
			if(itemdata.onclick != null) {
				if(typeof(itemdata.onclick) == "string") {
					menuitemshtml += " onclick=\"" + itemdata.onclick + "\"";
				} else {
					menuitemshtml += " onclick=\"return " + textVar + "[" + i + "].onclick()\"";
				}
			}
			if(itemdata.ondblclick != null) {
				menuitemshtml += " ondblclick=\"return " + textVar + "[" + i + "].ondblclick()\"";
			}
			if(href != null && itemdata.target == null && itemdata.submenu == null) menuitemshtml += " onclick=\"location.href='" + href + "'\"";
		}
		if(itemdata.classname != null) classname += " " + itemdata.classname;
		menuitemshtml += " class='" + classname + "'";
		menuitemshtml += " style='"
							+	(itemdata.width != null ? ("width:" + itemdata.width) : ";")
						+	"'"
		menuitemshtml += ">";
		
		var menuitematag = "<a";
		// Add options for A tag (if enabled)
		if(itemdata.disabled != 1 && options.disabled != 1) {
			// if(itemdata.onclick != null) menuitemshtml += " onclick=\"" + textVar + "[" + i + "].onclick()\"";
			if(href != null) menuitematag += " href='" + href + "'";
			if(itemdata.target != null) menuitematag += " target='" + itemdata.target + "'";
		}
		menuitematag += ">" + menuitemhtml + "<\/a>";
		
		if(options.dragAndDrop != null && itemdata.dragItem != null) {
			var dragAndDrop = Packages.Library.$.Clone({oldObj: options.dragAndDrop});
			dragAndDrop.html = menuitematag;
			dragAndDrop.item = itemdata.dragItem;
			menuitematag = Packages.Library.$.CreateDragAndDropItem(dragAndDrop);
		}
		
		menuitemshtml += menuitematag;
		
		// Are there any sub menus?
		if(itemdata.submenu != null && itemdata.submenu.length != 0) {
			// Add arrow marker
			var arrowhtml = (options.leftopen == 1 ? "&lsaquo;" : "&rsaquo;");
			if(options.depth == 0 && options.horizontal == 1) arrowhtml = "<span class='styledarrow_small'>v<\/span>";
			if(options.disableStyles != 1) menuitemshtml += "<div class='menuitemsubmenumarker'>" + arrowhtml + "<\/div>";
			
			// Store submenus in options, increment depth, and recurse
			options.menudata = itemdata.submenu;
			options.depth++;
			menuitemshtml += Packages.Library.$.CreateMenu(options);
			options.depth--;
		}
		
		menuitemshtml += "<\/li>";
	}
	
	// Wrap in UL with correct classes
	var classname = "";
	if(options.disableStyles != 1) {
		classname += "mclearfix menucontainer menucontainer" + options.depth + " ";
		if(options.depth == 0 && options.horizontal == 1) classname += "menucontainerhorizontal ";
		if(options.leftopen == 1) classname += "menucontainerleftopen ";
		if(options.block2and3 == 1 && options.depth == 0) classname += "menucontainerblock2and3 ";
	}
	if(options.classes[options.depth] != null) classname += options.classes[options.depth] + " ";
	
	var html = "";
	if(options.skipContainerUL == 1 && options.depth == 0) {
		// Skip outer UL on outer menu
		html = menuitemshtml;
	} else {
		html += "<ul ";
		html += 		"class='" + classname + "' ";
		if(options.id != null) html += 		"id='" + options.id + "' ";
		html += 	">";
		html += 	menuitemshtml;
		html += 	"<\/ul>";
	}
	
	if(options.skipContainerUL != 1 && options.depth == 0) {
		// Wrap entire outer container in a div, because we need to put a
		// clear:both at the end, and put the outer class on container.
		html = "<div class='" + classname + "' style='border:none;'>" +
				html +
				"<div style='clear:both'><\/div>" +
				"<\/div>";
	}
	
	return html;
};

/*************************************************************************************************
 * CreateMenuTreeFromFolderTree - Converts a nested folder listing into a menu nested array
 *
 * param - options : hash of options:
 * 		required:
 * 			folder : the folder listing array
 * 		optional:
 * 			firstItem : sorts and places an item maching this at the head of the list
 * 			defaultFile : file to use if empty folder is specified
 * 			skipList : array of items (filenames) to skip
 * 			path : prefix path for all items
 * 			specExt : hash of file extensions, value is hash of data, including (all optional)
 * 				onclick : onclick text, passes link and extension as arguments
 * 				classname : classname to place on LI
 * 				href : override href
 * 			onclick : an onclick to be applied to each item, replaces href
 * 		and as for Packages.Library.$.CreateMenu
 * 			except no menudata is required
 * 
 * returns the menu array list or null if an error occured
 ************************************************************************************************/
Packages.Library.$.CreateMenuTreeFromFolderTree = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateMenuTreeFromFolderTree",
		options: options,
		specification: {
			folder: {type: "array", required: 1},
			firstItem: {type: "string"},
			defaultFile: {type: "string"},
			skipList: {type: "array"},
			path: {type: "string"},
			specExt: {type: "object"},
			onclick: {type: "function"}
		}
	})) return null;
	
	// Set up defaults
	if(options.skipList == null) options.skipList = [];
	if(options.defaultFile == null) options.defaultFile = "Home.mhtm";
	if(options.specExt == null) options.specExt = {};
	if(options.path == null) options.path = "";
	
	var folder = options.folder;
	
	// Adjust the order so that options.firstItem comes first
	if(options.firstItem != null) {
		var i = 0;
		while(i < folder.length) {
			if(folder[i].name == options.firstItem) {
				var temp = folder[i];
				folder.splice(i, 1);
				folder.unshift(temp);
			}
			i++;
		}
	}
	
	// Get URL
	var currentURL = Packages.Library.$.GetPageURL({});
	// If xxxx/ replace with xxxx/Home.mhtm
	currentURL = currentURL.replace(/\/$/, "/" + options.defaultFile);
	// Remove query string
	currentURL = currentURL.replace(/\?(.*)$/, "");
	
	// Generate the menudata
	var menudata = [];
	
	for(var i = 0; i < folder.length; i++) {
        if(Packages.Library.$.Contains({array: options.skipList, item: folder[i].name})) continue;
		var fileentry = folder[i];
		var menuitem = {};
		
		// Store file entry in menuitem for other functions to manipulate
		menuitem.fileentry = fileentry;
		
		// Get filename, extension, and link
		var filename = fileentry.name;
		var link = Packages.Library.$.CleanURL({path: options.path + filename});
        var lastdot = filename.lastIndexOf(".");
		var tidyname = filename.replace(/_/g, " ");
		var extension = '';
		if(lastdot != -1) {
			tidyname = tidyname.substr(0, lastdot);
			extension = filename.substr(lastdot + 1);
		}
		
		// Store name
		menuitem.name = tidyname;
		
		if(fileentry.type == "file") {
			// For files only, add a link
			menuitem.href = link;
		}
		
		if(options.onclick != null) {
			// Use specified onclick
			menuitem.onclick = options.onclick;
			// Remove href
			menuitem.href = null;
		}
		
		// Get extension specific options
		var specext;
		if (extension != '') specext = options.specExt[extension];
		if(specext != null) {
			if(specext.onclick != null) {
				if(typeof(specext.onclick) == "function") {
					var scope = function(specext, link, extension) {
						menuitem.onclick = function() {
							specext.onclick(link, extension);
						};
					};
					scope(specext, link, extension);
				} else {
					menuitem.onclick = specext.onclick + "('" + link + "', '" + extension + "')";
				}
			}
			if(specext.classname != null) menuitem.classname = specext.classname;
			if(specext.href != null) menuitem.href = specext.href;
		}
		
		// Determine whether selected
		menuitem.selected = 0;
		if(currentURL != "" && link.match(new RegExp("^" + currentURL, "i"))) {
			menuitem.selected = 1;
			menuitem.disabled = 1;
		}
		
		if(fileentry.type == "folder") {
			// Substitute subfolders into options, change path, and recurse
			options.folder = fileentry.subfolders;
			var path = options.path;
			options.path = path + fileentry.name + "/";
			menuitem.submenu = Packages.Library.$.CreateMenuTreeFromFolderTree(options);
			options.path = path;
		}
		
		// Add item to array
		menudata.push(menuitem);
    }
	
	return menudata;
};

/*************************************************************************************************
 * CreateMenuHTMLFromFolderTree - Converts a nested folder listing into a HTML menu
 *
 * param - options : hash of options:
 * 		See Packages.Library.$.CreateMenuTreeFromFolderTree
 * 
 * returns the menu HTML list or null if an error occured
 ************************************************************************************************/
Packages.Library.$.CreateMenuHTMLFromFolderTree = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateMenuHTMLFromFolderTree",
		options: options,
		specification: {},
		optionsPassedTo: [
			Packages.Library.$.CreateMenuTreeFromFolderTree
		]
	})) return null;
	
	// Get menu data
	options.menudata = Packages.Library.$.CreateMenuTreeFromFolderTree(options);
	if(options.menudata == null) return null;
	
	// Create Menu
	return Packages.Library.$.CreateMenu(options);
};

/*************************************************************************************************
 * CreateMenuFromSubscribers - Creates a menu of plugins using subscribers
 *
 * param - options : hash of options, must contain:
 * 		menuTypes : array of menu type hashes to display on the menu, of the form:
 * 			key : the menu type key
 * 			name : user facing name (title) or null for no title
 * 	may contain:
 * 		execOptions : options to pass to executed function
 * 	Other options as for CreateMenu
 * 
 * returns the options ready for CreateMenu
 ************************************************************************************************/
Packages.Library.$.CreateMenuFromSubscribers = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateMenuFromSubscribers",
		options: options,
		specification: {
			menuTypes: {type: "array", required: 1},
			execOptions: {type: "array,object,string,number"}
		}
	})) return null;
	
	// Create a hash to store the menu items by type
	var menuItemTypes = {};
	
	// Fire subscriber to get registered menu items
		/****************************
		 * GetMenuItems - EVENT - finds the menu items available
		 *
		 * param - none, empty hash
		 *
		 * returns a hash containing:
		 * 		name : menu text
		 * 		description : (optional) description
		 * 		menuType : comma separated string of menu types this should be shown in
		 * 		order : (optional) an ordering within the menu
		 * 	Either
		 * 		item : the Package location to this item, if it needs an onclick
		 * 			in which case item.menuitem is instantiated, and .Execute called on it
		 * 		packagename : the string package name
		 * 	Or
		 * 		childMenuType : key of a menu type, that is fetched and displayed as a submenu
		 * 	Or
		 * 		submenu : array of submenu items
		 **************************/
	var responses = Packages.Library.$.EventFire({eventname: "GetMenuItems", data: {execOptions: options.execOptions}});
	if(responses.length > 0) {
		for(var i = 0; i < responses.length; i++) {
			if(responses[i] == null) continue;
			
			// Create an in scope function
			var f = function() {
				// Get action object
				var details = responses[i];
				
				// Skip if menuType not applicable
				var menuType = details.menuType;
				if(menuType == null) return;
				
				// Check the comma separated list of menu types for a match
				var foundType = null;
				var types = menuType.split(",");
				for(var t = 0; t < types.length; t++) {
					foundType = Packages.Library.$.FindArrayItem({
						array: options.menuTypes,
						path: "key",
						value: types[t]
					});
					if(foundType != null) break;
				}
				if(foundType == null) return;
				menuType = foundType.key;
				
				if(menuItemTypes[menuType] == null) menuItemTypes[menuType] = [];
				
				// Is this item a container for a submenu, or does it provide its own submenu?
				var submenu = details.submenu;
				if(details.childMenuType != null) {
					subMenuOptions = Packages.Library.$.CreateMenuFromSubscribers({
						menuTypes: [{key: details.childMenuType}],
						execOptions: options.execOptions
					});
					submenu = subMenuOptions.menudata;
				}
				
				// Does this item have its own onclick?
				var onclick;
				if(details.item != null) {
					onclick = function() {
						Packages.Library.$.DisplayMenuTool({packagename: details.packagename, execOptions: options.execOptions});
					};
				}
				
				// Create each menu item
				menuItemTypes[menuType].push({
					name: details.name,
					dragItem: {
						packagename: details.packagename,
						name: details.name
					},
					onclick: onclick,
					orderN: details.order, // Do not use 'order' or it conflicts with CreateMenu ordering
					submenu: submenu
				});
			}
			f(); // And execute it
		}
	}
	
	// Create the array of menu items
	var menuItems = [];
	for(var i = 0; i < options.menuTypes.length; i++) {
		var menuType = options.menuTypes[i].key;
		
		var items = menuItemTypes[menuType];
		if(items == null) continue;
		
		// Do we need to sort these?
		items.sort(function(a, b) {
			var ao = a.orderN != null ? a.orderN : 0;
			var bo = b.orderN != null ? b.orderN : 0;
			return ao - bo;
		});
		
		if(options.menuTypes[i].name != null) {
			menuItems.push({
				name: options.menuTypes[i].name,
				classname: "menutitle"
			});
		}
		
		// Add the menu items of this type
		menuItems = menuItems.concat(items);
	}
	
	options.menudata = menuItems;
	
	// Return options for a menu
	return options;
};

/*************************************************************************************************
 * DisplayMenuTool - displays the specified menu tool
 *
 * param - options : hash of options, must contain:
 * 		packagename : packagename of tool to display
 * 		execOptions : options to send to tool
 ************************************************************************************************/
Packages.Library.$.DisplayMenuTool = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.DisplayMenuTool",
		options: options,
		specification: {
			packagename: {type: "string", required: 1},
			execOptions: {type: "string,object,array,number"}
		}
	})) return;
	
	// Get itemObj
	var itemPackage = eval(options.packagename);
	var itemObj = new itemPackage.menuitem;
	var details = itemPackage.$.GetDetails();
	
	var items = itemObj.Execute(options.execOptions);
	if(items == null) return;
	
	// We have some items to show in a form
	var form = {
		type: "Form",
		object: itemObj.data,
		items: items,
		showSubmit: 0,
		submit: function() {
			itemObj.Submit();
			
		}
	};
	form.Form = new Packages.Form.Form(form);
	
	// Create pop up area to show the form, and set
	// a button to close the form
	Packages.Library.$.CreatePopupQuery ({
		title: details.name,
		message: form.Form.MakeForm(),
		buttons: {
			"submit": "Submit"
		},
		callback: function(key) {
			if(key != "submit") return;
			form.Form.Submit();
		}
	});
};

/*************************************************************************************************
 * CreateSelectOptionsFromArray - Creates the select options from an array of the form:
 * 		name: name of item to show
 * 		value: value of option
 * 		selected : 1 if selected
 *
 * param - options : hash of options, must contain:
 * 		items : array as described above
 * 	may contain:
 * 		value : value of selected item, on an array of selected items if multiple enabled
 * 		multiple : 1 multi select, 0 (default) single select
 * 
 * returns the string list of options for a select box
 ************************************************************************************************/
Packages.Library.$.CreateSelectOptionsFromArray = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateSelectOptionsFromArray",
		options: options,
		specification: {
			items: {type: "array", required: 1},
			value: {type: "string,number,array"},
			multiple: {type: "boolean"}
		}
	})) return null;
	
	var html = "";
	var items = options.items;
	
	for(var i = 0; i < items.length; i++) {
		var selected = 0;
		if(options.value == items[i].value) selected = 1;
		if(items[i].selected) selected = 1;
		if(options.multiple == 1 && options.value != null) {
			if(Packages.Library.$.Contains({array: options.value, item: items[i].value})) selected = 1;
		}
		html += "<option"
					+ (selected == 1 ? " selected='selected'" : "")
					+ " value='" + items[i].value + "'"
				+ ">"
					+ items[i].name
				+ "<\/option>";
	}
	
	return html;
};

/*************************************************************************************************
 * MakeElemMovable - makes the specified element draggable
 *
 * The output must be placed in the title bar container of the thing to be dragged
 *
 * The elemid refers to the outer container of the thing to move
 *
 * param - options : hash of options, must contain:
 * 			elemid : container elem id
 * 
 * returns the additional attributes for the title container to listen to mouse events or null on error
 ************************************************************************************************/
Packages.Library.$.MakeElemMovable = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeElemMovable",
		options: options,
		specification: {
			item: {type: "string", string: 1}
		}
	})) return null;
	
	options = {elemid: options.elemid}; // Force to be a new hash
	var textRef = GetTextRef(options);
	
	options.loaded = 0;
	options.moving = 0;
	
	options.interval = setInterval(function() {
		options.elem = document.getElementById(options.elemid);
		if(options.elem != null) options.loaded = 1;
		if(options.elem == null && options.loaded == 1) {
			// Item closed, destroy listeners
			clearInterval(options.interval);
			Packages.Library.$.EventUnsubscribe({eventsubscription: options.mouseUpEvent});
			return;
		}
		if(options.loaded == 0) return; // Not loaded yet
		
		if(options.moving == 0) return; // Not moving
		
		// Do the move
		options.elem.style.left = (Packages.Library.$v.Mouse.x-20) + "px";
		options.elem.style.top = (Packages.Library.$v.Mouse.y-20) + "px";
		options.elem.style.bottom = "auto";
		options.elem.style.right = "auto";
		options.elem.style.margin = "0px";
	}, 50);
	
	options.onMouseDown = function() {
		options.moving = 1;
		return false; // Don't do anything else
	}
	
	options.onMouseUp = function() {
		options.moving = 0;
	}
	
	options.mouseUpEvent = Packages.Library.$.EventSubscribe({eventname: "mouseup", callback: options.onMouseUp.bind(options)});
	
	return "onmousedown=\"return " + textRef + ".onMouseDown()\"";
}

/*************************************************************************************************
 * CreateDragAndDropItem - adds the necessary data to an item to make it drag and drop compatable
 *
 * 1. Adds an internal $noDump.dragAndDrop key to the item object to store drag and drop info
 * 2. Returns the markup wrapped in a container for the item with various on mouse events and classes
 * 3. (optionally) Stores a reference to the array that contains this item, so it can be removed
 *
 * Format of callbacks
 * Item callback : callback to the item when it is moved
 * 		params - options : hash of options containing:
 * 			containerData: container data for the container is dropped in
 * 			item: selected item
 * 			itemData: selected item data
 * Container callback : callback to the container when an item dropped in it
 * 		params:
 * 			same as Item callback
 *
 * param - options : hash of options, must contain:
 * 			item : the item hash
 * 			html : the markup for the item, which will be wrapped
 * 		may contain:
 * 			storeArray : the array that contains the item, if specified it will be removed when dragged out
 * 							otherwise it will stay in the array
 * 			allowReordering : 1 allow reordering (requires storeArray), 0 (default) do not
 * 			callback : (container) callback to fire after something has been dropped in it to force a refresh
 * 			itemCallback : (item) callback to fire when this item is dropped into something
 * 			checkValid: (item) callback to check this move is valid, as for itemCallback except returns 1 or 0 to say whether this is OK or not
 * 			classname : classname to put on the element
 * 			tag : the tag to use for the container
 * 			typeCheck : 1 (default) forces type checking, 0 disable
 * 			data : data to send to callback as itemData
 * 			containerData : data to send to callback as containerData (when acting as container)
 * 			type : override type that specifies the type this drag and drop item is
 * 			adjustDOM : 1 (default) where possibly update DOM to reflect changes, 0 don't
 * 			adjustArray : 1 (default) splice / insert this item into arrays, 0 don't
 * 			titleBar : (optional) header to display above html - the drag only applies to this item
 * 			attributes : (optional) string of additional attributes for tag
 * 
 * returns the html wrapped in content, also adds $noDump.dragAndDrop to the item
 ************************************************************************************************/
Packages.Library.$.CreateDragAndDropItem = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateDragAndDropItem",
		options: options,
		specification: {
			item: {type: "object", required: 1},
			html: {type: "string", required: 1},
			storeArray: {type: "array"},
			allowReordering: {type: "boolean"},
			callback: {type: "function"},
			itemCallback: {type: "function"},
			classname: {type: "string"},
			tag: {type: "string"},
			data: {type: "object"},
			containerData: {type: "object"},
			type: {type: "string"},
			adjustDOM: {type: "boolean"},
			titleBar: {type: "string"},
			attributes: {type: "string"}
		}
	})) return null;
	
	// The item must have a type otherwise it is invalid
	if(options.item.type == null && options.type == null) return options.html;
	
	// Create dragAndDrop hash
	if(options.item.$noDump == null) options.item.$noDump = {};
	options.item.$noDump.dragAndDrop = {elemId: "dragAndDrop" + Packages.Library.$.GetUniqueId({})};
	
	// Create a textvar to the dragAndDrop key, and store initial data in it
	options.item.$noDump.dragAndDrop.textVar = GetTextRef(options.item.$noDump.dragAndDrop);
	var dragAndDrop = options.item.$noDump.dragAndDrop;
	dragAndDrop.options = options;
	
	dragAndDrop.onMouseDown = function() {
		// Left click only
		if(window.event.button > 0) return true;
		
		// Don't bother if something else is being dragged
		if(Packages.Library.$v.DragAndDrop.selectedItem != null) return true;
		
		// Call back when on mouse down on the element
		// 'this' is the dragAndDrop object
		Packages.Library.$._ClearDragAndDrop();
		
		// Register this as the new drag and drop element
		Packages.Library.$v.DragAndDrop.selectedItem = this;
		
		// Create a clone of the item
		var dragHtml = document.getElementById(Packages.Library.$v.DragAndDrop.selectedItem.elemId).innerHTML;
		
		// Clean copy of HTML to remove all 'id' and 'name' attributes
		dragHtml = dragHtml.replace(/id="[^"]+"/g, "").replace(/id='[^']+'/g, "").replace(/name='[^']+'/g, "").replace(/name="[^"]+"/g, "");
		
		Packages.Library.$v.DragAndDrop.dragElem = document.createElement("div");
		Packages.Library.$v.DragAndDrop.dragElem.innerHTML = dragHtml;
		Packages.Library.$v.DragAndDrop.dragElem.className = "dragAndDropMove";
		Packages.Library.$v.DragAndDrop.dragElem.id = null;
		document.body.appendChild(Packages.Library.$v.DragAndDrop.dragElem);
		
		setTimeout(function() {
			var elem = Packages.Library.$v.DragAndDrop.dragElem;
			if(elem != null) elem.className = "dragAndDropMove dragAndDropMoveActive";
		}, 100);
		
		// Set up timer
		Packages.Library.$v.DragAndDrop.timer = setInterval(function() {
			Packages.Library.$v.DragAndDrop.dragElem.style.top = (Packages.Library.$v.Mouse.y + 5) + "px";
			Packages.Library.$v.DragAndDrop.dragElem.style.left = (Packages.Library.$v.Mouse.x + 5) + "px";
		}, 20);
		
		Packages.Library.$v.DragAndDrop.bodyClassName = document.body.className;
		document.body.className = Packages.Library.$v.DragAndDrop.bodyClassName + " disableUserSelect";
		Packages.Library.$v.DragAndDrop.bodyOnMouseUpSubscriber = Packages.Library.$.EventSubscribe({eventname: "mouseup", callback: Packages.Library.$._ClearDragAndDrop});
		
		return true;
	};
	
	dragAndDrop.onMouseUp = function() {
		// Cancel global callback
		Packages.Library.$.EventUnsubscribe({eventsubscription: this.mouseUpEvent});
		
		// Callback when one item is dropped on another item
		
		// Call back when on mouse up on the element
		// 'this' is the dragAndDrop object mouseup'd on
		var selectedItem = Packages.Library.$v.DragAndDrop.selectedItem;
		if(selectedItem == null) return true;
		
		Packages.Library.$._ClearDragAndDrop();
		
		// Does this element still exist on the page?
		var dropElem = document.getElementById(this.elemId);
		if(!dropElem) return true;
		
		// Only "care" about this, if the re-ordering is enabled
		if(this.options.allowReordering == 1 && this.options.storeArray != null) {
			// Do re-ordering action
			// Get item index positions
			var dropIndex = Packages.Library.$.FindItemsPositionInArray({
				array: this.options.storeArray,
				item: this.options.item
			});
		}
		
		// Are the items the same?
		if(Packages.Library.$.AreReferencesTheSame({
			item1: selectedItem.options.item,
			item2: this.options.item
		})) {
			// Yes, so don't do anything
			return true;
		}
		
		// Are the items of the same type?
		var selType = selectedItem.options.item.type;
		if(selectedItem.options.type != null) selType = selectedItem.options.type;
		var myType = this.options.item.type;
		if(this.options.type != null) myType = this.options.type;
		if(options.typeCheck != 0 && myType != selType) {
			// No, so don't do anything
			return true;
		}
		
		return Packages.Library.$._DragAndDropMoveItem({
			drag: selectedItem,
			destArray: this.options.storeArray,
			containerElem: dropElem.parentNode,
			containerData: this.options.containerData,
			destIndex: dropIndex,
			dropElem: dropElem,
			callback: this.options.callback
		});
	};
	
	// Apply a global mouseup event cancel
	dragAndDrop.mouseUpEvent = Packages.Library.$.EventSubscribe({eventname: "mouseup", callback: dragAndDrop.onMouseUp.bind(dragAndDrop)});
	
	if(options.tag == null) options.tag = "div";
	if(options.classname == null) options.classname = "";
	options.classname += " dragAndDropItem";
	
	var html = options.html;
	var onmousedown = "onmousedown=\"" + dragAndDrop.textVar + ".onMouseDown()\" ";
	if(options.titleBar != null) {
		html = "<div " +
			"class='titleBar' " +
			onmousedown +
		">" +
			options.titleBar +
		"<\/div>"
		+ html;
		
		onmousedown = ""; // Done here instead
	}
	
	return "<" + options.tag + " " +
				"class='" + options.classname + "' " +
				onmousedown +
				"onmouseup=\"" + dragAndDrop.textVar + ".onMouseUp()\" " +
				"id='" + dragAndDrop.elemId + "' " +
				(options.attributes != null) + options.attributes +
			">" +
				html +
			"<\/" + options.tag + ">";
};

/*************************************************************************************************
 * CreateDragAndDropContainer - adds the necessary data to a container to allow it to accept drag
 * and drop items
 *
 * 1. Returns the markup wrapped in a container for the item with various on mouse events and classes
 * 3. Stores a reference to the array so that new items can be added
 *
 * param - options : hash of options, must contain:
 * 			html : the markup of the collection of items to contain
 * 		may contain:
 * 			storeArray : the array that contains the item, if specified it will be removed when dragged out
 * 							otherwise it will stay in the array
 * 			callback : callback to fire after a change to force a refresh
 * 			data : data to send to callback as containerData
 * 			tag : tag to use on wrapper
 * 			classname : classname to add to wrapper
 * 			expandWhenActive : 1 (default) expand when drag and drop enabled, 0 don't
 * 
 * returns the html wrapped in content, also adds $noDump.dragAndDrop to the item
 ************************************************************************************************/
Packages.Library.$.CreateDragAndDropContainer = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateDragAndDropContainer",
		options: options,
		specification: {
			html: {type: "string", required: 1},
			storeArray: {type: "array"},
			callback: {type: "function"},
			data: {type: "object"},
			tag: {type: "string"},
			classname: {type: "string"},
			expandWhenActive: {type: "boolean"}
		}
	})) return null;
	
	// Create dragAndDrop hash
	var dragAndDrop = {elemId: "dragAndDrop" + Packages.Library.$.GetUniqueId({})};
	
	// Create a textvar to the dragAndDrop key, and store initial data in it
	dragAndDrop.textVar = GetTextRef(dragAndDrop);
	dragAndDrop.options = options;
	
	dragAndDrop.onMouseUp = function() {
		// Callback when one item dropped on another container
		
		// Call back when on mouse up on the element
		// 'this' is the dragAndDrop object mouseup'd on
		var selectedItem = Packages.Library.$v.DragAndDrop.selectedItem;
		if(selectedItem == null) return true;
		
		Packages.Library.$._ClearDragAndDrop();
		
		return Packages.Library.$._DragAndDropMoveItem({
			drag: selectedItem,
			destArray: this.options.storeArray,
			containerData: this.options.data,
			containerElem: document.getElementById(this.elemId),
			callback: this.options.callback
		});
	};
	
	if(options.tag == null) options.tag = "div";
	if(options.classname == null) options.classname = "";
	return "<" + options.tag + " " +
				"class='" + (options.expandWhenActive != 0 ? "dragAndDropContainer " : "") + options.classname + "' " +
				"onmouseup=\"" + dragAndDrop.textVar + ".onMouseUp()\" " +
				"id='" + dragAndDrop.elemId + "' " +
			">" +
				options.html +
			"<\/" + options.tag + ">";
}

/*************************************************************************************************
 * _ClearDragAndDrop - internal - clear drag and drop
 ************************************************************************************************/
Packages.Library.$._ClearDragAndDrop = function() {
	if(Packages.Library.$v.DragAndDrop.selectedItem == null) return;
	
	if(Packages.Library.$v.DragAndDrop.timer != null) clearInterval(Packages.Library.$v.DragAndDrop.timer);
	Packages.Library.$v.DragAndDrop.timer = null;
	if(Packages.Library.$v.DragAndDrop.selectedItem == null) return;
	if(Packages.Library.$v.DragAndDrop.dragElem == null) return;
	if(Packages.Library.$v.DragAndDrop.dragElem.parentNode == null) return;
	Packages.Library.$v.DragAndDrop.dragElem.parentNode.removeChild(Packages.Library.$v.DragAndDrop.dragElem);
	document.body.className = Packages.Library.$v.DragAndDrop.bodyClassName;
	Packages.Library.$v.DragAndDrop.selectedItem = null;
	Packages.Library.$.EventUnsubscribe({eventsubscription: Packages.Library.$v.DragAndDrop.bodyOnMouseUpSubscriber});
}

/*************************************************************************************************
 * _DragAndDropMoveItem - internal - moves an item from one container to another
 *
 * See CreateDragAndDropContainer
 *
 * param - options : hash of options, must contain:
 * 			drag : the dragAndDrop item being moved
 * 			containerElem : the container DOM element
 * 		may contain:
 * 			destArray : the destination array to copy into
 * 			destIndex : the position to insert the item at or null for end
 * 			dropElem : the DOM element to insert this item before
 * 			callback : callback to fire after a change to force a refresh
 * 			containerData : data set on container to be sent to callback
 * 
 * returns true or false depending on whether the action completed
 ************************************************************************************************/
Packages.Library.$._DragAndDropMoveItem = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$._DragAndDropMoveItem",
		options: options,
		specification: {
			drag: {type: "object", required: 1},
			containerElem: {type: "DOMobject", required: 1},
			destArray: {type: "array"},
			destIndex: {type: "number"},
			dropElem: {type: "DOMobject"},
			callback: {type: "function"},
			containerData: {type: "object"}
		}
	})) return true;
	
	var selectedItem = options.drag;
	if(selectedItem == null) return true;
	
	var item = selectedItem.options.item;
	var itemElem = document.getElementById(selectedItem.elemId);
	
	// Check valid
	if(selectedItem.options.checkValid != null) {
		if(selectedItem.options.checkValid({containerData: options.containerData, item: selectedItem.options.item, itemData: selectedItem.options.data})) {
			// True, so fine
		} else {
			// False, so stop
			return true;
		}
	}
	
	if(selectedItem.options.storeArray != null) {
		var itemIndex = Packages.Library.$.FindItemsPositionInArray({
			array: selectedItem.options.storeArray,
			item: selectedItem.options.item
		});
		
		if(itemIndex == null) return true;
		
		// Remove item from item array, and place just before the dropIndex in drop array
		// Remove from old array
		selectedItem.options.storeArray.splice(itemIndex, 1);
	}
	if(options.destArray != null && selectedItem.options.adjustArray != 0) {
		// Add to new array
		if(options.destIndex != null) {
			options.destArray.splice(options.destIndex, 0, item);
		} else {
			options.destArray.push(item);
		}
		
		// Update DOM
		if(selectedItem.options.adjustDOM != 0) {
			if(options.dropElem != null) {
				options.dropElem.parentNode.insertBefore(itemElem, options.dropElem);
			} else {
				options.containerElem.appendChild(itemElem);
			}
		}
		
		// Update stored data for the object in the new location
		item.$noDump.dragAndDrop.options.storeArray = options.destArray;
	}
	
	// Fire callback if we have one
	if(options.callback != null) options.callback({containerData: options.containerData, item: selectedItem.options.item, itemData: selectedItem.options.data});
	
	// Fire callback if we have one
	if(selectedItem.options.itemCallback != null) selectedItem.options.itemCallback({containerData: options.containerData, item: selectedItem.options.item, itemData: selectedItem.options.data});
	
	// Stop moving up the stack
	return false;
}

/*************************************************************************************************
 * EscapeValueForField - escapes the specified value ready to be inserted in the value of a tag
 *
 * param - options : hash of options, must contain:
 * 			value : the value to escape, if null, returns ""
 * 
 * returns the escaped value or "" on error
 ************************************************************************************************/
Packages.Library.$.EscapeValueForField = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EscapeValueForField",
		options: options,
		specification: {
			value: {type: "string,number"}
		}
	})) return "";
	
	if(options.value == null) return "";
	
	var value = options.value;
	
	value = value + ""; // Force string
	
	value = Packages.Library.$.ConvertFromHTML({str: value});
	
	value = value.replace(/&/g, "&amp;").replace(/\"/g, "&#34;").replace(/</, "&lt;").replace(/>/, "&gt;");
	return value;
}

/*************************************************************************************************
 * ToggleBodyClass - toggles a class on the body tag on and off
 *
 * param - options : hash of options, must contain:
 * 			className : the classname
 * 		may contain:
 * 			state : 1 on, 0 off (if null, inverts)
 ************************************************************************************************/
Packages.Library.$.ToggleBodyClass = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ToggleBodyClass",
		options: options,
		specification: {
			className: {type: "string", required: 1},
			state: {type: "boolean"}
		}
	})) return;
	
	// Get classes
	var classes = document.body.className;
	var array = classes.split(/ /);
	var hash = {};
	foreach(array, function(className) {
		hash[className] = 1;
	});
	
	// Change state
	if(options.state != null) {
		hash[options.className] = options.state;
	} else {
		hash[options.className] = (hash[options.className] == null ? 1 : 0);
	}
	
	// Rebuild list
	classes = "";
	for(var className in hash) {
		if(hash[className] == 0) continue;
		if(className == "") continue;
		
		classes += className + " ";
	}
	
	document.body.className = classes;
}

/*************************************************************************************************
 * AddHTMLToHead - adds the specified html to the head of the page
 *
 * The markup is deconstructed, and added as DOM elements
 *
 * param - options : hash of options, must contain:
 * 			html : the html to add
 * 		may contain:
 * 			attrs : hash of additional attributes to place on every tag
 * 			className : extra className to add to every tag
 * 			forceReload : 1 will reload even tags that already exist, 0 (default) don't
 *
 * return - hashIds : an array of hash ids for the elements added
 ************************************************************************************************/
Packages.Library.$.AddHTMLToHead = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.AddHTMLToHead",
		options: options,
		specification: {
			html: {type: "string", required: 1},
			attrs: {type: "object"},
			className: {type: "string"},
			forceReload: {type: "boolean"}
		}
	})) return [];
	
	var hashIds = [];
	
	var html = options.html;
	
	// Replace unsupported comments
	html = html.replace(/<!.*?>/g, "");
	
	while(html.match(new RegExp(/<([^>]+)>/))) {
		var local = html;
		if(RegExp.$1 == "") local.match(/<([^>]+)>/); // Do it again, because on a second render of the page RegExp.$1 is empty ??
		var entireTag = RegExp.$1;
		var tag = null;
		// Extract tag
		if(entireTag.match(/^([^ ]+)/)) {
			tag = RegExp.$1;
		} else {
			// Impossible
			Packages.Library.$.LogInfo({mesg: "Tag not found in [" + entireTag + "]", location: "Packages.Library.$.AddHTMLToHead", type: "Error", level: 4});
			return [];
		}
		// Remove opening tag from markup
		var match = "<"+  entireTag + ">";
		html = Packages.Library.$.Replace({
			content: html,
			search: match,
			replacement: ""
		});
		
		// Find the closing tag
		var content = null;
		var closingTag = html.indexOf("</" + tag + ">");
		if(closingTag) {
			content = html.substr(0, closingTag);
		}
		
		// Create a very unique id from this content
		var hash = entireTag;
		if(content != null) hash += content;
		var hashId = Packages.Library.$.HashString({string: hash});
		hashIds.push(hashId);
		if(document.getElementById(hashId) == null || options.forceReload == 1) {
			// Does not already exist in head
			
			// Extract attributes
			var attrs = {};
			if(entireTag != tag) {
				var attStr = entireTag;
				while(attStr.match(/([^= ]+)=(.)/)) {
					var res = attStr.match(/([^= ]+)=(.)/);
					// While there are attributes
					var name = res[1];
					var valueStartChar = res[2];
					var value = null;
					var endChar = "";
					if(valueStartChar == '"' || valueStartChar == "'") endChar = valueStartChar;
					if(endChar != "") {
						if(attStr.match(name + "=" + valueStartChar + "([^" + endChar + "]*)")) {
							var res = attStr.match(name + "=" + valueStartChar + "([^" + endChar + "]*)");
							value = res[1];
						}
					} else {
						if(attStr.match(name + "=" + "([^ ]+)")) {
							var res = attStr.match(name + "=" + "([^ ]+)");
							value = res[1];
						}
					}
					if(name != "") attrs[name] = value;
					
					// Remove the attribute
					attStr = Packages.Library.$.Replace({
						content: attStr,
						search: name + "=" + endChar + value + endChar,
						replacement: ""
					});
				}
			}
			
			// Add overiding attributes in options (if present)
			if(options.attrs != null) {
				for(name in options.attrs) {
					attrs[name] = options.attrs[name];
				}
			}
			
			// Add className is relevant
			if(options.className != null) {
				if(attrs.className == null) attrs.className = "";
				attrs.className += " " + options.className;
			}
			
			// Add hash id, unless it already has an id
			if(attrs.id == null) attrs.id = hashId;
			
			// Create the tag
			var elem = document.createElement(tag);
			// Add attributes
			for(var name in attrs) {
				elem[name] = attrs[name];
			}
			// Add content if there is any
			if(content != null) {
				elem.innerHTML = content;
			}
			
			// Add to header
			document.getElementsByTagName("head")[0].appendChild(elem);
		}
		
		// Remove markup from html passed in
		var match = "";
		if(content != null) {
			match = content + "<\/" + tag + ">";
		}
		html = Packages.Library.$.Replace({
			content: html,
			search: match,
			replacement: ""
		});
	}
	return hashIds;
};

/*************************************************************************************************
 * GetDiagonalLineStyles - gets the inline styles to render an element diagonally
 *
 * param - options : hash of options, must contain:
 * 			x1 : x of pos 1
 * 			y1 : y of pos 1
 * 			x2 : x of pos 2
 * 			y2 : y od pos 2
 * 		optionally:
 * 			thickness : thickness in pixels
 * 			colour : line colour
 * 			percent : 1 use percent, 0 (default) use px
 *
 * return - styles : string of styles
 ************************************************************************************************/
Packages.Library.$.GetDiagonalLineStyles = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetAngleBetweenPoints",
		options: options,
		specification: {
			x1: {type: "number", required: 1},
			x2: {type: "number", required: 1},
			y1: {type: "number", required: 1},
			y2: {type: "number", required: 1},
			thickness: {type: "number"},
			colour: {type: "string"},
			percent: {type: "boolean"}
		}
	})) return null;
	var styles = "";
	
	var unit = "px";
	if(options.percent == 1) unit = "%";
	
	// Get length
	var w = Math.abs(options.x1 - options.x2);
	var h = Math.abs(options.y1 - options.y2);
	var z = Math.sqrt((w*w) + (h*h));
	
	// Get angle
	var angle = Packages.Library.$.GetAngleBetweenPoints(options);
	
	styles += "width:" + z + unit + ";";
	styles += "position:absolute;";
	styles += "-webkit-transform:rotate(" + angle + "deg);";
	styles += "-webkit-transform-origin:0% 0%;"
	styles += "top:" + options.y1 + unit + ";";
	styles += "left:" + options.x1 + unit + ";";
	
	if(options.colour) styles += "background-color:" + options.colour + ";";
	if(options.thickness) styles += "height:" + options.thickness + unit + ";";
	
	return styles;
}

Packages.Library.$v.MakeHelpCounter = 0;
Packages.Library.$v.DragAndDrop = {
	selectedItem: null,
	count: 0
};Package("Library").Math = function() {};
/**************************************
 * Math - a collection of math functions, or array modification functions
 *************************************/

/*******************************************************************************
 * Merge - merges the items of the second object into the first object
 *
 * param - options : hash of options, must include:
 * 				base : base hash to receive values
 * 				extra : hash of extra options
 * 			may include:
 * 				shallow : 1 do shallow merge, 0 (default) do recursive merge
 * 				skiplist : array of things to skip
 ******************************************************************************/
Packages.Library.$.Merge = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Merge",
		options: options,
		specification: {
			base: 	{type: "array,object",	required: 1},
			extra: 	{type: "array,object",	required: 1},
			shallow: 	{type: "boolean"},
			skiplist: 	{type: "array"}
		}
	})) {
		return;
	}
	
	var base = options.base;
	var extra = options.extra;
	var skiplist = options.skiplist;
	if(skiplist == null) skiplist = [];
	for (var i in extra) {
		if(i == '$recursing') continue;
		if(Packages.Library.$.Contains({array: skiplist, item: i})) continue;
		
		// Does item exist in base, or are we doing a shallow copy?
		if(base[i] == null || options.shallow == 1) {
			// No, so straight copy
			base[i] = extra[i];
		} else {
			// Yes, what type is it?
			if (typeof base[i] == "object" && typeof extra[i] == "object") {
				if(extra[i].$recursing != null) {
					// Already processing
					continue;
				}
				extra[i].$recursing = {from: "Packages.Library.$.Merge"};
				Packages.Library.$.Merge({
					base: base[i],
					extra: extra[i],
					skiplist: skiplist
				});
				if(extra[i].$recursing == null) delete extra[i].$recursing;
			} else {
				base[i] = extra[i]
			}
		}
	}
};

/*********************************************************************
 * GetArrayFromCSV - converts the specified csv text into a 2D array
 *
 * Also adds a new first column with the row id
 *
 * param - csvtext - source
 *
 * returns the 2D array
 ********************************************************************/
Packages.Library.$.GetArrayFromCSV = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetArrayFromCSV",
		options: options,
		specification: {
			csvtext: {type: "string", required: 1}
		}
	})) return null;
	
	var array = [];
	var row = [];
	var lastChar = "\n";
	var inQuotes = 0;
	
	options.csvtext = options.csvtext.replace(/\r/, "");
	
	// Fix EOF by adding line feed to end of file
	var csvtext = options.csvtext + "\n";
	
	var cell = "";
	
	for(var x = 0; x < csvtext.length; x++) {
		var c = csvtext[x];
		
		if(inQuotes == 0) {
			// Only if we are not in quotes
			
			// Is this the start of quotes? Must be a new cell followed by a quote
			// Either ," or \n"
			// Or "" if we exit then immediatly re-enter quotes
			if(c == '\"' && (lastChar == ',' || lastChar == '\n' || lastChar == '\r' || lastChar == '"')) inQuotes = 1;
			
			// Is this the end of a cell, end of line
			if(c == ',' || c == '\n') {
				if(cell.match(/"/)) {
					// Strip escaped chars
					cell = cell.replace(/\"\"/g, "\"").replace(/^\"/, "").replace(/\"$/, "");
				}
				row.push(cell);
				cell = "";
				// Is this a newline or EOF?
				if(c == '\n') {
					// If we have more than 1 cell, or the first cell actually has some content its fine
					if(row.length > 1 || row[0] != "") { // Skip empty rows, an empty row will be [""]
						row.unshift((array.length == 0 ? "ID" : array.length + ""));
						array.push(row);
					}
					row = [];
				}
			} else {
				cell += c;
			}
		} else {
			// Only if we are inside quotes
			
			// Is this the end of our quotes?
			if(c == '\"') inQuotes = 0;
			
			cell += c;
		}
		
		lastChar = c;
	}
	
	return array;
};



/*********************************************************************
 * MakeCSV - Takes a two dimensional (array) and converts to CSV
 *
 * param - options - hash of options, must contain:
 * 				array : the 2D array
 * 			may contain:
 * 				sep : the separating character - default ','
 * 				stripNulls : 1 strip nulls, 0 (default) leave
 *
 * returns the array
 ********************************************************************/
Packages.Library.$.MakeCSV = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeCSV",
		options: options,
		specification: {
			array: {type: "array", required: 1},
			sep: {type: "string"},
			stripNulls: {type: "boolean"}
		}
	})) return null;
	
	var array = options.array;
	var data = [];
	
	for(var i = 0; i < array.length; i++) {
		var row = Packages.Library.$.MakeCSVLine({
			array: array[i],
			sep: options.sep,
			stripNulls: options.stripNulls
		});
		
		data.push(row);
	}
	
	return data.join("\n");
};

/*********************************************************************
 * MakeCSVLine - Take a single dimensional row (array) and converts to CSV
 *
 * Also removes the index column at the beginning
 *
 * param - options - hash of options, must contain:
 * 				array : the array row
 * 			may contain:
 * 				sep : the separating character - default ','
 * 				stripNulls: 1 strip nulls, 0 (default) leave them in
 *
 * returns the array
 ********************************************************************/
Packages.Library.$.MakeCSVLine = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeCSVLine",
		options: options,
		specification: {
			array: {type: "array", required: 1},
			sep: {type: "string"},
			stripNulls: {type: "boolean"}
		}
	})) return null;
	
	var sep = options.sep;
	if(sep == null) sep = ",";
	var array = options.array;
	var rowdata = [];
	
	for(var i = 0; i < array.length; i++) {
		if(i == 0) continue; // Skip index column
		
		var cell = array[i] + ""; // Force string
		
		if(options.stripNulls == 1 && array[i] == null) cell = "";
		
		if(cell.match(/[,\n\"\\]/)) {
			// See CSV::SetField
			cell = cell.replace(/\\/g, "\\\\");
			cell = cell.replace(/\"/g, "\"\"");
			cell = "\"" + cell + "\"";
		}
		rowdata.push(cell);
	}
	
	return rowdata.join(sep);
};

/*************************************************************************************************
 * MakeTable - creates a HTML table from CSV text
 *
 * param - options : hash of options, must contain:
 * 				csvtext : the csv
 *
 * returns the markup
 ************************************************************************************************/
Packages.Library.$.MakeTable = function(options) {
    if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeTable",
		options: options,
		specification: {
			csvtext: {type: "string", required: 1}
		}
	})) return null;
	
	var html = "";
    var table = Packages.Library.$.GetArrayFromCSV({csvtext: options.csvtext});
    html += "<table border='1' class='csvtable'>";
    for(var j=0;j<table.length;j++) {
        var tag = (j==0?"th":"td");
        html += "<tr>";
        for(var i=0;i<table[j].length;i++) {
            html += "<"+tag+" class='csvtablecell'>";
            html += table[j][i];
            html += "<\/"+tag+">";
        }
        html += "<\/tr>";
    }
    html += "<\/table>";
    return html;
};

/*********************************************************************
* Contains - returns whether the specified array contains the specified element
*
* param - options : hash of options, must contain:
* 			array : array to search
* 			item : item to precisely match (may be null)
*
* return 1 if match, otherwise 0
********************************************************************/
Packages.Library.$.Contains = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Contains",
		options: options,
		specification: {
			array: {type: "array", required: 1},
			item: {type: "string,number,boolean"}
		}
	})) return null;
	
	var array = options.array;
	var item = options.item;
	
	for(var i = 0; i < array.length; i++) {
		if(array[i] == item) return 1;
	}
	return 0;
};

/*******************************************************************************
 * FindArrayItem - finds an array item from an array
 *
 * param - options : hash of options, must contain:
 * 				array : array to search in
 * 				path : hash path of key (Eg "alpha.beta")
 * 				value : value to match
 * 			other options as for FindArrayItemIndex
 *
 * returns the array item or null if not found
 ******************************************************************************/
Packages.Library.$.FindArrayItem = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.FindArrayItem",
		options: options,
		specification: {},
		optionsPassedTo: [
			Packages.Library.$.FindArrayItemIndex
		]
	})) return null;
	
	// Validation done in FindArrayItemIndex
	var index = Packages.Library.$.FindArrayItemIndex(options);
	if(index == null) return null;
	return options.array[index];
};

/*******************************************************************************
 * FindArrayItemIndex - finds an array item from an array
 *
 * param - options : hash of options, must contain:
 * 				array : array to search in
 * 				value : value to match
 * 				inCommas : 1 first splits on commas and then tests, 0 (default) must match entire string
 * 			may contain:
 * 				path : hash path of key (Eg "alpha.beta"), or null if using base array
 *
 * returns the array item index or null if not found
 ******************************************************************************/
Packages.Library.$.FindArrayItemIndex = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.FindArrayItemIndex",
		options: options,
		specification: {
			array: {type: "array", required: 1},
			path: {type: "string,number,boolean"},
			value: {type: "string,number,boolean", required: 1},
			inCommas: {type: "number"}
		}
	})) return null;
	
	if(options.path == null) options.path = "";
	var array = options.array;
	var path = options.path + "";
	var value = options.value;
	
	for(var i = 0; i < array.length; i++) {
		var currentValue = null;
		try {
			if(path == "") currentValue = array[i];
			if(currentValue == null && path.indexOf(".") == -1) currentValue = array[i][path];
			if(currentValue == null) currentValue = eval("array[i]." + path);
		} catch(e) {
			var error = e.message;
			currentValue = null;
		}
		if(currentValue == null) continue;
		
		if(options.inCommas == 1 && typeof(currentValue) == "string") {
			// Test if the value matches one of the comma separated options
			var items = currentValue.split(",");
			for(var j = 0; j < items.length; j++) {
				if(items[j] == value) return i;
			}
		}
		
		if(currentValue == value) return i;
	}
    return null;
};

/*******************************************************************************
 * FindItemsPositionInArray - find the specified items position in the specified
 * array
 *
 * param - options : hash of options, must contain:
 * 				array : array to search in
 * 				item : the item to find
 *
 * returns the index or null if not found
 ******************************************************************************/
Packages.Library.$.FindItemsPositionInArray = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.FindItemsPositionInArray",
		options: options,
		specification: {
			array: {type: "array", required: 1},
			item: {type: "object", required: 1}
		}
	})) return null;
	
	options.item.$findItem = 1; // Add a temporary key
	var itemIndex = Packages.Library.$.FindArrayItemIndex({
		array: options.array,
		path: "$findItem",
		value: 1
	});
	delete options.item.$findItem; // Remove this key
	
	return itemIndex;
};

/*******************************************************************************
 * AreReferencesTheSame - compares two object references to see if they are the same
 *
 * param - options : hash of options, must contain:
 * 				item1 : object
 * 				item2 : object
 *
 * returns 1 if identical, 0 if not
 ******************************************************************************/
Packages.Library.$.AreReferencesTheSame = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.AreReferencesTheSame",
		options: options,
		specification: {
			item1: {type: "object", required: 1},
			item2: {type: "object", required: 1}
		}
	})) return null;
	
	options.item1.$findItem = 1; // Add a temporary key
	var same = options.item2.$findItem == 1 ? 1 : 0;
	delete options.item1.$findItem; // Remove this key
	
	return same;
};

/*********************************************************************
* GetSubObjectFromBreadcrumbs - gets the sub object in a recursive nested array
* where the path matches the path specified
*
* Used when there are objects in an array, and we want to find a certain one
* Except this is recursive, so we also have an array key for the next recursion
*
* param - options: hash of options, must contain:
* 				parentArray : the parent array
* 				path : array of folder names through the object
* 				idkey : the key of the id field in each object that we are matching
* 				subarraykey : the key of the sub array
*
* returns the sub object or null if not found
********************************************************************/
Packages.Library.$.GetSubObjectFromBreadcrumbs = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetSubObjectFromBreadcrumbs",
		options: options,
		specification: {
			parentArray: {type: "array", required: 1},
			path: {type: "array", required: 1},
			idkey: {type: "string", required: 1},
			subarraykey: {type: "string", required: 1}
		}
	})) return null;
	
	var parentArray = options.parentArray;
	var path = options.path;
	var idkey = options.idkey;
	var subarraykey = options.subarraykey;
	
	if(path.length == 0) return parentArray;
	// Clone path as we alter the array
	path = Packages.Library.$.Clone({oldObj: path});
	var id = path.shift();
	for(var i = 0; i < parentArray.length; i++) {
		var object = parentArray[i];
		if(object[idkey] == id) {
			if(path.length == 0) {
				// Finished
				return object;
			} else {
				// Recurse
				return Packages.Library.$.GetSubObjectFromBreadcrumbs({
					parentArray: object[subarraykey],
					path: path,
					idkey: idkey,
					subarraykey: subarraykey
				});
			}
		}
	}
	return null;
};

/*************************************************************************************************
 * ToHex - Converts the specified value to Hex
 *
 * param - options : hash of options, must contain:
 * 			num : value to convert
 *
 * returns hex version
 ************************************************************************************************/
Packages.Library.$.ToHex = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ToHex",
		options: options,
		specification: {
			num: {type: "number", required: 1}
		}
	})) return null;
	
	var num = options.num;
	
	if (num == null) return "00";
	num = parseInt(num, 10); if (num == 0 || isNaN(num)) return "00";
	num = Math.max(0, num); num = Math.min(num, 255);
	return "0123456789ABCDEF".charAt((num - num % 16) / 16)
		 + "0123456789ABCDEF".charAt(num % 16);
};

/*************************************************************************************************
 * GetSubItemFromPath - gets the sub item referenced by a . separated path
 *
 * param - options: hash of options, must contain:
 * 				parent : the parent object
 * 				path : array of folder names through the object
 *
 * returns the sub object or null if not found
 ********************************************************************/
Packages.Library.$.GetSubItemFromPath = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetSubItemFromPath",
		options: options,
		specification: {
			parent: {type: "object", required: 1},
			path: {type: "string", required: 1}
		}
	})) return null;
	
	var parent = options.parent;
	var steps = options.path.split(/\./);
	for(var s = 0; s < steps.length; s++) {
		var step = steps[s];
		parent = parent[step];
	}
	
	return parent;
};

/*************************************************************************************************
 * ToNumber - Forces a string to be a number, will be zero if this fails
 *
 * param - options : hash of options, must contain:
 * 			str : value to convert
 *
 * returns number variable version
 ************************************************************************************************/
Packages.Library.$.ToNumber = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ToNumber",
		options: options,
		specification: {
			str: {type: "string", required: 1}
		}
	})) return null;
	
	try {
		return options.str * 1;
	} catch(e) {
		return 0;
	}
};

/*************************************************************************************************
 * GetArrayString - Should convert an array to a string, instead returns a textref
 *
 * param - options : hash of options, must contain:
 * 			array : array to convert
 *
 * returns a textref to the array
 ************************************************************************************************/
Packages.Library.$.GetArrayString = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetArrayString",
		options: options,
		specification: {
			array: {type: "array", required: 1}
		}
	})) return null;
	
	return GetTextRef(options.array);
};

/*******************************************************************************
 * CreateArray - creates a multi-dimensional array to match the params given
 *
 * param - options : hash of options, must contain:
 * 			dim : array of sizes for each dimension
 *
 * returns a reference to a multi-dimensional array with each element set to null
 ******************************************************************************/
Packages.Library.$.CreateArray = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateArray",
		options: options,
		specification: {
			dim: {type: "array", required: 1}
		}
	})) return null;
	
	var dim1 = options.dim.shift();
    var array = new Array(dim1);
    for(var i=0; i < dim1; i++){
        if(options.dim[0] != null) {
			array[i] = Packages.Library.$.CreateArray({dim: Packages.Library.$.Clone({oldObj: options.dim})});
        } else {
			array[i] = null;
		}
    }
    return array;
};

/*******************************************************************************
 * DisplayNumericCommas - converts the number into a string with commas separating
 * thousands
 *
 * param - options : hash of options, must contain:
 * 			num : the source
 *
 * returns the string of the number with comma separations
 ******************************************************************************/
Packages.Library.$.DisplayNumericCommas = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.DisplayNumericCommas",
		options: options,
		specification: {
			num: {type: "number", required: 1}
		}
	})) return null;
	
    var str = options.num + "";
    var pstr = "";
    while(str != pstr) {
		pstr = str;
		str = str.replace(/(\d)(\d\d\d$)/, "$1,$2");
		str = str.replace(/(\d)(\d\d\d\.)/, "$1,$2");
		str = str.replace(/(\d)(\d\d\d,)/, "$1,$2");
    }
    return str;
};

/********************************************************************
 * MakeTableFromJSArray - takes the javascript nested 2D array, and creates the
 * equivalent table in HTML
 *
 * param - options : hash of options, must contain:
 * 				array : nested 2D array of cells
 * 			may contain:
 * 				classname : classname for the table
 *
 * returns the HTML for this table or null on error
 *******************************************************************/
Packages.Library.$.MakeTableFromJSArray = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeTableFromJSArray",
		options: options,
		specification: {
			array: {type: "array", required: 1},
			classname: {type: "string"}
		}
	})) return null;
	
	var classname = (options.classname != null ? "class='"+  classname + "'" : "");
	var array = options.array;
    var html = []; // Each row
    
    for (var i = 0; i < array.length; i++) {
		for(var j = 0; j < array[i].length; j++) {
			if(html[j] == null) html[j] = "";
			html[j] += "<td>" + array[i][j] + "</td>";
		}
    }
    var ret = "<table " + classname + ">";
    for(var i = 0; i< html.length; i++) {
		ret += "<tr>" + html[i] + "</tr>";
    }
    return ret + "</table>";
};

/*************************************************************************************************
 * IsEven - Detects whether the given number is even
 *
 * param - options : hash of options, must contain:
 * 			num : number to test
 * 		may contain:
 * 			invert : 1 to invert, 0 (default) not to
 *
 * returns 1 if even, or 0 if not, or null on error
 ************************************************************************************************/
Packages.Library.$.IsEven = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.IsEven",
		options: options,
		specification: {
			num: {type: "number", required: 1},
			invert: {type: "boolean"}
		}
	})) return null;
	
	if(options.invert != null) options.num += options.invert;
	return (options.num / 2 == Math.floor(options.num / 2) ? 0 : 1);
};

/*******************************************************************************
 * GetAngleBetweenPoints - gets the angle of x2,y2 from x1,y1
 *
 * param - options : hash of options, must contain:
 * 		x1,y1 - first cell (centre), if not specified, assumes 0,0
 * 		x2,y2, target
 *
 * returns the angle in degrees
 ******************************************************************************/
Packages.Library.$.GetAngleBetweenPoints = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetAngleBetweenPoints",
		options: options,
		specification: {
			x1: {type: "number"},
			x2: {type: "number"},
			y1: {type: "number", required: 1},
			y2: {type: "number", required: 1}
		}
	})) return null;
	
	var x1 = options.x1;
	var x2 = options.x2;
	var y1 = options.y1;
	var y2 = options.y2;
	
	if(x1 == null) x1 = 0;
	if(y1 == null) y1 = 0;
	
	return (Packages.Library.$.GetAngle({oposite: y2 - y1, adjacent: x2 - x1}) * 360 ) / ( 2 * Math.PI);
};

/*******************************************************************************
 * GetAngle - gets the angle of oposite and adjacent
 *
 * param - options : hash of options, must contain:
 * 			oposite : oposite length
 * 			adjacent : adjacent length
 *
 * returns the angle in radians
 ******************************************************************************/
Packages.Library.$.GetAngle = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetAngle",
		options: options,
		specification: {
			oposite: {type: "number", required: 1},
			adjacent: {type: "number", required: 1}
		}
	})) return null;
	
	var oposite = options.oposite;
	var adjacent = options.adjacent;

	if(oposite == 0 && adjacent == 0) return 0;
	
	return Math.atan2(oposite, adjacent);
};

/*******************************************************************************
 * GetMidPoint - gets the mid point between a and b, where p states how far
 * between a and b we are
 *
 * param - options : hash of options, must contain:
 * 			a : start value
 * 			b : end value
 * 			progress : progress (0.0 - 1.0)
 *
 * returns the mid value
 ******************************************************************************/
Packages.Library.$.GetMidPoint = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetMidPoint",
		options: options,
		specification: {
			a: {type: "number", required: 1},
			b: {type: "number", required: 1},
			progress: {type: "number", required: 1}
		}
	})) return null;
	
    return options.a + (options.b - options.a) * options.progress;
};

/*******************************************************************************
 * GetKeys - gets an array of keys in an object
 *
 * param - options : hash of options, must contain:
 * 			object : object to load keys from
 *
 * returns the array of keys
 ******************************************************************************/
Packages.Library.$.GetKeys = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetKeys",
		options: options,
		specification: {
			object: {type: "object", required: 1}
		}
	})) return null;
	
    var keys = [];
	for(var key in options.object) {
		keys.push(key);
	}
	return keys;
};

Packages.Library.$c.MakeComplexConditionFormItem = {
	conditionDefs: [
		{ref: "equals",			eval: "<%1%> == <%2%>",				name: "Exact Match"},
		{ref: "notequals",		eval: "<%1%> != <%2%>",				name: "Does Not Match"},
		{ref: "lessthan",		eval: "<%1%> < <%2%>",				name: "Less Than"},
		{ref: "greaterthan",	eval: "<%1%> > <%2%>",				name: "Greater Than"},
		{ref: "regexp",			eval: "<%1%>.match(new RegExp(<%2%>)) != null",	name: "Regular Expression"},
		{ref: "contains",		eval: "<%1%>.indexOf(<%2%>) != -1",	name: "Contains"},
		{ref: "in",		eval: "<%2%>.indexOf(<%1%>) != -1",	name: "Exists In"}
	]
};

/*******************************************************************************
 * MakeComplexConditionFormItem - makes a standard form item definition that can
 * be inserted into a normal form.
 *
 * Creates one of those filters you see in emails for sorting into folders.
 *
 * Will create multiple lines of:
 * 		If <variable> <matches or don't matches> <value> and
 * 		<variable> <matches or might match> <value>
 *
 * Works with subroutine below, where you pass in the complex array this will
 * return into your parent object, and evaluates out.
 *
 * param - options : all required, must contain:
 * 			itemid : key of the parent object
 * 			item : hash containing extra info to go into top level item
 * 			varDefs : array of variable definitions, each of the type
 * 				name : variable name (label only)
 * 				ref : internal name for this variable
 * 				itemdef : hash containing some of the information for displaying value field
 * 								(select box, text field etc) - same as for an ordinary
 * 								form item, must contain
 * 									type : the form item type
 * 									options: (optional) if a selectbox etc
 * 									value : default value
 *
 * returns the form item def
 ******************************************************************************/
Packages.Library.$.MakeComplexConditionFormItem = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MakeComplexConditionFormItem",
		options: options,
		specification: {
			itemid: {type: "string", required: 1},
			item: {type: "object", required: 1},
			varDefs: {type: "array", required: 1}
		}
	})) return null;
	
	if(options.varDefs.length == 0) {
		return {
			type: "Label",
			label: "No options",
			size: 5
		};
	}
	
	// Get the array of condition options for the selectbox
	var conditionOptions = [];
	for(var i = 0; i < Packages.Library.$c.MakeComplexConditionFormItem.conditionDefs.length; i++) {
		var conditionDef = Packages.Library.$c.MakeComplexConditionFormItem.conditionDefs[i];
		conditionOptions.push({
			name: conditionDef.name,
			value: conditionDef.ref
		});
	}
	
	// Get the array of attribute form defs for the main form item below
	var attributeFormDefs = [];
	for(var i = 0; i < options.varDefs.length; i++) {
		var varDef = options.varDefs[i];
		
		// Create the value form item
		var formitem = varDef.itemdef;
		formitem.name = "Value";
		formitem.description = "This value will be compared to the attribute with the condition you set.";
		formitem.id = "value";
		
		// Add attribute to form defs
		attributeFormDefs.push({
			ref: varDef.ref,
			name: varDef.name,
			form: {
				items: [
					{
						type: "SelectBox",
						name: "Condition",
						description: "Select the condition to compare to your value",
						options: conditionOptions,
						id: "condition",
						required: 1
					},
					formitem
				]
			}
		});
	}
	
	// Build form item
	var item = options.item;
	if(item == null) item = {};
	item.id = options.itemid;
	item.type = "MultiForm";
	item.title = "variable";
	item.form = {
		type: "Form",
		items: [
			{
				name: "Attributes",
				description: "Select an attribute to be compared",
				id: "variable",
				value: options.varDefs[0].ref,
				type: "ChoiceForm",
				formdefs: attributeFormDefs,
				required: 1
			}
		]
	};
	return item;
};

/*******************************************************************************
 * EvaluateComplexCondition - evaluates a Complex Condition with a given hash of
 * data.
 *
 * The variable ref must be the key in the specified hash
 *
 * The format of a conditions array, is an array of hashes, each of the form:
 * 		condition : the name of one of the matchdefs
 * 		variable : the name of key in data
 * 		value : a value to match against
 *
 * param - options: hash of data, must contain:
 * 				data : the hash object to load data from
 * 				conditions : array of conditions (returned from MakeComplexConditionFormItem)
 *
 * returns a true or false (1 or 0) depending on the conditions
 ******************************************************************************/
Packages.Library.$.EvaluateComplexCondition = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EvaluateComplexCondition",
		options: options,
		specification: {
			data: {type: "object", required: 1},
			conditions: {type: "array", required: 1}
		}
	})) return 1; // Legacy fail safe - must return 1 on failure
	
	var conditions = options.conditions;
	var hash = options.data;
	
	// All conditions must be OK, if any condition fails we return 0 instantly
	// If we get to the end and we haven't returned a 0 yet, return a 1 true.
	
	for(var i = 0; i < conditions.length; i++) {
		var condition = conditions[i];
		
		// Evaluate condition safely
		try {
			// Get match def
			var matchdef = Packages.Library.$.FindArrayItem({array: Packages.Library.$c.MakeComplexConditionFormItem.conditionDefs, path: "ref", value: condition.condition});
			
			var evalcmd = matchdef.eval;
			
			var value = hash[condition.variable]
			if(value != null && typeof(value) != "object") value = Packages.Library.$.PerformGlobalReplacements({content: value});
			var matchValue = condition.value;
			if(matchValue != null) matchValue = Packages.Library.$.PerformGlobalReplacements({content: matchValue});
			
			// Do replacements - replace with variable names, so need to to escape value contents
			evalcmd = evalcmd.replace(/<%1%>/, "value")
							 .replace(/<%2%>/, "matchValue");
			
			// Do eval
			var res = eval(evalcmd);
			
			// Evaluate response
			if(res == 0) return 0;
		} catch(e) {
			var m = e.mesg;
		} // Do nothing, ignore...
	}
	
	// Nobody said we can't do this, so return 1
	return 1;
};
/*******************************************************************************
 * GetEpochFromDate - gets EPoch from Date Field format
 *
 * param - options : hash of options, must contain:
 * 			date : the date returned from a date field
 *
 * Returns the epoch
 ******************************************************************************/
Packages.Library.$.GetEpochFromDate = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetEpochFromDate",
		options: options,
		specification: {
			date: {type: "string", required: 1}
		}
	})) return null;
	
	var value = options.date;
	
	if(value.match(/^(\d+?)-(\d+?)-(\d+?)$/)) {
		// Fix dates
		var year = parseInt(RegExp.$1); var month = RegExp.$2; var day = parseInt(RegExp.$3);
		var date = new Date(year, month - 1, day);
		return date.getTime() / 1000;
	}
	return 0;
}
/*******************************************************************************
 * TidyValueForEval - tidies the specified value ready for an eval
 *
 * Wraps strings in quotes
 * Removes prefixing 'pound' signs
 *
 * param - options : hash of options, must contain:
 * 			value : the source value
 *
 * Returns the tidied value
 ******************************************************************************/
Packages.Library.$.TidyValueForEval = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.TidyValueForEval",
		options: options,
		specification: {
			value: {type: "string,number"}
		}
	})) return null;
		
	var value = options.value;
	
	if(value == null) return null;
	if(typeof(value) == "number") return value;
	if(value.match(/^(\d+?)-(\d+?)-(\d+?)$/)) {
		return Packages.Library.$.GetEpochFromDate({date: value});
	}
	if(value.match(/^£/)) {
		// Remove pound prefix
		value = value.replace(/^£/, "");
	}
	if(value.match(/^[0-9\.,]+$/)) {
		// Remove commas from pure numbers
		value = value.replace(/,/g, "");
	}
	if(value.match(/[^0-9\.]/)) {
		// Fix strings
		value = "\"" + value + "\"";
	}
	if(value.match(/\n/)) {
		// Fix line breaks
		value = value.replace(/\n/g, "\\n");
	}
	if(value == "") {
		value = "\"\"";
	}
	
	return value;
};

/*******************************************************************************
 * Split - splits a string into an array (like .split) except skips blanks
 *
 * So if the string is "", .split would return [""]
 * We return []
 *
 * param - options : hash of options, must contain
 * 			value : the value to split, or null for no values
 * 			splitter : character to split on
 *
 * Returns the array of values
 ******************************************************************************/
Packages.Library.$.Split = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Split",
		options: options,
		specification: {
			value: {type: "string"},
			splitter: {type: "string", required: 1}
		}
	})) return null;
	
	if(options.value == null) return [];
	if(options.value == "") return [];
	return options.value.split(new RegExp(options.splitter));
}

/***************************************
 * LoadHexToArray - loads a string of hex into the specified offset of the specified array
 *
 * param - options : hash of options, containing:
 * 		array : array to write hex into
 * 		hexString : string to convert
 * 		wordSize : (optional) size of each block to place into array, default 1 byte
 * 		offset : (optional) offset in bytes from start of memory to load hex into (must be multiple of 4)
 **************************************/
Packages.Library.$.LoadHexToArray = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.LoadHexToArray",
		options: options,
		specification: {
			array: {type: "array", required: 1},
			hexString: {type: "string", required: 1},
			wordSize: {type: "number"},
			offset: {type: "number"}
		}
	})) return null;
	
	if(options.offset == null) options.offset = 0;
	if(options.wordSize == null) options.wordSize = 1;
	wOffset = options.offset / options.wordSize;
	for(var b = 0; b < options.hexString.length / (2 * options.wordSize); b ++) {
		var word = parseInt(options.hexString.substr(b * 2 * options.wordSize, 2 * options.wordSize), 16);
		options.array[wOffset + b] = word;
	}
};

/*******************************************************************************
 * GetType - gets the type of the specified item, more intelligent than typeof
 *
 * May return:
 * 	number, string, boolean, object, null, undefined, array, DOMobject
 *
 * param - options : hash of options, must contain:
 * 			item : item to get type of (may be null)
 * 		may contain:
 * 			strict : 1 (default) be very strict with arrays, 0 don't be
 *
 * returns the type
 ******************************************************************************/
Packages.Library.$.GetType = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetType",
		options: options,
		specification: {
			item: {}, // Accepts any type
			strict: {type: "boolean"}
		},
		doNotTest: 1 // item is commented out to allow any type
	})) return null;
	
	var item = options.item;
	var strict = options.strict;
	
	if(item == null) return "null";
    var type = typeof(item);
	if(type == "undefined") return "null";
	if(type == "unknown") return "null";
	if(type == "object") {
		// Is this a DOM object
		if(item.nodeType != null) return "DOMobject";
		
		if(item.length == null) return "object"; // If the object has no length it is an object
		// Objects may have a length, if all of their keys are numeric
		if(strict == 0) {
			return "array";
		} else {
			if(Array.isArray(item)) {
				// This is definitely an array, and last item exists
				return "array";
			}
		}
	}
	return type;
};

/*******************************************************************************
 * PadString - pads a string to a certain length with the character specified
 *
 * Pads to left
 *
 * param - options : hash of options, must contain:
 * 			value : value to pad
 * 			chr : char to pad with
 * 			length : length to pad to, if exceeds length nothing is done
 * 			right: 1 pads right, 0 (default) pads left
 *
 * returns the padded value
 ******************************************************************************/
Packages.Library.$.PadString = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.PadString",
		options: options,
		specification: {
			value: {type: "string,number", required: 1},
			chr: {type: "string", required: 1},
			length: {type: "number", required: 1},
			right: {type: "boolean"}
		}
	})) return null;
	
	options.value += "";
	if(options.value.length >= options.length) return options.value;
	
	var value = options.value;
	for(i = 0; i < (options.length - options.value.length); i++) {
		if(options.right == 1) {
			value = value + "" + options.chr; //  Force maintain string
		} else {
			value = options.chr + "" + value; //  Force maintain string
		}
	}
	
	return value;
};

/*******************************************************************************
 * CircularShiftRight - shifts the given 32 bit value n bits to the right, and places
 * the overflow on the left
 *
 * param - options : hash of options, must contain:
 * 			value : the 32 bit value
 * 			shift : the number of bits to shift right by
 *
 * returns the new value
 ******************************************************************************/
Packages.Library.$.CircularShiftRight = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CircularShiftRight",
		options: options,
		specification: {
			value: {type: "number"},
			shift: {type: "number"}
		}
	})) return null;
	
	var value = options.value;
	var n = options.shift;
	
    return ((value >>> n) | (value << (32 - n))) & 0xFFFFFFFF;
};

/*******************************************************************************
 * Rotate2DArray - rotates the specified 2D array by the number of degrees
 * specified. Note, only in multiples of 90.
 *
 * Only works on regular 2D arrays (all same length)
 *
 * param - options : hash of options, must contain:
 * 			array : the source array
 * 			deg : the number of degrees
 *
 * returns the new array
 ******************************************************************************/
Packages.Library.$.Rotate2DArray = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Rotate2DArray",
		options: options,
		specification: {
			array: {type: "array"},
			deg: {type: "number"}
		}
	})) return null;
	
	var array = options.array;
	var deg = options.deg;
	
    if(deg == 90 || deg == 270) {
		var rotated = [];
		for(var y = 0; y < array[0].length; y++) {
			var row = [];
			for(var x = 0; x < array.length; x++) {
				row.push(array[x][y]);
			}
			rotated.unshift(row);
		}
		array = rotated;
	}
	
	if(deg >= 180) {
		var flipped = [];
		for(var x = 0; x < array.length; x++) {
			var row = [];
			for(var y = 0; y < array[0].length; y++) {
				row.unshift(array[x][y]);
			}
			flipped.unshift(row);
		}
		array = flipped;
	}
	
	return array;
};

/*******************************************************************************
 * HashString - creates a 64 bit hash of the string specified, and returns the base64 version
 *
 * param - options : hash of options, must contain:
 * 			string : string to hash
 *
 * returns the base64 hash
 ******************************************************************************/
Packages.Library.$.HashString = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.HashString",
		options: options,
		specification: {
			string: {type: "string", required: 1}
		}
	})) return null;
	
	var str = options.string;
	
	var hash = 0;
	for(i = 0; i < str.length; i++) {
		var c = str.charCodeAt(i);
		hash = ((hash << 5) - hash) + c;
		hash |= 0;
	}
	
	return btoa(hash);
};/*********************************************************************
* Messages - stores or relays messages between objects
*
* This must be instatiated to create a new message queuing system
*
* Messages can be sent, if the reciever is available they will be notified
* If the reciever is not yet set, the message will be queued
*
* When a reciever is added, they are notified of all new messages
*
* A purge feature is provided
********************************************************************/
Package("Library").Messages = function() {
	this.textVar = GetTextRef(this);
	this.messages = {};
	/****************************************************************
	 * Send - sends a message to the specified reciever
	 *
	 * param - options : hash of option, must include:
	 * 				recipient : the safe object name of the recipient
	 * 				message : the message to send
	 ***************************************************************/
	this.Send = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.Messages.Send",
			options: options,
			specification: {
				recipient: 	{type: "string",	required: 1},
				message: 	{type: "string,object",	required: 1}
			}
		})) return;

		// Create a blank recipient if it doesn't already exist
		if(this.messages[options.recipient] == null) this.messages[options.recipient] = {messages: [], recievers: []};
		
		// Append message
		this.messages[options.recipient].messages.push(options.message);
		
		// Notify
		this.Notify({recipient: options.recipient});
	};
	/****************************************************************
	 * Notify - if a reciever is set up, sends the current messages and purges the list.
	 * Otherwise does nothing
	 *
	 * param - options : hash of options, must include:
	 * 				recipient : the safe object name of the recipient
	 ***************************************************************/
	this.Notify = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.Messages.Notify",
			options: options,
			specification: {
				recipient: 	{type: "string",	required: 1}
			}
		})) return;

		if(this.messages[options.recipient] == null) return;
		
		if(this.messages[options.recipient].recievers.length == 0) return; // No recievers set
		
		var messagesSent = 1;
		
		// Iterate through stored messages, and send
		for(var i = 0; i < this.messages[options.recipient].messages.length; i++) {
			// Send message to each reciever
			for(var j= 0; j < this.messages[options.recipient].recievers.length; j++) {
				if(this.messages[options.recipient].recievers[j](this.messages[options.recipient].messages[i]) == 0) messagesSent = 0;
			}
		}
		
		if(messagesSent == 0) {
			// Try again in a moment
			setTimeout(this.textVar + ".Notify({recipient: '" + options.recipient + "'})", 100);
			return;
		}
		
		// Messages sent successfully
		
		// Purge all messages
		this.messages[options.recipient].messages = [];
	};
	/****************************************************************
	 * SetReciever - adds the specify reciever to the list of recievers of these messages
	 *
	 * param - options : hash of options, must include:
	 * 				recipient : the safe object name of the recipient
	 * 				callback : the callback to execute for each message
	 ***************************************************************/
	this.SetReciever = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.Messages.SetReciever",
			options: options,
			specification: {
				recipient: 	{type: "string",	required: 1},
				callback: 	{type: "function",	required: 1}
			}
		})) return;

		// Create a blank recipient if it doesn't already exist
		if(this.messages[options.recipient] == null) this.messages[options.recipient] = {messages: [], recievers: []};
		
		// Append reciever
		this.messages[options.recipient].recievers.push(options.callback);
		
		// Notify
		this.Notify({recipient: options.recipient});
	};
};Package("Library").Package = function() {};
/*************************************************************************************************
 * Debug Levels, when a debug level is selected, all actions lower than that level apply
 *
 * 0 : No debugging - fastest, no errors are recorded, and no validation is even attempted
 * 1 : Log Only - validates, and logs to 'pageinfo' area only (default)
 * 2 : Skip automated error detection (logging) and use browser debugger
 * 3 :
 * 4 :
 * 5 : Alert - send a JavaScript 'Alert()' every time an issue occurs
 ************************************************************************************************/
/*************************************************************************************************
 * Package - Gets or creates a package of this type and returns the package object
 *
 * For each package (with is an empty hash) there are extra properties
 * 	$ : for class methods
 * 	$i : for instantiated objects
 * 	$c : for constants
 * 	$k : for classes (jscb)
 * 	$o : for objects (by an internal reference)
 * 	$s : for sub classes
 * 	$v : for variables (by an internal reference)
 *
 * param - packageName : the name space of this package
 *
 * returns the object
 ************************************************************************************************/
function Package(packageName) {
	if(typeof(Packages) == 'undefined') Packages = {$i: {}, $: {}};
	
	var alreadyExisted = 1;
	
	var spaces = packageName.split(".");
	var container = Packages;
	for(var i = 0; i < spaces.length; i++) {
		var nameSpace = spaces[i];
		if(container[nameSpace] == null) {
			container[nameSpace] = {$:{}, $i: {}, $c: {}, $o: {}, $v: {}, $s: {}};
			
			if(i == spaces.length - 1) alreadyExisted = 0; // The final name space did not exist
		}
		container = container[nameSpace]; // Move container to next namespace
	}
	
	if(!alreadyExisted) {
		if(Packages.$i.registeredPackages == null) Packages.$i.registeredPackages = [];
		Packages.$i.registeredPackages.push(container);
	}
	
	return container;
}
/*************************************************************************************************
 * Objectise - takes an ordinary 'persistent data hash' and adds the objectType attribute to it
 * that contains the methods for this data.
 *
 * The objectType attribute is an object that will be set to inherit from the
 *  superClass (if specified)
 * When constructed, the data hash is sent as the only parameter, so the object can work on the
 *  data
 * Finally, if an 'Update' function is found in the object, it is executed. This can be used to
 *  update the referenced data to the latest format before any execution
 *
 * The object name is deduced from the containerPackage, followed by the data.type attribute,
 *  the objectType is usually the filename of the exact class to use
 *
 * If a class can not be found, the superClass is constructed and returned in its place
 *
 * param - options : hash of options, must contain:
 * 			containerPackage : the container package
 * 			data : the data hash to apply object to
 * 			objectType : (view.js) or (edit.js) etc (the name of the file without extension)
 * 		may contain:
 * 			superClass : the super class to inherit from
 *
 * no return, the panel is altered
 ************************************************************************************************/
Packages.Library.$.Objectise = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Objectise",
		options: options,
		specification: {
			containerPackage: {type: "object", required: 1},
			data: {type: "object", required: 1},
			objectType: {type: "string", required: 1},
			superClass: {type: "function"}
		}
	})) return;
	
	var data = options.data;
	var objectType = options.objectType;
	var containerPackage = options.containerPackage;
	
	if(data.type == null) return;
	
	if(data[objectType] != null) return; // Already Objectised
	
	// Assumes class is loaded
	var type = data.type;
	
	// Insert object into data
	if(typeof(containerPackage[type]) == "object") {
		if(containerPackage[type].$k != null) {
			// Same class used for all objectTypes
			data[objectType] = new containerPackage[type].$k();
			data[objectType].data = data; // Put data into this object
		}
		if(containerPackage[type][objectType] != null) {
			// Different class used for each objectType (legacy)
			data[objectType] = new containerPackage[type][objectType](data);
		}
	}
	if(data[objectType] == null) {
	  	// Unknown class, use default
		if(options.superClass != null) data[objectType] = new options.superClass(data);
	} else {		
		// Add the prototype (superclass)
		if(options.superClass != null) data[objectType].prototype = new options.superClass();
	}
	
	// Update (if supported)
	if(data[objectType] != null && data[objectType].Update != null) data[objectType].Update();
	
	data.$noDump = {cache: {}, uid: Packages.Library.$.GetUniqueId({})};
};
/*************************************************************************************************
 * GetTextRef - Gets a text variable that can be used to reference the specified object
 *
 * param - object : the object to reference
 *
 * returns a text field that evaluates to this object
 ************************************************************************************************/
function GetTextRef(object) {
	if(Packages.$i.TextVars == null) Packages.$i.TextVars = [];
	var entry = Packages.$i.TextVars.length;
	Packages.$i.TextVars[entry] = object;
	object.$id = entry;
	return "Packages.$i.TextVars[" + entry + "]";
}
/*************************************************************************************************
 * GetSingleton - Gets the singleton instance of a class - if the class does not exist, creates
 * the singleton and returns its reference
 *
 * Instance is stored in $i, this can be done by the class itself - it doesn't matter
 *
 * No constructor is ever called on a singleton, the code should be placed within the class to be
 * executed upon instance
 *
 * param - basePackage : (not in quotes) everything except the class itself (the bit before the $i), Eg Packages.Library
 * param - className : (in quotes) the class name (the bit after the $i), Eg Subscribe
 * param - initMethod : (optional) method to call on object when created
 *
 * returns the singleton
 ************************************************************************************************/
function GetSingleton(basePackage, className, initMethod) {
	try {
		if(basePackage.$i[className] != null) return basePackage.$i[className];
		var theClass = basePackage[className];
		basePackage.$i[className] = Packages.Library.$.CreateObject({c: theClass});
		if(initMethod != null) basePackage.$i[className][initMethod]();
		return basePackage.$i[className];
	} catch(e) {
		Packages.Library.$.LogInfo({mesg: "Failed to create singleton for '" + className + "' with error: " + e.message, location: "Packages.Library.$.GetSingleton", type: "Class not found", level: 5});
	}
	return null;
}

/*************************************************************************************************
 * GetPackageClassDetails - gets details about the Package specified
 *
 * Instantiates the class and calls GetDetails on the object
 *
 * param - packageClass : the package function
 *
 * returns details about the package, or null if an error occured
 ************************************************************************************************/
function GetPackageClassDetails(packageClass) {
	if(packageClass == null) return null;
	
	// Try to get details using .$.GetDetails
	if(packageClass.$ != null && packageClass.$.GetDetails != null) return packageClass.$.GetDetails();
	
	// Try to get details using GetDetails on the instantiated object
	if(packageClass.$k != null) {
		var obj = Packages.Library.$.CreateObject({c: packageClass.$k, blank: 1});
		if(obj == null) return null;
		if(obj.GetDetails == null) return null;
		return obj.GetDetails();
	}
	
	return null;
}
/*************************************************************************************************
 * CreateObject - Creates a new object of type c, c maybe the container or the class, E.g
 * 	Packages.FileType.mhtm or Packages.FileType.mhtm.$k
 *
 * Also calls init on the object
 *
 * param - options, hash of options, must contain:
 * 			c : (not in quotes) the Packages, eg Packages.FileType.txt
 * 		may contain:
 * 			options : hash of options to set on object (if supported)
 * 			params : hash of params to pass when calling constructor
 * 			blank : 1 if this is a blank object (so don't set anything up), 0 (default) if it is normal
 *
 * returns the newly created object or null on error
 ************************************************************************************************/
Packages.Library.$.CreateObject = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateObject",
		options: options,
		specification: {
			c: {type: "object,function", required: 1},
			options: {type: "object"},
			params: {type: "object"},
			blank: {type: "boolean"}
		}
	})) return null;
	var c = options.c;
	var initoptions = options.options;
	var params = options.params;
	var blank = options.blank;
	
	if(typeof(c) == "object" && c.$k != null) c = c.$k;
	if(typeof(c) != "function") {
		Packages.Library.$.LogInfo({mesg: "CreateObject was not passed a valid Package", location: "Packages.Library.$.CreateObject", type: "No Package", level: 1});
		return null;
	}
	
	// Store InstantiateBlank
	var _instatiateBlank = Packages.Library.$v.InstantiateBlank;
	if(blank == 1) {
		Packages.Library.$v.InstantiateBlank = 1;
	}
	var obj = new c(params);
	if(blank != 1) {
		if(obj.$init != null) obj.$init(initoptions);
	}
	//Restore InstantiateBlank
	Packages.Library.$v.InstantiateBlank = _instatiateBlank;
	
	return obj;
}
/*************************************************************************************************
 * MergeIn - merges the items of the second object into the first object
 *
 * Used to extend an existing class, with items from another class.
 *
 * param - options : hash of options, must contain:
 * 			_this : primary object that will take the new items
 * 			extra : extra object that supplies the new items
 ************************************************************************************************/
Packages.Library.$.MergeIn = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.MergeIn",
		options: options,
		specification: {
			_this: {type: "object", required: 1},
			extra: {type: "object", required: 1}
		}
	})) return;
	
	Packages.Library.$.Merge({
		base: options._this,
		extra: options.extra,
		shallow: 1
	})
};

/*************************************************************************************************
 * ValidateOptions - ensures that the options specified conforms to the specification
 *
 * Check is recursive
 *
 * param - options: hash of options including:
 * 		calledFrom : name of location called from
 * 		options : (nested) hash of options (may be null if no options provided)
 * 		specification : hash specification of how the options should appear, of the form
 * 			key (key used in options): hash of specification for this option, of the form
 * 					type: comma separated list of types of the item (array, hash, string, number, function, DOMobject)
 * 										as Packages.Library.$.GetType
 * 					required: 1 this key is required, 0 optional
 * 					(the following are optional)
 * 						(for number)
 * 							min
 * 							max
 * 							integer : (true / false)
 * 							value : value it must equal if defined
 * 						(for string)
 * 							min : length
 * 							max : length
 * 							value : value it must equal if defined
 * 						(for array)
 * 							min : length
 * 							max : length
 * 							specification : specification of each item in array
 * 						(for object)
 * 							specification : specification of each item in array
 * 		path : (optional) (internal) path to this key
 * 		skipValidate : (optional) 1 skip validation, 0 (default) validate
 * 		optionsPassedTo : (optional) array of functions that this same set of options is passed to
 *
 * Returns 1 if ok, or 0 if failed, also logs an error as to why.
 ************************************************************************************************/
Packages.Library.$.ValidateOptions = function(options) {
	if(options.$getOptions == 1) {
		// Can not call ValidateOptions otherwise recursion will occur
		Packages.Library.$v.packageLastOptions = {
			calledFrom: "Packages.Library.$.ValidateOptions",
			options: options,
			specification: {},
			doNotTest: 1
		};
		return 1;
	}
	
	// Must check whether we are fetching options first - in GetFunctionDef
	// calls to functions with $getOptions enabled are done within the call to
	// ValidateOptions (which sets DebugLevel to 0). Therefore this check must
	// be done first.
	if(options.options != null && options.options.$getOptions == 1) {
		// Store options
		Packages.Library.$v.packageLastOptions = options;
		
		// Tell caller to stop
		return 0;
	}
	
	if(Packages.Library.$c.DebugLevel == 0) return 1; // Validation disabled
	
	if(options.skipValidate == 1) return 1;
	
	// Disable validation while validating to stop recursion
	var currentDebugLevel = Packages.Library.$c.DebugLevel;
	Packages.Library.$c.DebugLevel = 0;
	
	// Allow options to be null - because so many calls rely on this
	if(options.options == null) options.options = {};
	
	// Validate own options
	var error = "";
	if(options.calledFrom == null) error += "Missing 'calledFrom' option. ";
	if(options.options == null) error += "Missing 'options' option. ";
	if(options.specification == null) error += "Missing 'specification' option. ";
	
	if(error != "") {
		var calledFrom = options.calledFrom;
		if(calledFrom == null) {
			calledFrom = "unknown [" + Packages.Library.$.GetCallStack() + "]";
		}
		Packages.Library.$.LogInfo({mesg: error + "Called from: " + calledFrom, location: "Packages.Library.$.ValidateOptions", type: "Missing Arguments", level: 2});
		
		// Restore debug level and return
		Packages.Library.$c.DebugLevel = currentDebugLevel;
		return 0;
	}
	
	Packages.Library.$.ProcessFunctionDef({
		def: options
	})
	
	var path = options.path;
	if(path == null) path = "";
	var errors = [];
	// Iterate through specification
	for(var key in options.specification) {
		var spec = options.specification[key];
		var pathkey = path + key;
		if(options.options[key] == null) {
			// Key in spec does not exist in options
			if(spec.required == 1) {
				// Required
				errors.push("[" + pathkey + "] is required and missing.");
			}
		} else {
			// Key exists, check
			var val = options.options[key];
			if(!Packages.Library.$._ValidateOption({
				calledFrom: options.calledFrom,
				spec: spec,
				val: val,
				path: path,
				key: key
			})) errors.push("[" + pathkey + "] did not validate, type: " + Packages.Library.$.GetType({item: val}) + " should be: " + spec.type);
		}
	}
	var res = 1;
	if(errors.length > 0) {
		// Get call stack position
		var stack = Packages.Library.$.GetCallStack();
		
		for(var i = 0; i < errors.length; i++)  {
			Packages.Library.$.LogInfo({mesg: errors[i], location: options.calledFrom + stack, type: "Bad Arguments", level: 2});
		}
		res = 0;
	}
	
	// Restore debug level and return
	Packages.Library.$c.DebugLevel = currentDebugLevel;
	return res;
};

/*************************************************************************************************
 * GetCallStack - returns text listing the callstack
 *
 * param - options : hash of options, may contain:
 * 				ex : the exception to read stack data from
 *
 * return - the callstack
 ************************************************************************************************/
Packages.Library.$.GetCallStack = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetCallStack",
		options: options,
		specification: {
			ex: {type: "object"}
		}
	})) return null;
	
	var stack = null;
	if(options == null) options = {};
	if(Packages.Library.$v.testing == 1) options.ex = null; // Does not work
	if(options.ex != null) stack = options.ex.stack;
	if(stack == null) try { var a = {}; a.debug(); } catch(ex) {stack = "\n" + ex.stack;}
	// Trim stack
	var stacks = stack.split(/\n/);
	stack = stack.replace(/</, "&lt;").replace(/>/, "&gt;");
	if(options.ex == null) stacks.splice(1, 2); // Remove 2nd and third entries when generating our own stack
	
	if(Packages.Library.$v.testing == 1) {
		stacks.pop(); // Remove caller as this varies from test to test
	}
	
	stack = stacks.join("\n");
	
	// Remove location of error - as meaningless
	if(options.ex == null) stack = stack.replace(/at ([A-Za-z0-9\.\$]+) \([^\(]*\)/g, "$1");
	
	return stack;
}

/*************************************************************************************************
 * ProcessFunctionDef - processes a functions def, and follows any optionsPassedTo
 *
 * RECURSIVE
 *
 * param - options : hash of options, must contain:
 * 				def : the base def to process - alters this def
 ************************************************************************************************/
Packages.Library.$.ProcessFunctionDef = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ProcessFunctionDef",
		options: options,
		specification: {
			def: {type: "object", required: 1}
		}
	})) return;
	
	var def = options.def;
	
	// Fetch optionsPassedTo
	var optionsPassedTo = def.optionsPassedTo;
	if(optionsPassedTo != null) {
		for(var i = 0; i < optionsPassedTo.length; i++) {
			var fn = optionsPassedTo[i];
			var subDef = Packages.Library.$.GetFunctionDef({
				fn: fn
			});
			if(subDef != null) {
				Packages.Library.$.ProcessFunctionDef({
					def: subDef
				});
				
				// Add this sub defs options to our own if we don't have one already
				for(var key in subDef.specification) {
					if(def.specification[key] == null) def.specification[key] = subDef.specification[key];
				}
			} else {
				Packages.Library.$.LogInfo({mesg: "Failed to load optionsPassedTo[" + i+  "] spec from [" + def.calledFrom + "]", location: "Packages.Library.$.ProcessFunctionDef" + Packages.Library.$.GetCallStack(), type: "No Options", level: 4});
			}
		}
	}
	
	// Follow optionsFor (never used nor tested)
	for(var key in def.specification) {
		var spec = def.specification[key];
		var optionsFor = spec.optionsFor;
		if(optionsFor != null) {
			var fn = optionsFor;
			var subDef = Packages.Library.$.GetFunctionDef({
				fn: fn
			});
			if(subDef != null) {
				Packages.Library.$.ProcessFunctionDef({
					def: subDef
				});
				
				spec.specification = subDef.specification;
			}
		}
	}
}

/***************************************************************
 * GetFunctionDef - gets the specificationm from a given function
 *
 * param - options : hash of options, may include:
 * 			functionName : the name of the function
 * 		and as for CallFunction
 *
 * return - specification of function or null if an error occured
 **************************************************************/
Packages.Library.$.GetFunctionDef = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetFunctionDef",
		options: options,
		specification: {
			functionName: {type: "string"}
		},
		optionsPassedTo: [
			Packages.Library.$.CallFunction
		]
	})) return null;
	
	var functionName = options.functionName;
	if(functionName == null) functionName = "Not provided by caller";
	
	Packages.Library.$v.packageLastOptions = null;
	
	if(options.fnOptions == null) options.fnOptions = {};
	options.fnOptions.$getOptions = 1;
	var res = Packages.Library.$.CallFunction(options);
	
	var def = Packages.Library.$v.packageLastOptions;
	
	if(Packages.Library.$v.testing == 1) {
		return def; // Do not output validation messages
	}
	
	if(def == null) {
		Packages.Library.$.LogInfo({mesg: "Failed to load options for [" + functionName + "], no def.", location: "Packages.Library.$.GetFunctionDef" + Packages.Library.$.GetCallStack(), type: "No Options", level: 4});
		return null;
	}
	// Does the location match the functionName (if given)?
	if(options.functionName != null && def.calledFrom != options.functionName) {
		Packages.Library.$.LogInfo({mesg: "Failed to load options for [" + functionName + "], found [" + def.calledFrom + "] instead.", location: "Packages.Library.$.GetFunctionDef", type: "No Options", level: 4});
		return null;
	}
	
	return def;
}

/***************************************************************
 * CallFunction - calls the specified function with the specified options (params)
 * in test mode, and optionally cleans up afterward any side effects
 *
 * param - options : hash of options, must contain:
 * 			fn : the function
 * 		may contain:
 * 			fnOptions : options to pass to fn
 * 			cleanup : 1 cleanup, 0 don't
 *
 * return - result from fn
 **************************************************************/
Packages.Library.$.CallFunction = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CallFunction",
		options: options,
		specification: {
			fn: {type: "function", required: 1},
			fnOptions: {type: "object"},
			cleanup: {type: "boolean"}
		}
	})) return null;
	
	var fn = options.fn;
	var fnOptions = options.fnOptions;
	var cleanup = options.cleanup;
	
	var _currentTestingValue = Packages.Library.$v.testing; // May already be testing
	Packages.Library.$v.testing = 1;
	// Record current textvar size
	var textvarLength = Packages.$i.TextVars.length;
	
	// Call the function
	var res;
	try {
		res = fn(fnOptions);
	} catch(e) {res = {crashError: e.message}};
	
	if(cleanup) {
		// Cut textvars to previous size
		Packages.$i.TextVars.splice(textvarLength, Packages.$i.TextVars.length - textvarLength);
	}
	
	Packages.Library.$v.testing = _currentTestingValue; // Reset to what it was before
	
	return res;
};

/*************************************************************************************************
 * _ValidateOption - see ValidateOptions above, validates a specific option
 ************************************************************************************************/
Packages.Library.$._ValidateOption = function(options) {
	var errors = [];
	var pathkey = options.path + options.key;
	var spec = options.spec;
	var val = options.val;
	// Is val type, in our camma separated list of types?
	var res = 1;
	if(spec.type == null) return 1; // No type specified, accepts anything
	if(!spec.type.match(new RegExp(Packages.Library.$.GetType({item: val})))) res = 0;
	if(spec.type.match(/boolean/) && (val == 0 || val == 1)) {
		// Special case - 0 and 1 are boolean as well as true and false
		res = 1;
	}
	if(res == 0) {
		errors.push("[" + pathkey + "] type [" + Packages.Library.$.GetType({item: val}) + "] is not of type " + spec.type);
	}
	
	// Test the specifics of this val
	try {
		switch(Packages.Library.$.GetType({item: val})) {
			case "boolean": break; // No options
			case "number": {
				if(spec.min != null && val < spec.min) 				{errors.push("Option [" + pathkey + "], value [" + val + "] is less than " + spec.min);}
				if(spec.max != null && val > spec.max) 				{errors.push("Option [" + pathkey + "], value [" + val + "] is more than " + spec.max);}
				if(spec.integer != null && Math.floor(val) == val) 	{errors.push("Option [" + pathkey + "], value [" + val + "] is not an integer");}
				if(spec.value != null && spec.value != val) 		{errors.push("Option [" + pathkey + "], value [" + val + "] is not equal to " + spec.value);}
				break;
			}
			case "string": {
				if(spec.min != null && val.length < spec.min) 		{errors.push("[" + pathkey + "] length is less than " + spec.min);}
				if(spec.max != null && val.length > spec.max) 		{errors.push("[" + pathkey + "] length is more than " + spec.max);}
				if(spec.value != null && spec.value != val) 		{errors.push("[" + pathkey + "] is not equal to " + spec.value);}
				break;
			}
			case "array": {
				if(spec.min != null && val.length < spec.min) 		{errors.push("[" + pathkey + "] length is less than " + spec.min);}
				if(spec.max != null && val.length > spec.max) 		{errors.push("[" + pathkey + "] length is less than " + spec.max);}
				// Check all items in array
				if(spec.values != null) {
					for(var i = 0; i < val.length; i++) {
						var arr = val[i];
						if(!Packages.Library.$.ValidateOptions({
							calledFrom: options.calledFrom,
							specification: spec.values,
							options: arr,
							path: pathkey + "[" + i + "]."
						})) errors.push("[" + pathkey + "] array did not validate");;
					}
				}
				break;
			}
			case "object": {
				// Check items
				if(spec.values != null) {
					if(!Packages.Library.$.ValidateOptions({
						calledFrom: options.calledFrom,
						specification: spec.values,
						options: val,
						path: pathkey + "."
					})) errors.push("[" + pathkey + "] object did not validate");
				}
				break;
			}
		}
	} catch(e) {
		errors.push("[" + pathkey + "] error validating " + e.message);
	}
	if(errors.length > 0) {
		for(var i = 0; i < errors.length; i++)  {
			Packages.Library.$.LogInfo({mesg: errors[i], location: options.calledFrom, type: "Bad Arguments", level: 2});
		}
		return 0;
	} else {
		return 1;
	}
}

/*************************************************************************************************
 * Include - Fetches additional resources from the server
 * 
 * param - includes : array of file entries that describe the resources required of the form
 * 		packname : (optional) package name (will attempt to load)
 * 		file : (optional) file to be sent to Dynamic Loader
 * 		data : (optional) data to send to sub includes
 * param - callback : called when all files (and in the case of packages, all dependencies) have been loaded
 *
 * Where only a packname is specified, it gets the path of the package from the parent packages $p variable.
 * Package("<parent packname>").$p = "<abs path to folder containing resource files>"
 *
 * Iterates through all of the packages and gets the JS files required
 * Calls a DynamicLoad on all files
 * 	DynamicLoad fetches all files and then calls back FetchDone
 * FetchDone calls each new Package in turn and attempts to run its Include (if it has one)
 * 		The include will return the same as 'includes'
 * A new include object is created (with the parents object) for each return (recurse)
 * If no includes are found for the new Packages, the object is set to 'completed' and fires ChildDone on the parent object
 * Each time ChildDone is fired, it checks all of its child objects to see if any are waiting.
 * If none are waiting it sets itself to 'completed' and calls ChildDone on the parent
 * The object is the primary object (has a callback and no parent) the callback is fired and the object exits.
 * 
 ************************************************************************************************/
Package("Library").Include = function(includes, callback) {
	this.callback = callback;
	this.includes = includes;
	this.textVar = GetTextRef(this);
	this.active; // used to test whether object is still working
	/*************************************************************************************************
	* Fetch - Does the work
	*
	************************************************************************************************/
	this.Fetch = function() {
		this.active = 1;
		var files = [];
		for(var i = 0; i < includes.length; i++) {
			if(includes[i].packname != null) {
				var packname = includes[i].packname;
				// Is this already loaded?
				var loaded = 0;
				try{
					var res = eval("Packages." + packname);
					if(res != null) loaded = 1;
				}catch(e){};
				
				// If not loaded
				if(loaded == 0) {
					var rootpackage = packname.replace(/\.(.*)/, ""); // Extract just first section
					// Try and get the path
					var path = null;
					try {
						path = Packages[rootpackage].$p; // package path
					}catch(e) {};
					if(path != null) {
					
						// Get real path name from package name
						path += packname.replace(/\./g, "/");
					
						// Add file
						files.push({filepath: pPackagePath + path + ".js", mode: "LT_SCRIPT", ScriptPackage: packname});
					}
				} else {
					// Already loaded, splice from our list
					includes.splice(i, 1);
				}
			}
		}
		
		var fileLoader = new Packages.Library.DynamicLoad({
			callback: new Function(this.textVar + ".FetchDone()"),
			displayLoadingIcon: 0
		});
		fileLoader.Request(files);
	};
	/*************************************************************************************************
	* FetchDone - Called when all of the packages have been loaded
	*
	* Iterate through each loaded package, if it had an include, create a new object to carry out the fetches
	************************************************************************************************/
	this.FetchDone = function() {
		this.children = [];
		for(var i = 0; i < includes.length; i++) {
			if(includes[i].packname != null) {
				var packname = includes[i].packname;
				// Do in try block, as may not exist
				try {
					// Get everything but last package name (eg remove the view.js)
					var mainpackname= packname.substr(0, packname.lastIndexOf('.'));
					var childpackname= packname.substr(packname.lastIndexOf('.') + 1);
					var childincludes;
					var mainpack = eval("Packages." + mainpackname);
					// Get child includes
					childincludes = mainpack.$[childpackname].Include(includes[i].object);
					
					if(childincludes != null) {
						// We have child includes to get, create an object for each one
						
						var child = new Packages.Library.Include(childincludes, new Function(this.textVar + ".ChildDone()"));
						
						this.children.push(child);
						
						child.Fetch();
					}
				}catch(e) {};
			}
		}
		if(this.children.length == 0) {
			// No children to ever call us back, so call ChildDone now
			
			this.ChildDone();
		}
	};
	/*************************************************************************************************
	* ChildDone - Called when a child finishes loading its packages (and its grandchildren packages)
	*
	* Iterate through each child this object owns, if any child is still active does not nothing
	* If none of its children are active, sets itself inactive and calls its own callback
	************************************************************************************************/
	this.ChildDone = function() {
		var done = 1; // so prove me wrong
		for(var i = 0; i < this.children.length; i++) {
			if(this.children[i].active == 1) done = 0;
		}
		
		if(done == 1) {
			// Child complete
			this.active = 0;
			
			// Fire callback
			this.callback();
		}
	};
};Package("Library.Properties.Alias").Property = function() {}
/*******************************************************************************
 * GetChoiceForm - gets the form items for this property
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Properties.Alias.GetChoiceForm = function() {
    return [
        {
            type: "TextArea",
            name: "Aliases",
            description: "Specify a list of alias file names, one per line",
            id: "aliases",
            defaultvalue: ""
        }
    ];
};Package("Library.Properties.FolderContentPermissions").Property = function() {}
/*******************************************************************************
 * GetChoiceForm - gets the form items for this property
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Properties.FolderContentPermissions.GetChoiceForm = function() {
    return [
        {
            type: "HTML",
            html: "<h3>Applies to 'folders' only<\/h3>"
                +   "Apply specific permissions on this specific folder.<br>"
                +   "These permissions are in addition to the users current permissions. If a user already has permission [X], not checking permission [X] here does not remove that property.<br>"
                +   "Permissions only affect this folder and sub folders.",
        },
        {
            defaultvalue: [],
            name: "Permissions",
            description: "The permissions this user has.",
            type: "Options",
            id: "permissions",
            commaString: 1,
            options: Packages.Library.$.GetPermissionOptions({showall: 1})
        }
    ];
};

/*******************************************************************************
 * GetChoiceInfo - gets more information about this choice
 ******************************************************************************/
Packages.Library.Properties.FolderContentPermissions.GetChoiceInfo = function() {
    return {
        name: "Folder Content Permissions"
    }
};Package("Library.Properties.Permission").Property = function() {}
/*******************************************************************************
 * GetChoiceForm - gets the form items for this property
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Properties.Permission.GetChoiceForm = function() {
    return [
        {
            type: "Options",
            name: "Access",
            description: "Select the access to this file",
            id: "access",
            defaultvalue: [],
            commaString: 1,
            options: [
                {name: "View", value: "view", description: "View the contents of the file"},
                {name: "View and Edit", value: "edit", description: "View and Edit the contents of the file"},
                {name: "Edit Properties", value: "property", description: "Edit all of this properties file"}
            ]
        }
    ];
};Package("Library.Properties").Properties = function() {
	this.textVar = GetTextRef(this);
	this.data = {};
	/*******************************************************************************
	 * Init - initialises the Properties, and loads in the current properties
	 ******************************************************************************/
	this.Init = function(options) {
		// Fetch the prperties XML from the editbox
		var content = Packages.Library.$.GetCurrentFile();
		
		var xmldefs = Packages.Library.$.ReadXML({xml: content});
		if(xmldefs.length == 0) return;
		this.data = Packages.Library.$.ConvertXMLDefToJS({xmldef: xmldefs[0]});
	};
	/*******************************************************************************
	 * Save - stores the latest version of the properies prior to submission
	 ******************************************************************************/
	this.Save = function() {
		this.SaveEditor();
		Packages.Library.$.SaveEditor();
	};
	/*************************************************************************************************
     * SaveEditor - called when the editor wants to save the form
     ************************************************************************************************/
	this.SaveEditor = function() {
		var xmldef = Packages.Library.$.ConvertJSToXMLDef({object: this.data});
		var content = Packages.Library.$.WriteXML({xmldefs: [xmldef]});
		
		// Put the file into the main form
		Packages.Library.$.UpdateFile({content: content});
	};
	/*******************************************************************************
	 * GetPropertiesForm - Gets the properties form
	 *
	 * If in edit mode, and we have the file type specific properties available, creates
	 * the complete properties form.
	 * Otherwise creates just the System properties form
	 *
	 * Returns the markup for displaying the form
	 ******************************************************************************/
	this.GetPropertiesForm = function() {
		var items = [];
		
		items.push({
			name: "Property Sets",
			description: "Create properties that apply to specific users or groups",
			type: "MultiForm",
			id: "propertysets",
            data: this.data.propertysets,
			title: "permission",
			fullWidth: 1,
			popupEdit:		1,
			form: {
				type: "Form",
				items: [
					{
						name: "Permission",
						description: "The permission the user must have. When the user has that permission they can do everything inside the property set",
						type: "Options",
						id: "permission",
						multiple: 1,
						commaString: 1,
						defaultvalue: "",
						options: Packages.Library.$.GetPermissionOptions()
					},
					Packages.Library.$.GetMultiFormWithChoicesItemFromFolderOfChoices({
						choices: 		Packages.Library.Properties,
						name: 			"Properties",
						description: 	"",
						id: 			"property",
						choiceId: 		"type"
					})
				]
			}
		});
		
		this.form = {
			type: "Form",
			items: items,
			object: this.data,
			submit: this.Save.bind(this)
		};
		this.form.Form = new Packages.Form.Form(this.form);
		return this.form.Form.MakeForm();
	};
};

/***************************************************************
 * GetProperties - (singleton) - gets the properties instance
 *
 * Returns the single properties instance, and initialises it
 * if necessary
 **************************************************************/
Package("Library.Properties").$.GetProperties = function() {
	return GetSingleton(Packages.Library.Properties, "Properties", "Init");
};

/***************************************************************
 * GetPropertiesForm - gets the properties form for the specified
 * file
 *
 * Loads in an iframe
 *
 * param - options : hash of options, may contain:
 * 				filename : the name of the file to get the properties for
 * 							if not specified, uses pFileName (current file)
 **************************************************************/
Package("Library.Properties").$.GetPropertiesForm = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetPropertiesForm",
		options: options,
		specification: {
			filename: 	{type: "string"}
		}
	})) return;
	
	if(options.filename == null) {
		options.filename = pFileName;
		// Remove path prefix
		options.filename = options.filename.substring(options.filename.lastIndexOf('/') + 1);
	}
	
	var html = "<iframe src='" + options.filename + ".property?req-createorget=1' style='width:100%;height:90%;min-height:600px'>" + Packages.Library.$.GetLoaderImg() + "<\/iframe>";
	Packages.Library.$.CreatePopupQuery({
		title: "File Properties '" + options.filename + "'",
		message: html,
		wrapMessage: 0,
		buttons: {}
	});
};/**************************************
 * ServerRequest - requests a server for information asyncronously
 *************************************/
Package("Library").ServerRequest = function() {
	this.textVar = GetTextRef(this);
	this.ServerRequestObj = {};
	this.id = "serverreq_" + Packages.Library.$.GetUniqueId();
	/*******************************************************************************
	 * ServerRequest - gets the response for the specified query string
	 * 
	 * param - options : hash of options, must contain:
	 * 				page : the page to request
	 * 			may contain:
	 * 				query : hash of key=value
	 * 				post : hash of a key=value
	 * 				async : 1 (default) asyncronously, 0 syncronously
	 * 				callback : action to be ran when the response occurs
	 * 					params : options, hash of options containing
	 * 						serverReqElem : a DOM elem containing the content
	 * 						response : the response content
	 * 						callbackData : see callbackData
	 * 				callbackData : data passed to callback
	 * 				showMask : 1 (default) display loading mask, 0 hide
	 * 				maskContent : content to show on mask, (default: file requested)
	 * 				uriEncodePost : 1 (default) uriEncode post values, 0 don't bother
	 * 				ignoreResponse: 1 ignore response entirely, 0 (default) load
	 ******************************************************************************/
	this.ServerRequest = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.ServerRequest.ServerRequest",
			options: options,
			specification: {
				page: {type: "string", required: 1},
				query: {type: "object"},
				post: {type: "object"},
				async: {type: "boolean"},
				callback: {type: "function"},
				callbackData: {type: "object"},
				showMask: {type: "boolean"},
				maskContent: {type: "string"},
				uriEncodePost: {type: "boolean"},
				ignoreResponse: {type: "boolean"}
			}
		})) return;
		
		if(options.async == null) options.async = true;
		
		// Display mask layer during request
		if(options.showMask != 0) {
			if(options.maskContent == null) options.maskContent = "";
			this.mask = Packages.Library.$.CreateMaskLayer({
				content: Packages.Library.$.GetLoaderImg() +
					"<h1>Requesting data from server...</h1>" +
					"Page Requested: " + options.page + "<br>" +
					options.maskContent
			});
		}

		if(options.post == null) options.post = {};
		if(options.query == null) options.query = {};
		this.ServerRequestObj = options;
		
		// Take from global queries any base queries, but allow options.query to override
		var queries = Packages.Library.$.Clone({oldObj: Packages.Library.$v.GlobalQueries});
		for(var i in options.query) {
			if(options.query[i] != null) queries[i] = options.query[i];
		}
		
		var querystring = "";
		for(var i in queries) {
			querystring += i + "=" + encodeURIComponent(queries[i]) + "&";
		}
		options.poststring = "";
		for(var i in options.post) {
			if(options.uriEncodePost != 0) options.post[i] = encodeURIComponent(options.post[i]);
			options.poststring += i + "=" + options.post[i] + "&";
		}
		
		if(Packages.Library.$v.testing == 1) return; // Do nothing in test mode
		if(Packages.Library.$c.IsNode == 1) return; // Does not work in node
		
		if (window.XMLHttpRequest) { // code for IE7+, Firefox, Chrome, Opera, Safari
			this.xmlhttp = new XMLHttpRequest();
		} else { // code for IE6, IE5
			this.xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
		}
		this.xmlhttp.open("POST", options.page + "?req-plain=1&" + querystring, options.async);
		this.xmlhttp.onreadystatechange = this.ServerRequestCallback.bind(this);
		this.xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
		this.xmlhttp.send(options.poststring);
	}
	/*******************************************************************************
	 * ServerRequestCallback - fires the callback when the action is performed
	 ******************************************************************************/
	this.ServerRequestCallback = function() {
		if(this.xmlhttp.readyState != 4) return;
		
		// Remove the mask layer
		if(this.mask != null) this.mask.Close();
		
		if(this.ServerRequestObj.callback != null) {
			if(this.ServerRequestObj.ignoreResponse) {
				// Just call the callback, and ignore the response
				this.ServerRequestObj.callback();
				return;
			}
			// Analyse response
			var response = this.xmlhttp.responseText;
			
			// Put content into an element, so it can be accessed as a DOM element
			var elem = document.createElement("div");
			elem.innerHTML = response;
			var getFilesElem = document.getElementById('getFiles');
			getFilesElem.appendChild(elem);
			
			if(response.match(/^\/\/404:/)) {
				// Load failed
				response = null;
			}
			
			if(this.xmlhttp.status == 404) response = null;
			
			// Send the inner document to the callback, and find out if its happy
			this.ServerRequestObj.callback({serverReqElem: elem, response: response, callbackData: this.ServerRequestObj.callbackData});
			
			// Destroy element
			getFilesElem.removeChild(elem);
		}
	};
};
/*******************************************************************************
 * StagedRequest - Performs a multiple staged request to the server
 *
 * Creates a div, which contains up to date progress information
 *
 * Fires each request off in turn.
 *
 * On completion calls an 'all done' callback.
 *
 * Once object created, call 'Start'
 *
 * param - actions : array of actions, each action consists of:
 * 				url : url to post to
 * 				query : the query
 * 				post : the post
 * 				message : explanation of step
 * param - callback : callback to fire upon completion
 ******************************************************************************/
Package("Library").StagedRequest = function(actions, callback) {
	this.actions = actions;
	this.total = actions.length;
	this.callback = callback;
	this.textVar = GetTextRef(this);
	/***************************************************************************
	 * Start - starts this action
	 *
	 * returns the markup for a div that contains up to date data
	 **************************************************************************/
	this.Start = function() {
		if(this.actions.length == 0) {
			// Finished
			this.callback();
			
			var elem = document.getElementById('stageserverreq');
			if(elem != null) elem.innerHTML = "Complete";
			return "";
		}
		var count = this.total - this.actions.length;
		var progress = count / this.total;
		
		var action = this.actions.shift();
		new Packages.Library.ServerRequest().ServerRequest({
			page: action.url,
			query: action.query,
			post: action.post,
			callback: new Function(this.textVar + ".Start()")
		});
		
		var html = "<table style='width:300px;'><tr><td style='width:" + progress * 100 + "%;background-color:#4444FF'><\/td><td style='background-color:#222288'><\/td><\/tr><\/table>";
		html += "Current action: " + action.message + "<br>";
		html += "Current progress: " + Math.floor(progress * 100) + "%<br>";
		
		var elem = document.getElementById('stageserverreq');
		if(elem != null) elem.innerHTML = html;
		
		return "<div id='stageserverreq'>" + html + "<\/div>";
	};
};
/*******************************************************************************
 * UploadFile - uploads base64 file data to the server in chunks
 *
 * param - options : hash of options, must contain:
 * 			base64 : file data
 * 			filepath : filepath to upload to
 * 			filename : filename
 * 		may contain
 * 			callback : callback to call when done
 * 			finishedMessage : finishedMessage CreatePopupQuery def to display on completion
 ******************************************************************************/
Package("Library").$.UploadFile = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.UploadFile",
		options: options,
		specification: {
			base64: {type: "string", required: 1},
			filepath: {type: "string", required: 1},
			filename: {type: "string", required: 1},
			callback: {type: "function"},
			finishedMessage: {type: "object"}
		}
	})) return;
	
	// Determine size
	var size = options.base64.length;
	
	if(size == 0) return; // Empty file
	
	var sizeString = "" + ((size / 4) * 3);
	var figures = sizeString.length;
	var realSize = (size / 4) * 3;
	var HRsize = realSize + "B";
	if(figures > 3) HRsize = Math.ceil(realSize / (1024)) + "KB";
	if(figures > 6) HRsize = Math.ceil(realSize / (1024 * 1024)) + "MB";
	if(figures > 9) HRsize = Math.ceil(realSize / (1024 * 1024 * 1024)) + "GB";
	
	// Determine chunks
	var chunkSize = Math.floor(size / 10); // Try 10 equal pieces
	if(chunkSize > 500 * 1024) chunkSize = 500 * 1024; // Max 500KB chunks
	if(chunkSize < 10 * 1024) chunkSize = 10 * 1024; // Min 10KB chunks
	
	// Axis align the base64 data
	chunkSize = Math.floor(chunkSize / 4) * 4;
	
	// How many chunks
	var chunks = Math.floor(size / chunkSize);
	
	// What is the remainder (final chunk size?)
	var remainder = size - (chunks * chunkSize);
	
	// Create an upload window
	var win = Packages.Library.$.CreateMaskLayer({
		content: "<div class='srvuploader'>"
				+	"<h2>Uploading...</h2><hr>"
				+	"\"" + options.filename + "\""
				+	"<div class='svruploader_cont'><div id='srvuploader_progress'><\/div><\/div>"
				+	"<div id='srvuploader_speed'>" + HRsize + "<\/div>"
			+	"<\/div>",
		opacity: 1
	});
	
	// Get the time now
	var date = new Date();
	
	// Upload the chunks
	var ctrl = {};
	ctrl.pos = 0;
	ctrl.uploader = function(serverReqRes) {
		var start = ctrl.pos * chunkSize;
		var size = chunkSize;
		
		// Remainder
		var last = 0;
		if(ctrl.pos == chunks) {
			size = remainder;
			last = 1;
		}
		
		// Finished
		if(ctrl.pos > chunks) {
			// Close the window
			win.Close();
			
			// Call the callback
			if(options.callback != null) options.callback(serverReqRes);
			
			// Display a finished message
			if(options.finishedMessage != null) {
				Packages.Library.$.CreatePopupQuery(options.finishedMessage);
			}
			
			// And stop!
			return;
		}
		
		ctrl.pos ++; // Increment
		
		// Update status bar
		var elem = document.getElementById("srvuploader_progress");
		if(elem) {
			elem.style.width = ((ctrl.pos / chunks) * 100) + "%";
			// Calculate average speed
			var now = new Date();
			var secondsTaken = (now.getTime() - date.getTime()) / 1000;
			var dataUploaded = ctrl.pos * chunkSize * (3 / 4);
			var rate = dataUploaded / secondsTaken;
			var secondsRequired = secondsTaken * (chunks / ctrl.pos);
			var secondsRemaining = secondsRequired - secondsTaken;
			if(ctrl.pos > 3 || ctrl.pos / chunks > 0.1) {
				// Only display if more than 10% in, or 3 samples taken
				document.getElementById("srvuploader_speed").innerHTML =
					(5 * Math.ceil(secondsRemaining / 5)) + " seconds remaining<br>"
					+ "Size: " + HRsize + "<br>"
					+ "Speed: " + (Math.floor(rate) / 1000) + "KB/s";
			}
		}
		
		new Packages.Library.ServerRequest().ServerRequest({
			page: ".server", // A fake url
			query: {
				chunkFile64: options.filepath,
				chunkFileNum: ctrl.pos - 1,
				"req-files": last, // last time
				"req-ignorefile": 1
			},
			post: {
				chunkContents64: options.base64.substr(start, size)
			},
			uriEncodePost: 1,
			callback: ctrl.uploader,
			showMask: 0,
			ignoreResponse: (last ? 0 : 1)
		});
	};
	
	// Start
	ctrl.uploader();
};Package("Library.StatisticalAnalysis.Count").Stat = function() {};
/*******************************************************************************
 * Analyse - analyses the data given
 *
 * param - options : options for this analysis
 * param - data : the array of data to analyse
 * param - additionalOptions : additional options from caller
 *
 * returns the value of the analysis
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Count.Analyse = function(options, data, additionalOptions) {
    if(data.length == 0) return 0;
    
    var count = 0;
    foreach(data, function(value) {
        if(value != null && value != "") count ++;
    });
    
    return count;
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Count.GetChoiceForm = function() {
    return [];
};Package("Library.StatisticalAnalysis.Max").Stat = function() {};
/*******************************************************************************
 * Analyse - analyses the data given
 *
 * param - options : options for this analysis
 * param - data : the array of data to analyse
 * param - additionalOptions : additional options from caller
 *
 * returns the value of the analysis
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Max.Analyse = function(options, data, additionalOptions) {
    if(data.length == 0) return 0;
    
    var highest = null; // Track highest
    foreach(data, function(value) {
        if(!value.match(/^\d+$/)) return; // continue foreach
        value = value * 1; // Force to be a number
        
        if(highest == null || value > highest) {
            highest = value;
        }
    });
    
    return highest;
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Max.GetChoiceForm = function() {
    return [];
};Package("Library.StatisticalAnalysis.Mean").Stat = function() {};
/*******************************************************************************
 * Analyse - analyses the data given
 *
 * param - options : options for this analysis
 * param - data : the array of data to analyse
 * param - additionalOptions : additional options from caller
 *
 * returns the value of the analysis
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Mean.Analyse = function(options, data, additionalOptions) {
    if(data.length == 0) return 0;
    
    var total = 0;
    foreach(data, function(value) {
        if(!value.match(/^\d+$/)) return;
        value = value * 1; // Force to be a number
        
        total += value;
    });
    
    return total / data.length;
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Mean.GetChoiceForm = function() {
    return [];
};Package("Library.StatisticalAnalysis.Min").Stat = function() {};
/*******************************************************************************
 * Analyse - analyses the data given
 *
 * param - options : options for this analysis
 * param - data : the array of data to analyse
 * param - additionalOptions : additional options from caller
 *
 * returns the value of the analysis
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Min.Analyse = function(options, data, additionalOptions) {
    if(data.length == 0) return 0;
    
    var lowest = null; // Track lowest
    foreach(data, function(value) {
        if(!value.match(/^\d+$/)) return;
        value = value * 1; // Force to be a number
        
        if(lowest == null || value < lowest) {
            lowest = value;
        }
    });
    
    return lowest;
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Min.GetChoiceForm = function() {
    return [];
};Package("Library.StatisticalAnalysis.Mode").Stat = function() {};
/*******************************************************************************
 * Analyse - analyses the data given
 *
 * param - options : options for this analysis
 * param - data : the array of data to analyse
 * param - additionalOptions : additional options from caller
 *
 * returns the value of the analysis
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Mode.Analyse = function(options, data, additionalOptions) {
    if(data.length == 0) return 0;
    
    var values = {}; // Track how many times this value has occured
    var highest = {high: 0, value: null}; // Also track the highest of these values
    foreach(data, function(value) {
        // Value does not have to be a number
        
        if(values[value] == null) values[value] = 0;
        values[value] ++;
        
        if(values[value] > highest.high) {
            highest.high = values[value];
            highest.value = value;
        }
    });
    
    return highest.value;
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Mode.GetChoiceForm = function() {
    return [];
};Package("Library.StatisticalAnalysis").StatisticalAnalysis = function() {};
/***************************************************************
 * GetChoiceFormItem - returns the wrapper form item
 *
 * param - options : hash of extra fields (or overrides) for the form item
 *
 * returns the form item
 **************************************************************/
Packages.Library.StatisticalAnalysis.$.GetChoiceFormItem = function(options) {
	if(options == null) options = {};
	options.choices = Packages.Library.StatisticalAnalysis;
	if(options.name == null) options.choiceName = "Statistical Analysis Type";
	if(options.description == null) options.choiceDescription = "Specify the type of statistical analysis you require.";
	if(options.choiceId == null) options.choiceId = "StatAnalysis";
	return Packages.Library.$.GetChoiceFormsItemFromFolderOfChoices(options);
};

/***************************************************************
 * Analyse - analyses the data given
 *
 * param - options : hash of options, must contain:
 * 			statOptions : the options saved for this stat
 * 			data : array of data to analyse
 * 			subOptions : options passed to sub modules
 *
 * returns the value of the anaylsis
 **************************************************************/
Packages.Library.StatisticalAnalysis.$.Analyse = function(options) {
	return Packages.Library.StatisticalAnalysis[options.statOptions.StatAnalysis].Analyse(options.statOptions, options.data, options.subOptions);
};Package("Library.StatisticalAnalysis.Sum").Stat = function() {};
/*******************************************************************************
 * Analyse - analyses the data given
 *
 * param - options : options for this analysis
 * param - data : the array of data to analyse
 * param - additionalOptions : additional options from caller
 *
 * returns the value of the analysis
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Sum.Analyse = function(options, data, additionalOptions) {
    if(data.length == 0) return 0;
    
    var sum = 0;
    foreach(data, function(value) {
        if(!value.match(/^\d+$/)) return;
        value = value * 1; // Force to be a number
        
        sum += value;
    });
    
    return sum;
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.StatisticalAnalysis.Sum.GetChoiceForm = function() {
    return [];
};/***************************************************************
 * Constants
 **************************************************************/
Package("Library").$c.Subscriber = {};
/***************************************************************
 * Subscriber - (singleton) - allow any object to subscribe to an event
 *
 * Notes: format of eventname
 * 		Can not contain not legal object key names, and no '.'s allowed
 * 		Generally camel case, with underscores used for limiters
 **************************************************************/
Package("Library").Subscriber = function() {
	this.textVar = GetTextRef(this);
	this.events = {};
	this.groups = {};
	Packages.Library.$i.Subscriber = this;
};
/***************************************************************
 * EventSubscribe - subscribes a callback to an event
 *
 * param - hash of options, must contain:
 * 			eventname : string name for the event (may not be . separated)
 * 			callback : callback function to execute for event
 * 		may contain:
 * 			groupname : name of a group this event is added to
 * 			obj : the object this callback belongs to, if present, will check if this is a 'blank', and if so, will skip
 *
 * returns eventsubscription object for this subscription
 **************************************************************/
Packages.Library.$.EventSubscribe = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EventSubscribe",
		options: options,
		specification: {
			eventname: {type: "string", required: 1},
			callback: {type: "function", required: 1},
			groupname: {type: "string"},
			obj: {type: "object"}
		}
	})) return null;
	
	if(Packages.Library.$v.InstantiateBlank == 1) {
		// Instantiating a blank, do not set up it's subscribers
		return null;
	}
	
	var eventname = options.eventname;
	var callback = options.callback;

	var subscriberObj = GetSingleton(Packages.Library, "Subscriber");
	var events = subscriberObj.events;
	var groups = subscriberObj.groups;
	// Ensure event exists
	if(events[eventname] == null) events[eventname] = [];
	// Add event
	events[eventname].push(callback);
	
	// Create event def
	var eventDef = {name: eventname, event: events[eventname], id: events[eventname].length - 1};
	
	// Add to group if group specified
	if(options.groupname != null) {
		if(groups[options.groupname] == null) groups[options.groupname] = [];
		groups[options.groupname].push(eventDef);
	}
	
	// Return event def
	return eventDef;
};

/***************************************************************
 * EventUnsubscribe - unsubscribes a callback to an event
 *
 * param - options : hash of options, must include:
 * 			eventsubscription : the event subscription object sent
 *				back during a subscribe
 **************************************************************/
Packages.Library.$.EventUnsubscribe = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EventUnsubscribe",
		options: options,
		specification: {
			eventsubscription: {type: "object", required: 1}
		}
	})) return;
	
	var eventsubscription = options.eventsubscription;
	
	if(eventsubscription.id == null) return; // Broken eventsubscription
	
	var events = GetSingleton(Packages.Library, "Subscriber").events;
	// Remove event
	eventsubscription.event[eventsubscription.id] = null;
};
/***************************************************************
 * EventDeleteGroup - unsubscribes all events in the group specified
 *
 * param - options : hash of options, must include:
 * 			groupname : the name of the group
 **************************************************************/
Packages.Library.$.EventDeleteGroup = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EventDeleteGroup",
		options: options,
		specification: {
			groupname: {type: "string", required: 1}
		}
	})) return;
	
	var subscriberObj = GetSingleton(Packages.Library, "Subscriber");
	var groups = subscriberObj.groups;
	
	if(groups[options.groupname] == null) return; // Nothing to delete
	
	foreach(groups[options.groupname], function(eventDef) {
		Packages.Library.$.EventUnsubscribe({
			eventsubscription: eventDef
		});
	});
	groups[options.groupname] = null; // All deleted
};
/***************************************************************
 * EventFire - fires the specified event and collects data
 *
 * param - options : hash of options, must contain:
 * 			eventname : string name for the event (may not be . separated)
 * 		may contain:
 * 			data : hash of data to send to callbacks
 *
 * returns an array of the results from each call
 **************************************************************/
Packages.Library.$.EventFire = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.EventFire",
		options: options,
		specification: {
			eventname: {type: "string", required: 1},
			data: {type: "object"}
		}
	})) return null;
	
	var eventname = options.eventname;
	
	var events = GetSingleton(Packages.Library, "Subscriber").events;
	// Ensure event exists
	if(events[eventname] == null) return [];
	
	var results = [];
	for(var i = 0; i < events[eventname].length; i++) {
		if(events[eventname][i] == null) continue; // Removed event
		try{
			results.push(events[eventname][i](options.data));
		}catch(e) {
			var stack = Packages.Library.$.GetCallStack({ex: e});
			Packages.Library.$.LogInfo({mesg: e.message, location: "Subscriber Event Fire '" + eventname + "' in:\n" + stack, type: "Error", level: 2});
		};
	}
	return results;
};

// Quick functions


function Sub(eventname, callback) {
	return Packages.Library.$.EventSubscribe({eventname: eventname, callback: callback});
}

function RemSub(eventsubscription) {
	Packages.Library.$.EventUnsubscribe({eventsubscription: eventsubscription});
}

function Fire(eventname, options) {
	Packages.Library.$.EventFire({eventname: eventname, data: options});
}

function FireToArray(eventname, options) {
	return Packages.Library.$.EventFire({eventname: eventname, data: options});
}

function FireToString(eventname, options) {
	var res = Packages.Library.$.EventFire({eventname: eventname, data: options});
	return res.join("");
}

//Sub("TestSubscriber1", function(options) {
//	return options.string;
//});
//
//var secondsub = Sub("TestSubscriber1", function(options) {
//	return "Bob!";
//});
//
//RemSub(secondsub);
//
//alert(FireToString("TestSubscriber1", {string: "hello"}));
/**********
 * TabInterface - creates a tab manager, which can have new tabs added afterward
 *
 * param - settings : (all optional)
 * 				id : id for this tab interface
 * 				fullscreen : fixes tab area to fit full area, and scroll what doesn't fit
 * 				windowed : (optional) if 1 will create dialogue boxes rather than tabs
 * 				showHeader : (optional) if 0 will not show header bar
 **********/
Package("Library").TabInterface = function(settings) {
	if(settings == null) settings = {};
	this.textvar = GetTextRef(this);
	this.tabs = [];
	this.selectedtab;
	// The tabs arrays index is critical, so never splice things out, instead mark them as null (unused)
	if(settings.id == null) settings.id = "ti1_";
	/***************************
	 * Initialise - initialises the tabs and returns the markup
	 *
	 * returns the html markup
	 **************************/
	this.Initialise = function() {
		var html = "";
		html += "<div class='tabinterface_container" + (settings.fullscreen ? " tabinterface_fullscreen" : "") + "' id='" + settings.id + "container'>";
		html += 	"<div class='tabinterface_header' id='" + settings.id + "header' onclick='return true;'" + (settings.showHeader == 0 ? " style='display: none'" : "") + "><\/div>";
		html += 	"<div class='tabinterface_content' id='" + settings.id + "content' onclick='return true;'><\/div>";
		html += "<\/div>";
		return html;
	};
	/***************************
	 * CreateTab - creates a new tab
	 *
	 * param - tabconfig : hash of settings, must contain
	 * 				action : callback to execute to get HTML content (passes tabid as parameter)
	 * 				onfocus : callback to execute to when the tab receives focus
	 * 				name : name to display on tab
	 * 				singlekey : unique key (if another tab has this key, it will switch to that and not create a new tab)
	 * 				width: (optional - windowed only) width of window
	 * 				height: (optional - windowed only) height of window
	 * 				allowclose: (optional) 1 (default) allow tab to be closed, 0 prevent close
	 * 				param - (optional) param to pass through to action call
	 *
	 * returns the id of this tab in this system (for future calls)
	 **************************/
	this.CreateTab = function(tabconfigdef) {
		// Clone definition data, so that we don't disturb it - the data that comes in is based on a static hash that describes each app
		// When we create a tab, we must instatiate it first, and create our own copy.
		var tabconfig = Packages.Library.$.Clone({oldObj: tabconfigdef, skiplist: ['tabinterface']});
		
		// Using a single key?
		if(tabconfig.singlekey != null) {
			// Search for another tab with the same key
			for(var i = 0; i < this.tabs.length; i++) {
				if(this.tabs[i] == null) continue;
				if(this.tabs[i].singlekey == tabconfig.singlekey) {
					// Match found
					this.SwitchTo(i);
					return null;
				}
			}
		}
		
		// Create a new tab
		this.tabs.push(tabconfig);
		
		var tabid = this.tabs.length - 1;
		
		// Get tab content
		if(tabconfig.packageclass != null) {
			// Using a packageclass, we need to instantiate this first
			tabconfig.object = new tabconfig.packageclass();
			tabconfig.action = tabconfig.object.Initialise.bind(tabconfig.object);
		}
		var html = tabconfig.action(this, tabid, tabconfigdef.param);
		
		if(html == null) {
			html = "No content...";
		}
		
		var headingHTML = "<span class='tabinterface_heading_text' id='" + settings.id + "header_" + tabid + "_text'>" + tabconfig.name + "<\/span>";
		if(tabconfig.allowclose != 0) {
			headingHTML += "&nbsp;&nbsp;<a onclick='" + this.textvar + ".CloseTab(" + tabid + ")' class='tabinterface_closebutton'>x</a>";
		}
		
		if(settings.windowed == 1) {
			// Add window heading, and containers
			var content = html;
			html =  "<div class='tabinterface_window_container' style='" +
						(tabconfig.width  != null ? "min-width:" + tabconfig.width  + ";" : "") +
						(tabconfig.height != null ? "min-height:" + tabconfig.height + ";" : "") +
					"'>";
			html += "<div class='tabinterface_window_header tabinterface_heading'>" + headingHTML + "<\/div>";
			html += "<div class='tabinterface_window_content tabinterface_child'>";
			html += content;	
			html += "<\/div>"
			html += "<\/div>"
		}
		
		// Create the content area
		var contentcontainer = document.getElementById(settings.id + "content");
		var tabelem = document.createElement('div');
		tabelem.style.display = 'none';
		tabelem.id = settings.id + "child_" + tabid;
		tabelem.className = "tabinterface_child";
		tabelem.innerHTML = html;
		contentcontainer.appendChild(tabelem);
		
		// Create the tab
		var headercontainer = document.getElementById(settings.id + "header");
		var tabelem = document.createElement('div');
		tabelem.id = settings.id + "header_" + tabid;
		tabelem.className = "tabinterface_heading";
		tabelem.innerHTML = headingHTML;
		tabelem.onclick = new Function(this.textvar + ".SwitchTo(" + tabid + ")");
		headercontainer.appendChild(tabelem);
		
		this.SwitchTo(tabid);
		
		return tabid;
	};
	/***************************
	 * SwitchTo - switches to the specified tab
	 *
	 * param - id : id of the tab
	 **************************/
	this.SwitchTo = function(tabid) {
		// Hide all tabs
		for(var i = 0; i < this.tabs.length; i++) {
			if(this.tabs[i] == null) continue;
			var elem = document.getElementById(settings.id + "child_" + i);
			if(elem) elem.style.display = "none";
			
			var elem = document.getElementById(settings.id + "header_" + i);
			if(elem) elem.className = "tabinterface_heading";
		}
		
		// Set selected tab to display
		if(this.tabs[tabid] != null) {
			var elem = document.getElementById(settings.id + "child_" + tabid);
			if(elem) elem.style.display = "block";
			
			
			var elem = document.getElementById(settings.id + "header_" + tabid);
			if(elem) elem.className = "tabinterface_heading tabinterface_heading_selected";
			
			this.selectedtab = tabid;
		}
		
		// Send onfocus event last
		if(this.tabs[tabid].onfocus != null) this.tabs[tabid].onfocus();
	};
	/***************************
	 * CloseTab - closes the specified tab - only if in focus, otherwise switches to
	 *
	 * param - id : id of the tab
	 **************************/
	this.CloseTab = function(tabid) {
		// Ensure tab is currently in focus, if not, select it
		if(tabid != this.selectedtab) {
			this.SwitchTo(tabid);
			return;
		}
		
		var tabconfig = this.tabs[tabid];
		// Call close callback (if supported)
		if(tabconfig.object != null && tabconfig.object.Close != null) {
			// Check if it is OK to close
			if(tabconfig.object.Close() == 0) {
				// No, stay open
				return;
			}
			// Otherwise close
		}
		
		// Remove tab elems
		if(this.tabs[tabid] != null) {
			var contentcontainer = document.getElementById(settings.id + "content");
			var elem = document.getElementById(settings.id + "child_" + tabid);
			if(elem) contentcontainer.removeChild(elem);
			
			var headercontainer = document.getElementById(settings.id + "header");
			var elem = document.getElementById(settings.id + "header_" + tabid);
			if(elem) headercontainer.removeChild(elem);
		}
		
		// Set entry to null
		this.tabs[tabid] = null;
	};
	/***************************
	 * SetTabName - renames the heading for this tab
	 *
	 * param - id : id of the tab
	 * param - name : new name
	 **************************/
	this.SetTabName = function(tabid, name) {
		// Get header element
		var elem = document.getElementById(settings.id + "header_" + tabid + "_text");
		if(elem != null) elem.innerHTML = name;
	};
	/***************************
	 * CloseAll - closes all windows
	 **************************/
	this.CloseAll = function(tabid, name) {
		// Get header element
		for(var i = 0; i < this.tabs.length; i++) {
			if(this.tabs[i] != null) this.CloseTab(i);
		}
	};
};

/************************************
 * CreateMenuInterface - creates a menu for the items specified, the handler for each item can vary
 *
 * param - options : hash of options, must contain:
 * 		menuitems : array of menu items, must contain:
 * 					name : text to display for this menu item
 * 				may contain:
 * 					description : help to display in help button
 * 					action : method to execute when clicked
 * 					param : param to send in action call
 * 					tabinterface : tab interface object
 * 						will send callback as an argument to CreateTab method of tabinterface
 * 					singlekey : used with tabinterface - see tabinterface
 * 					packageclass : package class to instatiate and use
 * 						will instatiate and call 'initialise' on the object, and use its return
 * 	may contains:
 * 		idprefix : id prefix
 * 		showLastClicked : 1 highlights the last clicked item, 0 (default) doesn't (only if singlekey specified)
 *
 * returns html for this menu	
 ***********************************/
Packages.Library.$.CreateMenuInterface = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateMenuInterface",
		options: options,
		specification: {
			menuitems: {type: "array", required: 1}
		}
	})) return null;
	
	var menuitems = options.menuitems;
	var html = "<div class='menuinterface_container mColDGreen' onselectstart='return false;'>";
	for(var i = 0; i < menuitems.length; i++) {
		var item = menuitems[i];
		var itemtextref = GetTextRef(item)
		var onclick = itemtextref + ".action(" + (item.param != null ? itemtextref + ".param" : "") + ")";
		if(item.tabinterface != null) {
			// Using tab interfaces
			onclick = itemtextref + ".tabinterface.CreateTab(" + itemtextref + ")";
		}
		
		if(options.idprefix == null) options.idprefix = "tabmenuid";
		var id = options.idprefix + "_" + i;
		
		// Build menu item
		// Only use 'input' to show last clicked if it is enabled
		html += "<input " +
					"name='" + options.idprefix + (item.showLastClicked == 0 ? "off" : "") + "' " +
					"type='radio' " +
					"id='" + id + "'" +
					"class='menuinterface_input " + ((options.showLastClicked == 1 && item.showLastClicked != 0)? "menuinterface_showlast mColVLGreenInput" : "") + "' " +
					(i == 0 ? "checked='checked' " : "") +
				">";
		html += "<label class='menuinterface_item' " +
					"for='" + id + "' " +
					"onclick=\"" + onclick + "\" " +
					">" + item.name +
					(item.description != null ? Packages.Library.$.MakeHelp({help: item.description}) : "") +
				"<\/label>";
	}
	html += "<\/div>";
	return html;
};

/*************************************************************************************************
 * CreateSideArea - creates a side area full of collapsable panes
 *
 * param - options : hash of options, must contain:
 * 			panes : array of hashes describing the panes, each of the form:
 * 				may contain:
 * 					title : the title for the collapsable area, if null will not provide a title or any means to expand
 * 					groupName : a groupname, when used, only one collapsable item in the group may be expanded
 * 					id : pane id (the container id will be prefixed onto this)
 * 					content : the content of the field, if null will be empty
 * 					folded : 1 (default), if 0 the item will attempt to be displayed
 * 		may contain:
 * 			id : the id of the pane container
 * 			className : additional class to place on container
 *
 * return - html : the markup for this area or null on error
 ************************************************************************************************/
Packages.Library.$.CreateSideArea = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateSideArea",
		options: options,
		specification: {
			id: {type: "string"},
			className: {type: "string"},
			panes: {type: "array", required: 1}
		}
	})) return null;
	
	if(options.id == null) options.id = "sidepanearea" + Packages.Library.$.GetUniqueId();
	
	var panes = "";
	
	foreach(options.panes, function(pane) {
		if(pane.id == null) pane.id = "pane" + Packages.Library.$.GetUniqueId();
		panes += Packages.Library.$.CreateFoldArea({
			content: "<div id='" +  options.id + "_" + pane.id + "_content' class='sidepanearea_pane'>" + (pane.content != null ? pane.content : "") + "<\/div>",
			foldable: 1,
			folded: (pane.folded == null ? 1 : pane.folded),
			groupName: pane.groupName,
			title: pane.title,
			noArrow: (pane.title == null ? 1 : 0),
			foldid: options.id + "_" + pane.id + "_foldarea"
		});
	});
	
	// Add resizer button
	panes += "<div class='sidepanearea_togglesize mbutton' onclick=\"Packages.Library.$.ToggleBodyClass({className: 'sidepanearea_large'})\">&lt; &gt;<\/div>";
	
	return "<div "
			+	"class='sidepanearea" + (options.className != null ? " " + options.className : "") + "' "
			+	"id='sidepanearea' "
		+	">"
			+	panes
		+	"<\/div>";
};

/*************************************************************************************************
 * SetAndFocusPane - sets a pane in the CreateSideArea, and brings it to focus
 *
 * param - options : hash of options, must contain:
 * 		must contain:
 * 			id : the id of the pane container
 * 			paneId : the id of the pane
 * 		may contain:
 * 			content : the new content (if null, only focuses)
 ************************************************************************************************/
Packages.Library.$.SetAndFocusPane = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SetAndFocusPane",
		options: options,
		specification: {
			id: {type: "string", required: 1},
			paneId: {type: "string", required: 1},
			content: {type: "string"}
		}
	})) return;
	
	// Set content
	var elem = document.getElementById(options.id + "_" + options.paneId + "_content");
	if(elem && options.content != null) elem.innerHTML = options.content;
	
	// Bring to focus
	var elem = document.getElementById(options.id + "_" + options.paneId + "_foldarea");
	if(elem) elem.checked = true;
}/***************************************************************
 * Test - automatically tests the JS code that uses 'options'
 **************************************************************/
Package("Library").Test = function() {
	this.textVar = GetTextRef(this);
	
	this.testValues = {
		"string": ["a", "alpha", "a space", "24", "<xml>"],
		"number": [1, 2, 15, 103, 1001],
		"boolean": [0, 1],
		"function": [function() {return "test function return"}],
		"array": [[]],
		"object": [{}],
		"DOMobject": [document.body],
		"null": [null],
		"undefined": [null]
	};
	this.runs = 6; // The maximum number of variants a type has
	this.testing = 0;
	/***************************************************************
	 * Start - starts the testing
	 **************************************************************/
	this.Start = function() {
		
		if(!Packages.Library.$.IsPermission({permission: "test"})) {
			alert("You do not have the test permission. Are you logged in?");
		}
		
		// Remove all current log messages
		Packages.Library.$v.LoggedErrors = [];
		
		// Lock until filetype done
		Packages.Library.$v.TestLocks.FileType = 1;
		
		// Ask current file type if it has tests
		var _this = this;
		var fileTypeObj = Packages.Library.$.CreateObject({c: Packages.FileType[pFileTypeSafe]});
		setTimeout(function() {
			var fileTypeData = "No test code";
			if(fileTypeObj != null) {
				Packages.Library.$v.testing = 1;
				try {
					fileTypeData = fileTypeObj.Test({testPrefix: "Packages.FileType." + pFileTypeSafe, test: _this});
				} catch(e) {
					fileTypeData = "Error fetching data: " + e.message;
				}
				Packages.Library.$v.testing = 0;
				
			}
			if(fileTypeData == null) fileTypeData = "No information returned";
			_this.SaveTestResult({
				testName: "Packages.FileType." + pFileTypeSafe,
				data: fileTypeData
			});
			
			// Remove lock
			delete Packages.Library.$v.TestLocks.FileType;
		}, 0);
		
		if(fileTypeObj == null || fileTypeObj.Test == null) return; // Don't do testing if filetype doesn't support it
		
		// Do other tests
		this.SaveTestResult({
			testName: "Packages.Form",
			data: Packages.Tests.$.Form({testPrefix: "Packages.Form", test: this})
		});
		this.SaveTestResult({
			testName: "Packages.Library.Wrappers",
			data: Packages.Tests.$.Wrappers({testPrefix: "Packages.Library.Wrappers", test: this})
		});
		
		var count = 0;
		
		for(var key in Packages.Library.$) {
			if(key.match(/^_/)) continue; // Skip private methods
			this.TestFunction("Packages.Library.$." + key, Packages.Library.$[key]);
			count ++;
		}
		
		// Save all logged info
		this.SaveTestResult({
			testName: "LoggedErrors",
			data: Packages.Library.$v.LoggedErrors
		});
	};
	/***************************************************************
	 * TestFunction - tests the specified function
	 *
	 * param - functionName : the name of the function
	 * param - fn : the function
	 **************************************************************/
	this.TestFunction = function(functionName, fn) {
		
		if(this.testing > 5) {
			// More than 5 simultaneous tests
			var _this = this;
			setTimeout(function() {_this.TestFunction(functionName, fn)}, 10);
			return;
		}
		
		this.testing ++;
		
		// Get function options definition
		var def = Packages.Library.$.GetFunctionDef({
			functionName: functionName,
			fn: fn
		});
		if(def == null) return;
		Packages.Library.$.ProcessFunctionDef({
			def: def
		});
		
		if(def.doNotTest == 1) return; // Explicite do not test
		
		// Get sorted list of keys in the spec
		def.keys = Packages.Library.$.GetKeys({object: def.specification}).sort();
		
		var results = [];
		
		// Do the test
		this.TestFunctionParams(functionName, fn, def, {}, results);
		
		var resultData = {
			name: functionName,
			results: results
		};
		
		this.SaveTestResult({
			testName: functionName,
			data: resultData
		});
		
		this.testing --;
	};
	
	/***************************************************************
	 * SaveTestResult - saves the test results
	 *
	 * param - options : hash of options, must contain:
	 * 			testName : name of the test
	 * 			data : data to dump
	 **************************************************************/
	this.SaveTestResult = function(options) {
		// Dump to a file
		var dump = Packages.Library.$.Dump({obj: options.data, prettyPrint: 1});
		
		// Do normalisation
		dump = dump.replace(/Packages\.\$i\.TextVars\[\d+\]/g, "Packages.$i.TextVars[x]");
		dump = dump.replace(/uniqueid_\d+/g, "uniqueid_x");
		
		var testKey = "save" + Packages.Library.$.GetUniqueId({});
		Packages.Library.$v.TestLocks[testKey] = 1;
		
		// Save
		var _testingMode = Packages.Library.$v.testing;
		Packages.Library.$v.testing = 0; // Otherwise SetFile won't do anything!
		Packages.Library.$.SetFile({
			filepath: "System/TestResults/" + options.testName + ".testresult",
			content: dump,
			async: true,
			callback: function() {
				delete Packages.Library.$v.TestLocks[testKey];
			}
		});
		Packages.Library.$v.testing = _testingMode;
	}
	
	/***************************************************************
	 * TestFunctionParams - tests the specified function repeatedly
	 * by testing each value of params, but no every permutation
	 *
	 * param - functionName : the function name
	 * param - fn : the function
	 * param - def : the options def for the function
	 * param - baseParams : the base params (from previous calls)
	 * param - results : array of results to append to
	 **************************************************************/
	this.TestFunctionParams = function(functionName, fn, def, baseParams, results) {
		
		for(var test = 0; test < this.runs; test++) {
			var params = {};
			
			for(var k = 0; k < def.keys.length; k++) {
				var currentKey = def.keys[k];
				var currentParam = def.specification[currentKey];
				
				var types = currentParam.type.split(",");
				var values = [];
				for(var i = 0; i < types.length; i++) {
					var type = types[i];
					var typeValues = this.testValues[type];
					if(typeValues == null) {
						Packages.Library.$.LogInfo({mesg: "Unknown type [" + type + "] in [" + def.calledFrom + "]", location: "Packages.Library.$.TestFunction", type: "Unknown type", level: 4});
					} else {
						// Test values conform to any other options
						var goodValues = [];
						
						for(var j = 0; j < typeValues.length; j++) {
							var value = typeValues[j];
							if(type == "number") {
								if(currentParam.min != null && value < currentParam.min) value = null;
								if(currentParam.max != null && value > currentParam.max) value = null;
							}
							
							// If value is still not null, use it
							if(value != null) goodValues.push(value);
						}
						
						// Add good values to our list
						values = values.concat(goodValues);
					}
				}
				if(values.length == 0) {
					Packages.Library.$.LogInfo({mesg: "Unknown type (no test values suppied) [" + type + "] in [" + def.calledFrom + "]", location: "Packages.Library.$.TestFunction", type: "Unknown type", level: 4});
					return;
				}
				// Make copy
				values = Packages.Library.$.Clone({oldObj: values});
				
				// Add a null value if not required
				if(currentParam.required != 1) values.unshift(null);
				
				var param;
				if(test >= values.length) {
					param = values[0]; // Use first entry if not enough variants for this test
				} else {
					param = values[test];
				}
				params[currentKey] = param;
			}
			
			// Run the function
			var res = this.Call(functionName, fn, params);
			results.push({
				params: Packages.Library.$.Clone({oldObj: params}),
				res: res
			});
		}
	};
	
	/***************************************************************
	 * Call - calls the specified function with the specified options (params)
	 * in test mode, and cleans up
	 *
	 * param - functionName : the function name
	 * param - fn : the function
	 * param - options : options to pass to fn
	 *
	 * return - result from fn
	 **************************************************************/
	this.Call = function(functionName, fn, options) {
		console.log("Testing - Function: " + functionName);
		
		var res = Packages.Library.$.CallFunction({
			functionName: functionName,
			fn: fn,
			fnOptions: options,
			cleanup: 1
		})
		
		console.log("Testing - Function: " + functionName + " - DONE");
		
		return res;
	};
	
	/***************************************************************
	 * TestFunctionParamsRecursive - tests the specified function recursively
	 * by testing all permutations of the params
	 *
	 * NOT USED - does not work, generates far too much data
	 *
	 * param - functionName : the function name
	 * param - fn : the function
	 * param - def : the options def for the function
	 * param - baseParams : the base params (from previous calls)* param - results : array of results to append to
	 **************************************************************/
	this.TestFunctionParamsRecursive = function(functionName, fn, def, baseParams, results) {
		var currentKey = def.keys.shift();
		var currentParam = def.specification[currentKey];
		var types = currentParam.type.split(",");
		var values = [];
		for(var i = 0; i < types.length; i++) {
			var type = types[i];
			var typeValues = this.testValues[type];
			if(typeValues == null) {
				Packages.Library.$.LogInfo({mesg: "Unknown type [" + type + "] in [" + def.calledFrom + "]", location: "Packages.Library.$.TestFunction", type: "Unknown type", level: 4});
			} else {
				values = values.concat(typeValues);
			}
		}
		if(values.length == 0) {
			Packages.Library.$.LogInfo({mesg: "Unknown type [" + type + "] in [" + def.calledFrom + "]", location: "Packages.Library.$.TestFunction", type: "Unknown type", level: 4});
			return;
		}
		// Make copy
		values = Packages.Library.$.Clone({oldObj: values});
		
		// Add a null value if not required
		if(currentParam.required != 1) values.unshift(null);
		
		for(var v = 0; v < values.length; v++) {
			var val = values[v];
			baseParams[currentKey] = val;
			
			if(def.keys.length == 0) {
				// Call the function
				var res = this.Call(functionName, fn, baseParams);
				results.push({
					params: Packages.Library.$.Clone({oldObj: baseParams}),
					res: res
				});
			} else {
				// Recurse
				this.TestFunctionParams(functionName, fn, def, baseParams, results);
			}
		}
		
		def.keys.unshift(currentKey);
	};
};
/*************************************************************************************************
 * GetTestSampleFolderList - gets a sample list of folders
 *
 * param - options : none
 *
 * returns a sample folder listing
 ************************************************************************************************/
Packages.Library.$.GetTestSampleFolderList = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetTestSampleFolderList",
		options: options,
		specification: {}
	})) return null;
	
	return [
		{ name: "index.mhtm",	type: "mhtm" },
		{ name: "image.jpg",	type: "jpg" },
		{ name: "video.mp4",	type: "mp4" },
		{ name: ".Fred.user",	type: "user" },
		{ name: "alpha", 		type: "folder", subfolders: [
			{ name: "a space.alpha",	type: "alpha" }
		]}
	];
}/**************************************
 * Tutorial - creates a tutorial popup
 *
 * Monitors the objects on the page to trigger the tutorial to advance
 *
 * param - options : hash of options, must contain
 * 			steps : array of hashes, each describing a step, of the form
 * 				name : name of step to display
 * 				description : description to display (normally to describe current view)
 * 				action : text that describes the action to perform
 * 				checkFunction : function called to check if complete
 * 			title : title for pop up window
 *************************************/
Package("Library").Tutorial = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.Merge",
		options: options,
		specification: {
			steps: 	{type: "array",	required: 1},
			title: 	{type: "string",required: 1}
		}
	})) return;
	
	this.stepCounter = 0;
	
	/************************************
	 * Start - called to start the tutorial
	 ***********************************/
	this.Start = function() {
		// Create div absolutely fixed to the bottom of the screen
		var content = "<div id='tutorialContainer'><\/div>";
		
		Packages.Library.$.CreatePopupQuery({
			message: content,
			instant: 1,
			close: "Exit",
			title: options.title,
			interactive: 1,
			callback: this.Close.bind(this),
			popupNarrow: 1,
			buttons: {}
		});
		
		// Start the tutorial
		this.Display();
		
		this.monitorInterval = setInterval(this.Monitor.bind(this), 100);
	};
	
	/************************************
	 * Display - displays the current step
	 ***********************************/
	this.Display = function() {
		var elem = document.getElementById('tutorialContainer');
		if(!elem) return;
		
		var step = options.steps[this.stepCounter];
		
		var html = "";
		html += "<h3>" + step.name + " - Step ( " + (this.stepCounter + 1) + " / " + (options.steps.length) + " )<\/h3>";
		html += "<div class='tutorial_description'>" + Packages.Library.$.ConvertCRToBR({str: step.description}) + "<\/div>";
		html += "<hr>"
		html += "<h3>To do:<\/h3>";
		html += Packages.Library.$.ConvertCRToBR({str: step.action});
		if(step.checkFunction == null) html += "<hr>This tutorial is now finished, click 'Exit' to close.";
		
		// Tutorials can contain special characters to mark different types of print
		html = Packages.Library.$.ShortcutText({content: html});
		
		elem.innerHTML = html;
	};
	
	/************************************
	 * Monitor - called repeatedly to check if the trigger action has occured
	 * so the step can proceed to next step
	 ***********************************/
	this.Monitor = function() {
		var step = options.steps[this.stepCounter];
		var elem = document.getElementById('tutorialContainer');
		if(!elem) {
			this.Close();
			return;
		}
		if(this.stepCounter == options.steps.length - 1) {
			// End
			this.Close();
			return;
		}
		if(step.checkFunction == null) return;
		
		var result = step.checkFunction();
		
		if(result) {
			// Proceed
			this.stepCounter += 1;
			this.Display();
		}
	};
	
	/************************************
	 * Close - called when closed
	 ***********************************/
	this.Close = function() {
		clearInterval(this.monitorInterval);
	};
};

/*******************************************************************************
 * ShortcutText - Replaces text with shortcut highlight formatting
 *
 * Shortcuts are in the format
 * 		x{content}
 * 	Where x is the shortkey, and content is the code to wrap
 * Shortkey
 * 	b : button
 * 	c : comment
 * 	l : link
 * 	f : form label
 * 	t : tab (tab interface tab)
 * 	v : form value
 *
 * param - options : hash of options, must contain
 * 				content : the content to format
 * 				
 * returns the content replaced with shortcuts
 ******************************************************************************/
Packages.Library.$.ShortcutText = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ShortcutText",
		options: options,
		specification: {
			content: 	{type: "string",	required: 1}
		}
	})) return null;
	
	var html = options.content;
	
	// Help Bubble replacements
	while(html.match(/h{([^}]*)/)) {
		var content = RegExp.$1;
		var match = Packages.Library.$.EscapeForRegExp({content: "h{" + content + "}"});
		var oldHtml = html;
		html = html.replace(new RegExp(match), Packages.Library.$.MakeHelp({help: content}));
		if(oldHtml == html) {
			// No replacement made, put out an error and stop replacing
			Packages.Library.$.LogInfo({mesg: "Could not replace [" + match + "] in shortcut text", location: "Packages.Library.$.ShortcutText", type: "Error", level: 3});
			break;
		}
	}
	html = html.replace(/b{/g, "<span class='tutorial_button mbutton button'>");
	html = html.replace(/c{/g, "<span class='tutorial_comment'>");
	html = html.replace(/l{/g, "<span class='tutorial_link'>");
	html = html.replace(/f{/g, "<span class='tutorial_form_label'>");
	html = html.replace(/t{/g, "<span class='tutorial_tab'>");
	html = html.replace(/v{/g, "<span class='tutorial_value'>");
	html = html.replace(/}/g, "<\/span>");
	
	return html;
};Package("Library.UI").Splitter = function() {};
/*************************************************************************************************
 * CreateSplitTable - creates a split table with slider
 *
 * Bugs: In rearrangable mode, sometimes we collect containers
 *
 * param - options : hash of options, must contain:
 * 			areaContentA : content for area A
 * 			areaContentB : content for area B
 * 		may contain:
 * 			vertical : 1 display one above over, 0 (default) side by side
 * 			startSize : starting percentage of area A, default 50%
 * 			height: height to start with (either in px or %, suffix required)
 * 			rearrangable: 1 allow the areas to be dragged out and placed in other areas, 0 (default) don't
 * 			noScroll: 1 do not place content in scrollable areas, 0 (default) do
 * 
 * returns the html for this split table
 ************************************************************************************************/
Packages.Library.UI.$.CreateSplitTable = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.UI.$.CreateSplitTable",
		options: options,
		specification: {
			areaContentA: {type: "string,number", required: 1},
			areaContentB: {type: "string,number", required: 1},
			vertical: {type: "boolean"},
			startSize: {type: "number"},
			height: {type: "string"},
			rearrangable: {type: "boolean"},
			noScroll: {type: "boolean"}
		}
	})) return "";
	
	options.textVar = GetTextRef(options);
	if(options.startSize == null) options.startSize = 50;
	if(options.rearrangable == null) options.rearrangable = 0;
	
	var sliderWidth = 10;
	
	var areaA = options.areaContentA;
	var areaB = options.areaContentB;
	if(options.rearrangable == 1) {
		options.dragged = function(info) {
			if(info.containerData.moved != 1) return; // Not moved
			var item = info.item;
			var container = info.containerData;
			
			// Get the sibling element
			var siblingContainerElem = document.getElementsByClassName("splittable_" + item.split.$id + "_" + (item.id == 0 ? 1 : 0))[0];
			if(!siblingContainerElem) return;
			var siblingElem = siblingContainerElem.lastChild;
			if(!siblingElem) return;
			
			// Find the parent split container
			var containerElem = siblingElem.parentNode;
			while(containerElem != null && (!containerElem.className.match(/slidercontainer/))) {
				containerElem = containerElem.parentNode;
			}
			if(!containerElem) return;
			
			// Move siblingElem to a temporary secure place
			var storeElem = document.getElementById("splitStore");
			if(storeElem == null) return;
			storeElem.appendChild(siblingElem);
			
			if(item.split.$id != container.split.$id) {
				// Create a draganddrop item in which to place this remaining area
				var id = Packages.Library.$.GetUniqueId();
				var newElem = document.createElement("div");
				newElem.className = "splittablechild";
				newElem.innerHTML = Packages.Library.$.CreateDragAndDropContainer({
					html: " ",
					callback: options.dropped.bind(options),
					classname: "splitDragAndDrop splittable_" + id + "_" + 0,
					data: {
						split: {
							$id: id
						},
						id: 0,
						containerOnly: 1
					}
				});
			
				// Both items have now been moved out, so replace the split table
				containerElem.parentNode.replaceChild(newElem, containerElem);
				
				// Finally put the sibling element into the new drag and drop area
				var newContainerElem = document.getElementsByClassName("splittable_" + id + "_" + 0)[0];
				if(!newContainerElem) return;
				// And replace with the siblingElem
				newContainerElem.appendChild(siblingElem);
			} else {
				// Both items have now been moved out, so replace the split table
				containerElem.parentNode.replaceChild(siblingElem, containerElem);
			}
		};
		options.dropped = function(info) {
			info.containerData.moved = 0; // Only marked as done if everything finishes
			
			// Create a new split table for this item
			var item = info.item;
			var container = info.containerData;
			// Get container for the item in its section of its parent splitter
			var containerElem = document.getElementsByClassName("splittable_" + container.split.$id + "_" + container.id)[0];
			if(!containerElem) return;
			var areaAElem = containerElem.lastChild;
			if(!areaAElem) return;
			
			// If the item we dropped in is a container only, then remove this item and replace with a split table
			if(container.containerOnly == 1) {
				areaAElem = containerElem.lastChild;
				containerElem = containerElem.parentNode;
			}
			
			var elemPos = Packages.Library.$.GetElemPosition({elem: containerElem});
			var x = Packages.Library.$v.Mouse.x - (elemPos.left + (containerElem.offsetWidth / 2))
			var y = Packages.Library.$v.Mouse.y - (elemPos.top + (containerElem.offsetHeight / 2))

			// Can not read / write HTML, must alter the DOM
			// Get dropped items Elem
			var droppedContainerElem = document.getElementsByClassName("splittable_" + item.split.$id + "_" + item.id)[0];
			if(!droppedContainerElem) return;
			var areaBElem = droppedContainerElem.lastChild;
			if(!areaBElem) return;
			
			// Ensure the container does not belong in the item
			var parentElem = containerElem;
			while(parentElem != null) {
				var className = parentElem.className;
				if(className != null && className.indexOf("splittable_" + item.split.$id + "_" + item.id) != -1) return;
				parentElem = parentElem.parentNode;
			}
			
			// Move areaAElem to a temporary secure place
			var storeElem = document.getElementById("splitStore");
			if(storeElem == null) return;
			storeElem.appendChild(areaAElem);
			
			var flip = 0;
			var vertical = 0;
			
			// Determine the ordering and split direction
			if(Math.abs(x) > Math.abs(y)) {
				vertical = 0;
				if(x < 0) flip = 1;
			} else {
				vertical = 1;
				if(y < 0) flip = 1;
			}
			
			// Replace areaA with a new Split Table
			var newSplit = {
				areaContentA: "", // Moved later
				areaContentB: "", // Moved later
				rearrangable: 1,
				vertical: vertical
			};
			containerElem.innerHTML = Packages.Library.UI.$.CreateSplitTable(newSplit);
			
			
			// Now put the areaA in it
			var areaAContainerElem = document.getElementsByClassName("splittable_" + newSplit.$id + "_" + (flip == 0 ? 0 : 1))[0];
			if(!areaAContainerElem) return;
			var newAreaAElem = areaAContainerElem.lastChild;
			if(!newAreaAElem) return;
			// Remove newAreaAElem
			areaAContainerElem.removeChild(newAreaAElem);
			// And replace with the areaAElem
			areaAContainerElem.appendChild(areaAElem);
			
			// Now put the areaB in it
			var areaBContainerElem = document.getElementsByClassName("splittable_" + newSplit.$id + "_" + (flip == 0 ? 1 : 0))[0];
			if(!areaBContainerElem) return;
			var newAreaBElem = areaBContainerElem.lastChild;
			if(!newAreaBElem) return;
			// Remove newAreaAElem
			areaBContainerElem.removeChild(newAreaBElem);
			// And replace with the areaAElem
			areaBContainerElem.appendChild(areaBElem);
			
			// Mark as done
			info.containerData.moved = 1;
			// Done?
		};
		
		for(var i = 0; i <= 1; i++) {
			var area = i == 0 ? areaA : areaB; // Fetch
			
			// Create secure storage place
			if(document.getElementById('splitStore') == null) {
				var storeElem = document.createElement('div');
				storeElem.id = "splitStore";
				document.body.appendChild(storeElem);
			}
			
			area = Packages.Library.$.CreateDragAndDropItem({
				item: {
					id: i,
					type: "SplitArea",
					split: options
				},
				html: "<div class='splittablechild'>" + area + "<\/div>",
				itemCallback: options.dragged.bind(options),
				callback: options.dropped.bind(options),
				classname: "splittableitem splittable_" + options.$id + "_" + i,
				containerData: {
					split: options,
					id: i
				},
				adjustDOM: 0,
				titleBar: "<div class='sliderTitle mColLGreen'> <\/div>"
			});
			
			if(i == 0) { areaA = area; } else { areaB = area; } // Store
		}
	}
	
	var html = "";
	if(options.vertical == 1) {
		html = "<div class='slidercontainer slidercontainerVertical" + (options.noScroll == 1 ? " sliderNoScroll" : "") + "' style='height: " + options.height + ";max-height:100%'>"
				+	"<div class='slideAreaA slideArea' style='max-height:" + options.startSize + "%;'>"
					+	areaA
				+	"<\/div>"
				+	"<div class='slideCentre slideCentreVertical' onmousedown='return " + options.textVar + ".slideCell(this)'><\/div>"
				+	"<div class='slideAreaB slideArea' style='max-height:" + (100 - options.startSize) + "%;'>"
					+	areaB
				+	"<\/div>"
			+	"<\/div>";
	} else {
		html = "<div class='slidercontainer slidercontainerHorizonalNoTable" + (options.noScroll == 1 ? " sliderNoScroll" : "") + "'>"
				+	"<div class='slideAreaA slideArea' style='width:" + options.startSize + "%'>"
					+	areaA
				+	"<\/div>"
				+	"<div class='slideCentre' onmousedown='return " + options.textVar + ".slideCell(this)'><\/div>"
				+	"<div class='slideAreaB slideArea' style='width:" + (99 - options.startSize) + "%;'>"
					+	areaB
				+	"<\/div>"
			+	"<\/div>";
		//html = "<table class='slidercontainer slidercontainerHorizonal" + (options.noScroll == 1 ? " sliderNoScroll" : "") + "'>"
		//		+	"<tr>"
		//			+	"<td class='slideAreaA slideArea' style='width:" + options.startSize + "%'>"
		//				+	areaA
		//			+	"<\/td>"
		//			+	"<td class='slideCentre' onmousedown='return " + options.textVar + ".slideCell(this)'><\/td>"
		//			+	"<td class='slideAreaB slideArea'>"
		//				+	areaB
		//			+	"<\/td>"
		//		+	"<\/tr>"
		//	+	"<\/table>";
	}
	
	// Slide the cell
	options.slideCell = function(cellElem) {
		var startmx = Packages.Library.$v.Mouse.x;
		var startmy = Packages.Library.$v.Mouse.y;
		var tableElem = cellElem.parentNode.parentNode;
		var cellAElem = tableElem.firstChild.firstChild;
		var cellBElem = tableElem.firstChild.lastChild;
		if(options.vertical == 1 || 1) {
			tableElem = cellElem.parentNode;
			cellAElem = tableElem.firstChild;
			cellBElem = tableElem.lastChild;
		}
		// Get size of table
		var pixelWidth = tableElem.offsetWidth;
		var pixelHeight = tableElem.offsetHeight;
		
		// Get initial cell %
		var cellPx = (cellAElem.offsetWidth / pixelWidth) * 100;
		var cellPy = (cellAElem.offsetHeight / pixelHeight) * 100;
		options.intervalId = setInterval(function() {
			var mx = Packages.Library.$v.Mouse.x;
			var my = Packages.Library.$v.Mouse.y;
			
			// Get difference
			var x = mx - startmx;
			var y = my - startmy;
			
			// Get percentage difference
			var px = (x / pixelWidth) * 100;
			var py = (y / pixelHeight) * 100;
			
			// Set %
			if(options.vertical == 1) {
				cellAElem.style.maxHeight = (cellPy  + py) + "%";
				cellBElem.style.maxHeight = (100 - (cellPy  + py) - ((sliderWidth / pixelHeight) * 100)) + "%";
				cellAElem.style.minHeight = (cellPy  + py) + "%";
				cellBElem.style.minHeight = (100 - (cellPy  + py) - ((sliderWidth / pixelHeight) * 100)) + "%";
				cellAElem.style.height = (cellPy  + py) + "%";
				cellBElem.style.height = (100 - (cellPy  + py) - ((sliderWidth / pixelHeight) * 100)) + "%";
			} else {
				cellAElem.style.width = (cellPx  + px) + "%";
				cellBElem.style.width = (99 - (cellPx  + px)) + "%";
			}
		}, 100);
		
		options.onMouseUp = function() {
			clearInterval(options.intervalId);
		}
		
		options.mouseUpEvent = Packages.Library.$.EventSubscribe({eventname: "mouseup", callback: options.onMouseUp.bind(options)});
		
		window.event.preventDefault();
		window.event.stopPropagation();
		return 0; // Stop propogation
	}
	
	return html;
}
/*********************************************************************
* UserSpace - Creates a Load / Save interface to the userspace
*
* The userspace files is stored at:
* 	masterpath/Users/<username>.userspace
*
* The userspace file is a JS block as follows:
*	{
*		items: [ // Array of items (data), where all items must have a type key
*			{type: "Panel", text: "helloworld"},
*			{type: "FormItem", id: "dummy"}
*		],
*		cache: { // Hash cache, where keys are at the disgretion of the caller
*			xcsv_html-menu-xcsv_favourite: "Chips"
*		}
*	}
********************************************************************/
Package("Library").UserSpace = function() {
	this.textVar = GetTextRef(this);
	
	/****************************************************************
	 * Init - called to initialise object
	 ***************************************************************/
	this.Init = function() {
		this.UpdateServer(1); // Load initial values
	};
	/****************************************************************
	 * GetCache - fetches the specified cache
	 *
	 * param - options : hash of options, must contain:
	 * 				key : the key of the cache
	 *
	 * returns the specified cache, or null if not found
	 ***************************************************************/
	this.GetCache = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.UserSpace.GetCache",
			options: options,
			specification: {
				key: {type: "string", required: 1}
			}
		})) return null;
		
		return Packages.Library.$v.CurrentUserSpace.cache[options.key];
	};
	
	/****************************************************************
	 * SetCache - sets the specified cache
	 *
	 * param - options : hash of options, must contain:
	 * 				key : the key of the cache
	 * 				value : the new value
	 ***************************************************************/
	this.SetCache = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.UserSpace.SetCache",
			options: options,
			specification: {
				key: {type: "string", required: 1},
				value: {type: "string,number,object,array", required: 1}
			}
		})) return;
		
		Packages.Library.$v.CurrentUserSpace.cache[options.key] = options.value;
		
		this.UpdateServer();
	};
	
	/****************************************************************
	 * AddItem - adds the specified item to the item array
	 *
	 * param - options : hash of options, must contain:
	 * 		name : the name of the item, if not unique, will return 0
	 * 		item : the hash of data to store, must contain a "type" key
	 * 		alert : 1 tell LogInfo to alert messages, 0 don't
	 *
	 * returns 1 on sucess, or 0 if an error occured
	 ***************************************************************/
	this.AddItem = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.UserSpace.AddItem",
			options: options,
			specification: {
				name: {type: "string", required: 1},
				item: {type: "object", required: 1}
			}
		})) return 0;
		
		// Ensure item has a "type" key
		if(options.item.type == null) {
			Packages.Library.$.LogInfo({alert: options.alert, mesg: "Item has no type for item named '" +  options.name + "'", location: "UserSpace.AddItem", type: "Missing Property", level: 3});
			return 0;
		}
		
		// Ensure item has a name key
		if(options.name == "") {
			Packages.Library.$.LogInfo({alert: options.alert, mesg: "No name specified", location: "UserSpace.AddItem", type: "Missing Property", level: 3});
			return 0;
		}
		
		// Ensure item name is unique
		if(Packages.Library.$.FindArrayItem({
			array: Packages.Library.$v.CurrentUserSpace.items,
			path: "name",
			value: options.name
		})) {
			Packages.Library.$.LogInfo({alert: options.alert, mesg: "Item name '" + options.name + "' already used", location: "UserSpace.AddItem", type: "Unique Check Failed", level: 3});
			return 0;
		}
		
		// Assign name to item
		options.item.name = options.name;
		
		// Add item to array
		Packages.Library.$v.CurrentUserSpace.items.push(options.item);
		
		this.UpdateServer();
		
		return 1;
	};
	
	/****************************************************************
	 * GetItemsList - fetches a list (ready for a select box) of items
	 * for the specified type
	 *
	 * param - options : hash of options, must contain:
	 * 		type : the type of items
	 *
	 * returns an array of select options
	 ***************************************************************/
	this.GetItemsList = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.UserSpace.GetItemsList",
			options: options,
			specification: {
				type: {type: "string", required: 1}
			}
		})) return 0;
		
		// Get items for this type
		var selectItems = [];
		for(var i = 0; i < Packages.Library.$v.CurrentUserSpace.items.length; i++) {
			var item = Packages.Library.$v.CurrentUserSpace.items[i];
			if(item.type != options.type) continue;
			
			selectItems.push({
				name: item.name,
				value: item.name
			});
		}
		
		return selectItems;
	};
	
	/****************************************************************
	 * GetItem - loads an item from the list
	 *
	 * param - options : hash of options, must contain:
	 * 		name : the name of the item
	 * 	may contain:
	 * 		remove : 1 also remove the item from the list, 0 (default) leave
	 *
	 * returns the item, or null if not found
	 ***************************************************************/
	this.GetItem = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.UserSpace.GetItem",
			options: options,
			specification: {
				name: {type: "string", required: 1},
				remove: {type: "boolean"}
			}
		})) return null;
		
		// Does the item exist?
		var item = Packages.Library.$.FindArrayItem({
			array: Packages.Library.$v.CurrentUserSpace.items,
			path: "name",
			value: options.name
		});
		
		if(item == null) {
			// Does not exist
			Packages.Library.$.LogInfo({mesg: "Item name '" + options.name + "' does not exist", location: "UserSpace.GetItem", type: "Item Missing", level: 3});
			return null;
		} else {
			// Found
			
			// Are we removing the item?
			if(options.remove == 1) {
				// Iterate through, create a new list without this item in it
				var newList = [];
				for(var i = 0; i < Packages.Library.$v.CurrentUserSpace.items.length; i++) {
					if(Packages.Library.$v.CurrentUserSpace.items[i].name == options.name) continue;
					newList.push(Packages.Library.$v.CurrentUserSpace.items[i]);
				}
				Packages.Library.$v.CurrentUserSpace.items = newList;
				
				// Update the server
				this.UpdateServer();
			}
			
			// Return the item
			return item;
		}
		
		return null; // Error state
	};
	
	/****************************************************************
	 * UpdateServer - sends the userspace back to the server
	 *
	 * param - loadOnly : 1 load the data, do not save, 0 (default) save first
	 ***************************************************************/
	this.UpdateServer = function(loadOnly) {
		var accountData = Packages.Library.$.GetAccountData({});
		// Does not work for logged off users
		if(accountData.status != 1) return;
		
		// Do we need to save data?
		var post = null;
		var query = null;
		var callback = null;
		if(loadOnly == 1) {
			callback = this.ServerCallback.bind(this);
			query = {
				"req-createorget": 1
			};
		} else {
			post = {
				saveUserspace64: btoa(Packages.Library.$.Dump({
					obj: Packages.Library.$v.CurrentUserSpace,
					skiplist: ["view", "edit", "panel"]
				}))
			}
			// When creating / saving, it doesn't matter
			query = {
				"req-ignorefile": 1
			};
		}
		
		this.serverRequest = new Packages.Library.ServerRequest();
		this.serverRequest.ServerRequest({
			page: "$masterpath/Users/" + accountData.username + ".userspace",
			callback: callback,
			post: post,
			showMask: 0,
			query: query
		});
	};
	
	/****************************************************************
	 * ServerCallback - callback for UpdateServer
	 *
	 * Called from ServerRequestCallback
	 *
	 * param - options : hash of options, must contain:
	 * 			serverReqElem : the elem containing the response
	 * 			response : the response
	 ***************************************************************/
	this.ServerCallback = function(options) {
		var elem = options.serverReqElem;
		var response = options.response;
		var res;
		if(response == null || response == "") return; // No data, a save action
		eval("res = " + response);
		if(res != null) {
			if(res.items == null) res.items = [];
			if(res.cache == null) res.cache = {};
			Packages.Library.$v.CurrentUserSpace = res;
		}
		
		// Check to see if the load selectbox exists, if so, update it
		var loadElem = document.getElementById(this.idprefix + "_userloadarea");
		if(loadElem != null) {
			loadElem.innerHTML = this._CreateLoadControl();
		}
	};
	
	/****************************************************************
	 * _CreateLoadControl - internal method for creating load control
	 *
	 * returns the markup for the load control
	 ***************************************************************/
	this._CreateLoadControl = function() {
		var html = "";
		if(this.object.type == null) return "No type";
		// Add load from userspace button, if compatible items exist
		var typeItems = this.GetItemsList({type: this.object.type});
		
		if(typeItems.length == 0) return "No compatible items";
		
		html += "<select " +
					"class='userspaceload_sel' " +
					"id='" + this.idprefix + "_userloadname'" +
				">" +
					Packages.Library.$.CreateSelectOptionsFromArray({
						items: typeItems
					}) +
				"<\/select>";
		html += "<button " +
					"onclick=\"" + this.textVar + ".UserspaceLoad()\" " +
				">" +
					"Load" +
				"<\/button>";
		html += "<button " +
					"onclick=\"" + this.textVar + ".UserspaceLoad(1)\" " +
				">" +
					"Load and Remove" +
				"<\/button>";
		html += "<button " +
					"onclick=\"" + this.textVar + ".UpdateServer(1)\" " +
				">" +
					"Refresh List" +
				"<\/button>";
		return html;
	}
	
	/****************************************************************
	 * GetEditControl - creates the markup for a load / save controller
	 * when editing an object
	 *
	 * param - options : hash of options, must contain:
	 * 		object : the object being edited
	 * 	may contain:
	 * 		alert : 1 (default) alert on error, 0 only log
	 * 		idprefix : string prefix, default "uspc"
	 * 		preLoadCallback : callback just before object is loaded
	 * 		preSaveCallback : callback just before object is saved
	 * 		postLoadCallback : callback after the object is loaded
	 * 		postSaveCallback : callback after the object is saved
	 *
	 * returns the markup or null on error
	 ***************************************************************/
	this.GetEditControl = function(options) {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Library.UserSpace.GetEditControl",
			options: options,
			specification: {
				object: {type: "object,DOMobject", required: 1},
				idprefix: {type: "string"},
				preLoadCallback: {type: "function"},
				preSaveCallback: {type: "function"},
				postLoadCallback: {type: "function"},
				postSaveCallback: {type: "function"}
			}
		})) return null;
		
		if(options.idprefix == null) options.idprefix = "uspc" + Packages.Library.$.GetUniqueId({});;
		if(options.alert == null) options.alert = 1;
		
		// The first time, the object is stored within this
		// The second time, the object is updated with values from
		// the new object, editing the first object
		this.object = null;
		
		Packages.Library.$.Merge({
			base: this,
			extra: options
		})
		
		var userspaceSaveHtml = "<h4>Save<\/h4>";
		var userspaceLoadHtml = "<h4>Load<\/h4>";
		// User space
		// Add save to userspace button
		userspaceSaveHtml += "Name: ";
		userspaceSaveHtml += "<input " +
					"type='text' " +
					"class='userspacesave_name'" +
					"id='" + this.idprefix + "_usersavename' " +
					(this.object.name != null ? "value='" + this.object.name + "' " : "") +
				">";
		userspaceSaveHtml += "<button " +
					"onclick=\"" + this.textVar + ".UserspaceSave()\" " +
				">" +
					"Save" +
				"<\/button>";
		
		userspaceLoadHtml += "<div id='" + this.idprefix + "_userloadarea'>" +
								this._CreateLoadControl() +
							"<\/div>";
		
		var html = "<div class='userspacetable mclearfix'>" +
					"<h3>Userspace" +
						Packages.Library.$.MakeHelp({help: "Allow this item to be saved into or loaded from your user space"}) +
					"<\/h3>" +
					"<div class='userspacecell'>" +
						userspaceSaveHtml +
					"<\/div><div class='userspacecell'>" +
						userspaceLoadHtml +
					"<\/div>" +
				"<\/div>";
				
		return html;
	};
	
	/*************************************************************************************************
	* UserspaceSave - saves the object into the userspace
	************************************************************************************************/
    this.UserspaceSave = function() {
		// Get the name for this item
		var nameElem = document.getElementById(this.idprefix + "_usersavename");
		if(nameElem == null) {
			Packages.Library.$.LogInfo({alert: this.alert, mesg: "No name available", location: "Form.UserspaceSave", type: "Missing Property", level: 3});
			return;
		}
		name = nameElem.value;
		
		// Fire save pre save callback if we have one
		if(this.preSaveCallback != null) this.preSaveCallback();
		
		this.AddItem({
			name: name,
			item: this.object,
			alert: this.alert
		});
		
		// Fire save post save callback if we have one
		if(this.postSaveCallback != null) this.postSaveCallback();
    };
	
	/*************************************************************************************************
	 * UserspaceLoad - removes an item from the userspace
	 *
	 * param - remove : 1 remove from userspace, 0 leave
	 ************************************************************************************************/
    this.UserspaceLoad = function(remove) {
		// Get the name for this item
		var selectElem = document.getElementById(this.idprefix + "_userloadname");
		var name = selectElem.value;
		
		var item = this.GetItem({
			name: name,
			remove: remove
		});
		
		if(item != null) {
			// Fire save pre load callback if we have one
			if(this.preLoadCallback != null) this.preLoadCallback();
			
			// Merge values in - critical to enable any additional keys, and references to stay
			Packages.Library.$.Merge({
				base: this.object,
				extra: item
			});
			
			// Fire save post load callback if we have one
			if(this.postLoadCallback != null) this.postLoadCallback();
		}
    };
};
Packages.Library.$v.CurrentUserSpace = {items: [], cache: {}};

/******************************************************************
 * CreateUserspace - creates a new userspace controller and initialises it
 *****************************************************************/
Packages.Library.$.CreateUserspace = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateUserspace",
		options: options,
		specification: {}
	})) return null;
	
	var userSpace = new Packages.Library.UserSpace();
	userSpace.Init();
	
	if(Packages.Library.$v.testing == 1) {
		// In test mode, normalise results
		// Clone first so not to effect base information
		userSpace = Packages.Library.$.Clone({oldObj: userSpace});
		userSpace.serverRequest.xmlhttp.response = "{}";
		userSpace.serverRequest.xmlhttp.responseText = "";
	}
	return userSpace;
};Package("Library.Wrappers.Classes").Wrapper = function() {};
/*******************************************************************************
 * MakeWrapperHTML - creates the wrapper HTML
 *
 * param - options : options for this wrapper
 * param - html : markup to wrap
 *
 * returns the html wrapped
 ******************************************************************************/
Packages.Library.Wrappers.Classes.MakeWrapperHTML = function(options, html) {
    var classes = "";
	
	if(options.classes != null) {
		foreach(options.classes, function(className) {
			classes += className + " ";
		});
	}
	if(options.customClasses != null) {
		classes += options.customClasses;
	}
	
    return "<div class='" + classes + "'>" + html + "<\/div>";
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Wrappers.Classes.GetChoiceForm = function() {
    return [
		{
            type: "Options",
			options: Packages.Library.$.GetClassesOptions({}),
            name: "Predefined classes",
            id: "classes",
            description: "Select classes to apply to this item"
        },
        {
            type: "Text",
			name: "Custom classes",
            id: "customClasses",
            description: "A space separated list of custom classes"
        }
    ]
};Package("Library.Wrappers.Custom").Wrapper = function() {};
/*******************************************************************************
 * MakeWrapperHTML - creates the wrapper HTML
 *
 * param - options : options for this wrapper
 * param - html : markup to wrap
 *
 * returns the html wrapped
 ******************************************************************************/
Packages.Library.Wrappers.Custom.MakeWrapperHTML = function(options, html) {
    if(options.content == null || options.content == "") return html;
	
	var content = Packages.Library.$.GetVersionOfData({data:  options.content});
	
    return content.replace(/<%content%>/g, html);
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Wrappers.Custom.GetChoiceForm = function() {
    return [
        {
            type: "RichText",
			editPlain: 1,
            value: "",
            name: "Enter Custom Content",
            subtitle: "&lt;%content%&gt;",
            id: "content",
            description: "Use &lt;%content%&gt; to mark where to place content.",
			multiversion: 1
        }
    ]
};Package("Library.Wrappers.Overlay").Wrapper = function() {};
/*******************************************************************************
 * MakeWrapperHTML - creates the wrapper HTML
 *
 * param - options : options for this wrapper
 * param - html : markup to wrap
 *
 * returns the html wrapped
 ******************************************************************************/
Packages.Library.Wrappers.Overlay.MakeWrapperHTML = function(options, html) {
    if(options.textOverlay == null || options.textOverlay.length == 0) return html;
    var overlayHTML = "";
    
    for(var i = 0; i < options.textOverlay.length; i++) {
        var overlay = options.textOverlay[i];
        
        if(overlay.bordercolour == null) overlay.bordercolour = "";
        if(overlay.colour == null) overlay.colour = "";
        if(overlay.padding == null) overlay.padding = "";
        
        var textborderstyles = "";
        if(overlay.bordercolour != "") {
            var col = "#" + overlay.bordercolour;
            textborderstyles += "text-shadow: 2px 0 0 " + col + ", -2px 0 0 " + col + ", 0 2px 0 " + col + ", 0 -2px 0 " + col + ", 1px 1px " + col + ", -1px -1px 0 " + col + ", 1px -1px 0 " + col + ", -1px 1px 0 " + col + ";";
        }
        
        overlayHTML += "<div style='position:absolute;top:0px;width:100%;height:100%;" +
                        "'>" +
                Packages.Library.$.MakeButton({
                    text: Packages.Library.$.ConvertCRToBR({
                        str: Packages.Library.$.GetVersionOfData({
                            data: overlay.text
                        })
                    }),
                    width: "100%",
                    height: "100%",
                    tag: overlay.tag,
                    horizalign: overlay.horizalign,
                    button: 0,
                    vertalign: overlay.vertalign,
                    textContainerStyles: (overlay.colour != "" ? "color:#" + overlay.colour + ";" : "") +
                                (overlay.padding != "" ? "padding:" + overlay.padding + ";" : ""),
                    textstyles: (overlay.colour != "" ? "color:#" + overlay.colour + ";" : "") + textborderstyles
                }) +
                "<\/div>";
    }
    
    return "<div style='position:relative'>" + html + overlayHTML + "<\/div>";
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Wrappers.Overlay.GetChoiceForm = function() {
    return [
        {
            type: "MultiForm",
            name: "Text Overlays",
            description: "Allows text to be overlaid on this panel",
            id: "textOverlay",
            data: [],
            title: "refcode",
            form: {
                items: [
                    {
                        type: "Text",
                        name: "Ref Code",
                        description: "Reference short name for this overlay",
                        value: "Text Overlay",
                        id: "refcode",
                        required: 1
                    },
                    {
                        type: "SelectBox",
                        value: "h3",
                        name: "Text Style",
                        id: "tag",
                        options: [
                            {name: "Heading 1", value: "h1"},
                            {name: "Heading 2", value: "h2"},
                            {name: "Heading 3", value: "h3"},
                            {name: "Heading 4", value: "h4"},
                            {name: "Heading 5", value: "h5"},
                            {name: "Heading 6", value: "h6"},
                            {name: "Heading 7", value: "h7"},
                            {name: "Bold", value: "b"},
                            {name: "Italics", value: "i"},
                            {name: "Underlined", value: "u"},
                            {name: "Normal", value: "p"}
                        ]
                    },
                    {
                        type: "TextArea",
                        name: "Text",
                        description: "The text to overlay",
                        value: "",
                        id: "text",
                        required: 1,
                        multiversion: 1
                    },
                    {
                        type: "SelectBox",
                        value: "center",
                        name: "Horizontal Text Alignment",
                        id: "horizalign",
                        options: [
                            {name: "Left", value: "left"},
                            {name: "Middle", value: "center"},
                            {name: "Right", value: "right"}
                        ]
                    },
                    {
                        type: "SelectBox",
                        value: "middle",
                        name: "Vertical Text Alignment",
                        id: "vertalign",
                        options: [
                            {name: "Top", value: "top"},
                            {name: "Middle", value: "middle"},
                            {name: "Bottom", value: "bottom"}
                        ]
                    },
                    {
                        type: "ColourSelector",
                        value: "",
                        name: "Text Colour",
                        description: "Specify a text colour, or leave blank for default page colour",
                        id: "colour"
                    },
                    {
                        type: "ColourSelector",
                        value: "",
                        name: "Text Border Colour",
                        description: "Specify a line colour for the text, or leave blank for no line",
                        id: "bordercolour"
                    },
                    {
                        type: "Text",
                        name: "Padding",
                        description: "Padding to insert around the text",
                        value: "0px",
                        id: "padding"
                    }
                ]
            }
        }
    ]
};Package("Library.Wrappers.Permission").Wrapper = function() {};
/*******************************************************************************
 * MakeWrapperHTML - creates the wrapper HTML
 *
 * param - options : options for this wrapper
 * param - html : markup to wrap
 *
 * returns the html wrapped
 ******************************************************************************/
Packages.Library.Wrappers.Permission.MakeWrapperHTML = function(options, html) {
    if(options.permission == null || options.permission == "") return html;
	
	var permissionMatches = (Packages.Library.$.Contains({array: pPermissions, item: options.permission})) ? 1 : 0;
	if(Packages.Library.$.Contains({array: pPermissions, item: "ADMIN"})) return html;
	
	if(options.mode == null) options.mode = "allow"; // Legacy update
	
	if(options.mode == "allow") {
		if(permissionMatches) {
			return html;
		} else {
			return "";
		}
	}
	if(options.mode == "deny") {
		if(permissionMatches) {
			return "";
		} else {
			return html;
		}
	}
	
    return ""; // Confused, so don't show
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Wrappers.Permission.GetChoiceForm = function() {
    return [
		{
            type: "SelectBox",
			options: [
				{name: "Allow", value: "allow"},
				{name: "Deny", value: "deny"}
			],
            name: "Mode",
            id: "mode",
            description: "Choose whether these users will be allowed or denied content.\n"
					+	"Allow - only the users with the permission specified will be allowed to view the content\n"
					+	"Deny - only the users with the permission specified will be prevented from viewing the content"
        },
        {
            type: "SelectBox",
			options: Packages.Library.$.GetPermissionOptions(),
            name: "Permission required",
            id: "permission",
            description: "Select the permission required to view the content",
			none: "Any - visible to all"
        }
    ]
};Package("Library.Wrappers.Schedule").Wrapper = function() {};
/*******************************************************************************
 * MakeWrapperHTML - creates the wrapper HTML
 *
 * param - options : options for this wrapper
 * param - html : markup to wrap
 *
 * returns the html wrapped
 ******************************************************************************/
Packages.Library.Wrappers.Schedule.MakeWrapperHTML = function(options, html) {
    if(options.scheduled == null || options.scheduled.length == 0) return html;
    // Are we scheduled to show this panel?
    
    // Get todays date
    var date = new Date();
    var datestring = date.getFullYear() + "-" + (date.getMonth() + 1) + "-" + date.getDate();
    
    if(Packages.Library.$.EvaluateComplexCondition({
        data: {
            date: datestring,
            pageviews: Packages.Library.$.GetPageViews()
        },
        conditions: options.scheduled
    }) == 0) return "";
    
    // Its ok, so display
    return html;
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * param - options : current options for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Wrappers.Schedule.GetChoiceForm = function(options) {
    return [
        Packages.Library.$.MakeComplexConditionFormItem({
            itemid: "scheduled",
            varDefs: [
                {
                    name: "Date",
                    ref: "date",
                    itemdef: {
                        type: "Date"
                    }
                },
                {
                    name: "Page Views",
                    ref: "pageviews",
                    itemdef: {
                        type: "Text"
                    }
                }
            ],
            item: {
                name: "Schedule",
                description: "Schedule this content so that it will only appear when these conditions are satisfied."
            }
        })
    ];
};Package("Library.Wrappers.Styling").Wrapper = function() {};
/*******************************************************************************
 * MakeWrapperHTML - creates the wrapper HTML
 *
 * param - options : options for this wrapper
 * param - html : markup to wrap
 *
 * returns the html wrapped
 ******************************************************************************/
Packages.Library.Wrappers.Styling.MakeWrapperHTML = function(options, html) {
    // Calculate styles
    var styles = "";
	var extraClasses = "";
    for(var css in options) {
        if(css == "wrapper") continue;
        if(css == "type") continue;
        if(options[css] == null) continue;
        if(options[css] == "") continue;
        if(typeof(options[css]) != "string" && typeof(options[css]) != "number") continue;
		options[css] += ""; // Force string
        if(css == "misc_css") {
            styles += options[css].replace(/\n/, ";");
            continue;
        }
        
		if(css.match(/^class_(.+)/)) {
			var className = RegExp.$1;
			extraClasses += " " + className;
		} else {
			var attrib = css;
			
			var suffix = "";
			var prefix = "";
			if(css.match(/_px$/)) {
				suffix = "px";
				attrib = css.replace(/_px$/, "");
			}
			if(css.match(/_pt$/)) {
				suffix = "pt";
				attrib = css.replace(/_pt$/, "");
			}
			if(css.match(/_hash$/)) {
				prefix = "#";
				attrib = css.replace(/_hash$/, "");
			}
			
			// If value ends in a '%' then clear the suffix
			if(options[css].match(/%$/)) suffix = "";
			
			// Convert css safe name to css name
			attrib = attrib.replace(/_/g, "-");
			
			styles += attrib + ":" + prefix + options[css] + suffix + ";";
		}
    }
    
    html = "<div style=\"" + styles + "\" class='stylingstyles" + extraClasses + "'>"
            + html
        + "<\/div>";
        
    return html;
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Wrappers.Styling.GetChoiceForm = function() {
    var boxHtml = "<div class='stylingBox'>An example stylable element box<\/div>";
	
	var previewElemId = "stylingpreview" + Packages.Library.$.GetUniqueId();
    
    var livePreview = function(form, object) {
        var elem = document.getElementById(previewElemId);
        var html = Packages.Library.Wrappers.Styling.MakeWrapperHTML(object, boxHtml);
        if(elem) elem.innerHTML = html;
    };
    
    return [
        {
            type: "Text",
            numeric: 1,
            min: 0,
            id: "padding_px",
            name: "Inner spacing",
            subtitle: "padding",
            value: 0,
            suffix: "px",
			size: 4,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "Text",
            numeric: 1,
            id: "margin_px",
            name: "Outer spacing",
            subtitle: "margin",
            value: 0,
            suffix: "px",
			size: 4,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "Text",
            id: "width_px",
            name: "Width",
            value: "",
            suffix: "px",
			numeric: 1,
			min: 0,
			size: 4,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "Text",
            id: "height_px",
            name: "Height",
            value: "",
            suffix: "px",
			numeric: 1,
			min: 0,
			size: 4,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "Text",
            numeric: 1,
            min: 0,
            id: "border_width_px",
            name: "Border thickness",
            subtitle: "border-width",
            value: 0,
            suffix: "px",
			size: 4,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "Text",
            numeric: 1,
            min: 0,
            id: "border_radius_px",
            name: "Border roundedness",
            subtitle: "border-radius",
            value: 0,
            suffix: "px",
			size: 4,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "Text",
            numeric: 1,
            min: 0,
            id: "z_index",
            name: "Layer Ordering",
            subtitle: "z-index",
            value: "",
			size: 4,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "SelectBox",
            id: "text_align",
            name: "Text Alignment",
            subtitle: "text-align",
            value: "left",
            options: [
                {name: "Left", value: "left"},
                {name: "Centre (center)", value: "center"},
                {name: "Right", value: "right"}
            ],
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "Text",
            numeric: 1,
            min: 0,
            id: "font_size_pt",
            name: "Text Size",
            subtitle: "font-size",
            suffix: "pt",
			size: 4,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "SelectBox",
            id: "font_weight",
            name: "Bold",
            subtitle: "font-weight",
            value: "normal",
            options: [
                {name: "Normal", value: "normal"},
                {name: "Bold", value: "bold"},
                {name: "Bolder", value: "bolder"},
                {name: "Lighter", value: "lighter"}
            ],
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "SelectBox",
            id: "font_style",
            name: "Italics",
            subtitle: "font-style",
            value: "normal",
            options: [
                {name: "Normal", value: "normal"},
                {name: "Italic", value: "italic"},
                {name: "Oblique", value: "oblique"}
            ],
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "SelectBox",
            id: "text_decoration",
            name: "Underline",
            subtitle: "text-decoration",
            value: "none",
            options: [
                {name: "None", value: "none"},
                {name: "Underline", value: "underline"},
                {name: "Overline", value: "overline"},
                {name: "Line through", value: "line-through"}
            ],
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "ColourSelector",
            id: "border_color_hash",
            name: "Border Colour",
            subtitle: "border-color",
            value: "000",
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "ColourSelector",
            id: "background_color_hash",
            name: "Background Colour",
            subtitle: "background-color",
            value: "",
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "ColourSelector",
            id: "color_hash",
            name: "Text Colour",
            subtitle: "color",
            value: "",
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "TextArea",
            id: "misc_css",
            name: "Additional CSS Styles",
            value: "",
            foldable: 1,
            folded: 1,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "SelectBox",
            id: "position",
            name: "Position",
            value: "relative",
            options: [
                {name: "Inline (relative)", value: "relative"},
                {name: "Hovering (absolute)", value: "absolute"}
            ],
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "SelectBox",
            id: "overflow",
            name: "Overflow",
            value: "visible",
            options: [
                {name: "Show (visible)", value: "visible"},
                {name: "Hide (hidden)", value: "hidden"}
            ],
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "Checkbox",
            id: "class_mnopagebreak",
            name: "No page break",
			description: "When checked, and if printed, the content will not allow spliting over page breaks",
            checked: 0,
            action: livePreview,
            reloadForm: 0
        },
        {
            type: "HTML",
            name: "Preview",
            html: "<div id='" + previewElemId + "' class='stylingpreview'><\/div>"
        }
    ]
};Package("Tests.Wrappers");
/*************************************************************************************************
 * Wrappers - Tests the wrappers
 *
 * return - res : hash of data to store, containing
 *      pass : 1 pass, 0 fail
 *      detail : hash of detail, containing
 *          metaData : the metadata used to create the form
 *          inputData : the data as it was presented before entering the form
 *          outputData : the data as it was presented after entering the form
 *          content : the content that was displayed to make the form
 ************************************************************************************************/
Packages.Tests.$.Wrappers = function(options) {
    var contents = "";
    for(var type in Packages.Library.Wrappers) {
        var wrapper = Packages.Library.Wrappers[type];
        if(wrapper.GetChoiceForm == null) continue;
        
        var results = [];
        for(var set = 0; set < 5; set++) {
            var form = {
                items: wrapper.GetChoiceForm()
            };
            if(form.items == null) continue; // Not supported
            var data = Packages.Tests.$.GetFormObject({
                set: set,
                form: form
            });
            data.type = type;
            
            var content = Packages.Library.Wrappers.$.WrapHtml({
                wrappers: [data],
                html: "Wrapped Content"
            }).split(/\n/);
            results.push({
                data: data,
                content: content
            });
            contents += content;
        }
        
        options.test.SaveTestResult({
            testName: options.testPrefix + "." + type,
            data: results
        });
    }
    
    var mask = Packages.Library.$.CreateMaskLayer({
        content: contents,
        opacity: 1
    });
    // Close the mask
    mask.Close();
    
    return {
        pass: 1
    };
};Package("Library.Wrappers.Title").Wrapper = function() {};
/*******************************************************************************
 * MakeWrapperHTML - creates the wrapper HTML
 *
 * param - options : options for this wrapper
 * param - html : markup to wrap
 *
 * returns the html wrapped
 ******************************************************************************/
Packages.Library.Wrappers.Title.MakeWrapperHTML = function(options, html) {
    if(options.title == null || options.title == "") return html;
	
	// A tag options
	var aTagOptions = "";
	if(options.anchor != null && options.anchor != "") {
		aTagOptions += " class='wrapper_title_anchor' name='" + options.anchor + "'";
	}
	
    var titleHtml = "<div class='paneltitle'><h3><a" + aTagOptions + ">" +
		Packages.Library.$.ConvertCRToBR({
			str: Packages.Library.$.GetVersionOfData({
				data: options.title
			})
		}) +
	"<\/a><\/h3><\/div>";	
    
    return Packages.Library.$.CreateFoldArea({
        title: titleHtml,
        content: html,
        foldable: options.foldable,
        folded: options.folded,
        border: 0,
        direction: options.folddirection
    });
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Wrappers.Title.GetChoiceForm = function() {
    return [
        {
            type: "Text",
            value: "",
            name: "Enter Panel Title",
            subtitle: "Or blank for no title",
            id: "title",
            description: "The panel title appears as a heading above the content.",
			multiversion: 1
        },
        {
            type: "Checkbox",
            checked: 0,
            name: "Foldable",
            id: "foldable",
            description: "Allow this content to be folded (hidden by the user). Requires a title."
        },
        {
            type: "Checkbox",
            checked: 0,
            name: "Start Folded",
            id: "folded",
            description: "If in folded mode, this content starts folded"
        },
        {
            type: "Text",
            checked: 0,
            name: "Anchor",
            id: "anchor",
            description: "When specified, this content will be wrapped in an anchor that can be accessed with #&lt;anchor text&gt;"
        }
    ]
};Package("Library.Wrappers.URL").Wrapper = function() {};
/*******************************************************************************
 * MakeWrapperHTML - creates the wrapper HTML
 *
 * param - options : options for this wrapper
 * param - html : markup to wrap
 * param - additionalOptions : additional options from caller
 *
 * returns the html wrapped
 ******************************************************************************/
Packages.Library.Wrappers.URL.MakeWrapperHTML = function(options, html, additionalOptions) {
    if(options.url == "" || options.url == null) return html;
    if(additionalOptions.interactivemode == 0) return html;
    
    var path = Packages.Library.$.ConvertLegacy({str: options.url});
    if(!path.match(/http/i)) path = Packages.Library.$.GetPathToBase({filepath: path});
    
    return "<a href='" + path + "'>" + html + "<\/a>";
};

/*******************************************************************************
 * GetChoiceForm - gets the form items for this wrapper
 *
 * returns the form items
 ******************************************************************************/
Packages.Library.Wrappers.URL.GetChoiceForm = function() {
    return [
        {
            type: "URL",
			// thumbnailPrefix: Packages.Library.$.GetPathToBase({filepath: ""}),
            folder: pContainerFolders,
            value: "",
            name: "HyperLink",
            id: "url",
            description: "This makes the entire content a hyperlink for another page, an image or an external website.",
			useContainerPath: 1
        }
    ];
};Package("Library.Wrappers").Wrappers = function() {};
/***************************************************************
 * GetWrapperFormItem - returns the wrapper form item
 *
 * param - options : hash of extra fields (or overrides) for the form item and:
 * 		noNameOrDesc : 1 do not apply a name or desc, 0 (default) do
 *
 * returns the form item
 **************************************************************/
Packages.Library.Wrappers.$.GetWrapperFormItem = function(options) {
	if(options == null) options = {};
	options.choices = Packages.Library.Wrappers;
	if(options.noNameOrDesc  != 1) {
		if(options.name == null) options.name = "Wrappers";
		if(options.description == null) options.description = "You may have multiple wrappers. The wrappers are applied in the order given, so the last wrapper is the outermost.";
	}
	if(options.id == null) options.id = "Wrappers";
	options.choiceId = "type";
	return Packages.Library.$.GetMultiFormWithChoicesItemFromFolderOfChoices(options);
};

/***************************************************************
 * WrapHtml - performs the wrapping
 *
 * param - options : hash of options, must contain:
 * 			wrappers : the wrappers from the containing object
 * 			html : html to wrap
 * 			subOptions : options passed to sub modules
 *
 * returns the wrapped markup
 **************************************************************/
Packages.Library.Wrappers.$.WrapHtml = function(options) {
	if(options.wrappers == null) return options.html;
	
	for(var i = 0; i < options.wrappers.length; i++) {
		var childObject = options.wrappers[i];
		
		var wrapperName = childObject.type;
		
		var wrapper = Packages.Library.Wrappers[wrapperName];
		if(wrapper.MakeWrapperHTML == null) continue;
		
		options.html = wrapper.MakeWrapperHTML(childObject, options.html, options.subOptions);
	}
	
	return options.html;
};/*********************************************************************
 * WriteXML - (recursive) creates the XML from the JS object definition
 *
 * param - options : hash of options, must contain:
 * 				xmldefs : array of xmldefs, each of the form:
 * 					name : tag name
 * 					attributes : (optional) hash of name - value attributes
 * 					text : (optional) text inside the node
 * 					children : (optional) array of children (exactly as this array)
 * 			May contain:
 * 				depth : (internal) depth of whitespace (default 0)
 *
 * returns the string of XML (multiline and indented)
 ********************************************************************/
Packages.Library.$.WriteXML = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.WriteXML",
		options: options,
		specification: {
			xmldefs: 	{type: "array",	required: 1},
			depth: 		{type: "number"}
		}
	})) return null;
	
	var depth = options.depth;
	if(depth == null) depth = 0;
	var xmldefs = options.xmldefs;
	var whitespace = "";
	for(var i = 0; i < depth; i ++) whitespace += "\t";
	
	// Generate XML
	var xmlnodes = "";
	for(var i = 0; i < xmldefs.length; i++) {
		var object = xmldefs[i];
		if(object.attributes == null) object.attributes = {};
		
		// Get attributes
		var attributes = "";
		for(var name in object.attributes) {
			var val = object.attributes[name];
			if(val == null) val = "\"null\"";
			val = val + ""; // Force to be a string
			// Make safe replacements
			val = Packages.Library.$.ConvertCRToXML({str: val});
			attributes += " " + name + "=\"" + val + "\"";
		}
		
		var xmlnode = whitespace + "<" + object.name + attributes + ">";
		
		if(object.children != null) {
			xmlnode += Packages.Library.$.WriteXML({xmldefs: object.children, depth: depth + 1});
		} else if(object.text != null) {
			var text = object.text + ""; // Force to be a string
			// Make safe replacements
			text = Packages.Library.$.ConvertCRToXMLContent({str: text});
			xmlnode += text;
		}
		
		// Close node
		xmlnode += "<\/" + object.name + ">\n";
		
		xmlnodes += xmlnode;
	}
	
	return xmlnodes;
};

/*********************************************************************
* ReadXML - (recursive) reads the XML into a JS definition
*
* param - options : hash of options, must contain:
* 				xml : string of XML text to read
*
* return - xmldefs : array of xmldefs, each of the form:
* 					name : tag name
* 					attributes : (optional) hash of name - value attributes
* 					text : (optional) text inside the node
* 					children : (optional) array of children (exactly as this array)
********************************************************************/
Packages.Library.$.ReadXML = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ReadXML",
		options: options,
		specification: {
			xml: 	{type: "string",	required: 1}
		}
	})) return null;
	
	if(options.xml == 404) return null;
	
	// We must use pass by reference, this is extremely important as the xml string
	// constantly changes as parts are processed.
	
	// Create blank array for this tier
	var xmldefs = [];
	
	// Parse each node in this tier in turn, until there are done left
	// Search for whitespace <tagname optional attributes> whitespace
	var outerRegExp = /^\s*<(\w+)(.*?)>\s*/;
	while(options.xml.match(outerRegExp)) {
		// Node found, parsing
		
		options.xml = options.xml.replace(outerRegExp, ""); // Remove processed section
		var tag = RegExp.$1;
		var attrs = RegExp.$2;
		
		var object = {};
		object.name = tag;
		
		var attributes = {};
		
		// Split the attributes out
		var noAttrs = 0;
		// Search for name="value\"more"
		// Essentially, we look for either a \" or a non quote charactor
		var re = /(\w+)="((\\.|[^"])*)"/;
		//				   ^^^ ^^^^
		//		Escaped char/	\Non quote char
		while(attrs.match(re)) {
			attrs = attrs.replace(re, ""); // Remove
			var attr = RegExp.$1;
			var val = RegExp.$2;
			
			// De-escape the quote
			val = val.replace(/\\"/g, "\"");
			
			val = Packages.Library.$.ConvertXMLToCR({str: val});
			if(val == "null") val = null;
			attributes[attr] = val;
			noAttrs++;
		}
		// Store attributes
		object.attributes = attributes;
		
		// Did it end with a />?
		if(!attrs.match(/\/$/)) {
			// No /> so there are children
			
			// Does it contain something other than XML?
			// Search for whitespace <
			var re = /^\s*</;
			if(!options.xml.match(re)) {
				// Text content found
				options.xml = options.xml.replace(/([^<]*)/, ""); // Remove
				var text = RegExp.$1;
				text = Packages.Library.$.ConvertXMLToCR({str: text});
				object.text = text;
			} else {
				// XML content found
				// Does it contain any children - or is it just a closing tag
				// Search for whitespace </
				var re = /^\s*<\//;
				if(!options.xml.match(re)) {
					// Opening tag found
					
					// Get children
					object.children = Packages.Library.$.ReadXML(options);
				}
			}
			// Remove closing tag
			// Search for </tagname> whitespace
			var re = new RegExp("^\\s*<\/" + tag + ">\\s*");
			if(options.xml.match(re)) {
				options.xml = options.xml.replace(re, ""); // Remove
			}
		}
		
		xmldefs.push(object);
	}
	
	return xmldefs;
};

/*********************************************************************
 * XML to JS object - converts data from a string of XML to JS objects and back
 *
 * The JS object is converted to an XML Def, which can be converted through the
 * normal ReadXML and WriteXML functions.
 *
 * Format conversion
 * 	XML:	<parent1 attr1="val1" attr2="val2">
 * 				<child childattr1a="val1a" />
 * 				<child childattr2a="val2a" childattr2b="val2b">
 * 					<sub1 subattr1="val1"></sub1>
 * 					<sub2></sub2>
 * 				</child>
 * 			</parent1>
 *
 *	JS:		parent1 : {
 *						attr1: "val1",
 *						attr2: "val2",
 *						$: 	[
 * 								{
 * 									child1: {
 * 										childattr1a: "val1a"
 * 									},
 * 									child2: {
 * 										childattr2a: "val2a",
 * 										childattr2v: "val2b",
 * 										$: 	[
 *											{
 *												sub1: {
 *													subattr1: "val1",
 *													$: "content"
 *												}
 *											}
 *										]
 *									}
 * 								}
 *							]
 *					 }
 ********************************************************************/
Package("Library").XML = function() {};
/*********************************************************************
* ConvertJSToXMLDef - (recursive) converts a JS object to XML def
*
* param - options : hash of options, must contain:
* 				object : object to convert
* 			May contain:
* 				parentname : (internal) name for this tag (default 'root')
*
* return - xmldef : xmldef (see ReadXML and WriteXML)
********************************************************************/
Packages.Library.$.ConvertJSToXMLDef = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertJSToXMLDef",
		options: options,
		specification: {
			object: 	{type: "object,array,string,number,boolean,null,undefined",	required: 1},
			parentname: {type: "string"}
		}
	})) return null;
	if(options.parentname == null) options.parentname = "root";
	
	var object = options.object;
	var xmldef = {attributes: {}, name: options.parentname};
	
	if(typeof(object) == "object") {
		// Content is object / array
		for(var key in object) {
			if(key == "$noDump") continue; // Skip $noDump key
			if(key == "$id") continue; // Skip $noDump key
			var val = object[key];
			if(val == null) val = "null";
			if(typeof(val) == "boolean") val = val ? 1 : 0;
			
			if(key.match(/^\d/)) key = "a_" + key; // Numeric starts not allowed
			
			if(typeof(val) == "string" || typeof(val) == "number") {
				if(key == "$") {
					// Text content (where there are attributes)
					xmldef.text = val;
				} else {
					// Attributes
					xmldef.attributes[key] = val;
				}
			} else {
				// Nested object / array
				if(xmldef.children == null) xmldef.children = [];
				xmldef.children.push(Packages.Library.$.ConvertJSToXMLDef({object: val, parentname: key}));
			}
		}
	} else if(typeof(object) == "string" || typeof(object) == "number" || typeof(object) == "boolean") {
		// Content is text
		xmldef.text = object;
	}
	
	return xmldef;
};
/*********************************************************************
* ConvertXMLDefToJS - (recursive) converts a XML Def into a JS object
*
* param - options : hash of options, must contain:
* 				xmldef : xmldef to convert (internally used as object)
*
* returns JS object or null on error
********************************************************************/
Packages.Library.$.ConvertXMLDefToJS = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertXMLDefToJS",
		options: options,
		specification: {
			xmldef: {type: "object",	required: 1}
		}
	})) return null;
	
	var xmldef = options.xmldef;
	
	// Create blank object for this tier
	var object = {};
	
	// Parse xmldef
	var tag = xmldef.name;
	if(tag == null) return null;
	// If param starts with 'a_', remove this part
	if(tag.match(/^a_\d/)) tag = tag.replace(/^a_/, "");
	
	if(object[tag] != null && Packages.Library.$.GetType({item: object[tag]}) != "array") {
		// Was a single object or primitive, we are about to add another, convert to array
		object[tag] = [object[tag]];
	}
	if(object[tag] == null) {
		// Not defined, so define as single object
		object[tag] = {};
	}
	
	
	// Create object for this tier
	var noAttrs = 0;
	var res = {};
	
	// Split the attributes out
	for(var attr in xmldef.attributes) {
		var val = xmldef.attributes[attr];
		
		// If param starts with 'a_', remove this part
		if(attr.match(/^a_\d/)) attr = attr.replace(/^a_/, "");
		res[attr] = val;
		noAttrs++;
	}
	
	// Does it have a text node or children?
	if(xmldef.text != null) {
		// It has a text node
		res = xmldef.text;
	} else if(xmldef.children != null) {
		// It has children
		for(var c = 0; c < xmldef.children.length; c++) {
			var child = xmldef.children[c];
			var subres = Packages.Library.$.ConvertXMLDefToJS({xmldef: child});
			// Copy subres into res
			for(var item in subres) {
				if(res[item] != null && Packages.Library.$.GetType({item: res[item]}) != "array") {
					// Was a single object or primitive, we are about to add another, convert to array
					res[item] = [res[item]];
				}
				if(res[item] == null) {
					// Not defined, so define as single object
					res[item] = {};
				}
				if(Packages.Library.$.GetType({item: res[item]}) != "array") {
					// 'res' is empty single object or primitive
					res[item] = subres[item];
				} else {
					// 'res' is an array
					if(Packages.Library.$.GetType({item: subres[item].length}) != "array") {
						// 'subres' is an object or primitive
						res[item].push(subres[item]);
					} else {
						// 'subres' is an array
						res[item] = res[item].concat(subres[item]);
					}
				}
			}
		}
	}
	
	res = Packages.Library.$.XMLInterpretContent({item: res});
	
	if(Packages.Library.$.GetType({item: object[tag]}) != "array") {
		object[tag] = res; // object or primitive
	} else {
		object[tag].push(res); // array
	}
	
	if(object == null) return null;
	if(object.root == null) {
		if(typeof(object) != "object" || object.length == null) return object;
		return object;
	}
	return object.root;
};

/*********************************************************************
* XMLInterpretContent - interprets the content of an XML block
*
* Item may be null - so return empty array
* Item may be a primitive - so return the primitive
* Item may he a hash (without numeric keys) - so return the hash
* Item may he a hash (with numeric keys) - so convert into an array
* Item might be an array already - so return it
* 
* param - options : hash of options, must contain:
* 				item : item to process (object / array / undefined)
*
* returns an array of corrected data
********************************************************************/
Packages.Library.$.XMLInterpretContent = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.XMLInterpretContent",
		options: options,
		specification: {
			item: 	{type: "object,array,undefined,string,number,boolean,null",	required: 1}
		}
	})) return null;
	
	var item = options.item;
	
	var type = Packages.Library.$.GetType({item: item});
	
	// Item may be null - so return empty array
	if(type == null) return [];
	
	// Item may be a primitive - so return the primitive
	if(type == "string" || type == "number" || type == "boolean") return item;
	
	if(type == "object" ) {
		var arrayFromObject = Packages.Library.$.GetArrayFromObject({object: item});
		
		if(arrayFromObject == null)
		{
			// Item may he a hash (without numeric keys) - so return the hash
			return item;
		} else {
			// Item may he a hash (with numeric keys) - so convert into an array
			return arrayFromObject;
		}
	}
	// Item might be an array already - so return it
	if(type == "array") return item;
	
	// There are no other options, are there?
	return null;
};Package("Library").XMLRPC = function() {};
/*********************************************************************
 * CreateXMLRPCMethodCall - creates an XMLRPC method call
 *
 * Currently only supports type string
 *
 * param - options : hash of options, must contain:
 * 				methods : array of method defs, each of the form:
 * 						classname : class of method to call
 * 						method : method name to call
 * 					May contain:
 * 						params : array of params to send through
 * 						callback : method to call when the server responds to this specific request
 * 				callback : (optional) callback to call after all of the above is done
 ********************************************************************/
Packages.Library.$.CreateXMLRPCMethodCall = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.CreateXMLRPCMethodCall",
		options: options,
		specification: {
			methods: 	{type: "array",	required: 1},
			callback: 	{type: "function"}
		}
	})) return;
	
	var xmldefs = [];
	
	// Add blank 'last' method to ensure it always gets a return value
	options.methods.push({classname: "GEN", method: "Last"});
	
	for(var m = 0; m < options.methods.length; m++) {
		var method = options.methods[m];
		if(method.params == null) method.params = [];
		
		var xmldef = {
			name: "methodCall",
			children: [
				{
					name: "methodName",
					text: method.classname + "." + method.method
				},
				{
					name: "params",
					children: Packages.Library.$.XMLRPCCreateParams({params: method.params, wrapperTag: "param", wrapInner: 1})
				}
			]
		};
		
		xmldefs.push(xmldef);
	}
	
	var xml = Packages.Library.$.WriteXML({xmldefs: xmldefs});
	
	// Create a callback wrapper in scope
	var callback = function(serverRequestData) {
		var response = serverRequestData.response;
		
		// Get xml response
		var xmlReponse = Packages.Library.$.ReadXML({xml: response});
		if(xmlReponse == null || xmlReponse.length == 0) return;
		
		var methodResponsesContainer = xmlReponse[0];
		if(methodResponsesContainer.children == null) return;
		var methodResponses = methodResponsesContainer.children;
		
		// Send responses to caller
		// Log each response
		Packages.Library.$.LogInfo({mesg: "Sent:\n" + xml + "Received:\n" + response, location: "XMLRPC Callback", type: "Content", level: 10});
		
		var responses = [];
		if(methodResponses == null) return;
		for(var r = 0; r < methodResponses.length; r++) {
			responses.push(Packages.Library.$.ConvertXMLRPCResponse({xmldefs: methodResponses[r]}));
		}
		
		// Call the callback for each method (if it has one)
		for(var m = 0; m < options.methods.length; m++) {
			var method = options.methods[m];
			
			if(method.callback != null) method.callback(responses[m]);
		}
		
		// Finally call main callback
		if(options.callback != null) options.callback(responses);
	}
	
	var serverRequest = new Packages.Library.ServerRequest();
	serverRequest.ServerRequest({
		page: "",
		post: {xmlrpc: xml},
		query: {"req-ignorefile": 1},
		callback: callback
	});
};

/*********************************************************************
 * XMLRPCCreateParams - creates the XMLRPC params from an array of values
 *
 * param - options : hash of options, must contain:
 * 				params : array of params to send through
 * 				wrapperTag : the tag to wrap each item in
 * 				wrapInner : 1 wrap inner defs, 0 wrap once on outside
 *
 * returns the paramdefs ready to be placed in the children section of the node
 ********************************************************************/
Packages.Library.$.XMLRPCCreateParams = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.XMLRPCCreateParams",
		options: options,
		specification: {
			params: 	{type: "array",	required: 1},
			wrapperTag: {type: "string",	required: 1},
			wrapInner: 	{type: "boolean",	required: 1}
		}
	})) return null;
	
	var paramdefs = [];
	// Iterate through params and add each
	for(var i = 0; i < options.params.length; i++) {
		var param = options.params[i];
		var paramdef = {
			name: "value",
			children: [
				{
					name: Packages.Library.$c.XMLRPCTypes[Packages.Library.$.GetType({item: param, strict: 0})]
				}
			]
		}
		
		// Determine the type of the item, and depending on that type add the correct data
		if(Packages.Library.$.GetType({item: param}) == "string" || Packages.Library.$.GetType({item: param}) == "number") {
			paramdef.children[0].text = param;
		}
		if(Packages.Library.$.GetType({item: param, strict: 0}) == "array") {
			paramdef.children[0].children = Packages.Library.$.XMLRPCCreateParams({params: param, wrapperTag: "data", wrapInner: 0});
		}
		
		// Add xmldef to xmldefs
		if(options.wrapInner == 1) {
			// First wrap in a container
			paramdef = {
				name: options.wrapperTag,
				children: [
					paramdef
				]
			};
		}
		paramdefs.push(paramdef);
	}
	
	if(options.wrapInner == 0) {
		// Wrap all defs in container
		paramdefs = [{
			name: options.wrapperTag,
			children: paramdefs
		}];
	}
	return paramdefs;
};

/*********************************************************************
 * ConvertXMLRPCResponse - converts XMLRPC response to JS array
 *
 * Currently only supports type string and int
 *
 * param - options : hash of options, must contain:
 * 				xmldefs : the xmldefs for this method response
 *
 * returns the JS array or null if an error occurs
 ********************************************************************/
Packages.Library.$.ConvertXMLRPCResponse = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertXMLRPCResponse",
		options: options,
		specification: {
			xmldefs: 	{type: "object",	required: 1}
		}
	})) return null;
	
	var methodResponse = options.xmldefs;
	if(methodResponse.children == null) return null;
	
	var params = methodResponse.children[0];
	if(params.children == null) return null;
	var response = [];
	for(var i = 0; i < params.children.length; i++) {
		var param = params.children[i];	if(param == null) continue;
		if(param.children == null) continue;
		var value = param.children[0];	if(value == null) continue;
		
		response.push(Packages.Library.$.ConvertXMLRPCResponseParams({xmldefs: value}));
	}
	
	return response;
};

/*********************************************************************
 * ConvertXMLRPCResponseParams - converts XMLRPC response params to JS array
 *
 * param - options : hash of options, must contain:
 * 				xmldefs : xmldefs for the element that denotes value
 *
 * returns the JS array or null if an error occurs
 ********************************************************************/
Packages.Library.$.ConvertXMLRPCResponseParams = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.ConvertXMLRPCResponseParams",
		options: options,
		specification: {
			xmldefs: 	{type: "object",	required: 1}
		}
	})) return null;
	
	var value = options.xmldefs;
	
	if(value.children == null) return null;
	var type  = value.children[0];	if(type  == null) return null;
	
	if(type.name == "string" || type.name == "int") {
		if(type.text == null) type.text = ""; // Empty string
		return type.text;
	}
	if(type.name == "array") {
		var data = type.children[0];	if(data == null) return null;
		var items = data.children;	if(items == null) return null;
		
		var array = [];
		for(var i = 0; i < items.length; i++) {
			array.push(Packages.Library.$.ConvertXMLRPCResponseParams({xmldefs: items[i]}));
		}
		return array;
	}
	
	return null;
};

// Create types look up table
Packages.Library.$c.XMLRPCTypes = {
	"string": "string",
	"number": "int",
	"array" : "array"
};Package("Library").WEB = function() {};
Package("FileType").$p = ""; // Path to the FileType packages (root)
var filecontent = "";
/*********************************************************************
 * LoadViewer - BOOTLOADER - Start entry point in VIEW mode
 ********************************************************************/
Packages.Library.$.LoadViewer = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.LoadViewer",
		options: options,
		specification: {}
	})) return;
	
	if(Packages.Library.$v.testing == 1) return; // Do nothing in test mode
	
	Packages.Library.$.LogInfo({
		mesg: "Started LoadViewer",
		location: "Packages.Library.$.LoadViewer",
		level: 1
	});
	
	Packages.Library.$.Init();
    Packages.Library.$._LoadViewerStage2();
};
/*********************************************************************
 * _LoadViewerStage2 - callback worker after LoadViewer has gotten JS for the given file type
 ********************************************************************/
Packages.Library.$._LoadViewerStage2 = function() {
	if(Packages.Library.$v.testing == 1) return; // Do nothing in test mode
	
	var viewer;
    if (Packages.FileType[pFileTypeSafe].$k != null) {
		viewer = GetSingleton(Packages.FileType[pFileTypeSafe], "$k");
    } else if (Packages.FileType[pFileTypeSafe].view != null) {
		viewer = GetSingleton(Packages.FileType[pFileTypeSafe], "view");
    }
	
	if(viewer == null) {
		// No viewer found
        Packages.Library.$.DisplayDefaultControls();
    }
	
	Packages.Library.$i.FileObject = viewer;
	
	if(Packages.Library.$.WasPageBuiltWithNode() == 1
	&& Packages.Library.$.GetQueries({}).forceJSRender != 1) {
		// Already rendered
	} else {
		// Display normally
		viewer.WebDisplay();
	}
	
	if(Packages.Library.$c.IsNode != 1) {
		// Call live
		if(viewer.WebLive != null) viewer.WebLive();
	}
};
/*********************************************************************
 * LoadEditor - BOOTLOADER - Start entry point in EDIT mode
 ********************************************************************/
Packages.Library.$.LoadEditor = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.LoadEditor",
		options: options,
		specification: {}
	})) return;
	
	if(Packages.Library.$.GetQueries({}).nodeOnly == 1) return;
	
	if(Packages.Library.$v.testing == 1) return; // Do nothing in test mode
	
    Packages.Library.$.LoadViewer();
    Packages.Library.$._LoadEditorStage2();
};
/*********************************************************************
 * _LoadEditorStage2 - callback worker after LoadEditor has gotten JS for the given file type
 ********************************************************************/
Packages.Library.$._LoadEditorStage2 = function() {
	var object;
	if(Packages.FileType[pFileTypeSafe].edit != null) {
		object = GetSingleton(Packages.FileType[pFileTypeSafe], "edit");
	} else if(Packages.FileType[pFileTypeSafe].$k != null) {
		object = GetSingleton(Packages.FileType[pFileTypeSafe], "$k");
	}
	if(object == null) return; // No object
	
	if(object.WebEdit != null) object.WebEdit();
    Packages.Library.$i.FileObject = object;
	
	Packages.Library.$.EventSubscribe({eventname: "onexit", callback: function() {
		var response = null;
		if(Packages.Library.$i.FileObject.Exit != null) {
			var message = Packages.Library.$i.FileObject.Exit();
			if(message != null) {
				response = {
					stop: 1,
					message: message,
					id: "web_exit"
				}
			}
		}
		if(Packages.Library.$v.WEB.saved == 0 && response == null) {
			response = {
				stop: 1,
				message: "The current file has been edited but not saved",
				id: "web_exit"
			};
		}
		return response;
	}});
};
/*********************************************************************
 * SaveEditor - calls 'save editor' on the current file type
 ********************************************************************/
Packages.Library.$.SaveEditor = function (options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.SaveEditor",
		options: options,
		specification: {}
	})) return true;
	
	// Server Request is disabled in test mode
	
    if(Packages.Library.$i.FileObject != null) {
        if(Packages.Library.$i.FileObject.SaveEditor != null) {
            Packages.Library.$i.FileObject.SaveEditor();
        }
    }
	
	// Allow save?
	if(Packages.Library.$v.WEB.saveDisabled == 1) {
		Packages.Library.$.LogInfo({mesg: "Save disabled", location: "WEB.saveDisabled Packages.Library.$.SaveEditor", type: "Warning", level: 1});
		return false;
	}
	
	// Save the file to the server
	var serverRequest = new Packages.Library.ServerRequest();
	serverRequest.ServerRequest({
		page: Packages.Library.$.GetPageURL({}),
		callback: function() {
			Packages.Library.$.DisplayBriefMessage({mesg: "File saved"});
			Packages.Library.$v.WEB.saved = 1;
		},
		post: {
			editbox: document.getElementById('editbox').value
		}
	});
	
    return true; // Allow form to submit
};
/*********************************************************************
 * GetFile - gets the content from the editbox
 *
 * returns the content
 ********************************************************************/
Packages.Library.$.GetCurrentFile = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.GetCurrentFile",
		options: options,
		specification: {}
	})) return null;
	
	if(Packages.Library.$v.testing == 1) return "Test Content"; // Do nothing in test mode
	if(Packages.Library.$v.editboxContent != null) return Packages.Library.$v.editboxContent;
	
    return document.getElementById('editbox').value;
};
/*********************************************************************
 * UpdateFile - Pushes the specified content into the 'editbox'
 *
 * param - options : hash of options, must contain:
 * 			content : the content
 ********************************************************************/
Packages.Library.$.UpdateFile = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.UpdateFile",
		options: options,
		specification: {
			content: {type: "string", required: 1}
		}
	})) return;
	
	Packages.Library.$v.WEB.saved = 0;
    document.getElementById('editbox').value = options.content;
};
/*********************************************************************
 * DisplayDefaultControls - returns the markup for default editing controls
 ********************************************************************/
Packages.Library.$.DisplayDefaultControls = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.DisplayDefaultControls",
		options: options,
		specification: {}
	})) return;
	
	if(Packages.Library.$v.testing == 1) return; // Do nothing in test mode
	
	if(Packages.Library.$c.IsNode == 1) return; // Do nothing if node.js
	
	document.title = pFileName;
    document.getElementById("common_header").style.display="block";
    document.getElementById("editorform").style.display="inline";
    var fileloader = new Packages.Library.DynamicLoad({
		displayLoadingIcon: 0
	});
	fileloader.Request([{filepath: "/System/Software/CSS/Admin.css", mode: "LT_CSS"}]);
};
/*********************************************************************
 * DisplayCodeMirror - returns the markup for showing the codemirror editor
 ********************************************************************/
Packages.Library.$.DisplayCodeMirror = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.DisplayCodeMirror",
		options: options,
		specification: {}
	})) return;
	
	if(Packages.Library.$v.testing == 1) return; // Do nothing in test mode
	
    var fileloader = new Packages.Library.DynamicLoad({
		callback: new Function("Packages.Library.$._CodeMirrorCallback()"),
		displayLoadingIcon: 0
	});
	fileloader.Request([
        {filepath: "/System/Software/JS/External/CodeMirror/codemirror-compressed.js", mode: 'LT_SCRIPT'},
        {filepath: "/System/Software/JS/External/CodeMirror/codemirror.css",mode:'LT_CSS'},
        {filepath: "/System/Software/JS/External/CodeMirror/default.css", mode:'LT_CSS'}
    ]);
    document.getElementById('footer').innerHTML = "Code Editor by <a href='http://codemirror.net'>CodeMirror<\/a>. See <a href='http://codemirror.net/LICENSE'>license<\/a>.";
    document.getElementById('footer').style.display = "inline-block";
};
/*********************************************************************
 * _CodeMirrorCallback - loads the code mirror after supporting libraries have loaded
 ********************************************************************/
Packages.Library.$._CodeMirrorCallback = function() {
    CodeMirror.fromTextArea(document.getElementById('editbox'), {indentUnit: 4, lineNumbers: true});
};
/*********************************************************************
 * IsLive - Deduces whether this is a LIVE page request or not
 *
 * Used to determine if this page is being accessed on the live domain
 * or being accessed on the internal domain
 *
 * returns 1 if live, 0 if a draft version
 ********************************************************************/
Packages.Library.$.IsLive = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.Library.$.IsLive",
		options: options,
		specification: {}
	})) return null;
	
    if(Packages.Library.$.GetPageURL({}).match(/\/HTML/)) return 0;
    if(Packages.Library.$.GetPageURL({}).match(/\.admin/)) return 0;
	if(Packages.Library.$c.DebugLevel != 0) return 0;
    return 1;
};
Packages.Library.$v.WEB = {
	saved: 1,
	saveDisabled: 0
};var scrap = 
[{name:"Accounts.js",type:'file', params:{}},{name:"CSV",type:'folder',subfolders:[{name:"CSV.js",type:'file', params:{}},{name:"ColumnTypes",type:'folder',subfolders:[{name:"Calculation",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Date",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"ForeignKey",type:'folder',subfolders:[{name:"Methods",type:'folder',subfolders:[{name:"Inline",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}}]},{name:"Subscriber",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}}]},{name:"UserSpace",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}}]}]},{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Image",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Number",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Options",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"PrimaryKey",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Text",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Upload",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"User",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]}]},{name:"Controls",type:'folder',subfolders:[{name:"CategoryDescription.js",type:'file', params:{}},{name:"Compare.js",type:'file', params:{}},{name:"Filter.js",type:'file', params:{}},{name:"Group.js",type:'file', params:{}},{name:"Locator.js",type:'file', params:{}},{name:"Pager.js",type:'file', params:{}},{name:"Search.js",type:'file', params:{}},{name:"Sorter.js",type:'file', params:{}}]},{name:"View.js",type:'file', params:{}},{name:"ViewFormats",type:'folder',subfolders:[{name:"Custom",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"SystemDetail",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"SystemTable",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]}]},{name:"ViewTypes",type:'folder',subfolders:[{name:"AJAX",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Add",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Buttons",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Comparison",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Delete",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Edit",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Email",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"FileRedirect",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"GanttChart",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"GoBackHistory",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Listing",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"ListingWithGallery",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Logon",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Message",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Report",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]},{name:"Single",type:'folder',subfolders:[{name:"edit.js",type:'file', params:{}},{name:"view.js",type:'file', params:{}}]}]},{name:"View_MenuBox.js",type:'file', params:{}},{name:"XMLRPC.js",type:'file', params:{}}]},{name:"Cookie.js",type:'file', params:{}},{name:"CrossBrowser.js",type:'file', params:{}},{name:"Debug.js",type:'file', params:{}},{name:"Documenter.js",type:'file', params:{}},{name:"DynamicLoad.js",type:'file', params:{}},{name:"Extensions.js",type:'file', params:{}},{name:"File.js",type:'file', params:{}},{name:"Font.js",type:'file', params:{}},{name:"Gallery",type:'folder',subfolders:[{name:"Effects",type:'folder',subfolders:[{name:"Cut",type:'folder',subfolders:[{name:"view.js",type:'file', params:{}}]},{name:"Fade",type:'folder',subfolders:[{name:"view.js",type:'file', params:{}}]},{name:"FadeCSS",type:'folder',subfolders:[{name:"view.js",type:'file', params:{}}]},{name:"Grid",type:'folder',subfolders:[{name:"view.js",type:'file', params:{}}]},{name:"Rotate",type:'folder',subfolders:[{name:"view.js",type:'file', params:{}}]},{name:"Slide",type:'folder',subfolders:[{name:"view.js",type:'file', params:{}}]}]},{name:"Gallery.js",type:'file', params:{}}]},{name:"General.js",type:'file', params:{}},{name:"HTML.js",type:'file', params:{}},{name:"Math.js",type:'file', params:{}},{name:"Messages.js",type:'file', params:{}},{name:"Package.js",type:'file', params:{}},{name:"Properties",type:'folder',subfolders:[{name:"Alias",type:'folder',subfolders:[{name:"Property.js",type:'file', params:{}}]},{name:"FolderContentPermissions",type:'folder',subfolders:[{name:"Property.js",type:'file', params:{}}]},{name:"Permission",type:'folder',subfolders:[{name:"Property.js",type:'file', params:{}}]},{name:"Properties.js",type:'file', params:{}}]},{name:"ServerRequest.js",type:'file', params:{}},{name:"StatisticalAnalysis",type:'folder',subfolders:[{name:"Count",type:'folder',subfolders:[{name:"Stat.js",type:'file', params:{}}]},{name:"Max",type:'folder',subfolders:[{name:"Stat.js",type:'file', params:{}}]},{name:"Mean",type:'folder',subfolders:[{name:"Stat.js",type:'file', params:{}}]},{name:"Min",type:'folder',subfolders:[{name:"Stat.js",type:'file', params:{}}]},{name:"Mode",type:'folder',subfolders:[{name:"Stat.js",type:'file', params:{}}]},{name:"StatisticalAnalysis.js",type:'file', params:{}},{name:"Sum",type:'folder',subfolders:[{name:"Stat.js",type:'file', params:{}}]}]},{name:"Subscriber.js",type:'file', params:{}},{name:"TabInterface.js",type:'file', params:{}},{name:"Test.js",type:'file', params:{}},{name:"Tutorial.js",type:'file', params:{}},{name:"UI",type:'folder',subfolders:[{name:"Splitter.js",type:'file', params:{}}]},{name:"UserSpace.js",type:'file', params:{}},{name:"Wrappers",type:'folder',subfolders:[{name:"Classes",type:'folder',subfolders:[{name:"Wrapper.js",type:'file', params:{}}]},{name:"Custom",type:'folder',subfolders:[{name:"Wrapper.js",type:'file', params:{}}]},{name:"Overlay",type:'folder',subfolders:[{name:"Wrapper.js",type:'file', params:{}}]},{name:"Permission",type:'folder',subfolders:[{name:"Wrapper.js",type:'file', params:{}}]},{name:"Schedule",type:'folder',subfolders:[{name:"Wrapper.js",type:'file', params:{}}]},{name:"Styling",type:'folder',subfolders:[{name:"Wrapper.js",type:'file', params:{}}]},{name:"Test.js",type:'file', params:{}},{name:"Title",type:'folder',subfolders:[{name:"Wrapper.js",type:'file', params:{}}]},{name:"URL",type:'folder',subfolders:[{name:"Wrapper.js",type:'file', params:{}}]},{name:"Wrappers.js",type:'file', params:{}}]},{name:"XML.js",type:'file', params:{}},{name:"XMLRPC.js",type:'file', params:{}}];
var scrap = 
[{name:"WEB.js",type:'file', params:{}}];
Package("Form.Button").Item = function(item) {
    this.item = item;
	this.textVar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * item options:
	 * 		name : label of button
	 * 		action : JS string evaluated
	 * 		NOT IMPLEMENTED YET : confirm : text to display on a confirmation box before the action is fired, if null does not confirm
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html = "";
		var label = item.label;
		if(label == null) label = item.name;
		html += "<button "
				+	"onclick=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textVar + ")\" "
				+	"id='" + item.elemid + "'"
				+ ">"
				+ 	Packages.Library.$.EscapeValueForField({value: label})
				+ "<\/button>";
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - unused
	 ******************************************************************************/
	this.SaveFormItem = function() {
		return null;
	};
};Package("Form.Checkbox").Item = function(item) {
    this.item = item;
	this.textvar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * A checkbox item:
	 * 	checked : checkbox is checked
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html = "<input "
				+	"type='checkbox' "
				+	"onchange=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textvar + ")\" "
				+	(item.checked == 1 ? "checked='checked'" : "")
				+	" id='" + item.elemid
				+ "'>";
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		return (document.getElementById(item.elemid).checked ? 1 : 0);
	};
};Package("Form.ChoiceForm").Item = function(item) {
    this.item = item;
	this.textref = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * ChoiceForm - takes an array of forms, and allows the user to select which form
	 * they would like to edit.
	 *  value : (optional) the currently selected form or default
	 *  formdefs : array of form defs, each of the type:
	 *  	ref : for the chosen form, this will be stored in the value of the parent form item
	 *  	name : user facing text to describe this form
	 *  	form : (either) the child form
	 *  		if the form does not contain a child object, the parent object will be used
	 *  	getFormItems : (or) a function to call to get this forms items, passes in the refcode of item being drawn
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html = "";
		
		// Validate
		if(item.formdefs.length == 0) return "No options"; // No options
		
		if(item.value == null) item.value = item.formdefs[0].ref;
		
		// Only create selectbox if more than one option
		if(this.item.formdefs.length > 1) {
			// Create select box to choose a form
			html += "<select " +
						"id='" + item.elemid + "_selectbox' " +
						"onchange=\"" + this.textref + ".ChangeForm(); " + this.item.parentform.Form.textvar + ".Action(" + this.textref + ");\" " +
					">";
			for(var i = 0; i < this.item.formdefs.length; i++) {
				html += "<option " +
							((item.value == this.item.formdefs[i].ref) ? " selected='selected'" : "") + " " +
							"id='" + item.elemid + "_selectbox_" + i + "' " +
							"value='" + this.item.formdefs[i].ref + "'>" +
								this.item.formdefs[i].name +
						"<\/option>";
			}
			html += "<\/select>";
		}
		
		// Create a div to contain our changing form
		html += "<div id='" + this.item.elemid + "_ChoiceForm' class='form_choiceform'>" +
					this.ChangeForm(1) +
				"<\/div>";
		
		return html;
	};
	/*******************************************************************************
	 * ChangeForm - called to change the current form
	 *
	 * param - init : (optional) if 1 means we are initialising, and return the HTML not put into div
	 *
	 * Attempts to update the DIV, but if this element does not exist, returns the HTML
	 * for first time.
	 ******************************************************************************/
	this.ChangeForm = function(init) {
		if(this.item.formdefs.length == 0) return "No form defs";
		
		// Submit current data
		if(init != 1) this.form.Form.Submit();
		
		// Get the currently selected item
		var selelem = document.getElementById(item.elemid + "_selectbox");
		if(selelem != null && init != 1) {
			this.item.value = selelem.options[selelem.selectedIndex].value
		}
		
		// Get the formdef
		var formdef = Packages.Library.$.FindArrayItem({array: this.item.formdefs, path: "ref", value: this.item.value});
		
		if(formdef == null) formdef = this.item.formdefs[0];
		// Get the form part
		var form = formdef.form;
		
		// If we don't have a form, try and use getFormItems
		if(form == null && formdef.getFormItems != null) {
			form = {};
			form.items = formdef.getFormItems(this.item.value);
		}
		
		// Clone it so we can make changes
		this.form = Packages.Library.$.Clone({oldObj: form, skiplist: ['object']});
		
		// Copy back in members we do not want to be cloned
		this.form.object = form.object;
		
		if(this.form == null) return null; // Bad form
		
		// Create the form
		if(this.form.userspace == null) this.form.userspace = 0;
		this.form.type = "Form";
		this.form.showSubmit = 0;
		this.form.showComplexity = 0;
		this.form.allowUndo = 0;
		this.form.complexityLevels = this.item.parentform.complexityLevels;
		this.form.action = this.item.parentform.action;
		this.form.parentform = this.item.parentform;
		if(this.form.object == null) this.form.object = this.item.parentform.object;
		this.form.idprefix = this.item.elemid + "_choiceform_sub" + "_";
		this.form.Form = new Packages.Form.Form(this.form);
		var reload = 0;
		if(item.reloaded != null && item.reloaded == 1) reload = 1;
		var html = this.form.Form.MakeForm(reload);
		
		if(init == 1) return html;
		var divelem = document.getElementById(this.item.elemid + "_ChoiceForm");
		if(divelem != null)	divelem.innerHTML = html;
		return true;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		this.form.Form.Submit();
		if(this.form.Form.changed == 1) this.item.parentform.Form.changed = 1;
		return this.item.value;
	};
};Package("Form.ColourSelector").Item = function(item) {
    this.item = item;
	this.textVar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item (was makeColourSelector)
	 *
	 * Stores the RRGGBB value without the leading #
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html ="";
		
		if(this.item.value == null) this.item.value = "";
		
		var onchange = " onchange=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textVar + ")\"";
		
		html += "<input " +
					"type='radio' " +
					"id='" + this.item.elemid + "_transparent' " +
					"name='" + this.item.elemid + "_transop' " +
					(this.item.value == "" ? "checked='checked'" : "") +
					onchange +
				"> Transparent";
		html += "<br>"
		html += "<input " +
					"type='radio' " +
					"id='" + this.item.elemid + "_opaque' " +
					"name='" + this.item.elemid + "_transop' " +
					(this.item.value != "" ? "checked='checked'" : "") +
					onchange +
				">";
		html += "<input " +
					"type='color' " +
					"value='#" + (this.item.value == "" ? "dddddd" : this.item.value) + "' " +
					"id='" + this.item.elemid + "_colour' " +
					onchange +
				">";
		
		return html;
	}
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		if(document.getElementById(this.item.elemid + '_transparent').checked) return "";
		var col = document.getElementById(this.item.elemid + '_colour').value;
		
		// Remove leading #
		col = col.replace(/^#/, "");
		return col;
	};
};Package("Form.Date").Item = function(item) {
    this.item = item;
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * Tries to show the browser supported date picker
	 *
	 * options:
	 * 	value : default value (may be 'now' to set to current date)
	 * 	now : 1 use now, 0 (default) do not reset to now
	 ******************************************************************************/
	this.MakeFormItem = function() {
		if(item.value == null) item.value = "";
		if(item.now == 1) item.value = "now"; // Force now
		if(item.value == "now") {
			// Get todays date
			var date = new Date();
			item.value = Packages.Library.$.PadString({
				value: date.getFullYear(),
				chr: "0",
				length: 4
			}) + "-" +
			Packages.Library.$.PadString({
				value: (date.getMonth() + 1),
				chr: "0",
				length: 2
			}) + "-" +
			Packages.Library.$.PadString({
				value: date.getDate(),
				chr: "0",
				length: 2
			});
		}
		var html = "<input " + (item.enabled == 0 ? "disabled='disabled' " : "") + "type='Date' value=\"" + item.value + "\" id='" + item.elemid + "'>";
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		return document.getElementById(item.elemid).value;
	};
};Package("Form.FileMgr").Item = function(item) {
	Packages.Form.FileMgr.$i.Item = this;
	this.textVar = GetTextRef(this);
    this.item = item;
	/*******************************************************************************
	 * MakeFormItem - creates an interactive file manager using the FileBrowser
	 *
	 * Options for the item:
	 * 	     folder : folder listing to use
	 * 	     pathPrefix: (optional) path prefix from masterpath, default ""
	 * 	     extensionFilter : (optional) array of extensions only to display
	 * 	     select : (optional)	0 (default) No select
	 * 	     						1 Allow single select (radio buttons)
	 * 	     						2 Allow multiple select (checkboxes)
	 * 	     storeRelative : (optional) 1 store relative path from current folder, 0 (default) absolute
	 * 	     useContainerPath : (optional) 1 save absolute to the containerpath, and include $containerpath prefix, 0 (default) don't
	 * 	     					in either case, during loading, if a $containerpath is found it will work
	 * 	     offset : (optional) used with useContainerPath, the offset from the containerpath to the folder listing
	 * 	     thumbnailPrefix : (optional) prefix to place before paths to image thumbnails (can be ../)
	 ******************************************************************************/
	this.MakeFormItem = function() {
		if(!Packages.Library.$.ValidateOptions({
			calledFrom: "Packages.Form.FileMgr.Item.MakeFormItem",
			options: item,
			specification: {
				folder: {type: "array", required: 1},
				pathPrefix: {type: "string"},
				extensionFilter: {type: "array"},
				select: {type: "number"},
				storeRelative: {type: "boolean"},
				useContainerPath: {type: "boolean"},
				thumbnailPrefix: {type: "string"}
			}
		})) return "Invalid option for 'FileMgr' form item";
		
		this.item.selectedFiles = this.item.value;
		if(this.item.selectedFiles == null) this.item.selectedFiles = [];
		if(typeof(this.item.selectedFiles) == "string") this.item.selectedFiles = [this.item.selectedFiles];
		if(this.item.pathPrefix == null) this.item.pathPrefix = "";
		if(this.item.offset == null) this.item.offset = "";
		if(this.item.offset.length > 0 && !this.item.offset.match(/\/$/)) this.item.offset += "/";
		this.item.pathPrefix = this.item.pathPrefix.replace(/..\//g, ""); // Remove all ../
		var useRelative = this.item.storeRelative;
		
		if(this.item.thumbnailPrefix == null && this.item.useContainerPath) this.item.thumbnailPrefix = "$containerpath/";
		
		// Strip any domain from the front
		for(var i = 0; i < this.item.selectedFiles.length; i++) {
			if(!this.item.selectedFiles[i].match(/^https?:\/\/[^\/]+\//)) continue; // Skip if not a domain start
			this.item.selectedFiles[i] = this.item.selectedFiles[i].replace(/^https?:\/\/[^\/]+\//, "");
			useRelative = 0; // This is an absolute path
		}
		
		/*******************************************************************************
		 *  - callback - 
		 * param - FileMgr : hash of information containing
		 * 	selected
		 * 		file : selected file
		 * 		path : selected path
		 * 	drop
		 * 		file : dropped file (file dropped on) - use selected file
		 * 		path : path dropped on
		 ******************************************************************************/
		var _this = this; // scope changes within next block
		this.item.callbacks = {
			move: function(FileMgr) {
				new Packages.Library.ServerRequest().ServerRequest({
					page: ".admin",
					query: {
						"req-files": 1,
						moveSrc: FileMgr.selected.path + FileMgr.selected.file,
						moveDest: FileMgr.drop.path
					},
					callback: Packages.Library.$.ReloadFileMgr
				});
			},
			ctrlmove: function(FileMgr) {
				new Packages.Library.ServerRequest().ServerRequest({
					page: ".admin",
					query: {
						"req-files": 1,
						copySrc: FileMgr.selected.path + FileMgr.selected.file,
						copyDest: FileMgr.drop.path + "/" + FileMgr.selected.file
					},
					callback: Packages.Library.$.ReloadFileMgr
				});
			}
		};
		
		// Move the original list of selectedFiles to a safe (untouched location)
		this.item.originalSelectedFiles = this.item.selectedFiles;
		
		// Replace selectedFiles with a clone
		this.item.selectedFiles = Packages.Library.$.Clone({oldObj: this.item.selectedFiles});
		
		// Now convert the internal copy to the standard format
		
		// The standard format is:
		// folders : the array of folders, nested
		// path1/path2/file.extension
		// So that the path works through the specified folders to the file
		
		var currentPath = pOffset.split(/\//);
		for(var i = 0; i < this.item.selectedFiles.length; i++) {
			var filepath = this.item.selectedFiles[i];
			
			// Load relative file path to current position?
			if(useRelative == 1) {
				var path = this.item.selectedFiles[i].split(/\//);
				
				// Find each '..' entry and remove
				var p = 0;
				while(path[p] == '..') {
					p++;
				}
				
				// Remove '..' entries
				path.splice(0, p);
				
				// Add the parts of currentPath to replace them
				var commonParts = currentPath.length - p;
				var abs = "";
				for(var r = 0; r < commonParts; r++) {
					abs += currentPath[r] + "/";
				};
				
				filepath = abs + path.join("/");
			}
			
			// Is a $containerpath in the URL?
			if(filepath.match(/\$containerpath\//)) {
				// Convert to safe format
				
				// Remove common offset
				filepath = filepath.replace(new RegExp("^[^\\$]*\\$containerpath\/" + this.item.offset), "");
			}
			
			// Store changes
			this.item.selectedFiles[i] = filepath;
		}
		
		this.fileManager = new Packages.Form.Utils.File(this.item);
		// Disable context menu
		return "<div id='" + this.item.elemid + "_fm_div' class='fm_div' oncontextmenu='return false;'>" + this.fileManager.MakeFormItem() + "<\/div>";
	};
	/*******************************************************************************
	 * SaveFormItem - only really important if 'select' file enabled
	 *
	 * In single mode returns the file selected with path
	 *
	 * In multiple mode, returns an array of selected files with their path
	 ******************************************************************************/
	this.SaveFormItem = function() {
		var mode = this.item.select > 0 ? this.item.select : this.item.selectfolder;
		
		var currentPath = pOffset.split(/\//);
		for(var i = 0; i < this.item.selectedFiles.length; i++) {
			var filepath = this.item.selectedFiles[i];
			if(filepath == "") continue;
			
			// Store relative file path to current position?
			if(this.item.storeRelative == 1) {
				var path = this.item.selectedFiles[i].split(/\//);
				
				// Compare and remove matching starting entries
				var p = 0;
				while(currentPath[p] == path[p] && p < path.length) {
					p++;
				}
				
				// Remove similarities
				path.splice(0, p);
				
				// Add '../' for every folder left in currentPath
				var rel = "";
				for(var r = 0; r < (currentPath.length - p); r++) {
					rel += "../";
				}
				
				filepath = rel + path.join("/");
			}
			
			// Is a $containerpath in the URL?
			if(this.item.useContainerPath) {
				// Add on the offset and $containerpath
				filepath = "$containerpath/" + this.item.offset + filepath;
			}
			
			// Store changes in original object
			this.item.originalSelectedFiles[i] = filepath;
		}
		
		// We just want one file, and we have one
		if(mode == 1 && this.item.originalSelectedFiles.length > 0 ) return this.item.originalSelectedFiles[0];
		
		// We just want one file, but we don't have one
		if(mode == 1 && this.item.originalSelectedFiles.length == 0 ) return "";
		
		// We want multiple files
		if(mode == 2) return this.item.originalSelectedFiles;
		
		// Shouldn't ever get here
		return null;
	};
	/*******************************************************************************
	 * ReloadFileMgrCallback - default callback when a server request is performed
	 * Rebuilds the file manager to load the updated file listings
	 *
	 * param - folderlisting : (optional) folder listing to use, if not specified uses pFolders
	 ******************************************************************************/
	this.ReloadFileMgrCallback = function(folderlisting) {
		var elem = document.getElementById(this.item.elemid + "_fm_div");
		if(elem == null) {
			Packages.Library.$.EventUnsubscribe({eventsubscription: this.pFolderChangedSubscription});
			return;
		}
		this.item.folder = pFolders;
		
		elem.innerHTML = this.fileManager.MakeFormItem();
	};
	this.pFolderChangedSubscription = Packages.Library.$.EventSubscribe({eventname: "pFolderChanged", callback: this.ReloadFileMgrCallback.bind(this)});
};Package("Form.FileMgr.MenuItems.Clone").menuitem = function() {
	this.textvar = GetTextRef(this);
	this.fileMgr;
	this.data;
	/*******************************************************************************
	* Execute - Performs the action
	*
	* param - fileMgr : the fileMgr object that contains information about the selected files
	******************************************************************************/
    this.Execute = function(fileMgr) {
		this.fileMgr = fileMgr;
		
		this.data = {
			cloneName: fileMgr.selected.path +
			Packages.Library.$.GetFileName({filepath: fileMgr.selected.file}) +
			" (Copy)." +
			Packages.Library.$.GetFileExtension({filepath: fileMgr.selected.file})
		};
		return [
            {
                type: "Text",
                value: this.data.cloneName,
				name: "Name of clone",
				id: "cloneName"
			}
        ];
    };
    /*******************************************************************************
	* Submit - (local) Takes the data generated from the form and does the work
	******************************************************************************/
    this.Submit = function() {
        var query = {
			"req-files": 1,
            copySrc: this.fileMgr.selected.path + this.fileMgr.selected.file,
            copyDest: this.data.cloneName
        };
		new Packages.Library.ServerRequest().ServerRequest({
			page: ".admin",
			query: query,
			callback: Packages.Library.$.ReloadFileMgr
		});
    };
};
/*******************************************************************************
 * GetDetails - gets the details for this action
 *
 * Returns a hash of details
 ******************************************************************************/
Packages.Form.FileMgr.MenuItems.Clone.$.GetDetails = function() {
    return {
        name:       "Clone",
		item: 		Packages.Form.FileMgr.MenuItems.Clone,
        description:"Clone a file (copy in this folder)",
        permission: "copy",
        menuType:	"Folder,File",
		packagename:"Packages.Form.FileMgr.MenuItems.Clone"
	};
};
Packages.Library.$.EventSubscribe({eventname: "GetMenuItems", callback: Packages.Form.FileMgr.MenuItems.Clone.$.GetDetails});Package("Form.FileMgr.MenuItems.Delete").menuitem = function() {
	this.textvar = GetTextRef(this);
    this.data = {};
    /*******************************************************************************
	* Execute - Performs the action
	*
	* param - fileMgr : the fileMgr object that contains information about the selected files
	******************************************************************************/
    this.Execute = function(fileMgr) {
        var res = confirm("Are you sure you want to delete '" + fileMgr.selected.file + "'?");
        if(res) {
            var query = {
				"req-files": 1,
                deleteFile: fileMgr.selected.path + fileMgr.selected.file
            };
            new Packages.Library.ServerRequest().ServerRequest({
				page: ".admin",
				query: query,
				callback: Packages.Library.$.ReloadFileMgr
			});
        }
    };
};
/*******************************************************************************
 * GetDetails - gets the details for this action
 *
 * Returns a hash of details
 ******************************************************************************/
Packages.Form.FileMgr.MenuItems.Delete.$.GetDetails = function() {
    return {
        name:       "Delete",
		item:		Packages.Form.FileMgr.MenuItems.Delete,
        description:"Delete a file or folder",
        permission: "delete",
        menuType:	"Folder,File",
		packagename:"Packages.Form.FileMgr.MenuItems.Delete"
    };
};
Packages.Library.$.EventSubscribe({eventname: "GetMenuItems", callback: Packages.Form.FileMgr.MenuItems.Delete.$.GetDetails});Package("Form.FileMgr.MenuItems.NewFile").menuitem = function() {
	this.fileMgr;
    this.textvar = GetTextRef(this);
    this.data = {};
    /*******************************************************************************
	* Execute - Performs the action
	*
	* param - fileMgr : the fileMgr object that contains information about the selected files
	******************************************************************************/
    this.Execute = function(fileMgr) {
        this.fileMgr = fileMgr;
        this.data = {
			filename: "",
            content: ""
		};
		return [
            {
                type: "Text",
                value: this.data.filename,
                name: "Filename",
                id: "filename"
            },
            {
                type: "TextArea",
                value: this.data.content,
                name: "Content",
                id: "content"
            }
        ];
    };
    /*******************************************************************************
	* Submit - Takes the data generated from the form and does the work
	******************************************************************************/
    this.Submit = function() {
        Packages.Library.$.SetFile({
			filepath: this.fileMgr.selected.fullpath + "/" + this.data.filename,
			content: this.data.content,
			callback: Packages.Library.$.ReloadFileMgr
		});
    };
};
/*******************************************************************************
 * GetDetails - gets the details for this action
 *
 * Returns a hash of details
 ******************************************************************************/
Packages.Form.FileMgr.MenuItems.NewFile.$.GetDetails = function() {
    return {
        name:       "Blank File",
		item: 		Packages.Form.FileMgr.MenuItems.NewFile,
        description:"Create a blank new file (.txt, .css, .js etc)",
        permission: "createfile",
		menuType:	"CreateBlank",
		packagename:"Packages.Form.FileMgr.MenuItems.NewFile"
    };
};
Packages.Library.$.EventSubscribe({eventname: "GetMenuItems", callback: Packages.Form.FileMgr.MenuItems.NewFile.$.GetDetails});Package("Form.FileMgr.MenuItems.NewFolder").menuitem = function() {
	this.fileMgr;
    this.textvar = GetTextRef(this);
    this.data = {};
    /*******************************************************************************
	* Execute - Performs the action
	*
	* param - fileMgr : the fileMgr object that contains information about the selected files
	******************************************************************************/
    this.Execute = function(fileMgr) {
        this.fileMgr = fileMgr;
        this.data = {
			foldername: ""
		};
		return [
            {
                type: "Text",
                value: this.data.foldername,
				name: "Folder Name",
				id: "foldername"
            }
        ];
    };
    /*******************************************************************************
	* Submit - Takes the data generated from the form and does the work
	******************************************************************************/
    this.Submit = function() {
		var foldername = this.data.foldername;
		if(foldername == "") return;
		Packages.Library.$.MakeFolder({
			folderpath: this.fileMgr.selected.fullpath + "/" + foldername
		});
    };
};
/*******************************************************************************
 * GetDetails - gets the details for this action
 *
 * Returns a hash of details
 ******************************************************************************/
Packages.Form.FileMgr.MenuItems.NewFolder.$.GetDetails = function() {
    return {
        name:       "Folder",
		item:		Packages.Form.FileMgr.MenuItems.NewFolder,
		description:"Create a folder on your webspace",
		permission: "createfolder",
		menuType:	"CreateBlank",
		order: -1,
		packagename:"Packages.Form.FileMgr.MenuItems.NewFolder"
    };
};
Packages.Library.$.EventSubscribe({eventname: "GetMenuItems", callback: Packages.Form.FileMgr.MenuItems.NewFolder.$.GetDetails});Package("Form.FileMgr.MenuItems.Properties").menuitem = function() {
	this.textvar = GetTextRef(this);
    this.data = {};
    /*******************************************************************************
	* Execute - Performs the action
	*
	* param - fileMgr : the fileMgr object that contains information about the selected files
	******************************************************************************/
    this.Execute = function(fileMgr) {
        // Create an iframe to the properties editor for the given file properties .property file
		var propertiesFile = fileMgr.selected.path + fileMgr.selected.file;
		
		Packages.Library.Properties.$.GetPropertiesForm({
			filename: propertiesFile
		});
    };
};
/*******************************************************************************
 * GetDetails - gets the details for this action
 *
 * Returns a hash of details
 ******************************************************************************/
Packages.Form.FileMgr.MenuItems.Properties.$.GetDetails = function() {
    return {
        name:       "Properties",
		item:		Packages.Form.FileMgr.MenuItems.Properties,
        description:"Edit the Properties of this item",
        permission: "properties",
        menuType:	"Folder,File",
		packagename:"Packages.Form.FileMgr.MenuItems.Properties"
    };
};
Packages.Library.$.EventSubscribe({eventname: "GetMenuItems", callback: Packages.Form.FileMgr.MenuItems.Properties.$.GetDetails});Package("Form.FileMgr.MenuItems.Rename").menuitem = function() {
	this.textvar = GetTextRef(this);
	this.fileMgr;
	this.data;
	/*******************************************************************************
	* Execute - Performs the action
	*
	* param - fileMgr : the fileMgr object that contains information about the selected files
	******************************************************************************/
    this.Execute = function(fileMgr) {
		this.fileMgr = fileMgr;
		this.data = {
			rename: fileMgr.selected.path + fileMgr.selected.file
		};
		return [
            {
                type: "Text",
                value: this.data.rename,
				name: "New Name",
				id: "rename"
			}
        ];
    };
    /*******************************************************************************
	* Submit - (local) Takes the data generated from the form and does the work
	******************************************************************************/
    this.Submit = function() {
        var query = {
			"req-files": 1,
            moveSrc: this.fileMgr.selected.path + this.fileMgr.selected.file,
            moveDest: this.data.rename
        };
		new Packages.Library.ServerRequest().ServerRequest({
			page: ".admin",
			query: query,
			callback: Packages.Library.$.ReloadFileMgr
		});
    };
};
/*******************************************************************************
 * GetDetails - gets the details for this action
 *
 * Returns a hash of details
 ******************************************************************************/
Packages.Form.FileMgr.MenuItems.Rename.$.GetDetails = function() {
    return {
        name:       "Rename",
		item: 		Packages.Form.FileMgr.MenuItems.Rename,
        description:"Rename a file",
        permission: "rename",
        menuType:	"Folder,File",
		packagename:"Packages.Form.FileMgr.MenuItems.Rename"
	};
};
Packages.Library.$.EventSubscribe({eventname: "GetMenuItems", callback: Packages.Form.FileMgr.MenuItems.Rename.$.GetDetails});Package("Form.FileMgr.MenuItems.Upload").menuitem = function() {
	this.fileMgr;
    this.textvar = GetTextRef(this);
	this.filename = "";
	this.data = {};
    /*******************************************************************************
	* Execute - Performs the action
	*
	* param - fileMgr : the fileMgr object that contains information about the selected files
	******************************************************************************/
    this.Execute = function(fileMgr) {
		this.fileMgr = fileMgr;
		return [
            {
                type: "Upload",
                name: "Select File",
				callback: Packages.Library.$.ReloadFileMgr,
				path: fileMgr.selected.fullpath
            }
        ];
    };
	/*******************************************************************************
	* Submit - Takes the data generated from the form and does the work
	******************************************************************************/
    this.Submit = function() {};
};
/*******************************************************************************
 * GetDetails - gets the details for this action
 *
 * Returns a hash of details
 ******************************************************************************/
Packages.Form.FileMgr.MenuItems.Upload.$.GetDetails = function() {
    return {
        name:       "Upload",
		item:		Packages.Form.FileMgr.MenuItems.Upload,
        description:"Upload a file",
        permission: "upload",
        menuType:	"Create",
		packagename:"Packages.Form.FileMgr.MenuItems.Upload"
    };
};
Packages.Library.$.EventSubscribe({eventname: "GetMenuItems", callback: Packages.Form.FileMgr.MenuItems.Upload.$.GetDetails});/***************************************************************
 * A form object is built from a form data hash
 *
 * The form allows a data hash to be edited, the form data explains how that data hash may be edited
 *
 * A form data hash is of the type
 * 	type : must be "Form"
 * 	object : data hash to be edited
 * 	items: an array of hashes of the type:
 * 	  required
 * 	  	type : the type of form item
 * 	  common (for exact spec see help for the form item)
 * 		id : the key of the item in the data hash (the hash being edited)
 * 		value : the initial value
 * 		checked: the initial state
 * 		name : name of the item
 * 		description : help for this item
 * 		subtitle : text to display underneath the name
 * 		prefix : text to display just before form input
 * 		suffix : text to display just after form input
 * 		heading : text to display as a heading above the form input
 * 	  optionally
 * 	  	folded: this item starts with the form part folded
 * 	  	foldable: this item may be folded
 * 	  	action : function to execute when clicked
 * 	  	submitform : (optional) 1 (default) submit form before doing action callback, 0 don't
 * 	  	actionForm : (optional) when action executed, form object to save and refresh - if not specified, uses main form
 * 	  	required : (optional) will not allow the form to submit unless this field is present
 * 	  	defaultvalue : (optional) a default value to use when the value is null
 * 	  	conditions : array of conditions from MakeComplexConditionFormItem deciding whether to show an item
 * 	  	complexity : how complex this item is, default 1
 * 	  	fullWidth : 1 show item full width (with name above), 0 (default) display side by side
 * 	  	manipulate : a callback function that is called just before rendering to the item, to allow any last minute changes to be made
 * 	  		the item is passed as the only parameter
 * 	  	validationRegExp : regexp that must validate on result
 * 	  	validationMessage : message to output if validationRegExp fails
 * 	  	warnChanged : a message to display if the value has changed, does not apply if changed from null
 * 	  added by form
 * 	  	elemid : id of the primary element for this item
 * Optionally
 * 	idprefix : the prefix for all elems in this form
 * 	showSubmit : whether a submit button is shown, default 1
 * 	showComplexity : whether the complexity levels are shown, default 1 if there are items with complexities > 1
 * 	actionForm : form to save / refresh when action pressed (can be overwritten by item, default to parent)
 * 	action : action to apply whenever any item in the form is edited
 * 	reloadForm : 1 (default) after an action the form will reload, 0 will not
 * 	tabinterface : (optional) used when a tabinterface creates the form, will call 'Close' on the tab interface when form submitted
 * 	submit : function to execute after saving
 * 	submittext: text to display on submit button, default to 'Save'
 * 	requiredText : text to display when there are required fields at the bottom of the form
 * 	allowUndo : 1 (default) undo feature enabled, 0 disabled
 * 	undoSkipList : array of additional keys to skip when cloning for undo
 * 	plainBackground : 1 plain background, 0 (default) style
 * 	parentform : when called from nested form, this is the parent form
 * UserSpace - only works for objects with a "type" property
 * 	userspace : 1 (default) enable saving / loading of compatible objects, 0 disable
 * Internally:
 * 	conditionalDependancies : hash of id's that are dependancies for another field when display is conditional
 * 	complexityLevels : hash of complexity levels - passed from nested form to form
 * 	rootForm : the root form, for a nested form this points to top level parent form
 **************************************************************/
Package("Form").Form = function(form) {
    this.form = form;
	this.form.Form = this;
	this.textvar = GetTextRef(this);
	this.conditionalDependancies = {};
	this.form.rootForm = form;
	if(this.form.parentform != null) this.form.rootForm = this.form.parentform.rootForm;
	
	this.changed = 0; // Set to 1 when something changes
	
	this.id_prefix = "form_";
	if(form.idprefix != null) this.id_prefix += form.idprefix;
	
	/*******************************************************************************
	 * MakeForm - Gets the form as HTML
	 *
	 * param - makevalue : (optional) passed when making the form - stored in the form object
	 * 							used for tabinterface, and could be used for other things
	 * 
	 * returns the HTML markup for this form
	 ******************************************************************************/
	this.MakeForm = function(makevalue) {
		this.makevalue = makevalue;
		
		// Wrap form content in a container div
		return "<div "
				+	"id='" + this.id_prefix + "_container' "
				+	"class='form_container" + (form.plainBackground == 1 ? " form_container_plain" : "") + "' "
				+	"onmousedown='event = event || window.event; event.stopPropagation();' " // Stop onmousedown travelling up the DOM stack
				+ ">" +
					this.GetFormContent() +
				"<\/div>";
	};
	/*******************************************************************************
	 * Init - sets defaults and initialises form
	 *
	 * Called for re-init as well, in which case only the first part will fire
	 ******************************************************************************/
	this.Init = function(reload) {
		// Do re-init items
		if(this.form.complexityLevels == null) this.form.complexityLevels = {};
		this.currentComplexity = Packages.Library.$.GetCookies({}).formComplexity;
		if(this.currentComplexity == null) this.currentComplexity = 1;
		if(Packages.Library.$v.formtesting == 1) this.currentComplexity = 100; // Set high
		
		// If init already done, don't do this again
		if(this.initDone == 1) return;
		// -----------------------------------------
		
		if (Packages.Library.$.GetType({item: this.form.object}) == "DOMobject") {
		    this.objectIsDOM = 1;
		}
		
		// Get hash of multi version form field types
		this.versionTypes = {};
		this.versionTypeMap = {};
		var versions = Packages.Library.$.GetActiveVersions();
		for(var i = 0; i < versions.length; i++) {
			this.versionTypeMap[versions[i].refcode] = {};
			var typesList = versions[i].formtypes;
			if(typesList == null) continue;
			var types = typesList.split(/,/);
			for(var t = 0; t < types.length; t++) {
				this.versionTypes[types[t]] = 1;
				this.versionTypeMap[versions[i].refcode][types[t]] = 1;
			}
		}
		
		// Set up defaults
		if(form.requiredText == null) form.requiredText = "Required";
		this.initDone = 1;
	}
	/*******************************************************************************
	 * GetFormContent - Gets the HTML for this form, including optional 'submit' buttons that will
	 * fire callbacks to save the real data
	 *
	 * param - reload : (optional) 1 will load item.value with the value from the data object, 0 will leave as whatever was in the form
	 * 
	 * returns the HTML markup for this form
	 ******************************************************************************/
	this.GetFormContent = function(reload) {
		this.Init();
		var hasRequired = 0; // Are there any required fields
		
		var formitemshtml = "";
		
		// Any warnings?
		formitemshtml += Packages.Library.$.GetNodeJSWarning({});
		
		for(var i = 0; i < form.items.length; i++) {
			// MultiVersion?
			form.items[i] = this.ConvertToMultiVersion(form.items[i]);
			
			// Initialise
			var item = form.items[i];
			
			// Node?
			if(Packages.Library.$c.IsNode == 1) item.enabled = 0;
			
			var formItemHtml = this.MakeFormItem({itemid: i});
			
			// Skip if not content (hidden)
			if(formItemHtml == null) continue;
			
			var formitem = "";
			
			// Insert prefix
			formitem += (item.prefix != null ? item.prefix : "");
			
			formitem += formItemHtml;
			
			// Insert suffix
			formitem += (item.suffix != null ? item.suffix : "");
			
			// Is foldable?
			if(item.foldable == 1) {
				if(item.folded == null) item.folded = 1;
				formitem = Packages.Library.$.CreateFoldArea({
					title: (item.heading != null ? "<h3>" + item.heading + "<\/h3>" : ""),
					content: formitem,
					foldable: 1,
					folded: item.folded,
					foldid: item.elemid + "_folded",
					classname: "form_foldable"
				});
			} else {
				// Form item heading
				if(item.heading != null) formitem = "<h3>" + item.heading + "<\/h3>" + formitem;
			}
			formitem = "<div class='form_item " + item.className + "'>" + formitem + "<\/div>";
			
			var rowhtml = "<tr class='form_item_row'>";
			// Create the label / left hand side of form
			if(item.name != null) {
				var label = item.name;
				if(item.subtitle != null) label += "<br><i class='form_item_subtitle'>" + item.subtitle + "<\/i>";
				if(item.required == 1) {
					label += "<span class='form_item_required'>*<\/span>";
					hasRequired = 1;
				}
				
				rowhtml += "<td class='form_item_label'>" + label + "<\/td>";
				rowhtml += "<td class='form_item_help'>" + (item.description != null && item.description.length > 0 ? Packages.Library.$.MakeHelp({help: item.description}) : "") + "<\/td>";
				rowhtml += "<td class='form_item_control' id='" + this.id_prefix + "_itemcontainer_" + i + "'>";
				
				if(item.fullWidth == 1) {
					rowhtml += "<\/td><\/tr><tr class='form_item_row'>";
				}
			}
			if(item.name == null || item.fullWidth == 1) {
				rowhtml += "<td colspan='3' class='form_item_dcontrol' id='" + this.id_prefix + "_itemcontainer_" + i + "'>" + (item.name == null && item.description != null ? Packages.Library.$.MakeHelp({help: item.description}) : "");
			}
			rowhtml += formitem;
			rowhtml += "<div class='form_item_error_mesg' id='" + this.id_prefix + "_itemerror_" + i + "'><\/div>";
			rowhtml += "<\/td><\/tr>";
			
			formitemshtml += rowhtml;
		}
		formitemshtml = "<table>" + formitemshtml + "<\/table>";
		
		var html = "";
		
		// Display complexity of form at the top
		if(form.showComplexity != 0) {
			var complexities = Packages.Library.$.GetKeys({object: this.form.complexityLevels});
			if(complexities.length > 1) {
				var selectOptions = [];
				for(var i = 0; i < complexities.length; i++) {
					selectOptions.push({
						name: "Level " + complexities[i],
						value: complexities[i]
					});
					
					// If the current complexity isn't one of the current values, then
					// set to the next highest complexity
					if(this.form.complexityLevels[this.currentComplexity] == null) {
						if(complexities[i] >= this.currentComplexity) this.currentComplexity = complexities[i];
					}
				}
				// If we still don't find a complexity level, use highest available
				if(this.form.complexityLevels[this.currentComplexity] == null) {
					this.currentComplexity = complexities[complexities.length - 1];
				}
					
				var complexityHtml = "";
				complexityHtml += "Form Complexity" + Packages.Library.$.MakeHelp({help: "Controls the features that are displayed on the form.\nThe lower the complexity the simpler the form."}) + ": ";
				complexityHtml += "<select "
								+		"onchange=\"" + this.textvar + ".ChangeComplexity(this.value)\""
								+	">"
								+		Packages.Library.$.CreateSelectOptionsFromArray({
											items: selectOptions,
											value: this.currentComplexity
										})
								+	"<\/select>";
				html = "<div class='form_complexity'>" + complexityHtml + "<\/div>";
			}
		}
		
		// Add form items
		html += formitemshtml;
		
		if(hasRequired) {
			html += "<span class='form_item_required'>* " + form.requiredText + "<\/span>";
		}
		if(Packages.Library.$c.IsNode != 1) {
			if(form.showSubmit != 0) {
				// Add submit button
				if(form.submittext == null) form.submittext = "Save";
				html += "<button class='form_submit' onclick=\"" + this.textvar + ".Submit()\">" + form.submittext + "<\/button>";
			}
			
			// Userspace
			if(form.object != null && form.object.type != null && form.userspace != 0) {
				if(Packages.Library.$v.RunningOptions.offline != 1) {
					this.userspace = Packages.Library.$.CreateUserspace();
					var _this = this;
					var userSpaceHtml = this.userspace.GetEditControl({
						object: this.form.object,
						idprefix: this.id_prefix + "uspc",
						preSaveCallback: function() {_this.Submit({fireCallback: 0})},
						postLoadCallback: this.Refresh.bind(this),
						postSaveCallback: this.Refresh.bind(this)
					});
					
					// Make collasped
					html += Packages.Library.$.CreateFoldArea({
						content: userSpaceHtml,
						foldable: 1,
						folded: 1,
						title: "User Space"
					})
				}
			}
			
			// Undo
			if(form.allowUndo != 0 && form.object != null && this.objectIsDOM != 1 && form.object.$noDump != null && form.object.$noDump.formUndo != null && form.object.$noDump.formUndo.length > 0) {
				// Output a form to undo to an earlier version
				var undos = form.object.$noDump.formUndo;
				var options = [];
				for(var i = 0; i < undos.length; i++) {
					options.push({
						name: undos[i].$formDate,
						value: i,
						selected: (i == undos.length - 1 ? 1 : 0) // Select latest
					});
				}
				
				html += "Undo: ";
				html += "<select "
						+	"id='" + this.id_prefix + "_undo' "
						+ ">"
						+	Packages.Library.$.CreateSelectOptionsFromArray({items: options})
						+ "<\/select>";
				html += "<button "
						+	"onclick=\"" + this.textvar + ".Undo()\" "
						+ ">"
						+	"Undo"
						+ "<\/button>";
			}
		}
		
		// Add 'is form still displayed' tracker
		html += "<div style='display:none' id='" + this.id_prefix + "_inDOM'><\/div>";
		
		return html;
	};
	/*************************************************************************************************
	* MakeFormItem - makes the specified form item
	*
	* May be called externally
	*
	* param - options, hash of options, must contain:
	* 		itemid : the index of the item
	*
	* return - html : html for this item or null if hidden
	************************************************************************************************/
    this.MakeFormItem = function(options) {
		this.Init();
		var itemid = options.itemid;
		var item = form.items[options.itemid];
		
		// Each form item has a reference back to its form
		item.parentform = form;
		
		// Call manipulate to allow last minute changes
		if(item.manipulate != null) item.manipulate(item);
		
		// Initialise defaults
		if(item.className == null) item.className = "";
		
		item.elemid = this.id_prefix + "_item" + itemid;
		
		// Get value from object for this item, if not specified defaults to item.value
		if(form.object != null && form.object[item.id] != null) {
			// Otherwise use default of form
			try {
				item.reloaded = 1;
				item.value = form.object[item.id];
				item.checked = form.object[item.id];
				item.data = form.object[item.id];
			}catch(e){}
		}
		
		// Objectise the form item (unless already done)
		if(item.Item == null) this.ObjectiseFormItem(item);
		
		// Is a default specified for null values?
		if(item.value == null && item.defaultvalue != null) item.value = item.defaultvalue;
		if(item.checked == null && item.defaultvalue != null) item.checked = item.defaultvalue;
		
		// Set the determined value in item.value, onto the object itself, for use in conditional checking
		if(item.checked != null) item.value = item.checked;
		if(form.object != null && item.id != null && item.value != null) form.object[item.id] = item.value;
		
		// Do we need to unescape text?
		if(item.escapeChars == 1 && typeof(item.value) == "string") item.value = Packages.Library.$.ConvertLegacy({str: item.value});
		
		// Show this item?
		if(this.IsFormItemVisible(item) == 0) return null;
		
		// Call MakeFormItem on the form item
		return item.Item.MakeFormItem();
	};
	/*************************************************************************************************
	* Submit - submits this form and saves data in the source object
	*
	* param - options, hash of options, may contain:
	* 		fireCallback : 1 (default) fire callback, 0 don't
	* 		highlightErrors : 1 (default) highlight errors, 0 don't
	************************************************************************************************/
    this.Submit = function(options) {
		if(options == null) options = {};
		form.errors = null; // Reset
		
		// Store previous values in the objects cache for an undo
		if(form.allowUndo != 0 && this.objectIsDOM != 1) {
			if(form.object.$noDump == null) form.object.$noDump = {};
			if(form.object.$noDump.formUndo == null) form.object.$noDump.formUndo = [];
			var undoSkipList = ["view", "edit", "$noDump", "$id"];
			if(form.undoSkipList != null) undoSkipList = undoSkipList.concat(form.undoSkipList);
			var undoClone = Packages.Library.$.Clone({oldObj: form.object, skiplist: undoSkipList});
			undoClone.$formDate = new Date().toUTCString();
			form.object.$noDump.formUndo.push(undoClone);
		}
		
		var errors = 0;
		for(var i = 0; i < form.items.length; i++) {
			var item = form.items[i];
			
			item.error = null; // Reset
			if(item.forceError != null) item.error = item.forceError; // Allow other items to force an error
			item.forceError = null;
			
			if(item.show == 0) {
				// Hidden, so don't even try to load field from the form
				continue;
			}
			
			if(item.Item.SaveFormItem != null) {
				var value = item.Item.SaveFormItem();
				
				// Errors?
				
				// Is this a required field?
				if(item.required == 1) {
					if(value == null || value === "") {
						// Mark as error
						item.error = form.requiredText;
					}
				}
				
				if(item.validationRegExp != null) {
					if(!value.match(new RegExp(item.validationRegExp))) {
						item.error = (item.validationMessage ? item.validationMessage : "Invalid content entered");
					}
				}
				
				var containerElem = document.getElementById(this.id_prefix + "_itemcontainer_" + i);
				var errorElem = document.getElementById(this.id_prefix + "_itemerror_" + i);
				
				// Were there any errors?
				if(item.error != null && options.highlightErrors != 0) {
					errors = 1; // Mark as errors occured globally
					
					// Mark as error
					if(containerElem) containerElem.style.border = "1px solid red";
					if(errorElem) errorElem.innerHTML = item.error;
				} else {
					// Clear any previous errors
					if(containerElem) containerElem.style.border = "none";
					if(errorElem) errorElem.innerHTML = "";
				}
				
				// Save the value in our editing object
				if(item.id != null && form.object != null) {
					if(form.object[item.id] != value) {
						// this.changed = 1;
						if(item.warnChanged != null && item.warnChanged != ""
						&& form.object[item.id] != null && form.object[item.id] != "") {
							// Warn if changed and it was not null before
							var res = confirm("Warning!\n"
											+ item.warnChanged + "\n\n"
											+ "Field: " + item.name + "\n"
											+ "Was: " + form.object[item.id] + "\n"
											+ "Now: " + value + "\n\n"
											+ "Are you sure you want to keep this change?\n"
											+ "OK: To accept the change\n"
											+ "Cancel: To revert the change");
							if(!res) {
								value = form.object[item.id];
							}
						}
					}
					form.object[item.id] = value;
					
					if(item.removeIfEmpty == 1) {
						if(value == null || value == "" || value == 0) {
							if(this.objectIsDOM) {
								form.object.removeAttribute(item.id);
							} else {
								delete form.object[item.id];
							}
						}
					}
				}
			}
		}
		
		// Were there any errors?
		if(errors == 1 && options.highlightErrors != 0) {
			Packages.Library.$.LogInfo({mesg: "Errors occured submitting form", location: "Submitting form", type: "User", level: 4});
			
			// Store for multiform / nested form etc
			form.errors = 1;
		} else {
			// Form submitted
			
			// Do we have a callback event?
			if(form.submit != null && options.fireCallback != 0) {
				if(Packages.Library.$c.DebugLevel > 0) {
					form.submit();
				} else {
					try {
						form.submit();
					} catch(e) {
						Packages.Library.$.LogInfo({mesg: e.message, location: "Calling submit callback on form", type: "Error", level: 1});
					}
				}
			}
			
			// Do we have a tab interface to close?
			if(form.tabinterface != null) {
				form.tabinterface.CloseTab(this.makevalue);
			}
		}
    };
	
	/*************************************************************************************************
	* GetItemById - gets the form item of this id
	*
	* param - id : the id of the form item
	*
	* returns the form item, or null if not found
	************************************************************************************************/
    this.GetItemById = function(id) {
		for(var i = 0; i < form.items.length; i++) {
			if(form.items[i].id == id) return form.items[i];
		}
		return null;
    };
	/*************************************************************************************************
	* Refresh - recreates the entire form - to accept changes to the base data
	************************************************************************************************/
    this.Refresh = function() {
		var elem = document.getElementById(this.id_prefix + "_container");
		if(elem) elem.innerHTML = this.GetFormContent(1);
    };
	/*******************************************************************************
	 * Action - fires the action event
	 *
	 * Each item in the form may have an action assosciated with it when it is changed, when the item is changed
	 * it calls this method on its parent form.
	 *
	 * Not all form items currently support this method, they should all have an onchange or onclick handler
	 *
	 * ActionForm defaults to the current form, but can be overridden to refer to a parent form
	 * 
	 * An actionForm can be specified, per item or per form
	 * 
	 * Performs these actions on the actionForm:
	 * 	1. Saves the actionForm (if submitform on)
	 * 	2. Evaluates the js method
	 * 	3. Refreshes the actionForm with values from the original object (which may have been updated in [2])
	 *
	 * It is the responsibility of the item being executed to obtain their reference
	 * to the form
	 *
	 * param - item : the objectised item triggering the action, or null for general
	 ******************************************************************************/
	this.Action = function(item) {
		// Skip if this item has no action
		// And this items state does not effect another item
		if((item == null
			|| (
				item.item.action == null
				&& this.conditionalDependancies[item.item.id] == null
			)
		)
		&& this.form.action == null) return;
		
		// Get the actionForm
		var actionForm = this.form;
		if(this.form.actionForm != null) actionForm = this.form.actionForm;
		if(item != null && item.item.actionForm != null) actionForm = item.item.actionForm;
		if(item != null && item.item.actionFormRoot == 1) actionForm = this.form.rootForm;
		
		// Submit the form
		if(item != null && item.item.submitform != 0) actionForm.Form.Submit({fireCallback: 0}); // Get data
		
		// Perform the action (item)
		if(item != null && item.item.action != null) item.item.action(actionForm, this.form.object);
		
		// Refresh the form (put altered data in)
		if(item != null && item.item.reloadForm != 0) actionForm.Form.Refresh();
		
		// Perform the action (form)
		if(this.form.action != null && item != null && item.item.doFormAction != 0) this.form.action(actionForm, this.form.object);
	};
	
	/*******************************************************************************
	 * ChangeComplexity - changes complexity to the new level
	 *
	 * param - newComplexity : next complexity level
	 ******************************************************************************/
	this.ChangeComplexity = function(newComplexity) {
		this.Submit({fireCallback: 0}); // Get data
		
		Packages.Library.$.SetCookie({hash: {formComplexity: newComplexity}});
		
		this.Refresh();
	}
	
	/*******************************************************************************
	 * Undo - onclick event for Undo button - reverts the form data to an earlier version - if possible
	 ******************************************************************************/
	this.Undo = function() {
		if (this.objectIsDOM == 1) return;
		
		var undoElem = document.getElementById(this.id_prefix + "_undo");
		if(undoElem == null) return;
		
		var value = undoElem.value * 1;
		var undos = form.object.$noDump.formUndo;
		
		if(undos.length <= value || value < 0) return;
		
		var data = undos[value];
		
		// Merge all data in data back into form.object
		Packages.Library.$.Merge({
			base: form.object,
			extra: data
		});
		
		// Remove all Undo's since
		undos.splice(value, undos.length - value);
		
		var actionForm = this.form;
		if(this.form.actionForm != null) actionForm = this.form.actionForm;
		actionForm.Form.Refresh();
		
		this.Action();
	}
	
	/*******************************************************************************
	 * IsFormItemVisible - determines whether to show this form item
	 *
	 * param - item : the item
	 *
	 * return - show : 1 show, 0 hide
	 ******************************************************************************/
	this.IsFormItemVisible = function(item) {
		// Does this have a unique complexity level?
		if(item.complexity == null) item.complexity = 1;
		this.form.complexityLevels[item.complexity] = 1;
		// Is this item too complex for the current complexity level?
		if(item.complexity > this.currentComplexity) {
			item.show = 0;
			
			// Also store in object in case field is hidden
			if(item.id != null && form.object != null && item.value != null) form.object[item.id] = item.value;
			return 0;
		}
		
		// Conditional?
		if(item.conditions != null) {
			var show = 1; // Show unless something disagrees
			for(var c = 0; c < item.conditions.length; c++) {
				var condition = item.conditions[c];
				
				// Make an empty array if null
				if(this.conditionalDependancies[condition.variable] == null) this.conditionalDependancies[condition.variable] = [];
				
				// Add this field to the conditional dependancies list
				this.conditionalDependancies[condition.variable].push(item.id);
				
				if(!Packages.Library.$.EvaluateComplexCondition({
					data: form.object,
					conditions: item.conditions
				})) {
					// Do not display at the moment
					show = 0;
				}
			}
			
			// If hiding, then simply do not display this field
			item.show = show;
			if(show == 0) return 0;
		}
		
		return 1; // Show
	}
	
	/*******************************************************************************
	 * ConvertToMultiVersion - if multiversion is enabled for:
	 * 	In general by having multiple types
	 * 	For this form item
	 * 	For this specific form type
	 *
	 * The form item will be converted into a choice form for each version
	 *
	 * param - item : the item
	 *
	 * return - item : the modified item
	 ******************************************************************************/
	this.ConvertToMultiVersion = function(item) {
		// Skip if the field does not support multiple versions
		if(item.multiversion != 1) return item;
		// Skip if there is no version requiring this field type to be multiversion
		if(this.versionTypes[item.type] == null) return item;
		
		// Create a choiceform in the place of this item, and move all
		// of the settings for the item to the child forms
		
		var defaultVersion = Packages.Library.$.GetDefaultVersion();
		
		// Update value stored in object, if not already a sub object
		if(typeof(form.object[item.id]) != "object") {
			var oldData = form.object[item.id];
			form.object[item.id] = {};
			form.object[item.id][defaultVersion] = oldData;
		}
		
		// Create each version form
		var versionsForms = [];
		var versions = Packages.Library.$.GetActiveVersions();
		for(var v = 0; v < versions.length; v++) {
			var version = versions[v];
			
			// Is version relevant for this type?
			if(this.versionTypeMap[version.refcode][item.type] == null) continue;
			
			// Create child form item for the choice form
			var childFormItem = {
				id: version.refcode
			};
			// Copy in members from original item, skipping bad ones
			for(var key in item) {
				if(key.match(/^(name|description|id|parentform|multiversion)$/)) continue;
				childFormItem[key] = item[key];
			}
			childFormItem.multiversion == 0; // Expressly disabled
			
			// Add this choice form to our list of child formdefs
			versionsForms.push({
				name: version.name,
				description: version.description,
				ref: version.refcode,
				form: {
					object: form.object[item.id],
					items: [
						childFormItem
					]
				}
			});
		}
		
		// Create the replacement item
		var newItem = {
			type: "ChoiceForm",
			id: item.id + "_versionref",
			name: item.name,
			description: item.description,
			parentform: form,
			formdefs: versionsForms,
			fullWidth: 1
		};
		
		// Replace item with new item
		return newItem;
	};
	
	/*************************************************************************************************
	 * IsFormDisplayed - determines if this form is still displayed in the DOM or not
	 *
	 * return 1 if still in the DOM, 0 if not
	 ************************************************************************************************/
    this.IsFormDisplayed = function() {
	    var elem = document.getElementById(this.id_prefix + "_inDOM");
		if(elem) return 1;
		return 0;
    };
	
	/*************************************************************************************************
	 * OnExit - called when the page is closed
	 *
	 * returns a response to be displayed if exit is not advised, or {} if ok
	 ************************************************************************************************/
    this.OnExit = function() {
		if(this.form.parentform != null) return {}; // Don't check for child forms
	    if(this.IsFormDisplayed() == 0) {
			Packages.Library.$.EventUnsubscribe({eventsubscription: this.onExitEvent});
			return {};
		}
		
		// Save form data
		this.Submit({fireCallback: 0, highlightErrors: 0});
		
		if(this.changed == 0) return {};
		
		// Put out a warning message
		if(this.form.exitMessage == null) this.form.exitMessage = "The data you have entered into the form is not saved.";
		
		return {
			stop: 1,
			message: this.form.exitMessage,
			id: this.id_prefix + "_formexit"
		};
    };
	if(this.form.parentform == null) this.onExitEvent = Packages.Library.$.EventSubscribe({eventname: "onexit", callback: this.OnExit.bind(this)});
	
	/*************************************************************************************************
	 * ObjectiseFormItem - takes an ordinary 'persistent data hash' and adds the '$' attribute to it
	 * that contains the methods for this form item.
	 *
	 * param - formitem : the form item to objectise
	 *
	 * no return, the form item is altered
	 ************************************************************************************************/
    this.ObjectiseFormItem = function(formitem) {
	    Packages.Library.$.Objectise({
			containerPackage: Packages.Form,
			data: formitem,
			objectType: "Item",
			superClass: this.DefaultFormItemProto()
		});
    };
	/*************************************************************************************************
	 * DefaultFormItemProto - Gets the default form item prototype containing the raw methods that should be
	 * included in a form item
	 * 
	 * returns the prototype
	 ************************************************************************************************/
	this.DefaultFormItemProto = function() {
		var proto = function() {
			this.MakeFormItem = function() {
				return "This form item type is not known";
			};
		};
		return proto;
	};
};Package("Form.HTML").Item = function(item) {
    this.item = item;
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * Plain HTML item - define the html markup and thats it
	 *
	 * params:
	 * 	html : the markup to display
	 * 	onsubmit : (optional) callback to fire when item is saved
	 * 	defaultvalue : value to use to save against the id
	 * 	callback : (optional) callback to fire to fetch up to date markup
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html = item.html;
		if(item.callback != null) html = item.callback();
		
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		if(this.item.onsubmit != null) this.item.onsubmit();
		return item.defaultvalue;
	};
};Package("Form.Hidden").Item = function(item) {
    this.item = item;
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * Hidden - a form item that should not appear, but needs to be set in the object
	 *
	 * params:
	 * 	defaultvalue : value to set to this object
	 ******************************************************************************/
	this.MakeFormItem = function() {
		this.item.parentform.object[item.id] = item.defaultvalue;
		return null;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		return this.item.defaultvalue;
	};
};Package("Form.Label").Item = function(item) {
    this.item = item;
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * Options for the item:
	 * 	     size: (optional) heading style h<size>, default 2
	 * 	     label : text to display
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html = "";
		if(this.item.size == null) this.item.size = 2;
		html += "<div class='form_label'><h" + this.item.size + ">" + this.item.label + "<\/h" + this.item.size + "><\/div>";
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		return null;
	};
};/***********************************************************************************
 * MultiForm - a form item, allows a varying number of sub forms to be displayed within.
 *
 * Each sub form is identical, but you can have any number of them.
 *
 * The data is stored in an array of objects, and the MultiForm manages that array
 *
 * The user can add, delete or re-order the multiple forms
 *
 * Each form is folded, and contains a title based on one of the form items
 **********************************************************************************/
Package("Form.MultiForm").Item = function(item) {
    this.item = item;
	var _this = this;
	this.textvar = GetTextRef(this);
	this.forms = [];
	this.uniqueFields = [];
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * item consists of:
	 * 	form : the child form definition (values are taken as defaults only)
	 * 		items: the array of items for this form, as for a standard form, may also contain:
	 * 			forceUnique : 1 forces this value to be unique across all multiform data, 0 (default) doesn't
	 * 	data : array of objects (each object will be edited by its own sub form)
	 * optionally:
	 * 	title : the name of the title item in the form (to be displayed above the collapsable area)
	 * 	titleRef : html (with references to values on the form <%key%>)
	 * 	active : the name of an active item in the form, when enabled and inactive, the title will be greyed out
	 * 	popupEdit : 1 popup edit dialog, 0 (default) use collapsed edit area
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var formarea = "<div class='form_multiform_formarea' id='" + this.item.elemid + "_formcontainer'>" + this.MakeFormContent() + "<\/div>";
		var addbutton = "<button onclick=\"" + this.textvar + ".Add()\">+<\/button>";
		
		var html = "";
		html += "<div class='form_multiform_container'>";
		html += formarea;
		html += addbutton;
		html += "<\/div>";
		return html;
	};
	/*******************************************************************************
	 * ReloadForm - reloads the form with the latest data (used after a move or delete or add)
	 ******************************************************************************/
	this.ReloadForm = function() {
		document.getElementById(this.item.elemid + "_formcontainer").innerHTML = this.MakeFormContent();
	};
	/*******************************************************************************
	 * MakeFormContent - makes the form content from latest data
	 ******************************************************************************/
	this.MakeFormContent = function() {
		var html = "";
		if(this.item.data == null) this.item.data = [];
		
		// Create a list of forceUnique items
		this.uniqueFields = [];
		for(var i = 0; i < this.item.form.items.length; i++) {
			var item = this.item.form.items[i];
			if(item.forceUnique == 1) {
				this.uniqueFields.push(item.id);
			}
		}
		
		// Create the items
		for(var i = 0; i < this.item.data.length; i++) {
			var title = this.GetTitleForRow(i)
			var reload = 1; // Force data to reload from data object
			var foldedEdit = "";
			var buttons = "<button onclick=\"" + this.textvar + ".MoveUp(" + i + ")\">&uarr;<\/button> " +
						"<button onclick=\"" + this.textvar + ".MoveDown(" + i + ")\">&darr;<\/button> " +
						"<button onclick=\"" + this.textvar + ".Delete(" + i + ")\">x<\/button>" +
						"<button onclick=\"" + this.textvar + ".Copy(" + i + ")\">copy<\/button>";
			var buttonsClass = "";
			
			if(this.item.popupEdit != 1) {
				var form = this.GetFormForRow(i);
				this.forms[i] = form;
				foldedEdit = Packages.Library.$.CreateFoldArea({
						title: "<span class='form_multiform_title'>" + title + "<\/span>",
						content: form.Form.MakeForm(reload),
						foldable: 1,
						folded: 1,
						foldid: this.item.elemid + "_folded" + i
					});
			} else {
				foldedEdit = "<span class='form_multiform_title'>" + title + "<\/span>";
				buttons += "<button onclick=\"" + this.textvar + ".Edit(" + i + ")\">edit<\/button>";
				buttonsClass += " form_multiform_controls_wide";
			}
			
			var rowhtml = "<table border='0' class='form_multiform_entry'><tr>" +
					"<td class='form_multiform_controls" + buttonsClass + "'>" +
						buttons +
					"<\/td>" +
						"<td " +
						"class='form_multiform_area' " +
						"id='" + this.item.elemid + "_form" + i + "' " +
					">" +
						foldedEdit +
					"<\/td>" +
				"<\/tr>" +
				"<tr><div class='form_multiform_sep'><\/div><\/tr>" +
				"<\/table>";
			html += Packages.Library.$.CreateDragAndDropItem({
				item: this.item.data[i],
				html: rowhtml,
				storeArray: this.item.data,
				allowReordering: 1,
				callback: function() {
					_this.ReloadForm();
				}
			});
		}
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		
		var uniqueCheck = {};
		
		if(this.item.popupEdit != 1) {
			// Iterate through all child forms and tell them to save their data
			for(var i = 0; i < this.item.data.length; i++) {
				var form = this.forms[i];
				if(form == null) continue; // When a new form is added, don't submit it on reload
				
				form.Form.Submit();
				
				// Check unique fields
				var data = form.object;
				foreach(this.uniqueFields, function(id) {
					if(uniqueCheck[id] == null) uniqueCheck[id] = {};
					if(uniqueCheck[id][data[id]] != null) {
						// Matched an existing entry
						// Get the actual item in the items
						var item = Packages.Library.$.FindArrayItem({
							array: form.items,
							path: "id",
							value: id
						});
						item.forceError = "This value is not unique";
						form.Form.Submit();
					} else {
						// Record it
						uniqueCheck[id][data[id]] = 1;
					}
				});
				
				// Did errors occur?
				if(form.errors != null) {
					this.item.error = "One or more items contained errors";
					
					// Highlight that form
					document.getElementById(this.item.elemid + "_form" + i).style.border = "1px solid red";
				}
				if(form.Form.changed == 1) this.item.parentform.Form.changed = 1;
			}
		}
		
		return this.item.data;
	};
	
	/*******************************************************************************
	 * GetTitleForRow - gets the title for a row
	 *
	 * param - id : id of row to get a title for
	 *
	 * return - title : the title
	 ******************************************************************************/
	this.GetTitleForRow = function(id) {
		var title = "[Empty]";
		if(this.item.title != null) title = this.item.data[id][this.item.title];
		if(this.item.titleRef != null) title = Packages.Library.$.ReplaceReferencesWithObjectValues({
			text: this.item.titleRef,
			object: this.item.data[id]
		});
		if(title == null || title.match(/<%.+?%>/)) title = "New item";
		if(this.item.active != null && this.item.data[id][this.item.active] == 0) title = "<div class='form_multiform_inactive'>" + title + "<\/div>";
		
		return title;
	}
	/*******************************************************************************
	 * GetFormForRow - gets the form for the specified row
	 *
	 * param - id : id of row to get a form for
	 *
	 * return - form : the form
	 ******************************************************************************/
	this.GetFormForRow = function(id) {
		var form = Packages.Library.$.Clone({oldObj: this.item.form});
		form.type = "Form";
		form.object = this.item.data[id];
		form.parentform = this.item.parentform;
		form.showSubmit = 0;
		form.showComplexity = this.item.popupEdit == 1 ? 1 : 0;
		form.allowUndo = 0;
		form.complexityLevels = this.item.parentform.complexityLevels;
		form.action = this.item.parentform.action;
		form.idprefix = this.item.elemid + "_multiform_sub" + id + "_";
		form.Form = new Packages.Form.Form(form);
		
		return form;
	}
	/*******************************************************************************
	 * MoveUp - moves the currently selected form up
	 *
	 * param - id : id of form to move
	 ******************************************************************************/
	this.MoveUp = function(id) {
		this.SaveFormItem(); // Save current data
		
		if(id != 0) {
			var temp = this.item.data[id];
			this.item.data[id] = this.item.data[id - 1];
			this.item.data[id - 1] = temp;
		}
		
		this.ReloadForm(); // Reload form
	};
	/*******************************************************************************
	 * MoveDown - moves the currently selected form down
	 *
	 * param - id : id of form to move
	 ******************************************************************************/
	this.MoveDown = function(id) {
		this.SaveFormItem(); // Save current data
		
		if(id != this.item.data.length - 1) {
			var temp = this.item.data[id];
			this.item.data[id] = this.item.data[id + 1];
			this.item.data[id + 1] = temp;
		}
		
		this.ReloadForm(); // Reload form
	};
	/*******************************************************************************
	 * Delete - deletes the currently selected form
	 *
	 * param - id : id of form to delete
	 ******************************************************************************/
	this.Delete = function(id) {
		// Validate
		if(!confirm("Are you sure you wish to delete this item?")) return;
		
		this.SaveFormItem(); // Save current data
		
		this.item.data.splice(id, 1);
		
		this.ReloadForm(); // Reload form
	};
	/*******************************************************************************
	 * Copy - copies the selected item
	 *
	 * param - id : id of form to copy
	 ******************************************************************************/
	this.Copy = function(id) {
		this.SaveFormItem(); // Save current data
		
		var newItem = Packages.Library.$.Clone({oldObj: this.item.data[id]});
		
		this.item.data.splice(id, 0, newItem);
		
		this.ReloadForm(); // Reload form
	};
	/*******************************************************************************
	 * Edit - produces an edit form
	 *
	 * param - id : id of form to edit
	 ******************************************************************************/
	this.Edit = function(id) {
		var form = this.GetFormForRow(id);
		var _this = this;
		
		Packages.Library.$.CreatePopupQuery({
			title: "Edit [" + this.GetTitleForRow(id) + "]",
			message: form.Form.MakeForm(),
			wrapMessage: 0,
			callback: function(btn) {
				if(btn == 'OK') {
					form.Form.Submit();
					_this.ReloadForm();
					if(form.errors) return 0;
				}
				return 1;
			}
		});
	};
	/*******************************************************************************
	 * Add - adds a new form to the end
	 ******************************************************************************/
	this.Add = function(id) {
		this.SaveFormItem(); // Save current data
		
		this.item.data.push({});
		
		this.ReloadForm(); // Reload form
	};
};Package("Form.NestedForm").Item = function(item) {
    this.item = item;
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * item consists of:
	 * 	form : the child form
	 * optionally:
	 * 	relativeObject : key in parent form object that this object belongs to
	 ******************************************************************************/
	this.MakeFormItem = function() {
		this.form = this.item.form;
		if(this.form.userspace == null) this.form.userspace = 0;
		if(this.item.relativeObject != null) {
			if(this.item.parentform.object[this.item.relativeObject] == null) this.item.parentform.object[this.item.relativeObject] = {};
			this.form.object = this.item.parentform.object[this.item.relativeObject];
		}
		this.form.type = "Form";
		this.form.showSubmit = 0;
		this.form.showComplexity = 0;
		this.form.idprefix = this.item.elemid + "_nestedform_";
		this.form.parentform = this.item.parentform;
		this.form.Form = new Packages.Form.Form(this.form);
		this.form.allowUndo = 0;
		this.form.complexityLevels = this.item.parentform.complexityLevels;
		this.form.action = this.item.parentform.action;
		var reload = 0;
		if(item.reloaded != null && item.reloaded == 1) reload = 1;
		return "<div class='nested_form'>" + this.form.Form.MakeForm(reload) + "<\/div>";
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		this.form.Form.Submit();
		
		// Did errors occur?
		if(this.form.errors != null) this.item.error = "One or more items contained errors";
		
		if(this.form.Form.changed == 1) this.item.parentform.Form.changed = 1;
		
		return null;
	};
};Package("Form.Options").Item = function(item) {
    this.item = item;
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * Uses checkboxes to display a list of multiple options, from which the user can select
	 *
	 * item:
	 * 	value: (either) value of the selected item
	 * 		   (or) array of selected items
	 *  commaString: 1 the string is a comma separated list of options, 0 (default) the string is one option
	 *  				the value is an array of values
	 *  removeOnly: 1 shows only the selected items, with a button to remove each, 0 (default) shows all
	 * 	options:
	 * 		array of hashes each defining an item:
	 * 			name: user facing text
	 * 			value: the value
	 * 			description: (optional) help text to place inside a help bubble
	 * 			selected: (or) whether selected or not
	 * 		
	 ******************************************************************************/
	this.MakeFormItem = function() {
		// Create array of checked values
		var checkedValues = item.value;
		if(typeof(item.value) == "string") {
			checkedValues = [item.value];
			if(item.commaString == 1) {
				checkedValues = item.value.split(",");
			}
		}
		if(checkedValues == null) checkedValues = [];
		
		var html = "";
		for(var i = 0; i < item.options.length; i++) {
			var checked = "";
			if(item.options[i].selected) checked = "checked='checked'";
			if(Packages.Library.$.Contains({array: checkedValues, item: item.options[i].value})) checked = "checked='checked'";
			
			if(checked == "" && item.removeOnly == 1) continue;
			
			var name = item.options[i].name;
			if(name == "") name = "-";
			html += "<div class='form_options_option'>";
			html += "<input " +
						"type='checkbox' " +
						"id='" + item.elemid + "_" + i + "'" +
						checked +
					">";
			if(item.options[i].formattedName != null) name = item.options[i].formattedName;
			if(item.options[i].description != null) html += Packages.Library.$.MakeHelp({help: item.options[i].description});
			html += "<label class='form_options_label' for='" + item.elemid + "_" + i + "'>" + name + "<label>";
			html += "<\/div>";
		}
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		var multiple = [];
		for(var i = 0; i < item.options.length; i++) {
			var elem = document.getElementById(item.elemid + "_" + i);
			if(elem != null && elem.checked) {
				multiple.push(item.options[i].value);
			}
		}
		
		if(item.commaString == 1) {
			// Convert to comma separated string
			multiple = multiple.join(",");
		}
		
		return multiple;
	};
};Package("Form.RadioButtons").Item = function(item) {
    this.item = item;
	this.textvar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * item is of the form:
	 *  value: which radio button is selected (option matches value)
	 *  none: the name of a 'null' value at the top of the list, or null if unneeded
	 * 	options: array of options of the form:
	 * 		value: internal value
	 * 		name: text to display
	 * 		description: (optional) help for each item
	 * 		enabled : (optional) 1 (default) enabled, 0 disabled
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html = "";
		if(this.item.none != null) {
			this.item.options.unshift({name: this.item.none, value: null});
		}
		for(var i = 0; i < item.options.length; i++) {
			var checked = (item.options[i].value == item.value || item.options[i].selected ? " checked='checked'" : "");
			var name = item.options[i].name;
			if(name == "") name = "-";
			html += "<span class='form_options_option'>" +
						"<input " +
							(item.enabled == 0 ? "disabled='disabled' " : "") +
							"name='" + item.elemid + "_group' " +
							"type='radio'" +
							checked + " " +
							"id='" + item.elemid + "_" + i + "' " +
							"value='" + item.options[i].value + "'" +
							"onchange=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textvar + ")\" " +
						">" +
						"<label for='" + item.elemid + "_" + i + "'>" +
							name +
							(item.options[i].description != null ? Packages.Library.$.MakeHelp({help: item.options[i].description}) : "") +
						"</label>&nbsp;&nbsp;" +
					"<\/span>";
		}
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		for(var i = 0; i < item.options.length; i++) {
			if(document.getElementById(item.elemid + "_" + i).checked) {
				return item.options[i].value;
			}
		}
		return null;
	};
};Package("Form.RichText").Item = function(item) {
    this.item = item;
    this.textvar = GetTextRef(this);
    this.running = 0;
	this.rteElem = null;
	/* Inline Editing
	 *
	 * inline:
	 * 	null or disabled : does not support it
	 *  enabled : default standard, but allows switching to inline
	 *  default : default inline, allows switching to standard
	 *
	 * Requires id='richtext_editor" + this.data.$noDump.uid + "'
	 *  to be set on the inline container
	 *
	 * If data.$noDump.uid not found or elem not found, not enabled
	 */
	/* Formats
	 * Each format describes an item in the menu
	 * The format at the caret position is matched against the best match
	 * Formats can have a number of parameters
	 * 	tag : the tag
	 * 	title : as it appears in the menu
	 * 	block : 1 a block level element, switches nearest block level element, 0 not a block level element
	 * 	inline : 1 an inline element, wraps selection, 0 not
	 * 	nesting : 1 (default) allow these tags to nest, 0 don't, so when an item is inserted, it instead edits the existing
	 * 	classname : classname of element
	 * 	items : array of form items to show when editing / adding. If no items, shows no form
	 * 	insert : 1 always insert a new element, 0 (default) wrap selected text
	 * 	clear : 1 special case, clears all styles within the selection
	 */
    this.formats = [
        {tag: "h1", title: "Heading1", block: 1},
        {tag: "h2", title: "Heading2", block: 1},
        {tag: "h3", title: "Heading3", block: 1},
        {tag: "h4", title: "Heading4", block: 1},
        {tag: "h5", title: "Heading5", block: 1},
        {tag: "h6", title: "Heading6", block: 1},
        {tag: "q", title: "Quote", block: 1},
        {tag: "p", title: "Normal", block: 1},
        {tag: "div", title: "No Padding",	classname: "richtextnopadding", block: 1},
        {tag: "div", title: "List",			classname: "richtextlist", block: 1},
        {tag: "div", title: "Notice",		classname: "richtextnotice", block: 1},
        {tag: "div", title: "Highlight",	classname: "richtexthighlight", block: 1},
        {tag: "div", title: "Address",		classname: "richtextaddress", block: 1},
        {tag: "b", title: "Bold", inline: 1},
        {tag: "i", title: "Italic", inline: 1},
        {tag: "u", title: "Underline", inline: 1}
	];
	if(this.item.folder != null) {
		this.formats.push({tag: "a", title: "Link", nesting: 0, inline: 1, items:[
			{
				type: "URL",
				id: "href",
				folder: this.item.folder,
				pathPrefix: this.item.pathPrefix,
				thumbnailPrefix: this.item.thumbnailPrefix,
				useContainerPath: 1,
				offset: this.item.offset
			}
		]});
        this.formats.push({tag: "img", title: "Image", insert: 1, items:[
			{
				type: "FileMgr",
                select: 1,
                pathPrefix: this.item.pathPrefix,
				thumbnailPrefix: this.item.thumbnailPrefix,
                folder : this.item.folder,
				id: "src",
                extensionFilter: ['jpg', 'gif', 'png', 'jpeg'],
				foldable: 1,
				folded: 1,
				name: "Select image",
				useContainerPath: 1,
				offset: this.item.offset
			},
			{
				type: "Text",
                id: "alt",
				name: "Alt text"
			},
			{
				heading: "Styling",
				type: "NestedForm",
				relativeObject: "style",
				form: {
					idprefix: "style",
					items: [
						{
							name: "Float",
							description: "How the image sits within the text",
							id: "float",
							value: "none",
							type: "SelectBox",
							options: [
								{name: "None", value: "none"},
								{name: "Left", value: "left"},
								{name: "Right", value: "right"}
							]
						},
						{
							type: "Text",
							id: "width",
							name: "Width",
							description: "Requires a 'px' or '%' suffix",
							suffix: "enter 'px' or '%'",
							size: 10,
							removeIfEmpty: 1
						}
					]
				}
			}
		]});
		this.formats.push({title: "Clear", clear: 1});
	}
	
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * item options:
	 * 		value : content to edit
	 * 		pageClass : (optional) classname to add to editor to gain styles from page
	 * 		rows : (optional) number of rows for the editor (takes presidence over height)
	 * 		width : (optional) width of item
	 * 		height : (optional) height of item
	 ******************************************************************************/
	this.MakeFormItem = function() {
		// Get defaults - ensure item always has some starting value - to allow it to be formatted
		if(this.item.value == "") this.item.value = "<p><\/p>";
		if(this.item.rows != null) this.item.height = this.item.rows * 20;
		if(this.item.height == null) this.item.height = 16 * 20;
		if(this.item.pageClass == null) this.item.pageClass = "";
		
		// Legacy update value
		this.item.value = Packages.Library.$.ConvertLegacy({str: this.item.value});
		
		// Determine if inline editing
		this.inline = 0;
		this.inlineswitch = 0;
		if(this.item.inline != null
		&& this.item.inline != "disabled"
		&& this.item.inlineelemid != null) {
			this.inlineswitch = 1;
			if(this.item.inline == "default") this.inline = 1;
		}
		
		// Build item HTML
		var html = "";
		if(this.inlineswitch == 1) {
			html += "<input "
					+	"type='checkbox' "
					+	"id='" + item.elemid + "_inline_switcher' "
					+	"onchange=\"" + this.textvar + ".SwitchInlineMode()\" "
					+	(this.inline == 1 ? "checked='checked' " : "")
					+	"class='form_richtext_editor_inlineswitcher' "
				+	">"
				+	"<label "
					+	"for='" + item.elemid + "_inline_switcher'"
				+	">"
					+	"Edit Inline"
				+	"<\/label>";
		}
		if(this.item.editPlain > 0) {
			html += "<input "
					+	"type='checkbox' "
					+	"id='" + item.elemid + "_plain_switcher' "
					+	"onchange=\"" + this.textvar + ".SwitchPlainMode()\" "
					+	(this.item.editPlain == 2 ? "checked='checked' " : "")
					+	"class='form_richtext_editor_switcher' "
				+	">"
				+	"<label "
					+	"for='" + item.elemid + "_plain_switcher'"
				+	">"
					+	"View raw HTML (advanced)"
				+	"<\/label>";
			
			html += "<textarea " +
						"id='" + item.elemid + "_plain' " +
						"style='" +
							(this.item.width  != null ? "width:"  + this.item.width  + "px;" : "") +
							(this.item.height != null ? "height:" + this.item.height + "px;" : "") +
						"' " +
						"onchange=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textvar + ")\" " +
						"class='form_richtext_editor_plain' " +
					">" +
						this.item.value +
					"<\/textarea>";
		}
        html += "<div class='form_richtext_editor'>";
        html += this.GetMenu();
        html += "<div id='" + item.elemid + "_richtext' " +
					"style='" +
						(this.item.width  != null ? "width:"  + this.item.width  + "px;" : "") +
						(this.item.height != null ? "height:" + this.item.height + "px;" : "") +
						(this.item.enabled == 0 ? "background-color:#888888;" : "") +
						"display: " + (this.inline == 1 ? "none" : "block") + ";" +
					"' " +
					// (this.item.enabled == 0 ? "" : "contenteditable ") + Set in GetRTEElem
					"class='form_richtext_editor_area " + this.item.pageClass + "' " +
					"onchange=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textvar + ")\" " +
					"ondblclick=\"" + this.textvar + ".EditSelection(event)\" " +
				"'>" +
					this.item.value +
				"<\/div>";
		html += "<\/div>";
        
        // Start monitoring
        this.Monitor();
        
        return html;
    };
    /*******************************************************************************
	 * SaveFormItem - returns the data for this form item to the form
	 ******************************************************************************/
	this.SaveFormItem = function() {
        var switchElem = document.getElementById(this.item.elemid + "_plain_switcher");
		var plainElem = document.getElementById(this.item.elemid + "_plain");
		var value;
		if(switchElem && switchElem.checked) {
			value = plainElem.value;
		} else {
			value = this.GetFixedRTEValue();
		}
		return Packages.Library.$.ConvertToHTML({str: value});
	};
    /****************************************************
     * GetMenu - gets the menu for the RTE
     *
     * returns the html for the menu
     ***************************************************/
    this.GetMenu = function() {
		var html = "";
		html += "Format:";
		html += Packages.Library.$.MakeHelp({help: "Clicking on the text will highlight the current lines style.\nYou can adjust the current lines style by selecting another format from those listed."});
		html += "<div class='form_rte_menu'>";
        for(var i = 0 ;i < this.formats.length; i++) {
			html += "<div class='form_rte_menu_item'>";
            html += "<input " +
						"type='radio' " +
						"value='" + i + "' " +
						"id='" + this.item.elemid + "_menu_" + i + "' " +
						"name='" + this.item.elemid + "_menu'" + 
						(item.enabled == 0 ? "disabled='disabled' " : "") + 
						"onchange=\"" + this.textvar + ".ChangeMenu('" + i + "')\" " +
					">";
            html += "<button " +
						"onclick=\"" + this.textvar + ".ChangeMenu('" + i + "')\" " +
						"class='nouserselect' " +
					">" +
						"<div " +
							"class='" + this.item.pageClass + " form_rte_button' " +
							"style='background:none' " +
						">" +
							"<" + this.formats[i].tag + " " +
								(this.formats[i].classname != null ? "class='" + this.formats[i].classname + "' " : "") +
							">" +
								this.formats[i].title +
							"</" + this.formats[i].tag + ">" +
						"<\/div>" +
					"<\/button>";
			html += "<\/div>";
        }
		html += "<\/div>";
        return html;
    };
    /****************************************************
     * GetSelection - gets the current selection
     *
     * returns a hash of selection information, or null if not valid
     * 	hash as follows:
     * 		selection : the selection
     * 		range : the range
     * 		node : the containing node
     * 		baseNode : the actual node
     ***************************************************/
    this.GetSelection = function() {
        // Get the selected text
        var selection = window.getSelection();
		if(selection.rangeCount == 0) return null;
        var range = selection.getRangeAt(0);
        
        // Get the original node
        var node = range.startContainer.parentNode;
		
		// Ensure this belongs to our rtelem
		if(this.GetParentNodeWhere(node, "id", this.rteElem.id) == null) return null;
		
		return {
			selection: selection,
			range: range,
			node: node,
			baseNode: range.startContainer
		}
	}
	/****************************************************
     * ChangeMenu - called when the menu select box changes - updates the rich text to reflect
     *
     * This changes the selected content to that of the menu selection
     *
     * param - formatid : new format
     ***************************************************/
    this.ChangeMenu = function(formatid) {
		var selection = this.GetSelection();
		if (selection == null) return;
		var node = selection.node;
		var baseNode = selection.baseNode;
		
		var currentFormat = this.GetFormatForNode(node);
		
    	var format = this.formats[formatid];
		
		if(format.clear == 1) {
			if(currentFormat == null || currentFormat.inline != 1) return;
			var res = confirm("Are you sure you want to remove the formatting on item:\n" + node.innerText);
			if(res) {
				// Special clear action
				var parent = node.parentNode;
				while(node.firstChild) {
					parent.insertBefore(node.firstChild, node);
				}
				parent.removeChild(node);
			}
		}
        
		// Create the new node
		var newNode = document.createElement(format.tag);
		var complete = 0;
		
		if (format.insert == 1) {
			selection.range.insertNode(newNode);
			complete = 1;
		} else if (format.inline == 1 && Math.abs(selection.selection.extentOffset - selection.selection.baseOffset) > 0) {
			var wrap = 1;
			if(format.nesting == 0) {
				// Nesting disabled, test if nested within the same element
				var foundNode = this.GetParentNodeWhere(node, "tagName", format.tag)
				if(foundNode != null) {
					wrap = 0;
					// Set newNode to existing node to pop up editor
					newNode = node;
					complete = 1;
				}
			}
			if(wrap == 1) {
				newNode.appendChild(selection.range.extractContents());
				selection.range.insertNode(newNode);
				complete = 1;
			}
		} else if(format.block == 1) {
			var searchNode = this.GetParentNodeWhere(node, "style_display", ["block", "list-item"]);
			if(searchNode != null) node = searchNode;
			
			// Move the children
			while (node.firstChild) {
				newNode.appendChild(node.firstChild);
			}
			// Copy the attributes
			for (var index = node.attributes.length - 1; index >= 0; --index) {
				newNode.attributes.setNamedItem(node.attributes[index].cloneNode());
			}
			this.RemoveAllInlineStyles();
			
			// Replace nodes
			node.parentNode.replaceChild(newNode, node);
			
			complete = 1;
		}
		
		if(complete) {
			// Assign new classname
			var classname = format.classname;
			if(classname == null) classname = "";
			newNode.className = classname;
			
			this.CreateFormatEditForm(newNode, format);
		}
		
		// Put input focus back on editor
		this.rteElem.focus();
		// And select the changed item
		selection.selection.addRange(selection.range);
    };
    /****************************************************
     * EditSelection - pops up the editor for the selection when it is double clicked on
     ***************************************************/
    this.EditSelection = function(e) {
		e = e || window.event;
		var node;
		if(e) {
			node = e.target;
			if (!node) node = e.srcElement;
		}
		
		// Find format for this selection node
		var format = this.GetFormatForNode(node);
		if(format == null) return;
		
		this.CreateFormatEditForm(node, format);
	};
	/****************************************************
     * GetFormatForNode - gets the matching format for a node
     *
     * param - node : the node to get the format of
     *
     * return - format : a matching format, or null if not found
     ***************************************************/
    this.GetFormatForNode = function(node) {
		if(node.id == this.rteElem.id) return null; // Do not search self
		
		var format = null;
		for(var f = 0; f < this.formats.length; f++) {
			var format = this.formats[f];
			if(format.tag == null) continue; // Skip
			
			if(format.tag.toUpperCase() == node.tagName.toUpperCase()) {
				if(format.classname == null
				|| format.classname == node.className) {
					format.id = f;
					return format;
				}
			}
		}
		
		// Try parent
		return this.GetFormatForNode(node.parentNode);
	};
	
	/****************************************************
     * SwitchInlineMode - switches the inline editing mode
     ***************************************************/
    this.SwitchInlineMode = function() {
		this.inline = this.inline == 1 ? 0 : 1;
		this.GetRTEElem();
	}
	/****************************************************
     * GetRTEElem - fetches or updates the RTE elem
     ***************************************************/
    this.GetRTEElem = function() {
		var standardRTEElem = document.getElementById(item.elemid + "_richtext");
		if(standardRTEElem == null) return; // Stop if no standard elem found
		
		var formerContent; // Used for moving content
		if(this.rteElem != null) {
			this.rteElem.contentEditable = "false"; // Turn off on existing elem
			formerContent = this.rteElem.innerHTML;
		}
		
        if(this.inline == 1) {
			this.rteElem = document.getElementById(this.item.inlineelemid);
			standardRTEElem.style.display = "none";
		} else {
			// Standard
			this.rteElem = standardRTEElem;
			standardRTEElem.style.display = "block";
		}
		
		// Don't do anything else if rtelem doesn't exist
        if(this.rteElem == null) return;
		
		this.rteElem.contentEditable = "true";
		if(formerContent != null) {
			this.rteElem.innerHTML = formerContent;
		}
		this.rteElem.onmousedown = function() {window.event.stopPropagation();};
		this.rteElem.onmouseup = function() {window.event.stopPropagation();};
		this.rteElem.onclick = function() {window.event.stopPropagation();};
		this.rteElem.ondblclick = function() {window.event.stopPropagation();};
	};
	
	/****************************************************
     * Monitor - continually checks the position of the cursor within the div
     * Updates the menu elem when needed
     ***************************************************/
    this.Monitor = function() {
		if(this.rteElem == null) this.GetRTEElem();
		
		// If we have seen an rtelem (running) but now don't have one
		// Don't start another callback
		if(this.running && !this.rteElem) return;
		
        // Set up a timer to look again soon
        setTimeout(this.textvar + ".Monitor()", 100);
        
        if(this.rteElem == null) return;
		this.running = 1;
		
		var selection = this.GetSelection();
		if (selection == null) return;
		var node = selection.node;
		var currentFormat = this.GetFormatForNode(node);
		if(currentFormat == null) return;
        
        var elem = document.getElementById(this.item.elemid + "_menu_" + currentFormat.id);
		if(elem) elem.checked = 'checked';
		
		this.RemoveAllInlineStyles();
    };
	
	/****************************************************
     * RemoveAllInlineStyles - removes all inline styles
     *
     * With the following exceptions
     * 	img tags
     ***************************************************/
    this.RemoveAllInlineStyles = function() {
		if(this.rteElem == null) return;
		
		// Clean up the new node by removing all inline styles
		this.TraverseChildren(this.rteElem, function(elem) {
			if(elem.style == null) return;
			if(elem.tagName == "IMG") return;
			for(var key in elem.style) {
				elem.style[key] = "";
			}
		}, {noParentFire: 1});
	}
	
	/****************************************************
     * GetFixedRTEValue - gets the fixed RTE value
     *
     * Used because <%xxx%> is not valid and gets
     * converted to &lt;%xxx%&gt;
     *
     * return - the value of the RTE, fixed
     ***************************************************/
    this.GetFixedRTEValue = function() {
		if(this.rteElem == null) return "";
		
		return this.rteElem.innerHTML.replace(/&lt;%/g, "<%").replace(/%&gt;/g, "%>");
	}
	
	/****************************************************
     * SwitchPlainMode - called when mode switched
     ***************************************************/
    this.SwitchPlainMode = function() {
		var switchElem = document.getElementById(this.item.elemid + "_plain_switcher");
		var plainElem = document.getElementById(this.item.elemid + "_plain");
		if(switchElem && plainElem && this.rteElem) {
			if(switchElem.checked) {
				// Copy from rte -> plain
				plainElem.value = this.GetFixedRTEValue();
			} else {
				// Copy from plain -> rte
				this.rteElem.innerHTML = plainElem.value;
			}
		}
	}
	
	/****************************************************
     * CreateFormatEditForm - creates the editor form for the specified format
     *
     * Generates a form only if needed
     *
     * Updates the DOM on save since the DOM object is the thing being edited by form
     *
     * param - elem : elem being edited
     * param - format : the format
     ***************************************************/
    this.CreateFormatEditForm = function(elem, format) {
		if (format.items == null) return;
		
		this.formatEditForm = {
			type: "Form",
			items: format.items,
			object: elem,
			showSubmit: 0
		};
		this.formatEditForm.Form = new Packages.Form.Form(this.formatEditForm);
		
		var _this = this;
		
		Packages.Library.$.CreatePopupQuery({
			title: "Edit " + format.title,
			message: this.formatEditForm.Form.MakeForm(),
			buttons: {
				"Save": "Save"
			},
			callback: function() {
				_this.formatEditForm.Form.Submit();
				if(_this.formatEditForm.errors == 1) return 0;
				return 1;
			}
		});
	}
	
	/************ Utility Functions ***************/
	
	/****************************************************
     * GetParentNodeWhere - gets the parent node of the current node
     * where the property / value match
     *
     * Also checks self
     *
     * param - elem : current element
     * param - property : property to check, or style_property for styles
     * param - match : value to match (if a class, finds in the list of classes)
     * 				value may be an array of values to match [OR]
     *
     * returns the parent node found or null if rte container reached
     ***************************************************/
    this.GetParentNodeWhere = function(elem, property, match) {
		var values = match;
		if(typeof match == "string") values = [match];
		
		if (elem == null) return null;
		
		for(var v = 0; v < values.length; v++) {
			var value = values[v];
			if(property.match("^style_(.+)")) {
				var style = RegExp.$1;
				if(Packages.Library.$.GetElemStyle({elem: elem, property: style}) == value) return elem;
			} else if(property == "className") {
				var classes = " " + elem.classname + " ";
				if(classes.indexOf(" " + value + " ")) return elem;
			} else if(property == "tagName") {
				if(elem[property].toUpperCase() == value.toUpperCase()) return elem
			} else {
				if(elem[property] == value) return elem
			}
		}
		
		if(elem.id != item.elemid + "_richtext") return this.GetParentNodeWhere(elem.parentNode, property, values);
		
		// Otherwise fail
		return null;
	}
	
	/****************************************************
     * TraverseChildren - traverses all children of this node, calling
     * the specified method on each
     *
     * Also calls for self
     *
     * param - elem : current element
     * param - fn : method to fire
     * param - options : hash of options, may contain:
     * 		noParentFire : 1 do not fire on parent, 0 (default) do
     ***************************************************/
    this.TraverseChildren = function(elem, fn, options) {
		if(elem == null) return;
		if(options == null) options = {};
		if(options.noParentFire != 1) fn(elem);
		var children = elem.childNodes;
		for(var c = 0; c < children.length; c++) {
			var child = children[c];
			this.TraverseChildren(child, fn);
		}
	};
};Package("Form.SelectBox").Item = function(item) {
    this.item = item;
	this.textVar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * item:
	 * 	multiple: 1 on, 0 off
	 * 	none: the name of a 'null' value at the top of the list, or null if unneeded
	 * 	value: (either) value of the selected item
	 * 	options:
	 * 		array of hashes each defining an item:
	 * 			name: user facing text
	 * 			value: the value
	 * 			selected: (or) whether selected or not
	 * 		
	 ******************************************************************************/
	this.MakeFormItem = function() {
		// Make a clone of item.options as we edit them
		this.item.options = Packages.Library.$.Clone({oldObj: this.item.options});
		if(this.item.none != null) {
			this.item.options.unshift({name: this.item.none, value: "null"});
			this.item.none = null; // Done it
		}
		var html = "<select"
						+ " id='" + item.elemid + "'"
						+ (item.multiple ? " multiple='multiple'" : "")
						+ " onchange=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textVar + ")\""
					+ ">";
		html += Packages.Library.$.CreateSelectOptionsFromArray({
			items: item.options,
			value: item.value,
			multiple: this.item.multiple
		})
		html += "<\/select>";
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		var elem = document.getElementById(this.item.elemid);
		if(elem.selectedIndex == -1) return null;
		if(!this.item.multiple) {
			var value = elem.options[elem.selectedIndex].value;
			if(value == "null") value = null;
			this.item.value = value;
			return value;
		}
		
		var multiple = [];
		for(var i = 0; i < elem.options.length; i++) {
			if(elem.options[i].selected) {
				var value = item.options[i].value;
				if(value == "null") return null;
				multiple.push(value);
			}
		}
		return multiple;
	};
};Package("Form.Text").Item = function(item) {
    this.item = item;
	this.textVar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 *
	 * options:
	 * 	numeric : make this a numeric text field
	 * 	min : (if numeric) min value, (if string) min length
	 * 	max : (if numeric) max value, (if string) max length
	 * 	step : (if numeric) step value
	 * 	size : (optional) size of field
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var item = this.item;
		if(item.value == null) item.value = "";
		var min = ""; var max = ""; var step = ""; var type = 'text';
		if(item.numeric == 1) {
			type = 'Number';
			if(item.min == "") item.min = null;
			if(item.max == "") item.max = null;
			if(item.step == "") item.step = null;
			if(item.min  != null) min  = " min='"  + item.min + "'";
			if(item.max  != null) max  = " max='"  + item.max + "'";
			if(item.step != null) step = " step='" + item.step + "'";
		}
		if(item.password == 1) {
			type = 'password';
		}
		var styles = "";
		if(item.size != null) styles += "width:" + item.size + "em;";
		var html = "<input " +
						(item.enabled == 0 ? "disabled='disabled' " : "") +
						"type='" + type + "' " +
						"value=\"" + Packages.Library.$.EscapeValueForField({value: item.value}) + "\" " +
						"id='" + item.elemid + "' " +
						(item.size != null ? "size='" + item.size + "' " : "") +
						min +
						max +
						step +
						"onchange=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textVar + ")\"" +
						"style='" + styles + "'" +
					">";
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		var value = document.getElementById(this.item.elemid).value;
		
		if(this.item.numeric == 1) {
			if(value === "") return ""; // Do not force numeric, as "" is fine if the number is not required
			value = value * 1;
			if(this.item.min  != null && value < (this.item.min * 1)) value = this.item.min * 1;
			if(this.item.max  != null && value > (this.item.max * 1)) value = this.item.max * 1;
			if(this.item.step != null && value % (this.item.step * 1) != 0) value = (Math.floor(value / this.item.step)) * this.item.step;
		} else {
			if(this.item.min  != null && value.length < this.item.min) this.item.error = "Minimum length: " + this.item.min;
			if(this.item.max  != null && value.length > this.item.max) this.item.error = "Maximum length: " + this.item.min;
			value = Packages.Library.$.ConvertToHTML({str: value});
		}
		
		return value;
	};
};Package("Form.TextArea").Item = function(item) {
    this.item = item;
	this.textVar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 ******************************************************************************/
	this.MakeFormItem = function() {
		if(item.rows == null) item.rows = 5;
		if(item.cols == null) item.cols = 20;
		var html = "<textarea "
						+ (item.enabled == 0 ? "disabled='disabled' " : "")
						+ "rows='" + item.rows + "' "
						+ "cols='" + item.cols + "' "
						+ "id='" + item.elemid + "' "
						+ "onchange=\"" + this.item.parentform.Form.textvar + ".Action(" + this.textVar + ")\" "
					+ ">"
						+ Packages.Library.$.EscapeValueForField({value: item.value})
					+ "<\/textarea>";
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		return Packages.Library.$.ConvertToHTML({str: document.getElementById(item.elemid).value});
	};
};Package("Form.URL").Item = function(item) {
    this.item = item;
	this.textVar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item (was makeColourSelector)
	 ******************************************************************************/
	this.MakeFormItem = function() {
		this.data = {texturl: this.item.value, fileurl: this.item.value};
		
		if (this.item.folder == null) this.item.folder = pFolders;
		
		this.form = {
			type: "Form",
			object: this.data,
			showSubmit: 0,
			idprefix: this.item.elemid + "_url",
			items: [
				{
					type: "Label",
					size: 3,
					label: "URL Selector",
					description: "A URL can either be made to a resource on your site, or you can manually enter an external URL. If both an external URL and a file are selected, the file takes presidence."
				},
				{
					type: "Text",
					value: this.data.texturl,
					name: "Enter external URL here",
					id: "texturl",
					description: "The external URL (with the http://) Eg http://web.marloweos.com"
				},
				{
					type: "FileMgr",
					select: 1,
					pathPrefix: this.item.pathPrefix,
					thumbnailPrefix: this.item.thumbnailPrefix,
					folder : this.item.folder,
					id: "fileurl",
					storeRelative: this.item.storeRelative,
					useContainerPath: this.item.useContainerPath
				}
			]
		};
		this.form.Form = new Packages.Form.Form(this.form);
		return this.form.Form.MakeForm();
	}
	/*******************************************************************************
	 * SaveFormItem - returns the data for this form item
	 ******************************************************************************/
	this.SaveFormItem = function() {
		this.form.Form.Submit();
		if(this.data.fileurl != "") return this.data.fileurl;
		if(this.data.texturl != "") return this.data.texturl;
		return "";
	};
};Package("Form.Upload").Item = function(item) {
    this.item = item;
	this.textvar = GetTextRef(this);
	/*******************************************************************************
	 * MakeFormItem - creates the form item
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html = "<input type='file' id='" + item.elemid + "'>";
		return html;
	};
	/*******************************************************************************
	 * SaveFormItem - Extracts the base64 encoded dump file selected on the hard disc and converts it
	 * to a dump which is restored
	 ******************************************************************************/
	this.SaveFormItem = function() {
		var target = document.getElementById(item.elemid);
        var file = target.files[0];
		if(file == null) return null;
    
		this.filename = file.name;
		
		var reader = new FileReader();
		
		reader.onload = this._Upload.bind(this);
		
		reader.readAsDataURL(file);
		
		return item.path + "/" + this.filename;
    };
	/*******************************************************************************
	 * _Upload - Gets the file in base64 and sends it via a post to the server
	 *
	 * param - evt : the event object
	 ******************************************************************************/
	this._Upload = function(evt) {
		var path = item.path;
		if(path.length > 0) path += "/";
		
		Packages.Library.$.UploadFile({
			base64: evt.target.result.substr(evt.target.result.indexOf(',') + 1),
			filepath: path + this.filename,
			filename: this.filename,
			callback: item.callback,
			finishedMessage: item.finishedMessage
		});
    };
};Package("Form.Utils").File = function(item) {
    this.item = item;
	this.textvar = GetTextRef(this);
	
	// Defaults
	if(this.item.thumbnailPrefix == null) this.item.thumbnailPrefix = "";
	
	// Define constants
	var FM_DRAG = 2;
	var FM_CLICK=1;
	var FM_FILE=1;
	var FM_FOLDER=2;
	
	// Collapse icons
	var COLLAPSE_NONE = "-"; // No children
	var COLLAPSE_CLOSED = "+"; // Closed
	var COLLAPSE_OPEN = "o"; // Open
	
	// Create tab interface for showing dialogues
	this.tabinterface = new Packages.Library.TabInterface({
		id: "fm_dialogues",
		fullscreen: 1,
		windowed: 1,
		showHeader: 0
	});
	
	this.pathHistory = [];

	/******************************
	* FileMgr:
	* 		selected: currently selected file / folder
	* 			file: filename.type
	* 			path: path to this file
	* 			fullpath (if a folder, the path including this folder)
	* 			mode: FM_FILE or FM_FOLDER
	* 		drop: where the file was dropped
	* 			(as selected)
	* 		mode: what state we are in
	* 			CLICK: default
	* 			DRAG: awaiting a drop somewhere
	* 		parent: the object that owns this util
	* 		extensionFilter : (optional) array of extensions to be displayed
	*
	*
	*****************************/
	var FileMgr = {mode: FM_CLICK, parent: item.Item};
	this.textFileMgr = GetTextRef(FileMgr);

	/*******************************************************************************
	 * MakeFormItem - gets the HTML to create this form item
	 * 
	 * returns the HTML markup for this form item
	 ******************************************************************************/
	this.MakeFormItem = function() {
		var html = "";
		
		// Store internal copy of filtered extension
		if(this.filteredExtension == null) this.filteredExtension = item.extensionFilter;
		
		// If there is no extension already filtered, add tabs to select a file type
		// Create tabs of file extensions
		if(item.extensionFilter == null) {
			var _this = this;
			html += Packages.Library.$.CreateMenuInterface({
				idprefix: item.elemid + "filemgrext",
				showLastClicked: 1,
				menuitems: [
					{
						name: "All",
						action: function() {_this.SetExtensionFilter(null)}
					},
					{
						name: "Webpages",
						action: function() {_this.SetExtensionFilter(["htm", "html", "mhtm"])}
					},
					{
						name: "Images",
						action: function() {_this.SetExtensionFilter(["jpg", "gif", "jpeg", "png", "ico"])}
					},
					{
						name: "Text",
						action: function() {_this.SetExtensionFilter(["txt"])}
					},
					{
						name: "XCSV",
						action: function() {_this.SetExtensionFilter(["xcsv", "csv"])}
					},
					{
						name: "JS and CSS",
						action: function() {_this.SetExtensionFilter(["js", "css"])}
					},
					{
						name: "Logs",
						action: function() {_this.SetExtensionFilter(["log", "lastlog"])}
					}
				]
			});
		}
		
		html += "<div class='fm_dialog'>" + this.tabinterface.Initialise() + "<\/div>";
		if(this.item.select != null && this.item.select != 0) {
			// Add select none button
			html += "<button onclick='" + this.textvar + ".Reload({selectnone: 1})'>Select None<\/button>";
			html += "<button onclick='" + this.textvar + ".Reload({selectall: 1})'>Select All<\/button>";
		}
		FileMgr.callbacks = item.callbacks;
		
		if(this.lastShownFolderPath== null) {
			// Set defaults
			this.lastShownFolderPath = "";
		}
		
		this.cachedCookies = Packages.Library.$.GetCookies({});
		
		var folderArea = "<div id='" + item.elemid + "_fmgr_container' class='fm_foldercontainer'>" + this.GetNestedList(item.pathPrefix).html + "<\/div>";
		var fileArea = "<div id='" + item.elemid + "_fmgr_filecontainer' class='fm_filecontainer'>"
							+ this.ShowFolderListing(this.lastShownFolderPath)
						+	"<\/div>";
		//html += "<table id='" + item.elemid + "_fm'><tr>";
		//html += "<td style='width:200px'>" + folderArea + "<\/td>";
		//html += "<td>" + fileArea + "<\/td>";
		//html += "<\/tr><\/table>";
		
		html += Packages.Library.UI.$.CreateSplitTable({
			areaContentA: folderArea,
			areaContentB: fileArea,
			startSize: 20,
			noScroll: 1
		})
		
		html = "<div id='" + item.elemid + "_fm' class='fm_div_inner'>" + html + "<\/div>";
		
		return html;
	};
	/*******************************************************************************
	 * Reload - reloads the filemgr
	 *
	 * param - options : optional hash of options, may contain:
	 * 				selectnone : 1 ignore previously selected items, 0 (default) as before
	 * 				selectall : 1 select all items in the selected folder, 0 (default) after before
	 ******************************************************************************/
	this.Reload = function(options) {
		if(options == null) options = {};
		
		this.cachedCookies = Packages.Library.$.GetCookies({});
		
		if(options.selectnone == 1) {
			// Action selectnone, empty array
			this.item.selectedFiles.splice(0, this.item.selectedFiles.length);
		}
		
		// Reload left folder list
		document.getElementById(item.elemid + "_fmgr_container").innerHTML = this.GetNestedList(item.pathPrefix).html;
		
		// Reload files pane, if we have one yet
		if(this.lastShownFolderPath == null) return;
		this.ShowFolderListing(this.lastShownFolderPath);
		
		if(options.selectall == 1) {
			for(var i = 0; i < this.itemsInFolder.length; i++) {
				this.item.selectedFiles.push(this.itemsInFolder[i]);
			}
			
			this.Reload(); // Update listing to show every box ticked
		}
	};
	/*******************************************************************************
	 * GetNestedList - creates an interactive file manager - recursive
	 *
	 * param - path : path from the current browser path, to the files container
	 *
	 * * folder array of hashes, each one is a file of the form
	 *          name : the filename
	 *          type : either 'file' or 'folder'
	 *          subfolders : (if folder) is an array of files in this structure
	 *
	 * returns a hash of results:
	 * 		html : the HTML markup for this form
	 * 		containsFileCount : count of files in this folder, and all child folders
	 * 		fileCount : number of files in just the folder
	 ******************************************************************************/
	this.GetNestedList = function(path) {
		
		var pathInfo = this.GetPathInformation(path);
		var prefixid = pathInfo.pathPrefixId;
		var breadcrumbs = pathInfo.breadcrumbs;
		var fullPath = pathInfo.fullPath;
		var folder = pathInfo.folder;
		path = pathInfo.path;
		
		var fileCount = 0;
		var containsFileCount = 0;
		var itemsHtml = "";
		// If this is the ROOT level, display a link to the root folder
		if(path == "") {
			itemsHtml += "<li class='fm_folder fm_folder_name' "
						+	"onclick = \"" + this.textvar + ".ShowFolderListing('" + path + "')\""
					+	">"
						+	"<input " +
								"type='radio' " +
								"name='" + item.elemid + "selFolder' " +
								"id='" + "selFolder_" + prefixid + "' " +
								"style='display:none' " +
								"class='selFolder' " +
							">"
						+	" . "
					+	"<\/li>";
		}
		// Displays folders
		for(var i = 0; i < folder.length; i++) {
			if(folder[i].type == "file") {
				// File
				var lastdot = folder[i].name.lastIndexOf(".");
				var type = folder[i].name.substr(lastdot + 1);
				if(this.filteredExtension == null || Packages.Library.$.Contains({array: this.filteredExtension, item: type.toLowerCase()})) {
					// Count if type matches
					fileCount ++;
				}
			} else {
				// Folder
				var lastdot = folder[i].name.lastIndexOf(".");
				var tidyname = folder[i].name;
				if(folder[i].inherited != null) tidyname += '*';
				var checkid = prefixid + "fm_check_" + fullPath + folder[i].name
				var selectedid = prefixid + "fm_selected_" + folder[i].name
				var collapseid = prefixid + "fm_collapse_" + folder[i].name
				var collapseIcon = this.AddFolderCollapse(collapseid) + " ";
				var folderContentHtml = "";
				if(Packages.Library.$.FindArrayItem({array: folder[i].subfolders, path: "type", value: "folder"})) {
					// Only display folder expand / collapse if it has child folders
					folderContentHtml += collapseIcon;
				} else {
					// Hide it, but keep same size
					folderContentHtml += "<span style='color: #888888' class='fm_foldercollapse_icon'> " + COLLAPSE_NONE + " <\/span> ";
				}
				// For selecting
				if(item.selectfolder == 1) folderContentHtml += "<input type='radio' " +
														"onchange=\"" + this.textvar + ".OnSelectChange('" + path + folder[i].name + "', '" + selectedid + "')\" " +
														"name='" + this.item.elemid + "fm_selectradio' " +
														"id='" + selectedid + "' " +
														"class='fm_fileselect' " +
														"value='" + selectedid + "' " +
														this.WasFileSelected(fullPath + folder[i].name) + ">";
				if(item.selectfolder == 2) folderContentHtml += "<input type='checkbox' " +
														"onchange=\"" + this.textvar + ".OnSelectChange('" + path + folder[i].name + "')\" " +
														"id='" + selectedid + "' " +
														"class='fm_fileselect' " +
														this.WasFileSelected(fullPath + folder[i].name) + ">";
				// For showing current folder
				folderContentHtml += "<input " +
							"type='radio' " +
							"name='" + item.elemid + "selFolder' " +
							"id='" + "selFolder_" + prefixid + tidyname + ".' " +
							"style='display:none' " +
							"class='selFolder' " +
						">"
				folderContentHtml += "<span "
									+	"class='fm_folder_name' "
									+	Packages.Library.$.MakeElemFileDropable({path: path + folder[i].name + "/"})
								+ ">"
									+ tidyname
								+ "<\/span>";
				var nestedFolder = this.GetNestedList(path + folder[i].name + "/");
				folderContentHtml += "<span class='fm_folder_count'>" + nestedFolder.fileCount + " / " +
					Packages.Library.$.PadString({
						value: nestedFolder.containsFileCount,
						chr: "&nbsp;",
						length: 4,
						right: 1
					}) + "<\/span>";
				var folderHtml = "<span "
								+	"class='fm_folder_item' "
								+	"onMouseUp=\"return " + this.textvar + ".OnMouseUp(&quot;" + path + "&quot;, &quot;" + folder[i].name + "&quot;, " + FM_FOLDER + ")\" "
								+	"onMouseDown = \"" + this.textvar + ".OnMouseDown(&quot;" + path + "&quot;, &quot;" + folder[i].name + "&quot;, " + FM_FOLDER + "); "
								+		"return " + this.textvar + ".ShowFolderListing(&quot;" + path + folder[i].name + "/&quot;)\""
							+	">"
								+	"<span "
									+	"id=\"" + prefixid + folder[i].name + "\" " 
									+	"class='filenotselected fm_fileitem' "
								+	">"
									+	folderContentHtml
								+	"<\/span>"
							+	"<\/span>";
				folderHtml += "<input type='checkbox' class='fm_foldercollpase' id='" + collapseid + "' " + this.GetExpandState(collapseid) + ">";
				folderHtml += nestedFolder.html;
				itemsHtml += Packages.Library.$.CreateDragAndDropItem({
					html: folderHtml,
					item: folder[i],
					tag: "li",
					type: "fm_item",
					classname: "fm_folder",
					adjustDOM: 0,
					callback: this.DragAndDropCallback.bind(this),
					data: {
						path: path,
						name: folder[i].name,
						type: FM_FOLDER,
						fullpath: path + folder[i].name
					},
					containerData: {
						path: path + folder[i].name,
						type: FM_FOLDER
					}
				});
				containsFileCount += nestedFolder.containsFileCount;
			}
		}
		var html = "<ul class='fm_folders' id='" + prefixid + "'>"
					+	itemsHtml
				+	"<\/ul>";
		return {
			html: html,
			fileCount: fileCount,
			containsFileCount: containsFileCount + fileCount
		};
	};
	/*******************************************************************************
	 * ShowFolderListing - Displays this folder in the file listing pane
	 *
	 * param - path : path from the current browser path, to the files container
	 * param - options : hash of options, may contain:
	 * 		addToHistory : 1 (default) add to history, 0 don't
	 *
	 * * folder array of hashes, each one is a file of the form
	 *          name : the filename
	 *          type : either 'file' or 'folder'
	 *          subfolders : (if folder) is an array of files in this structure
	 *
	 * Pushes the HTML into the file section (if it exists) and returns it
	 ******************************************************************************/
	this.ShowFolderListing = function(path, options) {
		if(options == null) options = {};
		
		this.lastShownFolderPath = path;
		if(options.addToHistory != 0) {
			if(this.pathHistory.length == 0 || this.pathHistory[this.currentHistory] != path) {
				// Clear any forward history
				this.pathHistory.splice(this.currentHistory + 1, (this.pathHistory.length - this.currentHistory - 1));
				
				// Add path to history
				this.pathHistory.push(path);
				
				// Reset history position
				this.currentHistory = this.pathHistory.length - 1;
			}
		}
		
		var pathInfo = this.GetPathInformation(path);
		var prefixid = pathInfo.pathPrefixId;
		var breadcrumbs = pathInfo.breadcrumbs;
		var fullPath = pathInfo.fullPath;
		var folder = pathInfo.folder;
		path = pathInfo.path;
		
		this.itemsInFolder = [];
		
		// Select folder
		var elem = document.getElementById("selFolder_" + prefixid);
		if(elem) elem.checked = true;
		
		
		var showThumbnails = 1;
		var html = "";
		
		// Show back / forward button
		html += "<span "
				+	"onclick=\"" + this.textvar + ".GoBack();\" "
				+	"class='fm_backforward fm_back mbutton' "
			+	">"
				+	"&lt;"
			+	"<\/span>";
		html += "<span "
				+	"onclick=\"" + this.textvar + ".GoForward();\" "
				+	"class='fm_backforward fm_forward mbutton' "
			+	">"
				+	"&gt;"
			+	"<\/span>";
		// Show locator
		var _this = this;
		html += "<span "
				+	"class='fm_locator' "
				+	"onclick=\"" + _this.textvar + ".ShowFolderListing('/')\" "
			+	">"
				+	" / "
			+	"<\/span>";
		var locatorpath = "";
		foreach(breadcrumbs, function(breadcrumb) {
			locatorpath += breadcrumb + "/";
			html += "<span "
					+	"class='fm_locator' "
					+	"onclick=\"" + _this.textvar + ".ShowFolderListing('" + locatorpath + "')\" "
				+	">"
					+	breadcrumb + " / "
				+	"<\/span>";
		})
		html += "<hr>";
		
		// Create listing
		var filesHtml = "";
		for(var i = 0; i < folder.length; i++) {
			if(folder[i].type=="file") {
				var checkid = prefixid + "fm_collapse_" + fullPath + folder[i].name
				var selectedid = prefixid + "fm_selected_" + fullPath + folder[i].name
				var lastdot = folder[i].name.lastIndexOf(".");
				var tidyname = folder[i].name;
				var type = folder[i].name.substr(lastdot + 1);
				if(this.filteredExtension == null || Packages.Library.$.Contains({array: this.filteredExtension, item: type.toLowerCase()})) {
					if(folder[i].inherited == 1) tidyname += '*';
					if(folder[i].inherited == 2) tidyname += '**';
					var fileHtml = "";
					// href = pathPrefix+folder[i].name 
					fileHtml += "<div id='" + prefixid + fullPath + folder[i].name + "' " +
								"class='" + this.textvar + ".fm_fileitem'>";
					fileHtml += "<a href='#' " +
								"class='fm_file_a' " +
								"onDblClick = \"" + this.textvar + ".OnDblClick(&quot;" + path + "&quot;, &quot;" + folder[i].name + "&quot;, " + FM_FILE + ")\" " +
								"onMouseDown = \"return " + this.textvar + ".OnMouseDown(&quot;" + path + "&quot;, &quot;" + folder[i].name + "&quot;, " + FM_FILE + ")\" " +
								"onMouseUp=\"return " + this.textvar + ".OnMouseUp(&quot;" + path + "&quot;, &quot;" + folder[i].name + "&quot;, " + FM_FILE + ")\" " +
								"onClick = \"return " + this.textvar + ".OnClick(&quot;" + path + "&quot;, &quot;" + folder[i].name + "&quot;, " + FM_FILE + ")\" " +
							">";
					if(item.select == 1) fileHtml += "<input type='radio' " +
														"onclick=\"" + this.textvar + ".OnSelectChange(&quot;" + path + folder[i].name + "&quot;, &quot;" + selectedid + "&quot;)\" " +
														"name='" + this.item.elemid + "fm_selectradio' " +
														"id=\"" + selectedid + "\" " +
														"class='fm_fileselect' " +
														"value=\"" + selectedid + "\" " +
														this.WasFileSelected(fullPath + folder[i].name) + ">";
					if(item.select == 2) fileHtml += "<input type='checkbox' " +
														"onchange=\"" + this.textvar + ".OnSelectChange(&quot;" + path + folder[i].name + "&quot;, &quot;" + selectedid + "&quot;)\" " +
														"id=\"" + selectedid + "\" " +
														"class='fm_fileselect' " +
														this.WasFileSelected(fullPath + folder[i].name) + ">";
					this.itemsInFolder.push(path + folder[i].name);
					// Thumbnail not used (image size too big)
					if(showThumbnails == 1) {
						// Work out the background colour
						var coltype = type.toUpperCase();
						coltype += "AAA"; // Ensure minimum length of 3
						var col = "rgb(" + Math.floor((coltype.charCodeAt(0) - 65) * 9 + 10) + "," + Math.floor((coltype.charCodeAt(1) - 65) * 9 + 10) + "," + Math.floor((coltype.charCodeAt(2) - 65) * 9 + 10) + ")";
						fileHtml += "<span class='fm_thumb' style='background: -webkit-radial-gradient(25px 15px, circle, " + col + ", #000);'>";
						if(folder[i].name.match(/\.(jpg|gif|jpeg|png|ico)$/i)) {
							fileHtml += "<img src='" + this.item.thumbnailPrefix + fullPath + folder[i].name + "' class='fm_thumb' alt=''/>";
						} else {
							fileHtml += "<span style='font-weight: bold; color:#ccc;'>" + type.toUpperCase() + "<\/span>";
						}
						fileHtml += "<\/span>";
					}
					fileHtml += "<span class='fm_filename'>" + tidyname.replace(/\./, " .") + "<\/span>";
					fileHtml += "<\/a><\/div>";
					
					filesHtml += Packages.Library.$.CreateDragAndDropItem({
						html: fileHtml,
						item: folder[i],
						tag: "li",
						type: "fm_item",
						classname: "fm_file",
						adjustDOM: 0,
						data: {
							path: path,
							name: folder[i].name,
							type: FM_FILE,
							fullpath: path
						}
					});
				}
			}
		}
		html += "<ul "
				+	"class='fm_folders' "
				+	"id='" + prefixid + "'"
				+	Packages.Library.$.MakeElemFileDropable({path: path})
			+	">"
				+	filesHtml
			+	"<\/ul>";
		var elem = document.getElementById(item.elemid + "_fmgr_filecontainer");
		if(elem) {
			elem.innerHTML = html;
		}
		
		return html;
	};
	/*******************************************************************************
	 * GetPathInformation - Fetches the information for the specified path
	 *
	 * param - path : the path, in the form folder1/folder2/folder3 from item.pathPrefix
	 *
	 * returns a hash as follows:
	 * 		breadcrumbs : array of folders in this path
	 * 		pathPrefixId : the id for this path depth (used on various controls)
	 * 		fullPath : the full path, item.pathPrefix + path
	 * 		folder : array of entries in the folder
	 * 		path : the corrected path
	 ******************************************************************************/
	this.GetPathInformation = function(path) {
		path = path.replace(/^\//, "").replace(/\/$/, ""); // Remove leading / trailing slash
		
		var breadcrumbs = path.split(/\//);
		if(path == "") breadcrumbs = [];
		
		var folder = this.item.folder;
		if(breadcrumbs.length > 0) {
			var subfolder = Packages.Library.$.GetSubObjectFromBreadcrumbs({
				parentArray: this.item.folder,
				path: breadcrumbs,
				idkey: "name",
				subarraykey: "subfolders"
			});
			if(subfolder != null) folder = subfolder.subfolders;
		}
		
		return {
			breadcrumbs: breadcrumbs,
			pathPrefixId: item.elemid + "path." + path.replace(/\//g, ".") + (path.length > 0 ? "." : ""),
			fullPath: item.pathPrefix + (path == "" ? "" : path + "/"),
			folder: folder,
			path: (path == "" ? "" : path + "/")
		};
	};
	/*******************************************************************************
	 * GetExpandState - determines the expanded state of each checkbox
	 *
	 * param - collapseid : unique id for this collapse item
	 *
	 * return - the initial state, and the onclick code that triggers the store of
	 * the data
	 ******************************************************************************/
	this.GetExpandState = function(collapseid) {
		// Get previous state from cookie
		var selected = this.cachedCookies.expandedFolders;
		if(selected == null || typeof(selected) != "object") selected = {};
		
		var checked = "";
		var safeId = collapseid.replace(/[^A-Za-z0-9]/g, "_");
		if(selected[safeId] == 1) checked = " checked='checked'";
		
		return checked;
	};
	/*******************************************************************************
	 * WasFileSelected - determines if the file was selected or not
	 *
	 * Looks at the this.item.selectedFiles list to see if it contains this file
	 * 
	 * param - filepath : path + filename of file
	 * 
	 * returns checked if it was selected, or "" if it wasn't
	 ******************************************************************************/
	this.WasFileSelected = function(filepath) {
		if(Packages.Library.$.Contains({array: this.item.selectedFiles, item: filepath})) return "checked='checked'";
		return "";
	};
	/*******************************************************************************
	 * OnSelectChange - toggles the selected state of the file
	 *
	 * param - filepath : the filepath we are selecting / deselecting
	 * param - id : id of checkbox element
	 ******************************************************************************/
	this.OnSelectChange = function(filepath, id) {
		// Get current state
		var state = Packages.Library.$.GetCheckboxState({elemid: id});
		
		// Are we in single select mode?
		if(this.item.select == 1 || this.item.selectfolder == 1) {
			// Yes, so start by removing everything
			this.item.selectedFiles.splice(0, this.item.selectedFiles.length);
		}
		
		if(state == 1) {
			// If selecting, add to the selectedFiles list
			// (check not already in it)
			if(!Packages.Library.$.Contains({array: this.item.selectedFiles, item: filepath})) this.item.selectedFiles.push(filepath);
		} else {
			// Deselecting, so remove
			for(var i = 0; i < this.item.selectedFiles.length; i++) {
				if(this.item.selectedFiles[i] == filepath) {
					this.item.selectedFiles.splice(i, 1);
					break;
				}
			}
		}
		return true; // Browser accept the changed state
	};
	/*******************************************************************************
	 * SetExtensionFilter - updates the extension filters
	 * 
	 * param - filteredExtension : new filteredExtension
	 ******************************************************************************/
	this.SetExtensionFilter = function(filteredExtension) {
		this.filteredExtension = filteredExtension;
		
		this.Reload();
	}
	/*******************************************************************************
	 * AddFolderCollapse - creates the html markup for the [-] buttons and ties the
	 * onclick actions to the checkbox
	 * 
	 * param - id : the id of the checkbox
	 * 
	 * returns the html markup
	 ******************************************************************************/
	this.AddFolderCollapse = function(id) {
		var html = "";
		html += "<span class='fm_foldercollapse_icon' onclick=\"return " + this.textvar + ".FolderCollapseClick(this, '" + id + "')\">" + (this.GetExpandState(id) ? COLLAPSE_OPEN : COLLAPSE_CLOSED) + "<\/span>";
		return html;
	};
	/*******************************************************************************
	 * FolderCollapseClick - the onclick action for the [-] buttons
	 * 
	 * param - item : the elem of the little button
	 * param - id : the id of the checkbox
	 ******************************************************************************/
	this.FolderCollapseClick = function(item, id) {
		var elem = document.getElementById(id);
		if(elem.checked) {
			elem.checked = false;
			item.innerHTML = COLLAPSE_CLOSED;
		} else {
			elem.checked = true;
			item.innerHTML = COLLAPSE_OPEN;
		}
		
		var checked = (elem.checked ? 1 : 0);
		
		// Get cookies
		var selected = Packages.Library.$.GetCookies({}).expandedFolders;
		if(selected == null || typeof(selected) != "object") selected = {};
		
		var safeId = id.replace(/[^A-Za-z0-9]/g, "_");
		selected[safeId] = checked;
		
		// Set cookie
		Packages.Library.$.SetCookie({hash: {
			expandedFolders: selected
		}});
		
		return false; // Browser ignore click
	};
	/*******************************************************************************
	 * DisplayContextMenu - event handler when the right mouse button pressed
	 *
	 * Displays a list of the plugins that support this type of file / folder
	 *
	 * param - path : the path to this item
	 * param - file :  the file name
	 *
	 * returns false to disable browsers menu
	 ******************************************************************************/
	this.DisplayContextMenu = function() {
		
		if(FileMgr.selected == null) return null;
		var contextitems;
		if(FileMgr.selected.mode == FM_FOLDER) contextitems = [
			{key: "Folder", name: "Folder Options"},
			{key: "Create", name: "Create"}
		];
		if(FileMgr.selected.mode == FM_FILE  ) contextitems = [
			{key: "File", name: "File Options"},
			{key: "Create", name: "Create"}
		];
		if(contextitems == null) return null;
		
		var pathInfo = this.GetPathInformation(FileMgr.selected.path);
		var breadcrumbs = pathInfo.breadcrumbs;
		
		var elem = document.createElement('div');
		document.body.appendChild(elem);
		elem.className = "fm_contextMenu";
		elem.style.left = (Packages.Library.$v.Mouse.x + 5) + "px";
		elem.style.top = (Packages.Library.$v.Mouse.y + 5) + "px";
		
		elem.innerHTML = Packages.Library.$.CreateMenu(
			Packages.Library.$.CreateMenuFromSubscribers({
				menuTypes: contextitems,
				execOptions: FileMgr,
				dragAndDrop: {
					type: "favourite",
					adjustDOM: 0,
					data: {
						path: FileMgr.selected.path,
						file: FileMgr.selected.file,
						fullpath: FileMgr.selected.path + (FileMgr.selected.mode == FM_FOLDER ? FileMgr.selected.file : "")
					}
				}
			})
		);
		
		FileMgr.contextMenu = {elem: elem};
		
		this.closeContextMouseUpEvent = Packages.Library.$.EventSubscribe({eventname: "mouseup", callback: this.CloseContextMenu.bind(this)});
		
		// Stop propogation
		window.event.preventDefault();
		window.event.stopPropagation();
		return false;
	};
	/*******************************************************************************
	 * DragAndDropCallback - callback when something is dropped
	 * 
	 * param - options : see Packages.Library.$.CreateDragAndDropItem
	 ******************************************************************************/
	this.DragAndDropCallback = function(options) {
		var itemPath = options.itemData.path;
		var itemName = options.itemData.name;
		var containerPath = options.containerData.path;
		
		FileMgr.selected = {
			path: itemPath,
			file: itemName
		};
		FileMgr.drop = {
			path: containerPath
		};
		
		// Was this a copy or a move?
		if(window.event.ctrlKey) {
			this.FireActionCallback("ctrlmove");
		} else {
			// Ensure the file was either moved to somewhere other than where it started
			// And if the dragged to location is inside of the item folder, then this is stupid, don't do it
			var droppedPath = FileMgr.drop.path + "/";
			var itemPath = FileMgr.selected.path + FileMgr.selected.file;
			if(droppedPath.indexOf(itemPath) == 0) return;
			
			this.FireActionCallback("move");
		}
	}
	/*******************************************************************************
	 * OnMouseUp - event handler when the mouseUp action is done on the nav
	 *
	 * If a drag operation is in progress, will complete the action
	 *
	 * If the button was the right mouse button, will display context menu
	 *
	 * returns true or false depending on whether the browser should handle the response
	 ******************************************************************************/
	this.OnMouseUp = function(path, file, mode) {
		FileMgr.selected = {
			path: path,
			file: file,
			mode: mode,
			fullpath: path + (mode == FM_FOLDER ? file : "")
		};
		
		// Is it a right mouse button?
		if(window.event.button > 0) return this.DisplayContextMenu();
		
		// Stop additional on mouse events
		return false;
	};
	/*******************************************************************************
	 * OnDblClick - event handler when the mouse double clicks on something
	 * 
	 * param - path : the path to this item
	 * param - file :  the file name
	 * param - mode : FM_FILE or FM_FOLDER
	 ******************************************************************************/
	this.OnDblClick = function(path, file, mode) {
		// Was this the right mouse button?
		if(window.event.button > 0) return false;
		
		// It was the left mouse button
		window.open(path + file, "_blank");
		
		return false;
	};
	/*******************************************************************************
	 * OnClick - event handler when the mouse single clicks on something
	 * 
	 * param - path : the path to this item
	 * param - file :  the file name
	 * param - mode : FM_FILE or FM_FOLDER
	 ******************************************************************************/
	this.OnClick = function(path, file, mode) {
		// Was this the right mouse button?
		if(window.event.button > 0) return false;
		
		// It was the left mouse button
		return true;
	};
	/*******************************************************************************
	 * CloseContextMenu - closes context menu
	 ******************************************************************************/
	this.CloseContextMenu = function() {
		if(this.closeContextMouseUpEvent != null) Packages.Library.$.EventUnsubscribe({eventsubscription: this.closeContextMouseUpEvent});
		if(FileMgr.contextMenu != null) {
			var elem = FileMgr.contextMenu.elem;
			if(elem != null) {
				// Hide menu first (as onclick still needs to fire)
				elem.style.display = "none";
				setTimeout(function() {
					// After a delay, clean up and remove the element
					document.body.removeChild(elem);
				}, 1000);
			}
			FileMgr.contextMenu = null;
		}
	};
	/*******************************************************************************
	 * OnMouseDown - event handler when the mouse button goes down
	 * 
	 * param - path : the path to this item
	 * param - file :  the file name
	 * param - mode : FM_FILE or FM_FOLDER
	 * param - breadcrumbs : breadcrumb array trail to this file
	 ******************************************************************************/
	this.OnMouseDown = function(path, file, mode) {
		// Close context menu
		this.CloseContextMenu();
		
		// Tell browser to ignore mouse click
		return false;
	};
	/*******************************************************************************
	 * GoBack - goes back one pathHistory item
	 ******************************************************************************/
	this.GoBack = function() {
		if(this.pathHistory.length == 0) return;
		
		this.currentHistory --;
		if(this.currentHistory < 0) {
			this.currentHistory = 0;
			return;
		}
		
		this.ShowFolderListing(this.pathHistory[this.currentHistory], {addHistory: 0});
	};
	/*******************************************************************************
	 * GoForward - goes forward one pathHistory item
	 ******************************************************************************/
	this.GoForward = function() {
		if(this.pathHistory.length == 0) return;
		
		this.currentHistory ++;
		if(this.currentHistory >= this.pathHistory.length) {
			this.currentHistory = this.pathHistory.length - 1;
			return;
		}
		
		this.ShowFolderListing(this.pathHistory[this.currentHistory], {addHistory: 0});
	};
	/*******************************************************************************
	 * FireActionCallback - calls the specified callback
	 *
	 * param - callback : the callback
	 ******************************************************************************/
	this.FireActionCallback = function(callback) {
		if(FileMgr.callbacks == null) return;
		
		if(FileMgr.callbacks[callback] == null) return;
		
		FileMgr.callbacks[callback](FileMgr);
		
		// Close any open dialogue boxes
		this.tabinterface.CloseAll();
	};
};var scrap = 
[{name:"Button",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"Checkbox",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"ChoiceForm",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"ColourSelector",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"Date",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"FileMgr",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}},{name:"MenuItems",type:'folder',subfolders:[{name:"Clone",type:'folder',subfolders:[{name:"menuitem.js",type:'file', params:{}}]},{name:"Delete",type:'folder',subfolders:[{name:"menuitem.js",type:'file', params:{}}]},{name:"NewFile",type:'folder',subfolders:[{name:"menuitem.js",type:'file', params:{}}]},{name:"NewFolder",type:'folder',subfolders:[{name:"menuitem.js",type:'file', params:{}}]},{name:"Properties",type:'folder',subfolders:[{name:"menuitem.js",type:'file', params:{}}]},{name:"Rename",type:'folder',subfolders:[{name:"menuitem.js",type:'file', params:{}}]},{name:"Upload",type:'folder',subfolders:[{name:"menuitem.js",type:'file', params:{}}]}]}]},{name:"Form.js",type:'file', params:{}},{name:"HTML",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"Hidden",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"Label",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"MultiForm",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"NestedForm",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"Options",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"RadioButtons",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"RichText",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"SelectBox",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"Text",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"TextArea",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"URL",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"Upload",type:'folder',subfolders:[{name:"Item.js",type:'file', params:{}}]},{name:"Utils",type:'folder',subfolders:[{name:"File.js",type:'file', params:{}}]}];
Package("FileType.mhtm.EditProperties.Editor").Property = function() {}
/*******************************************************************************
 * GetChoiceForm - gets the form items for this property
 *
 * returns the form items
 ******************************************************************************/
Packages.FileType.mhtm.EditProperties.Editor.GetChoiceForm = function() {
    return [
        {
            type: "Text",
            name: "Edited By",
            id: "editor"
        }
    ];
};Package("Panels").$p = "FileType/mhtm/"; // Path to the FileType packages (root)
Package("Attributes").$p = "FileType/mhtm/"; // Path to the FileType packages (root)

/**************************************************************
 * Include - gets the packages required by this package
 *
 * param - hash : (optional) if specified contains a page hash, otherwise uses the filecontent
 *
 * returns the include array of packages required
 **************************************************************/
Package("FileType.mhtm.$.view").Include = function(hash) {
// Disabled during v4 -> v5 upgrade
	return [];
};/**************************************************************
 * CreatePanelHost - creates a panel host and returns the placeholder markup
 *
 * param - hostname : the hostname
 *
 * returns the markup containing a macro for this panel host
 **************************************************************/
Packages.FileType.mhtm.$.CreatePanelHost = function(hostname) {
	if(Packages.FileType.mhtm.$i.view.hostNames[hostname] == null) {
		// Create blank area if doesn't exist already
		Packages.FileType.mhtm.$i.view.hostNames[hostname] = [];
	}
	return "<%host_" + hostname + "%>";
};
/**************************************************************
 * AppendToPanelHost - appends the specified HTML to the specified panel host
 *
 * param - hostname : the hostname
 * param - html : additional html
 **************************************************************/
Packages.FileType.mhtm.$.AppendToPanelHost = function(hostname, html) {
	hostname = hostname.replace(/^host_/, ""); // Used to store host_ prefix
	if(Packages.FileType.mhtm.$i.view.hostNames[hostname] == null) {
		// Create blank area if doesn't exist already - in case host not added yet
		Packages.FileType.mhtm.$i.view.hostNames[hostname] = [];
	}
	Packages.FileType.mhtm.$i.view.hostNames[hostname].push(html);
};
/*************************************************************************************************
 * GetRenderCount - gets the render count for the page - used to stop out of date setTimeout's keeping going
 *
 * returns the current rendercount
 ************************************************************************************************/
Package("FileType.mhtm").$.GetRenderCount = function() {
	return Packages.FileType.mhtm.$i.view.rendercount;
};
/*************************************************************************************************
 * DefaultPanelProto - Gets the default panel prototype containing the raw methods that should be
 * included in a panel
 * 
 * returns the prototype
 ************************************************************************************************/
Package("FileType.mhtm").$.DefaultPanelProto = function() {
	var proto = function() {
		this.Display = function() {
			return "<div class='mhtmhiddenerror'>Unknown Panel Type<\/div>";
		};
		this.Update = function() {};
	};
	return proto;
};
/*************************************************************************************************
 * DefaultAttributeProto - Gets the default attribute prototype containing the raw methods that should be
 * included in a attribute
 * 
 * returns the prototype
 ************************************************************************************************/
Package("FileType.mhtm").$.DefaultAttributeProto = function() {
	var proto = function() {
		this.Initialise = function() {};
		this.Update = function() {};
	};
	return proto;
};

/*************************************************************************************************
 * ReplaceDomainPath - Where possible, replaces URLs that start with $containerpath with an on domain URL
 *
 * param - content : content to search in
 * 
 * returns modified content
 ************************************************************************************************/
Packages.FileType.mhtm.$.ReplaceDomainPath = function(content) {
	// Determine is we are on a HTML domain
	var pagePath = Packages.Library.$.GetPagePath({});
	
	// If we have HTML in current page path, this will not work
	if(pagePath.match(/HTML/)) return content;
	
	// Assumed domain points to the masterpath/HTML/
	content = content.replace(/(["'])[^\$"']*\$containerpath/g, "$1");
	
	return content;
};

/**************************************************************
 * GetInteractiveMode - gets the current interactivemode
 *
 * returns:
 * 		0 - non interactive
 * 		1 - interactive
 **************************************************************/
Package("FileType.mhtm.$.view").GetInteractiveMode = function() {
	return Packages.FileType.mhtm.$i.view.interactivemode;
}
Packages.FileType.mhtm.$c.LoadContentAreasRegExp = "<(.+?)class=([\"'])([^'\"]+)['\"]([^>]*)></";// Package: FileType.mhtm
Package('FileType.mhtm').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [../../../../../../../../../../System/Software/JS/FileType/mhtm.$jscb] as classpath [FileType.mhtm]


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [../../../../../../../../System/Software/JS/FileType/mhtm.$jscb] as classpath [FileType.mhtm]


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [../../../../../../System/Software/JS/FileType/mhtm.$jscb] as classpath [FileType.mhtm]


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [../../../../System/Software/JS/FileType/mhtm.$jscb] as classpath [FileType.mhtm]


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [../../System/Software/JS/FileType/mhtm.$jscb] as classpath [FileType.mhtm]


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb] as classpath [FileType.mhtm]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/_lib/Init.js] as classpath [FileType.mhtm] 
this.textVar = GetTextRef(this);
if(Packages.FileType.mhtm.$i.view == null) {
    Packages.FileType.mhtm.$i.view = this;
}

// Legacy, merge Packages.Panel into Packages.FileType.mhtm.Panels
for(var x in Packages.Panels) {
    if(Packages.FileType.mhtm.Panels[x] != null) continue; // Skip where already exists
    Packages.FileType.mhtm.Panels[x] = Packages.Panels[x];
}
// And set Packages.Panels to be a reference
Packages.Panels = Packages.FileType.mhtm.Panels;

// Legacy, merge Packages.Attributes into Packages.FileType.mhtm.Attributes
Package("FileType.mhtm.Attributes");
for(var x in Packages.Attributes) {
    if(Packages.FileType.mhtm.Attributes[x] != null) continue; // Skip where already exists
    Packages.FileType.mhtm.Attributes[x] = Packages.Attributes[x];
}
// And set Packages.Panels to be a reference
Packages.Attributes = Packages.FileType.mhtm.Attributes;

// Set up defaults
this.pSubFolder;
this.page = {};
// Edit modes
// 0 - preview
// 1 - standard edit
// 2 - advanced edit
// 3 - template cutter
// 4 - setup page
this.editmode = 0;
this.pTemplate;
this.pRedirect;
this.pLastEdit;
this.pLastEditor;
this.masterpages = [];
this.hostNames = {};
this.pNonJS = "";
this.pNonJSCSS = "";
this.pNonJSHeadHTML = "";
this.error = [];
this.loaded = 0;
this.checkPageCompleteChecks = 0;
this.headHashIds = [];
this.rendercount = 0; // Increments by 1 each time a render is done - used to track out of date objects and setTimeouts
this.renderComplete = 0;
this.nearestMaster = null;
this.wasNode = Packages.Library.$.WasPageBuiltWithNode();

/*************************************************************************************************
* InitMhtm - Called from bootloaders to ensure Mhtm fully initialised before use
************************************************************************************************/
this.InitMhtm = function() {
    if(this.initDone == 1) return;
    this.initDone = 1;
    if(typeof(user) == 'undefined') user = '';
    if(typeof(pass) == 'undefined') pass = '';
    
    // Is this a supported browser?
    if(!Packages.Library.$.IsSupportedBrowser()) {
        this.SafetyCatchShowNonJS();
        return;
    }
    Packages.Library.$.LogInfo({mesg: "Supported browser detected", location: "MHTM Display", type: "Info", level: 8});
    
    // Is edit mode enabled
    if(this.editon == null) this.editon = 0;
    
    /********** Paths **************
     * pOffset - relative - masterpath to current folder
     * pBaseOffset - absolute - start of URL (could be multiple parents deep) to HTML
     * pXOffset - relative - masterpath to HTML folder
     * pSubOffset - relative - HTML to current folder
     ********** Folder listings ****
     * pFolders - masterpath (or as for pContainerFolders if browse permission disabled)
     * pContainerFolders - HTML container folder
     * pXViewFolders - as for pContainerFolders except extracted from pFolders and not pContainerFolders so will include '.abc' hidden files
     * pSubFolder - current folder
     * ****************************/
    this.pSubOffset = pOffset.replace(/(.*?)HTML/, "");
    this.pSubFolder = Packages.Library.$.GetSubFolder({container: pContainerFolders, offset: this.pSubOffset});
    this.pXOffset = pOffset.replace(/HTML(.*)$/, "HTML");
    this.pXViewFolders = Packages.Library.$.GetSubFolder({container: pFolders, offset: this.pXOffset});
    // pBaseOffset must start at the container HTML position, and must be relative to the current position
    // Count number of subfolders in pSubOffset to calculate how many ../../ we need
    var path = this.pSubOffset.replace(/^\//, "").replace(/\/$/, "");
    var foldersDepth = path.split(/\//);
    var depth = foldersDepth.length;
    if(path.match(/System\/Apps\//)) depth -= 3; // Account for System/Apps/AppName/
    if(this.pSubOffset.length == 0) depth = 0;
    this.pBaseOffset = "";
    for(var d = 0; d < depth; d++) {
        this.pBaseOffset += "../";
    }
    
    Packages.Library.$.LogInfo({mesg: "PagePath: [" + Packages.Library.$.GetPagePath({}) + "]" +
                                    ", pXOffset: [" + this.pXOffset + "]" +
                                    ", pOffset: [" + pOffset + "]" +
                                    ", pBaseOffset: [" + this.pBaseOffset + "]" +
                                    ", pSubOffset: [" + this.pSubOffset + "]" +
                                    ", path: [" + path + "]" +
                                    ", foldersDepth: [" + depth + "]",
                                location: "mhtm.Display", type: "Tracking", level: 8});
    
    // Get files
    // Get the file (page) content
    var filecontent = Packages.Library.$.GetCurrentFile();
    if(filecontent.match(/page/)) {
        var pagecontent = filecontent.substring(filecontent.indexOf("var page = ") + 11);
        eval(this.textVar + ".page = " + pagecontent);
    }
    this.ObjectisePage();
    Packages.Library.$.LogInfo({mesg: "Fetched page data", location: "MHTM Display", type: "Info", level: 8});
}

// Adding file [System/Software/JS/FileType/mhtm.$jscb/_lib/Legacy.js] as classpath [FileType.mhtm] 
/*************************************************************************************************
 * ObjectisePage - Calls Legacy Update on the page (also called from edit)
 ************************************************************************************************/
this.ObjectisePage = function() {
    this.LegacyUpdate(this.page, this.textVar + ".page");
}
/*************************************************************************************************
 * ObjectiseAttribute - takes an ordinary 'persistent data hash' and adds the 'view' attribute to it
 * that contains the methods for this page attribute.
 *
 * param - attribute : the attribute to objectise
 *
 * no return, the panel is altered
 ************************************************************************************************/
this.ObjectiseAttribute = function(attribute) {
	var AttributeContainer = Packages.FileType.mhtm.Attributes;
	Packages.Library.$.Objectise({
		containerPackage: Packages.Attributes,
		data: attribute,
		objectType: "view",
		superClass: Packages.FileType.mhtm.$.DefaultAttributeProto()
	});
	
	if(this.editon > 0 && Packages.Attributes[attribute.type] != null && Packages.Attributes[attribute.type].edit != null) {
		// Add the edit object
		attribute.edit = new Packages.Attributes[attribute.type].edit(attribute);
	}
	
	if(this.editon > 0) {
		if(attribute.view.AttributeVersion == null) {
			// Legacy
			if(this.editon > 0 && AttributeContainer[attribute.type] != null && AttributeContainer[attribute.type].edit != null) {
				// Add the edit object
				attribute.edit = new AttributeContainer[attribute.type].edit(attribute);
			}
		} else {
			attribute.edit = attribute.view; // Shared object
		}
	}
};
/*************************************************************************************************
 * ObjectisePanel - takes an ordinary 'persistent data hash' and adds the 'view' attribute to it
 * that contains the methods for this panel.
 *
 * param - panel : the panel to objectise
 * param - panelKey : unique, but reproduceable (consistent) panelKey
 *
 * no return, the panel is altered
 ************************************************************************************************/
this.ObjectisePanel = function(panel, panelKey) {
	var PanelContainer = Packages.FileType.mhtm.Panels;
	
	Packages.Library.$.Objectise({
		containerPackage: PanelContainer,
		data: panel,
		objectType: "view",
		superClass: Packages.FileType.mhtm.$.DefaultPanelProto()
	});
	
	if(this.editon > 0) {
		if(panel.view.PanelVersion == null) {
			// Legacy
			if(this.editon > 0 && PanelContainer[panel.type] != null && PanelContainer[panel.type].edit != null) {
				// Add the edit object
				panel.edit = new PanelContainer[panel.type].edit(panel);
			}
		} else {
			panel.edit = panel.view; // Shared object
		}
	}
	
	panel.view.panelKey = panelKey;
};
/*************************************************************************************************
 * LegacyUpdate - takes an page (or master page) hash and ensures it is in the most up to date
 * format
 *
 * Also adds the live objects
 *
 * param - legacyHash : the old hash
 * param - hashName : the direct name of this hash (for strings)
 ************************************************************************************************/
this.LegacyUpdate = function(hash, hashName) {
	if(hash == null) return;
	if(hash.$noDump == null) hash.$noDump = {};
	if(hash.$noDump.objectisedChildren == 1) return; // Done already
	if(hash.Version == null) hash.Version = 2;
	
	if(hash.Version < 3) {
		// Update hash to version 3
		hash.Version = 3;
		
		// Change natilda escape characters to backslashes
		this.ChangeNatToBS(hash);
		
		// Move page areas to own hash 'Areas'
		if(hash.Areas == null) hash.Areas = {};
		for(var area in hash) {
			if(area.match(/^v/)) {
				if(hash.Areas[area] == null && hash[area] != null) {
					hash.Areas[area] = hash[area];
					delete hash[area];
				}
			}
		}
		
		// Rename all panel types to camel case
		var types = ["Text", "Menu", "Tag", "Image", "Inherit", "Html", "Seasonal", "SocialMedia", "W3c", "SiteMap", "RichText", "ExternalItem", "PanelMenu", "Download", "Table", "Gallery", "Minitable", "LastEdited"];
		for(var area in hash.Areas) {
			for(var i = 0; i < hash.Areas[area].length; i++) {
				for(var j = 0; j < types.length; j++) {
					if(hash.Areas[area][i].type == types[j].toLowerCase()) hash.Areas[area][i].type = types[j];
				}
				
				// Put all data into data hash
				hash.Areas[area][i].data = {};
				for(var d in hash.Areas[area][i]) {
					if(d == "title" || d == "type" || d == "folded" || d == "foldable" || d == "url" || d == "data") continue;
					hash.Areas[area][i].data[d] = hash.Areas[area][i][d];
					delete hash.Areas[area][i][d];
				}
				
				// Check basic data exists
				if(hash.Areas[area][i].title == null) hash.Areas[area][i].title = "";
				if(hash.Areas[area][i].url == null) hash.Areas[area][i].url = "";
				if(hash.Areas[area][i].linebreak == null) hash.Areas[area][i].linebreak = 1;
				if(hash.Areas[area][i].folded == null) hash.Areas[area][i].folded = 0;
				if(hash.Areas[area][i].foldable == null) hash.Areas[area][i].foldable = 0;
			}
		}
		
		// Add new areas with inherit in
		hash.Areas.vTopNavArea = [{type: "Inherit"}];
		
		// Create new Attributes standard
		// Rename page attributes to 'Attributes', note capital A
		hash.Attributes = {};
		
		if(hash.attributes == null) hash.attributes = [];
		
		// Rename all attribute types to camel case
		var types = {"page_css": "CSS", "page_title": "Title", "googleanalytics": "GoogleAnalytics", "js": "JS"};
		for(var i = 0; i < hash.attributes.length; i++) {
			var attribute = hash.attributes[i];
			if(types[attribute.type] == null) continue;
			var Attribute = {};
			
			// Put all data into data hash
			Attribute.data = {};
			Attribute.type = types[attribute.type];
			for(var d in attribute) {
				if(d == "type" || d == "data") continue;
				Attribute.data[d] = attribute[d];
			}
			
			// Put data into each attribute
			if(Attribute.type == "CSS") {
				Attribute.data.styles = hash.css.style;
				delete hash.css;
				Attribute.data.additionalcss = hash.pagecss;
				delete hash.pagecss;
			}
			if(Attribute.type == "Title") {
				Attribute.data.title = hash.title;
				delete hash.title;
			}
			
			hash.Attributes[types[attribute.type]] = Attribute;
		}
		
		delete hash.attributes; // old
	}
	if(hash.Version < 4) {
		// Upgrade to version 4
		hash.Version = 4;
		
		for(var area in hash.Areas) {
			for(var i = 0; i < hash.Areas[area].length; i++) {
				var panel = hash.Areas[area][i];
				
				panel.Wrappers = [];
				
				// Move various old positioned items to their new location
				if(panel.title != "" && panel.title != null) {
					panel.Wrappers.push({
						wrapper: "Title",
						title: panel.title,
						foldable: panel.foldable,
						folded: panel.folded
					});
				}
				delete panel.title; delete panel.foldable; delete panel.folded;
				if((panel.extmargin != "" && panel.extmargin != null) ||
				   (panel.margin != "" && panel.margin != null) ||
				   (panel.linebreak != 1 && panel.linebreak != null) ||
				   (panel.backgroundColour != "" && panel.backgroundColour != null)) {
					panel.Wrappers.push({
						wrapper: "Styling",
						margin_px: panel.extmargin,
						padding_px: panel.margin,
						background_color_hash: panel.backgroundColour
					});
				}
				panel.display = (panel.linebreak ? "block" : "inline-block"),
				delete panel.extmargin; delete panel.margin; delete panel.linebreak; delete panel.backgroundColour;
				if(panel.url != "" && panel.url != null) {
					panel.Wrappers.push({
						wrapper: "URL",
						url: panel.url
					});
				}
				delete panel.url;
				if(panel.textOverlay != "" && panel.textOverlay != null) {
					panel.Wrappers.push({
						wrapper: "Overlay",
						textOverlay: panel.textOverlay
					});
				}
				delete panel.textOverlay;
				if(panel.scheduled != "" && panel.scheduled != null) {
					panel.Wrappers.push({
						wrapper: "Schedule",
						scheduled: panel.scheduled
					});
				}
				delete panel.scheduled;
			}
		}
	}
	
	if(hash.Version < 4.2) {
		// Upgrade to version 4.2
		hash.Version = 4.2;
		
		for(var area in hash.Areas) {
			for(var i = 0; i < hash.Areas[area].length; i++) {
				var panel = hash.Areas[area][i];
				
				if(panel.Wrappers == null) continue;
				
				// Rename all of the the Wrappers type members to type
				for(var w = 0; w < panel.Wrappers.length; w++) {
					panel.Wrappers[w].type = panel.Wrappers[w].wrapper;
					delete panel.Wrappers[w].wrapper;
				}
			}
		}
	}
	
	if(hash.Version < 5) {
		// Upgrade to version 5
		hash.Version = 5;
		
		for(var area in hash.Areas) {
			for(var i = 0; i < hash.Areas[area].length; i++) {
				var panel = hash.Areas[area][i];
				
				// Upgrade 'button' panels to be image panels with an overlay
				if(panel.type == "Button") {
					if(panel.Wrappers == null) panel.Wrappers = [];
					
					panel.type = "Image"; // Change to an image
					
					// Add classes in wrapper
					panel.Wrappers.unshift({
						type: "Classes",
						classes: ["mbutton"],
						customClasses: "panel_button"
					});
					// Move settings to an overlay wrapper
					panel.Wrappers.unshift({
						type: "Overlay",
						textOverlay: [
							{
								refcode: "ButtonText",
								tag: panel.data.tag,
								text: panel.data.text,
								horizalign: panel.data.horizalign,
								vertalign: panel.data.vertalign
							}
						]
					});
					// Delete old data from panel
					delete panel.data.tag;
					delete panel.data.text;
					delete panel.data.horizalign;
					delete panel.data.vertalign;
				}
			}
		}
	}
	
	// Objectise
	for(var attribute in hash.Attributes) {
		this.ObjectiseAttribute(hash.Attributes[attribute], hashName + ".Attributes." + attribute);
	}
	for(var area in hash.Areas) {
		for(var i = 0; i < hash.Areas[area].length; i++) {
			this.ObjectisePanel(hash.Areas[area][i], area + "_" + i);
		}
	}
	hash.$noDump.objectisedChildren = 1;
};

// Adding file [System/Software/JS/FileType/mhtm.$jscb/_lib/LoadMasterpages.js] as classpath [FileType.mhtm] 
/*************************************************************************************************
 * LoadMasterpages - STAGE2 - Callback when Display has loaded all extra content
 *
 * param - callback : callback when masterpages loaded
 ************************************************************************************************/
this.LoadMasterpages = function(callback) {
    this.AfterMasterpagesLoadCallback = callback;
    
    Packages.Library.$.LogInfo({mesg: "Stage 2 started", location: "Stage 2", type: "Info", level: 8});
    
    // Load all master pages
    
    // Get offset from container path
    var paths = Packages.Library.$.Split({value: pContainerPath, splitter: "/"});
    paths.unshift(""); // Put top level folder at start of list
    var masterpagefiles = [];
    
    var currentPath = "";
    for(var i = 0; i < paths.length; i++) {
        currentPath += paths[i] + (paths[i] == "" ? "" : "/");
        var filepath = currentPath + "!master.mhtm";
        if(Packages.Library.$.GetPathToBase({filepath: "$containerpath/" + filepath}) == Packages.Library.$.GetPageURL({})) continue;
        if(Packages.Library.$.FileExist({folder: pContainerFolders, filepath: filepath})) {
            // Place at start of array, so loaded first, master pages closest to the requested page are processed last
            var pathToMaster = "$containerpath/" + filepath;
            var queryParams = {};
            if(Packages.Library.$.GetQuery({attr: "app"}) != 1) queryParams = {'req-noinherit': 1};
            masterpagefiles.unshift({filepath: pathToMaster, mode: 'LT_TEXT', queryParams: queryParams});
            this.nearestMaster = pathToMaster;
            // console.log("Path: " + pathToMaster + "\n");
        }
    }
    
    this.fileLoaderMasterpages = new Packages.Library.DynamicLoad({
        callback: new Function(this.textVar + ".LoadMasterPageIncludes()"),
        displayLoadingIcon: 0
    });
    this.fileLoaderMasterpages.Request(masterpagefiles);
    Packages.Library.$.LogInfo({mesg: "Stage 2 complete - sent requests for master pages", location: "Stage 2", type: "Info", level: 8});
};
/*************************************************************************************************
 * LoadMasterPageIncludes - STAGE3 - Callback when the page has loaded the raw content
 ************************************************************************************************/
this.LoadMasterPageIncludes = function() {
    Packages.Library.$.LogInfo({mesg: "Stage 3 started", location: "Stage 3", type: "Info", level: 8});
    // get all the master files
    //  - clean out all the non-existant ones and leave an array of existing files in order
    var includes = [];
    var fileobjs = this.fileLoaderMasterpages.GetFiles();
    // Master pages start at 1, because the page is 0
    var r = 1;
    for(var i = 0; i < fileobjs.length; i++) {
        var filecontent = this.fileLoaderMasterpages.GetFileContent(fileobjs[i]);
        if(filecontent == null) continue;
        if(filecontent != 404) {
            try {
                // Found good page
                var pagecontent = filecontent.substring(filecontent.indexOf("var page = ") + 11);    
                eval("this.masterpages[" + r + "] = " + pagecontent);
                includes = includes.concat(Packages.FileType.mhtm.$.view.Include(this.masterpages[r]));
                r++;
            } catch(e){
                // do nothing
            }
        }
    }
    // Get any additional includes needed for masterpages
    var include = new Packages.Library.Include(includes, new Function(this.textVar + ".ConfirmMasterPages()"))
    include.Fetch();
    Packages.Library.$.LogInfo({mesg: "Stage 3 complete - looking for master page includes", location: "Stage 3", type: "Info", level: 8});
};
/*************************************************************************************************
 * ConfirmMasterPages - STAGE4 - Callback when all pages (masterpages) are loaded with includes
 ************************************************************************************************/
this.ConfirmMasterPages = function() {
    Packages.Library.$.LogInfo({mesg: "Stage 4 started", location: "Stage 4", type: "Info", level: 8});
    //LegacyUpdate and objectise each MasterPage
    for(var i = 0; i < this.masterpages.length; i++) {
        this.LegacyUpdate(this.masterpages[i], this.textVar + ".masterpages[" + i + "]");
    }
    this.AfterMasterpagesLoadCallback();
};

// Adding file [System/Software/JS/FileType/mhtm.$jscb/_lib/Render.js] as classpath [FileType.mhtm] 
/*************************************************************************************************
 * RenderPage - renders the webpage - also called after 'preview' pressed
 *
 * param - options : hash of options, may contain
 * 			forceReload: 1 force a reload of all content, 0 (default) don't
 ************************************************************************************************/
this.RenderPage = function(options) {
    if(options == null) options = {};
    // Check if a previous render is still waiting
    if(this.renderInProgress == 1) {
        Packages.Library.$.LogInfo({mesg: "Skipped, previous render still running", location: "Render Page", type: "Warning", level: 6});
        return;
    }
    this.renderInProgress = 1;
    
    this.forceReload = options.forceReload;
    if(this.forceReload == null) this.forceReload = 0;
    
    this.interactivemode = (this.editmode > 0 && this.editmode < 4) ? 0 : 1;
	this.interactivemenumode = this.editmode > 0 ? 0 : 1;
    
    // Reset page information for a clean load
    // Clean up any previous renders
    this.pageHtml = this.pageTemplate;
    this.pageHtmlSetElems = [];
    this.hostNames = {};
    
    // Find all 'mhtm_render' elements left over from a previous instance
    this.headHashIds = [];
    this.renderElems = [];
    if(Packages.Library.$c.IsNode != 1) {
        this.renderElems = document.getElementsByClassName("mhtm_render");
    }
    this.headerHTML = "";
    
    this.defaultArea = null;
    
    Packages.Library.$.LogInfo({mesg: "Started", location: "Render Page", type: "Info", level: 8});
    this.rendercount++; // Increment page render by 1
    
    // Create messenger for a render (replaces previous)
    this.renderMessages = new Packages.Library.Messages();
    
    // Do a preload of all panels and attributes to give them the opportunity to
    // set anything up before everything else. Iterate through all panels and
    // attributes and call Preload on each. Preload is called before any other
    // attribute and panel is rendered to enable anything to be set up
    var panelsAndAttributes = this.GetPanelsAndAttributes();
    foreach(panelsAndAttributes, function(item) {
        if(item.object.view.Preload != null) {
            item.object.view.Preload();
        }
    });
    
    // ******** FIRE OFF PAGE ATTRIBUTES
    Packages.Library.$.LogInfo({mesg: "Firing masterpage attributes", location: "Render Page", type: "Info", level: 8});
    // Do this in reverse order (so the most distant pages are done first - and closer masterpages are done first)
    for(var r = this.masterpages.length-1;r >= 0; r--) {
        // back compatability - TBD, not needed, done in main update
        masterpage = this.masterpages[r];
        if(typeof(masterpage) == "undefined") {
            masterpage = {};
        }
        if(masterpage.Attributes == null) masterpage.Attributes = {};
        // Update
        this.masterpages[r] = masterpage;
    
        // Load the page attributes
        // Master file first
        for(var attribute in masterpage.Attributes) {
            try {
                masterpage.Attributes[attribute].view.Initialise();
            } catch(e) {this.LogError("MasterPage load fail", "Failed to load master page attribute '" + attribute + "', with error '" + e.message + "'")};
        }
    }
    Packages.Library.$.LogInfo({mesg: "Firing page attributes", location: "Render Page", type: "Info", level: 8});
    // Page last - so it can override everything
    for(var attribute in this.page.Attributes) {
        try {
            this.page.Attributes[attribute].view.Initialise();
        } catch(e) {this.LogError("Page load fail", "Failed to load page attribute '" + attribute + "', with error '" + e.message + "'")};
    }
    
    // ******** RENDER THE PAGE AREAS
    Packages.Library.$.LogInfo({mesg: "Render page areas", location: "Render Page", type: "Info", level: 8});
    this.LoadAreasIn();
    
    // Add Site notices
    Packages.Library.$.LogInfo({mesg: "Getting site notices", location: "Render Page", type: "Info", level: 8});
    var sitenotices = "";
    
    // Add Cookie policy - see EU Cookie Law
        /****************************
         * CookieUsage - EVENT - finds objects that use Cookies
         *
         * param - none, empty hash
         *
         * returns a hash containing:
         * 			id : a Cookie specific ID to ensure the same message does not appear twice
         * 			description : user facing description of cookie
         * 			party : 1 first, 2 analytical, 3 third
         **************************/
    var responses = Packages.Library.$.EventFire({eventname: "CookieUsage", data: {}});
    if(responses.length > 0) {
        var cookieMessages = {};
        for(var i = 0; i < responses.length; i++) {
            if(responses[i] != null) {
                cookieMessages[responses[i].id] = responses[i];
            }
        }
        var details = "";
        details += "<h2>Details about the construction of this webpage<\/h2>";
        details += "The EU Cookie directive requires all websites hosted in the EU to declare their cookie usage on each page that uses them. This area contains information about how cookies are used, and also information about how other systems are used in the construction of this web page.";
        details += "<h3>Cookie Usage<\/h3>";
        details += "The content using Cookies on this page is:";
        details += "<ul>";
        for(var id in cookieMessages) {
            var cookie = cookieMessages[id];
            var party = ['', 'is using First party', '* may be using Analytical', '* may be using Third party'];
            details += "<li>'" + cookie.description + "' " + party[cookie.party] + " cookies. " + (cookie.detail != null ? cookie.detail : "") + "<\/li>";
        }
        details += "</ul>";
        details += "*May be using cookies - since this content is hosted by a third party, we can not give details on their cookie usage.<br>";
        details += "For more information about Cookies on this site please visit the <a href='http://web.marloweos.com/Information/Cookies_and_Privacy.mhtm'>Cookie and Privacy Page<\/a><br>";
        details += "Note: This cookie usage is specific to the current page, other pages on this site may be using cookies for other purposes.<br>";
        details += "<h3>JavaScript Usage<\/h3>";
        details += "This page also relies on JavaScript to create the interactive content on this page. If JavaScript is disabled, a plain non-interactive page will be available.<br>";
        details += "<h3>HTML Usage<\/h3>";
        details += "This page is natively HTML 4.01 Transitional, but uses some HTML5 and CSS3 elements to enhance the experience on browsers that support them. Browsers that can not support the features should still provide the content, but may lack some styles and effects newer browsers can offer.";
        details += "<h3>TroubleShooting<\/h3>";
        details += "There is an automatic failsafe that renders a plain HTML page if JavaScript is disabled, or if the page takes longer than a few seconds to render. If an issue occurs and you are unable to get a page to view, please contact the web master.";
        sitenotices += "<span>";
        sitenotices += Packages.Library.$.CreateFoldArea({
        	title: "This page uses Cookies to improve your experience, details...",
        	content: details,
        	foldable: 1,
        	folded: 1
        });
        sitenotices += "<\/span>";
    }
    this.SetElemContent({elemid: "SiteNotices", content: sitenotices});
    
    this.CheckPageComplete();
    
    if(this.editmode == 3) {
        document.getElementById("page_template").onclick = Packages.FileType.mhtm.$i.edit.TemplateEditItem.bind(Packages.FileType.mhtm.$i.edit);
    }
    
    Packages.Library.$.LogInfo({mesg: "Complete - checking", location: "Render Page", type: "Info", level: 6});
};
/************************************************************************************************
 * CheckPageComplete - Verifies that all objects that use the 'ready' flag, are set to 1
 *
 * The ready flag is used to allow any object to communicate whether it has
 * finished loading, or not
 *
 **********************************************************************************************/
this.CheckPageComplete = function() {
    Packages.Library.$.LogInfo({mesg: "Starting", location: "Check Page Complete", type: "Info", level: 8});
        /****************************
         * Mhtm_RenderComplete - EVENT - checks all objects to find out whether they have finished rendering or not
         *
         * param - none, empty hash
         *
         * returns a hash of
         * 			ready : 0 if not ready or 1 if ready
         * 			info : information about what its waiting for
         **************************/
    var responses = Packages.Library.$.EventFire({eventname: "Mhtm_RenderComplete", data: {}});
    var ready = 1; // so prove me wrong
    this.checkPageCompleteChecks++;
    var waitingContent = ""; // string log of what we are waiting for
    for(var i = 0; i < responses.length; i++) {
        if(responses[i] != null && responses[i].ready != null && responses[i].ready == 0) {
            ready = 0;
            waitingContent += responses[i].info + ", ";
        }
    }
    if(this.checkPageCompleteChecks > 100) { // 100
        // Show what we have - this is NOT the end of the world, it just means some elements may be missing
        // But they will appear later
        ready = 1;
        this.LogMessage("Page Render Expired", "Page took longer than 2 seconds to render, missing:[" + waitingContent + "]");
    }
    if(ready == 1) {
        // Delete any elems we do not need that are left overs from previous renders
        // Use a normal array, renderElems is a DOMarray that is edited as elems deleted
        var normalArray = []; for(var i = 0; i < this.renderElems.length; i++) {normalArray.push(this.renderElems[i])};
        for(var i = 0; i < normalArray.length; i++) {
            var elem = normalArray[i];
            if(Packages.Library.$.Contains({array: this.headHashIds, item: elem.id})) {
                // Do not remove this one
            } else {
                elem.parentNode.removeChild(elem);
            }
        };
        
        // Ready - show page
        Packages.Library.$.LogInfo({mesg: "All content ready", location: "Check Page Complete", type: "Info", level: 8});
        
        // Log page complete
        Packages.Library.$.LogInfo({mesg: "PAGE COMPLETE", location: "Page", level: 8});
        this.LogMessage("Page Render Complete", "Page render completed in " + this.checkPageCompleteChecks + " attempts.");
        
        // Mark page as loaded
        this.loaded = 1;
        this.renderComplete = 1;
        this.renderInProgress = 0;
        
        // Write our host content to position
        for(var hostName in this.hostNames) {
            var hostContent = "";
            // Fetch all content for this host
            for(var i = 0; i < this.hostNames[hostName].length; i++) {
                hostContent += this.hostNames[hostName][i];
            }
            // Replace macro with content (may be blank)
            var replaced = Packages.Library.$.Replace({
                content: this.pageHtml,
                search: 		"<%host_" + hostName + "%>",
                replacement: 	hostContent
            });
            if(replaced != null) this.pageHtml = replaced;
        }
        
        // Do any waiting pageHtml modifications
        for(var i = 0; i < this.pageHtmlSetElems.length; i++) {
            this.pageHtmlSetElems[i].noRetry = 1;
            this.SetElemContent(this.pageHtmlSetElems[i]);
        }
        
        if(Packages.Library.$c.IsNode) {
            // Notify node we are all done
            Packages.NodeJS.$.NodeRenderComplete({
                headHTML: this.headerHTML,
                bodyHTML: this.editorHtml + "<div id='page_template'>" + this.pageHtml + "<\/div>"
            });
            
            // Live will be called in the browser, when rendered there
        } else {
            // Render performed in the browser
            document.getElementById('page_template').innerHTML = this.pageHtml;
            
            // And call live now
            this.CallLiveOnAllPanelsAndAttributes();
        }
        
        // See if edit needs to reload bar
        if(this.editon == 1) Packages.FileType.mhtm.$i.edit.GenerateEditbar();
    } else {
        // Not ready - schedule a call back to try again
        Packages.Library.$.LogInfo({mesg: "Waiting Page Render: Not ready, waiting for '" + waitingContent + "', wait count: " + this.checkPageCompleteChecks, location: "Check Page Complete", level: 6});
        setTimeout(this.CheckPageComplete.bind(this), 20);
    }
};
/*************************************************************************************************
 * LoadAreasIn - loads the content for all of the divs with a classname of 'contentarea'
 ************************************************************************************************/
this.LoadAreasIn = function() {
    // Keep a record of IDs found to avoid duplicates
    this.foundPageAreaElems = {};
    // Chrome found 2 BodyArea's in the HTML template, and attempted to load content twice!
    var foundAreaIds = {};
    // Iterate through all of our divs, skipping any that don't have the right classname
    var contentAreas = this.pageHtml.match(new RegExp(Packages.FileType.mhtm.$c.LoadContentAreasRegExp, "g"));
    for(var c = 0; c < contentAreas.length; c++) {
        if(!contentAreas[c].match(new RegExp(Packages.FileType.mhtm.$c.LoadContentAreasRegExp))) continue; // Should be impossible to fail
        var tagAndLeadIn = RegExp.$1;
        var quote = RegExp.$2;
        var classNamesString = RegExp.$3;
        var leadOut = RegExp.$4;
        
        // Skip if this is not a content area class
        if(!classNamesString.match(/contentarea/)) continue;
        
        // Find areaname in the class
        var classNames = classNamesString.split(/ /);
        var areaname = null;
        foreach(classNames, function(className) {
            if(className.match(/area_(.+)/)) {
                areaname = RegExp.$1;
            }
        });
        
        // If there is an ID, the classname is 'contentarea' and we haven't already loaded it
        if(areaname != null && foundAreaIds[areaname] == null) {
            
            // Mark area as loaded
            foundAreaIds[areaname] = 1;
            
            var areaHtml;
            // Correct div found, attempt to load content
            var _editmode = this.editmode; // store in case of errors
            if(Packages.Library.$c.DebugLevel >= 2) {
                areaHtml = this.LoadArea(areaname);
            } else {
                try{
                    areaHtml = this.LoadArea(areaname);
                } catch(e) {
                    this.LogError("MHTM View - LoadArea", "Failed in " + areaname + ". Error:'" + e.message + "', callstack: " + Packages.Library.$.GetCallStack({ex: e}))
                }
            }
            
            // Put the content into the page html
            this.pageHtml = Packages.Library.$.Replace({
                content: this.pageHtml,
                search: 		"<" + tagAndLeadIn + "class=" + quote + classNamesString + quote + leadOut + "></",
                replacement: 	"<" + tagAndLeadIn + "class=" + quote + classNamesString + quote + leadOut + ">" + areaHtml + "</"
            });
            
            this.editmode = _editmode; // retrieve
        }
        i++;
    }
    var defaultArea = this.GetDefaultArea();
    if(defaultArea != null
    && this.page.Areas[defaultArea] != null
    && this.foundPageAreaElems[defaultArea]) {
        // The template is set up with a default area
        for(var area in this.page.Areas) {
            if(this.foundPageAreaElems[area] != 1) {
                // Move panels that do not have an owning area to the default area
                for(var i = 0; i < this.page.Areas[area].length; i++) {
                    var panel = this.page.Areas[area][i];
                    // Skip inherit panels
                    if(panel.type == "Inherit") continue;
                    this.page.Areas[defaultArea].push(panel);
                }
                delete this.page.Areas[area];
            }
        }
    }
    
    // Iterate through all panels and attributes and call FillTemplate on each
    // FillTemplate is called after the template has been built with all Display returned content in it.
    // For complex panels, a callback is needed and so the Display returned data is just a placeholder.
    // FillTemplate ensures that the callback code is fired after the placeholders are in the pageHtml
    // ready to accept filling.
    var panelsAndAttributes = this.GetPanelsAndAttributes();
    foreach(panelsAndAttributes, function(item) {
        if(item.object.view.FillTemplate != null) {
            item.object.view.FillTemplate();
        }
    });
};
/*************************************************************************************************
 * LoadArea - loads the content for all of the empty div elements in the specified element
 *
 * param - id : elementid to search in
 ************************************************************************************************/
this.LoadArea = function(id) {
    if(id == null) return null; // Ensure we have an id
    if(id.length == 0) return null; // Ensure it has a value
    
    var name = "v" + id; // Get the name of the variable in 'page.Areas.xxx'
    
    // We either have an empty div (that'll need an area) or we have an area in our page for it
    var html = this.LoadPanelsIn(id, this.page, name, 0);
    
    // Make alterations to location of items
    html = Packages.FileType.mhtm.$.ReplaceDomainPath(html);
    
    return html;
};
/*************************************************************************************************
 * LoadPanelsIn - loads the entire content of the specified area and returns the markup for it
 * Also called from the Table Panel
 *
 * param - containerId : the elem id for the area container
 * param - page : Either 'page' or 'masterpages[i]'
 * param - varName : the variable name for the data array that holds the panels for this area (as text to be evaled)
 * param - inMaster : 0 (default) not in a master page, > 0 indicates depth of master page (for recursion)
 *
 * returns the markup for this area
 ************************************************************************************************/
this.LoadPanelsIn = function(containerId, page, varName, inMaster) {
    // Record this elem as existing
    this.foundPageAreaElems[varName] = 1;
    
    if(page.Areas[varName] == null) {
        // No contents defined for this area
        // We can load in default content (inherit)
        page.Areas[varName] = [{
            type: "Inherit"
        }];
    }
    var panels = page.Areas[varName];
    var html = "";
    var i = 0;
    while(i < panels.length) {
        var panel = panels[i]; // the panel object
        var panelhtml = ""; // html for the specific panel
        if(panel.type == "Inherit" && (inMaster + 1) < this.masterpages.length) {	
            //Inherit from master
            var _editmode = this.editmode; // store
            this.editmode = 0; // Set to non edit
            panelhtml += this.LoadPanelsIn(containerId, this.masterpages[inMaster + 1], varName, inMaster + 1);
            this.editmode = _editmode; // retrieve
        } else {
            // Ordinary panel
            if(panel.view != null) {
                panel.id = Packages.Library.$.GetUniqueId({});
                panelhtml = this.GetPanelDisplay(panel, containerId, i, inMaster);
                if(panel.applySystemWrappers != 0) panelhtml = "<div class='panelcontent'><div class='" + panel.type + "'>" + panelhtml + "<\/div><\/div>";
            }
        }
        
        panelhtml = "<div class='"
                    +   containerId.toLowerCase() + "_" + i + "_" + inMaster + " " // Use in Live to replace content
                +   "'>"
                    +   panelhtml
                +   "</div>";
        
        if(panel.type != "Inherit") {
            panelhtml = Packages.Library.Wrappers.$.WrapHtml({
                wrappers: panel.Wrappers,
                html: panelhtml,
                subOptions: {
                    interactivemode: this.interactivemode
                }
            });
        }
        
        // Create data object to pass to subscribers, html passed by reference
        var data = {html: panelhtml, panel: panel, containerId: containerId, varName: varName, index: i, array: panels, inMaster: inMaster};
        Packages.Library.$.EventFire({eventname: "mhtm_EncapsulatePanel", data: data});
        panelhtml = data.html; // Pull changed panelhtml from data
        
        html += panelhtml;
        i++;
    }
    html = this.EncapsulateAreaEdit(html, varName, containerId, panels);
    return html;
};
/*************************************************************************************************
 * GetPanelDisplay - calls the Display method on the specified panel
 *
 * param - panel : the panel to display
 * param - containerId : the container id (area id)
 * param - panelId : the panel id in container
 * param - inMaster : inheritance, 0 for page, 1+ for inherited pages
 *
 * returns the html for this panel
 ************************************************************************************************/
this.GetPanelDisplay = function(panel, containerId, panelId, inMaster) {
    var html;
    if(Packages.Library.$c.DebugLevel >= 2) {
        html = panel.view.Display();
    } else {
        try {
            html = panel.view.Display();
        } catch(e) {
            this.LogError("MHTM View - GetPanelDisplay", "Panel Render Failed in " + containerId + "[" + panelId + "] '" + panel.type + "'. Error:'" + e.message + "'")
        };
    }
    if(html == null) {
        this.LogError("MHTM View - GetPanelDisplay", "Panel Render Failed in " + containerId + "[" + panelId + "] '" + panel.type + "'. Error: no html returned")
        var panelError = panel.view.error;
        if(panelError == null) panelError = "";
        return "<div class='mhtmhiddenerror mhtm_livereload_" + containerId.toLowerCase() + "_" + panelId + "_" + inMaster + "'><b>Error Generating Panel</b><br>" + panelError + "<\/div>";
    } else {
        return Packages.Library.$.ConvertToHTML({str: html});
    }
}
/*************************************************************************************************
 * EncapsulateAreaEdit - if in edit mode, will encapsulate the html in the additional edit content and
 * return the encapsulated html
 *
 * param - html : html to encapsulate
 * param - varName : (see LoadArea, but with the array id)
 * param - panel : the panel
 * param - array : the array containing panels
 *
 * returns the encapsulated html
 ************************************************************************************************/
this.EncapsulateAreaEdit = function(html, varName, container_id, array) {
    if(this.editmode == 0) return html;
    if(this.editmode > 2) return html;
    
    html = Packages.Library.$.CreateDragAndDropContainer({
        html: html,
        storeArray: array,
        data: {
            areaname: varName
        }
        // callback: this.RenderPage.bind(this)
    });
    
    var outhtml = "";
    if(this.editmode == 1) outhtml += "<div class='editarea'>";
    if(this.editmode == 2) {
        outhtml += "<div class='editarea mhtm_edit_advanced' style='background-color:#" + Packages.Library.$.ToHex({num: Math.random()*255}) + Packages.Library.$.ToHex({num: Math.random()*255}) + Packages.Library.$.ToHex({num: Math.random()*255}) + ";'>";
        outhtml += "[Area Name: '" + container_id + "']<br>";
    }
    outhtml += "<div class='editareainner'>";
    
    outhtml += html;
    
    outhtml += "<\/div>";
    
    if(this.editmode == 2) outhtml += "<br>";
    outhtml += "<a href='#' ";
    if(this.editmode != 2) outhtml += "class='editadd' ";
    outhtml += "onClick=\"Packages.FileType.mhtm.$i.edit.AddPanelToArea('" + varName + "')\">add<\/a>";
    
    
    outhtml += "<\/div>";
    
    return outhtml;
};
/*************************************************************************************************
 * EncapsulatePanelChild - (subscriber event) if not an inherit item, will encapsulate the panel in a div with a child attribute
 *
 * param - data : hash of panel description sent in subscriber
 ************************************************************************************************/
this.EncapsulatePanelChild = function(data) {
    if(data.panel.type == "Inherit") return;
    
    // Legacy
    if(data.panel.display == null) data.panel.display = "block";
    
    data.html = "<div " +
                    "class='" +
                        data.containerId.toLowerCase() + "child " +
                        "mhtm_panel " +
                        (data.panel.styles == 'bordered' ? "borderedpanel" : "") +
                    "' " +
                    "style='display:" + data.panel.display + ";" +
                "'>"
                    + data.html
                + "<\/div>";
};
// Register subscriber event
Packages.Library.$.EventSubscribe({eventname: "mhtm_EncapsulatePanel", callback: this.EncapsulatePanelChild.bind(this)});

/*************************************************************************************************
 * AddHTMLToHead - Allows HTML to be added to the head of the page
 *
 * param - html : the HTML to add
 ************************************************************************************************/
this.AddHTMLToHead = function(html) {
   // Call the base library implementation
   // Record this to be deleted for next render
   
	if(Packages.Library.$c.IsNode != 1) {
		var hashIds = Packages.Library.$.AddHTMLToHead({
			html: html,
			className: "mhtm_render",
			forceReload: this.forceReload
		});
		
		this.headHashIds = this.headHashIds.concat(hashIds);
	}
   
   this.headerHTML += html;
};

/*************************************************************************************************
 * CallLiveOnAllPanelsAndAttributes - calls Live on all attributes and panels
 *
 * Called by WebLive
 *
 * Also called when 'view' done in the browser (in edit Preview)
 ************************************************************************************************/
this.CallLiveOnAllPanelsAndAttributes = function() {
    // Iterate through all panels and attributes and call Live on each
    var panelsAndAttributes = this.GetPanelsAndAttributes();
	
	this.interactivemode = this.editmode > 0 ? 0 : 1;
    
    var _this = this;
    
    // Check for panels that failed to load
    foreach(panelsAndAttributes, function(item) {
        if(item.type != "Panel") return;
        
        var ref = item.areaname.toLowerCase().substring(1) + "_" + item.index + "_" + item.inherit;
        var elems = document.getElementsByClassName(ref);
        if(elems.length == 0) return; // No panel
        var itemElem = elems[0];
        
        // Check for node reload triggers: mhtm_livereload_<area>_<panelid>
        var trigger = document.getElementsByClassName("mhtm_livereload_" + ref);
        if(trigger.length == 0) return; // No trigger
        
        // Call Display again
        var res = _this.GetPanelDisplay(item.object, item.areaname, item.index, item.inherit);
        if(!res) return; // No content
        itemElem.innerHTML = res;
    });
    
    // Call live on each panel and attribute
    foreach(panelsAndAttributes, function(item) {
        if(item.object.view.Live != null) {
            var res = item.object.view.Live();
            if(item.type == "Panel" && res != null) {
                // Replace content with returned content if there is any
                var ref = item.areaname.toLowerCase().substring(1) + "_" + item.index + "_" + item.inherit;
                var elems = document.getElementsByClassName(ref);
                if(elems[0] != null) elems[0].innerHTML = res;
            }
        }
    });
}

// Adding file [System/Software/JS/FileType/mhtm.$jscb/_lib/Util.js] as classpath [FileType.mhtm] 
/************************************************
 * GetDefaultArea - gets the name of the default area in the current template
 *
 * returns the default area id including the 'v' prefix
 ***********************************************/
this.GetDefaultArea = function() {
	if(this.defaultArea != null) return "v" + this.defaultArea;
	var elem;
	if(Packages.Library.$c.IsNode != 1) elem = document.getElementById('settingDefaultArea');
	if(!elem) {
		// Not found, so return null
		return null;
	}
	var defaultArea = elem.innerHTML;
	return "v" + defaultArea;
};
/************************************************
 * ChangeNatToBS - (recursive) updates all of the text items of this hash from the old natilda escape to backslashes
 *
 * param - hash : hash to scan and update
 ***********************************************/
this.ChangeNatToBS = function(hash) {
	for(var i in hash) {
		var val = hash[i];
		if(typeof(val) == "object") this.ChangeNatToBS(hash[i]);
		if(typeof(val) == "string") hash[i] = hash[i].replace(/~g/gi, "~").replace(/~n/gi, "\\n").replace(/~q/gi, "\\q").replace(/~s/gi, "\\s").replace(/~a/gi, "\\a").replace(/~p/gi, "\\p").replace(/~l/gi, "\\l");
	}
};
/************************************************
 * LogError - Pushes the specified error onto the error stack, and also fires off an event
 *
 * param - title : title of the error
 * param - error : the error to log
 * param - level : (optional) the error level
 ***********************************************/
this.LogError = function(title, error, level) {
	if(level == null) level = 1;
	this.error.push(error);
	
	// Fire event
		/****************************
		 * LogMessage - EVENT - sends internal general message to anyone who subscribes to it
		 *
		 * param - type : 'Error' or 'Info'
		 * param - heading : heading of message
		 * param - message : the message
		 * param - caller : the item sending the message
		 *
		 * returns nothing
		 **************************/
	Packages.Library.$.EventFire({eventname: "LogMessage", data: {type: "Error", heading: title, message: error, caller: "MHTM Web page"}});
	
	Packages.Library.$.LogInfo({mesg: error, location: title, type: "Error", level: level});
};
/************************************************
 * LogMessage - Puts message in pageinfo, and also fires off an event
 *
 * param - title : title of the message
 * param - message : the message to log
 ***********************************************/
this.LogMessage = function(title, message) {
	// Fire event
	Packages.Library.$.EventFire({eventname: "LogMessage", data: {type: "Info", heading: title, message: message, caller: "MHTM Web page"}});
	
	Packages.Library.$.LogInfo({mesg: message, location: title, type: "Info", level: 5});
};
/*************************************************************************************************
 * GetPanelsAndAttributes - Gets an array containing all of the panels and
 * attributes for this page and any inherited master pages
 *
 * returns an array of descriptor objects of the form:
 * 	type: 'Attribute' or 'Panel'
 * 	inherit: 0 for page, or 1,2,3... for master depending on depth
 * 	object: the actual object
 ************************************************************************************************/
this.GetPanelsAndAttributes = function() {
	var array = [];
	var masterpages = this.masterpages.length;
	if(masterpages == 0) masterpages = 1; // the page is 0
	for(var p = 0; p < masterpages; p++) {
		var page = this.page;
		if(p > 0) {
			// Masterpages are 1 based, as page is '0'
			page = this.masterpages[p];
		}
		// Do attributes first, in case template rewritten
		for(var attributename in page.Attributes) {
			var attribute = page.Attributes[attributename];
			if(attribute.view == null) continue; // Not objectised
			array.push({type: 'Attribute', inherit: p, object: attribute});
		}
		for(var areaname in page.Areas) {
			var area = page.Areas[areaname];
			for(var a = 0; a < area.length; a++) {
				if(area[a].view == null) continue; // Not objectised
				array.push({type: 'Panel', inherit: p, object: area[a], areaname: areaname, index: a});
			}
		}
	}
	return array;
};

/************************************************************************************************
 * IsAreaInPanel - determines if the area specified is within the panel specified or not
 *
 * param - options : hash of options, must contain:
 * 			areaname : the areaname
 * 			panel : the panel
 *
 * return 0 if not, 1 and 1 if it is
 **********************************************************************************************/
this.IsAreaInPanel = function(options) {
	if(!Packages.Library.$.ValidateOptions({
		calledFrom: "Packages.FileType.mhtm.IsAreaInPanel",
		options: options,
		specification: {
			areaname: {type: "string", required: 1},
			panel: {type: "object", required: 1}
		}
	})) return null;
	
	// Does this panel have areas within it?
	if(options.panel.edit.GetAreaPrefix != null) {
		// Does this areaname have the prefix?
		var prefix = options.panel.edit.GetAreaPrefix();
		if(options.areaname.indexOf(prefix) == 0) return 1;
	}
	
	return 0;
}

/************************************************************************************************
 * SetElemContent - sets the content of an element whether it exists in the DOM or just in the
 * HTML waiting to be displayed
 *
 * HTML approach only works for empty elems
 *
 * param - options : hash of options, must contain:
 * 			elemid : the id of the element
 * 			content : content to set
 * 		may contain:
 * 			noRetry : 1 do not schedule a retry, 0 (default) do
 **********************************************************************************************/
this.SetElemContent = function(options) {
	if(Packages.Library.$c.IsNode != 1) {
		var elem = document.getElementById(options.elemid);
		if(elem) {
			// Elem exists, so replace there
			elem.innerHTML = options.content;
		}
	}
	
	// Only proceed if there is a pageHtml string to check
	// In live mode, there is no pageHtml
	if(this.pageHtml == null) return;
	
	Packages.Library.$.LogInfo({
		mesg: "Searching for elemid: [" + options.elemid + "]",
		location: "mhtm.SetElemContent",
		type: "Debug",
		level: 10
	});
	
	// Also check our waiting page content
	if(this.pageHtml.match(new RegExp("<([^<]+?)id=([\"'])" + options.elemid + "['\"]([^>]*)></"))) {
		var tagAndLeadIn = RegExp.$1;
		var quote = RegExp.$2;
		var leadOut = RegExp.$3;
		
		Packages.Library.$.LogInfo({mesg: "Replaced: <" + tagAndLeadIn + "id=" + quote + options.elemid + quote + leadOut + "></" +
									" with <" + tagAndLeadIn + "id=" + quote + options.elemid + quote + leadOut + ">" + options.content + "</",
								location: "mhtm.SetElemContent", type: "Debug", level: 10});
		
		this.pageHtml = Packages.Library.$.Replace({
			content: this.pageHtml,
			search: 		"<" + tagAndLeadIn + "id=" + quote + options.elemid + quote + leadOut + "></",
			replacement: 	"<" + tagAndLeadIn + "id=" + quote + options.elemid + quote + leadOut + ">" + options.content + "</"
		});
	} else {
		// Not in the page yet, add to the list to re-process before using pageHtml
		if(options.noRetry != 1) this.pageHtmlSetElems.push(options);
	}
};


// Adding file [System/Software/JS/FileType/mhtm.$jscb/_live/Display.js] as classpath [FileType.mhtm] 
/*************************************************************************************************
* WebLive - BOOTLOADER - initialises the live for this file type
************************************************************************************************/
this.WebLive = function() {
    // Initialise MHTM
    this.InitMhtm();
    
    // Load the masterpages and set callback to call live
    this.LoadMasterpages(this.CallLiveOnAllPanelsAndAttributes);
};

// Adding file [System/Software/JS/FileType/mhtm.$jscb/_view/Display.js] as classpath [FileType.mhtm] 
/*************************************************************************************************
* WebDisplay - BOOTLOADER - initialises the viewer for this file type
************************************************************************************************/
this.WebDisplay = function() {
    // Has Node.JS already rendered the page
    // if(Packages.Library.$c.IsNode != 1 && document.getElementById("page_template") && this.editon == 0) return;
    
    // First - set up a timeout as a safety net in case page render fails
    setTimeout(this.SafetyCatchShowNonJS.bind(this), 10000);
    // DIE = anerror * 1; // Test Safety catch
    
    // Initialise MHTM
    this.InitMhtm();
    
    // Prepare template
    var filecontent = Packages.Library.$.GetCurrentFile();
    this.pTemplate = Packages.Library.$.GetAttribute({text: filecontent, attr: "template"});
    if(this.pTemplate == null) this.pTemplate = "Default.htm";
    this.pRedirect = Packages.Library.$.GetAttribute({text: filecontent, attr: "redirect"});
    this.pLastEdit = Packages.Library.$.GetAttribute({text: filecontent, attr: "lastedit"});
    this.pLastEditor = Packages.Library.$.GetAttribute({text: filecontent, attr: "lasteditor"});
    this.editorHtml = "<div class='pageedit' id='pageedit'><\/div>";
    this.editorHtml += "<div id='pageeditside'><\/div>";
    
    if(Packages.Library.$c.IsNode != 1) {
        document.getElementById('editor').innerHTML = this.editorHtml + "<div id='page_template'><\/div>";
    }
    
    // Record the method to call once the masterpages have loaded
    this.templateFileLoader = new Packages.Library.DynamicLoad({
        callback: this.AfterTemplateLoad.bind(this)
    });
    this.pageHtml = "";
    Packages.Library.$.LogInfo({mesg: "Sending off request for page template", location: "MHTM Display", type: "Info", level: 8});
    this.templateFileLoader.Request([{filepath: "$masterpath/System/Software/CSS/" + this.pTemplate, mode: "LT_TEXT"}]);
};
/*************************************************************************************************
* AfterTemplateLoad - callback after template loaded
************************************************************************************************/
this.AfterTemplateLoad = function() {
    // Get the template that was loaded
    this.pageTemplate = this.templateFileLoader.GetFileContent();
    
    // Load masterpages and set RenderPage as next callback
    this.LoadMasterpages(this.RenderPage);
}
/*************************************************************************************************
 * SafetyCatchShowNonJS - After 10 seconds, if the javascript rendering has failed, displays non js version
 ************************************************************************************************/
this.SafetyCatchShowNonJS = function() {
    // Do not do this if the page loaded sucessfully
    if(this.loaded == 1) return;
    if(this.testing == 1 || Packages.Library.$v.testRun == 1) return;
    
    // Page has not loaded, the following code is to make the best of a bas situation
    // Somewhere, the code has failed - we need to display something (the non js content) and stopped the existing javascript from still running
    
    // Kill the javascript content
    // document.getElementById('editor').innerHTML = '';
    
    // Set as page loaded - albeit poorly
    this.loaded = 1;
    this.failsafeLoaded = 1;
    
    this.LogMessage("Serious Warning", "Fail safe used for page, browser:[" + Packages.Library.$.GetBrowserName() + "]");
};};
// Package: FileType.mhtm.Attributes
Package('FileType.mhtm.Attributes').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.$s.mhtm != null) $super = new Packages.FileType.mhtm.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 1
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup] as classpath [FileType.mhtm.Attributes]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/_view/Init.js] as classpath [FileType.mhtm.Attributes] 
/*******************************************************************************
 * Initialise - Starts the attribute
 ******************************************************************************/
this.Initialise = function() {};

// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/_view/Version.js] as classpath [FileType.mhtm.Attributes] 
this.AttributeVersion = 5;};
// Package: FileType.mhtm.Attributes.CSS
Package('FileType.mhtm.Attributes.CSS').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Attributes != null) $super = new Packages.FileType.mhtm.Attributes.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/CSS] as classpath [FileType.mhtm.Attributes.CSS]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/CSS/_view/Init.js] as classpath [FileType.mhtm.Attributes.CSS] 
this.textvar = GetTextRef(this);
this.fileLoader;
this.ready = 1;
/*********************************************************************
 * Initialise - fires off this attribute
 ********************************************************************/
this.Initialise = function() {
	this.ready = 0;
	var cssFiles = [{filepath: "$masterpath/System/Software/CSS/Styles/Template.css", mode: "LT_TEXT"}];
	// if(Packages.Library.$.IsMobile()) cssFiles.push({filepath: "/System/Software/CSS/Styles/Mobile.css", mode: 'LT_TEXT'});
	this.fileLoader = new Packages.Library.DynamicLoad({
		callback: new Function(this.textvar + ".InitialiseCallback()"),
		displayLoadingIcon: 0
	});
	this.fileLoader.Request(cssFiles);
	return "";
};
/*********************************************************************
 * InitialiseCallback - called after initialise has loaded its resources
 ********************************************************************/
this.InitialiseCallback = function() {
	var attribute = this.data;
	var fileobjs = this.fileLoader.GetFiles();
	var css = "";
	for(var i = 0; i < fileobjs.length; i++) {
		css += this.fileLoader.GetFileContent(fileobjs[i]) + "\n";
	}
	css = css.replace(new RegExp("&"+"lt;","g"),'<').replace(new RegExp("&"+"gt;","g"),'>');
	
	// Get CSS from other items that have their own defined
		/****************************
		 * GetCSS - EVENT - collects CSS required for this page
		 *
		 * param - none, empty hash
		 *
		 * returns hash containing:
		 * 		id : unique id for this css (to avoid duplicates)
		 * 		css : the css (that may containing macros to be replaced out)
		 **************************/
	var responses = Packages.Library.$.EventFire({eventname: "GetCSS", data: {}});
	var cssResponses = {} // collected css arranged by id key, to remove duplicates
	for(var i = 0 ; i < responses.length; i++) {
		if(responses[i] != null) cssResponses[responses[i].id] = responses[i].css;
	}
	for(var key in cssResponses) {
		css += cssResponses[key] + "\n";
	}
	
	// Switch off the current options for shadows for older browsers
	if (Packages.Library.$.GetInternetExplorerVersion()<9) css = css.replace(/(\$shadowsext\$|\$shadowsint\$|\$shadowsoff\$)/gi, '');
	
	css = this.GetBasicStyle(css, "sideareaside", attribute.data.styles.sidearea.side, "float:" + this.getCSSVal(attribute.data.styles.sidearea.side) + ";");
	// This over complicated piece of code displays the divider, or hides it
	css = this.GetBasicStyle(css, "sideareaborder", (
			this.getCSSVal(attribute.data.styles.sidearea.divider) != null ? 1 : null // Are we setting state, or leaving to inherit (null)
		), "border-" + (
			this.getCSSVal(attribute.data.styles.sidearea.side) == 'left' ? "right" : "left" // We apply border to the inside (oposite side)
		) + (
			attribute.data.styles.sidearea.divider == 1 ? ":1px solid black;padding:5px;" : ":0px;border-" + attribute.data.styles.sidearea.side + ": 0px;padding:0px;" // first part assigns border, second part hides border, and for the other side (in case inheritance uses other side)
		));
	
	var otherside = (attribute.data.styles.sidearea.side == "left" ? "right" : "left");
	// Get simple styles that just need to check if they are inheriting or not
	css = this.GetBasicStyle(css, "menuspacing", attribute.data.styles.spacing.menu, "margin-left:" + this.getCSSVal(attribute.data.styles.spacing.menu) + "px;");
	css = this.GetBasicStyle(css, "panelspacing", attribute.data.styles.spacing.panel, "margin-top:" + this.getCSSVal(attribute.data.styles.spacing.panel) + "px;margin-bottom:" + this.getCSSVal(attribute.data.styles.spacing.panel) + "px;");
	css = this.GetBasicStyle(css, "bodywidthval", attribute.data.styles.bodyWidth, (Packages.Library.$.IsMobile() ? "100%" : this.getCSSVal(attribute.data.styles.bodyWidth)));
	css = this.GetBasicStyle(css, "bodyareashift", 1, "margin-" + attribute.data.styles.sidearea.side + ": " + (200 + (attribute.data.styles.sidearea.divider == 1 ? 15 : 0)) + "px;margin-" + otherside + ":0px;");
	css = this.GetBasicStyle(css, "menuwidth", attribute.data.styles.spacing.menunarrow, (attribute.data.styles.spacing.menunarrow == 1 ? "100px;" : "155px"));
	css = this.GetBasicStyle(css, "menuheight", attribute.data.styles.spacing.menutall, (attribute.data.styles.spacing.menutall == 1 ? "50px;" : "25px"));
	
	// Get complex styles that are applied to a type
	for(var type in attribute.data.styles.type) {
		css = this.GetStyle(css, type, attribute.data.styles.type[type]);
	}
	
	// Get text styles
	for(var textstyle in attribute.data.styles.textstyle) {
		var style = attribute.data.styles.textstyle[textstyle];
		css = this.GetTextStyle(css, textstyle + "style", style);
	}
	
	css = css.replace(/\$shadowsoff\$/gi, "-webkit-box-shadow: none; -moz-box-shadow: none;box-shadow: none;");
	css = css.replace(/\$roundednessoff\$/gi, "-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;");
	
	css = css.replace(/\$transition1\$/gi, "transition-property:all;transition-duration:1s;" +
					  "/* Firefox 4 */-moz-transition-property:all;-moz-transition-duration:1s;" +
					  "/* Safari and Chrome */-webkit-transition-property:all;-webkit-transition-duration:1s;" +
					  "/* Opera */-o-transition-property:all;-o-transition-duration:1s;");
	
	// Add additional override styles last - so they actually over ride
	if(attribute.data.additionalcss != null) css += Packages.Library.$.ConvertLegacy({str: attribute.data.additionalcss});
	
	// Add a .thepage prefix to all lines
	var lines = css.split(/\n/);
	var newLines = [];
	foreach(lines, function(line) {
		// If line is a selector, and does not start with .thepage already, add it
		if((
				line.match(/{/)
			 || line.match(/,$/)
		)
		&& !line.match(/^\s*\.thepage /)
		&& !line.match(/^\s*@/)
		&& !line.match(/^\s*div\./)) line = ".thepage " + line;
		newLines.push(line);
	});
	css = newLines.join("\n");
	
	if(Packages.Library.$c.IsNode != 1) {
		var uniqueId = "page_css" + this.textvar;
		
		// Add this generated style sheet to the head of the page, removing any previous ones first
		var pa = document.getElementsByTagName('head')[0] ;
		var styles = pa.getElementsByTagName('style');
		var stylesToRemove = [];
		foreach(styles, function(style) {
			if(style.id == uniqueId) {
				// Style belongs to a previous run of this object
				stylesToRemove.push(style);
			}
		});
		foreach(stylesToRemove, function(style) {
			pa.removeChild(style);
		});
		
		for(var n = 0;n < 1; n++) {
			var el= document.createElement('style');
			el.type = 'text/css';
			// el.media = 'screen';
			el.id = uniqueId;
			if(el.styleSheet) {
				el.styleSheet.cssText = css;// IE method
			} else {
				el.appendChild(document.createTextNode(css));// others
			}
			pa.appendChild(el);
		}
		
		// Set up meta tag for mobile to disable zoom, and fix width
		var el= document.createElement('meta');
		el.name = 'viewport';
		el.content = 'width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0';
		pa.appendChild(el);
		// <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"/> <!--320-->
	}
	
	Packages.FileType.mhtm.$i.view.AddHTMLToHead("<style>" + css + "</style>");
	Packages.FileType.mhtm.$i.view.AddHTMLToHead("<meta name='viewport' content='width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0'/> <!--320-->");
	
	this.ready = 1;
	return "";
};
/************************************************
 * GetTextStyle - puts out text styles (if not blank)
 *
 * param - csstemplate : template to make changes to
 * param - label : the text to be replaced
 * param - style : the hash of styles to apply to this text
 *
 * returns the updated css template
 ***********************************************/
this.GetTextStyle = function(csstemplate, label, style) {
	var replacement = "";
	
	for(var key in style) {
		var val = this.getCSSVal(style[key]);
		if(val == null) continue;
		replacement += key.replace(/_/, "-") + ": " + (key.match(/color/) ? "#" : "") + val + ";";
	}
	
	// Load font
	if(style.font_family != null) {
		Packages.FileType.mhtm.$i.view.AddHTMLToHead(Packages.Library.$.RequestFont({font: style.font_family, addToDom: 0}));
	}
	
	var re = new RegExp("\\$" + label + "\\$", "gi");
	return csstemplate.replace(re, replacement);
};
/************************************************
 * GetBasicStyle - puts out style (if not blank)
 *
 * param - csstemplate : template to make changes to
 * param - label : the text to be replaced
 * param - stylevalue : if blank or null, will replace the attrib with "", otherwise use replacement
 * param - replacement : the text to replace with
 *
 * returns the updated css template
 ***********************************************/
this.GetBasicStyle = function(csstemplate, label, stylevalue, replacement) {
	var re = new RegExp("\\$" + label + "\\$", "gi");
	if(this.getCSSVal(stylevalue) == null) return csstemplate.replace(re, "");
	return csstemplate.replace(re, replacement);
};
/************************************************
 * GetStyle - gets the CSS for the specified styleHash
 *
 * param - csstemplate : the template
 * param - label : the name of this css style (to be replaced)
 * param - colourHash : the hash of colour data
 *
 * returns the updated css template
 ***********************************************/
this.GetStyle = function(csstemplate, label, colourHash) {
	var mainRegex = new RegExp("\\$" + label + "\\$", "gi");
	var textRegex = new RegExp("\\$" + label + "Text\\$", "gi");
	var topColRegex = new RegExp("\\$" + label + "TopCol\\$", "gi");
	var backgroundImgRegex = new RegExp("\\$" + label + "BackgroundImg\\$", "gi");
	if(colourHash == null) {
		// no colour styles
		csstemplate = csstemplate.replace(mainRegex, "");
		csstemplate = csstemplate.replace(textRegex, "");
		csstemplate = csstemplate.replace(topColRegex, "");
		csstemplate = csstemplate.replace(backgroundImgRegex, "");
		return csstemplate;
	}
	
	var backgroundFrom = this.getCSSVal(colourHash.backgroundFrom);
	var backgroundTo = this.getCSSVal(colourHash.backgroundTo);
	var backgroundImage = this.getCSSVal(colourHash.backgroundImage);
	var textColour = this.getCSSVal(colourHash.textColour);
	var bold = this.getCSSVal(colourHash.bold);
	var italics = this.getCSSVal(colourHash.italics);
	var underlined = this.getCSSVal(colourHash.underlined);
	var textAlign = this.getCSSVal(colourHash.textAlign);
	var borderColour = this.getCSSVal(colourHash.borderColour);
	var borderThickness = this.getCSSVal(colourHash.borderThickness);
	var shadowDepth = this.getCSSVal(colourHash.shadowDepth);
	var roundedRadius = this.getCSSVal(colourHash.roundedRadius);
	
	// Ensure colours are prefixed by a '#'
	if(backgroundFrom != null && backgroundFrom != "none") backgroundFrom = "#" + backgroundFrom;
	if(backgroundTo != null && backgroundTo != "none") backgroundTo = "#" + backgroundTo;
	if(borderColour != null && borderColour != "none") borderColour = "#" + borderColour;
	if(textColour != null && textColour != "none") textColour = "#" + textColour;
	
	var css = "";
	
	if(roundedRadius != null) css += "-webkit-border-radius:" + roundedRadius + "px;-moz-border-radius:" + roundedRadius + "px;border-radius:" + roundedRadius + "px;";
	if(shadowDepth != null && shadowDepth > 0) css += "-webkit-box-shadow: #666 0px 2px " + shadowDepth + "px;-moz-box-shadow: #666 0px 2px " + shadowDepth + "px;box-shadow: #666 0px 2px " + shadowDepth + "px;";
	if(textColour != null) css += "color:" + textColour + ";";
	if(bold == 1) css += "font-weight:bold;";
	if(italics == 1) css += "font-style:italic;";
	if(underlined == 1) css += "text-decoration:underlined;";
	if(textAlign != null) css += "text-align:" + textAlign + ";";
	if(borderColour != null && borderThickness != null) css += "border:" + borderThickness + "px solid " + borderColour + ";";
	
	if(backgroundTo == null) backgroundTo = backgroundFrom; // Plain colours
	if(backgroundFrom != null  && backgroundTo != null) {
		// Add plain background for compatibility
		css += "background: #" + this.GetMidColour(backgroundFrom, backgroundTo) + ";";
		css += "background: -webkit-gradient(linear, 0 0, 0 bottom, from(" + 	backgroundFrom + "), to(" + backgroundTo + "));";
		css += "background: -webkit-linear-gradient(" + 						backgroundFrom + ", " + backgroundTo +");";
		css += "background: -moz-linear-gradient(" +							backgroundFrom + ", " + backgroundTo +");";
		css += "background: -ms-linear-gradient(" +								backgroundFrom + ", " + backgroundTo +");";
		css += "background: -o-linear-gradient(" + 								backgroundFrom + ", " + backgroundTo +");";
		css += "background: linear-gradient(" + 								backgroundFrom + ", " + backgroundTo +");";
	} else {
		if(backgroundImage != null ) {
			if(Packages.Library.$.GetInternetExplorerVersion() < 9) {
				// Background images not supported
				css += "background-color: #444444;";
				css += "background-image: none;";
			} else {
				css += "background-image: url('" + Packages.Library.$.GetPathToBase({filepath: backgroundImage}) + "');background-size:cover;";
			}
		}
	}
	// Replace all styles
	csstemplate = csstemplate.replace(mainRegex, css);
	
	// Get Replacements for sub parts of this css
	csstemplate = csstemplate.replace(textRegex, (textColour != null ? "color:" + textColour + ";" : ""));
	csstemplate = csstemplate.replace(topColRegex, (backgroundFrom != null ? "background-color:" + backgroundFrom + ";" : ""));
	csstemplate = csstemplate.replace(backgroundImgRegex, (backgroundImage != null ? "background-image:" + backgroundImage + ";" : ""));
	
	return csstemplate;
};
/**************************************************************
 * GetMidColour - gets the mid colour of the two specified
 *
 * param - col1 : base colour
 * param - col2 : other colour
 *
 * returns the HEX for the colour between the two colour
 *************************************************************/
this.GetMidColour = function(col1, col2) {
	//Strip leading #
	col1 = col1.replace(/#/, ""); col2 = col2.replace(/#/, "");
	var rgb1 = {r:parseInt(col1.substring(0,2),16),g:parseInt(col1.substring(2,4),16),b:parseInt(col1.substring(4,6),16)};
	var rgb2 = {r:parseInt(col2.substring(0,2),16),g:parseInt(col2.substring(2,4),16),b:parseInt(col2.substring(4,6),16)};
	rgb1.r = (rgb1.r + rgb2.r) / 2;
	rgb1.g = (rgb1.g + rgb2.g) / 2;
	rgb1.b = (rgb1.b + rgb2.b) / 2;
	return Packages.Library.$.ToHex({num: rgb1.r})+Packages.Library.$.ToHex({num: rgb1.g})+Packages.Library.$.ToHex({num: rgb1.b});
};
/****************************************************************
 * MakeDefaultCSS - Makes the default CSS for a page without any styles
 ***************************************************************/
this.MakeDefaultCSS = function() {
	this.data.data.additionalcss = "";
	this.data.data.styles.bodyWidth = "960px";
	this.data.data.styles.sidearea = {
			side: "left",
			divider: 0
		};
	this.data.data.styles.spacing = {
			menu: 0,
			panel: 0,
			menutall: 0,
			menunarrow: 0
		};
	this.data.data.styles.type = {
			pageBackground: {backgroundFrom: "333333", 	backgroundTo: "111111", textColour: "000000", borderColour: "000000", borderThickness: 1, roundedRadius: null, shadowDepth: null, textAlign: "left", bold: 0, italics: 0, underlined: 0},
			bodyBackground: {backgroundFrom: "DDDDDD", 	backgroundTo: "BBBBBB", textColour: "000000", borderColour: "000000", borderThickness: 1, roundedRadius: null, shadowDepth: 20, textAlign: "left", bold: 0, italics: 0, underlined: 0},
			bar: 			{backgroundFrom: "AAAAAA", 	backgroundTo: "777777", textColour: "000000", borderColour: "000000", borderThickness: 0, roundedRadius: null, shadowDepth: 0, textAlign: "left", bold: 0, italics: 0, underlined: 0},
			button: 		{backgroundFrom: "AAAAAA", 	backgroundTo: "777777", textColour: "000000", borderColour: "000000", borderThickness: 1, roundedRadius: null, shadowDepth: 20, textAlign: "left", bold: 0, italics: 0, underlined: 0},
			borderedPanel: 	{backgroundFrom: "AAAAAA", 	backgroundTo: "777777", textColour: "000000", borderColour: "000000", borderThickness: 1, roundedRadius: null, shadowDepth: 20, textAlign: "left", bold: 0, italics: 0, underlined: 0},
			borderedPanelTitle: {backgroundFrom: "AAAAAA", backgroundTo: "777777", textColour: "000000", borderColour: "000000", borderThickness: 1, roundedRadius: null, shadowDepth: 20, textAlign: "left", bold: 0, italics: 0, underlined: 0},
			mainPanels: 	{backgroundFrom: null, 		backgroundTo: null, 	textColour: null, 	  borderColour: null, 	  borderThickness: null, roundedRadius: null, shadowDepth: null, textAlign: "left", bold: 0, italics: 0, underlined: 0},
			highlight: 		{backgroundFrom: "FFFFFF", 	backgroundTo: "AAAAAA", textColour: "000000", borderColour: "000000", borderThickness: 0, roundedRadius: null, shadowDepth: 0, textAlign: "inherit", bold: 0, italics: 0, underlined: 0},
			subPanel: 		{backgroundFrom: "FFFFFF", 	backgroundTo: "FFFFFF", textColour: "000000", borderColour: "000000", borderThickness: 1, roundedRadius: null, shadowDepth: 20, textAlign: "left", bold: 0, italics: 0, underlined: 0}
		};
	this.data.data.styles.autogen = {
			colour: "888888"
		};
	// Add text styles
	this.data.data.styles.textstyle = {};
	for(var i = 1; i <= 7 ; i++) {
		this.data.data.styles.textstyle["h" + i] = {}; // Use browser default
	}
	this.data.data.styles.textstyle.p = {};
	this.data.data.styles.textstyle.body = {};
	
	// Now version 3.5
	this.data.version = 3.5;
};
/************************************************
 * getCSSVal - gets the CSS value for this attribute or null if set to inherit
 *
 * param - style : the name of the style
 *
 * returns the value or null if set to inherit
 ***********************************************/
this.getCSSVal = function(style) {
	if(style == 'inherit') return null;
	if(style == -1) return null;
	if(typeof(style) == 'string' && style == '') return null;
	return style;
};
/************************************************
 * DetectCSSVersion - detects the current version of the CSS data
 *
 * returns the version
 ***********************************************/
this.DetectCSSVersion = function() {
	if(this.data.version != null) return this.data.version;
	
	
	if(this.data.data.styles == null) return 0; // New one
	if(this.data.data.styles.colours != null) return 2;
	if(this.data.data.styles.type.sidePanelTitles == null && this.data.data.styles.type.sidePanels != null) return 3;
	if(this.data.data.styles.type.sidePanels != null) return 3.1;
	return 3.5;
}
/************************************************
 * Update - updates the data to the latest format
 ***********************************************/
this.Update = function() {
	this.data.version = this.DetectCSSVersion();
	
	// Initialise styles
	if(this.data.data.styles == null) this.data.data.styles = {};
	
	// Upgrade each version
	if(this.data.version <= 2) this.MakeDefaultCSS();
	
	var css = this.data.data.styles;
	
	if(this.data.version == 2) {
		// Updates Defaults with old CSS format data
		css.type = {
			pageBackground: {backgroundFrom: null, backgroundTo: null, textColour: null, borderColour: null, borderThickness: null, roundedRadius: null, shadowDepth: null},
			bodyBackground: this.UpdateColour(css.colours.background, null, null),
			bar: this.UpdateColour(css.colours.bar, null, null),
			button: this.UpdateColour(css.colours.bar, null, null),
			sidePanels: this.UpdateColour(css.colours.bar, css.roundednessext, css.shadowsext),
			sidePanelTitles: this.UpdateColour(css.colours.bar, css.roundednessext, css.shadowsext),
			mainPanels: {backgroundFrom: null, backgroundTo: null, textColour: null, borderColour: null, borderThickness: null, roundedRadius: null, shadowDepth: null},
			highlight: this.UpdateColour(css.colours.highlight, null, null),
			subPanel: this.UpdateColour(css.colours.inter, css.roundednessint, css.shadowsint)
		};
		css.sidearea = {
			side: css.sideareaside,
			divider: 0
		};
		
		// Add bodywidth
		css.bodyWidth = "";
		
		// Add extra spacing options
		css.spacing.menutall = 0;
		css.spacing.menunarrow = 0;
		
		// Get old CSS auto colour
		css.autogen.colour = css.type.pageBackground.backgroundFrom;
		
		// Delete old stuff
		delete css.colours;
		delete css.roundednessint;
		delete css.roundednessext;
		delete css.roundednessbar;
		delete css.shadowsint;
		delete css.shadowsext;
		delete css.borderThickness;
		
		// We are now version 3
		this.data.version = 3;
	}
	
	if(this.data.version == 3) {
		var css = this.data.data.styles;
		
		// Add new types since version 3
		if(css.type.sidePanelTitles == null) css.type.sidePanelTitles = {
			backgroundFrom: css.type.sidePanels.backgroundFrom,
			backgroundTo: css.type.sidePanels.backgroundTo,
			textColour: css.type.sidePanels.textColour,
			borderColour: css.type.sidePanels.borderColour,
			borderThickness: css.type.sidePanels.borderThickness,
			roundedRadius: css.type.sidePanels.roundedRadius,
			shadowDepth: css.type.sidePanels.shadowDepth,
			textAlign: css.type.sidePanels.textAlign
		};
		
		// We are now version 3.1
		this.data.version = 3.1;
	}
	
	if(this.data.version == 3.1) {
		var css = this.data.data.styles;
		
		// Renamed the sidearea key
		this.data.data.styles.type.borderedPanel = this.data.data.styles.type.sidePanels;
		this.data.data.styles.type.borderedPanelTitle = this.data.data.styles.type.sidePanelTitles;
		// Remove old key
		delete this.data.data.styles.type.sidePanels;
		delete this.data.data.styles.type.sidePanelTitles;
		
		// We are now version 3.5
		this.data.version = 3.5;
	}
	if(this.data.version == 3.5) {
		// Fix bug above - was mispelt
		delete this.data.data.styles.type.sidePanelTitles;
		
		this.data.version = 3.51;
	}
	
	if(this.data.version == 3.51) {
		// Added fonts, and extra text styles
		this.data.data.styles.textstyle.p = {};
		this.data.data.styles.textstyle.a = {};
		this.data.data.styles.textstyle.body = {};
		
		this.data.version = 3.52;
	}
	
	// Up to date
};
/************************************************
 * UpdateColour - updates the colour data to the new format (used from v2 to v3)
 *
 * param - colour : the 6 figure HEX colour this is based on
 * param - roundedRadius : the number of pixels roundedness
 * param - shadowDepth : the number of pixels shadow depth
 ***********************************************/
this.UpdateColour = function(colour, roundedRadius, shadowDepth) {
	return {
		backgroundFrom: colour.from,
		backgroundTo: colour.to,
		textColour: colour.text,
		borderColour: colour.border,
		borderThickness: this.attribute.data.styles.borderthickness,
		roundedRadius: roundedRadius,
		shadowDepth: shadowDepth
	};
};
/*********************************************************************
 * EventMhtm_RenderComplete - callback on render complete event
 *
 * param - data : data about this event
 *
 * returns 1 if ready, 0 if not
 ********************************************************************/
this.EventMhtm_RenderComplete = function(data) {
	return {
		ready: this.ready,
		info: "CSS Attribute"
	};
};
this.eventRenderComplete = Packages.Library.$.EventSubscribe({eventname: "Mhtm_RenderComplete", callback: this.EventMhtm_RenderComplete.bind(this), groupname: "mhtm_render", obj: this});};
// Package: FileType.mhtm.Attributes.Entrance
Package('FileType.mhtm.Attributes.Entrance').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Attributes != null) $super = new Packages.FileType.mhtm.Attributes.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Entrance] as classpath [FileType.mhtm.Attributes.Entrance]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Entrance/_view/Init.js] as classpath [FileType.mhtm.Attributes.Entrance] 
this.progress = 0;
this.effect;
/*******************************************************************************
 * Live - live upgrades the attribute
 ******************************************************************************/
this.Live = function() {
	if(Packages.Library.$c.IsNode) return; // Can't do this in node
	
	this.progress = 0;
	// Create the objects for the effect
	this.effect = new Packages.Attributes.Entrance[this.data.data.effect].$k();
	if(this.effect == null) return;
	this.effect.data = this.data;
	this.Timer();
};
/*******************************************************************************
 * Timer - keeps calling back to update progress of effect
 ******************************************************************************/
this.Timer = function() {
	if(this.data.data.steps == 0) return;
	
	this.progress += (1 / this.data.data.steps);
	
	// Do the action
	this.effect.Display(this.progress);
	
	if(this.progress < 1) {
		// Schedule a re-visit
		var _this = this;
		setTimeout(function() {
			_this.Timer()
		}, (1000 * this.data.data.duration) / this.data.data.steps);
		return;
	}
	// Complete
};};
// Package: FileType.mhtm.Attributes.Entrance.Fade
Package('FileType.mhtm.Attributes.Entrance.Fade').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.Attributes.$s.Entrance != null) $super = new Packages.FileType.mhtm.Attributes.Entrance.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Entrance/Fade] as classpath [FileType.mhtm.Attributes.Entrance.Fade]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Entrance/Fade/_view.js] as classpath [FileType.mhtm.Attributes.Entrance.Fade] 
/**********************************************************
 * Display - called repeatedly from 0 to 1.0 for each step of the fade
 *
 * param - progress : 0.0 - 1.0
 *********************************************************/
this.Display = function(progress) {
	document.getElementById('editor').style.opacity = progress;
};};
// Package: FileType.mhtm.Attributes.GoogleAnalytics
Package('FileType.mhtm.Attributes.GoogleAnalytics').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Attributes != null) $super = new Packages.FileType.mhtm.Attributes.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/GoogleAnalytics] as classpath [FileType.mhtm.Attributes.GoogleAnalytics]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/GoogleAnalytics/_view/Init.js] as classpath [FileType.mhtm.Attributes.GoogleAnalytics] 
/*******************************************************************************
 * Live - live upgrades the attribute
 ******************************************************************************/
this.Live = function() {
	// Only do this in LIVE sites
	if(Packages.Library.$.IsLive({}) == 0) return;
	if(Packages.FileType.mhtm.$i.view.editon > 0) return;
	
	if(this.data.data.method == null) this.data.data.method = "gaq"; // Upgrade
	if(this.data.data.requires == null) this.data.data.requires = []; // Upgrade
	
	if(this.data.data.method == "gaq") {
		window._gaq = window._gaq || [];
		window._gaq.push(['_setAccount', this.data.data.gacode]);
		window._gaq.push(['_trackPageview']);
		
		(function() {
		  var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
		  ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
		  var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
		})();
	}
	if(this.data.data.method == "ua") {
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
	  
		ga('create', this.data.data.gacode, 'auto');
		// Add requires if present
		foreach(this.data.data.requires, function(require) {
			ga('require', require);
		});
		ga('send', 'pageview');
	}
};
/*********************************************************************
 * EventLogMessage - callback on a message to be logged
 *
 * param - data : data about this event
 *
 * returns nothing
 ********************************************************************/
this.EventLogMessage = function(data) {
	if(this.data.data.method == "gaq") {
		if(window._gaq == null) return;
		window._gaq.push(['_trackEvent', data.type, data.heading, "Message: [" + data.message + "]. Caller: [" + data.caller + "]. Page: [" + Packages.Library.$.GetPageURL({}) + "]"]);
	}
	if(this.data.data.method == "ua") {
		if(window.ga == null) return;
		ga('send', 'event', data.type, data.heading, "Message: [" + data.message + "]. Caller: [" + data.caller + "]. Page: [" + Packages.Library.$.GetPageURL({}) + "]");
	}
};
this.eventLogMessage = Packages.Library.$.EventSubscribe({eventname: "LogMessage", callback: this.EventLogMessage.bind(this), groupname: "mhtm_render", obj: this});
/*********************************************************************
 * EventCookieUsage - callback when cookie usage is requested
 *
 * returns information about this cookie
 ********************************************************************/
this.EventCookieUsage = function(data) {
	return {
		id : "googleanalytics",
		party: 2, // Analytical cookies
		description: "Google Analytics"
	};
};
this.eventCookieUsage = Packages.Library.$.EventSubscribe({eventname: "CookieUsage", callback: this.EventCookieUsage.bind(this), groupname: "mhtm_render", obj: this});};
// Package: FileType.mhtm.Attributes.HeaderHTML
Package('FileType.mhtm.Attributes.HeaderHTML').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Attributes != null) $super = new Packages.FileType.mhtm.Attributes.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/HeaderHTML] as classpath [FileType.mhtm.Attributes.HeaderHTML]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/HeaderHTML/_view/Init.js] as classpath [FileType.mhtm.Attributes.HeaderHTML] 
/*******************************************************************************
 * Initialise - Starts the attribute
 ******************************************************************************/
this.Initialise = function() {
	Packages.FileType.mhtm.$i.view.AddHTMLToHead(Packages.Library.$.ConvertLegacy({str: this.data.data.html}));
};};
// Package: FileType.mhtm.Attributes.JS
Package('FileType.mhtm.Attributes.JS').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Attributes != null) $super = new Packages.FileType.mhtm.Attributes.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/JS] as classpath [FileType.mhtm.Attributes.JS]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/JS/_view/Init.js] as classpath [FileType.mhtm.Attributes.JS] 
/*******************************************************************************
 * Initialise - Starts the attribute
 ******************************************************************************/
this.Initialise = function() {
	var head = document.getElementsByTagName('head')[0];
	script = document.createElement('script');
	var path = Packages.Library.$.GetPathToBase({filepath: this.data.data.src});    
	script.src = path;
	script.type = 'text/javascript';
	head.appendChild(script);
};};
// Package: FileType.mhtm.Attributes.Template
Package('FileType.mhtm.Attributes.Template').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Attributes != null) $super = new Packages.FileType.mhtm.Attributes.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Template] as classpath [FileType.mhtm.Attributes.Template]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Template/_view/Init.js] as classpath [FileType.mhtm.Attributes.Template] 
/*******************************************************************************
 * Initialise - Starts the attribute
 ******************************************************************************/
this.Initialise = function() {
	// Replace whatever template we are using now
	var html = this.data.data.html;
	
	if(this.data.data.defaultArea != null) {
		Packages.FileType.mhtm.$i.view.defaultArea = this.data.data.defaultArea;
	}
	
	Packages.FileType.mhtm.$i.view.pageTemplate = html;
	Packages.FileType.mhtm.$i.view.pageHtml = Packages.FileType.mhtm.$i.view.pageTemplate; // Force now
	
	Packages.FileType.mhtm.$i.view.AddHTMLToHead(this.data.data.head);
};};
// Package: FileType.mhtm.Attributes.Title
Package('FileType.mhtm.Attributes.Title').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Attributes != null) $super = new Packages.FileType.mhtm.Attributes.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Title] as classpath [FileType.mhtm.Attributes.Title]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Title/_view/Init.js] as classpath [FileType.mhtm.Attributes.Title] 
/*******************************************************************************
 * Initialise - Starts the attribute
 ******************************************************************************/
this.Initialise = function() {
	if(this.data.data.title == "") return;
	document.title = this.data.data.title;
	Packages.FileType.mhtm.$i.view.AddHTMLToHead("<title>" + this.data.data.title + "</title>");
	return;
};};
// Package: FileType.mhtm.Attributes.Tracking
Package('FileType.mhtm.Attributes.Tracking').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Attributes != null) $super = new Packages.FileType.mhtm.Attributes.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Tracking] as classpath [FileType.mhtm.Attributes.Tracking]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Attributes.$jscb_sup/Tracking/_view/Init.js] as classpath [FileType.mhtm.Attributes.Tracking] 
this.MOUSEPOS = 1;
this.SCROLL = 2;
this.CLICK = 3;
this.WIDTH = 4;
this.KEY = 5;
this.FOCUS = 6;
/*******************************************************************************
 * Live - live upgrades the attribute
 ******************************************************************************/
this.Live = function() {
	// Only do this in LIVE sites
	if(Packages.Library.$.IsLive({}) == 0) return;
	if(Packages.FileType.mhtm.$i.view.editon > 0) return;
	if(this.data.data.enabled == 0) return;
	
	// Only allow one run per page, in case a master page and page has the option on
	if(Packages.FileType.mhtm.$v.TrackingOn == 1) return;
	Packages.FileType.mhtm.$v.TrackingOn = 1;
	
	this.rendercount = Packages.FileType.mhtm.$i.view.rendercount;
	
	// Create data arrays
	this.mousePos = [];
	this.scroll = [];
	this.clicks = [];
	this.widths = [];
	this.keys = [];
	this.focus = [];
	
	this.startTime = new Date().getTime();
	
	var _this = this;
	Packages.Library.$.EventSubscribe({eventname: "onexit", groupname: "mhtm_render", callback: function() {
		// Send data to server
		var data = Packages.Library.$.Dump({obj: [[_this.startTime, new Date().getTime()], _this.mousePos, _this.scroll, _this.clicks, _this.widths, _this.keys, _this.focus]});
		data = data.replace(/[\n\r\f\t ]/g, "");
		if(navigator.sendBeacon) {
			navigator.sendBeacon("?req-nooutput=1", "log-stats64=" + btoa(data));
		} else {
			var req = new XMLHttpRequest();
			req.open('post', '?req-nooutput=1', false);
			req.send("log-stats64=" + btoa(data));
		}
	}});
	
	this.mouseUpEvent = Packages.Library.$.EventSubscribe({eventname: "mouseup", callback: this.OnMouseUp.bind(this), groupname: "mhtm_render", obj: this});
	document.onkeyup = this.OnKeyUp.bind(this);
	
	this.Loop();
};

/*******************************************************************************
 * Loops - calls itself via a timeout to continually check status
 ******************************************************************************/
this.Loop = function() {
	if(this.rendercount != Packages.FileType.mhtm.$i.view.rendercount) return; // Don't action for previous renders
	
	// Check mouse position
	if(!this.relElem) this.relElem = document.getElementsByClassName('thepageinner')[0];
	var offset = Packages.Library.$.GetElemPosition({elem: this.relElem});
	if(offset != null) {
		var len = this.mousePos.length;
		if(len == 0
		|| (this.mousePos[len - 1][1] != Packages.Library.$v.Mouse.x - offset.x
		 && this.mousePos[len - 1][2] != Packages.Library.$v.Mouse.y - offset.y
		)) {
			this.mousePos.push([new Date().getTime(), Packages.Library.$v.Mouse.x - offset.x, Packages.Library.$v.Mouse.y - offset.y]);
		}
	}
	
	// Check scroll position
	var bodyElem = document.body;
	if(bodyElem) {
		var scroll = bodyElem.scrollTop;
		var len = this.scroll.length;
		if(len == 0
		|| this.scroll[len - 1][1] != scroll
		) {
			this.scroll.push([new Date().getTime(), scroll]);
		}
	}
	
	// Check page width
	var page = document.getElementById('page_template');
	if(page) {
		var pageWidth = page.offsetWidth;
		var len = this.widths.length;
		if(len == 0
		|| this.widths[len - 1][1] != pageWidth
		) {
			this.widths.push([new Date().getTime(), pageWidth]);
		}
	}
	
	// Get focus elem
	var focusElem = document.activeElement;
	if(focusElem) {
		var id = focusElem.id;
		if(id != this.focusId) {
			if(id == null) id = "doc"
			this.focusId = id;
			var idArr = this.StringToArray(id);
			this.focus.push([new Date().getTime(), idArr]);
		}
	}
	
	setTimeout(this.Loop.bind(this), 100)
};

/*******************************************************************************
 * OnMouseUp - called when the mouse up event fires
 *
 * param - data : not used
 ******************************************************************************/
this.OnMouseUp = function(data) {
	if(!this.relElem) this.relElem = document.getElementsByClassName('thepageinner')[0];
	var offset = Packages.Library.$.GetElemPosition({elem: this.relElem});
	if(offset) {
		this.clicks.push([new Date().getTime(), Packages.Library.$v.Mouse.x - offset.x, Packages.Library.$v.Mouse.y - offset.y]);
	}
}

/*******************************************************************************
 * OnKeyUp - called by DOM when key up, converts to actual char typed
 ******************************************************************************/
this.OnKeyUp = function(e) {
	// Account for JavaScript keycodes
	e = e || window.event;
	var code = e.keyCode;
	if(code == 13) code = 10;
	if(code > 64 && code <= 90) {
		if(e.shiftKey != 1) code += 32;
	}
	var c = String.fromCharCode(code);
	var shifts = {
		"1": "!",
		"2": "\"",
		"3": "£",
		"4": "$",
		"5": "%",
		"6": "^",
		"7": "&",
		"8": "*",
		"9": "(",
		"0": ")",
		"-": "_",
		"=": "+",
		";": ":",
		"'": "@",
		",": "<",
		".": ">",
		"/": "?",
	};
	if(e.shiftKey == 1 && shifts[c] != null) c = shifts[c];
	var n = this.ToNum(c);
	if(code == 8) n = 0;
	if(n == null) return;
	this.keys.push([new Date().getTime(), n]);
}

// Create quick lookup tables
this.chars = ["[Backspace]", "", " ", "\f", "\"", "'", "/", "\\", "+", "-", "*", "=", "&", "%", "$", "#", "(", ")", "[", "]", "{", "}", ".", ",", "?", "!", "@", "_", ":", ";", "|", "^"]; // 32

for(var i = 1; i <= 26; i++) {
	this.chars[32+i] = String.fromCharCode(i + 64);
	this.chars[32+i+26] = String.fromCharCode(i + 97);
}
for(var i = 1; i <= 10; i++) {
	this.chars[32+i+52] = String.fromCharCode(45 + i - 1);
}
/*******************************************************************************
 * ToNum - Converts a char into a numeric representation
 ******************************************************************************/
this.ToNum = function(c) {
	if(this.reverseChars == null) {
		this.reverseChars = {};
		for(var i = 0; i < 100; i++) {
			this.reverseChars[this.chars[i]] = i;
		}
	}
	return this.reverseChars[c];
}
/*******************************************************************************
 * ToChar - Reverses the ToNum process
 ******************************************************************************/
this.ToChar = function(n) {
	return this.chars[n];
}
/*******************************************************************************
 * StringToArray - As for ToNum but for a string
 ******************************************************************************/
this.StringToArray = function(str) {
	var arr = [];
	for(var i = 0; i < str.length; i++) {
		arr.push(this.ToNum(str.charAt(i)));
	}
	return arr;
}
/*******************************************************************************
 * ArrayToString - Reverse the StringToArray process
 ******************************************************************************/
this.ArrayToString = function(arr) {
	var str = "";
	for(var i = 0; i < arr.length; i++) {
		str += this.ToChar(arr[i]);
	}
	return str;
}

/*********************************************************************
 * EventCookieUsage - callback when cookie usage is requested
 *
 * returns information about this cookie
 ********************************************************************/
this.EventCookieUsage = function(data) {
	return {
		id : "tracking",
		party: 1, // First party cookies
		description: "Standard Tracking",
		detail: "Analyses webpage interaction for usability improvements."
	};
};
this.eventCookieUsage = Packages.Library.$.EventSubscribe({eventname: "CookieUsage", callback: this.EventCookieUsage.bind(this), groupname: "mhtm_render", obj: this});};
// Package: FileType.mhtm.Panels
Package('FileType.mhtm.Panels').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.$s.mhtm != null) $super = new Packages.FileType.mhtm.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 1
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup] as classpath [FileType.mhtm.Panels]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/_view/Version.js] as classpath [FileType.mhtm.Panels] 
this.PanelVersion = 5;

// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/_view/View.js] as classpath [FileType.mhtm.Panels] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
    var content = this.html.content_htm;
    if(content == null) return ""; // No default content
    return Packages.Library.$.ReplaceReferencesWithObjectValues({
        text: content,
        object: this.data.data
    });
};};
// Package: FileType.mhtm.Panels.Download
Package('FileType.mhtm.Panels.Download').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Download] as classpath [FileType.mhtm.Panels.Download]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Download/_view/Display.js] as classpath [FileType.mhtm.Panels.Download] 
/************************************************
 * Update - updates panel to latest version
 ***********************************************/
this.Update = function() {
	if(this.data.data.nofilescontent == null) this.data.data.nofilescontent = "";
	if(this.data.data.files == null) this.data.data.files = [];
}
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	var html = "";
	var i = 0;
	if(this.data.data.files == null || this.data.data.files.length == 0) return this.data.data.nofilescontent;
	while(i < this.data.data.files.length) {
		var filename = this.data.data.files[i].substr(this.data.data.files[i].lastIndexOf('/') + 1);
		var tidyname = filename.substr(0, filename.lastIndexOf('.'));
		tidyname = tidyname.replace(/_/, " ");
		var download = "";
		if (Packages.FileType.mhtm.$i.view.interactivemode == 1) {
			var path = this.data.data.files[i];
			if(!path.match(/http/i)) path = Packages.Library.$.GetPathToBase({filepath: path});
			download += "<a href='" + path + "'>" + tidyname + "<\/a>";
		} else {
			download += tidyname;
		}
		if(this.data.data.standardStyles != 0) {
			download = "<div class='download_file'>" + download + "<\/div>";
		}
		
		html += Packages.Library.Wrappers.$.WrapHtml({
			wrappers: this.data.data.downloadWrappers,
			html : download,
			subOptions: {
				interactivemode: Packages.FileType.mhtm.$i.view.interactivemode
			}
		});
		
		i++;
	}
	return html;
};
/*********************************************************************
 * EventGetCSS - callback to fetch CSS for the page
 *
 * param - data : data about this event
 *
 * returns a hash containing
 *      id : a unique id to ensure this gets loaded only once
 *      css : the CSS for this item
 ********************************************************************/
this.EventGetCSS = function(data) {
	return { id: 'downloadcss', css: this.css.Styles_css};
};
this.eventGetCSS = Packages.Library.$.EventSubscribe({eventname: "GetCSS", callback: this.EventGetCSS.bind(this), groupname: "mhtm_render", obj: this});

// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Download/_view/Styles.css] as classpath [FileType.mhtm.Panels.Download] 
this.css.Styles_css=".download {\n"
	+ "}\n"
	+ ".download_file {\n"
	+ "    $bar$\n"
	+ "    $panelspacing$\n"
	+ "    padding:5px;\n"
	+ "}\n"
	+ ".download_file a {\n"
	+ "    $barText$\n"
	+ "    text-decoration:none;\n"
	+ "}\n"
	+ ".download_file:hover {\n"
	+ "    $highlight$\n"
	+ "}";
};
// Package: FileType.mhtm.Panels.Gallery
Package('FileType.mhtm.Panels.Gallery').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Gallery] as classpath [FileType.mhtm.Panels.Gallery]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Gallery/_view/view.js] as classpath [FileType.mhtm.Panels.Gallery] 
this.textVar = GetTextRef(this);
/*******************************************************************************
 * Update - Updates data to latest format
 ******************************************************************************/
this.Update = function() {
	if(this.data.data.fs_effect == null) this.data.data.fs_effect = "Cut";
	if(this.data.data.sm_effect == null) this.data.data.sm_effect = "Cut";
	this.data.data.fs_effect = this.data.data.fs_effect.charAt(0).toUpperCase() + this.data.data.fs_effect.substr(1);
	this.data.data.sm_effect = this.data.data.sm_effect.charAt(0).toUpperCase() + this.data.data.sm_effect.substr(1);
	if(this.data.data.width  == -1) this.data.data.width  = 190;
	if(this.data.data.height == -1) this.data.data.height = 145;
};
/*******************************************************************************
 * Display - Creates the markup for this panel
 *
 * Note - the gallery automatically makes itself live
 ******************************************************************************/
this.Display = function() {
	if(this.data.data.img == null) {
		this.error = "No images selected";
		return null;
	}
	// Create a new gallery object
	this.gallery = {
		sm_effect: 	this.data.data.sm_effect,
		fs_effect: 	this.data.data.fs_effect,
		width: 		this.data.data.width,
		height: 	this.data.data.height,
		delay: 		this.data.data.delay,
		transitionTime: this.data.data.transitionTime,
		miniImages: this.data.data.miniImages,
		stretch:	this.data.data.stretch,
		viewerControl: this.data.data.viewerControl,
		pages: []
	};
	
	if(Packages.FileType.mhtm.$i.view.testing == 1) {
		this.gallery.animate = 0;
	}
	
	if(Packages.FileType.mhtm.$.view.GetInteractiveMode() != 1) {
		// Disable full screen when in non interactive mode
		this.gallery.fs_effect = null;
	}
	
	// Create the markup for each page
	for(var i = 0; i < this.data.data.img.length; i++) {
		this.gallery.pages[i] = "<img style=\"width:100%\" src=\"" + Packages.Library.$.GetPathToBase({filepath: this.data.data.img[i]}) + "\">";
	}
	
	// Disable user settings when in edit mode
	if(this.data.edit != null) this.gallery.useCookieData = 0;
	
	// Get the object
	this.gallery.Gallery = new Packages.Library.Gallery.Gallery(this.gallery);
	return this.gallery.Gallery.Display();
};};
// Package: FileType.mhtm.Panels.HeadingMenu
Package('FileType.mhtm.Panels.HeadingMenu').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/HeadingMenu] as classpath [FileType.mhtm.Panels.HeadingMenu]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/HeadingMenu/_view/Display.js] as classpath [FileType.mhtm.Panels.HeadingMenu] 
/*********************************************************************
 * Display - entry point for this panel
 ********************************************************************/
this.Display = function() {
	return "";
};
/*********************************************************************
 * Render - called back after Display to get contents of area
 ********************************************************************/
this.Live = function() {
	var html = "<ul class='headmenu'>";
	var areaelems = document.getElementsByClassName("area_" + this.data.data.area);
	if(areaelems.length == 0) return null;
	var areaelem = areaelems[0];
	this.PushTagsOnHeadingsInElem(areaelem, "pnmenu");
	
	// Go through an get all 'h' tag nodes, and then add an <a> tag to each one
	if(areaelem == null) return null;
	var items = areaelem.getElementsByTagName('a');
	for(var i = 0; i < items.length; i++) {
		if(items[i].name != "" && items[i].innerHTML != "") {
			var header = items[i].innerText;
			if(header == null) header = items[i].innerHTML;
			var headingSize = 0;
			if(items[i].className != null && items[i].className.match(/anchor_h(\d+)/)) headingSize = RegExp.$1;
			if(headingSize == 0) continue; // Skip those not added through PushTagsOnHeadingsInElem
			html += "<li><a href='#" + items[i].name + "' class='headmenu headmenu_indent" + headingSize + "'>" + header + "<\/a><\/li>";
		}
	}
	html += "<\/ul>";
	return html;
};
/*********************************************************************
 * PushTagsOnHeadingsInElem - puts a tags on all hx tags in this elem (recursive)
 *
 * param - elem : DOM object of area to look in
 * param - id : the id prefix for 'a' tag names
 ********************************************************************/
this.PushTagsOnHeadingsInElem = function(elem, id) {
	if(elem == null) return;
	// Get all children owned by this elem
	var children = elem.children;
	for(var i = 0; i < children.length; i++) {
		var childid = id + "_" + i;
		var child = children[i];
		// Recurse in and see if it has any more children
		this.PushTagsOnHeadingsInElem(child, childid);
		if(child.nodeName.match(/^h(\d)$/i)) {
			var headingSize = RegExp.$1;
			// This is a heading tag
			if(child.children.length == 0) {
				// Has no children on its own - good
				
				// Wrap heading content in an <a> tag with a name
				child.innerHTML = "<a name='" + childid + "' class='anchor_h" + headingSize + "'>" + child.innerHTML + "<\/a>";
			}
		}
	}
};
/*********************************************************************
 * EventGetCSS - callback to fetch CSS for the page
 *
 * param - data : data about this event
 *
 * returns a hash containing
 *      id : a unique id to ensure this gets loaded only once
 *      css : the CSS for this item
 ********************************************************************/
this.EventGetCSS = function(data) {
	return { id: 'headingcss', css: this.css.Styles_css};
};
this.eventGetCSS = Packages.Library.$.EventSubscribe({eventname: "GetCSS", callback: this.EventGetCSS.bind(this), groupname: "mhtm_render", obj: this});

// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/HeadingMenu/_view/Styles.css] as classpath [FileType.mhtm.Panels.HeadingMenu] 
this.css.Styles_css=".headmenu {\n"
	+ "    padding: 2px;\n"
	+ "}\n"
	+ ".headmenu li {\n"
	+ "    list-style: none;\n"
	+ "    margin:0px;\n"
	+ "    display: block;\n"
	+ "}\n"
	+ ".headmenu {\n"
	+ "    display: block;\n"
	+ "    margin-bottom: 10px;\n"
	+ "}\n"
	+ ".headmenu_indent1 {\n"
	+ "    margin-left: 0px;\n"
	+ "}\n"
	+ ".headmenu_indent2 {\n"
	+ "    margin-left: 10px;\n"
	+ "}\n"
	+ ".headmenu_indent3 {\n"
	+ "    margin-left: 20px;\n"
	+ "}\n"
	+ ".headmenu_indent4 {\n"
	+ "    margin-left: 30px;\n"
	+ "}\n"
	+ ".headmenu_indent5 {\n"
	+ "    margin-left: 40px;\n"
	+ "}\n"
	+ ".headmenu_indent6 {\n"
	+ "    margin-left: 50px;\n"
	+ "}";
};
// Package: FileType.mhtm.Panels.Host
Package('FileType.mhtm.Panels.Host').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Host] as classpath [FileType.mhtm.Panels.Host]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Host/_view/Display.js] as classpath [FileType.mhtm.Panels.Host] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	return "<div class='hostpanel'>"
			+	Packages.FileType.mhtm.$.CreatePanelHost(this.data.data.hostname)
		+	"<\/div>";
};
/*********************************************************************
 * FindPanelHost - callback when search for hosts performed
 *
 * returns a hash of information:
 * 		name : name to display
 * 		id : element id to write to
 ********************************************************************/
this.FindPanelHost = function(data) {
	if(this.data.data.hostname == "" || this.data.data.hostname == null) return null;
	return {
		name : this.data.data.hostname
	};
};
// Set up events
this.eventFindPanel = Packages.Library.$.EventSubscribe({eventname: "FindPanelHost", callback: this.FindPanelHost.bind(this), groupname: "mhtm_render", obj: this});};
// Package: FileType.mhtm.Panels.Html
Package('FileType.mhtm.Panels.Html').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Html] as classpath [FileType.mhtm.Panels.Html]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Html/_view/Display.js] as classpath [FileType.mhtm.Panels.Html] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	return Packages.Library.$.ConvertLegacy({str: this.data.data.html});
};
/*********************************************************************
 * EventCookieUsage - callback when cookie usage is requested
 *
 * returns information about this cookie
 ********************************************************************/
this.EventCookieUsage = function(data) {
	return {
		id : "htmlpanel",
		party: 3, // Third party content
		description: "Third Party HTML Embedded content"
	};
};
this.eventCookie = Packages.Library.$.EventSubscribe({eventname: "CookieUsage", callback: this.EventCookieUsage.bind(this), groupname: "mhtm_render", obj: this});};
// Package: FileType.mhtm.Panels.Image
Package('FileType.mhtm.Panels.Image').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Image] as classpath [FileType.mhtm.Panels.Image]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Image/_view/Display.js] as classpath [FileType.mhtm.Panels.Image] 
/************************************************
 * Update - updates the data to the latest version
 ***********************************************/
this.Update = function() {
	if(this.data.data.width  == null) this.data.data.width  = "";
	if(this.data.data.height == null) this.data.data.height = "";
	if(this.data.data.caption == null) this.data.data.caption = "";
};
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	var path = Packages.Library.$.GetPathToBase({filepath: this.data.data.img});
	var imgStyles = "style='" +
						(this.data.data.width != "" ? "width:" + this.data.data.width + "px;" : "") +
						(this.data.data.height != "" ? "height:" + this.data.data.height + "px;" : "") +
					"'";
	var caption = Packages.Library.$.ConvertCRToBR({
		str: Packages.Library.$.GetVersionOfData({
			data: this.data.data.caption
		})
	});
	if(caption == null) caption = "";
	var img = "<img " +
				"src='" + path + "?req-plain=1' " +
				"alt='" + Packages.Library.$.GetVersionOfData({
							data: this.data.data.alt
						}) + "' " +
				(caption == "" ? imgStyles : "") +
			">";
	
	if(this.data.data.popup == 1 && Packages.FileType.mhtm.$.view.GetInteractiveMode() == 1) {
		img = Packages.Library.$.CreatePopupArea({
			buttonText: img,
			content: "<img " +
						"src='" + path + "?req-plain=1' " +
						"alt='" + Packages.Library.$.GetVersionOfData({
									data: this.data.data.alt
								}) + "' " +
						"style='width:100%;height:auto;'" +
					">",
			noButtonStyle: 1
		});
	}
	
	var html = "";
	if(caption != "") {
		html += "<div class='imagecaptioncontainer' " + imgStyles + ">"
		html += "<div class='imageimage'>";
		html += img;
		html += "<\/div>";
		html += "<div class='imagecaption'>";
		html += caption;
		html += "<\/div>";
		html += "<\/div>";
	} else {
		html += img;
	}
	return html;
};
this.Live = this.Display;
/*********************************************************************
 * EventGetCSS - callback to fetch CSS for the page
 *
 * param - data : data about this event
 *
 * returns a hash containing
 *      id : a unique id to ensure this gets loaded only once
 *      css : the CSS for this item
 ********************************************************************/
this.EventGetCSS = function(data) {
	return { id: 'imagecss', css: this.css.Styles_css};
};
this.eventGetCSS = Packages.Library.$.EventSubscribe({eventname: "GetCSS", callback: this.EventGetCSS.bind(this), groupname: "mhtm_render", obj: this});

// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Image/_view/Styles.css] as classpath [FileType.mhtm.Panels.Image] 
this.css.Styles_css=".titlebanner .image {\n"
	+ "    border:none;\n"
	+ "}\n"
	+ ".imagecaption {\n"
	+ "    font-size:8pt;\n"
	+ "    padding:2px;\n"
	+ "}\n"
	+ ".imageimage {\n"
	+ "    overflow:hidden;\n"
	+ "    border-bottom: 2px solid #888888;\n"
	+ "}\n"
	+ ".imagecaptioncontainer {\n"
	+ "    $borderedPanel$\n"
	+ "    border:1px solid #888888;\n"
	+ "    margin:5px;\n"
	+ "    overflow:hidden;\n"
	+ "}";
};
// Package: FileType.mhtm.Panels.Inherit
Package('FileType.mhtm.Panels.Inherit').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Inherit] as classpath [FileType.mhtm.Panels.Inherit]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Inherit/_view/Display.js] as classpath [FileType.mhtm.Panels.Inherit] 
// Place holder only
this.Display = function() { return ""; };};
// Package: FileType.mhtm.Panels.LastEdited
Package('FileType.mhtm.Panels.LastEdited').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/LastEdited] as classpath [FileType.mhtm.Panels.LastEdited]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/LastEdited/_view/Display.js] as classpath [FileType.mhtm.Panels.LastEdited] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	var lastEdit = Packages.FileType.mhtm.$i.view.pLastEdit;
	if(Packages.Library.$v.testing == 1) lastEdit = 1000000000000;
	var html = "";
	var date = new Date(parseInt(lastEdit));
	html += date.toUTCString();
	return html;
};};
// Package: FileType.mhtm.Panels.Logon
Package('FileType.mhtm.Panels.Logon').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Logon] as classpath [FileType.mhtm.Panels.Logon]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Logon/_view/Display.js] as classpath [FileType.mhtm.Panels.Logon] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	return Packages.Library.$.CreateAccountForm({
		reloadOnLogin: 1,
		signupTemplate: this.data.data.templateUser,
		singleFieldLogin: this.data.data.singleFieldLogin
	});
};
this.Live = this.Display;

/*********************************************************************
 * EventGetCSS - callback to fetch CSS for the page
 *
 * param - data : data about this event
 *
 * returns a hash containing
 *      id : a unique id to ensure this gets loaded only once
 *      css : the CSS for this item
 ********************************************************************/
this.EventGetCSS = function(data) {
	return { id: 'logoncss', css: this.css.Styles_css};
};
this.eventGetCSS = Packages.Library.$.EventSubscribe({eventname: "GetCSS", callback: this.EventGetCSS.bind(this), groupname: "mhtm_render", obj: this});

// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Logon/_view/Styles.css] as classpath [FileType.mhtm.Panels.Logon] 
this.css.Styles_css=".account_signform .form_container{\n"
	+ "    background: none;\n"
	+ "}\n"
	+ ".account_signform .form_label{\n"
	+ "    background: none;\n"
	+ "}\n"
	+ ".account_signform .form_item{\n"
	+ "    background: none;\n"
	+ "}";
};
// Package: FileType.mhtm.Panels.Menu
Package('FileType.mhtm.Panels.Menu').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Menu] as classpath [FileType.mhtm.Panels.Menu]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Menu/_view/Display.js] as classpath [FileType.mhtm.Panels.Menu] 
this.textvar = GetTextRef(this);
/*********************************************************************
 * Display - Entry point - creates the menu
 ********************************************************************/
this.Display = function() {
	var panel = this.data;
	var startFolder = Packages.FileType.mhtm.$i.view.pSubFolder;
	var htmlpath = '';
	if(panel.data.start == 1) {
		startFolder = pContainerFolders;
		htmlpath = Packages.FileType.mhtm.$i.view.pBaseOffset;
	}
	if(Packages.FileType.mhtm.$i.view.testing == 1) {
		startFolder = Packages.Library.$.GetTestSampleFolderList({});
	}
	panel.$noDump.cache.frameid = 'menuframe' + Packages.Library.$.GetUniqueId({});
	var filetypes = ['csv', 'jpg', 'jpeg', 'gif', 'news', 'png'];
	var special = {};
	for(var i = 0; i < filetypes.length; i++) {
		special[filetypes[i]] = {onclick: "Packages.FileType.mhtm.Panels.Menu.OpenFile", href: '#'};
	}
	// To hide submenus, we set their class to 'hidden'
	
	// Determine classnames
	var menubarclass = (panel.data.barstyles != 0 ? " menuBar" : " menuNoBorder");
	if(panel.data.styleitem == 1) {
		menubarclass = " menuNoBorder menuItemBar";
	}
	
	var mainClassName = menubarclass;
	var subClassName = menubarclass;
	
	var menuitems = [];
	if(panel.data.specificItems.length == 0) {
		menuitems = Packages.Library.$.CreateMenuTreeFromFolderTree({
			folder: startFolder,
			path: htmlpath,
			skipList: ["robots.txt", "!master.mhtm"],
			firstItem: "Home.mhtm",
			specExt: special
		});
	} else {
		// Use the specific list of items to be shown
		for(var i = 0; i < panel.data.specificItems.length; i++) {
			var item = panel.data.specificItems[i];
			
			// Create menu item
			var menuitem = {};
			
			// Add data to menu item
			menuitem.href = item.url;
			if(item.img != null && item.img != "") {
				menuitem.img = Packages.Library.$.GetPathToBase({filepath: item.img});
			} else {
				menuitem.name = item.name;
			}
			
			// Add menuitem to menuitems
			menuitems.push(menuitem);
		}
	}
	
	// Do we have a host panel?
	if(panel.data.hostname != "") {
		menuitems.push({
			html: Packages.FileType.mhtm.$.CreatePanelHost(this.data.data.hostname)
		});
	}
	
	// Create HTML
	var html = "";
	html += Packages.Library.$.CreateMenu({
		menudata: menuitems,
		classes: [mainClassName, subClassName, subClassName, subClassName, subClassName],
		selectedclass: "menuSelected",
		horizontal: panel.data.horizontal,
		leftopen: panel.data.leftopen,
		hideSubMenus: (panel.data.submenus ? 0 : 1),
		disabled: (Packages.FileType.mhtm.$i.view.interactivemenumode == 1 ? 0 : 1),
		block2and3: (panel.data.block2and3 ? 1 : 0)
	});
	
	html += "<div class='menuframe' id='" + panel.$noDump.cache.frameid + "'><\/div>";
	
	return html;
};
/*********************************************************************
 * Update - updates data to latest version
 ********************************************************************/
this.Update = function() {
	var panel = this.data;
	if(panel.data.submenus == null) panel.data.submenus = 1;
	if(panel.data.hostname == null) panel.data.hostname = "";
	if(panel.data.barstyles == null) panel.data.barstyles = 1;
	if(panel.data.menublock == null) panel.data.menublock = 0;
	if(panel.data.specificItems == null) panel.data.specificItems = [];
};
/*********************************************************************
 * FindPanelHost - callback when search for hosts performed
 *
 * returns a hash of information:
 * 		name : name to display
 * 		id : element id to write to
 ********************************************************************/
this.FindPanelHost = function(data) {
	var panel = this.data;
	if(panel.data.hostname == null || panel.data.hostname == "") return null;
	return {
		name : panel.data.hostname
	};
};
// Set up events
this.eventFindPanel = Packages.Library.$.EventSubscribe({eventname: "FindPanelHost", callback: this.FindPanelHost.bind(this), groupname: "mhtm_render", obj: this});
/*********************************************************************
 * EventGetCSS - callback to fetch CSS for the page
 *
 * param - data : data about this event
 *
 * returns a hash containing
 *      id : a unique id to ensure this gets loaded only once
 *      css : the CSS for this item
 ********************************************************************/
this.EventGetCSS = function(data) {
	return { id: 'menucss', css: this.css.Styles_css};
};
this.eventGetCSS = Packages.Library.$.EventSubscribe({eventname: "GetCSS", callback: this.EventGetCSS.bind(this), groupname: "mhtm_render", obj: this});

// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Menu/_view/Styles.css] as classpath [FileType.mhtm.Panels.Menu] 
this.css.Styles_css=".menuBar, .menuItemBar li, .menuBar .menucontainer{\n"
	+ "    text-transform:capitalize;\n"
	+ "    $bar$\n"
	+ "    position:relative;\n"
	+ "}\n"
	+ ".menucontainer0 li {\n"
	+ "    $menuspacing$\n"
	+ "}\n"
	+ ".menucontainer1 li {\n"
	+ "    margin: 0px;\n"
	+ "}\n"
	+ ".menuBar li, .menuItemBar li {\n"
	+ "    max-width: $menuwidth$;\n"
	+ "    min-height: $menuheight$\n"
	+ "}\n"
	+ ".menuBar a, .menuItemBar a {\n"
	+ "    $barText$\n"
	+ "}\n"
	+ ".menuNoBorder,\n"
	+ ".menuNoBorder .menucontainer {\n"
	+ "    border:none;\n"
	+ "    background:none;\n"
	+ "    max-width: none;\n"
	+ "}\n"
	+ ".menuNoBorder .menucontainer1,\n"
	+ ".menuNoBorder .menucontainer2,\n"
	+ ".menuNoBorder .menucontainer3 {\n"
	+ "    background-color:#ffffff;\n"
	+ "    border: 1px solid #888888;\n"
	+ "    color: #000000;\n"
	+ "}\n"
	+ ".menuBar li:hover, .menuItemBar li:hover {\n"
	+ "    $highlight$\n"
	+ "}\n"
	+ ".menuNoBorder ul li:hover {\n"
	+ "    /*background:none;*/\n"
	+ "}\n"
	+ ".menuSelected {\n"
	+ "    font-weight:bold;\n"
	+ "}\n"
	+ ".menuframe {\n"
	+ "    position:fixed;\n"
	+ "    top:0;\n"
	+ "    left:0;\n"
	+ "    padding-top:2%;\n"
	+ "    padding-left:20%;\n"
	+ "    padding-right:20%;\n"
	+ "    width:60%;\n"
	+ "    display:none;\n"
	+ "    z-index:1000;\n"
	+ "}\n"
	+ ".menuframe iframe{\n"
	+ "    position:relative;\n"
	+ "    margin:0;\n"
	+ "    background-color:#FFFFFF;\n"
	+ "    display:block;\n"
	+ "}";


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Menu/_view.global/OpenFile.js] as classpath [FileType.mhtm.Panels.Menu] 
/*********************************************************************
 * OpenFile - Opens a 'non mhtm' page in an iframe pop up
 *
 * param - link : the src of the iframe
 * param - extension : extension of the object to load
 ********************************************************************/
Packages.FileType.mhtm.Panels.Menu.OpenFile = function(link, extension) {
    if(extension == "") return false;
	var html = "";
	switch(extension) {
		case 'png' :
		case 'jpg' :
		case 'gif' :
			{
				html = "<img src='"+link+"' style='width:100%;' alt=''\/>";
			}
			break;
		default:
			{
				html = "<iframe src='" + link + "' style='width:100%;height:100%;'>" + Packages.Library.$.GetLoaderImg() + "<\/iframe>";
			}
	}
	Packages.Library.$.CreatePopupQuery({
		message: html,
		buttons: {},
		wrapMessage: 0
	});
	
	return false; // Stop processing
};};
// Package: FileType.mhtm.Panels.PanelMenu
Package('FileType.mhtm.Panels.PanelMenu').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/PanelMenu] as classpath [FileType.mhtm.Panels.PanelMenu]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/PanelMenu/_view/Display.js] as classpath [FileType.mhtm.Panels.PanelMenu] 
/*********************************************************************
 * Display - entry point for this panel
 ********************************************************************/
this.Display = function() {
	return ""; // List generated on live only
};
/*********************************************************************
 * Render - called back after Display to get contents of area
 ********************************************************************/
this.Live = function() {
	var html = "<ul class='menu'>";
	var areaelems = document.getElementsByClassName("area_" + this.data.data.area);
	if(areaelems.length == 0) return null;
	var areaelem = areaelems[0];
	var items = areaelem.getElementsByClassName('wrapper_title_anchor');
	for(var i = 0; i < items.length; i++) {
		if(items[i].name != "" && items[i].innerHTML != "") {
			var header = items[i].innerText;
			if(header == null) header = items[i].innerHTML;
			html += "<li><a href='#" + items[i].name + "'>" + header + "<\/a><\/li>";
		}
	}
	html += "<\/ul>";
	return html;
};};
// Package: FileType.mhtm.Panels.RichText
Package('FileType.mhtm.Panels.RichText').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/RichText] as classpath [FileType.mhtm.Panels.RichText]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/RichText/_view/view.js] as classpath [FileType.mhtm.Panels.RichText] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
    var html = Packages.Library.$.FixHrefs({
        content: Packages.Library.$.ConvertLegacy({
            str: Packages.Library.$.GetVersionOfData({
                data: this.data.data.richtext
            })
        })
    });
    if(this.data.applySystemWrappers != 0) html = "<div class='richtext' id='richtext_editor" + this.data.$noDump.uid + "'>" + html + "<\/div>";
    return html;
};};
// Package: FileType.mhtm.Panels.Seasonal
Package('FileType.mhtm.Panels.Seasonal').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Seasonal] as classpath [FileType.mhtm.Panels.Seasonal]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Seasonal/_view/Display.js] as classpath [FileType.mhtm.Panels.Seasonal] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	var d = new Date();
	var month = d.getMonth();
	var day = d.getDate();
	
	var icon = "";
	// christmas
	if(month == 11) icon = 'holly.png';
	if(month == 11 && Math.random()>0.5) icon = 'ctree.png';
	// valentines
	if(month == 1 && day == 14) icon = 'valentine.png';

	var html = "";
	if(icon != "") {
		html = "<img src='/System/Software/Images/seasonal/"+icon+"?req-plain=1'";
		if(this.data.data.width != "") html += " width='"+this.data.data.width+"px' style='width:"+this.data.data.width+"px'";
		if(this.data.data.height != "") html += " height='"+this.data.data.height+"px'  style='height:"+this.data.data.height+"px'";
		html += " alt=''>";
	}
	return html;
};};
// Package: FileType.mhtm.Panels.SiteMap
Package('FileType.mhtm.Panels.SiteMap').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/SiteMap] as classpath [FileType.mhtm.Panels.SiteMap]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/SiteMap/_view/Display.js] as classpath [FileType.mhtm.Panels.SiteMap] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	var htmlpath = Packages.Library.$.GetPathToBase({filepath: ""});
	
	// Get menu items
	var startFolder = pContainerFolders;
	if(Packages.FileType.mhtm.$i.view.testing == 1) {
		startFolder = Packages.Library.$.GetTestSampleFolderList({});
	}
	var menuitems = Packages.Library.$.CreateMenuTreeFromFolderTree({
		folder: startFolder,
		path: htmlpath,
		skipList: ["robots.txt", "!master.mhtm"]
	});
	
	// Do we have a host panel?
	if(this.data.data.hostname != null && this.data.data.hostname != "") {
		menuitems.push({
			html: Packages.FileType.mhtm.$.CreatePanelHost(this.data.data.hostname)
		});
	}
	
	// Make sitemap
	return Packages.Library.$.CreateMenu({
		menudata: menuitems,
		disableStyles: 1
	});
};
/*********************************************************************
 * FindPanelHost - callback when search for hosts performed
 *
 * returns a hash of information:
 * 		name : name to display
 * 		id : element id to write to
 ********************************************************************/
this.FindPanelHost = function(data) {
	if(this.data.data.hostname == null || this.data.data.hostname == "") return null;
	return {
		name : this.data.data.hostname
	};
};
// Set up events
this.eventFindPanel = Packages.Library.$.EventSubscribe({eventname: "FindPanelHost", callback: this.FindPanelHost.bind(this), groupname: "mhtm_render", obj: this});};
// Package: FileType.mhtm.Panels.SocialMedia
Package('FileType.mhtm.Panels.SocialMedia').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/SocialMedia] as classpath [FileType.mhtm.Panels.SocialMedia]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/SocialMedia/_view/Display.js] as classpath [FileType.mhtm.Panels.SocialMedia] 
/************************************************
 * Update - updates the data to the latest version
 ***********************************************/
this.Update = function() {
	if(this.data.data.offset == null) this.data.data.offset = 0;
}
/************************************************
 * Live - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Live = function() {
	var style = "position:absolute;right:" + this.data.data.offset + "px;";
	if(Packages.Library.$.IsMobile() || this.data.data.offset == "" || this.data.data.offset == 0) style = "";
	var html = "<div style='text-align:center;" + style + "'>";
	var domain = "http://" + Packages.Library.$.GetDomain({});
	if(Packages.FileType.mhtm.$i.view.testing == 1) return "Untestable due to changes in markup";
	if(this.data.data.facebook == 1) {
		html += "<div style='display:inline-block;margin:2px;max-width:75px !important;'>";
		html += "<iframe src='//www.facebook.com/plugins/like.php?href=";
		html += domain;
		html += "&send=false&layout=box_count&width=45&show_faces=false&action=like&colorscheme=light&font&height=90' scrolling='no' ";
		html += "frameborder='0' style='border:none; overflow:hidden; width:45px; height:60px;' allowTransparency='true'><\/iframe>";
		html += "<\/div>";
	}
	if(this.data.data.gplusone == 1) {
		html += "<div style='display:inline-block;margin:2px;max-width:75px !important;'>";
		html += "<div class='g-plusone' data-size='tall' href='" + domain + "'><\/div>";
		var fileLoader = new Packages.Library.DynamicLoad({
			targetID: "gplus_button"
		});
		fileLoader.Request([{filepath: "https://apis.google.com/js/platform.js", mode: "LT_SCRIPT", className: "mhtm_render"}]);
		html += "<\/div>";
	}
	if(this.data.data.twitter == 1) {
		html += "<div style='display:inline-block;margin:2px;max-width:75px !important;'>";
		html += "<a href='https://twitter.com/share' class='twitter-share-button' data-url='" + domain + "' data-text='" + domain + "' data-count='vertical'>Tweet</a>";
		!function(d,s,id){
			var js,fjs=d.getElementsByTagName(s)[0];
			if(!d.getElementById(id)){
				js=d.createElement(s);
				js.id=id;
				js.className = "mhtm_render";
				js.src='//platform.twitter.com/widgets.js';
				fjs.parentNode.insertBefore(js,fjs);
			}
		}(document,'script','twitter-wjs');
		html += "<\/div>";
	}
	html += "<\/div>";
	return html;
};};
// Package: FileType.mhtm.Panels.Table
Package('FileType.mhtm.Panels.Table').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Table] as classpath [FileType.mhtm.Panels.Table]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Table/_view/Display.js] as classpath [FileType.mhtm.Panels.Table] 
this.selectedTab = "";
this.idprefix = "mhtm_tab" + Packages.Library.$.GetUniqueId({});

/*********************************************************************
 * Display - entry point for this panel
 *
 * Displays a 2D table of panels.
 *
 * If panel.data.tabs is enabled, each cell is actually a tab under the table of buttons
 *  The table contains switching buttons
 ********************************************************************/
this.Display = function() {
	var html = "";
	var tabareahtml = "";
	
	var cellNo = 0;
	var radioHtml = "";
	
	// html += "<table class='tabletable' " + (this.panel.data.autowidth == 1 ? " width='100%'" : "") + ">";
	html += "<div class='tabletable' " + (this.data.data.autowidth == 1 ? " style='width:100%'" : "") + ">";
	for(var y = 0; y < this.data.data.rows; y++) {
		html += "<div class='tablerow'>";
		for(var x = 0; x < this.data.data.cols; x++) {
			// Autowidth
			// html += "<td valign='top' " + (this.data.data.autowidth == 1 ? " width='" + Math.floor(100 / this.data.data.cols) + "%'" : "") + ">";
			html += "<div class='tablecell' " + (this.data.data.autowidth == 1 ? " style='width:" + Math.floor(100 / this.data.data.cols) + "%'" : "") + ">";
			var areaid = this.data.data.id + "_" + x + "_" + y;
			// Create cell separately so it can be placed in table or tab
			var cellpanels = Packages.FileType.mhtm.$i.view.LoadPanelsIn(areaid, Packages.FileType.mhtm.$i.view.page, "v" + areaid, 0);
			if(this.data.data.tabs == 1) {
				// Create hidden tab radio button
				radioHtml += "<input type='radio' style='display:none' id='" + this.idprefix + "rad_" + cellNo + "' name='" + this.idprefix + "'" + (x == 0 && y == 0 ? " checked='checked'" : "") + ">";
				
				// Get tab button
				html += "<div class='tabletabcontainer'><label class='tabletab_btn' id='" + this.idprefix + "btn_" + cellNo + "' for='" + this.idprefix + "rad_" + cellNo + "'>";
				if(Packages.FileType.mhtm.$i.view.page.Areas["v" + areaid] != null) {
					if(Packages.FileType.mhtm.$i.view.page.Areas["v" + areaid].length > 0
					&& Packages.FileType.mhtm.$i.view.page.Areas["v" + areaid][0].Wrappers != null) {
						var titleWrapper = Packages.Library.$.FindArrayItem({array: Packages.FileType.mhtm.$i.view.page.Areas["v" + areaid][0].Wrappers, path: "type", value: "Title"});
						if(titleWrapper != null) {
							html += "<b>" + Packages.Library.$.GetVersionOfData({data: titleWrapper.title}) + "<\/b>";
						}
					}
				}
				html += "<\/label><\/div>";
				
				// Get tab area
				
				// Border
				tabareahtml += "    <div " + (this.data.data.border == 1 ? "class='tabareaborder'" : "") + " id='" + this.idprefix + "area_" + cellNo + "'>";
				tabareahtml += "        <div class='table_tabview' id='" + areaid + "'";
				if(this.data.data.backgroundColour != "" && this.data.data.backgroundColour != null) tabareahtml += "style='background-color: #" + this.data.data.backgroundColour + "' ";
				tabareahtml += ">";
				tabareahtml += cellpanels;
				tabareahtml += "    <\/div><\/div>";
			} else {
				// Border
				html += "    <div " + (this.data.data.border == 1 ? "class='tableborderedcells'" : "");
				if(this.data.data.backgroundColour != "" && this.data.data.backgroundColour != null) html += " style='background-color: #" + this.data.data.backgroundColour + "' ";
				html += ">";
				html += "       <div class='tablecellcontent' id='" + areaid + "'>";
				html += cellpanels;
				html += "   <\/div><\/div>";
			}
			// html += "<\/td>";
			html += "<\/div>";
			
			cellNo++;
		}
		// html += "<\/tr>";
		html += "<\/div>";
		html+="<div style='clear:both;'><\/div>";
	}
	// html += "<\/table>";
	html += "<\/div>";
	if(this.data.data.tabs == 1) {
		this.selectedTab = this.data.data.id + "_" + 0 + "_" + 0;
		html += "<div class='mhtm_tabsarea mclearfix'>" + tabareahtml + "</div>";
		html = radioHtml + html;
	}
	return html;
};

/*********************************************************************
 * Update - called when object created to ensure data is upto date
 ********************************************************************/
this.Update = function() {
	if(this.data.data.border == undefined) this.data.data.border = 0;
	if(this.data.data.autowidth == undefined) this.data.data.autowidth = 1;
};
/*********************************************************************
 * EventGetCSS - callback to fetch CSS for the page
 *
 * param - data : data about this event
 *
 * returns a hash containing
 *      id : a unique id to ensure this gets loaded only once
 *      css : the CSS for this item
 ********************************************************************/
this.EventGetCSS = function(data) {
	var css = this.css.Styles_css;
	
	// Add programatically added tab CSS
	for(var i = 0; i < this.data.data.rows * this.data.data.cols; i++) {
		css += '#' + this.idprefix + "rad_" + i + ':checked ~ div #' + this.idprefix + "btn_" + i + ' {'
				+	'background:none;'
				+	'$bodyBackgroundTopCol$'
				+	'border-bottom:none;'
			+	'}' + "\n";
		css += '#' + this.idprefix + "rad_" + i + ':checked ~ .mhtm_tabsarea #' + this.idprefix + "area_" + i + ' {'
				+	'display:block;'
			+	'}' + "\n";
	}
	
	return { id: 'tablecss', css: css};
};
this.eventGetCSS = Packages.Library.$.EventSubscribe({eventname: "GetCSS", callback: this.EventGetCSS.bind(this), groupname: "mhtm_render", obj: this});

// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Table/_view/Styles.css] as classpath [FileType.mhtm.Panels.Table] 
this.css.Styles_css=".tablecellcontent {\n"
	+ "    border:none;\n"
	+ "    vertical-align:top;\n"
	+ "    white-space:normal;\n"
	+ "    text-wrap:normal;\n"
	+ "    display:inline-block;\n"
	+ "}\n"
	+ ".tablecell	{\n"
	+ "    display:table-cell;\n"
	+ "}\n"
	+ ".tablerow {\n"
	+ "    display:table-row;\n"
	+ "    width:100%;\n"
	+ "}\n"
	+ ".tabletable {\n"
	+ "    display:table;\n"
	+ "    vertical-align:top;\n"
	+ "    height:100%;\n"
	+ "    border-spacing: 0px;\n"
	+ "    position:relative;\n"
	+ "    margin-bottom:-1px;\n"
	+ "}\n"
	+ ".tabletable td {\n"
	+ "    height:100%;\n"
	+ "}\n"
	+ ".tableborderedcells {\n"
	+ "    border: 1px solid black;\n"
	+ "    height:100%;\n"
	+ "}\n"
	+ ".tabareaborder {\n"
	+ "    width:100%;\n"
	+ "    border-top: 1px solid #888888;\n"
	+ "}\n"
	+ ".tabletabcontainer {\n"
	+ "    float:left;\n"
	+ "    overflow-y: hidden;\n"
	+ "    height:25px;\n"
	+ "    margin-bottom:0;\n"
	+ "}\n"
	+ ".tabletab_btn {\n"
	+ "    padding-left:5px;\n"
	+ "    padding-right:5px;\n"
	+ "    float:left;\n"
	+ "    cursor:pointer;\n"
	+ "    height:40px;\n"
	+ "    border: 1px solid #888888;\n"
	+ "    $bar$;\n"
	+ "}\n"
	+ ".tabletab_btn:hover {\n"
	+ "    $highlight$\n"
	+ "}\n"
	+ ".mhtm_tabsarea {\n"
	+ "    position:relative;\n"
	+ "}\n"
	+ ".tabareaborder {\n"
	+ "    $bodyBackground$\n"
	+ "    $shadowsoff$\n"
	+ "    display: none;\n"
	+ "}";
};
// Package: FileType.mhtm.Panels.Tag
Package('FileType.mhtm.Panels.Tag').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Tag] as classpath [FileType.mhtm.Panels.Tag]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Tag/_view/Display.js] as classpath [FileType.mhtm.Panels.Tag] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	return "<" + this.data.data.tag +
				(this.data.data.colour != null && this.data.data.colour != "" ? " style='color:#" + this.data.data.colour + ";'" : "") +
			">" +
				Packages.Library.$.ConvertCRToBR({
					str: Packages.Library.$.ConvertLegacy({
						str: Packages.Library.$.GetVersionOfData({
							data: this.data.data.content
						})
					})
				}) +
			"<\/" + this.data.data.tag + ">";
};};
// Package: FileType.mhtm.Panels.Text
Package('FileType.mhtm.Panels.Text').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Text] as classpath [FileType.mhtm.Panels.Text]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/Text/_view/Display.js] as classpath [FileType.mhtm.Panels.Text] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	if(this.data.data.content == null) this.data.data.content = "";
	var content = Packages.Library.$.ConvertLegacy({
		str: Packages.Library.$.GetVersionOfData({
			data: this.data.data.content
		})
	});
	// Format as paragraphs?
	if(this.data.data.paragraph == 0) {
		return Packages.Library.$.ConvertCRToBR({
			str: content
		});
	}
	return Packages.Library.$.ConvertCRToPT({
		str: content
	});
};};
// Package: FileType.mhtm.Panels.VersionSwitcher
Package('FileType.mhtm.Panels.VersionSwitcher').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/VersionSwitcher] as classpath [FileType.mhtm.Panels.VersionSwitcher]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/VersionSwitcher/_view/Display.js] as classpath [FileType.mhtm.Panels.VersionSwitcher] 
/************************************************
 * Preload - called before any other panel or attribute is displayed
 ***********************************************/
this.Preload = function() {
	// Get currently selected version from the cookie
	var currentVersion = Packages.Library.$.GetCookies({}).currentVersion;
	// Determine if there is a new version is being selected in the query string
	var selectedVersion = Packages.Library.$.GetQuery({attr: "versionswitch"});
	if(selectedVersion) {
		currentVersion = selectedVersion;
		Packages.Library.$.SetCookie({hash: {currentVersion: currentVersion}});
	}
	// Or default to the default
	if(currentVersion == null) currentVersion = Packages.Library.$.GetDefaultVersion();
	
	this.currentVersion = currentVersion;
}
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	var html = "";
	
	// Create list of available versions
	var versions = Packages.Library.$.GetActiveVersions();
	
	var currentVersion = this.currentVersion;
	
	// List them
	for(var i = 0; i < versions.length; i++) {
		var version = versions[i];
		
		// Determine whether making a href (node) or onclick (non node)
		var hrefOrClick = "";
		if(Packages.Library.$c.IsNode == 1) {
			var href = Packages.Library.$.AddGlobalQueries({queries: {versionswitch: version.refcode}});
			hrefOrClick = "onclick=\"Packages.Library.$.SetCookie({hash: {currentVersion: '" + version.refcode + "'}});\" href=\"" + href + "\"";
		} else {
			hrefOrClick = "onclick=\"Packages.Library.$.SetCookie({hash: {currentVersion: '" + version.refcode + "'}}); Packages.FileType.mhtm.$i.view.RenderPage();\" href='#'";
		}
		
		html += "<li " +
					"class='" +
						"versionItem" +
						(version.refcode == currentVersion ? " versionItemSelected" : "") +
						(this.data.data.usebuttonsstyles ? " mbutton" : "") +
						(this.data.data.usebuttonsstyles && version.refcode == currentVersion ? " mbuttonselected" : "") +
					"'" +
				">" +
					"<a " +
						hrefOrClick +
					">" +
						version.name +
					"</a>" +
				"<\/li>";
	}
	
	return "<ul>" + html + "<\/ul>";
};};
// Package: FileType.mhtm.Panels.W3c
Package('FileType.mhtm.Panels.W3c').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/W3c] as classpath [FileType.mhtm.Panels.W3c]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/W3c/_view/Display.js] as classpath [FileType.mhtm.Panels.W3c] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	var html = "";
	html =  "<a href='http://validator.w3.org/check?uri=referer' style='width:88px;float:right;margin:0;'>";
	html += "<img src='http://www.w3.org/Icons/valid-html40' alt='Valid HTML 4.0 Transitional' height='31' width='88'><\/a>";
	html += "<a href='http://jigsaw.w3.org/css-validator/check/referer' style='width:88px;float:right;margin:0;'>";
	html += "<img style='border:0;width:88px;height:31px' src='http://jigsaw.w3.org/css-validator/images/vcss' alt='Valid CSS!'><\/a>";
	return html;
};};
// Package: FileType.mhtm.Panels.XCSV
Package('FileType.mhtm.Panels.XCSV').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/XCSV] as classpath [FileType.mhtm.Panels.XCSV]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/XCSV/_view/view.js] as classpath [FileType.mhtm.Panels.XCSV] 
this.xcsv = null;
this.ready = 1;
/************************************************
 * Update - called to update this panel data to the latest format
 ***********************************************/
this.Update = function() {
	// If using older method of specifying where each control sits, update to new method
	if(this.data.data.listingControls == null) {
		this.data.data.listingControls = [];
		var names = ["filter", "compare", "search", "locator"];
		for(var i = 0; i < names.length; i++) {
			// Get old value
			var hostPanel = this.data.data[names[i] + "HostPanel"];
			if(hostPanel == "none") continue;
			if(hostPanel == "this") hostPanel = "thisTop";
			// Create new entry in new format
			this.data.data.listingControls.push({
				type: names[i],
				hostPanel: hostPanel
			});
			// Remove old item
			delete this.data.data[names[i] + "HostPanel"];
		}
	}
}
/************************************************
 * InitPanel - initialises the panel before anything happens
 ***********************************************/
this.InitPanel = function() {
	this.divid = 'xcsvpanel_' + this.panelKey;
}
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	this.InitPanel();
	if(this.data.data.xcsvfile == null) {
		return "No XCSV file selected";
	}
	
	// Output a placeholder div ready for content
	return "<div id='" + this.divid + "'><\/div>";
};

/************************************************
 * FillTemplate - fills the placeholder returned in Display
 *
 * called from Render
 *
 * returns the html
 ***********************************************/
this.FillTemplate = function() {
	this.InitXCSV();
}
/************************************************
 * InitXCSV - loads the XCSV file and starts the work
 ***********************************************/
this.InitXCSV = function() {
	this.InitPanel();
	this.ready = 0;
	if(this.data.data.xcsvfile == null) {
		this.ready = 1;
		return;
	}
	
	var xcsvfile = Packages.Library.$.GetPathToBase({filepath: this.data.data.xcsvfile});
	
	if(this.xcsv == null) {
		// XCSV not loaded yet, load now
		this.xcsv = new Packages.Library.CSV.CSV({basepath: Packages.Library.$.GetPath({filepath: xcsvfile})});
		this.xcsv.LoadDataFromFile(xcsvfile, this.DisplayCallback.bind(this));
	} else {
		// XCSV already loaded (edit mode calling Display a second time)
		this.DisplayCallback();
	}
};
/************************************************
 * Live - Enhances the XCSV by reloading it as live
 ***********************************************/
this.Live = function() {
	this.InitXCSV();
};
/************************************************
 * DisplayCallback - callback when XML file loaded and ready
 ***********************************************/
this.DisplayCallback = function() {
	if(this.xcsv.ready == 0) return; // Don't allow to be called early
	var html = "";
	
	// Place the controls in the correct place
	this.headerHTML = "";
	this.footerHTML = "";
	
	// Get listing view first - loads the viewdef
	html += this.xcsv.View.GetViewArea({
		areaid: this.divid + "_viewarea",
		viewref: this.data.data.viewMulti,
		interactive: Packages.FileType.mhtm.$.view.GetInteractiveMode(),
		allowQuery: 1
	});
	
	// Get controls second
	for(var i = 0; i < this.data.data.listingControls.length; i++) {
		var control = this.data.data.listingControls[i];
		var controlHTML = "";
		if(control.type == "specificfilter") {
			var columndef = Packages.Library.$.FindArrayItem({array: this.xcsv.data.columndefs, path: "refcode", value: control.specifiedFilter});
			controlHTML = this.xcsv.controls.filter.GetSpecificFilter(columndef, {
				horizontal: control.horizontal,
				single: control.single,
				showTitle: control.showTitle,
				hideControl: control.hideControl,
				itemClass: (control.menuStyles == 1 ? "menuBar menuitemitem" : ""),
				unusedMore: control.unusedMore
			});
		} else {
			controlHTML = this.xcsv.View.GetControlHTML(control.type);
		}
		this.GetHTMLIntoHost(control.hostPanel, controlHTML, i);
	}
	
	this.headerHTML = "<div class='mclearfix'>" + this.headerHTML + "<\/div>";
	this.footerHTML = "<div class='mclearfix'>" + this.footerHTML + "<\/div>";
	
	// Put the content together
	Packages.FileType.mhtm.$i.view.SetElemContent({elemid: this.divid, content: this.headerHTML + html + this.footerHTML});
	
	// Mark as done
	this.ready = 1;
}
/************************************************
 * GetHTMLIntoHost - get the item into the specified Host
 *
 * Checks if host is a 'this' or a hostPanel
 *
 * param - hostname : the host id
 * param - html : HTML to put into area
 * param - index : control index - for id
 ***********************************************/
this.GetHTMLIntoHost = function(hostname, html, index) {
	// Decide where to put it
	if(hostname == null) return;
	
	if(hostname == "thisTop") {
		// Display in top of own panel
		this.headerHTML += html;
	} else if(hostname == "thisBottom") {
		// Display in bottom of own panel
		this.footerHTML += html;
	} else {
		// Display in specified panel
		Packages.FileType.mhtm.$.AppendToPanelHost(hostname, "<div id='" + this.divid + "_ctl_" + index + "'>" + html + "<\/div>");
		// Element may already exist, so update there too (for node generated pages in live)
		if(Packages.Library.$c.IsNode != 1) {
			var elem = document.getElementById(this.divid + "_ctl_" + index)
			if(elem) elem.innerHTML = html;
		}
	}
};
/*********************************************************************
 * EventMhtm_RenderComplete - callback on render complete event
 *
 * param - data : data about this event
 *
 * returns 1 if ready, 0 if not
 ********************************************************************/
this.EventMhtm_RenderComplete = function(data) {
	return {
		ready: this.ready,
		info: "XCSV Listing panel"
	};
};
this.eventRenderComplete = Packages.Library.$.EventSubscribe({eventname: "Mhtm_RenderComplete", callback: this.EventMhtm_RenderComplete.bind(this), groupname: "mhtm_render", obj: this});
/*********************************************************************
 * EventCookieUsage - callback when cookie usage is requested
 *
 * returns information about this cookie
 ********************************************************************/
this.EventCookieUsage = function(data) {
	return {
		id : "xcsvpanel",
		party: 1, // First party content
		description: "Page Listing",
		detail: "Stores your last choice of filters and sort order to increase your usability of this site."
	};
};
this.eventCookie = Packages.Library.$.EventSubscribe({eventname: "CookieUsage", callback: this.EventCookieUsage.bind(this), groupname: "mhtm_render", obj: this});};
// Package: FileType.mhtm.Panels.XCSVMenu
Package('FileType.mhtm.Panels.XCSVMenu').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/XCSVMenu] as classpath [FileType.mhtm.Panels.XCSVMenu]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/XCSVMenu/_view/Display.js] as classpath [FileType.mhtm.Panels.XCSVMenu] 
this.xcsv = null;
this.ready = 1;
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	this.ready = 0;
	if(this.data.data.xcsvfile == null) {
		this.ready = 1;
		return "No XCSV file selected";
	}
	
	this.divid = 'xcsvmenupanel_' + Packages.Library.$.GetUniqueId({});
	
	var xcsvfile = Packages.Library.$.GetPathToBase({filepath: this.data.data.xcsvfile});
	
	this.xcsv = new Packages.Library.CSV.CSV({basepath: Packages.Library.$.GetPath({filepath: xcsvfile})});
	this.xcsv.LoadDataFromFile(xcsvfile, this.DisplayCallback.bind(this));
	
	return "<div id='" + this.divid + "'><\/div>";
};
/************************************************
 * DisplayCallback - callback when XML file loaded and ready
 ***********************************************/
this.DisplayCallback = function() {
	var menuhtml = this.xcsv.View.GetMenuHTML({
		skipContainerUL: 1,
		pageurl: this.data.data.pageurl,
		disableStyles: this.data.data.disableStyles,
		horizontal: this.data.data.horizontal,
		disabled: (Packages.FileType.mhtm.$i.view.interactivemenumode == 1 ? 0 : 1),
	});
	
	if(this.data.data.hostPanel == "this") {
		// Display in own panel
		Packages.FileType.mhtm.$i.view.SetElemContent({elemid: this.divid, content: menuhtml});
	} else {
		// Display in specified panel
		Packages.FileType.mhtm.$.AppendToPanelHost(this.data.data.hostPanel, menuhtml);
	}
	this.ready = 1;
};
/*********************************************************************
 * EventMhtm_RenderComplete - callback on render complete event
 *
 * param - data : data about this event
 *
 * returns 1 if ready, 0 if not
 ********************************************************************/
this.EventMhtm_RenderComplete = function(data) {
	return {
		ready: this.ready,
		info: "XCSV Menu panel"
	};
};
this.eventRenderComplete = Packages.Library.$.EventSubscribe({eventname: "Mhtm_RenderComplete", callback: this.EventMhtm_RenderComplete.bind(this), groupname: "mhtm_render", obj: this});};
// Package: FileType.mhtm.Panels.XCSVSearch
Package('FileType.mhtm.Panels.XCSVSearch').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/XCSVSearch] as classpath [FileType.mhtm.Panels.XCSVSearch]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/XCSVSearch/_view/Display.js] as classpath [FileType.mhtm.Panels.XCSVSearch] 
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	var html = "";
	
	this.divid = "xcsvSearchPanel_" + Packages.Library.$.GetUniqueId({});
	
	html += "<form method='get' action='" + this.data.data.url + "'>"
	
	html += "<input " +
				"class='xcsv_searchbox' " +
				"type='text' " +
				"id='" + this.divid + "' " +
				"name='xcsv_searchby'" +
				"value='' " +
			">";
	
	html += "<input type='submit' class='xcsv_searchbutton button' value='" + this.data.data.searchButtonText + "'>";
	
	html += "<\/form>";
	
	return html;
};};
// Package: FileType.mhtm.Panels.XCSVSingle
Package('FileType.mhtm.Panels.XCSVSingle').$k = function() {
this.css = {}; this.images = {}; this.html = {}; this.data = {$noDump: {}}; this.childClass = {}; this.childObj = {}; var $super;
if(Packages.FileType.mhtm.$s.Panels != null) $super = new Packages.FileType.mhtm.Panels.$k();


// isJSCB: 1, isInternal: 0, isGlobal: 0, isSuper: 0
// Adding folder [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/XCSVSingle] as classpath [FileType.mhtm.Panels.XCSVSingle]


// Adding file [System/Software/JS/FileType/mhtm.$jscb/Panels.$jscb_sup/XCSVSingle/_view/view.js] as classpath [FileType.mhtm.Panels.XCSVSingle] 
this.xcsv = null;
this.ready = 1;
/************************************************
 * Display - gets the html markup for this panel
 *
 * returns the html
 ***********************************************/
this.Display = function() {
	this.ready = 0;
	if(this.data.data.xcsvfile == null) {
		this.ready = 1;
		return "No XCSV file selected";
	}
	
	this.divid = 'xcsvpanel_' + this.panelKey;
	return "<div id='" + this.divid + "'><\/div>";
};

/************************************************
 * FillTemplate - fills the placeholder returned in Display
 *
 * called from Render
 *
 * returns the html
 ***********************************************/
this.FillTemplate = function() {
	this.InitXCSV();
}

/************************************************
 * InitXCSV - loads the XCSV file and starts the work
 ***********************************************/
this.InitXCSV = function() {
	var xcsvfile = Packages.Library.$.GetPathToBase({filepath: this.data.data.xcsvfile});
	
	this.xcsv = new Packages.Library.CSV.CSV({
		basepath: Packages.Library.$.GetPath({filepath: xcsvfile}),
		preloadFilters: this.data.data.preloadFilters,
		viewConditions: this.data.data.viewConditions
	});
	this.xcsv.LoadDataFromFile(xcsvfile, this.DisplayCallback.bind(this));
}

/************************************************
 * Live - Enhances the XCSV by reloading it as live
 ***********************************************/
this.Live = function() {
	this.InitXCSV();
};

/************************************************
 * DisplayCallback - callback when XML file loaded and ready
 ***********************************************/
this.DisplayCallback = function() {
	if(this.xcsv.ready == 0) return; // Don't allow to be called early
	
	var html = "";
	
	// Create the markup
	html += this.xcsv.View.GetViewArea({
		areaid: this.divid + "_viewarea",
		viewref: this.data.data.viewSingle,
		interactive: Packages.FileType.mhtm.$.view.GetInteractiveMode()
	});
	
	Packages.FileType.mhtm.$i.view.SetElemContent({elemid: this.divid, content: html});
	this.ready = 1;
};
/*********************************************************************
 * EventMhtm_RenderComplete - callback on render complete event
 *
 * param - data : data about this event
 *
 * returns 1 if ready, 0 if not
 ********************************************************************/
this.EventMhtm_RenderComplete = function(data) {
	return {
		ready: this.ready,
		info: "XCSV Single View panel"
	};
};
this.eventRenderComplete = Packages.Library.$.EventSubscribe({eventname: "Mhtm_RenderComplete", callback: this.EventMhtm_RenderComplete.bind(this), groupname: "mhtm_render", obj: this});};
Packages.FileType.mhtm.$s.Attributes = Packages.FileType.mhtm.Attributes.$k;
Packages.FileType.mhtm.$s.Panels = Packages.FileType.mhtm.Panels.$k;
if(Packages.FileType.$s.mhtm != null) Packages.FileType.mhtm.Attributes.$k.prototype = new Packages.FileType.mhtm.$k();
if(Packages.FileType.mhtm.$s.Attributes != null) Packages.FileType.mhtm.Attributes.CSS.$k.prototype = new Packages.FileType.mhtm.Attributes.$k();
if(Packages.FileType.mhtm.$s.Attributes != null) Packages.FileType.mhtm.Attributes.Entrance.$k.prototype = new Packages.FileType.mhtm.Attributes.$k();
if(Packages.FileType.mhtm.Attributes.$s.Entrance != null) Packages.FileType.mhtm.Attributes.Entrance.Fade.$k.prototype = new Packages.FileType.mhtm.Attributes.Entrance.$k();
if(Packages.FileType.mhtm.$s.Attributes != null) Packages.FileType.mhtm.Attributes.GoogleAnalytics.$k.prototype = new Packages.FileType.mhtm.Attributes.$k();
if(Packages.FileType.mhtm.$s.Attributes != null) Packages.FileType.mhtm.Attributes.HeaderHTML.$k.prototype = new Packages.FileType.mhtm.Attributes.$k();
if(Packages.FileType.mhtm.$s.Attributes != null) Packages.FileType.mhtm.Attributes.JS.$k.prototype = new Packages.FileType.mhtm.Attributes.$k();
if(Packages.FileType.mhtm.$s.Attributes != null) Packages.FileType.mhtm.Attributes.Template.$k.prototype = new Packages.FileType.mhtm.Attributes.$k();
if(Packages.FileType.mhtm.$s.Attributes != null) Packages.FileType.mhtm.Attributes.Title.$k.prototype = new Packages.FileType.mhtm.Attributes.$k();
if(Packages.FileType.mhtm.$s.Attributes != null) Packages.FileType.mhtm.Attributes.Tracking.$k.prototype = new Packages.FileType.mhtm.Attributes.$k();
if(Packages.FileType.$s.mhtm != null) Packages.FileType.mhtm.Panels.$k.prototype = new Packages.FileType.mhtm.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Download.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Gallery.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.HeadingMenu.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Host.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Html.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Image.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Inherit.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.LastEdited.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Logon.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Menu.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.PanelMenu.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.RichText.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Seasonal.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.SiteMap.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.SocialMedia.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Table.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Tag.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.Text.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.VersionSwitcher.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.W3c.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.XCSV.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.XCSVMenu.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.XCSVSearch.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
if(Packages.FileType.mhtm.$s.Panels != null) Packages.FileType.mhtm.Panels.XCSVSingle.$k.prototype = new Packages.FileType.mhtm.Panels.$k();
window.onload = Packages.Library.$.LoadViewer;