var Typecast = {
	InitMask : false,
	InitSuggest : false,
	
	Init : function(){
		this.Parse(document.body.getElementsByTagName("input"));
		this.Behaviours.Mask.Init();
		this.Behaviours.Suggest.Init();
	},
	
	Parse : function(nodes){
		
		for(var i=0; i<nodes.length; i++){
			var node = nodes[i];

			if(node.type=="text" && node.className && node.className.indexOf("TC") != -1){
				if(!node.id) Typecast.Utils.GenerateID(node);
				
				var behaviourName = (node.className.indexOf("[") != -1) ? node.className.substring(node.className.indexOf("TC")+2, node.className.indexOf("[")) : node.className.substring(node.className.indexOf("TC")+2, node.className.length);
				
				Typecast["Init" + behaviourName] = true;
				Typecast.Behaviours[behaviourName].InitField(node);

				node.onfocus = Typecast.Behaviours[behaviourName].Run;
				node.onkeyup = Typecast.Behaviours[behaviourName].KeyHandler;
				node.onkeydown = Typecast.Behaviours[behaviourName].KeyHandler;
				node.onblur = Typecast.Behaviours[behaviourName].Stop;
				node.onmouseup = Typecast.Behaviours[behaviourName].MouseUp;
			}
		}
	},
	
	Behaviours : {
		Mask : {
			Init : function(){
			},
			
			InitField : function(field){
				var fieldData = [];
				if(!eval("Typecast.Config.Data.Mask.Masks." + field.id)){
					fieldData = field.className.substring(field.className.indexOf("[")+1, field.className.indexOf("]"))
				}else{
					fieldData = eval("Typecast.Config.Data.Mask.Masks." + field.id);
				}
				Typecast.Behaviours.Mask.ParseFieldData(field, fieldData);
				field.value = field.DefaultText.join("");
			},
			
			Run : function(e){
				e = (!e) ? window.event : e;
			},
			
			Stop : function(){
			},
			
			KeyHandler : function(e){
				e = (!e) ? window.event : e;
				var mask = Typecast.Behaviours.Mask;
				
				mask.CursorManager.TabbedInSetPosition(this);
				
				//Backspace
				if(e.keyCode==8 && e.type=="keydown" && this.AllowInsert){
					var preBackspaceCursorPosition = Typecast.Behaviours.Mask.CursorManager.GetPosition(this)[0];
					mask.CursorManager.Move(this, -1);
					var postBackspaceCursorPosition = Typecast.Behaviours.Mask.CursorManager.GetPosition(this)[0];
					
					if(preBackspaceCursorPosition != postBackspaceCursorPosition) mask.DataManager.RemoveCharacterByShiftLeft(this);
					mask.Render(this);
				}
				
				//Tab
				if(e.keyCode==9 && e.type=="keydown"){
					return
				}
				
				//Enter
				else if(e.keyCode==13 && e.type=="keyup"){
					return
				}
				
				//Esc
				else if(e.keyCode==27 && e.type=="keyup"){
				}
				
				//End
				else if(e.keyCode==35 && e.type=="keydown"){
					var startIdx = Typecast.Behaviours.Mask.MaskManager.FindNearestMaskCharacter(this, this.DataIndex[this.DataIndex.length-1], 1);
					Typecast.Behaviours.Mask.CursorManager.SetPosition(this, startIdx);
				}

				//Home
				else if(e.keyCode==36 && e.type=="keydown"){
					Typecast.Behaviours.Mask.CursorManager.SetPosition(this, this.MaskIndex[0]);
				}
				
				//Left or Up
				else if(e.keyCode==37 && e.type=="keydown" || e.keyCode==38 && e.type=="keydown"){
					mask.CursorManager.Move(this, -1);
				}
				
				//Right or Down
				else if(e.keyCode==39 && e.type=="keydown" || e.keyCode==40 && e.type=="keydown"){
					mask.CursorManager.Move(this, 1);
				}
				
				//Insert
				else if(e.keyCode==45 && e.type=="keydown" && this.AllowInsert){
					mask.CursorManager.ToggleInsert(this);
				}
				
				//Delete
				else if(e.keyCode==46 && e.type=="keydown"){
					if(this.InsertActive){
						mask.DataManager.RemoveCharacterByShiftLeft(this);
					}else{
						mask.DataManager.RemoveCharacterByOverwrite(this);
					}
					mask.Render(this);
				}
				
				//Numeric Characters
				else if((mask.MaskManager.CurrentMaskCharacter(this) == Typecast.Config.Settings.Mask.MaskCharacters.Numeric) && (e.keyCode>=48 && e.keyCode<=57 && e.type=="keydown" || e.keyCode>=96 && e.keyCode<=105 && e.type=="keydown")){
					var keycode = parseInt(e.keyCode);
					keycode = (keycode>=96 && keycode<=105) ? keycode-48 : keycode;

					mask.DataManager.AddData(this, String.fromCharCode(keycode));
					mask.Render(this);
					mask.CursorManager.Move(this, 1);
				}
				
				//Alpha Characters 65 - 90
				else if((mask.MaskManager.CurrentMaskCharacter(this) == Typecast.Config.Settings.Mask.MaskCharacters.Alpha) && (e.keyCode>=65 && e.keyCode<=90 && e.type=="keydown")){
					mask.DataManager.AddData(this, String.fromCharCode(e.keyCode));
					mask.Render(this);
					mask.CursorManager.Move(this, 1);
				}
				
				//Refresh
				else if(e.keyCode==116 && e.type=="keydown"){
					return
				}
				
				else{
				}
				return false
			},
			
			MouseUp : function(e){
				e = (!e) ? window.event : e;
				var cursorPosition = Typecast.Behaviours.Mask.CursorManager.GetPosition(this)[0];
				var startIdx = Typecast.Behaviours.Mask.MaskManager.FindNearestMaskCharacter(this, cursorPosition, 0);
				Typecast.Behaviours.Mask.CursorManager.SetPosition(this, startIdx);
			},
			
			ParseFieldData : function(field, fieldData){
				fieldData = fieldData.split(Typecast.Config.Settings.Mask.FieldDataSeparator);
				field.Data = [];
				field.DataIndex = [];
				field.DefaultText = (fieldData[1]) ? fieldData[1].split("") : fieldData[0].split(""); //if default text isn't provided use mask
				field.Mask = this.MaskManager.ParseMask(fieldData[0]);
				field.MaskIndex = this.MaskManager.ParseMaskIndex(field.Mask);
				field.CursorPersistance = [];
				field.InsertActive = (this.MaskManager.IsComplexMask(field)) ? false : true;
				field.HighlightChar = (this.MaskManager.IsComplexMask(field)) ? true : false;
				field.AllowInsert = (this.MaskManager.IsComplexMask(field)) ? false : true;
			},
			
			MaskManager : {
				ParseMask : function(mask){
					var arr = [];
					var maskCharacters = Typecast.Config.Settings.Mask.MaskCharacters;
					for(var i=0; i<mask.length; i++){
						for(maskCharacter in maskCharacters){
							char = eval("maskCharacters." + maskCharacter);
							if(mask.substring(i, i+1) == char){
								arr[i] = char;
							}
						}
					}
					return arr
				},
				
				ParseMaskIndex : function(mask){
					var arr = [];
					for(var i=0; i<mask.length; i++){
						if(mask[i] != null) arr[arr.length] = i;
					}
					return arr;
				},
				
				CurrentMaskCharacter : function(field){
					var cursorPosition = Typecast.Behaviours.Mask.CursorManager.GetPosition(field)[0];
					return field.Mask[cursorPosition];
				},
				
				FindNearestMaskCharacter : function(field, cursorPosition, dir){
					var nearestMaskCharacter = (field.DataIndex.length > 0) ? cursorPosition : field.MaskIndex[0];
					
					switch(dir){
						case -1:
							for(var i=field.DataIndex.length-1; i>-1; i--){
								if(field.DataIndex[i] < cursorPosition){
									nearestMaskCharacter = field.DataIndex[i];
									break;
								}
							}
						break;
						case 0:
							for(var i=0; i<field.DataIndex.length; i++){
								if(field.MaskIndex[i] >= cursorPosition){
									nearestMaskCharacter = field.MaskIndex[i];
									break;
								}else{
									nearestMaskCharacter = field.MaskIndex[field.DataIndex.length];
								}
							}							
						break;
						case 1:
							for(var i=0; i<field.DataIndex.length; i++){
								if(field.DataIndex[i] > cursorPosition){
									nearestMaskCharacter = field.DataIndex[i];
									break;
								}
							}
							if(cursorPosition == field.MaskIndex[field.MaskIndex.length-1]) nearestMaskCharacter = cursorPosition + 1;
							else if(cursorPosition == field.DataIndex[field.DataIndex.length-1]) nearestMaskCharacter = field.MaskIndex[field.DataIndex.length];
						break;
					}
					return nearestMaskCharacter
				},
				
				IsComplexMask : function(field){//reports if mask contains mixed mask characters... can't perform "insert" if true
					var isComplex = false;
					var previousMaskChar = "";
					for(var i=0; i<field.MaskIndex.length; i++){
						var currentMaskChar = field.Mask[field.MaskIndex[i]];
						if(currentMaskChar != previousMaskChar && previousMaskChar != ""){
							isComplex = true;
						}
						previousMaskChar = currentMaskChar;
					}
					return isComplex
				}
			},
			
			CursorManager : {
				Move : function(field, dir){
					var cursorPosition = this.GetPosition(field)[0];
					var startIdx = Typecast.Behaviours.Mask.MaskManager.FindNearestMaskCharacter(field, cursorPosition, dir);
					this.SetPosition(field, startIdx);
				},
				GetPosition : function(field){
					var arr = [0,0];
					if(field.selectionStart && field.selectionEnd){
						arr[0] = field.selectionStart;
						arr[1] = field.selectionEnd;
					}
					else if(document.selection){
						var range = field.createTextRange();
						range.setEndPoint("EndToStart", document.selection.createRange());
						arr[0] = range.text.length;
						arr[1] = document.selection.createRange().text.length;
					}
					return arr
				},
				SetPosition : function(field, startIdx){
					var endIdx = startIdx + ((field.HighlightChar) ? 1 : 0);
					Typecast.Utils.PartialSelect(field, startIdx, endIdx);
				},
				TabbedInSetPosition : function(field){
					var mask = Typecast.Behaviours.Mask;
					
					if(mask.MaskManager.CurrentMaskCharacter(field) == undefined){
						var startIdx = null;
						if(field.DataIndex.length > 0 && field.DataIndex.length != field.MaskIndex.length){
							startIdx = field.MaskIndex[field.DataIndex.length];
						}
						else if(field.DataIndex.length == field.MaskIndex.length){
							startIdx = field.DataIndex[field.DataIndex.length-1] + 1;
						}
						else{
							startIdx = field.MaskIndex[0];
						}
						this.SetPosition(field, startIdx);
					}
				},
				PersistPosition : function(field){
					field.CursorPersistance = this.GetPosition(field);
				},
				RestorePosition : function(field){
					this.SetPosition(field, field.CursorPersistance[0]);
				},
				ToggleInsert : function(field){
					if(field.InsertActive){
						field.InsertActive = false;
						field.HighlightChar = true;
					}else{
						field.InsertActive = true;
						field.HighlightChar = false;
					}
					var startIdx = this.GetPosition(field)[0];
					this.SetPosition(field, startIdx);
				}
			},
			
			DataManager : {
				AddData : function(field, char){
					var cursorPosition = Typecast.Behaviours.Mask.CursorManager.GetPosition(field)[0];
					if(field.InsertActive){
						this.InsertCharacter(field, char);
					}else{
						this.OverwriteCharacter(field, char, cursorPosition);
					}
					this.UpdateDataIndex(field);
				},
				InsertCharacter : function(field, char){
					var lastCharacterPosition = field.MaskIndex[field.MaskIndex.length-1];
					var currentCharacterPosition = this.CurrentDataIndexPosition(field);
					for(var i=lastCharacterPosition; i>=currentCharacterPosition; i--){
						field.Data[field.MaskIndex[i+1]] = field.Data[field.MaskIndex[i]];
					}
					field.Data[field.MaskIndex[currentCharacterPosition]] = char;
				},
				OverwriteCharacter : function(field, char, cursorPosition){
					field.Data[cursorPosition] = char;
				},
				RemoveCharacterByOverwrite : function(field){
					var currentCharacterPosition = this.CurrentDataIndexPosition(field);
					if(currentCharacterPosition != null){
						field.Data[field.DataIndex[currentCharacterPosition]] = "";
					}
				},
				RemoveCharacterByShiftLeft : function(field){
					var lastCharacterPosition = field.DataIndex[field.DataIndex.length-1];
					var currentCharacterPosition = this.CurrentDataIndexPosition(field);
					var cursorPosition = Typecast.Behaviours.Mask.CursorManager.GetPosition(field)[0];
					
					if(currentCharacterPosition != null && lastCharacterPosition >= cursorPosition){
						for(var i=currentCharacterPosition; i<=lastCharacterPosition; i++){
							field.Data[field.DataIndex[i]] = field.Data[field.DataIndex[i+1]];
						}
						field.Data.length = field.Data.length-1;
						this.UpdateDataIndex(field);
					}
				},
				UpdateDataIndex : function(field){
					field.DataIndex.length = 0;
					for(var i=0; i<field.Data.length; i++){
						if(field.Data[i] != undefined) field.DataIndex[field.DataIndex.length] = i;
					}
				},
				CurrentDataIndexPosition : function(field){
					var cursorPosition = Typecast.Behaviours.Mask.CursorManager.GetPosition(field)[0];
					var currentDataIndexPosition = null;
					for(var i=0; i<field.MaskIndex.length; i++){
						if(field.MaskIndex[i] == cursorPosition){
							currentDataIndexPosition = i;
							break;
						}
					}
					return currentDataIndexPosition
				}				
			},
			
			Render : function(field){
				this.CursorManager.PersistPosition(field);
				var composite = [];
				for(var i=0; i<field.Mask.length; i++){
					composite[i] = field.Mask[i];
					if(field.DefaultText[i]) composite[i] = field.DefaultText[i];
					if(field.Data[i]) composite[i] = field.Data[i];
				}
				field.value = composite.join("")
				
				this.CursorManager.RestorePosition(field);
			}
		},
		
		Suggest : {
			FieldID : null,
			OutputAreaVisible : false,
			InputValueBackup : null,
			ResultSet : [],
			ResultSetIndex : -1,
			
			Init: function(){
				this.CreateOutputArea();
			},
			
			InitField : function(field){
			},
			
			Run : function(e){
				e = (!e) ? window.event : e;
				var suggest = Typecast.Behaviours.Suggest;
				this.autocomplete = (Typecast.Config.Settings.Suggest.BrowserAutoComplete) ? "on" : "off"; //Reference: http://web.archive.org/web/20031203134351/http://devedge.netscape.com/viewsource/2003/form-autocompletion/
				suggest.FieldID = this.id;
			},
			
			Stop : function(e){
				e = (!e) ? window.event : e;
				var suggest = Typecast.Behaviours.Suggest;
				
				suggest.HideOutputArea();
				suggest.InputValueBackup = null;
				suggest.ResultSet.length = 0;
				suggest.ClearOutputAreaContents();
			},
			
			KeyHandler : function(e){
				e = (!e) ? window.event : e;
				var suggest = Typecast.Behaviours.Suggest;
				
				//Tab
				if(e.keyCode==9 && e.type=="keyup"){
					return
				}
				
				//Enter
				else if(e.keyCode==13 && e.type=="keyup"){
					suggest.InputValueBackup = this.value;
					suggest.HideOutputArea();
					suggest.PartialSelect(this, this.value.length);
					return
				}
				
				//Shift
				else if(e.keyCode==16 && e.type=="keyup"){
					return false
				}
				
				//Esc
				else if(e.keyCode==27 && e.type=="keyup"){
					suggest.RevertInputValue(this);
					suggest.HideOutputArea();
					return
				}
				
				//Up
				else if(e.keyCode==38 && e.type=="keydown"){
					if(suggest.ResultSet.length==0 && this.value.length > 0){
						suggest.LookUp(this);
						suggest.Render(this);
						suggest.InputValueBackup = this.value;
					}
					suggest.MoveResultSetIndex(-1);
					suggest.SuggestInputValue(this);
					//return false
				}
				
				//Down
				else if(e.keyCode==40 && e.type=="keydown"){
					if(suggest.ResultSet.length==0 && this.value.length > 0){
						suggest.LookUp(this);
						suggest.Render(this);
						suggest.InputValueBackup = this.value;
					}
					suggest.MoveResultSetIndex(1);
					suggest.SuggestInputValue(this);
					//return false
				}
				
				//Everything else
				else if(e.type=="keyup" && e.keyCode!=37 && e.keyCode!=38 && e.keyCode!=39 && e.keyCode!=40){
					suggest.LookUp(this);
					suggest.Render(this);
					suggest.InputValueBackup = this.value;
					if(e.keyCode!=8){
						suggest.AutoComplete(this);
					}
				}
			},
			
			MouseUp : function(e){
				e = (!e) ? window.event : e;
				return
			},
			
			LookUp : function(field){
				field = (!field) ? document.getElementById(this.FieldID) : field;
				var dictionaries = Typecast.Config.Data.Suggest.Dictionaries;
				var dictionary = (eval("dictionaries." + field.id)) ? eval("dictionaries." + field.id) : dictionaries.Default;
				dictionary.sort();
				var query = Typecast.Utils.CaseSensitize(field.value);

				this.ResultSet.length = 0;
				
				for(var i=0; i<dictionary.length; i++){
					if(Typecast.Utils.FindIn(dictionary[i], query) > -1){
						this.ResultSet[this.ResultSet.length] = dictionary[i];
					}
				}
			},
			
			Render : function(field){
				field = (!field) ? document.getElementById(this.FieldID) : field;
				if (this.ResultSet.length == 0) {
					this.HideOutputArea();
					return
				}
				
				var outputArea = document.getElementById(Typecast.Config.Settings.Suggest.OutputAreaID);
				this.ClearOutputAreaContents();
				
				var ul = document.createElement("ul");
					ul.id = "Suggestions";

				for(var i=0; i<this.ResultSet.length && i<Typecast.Config.Settings.Suggest.ResultLimit; i++){
					var li = document.createElement("li");
					li.id = i;
					li.onmouseover = this.MouseOver;
					li.onmouseout = this.MouseOut;
					
					var result = this.BuildHighlightedResult(this.ResultSet[i], field.value);
					
					li.appendChild(result);
					ul.appendChild(li);
				}
				
				outputArea.appendChild(ul);
				this.ShowOutputArea(field);
			},
			
			SuggestInputValue : function(field){
				if(this.ResultSetIndex == -1) return
				field = (!field) ? document.getElementById(this.FieldID) : field;
				
				if(this.ResultSetIndex>=0){	//arrow
					field.value = this.ResultSet[this.ResultSetIndex];
				}else{ //typing
					field.value += this.ResultSet[this.ResultSetIndex].substring(field.value.length, this.ResultSet[this.ResultSetIndex].length);
				}
			},
			
			AutoComplete : function(field){
				if(!Typecast.Config.Settings.Suggest.MatchFromStart) return;
				field = (!field) ? document.getElementById(this.FieldID) : field;
				var startIdx = field.value.length;
				
				if(this.ResultSet.length > 0){
					field.value += this.ResultSet[0].substring(field.value.length, this.ResultSet[0].length);
					this.PartialSelect(field, startIdx);
				}
			},
			
			PartialSelect : function(field, startIdx){
				if(!Typecast.Config.Settings.Suggest.MatchFromStart) return;
				field = (!field) ? document.getElementById(this.FieldID) : field;

				Typecast.Utils.PartialSelect(field, startIdx, field.value.length);
			},
			
			RevertInputValue : function(field){
				field = (!field) ? document.getElementById(this.FieldID) : field;
				field.value = (field.value == this.InputValueBackup) ? "" : this.InputValueBackup;
			},
			
			MoveResultSetIndex : function(dir){
				if(!this.OutputAreaVisible) return;
				if(this.ResultSet.length == 0) return;
				if(this.ResultSetIndex == -1 && dir == -1) return //Lower Bound Test
				if(this.ResultSetIndex == this.ResultSet.length-1 && dir == 1) return //Upper Bound Test
				if(this.ResultSetIndex == Typecast.Config.Settings.Suggest.ResultLimit-1 && dir == 1) return //User Defined Upper Bound Test
				
				var outputArea = document.getElementById(Typecast.Config.Settings.Suggest.OutputAreaID);
				
				if(outputArea && this.ResultSetIndex != -1) outputArea.childNodes[0].childNodes[this.ResultSetIndex].className = "";
				
				this.ResultSetIndex += dir;
				
				if(outputArea && this.ResultSetIndex == -1) this.RevertInputValue();
				if(outputArea && this.ResultSetIndex != -1) outputArea.childNodes[0].childNodes[this.ResultSetIndex].className = "selected";
			},
			
			MouseOver : function(e){
				e = (!e) ? window.event : e;
				this.className = "selected";
				Typecast.Behaviours.Suggest.ResultSetIndex = parseInt(this.id);
				Typecast.Behaviours.Suggest.SuggestInputValue();
			},
			
			MouseOut : function(e){
				e = (!e) ? window.event : e;
				this.className = "";
			},
			
			CreateOutputArea : function(){
				var sid = Typecast.Config.Settings.Suggest.OutputAreaID;
				var outputAreaExists = (document.getElementById(sid)) ? true : false;
				
				if(!outputAreaExists){
					var outputArea = document.createElement("div");
					outputArea.id = sid;
				}else{
					var outputArea = document.getElementById(sid);
				}
				outputArea.style.display = "none";
				outputArea.style.position = "absolute";
				this.OutputAreaVisible = false;
				document.body.appendChild(outputArea);
			},
			
			ShowOutputArea : function(field){
				field = (!field) ? document.getElementById(this.FieldID) : field;
				if(this.OutputAreaVisible) return
				if(field.value == "") return
				
				var outputArea = document.getElementById(Typecast.Config.Settings.Suggest.OutputAreaID);
				var xy = Typecast.Utils.GetXY(field);
				
				if(outputArea){
					if(Typecast.Config.Settings.Suggest.IEForceRelative && document.all) outputArea.parentNode.style.position = "relative";
					outputArea.style.display = "block";
					outputArea.style.left = xy[0] + "px";
					outputArea.style.top = xy[1] + field.offsetHeight + "px";
					outputArea.style.width = field.offsetWidth + "px";
				}else{
					Typecast.Behaviours.Suggest.LookUp(this);
					Typecast.Behaviours.Suggest.Render(this);
				}
				this.OutputAreaVisible = true;
			},
			
			HideOutputArea : function(){
				if(!this.OutputAreaVisible) return
				this.ResultSetIndex = -1;
				document.getElementById(Typecast.Config.Settings.Suggest.OutputAreaID).style.display = "none";
				this.OutputAreaVisible = false;
			},
			
			ClearOutputAreaContents : function(){
				var sid = Typecast.Config.Settings.Suggest.OutputAreaID;
				var outputArea = document.getElementById(sid);
				
				if(outputArea && outputArea.childNodes.length > 0) outputArea.removeChild(outputArea.childNodes[0]);
			},
			
			BuildHighlightedResult : function(str, fragment){
				var csStr = Typecast.Utils.CaseSensitize(str);
				var csFragment = Typecast.Utils.CaseSensitize(fragment);
				var span = document.createElement("span");
				var lhs = document.createTextNode(str.substring(0, csStr.indexOf(csFragment)));
				var strong = document.createElement("strong");
				var highlight = document.createTextNode(str.substring(csStr.indexOf(csFragment), csStr.indexOf(csFragment) + csFragment.length));
				var rhs = document.createTextNode(str.substring(csStr.indexOf(csFragment) + csFragment.length, csStr.length));
				
				strong.appendChild(highlight);
				span.appendChild(lhs);
				span.appendChild(strong);
				span.appendChild(rhs);
				
				return span
			}
		}
	},
	
	Utils : {
		FindClass : function(findClass, parentClass){
			parentClass = (!parentClass) ? 'Typecast' : parentClass;
			for(var i in eval(parentClass)){
				if(i == findClass){
					return i;
				}else{
					var found = Typecast.Utils.FindClass(findClass, parentClass + "." + i);
					// if something was found send it back up the tree
					// if the parentClass contains no dots it's the rootClass and should also be tacked on and returned
					if(found) return (parentClass.indexOf(".") == -1) ? parentClass + "." + i + "." + found : i + "." + found;
				}
			}
		},
		
		GenerateID : function(obj){
			dt = new Date();
			obj.id = "GenID" + dt.getTime();
			return obj
		},
		
		FindIn : function(str, fragment){
			if(!fragment || fragment.length <= 0) return -1
			var csStrIdx = this.CaseSensitize(str).indexOf(fragment);
			var matchFromStart = Typecast.Config.Settings.Suggest.MatchFromStart;
			
			if(matchFromStart && csStrIdx==0 ) {return csStrIdx}
			else if(!matchFromStart && csStrIdx!=-1) {return csStrIdx}
			else {return -1}
		},
		
		CaseSensitize : function(str){
			var isCaseSensitive = Typecast.Config.Settings.Suggest.isCaseSensitive;
			return (isCaseSensitive) ? str : str.toLowerCase();
		},
		
		GetXY : function(obj){
			var x=0;
			var y=0;
			while(obj.offsetParent){
				x+=obj.offsetLeft;
				y+=obj.offsetTop;
				obj = obj.offsetParent;
			}
			return [x,y]
		},
		
		PartialSelect : function(field, startIdx, endIdx){
			if(field.createTextRange){
				var fld= field.createTextRange();
				fld.moveStart("character", startIdx);
				fld.moveEnd("character", endIdx - field.value.length);
				fld.select();
			}else if(field.setSelectionRange){
				field.setSelectionRange(startIdx, endIdx);
			}
		}		
	}
}