/****************************************************************
** Licensed Materials - Property of IBM
**
** IBM Cognos Products: drill
**
** (C) Copyright IBM Corp. 2001, 2013
**
** US Government Users Restricted Rights - Use, duplication or 
** disclosure restricted by GSA ADP Schedule Contract with 
** IBM Corp.
*****************************************************************/
// Copyright (C) 2008 Cognos ULC, an IBM Company. All rights reserved.
// Cognos (R) is a trademark of Cognos ULC, (formerly Cognos Incorporated).

var newMetadataObjects = null;
var allMetadataObjects = new Array();
var metadataTree = null;
var newWin = null;
var activeNodeFetches = new Array();
var metadataErrors = new Array();
var metadataTreeTracking = "";


function setupMetadataTree(locale)
{
		if (metadataTree == null)
		{
			cfgSet("doMetadataTree",true);

			if (cfgGet("BROWSER")=="moz")
			{	
				document.getElementById("metadataTreeContainer").addEventListener("mouseup", function(e) {if(e.target.toString().indexOf("XULElement") > -1){e.cancelBubble = true;return false;}}, true);
				document.getElementById("metadataTreeContainer").addEventListener("dragover", function(e) {e.preventBubble();}, true);
				document.getElementById("metadataTreeContainer").addEventListener("dragdrop", function(e) {e.preventBubble();}, true);
			}
			var metadataTreeNode = document.getElementById("metadataTreeContainer");
			if (typeof bidi != "undefined")
				metadataTree = new CTree (metadataTreeNode, "", false, false, "metadataTree", null, null, null, null, bidi);
			else
				metadataTree = new CTree (metadataTreeNode, "", false, false, "metadataTree");
	        metadataTree.setItemTabIndex(0);			
			metadataTree.setLabel(PMT_DMT_DRILL_METADATA_TREE_LABEL);	
			metadataTree.setLoadOnTheFlyFunction(loadFunc);
			metadataTree.setContextMenu(treeContextMenuFunc);
			metadataTree.setAllowSelectionToggle(true);
			metadataTree.setRecursiveSelect(false);
			if(cfgGet("activeTree"))
				metadataTree.setSingleClickFunc(treeFocus);
			else
				metadataTree.setSingleClickFunc(null);				
			metadataTree.setHideOuterTable(true);
		}
		if (locale != null){
		    metadataTree.setLocale(locale);
		}
}

function doMetadataTree(browser, locale)
{
		setupMetadataTree(locale);
		if (metadataTree.getHasBeenDrawn() == false)
		{
			metadataTree.removeLoading(metadataTree.getRootNode());
			metadataTree.drawAll();
			metadataTree.checkData();
		}
}

function getMetadataRequestString(model, startAtPath, depth, contextNodeRef)
{
	var cl="";
	var pl="";
	var pv="";
	var rsp="";

	// extract contentLocale and productLocale from the cookie
	var cookieValues = document.cookie.split(";");
	for (var i = 0; i < cookieValues.length; i++)
	{
		if (cookieValues[i].match(/^\s*CRN=/i))
		{
			var aLocales = decodeURIComponent(decodeURIComponent(cookieValues[i].split("=")[1])).split("&");
			for (var j = 0; j < aLocales.length; j++)
			{
				if (aLocales[j].match(/^contentLocale=/i))
					cl = aLocales[j].split("=")[1];
				if (aLocales[j].match(/^productLocale=/i))
					pl = aLocales[j].split("=")[1];
			}
		}
	}

	if (cl == "") cl = cfgGet("contentLocale");
	if (pl == "") pl = cfgGet("productLocale");
			
	var sUrl = "";

	if (model) sUrl += "&model=" + model;

	if (cl) sUrl += "&cl=" + cl;

	if (pl) sUrl += "&pl=" + pl;
		
	if (startAtPath) sUrl += "&startAtPath=" + startAtPath;

	if (contextNodeRef) sUrl += "&contextNodeRef=" + encodeURIComponent(contextNodeRef);

	if (pv == "") pv = cfgGet("parameterValues");

	if (pv) sUrl += "&parameterValues=" + encodeURIComponent(cfgGet("parameterValues"));

	if (rsp == "") rsp = cfgGet("RPT_SVC_PARAM");

	if (rsp) sUrl += "&rptSvcParam=" + encodeURIComponent(cfgGet("RPT_SVC_PARAM"));

	if (depth) sUrl += "&depth=" + depth;
	
	return sUrl;
}

function doMetadataRequest(request)
{
	var url = "b_action=xts.run&m=/" + prod_dir + "/metadata.xts" + request;
	if (cafContextId != "")
		url += "&ui.cafcontextid=" + cafContextId;
	if (metadataTreeTracking != "")
		url += "&m_tracking=" + metadataTreeTracking;
	if (typeof routingServerGroup != "undefined")
	{
		url += "&ui.routingServerGroup=" + routingServerGroup;
	}
	// Store each request just in case of timeout or prompting
	cfgSet("CURRENT_REQUEST",request);
	setDispatcherErrorHandler(errorHandler);
	sendDispatcherRequest(url, getMetadataResponse);
}

