tree designer

/**
 * 
 * @description 树设计器对象
 */
function TreeDesigner() {
	UDeisgner.call(this);

	this.designerRelationMgr = null;
	this.create = createTree;
	this.loadXml = loadXmlTree;
//	this.preview = previewTree;
	this.toXml = toXmlTree;
	this.destory = destoryTree;
	this.toDesignerUnitInfo = getDesignerTreeUnitInfo;
	this.datasource = datasourceTree;
//	this.treeDesignerMap = new Map();
	this.dhxWins = null;
	this.tabbar = null;
	this.unitId = null;
	this.status = null;
	this.itemCopt = new Map();
	this.dynamicSetSizes = TD_dynamicSetSizes;
	this.getTreeRalationUnitId = TD_getTreeRalationUnitId;
	this.deleteRelationInTree = TD_deleteRelationInTree;
}

TreeDesigner.prototype.treeEntity = null; // 树的实体对象
TreeDesigner.prototype.treeObj = null; // 当前的树对象
TreeDesigner.prototype.ifrtree = null; // 将iframe 作为designer 属性

function datasourceTree(id, name) {
	this.ifrtree.contentWindow.setBack(id, name);
}

/**
 * 创建树单元
 * 
 * @param id 标签页id
 */
function createTree(containerObj, targetId) {
	var that = this;
	this.treeEntity = new TreeEntity(targetId);
	var menu = new dhtmlXMenuObject();
	menu.setSkin('dhx_ibusblue');
	menu.renderAsContextMenu();
	var treeId = that.treeEntity.id;
	menu.attachEvent("onclick", function(menuId,casState) {
		doMenuItemOnClick(targetId,menuId,tree,menu,treeId);
	});
	// 注册树节点的复选框选中事件处理函数
	menu.attachEvent("onCheckboxClick", function(id, state, zoneId, casState) {
		return treeCheckBoxClick(targetId, tree, id, state, zoneId, casState);
	});

	var divObj = createTreeDiv(targetId);
	containerObj.cells(targetId).attachObject(divObj);
	containerObj.setTabActive(targetId);
	var tree = new dhtmlXTreeObject(divObj, "100%", "100%", 0);
	tree.setSkin('dhx_ibusblue');
	tree.setImagePath("../unitdesigner/tree/imgs/dhtmlx/dhtmlxTree/ibus_blue/");
	tree.enableDragAndDrop(true,false);// 是否允许拖放动作
	tree.setDragBehavior("sibling");
	tree.enableCheckBoxes(true,true);
	tree.enableThreeStateCheckboxes(true);
	tree.setOnEditHandler(m_edit_func);
	// 双击编辑头事件
	tree.setOnDblClickHandler(function(nodeId) {
		tree.enableItemEditor(true);
	 	return false;
	});
	tree.enableContextMenu(menu);
	var treeString = "<tree id=\"0\">"
			+ "<item text=\"新建树单元\" open=\"1\" id='"
			+ targetId+ "' im0=\"folderClosed.gif\" im1=\"folderOpen.gif\" call=\"true\" select=\"1\">"
			+ "</item>" + "</tree>";
	tree.loadXMLString(treeString);
	that.treeEntity.name = "新建树单元";
	that.treeObj = tree;

	// 注册节点编辑事件处理函数
	tree.attachEvent("onEdit", function(state, id, value) {
		var falg = treeEditClick(targetId, state, id, tree, value);
		tree.enableItemEditor(false);
		return falg;
	});
	
	tree.attachEvent("onDrag", function(sId,tId,id,sObject,tObject){
//		return onDragImpl(targetId,sId,tId,id,sObject,tObject);
		return onDragImpl2(targetId,sId,tId,id,sObject,tObject);
	});
	/**
	 * description 树单元右键事件
	 */
	tree.attachEvent("onBeforeContextMenu", function(itemId) {
		return treeRightClick(targetId, tree, menu, itemId);
	});
	tree.showItemCheckbox(targetId,false);
}

function onDragImpl2(targetId,sId,tId,id,sObject,tObject){
//	alert("sId = " + sId);
//	alert("id = " + id);
	var designer = getSelfDesigner(targetId);
	var treeItems = designer.treeEntity.relationDS.items;
	var itemKeysArr = treeItems.keys;
	var itemObjectArr = [];
	for(var i = 0; i < itemKeysArr.length; i++){
		//alert("relationDs.title = " + treeItems.get(itemKeysArr[i]).title);
		itemObjectArr[i] = treeItems.get(itemKeysArr[i]);
	}
	//alert("itemObjectArr = " + itemObjectArr);
	var oldInd ="";
	for(var j = 0; j < itemKeysArr.length; j++){
		if(sId == itemKeysArr[j]){
			oldInd = j
		}
	}
	var newInd ="";
	if(id != null){
		for(var k = 0; k < itemKeysArr.length; k++){
			if(id == itemKeysArr[k]){
				newInd = k - 1;
			}
		}
	}else{
		newInd = itemKeysArr.length - 1;
	}
	if(oldInd > newInd){
		newInd = newInd + 1;
	}
//	alert("oldInd = " + oldInd);
//	alert("newInd = " + newInd);
	var mode = (oldInd <= newInd);
	var t = itemObjectArr;
	if (t) {
		if (mode) {
			var val = t[oldInd];
			for ( var j = oldInd; j < newInd; j++)
				t[j] = t[j + 1];
			t[newInd] = val;
		} else {
			var val = t[oldInd];
			for ( var j = oldInd; j >= (newInd + 1); j--)
				t[j] = t[j - 1];
			t[newInd] = val;
		}
	}
	var treeItemMap = treeItems.copy();
	//treeItems.clear();
	var newTreeItemMap = new Map();
	for(var m = 0; m < t.length; m++){
		newTreeItemMap.put(t[m].id,t[m]);
//		alert("t[m].title = " + t[m].title);
	}
//	treeItems = newTreeItemMap;
//	alert("treeItems = " + treeItems);
//	var relationDS = designer.treeEntity.getDataSource();
//	relationDS.items = newTreeItemMap;
	designer.treeEntity.relationDS.items.clear();
	designer.treeEntity.relationDS.items = newTreeItemMap;
	return true;
}

