https://www.burghotel-lech.com/(cms)/module/static/default/content…/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,v 1.1 2009-07-06 11:11:42 rm Exp $
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			var width = typeof options.width == "string" || options.width > 0 ? options.width : $(input).width();
702			element.css({
703				width: width,
704				top: offset.top + input.offsetHeight,
705				left: typeof options.overflow == "string" && options.overflow == 'right' ? ( offset.left + $(input).outerWidth() ) - width : offset.left
706			}).show();
707            if(options.scroll) {
708                list.scrollTop(0);
709                list.css({
710					maxHeight: options.scrollHeight,
711					overflow: 'auto'
712				});
713				
714                if($.browser.msie && typeof document.body.style.maxHeight === "undefined") {
715					var listHeight = 0;
716					listItems.each(function() {
717						listHeight += this.offsetHeight;
718					});
719					var scrollbarsVisible = listHeight > options.scrollHeight;
720                    list.css('height', scrollbarsVisible ? options.scrollHeight : listHeight );
721					if (!scrollbarsVisible) {
722						// IE doesn't recalculate width when scrollbar disappears
723						listItems.width( list.width() - parseInt(listItems.css("padding-left")) - parseInt(listItems.css("padding-right")) );
724					}
725                }
726                
727            }
728		},
729		selected: function() {
730			var selected = listItems && listItems.filter("." + CLASSES.ACTIVE).removeClass(CLASSES.ACTIVE);
731			return selected && selected.length && $.data(selected[0], "ac_data");
732		},
733		emptyList: function (){
734			list && list.empty();
735		},
736		unbind: function() {
737			element && element.remove();
738		}
739	};
740};
741
742$.Autocompleter.Selection = function(field, start, end) {
743	if( field.createTextRange ){
744		var selRange = field.createTextRange();
745		selRange.collapse(true);
746		selRange.moveStart("character", start);
747		selRange.moveEnd("character", end);
748		selRange.select();
749	} else if( field.setSelectionRange ){
750		field.setSelectionRange(start, end);
751	} else {
752		if( field.selectionStart ){
753			field.selectionStart = start;
754			field.selectionEnd = end;
755		}
756	}
757	field.focus();
758};
759
760})(jQuery);