function promptResponse(parameters, response, conversation, clientContext, tracking)
{
	if (response == "Cancel" || response == "Error")
	{
		if( newWin ) {
			newWin.close();
			newWin = null;
		}
	}
	else
	{
		metadataTreeTracking = tracking;
		var myXMLParser = null;
		var x = cfgGet("parameterValues");
		if (x)
		{
			myXMLParser = new XMLParser(cfgGet("parameterValues"));
		}
		if( parameters.length > 0 )
		{
			if (myXMLParser==null)
				myXMLParser = new XMLParser(parameters[0]);
			else
				myXMLParser.appendChild(parameters[0]);
			for (var i = 1; i < parameters.length; i++)
			{
				// we may have to be smarter about this so that parameters don't show up multiple times
				myXMLParser.appendChild(parameters[i]);
			}
			// set the parameter values so that we aren't prompted again
			cfgSet("parameterValues", myXMLParser.toString());
			// the metadata tree should be in the response
		}
		// Use the current stored request, just in case there was a login or prompt
		var request = cfgGet("CURRENT_REQUEST") + "&metadataTree=" + encodeURIComponent(response);
		setTimeout('doMetadataRequest("' + jsencode(request) + '");', 100);
	}
}

function getMetadataResponse(response)
{
	// testResponseWin(response);	
	var metadataObjects = response.split(";");
	var nodeDepth = 0;
	var lastNodeDepth = 0;
	
	if (metadataObjects[0] == "working")
	{
		var request = "&doWait=1&contextNodeRef=" + jsdecode(metadataObjects[1]) + "&m_tracking=" + jsdecode(metadataObjects[2]) + "&parameterValues=" + encodeURIComponent(cfgGet("parameterValues"));
		if (metadataObjects[3] != "")
			request = request + "&depth=" + jsdecode(metadataObjects[3]);
		setTimeout('doMetadataRequest("' + jsencode(request) + '");', 100);
	}
	else if (metadataObjects[0] == "prompting")
	{
		var value = "";
		var moLength = metadataObjects.length;
		for (var i = 5; i < moLength; i++)
		{
			if (i < moLength - 1)
			{
				// make sure the semi-colons we split on above are replaced
				value += jsdecode(metadataObjects[i]) + ";";
			}
			else
			{
				// the last element does not need a semi-colon appended to it
				value += jsdecode(metadataObjects[i]);
			}
		}
		newWin = window.open("","","toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=630,height=310");
		var frmWarpRequest = newWin.document.createElement("form");
		if( cfgGet("BROWSER")=='moz') {
			newWin.document.open();
			newWin.document.close();
			newWin.document.body.appendChild(frmWarpRequest);
			frmWarpRequest.action=jsdecode(metadataObjects[1]);
		} else {
			newWin.document.body.appendChild(frmWarpRequest);
			frmWarpRequest.setAttribute("action", jsdecode(metadataObjects[1]));
		}
		frmWarpRequest.setAttribute("name", "formWarpRequest");
		frmWarpRequest.setAttribute("id", "formWarpRequest");
		frmWarpRequest.setAttribute("method", "post");
		// b_action
		frmWarpRequest.appendChild(createInput(newWin, "b_action", "xts.run"));
		// m
		frmWarpRequest.appendChild(createInput(newWin, "m", "prompting/promptDataSource.xts"));
		// <input type="hidden" name="callbackFunction" value="window.opener.promptResponse"/>
		frmWarpRequest.appendChild(createInput(newWin, "callbackFunction", "window.opener.promptResponse"));
		// clientContext
		frmWarpRequest.appendChild(createInput(newWin, "clientContext", jsdecode(metadataObjects[2])));
		// conversation
		frmWarpRequest.appendChild(createInput(newWin, "ui.conversation", jsdecode(metadataObjects[3])));
		// tracking
		frmWarpRequest.appendChild(createInput(newWin, "tracking", jsdecode(metadataObjects[4])));
		// <input type="hidden" name="releaseConversation" value="1"/>
		frmWarpRequest.appendChild(createInput(newWin, "releaseConversation", "1"));
		if (typeof routingServerGroup != "undefined")
		{
			frmWarpRequest.appendChild(createInput("routingServerGroup", routingServerGroup));
		}
		frmWarpRequest.appendChild(createInput(newWin, "htmlFragment", value));
		frmWarpRequest.appendChild(createInput(newWin, "newWindow", "1"));
		// isEncoded
		frmWarpRequest.appendChild(createInput(newWin, "isEncoded", "1"));
		frmWarpRequest.submit();
		newWin.focus();
	}
	else
	{
		if (metadataObjects[0] != "FAULT")
			metadataTreeTracking = metadataObjects.shift();
		newMetadataObjects = new Array();
		var activeNodeName;
		for (var i = 0; i < metadataObjects.length; i++)
		{
			if (metadataObjects[i].length > 0)
			{
				if (i == 0)
				{
					if (metadataObjects[0] == "FAULT")
					{
   						if (cfgGet("META_TreeLoadedFirstTime") == "loading")
   							cfgSet("META_TreeLoadedFirstTime", "failed");
						metadataFault(jsdecode(metadataObjects));
						metadataTree.childrenReadyForNode(metadataTree.getRootNode());
						return false;
					}
					else if ((response.indexOf("<HTML>") > -1) && (response.indexOf("<ERROR_COMPONENT>") > -1) && (response.indexOf("<ERROR_CODE>") > -1))
					{
						metadataFault(response);
						return false;
					}
					else
					{
						activeNodeName = jsdecode(convertBack(metadataObjects[i]));
					}
				}
				else if (i == 1)
				{				
					if (cfgGet("META_TreeLoadedFirstTime") == "loading")
					{
						var metadataModelName = jsdecode(convertBack(metadataObjects[1]));
						var metadataModelScreentip = jsdecode(convertBack(metadataObjects[2]));						
						if (metadataModelScreentip.indexOf("resubmitSingleHierarchy"))
						{
							metadataModelScreentip = metadataModelScreentip.substring(0,metadataModelScreentip.indexOf("resubmitSingleHierarchy"));
						}
						metadataTree.getRootNode().setName(metadataModelName);
						metadataTree.setRootNodeShowing(true);
						if (metadataModelScreentip != "")
							metadataTree.getRootNode().setTooltip(metadataModelScreentip);
						metadataTree.drawAll();
					}
					else
						continue;
				}
				else if (i == 2)
				{				
					if (metadataObjects[i].indexOf("resubmitSingleHierarchy") >= 0)
					{
						var thisNode = activeNodeFetches[activeNodeName][0];
						thisNode.hierarchyPath = jsdecode(convertBack(metadataObjects[5]));
						thisNode.hierarchyName = jsdecode(convertBack(metadataObjects[4]));
						var request = getMetadataRequestString(cfgGet("cmLastModel"), encodeURIComponent(jsdecode(convertBack(metadataObjects[3]))), 2, activeNodeName);
						setTimeout('doMetadataRequest("' + jsencode(request) + '");', 100);
						return true;
					}	
					continue;
				}
				else
				{
					var metaObj = metadataObjects[i].split(",");
					var nodeType = jsdecode(metaObj[0]);
					var metaArray = new Array();
					for (var j = 1; j < metaObj.length; j++)
					{
						metaArray[j - 1] = jsdecode(metaObj[j]);
					}
					if (nodeType.indexOf("firstChild") > -1)
					{
						nodeDepth += 1;
					}
					var metaNode = createNewMetaObject(metaArray, activeNodeName, nodeDepth);
					if( metaNode != null )
					{
						activeNodeFetches[activeNodeName][nodeDepth] = metaNode;
						if (nodeType.indexOf("lastChild") > -1)
						{
							var theNextChild = null;
							if (metadataObjects.length > (i + 1))
							{
								theNextChild = metadataObjects[i + 1].split(",");
								if (theNextChild[0].indexOf("firstChild") > -1)
								{
									lastNodeDepth += 1;
									continue;
								}
							}
							if (lastNodeDepth > 0)
							{
								if (theNextChild != null && theNextChild.length > 0)
								{
									var hild = "hild";
									var currentDepthThisChild = nodeType.substr(nodeType.lastIndexOf(hild) + hild.length);
									var currentDepthNextChild = theNextChild[0].substr(theNextChild[0].lastIndexOf(hild) + hild.length);
									var depthDiff = (currentDepthThisChild - currentDepthNextChild);
									if (depthDiff > 0)
									{
										nodeDepth -= depthDiff;
										if (nodeDepth < 0)
											nodeDepth = 0;
										lastNodeDepth -= depthDiff;
										if (lastNodeDepth < 0)
											lastNodeDepth = 0;
										continue;
									}
								}
								nodeDepth -= lastNodeDepth + 1;
								lastNodeDepth = 0;
							}
							else
							{
								nodeDepth -= 1;
							}
						}
					}
				}
			}
		}
		var thisNode = activeNodeFetches[activeNodeName][0];
		thisNode.getTree().childrenReadyForNode(thisNode);
		delete activeNodeFetches[activeNodeName];
		cfgSet("META_TreeLoadedFirstTime", true);
		for (var j in newMetadataObjects)
			allMetadataObjects[j] = newMetadataObjects[j];
	}
	return true;
}