function onDragImpl(targetId,sId,tId,id,sObject,tObject){
	var designer = getSelfDesigner(targetId);
	if(id == null) return false;
	var item = showRelationTree(designer);
	var flag = true;
	try{
		if(item.keys.length == 0){
			item = designer.itemCopt.copy();
			flag = false;
		}else{
			designer.itemCopt = item.copy();
		}
		var itemsArr = [];
		for ( var i = 0; i < item.keys.length; i++) {
			itemsArr[i] = item.keys[i];
		}
		var itemsArrMap = new Map();
		for ( var i = 0; i < itemsArr.length; i++) {
			if(sId == itemsArr[i]){
				itemsArrMap.put(sId,i);
			}
			if(id == itemsArr[i]){
				itemsArrMap.put(id,i);
			}
		}
		if(itemsArrMap.get(sId) < itemsArrMap.get(id)){
			var itemsArr1 = [];
			var itemsArr2 = [];
			var itemsArr3 = [];
			for ( var i = 0; i < itemsArr.length; i++) {
				if(sId == itemsArr[i]){
					if(i > 0){
						itemsArr3 = (itemsArr.slice(0, i)).concat((itemsArr.slice(i+1)));
					}else {
						itemsArr3 = itemsArr.slice(1);
					}
				}
			}
			for ( var i = 0; i < itemsArr3.length; i++) {
				var itemsArr4 = itemsArr3.concat();
				if(itemsArr3.length != 0 && id == itemsArr[i]){
					itemsArr1 = itemsArr.splice(i, itemsArr3.length, sId);
					var len = itemsArr3.length - itemsArr1.length;
					for ( var y = 0; y < len; y++) {
						itemsArr2[y] = itemsArr4[y];
					}
					itemsArr2[len] = sId;
					itemsArr2 = itemsArr2.concat(itemsArr1);
				}
			}
		}
		if(itemsArrMap.get(sId) > itemsArrMap.get(id)){
			var itemsArr1 = [];
			var itemsArr2 = [];
			var itemsArr3 = [];
			for ( var i = 0; i < itemsArr.length; i++) {
				if(sId == itemsArr[i] && i > 0){
				   itemsArr3 = (itemsArr.slice(0, i)).concat((itemsArr.slice(i+1)));
				}
			}
			for ( var i = 0; i < itemsArr3.length; i++) {
				var itemsArr4 = itemsArr3.concat();
				if(itemsArr3.length != 0 && id == itemsArr[i]){
					var itemsArr3Length = itemsArr3.length;
					itemsArr1 = itemsArr3.splice(i, itemsArr3.length, sId);
					var len = itemsArr3Length - itemsArr1.length;
					for ( var y = 0; y < len; y++) {
						itemsArr2[y] = itemsArr4[y];
					}
					itemsArr2[len] = sId;
					itemsArr2 = itemsArr2.concat(itemsArr1);
				}
			}
		}
		itemsArrMap.clear();
		itemsArrMap = item.copy();
		item.clear();
		for ( var i = 0; i < itemsArr2.length; i++) {
			var titles = itemsArrMap.get(itemsArr2[i]).title;
			var isHidden = itemsArrMap.get(itemsArr2[i]).isHidden;
			var treeItem = new TreeItem(itemsArr2[i],titles);
			treeItem.isHidden = isHidden;
			item.put(itemsArr2[i], treeItem);
		}
		if(!flag){
			var relationDS = designer.treeEntity.getDataSource();
			relationDS.items = item;
		}
	}catch (e) {
		return false;
	}
	return true;
}


/**
 * 动态创建DIV
 * @param targetId 标签页ID
 */
function createTreeDiv(id) {
	var divObj = document.createElement('div');
	divObj.onmouseup = function(oevent) {
		if (!oevent)
			oevent = window.event;
		if (oevent.button == 2) {
			if (document.all)
				window.event.cancelBubble = true;
			else
				oevent.stopPropagation();
		}
	};
	divObj.setAttribute("id", id);
	divObj.className = "designer-bj";
	divObj.style.width = "100%";
	divObj.style.height = "100%";
	// document.body.appendChild(divObj);
	return divObj;
}

/**
 * 注册树节点的复选框选中事件处理函数
 * @param that 树单元设计器对象
 * @param tree 树Object
 * @param id 节点ID
 * @param state 状态
 */
