solr/src/main/resources/statistics/conf/velocity/jquery.autocomplete.js - drat - Git at Google

 /*
  * Autocomplete - jQuery plugin 1.1pre
  *
  * Copyright (c) 2007 Dylan Verheul, Dan G. Switzer, Anjesh Tuladhar, Jörn Zaefferer
  *
  * Dual licensed under the MIT and GPL licenses:
  *   http://www.opensource.org/licenses/mit-license.php
  *   http://www.gnu.org/licenses/gpl.html
  *
  * Revision: $Id: jquery.autocomplete.js 5785 2008-07-12 10:37:33Z joern.zaefferer $
  *
  */

 ;(function($) {

 $.fn.extend({
 	autocomplete: function(urlOrData, options) {
 		var isUrl = typeof urlOrData == "string";
 		options = $.extend({}, $.Autocompleter.defaults, {
 			url: isUrl ? urlOrData : null,
 			data: isUrl ? null : urlOrData,
 			delay: isUrl ? $.Autocompleter.defaults.delay : 10,
 			max: options && !options.scroll ? 10 : 150
 		}, options);

 		// if highlight is set to false, replace it with a do-nothing function
 		options.highlight = options.highlight || function(value) { return value; };

 		// if the formatMatch option is not specified, then use formatItem for backwards compatibility
 		options.formatMatch = options.formatMatch || options.formatItem;

 		return this.each(function() {
 			new $.Autocompleter(this, options);
 		});
 	},
 	result: function(handler) {
 		return this.bind("result", handler);
 	},
 	search: function(handler) {
 		return this.trigger("search", [handler]);
 	},
 	flushCache: function() {
 		return this.trigger("flushCache");
 	},
 	setOptions: function(options){
 		return this.trigger("setOptions", [options]);
 	},
 	unautocomplete: function() {
 		return this.trigger("unautocomplete");
 	}
 });

 $.Autocompleter = function(input, options) {

 	var KEY = {
 		UP: 38,
 		DOWN: 40,
 		DEL: 46,
 		TAB: 9,
 		RETURN: 13,
 		ESC: 27,
 		COMMA: 188,
 		PAGEUP: 33,
 		PAGEDOWN: 34,
 		BACKSPACE: 8
 	};

 	// Create $ object for input element
 	var $input = $(input).attr("autocomplete", "off").addClass(options.inputClass);

 	var timeout;
 	var previousValue = "";
 	var cache = $.Autocompleter.Cache(options);
 	var hasFocus = 0;
 	var lastKeyPressCode;
 	var config = {
 		mouseDownOnSelect: false
 	};
 	var select = $.Autocompleter.Select(options, input, selectCurrent, config);

 	var blockSubmit;

 	// prevent form submit in opera when selecting with return key
 	$.browser.opera && $(input.form).bind("submit.autocomplete", function() {
 		if (blockSubmit) {
 			blockSubmit = false;
 			return false;
 		}
 	});

 	// only opera doesn't trigger keydown multiple times while pressed, others don't work with keypress at all
 	$input.bind(($.browser.opera ? "keypress" : "keydown") + ".autocomplete", function(event) {
 		// track last key pressed
 		lastKeyPressCode = event.keyCode;
 		switch(event.keyCode) {

 			case KEY.UP:
 				event.preventDefault();
 				if ( select.visible() ) {
 					select.prev();
 				} else {
 					onChange(0, true);
 				}
 				break;

 			case KEY.DOWN:
 				event.preventDefault();
 				if ( select.visible() ) {
 					select.next();
 				} else {
 					onChange(0, true);
 				}
 				break;

 			case KEY.PAGEUP:
 				event.preventDefault();
 				if ( select.visible() ) {
 					select.pageUp();
 				} else {
 					onChange(0, true);
 				}
 				break;

 			case KEY.PAGEDOWN:
 				event.preventDefault();
 				if ( select.visible() ) {
 					select.pageDown();
 				} else {
 					onChange(0, true);
 				}
 				break;

 			// matches also semicolon
 			case options.multiple && $.trim(options.multipleSeparator) == "," && KEY.COMMA:
 			case KEY.TAB:
 			case KEY.RETURN:
 				if( selectCurrent() ) {
 					// stop default to prevent a form submit, Opera needs special handling
 					event.preventDefault();
 					blockSubmit = true;
 					return false;
 				}
 				break;

 			case KEY.ESC:
 				select.hide();
 				break;

 			default:
 				clearTimeout(timeout);
 				timeout = setTimeout(onChange, options.delay);
 				break;
 		}
 	}).focus(function(){
 		// track whether the field has focus, we shouldn't process any
 		// results if the field no longer has focus
 		hasFocus++;
 	}).blur(function() {
 		hasFocus = 0;
 		if (!config.mouseDownOnSelect) {
 			hideResults();
 		}
 	}).click(function() {
 		// show select when clicking in a focused field
 		if ( hasFocus++ > 1 && !select.visible() ) {
 			onChange(0, true);
 		}
 	}).bind("search", function() {
 		// TODO why not just specifying both arguments?
 		var fn = (arguments.length > 1) ? arguments[1] : null;
 		function findValueCallback(q, data) {
 			var result;
 			if( data && data.length ) {
 				for (var i=0; i < data.length; i++) {
 					if( data[i].result.toLowerCase() == q.toLowerCase() ) {
 						result = data[i];
 						break;
 					}
 				}
 			}
 			if( typeof fn == "function" ) fn(result);
 			else $input.trigger("result", result && [result.data, result.value]);
 		}
 		$.each(trimWords($input.val()), function(i, value) {
 			request(value, findValueCallback, findValueCallback);
 		});
 	}).bind("flushCache", function() {
 		cache.flush();
 	}).bind("setOptions", function() {
 		$.extend(options, arguments[1]);
 		// if we've updated the data, repopulate
 		if ( "data" in arguments[1] )
 			cache.populate();
 	}).bind("unautocomplete", function() {
 		select.unbind();
 		$input.unbind();
 		$(input.form).unbind(".autocomplete");
 	});


 	function selectCurrent() {
 		var selected = select.selected();
 		if( !selected )
 			return false;

 		var v = selected.result;
 		previousValue = v;

 		if ( options.multiple ) {
 			var words = trimWords($input.val());
 			if ( words.length > 1 ) {
 				v = words.slice(0, words.length - 1).join( options.multipleSeparator ) + options.multipleSeparator + v;
 			}
 			v += options.multipleSeparator;
 		}

 		$input.val(v);
 		hideResultsNow();
 		$input.trigger("result", [selected.data, selected.value]);
 		return true;
 	}

 	function onChange(crap, skipPrevCheck) {
 		if( lastKeyPressCode == KEY.DEL ) {
 			select.hide();
 			return;
 		}

 		var currentValue = $input.val();

 		if ( !skipPrevCheck && currentValue == previousValue )
 			return;

 		previousValue = currentValue;

 		currentValue = lastWord(currentValue);
 		if ( currentValue.length >= options.minChars) {
 			$input.addClass(options.loadingClass);
 			if (!options.matchCase)
 				currentValue = currentValue.toLowerCase();
 			request(currentValue, receiveData, hideResultsNow);
 		} else {
 			stopLoading();
 			select.hide();
 		}
 	};

 	function trimWords(value) {
 		if ( !value ) {
 			return [""];
 		}
 		var words = value.split( options.multipleSeparator );
 		var result = [];
 		$.each(words, function(i, value) {
 			if ( $.trim(value) )
 				result[i] = $.trim(value);
 		});
 		return result;
 	}

 	function lastWord(value) {
 		if ( !options.multiple )
 			return value;
 		var words = trimWords(value);
 		return words[words.length - 1];
 	}

 	// fills in the input box w/the first match (assumed to be the best match)
 	// q: the term entered
 	// sValue: the first matching result
 	function autoFill(q, sValue){
 		// autofill in the complete box w/the first match as long as the user hasn't entered in more data
 		// if the last user key pressed was backspace, don't autofill
 		if( options.autoFill && (lastWord($input.val()).toLowerCase() == q.toLowerCase()) && lastKeyPressCode != KEY.BACKSPACE ) {
 			// fill in the value (keep the case the user has typed)
 			$input.val($input.val() + sValue.substring(lastWord(previousValue).length));
 			// select the portion of the value not typed by the user (so the next character will erase)
 			$.Autocompleter.Selection(input, previousValue.length, previousValue.length + sValue.length);
 		}
 	};

 	function hideResults() {
 		clearTimeout(timeout);
 		timeout = setTimeout(hideResultsNow, 200);
 	};

 	function hideResultsNow() {
 		var wasVisible = select.visible();
 		select.hide();
 		clearTimeout(timeout);
 		stopLoading();
 		if (options.mustMatch) {
 			// call search and run callback
 			$input.search(
 				function (result){
 					// if no value found, clear the input box
 					if( !result ) {
 						if (options.multiple) {
 							var words = trimWords($input.val()).slice(0, -1);
 							$input.val( words.join(options.multipleSeparator) + (words.length ? options.multipleSeparator : "") );
 						}
 						else
 							$input.val( "" );
 					}
 				}
 			);
 		}
 		if (wasVisible)
 			// position cursor at end of input field
 			$.Autocompleter.Selection(input, input.value.length, input.value.length);
 	};

 	function receiveData(q, data) {
 		if ( data && data.length && hasFocus ) {
 			stopLoading();
 			select.display(data, q);
 			autoFill(q, data[0].value);
 			select.show();
 		} else {
 			hideResultsNow();
 		}
 	};

 	function request(term, success, failure) {
 		if (!options.matchCase)
 			term = term.toLowerCase();
 		var data = cache.load(term);
 		// recieve the cached data
 		if (data && data.length) {
 			success(term, data);
 		// if an AJAX url has been supplied, try loading the data now
 		} else if( (typeof options.url == "string") && (options.url.length > 0) ){

 			var extraParams = {
 				timestamp: +new Date()
 			};
 			$.each(options.extraParams, function(key, param) {
 				extraParams[key] = typeof param == "function" ? param() : param;
 			});

 			$.ajax({
 				// try to leverage ajaxQueue plugin to abort previous requests
 				mode: "abort",
 				// limit abortion to this input
 				port: "autocomplete" + input.name,
 				dataType: options.dataType,
 				url: options.url,
 				data: $.extend({
 					q: lastWord(term),
 					limit: options.max
 				}, extraParams),
 				success: function(data) {
 					var parsed = options.parse && options.parse(data) || parse(data);
 					cache.add(term, parsed);
 					success(term, parsed);
 				}
 			});
 		} else {
 			// if we have a failure, we need to empty the list -- this prevents the the [TAB] key from selecting the last successful match
 			select.emptyList();
 			failure(term);
 		}
 	};

 	function parse(data) {
 		var parsed = [];
 		var rows = data.split("\n");
 		for (var i=0; i < rows.length; i++) {
 			var row = $.trim(rows[i]);
 			if (row) {
 				row = row.split("|");
 				parsed[parsed.length] = {
 					data: row,
 					value: row[0],
 					result: options.formatResult && options.formatResult(row, row[0]) || row[0]
 				};
 			}
 		}
 		return parsed;
 	};

 	function stopLoading() {
 		$input.removeClass(options.loadingClass);
 	};

 };

 $.Autocompleter.defaults = {
 	inputClass: "ac_input",
 	resultsClass: "ac_results",
 	loadingClass: "ac_loading",
 	minChars: 1,
 	delay: 400,
 	matchCase: false,
 	matchSubset: true,
 	matchContains: false,
 	cacheLength: 10,
 	max: 100,
 	mustMatch: false,
 	extraParams: {},
 	selectFirst: true,
 	formatItem: function(row) { return row[0]; },
 	formatMatch: null,
 	autoFill: false,
 	width: 0,
 	multiple: false,
 	multipleSeparator: ", ",
 	highlight: function(value, term) {
 		return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + term.replace(/([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");
 	},
     scroll: true,
     scrollHeight: 180
 };

 $.Autocompleter.Cache = function(options) {

 	var data = {};
 	var length = 0;

 	function matchSubset(s, sub) {
 		if (!options.matchCase)
 			s = s.toLowerCase();
 		var i = s.indexOf(sub);
 		if (options.matchContains == "word"){
 			i = s.toLowerCase().search("\\b" + sub.toLowerCase());
 		}
 		if (i == -1) return false;
 		return i == 0 || options.matchContains;
 	};

 	function add(q, value) {
 		if (length > options.cacheLength){
 			flush();
 		}
 		if (!data[q]){
 			length++;
 		}
 		data[q] = value;
 	}

 	function populate(){
 		if( !options.data ) return false;
 		// track the matches
 		var stMatchSets = {},
 			nullData = 0;

 		// no url was specified, we need to adjust the cache length to make sure it fits the local data store
 		if( !options.url ) options.cacheLength = 1;

 		// track all options for minChars = 0
 		stMatchSets[""] = [];

 		// loop through the array and create a lookup structure
 		for ( var i = 0, ol = options.data.length; i < ol; i++ ) {
 			var rawValue = options.data[i];
 			// if rawValue is a string, make an array otherwise just reference the array
 			rawValue = (typeof rawValue == "string") ? [rawValue] : rawValue;

 			var value = options.formatMatch(rawValue, i+1, options.data.length);
 			if ( value === false )
 				continue;

 			var firstChar = value.charAt(0).toLowerCase();
 			// if no lookup array for this character exists, look it up now
 			if( !stMatchSets[firstChar] )
 				stMatchSets[firstChar] = [];

 			// if the match is a string
 			var row = {
 				value: value,
 				data: rawValue,
 				result: options.formatResult && options.formatResult(rawValue) || value
 			};

 			// push the current match into the set list
 			stMatchSets[firstChar].push(row);

 			// keep track of minChars zero items
 			if ( nullData++ < options.max ) {
 				stMatchSets[""].push(row);
 			}
 		};

 		// add the data items to the cache
 		$.each(stMatchSets, function(i, value) {
 			// increase the cache size
 			options.cacheLength++;
 			// add to the cache
 			add(i, value);
 		});
 	}

 	// populate any existing data
 	setTimeout(populate, 25);

 	function flush(){
 		data = {};
 		length = 0;
 	}

 	return {
 		flush: flush,
 		add: add,
 		populate: populate,
 		load: function(q) {
 			if (!options.cacheLength || !length)
 				return null;
 			/*
 			 * if dealing w/local data and matchContains than we must make sure
 			 * to loop through all the data collections looking for matches
 			 */
 			if( !options.url && options.matchContains ){
 				// track all matches
 				var csub = [];
 				// loop through all the data grids for matches
 				for( var k in data ){
 					// don't search through the stMatchSets[""] (minChars: 0) cache
 					// this prevents duplicates
 					if( k.length > 0 ){
 						var c = data[k];
 						$.each(c, function(i, x) {
 							// if we've got a match, add it to the array
 							if (matchSubset(x.value, q)) {
 								csub.push(x);
 							}
 						});
 					}
 				}
 				return csub;
 			} else
 			// if the exact item exists, use it
 			if (data[q]){
 				return data[q];
 			} else
 			if (options.matchSubset) {
 				for (var i = q.length - 1; i >= options.minChars; i--) {
 					var c = data[q.substr(0, i)];
 					if (c) {
 						var csub = [];
 						$.each(c, function(i, x) {
 							if (matchSubset(x.value, q)) {
 								csub[csub.length] = x;
 							}
 						});
 						return csub;
 					}
 				}
 			}
 			return null;
 		}
 	};
 };

 $.Autocompleter.Select = function (options, input, select, config) {
 	var CLASSES = {
 		ACTIVE: "ac_over"
 	};

 	var listItems,
 		active = -1,
 		data,
 		term = "",
 		needsInit = true,
 		element,
 		list;

 	// Create results
 	function init() {
 		if (!needsInit)
 			return;
 		element = $("<div/>")
 		.hide()
 		.addClass(options.resultsClass)
 		.css("position", "absolute")
 		.appendTo(document.body);

 		list = $("<ul/>").appendTo(element).mouseover( function(event) {
 			if(target(event).nodeName && target(event).nodeName.toUpperCase() == 'LI') {
 	            active = $("li", list).removeClass(CLASSES.ACTIVE).index(target(event));
 			    $(target(event)).addClass(CLASSES.ACTIVE);
 	        }
 		}).click(function(event) {
 			$(target(event)).addClass(CLASSES.ACTIVE);
 			select();
 			// TODO provide option to avoid setting focus again after selection? useful for cleanup-on-focus
 			input.focus();
 			return false;
 		}).mousedown(function() {
 			config.mouseDownOnSelect = true;
 		}).mouseup(function() {
 			config.mouseDownOnSelect = false;
 		});

 		if( options.width > 0 )
 			element.css("width", options.width);

 		needsInit = false;
 	}

 	function target(event) {
 		var element = event.target;
 		while(element && element.tagName != "LI")
 			element = element.parentNode;
 		// more fun with IE, sometimes event.target is empty, just ignore it then
 		if(!element)
 			return [];
 		return element;
 	}

 	function moveSelect(step) {
 		listItems.slice(active, active + 1).removeClass(CLASSES.ACTIVE);
 		movePosition(step);
         var activeItem = listItems.slice(active, active + 1).addClass(CLASSES.ACTIVE);
         if(options.scroll) {
             var offset = 0;
             listItems.slice(0, active).each(function() {
 				offset += this.offsetHeight;
 			});
             if((offset + activeItem[0].offsetHeight - list.scrollTop()) > list[0].clientHeight) {
                 list.scrollTop(offset + activeItem[0].offsetHeight - list.innerHeight());
             } else if(offset < list.scrollTop()) {
                 list.scrollTop(offset);
             }
         }
 	};

 	function movePosition(step) {
 		active += step;
 		if (active < 0) {
 			active = listItems.size() - 1;
 		} else if (active >= listItems.size()) {
 			active = 0;
 		}
 	}

 	function limitNumberOfItems(available) {
 		return options.max && options.max < available
 			? options.max
 			: available;
 	}

 	function fillList() {
 		list.empty();
 		var max = limitNumberOfItems(data.length);
 		for (var i=0; i < max; i++) {
 			if (!data[i])
 				continue;
 			var formatted = options.formatItem(data[i].data, i+1, max, data[i].value, term);
 			if ( formatted === false )
 				continue;
 			var li = $("<li/>").html( options.highlight(formatted, term) ).addClass(i%2 == 0 ? "ac_even" : "ac_odd").appendTo(list)[0];
 			$.data(li, "ac_data", data[i]);
 		}
 		listItems = list.find("li");
 		if ( options.selectFirst ) {
 			listItems.slice(0, 1).addClass(CLASSES.ACTIVE);
 			active = 0;
 		}
 		// apply bgiframe if available
 		if ( $.fn.bgiframe )
 			list.bgiframe();
 	}

 	return {
 		display: function(d, q) {
 			init();
 			data = d;
 			term = q;
 			fillList();
 		},
 		next: function() {
 			moveSelect(1);
 		},
 		prev: function() {
 			moveSelect(-1);
 		},
 		pageUp: function() {
 			if (active != 0 && active - 8 < 0) {
 				moveSelect( -active );
 			} else {
 				moveSelect(-8);
 			}
 		},
 		pageDown: function() {
 			if (active != listItems.size() - 1 && active + 8 > listItems.size()) {
 				moveSelect( listItems.size() - 1 - active );
 			} else {
 				moveSelect(8);
 			}
 		},
 		hide: function() {
 			element && element.hide();
 			listItems && listItems.removeClass(CLASSES.ACTIVE);
 			active = -1;
 		},
 		visible : function() {
 			return element && element.is(":visible");
 		},
 		current: function() {
 			return this.visible() && (listItems.filter("." + CLASSES.ACTIVE)[0] || options.selectFirst && listItems[0]);
 		},
 		show: function() {
 			var offset = $(input).offset();
 			element.css({
 				width: typeof options.width == "string" || options.width > 0 ? options.width : $(input).width(),
 				top: offset.top + input.offsetHeight,
 				left: offset.left
 			}).show();
             if(options.scroll) {
                 list.scrollTop(0);
                 list.css({
 					maxHeight: options.scrollHeight,
 					overflow: 'auto'
 				});

                 if($.browser.msie && typeof document.body.style.maxHeight === "undefined") {
 					var listHeight = 0;
 					listItems.each(function() {
 						listHeight += this.offsetHeight;
 					});
 					var scrollbarsVisible = listHeight > options.scrollHeight;
                     list.css('height', scrollbarsVisible ? options.scrollHeight : listHeight );
 					if (!scrollbarsVisible) {
 						// IE doesn't recalculate width when scrollbar disappears
 						listItems.width( list.width() - parseInt(listItems.css("padding-left")) - parseInt(listItems.css("padding-right")) );
 					}
                 }

             }
 		},
 		selected: function() {
 			var selected = listItems && listItems.filter("." + CLASSES.ACTIVE).removeClass(CLASSES.ACTIVE);
 			return selected && selected.length && $.data(selected[0], "ac_data");
 		},
 		emptyList: function (){
 			list && list.empty();
 		},
 		unbind: function() {
 			element && element.remove();
 		}
 	};
 };

 $.Autocompleter.Selection = function(field, start, end) {
 	if( field.createTextRange ){
 		var selRange = field.createTextRange();
 		selRange.collapse(true);
 		selRange.moveStart("character", start);
 		selRange.moveEnd("character", end);
 		selRange.select();
 	} else if( field.setSelectionRange ){
 		field.setSelectionRange(start, end);
 	} else {
 		if( field.selectionStart ){
 			field.selectionStart = start;
 			field.selectionEnd = end;
 		}
 	}
 	field.focus();
 };

 })(jQuery);
	/*
	* Autocomplete - jQuery plugin 1.1pre
	*
	* Copyright (c) 2007 Dylan Verheul, Dan G. Switzer, Anjesh Tuladhar, Jörn Zaefferer
	*
	* Dual licensed under the MIT and GPL licenses:
	* http://www.opensource.org/licenses/mit-license.php
	* http://www.gnu.org/licenses/gpl.html
	*
	* Revision: $Id: jquery.autocomplete.js 5785 2008-07-12 10:37:33Z joern.zaefferer $
	*
	*/

	;(function($) {

	$.fn.extend({
	autocomplete: function(urlOrData, options) {
	var isUrl = typeof urlOrData == "string";
	options = $.extend({}, $.Autocompleter.defaults, {
	url: isUrl ? urlOrData : null,
	data: isUrl ? null : urlOrData,
	delay: isUrl ? $.Autocompleter.defaults.delay : 10,
	max: options && !options.scroll ? 10 : 150
	}, options);

	// if highlight is set to false, replace it with a do-nothing function
	options.highlight = options.highlight \|\| function(value) { return value; };

	// if the formatMatch option is not specified, then use formatItem for backwards compatibility
	options.formatMatch = options.formatMatch \|\| options.formatItem;

	return this.each(function() {
	new $.Autocompleter(this, options);
	});
	},
	result: function(handler) {
	return this.bind("result", handler);
	},
	search: function(handler) {
	return this.trigger("search", [handler]);
	},
	flushCache: function() {
	return this.trigger("flushCache");
	},
	setOptions: function(options){
	return this.trigger("setOptions", [options]);
	},
	unautocomplete: function() {
	return this.trigger("unautocomplete");
	}
	});

	$.Autocompleter = function(input, options) {

	var KEY = {
	UP: 38,
	DOWN: 40,
	DEL: 46,
	TAB: 9,
	RETURN: 13,
	ESC: 27,
	COMMA: 188,
	PAGEUP: 33,
	PAGEDOWN: 34,
	BACKSPACE: 8
	};

	// Create $ object for input element
	var $input = $(input).attr("autocomplete", "off").addClass(options.inputClass);

	var timeout;
	var previousValue = "";
	var cache = $.Autocompleter.Cache(options);
	var hasFocus = 0;
	var lastKeyPressCode;
	var config = {
	mouseDownOnSelect: false
	};
	var select = $.Autocompleter.Select(options, input, selectCurrent, config);

	var blockSubmit;

	// prevent form submit in opera when selecting with return key
	$.browser.opera && $(input.form).bind("submit.autocomplete", function() {
	if (blockSubmit) {
	blockSubmit = false;
	return false;
	}
	});

	// only opera doesn't trigger keydown multiple times while pressed, others don't work with keypress at all
	$input.bind(($.browser.opera ? "keypress" : "keydown") + ".autocomplete", function(event) {
	// track last key pressed
	lastKeyPressCode = event.keyCode;
	switch(event.keyCode) {

	case KEY.UP:
	event.preventDefault();
	if ( select.visible() ) {
	select.prev();
	} else {
	onChange(0, true);
	}
	break;

	case KEY.DOWN:
	event.preventDefault();
	if ( select.visible() ) {
	select.next();
	} else {
	onChange(0, true);
	}
	break;

	case KEY.PAGEUP:
	event.preventDefault();
	if ( select.visible() ) {
	select.pageUp();
	} else {
	onChange(0, true);
	}
	break;

	case KEY.PAGEDOWN:
	event.preventDefault();
	if ( select.visible() ) {
	select.pageDown();
	} else {
	onChange(0, true);
	}
	break;

	// matches also semicolon
	case options.multiple && $.trim(options.multipleSeparator) == "," && KEY.COMMA:
	case KEY.TAB:
	case KEY.RETURN:
	if( selectCurrent() ) {
	// stop default to prevent a form submit, Opera needs special handling
	event.preventDefault();
	blockSubmit = true;
	return false;
	}
	break;

	case KEY.ESC:
	select.hide();
	break;

	default:
	clearTimeout(timeout);
	timeout = setTimeout(onChange, options.delay);
	break;
	}
	}).focus(function(){
	// track whether the field has focus, we shouldn't process any
	// results if the field no longer has focus
	hasFocus++;
	}).blur(function() {
	hasFocus = 0;
	if (!config.mouseDownOnSelect) {
	hideResults();
	}
	}).click(function() {
	// show select when clicking in a focused field
	if ( hasFocus++ > 1 && !select.visible() ) {
	onChange(0, true);
	}
	}).bind("search", function() {
	// TODO why not just specifying both arguments?
	var fn = (arguments.length > 1) ? arguments[1] : null;
	function findValueCallback(q, data) {
	var result;
	if( data && data.length ) {
	for (var i=0; i < data.length; i++) {
	if( data[i].result.toLowerCase() == q.toLowerCase() ) {
	result = data[i];
	break;
	}
	}
	}
	if( typeof fn == "function" ) fn(result);
	else $input.trigger("result", result && [result.data, result.value]);
	}
	$.each(trimWords($input.val()), function(i, value) {
	request(value, findValueCallback, findValueCallback);
	});
	}).bind("flushCache", function() {
	cache.flush();
	}).bind("setOptions", function() {
	$.extend(options, arguments[1]);
	// if we've updated the data, repopulate
	if ( "data" in arguments[1] )
	cache.populate();
	}).bind("unautocomplete", function() {
	select.unbind();
	$input.unbind();
	$(input.form).unbind(".autocomplete");
	});


	function selectCurrent() {
	var selected = select.selected();
	if( !selected )
	return false;

	var v = selected.result;
	previousValue = v;

	if ( options.multiple ) {
	var words = trimWords($input.val());
	if ( words.length > 1 ) {
	v = words.slice(0, words.length - 1).join( options.multipleSeparator ) + options.multipleSeparator + v;
	}
	v += options.multipleSeparator;
	}

	$input.val(v);
	hideResultsNow();
	$input.trigger("result", [selected.data, selected.value]);
	return true;
	}

	function onChange(crap, skipPrevCheck) {
	if( lastKeyPressCode == KEY.DEL ) {
	select.hide();
	return;
	}

	var currentValue = $input.val();

	if ( !skipPrevCheck && currentValue == previousValue )
	return;

	previousValue = currentValue;

	currentValue = lastWord(currentValue);
	if ( currentValue.length >= options.minChars) {
	$input.addClass(options.loadingClass);
	if (!options.matchCase)
	currentValue = currentValue.toLowerCase();
	request(currentValue, receiveData, hideResultsNow);
	} else {
	stopLoading();
	select.hide();
	}
	};

	function trimWords(value) {
	if ( !value ) {
	return [""];
	}
	var words = value.split( options.multipleSeparator );
	var result = [];
	$.each(words, function(i, value) {
	if ( $.trim(value) )
	result[i] = $.trim(value);
	});
	return result;
	}

	function lastWord(value) {
	if ( !options.multiple )
	return value;
	var words = trimWords(value);
	return words[words.length - 1];
	}

	// fills in the input box w/the first match (assumed to be the best match)
	// q: the term entered
	// sValue: the first matching result
	function autoFill(q, sValue){
	// autofill in the complete box w/the first match as long as the user hasn't entered in more data
	// if the last user key pressed was backspace, don't autofill
	if( options.autoFill && (lastWord($input.val()).toLowerCase() == q.toLowerCase()) && lastKeyPressCode != KEY.BACKSPACE ) {
	// fill in the value (keep the case the user has typed)
	$input.val($input.val() + sValue.substring(lastWord(previousValue).length));
	// select the portion of the value not typed by the user (so the next character will erase)
	$.Autocompleter.Selection(input, previousValue.length, previousValue.length + sValue.length);
	}
	};

	function hideResults() {
	clearTimeout(timeout);
	timeout = setTimeout(hideResultsNow, 200);
	};

	function hideResultsNow() {
	var wasVisible = select.visible();
	select.hide();
	clearTimeout(timeout);
	stopLoading();
	if (options.mustMatch) {
	// call search and run callback
	$input.search(
	function (result){
	// if no value found, clear the input box
	if( !result ) {
	if (options.multiple) {
	var words = trimWords($input.val()).slice(0, -1);
	$input.val( words.join(options.multipleSeparator) + (words.length ? options.multipleSeparator : "") );
	}
	else
	$input.val( "" );
	}
	}
	);
	}
	if (wasVisible)
	// position cursor at end of input field
	$.Autocompleter.Selection(input, input.value.length, input.value.length);
	};

	function receiveData(q, data) {
	if ( data && data.length && hasFocus ) {
	stopLoading();
	select.display(data, q);
	autoFill(q, data[0].value);
	select.show();
	} else {
	hideResultsNow();
	}
	};

	function request(term, success, failure) {
	if (!options.matchCase)
	term = term.toLowerCase();
	var data = cache.load(term);
	// recieve the cached data
	if (data && data.length) {
	success(term, data);
	// if an AJAX url has been supplied, try loading the data now
	} else if( (typeof options.url == "string") && (options.url.length > 0) ){

	var extraParams = {
	timestamp: +new Date()
	};
	$.each(options.extraParams, function(key, param) {
	extraParams[key] = typeof param == "function" ? param() : param;
	});

	$.ajax({
	// try to leverage ajaxQueue plugin to abort previous requests
	mode: "abort",
	// limit abortion to this input
	port: "autocomplete" + input.name,
	dataType: options.dataType,
	url: options.url,
	data: $.extend({
	q: lastWord(term),
	limit: options.max
	}, extraParams),
	success: function(data) {
	var parsed = options.parse && options.parse(data) \|\| parse(data);
	cache.add(term, parsed);
	success(term, parsed);
	}
	});
	} else {
	// if we have a failure, we need to empty the list -- this prevents the the [TAB] key from selecting the last successful match
	select.emptyList();
	failure(term);
	}
	};

	function parse(data) {
	var parsed = [];
	var rows = data.split("\n");
	for (var i=0; i < rows.length; i++) {
	var row = $.trim(rows[i]);
	if (row) {
	row = row.split("\|");
	parsed[parsed.length] = {
	data: row,
	value: row[0],
	result: options.formatResult && options.formatResult(row, row[0]) \|\| row[0]
	};
	}
	}
	return parsed;
	};

	function stopLoading() {
	$input.removeClass(options.loadingClass);
	};

	};

	$.Autocompleter.defaults = {
	inputClass: "ac_input",
	resultsClass: "ac_results",
	loadingClass: "ac_loading",
	minChars: 1,
	delay: 400,
	matchCase: false,
	matchSubset: true,
	matchContains: false,
	cacheLength: 10,
	max: 100,
	mustMatch: false,
	extraParams: {},
	selectFirst: true,
	formatItem: function(row) { return row[0]; },
	formatMatch: null,
	autoFill: false,
	width: 0,
	multiple: false,
	multipleSeparator: ", ",
	highlight: function(value, term) {
	return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>])(" + term.replace(/([\^\$\(\)\[\]\{\}\\.\+\?\\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");
	},
	scroll: true,
	scrollHeight: 180
	};

	$.Autocompleter.Cache = function(options) {

	var data = {};
	var length = 0;

	function matchSubset(s, sub) {
	if (!options.matchCase)
	s = s.toLowerCase();
	var i = s.indexOf(sub);
	if (options.matchContains == "word"){
	i = s.toLowerCase().search("\\b" + sub.toLowerCase());
	}
	if (i == -1) return false;
	return i == 0 \|\| options.matchContains;
	};

	function add(q, value) {
	if (length > options.cacheLength){
	flush();
	}
	if (!data[q]){
	length++;
	}
	data[q] = value;
	}

	function populate(){
	if( !options.data ) return false;
	// track the matches
	var stMatchSets = {},
	nullData = 0;

	// no url was specified, we need to adjust the cache length to make sure it fits the local data store
	if( !options.url ) options.cacheLength = 1;

	// track all options for minChars = 0
	stMatchSets[""] = [];

	// loop through the array and create a lookup structure
	for ( var i = 0, ol = options.data.length; i < ol; i++ ) {
	var rawValue = options.data[i];
	// if rawValue is a string, make an array otherwise just reference the array
	rawValue = (typeof rawValue == "string") ? [rawValue] : rawValue;

	var value = options.formatMatch(rawValue, i+1, options.data.length);
	if ( value === false )
	continue;

	var firstChar = value.charAt(0).toLowerCase();
	// if no lookup array for this character exists, look it up now
	if( !stMatchSets[firstChar] )
	stMatchSets[firstChar] = [];

	// if the match is a string
	var row = {
	value: value,
	data: rawValue,
	result: options.formatResult && options.formatResult(rawValue) \|\| value
	};

	// push the current match into the set list
	stMatchSets[firstChar].push(row);

	// keep track of minChars zero items
	if ( nullData++ < options.max ) {
	stMatchSets[""].push(row);
	}
	};

	// add the data items to the cache
	$.each(stMatchSets, function(i, value) {
	// increase the cache size
	options.cacheLength++;
	// add to the cache
	add(i, value);
	});
	}

	// populate any existing data
	setTimeout(populate, 25);

	function flush(){
	data = {};
	length = 0;
	}

	return {
	flush: flush,
	add: add,
	populate: populate,
	load: function(q) {
	if (!options.cacheLength \|\| !length)
	return null;
	/*
	* if dealing w/local data and matchContains than we must make sure
	* to loop through all the data collections looking for matches
	*/
	if( !options.url && options.matchContains ){
	// track all matches
	var csub = [];
	// loop through all the data grids for matches
	for( var k in data ){
	// don't search through the stMatchSets[""] (minChars: 0) cache
	// this prevents duplicates
	if( k.length > 0 ){
	var c = data[k];
	$.each(c, function(i, x) {
	// if we've got a match, add it to the array
	if (matchSubset(x.value, q)) {
	csub.push(x);
	}
	});
	}
	}
	return csub;
	} else
	// if the exact item exists, use it
	if (data[q]){
	return data[q];
	} else
	if (options.matchSubset) {
	for (var i = q.length - 1; i >= options.minChars; i--) {
	var c = data[q.substr(0, i)];
	if (c) {
	var csub = [];
	$.each(c, function(i, x) {
	if (matchSubset(x.value, q)) {
	csub[csub.length] = x;
	}
	});
	return csub;
	}
	}
	}
	return null;
	}
	};
	};

	$.Autocompleter.Select = function (options, input, select, config) {
	var CLASSES = {
	ACTIVE: "ac_over"
	};

	var listItems,
	active = -1,
	data,
	term = "",
	needsInit = true,
	element,
	list;

	// Create results
	function init() {
	if (!needsInit)
	return;
	element = $("<div/>")
	.hide()
	.addClass(options.resultsClass)
	.css("position", "absolute")
	.appendTo(document.body);

	list = $("<ul/>").appendTo(element).mouseover( function(event) {
	if(target(event).nodeName && target(event).nodeName.toUpperCase() == 'LI') {
	active = $("li", list).removeClass(CLASSES.ACTIVE).index(target(event));
	$(target(event)).addClass(CLASSES.ACTIVE);
	}
	}).click(function(event) {
	$(target(event)).addClass(CLASSES.ACTIVE);
	select();
	// TODO provide option to avoid setting focus again after selection? useful for cleanup-on-focus
	input.focus();
	return false;
	}).mousedown(function() {
	config.mouseDownOnSelect = true;
	}).mouseup(function() {
	config.mouseDownOnSelect = false;
	});

	if( options.width > 0 )
	element.css("width", options.width);

	needsInit = false;
	}

	function target(event) {
	var element = event.target;
	while(element && element.tagName != "LI")
	element = element.parentNode;
	// more fun with IE, sometimes event.target is empty, just ignore it then
	if(!element)
	return [];
	return element;
	}

	function moveSelect(step) {
	listItems.slice(active, active + 1).removeClass(CLASSES.ACTIVE);
	movePosition(step);
	var activeItem = listItems.slice(active, active + 1).addClass(CLASSES.ACTIVE);
	if(options.scroll) {
	var offset = 0;
	listItems.slice(0, active).each(function() {
	offset += this.offsetHeight;
	});
	if((offset + activeItem[0].offsetHeight - list.scrollTop()) > list[0].clientHeight) {
	list.scrollTop(offset + activeItem[0].offsetHeight - list.innerHeight());
	} else if(offset < list.scrollTop()) {
	list.scrollTop(offset);
	}
	}
	};

	function movePosition(step) {
	active += step;
	if (active < 0) {
	active = listItems.size() - 1;
	} else if (active >= listItems.size()) {
	active = 0;
	}
	}

	function limitNumberOfItems(available) {
	return options.max && options.max < available
	? options.max
	: available;
	}

	function fillList() {
	list.empty();
	var max = limitNumberOfItems(data.length);
	for (var i=0; i < max; i++) {
	if (!data[i])
	continue;
	var formatted = options.formatItem(data[i].data, i+1, max, data[i].value, term);
	if ( formatted === false )
	continue;
	var li = $("<li/>").html( options.highlight(formatted, term) ).addClass(i%2 == 0 ? "ac_even" : "ac_odd").appendTo(list)[0];
	$.data(li, "ac_data", data[i]);
	}
	listItems = list.find("li");
	if ( options.selectFirst ) {
	listItems.slice(0, 1).addClass(CLASSES.ACTIVE);
	active = 0;
	}
	// apply bgiframe if available
	if ( $.fn.bgiframe )
	list.bgiframe();
	}

	return {
	display: function(d, q) {
	init();
	data = d;
	term = q;
	fillList();
	},
	next: function() {
	moveSelect(1);
	},
	prev: function() {
	moveSelect(-1);
	},
	pageUp: function() {
	if (active != 0 && active - 8 < 0) {
	moveSelect( -active );
	} else {
	moveSelect(-8);
	}
	},
	pageDown: function() {
	if (active != listItems.size() - 1 && active + 8 > listItems.size()) {
	moveSelect( listItems.size() - 1 - active );
	} else {
	moveSelect(8);
	}
	},
	hide: function() {
	element && element.hide();
	listItems && listItems.removeClass(CLASSES.ACTIVE);
	active = -1;
	},
	visible : function() {
	return element && element.is(":visible");
	},
	current: function() {
	return this.visible() && (listItems.filter("." + CLASSES.ACTIVE)[0] \|\| options.selectFirst && listItems[0]);
	},
	show: function() {
	var offset = $(input).offset();
	element.css({
	width: typeof options.width == "string" \|\| options.width > 0 ? options.width : $(input).width(),
	top: offset.top + input.offsetHeight,
	left: offset.left
	}).show();
	if(options.scroll) {
	list.scrollTop(0);
	list.css({
	maxHeight: options.scrollHeight,
	overflow: 'auto'
	});

	if($.browser.msie && typeof document.body.style.maxHeight === "undefined") {
	var listHeight = 0;
	listItems.each(function() {
	listHeight += this.offsetHeight;
	});
	var scrollbarsVisible = listHeight > options.scrollHeight;
	list.css('height', scrollbarsVisible ? options.scrollHeight : listHeight );
	if (!scrollbarsVisible) {
	// IE doesn't recalculate width when scrollbar disappears
	listItems.width( list.width() - parseInt(listItems.css("padding-left")) - parseInt(listItems.css("padding-right")) );
	}
	}

	}
	},
	selected: function() {
	var selected = listItems && listItems.filter("." + CLASSES.ACTIVE).removeClass(CLASSES.ACTIVE);
	return selected && selected.length && $.data(selected[0], "ac_data");
	},
	emptyList: function (){
	list && list.empty();
	},
	unbind: function() {
	element && element.remove();
	}
	};
	};

	$.Autocompleter.Selection = function(field, start, end) {
	if( field.createTextRange ){
	var selRange = field.createTextRange();
	selRange.collapse(true);
	selRange.moveStart("character", start);
	selRange.moveEnd("character", end);
	selRange.select();
	} else if( field.setSelectionRange ){
	field.setSelectionRange(start, end);
	} else {
	if( field.selectionStart ){
	field.selectionStart = start;
	field.selectionEnd = end;
	}
	}
	field.focus();
	};

	})(jQuery);