function createInput(newWin, inputName, inputValue)
{
	var input = newWin.document.createElement("input");
	input.setAttribute("name", inputName);
	input.setAttribute("type", "hidden");
	input.setAttribute("value", inputValue);
	return(input);
}

function convertBack(str)
{
//	str = str.replace(/&semicolon/g, ";");
//	return str.replace(/&comma/g, ",");
	str = str.replace(/&semicolon/g, ";");
	str = str.replace(/\\>/g, ">");
	str = str.replace(/\\</g, "<");
	return str.replace(/&comma/g, ",");
}

function createNewMetaObject(metaObj, activeNodeName, nodeDepth)
{
	var selectType = cfgGet("SELECT_TYPE");
	var newNode = null;
	var setSelect = true;
	var path = convertBack(metaObj[3]);
	switch (metaObj[0])
	{
		case "querySubject":
			setSelect = cfgGet("selectQSubject");
			tntQuerySubject.setSelectable(setSelect);
			newMetadataObjects[path] = new mdFolder(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[7]));
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntQuerySubject, false, convertBack(metaObj[1]), path,  false);
			break;
		case "hierarchy":
			setSelect = cfgGet("selectHierarchy");
			tntHierarchy.setSelectable(setSelect);
			newMetadataObjects[path] = new mdFolder(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[7]));
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntHierarchy, false, convertBack(metaObj[1]), path,  false);
			newNode.m_HierarchyPath = convertBack(metaObj[4]);
			if (typeof metaObj[6] != "undefined" && convertBack(metaObj[6]) == "parentChild")
			{
				newNode.m_isParentChild = true;
			}
			break;
		case "filter":
			setSelect = cfgGet("selectFilter");
			tntFilter.setSelectable(setSelect);
			newMetadataObjects[path] = new mdFolder(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[7]));
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntFilter, false, convertBack(metaObj[1]), path,  false);
			break;

		case "dimension":
			setSelect = cfgGet("selectDimension");
			tntDimension.setSelectable(setSelect);
			newMetadataObjects[path] = new mdFolder(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[7]));
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntDimension, false, convertBack(metaObj[1]), path,  false);
			newNode.m_isDimension = true;
			break;
		case "measureDimension":
			/* This case is used to return the measure dimension	 */
		  setSelect = cfgGet("selectMeasureDimn");
			if(!setSelect) return newNode;
			tntMeasureDimension.setSelectable(setSelect);
			newMetadataObjects[path] = new mdFolder(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[7]));
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntMeasureDimension, false, convertBack(metaObj[1]), path,  false);
			
			return newNode;
			break;
		case "measure":
		
			/* This case is used to return the measure */
		  	setSelect = cfgGet("selectMeasure");
			if(!setSelect) return newNode;
			tntMeasure.setSelectable(setSelect);
			newMetadataObjects[path] = new mdQueryItem(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[6]), convertBack(metaObj[7]), convertBack(metaObj[8]), convertBack(metaObj[9]), convertBack(metaObj[10]), convertBack(metaObj[11]), convertBack(metaObj[12]), convertBack(metaObj[13]), convertBack(metaObj[15]), convertBack(metaObj[17]), convertBack(metaObj[19]),"");
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntMeasure, false, convertBack(metaObj[1]), path,  false);
			
			return newNode;
			break;
		case "rollupMeasure":
			/*  This case is used to return the rollup measures  */
		    setSelect = cfgGet("rollupMeasure");
			newMetadataObjects[path] = new mdQueryItem(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[6]), convertBack(metaObj[7]), convertBack(metaObj[8]), convertBack(metaObj[9]), convertBack(metaObj[10]), convertBack(metaObj[11]), convertBack(metaObj[12]), convertBack(metaObj[13]), convertBack(metaObj[15]), convertBack(metaObj[17]), convertBack(metaObj[19]), "");
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntRollupMeasure, false, convertBack(metaObj[1]), path,  false);
		 
			return newNode;
			break;
			
		case "queryItemFolder":
		case "measureFolder":
		case "hierarchyFolder":
		case "folder":
			setSelect = cfgGet("FALSE");
			tntFolder_2.setSelectable(setSelect);
			newMetadataObjects[path] = new mdFolder(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[7]));
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntFolder_2, false, convertBack(metaObj[1]), path,  false);
			break;
		case "namespace":
			setSelect = cfgGet("selectNamespace");
			tntNamespace.setSelectable(setSelect);
			newMetadataObjects[path] = new mdFolder(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[7]));
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntNamespace, false, convertBack(metaObj[1]), path,  false);
			break;
		case "calculation":
			newMetadataObjects[path] = new mdCalculation(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[6]), convertBack(metaObj[7]), convertBack(metaObj[8]), convertBack(metaObj[9]), convertBack(metaObj[10]), convertBack(metaObj[11]), convertBack(metaObj[12]), convertBack(metaObj[13]), convertBack(metaObj[15]), convertBack(metaObj[16]), convertBack(metaObj[17]), convertBack(metaObj[19]));
			if (metaObj[6] == 3) {
				setSelect = cfgGet("selectModelFact");
				tntCalculationFact.setSelectable(setSelect);
				newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntCalculationFact, false, convertBack(metaObj[1]), path,  false);
			} else if(metaObj[6] == 2) {
				setSelect = cfgGet("selectModelIdent");
				tntCalculationDimension.setSelectable(setSelect);
				newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntCalculationDimension, false, convertBack(metaObj[1]), path,  false);
			} else {
				setSelect = cfgGet("selectModelAttr");
				tntCalculationAttribute.setSelectable(setSelect);
				newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntCalculationAttribute, false, convertBack(metaObj[1]), path,  false);
			}
			break;
		case "namedSet":
			setSelect = cfgGet("selectNamedSet");
			tntNamedSet.setSelectable(setSelect);
			newMetadataObjects[path] = new mdQueryItem(convertBack(metaObj[1]), path, convertBack(metaObj[4]), 60, 7, 0, 0, 0, 0, "", "", "", "", "", convertBack(metaObj[18]), "");
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntNamedSet, false, convertBack(metaObj[1]), path,  false);
			break;
		case "level":
			setSelect = cfgGet("selectLevel");
			tntLevel.setSelectable(setSelect);
			newMetadataObjects[path] = new mdQueryItem(convertBack(metaObj[1]), path, convertBack(metaObj[4]), 60, 7, 0, 0, 0, 0, "", "", "", "", convertBack(metaObj[18]), "");
			newMetadataObjects[path].levelOrdinal = convertBack(metaObj[14]);
			newMetadataObjects[path].hun = convertBack(metaObj[16]);
			newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntLevel, false, convertBack(metaObj[1]), path,  false);
			break;
		case "queryItem":
			newMetadataObjects[path] = new mdQueryItem(convertBack(metaObj[1]), path, convertBack(metaObj[4]), convertBack(metaObj[5]), convertBack(metaObj[6]), convertBack(metaObj[7]), convertBack(metaObj[8]), convertBack(metaObj[9]), convertBack(metaObj[10]), convertBack(metaObj[11]), convertBack(metaObj[12]), convertBack(metaObj[13]), convertBack(metaObj[15]), convertBack(metaObj[17]), convertBack(metaObj[19]), convertBack(metaObj[16]));
			setSelect = cfgGet("selectQItem");
			if (metaObj[6] == 3) {
				tntQueryItemFact.setSelectable(setSelect);
				newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntQueryItemFact, false, convertBack(metaObj[1]), path,  false);
			} else if (metaObj[6] == 2) {
				tntQueryItemIdentifier.setSelectable(setSelect);
				newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntQueryItemIdentifier, false, convertBack(metaObj[1]), path,  false);
			} else {
				tntQueryItem.setSelectable(setSelect);
				newNode = new CTreeNode(activeNodeFetches[activeNodeName][nodeDepth - 1], tntQueryItem, false, convertBack(metaObj[1]), path,  false);
			}
			break;
		//***
		// The following entries are not to appear in the tree control for parameter or scope.
		//***
		case "calculationConstant":

		default:
			//alert("I don't know what this is: " + metaObj[0]);
			return newNode;
	}
	newNode.nodeMetaType = metaObj[0];
	newNode.setTooltip(convertBack(metaObj[2]));
	return newNode;
}

