function DOCUMENT_IFORM(params){	
	var 
		FORM_TEMPLATES={
			cid:{
				f_type:'text',
				f_rule:/^c|ñ?\d+$/,
				f_min:1
				},
			fio:{
				f_type:'text',
				f_min:5
				},
			login:{
				f_type:'text',
				f_rule:/^[a-zA-Z0-9._\-]+$/,
				f_min:3
				},
			jur_status:{
				f_type:'select',
				f_values:new Array(1,2)
				},
			mail:{
				f_type:'text',
				f_rule:/^[a-zA-Z0-9._\-]+\@[a-zA-Z0-9._\-]+\.\w{2,4}$/,
				f_min:6
				},
			phone:{
				f_type:'text',
				f_rule:/[\-\+\#\d]/,
				f_min:6
				},
			pwd:{
				f_type:'password',
				f_rule:/[a-zA-Z0-9._\-]+/,
				f_min:6
				},
			pwd2:{
				f_type:'password',
				f_rule:/[a-zA-Z0-9._\-]+/,
				f_min:6
				},
			file_img:{
				f_type:'file'
				},
			itemName:{
				f_type:'text',
				f_rule:/^[a-zA-Z0-9._\-]+$/,
				f_min:1
				},
			itemCaption:{
				f_type:'text',
				f_rule:/^[a-zA-Zà-ÿÀ-ß0-9._\-\s\(\)\—]+$/,
				f_min:1
				},
			itemCaptionFree:{
				f_type:'text',
				f_rule:/^[a-zA-Zà-ÿÀ-ß0-9._\-\s\(\)\—\?\,]+$/
				},
			itemDescription:{
				f_type:'textarea'
				},
			itemDsc:{
				f_type:'textarea',
				f_min:3
				},
			itemEventCount:{
				f_rule:/\d/,
				f_max:3
				},
			radioGroup:{
				f_type:'radio'
				},
			itemSelect:{
				f_type:'select'
				},
			count:{
				f_rule:/^\d+$/
				},
			message:{
				f_type:'textarea',
				f_rule:/[^\s]+/,
				f_min:1
				},
			date:{
				f_type:'text',
				f_rule:/^\d{1,2}\.\d{1,2}\.\d{2,4}$/,
				f_min:6
				},
			date_calendar:{
				f_type:'text',
				f_rule:/^\d{1,2}\.\d{1,2}\.\d{2,4}$/,
				f_onfocus:function(data){
					killAllCalendars();
					if (!data.field){
						return;
						}
					var calend=new Calendar(data.field,new Date(),getOffsetDaysFromDate(365),null,data.f_onselect);
					}
				},
			time:{
				f_type:'text',
				f_rule:/^(?:\d{1,2}[\.\:]\d{1,2})?$/,
				f_max:5
				},
			hour:{
				f_type:'text',
				f_rule:/^\d{1,2}$/,
				f_minvalue:0,
				f_maxvalue:23,
				f_min:1
				},
			hourEx:{
				f_type:'text',
				f_rule:/^\d{1,2}$/,
				f_minvalue:0,
				f_maxvalue:99,
				f_min:1
				},
			minute:{
				f_type:'text',
				f_rule:/^\d{1,2}$/,
				f_minvalue:0,
				f_maxvalue:59,
				f_min:1
				},
			city:{
				f_type:'text',
				f_rule:/^[\dà-ÿÀ-ß][\d\sà-ÿÀ-߸¨\.\-\/\_\(\)\,]*$/,
				f_min:1
				},			
			street:{
				f_type:'text'
				},
			house:{
				f_type:'text',
				f_rule:/\d*/
				},
			subway:{
				f_type:'text'
				}			
		},

		DEFAULT_FIELD_PARAMS={
			'f_type':'',
			'f_template':'',
			'f_rule':'',
			'f_min':'',
			'f_minvalue':'',
			'f_maxvalue':'',
			'f_max':'',
			'f_values':'',
			'f_errblock':'',
			'f_addcheck':'',
			'f_onclick':'',
			'f_skip':'',
			'f_onfocus':'',
			'f_field_equal':'',
			'f_callback':''
			},
		defaultParams={			
			'onresult':null
			};

	this.params=concatObjects(params,defaultParams);	
	if (!this.params.form || !this.params.fields) {
		return false;
		}
	this.form=(typeof this.params.form=='object')?this.params.form:document.forms[this.params.form];
	this.form.obj=this;
	this.fields=this.params.fields;
	this.suggestedFields=[];
	this.result={};
	this.checkRes=false;
	
	var formSubmiting=this.params.onresult;
	
	this.putEvents=function(){		
		var fields=this.fields,
			form=this.form,
			$this=this;
		for (fName in fields){
			 var 
			 	f=$id(fName)||form[fName],
				fData=fields[fName],
				fData=this.getFieldData(fData);
			 if (!f) {
				continue;
			 	}
			var onclickFunction=function(){				
				 var errBlock=$id(this.id+'_error')
				 $this.clearError(errBlock,this);
				 
				 /* if (errBlock){
					 errBlock.className='hidden'
					 errBlock.innerHTML=''
				 	} */
				
			 	} 
			 EVENTS.append(f,['onclick','onkeypress'],onclickFunction);			 
			 if (fData.f_onclick && typeof fData.f_onclick=='function'){
				 if (fData.f_type=='radio'){
					var els=$name(f.name) || f;
				 	for (var i=0; i<els.length; i++){
						var el=els[i];						
						EVENTS.append(el,'onclick',fData.f_onclick);
						}
				 	}
				else{
					EVENTS.append(f,['onclick','onkeypress'],fData.f_onclick);
					}
			 	}
			
				
			if (fData.f_onfocus && is_function(fData.f_onfocus)) {
				if (fData.f_type=='radio'){
					var els=$name(f.name) || f;
				 	for (var i=0; i<els.length; i++){
						var el=els[i];						
						EVENTS.append(el,'onfocus',fData.f_onfocus);
						}
				 	}
				else{
					var 
						func=fData.f_onfocus,
						funcData=fData;
					EVENTS.append(
						f,
						'onfocus',
						function(){
							funcData.field=this;
							func(funcData)
							}
						);
					}
			 	}
			 if (fData.f_suggest){
				 var sgData=fData.f_suggest;
				 if (fData.f_rule && !sgData['f_rule']){
					 sgData['f_rule']=fData.f_rule;
				 	}
				 var sg=new Suggest(f,sgData);
				 this.suggestedFields.push(f);			 
			 	}
				
			}
		}
	
	
	this.checking=function(){
		var fields=this.fields,
			form=this.form,
			res=true,
			toFocus='';
		
		for (fName in fields){				
			var 
				fParam=this.getFieldData(fields[fName]),
				f=$id(fName)||form[fName];				
			if (!f || f.disabled || !$displaying(f)){				
				continue;
				}
			if (fParam.f_type=='radio'){
				continue;
				}
			var 
				fVal=f.value,
				errBlock=$id(fParam.errblock)||$id(fName+'_error');				
			f.obj=this;
			fParam.err=this.checkField(fVal, fParam, f);			
			try{
				if(!fParam.err && fParam.f_field_equal && fields[fParam.f_field_equal] && fVal!=$value(fParam.f_field_equal)){
					fParam.err='çíà÷åíèå íå ñîâïàäàåò';
					}
				}
			catch (e){}			
			
			if (fParam.err){				
				res=false;
				if (this.writeError(errBlock,fParam.err,f)){
					
					}	
					//f.onkeypress=this.clearErrorByClick;
									
				if (!toFocus){
					toFocus=f;
					}
				}
			else{
				this.clearError(errBlock);
				}
			if (res && is_function(params.addcheck) ){
				res=(params.addcheck)(this.getResult());
				}
			}
		if (toFocus) toFocus.focus();		
		return res;
		}
	
	this.preSubmiting=function(){
		var submitRes,
			obj=this.obj;
		if (obj.isSuggesting()) {
			return false;
			}
		obj.checkRes=obj.checking();		
		if (obj.checkRes){
			obj.doSubmit();
			}		
		return false;
		}
	this.doSubmit=function(){		
		if (this.checkRes){
			this.submiting.call(this.form)
			}
		else{
			return false;
			}
		}
	
	this.submiting=function(){		
		var submitRes,
			form=this.obj,
			formHTML=form.form,
			formFields=form.fields,
			res=false
			
		if (this.obj.params.formChecking){
			this.checkRes=$function(this.params.formChecking);
			}
		else{
			this.checkRes=form.checking();
			}
		
		
		if (!this.checkRes){
			return false;
			}
		
		form.getResult();
		var sFunc=form.userSubmit?form.userSubmit:formSubmiting;		
		submitRes=(typeof sFunc=='function')?sFunc.call(this.obj,form.result,this.obj):$function(sFunc,form.result);
		return false;
		}
	
	this.checkField=function(val, params, field){
		var fullData=this.getFieldData(params),
			res='';	
		if (
				(fullData.f_max && val.length>fullData.f_max) ||
				(fullData.f_min && val.length<fullData.f_min) ||
				(fullData.f_minvalue && !isNaN(val) && val<fullData.f_minvalue ) ||
				(fullData.f_maxvalue && !isNaN(val) && val>fullData.f_maxvalue ) ||
				(fullData.f_rule && val.length>0 && val.search(fullData.f_rule)<0) ||
				(fullData.f_values && !in_array(fullData.f_values,val)) ||
				(typeof fullData.f_callback == 'function' && !fullData.f_callback.call(field,val))
				
			){			
			res='íåêîððåêòíîå çíà÷åíèå';
			}
		
		if (fullData.f_addcheck && res==''){
			res=$function(fullData.f_addcheck,val);
			}
		return res;
		}
	
	this.getFieldData=function(params){		
		if (typeof params!='object'){
			params={
				'f_template':params
				};
			}
		
		var fieldData=params;	
		if (fieldData.f_template && FORM_TEMPLATES[fieldData.f_template]){
			fieldData = $.extend(true, {}, FORM_TEMPLATES[fieldData.f_template], fieldData);
			}	
		fieldData=concatObjects(fieldData,DEFAULT_FIELD_PARAMS);
		return fieldData;
		}
	
	this.writeError=function(errBlock, errText,f){
		errBlock=$id(errBlock);
		if (!errBlock) {
			if (f=$id(f)){				
				toggleClass(f,1,SWITCH_FIELD_ERROR_CLASSES);
				//f.onclick=this.clearErrorByClick;
				}
			return false;
			}
		errBlock.className='error showed';
		errBlock.innerHTML=errText;
		return true;
		}
	
	this.clearError=function (errBlock,f){
		errBlock=$id(errBlock);

		if (!errBlock) {
			if (f=$id(f)){
				toggleClass(f,0,['field-unerror','field-error']);
				}
			return false;
			}
		errBlock.innerHTML=''
		errBlock.className='error hidden'
		}
	
	this.clearErrorByClick=function (e){
		var form=this.obj,
		errBlock=$id(form.fields[this.id].errblock)||$id(this.id+'_error')
		form.clearError(errBlock,$id(this.id))
		if (this.onclick) this.onclick=null
		if (this.onkeypressed) this.onkeypressed=null
		}
	
	this.getResult=function(){
		var fields=this.fields;		
		for (fName in fields){
			var 
				fParam=fields[fName],
				fieldData=this.getFieldData(fParam),
				f=$id(fName)||this.form[fName];
			if (
					!f || 
					f.disabled || 
					( 
					 	!$displaying(f) && !in_array(['radio','hidden'],fieldData.f_type)
						) 
					){
				
				continue;
				}
				
			
			if (fieldData.f_type=='radio'){				
				this.result[fName]=getRadioValue(fName);
				}
			else if (fieldData.f_type=='textarea') {
				this.result[fName]=f.value;
				}
			else if (fieldData.f_type=='select' && f.multiple){
				this.result[fName]=(getSelectedOptions(f)).join(',');
				}
			else {
				this.result[fName]=fieldData['f_resSource']?f[fieldData['f_resSource']]:f.value;
				}				
			if (this.result[fName]==undefined || this.result[fName]==null){
				this.result[fName]=='';
				}
			}
		
		return this.result;
		}	
	
	this.isSuggesting=function(){
		
		var res=0
		for (var i=0;i<this.suggestedFields.length; i++){
			var f=this.suggestedFields[i];
			/* if (f.suggestData.block){
				res++;
				}	 */			
			}
		return (res || $('div.suggest:visible').length);
		}		
	
	this.putEvents();
	
	this.form.onsubmit=this.form.submit=this.preSubmiting;
	return false;	
}

/* Modern suggest
================================================*/
function Suggest(field,initData){
	var $this=this;
	/* Default settings */
	this.data={
		field:$id(field),
		requestPath:PATH_AJAX,
		answerFormat:'json',
		pseudoInputHeight:30,//px
		limit:10,
		_state:0,
		pressRegisterInterval:500,
		f_prepare:function(){
			return {};
			},
		f_onselect:function(){
			},
		itemStateClasses:['passive','active'],
		minContainerWidth:235
		};
	field._suggest=this;
	this.cache={};
	this.pressTimer=null;
	this.items=[];
	if (!this.data.field){
		throw new Error('wrong suggested field');
		}	
	this.setData(initData);
	EVENTS.append(
		this.data.field,
		['onfocus','onclick'],
		function(){
			$this.start();
			}
		);	
	}
	
	/* Start suggestion */
	Suggest.prototype.start=function(){	
		var $this=this;
		this.setData('_state',1);
		
		var 
			isFirstTime=!this.getData('pseudoField'),
			pseudoField=this.buildPseudoField();
		this.refreshSuggestList();
		if (isFirstTime){			
			EVENTS.append(
				pseudoField,
				'onkeydown',
				function(e){					
					var 
						keyPressed=getKeyPressed(e),
						symbolPressed=false;
					//this.symbolPressed=false;
					//this.mustKillBlock=false;
					//this.startPressTimer();					
					switch (keyPressed){
						case 'ENTER':
							$this.catchItem();
							break;
						case 'ARROWUP':
							$this.setActiveItem('prev');
							break;
						case 'ARROWDOWN':
							$this.setActiveItem('next');
							break;
						case 'ESC':
							$this.stop();
							break;
						case 'TAB':
							preventDefaultEvent(e);
							$this.setActiveItem('next');							
							return false;
							break;
						case 'HOME':
							return false;
							break;
						case 'END':
							return false;
							break;
						default:							
							$this.clearPressTimer();
							$this.pressTimer=setTimeout(
								function(){
									$this.clearPressTimer();
									
									$this.refreshSuggestList();									
									},
									$this.getData('pressRegisterInterval')
								);
							break;
						}
					
					}
				);
			}
		}
		
	Suggest.prototype.refreshSuggestList=function(){		
		var 
			$this=this,
			pseudoField=this.buildPseudoField(),
			value=$value(pseudoField);
		this.setData('value',value);									
		if (!this.isOn()){
			return false;
			}
		$this.suggesting(
			value,
			function(items){
				if (!$this.isOn()){
					return false;
					}
				/* On getting items */
				$this.appendItems(items);
				}
			);
		}
		
	Suggest.prototype.appendItems=function(items){
		var 
			$this=this,
			suggestListContainer=this.getSuggestListContainer();
		$clear(suggestListContainer);
		if (!items || !items.length){
			return false;
			}
		if (this.activeItem){
			this.activeItem.setActive(false);
			this.activeItem=null;
			}
		for(var i=0; i<items.length; i++){
			var item=items[i];
			if (!item.id){
				continue;
				}
			var li=setChildExt(
				{
					parent:suggestListContainer,
					tag:'LI',
					id:suggestListContainer.id+'_item_'+i,
					onmouseover:function(){
						this.setActive(true);
						},
					onmouseout:function(){
						this.setActive(false);
						},
					onclick:function(){
						$this.catchItem(this._itemNum);
						},
					params:{
						_itemNum:i,
						_data:item,
						setActive:function(state){
							toggleClass(this,(state?1:0),$this.getData('itemStateClasses'));
							if (state){
								$this.activeItem=this;
								}
							}
						},
					child:{
						tag:'SPAN',
						content:item.name_full						
						}
					}
				);
			this.items[i]=li;			
			}
		if (this.items[0]){
			this.items[0].setActive(true);
			}
		}
	
	Suggest.prototype.catchItem=function(itemNum){
		if (!this.activeItem){
			return false;
			}
		if (!isset(itemNum)){
			itemNum=this.activeItem._itemNum;
			}
		var 
			item=this.items[itemNum],
			field=this.getData('field');
		if (!item._data){
			return false;
			}
		this.setData('catchedData',item._data);
		$value(field,item._data.name_full);
		
		var f_onselect=this.getData('f_onselect');
		if (is_function(f_onselect)){		
			f_onselect.call(
				field,
				concatObjects(
					item._data,
					{
						_pseudoFieldValue:$value(this.getData('pseudoField'))
						}
					)
				);
			}
		this.stop();
		return;
		}
	Suggest.prototype.reset=function(){		
		var 
			field=this.getData('field'),
			pseudoField=this.getData('pseudoField'),			
			f_onselect=this.getData('f_onselect');
		
		this.setData('catchedData',{});
		$clearValue(field);
		$clearValue(pseudoField);
		this.setData('value','');
		if (is_function(f_onselect)){		
			f_onselect.call(
				field,
				{_pseudoFieldValue:''}
				);
			}
		this.stop();
		return;
		}
	
	/* Highlighted active item */
	Suggest.prototype.setActiveItem=function(itemNum){
		var activeNum=-1;
		if (this.activeItem && is_function(this.activeItem.setActive)){
			this.activeItem.setActive(false);
			activeNum=this.activeItem._itemNum;
			}
			
		if (itemNum=='next'){
			itemNum=activeNum+1;
			}
		if (itemNum=='prev'){
			itemNum=activeNum-1;
			}
			
		if (itemNum<0 && this.items && this.items.length){
			itemNum=this.items.length-1;
			}			
		if (itemNum>(this.items.length-1)){
			itemNum=0;
			}		
		var 
			item=this.items[Number(itemNum)];			
		if (item && is_function(item.setActive)){
			item.setActive(true);
			}
		return;
		}
	
	/* Sending request */
	Suggest.prototype.suggesting=function(value,onload){
		var 
			$this=this,
			f_rule=this.getData('f_rule');
		if (!value || (f_rule && value.search(f_rule)<0)){
			return false;
			}
		if (this.cache[value]){
			if (is_function(onload)){
				onload(this.cache[value]);
				}
			}
		else{
			$this.displayLoadingIndicator();
			makeAjaxExt(
				{					
					params:concatObjects(
						{
							todo:'suggest',
							suggestAction:this.getData('f_action'),
							value:value,
							limit:this.getData('limit')
							},
						(this.getData('f_prepare'))()
						),
					onload:function(res){
						$this.cache[value]=res;
						$this.hideLoadingIndicator();
						if (is_function(onload)){
							onload(res);
							};
						},
					notCache:false
					}
				);			
			}		
		}
	
	/* Stop suggestion */
	Suggest.prototype.stop=function(){
		$blur(this.getData('pseudoField'));
		unsetChild(this.getData('pseudoFieldContainer'));
		unsetChild(this.getData('suggestContainer'));
		this.setData(
			{
				pseudoFieldContainer:null,
				pseudoField:null,
				suggestContainer:null,
				_state:0
				}
			);
		
		/* toggleClass(this.getData('pseudoFieldContainer'),0);
		toggleClass(this.getData('suggestContainer'),0); */
		//this.setData('_state',0);
		this.activeItem=null;
		}
		
	/* Unset press timer */
	Suggest.prototype.clearPressTimer=function(){		
		if (this.pressTimer){
			clearTimeout(this.pressTimer);
			this.pressTimer=null;
			return true;
			}
		return false;
		}
	
	/* Display indicator while data loading */
	Suggest.prototype.displayLoadingIndicator=function(){
		var 
			loadingIndicator=setChildExt(
				{
					parent:this.getSuggestContainer(),
					tag:'STRONG',
					className:'progress',
					id:this.getFieldData('id')+'_loading',
					child:{
						tag:'SPAN',
						content:'Çàãðóçêà'
						}
					}
				);
		this.setData('loadingIndicator',loadingIndicator);
		return loadingIndicator;
		}
		
	/* Kill indicator */
	Suggest.prototype.hideLoadingIndicator=function(){		
		return unsetChild(this.getData('loadingIndicator'));
		}
	
	
	/* Build pseudofield and set focus on it */
	Suggest.prototype.buildPseudoField=function(){		
		var 
			$this=this,
			field=this.getData('field'),
			pos=getWhereIs(field),
			container=this.getData('pseudoFieldContainer'),
			pseudoField=this.getData('pseudoField'),
			containerStyle={
				width:Math.max(field.offsetWidth-2,this.getData('minContainerWidth')),
				height:this.getData('pseudoInputHeight'),
				left:pos.left,
				top:pos.top-this.getData('pseudoInputHeight')-2
				};	
		
		if (!container || !pseudoField){
			
			//Create and save pseudo field and container for first time running
			container=setChildExt(
				{
					className:'pseudo-input-container',
					id:this.getFieldData('id')+'_pseudoFieldContainer',
					style:containerStyle
					}
				);
			pseudoField=setChildExt(
				{
					parent:container,
					tag:'INPUT',
					id:this.getFieldData('id')+'_pseudoField',
					value:this.getData('value')
					}
				);
			/* EVENTS.append(
				field,
				'onclick',
				function(e){
					if (!e) {
						var e = window.event;
						}
					if (!e.arrested){
						e.arrested=[this,container,pseudoField];
						}
					else{
						e.arrested.push(this,container,pseudoField);
						}
					}
				); */
			toArrestEvent(field,[container,pseudoField]);
			TriDorogiPage.registerBlurKilled(
				container,
				function(){
					$this.stop();
					}
				);
			//toArrestEvent(pseudoField);
			//TriDorogiPage.registerBlurKilled(pseudoField);
			//EVENTS.append(pseudoField,'onblur',f.suggestControl.killBlockByBlur);
			this.setData(
				{
					'pseudoFieldContainer':container,
					'pseudoField':pseudoField
					}
				);
			}
		else{			
			//Refreshing position
			setStyle(container,containerStyle);
			}
		toggleClass(container,1);
		//Set focus
		$focus(pseudoField);
		moveCaretToEnd(pseudoField);
		//this.suggestData.symbolPressed=true
		//this.suggestObj.doSuggest.call(this)
		return pseudoField;			
		}
		
	Suggest.prototype.getSuggestContainer=function(){
		var 
			$this=this,
			field=this.getData('field'),
			pos=getWhereIs(field),
			suggestContainer=this.getData('suggestContainer'),
			suggestListContainer=this.getData('suggestListContainer'),
			resetBtn=this.getData('resetBtn'),			
			suggestContainerStyle={
				width:Math.max(field.offsetWidth-2,this.getData('minContainerWidth')),
				left:pos.left,
				top:pos.bottom
				};
			
		if (!suggestContainer || !suggestListContainer){
			suggestContainer=setChildExt(
				{
					className:'suggest',
					id:this.getFieldData('id')+'_suggest',
					style:suggestContainerStyle
					}
				);
			suggestListContainer=setChildExt(
				{
					tag:'UL',
					parent:suggestContainer,
					id:this.getFieldData('id')+'_suggest_list'
					}
				);
			resetBtn=setChildExt(
				{
					parent:suggestContainer,
					tag:'STRONG',
					className:'resetBtn',
					id:this.getFieldData('id')+'_reset',
					child:{
						tag:'A',
						content:'Ñáðîñèòü',
						onclick:function(){
							$this.reset();
							}
						}
					}
				);
			toArrestEvent(field,suggestContainer);
			toArrestEvent(suggestContainer,this.getData('pseudoFieldContainer'));
			TriDorogiPage.registerBlurKilled(suggestContainer);			
			}
		else{
			//Refreshing position
			setStyle(suggestContainer,suggestContainerStyle);
			}	
		toggleClass(suggestContainer,1);
		this.setData('suggestContainer',suggestContainer);
		this.setData('suggestListContainer',suggestListContainer);
		this.setData('resetBtn',resetBtn);
		return suggestContainer;
		}
		
	Suggest.prototype.getSuggestListContainer=function(){
		this.getSuggestContainer();
		return this.getData('suggestListContainer');
		}

	Suggest.prototype.getData=function(property){
		if (property){
			return this.data[property];
			}
		else{
			return this.data;
			}
		}
	
	Suggest.prototype.getFieldData=function(property){
		if (!this.isBuilded()){
			return false;
			}
		if (property){
			return (this.getData('field'))[property];
			}
		else{
			return this.getData('field');
			}
		}
	
	Suggest.prototype.setData=function(data,val){
		if (!data){
			return false;
			}
		if (typeof data=='object'){
			for (var opt in data){
				this.data[opt]=data[opt];
				}		
			}
		else{
			this.data[data]=val;
			}
		return this.data;
		}		

	Suggest.prototype.isBuilded=function(){
		return !!this.getData('field');
		}
	
	Suggest.prototype.isOn=function(){
		return (this.getData('_state')>0);
		}