/** 
 * jquery.autocomplete.js 
 * Version 3.1 
 * Copyright (c) Dylan Verheul <dylan.verheul@gmail.com> 
 */ 
 (function($) { 
  
 /** 
 * Autocompleter Object 
 * @param {jQuery} $elem jQuery object with one input tag 
 * @param {Object=} options Settings 
 * @constructor 
 */ 
 $.Autocompleter = function($elem, options) { 
  
 /** 
 * Cached data 
 * @type Object 
 * @private 
 */ 
 this.cacheData_ = {}; 
  
 /** 
 * Number of cached data items 
 * @type number 
 * @private 
 */ 
 this.cacheLength_ = 0; 
  
 /** 
 * Class name to mark selected item 
 * @type string 
 * @private 
 */ 
 this.selectClass_ = 'jquery-autocomplete-selected-item'; 
  
 /** 
 * Handler to activation timeout 
 * @type ?number 
 * @private 
 */ 
 this.keyTimeout_ = null; 
  
 /** 
 * Last key pressed in the input field (store for behavior) 
 * @type ?number 
 * @private 
 */ 
 this.lastKeyPressed_ = null; 
  
 /** 
 * Last value processed by the autocompleter 
 * @type ?string 
 * @private 
 */ 
 this.lastProcessedValue_ = null; 
  
 /** 
 * Last value selected by the user 
 * @type ?string 
 * @private 
 */ 
 this.lastSelectedValue_ = null; 
  
 /** 
 * Is this autocompleter active? 
 * @type boolean 
 * @private 
 */ 
 this.active_ = false; 
  
 /** 
 * Is it OK to finish on blur? 
 * @type boolean 
 * @private 
 */ 
 this.finishOnBlur_ = false; 
  
 /** 
 * Assert parameters 
 */ 
 if (!$elem || !($elem instanceof jQuery) || $elem.length !== 1 || $elem.get(0).tagName.toUpperCase() !== 'INPUT') { 
 alert('Invalid parameter for jquery.Autocompleter, jQuery object with one element with INPUT tag expected'); 
 return; 
 } 
  
 /** 
 * Init and sanitize options 
 */ 
 if (typeof options === 'string') { 
 this.options = { url:options }; 
 } else { 
 this.options = options;  
 } 
 this.options.maxCacheLength = parseInt(this.options.maxCacheLength); 
 if (isNaN(this.options.maxCacheLength) || this.options.maxCacheLength < 1) { 
 this.options.maxCacheLength = 1; 
 } 
 this.options.minChars = parseInt(this.options.minChars); 
 if (isNaN(this.options.minChars) || this.options.minChars < 1) { 
 this.options.minChars = 1; 
 } 
  
 /** 
 * Init DOM elements repository 
 */ 
 this.dom = {}; 
  
 /** 
 * Store the input element we're attached to in the repository, add class 
 */ 
 this.dom.$elem = $elem; 
 if (this.options.inputClass) { 
 this.dom.$elem.addClass(this.options.inputClass); 
 } 
  
 /** 
 * Create DOM element to hold results, add class, position according to $elem 
 */ 
 this.dom.$results = $('<div></div>').hide(); 
 if (this.options.resultsClass) { 
 this.dom.$results.addClass(this.options.resultsClass); 
 } 
 var offset = this.dom.$elem.offset(); 
 this.dom.$results.css({ 
 position: 'absolute', 
 top: offset.top + $elem.outerHeight(), 
 left: offset.left 
 }); 
 $('body').append(this.dom.$results); 
  
 /** 
 * Shortcut to self 
 */ 
 var self = this; 
  
 /** 
 * Attach keyboard monitoring to $elem 
 */ 
 $elem.keydown(function(e) { 
 self.lastKeyPressed_ = e.keyCode; 
 switch(self.lastKeyPressed_) { 
  
 case 38: // up 
 e.preventDefault; 
 if (self.active_) { 
 self.focusPrev(); 
 } else { 
 self.activate(); 
 } 
 return false;  
 break; 
  
 case 40: // down 
 e.preventDefault; 
 if (self.active_) { 
 self.focusNext(); 
 } else { 
 self.activate(); 
 } 
 return false;  
 break; 
  
 case 9: // tab 
 case 13: // return 
 if (self.active_) { 
 e.preventDefault; 
 self.selectCurrent(); 
 return false;  
 } 
 break; 
  
 default: 
 self.activate(); 
  
 } 
 }); 
 $elem.blur(function() { 
 if (self.finishOnBlur_) { 
 setTimeout(function() { self.finish(); }, 200);  
 } 
 }); 
  
 } 
  
 $.Autocompleter.prototype.cacheRead = function(filter) { 
 var filterLength, searchLength, search, maxPos, pos; 
 if (this.options.useCache) { 
 filter = String(filter); 
 filterLength = filter.length; 
 if (this.options.matchSubset) { 
 searchLength = 1; 
 } else { 
 searchLength = filterLength; 
 } 
 while (searchLength <= filterLength) { 
 if (this.options.matchInside) { 
 maxPos = filterLength - searchLength; 
 } else { 
 maxPos = 0; 
 } 
 pos = 0; 
 while (pos <= maxPos) { 
 search = filter.substr(0, searchLength); 
 if (this.cacheData_[search] !== undefined) { 
 return this.cacheData_[search]; 
 } 
 pos++; 
 } 
 searchLength++; 
 }  
 } 
 return false; 
 }; 
  
         $.Autocompleter.prototype.cacheWrite = function(filter, data) { 
                 if (this.options.useCache) { 
                         if (this.cacheLength_ >= this.options.maxCacheLength) { 
                                 this.cacheFlush(); 
                         } 
                         filter = String(filter); 
                         if (this.cacheData_[filter] !== undefined) { 
                                 this.cacheLength_++; 
                         } 
                         return this.cacheData_[filter] = data; 
                 } 
                 return false;        
     }; 
  
         $.Autocompleter.prototype.cacheFlush = function() { 
             this.cacheData_ = {}; 
             this.cacheLength_ = 0; 
     }; 
  
         $.Autocompleter.prototype.callHook = function(hook, data) { 
                 var f = this.options[hook]; 
                 if (f && $.isFunction(f)) { 
                         return f(data, this); 
                 } 
                 return false; 
         }; 
          
         $.Autocompleter.prototype.activate = function() { 
             var self = this; 
             var activateNow = function() { 
                 self.activateNow();  
             }; 
                 var delay = parseInt(this.options.delay); 
                 if (isNaN(delay) || delay <= 0) { 
                         delay = 250; 
                 } 
                 if (this.keyTimeout_) { 
                         clearTimeout(this.keyTimeout_); 
                 } 
                 this.keyTimeout_ = setTimeout(activateNow, delay); 
         }; 
  
     $.Autocompleter.prototype.activateNow = function() { 
                 var value = this.dom.$elem.val(); 
                 if (value !== this.lastProcessedValue_ && value !== this.lastSelectedValue_) { 
                         if (value.length >= this.options.minChars) { 
                                 this.active_ = true; 
                                 this.lastProcessedValue_ = value; 
                                 this.fetchData(value);                           
                         }                                                        
                 } 
         };               
          
         $.Autocompleter.prototype.fetchData = function(value) { 
                 if (this.options.data) { 
                         this.filterAndShowResults(this.options.data, value); 
                 } else { 
                     var self = this; 
                         this.fetchRemoteData(value, function(remoteData) { 
                                 self.filterAndShowResults(remoteData, value);                                    
                         }); 
                 }                        
         }; 
  
         $.Autocompleter.prototype.fetchRemoteData = function(filter, callback) { 
                 var data = this.cacheRead(filter); 
                 if (data) { 
                         callback(data);  
                 } else { 
                         try { 
                     var self = this; 
                                 this.dom.$elem.addClass(this.options.loadingClass);                              
                                 $.get(this.makeUrl(filter), function(data) { 
                                         var parsed = self.parseRemoteData(data); 
                                         self.cacheWrite(filter, parsed); 
                                         self.dom.$elem.removeClass(self.options.loadingClass); 
                                         callback(parsed); 
                                 });                              
                         } catch(e) { 
                                 this.dom.$elem.removeClass(this.options.loadingClass); 
                                 callback(false); 
                         }                                
                 } 
         }; 
  
     $.Autocompleter.prototype.setExtraParam = function(name, value) { 
         var index = $.trim(String(name)); 
         if (index) { 
             if (!this.options.extraParams) { 
                 this.options.extraParams = {}; 
             } 
             if (this.options.extraParams[index] !== value) { 
                 this.options.extraParams[index] = value; 
                 this.cacheFlush(); 
             } 
         } 
     }; 
  
         $.Autocompleter.prototype.makeUrl = function(param) { 
             var self = this; 
                 var paramName = this.options.paramName || 'q'; 
                 var url = this.options.url; 
                 var params = $.extend({}, this.options.extraParams); 
                 var urlAppend = []; 
                 params[paramName] = param; 
                 $.each(params, function(index, value) { 
                         urlAppend.push(self.makeUrlParam(index, value)); 
                 }); 
                 url += url.indexOf('?') == -1 ? '?' : '&'; 
                 url += urlAppend.join('&'); 
                 return url; 
         }; 
          
         $.Autocompleter.prototype.makeUrlParam = function(name, value) { 
                 return String(name) + '=' + encodeURIComponent(value); 
         } 
          
         $.Autocompleter.prototype.parseRemoteData = function(remoteData) { 
                 var results = []; 
                 var text = String(remoteData).replace('\r\n', '\n'); 
                 var i, j, data, line, lines = text.split('\n'); 
                 var value; 
                 for (i = 0; i < lines.length; i++) { 
                         line = lines[i].split('|'); 
                         data = []; 
                         for (j = 0; j < line.length; j++) { 
                                 data.push(unescape(line[j])); 
                         } 
                         value = data.shift(); 
                         results.push({ value: unescape(value), data: data }); 
                 } 
                 return results; 
         }; 
          
         $.Autocompleter.prototype.filterAndShowResults = function(results, filter) { 
                 this.showResults(this.filterResults(results, filter), filter); 
         }; 
          
         $.Autocompleter.prototype.filterResults = function(results, filter) { 
                  
                 var filtered = []; 
                 var value, data, i, result, type; 
                 var regex, pattern, attributes = ''; 
                  
                 for (i = 0; i < results.length; i++) { 
                         result = results[i]; 
                         type = typeof result; 
                         if (type === 'string') { 
                                 value = result; 
                                 data = {}; 
                         } else if ($.isArray(result)) { 
                                 value = result.shift(); 
                                 data = result; 
                         } else if (type === 'object') { 
                                 value = result.value; 
                                 data = result.data; 
                         } 
                         value = String(value); 
                         // Condition below means we do NOT do empty results 
                         if (value) { 
                                 if (typeof data !== 'object') { 
                                         data = {}; 
                                 } 
                                 pattern = String(filter); 
                                 if (!this.options.matchInside) { 
                                         pattern = '^' + pattern; 
                                 } 
                                 if (!this.options.matchCase) { 
                                         attributes = 'i'; 
                                 } 
                                 regex = new RegExp(pattern, attributes); 
                                 if (regex.test(value)) { 
                                         filtered.push({ value: value, data: data }); 
                                 }                                        
                         } 
                 } 
                  
                 if (this.options.sortResults) { 
                         return this.sortResults(filtered); 
                 } 
                  
                 return filtered; 
                  
         }; 
  
         $.Autocompleter.prototype.sortResults = function(results) { 
             var self = this; 
                 if ($.isFunction(this.options.sortFunction)) { 
                         results.sort(this.options.sortFunction); 
                 } else { 
                         results.sort(function(a, b) { return self.sortValueAlpha(a, b); }); 
                 } 
                 return results; 
         }; 
          
         $.Autocompleter.prototype.sortValueAlpha = function(a, b) { 
                 a = String(a.value); 
                 b = String(b.value); 
                 if (!this.options.matchCase) { 
                         a = a.toLowerCase(); 
                         b = b.toLowerCase(); 
                 } 
                 if (a > b) { 
                         return 1; 
                 } 
                 if (a < b) { 
                         return -1; 
                 } 
                 return 0; 
         }; 
          
         $.Autocompleter.prototype.showResults = function(results, filter) { 
             var self = this; 
                 var $ul = $('<ul></ul>'); 
                 var i, result, $li, extraWidth, first = false, $first = false; 
                 var numResults = results.length; 
                 for (i = 0; i < numResults; i++) { 
                         result = results[i]; 
                         $li = $('<li>' + this.showResult(result.value, result.data) + '</li>'); 
                         $li.data('value', result.value); 
                         $li.data('data', result.data); 
                         $li.click(function() { 
                                 var $this = $(this); 
                                 self.selectItem($this); 
                         }).mousedown(function() { 
                                 self.finishOnBlur_ = false; 
                         }).mousedown(function() { 
                                 self.finishOnBlur_ = true; 
                         }); 
                         $ul.append($li); 
                         if (first === false) { 
                                 first = String(result.value); 
                                 $first = $li; 
                                 $li.addClass(this.options.firstItemClass); 
                         } 
                         if (i == numResults - 1) { 
                                 $li.addClass(this.options.lastItemClass); 
                         } 
                 } 
                 this.dom.$results.html($ul).show(); 
                 extraWidth = this.dom.$results.outerWidth() - this.dom.$results.width(); 
                 this.dom.$results.width(this.dom.$elem.outerWidth() - extraWidth); 
                 $('li', this.dom.$results).hover( 
                         function() { self.focusItem(this); }, 
                         function() { /* void */ } 
                 ); 
                 if (this.autoFill(first, filter)) { 
                         this.focusItem($first); 
                 } 
         }; 
          
         $.Autocompleter.prototype.showResult = function(value, data) { 
                 if ($.isFunction(this.options.showResult)) { 
                         return this.options.showResult(value, data); 
                 } else { 
                         return value; 
                 }                        
         }; 
          
         $.Autocompleter.prototype.autoFill = function(value, filter) { 
                 var lcValue, lcFilter, valueLength, filterLength; 
                 if (this.options.autoFill && this.lastKeyPressed_ != 8) { 
                         lcValue = String(value).toLowerCase(); 
                         lcFilter = String(filter).toLowerCase(); 
                         valueLength = value.length; 
                         filterLength = filter.length; 
                         if (lcValue.substr(0, filterLength) === lcFilter) { 
                                 this.dom.$elem.val(value); 
                                 this.selectRange(filterLength, valueLength); 
                                 return true; 
                         } 
                 } 
                 return false; 
         }; 
          
         $.Autocompleter.prototype.focusNext = function() { 
                 this.focusMove(+1); 
         }; 
  
         $.Autocompleter.prototype.focusPrev = function() { 
                 this.focusMove(-1); 
         }; 
  
         $.Autocompleter.prototype.focusMove = function(modifier) { 
                 var i, $items = $('li', this.dom.$results); 
                 modifier = parseInt(modifier); 
                 for (var i = 0; i < $items.length; i++) { 
                         if ($($items[i]).hasClass(this.selectClass_)) { 
                                 this.focusItem(i + modifier); 
                                 return; 
                         } 
                 } 
                 this.focusItem(0); 
         }; 
          
         $.Autocompleter.prototype.focusItem = function(item) { 
                 var $item, $items = $('li', this.dom.$results); 
                 if ($items.length) { 
                         $items.removeClass(this.selectClass_).removeClass(this.options.selectClass); 
                         if (typeof item === 'number') { 
                                 item = parseInt(item); 
                                 if (item < 0) { 
                                         item = 0; 
                                 } else if (item >= $items.length) { 
                                         item = $items.length - 1; 
                                 } 
                                 $item = $($items[item]); 
                         } else { 
                                 $item = $(item); 
                         } 
                         if ($item) { 
                                 $item.addClass(this.selectClass_).addClass(this.options.selectClass);                            
                         }                                
                 } 
         }; 
          
         $.Autocompleter.prototype.selectCurrent = function() { 
                 var $item = $('li.' + this.selectClass_, this.dom.$results); 
                 if ($item.length == 1) { 
                         this.selectItem($item);                          
                 } else { 
                         this.finish(); 
                 } 
         }; 
          
         $.Autocompleter.prototype.selectItem = function($li) { 
                 var value = $li.data('value'); 
                 var data = $li.data('data'); 
                 var displayValue = this.displayValue(value, data); 
                 this.lastProcessedValue_ = displayValue; 
                 this.lastSelectedValue_ = displayValue; 
                 this.dom.$elem.val(displayValue).focus(); 
                 this.setCaret(displayValue.length); 
                 this.callHook('onItemSelect', { value: value, data: data }); 
                 this.finish(); 
         }; 
          
         $.Autocompleter.prototype.displayValue = function(value, data) { 
                 if ($.isFunction(this.options.displayValue)) { 
                         return this.options.displayValue(value, data); 
                 } else { 
                         return value; 
                 }                        
         }; 
          
         $.Autocompleter.prototype.finish = function() { 
                 if (this.keyTimeout_) { 
                         clearTimeout(this.keyTimeout_); 
                 } 
                 if (this.dom.$elem.val() !== this.lastSelectedValue_) { 
                         if (this.options.mustMatch) { 
                                 this.dom.$elem.val('');                                  
                         } 
                         this.callHook('onNoMatch'); 
                 } 
                 this.dom.$results.hide(); 
                 this.lastKeyPressed_ = null; 
                 this.lastProcessedValue_ = null; 
                 if (this.active_) { 
                         this.callHook('onFinish'); 
                 } 
                 this.active_ = false;                    
         }; 
          
         $.Autocompleter.prototype.selectRange = function(start, end) { 
                 var input = this.dom.$elem.get(0); 
                 if (input.setSelectionRange) { 
                         input.focus(); 
                         input.setSelectionRange(start, end); 
                 } else if (this.createTextRange) { 
                         var range = this.createTextRange(); 
                         range.collapse(true); 
                         range.moveEnd('character', end); 
                         range.moveStart('character', start); 
                         range.select(); 
                 } 
         }; 
          
         $.Autocompleter.prototype.setCaret = function(pos) { 
                 this.selectRange(pos, pos); 
         }; 
                          
     /** 
      * autocomplete plugin 
      */ 
     $.fn.autocomplete = function(options) { 
  
         if (typeof options === 'string') { 
             options = { url:options }; 
         } 
          
         var o = $.extend({}, $.fn.autocomplete.defaults, options); 
  
                 return this.each(function() { 
                     var $this = $(this); 
                     var ac = new $.Autocompleter($this, o); 
                     $this.data('autocompleter', ac); 
                 }); 
  
         }; 
  
     /** 
      * Default options for autocomplete plugin 
      */ 
         $.fn.autocomplete.defaults = { 
                 minChars: 1, 
                 loadingClass: 'acLoading', 
                 resultsClass: 'acResults', 
                 inputClass: 'acInput', 
                 selectClass: 'acSelect', 
                 mustMatch: false, 
                 matchCase: false, 
                 matchInside: true, 
                 matchSubset: true, 
                 useCache: false, 
                 maxCacheLength: 10, 
                 autoFill: false, 
                 sortResults: true, 
                 sortFunction: false, 
                 onItemSelect: function idAta(item){
				 document.getElementById('semtid').value=item.data;
				 document.getElementById('semtidetay').value=item.data;
				 }, 
                 onNoMatch: false 
         }; 
          
 })(jQuery);