function metadataFault(metaFaultObjects)
{
	if ((typeof metaFaultObjects == "string") && (metaFaultObjects.indexOf("<HTML>") > -1) && (metaFaultObjects.indexOf("<ERROR_COMPONENT>") > -1) && (metaFaultObjects.indexOf("<ERROR_CODE>") > -1))
	{
		document.getElementById("metadataTreeContainer").innerHTML = metaFaultObjects;
		return;
	}
	metadataErrors = new Array();
	var maDenied = false;
	var maTimeout = false;
	for (var i = 0; i < metaFaultObjects.length; i++)
	{
		if (metaFaultObjects[i].indexOf("timeout") > -1)
			maTimeout = true;
		if (metaFaultObjects[i].indexOf("MA-DEF-0024") > -1)
			maDenied = true;
		metadataErrors[metadataErrors.length] = convertBack(metaFaultObjects[i]);
	}
	if (maTimeout==true)
	{
		metaLogonWindow(self);
	}
	else
	{
		cfgRemove("META_TreeLoadedFirstTime");
		metaErrorPage(metadataErrors);
	}
}



function mdFolder(name, path, ref, parent, description)
{
	this.name = name;
	this.ref = ref;
	this.path = path;
	this.parent = parent;
	this.description = description;
}

function mdCalculation(name, path, ref, datatype, usage, regularAggregate, semiAggregate, promptType, displayType, sortOnRef, promptCascadeOnRef, promptFilterItemRef, currency, parent, description)
{
	this.name = name;
	this.ref = ref;
	this.path = path;
	this.datatype = datatype;
	this.usage = usage;
	this.regularAggregate = regularAggregate;
	this.semiAggregate = semiAggregate;
	this.promptType = promptType;
	this.displayType = displayType;
	this.sortOnRef = sortOnRef;
	this.promptCascadeOnRef = promptCascadeOnRef;
	this.promptFilterItemRef = promptFilterItemRef;
	this.currency = currency;
	this.parent = parent;
	this.description = description;
}

