navigator-js.js

/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:</p>

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
this.navigatorjs = this.navigatorjs || {};

(function() {
	var AsynchResponders = function() {
		this._responders = [];
	};

	//PUBLIC API
	AsynchResponders.prototype = {
		getLength: function() {
			return this._responders.length;
		},

		isBusy: function() {
			return this.getLength() > 0;
		},

		hasResponder: function(responder) {
			return this._responders.indexOf(responder) != -1;
		},

		addResponder: function(responder) {
			this._responders.push(responder);
		},

		addResponders: function(additionalRespondersArray) {
			if (additionalRespondersArray && additionalRespondersArray instanceof Array && additionalRespondersArray.length) {
				this._responders = this._responders.concat(additionalRespondersArray);
			}
		},

		takeOutResponder: function(responder) {
			var index = this._responders.indexOf(responder);
			if (index != -1) {
				this._responders.splice(index, 1);
				return true;
			}

			return false;
		},

		reset: function() {
			if (this._responders.length > 0) {
				console.warn("Resetting too early? Still have responders marked for asynchronous tasks");
			}

			this._responders = [];
		}
	};

	navigatorjs.AsynchResponders = AsynchResponders;
}());;this.navigatorjs = this.navigatorjs || {};

(function() {

	/**
	 * History manager for the navigatorjs.Navigator
	 * 
	 * @example 
	 *	<code>
	 *		
	 *		// Create the normal navigator
	 *		var navigator = new navigatorjs.Navigator();
	 *		
	 *		// Create the history and supply the navigator it should manage
	 *		var history = new navigatorjs.History(navigator);
	 *
	 *		// Navigate to states as you normally would
	 *		navigator.request('/my/state');
	 *		
	 *		// Go back in time
	 *		history.back();
	 *		
	 *	</code>
	 *
	 * @author Laurent van Dommelen
	 * @created 11 oct 2013
	 * 
	 * @param {navigatorjs.Navigator} navigator
	 */
	var History = function(navigator) {

		// Bind the methods to this scope
		navigatorjs.utils.AutoBind(this, this);

		// Initialize the instance
		this._initialize(navigator);
	};

	// Default max history length, don't change this, 
	// change the maxLength instance property
	History.MAX_HISTORY_LENGTH = 100;

	// Navigation direction types
	History.DIRECTION_BACK = -1;
	History.DIRECTION_NORMAL = 0;
	History.DIRECTION_FORWARD = 1;

	/**
	 * Instance properties
	 */
	History.prototype = {

		// The navigator it is controlling
		_navigator: null,

		// The history, last state is at start of Array
		_history: null,

		// The current position in history
		_historyPosition: 0,

		// The navigator doesn't know anything about going forward or back.
		// Therefore, we need to keep track of the direction.
		// This is changed when the forward or back methods are called.
		_navigationDirection: History.DIRECTION_NORMAL,

		// The max number of history states
		maxLength: History.MAX_HISTORY_LENGTH,

		/**
		 * Create the history manager. When navigating back and forword, the history is maintained. 
		 * It is truncated when navigating to a state naturally
		 * 
		 * @param {navigatorjs.Navigator} navigator
		 * @param {Object} [options]
		 */
		_initialize: function(navigator, options) {

			// Setup the options
			if (options) {
				this.maxLength = options.maxLength || this.maxLength;
			}

			// Create the history array containing the NavigationState objects
			this._history = [];

			// Listen to changes on the navigator
			this._navigator = navigator;
			this._navigator.on(navigatorjs.NavigatorEvent.STATE_CHANGED, this._handleStateChange);
		},

		/**
		 * Go back in the history
		 * 
		 * @param {Number} [steps=1] The number of steps to go back in history
		 * @return {Boolean} Returns false if there was no previous state
		 */
		back: function(steps) {

			// Check if we know history
			if (this._historyPosition == this._history.length - 1) {
				return false;
			}

			// Set to 1 by default
			steps = steps || 1;

			// Set the history position and navigate to it
			this._historyPosition = Math.min(this._history.length - 1, this._historyPosition + steps);
			this._navigationDirection = History.DIRECTION_BACK;
			this._navigateToCurrentHistoryPosition();
			return true;
		},

		/**
		 * Go forward in the history
		 * 
		 * @param {Number} [steps=1] The number of steps to go forward in history
		 * @return {Boolean} Returns false if there was no next state
		 */
		forward: function(steps) {
			if (this._historyPosition === 0) {
				return false;
			}

			// Set to 1 by default
			steps = steps || 1;

			// Set the history position and navigate to it
			this._historyPosition = Math.max(0, this._historyPosition - steps);
			this._navigationDirection = History.DIRECTION_FORWARD;
			this._navigateToCurrentHistoryPosition();
			return true;
		},

		/**
		 * Go back in the history and return that NavigationState
		 * 
		 * @param {Number} [steps=1] The number of steps to go back in history
		 * @return {navigatorjs.NavigationState} The found state or null if no state was found
		 */
		getPreviousState: function(steps) {

			// Cannot go beyond the first entry in history
			if (this._history.length === 0 || this._historyPosition == Math.max(0, this._history.length - 1)) {
				return null;
			}

			// Set to 1 by default
			steps = steps || 1;

			// Fetch the requested state in history
			var position = Math.min(this._history.length - 1, Math.max(0, this._historyPosition + steps));
			return this._history[position];
		},

		/**
		 * Go forward in the history and return that NavigationState
		 * 
		 * @param {Number} [steps=1] The number of steps to go back in history
		 * @return {navigatorjs.NavigationState} The found state or null if no state was found
		 */
		getNextState: function(steps) {

			// Cannot look into the future
			if (this._history.length === 0 || this._historyPosition === 0) {
				return null;
			}

			// Set to 1 by default
			steps = steps || 1;

			// Fetch the requested state in history
			var position = Math.max(0, this._historyPosition - steps);
			return this._history[position];
		},

		/**
		 * Fetch the current NavigationState
		 * 
		 * @return {navigatorjs.NavigationState}
		 */
		getCurrentState: function() {
			return this._history[this._historyPosition] || null;
		},

		/**
		 * Clear the navigation history
		 */
		clearHistory: function() {
			this._history = [];
			this._historyPosition = 1;
		},

		/**
		 * Get the full history
		 * 
		 * @return {Array} List of navigatorjs.NavigationStates
		 */
		all: function() {
			return this._history;
		},

		/**
		 * Get the state by historyposition
		 * 
		 * @param {Number} position The position in history
		 * @return {navigatorjs.NavigationState} The found state or null if no state was found
		 */
		getStateByPosition: function (position) {
			if (position < 0 || position > this._history.length - 1) {
				return null;
			}
			return this._history[position];
		},

		/**
		 * Get the first occurence of a state in the history
		 * 
		 * @param {navigatorjs.NavigationState} state The NavigationState in history
		 * @return {Number} The found position or false if not found
		 */
		getPositionByState: function(state) {
			return this.getPositionByPath(state.getPath());
		},

		/**
		 * Find the first occurence of the path in the history
		 * 
		 * @param {String} path
		 * @return {Number} The index or false if not found
		 */
		getPositionByPath: function(path) {
			var count = this.getLength();
			for (var i = 0; i < count; i++) {
				if (this._history[i].getPath() == path) {
					return i;
				}
			}
			return false;
		},

		/**
		 * Get the number of items in the history
		 * 
		 * @return {Number}
		 */
		getLength: function() {
			return this._history.length;
		},

		/**
		 * Tell the navigator to go the current historyPosition
		 */
		_navigateToCurrentHistoryPosition: function() {
			var newState = this._history[this._historyPosition];
			this._navigator.request(newState);
		},

		/**
		 * Check what to do with the new state
		 *
		 * @param {Object} event
		 * @param {Object} update
		 */
		_handleStateChange: function(event, update) {
			var state = update.state;

			switch (this._navigationDirection) {

				case History.DIRECTION_BACK:
					this._navigationDirection = History.DIRECTION_NORMAL;
					break;

				case History.DIRECTION_NORMAL:

					// Strip every history state before current
					this._history.splice(0, this._historyPosition);

					// Add the state at the beginning of the history array
					this._history.unshift(state);
					this._historyPosition = 0;

					// Truncate the history to the max allowed items
					this._history.length = Math.min(this._history.length, this.maxLength);
					break;

				case History.DIRECTION_FORWARD:
					this._navigationDirection = History.DIRECTION_NORMAL;
					break;
			}
		}
	};

	// Copy the History object to the navigatorjs namespace
	navigatorjs.History = History;
}());;this.navigatorjs = this.navigatorjs || {};

this.navigatorjs.NavigationBehaviors = {};

/**
 * Will show when the state matches, will hide when it doesn't
 */
this.navigatorjs.NavigationBehaviors.SHOW = "show";
/**
 * Will hide when the state matches, even if it has a show on a higher level
 */
this.navigatorjs.NavigationBehaviors.HIDE = "hide";
/**
 * Will update before any show method gets called
 */
this.navigatorjs.NavigationBehaviors.UPDATE = "update";
/**
 * Will swap out and in, when the state is changed
 */
this.navigatorjs.NavigationBehaviors.SWAP = "swap";
/**
 * Will ask for validation of the state, if a state can't be validated, it is denied
 */
this.navigatorjs.NavigationBehaviors.VALIDATE = "validate";
/**
 * Will try to add all behaviors, based on the class properties of the responder
 */
