YNU_JEUS/app_home/himed/xpapps/com/commonxp/xp/comm_rpt.xjs

<?xml version="1.0" encoding="utf-8"?>
<Script type="xscript4.0"><![CDATA[/***************************************************************************************  
 * System Name		:	HIT
 * Job Name 		:	
 * File Name 		:	comm_rpt.xjs
 * Creator 	    	:	이상준
 * Make Date 		:	2014-02-18
 *                                                                                        
 * Description  	:	                                                                   
 *--------------------------------------------------------------------------------------- 
 * Modify Date     	Modifier  	Modify Description                                     
 *--------------------------------------------------------------------------------------- 
 * 2014-02-18        HIT       
 *                                                                                        
 *--------------------------------------------------------------------------------------- 
 ****************************************************************************************/

/********************************************************************************************************************/
/************************* 리포트 연계 함수 *********************************************************************/
/********************************************************************************************************************/
//	rptf_getReportURL	: 보고서의 URL 을 리턴한다.
//	rptf_exeReportPreview30	: 보고서를 미리보기 또는 프린터로 출력한다.
//	rptf_getCSVString	: 주어진 데이터셋에서 CSV 스트링을 추출한다.
//	rptf_getXMLString	: 주어진 데이터셋에서 XML 스트링을 추출한다.
//	rptf_getImageURL	: 보고서 이미지 url
//	rptf_getLogoImageKey	: 로고를 얻기위하여 해당 시스템코드에 대한 이미지키를 반환한다.
//	rptf_getLogoImageURL	: 병원별 logo이미지
//	rptf_getLogoEImageURL	: 병원별 logo이미지
//	rptf_getBigLogoImageURL	: EMR 서식용
//	rptf_printRexbar		: 렉스퍼트형 바코드 출력
//	rptf_printRexbarMulti	: 렉스퍼트형 바코드 출력(2개이상 dataset연결)
/**********************************************************************************
 * 함수명      : rptf_getReportURL  (내부용)
 * 설명        : 보고서의 URL 을 리턴한다.
 * argument    : sReportID   (String)  - 화면 및 보고서 관리에 등록된 해당보고서 ID
 * return Type : String - 해당보고서의 URL
**********************************************************************************/
function rptf_getReportURL(sReportID)
{
	var url = sysf_getURLprefix() +"/xpapps/com/commonxp/"+ sReportID +".reb";
	
	// 퀵뷰 상태이면 로컬파일시스템에서 가져옴
	if (sysf_isQuickView()) { 
		var sformURL = sysf_getFormURL().replace("\\", "/");
		var sAppPath = sformURL.substring(0, sformURL.lastIndexOf('/xpapps/'));
		url = sAppPath + "/xpapps/" + sysf_getScreenURL(sReportID);
	}
	return url;
}


/**********************************************************************************
 * 함수명      : rptf_exeReportPreview30 
 * 설명        : 보고서를 미리보기 또는 프린터로 출력한다.
 * argument    : arrReportIDs   (Array)  - 화면 및 보고서 관리에 등록된 해당보고서 ID Array
 *				 arrParams      (Array)  - 보고서에 전달할 파라미터 Array
 *				 sOptions     (String) - 보고서 출력에 대한 옵션 [zoomlvl 옵션(숫자(50, 75, 100, 125, 150, 200 등), WholePage, PageWidth) 추가 - 2019.03.21 smkim]
 *				 sPrnopt 	 (String) - 프린트에 대한 옵션
 *				 divObjId (String) - XP 화면내에 보고서 미리보기를 Embed 하는 경우 부모div 아이디를 명시한다. 
 *				 spool       (Boolean)- 일괄출력여부 
 *				 
 * return Type : void
**********************************************************************************/
function rptf_exeReportPreview30(arrReportIDs, arrParams, sOptions, sPrnopt, divObjId)
{
	var reportNames = new Array();
	var uniqueId = rptf_makeReportId();
	
	for (var i=0; i<arrReportIDs.length; i++)
	{
		var reportURL = rptf_getReportURL(arrReportIDs[i]); 
		reportNames.push(reportURL + "|" + arrReportIDs[i]);
	}
	
	if (arrParams == null)
	{
		arrParams = new Array();
	}

	// 세션 정보를 파라메터에 추가 (필요시코딩)
	for (var j = 0; j < reportNames.length; ++j) {

		if (j >= arrParams.length) {
			arrParams.push(new Object());
		}
		rptf_addSessionValues(arrParams[j]);
	}
	
	if (sOptions == null || sOptions == "") {
		sOptions = "open=0;save=1;directprint=0;printdialog=0;print=1;stop=1;excel=1;zoomin=1;zoomout=1;moveprev=1;movenext=1;combo=1;movefirst=1;movelast=1;help=1;async=1";
	}
	
	if (sPrnopt == null) {
		sPrnopt = "1";
	}
	
	// 보고서 오픈
	rptf_openReport(reportNames, arrParams, sOptions, sPrnopt, uniqueId, divObjId);
}

/**********************************************************************************
 * 함수명      : rptf_getCSVString
 * 설명        : 주어진 데이터셋에서 CSV 스트링을 추출한다.
 * argument    : objDs   (DataSet)  - CSV 스트링을 추출할 데이터셋
 *			     arrColNames  (Array) - CSV 스트링으로 추출할 열이름의 배열
 *				 				 
 * return Type : void
 **********************************************************************************/
function rptf_getCSVString(objDs, arrColNames)
{
	var nRowCnt = objDs.getRowCount();
	var nColCnt = objDs.getColCount();
	var sCSV = "";

	for (var j=0; j<nRowCnt; j++) {
		
		if (j > 0) {
			sCSV += rex_gsCsvSeparatorRow;
		}
		
		for (var k=0; k<arrColNames.length; k++) {
			var sColNm = objDs.getColID(k);
			var sColVal = objDs.getColumn(j, arrColNames[k]);
			sCSV += sColVal + rex_gsCsvSeparatorColumn
		}
	}
	
	return sCSV;
}

/**********************************************************************************
 * 함수명      : rptf_getXMLString
 * 설명        : 주어진 데이터셋에서 XML 스트링을 추출한다.
 * argument    : sRepeateNode	(String)	- XML 방식에서 반복노드를 지정하기위한 파라미터
 *				 dataset		(DataSet)	- CSV 스트링을 추출할 데이터셋
 *				 				 
 * return Type : void
**********************************************************************************/
function rptf_getXMLString(objDs, sRepeateNode)
{
	var aNodeStack = sRepeateNode.split("/")  // 반복노드 스택
	var recodeName = aNodeStack[aNodeStack.length -1]; // 레코드네임은 마지막 노드
	var sTemp = "";

	var nRowCnt = objDs.getRowCount();
	var nColCnt = objDs.getColCount();
	
	//for (var j=0; j<toNumber(nRowCnt); j++) {
	for (var j=0; j<nRowCnt; j++) {
		sTemp += '<'+ recodeName +'>' + "\n";
		
		//for (var k=0; k<toNumber(nColCnt); k++) {
		for (var k=0; k<nColCnt; k++) {
			var sColNm = objDs.getColID(k);
			var sColVal = utlf_transNullToEmpty(objDs.getColumn(j, k));
			//sTemp += '<' + sColNm + '><![CDATA[' + sColVal + ']]]]]]><![CDATA[><![CDATA[></' + sColNm + '>' + "\n";
			sTemp += '<' + sColNm + '><![CDATA[' + sColVal + ']]]]><![CDATA[></' + sColNm + '>' + "\n";
		}
		
		sTemp += '</'+recodeName+'>' + "\n";
	}
	
	// 반보노드 경로대로 XML path 를 만들어 줌
	for (var i=aNodeStack.length -2; i>=0; i--)
	{
		sTemp = '<'+aNodeStack[i]+'>\n'+sTemp+'\n</'+aNodeStack[i]+'>';
	
	}
	
	return sTemp;
}

/**********************************************************************************
 * 함수명     : rptf_createDOM
 * 설명       : 주어진 DomDocument 의 최상위 노드 root 를 생성 
 * argument    : objDOMdoc	(DomDocument)	- XML 문서 전체를 표현하고 다루기 위한 DOM 오브젝트
 *				 sXPath		(String)	- 노드를 생성할  XPath
 *				 				 
 * return Type : void
**********************************************************************************/
function rptf_createDOM()
{
	var objDomParser = new DomParser;
	return objDomParser.parseFromString("<root></root>"); 
}

/**********************************************************************************
 * 함수명     : rptf_makeNodeToDOM
 * 설명       : 주어진 DomDocument 의 해당 XPath 에 노드를 생성  (단일노드).
 * argument    : objDOMdoc	(DomDocument)	- XML 문서 전체를 표현하고 다루기 위한 DOM 오브젝트
 *				 sXPath		(String)	- 노드를 생성할  XPath
 *				 				 
 * return Type : void
**********************************************************************************/
function rptf_makeNodeToDOM(objDOMdoc, sXPath)
{
	// XPATH 공백제거
	sXPath = utlf_trim(sXPath);
	
	// 첫번째 "/" 제거
	if (sXPath.indexOf("/")==0) {
		sXPath = sXPath.substr(1,sXPath.length);
	}
	
	trace("["+sXPath+"]");
	var aNodeStack = sXPath.split("/")  // 반복노드 스택
	if (aNodeStack.length ==0)
	{
		return;
	}
	
	var currentElement = objDOMdoc.documentElement;
	var currentXPath = "/"+aNodeStack[0];
	
	// 경로상의 모든 노드를 만듬
	for (var i=0; i<aNodeStack.length; i++)
	{
		var nodeList = currentElement.getElementsByTagName(aNodeStack[i]);

		if (nodeList.length > 0) {	// 
			currentElement =  nodeList[0];
		}
		else // 없으면 생성하여 세팅
		{
			var newElement = objDOMdoc.createElement(aNodeStack[i]);
			currentElement.appendChild(newElement);
			currentElement = newElement;
		}
	}
	
	return currentElement;
	
}

/**********************************************************************************
 * 함수명     : rptf_setValueToDOM
 * 설명       : 주어진 DomDocument 의 해당 XPath 에 값을 세팅한다 (단일노드).
 * argument    : objDOMdoc	(DomDocument)	- XML 문서 전체를 표현하고 다루기 위한 DOM 오브젝트
 *				 sXPath		(String)	- 데이터가 위치할 XPath
 *               sValue		(String)	- 세팅하고자 하는 값
 *				 				 
 * return Type : void
**********************************************************************************/

function rptf_setValueToDOM(objDOMdoc, sXPath, sValue)
{
	// 해당노드가 있는지 확인한다.
	var objNodeList = objDOMdoc.getElementsByPath(sXPath);
	if (objNodeList.length == 0)
	{
		var newElement = rptf_makeNodeToDOM(objDOMdoc, sXPath);
		newElement.appendChild(objDOMdoc.createCDATASection(sValue));
	}
	else 
	{
		objNodeList[0].childNodes[0].data = sValue;
	}
}

/**********************************************************************************
 * 함수명     : rptf_getValueFromDOM
 * 설명       : 주어진 DomDocument 의  해당 XPath 의 값을 가져온다..
 * argument    : objDOMdoc	(DomDocument)	- XML 문서 전체를 표현하고 다루기 위한 DOM 오브젝트
 *				 sXPath		(String)	- 데이터가 위치한 XPath
 *				 				 
 * return Type : void
**********************************************************************************/

function rptf_getValueFromDOM(objDOMdoc, sXPath)
{
	var objNodeList = objDOMdoc.getElementsByPath(sXPath);
	if (objNodeList.length > 0)
	{
		if(utlf_isNull(objNodeList[0].childNodes[0]))
		{
			return "";
		}
		return objNodeList[0].childNodes[0].data;
	} else {
		return "";
	}
}

/**********************************************************************************
 * 함수명     : rptf_setNodeListToDOM
 * 설명       : 주어진 DomDocument 의  해당 XPath 에 데이터셋의 내용을 노드리스트형식으로 세팅한다.
 * argument    : objDOMdoc	(DomDocument)	- XML 문서 전체를 표현하고 다루기 위한 DOM 오브젝트
 *				 sXPath		(String)	- 데이터가 위치할 XPath
 *               objDs		(Dataset)  - 데이터를 가지고 있는 데이터셋
 *				 bCdata		CDATA 사용유무 True - Default / False	[2016.08.08 DataSet 내 CDATA 처리가 되어있을경우 예외처리]
 * return Type : void
**********************************************************************************/
function rptf_setNodeListToDOM(objDOMdoc, sXPath, objDs, bCdata)
{
	var nIndex = sXPath.lastIndexOf("/")  
	var nodeXPath = sXPath.substr(0,nIndex); 
	var nodeName = sXPath.substr(nIndex+1, sXPath.length - nIndex); 
	
	if( utlf_isNull(bCdata) )	bCdata = true;
	// 노드를 만듬
	var newElement = rptf_makeNodeToDOM(objDOMdoc, nodeXPath);

	var nRowCnt = objDs.getRowCount();
	var nColCnt = objDs.getColCount();
	
	//for (var j=0; j<toNumber(nRowCnt); j++) {
	for (var j=0; j<nRowCnt; j++) {
		
		var recordNode = objDOMdoc.createElement(nodeName);
		
		//for (var k=0; k<toNumber(nColCnt); k++) {
		for (var k=0; k<nColCnt; k++) {
			var sColNm = objDs.getColID(k);
			var sColVal = utlf_transNullToEmpty(objDs.getColumn(j, k));
			var columnNode = objDOMdoc.createElement(sColNm);
			if(bCdata == false){
				columnNode.appendChild(objDOMdoc.createTextNode(sColVal));
			}else{
				columnNode.appendChild(objDOMdoc.createCDATASection(sColVal));
			}
				
			recordNode.appendChild(columnNode);
		}
		
		newElement.appendChild(recordNode);
	}
}


/**********************************************************************************
 *  이후부터 보고서 내부용 연계 함수 										  *
 **********************************************************************************/
var rpt_reportId = 0;
var rpt_goParamSet = {};

function rptf_makeReportId()
{
	rpt_reportId = rpt_reportId + 1;
	return "R" + rpt_reportId;
}

function rptf_getfnParamSet(id) {
	rpt_goParamSet = new rex_fnParamSet(id);
	return rpt_goParamSet;
}

function rptf_getReportId(url) {
	var start = url.lastIndexOf("/");
	var reportId = url.substr(start+1,10);
	
	return reportId;
}

function rptf_openReport(rptnames, params, options, prnopt, uniqueId, divObjId) {
    var	rpt_id = rptf_makeReportId();
	oReport = rptf_getfnParamSet(rpt_id); // 파라미터 셋 생성
	
	oReport.datatype           = "csv";
	oReport.event.finishprint  = rptf_printFinished;
	oReport.event.finishexport = rptf_printExport;
	//oReport.event.init = reportInit;
	oReport.rptnames           = rptnames;
	oReport.callback           = rptf_getCallbackName(options);
	oReport.closecallback      = rptf_getCloseCallbackName(options);

	var rptNameSplit = null;
	var param = null;
	var rebId = null;
	var subMemoUsed = false;
	if(rptnames.length == 1) {
		rptNameSplit = rptnames[0].split("|");
		oReport.rptname = rptNameSplit[0];
		oReport.title = rptNameSplit[1];
		param = params[0];
		
		for(skey in param) {
		
			if (skey.indexOf("user_data",0) == 0) {
				// check if dataset name exists.
				if(skey == "user_data") {
					oReport.type = "memo";
					oReport.data = param[skey];
				}
				else {
					var dataset = skey.substr(10);
					oReport.sub(dataset).type = "memo";
					oReport.sub(dataset).data = param[skey];
					subMemoUsed = true;
				}
			}
			else if (skey.indexOf("xml_data",0) == 0) {
				// check if xml dataset name exists.
				if(skey == "xml_data") {
					oReport.type = "memo";
					oReport.data = param[skey]
					oReport.datatype = "xml";                     
				}
				else {
					var dataset = skey.substr(9);
					oReport.sub(dataset).type = "memo";
					oReport.sub(dataset).data = param[skey];
					oReport.sub(dataset).datatype = "xml";
					subMemoUsed = true;
				}
			}
			else if (skey.indexOf("xpath",0) == 0) { // xml repeat data for xml datatype
				// check if xml dataset name exists.
				if(skey == "xpath") {
					oReport.xpath = param[skey];
				}
				else {
					var dataset = skey.substr(6);
					oReport.sub(dataset).xpath = param[skey];
				}
			}
			else if (skey.indexOf("connect_name",0) == 0) { // connect name 처리
				// check if dataset name exists.
				if (skey == "connect_name") {
					oReport.connectname = param[skey];
				}
				else {
					var dataset = skey.substr(13);
					oReport.sub(dataset).connectname = param[skey];
				}
			}
			else {
				oReport.param(skey).value = param[skey];
			}
		}
		if (subMemoUsed) { // explicitly add "http" type as sub
			oReport.sub("*").type="http";
			oReport.sub("*").datatype="csv";
		}
		oReport.param("report_id").value = rptf_getReportId(rptNameSplit[0]);
		oReport.param("report_nm").value = rptNameSplit[1];
	}
	else {
		// multi-report
		var titleStr = "";
		for(var i = 0; i < rptnames.length; i++) {
			rebId = "reb"+i;
			rptNameSplit = rptnames[i].split("|");
			oReport.reb(rebId).rptname = rptNameSplit[0];
			if (i == 0) {
				titleStr = rptNameSplit[1];
			} else {
				titleStr = titleStr + "," + rptNameSplit[1];
			}
			
			oReport.reb(rebId).datatype = "csv";
			param = params[i];
			for(skey in param) {
				if (skey.indexOf("user_data",0) == 0) {
					// check if dataset name exists.
					if(skey == "user_data") {
						oReport.reb(rebId).type = "memo";
						oReport.reb(rebId).data = param[skey]
					}
					else {
						var dataset = skey.substr(10);
						oReport.reb(rebId).sub(dataset).type = "memo";
						oReport.reb(rebId).sub(dataset).data = param[skey];
					}
				}
				else if (skey.indexOf("xml_data",0) == 0) {
					// check if dataset name exists.
					if(skey == "xml_data") {
						oReport.reb(rebId).type = "memo";
						oReport.reb(rebId).data = param[skey];
						oReport.reb(rebId).datatype = "xml";
					}
					else {
						var dataset = skey.substr(9);
						oReport.reb(rebId).sub(dataset).type = "memo";
						oReport.reb(rebId).sub(dataset).data = param[skey];
						oReport.reb(rebId).sub(dataset).datatype = "xml";
					}
				}
				else if (skey.indexOf("xpath",0) == 0) { // xml repeat data for xml datatype
					// check if xml dataset name exists.
					if(skey == "xpath") {
						oReport.reb(rebId).xpath = param[skey];
					}
					else {
						var dataset = skey.substr(6);
						oReport.reb(rebId).sub(dataset).xpath = param[skey];
					}
				}
				else if (skey.indexOf("connect_name",0) == 0) { // connect name 처리
					// check if dataset name exists.
					if (skey == "connect_name") {
						oReport.reb(rebId).connectname = param[skey];
					}
					else {
						var dataset = skey.substr(13);
						oReport.reb(rebId).sub(dataset).connectname = param[skey];
					}
				}
				else {
					oReport.reb(rebId).param(skey).value = param[skey];
				}
			}
			
			oReport.reb(rebId).param("report_id").value = rptf_getReportId(rptNameSplit[0]);
			oReport.reb(rebId).param("report_nm").value = rptNameSplit[1];
		}
		oReport.title = titleStr;
	}
	
	oReport.printoption = prnopt;
	var frompage = 1;
	var topage = -1;
	var copies = 1;
	// parsing prnopt for direct print
	if (prnopt != null && prnopt != "") {
		var prnopts = prnopt.split(";");
		for(var i =0; i< prnopts.length; i++)
		{
			if (prnopts[i].indexOf("copies=",0) == 0) {
				copies = prnopts[i].substr(7);
			}
			else if (prnopts[i].indexOf("frompage=",0) == 0) {
				frompage = prnopts[i].substr(9);
			}
			else if (prnopts[i].indexOf("topage=",0) == 0) {
				topage = prnopts[i].substr(7);
			}
		}
	}
	
	// 바로출력 옵션이면 body에 숨긴 div 를 삽입한다. (한번삽입한 객채를 계속 재사용한다)
	if(options.indexOf("directprint=1") >= 0 || options.indexOf("export=1") >= 0) {
	
		var printDialog = true;
		if(options.indexOf("printdialog=0") >= 0) {
			printDialog = false;
		}
		
		var objDiv = null;
		try {
			objDiv = eval(divObjId);
		} catch(e) {}
		
		if(utlf_isNull(objDiv)) {
			// div 객체가 없으면 동적으로 생성		
			objDiv = this.components["rpt_print_div"];
	
			if (objDiv == null) 
			{
				objDiv = new Div("rpt_print_div", 0, 0, 0, 0);			
				if(options.indexOf("async=0") >= 0) objDiv.asyncmode = false;	// async=0 일때 asyncmode false로 셋팅 (간헐적으로 레포트 출력 후 죽는 현상 예외 처리 추가)
				
				this.addChild("rpt_print_div", objDiv); 
				objDiv.url = "com_hismainxp::form_report.xfdl";
				objDiv.show(); 
			}
		} else {
			if (utlf_isNull(objDiv.url)) { // 처음로딩이라면
				objDiv.asyncmode = false;
				objDiv.parent.rpt_reportParam = null;
				objDiv.url = "com_hismainxp::form_report.xfdl";
			}
		}
		
		objDiv.parent.rpt_reportParam = oReport;
 		
		if (options.indexOf("export=1") >= 0)
		{
			// Export 다이얼로그
			var dialog = (options.indexOf("exportdialog=1") >= 0) ? true:false;
			
			// 파일타입
			var filetype = "pdf";
			var temp = options.split("exporttype=");
			if (temp.length > 1)
			{
				filetype = temp[1].split(";")[0];
			}
			
			// 파일명 
			var fileName = "c:\\report\\report_"+rpt_id;
			temp = options.split("exportfilename=");
			if (temp.length > 1)
			{
				fileName = temp[1].split(";")[0];
			}
			
			oReport.save(dialog, filetype, fileName, 1, -1, "", objDiv);
		}
		else if(options.indexOf("directprint=1") >= 0)
		{
			// 바로출력
			oReport.print(printDialog, frompage, topage, copies, "", objDiv); // oReport.printoption 으로 함께 지정해야함.	
		}
	}
	else {
		oReport.toolbarbuttonoption = options.replace("directprint=0","");	
		
		// div 파라미터가 정의되어있지 않다면
		if (divObjId == null)
		{
			// rexpert30 오픈시 size 조절 2013.02.13 장재현
			var rexOptions = options.split(";");
			var rexWidth = null;
			var rexHeight = null;
			
			for(var i = 0; i < rexOptions.length; i++) {
				if(rexOptions[i].indexOf("width=",0) == 0) {
					rexWidth = rexOptions[i].replace("width=", "");
				}
				if(rexOptions[i].indexOf("height=",0) == 0) {
					rexHeight = rexOptions[i].replace("height=", "");
				}
			}
		
			// 모달리스팝업 띄움
			if (rexWidth != null && rexHeight != null) // 사이즈가 명확히 정해지면 해당 사이즈로 띄움
			{
				frmf_openInternal(rpt_id, "com_hismainxp::form_report.xfdl", {rpt_reportParam : oReport}, null, null, null, null, Number(rexWidth), Number(rexHeight), "resize=true", "", "", "M");
			}
			else
			{
				frmf_openInternal(rpt_id, "com_hismainxp::form_report.xfdl", {rpt_reportParam : oReport}, null, null, null, null, null, null, null, null, null, "M");
			}
		}
		else
		{
			// embed 방식을 띄움
			var objDiv = eval(divObjId);
			if (objDiv.url == "") { // 처음로딩이라면
				objDiv.parent.rpt_reportParam = oReport;
				objDiv.url = "com_hismainxp::form_report.xfdl";
			}
			else
			{
				objDiv.fnOpen(oReport);
			}
			
			try {
				var reportDivLeftPos  = system.clientToScreenX(objDiv, 0);
				var menuGroupRightPos = system.clientToScreenX(agv_objAppWorkPath.form.div_menu_group, 0) + agv_objAppWorkPath.form.div_menu_group.position.width * 2;
				
				if(reportDivLeftPos < menuGroupRightPos) {
					oReport.isEmbeded = true;
				}
			} catch(e) {}
			
			/*
			if (this.components[divObjId].url == "") { // 처음로딩이라면
				this.components[divObjId].url = "com_hismainxp::form_report.xfdl";
			}
			else
			{
				this.components[divObjId].fnOpen(oReport);
			}
			*/
		}
	}
}

// 콜백메소드를 가져오는 함수
function rptf_getCallbackName(option) {
	if (option == null || option == "") {
		return null;
	}
	
	var opts = option.split(";");
	for(var i =0; i< opts.length; i++)
	{
		if (opts[i].indexOf("callback=",0) == 0) {
			return opts[i].substr(9);
		}
	}
	
	return null;
}

// 클로즈(미리보기 창닫기) 콜백메소드를 가져오는 함수
function rptf_getCloseCallbackName(option) {
	if (option == null || option == "") {
		return null;
	}
	
	var opts = option.split(";");
	for(var i =0; i< opts.length; i++)
	{
		if (opts[i].indexOf("closecallback=",0) == 0) {
			return opts[i].substr(14);
		}
	}
	
	return null;
}

// 보고서 출력완료시 수행되는 함수
function rptf_printFinished(rexCtl, eventName, eventData) {

	// 출력완료시 이벤트를 TF뷰어에 브로드 캐스팅
	if (eventData != null && eventData.callback != null) {
		var evHandler = eventData.callback;
		// 콜백함수 호출
		eval(evHandler+"()");
	}
	
	// 다음보고서 출력 (스풀링)
	//if (spoolArr.length > 0) {
	//	nextPrint();
	//}
}

// 보고서 저장 완료시 수행되는 함수
function rptf_printExport(rexCtl, eventName, eventData) {

	// 출력완료시 이벤트를 TF뷰어에 브로드 캐스팅
	if (eventData != null && eventData.callback != null) {
		var evHandler = eventData.callback;
		// 콜백함수 호출
		eval(evHandler+"()");
	}
}


/**********************************************************************************
 * 함수명      : rptf_addSessionValues
 * 설명        : 오브젝트에 세션변수를 추가한다. (내부함수)
 * argument    : obj   (Object)  - 세션변수를 추가할 자바스크립트오브젝트
 *				 				 
 * return Type : void
**********************************************************************************/
function rptf_addSessionValues(objParam)
{
	var nColCnt = gds_userInfo.getColCount();
	for(i=0;i<nColCnt;i++) 
	{
		var sColNm = gds_userInfo.getColID(i);
		var	sColVal = gds_userInfo.getColumn(0, i);
		objParam["session_"+sColNm] = sColVal;
	}
}

// default DBconnection
var rex_gsUserService = "hisdb";

var rex_gsRptServiceURL = sysf_getURLprefix() + "/rexpert/rexservice.jsp";
// XML
var rex_gsXPath = "gubun/rpt1/rexdataset/rexrow";

// viewer Version
var rex_viewer_version = "1,0,0,17";
var rex_viewer_install = "EACH";  // EACH, ONCE, NONE

// CSV
var rex_gsCsvSeparatorColumn = "|*|";
var rex_gsCsvSeparatorRow = "^#^";
var rex_gsCsvEncoding = "utf-8"; 

// Language information
var rex_gsViewerLanguage = "ko";

// RexServer 2.5 compatible
var rex_gsServerVersion = "3.0"	// 2.5, 3.0

function rtpf_getRexParamSet() {
	return rpt_goParamSet;
}

function rex_fnParamSet(id) {
	this.id = id;
	this.type;	//http, file, memo, ado(not used)
	this.opentype;
	this.rptname;
	this.exportrptname = null;
	this.exportfiletype = "pdf";
	this.datatype;

	this.title; // added by kimhd.
    this.rptnames; // added by kimhd. it stores array of rptname;
    this.callback; // added by kimhd. it invoked after printing.
    
	this.rebfiles = {};
	this.subreports = {};
	this.params = {};
	this.httpparams = {};
	this.datasets = {};

	this.printoption;

	this.event = {};
	
	this.isEmbeded = false;
}
	rex_fnParamSet.prototype.reb = function(id) {
		if (this.rebfiles[id] == undefined) {
			this.rebfiles[id] = new rex_RebFile(id);
		}

		return this.rebfiles[id];
	}
	
	rex_fnParamSet.prototype.param  = function(id) {
		if (this.params[id] == undefined) {
			this.params[id] =  {};
		}

		return this.params[id];
	}
	
	rex_fnParamSet.prototype.httpparam  = function(id) {
		if (this.httpparams[id] == undefined) {
			this.httpparams[id] =  {};
		}

		return this.httpparams[id];
	}
	
	rex_fnParamSet.prototype.sub  = function(id) {
		if (this.subreports[id] == undefined) {
			this.subreports[id] = new rex_RebSubReport(id);
		}
	
		return this.subreports[id];
	}

	rex_fnParamSet.prototype.dataset = function(id) {
		if (this.datasets[id] == undefined) {
			this.datasets[id] = {};
		}
		
		return this.datasets[id];
	}

	rex_fnParamSet.prototype.toString = function() {
		var sb = "";

		var con = new rex_RebConnction();
		var oParam = {};

		var rebfile = new rex_RebFile();

		sb += "<?xml version='1.0' encoding='utf-8'?>";
		sb += "<oof version ='3.0'>";

		//sb += "<document title='A' enable-thread='0'>";
		sb += "<document enable-thread='1'>";

		//sb += "<document>";
	
		if (this.type == undefined) this.type = "http";

		sb += "<file-list>";

		if(this.rptname != undefined)
		{
			sb += rebfile.toStringFile(this.rptname, "", "") + "";

			this.exportrptname = this.rptname.substr(this.rptname.lastIndexOf("/") + 1);
		}

		var sConnMain = "";
		var sConnSub = "";
		var sConn = "";

		for(var nkey in this.rebfiles)
		{
			if (this.rebfiles[nkey].connectname != undefined) {
				oParam["type"] = this.rebfiles[nkey].type;
				oParam["namespace"] = this.rebfiles[nkey].namespace;
				oParam["path"] = this.rebfiles[nkey].path;
				oParam["data"] = this.rebfiles[nkey].data;
				oParam["connectname"] = this.rebfiles[nkey].connectname;
				oParam["datatype"] = this.rebfiles[nkey].datatype;
				oParam["xpath"] = this.rebfiles[nkey].xpath;
				oParam["encoding"] = this.rebfiles[nkey].encoding;

				con = new rex_RebConnction();
				sConn += con.toString(oParam, this.rebfiles[nkey].httpparams, this.rebfiles[nkey].datasets);
			}

			for(var key in this.rebfiles[nkey].subreports)
			{
				if(key != undefined)
				{
					if(this.rebfiles[nkey].sub(key).namespace == undefined )
					{
						oParam["namespace"] = key;
					} else {
						oParam["namespace"] = this.rebfiles[nkey].sub(key).namespace;
					}

					oParam["type"] = this.rebfiles[nkey].sub(key).type;
					oParam["path"] = this.rebfiles[nkey].sub(key).path;
					oParam["data"] = this.rebfiles[nkey].sub(key).data;
					oParam["connectname"] = this.rebfiles[nkey].sub(key).connectname;
					oParam["datatype"] = this.rebfiles[nkey].sub(key).datatype;
					oParam["xpath"] = this.rebfiles[nkey].sub(key).xpath;
					oParam["encoding"] = this.rebfiles[nkey].sub(key).encoding;

					con = new rex_RebConnction();
					sConn += con.toString(oParam, this.rebfiles[nkey].sub(key).httpparams, this.rebfiles[nkey].sub(key).datasets);
				}
			}

			if (sConn != "") { 
				sConn = "<connection-list>" + sConn + "</connection-list>";
			}

			//alert(this.rebfiles[nkey].subreports["ADO2"]);
			if(this.rebfiles[nkey].rptname != undefined)
			{
				rebfile = new rex_RebFile();
				sb += rebfile.toStringFile(this.rebfiles[nkey].rptname, rebfile.toStringField(this.rebfiles[nkey].params), sConn) + "";
				
				if (this.exportrptname == null) {
					this.exportrptname = this.rebfiles[nkey].rptname.substr(this.rebfiles[nkey].rptname.lastIndexOf("/") + 1);
				}
			}
		} // end for

		sb += "</file-list>";

		sConnMain += "<connection-list>";

		for(var nkey in this.subreports)
		{			
			if(this.subreports[nkey].namespace == undefined )
			{
				oParam["namespace"] = nkey;
			} else {
				oParam["namespace"] = this.subreports[nkey].namespace;
			}

			oParam["type"] = this.subreports[nkey].type;
			oParam["path"] = this.subreports[nkey].path;
			oParam["data"] = this.subreports[nkey].data;
			oParam["connectname"] = this.subreports[nkey].connectname;
			oParam["datatype"] = this.subreports[nkey].datatype;
			oParam["xpath"] = this.subreports[nkey].xpath;
			oParam["encoding"] = this.subreports[nkey].encoding;

			con = new rex_RebConnction();
			sConnSub += con.toString(oParam, this.subreports[nkey].httpparams, this.subreports[nkey].datasets);
		}

		if (sConnSub == "") {
			oParam["type"] = this.type;  // http, file, memo
			oParam["namespace"] = this.namespace;
			oParam["path"] = this.path;
			oParam["data"] = this.data;
			oParam["connectname"] = this.connectname;
			oParam["datatype"] = this.datatype;
			oParam["xpath"] = this.xpath;
			oParam["encoding"] = this.encoding;
	
			sConnMain += con.toString(oParam, this.httpparams, this.datasets);
		} else {
			sConnMain += sConnSub;
		}

		sConnMain += "</connection-list>";

		if (sConn == "") {
			sb += sConnMain;
		}

		sb += rebfile.toStringField(this.params);
	
		sb += "</document>";
		sb += "</oof>";
	
		return sb;
	}
//} // end of rex_fnParamSet

function rex_RebFile() {
	this.id = arguments[0];
	this.subreports = {};
	this.params = {};
	this.httpparams = {};

	rex_RebFile.prototype.sub = function(id) {
		if (this.subreports[id] == undefined) {
			this.subreports[id] = new rex_RebSubReport(id);
		}

		return this.subreports[id];
	}

	rex_RebFile.prototype.param = function(id) {
		if (this.params[id] == undefined) {
			this.params[id] = {};
		}
		
		return this.params[id];
	}

	rex_RebFile.prototype.httpparam  = function(id) {
		if (this.httpparams[id] == undefined) {
			this.httpparams[id] =  {};
		}

		return this.httpparams[id];
	}

	rex_RebFile.prototype.toStringFile = function(rptname, param, connect) {
		var sb = "";
		
		
		/*
		if (rptname.length > 7) {
			if (rptname.substring( 0, 7 ) != "http://" && rptname.substring( 0, 8 ) != "https://") { 
				rptname =  sysf_getURLprefix() + rptname;
			}
		} else {
			rptname =  sysf_getURLprefix() + rptname;
		}
		*/
		//sb += "<file type='reb' path='" + rptname + ".reb'>";
		sb += "<file type='reb' path='" + rptname+"'>"; // modified by kimhd
		sb += param;
		sb += connect;
		sb += "</file>";

		return sb;
	}

	rex_RebFile.prototype.toStringField = function(param) {
		var sb = "";

		sb += "<field-list>";
		for ( var key in param) {
			sb += "<field name='" + key + "'><![CDATA[" + param[key].value + "]]]]><![CDATA[></field>";
		}
		sb += "</field-list>";

		return sb;
	}
} // end of rex_RebFile

function rex_RebSubReport() {
	this.id = arguments[0];
	this.params = {};
	this.httpparams = {};
	this.datasets = {}

	rex_RebSubReport.prototype.param = function(id) {
		if (this.params[id] == undefined) {
			this.params[id] = {};
		}

		return this.params[id];
	}

	rex_RebSubReport.prototype.httpparam  = function(id) {
		if (this.httpparams[id] == undefined) {
			this.httpparams[id] = {};
		}

		return this.httpparams[id];
	}

	rex_RebSubReport.prototype.dataset = function(id) {
		if (this.datasets[id] == undefined) {
			this.datasets[id] = {};
		}

		return this.datasets[id];
	}
} // end of rex_RebSubReport

function rex_RebConnction() {
	rex_RebConnction.prototype.toString = function(oParam, oHttpParams, oDataSets) {		
		var sb = "";

		var type = oParam["type"];
		var namespace = oParam["namespace"];
		var path = oParam["path"];
		var isExistPath = false;
		var data = oParam["data"];
		var connectname = oParam["connectname"];
		var datatype = oParam["datatype"];
		var encoding = oParam["encoding"];
		var xpath = oParam["xpath"];

		if (type == undefined) type = "http";
		if (namespace == undefined) namespace = "*";

		if (path == undefined) {
			isExistPath = false;
			
			path = rex_gsRptServiceURL;
		} else {
			isExistPath = true;
		}

		if (data == undefined) data = "";
		
		if (connectname == undefined) {
			if (rex_gsServerVersion == "2.5") {
				connectname = "";
			} else {
				connectname = rex_gsUserService;
			}
		}

		if (datatype == undefined) datatype = "CSV";

		if (encoding == undefined) {
			
			if (rex_gsServerVersion == "2.5") {
				encoding = rex_gsCsvEncoding_RexServer25;
			} else {
				encoding = rex_gsCsvEncoding;
			}
		}

		if (xpath == undefined) {

			if (type == "http") {
				if (!isExistPath) xpath = rex_gsXPath;
			} else {
				xpath = "{%dataset.xml.root%}";
			}
		 }

		sb += "<connection type='" + type + "' namespace='" + namespace + "'>";

		var sHttpParams = "";

		if(oHttpParams != undefined )
		{
			for(var key in oHttpParams)
			{	
				if (typeof(oHttpParams[key].value) == "object") {
					for(var i = 0; i < oHttpParams[key].value.length; i++) {
						sHttpParams += "<http-param name='" + key + "'><![CDATA[" + oHttpParams[key].value[i] + "]]]]><![CDATA[></http-param>";
					}
				} else {
					sHttpParams += "<http-param name='" + key + "'><![CDATA[" + oHttpParams[key].value + "]]]]><![CDATA[></http-param>";
					//sHttpParams += "<http-param name='" + key + "'>" + oHttpParams[key].value + "</http-param>";
				}
			}
		}

		if (type == "http") {
			if (sHttpParams != "") {
				sHttpParams = "<http-param-list>" + sHttpParams + "</http-param-list>";
			} else if (isExistPath == false) {
				if (rex_gsServerVersion == "2.5") {
					sHttpParams += "<http-param-list>";
					sHttpParams += "<http-param name='designtype'>run</http-param>";
					sHttpParams += "<http-param name='datatype'>" + datatype.toUpperCase() + "</http-param>";
					sHttpParams += "<http-param name='sql'>{%auto%}</http-param>";
					sHttpParams += "<http-param name='split'></http-param>";
					sHttpParams += "<http-param name='userservice'>" + connectname + "</http-param>";
					sHttpParams += "<http-param name='image'></http-param>";
					sHttpParams += "<http-param name='rex_param_sql'></http-param>";
					sHttpParams += "</http-param-list>";
				} else {
					sHttpParams += "<http-param-list>";
					sHttpParams += "<http-param name='Q1SQL'>{%auto%}</http-param>";
					sHttpParams += "<http-param name='OE'>None</http-param>";
					sHttpParams += "<http-param name='CN'>" + connectname + "</http-param>";
					sHttpParams += "<http-param name='ID'>SD" + datatype.toUpperCase() + "</http-param>";
					sHttpParams += "<http-param name='PE'>FALSE</http-param>";
					sHttpParams += "<http-param name='QC'>1</http-param>";
					sHttpParams += "<http-param name='OT'>DataOnly</http-param>";
					sHttpParams += "<http-param name='Q1Type'>SQL</http-param>";
					sHttpParams += "</http-param-list>";
				}
			}

			sb += "<config-param-list>";
			sb += "<config-param name='path'>" + path + "</config-param>";
			sb += "</config-param-list>";
			sb += sHttpParams;
		} else if (type == "file") {
			sb += "<config-param-list>";
			sb += "<config-param name='path'>" + path + "</config-param>";
			sb += "</config-param-list>";

			if (sHttpParams != "") {
				sb += sHttpParams;
			}
		} else if (type == "memo") {
			sb += "<config-param-list>";

			if (datatype.toUpperCase() == "CSV") {
				sb += "<config-param name='data'><![CDATA[" + data + "]]]]><![CDATA[></config-param>";
			} else {
				sb += "<config-param name='data'>" + data + "</config-param>";
			}

			sb += "</config-param-list>";
		}

		if (datatype.toUpperCase() == "CSV") {
			if (rex_gsServerVersion == "2.5") {
				sb += "<content content-type='csv'>";
				
				if (type == "memo") {
					sb += "<content-param name='col-delim'>" + rex_gsCsvSeparatorColumn + "</content-param>";
					sb += "<content-param name='row-delim'>" + rex_gsCsvSeparatorRow + "</content-param>";

					encoding = "utf16le";
				} else {
					sb += "<content-param name='col-delim'>" + rex_gsCsvSeparatorColumn_RexServer25 + "</content-param>";
					sb += "<content-param name='row-delim'>" + rex_gsCsvSeparatorRow_RexServer25 + "</content-param>";
				}

				sb += "<content-param name='encoding'>" + encoding + "</content-param>";
				sb += "</content>";
			} else {
				sb += "<content content-type='csv'>";
				sb += "<content-param name='col-delim'>" + rex_gsCsvSeparatorColumn + "</content-param>";
				sb += "<content-param name='row-delim'>" + rex_gsCsvSeparatorRow + "</content-param>";

				if (type == "memo") encoding = "utf16le";

				sb += "<content-param name='encoding'>" + encoding + "</content-param>";
				sb += "</content>";
			}
		} else {
			var sDataSets = "";

			if(oDataSets != undefined )
			{
				for(var key in oDataSets)
				{
					sDataSets += "<content content-type='xml' namespace='" + key + "'>";
					sDataSets += "<content-param name='root'>" + oDataSets[key].xpath + "</content-param>";
					sDataSets += "<content-param name='preservedwhitespace'>1</content-param>";
					sDataSets += "<content-param name='bindmode'>name</content-param>";
					sDataSets += "</content>";
				}
			}

			if (sDataSets == "") {
				sDataSets += "<content content-type='xml'>";
				sDataSets += "<content-param name='root'>" + xpath + "</content-param>";
				sDataSets += "<content-param name='preservedwhitespace'>1</content-param>";
				sDataSets += "<content-param name='bindmode'>name</content-param>";
				sDataSets += "</content>";
			}

			sb += sDataSets;
		}

		sb += "</connection>";

		return sb;
	}
} // end of rex_RebConnction

rex_fnParamSet.prototype.print = function() {
	this.opentype = "print";

	this.print = {};
	this.print.dialog = arguments[0];
	this.print.startpage = arguments[1];
	this.print.endpage = arguments[2];
	this.print.copycount = arguments[3];
	this.print.Option = arguments[4];
	this.print.divObj = arguments[5];


	// div 객체에 로딩함 
	if (this.print.divObj.url == "")
	{
		this.print.divObj.url = "com_hismainxp::form_report.xfdl";
	}
	else
	{
		this.print.divObj.fnOpen(this);
		
	}
}

rex_fnParamSet.prototype.save = function() {
	this.opentype = "save";

	this.save = {};
	this.save.dialog = arguments[0];
	this.save.filetype = arguments[1];
	this.save.fileName = arguments[2];
	this.save.startpage = arguments[3];
	this.save.endpage = arguments[4];
	this.save.Option = arguments[5];
	this.save.divObj = arguments[6];

	// div 객체에 로딩함 
	if (this.save.divObj.url == "")
	{
		this.save.divObj.url = "com_hismainxp::form_report.xfdl";
	}
	else
	{
		this.save.divObj.fnOpen(this);
		
	}
}

/**********************************************************************************
* 함수명		: rptf_getImageURL
* 설  명		: 보고서 이미지 url
* argument		: 	sImgcd - 이미지코드
*					sType - 이미지형식
* return Type	: String - 이미지 URL
* 작성자		: 임준호
**********************************************************************************/
function rptf_getImageURL(sImgcd, sType){
    if (utlf_isNull(sType)) {
        sType = "gif";
    }
    return sysf_getURLprefix()+"/xpapps/com/commonxp/images/" + sImgcd + "." + sType;
}

/**********************************************************************************
* 함수명		: rptf_getLogoImageKey
* 설  명		: 로고를 얻기위하여 해당 시스템코드에 대한 이미지키를 반환한다.
* argument		: sSyscd - 시스템코드
* return Type	: String - image key
* 작성자		: 임준호
**********************************************************************************/
function rptf_getLogoImageKey(sSyscd){
	
	var sImageKey = "";
	
	if(utlf_isNull(sSyscd)){
		sSyscd = sysf_getSystemCd();
	}
	
	if(sSyscd.toUpperCase() == "MIS030") {
		sImageKey = sysf_getUserInfo("dutplceinstcd");
	}else{
		sImageKey = sSyscd.substr(3,3);
	}
	/*if(!((sImageKey >="011" && sImageKey <= "018")|| sImageKey == "103")){
		sImageKey = "001";
	}*/
	return sImageKey;
}

/**********************************************************************************
* 함수명		: rptf_getLogoImageURL
* 설  명		: 병원별 logo이미지
* argument		: sSyscd - 시스템코드
* return Type	: String - 이미지 URL
* 작성자		: 임준호
**********************************************************************************/
function rptf_getLogoImageURL(sSyscd){
	return rptf_getImageURL("logo"+rptf_getLogoImageKey(sSyscd));
}

/**********************************************************************************
* 함수명		: rptf_getLogoEImageURL
* 설  명		: 병원별 logo이미지
* argument		: sSyscd - 시스템코드
* return Type	: String - 이미지 URL
* 작성자		: 임준호
**********************************************************************************/
function rptf_getLogoEImageURL(sSyscd){
	return rptf_getImageURL("logo"+rptf_getLogoImageKey(sSyscd)+"e","jpg");
}

/**********************************************************************************
* 함수명		: rptf_getBigLogoImageURL
* 설  명		: EMR 서식용
* argument		:	sType - 형식
*					sSyscd - 시스템코드
* return Type	: String - 이미지 URL
* 작성자		: 임준호
**********************************************************************************/
function rptf_getBigLogoImageURL(sType, sSyscd){
	
	if(utlf_isNull(sType))	sType = "";
	
    if(sType.toUpperCase() == "H"){
        sType == "";
    }else if(sType.toUpperCase() == "E"){
        sType = "e";
    }
	
    return rptf_getImageURL("biglogo" + rptf_getLogoImageKey(sSyscd) + sType, "jpg");
}

/**********************************************************************************
* 함수명		: rptf_printRexbar
* 설  명		: 렉스포트형 바코드 출력
* argument		: 	rexnm (string) 		: 레포트코드
*           	  	previewYn (string) 	: 미리보기 여부(보기:true || Y, 안보기:비우거나 false)  
*           		tfXPath (string) 	: 인스턴스 ex)"/root/send/srch"                                  
*           		xpXPath (object)	: Dataset	ex)ds_send_srch                                
*           		infoXPath (string) 	: 바코드 프린터 정보 위치        
*					callBack (string)	: callBack 함수
*					sOption (string)	: 프린트 옵션
* return Type	: TRUE or FALSE
: 사용예 		: rptf_printRexbar("RFADT62303", "", "root/main/lbllist/lbllist", ds_main_lbllist, "", "lf_complete");
* 작성자		: 노회식
**********************************************************************************/
/*function rptf_printRexbar(rexnm, closeYn, printCount, dataXPath, paramsXPath, infoXPath){*/
function rptf_printRexbar(rexnm, previewYn, tfXPath, xpXPath, infoXPath, callBack, sOption){
    var posx 	= "";
    var posy 	= "";
    var printnm = "";
    
    if(infoXPath == "" || infoXPath == "undefined" || infoXPath == null) infoXPath = "ds_data";
	
	if( utlf_isNull(objects[infoXPath+"_setupinfo"]) ){
		dsf_createDs(infoXPath+"_setupinfo", [{col:"rexgbn", type:"string", size:256}], false);
	}
	if( utlf_isNull(objects[infoXPath+"_setupinfo"].getColumnInfo("rexgbn")) ){
		objects[infoXPath+"_setupinfo"].addColumn("rexgbn", "string");
	}
	
	if( utlf_isNull(objects[infoXPath+"_blank"]) ){
		dsf_createDs(infoXPath+"_blank", [{col:"left", type:"string", size:256}
										 ,{col:"top", type:"string", size:256}], false);
	}
	if( utlf_isNull(objects[infoXPath+"_blank"].getColumnInfo("left")) ){
		objects[infoXPath+"_blank"].addColumn("left", "string");
	}
	if( utlf_isNull(objects[infoXPath+"_blank"].getColumnInfo("top")) ){
		objects[infoXPath+"_blank"].addColumn("top", "string");
	}
	
	if( !utlf_isNull(objects[infoXPath+"_comm01"]) && utlf_isNull(objects[infoXPath+"_comm01"].getColumnInfo("setupval")) ){
		objects[infoXPath+"_comm01"].addColumn("setupval", "string");
	}
	
	if( !utlf_isNull(objects[infoXPath+"_pcllist"]) ){
		if( utlf_isNull(objects[infoXPath+"_pcllist"].getColumnInfo("barnm")) ){
			objects[infoXPath+"_pcllist"].addColumn("barnm", "string");
		}
		if( utlf_isNull(objects[infoXPath+"_pcllist"].getColumnInfo("xpos")) ){
			objects[infoXPath+"_pcllist"].addColumn("xpos", "string");
		}
		if( utlf_isNull(objects[infoXPath+"_pcllist"].getColumnInfo("ypos")) ){
			objects[infoXPath+"_pcllist"].addColumn("ypos", "string");
		}
		if( utlf_isNull(objects[infoXPath+"_pcllist"].getColumnInfo("prtnm")) ){
			objects[infoXPath+"_pcllist"].addColumn("prtnm", "string");
		}
	}
	
	if(objects[infoXPath+"_setupinfo"].getColumn(0,"rexgbn") != "1") {
		if(!utlf_isNull(callBack)) {
			eval(callBack+"()");
			return false;
		} else return false;
	}

    try{
        if(!utlf_isNull(objects[infoXPath+"_pcllist"])  									// ds 존재 체크
//		  && utlf_transNullToEmpty(objects[infoXPath+"_pcllist"].getColumn(0,"dsvaluepath")).substr(0,14) == "/setupinfo/pcl" 	// path 체크
		  && objects[infoXPath+"_pcllist"].findRowExpr("barnm=='"+rexnm+"'") > -1) {		// barnm 값 체크
			var rowNo = objects[infoXPath+"_pcllist"].findRowExpr("barnm=='"+rexnm+"'");
            posx 	= objects[infoXPath+"_pcllist"].getColumn(rowNo,"xpos");
            posy 	= objects[infoXPath+"_pcllist"].getColumn(rowNo,"ypos");
            printnm = objects[infoXPath+"_pcllist"].getColumn(rowNo,"prtnm");
        }else{
            posx 	= objects[infoXPath+"_blank"].getColumn(0,"left");
            posy 	= objects[infoXPath+"_blank"].getColumn(0,"top");
            
            if( !utlf_isNull(objects[infoXPath+"_comm01"]) ){
				printnm = objects[infoXPath+"_comm01"].getColumn(0,"setupval");
			}
        }
        if(utlf_isNull(posx)) posx = "0";
        if(utlf_isNull(posy)) posy = "0";
        
        
		var objDOM 		= rptf_createDOM();	// DOM 객체 설정
		var objParam 	= new Object();
		rptf_setNodeListToDOM(objDOM, tfXPath, xpXPath);
		objParam.xml_data_XML1 	= objDOM.documentElement.source;
		var option = "open=1;save=1;print=1;zoom=1;";

		if(previewYn == "true" || previewYn == "Y") {
			option = option + "directprint=0;";
			printnm = "";
		} else {
			//TF의 미리보기 출력로직과 XP의 출력 로직이 동일하고 TF의 바로출력 로직의 좌표값이 10배 차이 발생
			//기반기술과 상의하여 XP 바코드 출력 시 n/10 처리 2016.08.22
			posx = Math.round(Number(posx)/10, 0);
			posy = Math.round(Number(posy)/10, 0);
			
			option = option + "directprint=1;printdialog=0;";
		}
		
		if(!utlf_isNull(callBack)) {
			option = option + "callback="+callBack+";";
		}
		sysf_trace("printnm : "+printnm);
		var prntOtion 	= "offsetx=" + posx + ";" + "offsety=" + posy + ";" + "printername="+printnm+";";
		
		if( !utlf_isNull(sOption) ){
			prntOtion = prntOtion + sOption;
		}
		
		rptf_exeReportPreview30([rexnm],[objParam], option, prntOtion);
    } catch(e){
        alert("출력시 오류가 발생하였습니다\n" + e);
        return false;
    }
    return true;       
}

/**********************************************************************************
* 함수명		: rptf_printRexbarMulti
* 설  명		: 렉스포트형 바코드 출력(두개 이상 데이터셋 전송)
* argument		: 	rexnm (string) 		: 레포트코드
*           	  	previewYn (string) 	: 미리보기 여부(보기:true, 안보기:비우거나 false)  
*           		tfXPath (string) 	: 인스턴스 ex)"/root/send/srch^/root/prnt/data"
*           		xpXPath (string)	: Dataset명	ex)"ds_send_srch^ds_prnt_data"
*           		infoXPath (string) 	: 바코드 프린터 정보 위치        
*					callBack (string)	: callBack 함수
*					sOption (string)	: 프린트 옵션
* return Type	: TRUE or FALSE
: 사용예 		: rptf_printRexbarMulti("RFADT61300", "", "/root/main/prnt/lbllist^/root/send/prcpinfo", "ds_main_prnt_lbllist^ds_send_prcpinfo", "", "lf_complete");
* 작성자		: 노회식
**********************************************************************************/
function rptf_printRexbarMulti(rexnm, previewYn, tfXPath, xpXPath, infoXPath, callBack, sOption){
    var posx 	= "";
    var posy 	= "";
    var printnm = "";

    if(infoXPath == "" || infoXPath == "undefined" || infoXPath == null) infoXPath = "ds_data";
    
    if( utlf_isNull(objects[infoXPath+"_setupinfo"]) ){
		dsf_createDs(infoXPath+"_setupinfo", [{col:"rexgbn", type:"string", size:256}], false);
	}
	if( utlf_isNull(objects[infoXPath+"_setupinfo"].getColumnInfo("rexgbn")) ){
		objects[infoXPath+"_setupinfo"].addColumn("rexgbn", "string");
	}
	
	if( utlf_isNull(objects[infoXPath+"_blank"]) ){
		dsf_createDs(infoXPath+"_blank", [{col:"left", type:"string", size:256}
										 ,{col:"top", type:"string", size:256}], false);
	}
	if( utlf_isNull(objects[infoXPath+"_blank"].getColumnInfo("left")) ){
		objects[infoXPath+"_blank"].addColumn("left", "string");
	}
	if( utlf_isNull(objects[infoXPath+"_blank"].getColumnInfo("top")) ){
		objects[infoXPath+"_blank"].addColumn("top", "string");
	}
	
	if( !utlf_isNull(objects[infoXPath+"_comm01"]) && utlf_isNull(objects[infoXPath+"_comm01"].getColumnInfo("setupval")) ){
		objects[infoXPath+"_comm01"].addColumn("setupval", "string");
	}

	if( !utlf_isNull(objects[infoXPath+"_pcllist"]) ){
		if( utlf_isNull(objects[infoXPath+"_pcllist"].getColumnInfo("barnm")) ){
			objects[infoXPath+"_pcllist"].addColumn("barnm", "string");
		}
		if( utlf_isNull(objects[infoXPath+"_pcllist"].getColumnInfo("xpos")) ){
			objects[infoXPath+"_pcllist"].addColumn("xpos", "string");
		}
		if( utlf_isNull(objects[infoXPath+"_pcllist"].getColumnInfo("ypos")) ){
			objects[infoXPath+"_pcllist"].addColumn("ypos", "string");
		}
		if( utlf_isNull(objects[infoXPath+"_pcllist"].getColumnInfo("prtnm")) ){
			objects[infoXPath+"_pcllist"].addColumn("prtnm", "string");
		}
	}

	if(objects[infoXPath+"_setupinfo"].getColumn(0,"rexgbn") != "1") {
		if(!utlf_isNull(callBack)) {
			eval(callBack+"()");
			return false;
		} else return false;
	}

    try{
        if(!utlf_isNull(objects[infoXPath+"_pcllist"])  												// ds 존재 체크
//		  && objects[infoXPath+"_pcllist"].getColumn(0,"dsvaluepath").substr(0,14) == "/setupinfo/pcl" 	// path 체크
		  && objects[infoXPath+"_pcllist"].findRowExpr("barnm=='"+rexnm+"'") > -1) {					// barnm 값 체크
			var rowNo = objects[infoXPath+"_pcllist"].findRowExpr("barnm=='"+rexnm+"'");
            posx 	= objects[infoXPath+"_pcllist"].getColumn(rowNo,"xpos");
            posy 	= objects[infoXPath+"_pcllist"].getColumn(rowNo,"ypos");
            printnm = objects[infoXPath+"_pcllist"].getColumn(rowNo,"prtnm");
        }else{
            posx 	= objects[infoXPath+"_blank"].getColumn(0,"left");
            posy 	= objects[infoXPath+"_blank"].getColumn(0,"top");
			if( !utlf_isNull(objects[infoXPath+"_comm01"]) ){
				printnm = objects[infoXPath+"_comm01"].getColumn(0,"setupval");
			}
        }
        if(utlf_isNull(posx)) posx = "0";
        if(utlf_isNull(posy)) posy = "0";
        
		var objDOM = rptf_createDOM();	// DOM 객체 설정
		var arrTPath = tfXPath.split("^");
		var arrXPath = xpXPath.split("^");
	
		for(var i = 0 ; i < arrTPath.length ; i++) {
// 			sysf_trace("arrTPath[i] : " + i + " / " + arrTPath[i]);
// 			sysf_trace("arrXPath[i] : " + i + " / " + arrXPath[i]);
			rptf_setNodeListToDOM(objDOM, arrTPath[i], eval(arrXPath[i]));
		}

		var objParam = new Object();
		objParam.xml_data_XML1 	= objDOM.documentElement.source;
		var option = "open=1;save=1;print=1;zoom=1;";
		
		if(previewYn == "true" || previewYn == "Y") {
			option = option + "directprint=0;";
			printnm = "";
		} else {
			//TF의 미리보기 출력로직과 XP의 출력 로직이 동일하고 TF의 바로출력 로직의 좌표값이 10배 차이 발생
			//기반기술과 상의하여 XP 바코드 출력 시 n/10 처리 2016.08.22
			posx = Math.round(Number(posx)/10, 0);
			posy = Math.round(Number(posy)/10, 0);
			
			option = option + "directprint=1;printdialog=0;";
		}
		
		if(!utlf_isNull(callBack)) {
			option = option + "callback="+callBack+";";
		}
		
		var prntOtion 	= "offsetx=" + posx + ";" + "offsety=" + posy + ";" + "printername="+printnm+"";
		
		if( !utlf_isNull(sOption) ){
			prntOtion = prntOtion + sOption;
		}
		
		rptf_exeReportPreview30([rexnm],[objParam], option, prntOtion);
    } catch(e){
        alert("출력시 오류가 발생하였습니다\n" + e);
        return false;
    }
    return true;       
}]]></Script>