function mdQueryItem(name, path, ref, datatype, usage, regularAggregate, semiAggregate, promptType, displayType, sortOnRef, promptCascadeOnRef, promptFilterItemRef, currency, parent, description, promptUseItemRef)
{
	this.name = name;
	this.ref = ref;
	this.path = path;
	this.datatype = datatype;
	this.usage = usage;
	this.regularAggregate = regularAggregate;
	this.semiAggregate = semiAggregate;
	this.promptType = promptType;
	this.displayType = displayType;
	this.sortOnRef = sortOnRef;
	this.promptCascadeOnRef = promptCascadeOnRef;
	this.promptFilterItemRef = promptFilterItemRef;
	this.promptUseItemRef = promptUseItemRef;
	this.currency = currency;
	this.parent = parent;
	this.description = description;
}

function loadFunc(loadingNode)
{
	if (cfgGet("META_TreeLoadedFirstTime") == null)
	{
		cfgSet("META_TreeLoadedFirstTime", "loading");
		activeNodeFetches[loadingNode.getValue()] = new Array(loadingNode);
		var req;
		var StAt = cfgGet("START_AT");
		req = getMetadataRequestString(cfgGet("cmLastModel"), StAt, 2, loadingNode.getValue());
		doMetadataRequest(req);
	}
	else if (cfgGet("META_TreeLoadedFirstTime") != "loading" && cfgGet("META_TreeLoadedFirstTime") != "failed")
	{
		var iDepth = 2;
		if (loadingNode.nodeMetaType == "measureDimension" || loadingNode.nodeMetaType == "measureFolder")
		{
			iDepth = 3;
		}
		activeNodeFetches[loadingNode.getValue()] = new Array(loadingNode);
		var req = getMetadataRequestString(cfgGet("cmLastModel"), encodeURIComponent(loadingNode.getValue()), iDepth, loadingNode.getValue());
		doMetadataRequest(req);
	}
}

