/*!
 * Copyright 2011 Guangzhou Donghong Software Technology Inc.
 * Licensed under the www.jxstar.org
 */
 
/**
 * 处理选择控件的数据赋值。
 * 
 * @author TonyTan
 * @version 1.0, 2010-11-22
 */
JxSelect = {};

(function(){

	Ext.apply(JxSelect, {
		/**
		* 创建下拉选择数据的窗口对象
		* 
		* config: 选择数据的配置，参数有：						
			pageType: 'combogrid',
			nodeId: 'jz_type_v',
			isSame: '0',	//是否同名赋值
			isMoreSelect: '', //是否可以多选
			sourceField: 'jz_type.type_name;type_id',
			targetField: 'jz_list.type_name;type_id',
			whereSql: '',
			whereValue: '',
			whereType: ''
		* targetFlag: 目标对象类别标识，可能是node_funid_editgrid或node_funid_form
		*/
		createSelectWin: function(config, parentField, targetFlag) {
			if(parentField.readOnly || parentField.disabled){
				return;
			}

			//解决grid的选择控件穿透了弹出的对话框问题 start

			if(parentField.gridEditor){

				parentField.gridEditor.completeEdit();

			}

           //解决grid的选择控件穿透了弹出的对话框问题  end
			//处理多语言选择窗口配置信息
			JxLang.langSelectConfig(config);
			
			//如果是多选，页面类型改为
			var ismore = false;
			if (config.isMoreSelect == '1') {
				ismore = true;
				config.pageType = 'selgrid';
			}
			
			var self = this;
			var nodeId = config.nodeId;
			
			//功能对象信息
			var define = Jxstar.findNode(nodeId);
			if (define == null) {
				JxHint.alert(String.format(jx.star.nopage, nodeId));	//'没有定义【{0}】功能页面信息！'
				return;
			}
			
			//取创建页面的函数
			var hdCall = function(f) {
				var page = f(define, {pageType:config.pageType});
				//创建表格对象
				if (typeof page.showPage == 'function') {
					page = page.showPage(config.pageType);
				}
				//设置页面高度
				//page.height = 495;
				//-------------------增加多项的选择区域-------------------
				var items = [page], ly = 'fit', w = 750, h = 500;
				if (ismore) {
					w = 800; h = 560;
					ly = 'border';
					items = [
						{region:'south', xtype:'box', style:'border-top:1px solid #F0AD4E; background-color:#FFF;', height:68, 
							id:'xsel_more_data', html:'<ul></ul>'},
						{region:'center', xtype:'container', layout:'fit', items:[page]}
					];
					JxSelect.selectMoreData = {};//初始化数据
				}
				//----------------------------------------------------
				//创建对话框
				var	win = new Ext.Window({
					title: jx.base.select+define.nodetitle,	//'选择'
					layout: ly,
					width: w,
					height: h,
					border: false,
					modal: true,
					closeAction: 'close',
					items: items
				});
				win.show();
				
				//如果是布局页面，grid显示会延时，所以需要延时函数
				JxUtil.delay(500, function(){
					//如果page不是grid，则认为是树形页面，取左边的grid
					var selgrid = page;
					if (!selgrid.isXType('grid')) {
						selgrid = selgrid.getComponent(1);
						if (selgrid == null) {
							// wujh  改  2023-08-08 添加新控件id:sel_site_control
							if (nodeId === 'sel_site_control') {
								var selWinCfg = {};
								selWinCfg.config = config;
								selWinCfg.page = page;
								
								// 取目标grid或form，根据ID查找
								var tagRecord = self.selectTagRecord(parentField, targetFlag);
								selWinCfg.tagRecord = tagRecord;
						
								//取扩展值
								var whereValue = config.whereValue;
								//解析选择窗口中的[table.field];{table.field}参数
								whereValue = self.parseWhereValue(whereValue, parentField, targetFlag);
						
								selWinCfg.whereValue = whereValue;
									
								win.setSize(1200, 600);
								win.selWinCfg = selWinCfg;
								JxUtil.selAddrWinId = win.getId();//通过ID查询win对象
								return;
							}
							JxHint.alert(jx.star.nogrid);	//'选择功能页面不能识别表格，请检查！'
							return false;
						} else {
							selgrid = selgrid.getComponent(0);
						}
					}
					//查询栏中去掉selectwin的过滤条件
					config = self.clearWhere(config, parentField);
					
					var whereValue = config.whereValue;
					//解析选择窗口中的[table.field];{table.field}参数
					whereValue = self.parseWhereValue(whereValue, parentField, targetFlag);
					
					//显示表格对象后再加载数据才稳定
					if (selgrid.isShow == '1') {
						Jxstar.loadData(selgrid, {where_sql:config.whereSql, where_value:whereValue, where_type:config.whereType});
					} else {
						//不做缺省查询，但也要保留选择的where条件，在查询中能带上这个查询条件
						selgrid.jxstarParam.old_wsql = config.whereSql||'';
						selgrid.jxstarParam.old_wtype = config.whereType||'';
						selgrid.jxstarParam.old_wvalue = config.whereValue||'';
					}
					//添加选择数据的方法
					selgrid.on('rowdblclick', function(grid, n, event){
						
						//取选择的来源记录数据
						var srcRecords = JxUtil.getSelectRows(grid);
						//从选择区域中取数据
						if (ismore) srcRecords = JxSelect.getMoreData();
						
						if (srcRecords == null || srcRecords.length == 0) {
						//如果选择的记录为空，则说明是清空选择的数据
							var store = grid.getStore();
							srcRecords = []; srcRecords[0] = JxUtil.emptyRecord(store);
						} else {
							//如果不是多选，则只取第一天记录的值
							if (!ismore) srcRecords = [srcRecords[0]];
						}
						
						//修改前的值
						var orgValue = parentField.getValue();
						//取选择字段的容器对象，根据它判断是在grid控件中还是在查询控件中
						var fieldCt = parentField.ownerCt;
						//查询值或统计参数值的输入控件赋值
						if (fieldCt && fieldCt.initialConfig.name && fieldCt.initialConfig.name.indexOf('_qv') > 0) {
							self.setControlData(srcRecords, parentField, config.sourceField, config.targetField);
						} else {
							//取目标grid或form，根据ID查找
							var tagRecord = self.selectTagRecord(parentField, targetFlag);
							//给目标表赋值
							self.setSelectData(srcRecords, tagRecord, config.isSame, config.sourceField, config.targetField);
							//触发 grid.afteredit 事件
							if (targetFlag.indexOf('_editgrid') > 0) {
								self.fireAfterEdit(parentField, tagRecord, config);
							}
						}
						//隐藏选择的窗口
						win.close();
						//触发值改变事件
						parentField.fireEvent('change', parentField, parentField.getValue(), orgValue);
					});
					
					//-----------------多选添加数据，勾选选择、取消清除-----------------
					if (ismore) {
						var sm = selgrid.getSelectionModel();
						var fieldn = JxSelect.getMoreField(config.sourceField);
						sm.on('rowselect', function(xs, index, r){
							JxSelect.selRowData(fieldn, define.pkcol, r);
						});
						sm.on('rowdeselect', function(xs, index, r){
							JxSelect.delMoreData(fieldn, define.pkcol, r);
						});

						
						//打开窗口时，若是多选，自动加载表单中已选的记录到已选区中 add by simon.chen 20220227 start
						//取选择字段的容器对象，根据它判断是在grid控件中还是在查询控件中
						var fieldCt = parentField.ownerCt;
						//是否查询控件
						var isQryField = (fieldCt && fieldCt.initialConfig.name && fieldCt.initialConfig.name.indexOf('_qv') > 0);
						if(!isQryField){
							 //后台查询已选择记录后回调
							var selectedHdCall = function(data){
								for(var i = 0; i < data.length; i++){
									//将json转化为Record
									var r = JxSelect.createSelectedRecord(data[i],selgrid);
									//调用平台已有的选择记录方法，将历史已选记录加入到已选框中
									JxSelect.selRowData(fieldn, define.pkcol, r);
								}
							};
							//取目标grid或form，根据ID查找
							var tagRecord = self.selectTagRecord(parentField, targetFlag);
							//表单在获取记录数据时需要先获取myRecord
							var tagData = tagRecord.data;
							if (tagData == null) {//为空说明是form
								tagData = tagRecord.getFieldValues();
							}
							//获取选择窗口主键字段对应的目标字段
							var targetSelectedFkCol = JxSelect.getTargetSelectedFkCol(config.sourceField, config.targetField, define.pkcol);
							debugger
							//获取选择窗口主键字段对应的目标字段的值
							var targetSelectedFkVal = tagData[targetSelectedFkCol];
							//去掉最后一个分号，因为多选时最后一个是分号
							targetSelectedFkVal = targetSelectedFkVal.replace(/;$/,"");
							if (targetSelectedFkCol && targetSelectedFkVal){
								var whereSql = config.whereSql;
								if (whereSql && whereSql.length > 0){
									whereSql += ' and ';
								}
								whereSql += '(' + define.pkcol.replace('__','.') + ' in (\'' + targetSelectedFkVal.replace(/;/g,'\',\'') + '\'))';
								var options = {
									where_sql : whereSql,
									where_type : config.whereType,
									where_value : config.whereValue,
									callback : selectedHdCall
								};
								Jxstar.queryData(config.nodeId, options);
							}
						}
						//打开窗口时，若是多选，自动加载表单中已选的记录到已选区中 add by simon.chen 20220227 end
						
					}//---------------------------------------------------------
				});
			};

			//异步从JS文件加载功能对象
			var pathname = config.layoutPage;
			if (pathname == null || pathname.length == 0) {
				pathname = define.gridpage;
			}
			if (pathname == null || pathname.length == 0){
				JxHint.alert(String.format(jx.star.nopage, nodeId));	//'没有定义【{0}】功能页面信息！'
				return;
			}
			Request.loadJS(pathname, hdCall);
		},
		
		//查询栏中去掉selectwin的过滤条件
		clearWhere: function(config, parentField) {
			var retcfg = config;
			//取选择字段的容器对象，根据它判断是在grid控件中还是在查询控件中
			var fieldCt = parentField.ownerCt;
			//查询值或统计参数值的输入控件赋值
			if (fieldCt && fieldCt.initialConfig.name && (fieldCt.initialConfig.name.indexOf('_qv') > 0)) {
				var value = config.whereValue;
				if (value != null && (value.indexOf('\{') >= 0 || value.indexOf('[') >= 0)) {
					retcfg.whereValue = '';
					retcfg.whereType = '';
					retcfg.whereSql = '';
				}
			}
			return retcfg;
		},
		//多选的记录
		selectMoreData: {},
		//取标签字段名
		getMoreField: function(srcField) {
			if (srcField.length == 0) {
				alert('找不到标签字段，不能添加！');
				return null;
			}
			var srcNames = srcField.split(';');
			if (srcNames[0].length == 0) {
				alert('找不到标签字段，不能添加！');
				return null;
			}
			return srcNames[0].replace('.', '__');
		},
		//添加或删除选择的记录
		selRowData: function(fieldn, fkey, record) {
			if (!record) return;
			var id = record.get(fkey);
			if (!id) {
				alert('找不到主键，不能添加！'); return;
			}
			var selx = Ext.get('xsel_more_data').child('ul');
			var sid = selx.first('#'+id);
			if (sid) {
				//JxSelect.delMoreData(fieldn, fkey, record);
			} else {
				var seln = selx.insertHtml('beforeEnd', '<li class="x-seldata" id="'+ id +'">'+ record.get(fieldn) +'</li>', true);
				var deln = seln.insertHtml('beforeEnd', '<span class="top-fun-img"><i class="fa eb_remco bigger-110"></i></span>', true);
				deln.on('click', function(){
					JxSelect.delMoreData(fieldn, fkey, record);
				});
				JxSelect.selectMoreData[id] = record;
			}
		},
		delMoreData: function(fieldn, fkey, record) {
			var id = record.get(fkey);
			if (!id) {
				alert('找不到主键，不能移除！'); return;
			}
			var selx = Ext.get('xsel_more_data').child('ul');
			var sid = selx.first('#'+id);
			if (sid) sid.remove();
			
			JxSelect.selectMoreData[id] = null;
			delete JxSelect.selectMoreData[id];
		},
		getMoreData: function() {
			var ret = [], smd = JxSelect.selectMoreData;
			for (k in smd) {
				ret.push(smd[k]);
			}
			return ret;
		},


		/**
		 * 获取选择窗口主键字段对应的目标字段
		 * sourceField: 来源字段，格式：tablename.field;field;tablename1.field...
		 * targetField: 目标字段，格式：tablename.field;field;tablename1.field...
		 * pkcol: 选择窗口的主键字段，格式：tablename__field
		 * add by simon.chen 20220227
		 **/
		getTargetSelectedFkCol: function(sourceField, targetField, pkcol){
		   //如果定义了来源字段名与目标字段名根据对应关系赋值
		   if (sourceField != null && sourceField.length > 0) {
			  //分解来源字段名与目标字段名
			  var srcFields = sourceField.split(";");
			  var tagFields = targetField.split(";");
			  //第一个字段名必需带表名
			  var srcTableName = srcFields[0].split(".")[0];
			  var tagTableName = tagFields[0].split(".")[0];
			  //根据每个字段，取来源数据写入目标数据对象中
			  for (var i = 0; i < srcFields.length; i++) {
				 if (srcFields[i].length == 0 ||
					tagFields[i] == null || tagFields[i].length == 0) continue;
				 //构建来源数据字段名
				 var srcTmps = srcFields[i].split(".");
				 if(srcTmps.length > 1){
					srcFieldName = srcTmps[0] + '__' + srcTmps[1];
					srcTableName = srcTmps[0];
				 }else{
					srcFieldName = srcTableName + "__" + srcFields[i];
				 }
				 //构建目标数据字段名
				 var tagTmps = tagFields[i].split(".");
				 if(tagTmps.length > 1){
					tagFieldName = tagTmps[0] + '__' + tagTmps[1];
					tagTableName = tagTmps[0];
				 }else{
					if(tagFields[i].indexOf('__') > 0){
					   tagFieldName = tagFields[i];
					} else {
					   tagFieldName = tagTableName + "__" + tagFields[i];
					}
				 }
				 if(srcFieldName == pkcol)
					 return tagFieldName;
			  }
		   }
		   return '';
		},
		
		
		/**
		 * 创建已选择的一条记录
		 * rJson: 记录的json数据
		 * selgrid: 选择窗口的grid
		 * add by simon.chen 20220227
		 **/
		createSelectedRecord: function(rJson, selgrid){
			   //列模型
			   var cm = selgrid.getColumnModel();
			   //数据存储
			   var store = selgrid.getStore();
			   var record = new (store.reader.recordType)({});
			   var cols = record.fields.keys;
			   //给每个字段赋值
			   for (var i = 0; i < cols.length; i++){
				   var col = cols[i]
				   var colobj = cm.getColumnById(col);
				   record.set(cols[i], rJson[col]);
			   }
			   return record;
		},
		


		/**
		* 创建下拉选择数据的窗口对象
		* 
		* config: 选择数据的配置，参数有：						
			pageType: 'combogrid',
			nodeId: 'jz_type_v',
			isSame: '0',	//是否同名赋值
			sourceField: 'jz_type.type_name;type_id',
			targetField: 'jz_list.type_name;type_id',
			whereSql: '',
			whereValue: '',
			whereType: ''
		* menuDiv: 右键菜单显示块
		* targetFlag: 目标对象类别标识，可能是node_funid_editgrid或node_funid_form
		*/
		createComboGrid: function(config, menuDiv, targetFlag) {
			//处理多语言选择窗口配置信息
			JxLang.langSelectConfig(config);
			
			var self = this;
			var nodeId = config.nodeId;
			var parentField = menuDiv.parentField;
			//如果只读则不显示
			menuDiv.on('beforeshow', function(){
				if (parentField.readOnly) return false;
			});
			menuDiv.on('show', function(){
				var grid = this.getComponent(0);
				if (grid && grid.qryCt){
					var ct = grid.qryCt.getComponent(0);
					if (!ct) return;
					var len = ct.items.getCount();
					//默认缺省字段，有一个容器对象
					if (len == 1) {
						var cmp = ct.getComponent(0);
						if (cmp.isXType('box')){
							var fld = cmp.el.first('input', true);
							fld.value = '';
							fld.focus();
						}
					} else {
					//自定义查询方案取字段
						ct.items.each(function(fld, index){
							if (fld.isXType('field')){
								fld.setValue('');
								if (index == 0) fld.focus();
							}
						});
					}
				} else if (grid) {
					//查询字段在工具栏中
					var tbar = grid.getTopToolbar();
					var flds = tbar.findByType('field');
					Ext.each(flds, function(fld, index){
						fld.setValue('');
						if (index == 0) fld.focus();
					});
				}
			});
			
			//功能对象信息
			var define = Jxstar.findNode(nodeId);
			if (define == null) {
				JxHint.alert(String.format(jx.star.nopage, nodeId));	//没有定义【{0}】功能页面信息！
				return;
			}
			//查询栏中去掉selectwin的过滤条件
			config = self.clearWhere(config, parentField);
			
			//刷新表格中的数据
			var refreshData = function(page) {
				//解析查询参数值中的[]字段变量，如果在查询栏中使用，则会选择不到值
				var whereValue = config.whereValue;
				//解析选择窗口中的[table.field];{table.field}参数
				whereValue = self.parseWhereValue(whereValue, parentField, targetFlag);
				//显示表格对象后再加载数据才稳定
				Jxstar.loadData(page, {where_sql:config.whereSql, where_value:whereValue, where_type:config.whereType});
			}

			//取创建页面的函数
			var hdCall = function(f) {
				var page = f(define, {pageType:config.pageType});
				//创建表格对象
				if (typeof page.showPage == 'function') {
					page = page.showPage(config.pageType);
				}
				//设置grid高度
				page.height = 328;
				//把新页面添加到目标窗口中
				menuDiv.add(page);
				//重新显示目标窗口
				menuDiv.doLayout();
				
				//创建时显示数据
				refreshData(page);
				//显示时，刷新表格中的数据
				menuDiv.on('show', function(){
					refreshData(page);
				});
				menuDiv.on('destroy', function(){
					config = null;
					targetFlag = null;
					refreshData = null;
				});
				
				//添加选择数据的方法
				page.on('rowclick', function(grid, index, e){
					//rowclick事件会执行两次，用下面的方法判断不重复执行
					if (!menuDiv.isVisible()) return false;

					//取选择的来源记录数据
					var srcRecords = JxUtil.getSelectRows(grid);
					if (srcRecords == null || srcRecords.length == 0) {
					//如果选择的记录为空，则说明是清空选择的数据
						var store = grid.getStore();
						srcRecords = []; srcRecords[0] = JxUtil.emptyRecord(store);
					} else {
						//如果不是多选，则只取第一天记录的值
						srcRecords = [srcRecords[0]];
					}
						
					//取选择字段的容器对象，根据它判断是在grid控件中还是在查询控件中
					var fieldCt = parentField.ownerCt;
					//查询值或统计参数值的输入控件赋值
					if (fieldCt && fieldCt.initialConfig.name && fieldCt.initialConfig.name.indexOf('_qv') > 0) {
						self.setControlData(srcRecords, parentField, config.sourceField, config.targetField);
					} else {
						//取目标grid或form，根据ID查找
						var tagRecord = self.selectTagRecord(parentField, targetFlag);
						//给目标表赋值
						self.setSelectData(srcRecords, tagRecord, config.isSame, config.sourceField, config.targetField);
						//触发 grid.afteredit 事件
						if (targetFlag.indexOf('_editgrid') > 0) {
							self.fireAfterEdit(parentField, tagRecord, config);
						}
					}
					//隐藏选择的窗口
					menuDiv.hide();
				});
			};

			//异步从JS文件加载功能对象
			var pathname = define.gridpage;
			if (pathname == null || pathname.length == 0){
				JxHint.alert(String.format(jx.star.nopage, nodeId));	//'没有定义【{0}】功能页面信息！'
				return;
			}
			Request.loadJS(pathname, hdCall);
		},
		
		//触发表格编辑后事件
		fireAfterEdit: function(parentField, tagRecord, config){
			var gdom = parentField.el.findParentNode('div.x-grid-panel');
			var grid = Ext.getCmp(gdom.id);
			if (grid) {
				var field = config.fieldName.replace('.', '__');
				var e = {
					grid: grid,
					record: tagRecord,
					field: field,
					originalValue: parentField.getValue(),
					value: tagRecord.get(field)
				};
				grid.fireEvent("afteredit", e);
			}
		},
		
		//解析选择窗口中的[table.field];{table.field}参数
		parseWhereValue: function(whereValue, parentField, targetFlag) {
			var self = this;
			//如果含{table.field}表示，从父Form中取值，一般是Grid编辑的明细表中取父form
			if (whereValue != null && whereValue.indexOf('\{') >= 0) {
				var getRecord = function(subgrid) {
					if (!subgrid) return null;
					
					var form = JxUtil.getParentForm(subgrid);
					var tagRecord = null;
					//可编辑子表且没有主form对象时，form为null
					if (form) {
						tagRecord = form.myRecord;
						//如果有修改，先保存，否则取不到最新编辑的值
						if (form.isDirty()) {
							form.updateRecord(tagRecord);
							tagRecord.commit();
						}
					}
					//如果主表单没有打开，form.myRecord为null，则取表格记录
					if (!tagRecord) {
						var mGrid = JxUtil.getParentGrid(subgrid);
						if (mGrid) {
							var records = JxUtil.getSelectRows(mGrid);
							if (records && records.length > 0) {
								tagRecord = records[0];
							}
						}
					}
					return tagRecord;
				};
				if (targetFlag.indexOf('grid') >= 0) {
					var gdom = parentField.el.findParentNode('div.x-grid-panel');
					var subgrid = Ext.getCmp(gdom.id);
					
					var tagRecord = getRecord(subgrid);
					if (tagRecord) {
						whereValue = JxUtil.parseWhereValue(whereValue, tagRecord, true);
					}
				}
				//弹出子窗口subform中从父表中取值
				if (targetFlag.indexOf('form') >= 0) {
					var form = parentField.ownerCt;
					if (form.isXType('form') == false) {
						form = form.findParentByType('form');
					}
					var subgrid = form.getForm().myGrid;
					
					var tagRecord = getRecord(subgrid);
					if (tagRecord) {
						whereValue = JxUtil.parseWhereValue(whereValue, tagRecord, true);
					}
				}
			}
			//解析查询参数值中的[]字段变量，如果在查询栏中使用，则会选择不到值
			if (whereValue != null && whereValue.indexOf('[') >= 0) {
				var tagRecord = self.selectTagRecord(parentField, targetFlag);
				whereValue = JxUtil.parseWhereValue(whereValue, tagRecord);
			}
			return whereValue;
		},
		
		/**
		* private 取目标grid或form，根据ID查找。选择窗口或下拉GRID控件使用。
		* parentField -- 当前选择控件的字段对象
		* targetFlag -- 当前选择控件所在的PanelID，现在取消通过Ext.getCmp(targetFlag)的方式找控件
		*/
		selectTagRecord: function(parentField, targetFlag) {
			var tagRecord;
			if (targetFlag.indexOf('grid') >= 0) {
				var gdom = parentField.el.findParentNode('div.x-grid-panel');
				var grid = Ext.getCmp(gdom.id);
				if (grid) {
					var last = grid.lastEdit;
					if (last) {//防止标记到了下一行，实际触发原记录
						tagRecord = grid.getStore().getAt(last.row);
					} else {
						var selRecord = JxUtil.getSelectRows(grid);
						if (selRecord && selRecord.length > 0) {
							tagRecord = selRecord[0];
						}
					}
				}
			} else {
				var form = parentField.ownerCt;
				//有些自定义的form页面，字段的容器对象就是form
				if (form.isXType('form') == false) {
					form = form.findParentByType('form');
				}
				
				if (form) {
					tagRecord = form.getForm();
				}
			}
			if (Ext.isEmpty(tagRecord)) {//'没有找到目标记录对象，不能选择！'
				JxHint.alert(jx.star.notag);
			}
			
			return tagRecord;
		},
	
		/**
		* 处理选择表格数据的赋值方法，
		* 
		* srcRecords: 来源记录，是一个数组
		* fieldCtl: 目标选择控件
		* sourceField: 来源字段
		* targetField: 目标字段，如果是统计参数，不能添加表名
		*/
		setControlData: function(srcRecords, fieldCtl, srcField, tagField) {
			var self = this;
			var fieldCt = fieldCtl.ownerCt;
			//统计条件值输入控件
			if (fieldCt.isXType('toolbar') || srcField.indexOf(';') > 0) {
				var srcNames = srcField.split(';');
				var tagNames = tagField.split(';');
				if (srcNames[0].length == 0 || tagNames[0].length == 0) {
					JxHint.alert(jx.star.noselfield);
					return false;
				}
				//取来源字段的表名
				var srcTable = srcNames[0].split(".")[0];
				
				for(var i = 0, n = srcNames.length; i < n; i++) {
					if (srcNames[i].length == 0 || 
						tagNames[i] == null || tagNames[i].length == 0) continue;
						
					//构建来源数据字段名
					var srcTmps = srcNames[i].split(".");
					if(srcTmps.length > 1){
						srcName = srcTmps[0] + '__' + srcTmps[1];
						srcTable = srcTmps[0];
					}else{
						srcName = srcTable + "__" + srcNames[i];
					}
					//取来源字段的值
					var srcValue = self.getValue(srcRecords, srcName);
					
					//找到目标控件
					var tagName = tagNames[i].replace('.', '__');
					var fields = fieldCt.find('name', tagName);
					if (fields == null || fields.length == 0) continue;
					//给目标控件赋值
					fields[0].setValue(srcValue);
				}
			} else {
			//查询值输入控件
				var srcName = srcField.split(';')[0].replace('.', '__');
				if (srcName == null || srcName.length == 0) {
					JxHint.alert(jx.star.nosrc);	//'没有定义来源字段，不能选择记录！'
					return false;
				}
				
				var srcValue = self.getValue(srcRecords, srcName);
				fieldCtl.setValue(srcValue);
			}
		},

		/**
		* 处理选择表格数据的赋值方法，
		* 
		* srcRecords: 来源记录，是一个数组
		* tagRecord: 目标记录
		* isSame: 是否同名赋值 '1', '0'
		* sourceField: 来源字段，格式：tablename.field;field;tablename1.field...
		* targetField: 目标字段，格式：tablename.field;field;tablename1.field...
		*/
		setSelectData: function(srcRecords, tagRecord, isSame, sourceField, targetField) {
			var self = this;
			//来源字段名、目标字段名
			var srcFieldName, tagFieldName;

			//如果允许同名字段赋值，则先处理同名字段的值
			var tagData = tagRecord.data;
			if (tagData == null) {//为空说明是form
				tagData = tagRecord.getFieldValues();
			}
			if (isSame == '1'){
				for(srcFieldName in srcRecords[0].data) {
					var srctmp = srcFieldName.split("__")[1];
					for(tagFieldName in tagData) {
						var tagtmp = tagFieldName.split("__")[1];
						//auditing字段的值不赋值
						if (srctmp.indexOf('auditing') < 0 && srctmp == tagtmp) {
							//取值赋给目标数据对象
							tagRecord.set(tagFieldName, self.getValue(srcRecords, srcFieldName));
						}
					}
				}
			}

			//如果定义了来源字段名与目标字段名根据对应关系赋值
			if (sourceField != null && sourceField.length > 0) {
				//分解来源字段名与目标字段名
				var srcFields = sourceField.split(";");
				var tagFields = targetField.split(";");
				//第一个字段名必需带表名
				var srcTableName = srcFields[0].split(".")[0];
				var tagTableName = tagFields[0].split(".")[0];

				//根据每个字段，取来源数据写入目标数据对象中
				for (var i = 0; i < srcFields.length; i++) {
					if (srcFields[i].length == 0 || 
						tagFields[i] == null || tagFields[i].length == 0) continue;
					//构建来源数据字段名
					var srcTmps = srcFields[i].split(".");
					if(srcTmps.length > 1){
						srcFieldName = srcTmps[0] + '__' + srcTmps[1];
						srcTableName = srcTmps[0];
					}else{
						srcFieldName = srcTableName + "__" + srcFields[i];
					}

					//构建目标数据字段名
					var tagTmps = tagFields[i].split(".");
					if(tagTmps.length > 1){
						tagFieldName = tagTmps[0] + '__' + tagTmps[1];
						tagTableName = tagTmps[0];
					}else{
						if(tagFields[i].indexOf('__') > 0){
							tagFieldName = tagFields[i];
						} else {
							tagFieldName = tagTableName + "__" + tagFields[i];
						}
					}

					//取值赋给目标数据对象
					tagRecord.set(tagFieldName, self.getValue(srcRecords, srcFieldName));
				}
			}
		},
		
		//构建查询combosel控件
		//值必须是选择的，则会造成其它附带字段值没法清空
		initCombo: function(funId, combo, targetFlag, isAll) {
			var self = this;
			//继续添加初始参数
			combo.pageSize = 10;
			combo.minListWidth = 350;
			combo.typeAhead = false;
			combo.minChars = 0;
			combo.itemSelector = 'div.search-item';
			combo.queryParam = 'where_value';//后台查询值的参数名
			combo.loadingText = '正在查询...';
			combo.listEmptyText = '没有找到数据...';
			//当数据比较多时，会造成不能选择值，值比较少的控件适合用这种方式
			combo.isAll = combo.isAll || isAll || (Jxstar.systemVar.edit__combo__all == '1');
			
			var colCode = combo.getName();
			//从后台取设计信息，构建控件元素
			//{selcfg:{},fields:[{name:'funall_default__func_name'},{}...],design:[{n:funall_default__func_name,w:165,h:false},{}...]}
			//selcfg:{nodeId:'sys_dept', sourceField:'sys_dept.dept_name;dept_id', targetField:'mat_app.dept_name;sys_user.dept_id', 
			//whereSql:"", whereValue:'', whereType:'', isSame:'0', queryField:'', likeType:''};
			var endcall = function(data) {
				//查询数据的功能ID
				var config = data.selcfg;
				if (!config || !data.fields) {//'智能选择字段【{0}】定义信息为空！'
					JxHint.alert(String.format(jx.star.selnot, colCode));
					return;
				}
				
				var qryFunId = config.nodeId;
				var qf = config.queryField||'', sf = config.sourceField||'';
				if (qf.length == 0 && sf.length == 0) {//'智能选择字段【{0}】扩展信息中必须定义来源字段或者查询字段！'
					JxHint.alert(String.format(jx.star.selsrc, colCode));
					return;
				}
				//查询栏中去掉selectwin的过滤条件
				config = self.clearWhere(config, combo);
			
				//要支持可以查询多个字段的值
				var qryParam = self.comboWhere(config);
				
				var e = encodeURIComponent;
				var server_param = JxThree.getServerParam(qryParam.where_sql, '', qryParam.where_type);
				var url = Jxstar.path + '/commonAction.do?eventcode=query_data&funid=queryevent&pagetype=grid';
					url += '&query_funid='+ qryFunId +'&server_param='+ e(server_param) +'&user_id='+Jxstar.session['user_id'];
				
				//创建数据对象
				var store = new Ext.data.Store({
					proxy: new Ext.data.HttpProxy({
						method: 'POST',
						timeout: 60000,
						url: url
					}),
					reader: new Ext.data.JsonReader({
						root: 'data.root',
						totalProperty: 'data.total'
					}, data.fields)
				});
				combo.store = store;
				
				//把日期字段提出来，处理日期字段显示格式
				var dfs = {}, dfn = 0;
				Ext.each(data.fields, function(item) {
					if (item.type == 'date') {
						dfn++;
						dfs[item.name] = item;
					}
				});
				
				//计算合计表格宽度，构建字段
				var ds = data.design, tw = 0, xt = [], j = 0;
				Ext.each(ds, function(item) {
					if (!item.h) {
						tw += item.w;
						//符合条件的是日期字段
						if (dfn > 0 && dfs[item.n]) {
							var f = dfs[item.n].dateFormat;
							xt[j++] = '<td style="width:'+ item.w +'px;">{[values.'+ item.n +' ? values.'+ item.n +'.format("'+ f +'") : ""]}</td>';
						} else {
							xt[j++] = '<td style="width:'+ item.w +'px;">{'+ item.n +'}</td>';
						}
					}
				});
				
				//根据查询功能的Grid设计文件解析出来
				var tpl = new Ext.XTemplate(
					'<tpl for="."><div class="search-item" style="width:'+ tw +'px;border-bottom:1px dotted #a3bae9;">',
						'<table border=0 style="width:100%;font-size:13px;"><tr>',
						xt.join(''),
						'</tr></table>',
					'</div></tpl>');
				combo.tpl = tpl;
				
				//都采用类似查询
				combo.on('beforequery', function(qe){
					var cb = qe.combo;
					var isAll = cb.isAll;//是否显示所有数据
					var lt = config.likeType;//匹配模式：all, left
					var qv = '', ov = '';
					//一个值可以查询多个字段
					for (var i = 0; i < qryParam.plen; i++) {
						ov = isAll ? '%;' : (((lt == 'left') ? '':'%') + qe.query + '%;');
						qv += ov;
					}
					
					//在查询的时候，解析选择窗口中的[table.field];{table.field}参数
					qryParam.where_value = self.parseWhereValue(config.whereValue, cb, targetFlag);
					
					//组合查询值
					var pv = qryParam.where_value;
					if (qv.length > 0) {
						qv = qv.substr(0, qv.length-1);
						
						if (pv && pv.length > 0) {
							qv = pv + ';' + qv;
						}
					} else {
						qv = pv;
					}
					qe.query = qv;
				});
				
				//智能选择控件赋值
				var setData = function(cb, record, isend) {
					//取选择字段的容器对象，根据它判断是在grid控件中还是在查询控件中
					var fieldCt = cb.ownerCt;
					//查询值或统计参数值的输入控件赋值
					if (fieldCt && fieldCt.initialConfig.name && fieldCt.initialConfig.name.indexOf('_qv') > 0) {
						self.setControlData([record], cb, config.sourceField, config.targetField);
					} else {
						//取目标grid或form，根据ID查找
						var tagRecord = self.selectTagRecord(cb, targetFlag);
						//给目标表赋值
						self.setSelectData([record], tagRecord, config.isSame, config.sourceField, config.targetField);
						
						//如果是EditGrid，则需给combo赋值
						if (targetFlag.indexOf('grid') >= 0) {
							cb.setValue(tagRecord.get(cb.getName()));
							//触发编辑后事件
							if (isend) self.fireAfterEdit(cb, tagRecord, config);
						}
					}
				};
				
				//选择记录赋值到表单中，记录当前选择的值
				combo.on('select', function(cb, record, index){
					setData(cb, record);
					cb.selValue = cb.getValue();
				});
				//当没有选择时，记录原值
				combo.on('focus', function(cb){
					cb.selValue = cb.getValue();
				});
				
				//如果不是只读，则清空选择值，然后保留输入值
				var readonly = config.isReadonly;
				//如果值为空或不是选择的值，则清空记录
				combo.on('blur', function(cb){
					if (targetFlag.indexOf('form') >= 0) {
						var value = cb.getValue();
						if (value.length == 0 || cb.selValue.length == 0 || (cb.selValue && cb.selValue != value)) {
							var record = JxUtil.emptyRecord(store);
							setData(cb, record);
						}
						if (readonly == '0') {
							cb.setValue(value);
						}
					}
				});
				
				//处理EditGrid中，编辑完成时的数据校验
				if (targetFlag.indexOf('grid') >= 0) {
					var editor = combo.gridEditor;
					if (editor) {
						//如果是必填字段，清空值时不会执行此事件
						editor.on('complete', function(ed, value, start){
							//如果原值与新值都为空，则不处理
							if (Ext.isEmpty(value) && Ext.isEmpty(start)) return;
							//如果值为空或不是选择的值，则清空记录
							var incb = ed.field;
							if (value.length == 0 || (value != start && value != incb.selValue)) {
								var record = JxUtil.emptyRecord(store);
								setData(incb, record, true);
								if (readonly == '0') {
									var fn = incb.getName();
									var tagRecord = self.selectTagRecord(incb, targetFlag);
									//修改目标record中的字段值，否则界面上不显示输入的值
									tagRecord.set(fn, value);
								}
							}
						});
					}
				}
				
				//EditGrid中，显示combo时会执行initList，所以需要重新绑定
				if (combo.list) {
					combo.view.tpl = combo.tpl;
					//选false，重新绑定store，否则分页栏无效
					combo.bindStore(store, false);
				}
			};
			
			//从后台取设计信息
			var params = 'funid=queryevent&selfunid='+ funId;
			params += '&colcode='+ colCode.replace('__', '.') +'&pagetype=grid&eventcode=query_selctl';
			Request.dataRequest(params, endcall);
		},
		
		//private 支持取多条记录中某个字段的值
		getValue: function(records, field) {
			var isMore = (records.length > 1);
			if (isMore) {
				var value = '';
				for (var i = 0, n = records.length; i < n; i++) {
					value += records[i].get(field) + ';';
				}
				return value;
			} else {
				var value = records[0].get(field);
				if (value == null) {
					var tmps = field.split("__");
					//如果设置的值为[val]格式，表示此值是常量值
					if (tmps.length > 1 && tmps[1].length > 0) {
						var name = tmps[1];
						if (name.charAt(0) == '[' && name.charAt(name.length-1) == ']') {
							value = name.substring(1, name.length-1);
						}
					}
				}
				return value;
			}
		},
		
		//private 构建智能查询的whereSql
		comboWhere: function(config) {
			var whereSql = config.whereSql;
			var whereValue = config.whereValue;
			var whereType = config.whereType;
			
			//解析查询字段的where
			var qf = config.queryField, len = 0;
			if (qf && qf.length > 0) {
				var fs = qf.split(';'), where = '', type = '';
				for (var i = 0; i < fs.length; i++) {
					if (fs[i].length > 0) {
						where += fs[i] + ' like ? or ';
						type += 'string;';
						len++;
					}
				}
				
				if (where.length > 0) {
					if (whereSql.length > 0) whereSql = '(' + whereSql + ') and '
					if (whereType.length > 0) whereType = whereType + ';';
					
					whereSql += '(' + where.substr(0, where.length - 4) + ')';
					whereType += type.substr(0, type.length - 1);
				}
			} else {
				//如果没有设置查询字段，则取来源字段的第一个字段
				var sf = config.sourceField;
				if (sf && sf.length > 0) {
					qf = sf.split(';')[0];
					if (qf.length > 0) {
						if (whereSql.length > 0) whereSql = '(' + whereSql + ') and ';
						whereSql = whereSql + qf + ' like ?';
						
						if (whereType.length > 0) whereType = whereType + ';';
						whereType = whereType + 'string';
						
						len = 1;
					}
				}
			}
			
			//传递plen，查询字段个数，用于构建whereValue
			return {where_sql:whereSql, where_value:whereValue, where_type:whereType, plen:len};
		},
		
		/**
		* 创建选择树形数据的窗口对象；要求来源字段必须填写。
		* 
		* config: 选择数据的配置，参数有：						
			pageType: 'checktree',
			nodeId: 'jz_type_v',
			isSame: '0',	//是否同名赋值
			sourceField: 'jz_type.type_name;type_id',
			targetField: 'jz_list.type_name;type_id',
			whereSql: '',
			whereValue: '',
			whereType: '',
			isMoreSelect: '0'
		* menuDiv: 右键菜单显示块
		* targetFlag: 目标对象类别标识，可能是node_funid_editgrid或node_funid_form
		*/
		createCheckTree: function(config, menuDiv, targetFlag) {
			//处理多语言选择窗口配置信息
			JxLang.langSelectConfig(config);
			
			var self = this;
			var nodeId = config.nodeId;
			var parentField = menuDiv.parentField;
			var ismore = config.isMoreSelect||'0';//是否可以多选
			var srcField = config.sourceField;
			
			//功能对象信息
			var define = Jxstar.findNode(nodeId);
			if (define == null) {
				JxHint.alert(String.format(jx.star.nopage, nodeId));	//没有定义【{0}】功能页面信息！
				return;
			}
			if (srcField.length == 0) {
				JxHint.alert(jx.req.text2);//'必须有来源字段定义！'
				return;
			};
			
			menuDiv.on('destroy', function(){
				config = null;
				targetFlag = null;
			});
			
			var getRecord = function(node, srcField) {
				var data = {};
				var attr = node.attributes;
				var fields = srcField.split(';');
				var table = fields[0].split('.')[0];
				for (var i = 0; i < fields.length; i++) {
					if (fields[i].length == 0) continue;
					
					var fs = fields[i].split('.');
					if (fs.length == 1) {
						data[table+'__'+fs] = attr[fs];
					} else {
						var fn = fields[i].replace('.', '__');
						data[fn] = attr[fs[1]];
					}
				}
				return new Ext.data.Record(data);
			};
			
			//添加选择数据的方法
			var seltree = function(flag) {
				//rowclick事件会执行两次，用下面的方法判断不重复执行
				if (!menuDiv.isVisible()) return false;
				
				//取选择的来源记录数据
				var srcRecords = [];
				if (ismore == '1') {//多选
					var selNodes = tree.getChecked(), first, other;
					Ext.each(selNodes, function(node){
						if (!first) {
							first = getRecord(node, srcField);
						} else {
							other = getRecord(node, srcField);
							Ext.iterate(first.data, function(key, value){
								first.data[key] += ';'+other.data[key];
							});
						}
					});
					if (first) srcRecords[0] = first;
				} else {
					var node = tree.getSelectionModel().getSelectedNode();
					if (node) srcRecords[0] = getRecord(node, srcField);
				}
				
				//清除选择的记录
				if (flag == '0') {
					var data = {};
					var fields = srcField.split(';');
					var table = fields[0].split('.')[0];
					for (var i = 0; i < fields.length; i++) {
						if (fields[i].length == 0) continue;
						
						var fs = fields[i].split('.');
						if (fs.length == 1) {
							data[table+'__'+fs] = '';
						} else {
							var fn = fields[i].replace('.', '__');
							data[fn] = '';
						}
					}
					srcRecords[0] = new Ext.data.Record(data);
				} else {
					if (srcRecords == null || srcRecords.length == 0) {
						JxHint.alert(jx.req.text3);//'没有选择记录！'
						return;
					}
				}
					
				//取选择字段的容器对象，根据它判断是在grid控件中还是在查询控件中
				var fieldCt = parentField.ownerCt;
				//查询值或统计参数值的输入控件赋值
				if (fieldCt && fieldCt.initialConfig.name && fieldCt.initialConfig.name.indexOf('_qv') > 0) {
					self.setControlData(srcRecords, parentField, config.sourceField, config.targetField);
				} else {
					//取目标grid或form，根据ID查找
					var tagRecord = self.selectTagRecord(parentField, targetFlag);
					//给目标表赋值
					self.setSelectData(srcRecords, tagRecord, config.isSame, config.sourceField, config.targetField);
				}
				//隐藏选择的窗口
				menuDiv.hide();
				
				var msg = '', selNodes = tree.getChecked();
				Ext.each(selNodes, function(node){
					if(msg.length > 0){
						msg += ', ';
					}
					msg += node.text;
				});
			};
			
			//查询数据URL
			var dataUrl = Jxstar.path + '/commonAction.do?eventcode=query_tree&funid=queryevent&add_grid=1';//把树形数据字段都加上，方便解析
				dataUrl += '&add_check='+ismore;
				dataUrl += '&tree_funid='+define.nodeid+'&user_id='+Jxstar.session['user_id'];
			//解析查询参数值中的[]字段变量，如果在查询栏中使用，则会选择不到值
			var whereValue = config.whereValue;
			//解析选择窗口中的[table.field];{table.field}参数
			whereValue = self.parseWhereValue(whereValue, parentField, targetFlag);
			//显示表格对象后再加载数据才稳定
			var e = encodeURIComponent;
				dataUrl += '&where_sql='+ config.whereSql +'&where_value='+ e(whereValue) +'&where_type='+ config.whereType;
				
			var tbar = new Ext.Toolbar({items:[
				{iconCls:'eb_select', text:'选择', handler:function(){seltree();}},
				{iconCls:'eb_clear', text:'清除', handler:function(){seltree('0');}},
				{iconCls:'eb_refresh', text:'刷新', handler:function(){tree.getLoader().load(tree.getRootNode());}}
				]});
			var tree = new Ext.tree.TreePanel({
				tbar:tbar,
				border:false,
				height:295,

				autoScroll:true,
				rootVisible:false,
				lines:false,
				useArrows:false,
				
				loader: new Ext.tree.TreeLoader({
					dataUrl: dataUrl
				}),
				
				root: new Ext.tree.AsyncTreeNode({id:'10', iconCls:'tree_root_ext', text:'刷新'})
			});
			//双击后选择
			if (ismore != '1') {
				tree.on('dblclick', function(n){
					seltree();
				});
			}
			
			//把新页面添加到目标窗口中
			menuDiv.add(tree);
			//重新显示目标窗口
			menuDiv.doLayout();
		}
	});//Ext.apply

})();