常规功能和模块自定义系统 (cfcmms)—020自定义grid方案(4改成任意层表头)

						/**
						 * 根据module的定义和schemeOrderId返回此列表方案的多层表头定义
						 */
						getColumnsWithMult : function(module, schemeOrderId) {

							var scheme = module.getGridScheme(schemeOrderId); // 当前选中的gridScheme
							// tf_orderid是二位数的，是最顶层，4位数的是第二层
							for (var i = scheme.tf_schemeGroups.length - 1; i >= 0; i--) {
								var sg = scheme.tf_schemeGroups[i];
								if (('' + sg.tf_gridGroupOrder).length > 2) {
									// 不是二位数，那么就不是顶层,将非顶层放在一块,看看能不能找到他的直接父层。
									// 如果找到了，就把自己加在父层的 columns 里面
									var subOrder = '' + sg.tf_gridGroupOrder;
									for (var j = i - 1; j >= 0; j--) {
										var parent = scheme.tf_schemeGroups[j];
										var parentOrder = '' + parent.tf_gridGroupOrder;
										if (parentOrder.length == subOrder.length - 2
												&& subOrder.substring(0, parentOrder.length) == parentOrder) {
											// 如果是直接的父级
											if (!parent.columns)
												parent.columns = [];
											parent.columns.unshift(scheme.tf_schemeGroups.pop());
											break;
										}
									}
								}
							}
							var columns = this.getLockedLeftColumns(module);
							// 递归生成grid 的 columns
							return columns.concat(this.addGroupAndField(module,
									scheme.tf_schemeGroups));
						},

						/**
						 * 生成指定数组定义的列表组和列表，这是一个递归调用的函数。
						 */
						getGroupAndField : function(module, groups) {
							var result = [];
							for ( var i in groups) {
								var sg = groups[i];
								// 是否需要分组
								var isgroup = sg.tf_isShowHeaderSpans;
								var group = {
									gridGroupId : sg.tf_gridGroupId,
									text : sg.tf_gridGroupName,
									locked : sg.tf_isLocked,
									columns : []
								};
								// 加入分组下的字段
								for ( var j in sg.tf_groupFields) {
									var gf = sg.tf_groupFields[j];
									var field = this.createColumn(module, sg, gf);
									if (field)
										if (isgroup) {
											this.canReduceTitle(group, field);
											group.columns.push(field);
										} else
											result.push(field);
								}
								if (isgroup) {
									result.push(group);
								}
								// 本分组下如果还有下层分组，则递归调用本函数
								if (sg.columns) {
									var subColumns = this.getGroupAndField(module, sg.columns);
									for ( var k in subColumns)
										if (isgroup)
											group.columns.push(subColumns[k])
										else
											result.push(subColumns[k])
								}
							}
							return result;
						},

						/**
						 * 建立一个列
						 */
						createColumn : function(module, group, groupfield) {
							var fd = module.getFieldDefine(groupfield.tf_fieldId);
							var field;
							if (fd) {
								if (fd.tf_isHidden)
									return null;
								field = this.getColumn(groupfield, fd, module);
							} else { // 如果不是本模块的基本字段，那么在附加字段中找（可能是父模块，祖父模块的字段，或者子模块的聚合字段）
								var fd = module.getAdditionFieldDefine(groupfield.tf_fieldId);
								field = this.getColumn(groupfield, fd, module);
								if (field.dataIndex.search('C_') == 0) {
									field.moduleName = field.dataIndex.slice(2);
									field.renderer = this.childCountFieldRenderer;
								}
							}
							field.locked = group.tf_isLocked || groupfield.tf_isLocked;
							// 如果列显示字段有附加的属性，如renderer 可以放在这里加入进去
							if (groupfield.tf_otherSetting) {
								try {
									eval('Ext.apply(field,{' + groupfield.tf_otherSetting + '})');
								} catch (err) {
									console.log(groupfield.tf_otherSetting + '解析出错。');
								}
							}
							return field;
						},

						getLockedLeftColumns : function(module) {
							var columns = [];
							// 是否有附件，有附件则加入附件按钮
							if (module.tf_hasAttachment
									&& module.tf_userRole.tf_attachmentBrowse)
								columns.push({
									locked : true,
									xtype : 'attachmentnumbercolumn'
								});

							// 是否模块具有审核功能
							if (module.tf_hasAuditing) {
								columns.push({
									locked : true,
									xtype : 'auditingactioncolumn'
								});
							}
							// 是否模块具有审批功能
							if (module.tf_hasApprove) {
								columns.push({
									locked : true,
									xtype : 'approveactioncolumn'
								});
							}

							// 是否模块具有支付功能
							if (module.tf_hasPayment) {
								columns.push({
									locked : true,
									xtype : 'payoutactioncolumn'
								});
							}
							// 如果是附件模块，加一个可以预览的列
							if (module.tf_moduleName == '_Attachment') {
								columns
										.push({
											dataIndex : 'tf_attachmentId',
											text : '预览',
											align : 'center',
											menuDisabled : true,
											sortable : true,
											width : 56,
											resizable : false,
											renderer : function(val, rd, model) {
												if (model.get('tf_filename'))
													return '<img height="16" width="16" src="attachment/preview.do?id='
															+ model.get('tf_attachmentId') + '" />';
												else
													return '<img height="16" width="16" src="" />';
											}
										});
							}
							// 如果模块有记录icon,则加入记录字段icon列
							if (module.tf_hasRecordIcon) {
								columns.push({
									xtype : 'recordiconcolumn'
								})
							}
							return columns;
						}