function treeCheckBoxClick(targetId, tree, id, state, zoneId, casState) {
	var designer = getSelfDesigner(targetId);
	var relationDS = designer.treeEntity.getDataSource();// 调用关联树的数据源
	var childNodes = tree.getSubItems(targetId);
	if(childNodes.length == 0){
		var item = relationDS.items.get(id);
		if (state) {
			tree.deleteItem(id, targetId);
			item.isHidden = true;
			return true;
		}else{
			tree.insertNewChild(targetId, item.id, item.title);
			item.isHidden = false;
			if(!designer.treeEntity.enableCheckBox){
				tree.showItemCheckbox(item.id,false);
			}
			return true;
		}
	}
	if (state) {
		tree.deleteItem(id, designer.treeEntity.id);
		relationDS.items.get(id).isHidden = true;
	} else {
		var itemKeysArr = relationDS.items.keys;
		var idIndex = "";
		for(var i = 0; i < itemKeysArr.length; i++){
			if(id == itemKeysArr[i]){
				idIndex = i -1;
				if(idIndex <= 0){
					idIndex = 0;
				}
			}
		}
		var newInsertTopId = "";
		while(idIndex >= 0){
			insertTopId = itemKeysArr[idIndex--];
			var parentItemText = tree.getItemText(insertTopId);
			if(parentItemText != 0){
				newInsertTopId = insertTopId;
				break;
			}
		}
		
		var title = relationDS.items.get(id).title;
//		tree.insertNewChild(designer.treeEntity.id, id, title);
		if(newInsertTopId == ""){
			var firstItemId = tree.getItemIdByIndex(designer.treeEntity.id,0);
			var tempTitle = tree.getItemText(firstItemId);
			//alert("tempTitle = " + tempTitle);
			tree.insertNewNext(firstItemId,id,title);
			tree.deleteItem(firstItemId,false);
			tree.insertNewNext(id,firstItemId,tempTitle);
			if(!designer.treeEntity.enableCheckBox){
				tree.showItemCheckbox(firstItemId,false);
			}
		}else{
			tree.insertNewNext(newInsertTopId,id,title);
		}
		relationDS.items.get(id).isHidden = false;
	}
	if(!designer.treeEntity.enableCheckBox){
		tree.showItemCheckbox(id,false);
	}
//	tree.enableDragAndDropScrolling(false,false);// 是否允许拖放动作
//	tree.enableDragAndDropScrolling(true);// 是否允许拖放动作
	return true;
}

/**
 * 注册节点编辑事件处理函数
 */
function treeEditClick(targetId, state, id, tree, value) {
	var designer = getSelfDesigner(targetId);
	var relationDS = designer.treeEntity.getDataSource();
	// 编辑后事件
	if (state == 0 || state == 1 || state == 2) {
		return true;
	} else if (state == 3) {
		// 编辑根节点时
		if (tree.getLevel(id) == 1) {
			designer.treeEntity.name = tree.getItemText(id);
		}
		// 编辑二级节点时
		else if (tree.getLevel(id) == 2) {
			relationDS.items.get(id).title = tree.getItemText(id);
		}
	} else {
	}
	return true;
}

/**
 * description 创建与加载右键事件
 */
function treeRightClick(targetId, tree, menu, itemId) {
	var itemPosMap = new Map();
	//menu.clearAll();
	var designer = getSelfDesigner(targetId);
	// 根节点
	if (tree.getLevel(itemId) == 1) {
		tree.selectItem(itemId,true,false);
		var menuXml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?> " + "<menu>"
			+ "<item id='attribute' text='设置…'>" + "</item>"
			+ "<item id='relation' text='关联'>";
//		if(!menu.isItemEnabled("relation")) {
			var relationMap = designer.designerRelationMgr.getRelationInfo(targetId); // 通过设计器ID获取布局下所有设计器的信息
			for ( var i = 0; i < relationMap.keys.length; i++) {
				if (relationMap.get(relationMap.keys[i]).type != "tree") {
					menuXml += "<item id='" + relationMap.keys[i] + "' text='"
							+ relationMap.get(relationMap.keys[i]).text
							+ "' img='new.gif'></item>";
				}
			}
//		}
		menuXml += "</item>";
		menuXml += "<item id='unchainRelation' text='解除关联'>";
		menuXml += "</item>";
		
		menuXml += "<item id='relationItem' text='关联项'>";
			if (designer.treeEntity.type == "RELATION") {
//				var items = showRelationTree(designer); //显示关联树的数据
				var items = designer.treeEntity.relationDS.items;
				var itemKeys = items.keys;
				for ( var j = 0; j < itemKeys.length; j++) {
					var itemTitleId = items.get(itemKeys[j]).id;
					itemPosMap.put(itemTitleId,j);
					var itemTitleName = items.get(itemKeys[j]).title;
//					alert("itemTitleName = " + itemTitleName);
					var isHidden = items.get(itemKeys[j]).isHidden;
					if (isHidden) {
						menuXml += "<item id='" + itemTitleId + "' text='"+ itemTitleName + "' type='checkbox'/>";
					} else{
						menuXml += "<item id='" + itemTitleId + "' text='"+ itemTitleName+ "' type='checkbox' checked='true'/>";
					}
				}
			}
//			if (designer.treeEntity.type == "LEVEL") {
//				var levelDS = designer.treeEntity.getDataSource();
//			}
		menuXml += "</item>";
		menuXml += "<item id='file_sep_1' type='separator' /> ";
		menuXml += "<item id='relAssembleId' text='关系装配...'>";
		menuXml += "</item>";
		
		menuXml += "<item id='synchId' text='同步'>";
		menuXml += "</item>";

		menuXml += "<item id='treeExtendId' text='扩展...'>";
		menuXml += "</item>";
		menuXml += "</menu>";
		menu.clearAll();
		menu.loadXMLString(menuXml);
//		alert(menuXml);
//		tree.enableContextMenu(menu);
		setTreeState(targetId,tree,menu);
		var itemPosKeys = itemPosMap.keys;
		for(var i = 0; i < itemPosKeys.length; i++){
			menu.setItemPosition(itemPosKeys[i],i);
		}
		return true;
	}
	// 非根节点
	else if(tree.getLevel(itemId) == 2){
		menu.clearAll();
		tree.selectItem(itemId,true,false);
		var xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?> " + "<menu><item id='delItem' text='隐藏'></item></menu>";
		menu.loadXMLString(xmlString);
		return true;
	}
}

