1. jQuery.autocomplete = function(input, options) {
2.         // Create a link to self
3.         var me = this;
4.  
5.         // Create jQuery object for input element
6.         var $input = $(input).attr("autocomplete", "off");
7.  
8.         // Apply inputClass if necessary
9.         if (options.inputClass) $input.addClass(options.inputClass);
10.  
11.         // Create results
12.         var results = document.createElement("div");
13.         // Create jQuery object for results
14.         var $results = $(results);
15.         $results.hide().addClass(options.resultsClass).css("position", "absolute");
16.         if( options.width > 0 ) $results.css("width", options.width);
17.  
18.         // Add to body element
19.         $("body").append(results);
20.  
21.         input.autocompleter = me;
22.  
23.         var timeout = null;
24.         var prev = "";
25.         var active = -1;
26.         var cache = {};
27.         var keyb = false;
28.         var hasFocus = false;
29.         var lastKeyPressCode = null;
30.  
31.         // flush cache
32.         function flushCache(){
33.                 cache = {};
34.                 cache.data = {};
35.                 cache.length = 0;
36.         };
37.  
38.         // flush cache
39.         flushCache();
40.  
41.         // if there is a data array supplied
42.         if( options.data != null ){
43.                 var sFirstChar = "", stMatchSets = {}, row = [];
44.  
45.                 // no url was specified, we need to adjust the cache length to make sure it fits the local data store
46.                 if( typeof options.url != "string" ) options.cacheLength = 1;
47.  
48.                 // loop through the array and create a lookup structure
49.                 for( var i=0; i < options.data.length; i++ ){
50.                         // if row is a string, make an array otherwise just reference the array
51.                         row = ((typeof options.data[i] == "string") ? [options.data[i]] : options.data[i]);
52.  
53.                         // if the length is zero, don't add to list
54.                         if( row[0].length > 0 ){
55.                                 // get the first character
56.                                 sFirstChar = row[0].substring(0, 1).toLowerCase();
57.                                 // if no lookup array for this character exists, look it up now
58.                                 if( !stMatchSets[sFirstChar] ) stMatchSets[sFirstChar] = [];
59.                                 // if the match is a string
60.                                 stMatchSets[sFirstChar].push(row);
61.                         }
62.                 }
63.  
64.                 // add the data items to the cache
65.                 for( var k in stMatchSets ){
66.                         // increase the cache size
67.                         options.cacheLength++;
68.                         // add to the cache
69.                         addToCache(k, stMatchSets[k]);
70.                 }
71.         }
72.  
73.         $input
74.         .keydown(function(e) {
75.                 // track last key pressed
76.                 lastKeyPressCode = e.keyCode;
77.                 switch(e.keyCode) {
78.                         case 38: // up
79.                                 e.preventDefault();
80.                                 moveSelect(-1);
81.                                 break;
82.                         case 40: // down
83.                                 e.preventDefault();
84.                                 moveSelect(1);
85.                                 break;
86.                         case 9:  // tab
87.                         case 13: // return
88.                                 if( selectCurrent() ){
89.                                         // make sure to blur off the current field
90.                                         $input.get(0).blur();
91.                                         e.preventDefault();
92.                                 }
93.                                 break;
94.                         default:
95.                                 active = -1;
96.                                 if (timeout) clearTimeout(timeout);
97.                                 timeout = setTimeout(function(){onChange();}, options.delay);
98.                                 break;
99.                 }
100.         })
101.         .focus(function(){
102.                 // track whether the field has focus, we shouldn't process any results if the field no longer has focus
103.                 hasFocus = true;
104.         })
105.         .blur(function() {
106.                 // track whether the field has focus
107.                 hasFocus = false;
108.                 hideResults();
109.         });
110.  
111.         hideResultsNow();
112.  
113.         function onChange() {
114.                 // ignore if the following keys are pressed: [del] [shift] [capslock]
115.                 if( lastKeyPressCode == 46 || (lastKeyPressCode > 8 && lastKeyPressCode < 32) ) return $results.hide();
116.                 var v = $input.val();
117.                 if (v == prev) return;
118.                 prev = v;
119.                 if (v.length >= options.minChars) {
120.                         $input.addClass(options.loadingClass);
121.                         requestData(v);
122.                 } else {
123.                         $input.removeClass(options.loadingClass);
124.                         $results.hide();
125.                 }
126.         };
127.  
128.         function moveSelect(step) {
129.  
130.                 var lis = $("li", results);
131.                 if (!lis) return;
132.  
133.                 active += step;
134.  
135.                 if (active < 0) {
136.                         active = 0;
137.                 } else if (active >= lis.size()) {
138.                         active = lis.size() - 1;
139.                 }
140.  
141.                 lis.removeClass("ac_over");
142.  
143.                 $(lis[active]).addClass("ac_over");
144.  
145.                 // Weird behaviour in IE
146.                 // if (lis[active] && lis[active].scrollIntoView) {
147.                 //      lis[active].scrollIntoView(false);
148.                 // }
149.  
150.         };
151.  
152.         function selectCurrent() {
153.                 var li = $("li.ac_over", results)[0];
154.                 if (!li) {
155.                         var $li = $("li", results);
156.                         if (options.selectOnly) {
157.                                 if ($li.length == 1) li = $li[0];
158.                         } else if (options.selectFirst) {
159.                                 li = $li[0];
160.                         }
161.                 }
162.                 if (li) {
163.                         selectItem(li);
164.                         return true;
165.                 } else {
166.                         return false;
167.                 }
168.         };
169.  
170.         function selectItem(li) {
171.                 if (!li) {
172.                         li = document.createElement("li");
173.                         li.extra = [];
174.                         li.selectValue = "";
175.                 }
176.                 var v = $.trim(li.selectValue ? li.selectValue : li.innerHTML);
177.                 input.lastSelected = v;
178.                 prev = v;
179.                 $results.html("");
180.                 $input.val(v);
181.                 hideResultsNow();
182.                 if (options.onItemSelect) setTimeout(function() { options.onItemSelect(li) }, 1);
183.         };
184.  
185.         // selects a portion of the input string
186.         function createSelection(start, end){
187.                 // get a reference to the input element
188.                 var field = $input.get(0);
189.                 if( field.createTextRange ){
190.                         var selRange = field.createTextRange();
191.                         selRange.collapse(true);
192.                         selRange.moveStart("character", start);
193.                         selRange.moveEnd("character", end);
194.                         selRange.select();
195.                 } else if( field.setSelectionRange ){
196.                         field.setSelectionRange(start, end);
197.                 } else {
198.                         if( field.selectionStart ){
199.                                 field.selectionStart = start;
200.                                 field.selectionEnd = end;
201.                         }
202.                 }
203.                 field.focus();
204.         };
205.  
206.         // fills in the input box w/the first match (assumed to be the best match)
207.         function autoFill(sValue){
208.                 // if the last user key pressed was backspace, don't autofill
209.                 if( lastKeyPressCode != 8 ){
210.                         // fill in the value (keep the case the user has typed)
211.                         $input.val($input.val() + sValue.substring(prev.length));
212.                         // select the portion of the value not typed by the user (so the next character will erase)
213.                         createSelection(prev.length, sValue.length);
214.                 }
215.         };
216.  
217.         function showResults() {
218.                 // get the position of the input field right now (in case the DOM is shifted)
219.                 var pos = findPos(input);
220.                 // either use the specified width, or autocalculate based on form element
221.                 var iWidth = (options.width > 0) ? options.width : $input.width();
222.                 // reposition
223.                 $results.css({
224.                         width: parseInt(iWidth) + "px",
225.                         top: (pos.y + input.offsetHeight) + "px",
226.                         left: pos.x + "px"
227.                 }).show();
228.         };
229.  
230.         function hideResults() {
231.                 if (timeout) clearTimeout(timeout);
232.                 timeout = setTimeout(hideResultsNow, 200);
233.         };
234.  
235.         function hideResultsNow() {
236.                 if (timeout) clearTimeout(timeout);
237.                 $input.removeClass(options.loadingClass);
238.                 if ($results.is(":visible")) {
239.                         $results.hide();
240.                 }
241.                 if (options.mustMatch) {
242.                         var v = $input.val();
243.                         if (v != input.lastSelected) {
244.                                 selectItem(null);
245.                         }
246.                 }
247.         };
248.  
249.         function receiveData(q, data) {
250.                 if (data) {
251.                         $input.removeClass(options.loadingClass);
252.                         results.innerHTML = "";
253.  
254.                         // if the field no longer has focus or if there are no matches, do not display the drop down
255.                         if( !hasFocus || data.length == 0 ) return hideResultsNow();
256.  
257.                         if ($.browser.msie) {
258.                                 // we put a styled iframe behind the calendar so HTML SELECT elements don't show through
259.                                 $results.append(document.createElement('iframe'));
260.                         }
261.                         results.appendChild(dataToDom(data));
262.                         // autofill in the complete box w/the first match as long as the user hasn't entered in more data
263.                         if( options.autoFill && ($input.val().toLowerCase() == q.toLowerCase()) ) autoFill(data[0][0]);
264.                         showResults();
265.                 } else {
266.                         hideResultsNow();
267.                 }
268.         };
269.  
270.         function parseData(data) {
271.                 if (!data) return null;
272.                 var parsed = [];
273.                 var rows = data.split(options.lineSeparator);
274.                 for (var i=0; i < rows.length; i++) {
275.                         var row = $.trim(rows[i]);
276.                         if (row) {
277.                                 parsed[parsed.length] = row.split(options.cellSeparator);
278.                         }
279.                 }
280.                 return parsed;
281.         };
282.  
283.         function dataToDom(data) {
284.                 var ul = document.createElement("ul");
285.                 var num = data.length;
286.  
287.                 // limited results to a max number
288.                 if( (options.maxItemsToShow > 0) && (options.maxItemsToShow < num) ) num = options.maxItemsToShow;
289.  
290.                 for (var i=0; i < num; i++) {
291.                         var row = data[i];
292.                         if (!row) continue;
293.                         var li = document.createElement("li");
294.                         if (options.formatItem) {
295.                                 li.innerHTML = options.formatItem(row, i, num);
296.                                 li.selectValue = row[0];
297.                         } else {
298.                                 li.innerHTML = row[0];
299.                                 li.selectValue = row[0];
300.                         }
301.                         var extra = null;
302.                         if (row.length > 1) {
303.                                 extra = [];
304.                                 for (var j=1; j < row.length; j++) {
305.                                         extra[extra.length] = row[j];
306.                                 }
307.                         }
308.                         li.extra = extra;
309.                         ul.appendChild(li);
310.                         $(li).hover(
311.                                 function() { $("li", ul).removeClass("ac_over"); $(this).addClass("ac_over"); active = $("li", ul).indexOf($(this).get(0)); },
312.                                 function() { $(this).removeClass("ac_over"); }
313.                         ).click(function(e) { e.preventDefault(); e.stopPropagation(); selectItem(this) });
314.                 }
315.                 return ul;
316.         };
317.  
318.         function requestData(q) {
319.                 if (!options.matchCase) q = q.toLowerCase();
320.                 var data = options.cacheLength ? loadFromCache(q) : null;
321.                 // recieve the cached data
322.                 if (data) {
323.                         receiveData(q, data);
324.                 // if an AJAX url has been supplied, try loading the data now
325.                 } else if( (typeof options.url == "string") && (options.url.length > 0) ){
326.                         $.get(makeUrl(q), function(data) {
327.                                 data = parseData(data);
328.                                 addToCache(q, data);
329.                                 receiveData(q, data);
330.                         });
331.                 // if there's been no data found, remove the loading class
332.                 } else {
333.                         $input.removeClass(options.loadingClass);
334.                 }
335.         };
336.  
337.         function makeUrl(q) {
338.                 var url = options.url + "?q=" + encodeURI(q);
339.                 for (var i in options.extraParams) {
340.                         url += "&" + i + "=" + encodeURI(options.extraParams[i]);
341.                 }
342.                 return url;
343.         };
344.  
345.         function loadFromCache(q) {
346.                 if (!q) return null;
347.                 if (cache.data[q]) return cache.data[q];
348.                 if (options.matchSubset) {
349.                         for (var i = q.length - 1; i >= options.minChars; i--) {
350.                                 var qs = q.substr(0, i);
351.                                 var c = cache.data[qs];
352.                                 if (c) {
353.                                         var csub = [];
354.                                         for (var j = 0; j < c.length; j++) {
355.                                                 var x = c[j];
356.                                                 var x0 = x[0];
357.                                                 if (matchSubset(x0, q)) {
358.                                                         csub[csub.length] = x;
359.                                                 }
360.                                         }
361.                                         return csub;
362.                                 }
363.                         }
364.                 }
365.                 return null;
366.         };
367.  
368.         function matchSubset(s, sub) {
369.                 if (!options.matchCase) s = s.toLowerCase();
370.                 var i = s.indexOf(sub);
371.                 if (i == -1) return false;
372.                 return i == 0 || options.matchContains;
373.         };
374.  
375.         this.flushCache = function() {
376.                 flushCache();
377.         };
378.  
379.         this.setExtraParams = function(p) {
380.                 options.extraParams = p;
381.         };
382.  
383.         this.findValue = function(){
384.                 var q = $input.val();
385.  
386.                 if (!options.matchCase) q = q.toLowerCase();
387.                 var data = options.cacheLength ? loadFromCache(q) : null;
388.                 if (data) {
389.                         findValueCallback(q, data);
390.                 } else if( (typeof options.url == "string") && (options.url.length > 0) ){
391.                         $.get(makeUrl(q), function(data) {
392.                                 data = parseData(data)
393.                                 addToCache(q, data);
394.                                 findValueCallback(q, data);
395.                         });
396.                 } else {
397.                         // no matches
398.                         findValueCallback(q, null);
399.                 }
400.         }
401.  
402.         function findValueCallback(q, data){
403.                 if (data) $input.removeClass(options.loadingClass);
404.  
405.                 var num = (data) ? data.length : 0;
406.                 var li = null;
407.  
408.                 for (var i=0; i < num; i++) {
409.                         var row = data[i];
410.  
411.                         if( row[0].toLowerCase() == q.toLowerCase() ){
412.                                 li = document.createElement("li");
413.                                 if (options.formatItem) {
414.                                         li.innerHTML = options.formatItem(row, i, num);
415.                                         li.selectValue = row[0];
416.                                 } else {
417.                                         li.innerHTML = row[0];
418.                                         li.selectValue = row[0];
419.                                 }
420.                                 var extra = null;
421.                                 if( row.length > 1 ){
422.                                         extra = [];
423.                                         for (var j=1; j < row.length; j++) {
424.                                                 extra[extra.length] = row[j];
425.                                         }
426.                                 }
427.                                 li.extra = extra;
428.                         }
429.                 }
430.  
431.                 if( options.onFindValue ) setTimeout(function() { options.onFindValue(li) }, 1);
432.         }
433.  
434.         function addToCache(q, data) {
435.                 if (!data || !q || !options.cacheLength) return;
436.                 if (!cache.length || cache.length > options.cacheLength) {
437.                         flushCache();
438.                         cache.length++;
439.                 } else if (!cache[q]) {
440.                         cache.length++;
441.                 }
442.                 cache.data[q] = data;
443.         };
444.  
445.         function findPos(obj) {
446.                 var curleft = obj.offsetLeft || 0;
447.                 var curtop = obj.offsetTop || 0;
448.                 while (obj = obj.offsetParent) {
449.                         curleft += obj.offsetLeft
450.                         curtop += obj.offsetTop
451.                 }
452.                 return {x:curleft,y:curtop};
453.         }
454. }
455.  
456. jQuery.fn.autocomplete = function(url, options, data) {
457.         // Make sure options exists
458.         options = options || {};
459.         // Set url as option
460.         options.url = url;
461.         // set some bulk local data
462.         options.data = ((typeof data == "object") && (data.constructor == Array)) ? data : null;
463.  
464.         // Set default values for required options
465.         options.inputClass = options.inputClass || "ac_input";
466.         options.resultsClass = options.resultsClass || "ac_results";
467.         options.lineSeparator = options.lineSeparator || "\n";
468.         options.cellSeparator = options.cellSeparator || "|";
469.         options.minChars = options.minChars || 1;
470.         options.delay = options.delay || 400;
471.         options.matchCase = options.matchCase || 0;
472.         options.matchSubset = options.matchSubset || 1;
473.         options.matchContains = options.matchContains || 0;
474.         options.cacheLength = options.cacheLength || 1;
475.         options.mustMatch = options.mustMatch || 0;
476.         options.extraParams = options.extraParams || {};
477.         options.loadingClass = options.loadingClass || "ac_loading";
478.         options.selectFirst = options.selectFirst || false;
479.         options.selectOnly = options.selectOnly || false;
480.         options.maxItemsToShow = options.maxItemsToShow || -1;
481.         options.autoFill = options.autoFill || false;
482.         options.width = parseInt(options.width, 10) || 0;
483.  
484.         this.each(function() {
485.                 var input = this;
486.                 new jQuery.autocomplete(input, options);
487.         });
488.  
489.         // Don't break the chain
490.         return this;
491. }
492.  
493. jQuery.fn.autocompleteArray = function(data, options) {
494.         return this.autocomplete(null, options, data);
495. }
496.  
497. jQuery.fn.indexOf = function(e){
498.         for( var i=0; i<this.length; i++ ){
499.                 if( this[i] == e ) return i;
500.         }
501.         return -1;
502. };