var DDRegister=function() {
	var inputs=$$('select.DropDown');
	for(i=0; i<inputs.length; ++i) {
		new DropDown(inputs[i]);
	}
};

// params is a structure with the following keys:
// *id - string with unique id of the menu
// *ULbody - id or HTML node of the UL element which contains menu options
// src - url to Effi DataList method which returns list of menu options
// onSelect(index, isSelected) - callback function to be invoked when menu
//		item is (un)selected. Integer index is menu item index,
//		Boolean isSelected - specifies whether menu item is selected or unselected
// onClose() - callback function to be invoked before menu hiding
// value - array of selected items. The same as in SetValue params
var ContextMenu = Class.create({
initialize: function(params) {
	this.id=params.id;
	this.optionUL=$(params.ULbody);
	this.items = new Array();
	this.selected = params.onSelect;
	this.closed = params.onClose;

	this.liMouseOverCallback=this.onLIMouseOver.bind(this);
	this.ulMouseOutCallback=this.onULMouseOut.bind(this);
	this.ulMouseUpCallback=this.onULMouseUp.bind(this);
	this.ulMouseDownCallback=this.onULMouseDown.bind(this);
	this.keyDownCallback=this.onKeyDown.bind(this);
	this.stopEventCallback=(function(evt){evt.stop();});

	if(params.src) {
		var thisobj = this;
		new ServerCall(params.src, undefined, {
			onSuccess: this.setupDynamicLI,
			onException: function(){
				thisobj.setWidth(40);
				thisobj.element.setStyle({"visibility": "inherit"});
			},
			thisObject: this
		});
	}
	else {
		this.setupStaticLI();
	}
	if(params.value instanceof Array) this.SetValue(params.value);

	this.optionUL.observe('mousedown', this.ulMouseDownCallback);
	this.optionUL.observe('mouseup', this.ulMouseUpCallback);
	this.optionUL.observe('contextmenu', this.stopEventCallback);
	this.optionUL.observe('mouseout', this.ulMouseOutCallback);
	this.optionUL.observe('keydown', this.keyDownCallback);
},
Show: function(x, y) {
// (x, y) is absolute viewport coordinates of left-top point of the UL
	var bSetPos=false;
	var positionedParent=null;
	if(typeof(x)!='undefined' && typeof(y)!='undefined' && x!==null && y!==null) {
		positionedParent=this.optionUL.getOffsetParent();
		var pvo=Element.cumulativeOffset(positionedParent);
		y-=pvo.top;
		x-=pvo.left;
		this.optionUL.setStyle({position: 'absolute', visibility: 'hidden', left: '-1000px', top: '-1000px'});
		bSetPos=true;
	}
	this.optionUL.setStyle({display: '', visibility: '', position: 'absolute', display: 'block'});
	if(Prototype.Browser.IE && !this.rendered) {
		var objWidth=this.optionUL.offsetWidth-30;
		for(var i=0; i<this.items.length; ++i) {
			this.items[i].setStyle({width: objWidth});
		}
		this.rendered=true;
	}
	if (bSetPos) {
		var dx=positionedParent.offsetWidth-(x+this.optionUL.offsetWidth);
		if (dx<0) x+=dx; // horizontal correction
		this.optionUL.setStyle({left: x+'px', top: y+'px'});
	}
	this.optionUL.tabIndex=1;
	this.optionUL.focus();
},
Hide: function() {
	this.optionUL.setStyle({display: 'none'});
},

setupDynamicLI: function(oPacket) {
	var data = oPacket.Data();
	if (!data.length > 0) return;
	var header = data[0];
	var key = this.optionUL.readAttribute('key-column');
	if(!key) key = this.optionUL.readAttribute('key');
	var show = this.optionUL.readAttribute('show');
	var keyIdx = 0;
	var showIdx = 1;
	for(var c = 0; c < header.length; ++c) {
		if (header[c] == key) keyIdx = c;
		if (header[c] == show) showIdx = c;
	}

	this.optionUL.innerHTML='';
	this.items.length = 0;
	for(var i = 1; i < data.length; ++i) {
		var li=new Element('li');
		li.innerHTML='<span class="ContextMenuStatus"> </span>'+data[i][showIdx];
		this.items.push(li);
		this.optionUL.appendChild(li);
		li.writeAttribute( 'value', String(data[i][keyIdx].Value()) );
		li.writeAttribute('index', i - 1);
		li.observe('mouseover', this.liMouseOverCallback);
	}
},

setupStaticLI: function() {
	var thisobj = this;
	$A(this.optionUL.childNodes).each(function(element){
		if (element.nodeName.toLowerCase() != "li") return;
		element = $(element);
		var myIndex = thisobj.items.length;
		thisobj.items.push(element);
		element.writeAttribute('index', myIndex);
		element.observe('mouseover', thisobj.liMouseOverCallback);
	});
},
onKeyDown: function(evt) {
	var key=$(evt).which || evt.keyCode;
	var index=this.highlightIndex;
	if(key==38) { // up arrow
		if(index>0) --index;
		else index=this.items.length-1;
		this.highlight(index);
	}
	else if(key==40) { // down arrow
		if(index<this.items.length-1) ++index;
		else index=0;
		this.highlight(index);
	}
	else if(key==32) { // space
		this.selectItem(index);
	}
	else if(key==13) { // enter
		this.selectItem(index);
		if(!evt.ctrlKey) {
			if(this.closed) this.closed();
			this.Hide();
		}
	}
	else if(key==27) { // escape
		if(this.closed) this.closed();
		this.Hide();
	}
	else return;
	evt.stop();
},
onULMouseDown: function(event) {
	event.stop();
},
onULMouseUp: function(event) {
	var li=Event.element(event);
	if(li.nodeName.toLowerCase() != "li") li=li.up('li');
	if(li==undefined) return;
	this.selectItem(parseInt(li.readAttribute('index')));

	if(!(event.ctrlKey || event.isRightClick())) {
		if(this.closed) this.closed();
		this.Hide();
	}
},
selectItem: function(index) {
	if(!(index>=0 && index<this.items.length)) return;
	var li=this.items[index];

	if(li.hasClassName('Selected')) {
		li.removeClassName('Selected');
		if(this.selected) this.selected(index, false);
	}
	else {
		li.addClassName('Selected');
		if(this.selected) this.selected(index, true);
	}
},
onLIMouseOver: function(event) {
	var element = Event.element(event);
	if(element.nodeName.toLowerCase() != "li") return;
	this.highlight(parseInt(element.readAttribute("index")));
},
onULMouseOut: function(event) {
	if(Event.element(event).up('ul')==this.optionUL) return;
	this.highlight();
},
highlight: function(index) {
	if(this.highlightIndex!=undefined && this.highlightIndex != index) {
		this.items[this.highlightIndex].removeClassName('Active');
		this.highlightIndex=undefined;
	}
	if (!this.items[index]) return;
	this.items[index].addClassName('Active');
	this.highlightIndex = index;
},
SetValue: function(value) {
	if(!(value instanceof Array)) return;
	for(var vi=0; vi<value.length; ++vi) {
		for(var li=0; li<this.items.length; ++li) {
			if(value[vi]==this.items[li].readAttribute('value')) {
				this.items[li].addClassName('Selected');
			}
		}
	}
},
Value: function() {
	var res=[];
	var index=0;
	for(var i=0; i<this.items.length; ++i) {
		if(!this.items[i].hasClassName('Selected')) continue;
		res[index]=this.items[i].readAttribute('value');
		++index;
	}
	return res;
},
ID: function(){ return this.id; }
});