/**
 * return 返回关联后的关联树items
 */
function showRelationTree(that) {
	var relationDS = that.treeEntity.getDataSource();
	if(relationDS != null) {
		var items = relationDS.items;
	}
	return items;
}

/**
 * 创建树与加载树的时候，如果没有关联项，让其解除关联与关联项显示状态disabled
 * @param that 树单元设计器对象
 * @param tree 树Object
 * @param menu 菜单Object
 */
function setTreeState(targetId,tree,menu) {
	var designer = getSelfDesigner(targetId);
	if(designer.treeEntity.type == "RELATION") {
		if(!designer.treeEntity.isRelation) {
			menu.setItemEnabled("relation");
			menu.setItemDisabled("unchainRelation");
			menu.setItemDisabled("relationItem");
			menu.setItemDisabled("synchId");
		}else{
			menu.setItemDisabled("relation");
			menu.setItemDisabled("relAssembleId");
			menu.setItemEnabled("unchainRelation");
			menu.setItemEnabled("relationItem");
			menu.setItemEnabled("synchId");
		}
	}else if(designer.treeEntity.type == "LEVEL") {
		menu.setItemDisabled("relation");
		menu.setItemDisabled("unchainRelation");
		menu.setItemDisabled("relationItem");
		menu.setItemDisabled("synchId");
	}
}

/**
 * 树节点单击事件处理函数
 * @param id 标签页ID
 * @param designer 树单元设计器对象
 * @param menuId 菜单属性ID
 * @param tree 树Object
 * @param menu 菜单Object
 */
function doMenuItemOnClick(targetId,menuId,tree,menu,treeId) {
	var dhxWins;
	var designer = getSelfDesigner(targetId);
	// 属性
	if (menuId == "attribute") {
		onAttrribueButtonClick(targetId,menuId,menu,dhxWins);
		return;
	}
	// 关联
	else if (menuId == "relation") {
		return;
	}
	// 关联项
	else if (menu.getParentId(menuId) == "relationItem") {
		return;
	} 
	//树单元扩展
	else if (menuId == "treeExtendId") {
		treeExtends(targetId, menu, dhxWins);
		return;
	}
	//关系装配
	else if(menuId == "relAssembleId") {
		relationAssemble();
		return;
	}
	//同步
	else if(menuId == "synchId") {
		var items = showRelationTree(designer);
		items.clear();
		var itemId = tree.getSelectedItemId();
		tree.deleteChildItems(itemId);
		var unitId = designer.unitId;
		getRelationInfo(designer,unitId,tree,treeId);
		
		var childList = tree.getAllChildless();
		var idArray = childList.split(",");
		if(designer.treeEntity.enableCheckBox){
			for(var i = 0; i < idArray.length; i++){
				tree.showItemCheckbox(idArray[i],true);
			}
		}else{
			for(var i = 0; i < idArray.length; i++){
				tree.showItemCheckbox(idArray[i],false);
			}
		}
	}
	// 解除关联
	else if (menuId == "unchainRelation") {
		
		tree.deleteChildItems(tree.getSelectedItemId(),true);
		designer.treeEntity = new TreeEntity(treeId);
		designer.treeEntity.name = "新建树单元";
		tree.showItemCheckbox(treeId,false); //设置解除关联后将checkbox状态改为false
		tree.enableCheckBoxes(false,true);
		designer.status = null;
		return;
	}
	// 隐藏节点
	else if (menuId == "delItem") {
		var nodeId = tree.getSelectedItemId();
//		alert("tree.stopEdit() = " + tree.stopEdit());
		if (nodeId == tree.stopEdit()) {
			return;
		}
		var nodeIndexId = tree.getIndexById(nodeId);
		var nextNodeIndexId = nodeIndexId + 1;
		var nextId = tree.getItemIdByIndex(treeId,nextNodeIndexId);
		tree.deleteItem(nodeId, false); // 隐藏节点
		tree.selectItem(nextId,false); //选中下一个节点
		//designer.treeEntity.isRelation = true; //设置关联
		var relationDS = designer.treeEntity.getDataSource();
		relationDS.items.get(nodeId).isHidden = true;// 更新项的隐藏状态为true
		return true;
	}
	// 处理具体的关联类型，如关联到列表单元等
	else {
		designer.status = 0;
		if(menuId == "relationItem") {return;}
		getRelationInfo(designer,menuId,tree,treeId);
//		if(tree.hasChildren(treeId) > 0) {
//			tree.showItemCheckbox(null,false);
//		}else{
//			tree.showItemCheckbox(treeId,false);
//		}
		var childList = tree.getAllChildless();
		var idArray = childList.split(",");
		if(designer.treeEntity.enableCheckBox){
			for(var i = 0; i < idArray.length; i++){
				tree.showItemCheckbox(idArray[i],true);
			}
		}else{
			for(var i = 0; i < idArray.length; i++){
				tree.showItemCheckbox(idArray[i],false);
			}
		}

	}
	return;
}

