solr/example/files/conf/velocity/js/jquery.autocomplete.js - lucene-solr - 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);
     data = null; // Avoid buggy cache and go to Solr every time
     // 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: false,
   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);
	data = null; // Avoid buggy cache and go to Solr every time
	// 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: false,
	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);