var MenuButton = Class.create({
initialize: function(element) {
	this.element = $(element);
	this.optionUL = $(element+"_UL");
	this.element.JSControl = this;
	this.ID_ = this.element.readAttribute('id');
	this.alignTo=this.optionUL.getAttribute('align-to');
	this.shiftX=parseInt(this.optionUL.getAttribute('shift-x'), 10);
	this.shiftY=parseInt(this.optionUL.getAttribute('shift-y'), 10);

	this.buttonMouseDownCallback=this.OnButtonMouseDown.bind(this);
	this.documentMouseDownCallback=this.OnDocumentMouseDown.bind(this);

	this.menuObj=new ContextMenu({
		id: this.ID(),
		ULbody: this.optionUL,
		onSelect: this.OnChange.bind(this),
		onClose: undefined,
		src: this.optionUL.readAttribute('src')
	});

	this.element.observe('mousedown', this.buttonMouseDownCallback);
},
OnButtonMouseDown: function(event) {
	var element = Event.element(event);
	if (this.alignTo=='bottom') {
		var y=getAbsoluteOffset(this.element, "offsetTop")+this.element.offsetHeight;
		if (!isNaN(this.shiftY)) y+=this.shiftY;
		var x=getAbsoluteOffset(this.element, "offsetLeft");
		if (!isNaN(this.shiftX)) x+=this.shiftX;
		this.menuObj.Show(x, y);
	} else {
		this.menuObj.Show(event.pointerX(), event.pointerY());
	}
	event.stop();
	Event.observe(document, "mousedown", this.documentMouseDownCallback);
},
OnDocumentMouseDown: function(event) {
	this.menuObj.Hide();
	Event.stopObserving(document, "mousedown", this.documentMouseDownCallback);
},
OnChange: function(evt) {
	new AEvent("CHANGE", {}, this);
	new AEvent("CLICK", {}, this);
},
SetValue: function(value) {
	this.menuObj.SetValue(value);
},
Value: function() {
	return this.menuObj.Value();
},
ID: function() { return this.ID_; }
});