function returnRelList(designer,tree,tree) {
	var nodeAll = tree.getAllSubItems(treeId);
	var itemArray1 = [];
	var arrayId = nodeAll.split(",");
	itemArray1 = arrayId;
	for(var i=0;i<itemArray1.length;i++) {
		var nodeId = itemArray1[i];
	}
	
	var itemArray2 = [];
}

/**
 * 通过指定设计器ID获取该设计器的信息
 * 
 */
function getRelationInfo(designer,menuId,tree,treeId){
	var designerRelationXml = designer.designerRelationMgr.getDeisgnerInfo(menuId); // 通过指定设计器ID获取该设计器信息
	var xmlDoc = parseXml(designerRelationXml);
	var nodeObj = xmlDoc.documentElement;
	// 更新数据源属性信息
	var srcId = nodeObj.getAttributeNode("id").nodeValue;
	var relationDS = designer.treeEntity.getDataSource();
	relationDS.unitId = srcId; //树id
//	relationDS.unitTitle = srcTitle; //树的名称
	var nodes = nodeObj.nodeName; //获取实体的名称
	if(nodes == "FormEntity") {
		nodes = nodeObj.childNodes;
		for ( var r = 0; r < nodes.length; r++) {
			if(nodes[r].nodeName == "item") {
				try {
					var itemId = nodes[r].getAttributeNode("id").nodeValue;
					var itemTitle = nodes[r].getAttributeNode("title").nodeValue;
					var isHidden = nodes[r].getAttributeNode("isHidden").nodeValue;
					var isFK = nodes[r].getAttributeNode("isFK").nodeValue;
					var fkType = nodes[r].getAttributeNode("fkType").nodeValue;
					if(isFK == "true" || isFK == true) {
						var treeItem = new TreeItem(itemId, itemTitle);
						treeItem.isHidden = false;
						treeItem.itemType = fkType;
						var relationDS = designer.treeEntity.getDataSource();
						relationDS.items.put(itemId, treeItem);
						tree.insertNewChild(treeId,itemId,itemTitle, "", "", "", "", "","");
					}
				}catch(e) {
					return;
				}
			}
		}
	}else if(nodes == "GridEntity") {
		nodes = nodeObj.childNodes[0].childNodes;
		for ( var r = 0; r < nodes.length; r++) {
			try {
				var itemId = nodes[r].getAttributeNode("id").nodeValue;
				var itemTitle = nodes[r].getAttributeNode("title").nodeValue;
				var isHidden = nodes[r].getAttributeNode("isHidden").nodeValue;
				var isFK = nodes[r].getAttributeNode("isFK").nodeValue;
				var fkType = nodes[r].getAttributeNode("fkType").nodeValue;
				if(isFK == "true" || isFK == true) {
					var treeItem = new TreeItem(itemId, itemTitle);
					treeItem.isHidden = false;
					treeItem.itemType = fkType;
					var relationDS = designer.treeEntity.getDataSource();
					relationDS.items.put(itemId, treeItem);
					tree.insertNewChild(treeId,itemId,itemTitle, "", "", "", "", "","");
				}
			}catch(e) {
				return;
			}
		}
	}
	designer.treeEntity.isRelation = true; // 设置关联隐藏
	designer.unitId = menuId;
	
}

/**
 * 属性菜单项单击事件处理函数
 * 
 * @param targetId 标签ID
 * @param designer 树单元设计器对象
 * @param menuId 属性ID
 * @param menu 菜单对象
 */
function onAttrribueButtonClick备份(targetId,menuId,menu,dhxWins) {
//	var dhxWins;
	var designer = getSelfDesigner(targetId);
	if (menuId == "attribute") {
		var event = getEvent();
		var mousePos = mousePosition(event);
		if (dhxWins == null) {
			dhxWins = new dhtmlXWindows();
			dhxWins.setSkin("dhx_ibusblue");
			dhxWins.attachViewportTo("winVP");
			dhxWins.setImagePath("../unitdesigner/tree/imgs/dhtmlx/dhxWindows/");
		}
		if (dhxWins.isWindow("TreeAttrWin")) {return;}
		var w1 = dhxWins.createWindow("TreeAttrWin", mousePos.x, mousePos.y,300, 430);
		dhxWins.window('TreeAttrWin').setModal(true);
		w1.setText("树单元属性");
		w1.button("minmax1").hide();
		w1.button("park").hide();
		w1.denyResize();
		var tabbar = w1.attachTabbar();
		tabbar.setSkin("ibusblue");
		tabbar.setImagePath("../unitdesigner/tree/imgs/dhtmlx/dhtmlxTabbar/");
		var tab_tree_xml = "<tabbar> "
				+ "<row> "
				+ "<tab id=\"tree_unit_attrId\" width='100px' selected=\"1\">基本属性 </tab> "
				+ "<tab id=\"tree_dataId\" width='100px'>数据源</tab> "
				+ "</row> " + "</tabbar>";
		tabbar.loadXMLString(tab_tree_xml); // 加载tabbar标签xml
		tabbar.cells("tree_unit_attrId").attachURL("../unitdesigner/tree/tree_attribute.jsp?targetId=" + targetId);
		tabbar.cells("tree_dataId").attachURL("../unitdesigner/tree/define_data.jsp?targetId=" + targetId);
//		designer.treeObj = tree;
		designer.ifrtree = tabbar.cells("tree_dataId")._frame;
		designer.dhxWins = dhxWins; // 将dhxWins对象作为designer属性
		designer.tabbar = tabbar; //将tabbar 作为designer属性
	}
}