function onDragStartF(evt)
{
	//get the event in a cross-browser fashion
	evt = (evt) ? evt : ((event) ? event : null);	
	
	//cancel any text selection
	clearSelection();

	//prevent the event from bubbling to other elements
	cancelBub(evt);
	
	var dragRef = evt.srcElement.getAttribute('dragRef');
	if (typeof dragRef == "string" && dragRef.length != 0)
	{
		var uiNode = getUINode(evt);
		if (uiNode)
		{
			//get the tree object
			var tree = uiNode.getAttribute('dragTree').toString();
			
			//get tree Node
			var node = getTreeNode(tree, dragRef);
			
			if (node.getNodeTypeObject().m_bIsDraggable == true)
			{
				if (!node.isSelected())
				{
					if ((evt.ctrlKey == false) && (evt.shiftKey == false))
					{
						node.getTree().getRootNode().setSelected(false);
					}
					//select all the children
					node.setSelected(true);
					//update the parent		
					node.updateParent();
									
					var label = document.getElementById(tree + node.getTreeRef() + 'label');
					label.className = getClassName(node, node.getTree());

					if ((evt.ctrlKey == false) && (evt.shiftKey == false))
					{
						node.getTree().redraw();
					}
				}
				var treeObj = node.getTree();

				var selectedNodes = treeObj.getSelectedFolderNodes();
				selectedNodes = selectedNodes.concat(treeObj.getSelectedLeafNodes());
				var arr = new Array();
				for (var i = 0; i < selectedNodes.length; i++)
				{
					var nodeObj = selectedNodes[i].getNodeTypeObject();
					arr[selectedNodes[i].getName()] = getTreeNodeObjectIcon(nodeObj);
				}
				showDragToolTip(arr, evt);

				if (cfgGetAt("ReportType", "crosstab") == true)
					dragStartCrosstab();
			}
			else
			{
				event.dataTransfer.clearData("Text");
			}
		}
	}
}

function onDragF(evt)
{
	var dtt = document.getElementById('dragToolTip');
	if (dtt && dtt.style && dtt.style.display == "inline")
	{
		dtt.style.left = (event.clientX + 20) + "px";
		dtt.style.top = event.clientY + "px";
	}
}

function onDragEndF(evt)
{
	var dtt = document.getElementById('dragToolTip');
	if (dtt && dtt.style)
	{
		dtt.style.display = "none";
	}

	if (cfgGetAt("ReportType", "crosstab") == true)
		dragEndCrosstab();
}

function showDragToolTip(arr, event)
{
	var htmlOUT = "<table cellspacing=\"0\" cellpadding=\"0\" class=\"clsTooltipTable\">";

	var childrenExist = false;
	for (var i in arr)
	{
		childrenExist = true;
		htmlOUT += "<tr nowrap=\"nowrap\"><td></td><td><img src=\"" + arr[i] + "\"/></td><td nowrap=\"nowrap\">&nbsp;" + i + "</td></tr>\n";
	}

	htmlOUT += "</table>";

	var dtt = document.getElementById("dragToolTip");
	if (dtt && dtt.style && childrenExist)
	{
		dtt.innerHTML = htmlOUT;
		dtt.style.zIndex = 100;
		dtt.style.position = "absolute";
		dtt.style.left = (event.clientX + 20) + "px";
		dtt.style.top = event.clientY + "px";
		dtt.style.display = "inline";
	}
}


function treeContextMenuFunc(evt)
{
	selectNode(evt);
}


function addSelectedDblClick(evt)
{
	// addSelected();
}

function getSelectedNode()
{	
	return processSelectedNode();
}
function processSelectedNode()
{
		
	var allSelectedNodes = metadataTree.getSelectedLeafNodes();
	var sSelected = "";
	if (allSelectedNodes.length > 0)
	{
		for (var i = 0; i < allSelectedNodes.length; i++)
		{
			if (allSelectedNodes[i].getNodeType() == TREE_ITEM)
			{
				var leafNode = allSelectedNodes[i];
				
				var nodeObject = allMetadataObjects[leafNode.getValue()];
				sSelected = nodeObject.ref;
				sMetaDataType = leafNode.nodeMetaType;
				sParentMetaDataType = leafNode.m_oParentTreeNode.nodeMetaType;
			}
		}
	}
	else
	{
		allSelectedNodes = metadataTree.getSelectedFolderNodes();
		if (allSelectedNodes.length > 0) {			
			var leafNode = allSelectedNodes[0];
			var nodeObject = allMetadataObjects[leafNode.getValue()];
			sSelected = nodeObject.ref;
			sMetaDataType = leafNode.nodeMetaType;
			sParentMetaDataType = leafNode.m_oParentTreeNode.nodeMetaType;
		}
	}	
	return {"sSelected":sSelected,"sMetaDataType":sMetaDataType,"sParentMetaDataType":sParentMetaDataType};
}

function addSelected(qid, groupType)
{
	var reportState = "";
	if (getReportFrame())
		reportState = getReportFrame().reportState;
	if (reportState == "" || reportState == "invalidPackage" || reportState == "noPackage" || reportState == "upgrading" || reportState == "submitted" || reportState == "prompting")
		return;

	var unfetchedChildren = metadataTree.getSelectedUnfetchedChildren();
	if (typeof qid == "undefined") 
	{
		qid = "";
	}
	if (unfetchedChildren)
		waitForFetchingChildren(qid, groupType);
	else
		processFetchedChildren(qid, groupType);
}

function waitForFetchingChildren(qid, groupType)
{
	if (metadataTree.getLoading())
		setTimeout("waitForFetchingChildren('" + qid + "', '" + groupType + "')", 100);
	else
		addSelected(qid, groupType);
}