this.navigatorjs.NavigationBehaviors.AUTO = "auto";
/**
 * Used for looping through when the AUTO behavior is used.
 */
this.navigatorjs.NavigationBehaviors.ALL_AUTO = ["show", "update", "swap", "validate"];;this.navigatorjs = this.navigatorjs || {};

this.navigatorjs.NavigationResponderBehaviors = {};
this.navigatorjs.NavigationResponderBehaviors.IHasStateInitialization = {name: "IHasStateInitialization", methods: ["initializeByNavigator"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateValidation = {name: "IHasStateValidation", methods: ["validate"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateValidationAsync = {name: "IHasStateValidationAsync", "extends": ["IHasStateValidation"], methods: ["prepareValidation"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateValidationOptional = {name: "IHasStateValidationOptional", "extends": ["IHasStateValidation"], methods: ["willValidate"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateValidationOptionalAsync = {name: "IHasStateValidationOptionalAsync", "extends": ["IHasStateValidationAsync", "IHasStateValidationOptional"], methods: []};
this.navigatorjs.NavigationResponderBehaviors.IHasStateRedirection = {name: "IHasStateRedirection", "extends": ["IHasStateValidation"], methods: ["redirect"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateSwap = {name: "IHasStateSwap", methods: ["willSwapToState", "swapOut", "swapIn"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateTransition = {name: "IHasStateTransition", methods: ["transitionIn", "transitionOut"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateUpdate = {name: "IHasStateUpdate", methods: ["updateState"]};

this.navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface = function(object, interface) {
	if (object.navigatorBehaviors == undefined || !object.navigatorBehaviors instanceof Array) {
		//The input interface is not set on object's navigatorBehaviors.
		return false;
	}

	var inheritanceChain = navigatorjs.NavigationResponderBehaviors.getInterfaceInheritanceChain(interface),
		methodsToBeImplemented = navigatorjs.NavigationResponderBehaviors.getInterfaceMethods(inheritanceChain),
		i, method,
		length = methodsToBeImplemented.length;

	for (i = 0; i < length; i++) {
		method = methodsToBeImplemented[i];

		if (object[method] == undefined || typeof object[method] !== 'function') {
			return false;
		}
	}

	return true;
};

this.navigatorjs.NavigationResponderBehaviors.getInterfaceInheritanceChain = function(interface, existingChain) {
	var chain = existingChain || [],
		extendsArray,
		extendingInterface,
		i, length,
		interfaceObject = navigatorjs.NavigationResponderBehaviors[interface];

	if (interfaceObject == undefined || typeof interfaceObject !== 'object') {
//		console.log('behaviorObject for interface is undefined ', interface );
		return chain;
	}

	chain.push(interface);
	extendsArray = interfaceObject["extends"];
	if (extendsArray == undefined) {
//		console.log('extendsArray for interface is undefined, the chain ends here ', interface, chain);
		return chain;
	}

	length = extendsArray.length;

	for (i = 0; i < length; i++) {
		extendingInterface = extendsArray[i];
		if (chain.indexOf(extendingInterface) == -1) {
			//We did not yet extend this interface, so continue to follow the chain
			navigatorjs.NavigationResponderBehaviors.getInterfaceInheritanceChain(extendingInterface, chain);
		}
	}

	return chain;
};

this.navigatorjs.NavigationResponderBehaviors.getInterfaceMethods = function(interfaces) {
	if (interfaces == undefined || !interfaces instanceof Array) {
		//No valid input
		return [];
	}

	var combinedInterfacesChain = [],
		interface, i,
		length = interfaces.length,
		interfaceObject,
		interfaceMethods,
		j, methodsLength, method,
		methods = [];

	for (i = 0; i < length; i++) {
		interface = interfaces[i];
		navigatorjs.NavigationResponderBehaviors.getInterfaceInheritanceChain(interface, combinedInterfacesChain);
	}

	length = combinedInterfacesChain.length;
	for (i = 0; i < length; i++) {
		interface = combinedInterfacesChain[i];
		interfaceObject = navigatorjs.NavigationResponderBehaviors[interface];
		interfaceMethods = interfaceObject.methods;
		if (interfaceObject != undefined && typeof interfaceObject === 'object' && interfaceMethods != undefined && interfaceMethods instanceof Array) {
			methodsLength = interfaceMethods.length;
			for (j = 0; j < methodsLength; j++) {
				method = interfaceMethods[j];
				if (methods.indexOf(method) == -1) {
					methods.push(method);
				}
			}
		}
	}

	return methods;
};;this.navigatorjs = this.navigatorjs || {};

(function() {
	var NavigationState = function(pathStringOrArray) {
		this._path = '';

		if (pathStringOrArray instanceof Array) {
			this.setSegments(pathStringOrArray);
		} else {
			this.setPath(pathStringOrArray || "");
		}
	};

	NavigationState.make = function(stateOrPath) {
		return stateOrPath instanceof navigatorjs.NavigationState ? stateOrPath : new navigatorjs.NavigationState(stateOrPath);
	};

	NavigationState.prototype = {
		setPath: function(path) {
			this._path = '/' + path.toLowerCase() + '/';
			this._path = this._path.replace(new RegExp("[^-_/A-Za-z0-9* ]", "g"), "");
			this._path = this._path.replace(new RegExp("\/+", "g"), "/");
			this._path = this._path.replace(/\s+/g, "-");

			return this;
		},

		getPath: function() {
			return this._path;
		},

		getPathRegex: function() {
			var segments = this.getSegments(),
				regexPath = "\/",
				segment,
				i, length = segments.length;

			for(i=0; i<length; i++) {
				segment = segments[i];

				if(segment == "**") {
					// match any character, including slashes (multiple segments)
					// eg: bla or bla/bla or bla/bla/bla
					regexPath = regexPath + "(.*)";
				} else if(segment == "*") {
					// match anything expect slashes and end with a slash (1 segment only).
					// eg: bla/ but not /bla/ or bla/bla/
					regexPath = regexPath + "([^/]*)\/";
				} else {
					// Either the segment, a wildcard or double wildcard and ends with a forward slash (1 segment only).
					// eg: segment/ or */ or **/
					regexPath = regexPath + "("+segment+"|\\*|\\*\\*)\/";
				}
			}

			return new RegExp(regexPath);
		},

		setSegments: function(segments) {
			this.setPath(segments.join("/"));
		},

		getSegments: function() {
			var segments = this._path.split("/");

			segments.pop();
			segments.shift();

			return segments;
		},

		getSegment: function(index) {
			return this.getSegments()[index];
		},

		getFirstSegment: function() {
			return this.getSegment(0);
		},

		getLastSegment: function() {
			var segments = this.getSegments();
			return this.getSegment(segments.length - 1);
		},

		contains: function(foreignStateOrPathOrArray) {
			if(foreignStateOrPathOrArray instanceof Array) {
				return this._containsStateInArray(foreignStateOrPathOrArray);
			}

			var foreignStateOrPath = foreignStateOrPathOrArray, //if we get this far, it is a state or path
				foreignState = NavigationState.make(foreignStateOrPath),
				foreignSegments = foreignState.getSegments(),
				nativeSegments = this.getSegments(),
				foreignMatch = this.getPath().match(foreignState.getPathRegex()),
				nativeMatch = foreignState.getPath().match(this.getPathRegex()),
				isForeignMatch = foreignMatch && foreignMatch.index == 0 ? true : false,
				isNativeMatch = nativeMatch && nativeMatch.index == 0 ? true : false,
				foreignSegmentDoubleWildcardsMatch = foreignState.getPath().match(/\*\*/g),
				doubleWildcardsLength = foreignSegmentDoubleWildcardsMatch ? foreignSegmentDoubleWildcardsMatch.length : 0,
				tooManyForeignSegments = foreignSegments.length > (nativeSegments.length + doubleWildcardsLength),
				enoughNativeSegments = nativeSegments.length > foreignSegments.length;

			return (isForeignMatch || (isNativeMatch && enoughNativeSegments)) && !tooManyForeignSegments;
		},

		_containsStateInArray: function(foreignStatesOrPaths) {
			var i, length = foreignStatesOrPaths.length,
				foreignStateOrPath;

			for(i=0; i<length; i++){
				foreignStateOrPath = foreignStatesOrPaths[i];
				if(this.contains(foreignStateOrPath)) {
					return true;
				}
			}

			return false;
		},

		equals: function(stateOrPathOrArray) {
			if(stateOrPathOrArray instanceof Array) {
				return this._equalsStateInArray(stateOrPathOrArray);
			}

			var stateOrPath = stateOrPathOrArray, //if we get this far, it is a state or path
				state = NavigationState.make(stateOrPath),
				subtractedState = this.subtract(state) || state.subtract(this); //Or the other way around for double wildcard states
			
			if (subtractedState === null) {
				return false;
			}

			return subtractedState.getSegments().length === 0;
		},

		_equalsStateInArray: function(statesOrPaths) {
			var i, length = statesOrPaths.length,
				stateOrPath;

			for(i=0; i<length; i++){
				stateOrPath = statesOrPaths[i];
				if(this.equals(stateOrPath)) {
					return true;
				}
			}

			return false;
		},

		subtract: function(operandStateOrPath) {
			var operand = NavigationState.make(operandStateOrPath),
				subtractedPath;

			if (!this.contains(operand)) {
				return null;
			}
			
			subtractedPath = this.getPath().replace(operand.getPathRegex(), "");

			return new navigatorjs.NavigationState(subtractedPath);
		},

		append: function(stringOrState) {
			var path = stringOrState;
			if (stringOrState instanceof NavigationState) {
				path = stringOrState.getPath();
			}
			return this.setPath(this._path + path);
		},

		prepend: function(stringOrState) {
			var path = stringOrState;
			if (stringOrState instanceof NavigationState) {
				path = stringOrState.getPath();
			}
			return this.setPath(path + this._path);
		},

		hasWildcard: function() {
			return this.getPath().indexOf("/*/") != -1;
		},

		mask: function(sourceStateOrPath) {
			var sourceState = NavigationState.make(sourceStateOrPath),
				unmaskedSegments = this.getSegments(),
				sourceSegments = sourceState.getSegments(),
				length = Math.min(unmaskedSegments.length, sourceSegments.length),
				i;

			for (i = 0; i < length; i++) {
				if (unmaskedSegments[i] === "*") {
					unmaskedSegments[i] = sourceSegments[i];
				}
			}

			return new navigatorjs.NavigationState(unmaskedSegments);
		},

		clone: function() {
			return new navigatorjs.NavigationState(this._path);
		}
	};

	navigatorjs.NavigationState = NavigationState;
}());;this.navigatorjs = this.navigatorjs || {};

(function() {
	//
	var _$eventDispatcher = null;
	//internal namespaces
	var _flow = {};
	var _transition = {};
	var _validation = {};
	var _hidden = {};
	//
	var _currentState = null;
	var _previousState = null;
	var _defaultState = null;
	var _isTransitioning = false;
	//
	var _responders = null; //new navigatorjs.ResponderLists();
	var _respondersByID = null; //{};
	var _statusByResponderID = null; //{};
	var _redirects = null;
	var _disappearingAsynchResponders = null;
	var _appearingAsynchResponders = null;
	var _swappingAsynchResponders = null;
	var _validatingAsynchResponders = null;
	var _preparedValidatingAsynchRespondersStack = null;
	var _inlineRedirectionState = null;
	//
	var _asyncInvalidated = false;
	var _asyncValidated = false;
	var _asyncValidationOccurred = false;
	var _responderIDCount = 0;


	var _modify = function(addition, responder, pathsOrStates, behaviorString) {
		if (_relayModification(addition, responder, pathsOrStates, behaviorString)) {
			return;
		}

		// Using the path variable as dictionary key to break instance referencing.
		var path = navigatorjs.NavigationState.make(pathsOrStates).getPath(),
			list, matchingInterface;

		// Create, store and retrieve the list that matches the desired behavior.
		switch (behaviorString) {
			case navigatorjs.NavigationBehaviors.SHOW:
				matchingInterface = "IHasStateTransition";
				list = _responders.showByPath[path] = _responders.showByPath[path] || [];
				break;
			case navigatorjs.NavigationBehaviors.HIDE:
				matchingInterface = "IHasStateTransition";
				list = _responders.hideByPath[path] = _responders.hideByPath[path] || [];
				break;
			case navigatorjs.NavigationBehaviors.VALIDATE:
				matchingInterface = "IHasStateValidation";
				list = _responders.validateByPath[path] = _responders.validateByPath[path] || [];
				break;
			case navigatorjs.NavigationBehaviors.UPDATE:
				matchingInterface = "IHasStateUpdate";
				list = _responders.updateByPath[path] = _responders.updateByPath[path] || [];
				break;
			case navigatorjs.NavigationBehaviors.SWAP:
				matchingInterface = "IHasStateSwap";
				list = _responders.swapByPath[path] = _responders.swapByPath[path] || [];
				break;
			default:
				throw new Error("Unknown behavior: " + behaviorString);
		}

		//TODO: Build in more strict validation?
		if (!navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, matchingInterface)) {
			throw new Error("Responder " + responder + " should implement " + matchingInterface + " to respond to " + behaviorString);
		}
		if (addition) {
			// add
			if (list.indexOf(responder) < 0) {
				list.push(responder);

				if (responder.__navigatorjs == undefined) {
					//Create new hidden navigatorjs data
					_responderIDCount++;
					responder.__navigatorjs = {id: _responderIDCount};
					_respondersByID[responder.__navigatorjs.id] = responder;
				}

				// If the responder has no status yet, initialize it to UNINITIALIZED:
				_statusByResponderID[responder.__navigatorjs.id] = _statusByResponderID[responder.__navigatorjs.id] || navigatorjs.transition.TransitionStatus.UNINITIALIZED;
			} else {
				return;
			}
		} else {
			// remove
			var index = list.indexOf(responder);
			if (index >= 0) {
				list.splice(index, 1);

				delete _statusByResponderID[responder.__navigatorjs.id];
				delete _respondersByID[responder.__navigatorjs.id];
			} else {
				return;
			}

			if (matchingInterface == "IHasStateSwap" && _responders.swappedBefore[responder]) {
				// cleanup after the special swap case
				delete _responders.swappedBefore[responder];
			}
		}

		_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
	};

	var _relayModification = function(addition, responder, pathsOrStates, behaviorString) {
		if (!responder) {
			throw new Error("add: responder is null");
		}

		var i, length;

		if (pathsOrStates instanceof Array) {
			length = pathsOrStates.length;
			for (i = 0; i < length; i++) {
				_modify(addition, responder, pathsOrStates[i], behaviorString);
			}
			return true;
		}

		behaviorString = behaviorString || navigatorjs.NavigationBehaviors.AUTO;
		if (behaviorString == navigatorjs.NavigationBehaviors.AUTO) {
			length = navigatorjs.NavigationBehaviors.ALL_AUTO.length;
			for (i = 0; i < length; i++) {
				try {
					_modify(addition, responder, pathsOrStates, navigatorjs.NavigationBehaviors.ALL_AUTO[i]);
				} catch (e) {
					// ignore 'should implement xyz' errors
				}
			}
			return true;
		}

		return false;
	};

	/**
	 * Check if there is a responder registered for a given state. Optionally check for implementation of a given
	 * interface. This allows you to check if there was something mapped to a state which implements
	 * "IHasStateValidationAsync" for example.
	 */
	var _hasRegisteredResponder = function(state, optionalInterface) {
		var i, length = _responders.all.length,
			j, respondersLength, responder,
			responders, respondersForPath, path;
		
		for(i=0; i<length; i++) {
			responders = _responders.all[i];
			for(path in responders) {
				if(state.equals(path)) {

					if(optionalInterface) {
						//Loop through all responders and check if it implements the given interface
						respondersForPath = responders[path];
						respondersLength = respondersForPath.length;
						for(j=0; j<respondersLength; j++) {
							responder = respondersForPath[j];
							if(navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, optionalInterface)) {
								return true;
							}
						}
					} else {
						return true;
					}

					return true;
				}
			}
		}

		return false;
	};

	var _request = function(pathOrState) {
		if (pathOrState == null) {
			// logger.error("Requested a null state. Aborting request.");
			return;
		}

		var requestedState,
			path,
			fromState,
			toState;

		// Store and possibly mask the requested state
		requestedState = navigatorjs.NavigationState.make(pathOrState);
		if (requestedState.hasWildcard()) {
			requestedState = requestedState.mask(_currentState || _defaultState);
		}

		// Check for exact match of the requested and the current state
		if (_currentState && _currentState.getPath() == requestedState.getPath()) {
			//logger.info("Already at the requested state: " + requested);
			return;
		}

		if (_redirects) {
			for (path in _redirects) {
				fromState = new navigatorjs.NavigationState(path);
				if (fromState.equals(requestedState)) {
					toState = navigatorjs.NavigationState.make(_redirects[path]);
					//logger.info("Redirecting " + from + " to " + to);
					_request(toState);
					return;
				}
			}
		}

		// this event makes it possible to add responders just in time to participate in the validation process.
		_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.STATE_REQUESTED, {state: requestedState});

		// Inline redirection is reset with every request call.
		// It can be changed by a responder implementing the IHasStateRedirection interface.
		_inlineRedirectionState = null;

		_performRequestCascade(requestedState);
	};

	var _performRequestCascade = function(requestedState, startAsyncValidation) {
		if (!_defaultState) { throw new Error("No default state set. Call start() before the first request!"); }
		// Request cascade starts here.
		//
//		console.groupEnd();
//		console.group('_performRequestCascade', requestedState.getPath(), startAsyncValidation);
		if (requestedState.getPath() == _defaultState.getPath() && !_defaultState.hasWildcard()) {
//			console.log('exact match');
			// Exact match on default state bypasses validation.
			_grantRequest(_defaultState);
		} else if (_asyncValidationOccurred && (_asyncValidated && !_asyncInvalidated)) {
//			console.log('Async operation completed');
			// Async operation completed
			_grantRequest(requestedState);
		} else if (_validate(requestedState, true, startAsyncValidation)) {
//			console.log('Any other state needs to be validated.');
			// Any other state needs to be validated.
			_grantRequest(requestedState);
		} else if (_validatingAsynchResponders && _validatingAsynchResponders.isBusy()) {
//			console.log('Waiting for async validation.');
			// Waiting for async validation.
			// FIXME: What do we do in the mean time, dispatch an event or sth?
			//logger.notice("waiting for async validation to complete");
		} else if (startAsyncValidation && _asyncValidationOccurred) {
//			console.log('any async prepration happened instantaneuously');
			// any async prepration happened instantaneuously
		} else if (_inlineRedirectionState) {
//			console.log('_inlineRedirectionState');
			_request(_inlineRedirectionState);
		} else if (_currentState) {
//			console.log('_inlineRedirectionState');
			// If validation fails, the notifyStateChange() is called with the current state as a parameter,
			// mainly for subclasses to respond to the blocked navigation (e.g. SWFAddress).
			_notifyStateChange(_currentState);
		} else if (requestedState.hasWildcard()) {
//			console.log('wildcard error');
			// If we get here, after validateWithWildcards has failed, this means there are still
			// wildcards in the requested state that didn't match the previous state. This,
			// unfortunately means your application has a logic error. Go fix it!
			throw new Error("Check wildcard masking: " + requestedState.getPath());
		} else if (_defaultState) {
//			console.log('everything failed, use default state');
			// If all else fails, we'll put up the default state.
			_grantRequest(_defaultState);
		} else {
//			console.log('everything failed without default state');
			// If you don't provide a default state, at least make sure your first request makes sense!
			throw new Error("First request is invalid: " + requestedState.getPath());
		}
	};

	var _grantRequest = function(state) {
		_asyncInvalidated = false;
		_asyncValidated = false;
		_previousState = _currentState;
		_currentState = state;

		_notifyStateChange(_currentState);

		_flow.startTransition();
	};

	var _notifyStateChange = function(state) {
		//logger.notice(state);

		// Do call the super.notifyStateChange() when overriding.
		if (state != _previousState) {
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.STATE_CHANGED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID, state: _currentState});
		}
	};

	// FLOW NAMESPACE START
	_flow.startTransition = function() {
		_isTransitioning = true;
		_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STARTED);

		_disappearingAsynchResponders = new navigatorjs.AsynchResponders();
		_disappearingAsynchResponders.addResponders(_flow.transitionOut());

		if (!_disappearingAsynchResponders.isBusy()) {
			_flow.performUpdates();
		}
	};

	_flow.transitionOut = function() {
		var respondersToShow = _getRespondersToShow(),
			responderID,
			responder,
			waitForResponders = [],
			i;

		// This initialize call is to catch responders that were put on stage to show,
		// yet still need to wait for async out transitions before they actually transition in.
		_initializeIfNeccessary(respondersToShow);

		for (responderID in _statusByResponderID) {
			responder = _respondersByID[responderID];
			if (respondersToShow.indexOf(responder) == -1) {
				// if the responder is not already hidden or disappearing, trigger the transitionOut:
				if (navigatorjs.transition.TransitionStatus.HIDDEN < _statusByResponderID[responderID] && _statusByResponderID[responderID] < navigatorjs.transition.TransitionStatus.DISAPPEARING &&
					//We could also not be hidden or disappearing but performing a state swap.
					navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateTransition")) {

					_statusByResponderID[responderID] = navigatorjs.transition.TransitionStatus.DISAPPEARING;
					waitForResponders.push(responder);

					//use namespace transition;
					//console.log('_flow -> transitionOut', responder);
					responder.transitionOut(new navigatorjs.transition.TransitionCompleteDelegate(responder, navigatorjs.transition.TransitionStatus.HIDDEN, navigatorjs.NavigationBehaviors.HIDE, this, _transition).call);
				} else {
					// already hidden or hiding
				}
			}
		}

		// loop backwards so we can splice elements off the array while in the loop.
		for (i = waitForResponders.length; --i >= 0;) {
			if (_statusByResponderID[waitForResponders[i].__navigatorjs.id] == navigatorjs.transition.TransitionStatus.HIDDEN) {
				waitForResponders.splice(i, 1);
			}
		}

		if (waitForResponders.length > 0) {
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
		}

		return waitForResponders;
	};

	_flow.performUpdates = function() {
		_disappearingAsynchResponders.reset();

		var path, state, list, i, responder;

		for (path in _responders.updateByPath) {
			// create a state object for comparison:
			state = new navigatorjs.NavigationState(path);

			if (_currentState.contains(state)) {
				// the lookup path is contained by the new state.
				list = _responders.updateByPath[path];

				_initializeIfNeccessary(list);

				// check for existing validators.
				for (i = 0; i < list.length; i++) {
					responder = list[i];
					responder.updateState(_currentState.subtract(state), _currentState);
				}
			}
		}

		_flow.startTransitionIn();
	};

	_flow.startTransitionIn = function() {
		_appearingAsynchResponders = new navigatorjs.AsynchResponders();
		_appearingAsynchResponders.addResponders(_flow.transitionIn());

		if (!_appearingAsynchResponders.isBusy()) {
			_flow.startSwapOut();
		}
	};

	_flow.transitionIn = function() {
		var respondersToShow = _getRespondersToShow(),
			respondersToWaitFor = [],
			responder,
			status,
			i;

		_initializeIfNeccessary(respondersToShow);

		//for each (var responder : IHasStateTransition in respondersToShow) {
		for (i = 0; i < respondersToShow.length; i++) {
			responder = respondersToShow[i];
			status = _statusByResponderID[responder.__navigatorjs.id];

			if (status < navigatorjs.transition.TransitionStatus.APPEARING || navigatorjs.transition.TransitionStatus.SHOWN < status) {
				// then continue with the transitionIn() call.
				_statusByResponderID[responder.__navigatorjs.id] = navigatorjs.transition.TransitionStatus.APPEARING;
				respondersToWaitFor.push(responder);

				//use namespace transition;
				responder.transitionIn(new navigatorjs.transition.TransitionCompleteDelegate(responder, navigatorjs.transition.TransitionStatus.SHOWN, navigatorjs.NavigationBehaviors.SHOW, this, _transition).call);
			}
		}

		// loop backwards so we can splice elements off the array while in the loop.
		for (i = respondersToWaitFor.length; --i >= 0;) {
			if (_statusByResponderID[respondersToWaitFor[i].__navigatorjs.id] == navigatorjs.transition.TransitionStatus.SHOWN) {
				respondersToWaitFor.splice(i, 1);
			}
		}

		if (respondersToWaitFor.length > 0) {
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
		}

		return respondersToWaitFor;
	};

	_flow.startSwapOut = function() {
		_swappingAsynchResponders = new navigatorjs.AsynchResponders();
		_swappingAsynchResponders.addResponders(_flow.swapOut());

		if (!_swappingAsynchResponders.isBusy()) {
			_flow.swapIn();
		}
	};

	_flow.swapOut = function() {
		_appearingAsynchResponders.reset();

		var waitForResponders = [],
			path, state,
			swapByPathList,
			responder,
			i,
			truncatedState;

		for (path in _responders.swapByPath) {
			// create a state object for comparison:
			state = new navigatorjs.NavigationState(path);

			if (_currentState.contains(state)) {
				// the lookup path is contained by the new state.
				swapByPathList = _responders.swapByPath[path];

				_initializeIfNeccessary(swapByPathList);

				// check for existing swaps.
				for (i = 0; i < swapByPathList.length; i++) {
					responder = swapByPathList[i];
					if (!_responders.swappedBefore[responder]) {
						continue;
					}

					truncatedState = _currentState.subtract(state);
					if (responder.willSwapToState(truncatedState, _currentState)) {
						_statusByResponderID[responder.__navigatorjs.id] = navigatorjs.transition.TransitionStatus.SWAPPING;
						waitForResponders.push(responder);

						//use namespace transition;
						responder.swapOut(new navigatorjs.transition.TransitionCompleteDelegate(responder, navigatorjs.transition.TransitionStatus.SHOWN, navigatorjs.NavigationBehaviors.SWAP, this, _transition).call);
					}
				}
			}
		}

		// loop backwards so we can splice elements off the array while in the loop.
		for (i = waitForResponders.length; --i >= 0;) {
			if (_statusByResponderID[waitForResponders[i].__navigatorjs.id] == navigatorjs.transition.TransitionStatus.SHOWN) {
				waitForResponders.splice(i, 1);
			}
		}

		if (waitForResponders.length > 0) {
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
		}

		return waitForResponders;
	};

	_flow.swapIn = function() {
		_swappingAsynchResponders.reset();

		var path,
			state,
			swapByPathList,
			responder,
			truncatedState,
			i;

		for (path in _responders.swapByPath) {
			// create a state object for comparison:
			state = new navigatorjs.NavigationState(path);

			if (_currentState.contains(state)) {
				// the lookup path is contained by the new state.
				swapByPathList = _responders.swapByPath[path];

				_initializeIfNeccessary(swapByPathList);

				// check for existing swaps.
				//for each (var responder : IHasStateSwap in swapByPathList) {
				for (i = 0; i < swapByPathList.length; i++) {
					responder = swapByPathList[i];
					truncatedState = _currentState.subtract(state);
					if (responder.willSwapToState(truncatedState, _currentState)) {
						_responders.swappedBefore[responder] = true;
						responder.swapIn(truncatedState, _currentState);
					}
				}
			}
		}

		_flow.finishTransition();
	};

	_flow.finishTransition = function() {
		_isTransitioning = false;
		_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_FINISHED);
	};
	// FLOW NAMESPACE END

	// TRANSITION NAMESPACE START
	_transition.notifyComplete = function(responder, status, behavior) {
		if (_statusByResponderID[responder.__navigatorjs.id]) {
			_statusByResponderID[responder.__navigatorjs.id] = status;
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
		}

		var asynchResponders,
			callbackMethod;

		switch (behavior) {
			case navigatorjs.NavigationBehaviors.HIDE:
				asynchResponders = _disappearingAsynchResponders;
				callbackMethod = _flow.performUpdates;
				break;
			case navigatorjs.NavigationBehaviors.SHOW:
				asynchResponders = _appearingAsynchResponders;
				callbackMethod = _flow.startSwapOut;
				break;
			case navigatorjs.NavigationBehaviors.SWAP:
				asynchResponders = _swappingAsynchResponders;
				callbackMethod = _flow.swapIn;
				break;
			default:
				throw new Error("Don't know how to handle notification of behavior " + behavior);
		}

		// If the notifyComplete is called instantly, the array of asynchronous responders is not yet assigned, and therefore not busy.
		if (asynchResponders.isBusy()) {
			asynchResponders.takeOutResponder(responder);

			// isBusy counts the number of responders, so it might have changed after takeOutResponder().
			if (!asynchResponders.isBusy()) {
				callbackMethod();
			} else {
				//logger.notice("waiting for " + asynch.length + " responders to " + behavior);
			}
		}
	};
	// TRANSITION NAMESPACE END

	// HIDDEN NAMESPACE START
	_hidden.hasResponder = function(responder) {
		if (_statusByResponderID[responder.__navigatorjs.id]) {return true;}

		var respondersByPath,
			existingResponders,
			i, j;

		for (i = 0; i < _responders.all.length; i++) {
			respondersByPath = _responders.all[i];
			for (j = 0; j < respondersByPath.length; j++) {
				existingResponders = respondersByPath[j];
				if (existingResponders.indexOf(responder) >= 0) {return true;}
			}
		}

		return false;
	};

	_hidden.getStatusByResponderID = function() {
		return _statusByResponderID;
	};

	_hidden.getRespondersByID = function() {
		return _respondersByID;
	};

	_hidden.getStatus = function(responder) {
		return _statusByResponderID[responder.__navigatorjs.id];
	};

	_hidden.getKnownPaths = function() {
		var list = {},
			path,
			knownPaths = [];

		list[_defaultState.getPath()] = true;

		for (path in _responders.showByPath) {
			list[new navigatorjs.NavigationState(path).getPath()] = true;
		}

		for (path in list) {
			knownPaths.push(path);
		}

		knownPaths.sort();
		return knownPaths;
	};
	// HIDDEN NAMESPACE END

	// VALIDATION NAMESPACE START
	_validation.notifyValidationPrepared = function(validatorResponder, truncatedState, fullState) {
		// If the takeOutResponder() method returns false, it was not in the responder list to begin with.
		// This happens if a second navigation state is requested before the async validation preparation of the first completes.
		if (_validatingAsynchResponders.takeOutResponder(validatorResponder)) {
			if (validatorResponder.validate(truncatedState, fullState)) {
				_asyncValidated = true;
			} else {
				//logger.warn("Asynchronously invalidated by " + validatorResponder);
				_asyncInvalidated = true;

				if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(validatorResponder, "IHasStateRedirection")) {
					_inlineRedirectionState = validatorResponder.redirect(truncatedState, fullState);
				}
			}

			if (_asyncInvalidated || !_validatingAsynchResponders.isBusy()) {
				_validatingAsynchResponders.reset();
				_preparedValidatingAsynchRespondersStack = [];
				_performRequestCascade(fullState, false);
			} else {
				_validateFirstValidatingAsynchResponderFromStack();
//				console.log("Waiting for " + _validatingAsynchResponders.getLength() + " validators to prepare");
			}
		} else {
			// ignore async preparations of former requests.
		}
	};
	// VALIDATION NAMESPACE END

	var _validateFirstValidatingAsynchResponderFromStack = function() {
		if(_preparedValidatingAsynchRespondersStack.length == 0) {
			return false;
		}

		var preparedResponder = _preparedValidatingAsynchRespondersStack.shift();
		preparedResponder.responder.prepareValidation(preparedResponder.remainderState, preparedResponder.unvalidatedState, preparedResponder.callOnPrepared);

		return true;
	};


	var _validate = function(stateToValidate, allowRedirection, allowAsyncValidation) {
		var allowRedirection = allowRedirection == undefined ? true : allowRedirection,
			allowAsyncValidation = allowAsyncValidation == undefined ? true : allowAsyncValidation,
			unvalidatedState = stateToValidate,
			callOnPrepared = null,
			implicit,
			invalidated = false,
			validated = false,
			path,
			state,
			remainderState,
			validateByPathList,
			i,
			responder,
			validatorResponder;

		// check to see if there are still wildcards left
		if (unvalidatedState.hasWildcard()) {
//			console.log("validate - validateState: Requested states may not contain wildcards", "return false");
			// throw new Error("validateState: Requested states may not contain wildcards " + NavigationState.WILDCARD);
			return false;
		}

		if (unvalidatedState.equals(_defaultState)) {
//			console.log("validate - unvalidatedState.equals(_defaultState)", unvalidatedState.getPath(), _defaultState.getPath() , "return false");
			return true;
		}

		if (allowAsyncValidation) {
			// This conditional is only true if we enter the validation the first (synchronous) time.
			_asyncValidationOccurred = false;
			_asyncInvalidated = false;
			_asyncValidated = false;

			// reset asynchronous validation for every new state.
			_validatingAsynchResponders = new navigatorjs.AsynchResponders();
			_preparedValidatingAsynchRespondersStack = [];
		}

		implicit = _validateImplicitly(unvalidatedState);
//		console.groupCollapsed('Responders');

		//TODO should we order the states? As mapping a validating child state before a invalidating parent state will validate the state
		for (path in _responders.validateByPath) {
//			console.log(path);
			// create a state object for comparison:
			state = new navigatorjs.NavigationState(path);

			if (unvalidatedState.contains(state)) {
				remainderState = unvalidatedState.subtract(state);

				// the lookup path is contained by the new state.
				validateByPathList = _responders.validateByPath[path];

				_initializeIfNeccessary(validateByPathList);

				if (allowAsyncValidation && _hasRegisteredResponder(stateToValidate)) {
					// check for async validators first. If this does not
					for (i = 0; i < validateByPathList.length; i++) {
						responder = validateByPathList[i];

						// check for optional validation
						if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateValidationOptionalAsync") && !responder.willValidate(remainderState, unvalidatedState)) {
							continue;
						}

						if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateValidationAsync")) {
							_asyncValidationOccurred = true;

							callOnPrepared = new navigatorjs.transition.ValidationPreparedDelegate(responder, remainderState, unvalidatedState, this, _validation).call;
							_validatingAsynchResponders.addResponder(responder);
							_preparedValidatingAsynchRespondersStack.push({responder: responder, remainderState: remainderState, unvalidatedState: unvalidatedState, callOnPrepared: callOnPrepared});

//							console.log("Preparing validation (total of " + _validatingAsynchResponders.getLength() + ")");
						}
					}
				}

				// check regular validators
				//for each (responder in list) {
				for (i = 0; i < validateByPathList.length; i++) {
					responder = validateByPathList[i];
					// skip async validators, we handled them a few lines back.
					if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateValidationAsync")) {
						continue;
					}

					// check for optional validation
					if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateValidationOptional") && !responder.willValidate(remainderState, unvalidatedState)) {
						continue;
					}

					if (responder.validate(remainderState, unvalidatedState) && _hasRegisteredResponder(unvalidatedState)) {
						validated = true;
					} else {
						//logger.warn("Invalidated by validator: " + responder);
						invalidated = true;

						if (allowRedirection && navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateRedirection")) {
							_inlineRedirectionState = responder.redirect(remainderState, unvalidatedState);
						}

//						console.log("validate - a responder was mapped to the given state, but it did not validate");
//						console.groupEnd();
						return false;
					}
				}
			}
		}

		if (_asyncValidationOccurred && _validateFirstValidatingAsynchResponderFromStack()) {
			// If there are active async validators, stop the validation chain and wait for the prepration to finish.
			// if (_validating.isBusy()) return false;
			// if (_asyncValidationOccurred && (_asyncValidated || _asyncInvalidated) {
			// async validation was instantaneous, which means that the validation was approved or denied elsewhere
			// in the stack. this method should return false any which way.
//			console.log("validate - _asyncValidationOccurred","return false");
//			console.groupEnd();
			return false;
		}

//		console.groupEnd();

		if (_validatingAsynchResponders.isBusy()) {
//			console.log("validate - _validatingAsynchResponders.isBusy", "return false");
			// the request cascade will double check the asynch validators and act accordingly.
			return false;
		}

		// invalidation overrules any validation
		if (invalidated || _asyncInvalidated) {
//			console.log("validate - invalidated || _asyncInvalidated", invalidated,  _asyncInvalidated, "return false");
			return false;
		}

		if (validated || _asyncValidated) {
//			console.log("validate - validated || _asyncValidated", validated, _asyncValidated, "return true");
			return true;
		}

		if (!implicit) {
//			console.log("validate - Validation failed. No validators or transitions matched the requested ", unvalidatedState);
			//logger.warn("Validation failed. No validators or transitions matched the requested " + unvalidatedState);
		}

//		console.log("validate - return with the implicit return value", implicit);

		return implicit;
	};

	var _validateImplicitly = function(state) {
		var path;
		for (path in _responders.showByPath) {
			if (new navigatorjs.NavigationState(path).equals(state)) {
				// info("Validation passed based on transition responder.");
				return true;
			}
		}

		return false;
	};

	var _getRespondersToShow = function() {
		var respondersToShow = _getResponderList(_responders.showByPath, _currentState),
			respondersToHide = _getResponderList(_responders.hideByPath, _currentState),
			i,
			hideResponder,
			hideIndex;

		// remove elements from the toShow list, if they are in the toHide list.
//			for each (var hide : IHasStateTransition in toHide) {
		for (i = 0; i < respondersToHide.length; i++) {
			hideResponder = respondersToHide[i];
			hideIndex = respondersToShow.indexOf(hideResponder);
			if (hideIndex >= 0) {
				respondersToShow.splice(hideIndex, 1);
			}
		}

		return respondersToShow;
	};

	var _initializeIfNeccessary = function(responderList) {
		var i, responder;
//			for each (var responder : INavigationResponder in responderList) {
		for (i = 0; i < responderList.length; i++) {
			responder = responderList[i];
			if (_statusByResponderID[responder.__navigatorjs.id] == navigatorjs.transition.TransitionStatus.UNINITIALIZED && navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateInitialization")) {
				// first initialize the responder.
				responder.initializeByNavigator();
				_statusByResponderID[responder.__navigatorjs.id] = navigatorjs.transition.TransitionStatus.INITIALIZED;
			}
		}
	};

	var _getResponderList = function(listObj, state) {
		var responders = [],
			path;

		for (path in listObj) {
			if (state.contains(new navigatorjs.NavigationState(path))) {
				responders = responders.concat(listObj[path]);
			}
		}

		return responders;
	};

	var Navigator = function() {
		navigatorjs.utils.AutoBind(this, this);

		_$eventDispatcher = $({});
		_currentState = null;
		_responders = new navigatorjs.ResponderLists();
		_respondersByID = {};
		_statusByResponderID = {};
		_redirects = null;
		_responderIDCount = 0;
	};


	//PUBLIC API
	Navigator.prototype = {
		add: function(responder, pathsOrStates, behaviorString) {
			_modify(true, responder, pathsOrStates, behaviorString);
		},

		remove: function(responder, pathsOrStates, behaviorString) {
			_modify(false, responder, pathsOrStates, behaviorString);
		},

		registerRedirect: function(fromStateOrPath, toStateOrPath) {
			_redirects = _redirects || {};
			_redirects[navigatorjs.NavigationState.make(fromStateOrPath).getPath()] = navigatorjs.NavigationState.make(toStateOrPath);
		},

		start: function(defaultStateOrPath, startStateOrPath) {
			_defaultState = navigatorjs.NavigationState.make(defaultStateOrPath || "");

			this.request(startStateOrPath || _defaultState);
		},

		request: function(pathOrState) {
			_request(pathOrState);
		},

		getCurrentState: function() {
			if (!_currentState) {
				if (_defaultState) {
					return _defaultState.clone();
				}

				return null;
			}

			return _currentState.clone();
		},

		isTransitioning: function() {
			return _isTransitioning;
		},

		on: function(event, handler) {
			_$eventDispatcher.on(event, handler);
			return this;
		},

		off: function(event, handler) {
			_$eventDispatcher.off(event, handler);
			return this;
		},

		logResponders: function() {
//			console.log(_responders.toString());
		}
	};

	navigatorjs.Navigator = Navigator;
}());;this.navigatorjs = this.navigatorjs || {};

this.navigatorjs.NavigatorEvent = {};
this.navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED = "TRANSITION_STATUS_UPDATED";
this.navigatorjs.NavigatorEvent.STATE_REQUESTED = "STATE_REQUESTED";
this.navigatorjs.NavigatorEvent.STATE_CHANGED = "STATE_CHANGED";
this.navigatorjs.NavigatorEvent.TRANSITION_STARTED = "TRANSITION_STARTED";
this.navigatorjs.NavigatorEvent.TRANSITION_FINISHED = "TRANSITION_FINISHED";;this.navigatorjs = this.navigatorjs || {};

(function() {
	var ResponderLists = function() {
		this.validateByPath = {};
		this.updateByPath = {};
		this.swapByPath = {};
		this.showByPath = {};
		this.hideByPath = {};
		this.swappedBefore = {};

		this.all = [this.validateByPath,
		            this.updateByPath,
		            this.swapByPath,
		            this.showByPath,
		            this.hideByPath,
		            this.swappedBefore];
	};

	//PUBLIC API
	ResponderLists.prototype = {
		validateByPath: null, //[]
		updateByPath: null, //[]
		swapByPath: null, //[]
		showByPath: null, //[]
		hideByPath: null, //[]
		swappedBefore: null, //[]
		all: null, //[]

		toString: function() {
			var s = "ResponderLists [",
				variable,
				list, contents, key;

			for (variable in this) {
				list = this[variable];

				if (this.all.indexOf(list) > -1) {
					contents = [];
					for (key in list) {
						contents.push("[" + key + " = " + list[key] + "]");
					}
					s += "\n\t[" + variable + ": " + contents.join(", ") + "], ";
				}
			}

			s += "]";
			return s;
		}
	};

	navigatorjs.ResponderLists = ResponderLists;
}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.features = this.navigatorjs.features || {};

(function() {

	var _navigator = null,
		_template = '<div class="debugConsole">Path: <input type="text" class="path" /><div class="pathRenderer"></div><div class="responders"><div class="names"></div><div class="status"></div></div></div>',
		_visible = true,
		_inputRegex = new RegExp("[-_/A-Za-z0-9]"),
		_$el = null,
		_$pathInput = null,
		_$pathRenderer = null,
		_$responders = null,
		_$responderNames = null,
		_$responderStatus = null,
		_respondersByID = null,
		_statusByResponderID = null;

	//Input keydown validation and requesting the entered path
	var _onKeyPress = function(e) {
		switch (e.which) {
			case 13: //Return
				e.preventDefault(); //Prevent char from writing in textfield
				_navigator.request(_$pathInput.val());
				return;
				break;
			case 8: //Backspace
			case 0: //Others such as arrows
				return; //This can just be executed
				break;
		}

		var char = String.fromCharCode(e.which);
		if (!_inputRegex.test(char)) {
			e.preventDefault(); //Prevent char from writing in textfield
		}

		_autoSizeInput();
	};

	//Toggle showing debug console
	var _onWindowKeyPress = function(e) {
		switch (String.fromCharCode(e.which)) {
			case "~":
			case "$":
			case "`":
				_visible = !_visible;
				_$el.css({display: _visible ? '' : 'none'});
				break;
		}
	};

	var _onResponderClick = function(e) {
		var responderID = $(e.target).data("responder-id");

		console.log('Responder', _respondersByID[responderID]);
	};

	var _autoSizeInput = function() {
		_$pathRenderer.text(_$pathInput.val());
		_$pathInput.css({width: _$pathRenderer.width()});
	};

	var _handleStatusUpdated = function(e, data) {
		_respondersByID = data.respondersByID;
		_statusByResponderID = data.statusByResponderID;
		_updateDisplay();
	};

	var _updateDisplay = function() {
		var currentState = _navigator.getCurrentState(),
			responderID, responder, status, color, responderNamesHTMLString = "", responderStatusHTMLString = "";
		if (!currentState) {
			return;
		}

		_$pathInput.val(currentState.getPath());
		_autoSizeInput();

		for (responderID in _respondersByID) {
			responder = _respondersByID[responderID];
			status = _statusByResponderID[responderID];

			if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateTransition") || navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateInitialization")) {
				responderNamesHTMLString += '<span data-responder-id="' + responderID + '">' + _getResponderString(responder) + '</span><br />';
				color = _getColorByStatus(status);
				responderStatusHTMLString += '<span style=" color:' + color + '; font-weight:bold;" data-responder-id="' + responderID + '">' + navigatorjs.transition.TransitionStatus.toString(status) + '</span><br />';
			}
		}

		_$responderNames.html(responderNamesHTMLString);
		_$responderStatus.html(responderStatusHTMLString);
	};

	var _getResponderString = function(responder) {
		var responderString = responder.toString();

		if(responderString == "[object Object]" && responder.$el) {
			var tagName = responder.$el.prop("tagName").toLowerCase(),
				classes = responder.$el.attr("class").split(" ").join(".");

			responderString = tagName+"."+classes;
		}

		return responderString;
	};

	var _getColorByStatus = function(status) {
		var color = "";
		switch (status) {
			case navigatorjs.transition.TransitionStatus.UNINITIALIZED:
				color = "#AAAAAA";
				break;
			case navigatorjs.transition.TransitionStatus.INITIALIZED:
				color = "#FFFFFF";
				break;
			case navigatorjs.transition.TransitionStatus.HIDDEN:
				color = "#FF0000";
				break;
			case navigatorjs.transition.TransitionStatus.APPEARING:
			case navigatorjs.transition.TransitionStatus.DISAPPEARING:
				color = "#FFFF00";
				break;
			case navigatorjs.transition.TransitionStatus.SHOWN:
				color = "#00FF00";
				break;
		}

		return color;
	};

	var DebugConsole = function(navigator) {
		_navigator = navigator;

		_$el = $(_template);
		_$pathInput = _$el.find(".path");
		_$pathRenderer = _$el.find(".pathRenderer");
		_$responders = _$el.find(".responders");
		_$responderNames = _$responders.find(".names");
		_$responderStatus = _$responders.find(".status");

		//STYLING
		_$el.css({
			backgroundColor: '#000000',
			color: '#AAAAAA',
			fontFamily: 'Arial',
			fontSize: 12,
			padding: 5
		});

		_$pathInput.css({
			color: '#00FF00',
			backgroundColor: 'transparent',
			fontFamily: 'Arial',
			fontSize: 12,
			minWidth: 200,
			border: 0
		});

		_$pathRenderer.attr('style',_$pathInput.attr('style'));
		_$pathRenderer.css({
			position: 'absolute',
			height:0,
			overflowY:'hidden'
		});

		_$responderNames.css({
			display: 'inline-block',
			color: '#FF9900',
			marginRight: 15
		});

		_$responderStatus.css({
			display: 'inline-block'
		});

		_$pathInput.on('keypress', _onKeyPress);
		$(window).on('keypress', _onWindowKeyPress);

		_$responderNames.on('click', _onResponderClick);
		_$responderStatus.on('click', _onResponderClick);

		_navigator.on(navigatorjs.NavigatorEvent.STATE_CHANGED, _handleStatusUpdated);
		_navigator.on(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, _handleStatusUpdated);
	};

	//PUBLIC API
	DebugConsole.prototype = {
		get$El: function() {return _$el;}
	};

	navigatorjs.features.DebugConsole = DebugConsole;
}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.integration = this.navigatorjs.integration || {};

(function() {
	var StateCommandMap = function(navigator, injector) {
		this._navigator = navigator;
		this._injector = injector;
		this._commandsByState = {};
		this._verifiedCommandClasses = {};

		//this._navigator.add(this, "");

		this.initialize();
	};

	StateCommandMap.prototype = {
		navigatorBehaviors: ["IHasStateValidationOptional", "IHasStateUpdate"],

		_navigator: null,
		_injector: null,
		_commandsByState: null, //{}
		_verifiedCommandClasses: null, //{}

		initialize: function() {
		},

		mapCommand: function(stateOrPath, CommandClass, aExactMatch, aOneShot) {
			var exactMatch = aExactMatch == undefined ? false : aExactMatch,
				oneShot = aOneShot == undefined ? false : aOneShot,
				state = navigatorjs.NavigationState.make(stateOrPath),
				commands = this._commandsByState[state.getPath()] || [];

			this._commandsByState[state.getPath()] = commands;
			this._navigator.add(this, state);

			if (this._hasCommand(commands, CommandClass)) {
				throw new Error("Already mapped " + CommandClass + " to state " + state.getPath());
				return;
			}

			this._verifyCommandClass(CommandClass);

			commands.push({CommandClass: CommandClass, state: state, exactMatch: exactMatch, oneShot: oneShot});
		},

		unmapCommand: function(stateOrPath, CommandClass) {
			var state = navigatorjs.NavigationState.make(stateOrPath),
				commands = this._commandsByState[state.getPath()] || [],
				i, wrapper;
			this._commandsByState[state.getPath()] = commands;
			this._navigator.remove(this, state);
			for (i = commands.length; --i >= 0;) {
				wrapper = commands[i];
				if (wrapper.CommandClass == CommandClass) {
					commands.splice(i, 1);
					return;
				}
			}
		},

		willValidate: function(truncatedState, fullState) {
			// will only validate if the state matches a command.
			return this.validate(truncatedState, fullState);
		},

		validate: function(truncatedState, fullState) {
			var path, mappedState, commands, isExact, i, wrapper;

			for (path in this._commandsByState) {
				mappedState = navigatorjs.NavigationState.make(path);

				if (fullState.contains(mappedState)) {
					commands = this._commandsByState[path];
					isExact = fullState.equals(mappedState);

					// reverse loop to accomodate for oneshot removal
					i = commands.length;
					for (i; --i >= 0;) {
						wrapper = commands[i];
						if (!isExact && wrapper.exactMatch) {
							continue;
						}
						return true;
					}
				}
			}

			return false;
		},

		updateState: function(truncatedState, fullState) {
			var path, mappedState, commands, isExact, i, wrapper, command;

			for (path in this._commandsByState) {
				mappedState = navigatorjs.NavigationState.make(path);
				if (fullState.contains(mappedState)) {
					commands = this._commandsByState[path];
					isExact = fullState.equals(mappedState);

					// reverse loop to accomodate for oneshot removal
					i = commands.length;
					for (i; --i >= 0;) {
						wrapper = commands[i];
						if (!isExact && wrapper.exactMatch) {
							continue;
						}

						this._injector.map('fullState').toValue(fullState);
						this._injector.map('truncatedState').toValue(fullState.subtract(wrapper.state));

						command = new wrapper.CommandClass({injector:this._injector});
						command.execute();

						this._injector.unmap('fullState');
						this._injector.unmap('truncatedState');

						if (wrapper.oneShot) {
							this.unmapCommand(wrapper.state, wrapper.CommandClass);
						}
					}
				}
			}
		},

		_hasCommand: function(wrappedCommandsList, testForCommandClass) {
			var i, commandWrapper, length = wrappedCommandsList.length;
			for (i = 0; i < length; i++) {
				commandWrapper = wrappedCommandsList[i];
				if (commandWrapper.CommandClass == testForCommandClass) {
					return true;
				}
			}
			return false;
		},

		_verifyCommandClass: function(CommandClass) {
			if (this._verifiedCommandClasses[CommandClass]) {
				return;
			}
			if (CommandClass.prototype["execute"]===undefined) {
				throw new Error("Command doesn't implement an execute method - " + CommandClass);
			}
			this._verifiedCommandClasses[CommandClass] = true;
		}
	};

	navigatorjs.integration.StateCommandMap = StateCommandMap;

}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.integration = this.navigatorjs.integration || {};

(function() {
	var _usingPushState,
		_rootUrl,
		_navigator,
		_started;

	var StateUrlSyncer = function(navigator) {
		navigatorjs.utils.AutoBind(this, this);

		_usingPushState = false;
		_rootUrl = '/';
		_navigator = navigator;
		_started = false;
	};

	StateUrlSyncer.prototype = {
		supportsPushState: !!(window && window.history && window.history.pushState),

		usePushState: function(rootUrl) {
			if(_started) {
				throw new Error("Cannot switch to using push states after start was called");
				return;
			}

			_usingPushState = this.supportsPushState;
			_rootUrl = rootUrl || _rootUrl;

			this._redirectPushStateOrHashOnDeeplink();
		},

		isUsingPushState: function() {
			return _usingPushState;
		},

		_redirectPushStateOrHashOnDeeplink: function() {
			var pushUrl = this.parsePushStateUrl(window.location.pathname),
				hashUrl = this.parseHashUrl(window.location.hash);

			if(this.supportsPushState && pushUrl=="" && hashUrl!="") {
				//There is a hash and no push state.
				window.history.replaceState(null, '', new navigatorjs.NavigationState(_rootUrl + hashUrl).getPath());
			} else if(!this.supportsPushState && pushUrl!="") {
				//There is a push state deeplink, but we don't support it. Redirect back.
				window.location.href = _rootUrl + "#/" + pushUrl;
			}
		},

		start: function() {
			if(_started) {
				throw new Error("Already started");
				return;
			}

			_started = true;
			this._addListeners();
		},

		_addListeners: function() {
			if (_usingPushState) {
				$(window).on('popstate', this._onUrlChange);
			} else {
				$(window).on('hashchange', this._onUrlChange);
			}

			var STATE_CHANGED = navigatorjs.NavigatorEvent.STATE_CHANGED;

			_navigator.on(STATE_CHANGED, this._onStateChanged);
		},

		_removeListeners: function() {
			$(window).off('popstate', this._onUrlChange);
			$(window).off('hashchange', this._onUrlChange);
		},

		setUrl: function(url) {
			var newState,
				urlState = this.getUrlState();
			if (_usingPushState) {
				newState = new navigatorjs.NavigationState(_rootUrl + url);
				if(newState.equals(urlState)) {
					window.history.replaceState(null, '', newState.getPath());
				} else {
					window.history.pushState(null, '', newState.getPath());
				}
			} else {
				newState = new navigatorjs.NavigationState(url);
				if(!newState.equals(urlState)) {
					window.location.hash = newState.getPath();
				}
			}
		},

		getRawUrl: function() {
			if (_usingPushState) {
				return this.parsePushStateUrl(window.location.pathname);
			} else {
				return this.parseHashUrl(window.location.hash);
			}
		},

		getUrlState: function() {
			return new navigatorjs.NavigationState(this.getRawUrl());
		},

		_onStateChanged: function() {
			this.setUrl(_navigator.getCurrentState().getPath());
		},

		_onUrlChange: function() {
			_navigator.request(this.getUrlState());
		},

		resetUrl: function() {
			this.setUrl('');
		},

		parseHashUrl: function(hashUrl) {
			return hashUrl.replace(/^#|$/g, '');
		},

		parsePushStateUrl: function(pushStateUrl) {
			return pushStateUrl.replace(_rootUrl, '');
		},

		dispose: function() {
			this._removeListeners();
		}

	};

	navigatorjs.integration.StateUrlSyncer = StateUrlSyncer;

})();;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.integration = this.navigatorjs.integration || {};

(function() {
	var _navigator = null;
	var _orderedRecipes = null;
	var _$root = null;


	var StateViewMap = function(navigator, $root) {
		_navigator = navigator;
		_orderedRecipes = [];
		_$root = $root || $('body');

		_navigator.on(navigatorjs.NavigatorEvent.STATE_REQUESTED, _handleStateRequested);
	};

	function _addRecipe(statesOrPaths) {
		var recipe = new navigatorjs.integration.ViewRecipe();

		var i, length = statesOrPaths.length;
		for (i = 0; i < length; i++) {
			recipe.addState(navigatorjs.NavigationState.make(statesOrPaths[i]));
		}

		_orderedRecipes.push(recipe);

		return recipe;
	}

	function _handleStateRequested(e, eventData) {
		var requestedState = eventData.state,
			index, recipe, recipeStates, recipesLength = _orderedRecipes.length,
			j, state, statesLength,
			viewInstance;

		for (index = 0; index < recipesLength; index++) {
			recipe = _orderedRecipes[index];
			recipeStates = recipe.getStates();
			statesLength = recipeStates.length;

			for (j = 0; j < statesLength; j++) {
				state = recipeStates[j];

				if (requestedState.contains(state)) {
					viewInstance = recipe.getViewInstance();

					if (viewInstance.navigatorBehaviors instanceof Array) {
						_addViewElementToDOM(recipe);
						_navigator.add(viewInstance, state);
					}
				}
			}
		}
	}

	function _addViewElementToDOM(recipe) {
		if (recipe.isInstantiated() && $.contains(document.documentElement, recipe.getViewInstance().$el)) {
			return;
		}

		var parentRecipe = recipe.getParentRecipe(),
			$container = _$root,
			$inside,
			insideSelector = recipe.getInsideSelector();

		if (parentRecipe) {
			if (!parentRecipe.isInstantiated()) {
				_addViewElementToDOM(parentRecipe);
			}

			$container = parentRecipe.getViewInstance().$el;
		}

		if (insideSelector != null) {
			$inside = $container.find(insideSelector);
			$container = $inside.length > 0 ? $inside.first() : $container;
		}

		var i = _orderedRecipes.indexOf(recipe) + 1,
			length = _orderedRecipes.length,
			testRecipe;
		for (i; i < length; i++) {
			testRecipe = _orderedRecipes[i];

			if (testRecipe.isInstantiated() && testRecipe.getViewInstance().$el.parent()[0] == $container[0]) {
				testRecipe.getViewInstance().$el.before(recipe.getViewInstance().$el);
				return;
			}
		}

		// otherwise add on top
		$container.append(recipe.getViewInstance().$el);
	}

	//PUBLIC API
	StateViewMap.prototype = {
		mapState: function(statesOrPaths) {
			var allArgumentsAsOneFlatArray = [];
			allArgumentsAsOneFlatArray = allArgumentsAsOneFlatArray.concat.apply(allArgumentsAsOneFlatArray, arguments);
			return _addRecipe(allArgumentsAsOneFlatArray);
		},

		get$Root: function() {
			return _$root;
		}
	};

	navigatorjs.integration.StateViewMap = StateViewMap;

}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.integration = this.navigatorjs.integration || {};

(function() {

	var ViewRecipe = function() {
		this._states = [];
		this._viewClass = null;
		this._viewArguments = [];
		this._viewInstance = null;
		this._insideSelector = null;
		this._parentRecipe = null;
	};

	//PUBLIC API
	ViewRecipe.prototype = {

		addState: function(navigationState) {
			var i, existingState, length = this._states.length;

			for (i = 0; i < length; i++) {
				existingState = this._states[i];

				if (existingState.getPath() == navigationState.getPath()) {
					return;
				}
			}

			this._states.push(navigationState);

			return this;
		},

		getStates: function() {
			return this._states;
		},

		toView: function(viewClass) {
			this._viewClass = viewClass;

			return this;
		},

		getViewClass: function() {
			return this._viewClass;
		},

		getViewInstance: function() {
			if (!this.isInstantiated()) {

				var params = this._viewArguments;
				switch (params.length) {
					default:
					case 0:
						this._viewInstance = new this._viewClass();
						break;
					case 1:
						this._viewInstance = new this._viewClass(params[0]);
						break;
					case 2:
						this._viewInstance = new this._viewClass(params[0], params[1]);
						break;
					case 3:
						this._viewInstance = new this._viewClass(params[0], params[1], params[2]);
						break;
					case 4:
						this._viewInstance = new this._viewClass(params[0], params[1], params[2], params[3]);
						break;
					case 5:
						this._viewInstance = new this._viewClass(params[0], params[1], params[2], params[3], params[4]);
						break;
				}

			}
			return this._viewInstance;
		},

		isInstantiated: function() {
			return this._viewInstance != null;
		},

		withArguments: function() {
			if (arguments.length > 5) {
				throw new Error("Uncle Bob says you want to use too many arguments");
			}
			this._viewArguments = arguments;

			return this;
		},

		inside: function(selector) {
			this._insideSelector = selector;

			return this;
		},

		getInsideSelector: function() {
			return this._insideSelector;
		},

		withParent: function(parentRecipe) {
			this._parentRecipe = parentRecipe;
			return this;
		},

		getParentRecipe: function() {
			return this._parentRecipe;
		}
	};

	navigatorjs.integration.ViewRecipe = ViewRecipe;

}());;if (!Array.prototype.indexOf) {
	Array.prototype.indexOf = function (elt /*, from*/) {
		var len = this.length;
		var from = Number(arguments[1]) || 0;
		from = (from < 0) ? Math.ceil(from) : Math.floor(from);
		if (from < 0) from += len;
		for (; from < len; from++) {
			if (from in this && this[from] === elt) {
				return from;
			}
		}
		return -1;
	};
};this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.transition = this.navigatorjs.transition || {};

(function() {
	var TransitionCompleteDelegate = function(responder, status, behavior, navigator, transitionNamespace) {
		this._responder = responder;
		this._status = status;
		this._behavior = behavior;
		this._navigator = navigator;
		this._transitionNamespace = transitionNamespace;
		this._called = false;
		navigatorjs.utils.AutoBind(this, this);
	};

	//PUBLIC API
	TransitionCompleteDelegate.prototype = {
		call: function() {
			//console.log('TransitionCompleteDelegate -> call', this);
			if (this._called) { throw new Error("Illegal second call to transition complete. This instance is already prepared for garbage collection!"); }

			this._called = true;
			this._transitionNamespace.notifyComplete(this._responder, this._status, this._behavior);
			this._responder = null;
			this._navigator = null;
			this._transitionNamespace = null;
		}
	};

	navigatorjs.transition.TransitionCompleteDelegate = TransitionCompleteDelegate;
}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.transition = this.navigatorjs.transition || {};

this.navigatorjs.transition.TransitionStatus = {};
this.navigatorjs.transition.TransitionStatus.UNINITIALIZED = -2;
this.navigatorjs.transition.TransitionStatus.INITIALIZED = -1;
this.navigatorjs.transition.TransitionStatus.HIDDEN = 1;
this.navigatorjs.transition.TransitionStatus.APPEARING = 2;
this.navigatorjs.transition.TransitionStatus.SHOWN = 3;
this.navigatorjs.transition.TransitionStatus.SWAPPING = 4;
this.navigatorjs.transition.TransitionStatus.DISAPPEARING = 5;

this.navigatorjs.transition.TransitionStatus.toString = function(status) {
	switch (status) {
		case navigatorjs.transition.TransitionStatus.UNINITIALIZED:
			return "UNINITIALIZED";
		case navigatorjs.transition.TransitionStatus.INITIALIZED:
			return "INITIALIZED";
		case navigatorjs.transition.TransitionStatus.HIDDEN:
			return "HIDDEN";
		case navigatorjs.transition.TransitionStatus.APPEARING:
			return "APPEARING";
		case navigatorjs.transition.TransitionStatus.SHOWN:
			return "SHOWN";
		case navigatorjs.transition.TransitionStatus.SWAPPING:
			return "SWAPPING";
		case navigatorjs.transition.TransitionStatus.DISAPPEARING:
			return "DISAPPEARING";
	}

	return "UNKNOWN";
};;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.transition = this.navigatorjs.transition || {};

(function() {
	var ValidationPreparedDelegate = function(validatorResponder, truncatedState, fullState, navigator, validationNamespace) {
		this._validatorResponder = validatorResponder;
		this._truncatedState = truncatedState;
		this._fullState = fullState;
		this._navigator = navigator;
		this._validationNamespace = validationNamespace;
		navigatorjs.utils.AutoBind(this, this);
	};

	//PUBLIC API
	ValidationPreparedDelegate.prototype = {
		call: function() {
			this._validationNamespace.notifyValidationPrepared(this._validatorResponder, this._truncatedState, this._fullState);
			this._validatorResponder = null;
			this._truncatedState = null;
			this._fullState = null;
			this._navigator = null;
			this._validationNamespace = null;
		}
	};

	navigatorjs.transition.ValidationPreparedDelegate = ValidationPreparedDelegate;
}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.utils = this.navigatorjs.utils || {};

this.navigatorjs.utils.AutoBind = function(object, context) {
	var key, method;
	for (key in object) {
		method = object[key];
		if (typeof method === 'function') {
			object[key] = $.proxy(object[key], context);
		}
	}
};;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.utils = this.navigatorjs.utils || {};

this.navigatorjs.utils.Bind = function(functionOrArray, context) {
	var bind = function (method, context) {
		if (typeof method === 'function') {
			$.proxy(method, context);
		}
	}

	if (typeof functionOrArray === 'array') {
		var i, length = functionOrArray.length;
		for (i = 0; i < length; i++) {
			bind(functionOrArray[i], context);
		}

	} else {
		bind(functionOrArray, context);
	}

};