Proyectos de Subversion Moodle

/*

 * Autocomplete - jQuery plugin 1.0.2

 *

 * 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,v 1.1.1.1 2009-03-17 18:35:18 kannan Exp $

 *

 */

;(function($) {

$.fn.extend({

	autocomplete: function(urlOrData, options) {

		var isUrl = typeof urlOrData == "string";

		options = $.extend({}, $.Autocompleter.defaults, {

			url: isUrl ? urlOrData : null,

			data: isUrl ? null : urlOrData,

			delay: isUrl ? $.Autocompleter.defaults.delay : 10,

			max: options && !options.scroll ? 10 : 150

		}, options);

		// if highlight is set to false, replace it with a do-nothing function

		options.highlight = options.highlight || function(value) { return value; };

		// if the formatMatch option is not specified, then use formatItem for backwards compatibility

		options.formatMatch = options.formatMatch || options.formatItem;

		return this.each(function() {

			new $.Autocompleter(this, options);

		});

	},

	result: function(handler) {

		return this.bind("result", handler);

	},

	search: function(handler) {

		return this.trigger("search", [handler]);

	},

	flushCache: function() {

		return this.trigger("flushCache");

	},

	setOptions: function(options){

		return this.trigger("setOptions", [options]);

	},

	unautocomplete: function() {

		return this.trigger("unautocomplete");

	}

});

$.Autocompleter = function(input, options) {

	var KEY = {

		UP: 38,

		DOWN: 40,

		DEL: 46,

		TAB: 9,

		RETURN: 13,

		ESC: 27,

		COMMA: 188,

		PAGEUP: 33,

		PAGEDOWN: 34,

		BACKSPACE: 8

	};

	// Create $ object for input element

	var $input = $(input).attr("autocomplete", "off").addClass(options.inputClass);

	var timeout;

	var previousValue = "";

	var cache = $.Autocompleter.Cache(options);

	var hasFocus = 0;

	var lastKeyPressCode;

	var config = {

		mouseDownOnSelect: false

	};

	var select = $.Autocompleter.Select(options, input, selectCurrent, config);

	var blockSubmit;

	// prevent form submit in opera when selecting with return key

	$.browser.opera && $(input.form).bind("submit.autocomplete", function() {

		if (blockSubmit) {

			blockSubmit = false;

			return false;

		}

	});

	// only opera doesn't trigger keydown multiple times while pressed, others don't work with keypress at all

	$input.bind(($.browser.opera ? "keypress" : "keydown") + ".autocomplete", function(event) {

		// track last key pressed

		lastKeyPressCode = event.keyCode;

		switch(event.keyCode) {

			case KEY.UP:

				event.preventDefault();

				if ( select.visible() ) {

					select.prev();

				} else {

					onChange(0, true);

				}

				break;

			case KEY.DOWN:

				event.preventDefault();

				if ( select.visible() ) {

					select.next();

				} else {

					onChange(0, true);

				}

				break;

			case KEY.PAGEUP:

				event.preventDefault();

				if ( select.visible() ) {

					select.pageUp();

				} else {

					onChange(0, true);

				}

				break;

			case KEY.PAGEDOWN:

				event.preventDefault();

				if ( select.visible() ) {

					select.pageDown();

				} else {

					onChange(0, true);

				}

				break;

			// matches also semicolon

			case options.multiple && $.trim(options.multipleSeparator) == "," && KEY.COMMA:

			case KEY.TAB:

			case KEY.RETURN:

				if( selectCurrent() ) {

					// stop default to prevent a form submit, Opera needs special handling

					event.preventDefault();

					blockSubmit = true;

					return false;

				}

				break;

			case KEY.ESC:

				select.hide();

				break;

			default:

				clearTimeout(timeout);

				timeout = setTimeout(onChange, options.delay);

				break;

		}

	}).focus(function(){

		// track whether the field has focus, we shouldn't process any

		// results if the field no longer has focus

		hasFocus++;

	}).blur(function() {

		hasFocus = 0;

		if (!config.mouseDownOnSelect) {

			hideResults();

		}

	}).click(function() {

		// show select when clicking in a focused field

		if ( hasFocus++ > 1 && !select.visible() ) {

			onChange(0, true);

		}

	}).bind("search", function() {

		// TODO why not just specifying both arguments?

		var fn = (arguments.length > 1) ? arguments[1] : null;

		function findValueCallback(q, data) {

			var result;

			if( data && data.length ) {

				for (var i=0; i < data.length; i++) {

					if( data[i].result.toLowerCase() == q.toLowerCase() ) {

						result = data[i];

						break;

					}

				}

			}

			if( typeof fn == "function" ) fn(result);

			else $input.trigger("result", result && [result.data, result.value]);

		}

		$.each(trimWords($input.val()), function(i, value) {

			request(value, findValueCallback, findValueCallback);

		});

	}).bind("flushCache", function() {

		cache.flush();

	}).bind("setOptions", function() {

		$.extend(options, arguments[1]);

		// if we've updated the data, repopulate

		if ( "data" in arguments[1] )

			cache.populate();

	}).bind("unautocomplete", function() {

		select.unbind();

		$input.unbind();

		$(input.form).unbind(".autocomplete");

	});

	function selectCurrent() {

		var selected = select.selected();

		if( !selected )

			return false;

		var v = selected.result;

		previousValue = v;

		if ( options.multiple ) {

			var words = trimWords($input.val());

			if ( words.length > 1 ) {

				v = words.slice(0, words.length - 1).join( options.multipleSeparator ) + options.multipleSeparator + v;

			}

			v += options.multipleSeparator;

		}

		$input.val(v);

		hideResultsNow();

		$input.trigger("result", [selected.data, selected.value]);

		return true;

	}

	function onChange(crap, skipPrevCheck) {

		if( lastKeyPressCode == KEY.DEL ) {

			select.hide();

			return;

		}

		var currentValue = $input.val();

		if ( !skipPrevCheck && currentValue == previousValue )

			return;

		previousValue = currentValue;

		currentValue = lastWord(currentValue);

		if ( currentValue.length >= options.minChars) {

			$input.addClass(options.loadingClass);

			if (!options.matchCase)

				currentValue = currentValue.toLowerCase();

			request(currentValue, receiveData, hideResultsNow);

		} else {

			stopLoading();

			select.hide();

		}

	};

	function trimWords(value) {

		if ( !value ) {

			return [""];

		}

		var words = value.split( options.multipleSeparator );

		var result = [];

		$.each(words, function(i, value) {

			if ( $.trim(value) )

				result[i] = $.trim(value);

		});

		return result;

	}

	function lastWord(value) {

		if ( !options.multiple )

			return value;

		var words = trimWords(value);

		return words[words.length - 1];

	}

	// fills in the input box w/the first match (assumed to be the best match)

	// q: the term entered

	// sValue: the first matching result

	function autoFill(q, sValue){

		// autofill in the complete box w/the first match as long as the user hasn't entered in more data

		// if the last user key pressed was backspace, don't autofill

		if( options.autoFill && (lastWord($input.val()).toLowerCase() == q.toLowerCase()) && lastKeyPressCode != KEY.BACKSPACE ) {

			// fill in the value (keep the case the user has typed)

			$input.val($input.val() + sValue.substring(lastWord(previousValue).length));

			// select the portion of the value not typed by the user (so the next character will erase)

			$.Autocompleter.Selection(input, previousValue.length, previousValue.length + sValue.length);

		}

	};

	function hideResults() {

		clearTimeout(timeout);

		timeout = setTimeout(hideResultsNow, 200);

	};

	function hideResultsNow() {

		var wasVisible = select.visible();

		select.hide();

		clearTimeout(timeout);

		stopLoading();

		if (options.mustMatch) {

			// call search and run callback

			$input.search(

				function (result){

					// if no value found, clear the input box

					if( !result ) {

						if (options.multiple) {

							var words = trimWords($input.val()).slice(0, -1);

							$input.val( words.join(options.multipleSeparator) + (words.length ? options.multipleSeparator : "") );

						}

						else

							$input.val( "" );

					}

				}

			);

		}

		if (wasVisible)

			// position cursor at end of input field

			$.Autocompleter.Selection(input, input.value.length, input.value.length);

	};

	function receiveData(q, data) {

		if ( data && data.length && hasFocus ) {

			stopLoading();

			select.display(data, q);

			autoFill(q, data[0].value);

			select.show();

		} else {

			hideResultsNow();

		}

	};

	function request(term, success, failure) {

		if (!options.matchCase)

			term = term.toLowerCase();

		var data = cache.load(term);

		// recieve the cached data

		if (data && data.length) {

			success(term, data);

		// if an AJAX url has been supplied, try loading the data now

		} else if( (typeof options.url == "string") && (options.url.length > 0) ){

			var extraParams = {

				timestamp: +new Date()

			};

			$.each(options.extraParams, function(key, param) {

				extraParams[key] = typeof param == "function" ? param() : param;

			});

			$.ajax({

				// try to leverage ajaxQueue plugin to abort previous requests

				mode: "abort",

				// limit abortion to this input

				port: "autocomplete" + input.name,

				dataType: options.dataType,

				url: options.url,

				data: $.extend({

					q: lastWord(term),

					limit: options.max

				}, extraParams),

				success: function(data) {

					var parsed = options.parse && options.parse(data) || parse(data);

					cache.add(term, parsed);

					success(term, parsed);

				}

			});

		} else {

			// if we have a failure, we need to empty the list -- this prevents the the [TAB] key from selecting the last successful match

			select.emptyList();

			failure(term);

		}

	};

	function parse(data) {

		var parsed = [];

		var rows = data.split("\n");

		for (var i=0; i < rows.length; i++) {

			var row = $.trim(rows[i]);

			if (row) {

				row = row.split("|");

				parsed[parsed.length] = {

					data: row,

					value: row[0],

					result: options.formatResult && options.formatResult(row, row[0]) || row[0]

				};

			}

		}

		return parsed;

	};

	function stopLoading() {

		$input.removeClass(options.loadingClass);

	};

};

$.Autocompleter.defaults = {

	inputClass: "ac_input",

	resultsClass: "ac_results",

	loadingClass: "ac_loading",

	minChars: 1,

	delay: 400,

	matchCase: false,

	matchSubset: true,

	matchContains: false,

	cacheLength: 10,

	max: 100,

	mustMatch: false,

	extraParams: {},

	selectFirst: true,

	formatItem: function(row) { return row[0]; },

	formatMatch: null,

	autoFill: false,

	width: 0,

	multiple: false,

	multipleSeparator: ", ",

	highlight: function(value, term) {

		return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + term.replace(/([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");

	},

    scroll: true,

    scrollHeight: 180

};

$.Autocompleter.Cache = function(options) {

	var data = {};

	var length = 0;

	function matchSubset(s, sub) {

		if (!options.matchCase)

			s = s.toLowerCase();

		var i = s.indexOf(sub);

		if (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);