function processFetchedChildren(qid, groupType)
{
	if (typeof qid == "undefined" || qid == null || qid == "null")
		qid = "";
	var allSelectedLeafNodes = metadataTree.getSelectionOrder();
	var sFilterCmd = null;
	for (var i = 0; i < allSelectedLeafNodes.length; i++)
	{
		if (allSelectedLeafNodes[i].getNodeType() == TREE_ITEM)
		{
			var leafNode = allSelectedLeafNodes[i];
			var nodeObject = allMetadataObjects[leafNode.getValue()];
			var nodeObjectType = getNodeObjectType(nodeObject);
			var nodeType = "XX";
			if (nodeObjectType == 'FILTER')
			{
				var oCC = cfgGet("combinedFilters");
				if (oCC)
				{
					var oF = new CFilter(oCC.generateID(), nodeObject.name, gsFILTER_REFTYPE_MODEL, gsFILTER_MODEL, nodeObject.ref, "none", nodeObject.name, null);
					oCC.getCurrentFilterGroup().addPredicate(oF);
					oF.setDirty();
					sFilterCmd = oCC.getCommand();
					continue;
				}
				else
				{
					nodeType = "OD";
				}
			}
			else if (nodeObjectType == 'CALCULATION')
				nodeType = "MX";
			if (nodeObjectType != 'FOLDER' )
				cc(nodeType, qid, nodeObject.ref, nodeObject.name, nodeObject.datatype, nodeObject.usage, nodeObject.regularAggregate, nodeObject.semiAggregate, nodeObject.promptType, nodeObject.displayType, nodeObject.sortOnRef, nodeObject.promptCascadeOnRef, nodeObject.promptFilterItemRef, groupType ? groupType : "none");
		}
	}
	
	if (sFilterCmd)
	{
		// a filter had been added
		var mc = cfgGet("MultiColumnAddCommand");
		
		// remove flag because report will be refresh, so we quit the 'wizard mode' for the combined filters. 
		dlgGlobalRemoveParm("xxFilterComplexMode");
		if (mc)
		{
			// Columns were added too. Submit the command and refresh the report
  		// Add filter command to the multi-command string
  		mc += ";" + sFilterCmd;
  		cfgSet("MultiColumnAddCommand", mc);
		}
		else {
		  // refresh the combined filter dialog
			complexFilter();
		}
	}
	endac();
	metadataTree.deSelectAll();
}

function getNodeObjectType(leafNode)
{
	if (leafNode instanceof mdCalculation)
		return "CALCULATION";
	else if (leafNode instanceof mdQueryItem)
		return "QUERYITEM";
	else if (leafNode instanceof mdFolder)
		return "FOLDER";
}

function getTreeNodeObjectIcon(leafNode)
{
	return leafNode.m_sIconSrc;
}

tntRoot.m_sIconSrc = "../" + images_dir + "/metadatatree/package.gif";
tntRoot.m_sIconOpenSrc = "../" + images_dir + "/metadatatree/package.gif";
tntRoot.m_sIconAltText = PMT_DMT_DRILL_METADATA_TREENODE_PACKAGE;
var tntQueryItem = new CTreeNodeType(TREE_ITEM, false,"../" + images_dir + "/metadatatree/metadata_attribute.gif", "../" + images_dir + "/metadatatree/metadata_attribute.gif");
tntQueryItem.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_ATTRIBUTE);
var tntQueryItemFact = new CTreeNodeType(TREE_ITEM, false,"../" + images_dir + "/metadatatree/query_item_fact.gif", "../" + images_dir + "/metadatatree/query_item_fact.gif");
tntQueryItemFact.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_QUERY_ITEM_FACT);
var tntQueryItemIdentifier = new CTreeNodeType(TREE_ITEM, false,"../" + images_dir + "/metadatatree/query_item_dimension.gif", "../" + images_dir + "/metadatatree/query_item_dimension.gif");
tntQueryItemIdentifier.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_QUERY_ITEM_DIM);
var tntFilter = new CTreeNodeType(TREE_ITEM, false,"../" + images_dir + "/metadatatree/filter.gif", "../" + images_dir + "/metadatatree/filter.gif");
tntFilter.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_FILTER);
var tntCalculationFact = new CTreeNodeType(TREE_ITEM, false,"../" + images_dir + "/metadatatree/calculation_fact.gif", "../" + images_dir + "/metadatatree/calculation_fact.gif");
tntCalculationFact.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_CALC_FACT);
var tntCalculationDimension = new CTreeNodeType(TREE_ITEM, false,"../" + images_dir + "/metadatatree/calculation_dimension.gif", "../" + images_dir + "/metadatatree/calculation_dimension.gif");
tntCalculationDimension.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_CALC_DIM);
var tntCalculationAttribute = new CTreeNodeType(TREE_ITEM, false,"../" + images_dir + "/metadatatree/calculation_attribute.gif", "../" + images_dir + "/metadatatree/calculation_attribute.gif" );
tntCalculationAttribute.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_CALC_ATT);
var tntCalculationConstant = new CTreeNodeType(TREE_ITEM, false,"../" + images_dir + "/metadatatree/calculation_constant.gif", "../" + images_dir + "/metadatatree/calculation_constant.gif");
tntCalculationConstant.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_CALC_CONST);
var tntQuerySubject = new CTreeNodeType(TREE_FOLDER, true, "../" + images_dir + "/metadatatree/query_subject.gif", "../" + images_dir + "/metadatatree/query_subject.gif");
tntQuerySubject.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_QUERY_SUBJECT);
var tntDimension = new CTreeNodeType(TREE_FOLDER, true, "../" + images_dir + "/metadatatree/dimension.gif", "../" + images_dir + "/metadatatree/dimension.gif");
tntDimension.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_DIM);
var tntHierarchy = new CTreeNodeType(TREE_FOLDER, true, "../" + images_dir + "/metadatatree/hierarchy.gif", "../" + images_dir + "/metadatatree/hierarchy.gif");
tntHierarchy.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_HIERARCHY);
var tntLevel  = new CTreeNodeType(TREE_ITEM, true, "../" + images_dir + "/metadatatree/level.gif", "../" + images_dir + "/metadatatree/level.gif", PMT_DMT_DRILL_METADATA_TREENODE_LEVEL);
tntLevel.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_LEVEL);
var tntMeasure = new CTreeNodeType(TREE_ITEM, false, "../" + images_dir + "/metadatatree/metadata_measure.gif", "../" + images_dir + "/metadatatree/metadata_measure.gif");
tntMeasure.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_METADATA_MEASURE);
var tntNamespace = new CTreeNodeType(TREE_FOLDER, true, "../" + images_dir + "/metadatatree/namespace.gif", "../" + images_dir + "/metadatatree/namespace.gif");
tntNamespace.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_NAMSEPACE);
var tntFolder_2 = new CTreeNodeType(TREE_FOLDER, true, "../" + images_dir + "/metadatatree/folder_open.gif", "../" + images_dir + "/metadatatree/folder_open.gif");
tntFolder_2.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_FOLDER);
var tntMeasureDimension = new CTreeNodeType(TREE_FOLDER, true, "../" + images_dir + "/metadatatree/measure_dimension.gif", "../" + images_dir + "/metadatatree/measure_dimension.gif");
tntMeasureDimension.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_MEASURE_DIMM);
var tntRollupMeasure = new CTreeNodeType(TREE_ITEM, true, "../" + images_dir + "/metadatatree/rollup_measure.gif", "../" + images_dir + "/metadatatree/rollup_measure.gif");
tntRollupMeasure.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_MEASURE_ROLLUP);
var tntNamedSet = new CTreeNodeType(TREE_ITEM, false, "../" + images_dir + "/metadatatree/named_set.gif", "../" + images_dir + "/metadatatree/named_set.gif");
tntNamedSet.setAltText(PMT_DMT_DRILL_METADATA_TREENODE_NAMED_SET);
tntQueryItem.m_bIsDraggable = false;
tntQueryItemFact.m_bIsDraggable = false;
tntQueryItemIdentifier.m_bIsDraggable = false;
tntFilter.m_bIsDraggable = false;
tntCalculationFact.m_bIsDraggable = false;
tntCalculationDimension.m_bIsDraggable = false;
tntCalculationAttribute.m_bIsDraggable = false;
tntCalculationConstant.m_bIsDraggable = false;
tntQuerySubject.m_bIsDraggable = false;
tntDimension.m_bIsDraggable = false;
tntHierarchy.m_bIsDraggable = false;
tntLevel.m_bIsDraggable = false;
tntLevel.setRecursiveSelect(false);
tntLevel.m_nodeTypeName = "level";
tntMeasure.m_bIsDraggable = false;
tntNamespace.m_bIsDraggable = false;
tntFolder_2.m_bIsDraggable = false;
tntMeasureDimension.m_bIsDraggable = false;
tntRollupMeasure.m_bIsDraggable = false;
tntRollupMeasure.setRecursiveSelect(false);
tntNamedSet.m_bIsDraggable = false;