/**
 * 属性菜单项单击事件处理函数
 * 
 * @param targetId 标签ID
 * @param designer 树单元设计器对象
 * @param menuId 属性ID
 * @param menu 菜单对象
 */
function onAttrribueButtonClick(targetId,menuId,menu,dhxWins) {
	var designer = getSelfDesigner(targetId);
	if (menuId == "attribute") {
		var event = getEvent();
		var mousePos = mousePosition(event);
		if (dhxWins == null) {
			dhxWins = new dhtmlXWindows();
			dhxWins.setSkin("dhx_ibusblue");
			dhxWins.attachViewportTo("winVP");
			dhxWins.setImagePath("../unitdesigner/tree/imgs/dhtmlx/dhxWindows/");
			designer.dhxWins = dhxWins;
		}
		if (dhxWins.isWindow("TreeAttrWin")) {return;}
		var w1 = dhxWins.createWindow("TreeAttrWin", mousePos.x, mousePos.y,300, 191);
		dhxWins.window('TreeAttrWin').setModal(true);
		w1.setText("树单元属性");
		w1.button("minmax1").hide();
		w1.button("park").hide();
		w1.denyResize();
		w1.attachURL("../unitdesigner/tree/tree_attribute.jsp?targetId=" + targetId);
	}
}

/**
 * 树单元扩展事件
 * @param targetId 标签页ID
 * @param designer 树单元设计器对象
 * @param menu 菜单Object
 * @param dhxWins 窗体Object
 */
function treeExtends(targetId, menu, dhxWins) {
	var designer = getSelfDesigner(targetId);
	if (dhxWins == null) {
		dhxWins = new dhtmlXWindows();
		designer.dhxWins = dhxWins;
		dhxWins.setSkin("dhx_ibusblue");
		dhxWins.attachViewportTo("winVP");
		dhxWins.setImagePath("../unitdesigner/tree/imgs/dhtmlx/dhxWindows/");
	}
	if (dhxWins.isWindow("eventExpand")) {
		return;
	}
	var extend = dhxWins.createWindow("eventExpand", 300, 0, 600, 410);
	extend.setText("树单元扩展");
	extend.button("minmax1").hide();
	extend.button("park").hide();
	extend.denyResize();
	var tabbar = extend.attachTabbar();
	tabbar.setSkin("ibusblue");
	tabbar.setImagePath("../unitdesigner/tree/imgs/dhtmlx/dhtmlxTabbar/");
	var tabbarXml = "<tabbar>" + "<row>"
			+ "<tab id=\"client_expand\" width='100px' selected=\"1\">客户端扩展"
			+ "</tab>" + "<tab id=\"server_expand\" width='100px'>服务端扩展"
			+ "</tab>" + "</row>" + "</tabbar>";
	tabbar.loadXMLString(tabbarXml);
	tabbar.cells("client_expand").attachURL("../unitdesigner/tree/tree_client.jsp?targetId=" + targetId);
	extend._frame = tabbar.cells("client_expand")._frame; 
	tabbar.cells("server_expand").attachURL("../unitdesigner/tree/tree_server.jsp?targetId=" + targetId);
}

/**
 * 加载树单元
 * 
 * @description
 */
