//////////////////////////////////////////////////////////////////////////////////////////////////
// AHC object:																					//
//////////////////////////////////////////////////////////////////////////////////////////////////
var AHC		= AHC || { modules: [] };
AHC.modules	= AHC.modules.concat(["Execute script when ready", "XML", "Remove comments"]);

AHC.re		= {};
AHC.re.str	= {};
with(AHC.re.str) {
	AHC.re.str.QN			= "[a-z_\\-][a-z0-9_\\-]*";
	AHC.re.str.string		= "(?:'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'|\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\")";
	AHC.re.str.attribute	= "("+QN+")\\s*=\\s*((?:"+string+")|(?:[^\"'\\/>\\s]*(?:(?:\\/[^>]|\\s(?!"+QN+"=))[^\\/>\\s]*)*))";
	AHC.re.str.tag			= "<(\\/)?(?:("+QN+"):)?("+QN+")((?:\\s+"+attribute+")*)\\s*(\\/)?>";
}
for(var s in AHC.re.str) AHC.re[s] = new RegExp(AHC.re.str[s]);

//////////////////////////////////////////////////////////////////////////////////////////////////
// It is sometimes helpful to have the GET requests somewhere:									//
AHC.parseGetRequestFromUrl	= function(url) {	// Handy for figuring out srcipt tag src urls with GET requests in them :-)
	var search	= url.match(/\?.*$/)[0];
	var exps	= search.substring(1,search.length).match(/[^=&]+(?:=[^&]*)?/g);
	var GET		= {};
	for(var i=0; i<exps.length; i++) {
 		var parts = exps[i].match(/^([^=]+)(?:=(.*))?$/);
 		GET[unescape(parts[1])] = parts[2]? unescape(parts[2]) : true;
	}
	return GET;
};

if(location.search) AHC.GET = AHC.parseGetRequestFromUrl(location.search);

