if(document.all && !document.getElementById) {
	document.getElementById = function(id) {
		 return document.all[id];
	}
}

if (!String.repeat) {
	String.prototype.repeat = function(l){
		return new Array(l+1).join(this);
	}
}

if (!String.trim) {
	String.prototype.trim = function() {
		return this.replace(/^\s+|\s+$/g,'');
	}
}

(function(){

/**
 * The primary namespace object
 * @type {Object}
 * @alias MDW
 */
if(!window['MDW']) {
	window['MDW'] = {};
}

function isCompatible(other) {
	if( other===false 
		|| !Array.prototype.push
		|| !Object.hasOwnProperty
		|| !document.createElement
		|| !document.getElementsByTagName
		) {
		alert('TR- if you see this message isCompatible is failing incorrectly.');
		return false;
	}
	return true;
}
window['MDW']['isCompatible'] = isCompatible;

function $() {
	var elements = new Array();
	for (var i = 0; i < arguments.length; i++) {
		var element = arguments[i];
		if (typeof element == 'string') {
			element = document.getElementById(element);
		}
		if (arguments.length == 1) {
			return element;
		}
		elements.push(element);
	}
	return elements;
};
window['MDW']['$'] = $;

function addEvent( node, type, listener ) {
	if(!isCompatible()) { return false }
	if(!(node = $(node))) return false;
	if (node.addEventListener) {
		node.addEventListener( type, listener, false );
		return true;
	} else if(node.attachEvent) {
		node['e'+type+listener] = listener;
		node[type+listener] = function(){node['e'+type+listener]( window.event );}
		node.attachEvent( 'on'+type, node[type+listener] );
		return true;
	}
	return false;
};
window['MDW']['addEvent'] = addEvent;
function removeEvent(node, type, listener ) {
	if(!(node = $(node))) return false;
	if (node.removeEventListener) {
		node.removeEventListener( type, listener, false );
		return true;
	} else if (node.detachEvent) {
		node.detachEvent( 'on'+type, node[type+listener] );
		node[type+listener] = null;
		return true;
	}
	return false;
};
window['MDW']['removeEvent'] = removeEvent;
function getElementsByClassName(className, tag, parent){
	parent = parent || document;
	if(!(parent = $(parent))) return false;
	var allTags = (tag == "*" && parent.all) ? parent.all : parent.getElementsByTagName(tag);
	var matchingElements = new Array();
	className = className.replace(/\-/g, "\\-");
	var regex = new RegExp("(^|\\s)" + className + "(\\s|$)");
	
	var element;
	for(var i=0; i<allTags.length; i++){
		element = allTags[i];
		if(regex.test(element.className)){
			matchingElements.push(element);
		}
	}
	return matchingElements;
};
window['MDW']['getElementsByClassName'] = getElementsByClassName;

function toggleDisplay(node, value) {
	if(!(node = $(node))) return false;
	if ( node.style.display != 'none' ) {
		node.style.display = 'none';
	} else {
		node.style.display = value || '';
	}
	return true;
}
window['MDW']['toggleDisplay'] = toggleDisplay;

function insertAfter(node, referenceNode) {
	if(!(node = $(node))) return false;
	if(!(referenceNode = $(referenceNode))) return false;
	
	return referenceNode.parentNode.insertBefore(node, referenceNode.nextSibling);
};
window['MDW']['insertAfter'] = insertAfter;

function removeChildren(parent) {
	if(!(parent = $(parent))) return false;
	while (parent.firstChild) {
		parent.firstChild.parentNode.removeChild(parent.firstChild);
	}
	return parent;
};
window['MDW']['removeChildren'] = removeChildren;

function prependChild(parent,newChild) {
	if(!(parent = $(parent))) return false;
	if(!(newChild = $(newChild))) return false;
	if(parent.firstChild) {
		parent.insertBefore(newChild,parent.firstChild);    
	} else {
		parent.appendChild(newChild);
	}
	return parent;
} 
window['MDW']['prependChild'] = prependChild;

function bindFunction(obj, func) {
	return function() {
		func.apply(obj,arguments);    
	};
};
window['MDW']['bindFunction'] = bindFunction;
function getBrowserWindowSize() {
	var de = document.documentElement;
	return {
		'width':(
			window.innerWidth 
			|| (de && de.clientWidth ) 
			|| document.body.clientWidth),
		'height':(
			window.innerHeight 
			|| (de && de.clientHeight ) 
			|| document.body.clientHeight)
	}
};
window['MDW']['getBrowserWindowSize'] = getBrowserWindowSize;

window['MDW']['node'] = {
	ELEMENT_NODE                : 1,
	ATTRIBUTE_NODE              : 2,
	TEXT_NODE                   : 3,
	CDATA_SECTION_NODE          : 4,
	ENTITY_REFERENCE_NODE       : 5,
	ENTITY_NODE                 : 6,
	PROCESSING_INSTRUCTION_NODE : 7,
	COMMENT_NODE                : 8,
	DOCUMENT_NODE               : 9,
	DOCUMENT_TYPE_NODE          : 10,
	DOCUMENT_FRAGMENT_NODE      : 11,
	NOTATION_NODE               : 12
};
function walkElementsLinear(func,node) {
	var root = node || window.document;
	var nodes = root.getElementsByTagName("*");
	for(var i = 0 ; i < nodes.length ; i++) {
		func.call(nodes[i]);
	}
};
window['MDW']['walkElementsLinear'] = walkElementsLinear;

function walkTheDOMRecursive(func,node,depth,returnedFromParent) {
	var root = node || window.document;
	returnedFromParent = func.call(root,depth++,returnedFromParent);
	node = root.firstChild;
	while(node) {
		walkTheDOMRecursive(func,node,depth,returnedFromParent);
		node = node.nextSibling;
	}
};
window['MDW']['walkTheDOMRecursive'] = walkTheDOMRecursive;
function walkTheDOMWithAttributes(node,func,depth,returnedFromParent) {
	var root = node || window.document;
	returnedFromParent = func(root,depth++,returnedFromParent);
	if (root.attributes) {
		for(var i=0; i < root.attributes.length; i++) {
			walkTheDOMWithAttributes(root.attributes[i],func,depth-1,returnedFromParent);
		}
	}
	if(root.nodeType != MDW.node.ATTRIBUTE_NODE) {
		node = root.firstChild;
		while(node) {
			walkTheDOMWithAttributes(node,func,depth,returnedFromParent);
			node = node.nextSibling;
		}
	}
};
window['MDW']['walkTheDOMWithAttributes'] = walkTheDOMWithAttributes;
function walkTheDOM(node, func) {
	func(node);
	node = node.firstChild;
	while (node) {
		 walkTheDOM(node, func);
		 node = node.nextSibling;
	}
}
window['MDW']['walkTheDOM'] = walkTheDOM;
function camelize(s) {
	return s.replace(/-(\w)/g, function (strMatch, p1){
		return p1.toUpperCase();
	});
}
window['MDW']['camelize'] = camelize;

function uncamelize(s, sep) {
	sep = sep || '-';
	return s.replace(/([a-z])([A-Z])/g, function (strMatch, p1, p2){
		return p1 + sep + p2.toLowerCase();
	});
}
window['MDW']['camelize'] = camelize;

function addLoadEvent(loadEvent,waitForImages) {
	if(!isCompatible()) return false;
	if(waitForImages) {
		return addEvent(window, 'load', loadEvent);
	}
	var init = function() {
		if (arguments.callee.done) return;
		arguments.callee.done = true;
		loadEvent.apply(document,arguments);
	};
	if (document.addEventListener) {
		document.addEventListener("DOMContentLoaded", init, false);
	}
	if (/WebKit/i.test(navigator.userAgent)) {
		var _timer = setInterval(function() {
			if (/loaded|complete/.test(document.readyState)) {
			    clearInterval(_timer);
			    init();
			}
		},10);
	}
	// For Internet Explorer (using conditional comments) attach a script 
	// that is deferred to the end of the load process and then check to see
	// if it has loaded
	/*@cc_on @*/
	/*@if (@_win32)
	document.write("<script id=__ie_onload defer src=javascript:void(0)><\/script>");
	var script = document.getElementById("__ie_onload");
	script.onreadystatechange = function() {
		if (this.readyState == "complete") {
			init();
		}
	};
	/*@end @*/
	return true;
}
window['MDW']['addLoadEvent'] = addLoadEvent;
function stopPropagation(eventObject) {
	eventObject = eventObject || getEventObject(eventObject);
	if(eventObject.stopPropagation) {
		eventObject.stopPropagation();
	} else {
		eventObject.cancelBubble = true;
	}
}
window['MDW']['stopPropagation'] = stopPropagation;

function preventDefault(eventObject) {
	eventObject = eventObject || getEventObject(eventObject);
	if(eventObject.preventDefault) {
		eventObject.preventDefault();
	} else {
		eventObject.returnValue = false;
	}
}
window['MDW']['preventDefault'] = preventDefault;

function getEventObject(W3CEvent) {
	return W3CEvent || window.event;
}
window['MDW']['getEventObject'] = getEventObject;

function getTarget(eventObject) {
	eventObject = eventObject || getEventObject(eventObject);
	var target = eventObject.target || eventObject.scrElement;
	if(target.nodeType == MDW.node.TEXT_NODE) {
		target = node.parentNode;
	}
	return target;

}
window['MDW']['getTarget'] = getTarget;

function getMouseButton(eventObject) {
	eventObject = eventObject || getEventObject(eventObject);
	var buttons = {
		'left':false,
		'middle':false,
		'right':false
	};
	if(eventObject.toString && eventObject.toString().indexOf('MouseEvent') != -1) {
		switch(eventObject.button) {
			case 0: buttons.left = true; break;
			case 1: buttons.middle = true; break;
			case 2: buttons.right = true; break;
			default: break;
		}
	} else if(eventObject.button) {
		switch(eventObject.button) {
			case 1: buttons.left = true; break;
			case 2: buttons.right = true; break;
			case 3:
			    buttons.left = true;
			    buttons.right = true;
			break;
			case 4: buttons.middle = true; break;
			case 5:
			    buttons.left = true;
			    buttons.middle = true;
			break;
			case 6:
			    buttons.middle = true;
			    buttons.right = true;
			break;
			case 7:
			    buttons.left = true;
			    buttons.middle = true;
			    buttons.right = true;
			break;
			default: break;
		}
	} else {
		return false;
	}
	return buttons;

}
window['MDW']['getMouseButton'] = getMouseButton;

function getPointerPositionInDocument(eventObject) {
	eventObject = eventObject || getEventObject(eventObject);
	var x = eventObject.pageX || (eventObject.clientX +
		(document.documentElement.scrollLeft || document.body.scrollLeft));
	var y= eventObject.pageY || (eventObject.clientY +
		(document.documentElement.scrollTop || document.body.scrollTop));
	return {'x':x,'y':y};
}
window['MDW']['getPointerPositionInDocument'] = getPointerPositionInDocument;
function getKeyPressed(eventObject) {
	eventObject = eventObject || getEventObject(eventObject);
	var code = eventObject.keyCode;
	var value = String.fromCharCode(code);
	return {'code':code,'value':value};
}
window['MDW']['getKeyPressed'] = getKeyPressed;

function setStyleById(element, styles) {
	if(!(element = $(element))) return false;
	for (property in styles) {
		if(!styles.hasOwnProperty(property)) continue;
	
		if(element.style.setProperty) {
			element.style.setProperty(
			uncamelize(property,'-'),styles[property],null);
		} else {
			element.style[camelize(property)] = styles[property];
		}
	}
	return true;
}
window['MDW']['setStyle'] = setStyleById;
window['MDW']['setStyleById'] = setStyleById;

function setStylesByClassName(parent, tag, className, styles) {
	if(!(parent = $(parent))) return false;
	var elements = getElementsByClassName(className, tag, parent);
	for (var e = 0 ; e < elements.length ; e++) {
		setStyleById(elements[e], styles);
	}
	return true;
}
window['MDW']['setStylesByClassName'] = setStylesByClassName;

function setStylesByTagName(tagname, styles, parent) {
	parent = $(parent) || document;
	var elements = parent.getElementsByTagName(tagname);
	for (var e = 0 ; e < elements.length ; e++) {
		setStyleById(elements[e], styles);
	}
}
window['MDW']['setStylesByTagName'] = setStylesByTagName;

function getClassNames(element) {
	if(!(element = $(element))) return false;
	return element.className.replace(/\s+/,' ').split(' ');
};
window['MDW']['getClassNames'] = getClassNames;

function hasClassName(element, className) {
	if(!(element = $(element))) return false;
	var classes = getClassNames(element);
	for (var i = 0; i < classes.length; i++) {
		// Check if the className matches and return true if it does
		if (classes[i] === className) { return true; }
	}
	return false;
};
window['MDW']['hasClassName'] = hasClassName;

function addClassName(element, className) {
	if(!(element = $(element))) return false;
	element.className += (element.className ? ' ' : '') + className;
	return true;
};
window['MDW']['addClassName'] = addClassName;


function removeClassName(element, className) {
	if(!(element = $(element))) return false;
	var classes = getClassNames(element);
	var length = classes.length
	for (var i = length-1; i >= 0; i--) {
		if (classes[i] === className) { delete(classes[i]); }
	}
	element.className = classes.join(' ');
	return (length == classes.length ? false : true);
};
window['MDW']['removeClassName'] = removeClassName;

function addStyleSheet(url,media) {
	media = media || 'screen';
	var link = document.createElement('LINK');
	link.setAttribute('rel','stylesheet');
	link.setAttribute('type','text/css');
	link.setAttribute('href',url);
	link.setAttribute('media',media);
	document.getElementsByTagName('head')[0].appendChild(link);
}
window['MDW']['addStyleSheet'] = addStyleSheet;


function removeStyleSheet(url,media) {
	var styles = getStyleSheets(url,media);
	for(var i = 0 ; i < styles.length ; i++) {
		var node = styles[i].ownerNode || styles[i].owningElement;
		styles[i].disabled = true;
		node.parentNode.removeChild(node);
	}
}
window['MDW']['removeStyleSheet'] = removeStyleSheet;

function getStyleSheets(url,media) {
	var sheets = [];
	for(var i = 0 ; i < document.styleSheets.length ; i++) {
		if (url &&  document.styleSheets[i].href.indexOf(url) == -1) { continue; }
		if(media) {
			media = media.replace(/,\s*/,',');
			var sheetMedia;
			    
			if(document.styleSheets[i].media.mediaText) {
			    sheetMedia = document.styleSheets[i].media.mediaText.replace(/,\s*/,',');
			    sheetMedia = sheetMedia.replace(/,\s*$/,'');
			} else {
			    sheetMedia = document.styleSheets[i].media.replace(/,\s*/,',');
			}
			if (media != sheetMedia) { continue; }
		}
		sheets.push(document.styleSheets[i]);
	}
	return sheets;
}
window['MDW']['getStyleSheets'] = getStyleSheets;

function editCSSRule(selector,styles,url,media) {
	var styleSheets = (typeof url == 'array' ? url : getStyleSheets(url,media));

	for ( i = 0; i < styleSheets.length; i++ ) {
		var rules = styleSheets[i].cssRules || styleSheets[i].rules;
		if (!rules) { continue; }
		selector = selector.toUpperCase();
		
		for(var j = 0; j < rules.length; j++) {
			if(rules[j].selectorText.toUpperCase() == selector) {
			    for (property in styles) {
			        if(!styles.hasOwnProperty(property)) { continue; }
			        rules[j].style[camelize(property)] = styles[property];
			    }
			}
		}
	}
}
window['MDW']['editCSSRule'] = editCSSRule;

function addCSSRule(selector, styles, index, url, media) {
	var declaration = '';
	for (property in styles) {
		if(!styles.hasOwnProperty(property)) { continue; }
		declaration += property + ':' + styles[property] + '; ';
	}

	var styleSheets = (typeof url == 'array' ? url : getStyleSheets(url,media));
	var newIndex;
	for(var i = 0 ; i < styleSheets.length ; i++) {
		if(styleSheets[i].insertRule) {
			newIndex = (index >= 0 ? index : styleSheets[i].cssRules.length);
			styleSheets[i].insertRule(selector + ' { ' + declaration + ' } ', 
			    newIndex);
		} else if(styleSheets[i].addRule) {
			newIndex = (index >= 0 ? index : -1);
			styleSheets[i].addRule(selector, declaration, newIndex);
		}
	}
}
window['MDW']['addCSSRule'] = addCSSRule;

function getStyle(element,property) {
	if(!(element = $(element)) || !property) return false;
	var value = element.style[camelize(property)];
	if (!value) {
		if (document.defaultView && document.defaultView.getComputedStyle) {
			var css = document.defaultView.getComputedStyle(element, null);
			value = css ? css.getPropertyValue(property) : null;
		} else if (element.currentStyle) {
			value = element.currentStyle[camelize(property)];
		}
	}
	return value == 'auto' ? '' : value;
}
window['MDW']['getStyle'] = getStyle;
window['MDW']['getStyleById'] = getStyle;

function parseJSON(s,filter) {
	var j;

	function walk(k, v) {
		var i;
		if (v && typeof v === 'object') {
			for (i in v) {
			    if (v.hasOwnProperty(i)) {
			        v[i] = walk(i, v[i]);
			    }
			}
		}
		return filter(k, v);
	}

 if (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.
			test(s)) {
		try {
			j = eval('(' + s + ')');
		} catch (e) {
			throw new SyntaxError("parseJSON");
		}
	} else {
		throw new SyntaxError("parseJSON");
	}
	if (typeof filter === 'function') {
		j = walk('', j);
	}
	return j;
};

function getRequestObject(url,options) {
	var req = false;
	if(window.XMLHttpRequest) {
		var req = new window.XMLHttpRequest();
	} else if (window.ActiveXObject) {
		var req = new window.ActiveXObject('Microsoft.XMLHTTP');
	}
	if(!req) return false;
	options = options || {};
	options.method = options.method || 'GET';
	options.send = options.send || null;
	req.onreadystatechange = function() {
		switch (req.readyState) {
			case 1:
			    if(options.loadListener) {
			        options.loadListener.apply(req,arguments);
			    }
			    break;
			case 2:
			    if(options.loadedListener) {
			        options.loadedListener.apply(req,arguments);
			    }
			    break;
			case 3:
			    if(options.ineractiveListener) {
			        options.ineractiveListener.apply(req,arguments);
			    }
			    break;
			case 4:
			    try { 
			    if (req.status && req.status == 200) {
			        var contentType = req.getResponseHeader('Content-Type');
			        var mimeType = contentType.match(/\s*([^;]+)\s*(;|$)/i)[1];
			                            
			        switch(mimeType) {
			            case 'text/javascript':
			            case 'application/javascript':
			                if(options.jsResponseListener) {
			                    options.jsResponseListener.call(
			                        req,
			                        req.responseText
			                    );
			                }
			                break;
			            case 'application/json':
			                if(options.jsonResponseListener) {
			                    try {
			                        var json = parseJSON(
			                            req.responseText
			                        );
			                    } catch(e) {
			                        var json = false;
			                    }
			                    options.jsonResponseListener.call(
			                        req,
			                        json
			                    );
			                }
			                break;
			            case 'text/xml':
			            case 'application/xml':
			            case 'application/xhtml+xml':
			                if(options.xmlResponseListener) {
			                    options.xmlResponseListener.call(
			                        req,
			                        req.responseXML
			                    );
			                }
			                break;
			            case 'text/html':
			                if(options.htmlResponseListener) {
			                    options.htmlResponseListener.call(
			                        req,
			                        req.responseText
			                    );
			                }
			                break;
			        }
			        if(options.completeListener) {
			            options.completeListener.apply(req,arguments);
			        }

			    } else {
			        if(options.errorListener) {
			            options.errorListener.apply(req,arguments);
			        }
			    }
			    

			    } catch(e) {
			        //ignore errors
			        //alert('Response Error: ' + e);
			    }
			    break;
		}
	};
	req.open(options.method, url, true);
	req.setRequestHeader('X-MDW-Ajax-Request','AjaxRequest');
	return req;
}
window['MDW']['getRequestObject'] = getRequestObject;

function ajaxRequest(url,options) {
	var req = getRequestObject(url,options);
	return req.send(options.send);
}
window['MDW']['ajaxRequest'] = ajaxRequest;

var XssHttpRequestCount=0;
var XssHttpRequest = function(){
	this.requestID = 'XSS_HTTP_REQUEST_' + (++XssHttpRequestCount);
}
XssHttpRequest.prototype = {
	url:null,
	scriptObject:null,
	responseJSON:null,
	status:0,
	readyState:0,
	timeout:30000,
	onreadystatechange:function() { },
	
	setReadyState: function(newReadyState) {
		if(this.readyState < newReadyState || newReadyState==0) {
			this.readyState = newReadyState;
			this.onreadystatechange();
		}
	},
	
	open: function(url,timeout){
		this.timeout = timeout || 30000;
		this.url = url 
			+ ((url.indexOf('?')!=-1) ? '&' : '?' ) 
			+ 'XSS_HTTP_REQUEST_CALLBACK=' 
			+ this.requestID 
			+ '_CALLBACK';    
		this.setReadyState(0);        
	},
	
	send: function(){
		var requestObject = this;
		this.scriptObject = document.createElement('script');
		this.scriptObject.setAttribute('id',this.requestID);
		this.scriptObject.setAttribute('type','text/javascript');
		var timeoutWatcher = setTimeout(function() {
			window[requestObject.requestID + '_CALLBACK'] = function() { };
			requestObject.scriptObject.parentNode.removeChild(
			    requestObject.scriptObject
			);
			requestObject.status = 2;
			requestObject.statusText = 'Timeout after ' 
			    + requestObject.timeout 
			    + ' milliseconds.'
			requestObject.setReadyState(2);
			requestObject.setReadyState(3);
			requestObject.setReadyState(4);
			        
		},this.timeout);
		window[this.requestID + '_CALLBACK'] = function(JSON) {

			clearTimeout(timeoutWatcher);
			requestObject.setReadyState(2);
			requestObject.setReadyState(3);
			requestObject.responseJSON = JSON; 
			requestObject.status=1;
			requestObject.statusText = 'Loaded.'
			requestObject.setReadyState(4);
		}
		this.setReadyState(1);
		this.scriptObject.setAttribute('src',this.url);                    
		var head = document.getElementsByTagName('head')[0];
		head.appendChild(this.scriptObject);
		
	}
}
window['MDW']['XssHttpRequest'] = XssHttpRequest;
function getXssRequestObject(url,options) {
	var req = new  XssHttpRequest();
	options = options || {};
	options.timeout = options.timeout || 30000;
	req.onreadystatechange = function() {
		switch (req.readyState) {
			case 1:
			    if(options.loadListener) {
			        options.loadListener.apply(req,arguments);
			    }
			    break;
			case 2:
			    if(options.loadedListener) {
			        options.loadedListener.apply(req,arguments);
			    }
			    break;
			case 3:
			    if(options.ineractiveListener) {
			        options.ineractiveListener.apply(req,arguments);
			    }
			    break;
			case 4:
			    if (req.status == 1) {
			        if(options.completeListener) {
			            options.completeListener.apply(req,arguments);
			        }
			    } else {
			        if(options.errorListener) {
			            options.errorListener.apply(req,arguments);
			        }
			    }
			    break;
		}
	};
	req.open(url,options.timeout);
	
	return req;
}
window['MDW']['getXssRequestObject'] = getXssRequestObject;

function xssRequest(url,options) {
	var req = getXssRequestObject(url,options);
	return req.send(null);
}
window['MDW']['xssRequest'] = xssRequest;

function makeCallback(method, target) {
	return function() { method.apply(target,arguments); }
}

var actionPager =  {
	lastHash : '',
	callbacks: [],
	safariHistory : false,
	msieHistory: false,
	ajaxifyClassName: '',
	ajaxifyRoot: '',
	
	
	init: function(ajaxifyClass,ajaxifyRoot,startingHash) {

		this.ajaxifyClassName = ajaxifyClass || 'MDWActionLink';
		this.ajaxifyRoot = ajaxifyRoot || '';

		if (/Safari/i.test(navigator.userAgent)) {
			this.safariHistory = [];
		} else if (/MSIE/i.test(navigator.userAgent)) {
			this.msieHistory = document.createElement("iframe");
			this.msieHistory.setAttribute("id", "msieHistory");
			this.msieHistory.setAttribute("name", "msieHistory");
			setStyleById(this.msieHistory,{
			    'width':'100px',
			    'height':'100px',
			    'border':'1px solid black',
			    'visibility':'visible',
			    'zIndex':'-1'
			});
			document.body.appendChild(this.msieHistory);
			this.msieHistory = frames['msieHistory'];
			
		}

		this.ajaxifyLinks();
		var location = this.getLocation();
		if(!location.hash && !startingHash) { startingHash = 'start'; }
		ajaxHash = this.getHashFromURL(location.hash) || startingHash;
		this.addBackButtonHash(ajaxHash);
		var watcherCallback = makeCallback(this.watchLocationForChange,this);
		window.setInterval(watcherCallback,200);
	},
	ajaxifyLinks: function() {
		links = getElementsByClassName(this.ajaxifyClassName, 'a', document);
		for(var i=0 ; i < links.length ; i++) {
			if(hasClassName(links[i],'MDWActionPagerModified')) { continue; }
			links[i].setAttribute(
			    'href',
			    this.convertURLToHash(links[i].getAttribute('href'))
			);
			addClassName(links[i],'MDWActionPagerModified');
			addEvent(links[i],'click',function() {
			     if (this.href && this.href.indexOf('#') > -1) {
			         actionPager.addBackButtonHash(
			            actionPager.getHashFromURL(this.href)
			        );
			     }
			});
		}
	},
	addBackButtonHash: function(ajaxHash) {
		if (!ajaxHash) return false;
		if (this.safariHistory !== false) {
			if (this.safariHistory.length == 0) {
			    this.safariHistory[window.history.length] = ajaxHash;
			} else {
			    this.safariHistory[window.history.length+1] = ajaxHash;
			}
			return true;
		} else if (this.msieHistory !== false) {
			this.msieHistory.document.execCommand('Stop');
			this.msieHistory.location.href = '/fakepage?hash='
			    + ajaxHash
			    + '&title='+document.title;
			return true;
		} else {
			var timeoutCallback = makeCallback(function() {
			    if (this.getHashFromURL(window.location.href) != ajaxHash) {
			        window.location.replace(location.href+'#'+ajaxHash);
			    }
			},this);
			setTimeout(timeoutCallback, 200);
			return true;
		}
		return false;
	},
	watchLocationForChange: function() {
		
		var newHash;
		if (this.safariHistory !== false) {
			if (this.safariHistory[history.length]) {
			    newHash = this.safariHistory[history.length];
			}
		} else if (this.msieHistory !== false) {
			newHash = this.msieHistory.location.href.split('&')[0].split('=')[1];
		} else if (location.hash != '') {
			newHash = this.getHashFromURL(window.location.href);

		}
		if (newHash && this.lastHash != newHash) {
			if (this.msieHistory !== false 
			&& this.getHashFromURL(window.location.href) != newHash) {
			    location.hash = newHash;
			}
			try {
			    this.executeListeners(newHash);
			    this.ajaxifyLinks();
			} catch(e) {
			    alert(e);
			}
			this.lastHash = newHash;
		}
	},
	register: function(regex,method,context){
		var obj = {'regex':regex};
		if(context) {
			obj.callback = function(matches) { method.apply(context,matches); };
		} else {
			obj.callback = function(matches) { method.apply(window,matches); };
		}
		this.callbacks.push(obj)
	},
	convertURLToHash: function(url) {
		if (!url) {
			return '#';
		} else if(url.indexOf("#") != -1) {
			return url.split("#")[1];
		} else {
			if(url.indexOf("://") != -1) {
			    url = url.match(/:\/\/[^\/]+(.*)/)[1];
			}
			return '#' + url.substr(this.ajaxifyRoot.length)
		}
	},
	getHashFromURL: function(url) {
		if (!url || url.indexOf("#") == -1) { return ''; }
		return url.split("#")[1];
	},
	getLocation: function() {
		if(!window.location.hash) {
			var url = {host:null,hash:null}
			if (window.location.href.indexOf("#") > -1) {
			    parts = window.location.href.split("#")[1];
			    url.domain = parts[0];
			    url.hash = parts[1];
			} else {
			    url.domain = window.location;
			}
			return url;
		}
		return window.location;
	},
	executeListeners: function(hash){
		for(var i in this.callbacks) {
			if((matches = hash.match(this.callbacks[i].regex))) {
			    this.callbacks[i].callback(matches);
			}
		}
	}
}
window['MDW']['actionPager'] = actionPager;

function clone(myObj) {
	if(typeof(myObj) != 'object') return myObj;
	if(myObj == null) return myObj;
	var myNewObj = new Object();
	for(var i in myObj) {
		myNewObj[i] = clone(myObj[i]);
	}
	return myNewObj;
}

var requestQueue = [];

function ajaxRequestQueue(url,options,queue) {
	queue = queue || 'default';
	options = clone(options) || {};
	if(!requestQueue[queue]) requestQueue[queue] = [];
	var userCompleteListener = options.completeListener;
	options.completeListener = function() {
		if(userCompleteListener) {
			userCompleteListener.apply(this,arguments);        
		};
		requestQueue[queue].shift();
		if(requestQueue[queue][0]) {
			var q = requestQueue[queue][0].req.send(
			    requestQueue[queue][0].send
			);
		}
	}

	var userErrorListener = options.errorListener;
	options.errorListener = function() {
	
		if(userErrorListener) {
			userErrorListener.apply(this,arguments);        
		};
		requestQueue[queue].shift();
		if(requestQueue[queue].length) {
			var q = requestQueue[queue].shift();
			q.req.abort();
			var fakeRequest = new Object();
			fakeRequest.status = 0;
			fakeRequest.readyState = 4

			fakeRequest.responseText = null;
			fakeRequest.responseXML = null;
			fakeRequest.statusText = 'A request in the queue received an error';
			q.error.apply(fakeRequest);
		}
	   
	}

	requestQueue[queue].push({
		req:getRequestObject(url,options),
		send:options.send,
		error:options.errorListener
	});  
	if(requestQueue[queue].length == 1) {
		ajaxRequest(url,options);
	}
}
window['MDW']['ajaxRequestQueue'] = ajaxRequestQueue;

})();