function loadXmlTree(el, containerObj, targetId) {
	var that = this;
//	alert(serializeXml(el));
	var xmlFileDoc = parseXml(serializeXml(el));
	//var rootElement = xmlFileDoc.documentElement; //获得根节点元素
	var rootId = el.getAttributeNode("id").nodeValue;
	var rootText = el.getAttributeNode("name").nodeValue;
	var treeType = el.getAttributeNode("type").nodeValue;
	var enableCheckBox = el.getAttributeNode("enableCheckBox").nodeValue;
	var enableDragAndDrop = el.getAttributeNode("enableDragAndDrop").nodeValue;
	var enableItemEdit = el.getAttributeNode("enableItemEdit").nodeValue;
	var enableKeyboardNavigation = el.getAttributeNode("enableKeyboardNavigation").nodeValue;
	var enableMultiselection = el.getAttributeNode("enableMultiselection").nodeValue;
	// 创建菜单项
	var loadDhxMenu = new dhtmlXMenuObject();
	loadDhxMenu.setSkin('dhx_ibusblue');
	loadDhxMenu.renderAsContextMenu();
	// 加载后menu的单击事件
	loadDhxMenu.attachEvent("onclick", function(menuId) {
		doMenuItemOnClick(targetId, menuId, loadDhxTree, loadDhxMenu, rootId);
	});
	
	// 加载后注册树节点的复选框选中事件处理函数
	loadDhxMenu.attachEvent("onCheckboxClick", function(id, state, zoneId,casState) {
		return treeCheckBoxClick(targetId, loadDhxTree, id, state, zoneId, casState);
	});
	var divObj = createTreeDiv(targetId);
	containerObj.cells(targetId).attachObject(divObj);
	containerObj.setTabActive(targetId);
	
	loadDhxTree = new dhtmlXTreeObject(divObj, "100%", "100%", 0);
	loadDhxTree.setSkin('dhx_ibusblue');
	loadDhxTree.setImagePath("../unitdesigner/tree/imgs/dhtmlx/dhtmlxTree/ibus_blue/");
	loadDhxTree.enableDragAndDrop(true);
	loadDhxTree.setDragBehavior("sibling");
	loadDhxTree.setOnEditHandler(m_edit_func);
	loadDhxTree.enableCheckBoxes(true,true);
	loadDhxTree.enableThreeStateCheckboxes(true);
	// 双击编辑头事件
	loadDhxTree.setOnDblClickHandler(function(nodeId) {
		loadDhxTree.enableItemEditor(true);
		return false;
	});
	loadDhxTree.enableContextMenu(loadDhxMenu);
	
	var treeXmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
			+ "<tree id='0'>"
			+ "<item id='"+ rootId+ "' text='"+ rootText+ "' open='1' im0='folderClosed.gif' im1='folderOpen.gif' call='1' select='1'>"
			+ "</item>" + 
			"</tree>";
	loadDhxTree.loadXMLString(treeXmlString);
	that.treeEntity = new TreeEntity(rootId);
	var treeId = that.treeEntity.id;
	that.treeEntity.name = rootText;
	if(treeType == "RELATION") {
		var loadNodes = el.childNodes;
		if (loadNodes.length > 0) {
			var relationDS = that.treeEntity.getDataSource();
			if(relationDS != null) {
				var dsId = loadNodes[0].getAttributeNode("unitId").nodeValue;
				relationDS.unitId = dsId; //关联列表、表单等的ID值
				if(dsId != ""){
					that.treeEntity.isRelation = true; // 加载后设置关联隐藏
				}
			}
			var nodes = loadNodes[0].childNodes;
			for ( var r = 0; r < nodes.length; r++) {
				var itemId = nodes[r].getAttributeNode("id").nodeValue;
				var itemTitle = nodes[r].getAttributeNode("title").nodeValue;
				var itemIsHidden = nodes[r].getAttributeNode("isHidden").nodeValue;
				var itemType = nodes[r].getAttributeNode("itemType").nodeValue;
				if(itemIsHidden == "false") {
					var loadTreeItem = new TreeItem(itemId, itemTitle); // 更新树实体属性;
					loadTreeItem.isHidden = false;
					loadTreeItem.itemType = itemType;
					loadDhxTree.insertNewChild(rootId, itemId, itemTitle);
					relationDS.items.put(itemId, loadTreeItem);
				}else if(itemIsHidden == "true") {
					var loadTreeItem = new TreeItem(itemId, itemTitle);
					loadTreeItem.isHidden = true;
					loadTreeItem.itemType = itemType;
					relationDS.items.put(itemId, loadTreeItem);
				}
			}
		}
		
		if(relationDS.unitId != null) {
			that.status = 0; //处理树类型加载值
			if(!relationDS.unitId) {
				that.status = null; //处理树类型的状态
			}
		}
		that.unitId = relationDS.unitId;
	}else if(treeType == "LEVEL") {
//		alert("level");
		var mainDataNodes = el.getElementsByTagName("mainDataSource");
		var subDataNodes = el.getElementsByTagName("subDataSource");
		if(mainDataNodes != null) {
			for(var j=0;j<mainDataNodes.length;j++) {
				mainEntityId = mainDataNodes[j].getAttributeNode("entity").nodeValue;
				var idAttr = mainDataNodes[j].getAttributeNode("idAttr").nodeValue;
				var textAttr = mainDataNodes[j].getAttributeNode("textAttr").nodeValue;
				var relationAttr = mainDataNodes[j].getAttributeNode("relationAttr").nodeValue;
				var relationType = mainDataNodes[j].getAttributeNode("relationType").nodeValue;
				var mainDataSource = new MainDataSource(mainEntityId,idAttr,textAttr,relationAttr,relationType);
			}
		}
		if(subDataNodes != null) {
			for(var k=0;k<subDataNodes.length;k++) {
				subEntityId = subDataNodes[k].getAttributeNode("entity").nodeValue;
				var subIdAttr = subDataNodes[k].getAttributeNode("idAttr").nodeValue;
				var subTextAttr = subDataNodes[k].getAttributeNode("textAttr").nodeValue;
				var subRelationAttr = subDataNodes[k].getAttributeNode("relationAttr").nodeValue;
				var subRelationType = subDataNodes[k].getAttributeNode("relationType").nodeValue;
				var subMainAttr = subDataNodes[k].getAttributeNode("mainAttr").nodeValue;
				var subDataSource = new SubDataSource(subEntityId,subIdAttr,subTextAttr,subRelationAttr,subRelationType,subMainAttr);
			}
		}
//		loadDhxTree.insertNewChild(rootId,mainEntityId,subEntityId);
	}

	// 加载后，给树添加右键监听事件
	loadDhxTree.attachEvent("onBeforeContextMenu", function(itemId) {
		return treeRightClick(targetId, loadDhxTree, loadDhxMenu, itemId);
	});
	that.treeObj = loadDhxTree;
	loadDhxTree.showItemCheckbox(targetId,false);
	returnRelationAttr(loadDhxTree,targetId,enableCheckBox,enableDragAndDrop,enableItemEdit,enableKeyboardNavigation,enableMultiselection,treeId); //预览返回加载后属性设置
//	returnRelationAttr(loadDhxTree,targetId,enableDragAndDrop,enableItemEdit,enableKeyboardNavigation,enableMultiselection,treeId);
	
	loadDhxTree.attachEvent("onDrag", function(sId,tId,id,sObject,tObject){
		return onDragImpl2(targetId,sId,tId,id,sObject,tObject);
	});
	
	// 加载后注册节点编辑事件处理函数
	loadDhxTree.attachEvent("onEdit", function(state, id, value) {
		
		var falg = treeEditClick(targetId, state, id, loadDhxTree, value);
		loadDhxTree.enableItemEditor(false);
		return falg;
	});
}