function fetchMetadataFunctionList()
{
	var req = "";
	var cl = "";

	// extract contentLocale from the cookie
	var cookieValues = document.cookie.split(";");
	for (var i = 0; i < cookieValues.length; i++)
	{
		if (cookieValues[i].match(/^\s*CRN=/i))
		{
			var aLocales = decodeURIComponent(decodeURIComponent(cookieValues[i].split("=")[1])).split("&");
			for (var j = 0; j < aLocales.length; j++)
			{
				if (aLocales[j].match(/^contentLocale=/i))
					cl = aLocales[j].split("=")[1];
				break;
			}
		}
		if (cl != "")
			break;
	}

	if (cl == "") 
		cl = cfgGet("contentLocale");
	if (cl)
		req += "&cl=" + cl;
	req += "&model=" + cfgGet("cmLastModel");

	var url = "b_action=xts.run&m=/" + qs_dir + "/functionList.xts" + req;
	if (cafContextId != "")
		url += "&ui.cafcontextid=" + cafContextId;
	sendDispatcherRequest(url, metadataFunctionListResponse);
}

function metadataFunctionListResponse(response)
{
	response = response.split(";");
	for (var i = 0; i < response.length; i++)
	{
		if (response[i].length > 0)
			cfgSetAt("CalcFns", cfgSize("CalcFns"), response[i]);
	}
	var newFnToRun = cfgGet("postFetchFunctionToRun");
	if (cfgSize("postFetchParameter") > 0)
	{
		var newFnParam = "";
		for (var pfpCounter = 0; pfpCounter < cfgSize("postFetchParameter"); pfpCounter++)
		{
			if(newFnParam != "")
				newFnParam =+ ",";
			newFnParam += "'" + cfgGetAt("postFetchParameter", pfpCounter) + "'";
		}
		newFnToRun(eval(newFnParam));
	}
	else
		newFnToRun();
	cfgRemove("postFetchFunctionToRun");
	cfgRemove("postFetchParameter");
}

function errorHandler(errorStoppedAt, e)
{
// alert("errorHandler broke at: [" + errorStoppedAt + "]\nwith message: [" + e.message + "]\nin file: [" + e.fileName + "]\nat line: [" + e.lineNumber + "]");
}

// Following functions used in metadataTree.js
function jsdecode(str)
{
	if (typeof str == "undefined" || str == "")
	{
		return "";
	}
	if (typeof str != "string")
	{
		return str;
	}
	return str.replace(/\\'/g, "'").replace(/\\"/g, '"').replace(/\\>/g, ">").replace(/\\</g, "<").replace(/\\\\/g, "\\");
}

function jsencode(str)
{
	if (typeof str == "undefined" || str == "")
		return "";
	return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
}