AHC.cookies		= {};
var cookieSets	= document.cookie.split(/\s*;\s*/);
for(var c in cookieSets) if(typeof cookieSets[c] === "string") {
	var nameValuePair				= cookieSets[c].split('=');
	AHC.cookies[nameValuePair[0]]	= nameValuePair[1];
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Events:																						//
AHC.addEventListener	= function(element, event, callback, useCapture) {
	if(typeof element === "string") element = document.getElementById(element);
	(function(callback) {
		if(element.addEventListener) element.addEventListener(event, callback, useCapture);
		else element.attachEvent("on"+event, callback);
	})( (!("event" in window))? callback : function() {
			var event			= window.event;
			var preventDefault	= false;
			
			event.currentTarget	= element;
			event.which			= event.keyCode;
			event.preventDefault= function() { event.returnValue = false; preventDefault = true;	};
			
			var returnValue	= callback.call(element, event);
			//alert("return value: " + ((typeof returnValue != 'undefined')? returnValue : !preventDefault));
			return (typeof returnValue != 'undefined')? returnValue : !preventDefault;
		}
	);
};

AHC.removeEventListener	= function(element, event, callback, useCapture) {
	if("removeEventListener" in element) {
		if(useCapture != null || useCapture == undefined) {
			element.removeEventListener(event, callback, true);
			element.removeEventListener(event, callback, false);
		} else element.removeEventListener(event, callback, useCapture);
	} else element.detachEvent('on'+event, callback);
};

//////////////////////////////////////////////////////////////////////////////////////////////////
// Setup for onReady																			//
AHC.addEventListener(window, "load", function() { if(!document.readyState) document.readyState = "complete"; }, false);
//////////////////////////////////////////////////////////////////////////////////////////////////
// Executed whenever the document is done loading regardless if document has already passed the	//
// status change event.																			//
AHC.onReady			= function(callback) {
	if(document.readyState !== "complete") {
		if("addEventListener" in window) window.addEventListener("load", callback, false);
		else window.attachEvent("onload", callback);
	} else callback.call();
};

//////////////////////////////////////////////////////////////////////////////////////////////////
// Convert objects to JSON (personaly, this is just a genaric toString for Object but whatever)://
AHC.toJson			= function(data) {
	switch(typeof data) {
		case "string":	return '"'+data.replace(/"/g, '\\"')+'"';
		case "object":
			if(data instanceof Array) {
				var s = "[";
				for(var d=0; d<data.length; d++) {	// use for loop here :-/
					var j = this.toJson(data[d]);
					if(j != null) s += j + ", ";
				}
				if(s.length !== 1) s = s.substring(0, s.length-2);
				return s + "]";
			} else {
				var s = "{ ";
				for(d in data) {
					var j = this.toJson(data[d]);
					if(j != null) s += '"'+d+'": ' + j + ", ";
				}
				if(s.length !== 2) s = s.substring(0, s.length-2);
				return s + " }";
			}
			break;
		case "function":
			return null;
			break;
		default: return data;
	}
};

AHC.request			= function(url, method, params, options) {
	var isGET		= method.toUpperCase() === "GET";
	var hasCallback	= "callback" in options && typeof options.callback == "function";
	var request		= new XMLHttpRequest();
	var data;
	
	if(typeof params == "object") {
		if("jsonData" in options && options.toJson && !isGET) {
			data	= this.toJson(params);
		} else {
			// Normal url request string:
			data	= isGET? "?" : "";
			for(var k in params) data += k+"="+escape(params[k])+"&";
			data	= data.substring(0, data.length-1);
		}
	}
	
	request.open(method, url + (isGET? data : ""), hasCallback);
	
	if("jsonResponse" in options && options.expectsJsonResponse) {
		request.setRequestHeader("Content-Type", "application/json");
	}
	
    if(hasCallback) request.onreadystatechange = options.callback;
    
    request.send(isGET? null : data);
    
    if(!hasCallback) { eval("j="+request.responseText); return j; }
};

AHC.dateToString	= function(date) {
	var d = (typeof(date) == "string")? new Date(date) : date;
	return (["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"])[d.getMonth()] + " "
			+ d.getDate() + ", " + d.getFullYear();
};

AHC.toHexadecimal	= function(b10) {
	var s = "0123456789ABCDEF";
	var r = "";
	while(b10 != 0) { r = s[b10 % 16] + r; b10 >>= 4;}
	return r;
};

//////////////////////////////////////////////////////////////////////////////////////////////////
// Printing code for News Releases																//
AHC.printNewsRelease = function() {
	$("#print").remove();
	$("body").append("<div id='print' style='display:none'></div>");
	$("#print").append($("link[type=text/css]").clone()); // grab page's CSS
	$("#print link[type=text/css]").wrapAll("<head/>");
	// Page-specific content
	$("#print").append($(".section.page-content").clone());
	$("#print").children(".section.page-content").wrap('<div class="column1" />');
	$("#print").children(".column1").wrap('<div class="content-body" />');
	$("#print").children(".content-body").wrap('<div class="AHC-OC" />');
	$("#print").children(".AHC-OC").wrap("<body/>");
	$("#print head, #print body").wrapAll("<html/>");
	$("#print").find("iframe, .addthis_button, .printButton").remove();
	$("#print .content-body").append($(".column2").clone());
	$("#print .column2").find(".section.widget").each(function() {
		if ($(this).find(".contacts").length == 0)
			$(this).remove(); // keep only the contacts widget
	});
	var printWindow = window.open('', '', 'width = 640, height = 480, status = 0, toolbar = 0');
	printWindow.document.write($("#print").html());
	printWindow.document.close();
	printWindow.focus();
	$("#print").remove();
	printWindow.print(); 
	return false;
};

//////////////////////////////////////////////////////////////////////////////////////////////////
// XmlHttpRequest: (We're not supporting IE6 so why would I need this?)							//
AHC.XMLHttpRequest	= function() {
	if(window.XMLHttpRequest) return new XMLHttpRequest(); else return new ActiveXObject("Microsoft.XMLHTTP");
};

AHC.flickr				= {};
AHC.flickr.url			= "http://www.flickr.com/services/rest/";
AHC.flickr.ahcUrl		= "/dev/jsp/AHC_Flickr.jsp";
AHC.flickr.ucmUrl		= "/prod/groups/ahc/@sec/@ahc/documents/asset/ahc_asset_246570.jsp";
AHC.flickr.api_key		= "e80df2981254c62a8107323c42274340";
AHC.flickr.user_id		= "46426648@N08";
AHC.flickr.rePhotoUrl	= /^http:\/\/www\.flickr\.com\/photos\/([^/]+)\/(\d+)\/.*$/;
AHC.flickr.exec			= function(method, params, callback) {
	var request	= "method="+method+"&api_key="+this.api_key+"&user_id="+this.user_id+"&";
	
	if(callback !== null && callback !== undefined && typeof callback === "string")
		params.jsoncallback	= callback;

	for(var p in params) request += p+"="+params[p]+"&";
	request	= request.substring(0, request.length-1);

	if(location.host.match(/^www\.ahc\.umn\.edu$/)) {
		
		var hasCallback	= (callback !== null && callback !== undefined && typeof callback === "function"),
			Flickr		= new XMLHttpRequest();
		
		Flickr.open("GET", this.ahcUrl+"?"+request, hasCallback);
		if(hasCallback) Flickr.onreadystatechange = callback;
		Flickr.send(null);
		if(!hasCallback) { var j; eval("j="+Flickr.responseText); return j; }
		
	} else if(location.host.match(/^umcontent\.umn\.edu$/)) {
	
		var hasCallback	= (callback !== null && callback !== undefined && typeof callback === "function"),
			Flickr		= new XMLHttpRequest();
		
		Flickr.open("GET", this.ucmUrl+"?"+request, hasCallback);
		if(hasCallback) Flickr.onreadystatechange = callback;
		Flickr.send(null);
		if(!hasCallback) { var j; eval("j="+Flickr.responseText); return j; }
	
	} else {
		if(!"jsoncallback" in params) request += "&jsoncallback=AHC.flickr.response";
		
		var s	= document.createElement("script");
		s.setAttribute("type",	"text/javascript");
		s.setAttribute("src",	this.url+"?"+request);
		document.getElementsByTagName("body")[0].appendChild(s);
	}
};
AHC.flickr.response	= function(json) {
	if(console in window) console.log(json);
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Handy XML loader:																			//
AHC.xml				= function(text) {
	if(window.DOMParser) {
		parser			= new DOMParser();
		xmlDoc			= parser.parseFromString(text,"text/xml");
	} else { // Internet Explorer
		xmlDoc			= new ActiveXObject("Microsoft.XMLDOM");
		xmlDoc.async	= "false";
		xmlDoc.loadXML(text);
	}
	return xmlDoc;	
};
AHC.setXMLNS		= function(doc, defaultNS) {
	if("setProperty" in doc) {
		doc.setProperty("SelectionLanguage", "XPath");
		var d	= doc.documentElement;
		var ns	= "";
		for(var i=0; i<d.attributes.length; i++) {
			var xmlns = d.attributes.item(i).nodeName;
			if(xmlns.match(/^xmlns(?::.+)?$/)) {
				if(xmlns.match(/^xmlns$/) && defaultNS) xmlns += ":"+defaultNS;
				ns	+= xmlns + "=\""+d.attributes.item(i).nodeValue+"\" ";
			}
		}
		doc.setProperty("SelectionNamespaces", ns);
	}
}
// XPath support
AHC.XPath	= {
	ANY_TYPE:						0,
	NUMBER_TYPE:					1,
	STRING_TYPE:					2,
	BOOLEAN_TYPE:					3,
	UNORDERED_NODE_ITERATOR_TYPE:	4,
	ORDERED_NODE_ITERATOR_TYPE:		5,
	UNORDERED_NODE_SNAPSHOT_TYPE:	6,
	ORDERED_NODE_SNAPSHOT_TYPE:		7,
	ANY_UNORDERED_NODE_TYPE:		8,
	FIRST_ORDERED_NODE_TYPE:		9
};
// DOM addProperty here?
AHC.xpathEvaluate	= function(xpathExpression, contextNode, namespaceResolver, resultType, result) {
	var doc	= (contextNode.nodeType === 9)? contextNode : contextNode.ownerDocument;
	if(doc.evaluate) return doc.evaluate(xpathExpression, contextNode, namespaceResolver, resultType, result);
	else return {
		nodes:			contextNode.selectNodes(xpathExpression),
		index:			0,
		iterateNext:	function() {
			if(this.index < this.nodes.length) return this.nodes[this.index++]; else return null;
		}
	};
};

AHC.$				= function(xpathExpression, contextNode, namespaceResolver) {
	if(!contextNode) contextNode = document;
	var doc	= (contextNode.nodeType === 9)? contextNode : contextNode.ownerDocument;
	
	if(doc.evaluate) {
		var results	= doc.evaluate(xpathExpression, contextNode, namespaceResolver, this.XPath.UNORDERED_NODE_SNAPSHOT_TYPE, null);
		var nodes	= [];
		for(var i=0; i<results.snapshotLength; i++) nodes.push(results.snapshotItem(i));
		return (nodes.length !== 0)? nodes : null;
	} else {
		try{ return contextNode.selectNodes(xpathExpression); } catch(e) { return null; }	// No, I don't care if I mistakenly search for something that is not there IE X(
	}
};

AHC.xpathsToObject	= function(xpaths, node, ns) {
	var results	= {};
	for(var item in xpaths) switch(typeof xpaths[item]) {
		case "string":
			results[item]	= this.$(xpaths[item], node, ns);
/*			if("console" in window && node.nodeName === "enclosure") {
				console.log("enclosure: %o; xpaths[item]: %o; results[item]: %o", node, xpaths[item], results[item]);
			}
//*/
			break;
		case "object":
			var r	= [];
			for(var xpath in xpaths[item]) {
				var nodes = this.$(xpath, node, ns);
				
				if(nodes != null) {
					for(var i=0; i<nodes.length; i++)
						r.push(this.xpathsToObject(xpaths[item][xpath], nodes[i], ns));
					results[item]	= r;
				}
			}
			break;
	}
	return results;
};

//////////////////////////////////////////////////////////////////////////////////////////////////
//	Modified look at xpaths to object (2010-05-14)
AHC.XPath.feeds	= {
	atom:	{
		xmlns:			"http://www.w3.org/2005/Atom",
		ns:		{
			atom:		"http://www.w3.org/2005/Atom",
			itunes:		"http://www.itunes.com/dtds/podcast-1.0.dtd"
		},
		xpaths:	{
			title:		"/atom:feed/atom:title/text()",
			subtitle:	"/atom:feed/atom:subtitle/text()",
			authors:	"/atom:feed/atom:author/atom:name/text()",
			link:		"/atom:feed/atom:link[@rel='alternate']/@href",
			entries:			{
				"/atom:feed/atom:entry": {
					link:		"atom:link[@rel='alternate']/@href",
					title:		"atom:title/text()",
					date:		"atom:published/text()",
					content:	"atom:content/text()"
				}
			}
		}
	},
	rss:	{
		xmlns:			"",
		ns:		{
			atom:		"http://www.w3.org/2005/Atom",
			content:	"http://purl.org/rss/1.0/modules/content/",
			itunes:		"http://www.itunes.com/dtds/podcast-1.0.dtd",
			itunesu:	"http://www.itunesu.com/feed"
		},
		xpaths:	{
			title:		"/rss/channel/title/text()",
			subtitle:	"/rss/channel/description/text()",
			authors:	"/rss/channel/managingeditor/text()",
			link:		"/rss/channel/link/text()",
			entries:		{
				"/rss/channel/item": {
					link:			"link/text()",
					title:			"title/text()",
					date:			"pubDate/text()",
					content:		"description/text()",
					image:			"image/text()",
					enclosure:			{
						"enclosure": {
							url:		"@url",
							length:		"@length",
							type:		"@type"
						}
					},
					itunesSummary:	"itunes:summary/text()",
					itunesDuration:	"itunes:duration/text()"
				}
			}
		}
	}
};

AHC.readFeed2		= function(feed, options) {
	if(typeof feed == "string") {
		if(options && "GET" in options) {
			feed	+= "?";
			for(var item in options.GET) feed += escape(item) + "=" + escape(options.GET[item]) + "&";
			if(feed[feed.length-1] === '&') feed = feed.substring(0, feed.length-1);
		}
		
		if(feed.match(/^http(?:s)?:\/\/.+$/i)) {
			if(feed.match(/^http(?:s)?:\/\/([^\/]+?)(?:\/|$)/i)[1] === location.host) {
				if("console" in window && "log" in console) console.log("loading via XMLHttpRequest");
				var feedRequest		= new XMLHttpRequest();
				var method			= ("GET" in options)? "GET" : null;
				feedRequest.open(("POST" in options)? "POST" : method, feed, false);
				feedRequest.send(("POST" in options)? options.POST : null);
				
				if(feedRequest.status !== 200) feed	= null;
				else feed = (feedRequest.responseXML != null)? feedRequest.responseXML : feedRequest.responseText;
				
			} else {
				var script	= document.createElement("script");
				script.setAttribute("type", "text/javascript");
				script.setAttribute("src", feed);
				document.getElementsByTagName("head")[0].appendChild(script);

				return null;
			}
		}
		
		feed = AHC.xml(feed);				// Assume that this is XML then.  What else could it be?
	}
	return this.readFeed(feed);
};

AHC.readFeed		= function(feed) {
	var xmlns	= feed.documentElement.getAttribute("xmlns");
	xmlns		= xmlns? xmlns : "";
	var xpFeed;
	for(var feedType in this.XPath.feeds) if(this.XPath.feeds[feedType].xmlns === xmlns) {
		xpFeed = this.XPath.feeds[feedType]; break;
	}
	
	var ns		= function(ns) { return xpFeed.ns[ns]; }
	
	this.setXMLNS(feed, feedType);
	return this.xpathsToObject(xpFeed.xpaths, feed, ns);
};
//////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////
//	XML Data for frequently used URLs
AHC.XMLReaders							= {};
AHC.XMLReaders.XPaths					= {};
AHC.XMLReaders.XPaths.eventsCalendar	= {
	ns:				function(prefix) {
		var ns	= {
			"dc":		"http://purl.org/dc/elements/1.1/",
			"sy":		"http://purl.org/rss/1.0/modules/syndication/",
			"event":	"http://a.umn.edu/rss/events/"
		};
		return ns[prefix];
	},
	items:			"/rss/channel/item",
	title:			"title/node()",
	date:			"event:startDate/node()",
	startTime:		"event:startTime/node()",
	endTime:		"event:endTime/node()",
	location:		"event:location/node()",
	description:	"description/node()",
	teaser:			"event:teaser/node()",
	link:			"link/node()"
};
AHC.XMLReaders.XPaths.flikr	= {
	ns:				function(prefix) {
		var ns	= { "media": "http://search.yahoo.com/mrss/" };
		return ns[prefix];
	},
	items:			"/rss/channel/item",
	image:			"media:thumbnail/@url",
	link:			"link/node()"
};

AHC.XMLReaders.eventsCalendar	= function(RSS) {
	var XMLDoc			= AHC.xml(RSS);
	
	if("setProperty" in XMLDoc) XMLDoc.setProperty("SelectionNamespaces", "xmlns:event=\""+this.XPaths.eventsCalendar.ns("event")+"\"");
	
	var ns				= this.XPaths.eventsCalendar.ns;
	var xTitle			= this.XPaths.eventsCalendar.title;
	var xDescription	= this.XPaths.eventsCalendar.description;
	var xTeaser			= this.XPaths.eventsCalendar.teaser;
	var xDate			= this.XPaths.eventsCalendar.date;
	var xStartTime		= this.XPaths.eventsCalendar.startTime;
	var xEndTime		= this.XPaths.eventsCalendar.endTime;
	var xLocation		= this.XPaths.eventsCalendar.location;
	var xLink			= this.XPaths.eventsCalendar.link;
	var events			= [];
	var items			= AHC.xpathEvaluate(AHC.XMLReaders.XPaths.eventsCalendar.items, XMLDoc, ns, 0, null);

	var item			= null;
	while((item = items.iterateNext())) {
 		var title		= AHC.xpathEvaluate(xTitle,			item, ns, 0, null).iterateNext();
		var date		= AHC.xpathEvaluate(xDate,			item, ns, 0, null).iterateNext();
		var startTime	= AHC.xpathEvaluate(xStartTime,		item, ns, 0, null).iterateNext();
		var endTime		= AHC.xpathEvaluate(xEndTime,		item, ns, 0, null).iterateNext();
		var location	= AHC.xpathEvaluate(xLocation,		item, ns, 0, null).iterateNext();
		var description	= AHC.xpathEvaluate(xDescription,	item, ns, 0, null).iterateNext();
		var teaser		= AHC.xpathEvaluate(xTeaser,		item, ns, 0, null).iterateNext();
		var link		= AHC.xpathEvaluate(xLink,			item, ns, 0, null).iterateNext();
		
		if(title.textContent != undefined)		 title		 = title.textContent;		else title			= (title.text)?			title.text		 : title.data;
		if(date.textContent != undefined) 		 date		 = date.textContent;		else date			= (date.text)?			date.text		 : date.data;
		if(startTime.textContent != undefined)	 startTime	 = startTime.textContent;	else startTime		= (startTime.text)?		startTime.text	 : startTime.data;
		if(endTime.textContent != undefined)	 endTime	 = endTime.textContent;		else endTime		= (endTime.text)?		endTime.text	 : endTime.data;
		if(location.textContent != undefined)	 location	 = location.textContent;	else location		= (title.text)?			location.text	 : location.data;
		if(description.textContent != undefined) description = description.textContent;	else description	= (description.text)?	description.text : description.data;
		if(teaser.textContent != undefined)		 teaser		 = teaser.textContent;		else teaser			= (teaser.text)?		teaser.text		 : teaser.data;
		if(link.textContent != undefined)		 link		 = link.textContent;		else link			= (link.text)?			link.text		 : link.data;
 		
		events.push({
			title:			title.replace(/^\d+\/\d+\/\d+\s*\d+:\d+\s*(?:(?:a|p)m)?/i, ""),
			date:			date,
			startTime:		startTime,
			endTime:		endTime,
			location:		location,
			description:	description,
			teaser:			teaser,
			link:			link
		});
	}

	return events;
};

AHC.XMLReaders.flikr	= function(RSS) {
	var XMLDoc	= new AHC.xml(RSS);
	var ns		= AHC.XMLReaders.XPaths.flikr.ns;
	var xImage	= AHC.XMLReaders.XPaths.flikr.image;
	var xLink	= AHC.XMLReaders.XPaths.flikr.link;
	var images	= [];
	var items	= AHC.xpathEvaluate(AHC.XMLReaders.XPaths.flikr.items, XMLDoc, ns, 0, null);
	
	var item	= null;
	while((item = items.iterateNext())) {
		var thumbnail	= AHC.xpathEvaluate(xImage, item, ns, 0, null).iterateNext();
		var link		= AHC.xpathEvaluate(xLink,  item, ns, 0, null).iterateNext();
		
		if(thumbnail.textContent != undefined)	 thumbnail	 = thumbnail.textContent;	else thumbnail	= (thumbnail.text)?	thumbnail.text	: thumbnail.data;
		if(link.textContent != undefined)		 link		 = link.textContent;		else link		= (link.text)?		link.text		: link.data;
		
		images.push({
			thumbnail:	thumbnail,
			link:		link
		});
	}

	return images;
};
//////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////
//	"init.js"
//////////////////////////////////////////////////////////////////////////////////////////////////
// Here are some clean up scripts that need to run or else other scripts just seem to fail or to
// add features such as tracking:
// 1. Remove all comments.  Comment tags have proven time and time again to get in the way of the
//	  templates.
// 2. Add Google tracking to all external links
//////////////////////////////////////////////////////////////////////////////////////////////////
// Protected scripts:																			//
(function() {
	// Remove comments:
	function cleanNodes(node) {
		var childNode		= node.firstChild;
		var childNode_next	= null;
		while(childNode) {
			childNode_next	= childNode.nextSibling;
			switch(childNode.nodeType) {
				case 1:
					if(childNode.href) {
						var href = childNode.href;
						if(href.replace(/#.*$/, "") === location.href.replace(location.hash, ""))
							childNode.href = href.replace(/^.*?(#.*)$/, "$1");
					}
					if(childNode.hasChildNodes()) cleanNodes(childNode);
					break;
				case 8: node.removeChild(childNode); break;
			}
			childNode		= childNode_next;
		}
	}
	
	//////////////////////////////////////////////////////////////////////////////////////////////
	// Add Google tracking to all external links												//
	//////////////////////////////////////////////////////////////////////////////////////////////
	function addPageTrackview() {
		if("_gaq" in window) {
			/*
				1. Find all anchor tags
				2. Determine if they are external
				3. Parse inportant link details
					a. <img>
					b. document downloads
					c. <a>
				4. Add tracking
			 */
			var a		= document.getElementsByTagName("a");
			var local	= ("http(?:s)?://" + location.hostname + "/").replace(/\./g, "\\.").replace(/\//g, "\\/");
			var internal= new RegExp("^(?:\\/|#|\\?|"+local+")");
			for(var i=0; i<a.length; i++) {
				if(a[i].href !== "" && !a[i].href.match(internal))
					AHC.addEventListener(a[i], "click", function(event) {
						var event	= event || window.event;
						var element	= event.currentTarget || event.srcElement;
						var url		= element.href.replace(/^http(?:s)?:\/\//, "");
						_gaq.push(["_trackEvent", "Link", "External URL", "Dest: " + url + ", Src: " + window.location]);
					}, true);
				else if(a[i].href.match(/\.(?:zip|docx?|pdf|txt)$/i))
					AHC.addEventListener(a[i], "click", function(event) {
						var event	= event || window.event;
						var element	= event.currentTarget || event.srcElement;
						var url		= element.href.replace(/^http(?:s)?:\/\//, "");
						_gaq.push(["_trackEvent", "Link", "Download", "Dest: " + url + ", Src: " + window.location]);
					}, true);
			}
			
			// Track University of Minnesota search field use
			$("#gsearch").submit(function() {
				_gaq.push(["_trackEvent", "UMN Search", "Search Action", "Value: " + $("#gsearch #search_field").val()]);
			});
		}
	}
	
	//////////////////////////////////////////////////////////////////////////////////////////////
	// Our little init script																	//
	//////////////////////////////////////////////////////////////////////////////////////////////
	AHC.onReady(function() {
		cleanNodes(document);
		// todo: is(isSSPU) Add google tracking code here
		addPageTrackview();
	});
})();