/**
 * 预览返回加载后属性设置
 */
function returnRelationAttr(loadDhxTree,targetId,enableCheckBox,enableDragAndDrop,enableItemEdit,enableKeyboardNavigation,enableMultiselection,treeId) {
//function returnRelationAttr(loadDhxTree,targetId,enableDragAndDrop,enableItemEdit,enableKeyboardNavigation,enableMultiselection,treeId) {
	var designer = getSelfDesigner(targetId);
	//是否支持复选
	if(enableCheckBox == 'false') {
		loadDhxTree.enableCheckBoxes(0);
		loadDhxTree.enableThreeStateCheckboxes(false); // 是否支持复选框
		loadDhxTree.showItemCheckbox(null, false); 
		loadDhxTree.showItemCheckbox(loadDhxTree.getAllSubItems(treeId), false);
		designer.treeEntity.enableCheckBox = false;
	}else if(enableCheckBox == 'true'){
		loadDhxTree.enableCheckBoxes(1);
		loadDhxTree.showItemCheckbox(targetId, true);
		loadDhxTree.enableThreeStateCheckboxes(true); // 是否支持复选框
		loadDhxTree.showItemCheckbox(null,true);
		loadDhxTree.showItemCheckbox(loadDhxTree.getAllSubItems(treeId), true);
		designer.treeEntity.enableCheckBox = true;
	}
	if(enableDragAndDrop == 'false') {
		loadDhxTree.enableDragAndDrop(false); // 是否允许拖放动作
		loadDhxTree.setDragBehavior("sibling", true);
		designer.treeEntity.enableDragAndDrop = false;
	}else if(enableDragAndDrop == 'true'){
		loadDhxTree.enableDragAndDrop(true,false); // 是否允许拖放动作
		loadDhxTree.setDragBehavior("sibling");
		designer.treeEntity.enableDragAndDrop = true;
	}
	
	if(enableItemEdit == 'false') {
		loadDhxTree.enableItemEditor(false); //是否支持编辑
		designer.treeEntity.enableItemEdit = false;
	}else if(enableItemEdit == 'true'){ 
		loadDhxTree.enableItemEditor(true); //是否支持编辑
		designer.treeEntity.enableItemEdit = true;
	}
	
	if(enableKeyboardNavigation == 'false') {
		loadDhxTree.enableKeyboardNavigation(false); // 是否支持键盘导航
		designer.treeEntity.enableKeyboardNavigation = false;
	}else if(enableKeyboardNavigation == 'true'){
		loadDhxTree.enableKeyboardNavigation(true); // 是否支持键盘导航
		designer.treeEntity.enableKeyboardNavigation = true;
	}
	
	if(enableMultiselection == 'false') {
		loadDhxTree.enableMultiselection(false); // 是否支持多选
		designer.treeEntity.enableMultiselection = false;
	}else if(enableMultiselection == 'true'){
		loadDhxTree.enableMultiselection(false); // 是否支持多选
		designer.treeEntity.enableMultiselection = true;
	}
}

/**
 * 返回树单元的数据
 */
function toXmlTree() {
	var that = this;
	var dataXml = null;
	if (this.treeEntity != null) {
		this.treeEntity.rootTitle = this.designerRelationMgr.getSelfInfo(this.treeEntity.id);
		dataXml = this.treeEntity.getXml();
	}
//	alert("dataXml :="+dataXml);
	return dataXml;
}

/**
 * 销毁树单元
 */
function destoryTree() {
	return true;
}

/**
 * 返回树单元字段的信息
 */

function getDesignerTreeUnitInfo() {
	var designerMap = new Map();
	try {
		var relationDS = this.treeEntity.getDataSource();
		var items = relationDS.items;
		var itemKeys = relationDS.items.keys;
		for(var i=0;i<itemKeys.length;i++) {
			var itemId = items.get(itemKeys[i]).id;
			var itemName = items.get(itemKeys[i]).title;
			designerMap.put(itemId, itemName);
		}
	}catch (e) {
		alert(e);
	}
	return designerMap;
}

function TD_dynamicSetSizes(id,width,height){
	try{
		var unitDiv = document.getElementById(id);
		unitDiv.style.width = width;
		unitDiv.style.height = height;
	}catch (e) {
		// TODO: handle exception
	}
}

function TD_getTreeRalationUnitId(){
	if(this.treeEntity.relationDS != null){
		return this.treeEntity.relationDS.unitId;
	}else{
		return "";
	}
}

function TD_deleteRelationInTree(){
	this.treeObj.deleteChildItems(this.treeEntity.id,true);
	this.treeObj.showItemCheckbox(this.treeEntity.id,false); //设置解除关联后将checkbox状态改为false
	this.treeObj.enableCheckBoxes(false,true);
	this.treeObj.status = null;
	var tempName = this.treeEntity.name;
	this.treeEntity = new TreeEntity(this.treeEntity.id);
	this.treeEntity.name = tempName;
}