var DropDown = Class.create(JSControl, {
	initialize: function($super, element){
		$super(element);
		this.valcont_ = $(this.ID() + "_VALUE");
		this.list_ = $(this.ID() + "_LIST");

		var first = this.first_item();
		if (first){
			this.select(first);
			this.oninit();
		}

		var src = this.element.getAttribute("src");
		if (src) this.SetAttribute("src", src);

		var vis = this.element.getAttribute("visibility");
		if (["yes", "ro", "vo", "link", "no"].indexOf(vis) === -1) vis = "yes";
		this.SetAttribute("visibility", vis);
	},

	first_item: function(){
		for (var child = this.list_.firstChild; child; child = child.nextSibling)
			if (child.nodeType == Node.ELEMENT_NODE) return child;
		return null;
	},

	last_item: function(){
		for (var child = this.list_.lastChild; child; child = child.previousSibling)
			if (child.nodeType == Node.ELEMENT_NODE) return child;
		return null;
	},

	next_item: function(elem){
		if (!elem) return null;
		for (var sibling = elem.nextSibling; sibling; sibling = sibling.nextSibling)
			if (sibling.nodeType == Node.ELEMENT_NODE) return sibling;
		return null;
	},

	prev_item: function(elem){
		if (!elem) return null;
		for (var sibling = elem.previousSibling; sibling; sibling = sibling.previousSibling)
			if (sibling.nodeType == Node.ELEMENT_NODE) return sibling;
		return null;
	},

	has_default_item: function(){
		var lbl=this.element.getAttribute("def-label");
		return lbl!=null && lbl!==undefined;
	},

	add_default_item: function(){
		var def_lbl = this.element.getAttribute("def-label");
		if (def_lbl !== null){
			var li = this.add_item({"label": def_lbl});
			var def_val = this.element.getAttribute("def-value");
			if (def_val) {
				li.setAttribute("serialized-value", def_val);
//				li.setAttribute("item-value", def_val);
			}
		}
	},

	init_dynamic: function(apacket){
		if (!this.dynamic_){
			LogL(this.ID() + ": not a dynamic control anymore");
			return;
		}
		var data = apacket.Data(); if (data.length == 0) return;
		var val_colnam = this.element.getAttribute("key-column") || this.element.getAttribute("key") || "";
		var lbl_colnam = this.element.getAttribute("show") || "";
		var header = data.shift();
		var val_col = 0;
		var lbl_col = 1;
		for (var iii = 0; iii < header.length; ++iii){
			if (header[iii] == val_colnam) val_col = iii;
			if (header[iii] == lbl_colnam) lbl_col = iii;
		}
		var oldval = this.Value();
		Element.clear(this.list_);
		this.add_default_item();
		data.each(function(row){
			this.add_item({"label": row[lbl_col], "serialized-value": URLSerialize(row[val_col])});
		}, this);
		this.loaded_ = true;
		if (this.value_) delete this.value_;
		Element.setStyle(this.element, {"visibility": ""});
		if (!this.is_null(oldval)) this.SetValue(oldval);
		if (this.is_null(this.Value())){
			this.select(this.first_item());
			if (this.has_default_item()) this.oninit();
			else this.onchange();
		}
	},

	is_null: function(val){
		if (val instanceof String) return !val.length;
		if (val instanceof Optional) return arguments.callee(val.Value());
		return !val;
		// infinite recursion was here when val is an instance of String (it has self-referenced .Value() function)
		// return !val || typeof val.Value == "function" && arguments.callee(val.Value());
	},

	add_item: function(attrs){
		var li = new Element("li");
		if (typeof attrs["label"] != "undefined"){
			li.appendChild(document.createTextNode(attrs["label"] || ""));
			delete attrs["label"];
		}
		for (var nam in attrs) li.setAttribute(nam, attrs[nam]);
		this.list_.appendChild(li);
		return li;
	},

	refresh: function(src){
		Element.clear(this.list_);
		this.assign_value(null);
		this.dynamic_ = true;
		this.loaded_ = false;
		if (typeof src != "undefined") this.src_ = src = String(src);
		else src = this.src_;
		if (this.server_call_) this.server_call_.Abort();
		this.server_call_ = new ServerCall(src, null, {
			"onSuccess": this.init_dynamic,
			"onException": function(sMessage, nErrorCode) {
				// it's better than silent error suppression
				LogE("DropDown refresh error: "+sMessage+" Cannot load source '"+src+"'. ");
				alert("`Error: `"+sMessage);
			},
			"thisObject": this
		});
	},

	Attribute: function(name) {
		// visibility is reqired for correct work of dependsOn feature
		switch(name) {
			case "visibility": return (typeof(this.visibility_)=="undefined" ? "yes" : this.visibility_);
			default: return this.element.getAttribute(name);
		}
	},

	SetAttribute: function($super, nam, val){
		switch(nam){
			case "src":
				this.element.setAttribute(nam, val);
				if (this.src_ != val) this.refresh(val);
				break;
			case "disabled":
				return this.SetAttribute("visibility", ["disabled", "yes"].include(val) ? "ro" : "yes");
			case "visibility":
				if (!["yes", "ro", "vo", "link", "no"].include(val)) break;
				this.element.setAttribute(nam, val);
				if (this.visibility_ === val) break;
				if ("yes" == val){
					this.set_handlers();
					if (this.tabbase_) this.element.tabIndex = this.tabbase_;
				}else{
					this.setClosed();
					if ("yes" === this.visibility_){
						this.unset_handlers();
						this.element.tabIndex = -1;
					}
				}
				this.visibility_ = val;
				break;
			case "max-width":
				if (!["em", "ex", "px", "in", "cm", "mm", "pt", "pc"].collect(val.endsWith, val).any()) val += "px";
				Element.setStyle(this.element, {"maxWidth": val});
				break;
			case "key-column":
			case "key":
			case "show":
			case "key-type":
			case "def-label":
			case "def-value":
				this.element.setAttribute(nam, val);
				break;
			default: $super(nam, val);
		}
	},

	highlighted_classname_: "Active",
	highlight: function(elem){
		if (this.highlighted_ == elem) return;
		if (this.highlighted_){
			Element.removeClassName(this.highlighted_, this.highlighted_classname_);
			this.highlighted_ = null;
		}
		if (elem){
			Element.addClassName(elem, this.highlighted_classname_);
			if (elem.parentNode == this.list_ && this.isopen_) Element.scrollContainerTo(this.list_, elem);
			this.highlighted_ = elem;
		}
	},

	assign_value: function(elem){
		if (!this.valcont_) return;
		Element.clear(this.valcont_);
		var persistent_attrs = ["class", "id", "htmlid", "localid"];
		$A(this.valcont_.attributes).each(function(attr){
			if (!persistent_attrs.include(attr.name)) this.valcont_.removeAttribute(attr.name);
		}, this);
		if (!elem) return;
		for (var child = elem.firstChild; child; child = child.nextSibling)
			this.valcont_.appendChild(child.cloneNode(true));
		$A(elem.attributes).each(function(attr){
			if (!persistent_attrs.include(attr.name)) this.valcont_.setAttribute(attr.name, attr.value);
		}, this);
	},

	select: function(elem){
		this.highlight(elem);
		this.assign_value(elem);
	},

	item_value: function(elem){
		if (!elem) return optional();
		var val = elem.getAttribute("item-value");
		if (val !== null){
			switch (this.element.getAttribute("key-type")){
				case "int": return optional(int(val));
				case "int64": return optional(int64(val));
				case "string":
				default: return optional(val);
			}
		}
		val = elem.getAttribute("serialized-value");
		if (val !== null) {
			var rv=URLRestore(val);
			if(rv.IsNull) return rv;
			else return optional(rv);
		}
		return optional();
	},

	Value: function(){
		if (this.dynamic_ && !this.loaded_) return this.value_ || optional();
		return this.item_value(this.valcont_);
	},

	unwrap_optional: function(val){
		if (!val) return val;
		else if (val instanceof Optional) return arguments.callee(val.Value());
		else return val;
	},

	SetValue: function(val){
		if (!this.wm_refresh_handled_){
			var awnd = AControl.GetParentWindow(this.element);
			awnd.Subscribe("WM_REFRESH", this.WM_REFRESH, this);
			this.wm_refresh_handled_ = true;
		}

		if (val && (typeof val.Selected == "object" || typeof val.key == "object" && typeof val.show == "object")){
			if (this.dynamic_){
				this.element.removeAttribute("src");
				if (this.server_call_) this.server_call_.Abort();
				delete this.server_call_;
				this.dynamic_ = false;
				delete this.loaded_;
			}
			Element.clear(this.list_);
			this.add_default_item();
			if (val.key && val.show)
				for (var iii = 0; iii < val.key.length; ++iii)
					this.add_item({"label": val.show[iii], "serialized-value": URLSerialize(val.key[iii])});
			this.SetValue(val.Selected);
			Element.setStyle(this.element, {"visibility": ""});
			this.oninit();
			return;
		}

		if (this.dynamic_ && !this.loaded_){
			this.value_ = val;
			this.store_value();
			return;
		}

		if (this.dynamic_ && !this.loaded_){
			this.value_ = val;
			this.store_value();
			return;
		}

		var serialized_val = URLSerialize(this.unwrap_optional(val));
		for (var child = this.list_.firstChild; child; child = child.nextSibling)
			if (child.nodeType == Node.ELEMENT_NODE && URLSerialize(this.unwrap_optional(this.item_value(child))) == serialized_val){
				this.select(child);
				this.store_value();
				return;
			}
		this.select(this.first_item());
		this.store_value();
	},

	set_handlers: function(){
		if (typeof this.handlers_ === "undefined"){
			this.handlers_ = [//
				[this.element, "mousedown", this.mousedown.bindAsEventListener(this)],
				[this.element, "keydown", this.keydown.bindAsEventListener(this)],
				[this.element, "keypress", this.keypress.bindAsEventListener(this)],
				[this.element, "blur", this.blur.bindAsEventListener(this)]
			];
			if (Prototype.Browser.IE)
				this.handlers_.push([this.element, "beforedeactivate", this.onbeforedeactivate.bindAsEventListener(this)]);
		}
		this.add_handlers(this.handlers_);
	},

	unset_handlers: function(){
		if (typeof this.handlers_ != "undefined") this.remove_handlers(this.handlers_);
	},

	add_handlers: function(handlers){
		if (Prototype.Browser.IE) handlers.each(function(args){ Event.observe.apply(null, args); });
		else handlers.each(function(args){ args[0].addEventListener(args[1], args[2], false); });
	},

	remove_handlers: function(handlers){
		if (Prototype.Browser.IE) handlers.each(function(args){ Event.stopObserving.apply(null, args); });
		else handlers.each(function(args){ args[0].removeEventListener(args[1], args[2], false); });
	},

	update_list_position: function(){
		var list = this.list_;
		var scrollTop = list.scrollTop;
		var pos = ItemsList.getOptimalPosition(this.element, list);
		var offs = this.offs(this.element);
		Element.setStyle(list, {
			"left": offs[0] + "px",
			"top": offs[1] + (pos.offsetTop || 0) + "px",
			"width": this.element.clientWidth + "px",
			"maxHeight": typeof pos.maxHeight === "undefined" ? "" : pos.maxHeight + "px"
		});
		if (scrollTop != 0) list.scrollTop = scrollTop;
		if (this.highlighted_ && this.highlighted_.parentNode === this.list_){
			var item_top = this.highlighted_.offsetTop;
			var item_bot = item_top + this.highlighted_.offsetHeight;
			var list_h = list.offsetHeight;
			if (list.scrollTop + list_h < item_bot) list.scrollTop = item_bot - list_h;
			if (list.scrollTop > item_top) list.scrollTop = item_top;
		}
	},

	offs: function(elem){
		if ("getBoundingClientRect" in elem){
			var rect = elem.getBoundingClientRect();
			var root = document.documentElement;
			return [rect.left - root.clientLeft, rect.top - root.clientTop];
		}
		var res = Element.cumulativeOffset(elem);
		var scr = Element.cumulativeScrollOffset(elem);
		for (var iii = 0; iii < 2; ++iii) res[iii] -= scr[iii];
		return res;
	},

	setOpen: function(){
		if (this.isopen_) return;
		if (this.highlighted_ && this.highlighted_.parentNode == this.list_)
			Element.scrollContainerTo(this.list_, this.highlighted_);
		Element.setStyle(this.element, {"width": this.list_.offsetWidth + "px"});
		Element.setStyle(this.list_, {"position": "", "height": "", "borderStyle": ""});
		document.body.appendChild(Element.remove(this.list_));
		this.update_list_position();
		if ("zindex_timer_" in this) window.clearTimeout(this.zindex_timer_);
		this.zindex_timer_ = window.setTimeout(this.update_zindex.bind(this), 200);

		if (typeof this.list_handlers_ === "undefined"){
			var docscroll = this.document_scroll.bindAsEventListener(this);
			this.list_handlers_ = [
				[this.list_, "mousedown", this.list_mousedown.bindAsEventListener(this)],
				[this.list_, "mouseup", this.list_mouseup.bindAsEventListener(this)],
				[this.list_, "mouseover", this.list_mouseover.bindAsEventListener(this)],
				[this.element, "blur", this.setClosed.bind(this)],
				[document, "mousewheel", docscroll],
				[document, "DOMMouseScroll", docscroll]
			];
		}
		this.add_handlers(this.list_handlers_);
		this.isopen_ = true;
	},

	update_zindex: function(){
		var zindex = 0;
		for (var elem = this.element; elem && elem.nodeType === Node.ELEMENT_NODE; elem = elem.parentNode){
			zindex += parseInt(Element.getStyle(elem, "zIndex")) || 0;
		}
		Element.setStyle(this.list_, {"zIndex": zindex + 100});
		delete this.zindex_timer_;
	},

	document_scroll: function(event){
		if (typeof this.scroll_timer_ !== "undefined"){
			window.clearTimeout(this.scroll_timer_);
			delete this.scroll_timer_;
		}
		this.scroll_timer_ = this.update_list_position.bind(this).defer();
	},

	setClosed: function(){
		if (!this.isopen_) return;
		Element.setStyle(this.list_, {"position": "static", "height": "0", "borderStyle": "none", "width": ""});
		Element.setStyle(this.element, {"width": ""});
		this.element.appendChild(Element.remove(this.list_));
		if (typeof this.list_handlers_ != "undefined") this.remove_handlers(this.list_handlers_);
		this.isopen_ = false;
	},

	toggleOpen: function(){
		if (this.isopen_) this.setClosed();
		else this.setOpen();
	},

	mousedown: function(event){
		var elem = Event.element(event);
		if (elem != this.list_ && !Element.descendantOf(elem, this.list_)){
			this.toggleOpen();
			event.preventDefault();
			this.element.focus();
		}
	},

	keydown: function(event){
		if(event.altKey || event.ctrlKey || event.shiftKey) return;
		switch (event.which || event.keyCode) {
			case Event.KEY_ESC: this.setClosed(); break;
			case Event.KEY_UP:
			case Event.KEY_LEFT:
				var sibling = this.prev_item(this.highlighted_);
				if (sibling) this.select(sibling);
				event.preventDefault();
				break;
			case Event.KEY_DOWN:
			case Event.KEY_RIGHT:
				var sibling = this.next_item(this.highlighted_);
				if (sibling) this.select(sibling);
				event.preventDefault();
				break;
			case Event.KEY_HOME:
			case Event.KEY_PAGEUP: {
				this.select(this.first_item());
				event.preventDefault();
				break;
			}
			case Event.KEY_END:
			case Event.KEY_PAGEDOWN: {
				this.select(this.last_item());
				event.preventDefault();
				break;
			}
			case Event.KEY_BACKSPACE:
				if (typeof this.keyboard_input_ != "undefined" && this.keyboard_input_.length > 0){
					this.keyboard_input_ = this.keyboard_input_.slice(0, -1);
					this.select_by_substr(this.keyboard_input_);
				}
				event.preventDefault();
				return;
			case Event.KEY_RETURN: {
				if (this.isopen_) this.select(this.highlighted_);
				this.toggleOpen();
				event.preventDefault();
				this.check_change();
				break;
			}

			default:
				return;
		}
		delete this.keyboard_input_;
		StopEvent(event);
		return false;
	},

	keypress: function(event){
		var keycode = event.which || event.keyCode;
		var charcode = Event.getKeyCode(event);
		if (charcode){
			var letter = String.fromCharCode(charcode)
			this.select_by_substr((this.keyboard_input_ || "") + letter.toLowerCase());
			if (letter == " ") event.preventDefault();
		}
	},

	select_by_substr: function(str){
		for (var child = this.list_.firstChild; child; child = child.nextSibling){
			if (child.nodeType != Node.ELEMENT_NODE) continue;
			for (var grandchild = child.firstChild; grandchild; grandchild = grandchild.nextSibling){
				if (grandchild.nodeType != Node.TEXT_NODE) continue;
				if (String(grandchild.nodeValue).toLowerCase().replace(/^\s+/g, "").startsWith(str)){
					this.keyboard_input_ = str;
					this.select(child);
					this.underline(str);
					return;
				}
			}
		}
	},

	get_event_item: function(event){
		if (!event) return null;
		var elem = Event.element(event);
		if (!elem || !Element.descendantOf(elem, this.list_)) return null;
		while (elem && elem.parentNode != this.list_) elem = elem.parentNode;
		return elem;
	},

	list_mousedown: function(event){ event.preventDefault(); },

	list_mousedown: function(event){
		if (Prototype.Browser.IE) this.ignore_blur_ = true;
		event.preventDefault();
	},

	list_mouseup: function(event){
		var li = this.get_event_item(event); if (!li) return;
		var oldval = URLSerialize(this.Value());
		this.select(li);
		this.setClosed();
		if (oldval != URLSerialize(this.Value())) this.onchange();
	},

	list_mouseover: function(event){
		var li = this.get_event_item(event);
		if (li) this.highlight(li);
	},

	Focus: function(){ this.element.focus(); },

	blur: function(){
		delete this.keyboard_input_;
		this.underline(null);
		this.check_change();
	},

	onbeforedeactivate: function(event){
		if (this.ignore_blur_){
			delete this.ignore_blur_;
			Event.stop(event);
			return false;
		}else return true;
	},

	underline: function(str){
		if (str && str.length > 0)
			for (var vchild = this.valcont_.firstChild; vchild; vchild = vchild.nextSibling){
				if (vchild.nodeType != Node.TEXT_NODE) continue;
				var val = String(vchild.nodeValue);
				if (val.toLowerCase().replace(/^\s+/g, "").startsWith(str)){
					var ind = val.toLowerCase().indexOf(str);
					if (ind > 0) vchild.parentNode.insertBefore(document.createTextNode(val.substr(0, ind)), vchild);
					var part = new Element("font", {"class": "Highlight"});
					part.appendChild(document.createTextNode(val.substr(ind, str.length)));
					vchild.parentNode.insertBefore(part, vchild);
					if (ind + str.length < val.length)
						vchild.parentNode.insertBefore(document.createTextNode(val.substr(ind + str.length)), vchild);
					vchild.parentNode.removeChild(vchild);
					break;
				}
			}
		else
			for (var vchild = this.valcont_.firstChild; vchild; vchild = vchild.nextSibling){
				if (vchild.nodeType != Node.ELEMENT_NODE || Node.localName(vchild).toLowerCase() != "font") continue;
				if (vchild.getAttribute("class") == "Highlight"){
					for (var vgrandchild = vchild.firstChild; vgrandchild; vgrandchild = vchild.firstChild){
						vchild.parentNode.insertBefore(vchild.removeChild(vgrandchild), vchild);
					}
					vchild.parentNode.removeChild(vchild);
					break;
				}
			}
	},

	check_change: function(){
		if (URLSerialize(this.Value()) != this.stored_value_) this.onchange();
	},

	oninit: function(){
		new AEvent("WM_INIT", {}, this);
		this.store_value();
	},

	onchange: function(args){
		new AEvent("CHANGE", typeof args == "undefined" ? {} : {"args": args}, this);
		this.store_value();
	},

	store_value: function(){
		this.stored_value_ = URLSerialize(this.Value());
	},

	SetTabOrder: function(tabbase){
		this.tabbase_ = tabbase;
		if (this.visibility_ && this.visibility_ != "yes") return tabbase++;
		else{
			this.element.tabIndex = tabbase++;
			return tabbase;
		}
	},

	WM_REFRESH: function(aevent){
		if (aevent.Data()["id"] == this.element.getAttribute("localid")) this.refresh();
	}
});