/**
	SmartTextBox jQuery plugin
	@version 1.2.0-rc1
	@author Pierre Gayvallet
	@see http://wayofspark.com/projects/smarttextbox
	@copyright (c) 2009-2010 Pierre Gayvallet - GPL license.
*/

(function($){

$.SmartTextBox = {};
var SmartTextBox = $.SmartTextBox;

/**
	SmartTextBox.BaseClass
	Allow pseudo inheritance in javascript objects
*/
SmartTextBox.BaseClass = function(o){};
SmartTextBox.BaseClass.prototype.construct = function(){};
SmartTextBox.BaseClass.extend = function(def) {
  var classDef = function() {
      if (arguments[0] !== SmartTextBox.BaseClass) { this.construct.apply(this, arguments); }
  };
  var proto = new this(SmartTextBox.BaseClass);
  var superClass = this.prototype;
  for(var n in def) {
      var item = def[n];
      proto[n] = item;
  }
  classDef.prototype = proto;
  classDef.extend = this.extend;      
  return classDef;
};

/**
	SmartTextBox.SmartTextBox
	Manager Class for a TextBox
*/
SmartTextBox.SmartTextBox = SmartTextBox.BaseClass.extend({
	_options : {
		// Autocomplete configuration
		autocomplete : true,  	 			// on/off
		minSearchLength : 2,       			// min length to type to receive suggestions
		maxResults : 10,     			    // max number of results to display
		caseSensitive : false,  		    // case sensitive search
		highlight : true,				    // highlight autocomplete search in results
		fullSearch : true,                  // search at start of values or in all the string
		autocompleteValues : [],
        autocompleteUrl : null,
		placeholder : "Please start typing to receive suggestions", // search placeholder text
		// SmartTextBox configuration
		onlyAutocomplete: false,            // can only insert from autocomplete values
        uniqueValues : true,                // values can only be added once  
		submitKeys : [13],					// list of keys to save an input to box
		submitChars : [ ";", ","],			// list of chars to save an input to box
		separator : ";",					// separator for serialize method
		updateOriginal : true,				// update the original input value when change
		// Events handling
		onElementAdd : 		null,
		onElementRemove : 	null,
		onElementFocus : 	null,
		onElementBlur : 	null,
		// Misc
		hideEmptyInputs : true,               // hide empty inputs
        editOnFocus : false,                  // edit box on focus ( click or <- -> )
        editOnDoubleClick : false,            // edit box on doubleClick
		// CSS
		containerClass : "smartTextBox",  // base CSS class for containers
		// Debug configuration
		debug : false						// debug mode - show logs in firebug console
	},
	construct : function(el, o){
		this.options = {};
		var o = o || {};
		$.extend(this.options, this._options);
		$.extend(this.options, o);
		
		var self = this;
		this.original = $(el);
		this.focused = false;
		this.elements = [];
		
		$(this.original).data("SmartTextBox", this);
		this.original.hide();
		
		this.container = $("<div></div>")
			.addClass(this.options.containerClass)
			 .click(function(e){
				if( (self.container.index(e.target)>-1 || self.list.index(e.target)>-1) &&
					(!self.currentFocus || self.currentFocus != self.elements[self.elements.length-1]))
						self.focusLast();												
			 }).insertAfter(this.original);
										 
		this.list = $("<ul></ul>")
			.addClass(this.options.containerClass + "-items")
			.appendTo(this.container);
								  
		$(document).keydown(function(e){
						self.onKeyDown(e)
					})
				   .click(function(e){
						if(!self.currentFocus) return;
						if (e.target.className.indexOf(self.options.containerClass)>-1){
							if(self.container.index(e.target)>-1) return;
							var parent = $(e.target).parents('.' + self.options.containerClass);
							if (parent.index(self.container)>-1) return;
						}
						self.blur();
					});
		
		if(this.options.autocomplete){
			this.autocomplete = new SmartTextBox.AutoComplete(this, this.options);
		}
		
		this.add("input");
		this.loadOriginal();
	},
	setValues : function(values){
		this.removeAll();
		var self = this;
		$.each(values, function(i, el){
			self.addBox(el);
		});
	},
	removeAll : function() {
		var toRemove = [];
		$.each(this.elements, function(){
			if(this.is('box')) {
				toRemove.push(this);
			}
		})
		$.each(toRemove, function(){
			this.remove();
		})
	},
	setAutocompleteValues : function(values){
		if(!this.options.autocomplete) return;
		if(typeof values == "string") {
			this.autocomplete.setValues(values.split(this.options.separator));
		} else {
			this.autocomplete.setValues(values);
		}
	},
	onKeyDown : function(event){
		if(!this.currentFocus) return;
		
		var caret = this.currentFocus.is('input') ? this.currentFocus.getCaret() : null;
		var value = this.currentFocus.getValue();
		var custom = (this.currentFocus.is('input') && this.currentFocus.isSelected());
		
		// bug on FF making elem to loose focus... this fix it
		this.currentFocus.valueContainer.focus();
		
		switch(event.keyCode){
			case 37: // <-
				if( this.currentFocus.is('box') || ((caret == 0 || !value.length) && !custom) ){
					event.preventDefault();
					this.focusRelative('previous');
				}
				break;
			case 39: // ->
				if( this.currentFocus.is('box') || (caret == value.length && !custom)){
					event.preventDefault();
					this.focusRelative('next');
				}
				break;
			case 8: // backspace
				if(this.currentFocus.is('box')){
					this.currentFocus.remove();
					event.preventDefault();
				} else if ((caret == 0 || !value.length) && !custom) {
					this.focusRelative('previous');
					event.preventDefault();
				}		
				break;
			case 27: // escape
				this.blur();
				break;
		}
	},
	create : function(type, value, options){
		var n;
		if(type=="box"){
			n = new SmartTextBox.BoxElement(value, this, options);
		}
		else if(type=="input"){
			n = new SmartTextBox.InputElement(value, this, options);
		}
		else{
			// handle case - do nothing for now.
		}
		return n;
	},
	getElementIndex : function(elem){
		return $(this.elements).index(elem);
	},
	getElement : function(index){
		if((index<0) || (index>this.elements.length-1)) return null;
		return this.elements[index];
	},
	getElementsByType : function(type) {
		var els = [];
		$.each(this.elements, function(){
			if(this.is(type)) {
				els.push(this);
			}
		});
		return els;
	},
	getLastBox : function(){
		for(var i=this.elements.length-1;i>-1;i--){
			if(this.elements[i].is('box')) return this.elements[i];
		}
		return null;
	},
	insertElement : function(element, index){
		var i = (arguments.length > 1) ? index : this.elements.length;
		this.elements.splice(i,0, element);
	},
	add : function(type, value, relTo, relPos){
		var type = type || "box";
		var value = value || "";
		var relPos = relPos || "after"
		var relTo = relTo || this.getLastBox();
		
		var n = this.create(type, value);
		var i = 0;
		if(relTo) i = this.getElementIndex(relTo) + ((relPos=='after') ? 1 : 0);

		this.insertElement(n, i);
		relTo ? n.inject(relTo, relPos) : n.inject();
		return n;
	},
	addBox : function(value, relTo, relPos){
		if(!$.trim(value).length) return;
		return this.add("box", $.trim(value), relTo, relPos);
	},
	removeBox : function(valueOrIndex) {
		var found = null;
		$.each(this.elements, function(){
			if(this.getValue()==valueOrIndex) {
				found = this;
				return false;
			}
		});
		if(!found&&!isNaN(valueOrIndex)) {
			var boxes = this.getElementsByType("box");
			if(boxes.length>valueOrIndex) {
				found = boxes[valueOrIndex];
			}
		}
		if(found) {
			found.remove();
		}
	},
	handleElementEvent : function(type, elem, options){
		switch(type){
			case "add":
				this.onElementAdd(elem, options);
				break;
			case "focus":
				this.onElementFocus(elem, options);
				break;
			case "blur" :
				this.onElementBlur(elem, options);
				break;
			case "remove" :
				this.onElementRemove(elem, options);
				break;
		}
	},
	onElementAdd : function(elem){
		if(this.autocomplete) this.autocomplete.setupElement(elem);
		if(elem.is('box')){
			var i = this.getElementIndex(elem);
			var prev = this.getElement(i-1);
			if((prev && prev.is('box')) || (!prev)){
				var b = this.add("input", "", elem, "before");
				if(this.options.hideEmptyInputs) b.hide();
			}
			if(this.options.updateOriginal) this.updateOriginal();
			if(this.options.onElementAdd) this.options.onElementAdd(elem, this);
		}
	},
	onElementFocus : function(elem){
		if(this.currentFocus==elem) return;
		if(this.currentFocus) this.currentFocus.blur();
		this.currentFocus = elem;
		if(this.currentFocus.is('input')&&this.autocomplete) this.autocomplete.search(this.currentFocus);
		if(this.options.onElementFocus) this.options.onElementFocus(elem, this);
	},
	onElementBlur : function(elem){
		if(this.currentFocus==elem){
			this.currentFocus = null;
			if(this.autocomplete) this.autocomplete.hide();
			if(this.options.onElementBlur) this.options.onElementBlur(elem, this);
		}
	},
	onElementRemove : function(elem){
		var removedIndex = this.getElementIndex(elem);
		this.focusRelative((removedIndex==this.elements.length-1) ? 'previous' : 'next', elem);
		this.elements.splice(removedIndex, 1);
		if(this.getElement(removedIndex)&&this.getElement(removedIndex).is("input")) {
			if((this.getElement(removedIndex+1)&&this.getElement(removedIndex+1).is("input"))||
			   (this.getElement(removedIndex-1)&&this.getElement(removedIndex-1).is("input"))) {
				this.getElement(removedIndex).remove();
			}
		}
		if(this.options.updateOriginal) this.updateOriginal();
		if(this.elements.length==1&&this.elements[0].is("input")) {
			this.elements[0].show();
		}
		if(this.options.onElementRemove) this.options.onElementRemove(elem, this);
	},
	blur: function(){
		$.each(this.elements, function(i, el){
			el.blur();
		});
	},
	focusLast : function(){
		this.elements[this.elements.length-1].focus();
	},
	focusRelative : function(dir, from){
		var b = from || this.currentFocus;
		var idx = $(this.elements).index(b);
		idx = (dir == 'previous') ? idx-1 : idx+1;
		if(idx<0) return; //idx = 0;
		if(idx>=this.elements.length) return; //idx = this.elements.length-1;
		this.elements[idx].focus();
		if(this.elements[idx].is("input")){
			(dir == 'previous') ? this.elements[idx].setCaretToEnd() : this.elements[idx].setCaretToStart();
		}
	},
	getBoxValues : function() {
        var values = [];
		$.each(this.elements, function(i, el){
            if(!this.is('box')) return;
            values.push(this.getValue());
        });
		return values;
	},
	containsValue : function(value) {
		return ($(this.getBoxValues()).index(value)>-1);
	},
	serialize : function(){
		return this.getBoxValues().join(this.options.separator);
	},
	updateOriginal : function(){
		this.original.attr('value', this.serialize());
	},
	loadOriginal : function(){
		this.load(this.original.attr('value'));
	},
	load : function(values){
		if(typeof values == "string") {
			var values = values.split(this.options.separator);
		} 
		this.setValues(values);
	}
});

/** 
	SmartTextBox.AutoComplete
*/
SmartTextBox.AutoComplete = SmartTextBox.BaseClass.extend({
	_options : {
	},
	construct : function(stb, o){
		this.stb = stb;
		this.currentValue = "";
		this.options = {};
		$.extend(this.options, this._options);
		$.extend(this.options, o || {});
		if (this.options.autocompleteUrl) {
			this.ajaxLoad(this.options.autocompleteUrl);
		} else {
			this.setValues(this.options.autocompleteValues);
		}
		var self = this;
		this.baseClass = this.stb.options.containerClass + "-autocomplete";
		
		this.container = $("<div></div>")
							.addClass(this.baseClass)
							.css("width", this.stb.container.width())
							.appendTo(this.stb.container);
		this.placeHolder = $("<div></div>")
								.addClass(this.baseClass + "-placeholder")
								.html(this.options.placeholder)
								.appendTo(this.container)
								.hide();
		this.resultList = $("<div></div>")
								.addClass(this.baseClass + "-results")
								.appendTo(this.container)
								.hide();
	},
	ajaxLoad : function(url) {
	   var self = this;
	   $.get(url, {}, function(response){
	       var values = response.values;
		   self.setValues(values);
	   }, 'json');
	},
	setValues : function(values){
		this.values = values || [];
	},
	getValues : function(){
		return this.values || [];
	},
	setupElement : function(element){
		if(!element.is('input')) return;
		var self = this;
		element.valueContainer
					.keydown(function(e){ self.navigate(e);  })
					.keyup(function(){ self.search(); });
	},
	navigate : function(e){
		switch(e.keyCode){
			case 38: // arrowUp
				(this.currentSelection && this.currentSelection.prev().length) ? this.focusRelative('prev') : this.blur(); 
				break;
			case 40: // arrowDown
				this.currentSelection ? this.focusRelative('next') : this.focusFirst();
				break;
			case 13: // enter
				if(this.currentSelection){
					e.stopPropagation();
					this.addCurrent();
					this.currentElem.focus();
					this.search();
				}
				break;
		};
	},
	search : function(elem){		
		if(elem) this.currentElem = elem;
		if (!this.getValues().length) return;
		window.clearTimeout(this.hidetimer);
		var value = this.currentElem.getValue();
		if(value.length<this.options.minSearchLength) this.showPlaceHolder();
		if (value == this.currentValue) return;
		this.currentValue = value;
		this.hideResultList();
		if(value.length<this.options.minSearchLength) return;
		this.showResults(value);
	},
	showPlaceHolder : function(){
		if(this.placeHolder) this.placeHolder.show();
	},
	hidePlaceHolder : function(){
		if(this.placeHolder) this.placeHolder.hide();
	},
	showResultList : function(){
		this.resultList.show();
	},
	hideResultList : function(){
		this.resultList.hide();
	},
	hide : function(){
		var self = this;
		this.hidetimer = window.setTimeout(function(){
			self.hidePlaceHolder();
			self.hideResultList();
			self.currentValue = "";
		}, 150);
	},
	showResults : function(value){
		var results = this.searchResults(value);
		this.hidePlaceHolder();
		if(!results.length) return;
		this.blur();
		this.resultList.empty().show();
		var self = this;
		results.sort();
		$.each(results, function(i, e){
			self.addResult(e, value);
		});
		this.results = results;
	},
	searchResults : function(value){
		var newvals = [], regexp = new RegExp((this.options.fullSearch ? '' : '\\b') + value, this.caseSensitive ? '' : 'i');
		var values = this.getValues(); 
		for (var i = 0; i < values.length; i++){
			if(this.stb.options.uniqueValues&&this.stb.containsValue(values[i])) continue;
			if (regexp.test(values[i])) {
				newvals.push(values[i]);
			}
			if (newvals.length >= this.options.maxResults) break;
		}
		return newvals;
	},
	addResult : function(result, value){
		var self = this;
		var newSel = $("<div></div>")
		   .addClass(this.baseClass+"-result")
		   .appendTo(this.resultList)
		   .mouseenter(function(e){
				self.focus(this);
		   })
		   .mousedown(function(e){
				e.stopPropagation();
				window.clearTimeout(self.hidetimer);
				self.doAdd = true;
		   })
		   .mouseup(function(e){
				if(self.doAdd){
					self.addCurrent();
					self.currentElem.focus();
					self.search();
					self.doAdd = false;
				}
		   });
		   
        var valueContainer = $("<span>")
		    .addClass(self.baseClass+"-value")
            .html(result)
			.css("display", "none")
			.appendTo(newSel);
	    var displayContainer = $("<span>")
	       .addClass(self.baseClass+"-display")
		   .html(self.formatResult(result, value))
		   .appendTo(newSel);			  
	},
	formatResult : function(result, value) {
		if (this.options.highlight) {
			var lcr = result.toLowerCase();
			var lcv = value.toLowerCase();
			var idx = lcr.indexOf(lcv);
			var formatted = "<span>" + result.substring(0, idx) + "</span>" +
			                "<span class='" + this.baseClass + "-highligh'>" + result.substring(idx, idx + value.length) + "</span>" + 
							"<span>" + result.substring(idx + value.length) + "</span>";
			return formatted;
		} else {
			return result;
		}
	},
	addCurrent : function(){
		var value = $("."+this.baseClass+"-value", this.currentSelection).html(); 
		this.currentElem.setValue(value);
		this.currentElem.saveAsBox();
		this.currentSelection = null;
	},
	focus : function(element){
		this.blur();
		this.currentSelection = $(element).addClass(this.baseClass + '-result-focus');
	},
	focusFirst : function(){
		this.focus(this.resultList.children(":first"));
	},
	focusRelative : function(dir){
		if(dir=='next'){
			this.focus( this.currentSelection.next().length ? this.currentSelection.next() : this.currentSelection);
		}
		else{
			this.focus( this.currentSelection.prev().length ? this.currentSelection.prev() : this.currentSelection);
		}
	},
	blur : function(){
		if(this.currentSelection){
			this.currentSelection.removeClass(this.baseClass + "-result-focus");
			this.currentSelection = null;
		}
	}
});


/**
	SmartTextBox.GrowingInput
*/
SmartTextBox.GrowingInput = SmartTextBox.BaseClass.extend({	
	options: {
		min: 0,
		max: null,
		startWidth: 2,
		correction: 10
	},
	construct : function(el, o){
		var o = o || {}; $.extend(this.options, o);
		var self = this;
		this.element = $(el);
		
		this.calc = $("<span></span>")
						.css({
							'float': 'left',
							'display': 'inline-block',
							'position': 'absolute',
							'left': -1000
						})
						.insertAfter(this.element);

		this.requiredStyles = ['font-size', 'font-family', 'padding-left', 'padding-top', 'padding-bottom', 
							   'padding-right', 'border-left', 'border-right', 'border-top', 'border-bottom', 
							   'word-spacing', 'letter-spacing', 'text-indent', 'text-transform'];
		
		this.copyCat();			
		this.resize();
		var resize = function(){ self.resize(); }
		this.element.click(resize)
					.blur(resize)
					.keyup(resize)
					.keydown(resize)
					.keypress(resize);
	},
	copyCat : function(){
		var self = this;
		$.each(this.requiredStyles, function(i, el){
			self.calc.css(el, self.element.css(el));
		});
	},
	calculate: function(chars){
		this.calc.html(chars);
		var width = this.calc.width();
		return (width ? width : this.options.startWidth) + this.options.correction;
	},
	resize: function(){
		this.lastvalue = this.value;
		this.value = this.element.attr('value');
		var value = this.value;
		
		if((this.options.min || (this.options.min==0)) && this.value.length < this.options.min){
			if((this.lastvalue || (this.lastvalue==0)) && (this.lastvalue.length <= this.options.min)) return;
			for(var i=0; i<this.options.min; i++){ value += "-";}
		}
		if((this.options.max || (this.options.max==0)) && this.value.length > this.options.max){
			if((this.lastvalue || (this.lastvalue==0)) && (this.lastvalue.length >= this.options.max)) return;
			value = this.value.substr(0, this.options.max);
		}
		
		var newWidth = this.calculate(value);
		this.element.width(newWidth);
		return this;
	}
});

/**
 * SmartTextBox.BaseElement - Base, abstract class for SmartTextBox elements
 */
SmartTextBox.BaseElement = SmartTextBox.BaseClass.extend({
	type : "base",
	options : {
	},
	construct : function(value, stb, o){
		var o = o || {}; $.extend(this.options, o);
		this.value = value;
		this.stb = stb;
		this.className = this.stb.options.containerClass + "-elem";
		this.elemClassName = this.stb.options.containerClass + "-" + this.type +"-elem";
		this.focused = false;
		this.init();
	},
	init : function(){
		this.constructElement();
	},
	constructElement : function(){
		this.el = null;
	},
	is : function(t){
		return this.type==t;
	},
	inject : function(elem, pos){
		if(elem) (pos == 'before') ? this.getElement().insertBefore(elem.getElement()) : this.getElement().insertAfter(elem.getElement());
		else this.getElement().prependTo(this.stb.list);
		this.notifyEvent("add");
	},
	remove : function(notify){
		this.blur();
		this.el.remove();
		this.onRemove();
		var n = (typeof notify == 'undefined') ? true : notify;
		if(n) this.notifyEvent("remove");
	},
	focus : function(notify){
		if(this.focused) return this;
		this.show();
		this.el.addClass(this.className + "-focus")
			   .addClass(this.className + "-" + this.type + "-focus");
		this.focused = true;
		
		var n = (typeof notify == 'undefined') ? true : notify;
		if(n) this.notifyEvent('focus');
		this.onFocus();
		
		return this;
	},
	blur : function(notify){
		if(!this.focused) return this;
		this.el.removeClass(this.className + "-focus")
			   .removeClass(this.className + "-" + this.type + "-focus");
		this.focused = false;
		
		var n = (typeof notify == 'undefined') ? true : notify;
		if(n) this.notifyEvent('blur');
		this.onBlur();
		
		return this;
	},
	onMouseIn : function(){
		this.el.addClass(this.className + "-hover")
			   .addClass(this.className + "-" + this.type + "-hover");
	},
	onMouseOut : function(){
		this.el.removeClass(this.className + "-hover")
			   .removeClass(this.className + "-" + this.type + "-hover");
	},
	onFocus : function(){
		return;
	},
	onBlur : function(){
		return;
	},
	onRemove : function(){
		return;
	},
	show : function(notify){
		this.el.show();
		var n = (typeof notify == 'undefined') ? true : notify;
		if(n) this.notifyEvent('show');
		return this;
	},
	hide : function(notify){
		this.el.hide();
		var n = (typeof notify == 'undefined') ? true : notify;
		if(n) this.notifyEvent('hide');
		return this;
	},
	setValue : function(v, notify){
		this.value = v;
		this.valueContainer.text(v);
		var n = (typeof notify == 'undefined') ? true : notify;
		if(n) this.notifyEvent("setValue");
		return this;
	},
	getValue : function(){
		return this.value;
	},
	getElement : function(){
		return this.el;
	},
	notifyEvent : function(type){
		this.stb.handleElementEvent(type, this);
		return this;
	},
	toString : function(){
		return "[BoxElement type='" + this.type + "' value='" + this.getValue() + "']";
	}
});

/**
	SmartTextBox.BoxElement
*/
SmartTextBox.BoxElement = SmartTextBox.BaseElement.extend({
	type : "box",
	constructElement : function(){
		var self = this;
		this.el = $("<li></li>")
			.addClass(this.className)
			.addClass(this.elemClassName)
			.hover(
				function(){ self.onMouseIn();  },
				function(){ self.onMouseOut(); }
			)
			.mousedown(function(event){
				self.focus();
			});

		if(this.stb.options.editOnDoubleClick){
			this.el.dblclick(function(event){
				event.preventDefault();
				self.toInput();
			});
		}
		
		this.valueContainer = $("<span></span>")
			.addClass(this.className+"-valueContainer")
			.appendTo(this.el);
		
		this.removeButton = $("<a></a>")
			.addClass(this.className+"-deleteButton")
			.attr("href", "javascript:;")
			.click(function(e){ self.remove(); e.stopPropagation(); })
			.appendTo(this.el);
			
		this.setValue(this.value);
	},
	onFocus : function(){
		var self = this;
		if(this.stb.options.editOnFocus){
			window.setTimeout(function(){
				self.toInput()
			}, 50);
		}
	},
	onBlur : function(){
		return;
	},
	toInput : function(){
		var v = this.getValue();
		var idx = this.stb.getElementIndex(this);
		this.remove();
		var nextElem = this.stb.getElement(idx-1);
		if(nextElem.is("input") && !$.trim(nextElem.getValue()).length){
			nextElem.setValue(v);
			nextElem.valueContainer.focus();
			nextElem.setCaretToEnd();
		}
	}
});

/**
	SmartTextBox.InputElement
*/
SmartTextBox.InputElement = SmartTextBox.BaseElement.extend({
	type : "input",
	constructElement : function(){
		var self = this;
		this.el = $("<li></li>")
			.addClass(this.className)
			.addClass(this.elemClassName)
			.hover(
				function(){ self.onMouseIn(); },
				function(){ self.onMouseOut(); }
			)
			.click(
				function(){ self.focus(); }
			);
					
		this.valueContainer = $("<input />")
			.addClass(this.elemClassName+"-valueInput")
			.focus( function(event){ event.stopPropagation(); self.focus(); })
			.blur( function(event){ self.blur(); })
			.appendTo(this.el);
		
		this.growingInput = new SmartTextBox.GrowingInput(this.valueContainer);

		$(document).keydown( function(event){ self.onKeyDown(event) } );
		$(document).keypress( function(event){ self.onKeyPress(event) } );
		
		this.setValue(this.value);
	},
	getValue : function(){
		return this.valueContainer.attr('value');
	},
	setValue : function(v){
		this.value = v;
		this.valueContainer.attr("value", v);
		this.growingInput.resize();
		this.notifyEvent("setValue");
		return this;
	},
	getCaret: function(){
		var elem = this.valueContainer[0];
		if(elem.createTextRange) {
			var r = document.selection.createRange().duplicate();		
			r.moveEnd('character', elem.value.length);
			if (r.text === '') return elem.value.length;
			return elem.value.lastIndexOf(r.text);
		} else {
			return elem.selectionStart;
		}
	},
	getCaretEnd: function(){
		var elem = this.valueContainer[0];
		if (elem.createTextRange){
			var r = document.selection.createRange().duplicate();
			r.moveStart('character', -elem.value.length);
			return r.text.length;
		} else {
			return elem.selectionEnd;
		}
	},
	setCaret: function(pos){
		var elem = this.valueContainer[0];
		if(elem.createTextRange){
			elem.focus ();
			var sel = document.selection.createRange();
			sel.moveStart('character', -elem.value.length);
			sel.moveStart('character', pos);
			sel.moveEnd('character', 0);
			sel.select();
		}
		else{
			elem.selectionStart = pos; 
			elem.selectionEnd = pos;
		}
	},
	setCaretToStart : function(){
		this.setCaret(0);
	},
	setCaretToEnd : function(){
		this.setCaret(this.valueContainer.attr("value").length || 0);
	},
	isSelected: function(){
		return this.focused && (this.getCaret() !== this.getCaretEnd());
	},
	saveAsBox : function(){
		var v = this.getValue();
		if(!v) return;
		this.stb.add("box", $.trim(v), this, "before");
		this.setValue("");
	},
	onKeyDown : function(event){
		if(!this.focused) return;
		if($.inArray(event.keyCode, this.stb.options.submitKeys)>-1 &&
		   !this.stb.options.onlyAutocomplete &&
		   !(this.stb.options.uniqueValues&&this.stb.containsValue(this.getValue()))) {
			event.preventDefault();
			this.saveAsBox();
		}
	},
	onKeyPress : function(event){
		if(!this.focused) return;
		if($.inArray(String.fromCharCode(event.charCode || event.keyCode || 0), this.stb.options.submitChars)>-1 &&
		   !this.stb.options.onlyAutocomplete && 
		   !(this.stb.options.uniqueValues&&this.stb.containsValue(this.getValue()))) {
			event.preventDefault();
			this.saveAsBox();
		}
	},
	onFocus : function(){
		this.show();
		this.valueContainer.focus();
		this.growingInput.resize();
	},
	onBlur : function(){
		this.valueContainer.blur();
		if(this.stb.options.hideEmptyInputs && this.el.next().length && !this.getValue()) this.hide();
		if(this.stb.options.editOnFocus){
			this.saveAsBox();
		}
	}
});

// Adds SmartTextBox to jQuery fn functions
$.fn.extend({
	smartTextBox: function(key, value){
		return this.each(function(){
			var Smb = $(this).data("SmartTextBox");
			if(Smb) {
				switch(key){
					case "add":
						Smb.addBox(value);
						break;
					case "remove":
						Smb.removeBox(value);
						break;
					case "load":
						Smb.load(value);
						break;
					case "clear":
						Smb.removeAll();
						break;
					case "autocomplete":
						Smb.setAutocompleteValues(value);
						break;
				}
			} else {
				new $.SmartTextBox.SmartTextBox(this, key);
			}
		});
	}
});

})(jQuery);