Gravatar pretty much equals disregarding privacy
[statusnet:gnu-social.git] / plugins / Autocomplete / jquery-autocomplete / jquery.autocomplete.js
1 /*
2  * Autocomplete - jQuery plugin 1.0.2
3  *
4  * Copyright (c) 2007 Dylan Verheul, Dan G. Switzer, Anjesh Tuladhar, Jörn Zaefferer
5  *
6  * Dual licensed under the MIT and GPL licenses:
7  *   http://www.opensource.org/licenses/mit-license.php
8  *   http://www.gnu.org/licenses/gpl.html
9  *
10  * Revision: $Id: jquery.autocomplete.js 5747 2008-06-25 18:30:55Z joern.zaefferer $
11  *
12  */
13
14 ;(function($) {
15         
16 $.fn.extend({
17         autocomplete: function(urlOrData, options) {
18                 var isUrl = typeof urlOrData == "string";
19                 options = $.extend({}, $.Autocompleter.defaults, {
20                         url: isUrl ? urlOrData : null,
21                         data: isUrl ? null : urlOrData,
22                         delay: isUrl ? $.Autocompleter.defaults.delay : 10,
23                         max: options && !options.scroll ? 10 : 150
24                 }, options);
25                 
26                 // if highlight is set to false, replace it with a do-nothing function
27                 options.highlight = options.highlight || function(value) { return value; };
28                 
29                 // if the formatMatch option is not specified, then use formatItem for backwards compatibility
30                 options.formatMatch = options.formatMatch || options.formatItem;
31                 
32                 return this.each(function() {
33                         new $.Autocompleter(this, options);
34                 });
35         },
36         result: function(handler) {
37                 return this.bind("result", handler);
38         },
39         search: function(handler) {
40                 return this.trigger("search", [handler]);
41         },
42         flushCache: function() {
43                 return this.trigger("flushCache");
44         },
45         setOptions: function(options){
46                 return this.trigger("setOptions", [options]);
47         },
48         unautocomplete: function() {
49                 return this.trigger("unautocomplete");
50         }
51 });
52
53 $.Autocompleter = function(input, options) {
54
55         var KEY = {
56                 UP: 38,
57                 DOWN: 40,
58                 DEL: 46,
59                 TAB: 9,
60                 RETURN: 13,
61                 ESC: 27,
62                 COMMA: 188,
63                 PAGEUP: 33,
64                 PAGEDOWN: 34,
65                 BACKSPACE: 8
66         };
67
68         // Create $ object for input element
69         var $input = $(input).attr("autocomplete", "off").addClass(options.inputClass);
70
71         var timeout;
72         var previousValue = "";
73         var cache = $.Autocompleter.Cache(options);
74         var hasFocus = 0;
75         var lastKeyPressCode;
76         var config = {
77                 mouseDownOnSelect: false
78         };
79         var select = $.Autocompleter.Select(options, input, selectCurrent, config);
80         
81         var blockSubmit;
82         
83         // prevent form submit in opera when selecting with return key
84         $.browser.opera && $(input.form).bind("submit.autocomplete", function() {
85                 if (blockSubmit) {
86                         blockSubmit = false;
87                         return false;
88                 }
89         });
90         
91         // only opera doesn't trigger keydown multiple times while pressed, others don't work with keypress at all
92         $input.bind(($.browser.opera ? "keypress" : "keydown") + ".autocomplete", function(event) {
93                 // track last key pressed
94                 lastKeyPressCode = event.keyCode;
95                 switch(event.keyCode) {
96                 
97                         case KEY.UP:
98                                 event.preventDefault();
99                                 if ( select.visible() ) {
100                                         select.prev();
101                                 } else {
102                                         onChange(0, true);
103                                 }
104                                 break;
105                                 
106                         case KEY.DOWN:
107                                 event.preventDefault();
108                                 if ( select.visible() ) {
109                                         select.next();
110                                 } else {
111                                         onChange(0, true);
112                                 }
113                                 break;
114                                 
115                         case KEY.PAGEUP:
116                                 event.preventDefault();
117                                 if ( select.visible() ) {
118                                         select.pageUp();
119                                 } else {
120                                         onChange(0, true);
121                                 }
122                                 break;
123                                 
124                         case KEY.PAGEDOWN:
125                                 event.preventDefault();
126                                 if ( select.visible() ) {
127                                         select.pageDown();
128                                 } else {
129                                         onChange(0, true);
130                                 }
131                                 break;
132                         
133                         // matches also semicolon
134                         case options.multiple && $.trim(options.multipleSeparator) == "," && KEY.COMMA:
135                         case KEY.TAB:
136                         case KEY.RETURN:
137                                 if( selectCurrent() ) {
138                                         // stop default to prevent a form submit, Opera needs special handling
139                                         event.preventDefault();
140                                         blockSubmit = true;
141                                         return false;
142                                 }
143                                 break;
144                                 
145                         case KEY.ESC:
146                                 select.hide();
147                                 break;
148                                 
149                         default:
150                                 clearTimeout(timeout);
151                                 timeout = setTimeout(onChange, options.delay);
152                                 break;
153                 }
154         }).focus(function(){
155                 // track whether the field has focus, we shouldn't process any
156                 // results if the field no longer has focus
157                 hasFocus++;
158         }).blur(function() {
159                 hasFocus = 0;
160                 if (!config.mouseDownOnSelect) {
161                         hideResults();
162                 }
163         }).click(function() {
164                 // show select when clicking in a focused field
165                 if ( hasFocus++ > 1 && !select.visible() ) {
166                         onChange(0, true);
167                 }
168         }).bind("search", function() {
169                 // TODO why not just specifying both arguments?
170                 var fn = (arguments.length > 1) ? arguments[1] : null;
171                 function findValueCallback(q, data) {
172                         var result;
173                         if( data && data.length ) {
174                                 for (var i=0; i < data.length; i++) {
175                                         if( data[i].result.toLowerCase() == q.toLowerCase() ) {
176                                                 result = data[i];
177                                                 break;
178                                         }
179                                 }
180                         }
181                         if( typeof fn == "function" ) fn(result);
182                         else $input.trigger("result", result && [result.data, result.value]);
183                 }
184                 $.each(trimWords($input.val()), function(i, value) {
185                         request(value, findValueCallback, findValueCallback);
186                 });
187         }).bind("flushCache", function() {
188                 cache.flush();
189         }).bind("setOptions", function() {
190                 $.extend(options, arguments[1]);
191                 // if we've updated the data, repopulate
192                 if ( "data" in arguments[1] )
193                         cache.populate();
194         }).bind("unautocomplete", function() {
195                 select.unbind();
196                 $input.unbind();
197                 $(input.form).unbind(".autocomplete");
198         });
199         
200         
201         function selectCurrent() {
202                 var selected = select.selected();
203                 if( !selected )
204                         return false;
205                 
206                 var v = selected.result;
207                 previousValue = v;
208                 
209                 if ( options.multiple ) {
210                         var words = trimWords($input.val());
211                         if ( words.length > 1 ) {
212                                 v = words.slice(0, words.length - 1).join( options.multipleSeparator ) + options.multipleSeparator + v;
213                         }
214                         v += options.multipleSeparator;
215                 }
216                 
217                 $input.val(v);
218                 hideResultsNow();
219                 $input.trigger("result", [selected.data, selected.value]);
220                 return true;
221         }
222         
223         function onChange(crap, skipPrevCheck) {
224                 if( lastKeyPressCode == KEY.DEL ) {
225                         select.hide();
226                         return;
227                 }
228                 
229                 var currentValue = $input.val();
230                 
231                 if ( !skipPrevCheck && currentValue == previousValue )
232                         return;
233                 
234                 previousValue = currentValue;
235                 
236                 currentValue = lastWord(currentValue);
237                 if ( currentValue.length >= options.minChars) {
238                         $input.addClass(options.loadingClass);
239                         if (!options.matchCase)
240                                 currentValue = currentValue.toLowerCase();
241                         request(currentValue, receiveData, hideResultsNow);
242                 } else {
243                         stopLoading();
244                         select.hide();
245                 }
246         };
247         
248         function trimWords(value) {
249                 if ( !value ) {
250                         return [""];
251                 }
252                 var words = value.split( options.multipleSeparator );
253                 var result = [];
254                 $.each(words, function(i, value) {
255                         if ( $.trim(value) )
256                                 result[i] = $.trim(value);
257                 });
258                 return result;
259         }
260         
261         function lastWord(value) {
262                 if ( !options.multiple )
263                         return value;
264                 var words = trimWords(value);
265                 return words[words.length - 1];
266         }
267         
268         // fills in the input box w/the first match (assumed to be the best match)
269         // q: the term entered
270         // sValue: the first matching result
271         function autoFill(q, sValue){
272                 // autofill in the complete box w/the first match as long as the user hasn't entered in more data
273                 // if the last user key pressed was backspace, don't autofill
274                 if( options.autoFill && (lastWord($input.val()).toLowerCase() == q.toLowerCase()) && lastKeyPressCode != KEY.BACKSPACE ) {
275                         // fill in the value (keep the case the user has typed)
276                         $input.val($input.val() + sValue.substring(lastWord(previousValue).length));
277                         // select the portion of the value not typed by the user (so the next character will erase)
278                         $.Autocompleter.Selection(input, previousValue.length, previousValue.length + sValue.length);
279                 }
280         };
281
282         function hideResults() {
283                 clearTimeout(timeout);
284                 timeout = setTimeout(hideResultsNow, 200);
285         };
286
287         function hideResultsNow() {
288                 var wasVisible = select.visible();
289                 select.hide();
290                 clearTimeout(timeout);
291                 stopLoading();
292                 if (options.mustMatch) {
293                         // call search and run callback
294                         $input.search(
295                                 function (result){
296                                         // if no value found, clear the input box
297                                         if( !result ) {
298                                                 if (options.multiple) {
299                                                         var words = trimWords($input.val()).slice(0, -1);
300                                                         $input.val( words.join(options.multipleSeparator) + (words.length ? options.multipleSeparator : "") );
301                                                 }
302                                                 else
303                                                         $input.val( "" );
304                                         }
305                                 }
306                         );
307                 }
308                 if (wasVisible)
309                         // position cursor at end of input field
310                         $.Autocompleter.Selection(input, input.value.length, input.value.length);
311         };
312
313         function receiveData(q, data) {
314                 if ( data && data.length && hasFocus ) {
315                         stopLoading();
316                         select.display(data, q);
317                         autoFill(q, data[0].value);
318                         select.show();
319                 } else {
320                         hideResultsNow();
321                 }
322         };
323
324         function request(term, success, failure) {
325                 if (!options.matchCase)
326                         term = term.toLowerCase();
327                 var data = cache.load(term);
328                 // recieve the cached data
329                 if (data && data.length) {
330                         success(term, data);
331                 // if an AJAX url has been supplied, try loading the data now
332                 } else if( (typeof options.url == "string") && (options.url.length > 0) ){
333                         
334                         var extraParams = {
335                                 timestamp: +new Date()
336                         };
337                         $.each(options.extraParams, function(key, param) {
338                                 extraParams[key] = typeof param == "function" ? param() : param;
339                         });
340                         
341                         $.ajax({
342                                 // try to leverage ajaxQueue plugin to abort previous requests
343                                 mode: "abort",
344                                 // limit abortion to this input
345                                 port: "autocomplete" + input.name,
346                                 dataType: options.dataType,
347                                 url: options.url,
348                                 data: $.extend({
349                                         q: lastWord(term),
350                                         limit: options.max
351                                 }, extraParams),
352                                 success: function(data) {
353                                         var parsed = options.parse && options.parse(data) || parse(data);
354                                         cache.add(term, parsed);
355                                         success(term, parsed);
356                                 }
357                         });
358                 } else {
359                         // if we have a failure, we need to empty the list -- this prevents the the [TAB] key from selecting the last successful match
360                         select.emptyList();
361                         failure(term);
362                 }
363         };
364         
365         function parse(data) {
366                 var parsed = [];
367                 var rows = data.split("\n");
368                 for (var i=0; i < rows.length; i++) {
369                         var row = $.trim(rows[i]);
370                         if (row) {
371                                 row = row.split("|");
372                                 parsed[parsed.length] = {
373                                         data: row,
374                                         value: row[0],
375                                         result: options.formatResult && options.formatResult(row, row[0]) || row[0]
376                                 };
377                         }
378                 }
379                 return parsed;
380         };
381
382         function stopLoading() {
383                 $input.removeClass(options.loadingClass);
384         };
385
386 };
387
388 $.Autocompleter.defaults = {
389         inputClass: "ac_input",
390         resultsClass: "ac_results",
391         loadingClass: "ac_loading",
392         minChars: 1,
393         delay: 400,
394         matchCase: false,
395         matchSubset: true,
396         matchContains: false,
397         cacheLength: 10,
398         max: 100,
399         mustMatch: false,
400         extraParams: {},
401         selectFirst: true,
402         formatItem: function(row) { return row[0]; },
403         formatMatch: null,
404         autoFill: false,
405         width: 0,
406         multiple: false,
407         multipleSeparator: ", ",
408         highlight: function(value, term) {
409                 return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + term.replace(/([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");
410         },
411     scroll: true,
412     scrollHeight: 180
413 };
414
415 $.Autocompleter.Cache = function(options) {
416
417         var data = {};
418         var length = 0;
419         
420         function matchSubset(s, sub) {
421                 if (!options.matchCase) 
422                         s = s.toLowerCase();
423                 var i = s.indexOf(sub);
424                 if (i == -1) return false;
425                 return i == 0 || options.matchContains;
426         };
427         
428         function add(q, value) {
429                 if (length > options.cacheLength){
430                         flush();
431                 }
432                 if (!data[q]){ 
433                         length++;
434                 }
435                 data[q] = value;
436         }
437         
438         function populate(){
439                 if( !options.data ) return false;
440                 // track the matches
441                 var stMatchSets = {},
442                         nullData = 0;
443
444                 // no url was specified, we need to adjust the cache length to make sure it fits the local data store
445                 if( !options.url ) options.cacheLength = 1;
446                 
447                 // track all options for minChars = 0
448                 stMatchSets[""] = [];
449                 
450                 // loop through the array and create a lookup structure
451                 for ( var i = 0, ol = options.data.length; i < ol; i++ ) {
452                         var rawValue = options.data[i];
453                         // if rawValue is a string, make an array otherwise just reference the array
454                         rawValue = (typeof rawValue == "string") ? [rawValue] : rawValue;
455                         
456                         var value = options.formatMatch(rawValue, i+1, options.data.length);
457                         if ( value === false )
458                                 continue;
459                                 
460                         var firstChar = value.charAt(0).toLowerCase();
461                         // if no lookup array for this character exists, look it up now
462                         if( !stMatchSets[firstChar] ) 
463                                 stMatchSets[firstChar] = [];
464
465                         // if the match is a string
466                         var row = {
467                                 value: value,
468                                 data: rawValue,
469                                 result: options.formatResult && options.formatResult(rawValue) || value
470                         };
471                         
472                         // push the current match into the set list
473                         stMatchSets[firstChar].push(row);
474
475                         // keep track of minChars zero items
476                         if ( nullData++ < options.max ) {
477                                 stMatchSets[""].push(row);
478                         }
479                 };
480
481                 // add the data items to the cache
482                 $.each(stMatchSets, function(i, value) {
483                         // increase the cache size
484                         options.cacheLength++;
485                         // add to the cache
486                         add(i, value);
487                 });
488         }
489         
490         // populate any existing data
491         setTimeout(populate, 25);
492         
493         function flush(){
494                 data = {};
495                 length = 0;
496         }
497         
498         return {
499                 flush: flush,
500                 add: add,
501                 populate: populate,
502                 load: function(q) {
503                         if (!options.cacheLength || !length)
504                                 return null;
505                         /* 
506                          * if dealing w/local data and matchContains than we must make sure
507                          * to loop through all the data collections looking for matches
508                          */
509                         if( !options.url && options.matchContains ){
510                                 // track all matches
511                                 var csub = [];
512                                 // loop through all the data grids for matches
513                                 for( var k in data ){
514                                         // don't search through the stMatchSets[""] (minChars: 0) cache
515                                         // this prevents duplicates
516                                         if( k.length > 0 ){
517                                                 var c = data[k];
518                                                 $.each(c, function(i, x) {
519                                                         // if we've got a match, add it to the array
520                                                         if (matchSubset(x.value, q)) {
521                                                                 csub.push(x);
522                                                         }
523                                                 });
524                                         }
525                                 }                               
526                                 return csub;
527                         } else 
528                         // if the exact item exists, use it
529                         if (data[q]){
530                                 return data[q];
531                         } else
532                         if (options.matchSubset) {
533                                 for (var i = q.length - 1; i >= options.minChars; i--) {
534                                         var c = data[q.substr(0, i)];
535                                         if (c) {
536                                                 var csub = [];
537                                                 $.each(c, function(i, x) {
538                                                         if (matchSubset(x.value, q)) {
539                                                                 csub[csub.length] = x;
540                                                         }
541                                                 });
542                                                 return csub;
543                                         }
544                                 }
545                         }
546                         return null;
547                 }
548         };
549 };
550
551 $.Autocompleter.Select = function (options, input, select, config) {
552         var CLASSES = {
553                 ACTIVE: "ac_over"
554         };
555         
556         var listItems,
557                 active = -1,
558                 data,
559                 term = "",
560                 needsInit = true,
561                 element,
562                 list;
563         
564         // Create results
565         function init() {
566                 if (!needsInit)
567                         return;
568                 element = $("<div/>")
569                 .hide()
570                 .addClass(options.resultsClass)
571                 .css("position", "absolute")
572                 .appendTo(document.body);
573         
574                 list = $("<ul/>").appendTo(element).mouseover( function(event) {
575                         if(target(event).nodeName && target(event).nodeName.toUpperCase() == 'LI') {
576                     active = $("li", list).removeClass(CLASSES.ACTIVE).index(target(event));
577                             $(target(event)).addClass(CLASSES.ACTIVE);            
578                 }
579                 }).click(function(event) {
580                         $(target(event)).addClass(CLASSES.ACTIVE);
581                         select();
582                         // TODO provide option to avoid setting focus again after selection? useful for cleanup-on-focus
583                         input.focus();
584                         return false;
585                 }).mousedown(function() {
586                         config.mouseDownOnSelect = true;
587                 }).mouseup(function() {
588                         config.mouseDownOnSelect = false;
589                 });
590                 
591                 if( options.width > 0 )
592                         element.css("width", options.width);
593                         
594                 needsInit = false;
595         } 
596         
597         function target(event) {
598                 var element = event.target;
599                 while(element && element.tagName != "LI")
600                         element = element.parentNode;
601                 // more fun with IE, sometimes event.target is empty, just ignore it then
602                 if(!element)
603                         return [];
604                 return element;
605         }
606
607         function moveSelect(step) {
608                 listItems.slice(active, active + 1).removeClass(CLASSES.ACTIVE);
609                 movePosition(step);
610         var activeItem = listItems.slice(active, active + 1).addClass(CLASSES.ACTIVE);
611         if(options.scroll) {
612             var offset = 0;
613             listItems.slice(0, active).each(function() {
614                                 offset += this.offsetHeight;
615                         });
616             if((offset + activeItem[0].offsetHeight - list.scrollTop()) > list[0].clientHeight) {
617                 list.scrollTop(offset + activeItem[0].offsetHeight - list.innerHeight());
618             } else if(offset < list.scrollTop()) {
619                 list.scrollTop(offset);
620             }
621         }
622         };
623         
624         function movePosition(step) {
625                 active += step;
626                 if (active < 0) {
627                         active = listItems.size() - 1;
628                 } else if (active >= listItems.size()) {
629                         active = 0;
630                 }
631         }
632         
633         function limitNumberOfItems(available) {
634                 return options.max && options.max < available
635                         ? options.max
636                         : available;
637         }
638         
639         function fillList() {
640                 list.empty();
641                 var max = limitNumberOfItems(data.length);
642                 for (var i=0; i < max; i++) {
643                         if (!data[i])
644                                 continue;
645                         var formatted = options.formatItem(data[i].data, i+1, max, data[i].value, term);
646                         if ( formatted === false )
647                                 continue;
648                         var li = $("<li/>").html( options.highlight(formatted, term) ).addClass(i%2 == 0 ? "ac_even" : "ac_odd").appendTo(list)[0];
649                         $.data(li, "ac_data", data[i]);
650                 }
651                 listItems = list.find("li");
652                 if ( options.selectFirst ) {
653                         listItems.slice(0, 1).addClass(CLASSES.ACTIVE);
654                         active = 0;
655                 }
656                 // apply bgiframe if available
657                 if ( $.fn.bgiframe )
658                         list.bgiframe();
659         }
660         
661         return {
662                 display: function(d, q) {
663                         init();
664                         data = d;
665                         term = q;
666                         fillList();
667                 },
668                 next: function() {
669                         moveSelect(1);
670                 },
671                 prev: function() {
672                         moveSelect(-1);
673                 },
674                 pageUp: function() {
675                         if (active != 0 && active - 8 < 0) {
676                                 moveSelect( -active );
677                         } else {
678                                 moveSelect(-8);
679                         }
680                 },
681                 pageDown: function() {
682                         if (active != listItems.size() - 1 && active + 8 > listItems.size()) {
683                                 moveSelect( listItems.size() - 1 - active );
684                         } else {
685                                 moveSelect(8);
686                         }
687                 },
688                 hide: function() {
689                         element && element.hide();
690                         listItems && listItems.removeClass(CLASSES.ACTIVE);
691                         active = -1;
692                 },
693                 visible : function() {
694                         return element && element.is(":visible");
695                 },
696                 current: function() {
697                         return this.visible() && (listItems.filter("." + CLASSES.ACTIVE)[0] || options.selectFirst && listItems[0]);
698                 },
699                 show: function() {
700                         var offset = $(input).offset();
701                         element.css({
702                                 width: typeof options.width == "string" || options.width > 0 ? options.width : $(input).width(),
703                                 top: offset.top + input.offsetHeight,
704                                 left: offset.left
705                         }).show();
706             if(options.scroll) {
707                 list.scrollTop(0);
708                 list.css({
709                                         maxHeight: options.scrollHeight,
710                                         overflow: 'auto'
711                                 });
712                                 
713                 if($.browser.msie && typeof document.body.style.maxHeight === "undefined") {
714                                         var listHeight = 0;
715                                         listItems.each(function() {
716                                                 listHeight += this.offsetHeight;
717                                         });
718                                         var scrollbarsVisible = listHeight > options.scrollHeight;
719                     list.css('height', scrollbarsVisible ? options.scrollHeight : listHeight );
720                                         if (!scrollbarsVisible) {
721                                                 // IE doesn't recalculate width when scrollbar disappears
722                                                 listItems.width( list.width() - parseInt(listItems.css("padding-left")) - parseInt(listItems.css("padding-right")) );
723                                         }
724                 }
725                 
726             }
727                 },
728                 selected: function() {
729                         var selected = listItems && listItems.filter("." + CLASSES.ACTIVE).removeClass(CLASSES.ACTIVE);
730                         return selected && selected.length && $.data(selected[0], "ac_data");
731                 },
732                 emptyList: function (){
733                         list && list.empty();
734                 },
735                 unbind: function() {
736                         element && element.remove();
737                 }
738         };
739 };
740
741 $.Autocompleter.Selection = function(field, start, end) {
742         if( field.createTextRange ){
743                 var selRange = field.createTextRange();
744                 selRange.collapse(true);
745                 selRange.moveStart("character", start);
746                 selRange.moveEnd("character", end);
747                 selRange.select();
748         } else if( field.setSelectionRange ){
749                 field.setSelectionRange(start, end);
750         } else {
751                 if( field.selectionStart ){
752                         field.selectionStart = start;
753                         field.selectionEnd = end;
754                 }
755         }
756         field.focus();
757 };
758
759 })(jQuery);