var Aheuh = {
	Version: '1.0',
	initialize: function () {}
};
Aheuh.initialize();Object.extend(navigator, {
	IE: (navigator.appVersion.indexOf('MSIE')!=-1),
    IE6: (navigator.appVersion.indexOf('MSIE 6')!=-1),
    IE7: (navigator.appVersion.indexOf('MSIE 7')!=-1),
	FF: (navigator.userAgent.indexOf('Firefox')!=-1),
	Gecko: (navigator.appVersion.indexOf('Gecko')!=-1),
	Opera: (navigator.appName.indexOf('Opera')!=-1),
	Safari: (navigator.appVersion.indexOf('Safari')!=-1)
});Aheuh.PopHtml = Class.create({
	
	initialize: function (o) {
		this._name = o.name;
		this._target = o.target;
		this._contentURL = o.contentURL;
		this._methodURL = o.methodURL;
		this._ajaxParams = o.ajaxParams;
		this._bgColor = o.bgColor || '#000';
		this._bgAlpha = o.bgAlpha || 50;
		this._onEvent = o.onEvent;
		this._targetHtmlStatic = o.targetHtmlStatic;
		this._tempoShowContent = o.tempoShowContent || 0;
		this._content = this._bg = null;
		this._doc = (!navigator.Safari) ?document.documentElement :document.body;
		this._intervalFixFirefox = this._intervalShowContent = null;
		Event.observe(window,'resize',this._onWindowResize.bind(this));		
		Event.observe(window,'scroll',this._onWindowResize.bind(this));
		this._writeBg();
		this._writeContent();
	},
	
	_onWindowResize: function () {
		this._startSetContentPosition(this._content);
		Aheuh.Axis.each( this._setBgSize.bind(this,this._bg) );
	},
	
	_getPageSize: function (k) {
		return (this._doc[k.scrollscale]<this._getWindowSize(k)) ?this._getWindowSize(k) :this._doc[k.scrollscale];
	},
	
	_getWindowSize: function (k) {
		return document.documentElement[k.clientscale];
	},
	
	_getCenter: function (o,k) {
		return this._doc[k.scrollpos] + (this._getWindowSize(k)/2)-(o[k.offsetscale]/2);		
	},
	
	_writeContent: function () {
		if (this._contentURL) {
			var newAJAX = new Ajax.Request(
				this._contentURL, {
					method: this._methodURL,
					postBody:$H(this._ajaxParams).toQueryString(),
					onComplete: function(response) {
						this._content.innerHTML = response.responseText;
						this._setInterval();
					}.bind(this)
				}
			);
		}
		else {
			this._content.appendChild(this._targetHtmlStatic);
			Element.setStyle(this._targetHtmlStatic,{ display:'block' });
			this._setInterval();
		}
	},
	
	_setInterval: function () {
		if (this._intervalFixFirefox==null) { this._intervalFixFirefox = new PeriodicalExecuter(this._setContent.bind(this),0); }
		else {
			this._intervalFixFirefox.callback = this._setContent.bind(this);
			this._intervalFixFirefox.registerCallback();
		}
	},
	
	_setIntervalShowContent: function () {
		if (this._intervalShowContent==null) { this._intervalShowContent = new PeriodicalExecuter(this._showContent.bind(this,'visible'),this._tempoShowContent); }
		else {
			this._intervalShowContent.callback = this._showContent.bind(this,'visible');
			this._intervalShowContent.registerCallback();
		}
	},
	
	_showContent: function (visibility) {
		Element.setStyle(this._content,{ visibility:visibility });
		this._content.focus();
		this._intervalShowContent.stop();
	},
	
	_writeBg: function () {
		
		var str =
		'<div id="PopHtmlBg" style="z-index:1000;position:absolute;top:0;left:0;background:'+this._bgColor+';filter:alpha(opacity='+this._bgAlpha+');-moz-opacity:0.'+this._bgAlpha+';opacity:0.'+this._bgAlpha+';"></div>' +
		'<div id="PopHtmlContent" style="z-index:1001;position:absolute;top:0;left:0;"></div>';	
		
		if (navigator.IE6) {
			str += '<iframe id="PopHtmlIframeIE6Hack" style="z-index:999;position:absolute;top:0;left:0;filter:alpha(opacity=0);"></iframe>';	
		}
		
		this._target.innerHTML = str;
		this._target.setStyle({ display:'block' });
		this._bg = $('PopHtmlBg');
		this._content = $('PopHtmlContent');
		Element.setStyle(this._content,{ visibility:'hidden' });
		Aheuh.Axis.each( this._setBgSize.bind(this,this._bg) );
		if (navigator.IE6) {
			this._IframeIE6Hack = $('PopHtmlIframeIE6Hack');
			Aheuh.Axis.each( this._setBgSize.bind(this,this._IframeIE6Hack) );
		}
		
	},
	
	_setBgSize: function (o,k) {
		o.style[k.scale] = this._getPageSize(k) + 'px';
	},
	
	_setContent: function () {
		this._intervalFixFirefox.stop();
		if (this._onEvent) { this._onEvent("onReady",this._name); } 
		this.refresh();
	},
	
	_startSetContentPosition: function () {
		Aheuh.Axis.each( this._setContentPosition.bind(this) );
		this._setIntervalShowContent();
	},
	
	_setContentPosition: function (k) {
		this._content.style[k.pos] = this._getCenter(this._content,k) + 'px';
	},
	
	close: function () {
		Element.setStyle(this._target,{ display:'none' });
	},
	
	refresh: function () {
		this._startSetContentPosition();
	}	
	
});Aheuh.Roll = Class.create({
	
	initialize: function (a) {
		this.img = a.getElementsByTagName("img")[0];
		this.locked = false;
		this.pngIE6 = navigator.IE6 && this.img.src.indexOf('.png')!=-1;
		if (this.pngIE6) {
			this.ie6Hack = new Aheuh.IE6Hack();
		}
		else {
			Event.observe(this.img, "mouseover", this.change.bind(this,1));
			Event.observe(this.img, "mouseout", this.change.bind(this,0));
		}
	},
	
	change: function (state) {
		if (!this.locked) {
			this.img.src = this.img.src.substring(0,this.img.src.length-5) + state + "." + this.img.src.substring(this.img.src.length-3,this.img.src.length);
		}
	},
	
	manual: function (state) {
		if (this.pngIE6) {
			this.ie6Hack.pngRollManual(this.img,state == 1?0 :1,state);
		}
		else {
			this.img.src = this.img.src.substring(0,this.img.src.length-5) + state + "." + this.img.src.substring(this.img.src.length-3,this.img.src.length);
		}
	},
	
	lock: function (locked) { 
		this.locked = locked; 
	}
	
});Aheuh.Scroller = Class.create({
	
	_baseHtmlClass: { mask:'scrollerMask', content:'scrollerContent' },
	_buttons: { Left:-1, Right:1 ,Top:-1, Bottom:1 },
	_axis: { Left:'x', Right:'x', Top:'y', Bottom:'y' },
	
	initialize: function (o) {
		if ($(o.root)) {
			
			for (var i in this._baseHtmlClass) {
				var check = $$('#'+o.root+' .'+this._baseHtmlClass[i]);
				if (check.length==0) { alert('Html Class required : '+this._baseHtmlClass[i]); return; }
				else { this['_'+i] = check[0]; }
			}
			
			this._root = o.root;
			this.speed = o.speed || 2;
			this.speedInterval = o.speedInterval || 2;
			this._wheelSpeed = o.wheelSpeed|| 10;
			this._interval = null;			
			this._cursors = { scrollx:false, scrolly:false };
			this._tools = {};
			this._wheelFactor = 0;
			
			if ($$('#'+o.root+' .scrollerTools')) {
				for (var i in this._buttons) {
					$$('#'+o.root+' .scroller'+i).each( this._setButtonsEvents.bind(this,this._axis[i],this._buttons[i]) );
				}
				this.reload();
				Aheuh.Axis.each( this._setBg.bind(this) );
			}
			
		}
		else { alert('Root Scroller Html ID required'); }
	},
	
	_setButtonsEvents: function (axis,move,o) {
		Event.observe(o,'mouseover',this._setInterval.bind(this,axis,move));
		Event.observe(o,'mouseout',this._stop.bind(this));
	},
	
	_scrolling: function (k) {
		var tools = $$('#'+this._root+' .scrollerTools'+k.key.toUpperCase());
		var visibility = '';
		if (this._mask[k.scrollscale]>this._mask[k.offsetscale]) {
			this._cursors['scroll'+k.key] = true;
			visibility = 'visible';
			this._mask[k.scrollpos] = 0;
			if (k.key == 'y'&&!this._cursors['element'+k.key]) {
				Event.observe(this._mask, document.all ?'mousewheel' :'DOMMouseScroll', this._onMouseWheel.bindAsEventListener(this));
			}
		}
		else {
			this._cursors['scroll'+k.key] = false;
			visibility = 'hidden';
		}
		if (tools.length>0) {
			this._tools['element'+k.key] = tools[0];
			this._viewScrollTools(visibility,k.key);
		}
	},
	
	_setCursor: function (k) {
		if (this._cursors['scroll'+k.key]) {
			var o = $$('#'+this._root+' .scrollerCursor'+Aheuh.Axis.pos[k.key]);			
			if (o.length>0) {
				if (!this._cursors['element'+k.key]) {				
					this._cursors['start'+k.key] = o[0][k.offsetpos];
					this._cursors['size'+k.key] = o[0][k.offsetscale];
					this._cursors['element'+k.key] = o[0];
					this._cursors['params'+k.key] = {target:o[0], xmin:0, xmax:0, ymin:0, ymax:0, onMoveFunction:this._onDrag.bind(this,k) };
					this._cursors['params'+k.key][k.min] = o[0][k.offsetpos];
					this._cursors['params'+k.key][k.max] = o[0][k.offsetpos]+o[0][k.offsetscale];
					this._cursors['drag'+k.key] = new Aheuh.Drag(this._cursors['params'+k.key]);
				}			
				this._cursors['fact'+k.key] = this._getFactor(k);
				if (k.key == 'y') {	this._setWheelFactor(); }
				o[0].style[k.scale] = this._cursors['size'+k.key]*this._cursors['fact'+k.key]+'px';
				this._cursors['drag'+k.key].reload(this._cursors['params'+k.key]);				
			}
		}
	},
	
	_getFactor: function (k) {
		return (this._mask[k.offsetscale]-(this._mask[k.offsetscale]-this._cursors['size'+k.key]))/(this._mask[k.scrollscale]-(this._mask[k.offsetscale]-this._cursors['size'+k.key]));
	},
	
	_setWheelFactor: function () {
		this._wheelFactor = this._wheelSpeed - this._cursors['facty'];
	},
	
	_setInterval: function (axis,move) {
		if (!this._interval) {
			this._interval = new PeriodicalExecuter(this._scroll.bind(this,axis,move),this.speedInterval/1000);
		}
		else {
			this._interval.callback = this._scroll.bind(this,axis,move);
			this._interval.registerCallback();
		}
	},
	
	_scroll: function (axis,move) {
		this._mask[Aheuh.Axis[axis].scrollpos] += this.speed*move;
		this._moveCursor(axis);
	},
	
	_moveCursor: function (axis) {
		if (this._cursors['element'+axis]) {
			this._cursors['element'+axis].style[Aheuh.Axis[axis].pos] = this._cursors['start'+axis] + this._mask[Aheuh.Axis[axis].scrollpos] * this._cursors['fact'+axis] + "px";
		}
	},
	
	_onMouseWheel: function (e) {
		Event.stop(e);
		this._scroll('y',Event.Wheel(e)*-1*this._wheelFactor);
	},
	
	_stop: function () {
		this._interval.stop();
	},
	
	_setBg: function (k) {
		if (this._cursors['scroll'+k.key]) {
			var o = $$('#'+this._root+' .scrollerCursorBg'+Aheuh.Axis.pos[k.key]);
			if (o.length>0) {
				Event.observe(o[0], "click", this._onBgClick.bindAsEventListener(this,k));
			}
		}
	},
	
	_onDrag: function (k) {
		this._mask[k.scrollpos] = (this._cursors['element'+k.key][k.offsetpos]-this._cursors['start'+k.key])/this._cursors['fact'+k.key];
	},
	
	_onBgClick: function (e,k) {
		var move = (Event[k.pointer](e)>this._cursors['element'+k.key].cumulativeOffset()[Aheuh.Axis.id[k.key]]+this._cursors['element'+k.key][k.offsetscale]) ?1 :-1;		
		this._scroll(k.key,this._cursors['element'+k.key][k.offsetscale]*move);		
	},
	
	moveTo: function (o) {
		Aheuh.Axis.each(function (k){
			this._mask[k.scrollpos] = $(o)[k.offsetpos];
			this._moveCursor(k.key);
		}.bind(this));
	},
	
	_viewScrollTools: function (visibility,k) {
		this._tools['element'+k].setStyle({ visibility:visibility });
	},
	
	forceScrollTools: function (visibility,k) {
		if (this._cursors['scroll'+k]) {
			this._viewScrollTools(visibility,k);
		}
	},
	
	reload: function () {
		Aheuh.Axis.each( this._scrolling.bind(this) );
		Aheuh.Axis.each( this._setCursor.bind(this) );
	}
	
});Aheuh.ScrollerCursor = Class.create(Aheuh.Scroller, {
	
	initialize: function ($super,o) {
		this._cursorSizeX = o.cursorSizeX || 0;
		this._cursorSizeY = o.cursorSizeY || 0;
		$super(o);
	},
	
	_setCursor: function (k) {
		if (this._cursors['scroll'+k.key]) {
			var o = $$('#'+this._root+' .scrollerCursor'+Aheuh.Axis.pos[k.key]);			
			if (o.length>0) {
				if (!this._cursors['element'+k.key]) {			
					this._cursors['start'+k.key] = o[0][k.offsetpos];
					this._cursors['size'+k.key] = o[0][k.offsetscale];
					this._cursors['element'+k.key] = o[0];
					this._cursors['params'+k.key] = {target:o[0], xmin:0, xmax:0, ymin:0, ymax:0, onMoveFunction:this._onDrag.bind(this,k) };
					this._cursors['params'+k.key][k.min] = o[0][k.offsetpos];
					this._cursors['params'+k.key][k.max] = o[0][k.offsetpos]+o[0][k.offsetscale];
					this._cursors['drag'+k.key] = new Aheuh.Drag(this._cursors['params'+k.key]);
				}				
				o[0].style[k.scale] = this['_cursorSize'+k.key.toUpperCase()]+'px';
				this._cursors['fact'+k.key] = this._getFactor(k);
				if (k.key == 'y') {	this._setWheelFactor(); }
				this._cursors['drag'+k.key].reload(this._cursors['params'+k.key]);				
			}
		}
	},
	
	_getFactor: function (k) {
		return (this._cursors['size'+k.key]-this._cursors['element'+k.key][k.offsetscale])/(this._mask[k.scrollscale]-this._mask[k.offsetscale]);
	}
	
});Aheuh.Checkbox = Class.create({
	
	initialize: function (o) {		
		this._cntRun = 0;
		this._checkboxes = $$(o.$$search);
		this._onChange = o.onChange;
		this._firstRun = true;
		this._checkboxes.each( this._set.bind(this,o.newHTML) );
	},
	
	_set: function (html,o) {
		o.down().setStyle({ display:'none' });
		var value = (o.down().checked!='') ?1 :0;
		o.innerHTML += html;
		var r = this['_roll'+o.down().name] = new Aheuh.Roll(o.down(1));
		r.lock(true);		
		this._change(r,o.down(),value);
		Event.observe(o.down(1),'click',this._change.bind(this,r,o.down(),null));
	},
	
	_change: function (roll,input,v) {
		input.checked =  (this._firstRun) ? (v==1) ?'checked' :'' : (input.checked=='') ?'checked' :'';
		var value = (v) ?v :(input.checked) ?1 :0;
		roll.manual(value);
		if (this._onChange&&!this._firstRun) this._onChange(input);
		if (this._cntRun++>=this._checkboxes.length-1) this._firstRun = false;
	},
	
	refresh: function () {
		this._checkboxes.each(function(o){
			var value = (o.down().checked) ?1 :0;
			this['_roll'+o.down().name].manual(value);
		}.bind(this));
	}
	
});Aheuh.RadioGroup = Class.create(Aheuh.Checkbox, {

	initialize: function ($super,o) {
		this._checked = null;
		this._cnt = 0;
		$super(o);
	},
	
	_change: function($super,roll,input,v) {
		$super(roll,input,v);
		if (this._cnt++>=this._checkboxes.length) {
			if (this._checked) {
				this._checked.roll.manual(0);
				this._checked.input.value = 0;
				this._checked.input.checked = '';
			}
			this._checked = (input.checked) ?{ roll:roll, input:input } :null;
		}
		else if (v==1) this._checked = { roll:roll, input:input };
	},
	
	selected: function () {
		return (this._checked) ?this._checked :'';
	}
	
});Aheuh.SelectHtml = Class.create({
	
	initialize: function (params) {		
		this._params = params;
		this.isOpen = this._closeOnClick = this._keyActive = this.changeFunctionActive = false;
		this._styles = new Array();
		this._datas = new Array();
		this.keyIndex = {};
		this._select = $(params.selectHtml);
		this._select.setStyle({ display:'none' });
		this._onChangeFunction = this._select.onchange;
		this._index = this.keyCntCheck = 0;
		this._keyInterval = null;
		this._keyCurrentString = '';
	},
	
	init: function () {
		
		this._writeHtml = $(this._params.selectWrite);
		this._zIndex = this._writeHtml.getStyle('zIndex');
			
		this._setStyles();
		this._style = this._styles[this._params.style || 0];
		this._parseDatas(this._select);
		
		this._write();		
			
		this._mainClick = $$('#'+this._params.selectWrite+' .main')[0];
		this._main = $$('#'+this._params.selectWrite+' .selectMain')[0];
		this._mask = $$('#'+this._params.selectWrite+' .scrollerMask')[0];		
		this._content = $$('#'+this._params.selectWrite+' .selectOptions')[0];

		this._scroller =  new Aheuh.Scroller({ root:this._params.selectWrite, speed:5, speedInterval:2 });	
		this._scroller.forceScrollTools('hidden','y');
		
		this._setEvents();
		this.setSelectedIndex(this._index);

	},
	
	_setStyles: function () {
		var styles = Aheuh.SelectHtmlConfig.styles;
		for (var i in styles) {
			this._styles.push({ name:i, html:styles[i] });
		}
	},
	
	_parseDatas: function (o) {
		for (var i=0;i<o.length;i++) {
			if (o[i].selected) {
				this._index = i;
			}
			this._add({ data:o[i].value, label:o[i].innerHTML });
		}
	},
	
	_write: function () {
		
		this._writeHtml.innerHTML = this._style.html;
		var writeOptions = $$('#'+this._params.selectWrite+' .selectOptions')[0];
		
		var options = '<ul>';
		for (var i=0;i<this._datas.length;i++) {
			options += '<li id="'+i+''+this._select.id+'"><a href="#0">' + this._datas[i].label + '</a></li>';
		}
		options += '</ul>';
		writeOptions.innerHTML = options;
		
	},
	
	_add: function (o) {
		this._addKeyIndex(o.label.charAt(0).toLowerCase(),this._datas.length,o.label);
		this._datas.push(o);
	},
	
	_addKeyIndex: function (key,index,label) {
		if (!this.keyIndex[key]) { this.keyIndex[key] = {infos:[]}; }
		this.keyIndex[key].infos.push({ index:index, label:label });
	},
	
	_setEvents: function () {
		
		var tmp = this._content.getElementsByTagName("a");
		
		for (var i=0;i<tmp.length;i++) {
			tmp[i].className = "s"+i;
			Event.observe(tmp[i], "click", this._onItemClickEvents.bindAsEventListener(this));
			Event.observe(tmp[i], "mouseover", this._onItemOverEvents.bindAsEventListener(this));
			Event.observe(tmp[i], "mouseout", this._onItemOutEvents.bindAsEventListener(this));
		}
		
		Event.observe(this._mainClick, "click", this._onMainClick.bindAsEventListener(this));
		Event.observe(this._mainClick, "click", Event.SelectionClear);
		Event.observe(this._mainClick, "mouseover", this._onMainOver.bindAsEventListener(this));
		Event.observe(this._mainClick, "mouseout", this._onMainOut.bindAsEventListener(this));		
		Event.observe(this._mainClick, this._scroller._mouseWheelEvent, this._onMainMouseWheel.bindAsEventListener(this));
		
		Event.observe(this._writeHtml, "mouseover", this._onWriteMouseOver.bindAsEventListener(this));
		Event.observe(this._writeHtml, "mouseout", this._onWriteMouseOut.bindAsEventListener(this));
		
		Event.observe(document, "mouseup", this._checkToClose.bindAsEventListener(this));
		Event.observe(document, "keydown", this._setSelectedKeyboardIndex.bindAsEventListener(this));
		
	},
	
	_onItemClickEvents: function (e) {
		this._content.style.visibility = this._mask.style.visibility = "hidden";
		this.isOpen = this._closeOnClick = this._keyActive = false;
		this.setSelectedIndex(parseInt(Event.element(e).parentNode.id)); 
		this._scroller.reload();
		this._scroller.forceScrollTools('hidden','y');
	},
	_onItemOverEvents: function (e) {
		if (this.itemMouseOver!="") { Element.removeClassName($(this.keyItemSelected), "on"); }
		this.itemMouseOver = Event.element(e);
	},
	_onItemOutEvents: function () {
		this.itemMouseOver = "";
	},
	
	_onMainClick: function () {
		this._scroller.reload();
		this._scroller.moveTo(this._index+this._select.id);
		var visibility = (this.isOpen) ?'hidden' :'visible';	
		this._showHideDatas(visibility);
	},
	_onMainOver: function () {
		this._keyActive = true;
	},
	_onMainOut: function () {
		if (!this.isOpen){  this._keyActive = false; }
	},
	_onMainMouseWheel: function (e) {
		(Event.Wheel(e)==-1) ?this.setSelectedIndex(this._index+1) :this.setSelectedIndex(this._index-1);
	},
	
	_onWriteMouseOver: function () {
		if (this.isOpen) { this._keyActive = true; this._closeOnClick = false; }
	},
	_onWriteMouseOut: function () {
		if (this.isOpen) { this._keyActive = false; this._closeOnClick = true; }
	},
	
	_showHideDatas: function (visibility) {
		this._content.style.visibility = this._mask.style.visibility = visibility;
		this._scroller.forceScrollTools(visibility,'y');
		this.isOpen = this._keyActive = (visibility=="hidden") ?false :true;		
		var zIndex = (this.isOpen) ?Number(this._zIndex)+1 :this._zIndex;		
		this._writeHtml.setStyle({ zIndex:zIndex })		
		this.itemMouseOver = "";
	},
	
	getSelectedData: function () {
		return this._datas[this._index].data;
	},
	
	getSelectedLabel: function () {
		return this._datas[this._index].label;
	},
	
	setSelectedIndex: function (index) {
		if (index>=0&&index<this._datas.length) {
			Element.removeClassName(this._content.getElementsByTagName('a')[this._index], "on");
			this._index = index;
			this._main.innerHTML = this.getSelectedLabel();			
			Element.addClassName(this._content.getElementsByTagName('a')[index], "on");
			this._select.selectedIndex = index;			
			if (this._onChangeFunction&&this.changeFunctionActive) { this._onChangeFunction(); }
			if (!this.changeFunctionActive) { this.changeFunctionActive = true; }
		}
	},
	
	setSelectedData : function (data) {
		this.changeFunctionActive = false;
		for (var i=0;i<this._datas.length;i++) { if (this._datas[i].data==data) { this.setSelectedIndex(i); }}
	},
	
	_checkToClose: function () {
		if (this._closeOnClick&&this.isOpen) {
			this._showHideDatas("hidden");
		}
	},
	
	_setKeyInterval: function () {
		if (!this._keyInterval) {
			this._keyInterval = new PeriodicalExecuter(this._checkKeyInterval.bind(this),0.5);
		}
		else {
			this._keyInterval.stop();
			this._keyInterval.callback = this._checkKeyInterval.bind(this);
			this._keyInterval.registerCallback();
		}
	},
	
	_checkKeyInterval: function () {
		this._keyCurrentString = this.currentKey = '';
		this._keyInterval.stop();
	},
	
	_setSelectedKeyboardIndex: function (e) {

		if (this._keyActive) {
			
			e.stop();
			
			var keyCode = (window.event) ?e.keyCode :e.which;
			var keyCodeLabel = String.fromCharCode(keyCode).toLowerCase();
			
			this._setKeyInterval();
			this._keyCurrentString += keyCodeLabel;			
			var firstKey = this._keyCurrentString.charAt(0);
			
			if (keyCode==13&&this.isOpen) {
				if (this.itemMouseOver!="") this.setSelectedIndex(parseInt(this.itemMouseOver.parentNode.id));
				this._showHideDatas("hidden");
			}
			
			if (this.keyIndex[firstKey]) {
				
				this.keyCntCheck = this._getKeyCntCheck(keyCodeLabel,this.keyIndex[firstKey].infos);
				
				if (this.keyCntCheck!=-1) {
				
					if (this.keyItemSelected!="") {
						Element.removeClassName($(this.keyItemSelected), "on");
					}
					Element.removeClassName(this._content.getElementsByTagName("div")[this._index], "on");
					
					this.keyItemSelected = this.keyIndex[firstKey].infos[this.keyCntCheck].index + this._select.id;
					Element.addClassName($(this.keyItemSelected), "on");
					
					this._scroller.moveTo(this.keyItemSelected);
					this.currentKey = keyCodeLabel;
					this.itemMouseOver = $(this.keyItemSelected);
	
					this.setSelectedIndex(this.keyIndex[firstKey].infos[this.keyCntCheck].index);
				
				}
			
			}
			
			if (keyCode==38&&this._index>0) {
				this.setSelectedIndex(this._index-1);
				this._scroller.moveTo(this._content.getElementsByTagName('li')[this._index].id);
			}
			else if (keyCode==40&&this._index<this._datas.length) {
				this.setSelectedIndex(this._index+1);
				this._scroller.moveTo(this._content.getElementsByTagName('li')[this._index].id);
			}
			
		}
		
	},
	
	_getKeyCntCheck: function (key,keyArray) {
		if (this.currentKey==key && this._keyCurrentString.length==1 || this.currentKey == '') {
			return (this.keyCntCheck<this.keyIndex[key].infos.length-1) ?this.keyCntCheck+1 :0;
		}
		else if (this._keyCurrentString.length>1) {
			for (var i=0;i<keyArray.length;i++) {
				if (keyArray[i].label.substring(0,this._keyCurrentString.length).toLowerCase()==this._keyCurrentString) {
					return i;
				}
			}
		}
		return -1;
	}
	
});Aheuh.SelectHtmlConfig = {
	styles:{			
		style1: '<div class="main"><div class="selectMain">&nbsp;</div></div>' +
			'<div class="scrollerMask"><div class="scrollerContent selectOptions"></div></div>' +
			'<div class="scrollerTools">' +
				'<div class="scrollerToolsY">' +
					'<div class="scrollerCursorTop"></div>' +
					'<div class="scrollerCursorBgTop"></div>' +
				'</div>' +
			'</div>' +
		'</div>'	
	}
};Aheuh.Axis = {
    initialize: function() {
        this.each( function(k,r){ this.base[k] = this.base[k]||this.keys(k); }.bind(this) );
    },
    base:{x:null,y:null},
    pos:{x:'Left',y:'Top'},
    scale:{x:'Width',y:'Height'},
    id:{x:0,y:1},
    keys: function(key){
         this[key] = this[key] ||
            {
                key:key,          
                min:key+'min',
                max:key+'max',
                axis:key+'axis',
                limit:key+'limit',
                factor:key+'factor',
                pos:this.pos[key].toLowerCase(),
                scale:this.scale[key].toLowerCase(),
                scrollpos:'scroll'+this.pos[key],
                scrollscale:'scroll'+this.scale[key],
                offsetpos:'offset'+this.pos[key],
                offsetscale:'offset'+this.scale[key],
                clientscale:'client'+this.scale[key],
				mouse:key+'mouse',
				pointer:'pointer'+key.toUpperCase()
            };
        return this[key];
    },
    from: function(o)
    {
        return {x:o[0],y:o[1]};
    },
    each: function(iterator,memo)
    {
        for(var key in this.base)
            memo = iterator((this[key]||key),memo);
        return memo;
    }
}
Aheuh.Axis.initialize();Aheuh.Cookie = Class.create({
	
	initialize: function () {  },
	
	create: function (name, value, days) {
		var expires = "";
		if (days) {
			var d = new Date();
			d.setTime(d.getTime() + (days * 24 * 60 * 60 * 1000));
			expires = "; expires=" + d.toGMTString();
		}
		document.cookie = name + "=" + value + expires + "; path=/";
	},
	
	read: function (name) {
		var nameEQ = name + "=";
		var ca = document.cookie.split(';');
		for (var i=0;i<ca.length;i++) {
			var c = ca[i];
			while (c.charAt(0) == ' ') c = c.substring(1, c.length);
			if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);
		}
		return null;
	},
	
	erase :function (name) {
		this.create(name, "", -1);
	}
		
});Aheuh.Drag = Class.create({
	
	initialize: function (o) {
		this._target = o.target;
		this._mouseOldPos = {};
		this._setLimit(o.xmin,o.xmax,o.ymin,o.ymax);
		this.onMoveFunction = o.onMoveFunction;		
		this.draggable = false;
		this._targetDown = this.setDraggable.bind(this,true);
		this._docMouseUp = this.setDraggable.bind(this,false);
		this._docMouseMove = this._setMove.bindAsEventListener(this);
		Event.observe(this._target,"mousedown",this._targetDown);
		Event.observe(document,"mouseup",this._docMouseUp);
		Event.observe(document,"mousemove",this._docMouseMove);
	},
	
	_setLimit: function (xmin,xmax,ymin,ymax) {
		Aheuh.Axis.each( function (k){
			this[k.min] = eval(k.min); this[k.max] = eval(k.max);
			this['target'+[k.max]] = this[k.max]-this._target[k.offsetscale];
			this._mouseOldPos[k.mouse] = null;
		}.bind(this));
	},
	
	setDraggable: function (draggable) {
		this.draggable = draggable;
		Aheuh.Axis.each( function (k){ this._mouseOldPos[k.mouse] = null; }.bind(this));
	},
	
	_setMove: function (e) {
		Aheuh.Axis.each( this._move.bind(this,e) );
	},
	
	_move: function (e,k) {
		if (this.draggable) {			
			var mouse = Event['pointer'+k.key.toUpperCase()](e);
			if (this._mouseOldPos[k.mouse]) {	
				if (this[k.max]>this[k.min]) {
					var n = this._target[k.offsetpos]-(this._mouseOldPos[k.mouse]-mouse);					
					if (n<this[k.min]) { n = this[k.min]; }
					else if (n+this._target[k.offsetscale]>this[k.max]) { n = this['target'+[k.max]]; }
					this._target.style[k.pos] = n+"px";
					if (this.onMoveFunction) { this.onMoveFunction(); }
				}
			}
			Event.SelectionClear();
			this._mouseOldPos[k.mouse] = mouse;
			e.stop();
		}
	},
	
	reload: function (o) {
		this._setLimit(o.xmin,o.xmax,o.ymin,o.ymax);
	},
	
	kill: function () {
		Event.stopObserving(this._target,"mousedown",this._targetDown);
		Event.stopObserving(document,"mouseup",this._docMouseUp);
		Event.stopObserving(document,"mousemove",this._docMouseMove);
	}

});Aheuh.XML = Class.create({
	
	load: function (url,onLoadFunction) {
		this._request = window.XMLHttpRequest? new XMLHttpRequest(): new ActiveXObject("Microsoft.XMLHTTP");
		this._onLoadFunction = onLoadFunction;
		this._request.onreadystatechange = this._onLoad.bind(this);
		this._request.open("GET", url, true);
		this._request.send(null);
	},
	
	_onLoad: function () {
		if (this._request.readyState == 4 && (this._request.status == 200 || this._request.status == 304)) {			
			this._onLoadFunction(this._request.responseXML.documentElement);
		}
	},
	
	removeWhitespace: function (xml) {
		for (var i=0;i<xml.childNodes.length;i++) {
			var node = xml.childNodes[i];
			if (node.nodeType == 1) this.removeWhitespace(node);
			if (((/^\s+$/.test(node.nodeValue))) && (node.nodeType == 3)) xml.removeChild(xml.childNodes[i--]);
		}
	}
	
});Object.extend(Event, {
	Wheel: function (event){
		var delta = 0;
		if (!event) event = window.event;
		if (event.wheelDelta) {
			delta = event.wheelDelta/120; 
			if (window.opera) delta = -delta;
		} else if (event.detail) { delta = -event.detail/3;	}
		return Math.round(delta);
	}
});

Object.extend(Event, {
	SelectionClear: function () {
		if (document.execCommand&&navigator.userAgent.indexOf("Firefox")==-1) { document.execCommand("Unselect"); }
		else if (window.getSelection&&window.getSelection().removeAllRanges) {			
			window.getSelection().removeAllRanges();
			window.getSelection().addRange(document.createRange());
		}
	}
});

Object.extend(Array, {
    sortOnNumber: function (a) { return a.sort( function(n1,n2) { return (n1-n2) } ) }
});