/**
 * 버튼 기능 처리
 */
function ButtonAtom (strVarName, nScriptIndex, strRefVarName, 
		strConnectionModelName, nButtonType, nOpenFormType, 
		strHelp, bCheckForignKey, bVanish, bSendToParent, bExcelPrint,
		bAfterSave, bScroll, strScrollName, strHyperLinkName,
		nJobLevel, strGroupLevel, bIsDisable)
{
	this.Atom (strVarName, strRefVarName, strScrollName, -1, nScriptIndex);
	
	this.m_strConnectionModelName = strConnectionModelName; // 연결모델명
	
	this.m_nButtonType = nButtonType; // 버튼 기능 타입
	this.m_nOpenFormType = nOpenFormType; // 상세폼 열기 방식
	
	this.m_strHelp = strHelp; //출력 메시지
	this.m_bVanish = bVanish;
	this.m_bCheckForignKey = bCheckForignKey;	// 유효성 체크
	this.m_bSendToParent = bSendToParent; //부모폼 값 전달.
	
	this.m_heAtom = document.getElementById(this.m_strVarName);
	this.m_bChangeScriptText = false;
	
	this.m_bExcelPrint = bExcelPrint;
	this.m_objExcelImport = null; // 엑셀값 가져오기에 필요한 객체

	this.m_bAfterSave = bAfterSave;		// 저장후 화면보존
	this.m_bScroll = bScroll; // 스크롤에 묶였나?
	this.m_strHyperLinkName = strHyperLinkName;; // 하이퍼링크 아톰명
	
	this.m_nJobLevel = nJobLevel; //직무등급.
	this.m_strGroupLevel = strGroupLevel; //접근범주.
	
	this.m_bIsDisable = bIsDisable; //비활성화.
	
	if (null != strScrollName && 0 < strScrollName.length)
	{
		this.m_heAtom.style.cursor = "hand";
	}
}

ButtonAtom.prototype = new Atom ();
ButtonAtom.prototype.constructor = ButtonAtom;

ButtonAtom.prototype.getAtomType = function ()
{
	return "Button";
}

ButtonAtom.prototype.getHTML = function ()
{
	return this.m_heAtom;
}

/**
 * 아톰리스트에 추가
 */
ButtonAtom.prototype.putAtom = function ()
{
	ButtonAtom._atoms[this.m_strVarName] = this;
}

ButtonAtom.prototype.setHTML = function(heAtom)
{
	this.m_heAtom = heAtom;
}

ButtonAtom.prototype.setRowIndex = function (nRowIndex)
{
	this.m_nRowIndex = nRowIndex;
}

ButtonAtom.prototype.isSureInput = function ()
{
	return false;
}

ButtonAtom.prototype.isSureInputScroll = function ()
{
	return false;
}

ButtonAtom.prototype.isOperation = function ()
{
	return false;
}

ButtonAtom.prototype.isRelatedOperation = function ()
{
	return false;
}

ButtonAtom.prototype.clone = function(bIsHtml)
{
	var objNewAtom = new ButtonAtom(
		this.m_strVarName, this.m_nScriptIndex, this.m_strRefVarName, this.m_strConnectionModelName, 
		this.m_nButtonType, this.m_nOpenFormType, this.m_strHelp, this.m_bCheckForignKey, this.m_bVanish, 
		this.m_bSendToParent, this.m_bExcelPrint, this.m_bAfterSave, this.m_bScroll, this.m_strScrollName, 
		this.m_strHyperLinkName, this.m_nJobLevel, this.m_strGroupLevel);
		
	if (false != bIsHtml && null != this.m_heAtom)
	{
		objNewAtom.setHTML(this.m_heAtom.cloneNode(true));
	}
	else
	{
		objNewAtom.setHTML(null);
	}
	
 	return objNewAtom;
}

ButtonAtom.prototype.getButtonType = function ()
{
	return this.m_nButtonType;
}

ButtonAtom.prototype.isAfterSave = function ()
{
	return this.m_bAfterSave;
}

/**
* 요청정보를 만든다.
* @param xnRequest
* @param isScroll 스크롤 아톰의 묶여있다면 true. 그 외에는 undefined
*/
ButtonAtom.prototype.makeRequest = function (xnRequest, isScroll)
{
	var strVarName = this.getVarName();
	var strValue = this.getValue();

	var xnAtom = XmlLib.createChild(xnRequest, "Button");
	
	xnAtom.setAttribute("VarName", strVarName);
	XmlLib.setTextValue(xnAtom, strValue);
}

ButtonAtom.prototype.setTextByScript = function (strButtonName)
{
	this.setValue(strButtonName);
	this.m_bChangeScriptText= true;
}

/**
 * 현재 객체의 텍스트 값 설정
 *
 * @param strButtonName 설정할 버튼 텍스트
 */
ButtonAtom.prototype.setValue = function (strButtonName)
{
	
	if (null != this.m_heAtom)
	{
		this.m_heAtom.value = strButtonName;
	}
	else
	{
		// 스크롤에 묶인 버튼의 경우 화면에 보이지 않는 아톰은 아직 HTML이 만들어지지 않았다.
		// 그러므로 텍스트 값 설정이 필요 없다.
	}
}

ButtonAtom.prototype.setRefVarName = function (strRefVarName)
{
	this.m_strRefVarName = strRefVarName
}

/**
 * 객체의 연결모델명
 */
ButtonAtom.prototype.getConnectionModelName = function ()
{
	return this.m_strConnectionModelName;
}

ButtonAtom.prototype.setConnectionModelName = function (strModelName)
{
	this.m_strConnectionModelName = strModelName;
}

/*
* 현재 객체의 텍스트 값 반환
* @return 버튼 텍스트
*/
ButtonAtom.prototype.getValue = function ()
{
	return (null == this.m_heAtom) ? "" : this.m_heAtom.value;
}

/**
* 화면에 아톰의 값을 출력한다.
*/
ButtonAtom.prototype.displayValue = function ()
{
// TODO 미구현.. 스크롤에 버튼이 묶였을 경우,, 형만 맞추어 놓았습니다.
}
	

////////////////////////////////////////////////////////////
// public 메서드 

/**
 * ButtonAtom의 초기화 작업을 수행한다. 
 * 보안설정을 적용합니다.
 */
ButtonAtom.prototype.init = function ()
{	
	var bIsValid = this._isValidAccessRight();
	
	if (IsTrialModel())
	{
		return;
	}
	
	if (null != this.m_heAtom)
	{
		if (IsWebModel())
		{
			if (bIsValid)
			{
				if ("hidden" != this.m_heAtom.style.visibility)
				{
					this.setVisible();
				}			
			}
			else
			{
				this.setHidden();
			}
		}
		else
		{
			if (bIsValid)
			{
				if (!this.m_bIsDisable)
				{
					this.setDisabled(false);
				}
			}
			else
			{
				this.setDisabled(true);
			}
		}
	}
}

/**
 * 버튼의 비활성화 속성을 설정합니다.
 * @param bIsDisable true: 비활성화.
 */
ButtonAtom.prototype.setDisabled = function (bIsDisable)
{
	if (bIsDisable)
	{
		this.getHTML().disabled = true;
		//그림 설정된 경우 처리
		if ("DIV" == this.getHTML().tagName)
		{
			this.getHTML().style.filter = "Gray(enabled=true)";
			this.getHTML().style.cursor = "default"
		}
	}
	else
	{
		//활성화시키지 전에 권한 검사를 합니다.
		var bIsValid = this._isValidAccessRight();
		
		this.getHTML().disabled = !bIsValid;
		//그림 설정된 경우 처리		
		if ("DIV" == this.getHTML().tagName)
		{
			this.getHTML().style.filter = "Gray(enabled=" + (!bIsValid) + ")";
			this.getHTML().style.cursor = bIsValid ? "hand" : "default"
		}
		
		//웹페이지모델의 버튼아톰은 권한이 없는경우 화면감춤이 설정됩니다.
		if (IsWebModel())
		{
			bIsValid ? this.setVisible() : this.setHidden();
		}
	}
}

/**
 * 사용자가 버튼을 사용할 수 있는 접근 권한을 가지고 있는가?
 * 모델의 제품 영역에 해당하는 사용자의 직무등급과 접근범주를 사용해서 권한을 검사합니다.
 */
ButtonAtom.prototype._isValidAccessRight = function ()
{
	var strRegistryFlag = GetKnowledgeBankRegistryFlag();
	if (null != strRegistryFlag && 0 < strRegistryFlag.length)
	{
		var strDealLevel = "";
		var strUserGroupCode = "";
		if (IsWebModel())
		{
			strDealLevel = GlobalField.getPortalUserDataJobLevel();
			strUserGroupCode = GlobalField.getPortalUserDataGroupCode();
		}
		else
		{
			strDealLevel = PQService.getGlobalInfo("JobLevel");
			strUserGroupCode = PQService.getGlobalInfo("GroupCode");
		}
		
		//직무등급 검사.
		var nJobLevel = ModelCore.getJobLevel(strRegistryFlag, strDealLevel);		
		var	bIsValidJobLevel = nJobLevel <= this.m_nJobLevel;
		//접근범주 검사.
		var bIsValidGroupLevel = this._isValidGroupLevel(strUserGroupCode);
		
		return bIsValidJobLevel && bIsValidGroupLevel;
	}
	
	return true;
}

/**
 * 사용자가 적절한 접근 범주 권한을 가지고 있는가?
 * @param strUserGroupCode 사용자의 그룹 코드.
 */
ButtonAtom.prototype._isValidGroupLevel = function (strUserGroupCode)
{
	if (0 == strUserGroupCode.length || 0 == this.m_strGroupLevel.length || 
		0 == this.m_strGroupLevel.indexOf("전사공통"))
	{
		return true;
	}
	
	if (0 > this.m_strGroupLevel.indexOf(strUserGroupCode))
	{
		return false;
	}
	
	//11그룹의 사용자는 111그룹에게 허용된 메뉴는 볼수 있고 1그룹에 허용된 메뉴는 볼 수 없다.
	if (strUserGroupCode.length > this.m_strGroupLevel.length)
	{
		return false;
	}
	
	return true;
}

/**
 * 검색식 창 이후 동작을 수행합니다.
 *
 * @param strRefVarName 검색식에서 넘어온 참조변수명
 */
ButtonAtom.prototype.executeSearchFormulaResult = function (strRefVarName)
{
	var objAtom = null;
	if (ContainsReportBrowseAtom())
	{
		objAtom = ReportBrowseAtom.getAtom(strRefVarName);
	}
	if (objAtom == null && ContainsGridExAtom())
	{
		objAtom = GridExAtom.getAtom(strRefVarName);
	}
	
	if (null == objAtom)
	{
		return;
	}
	
	// 14 : 검색 필터 , 15 : 검색 식 
	objAtom.setSupportType(ButtonAtom.SEARCHFORMULA);
	
	var objFormula = g_htSearchFormulaList[strRefVarName];
	if (null == objFormula)
	{
		return;
	}
	
	arSupportWindowWhere = objFormula.SearchFormulaHandler.getFormulaWhereClause();
	
	if (null == arSupportWindowWhere || 0 == arSupportWindowWhere.length)
	{
		return;
	}
	// 검색 버튼 동작을 수행합니다.
	this._executeSearch();
}

ButtonAtom.prototype.setVisible = function ()
{
	if (IsWebModel())
	{
		var bIsValid = this._isValidAccessRight();
		this.m_heAtom.style.visibility = bIsValid ? "visible" : "hidden";
	}
	else
	{
		this.m_heAtom.style.visibility = "visible";
	}
}

ButtonAtom.prototype.setHidden = function ()
{
	this.m_heAtom.style.visibility = "hidden";
}

ButtonAtom.prototype.setVisibility = function (bVisible)
{
	if (bVisible)
	{
		this.setVisible();
	}
	else
	{
		this.setHidden();
	}
}

/**
 * 선택표시 (f9 기능)
 */
ButtonAtom.prototype.vanish = function ()
{
	if (this.m_bVanish)
	{
		// 현재 감춤 상태이면 표시한다.
		if ("hidden" == this.m_heAtom.style.visibility)
		{
			this.setVisible();
		}
		else // 표시된 상태이면 감춘다.
		{
			this.setHidden();
		}
	}
}

/**
 * 인자로 받은 값만큼 top을 변경시킨다
 * 
 * @param nRepositionValue (top 변경 값)
 */
ButtonAtom.prototype.repositionYPos = function (nRepositionValue)
{
	var nTop = this.m_heAtom.offsetTop;
	
	this.m_heAtom.style.top = (nTop + nRepositionValue) + "px";
}

/**
 * 인자로 받은 값만큼 left를 변경시킨다
 * 
 * @param nRepositionValue (left 변경 값)
 */
ButtonAtom.prototype.repositionXPos = function (nRepositionValue)
{
	var nLeft = this.m_heAtom.offsetLeft;
	
	this.m_heAtom.style.left = (nLeft + nRepositionValue) + "px";
}


////////////////////////////////////////////////////////////
// event handler

ButtonAtom.prototype.onFocus = function ()
{
	// 초점 얻음 스크립트
	if (-1 != ScriptAtomEvent.onFocus(this.m_nScriptIndex))
	{
	}
}

/**	
 * 버튼클릭 이벤트 발생시 기능버튼 기능을 수행합니다.
 */
ButtonAtom.prototype.onClick = function (objEvent)
{
	try
	{
		this._inspectionForAction();
	}
	catch (e)
	{
		HandleException(e);
		return;
	}
	
	if (!this._showHelpMessage())
	{
		return;
	}

	// 전처리 보다 유효성 검사를 먼저 수행한다.
	// 호철처 회귀 일때도 저장과 같은 루틴으로 처리..
	if (ButtonAtom.SAVE == this.m_nButtonType || ButtonAtom.SAVECLOSE == this.m_nButtonType || ButtonAtom.RETPARENT == this.m_nButtonType )
	{
		// 저장시 팝업의 유효성 검사 수행
		if (ContainsPopupAtom() && false == PopupAtom.checkPopupForeignKey())
		{
			return;
		}
	}
	
	if (true == this.isScroll())
	{
		ScrollOnClick(this.m_strScrollName, this.m_strVarName, this.m_heAtom, objEvent);
	}
	
	if (-1 != ScriptAtomEvent.onClick(this.m_nScriptIndex))
	{
		switch (this.m_nButtonType)
		{
			case ButtonAtom.OK : 
			{
				break ; // 임시코드 - 배준배 - 
			}
			case ButtonAtom.CLOSE: //닫기
			{
				this.executeClose(false);
				break;
			}
			case ButtonAtom.SAVE:	// 저장
			{
				if (g_bQWPClientMode)
				{
					g_objDoc.executeSave();
				}
				else
				{
					this._executeSave();
				}
				break;
			}
			case ButtonAtom.SAVECLOSE:	// 저장후닫기
			{
				if (true == this._executeSave())
				{
					this.executeClose(false);
				}
				break;
			}
			case ButtonAtom.DELETE:	// 삭제
			{
				if (g_bQWPClientMode)
				{
					g_objDoc.executeDelete();
				}
				else
				{
					this._executeDelete();
				}
				break;
			}
			case ButtonAtom.PREV:	// 앞장
			case ButtonAtom.NEXT:	// 뒷장
			{
				if (g_bQWPClientMode)
				{
					this._executeInquiryDoc();
				}
				else
				{
					this._executeInquiry();
				}
				break;
			}
			case ButtonAtom.SEARCH:	// 검색
			{
				this._executeSearch();
				break;
			}
			case ButtonAtom.OPENMODEL: // 상세폼보기
			{
				this.executeOpenModel();
				break;
			} 
			case ButtonAtom.RETPARENT: // 호출처회귀
			{
				if (true == this._executeSaveParent())
				{
					this.executeClose(false);
				}
				break;
			}
			case ButtonAtom.SEARCHFILTER: // 검색필터
			{
				this._executeSearchFilter();
				break;
			}
			case ButtonAtom.SEARCHFORMULA: // 검색식
			{
				this._executeSearchFormula();
				break;
			}
			case ButtonAtom.NTOA_NTOAACTION_RECLAIM: // 결재기능버튼 - 회수
			{
				this._excuteNtoaActionReclaim();
				break;
			}
			case ButtonAtom.NTOA_NTOAACTION_SEND: // 결재기능버튼 - 송신
			{
				this._executeNtoaActionSend();
				break;
			}
			case ButtonAtom.PRINT: //출력
			{
				if (IsWebModel())
				{
					this._printWebModel();
				}
				else
				{
					// Excel출력이 체크된 경우
					if (this.m_bExcelPrint)
					{
						this._exportExcel();
					}
					else
					{
						//TODO
						alert("알림 : 출력 기능을 준비중 입니다.");
					}
				}
				
				break;
			}
			case ButtonAtom.CHART: // 챠트 출력
			{
				this._executeSearch();
				break;
			}
			case ButtonAtom.EXCEL_IMPORT :
			{
				this._executeExcelImport();
				break;
			}
			case ButtonAtom.CONNECTCHART :	// 챠트 연결
			{
				this._executeConnectChart();
				break;
			}
			case ButtonAtom.LOGIN:	// 로그인
			{
				break;
			}
			case ButtonAtom.OPENFORM_POPUP:		// 출력물
			{
				this.executeOpenReportModel();
				break;
			}
			default:
				alert("에러 : 버튼 기능을 지원하지 않습니다.");
				break;
		}
		
		ScriptAtomEvent.onClickAfter(this.m_nScriptIndex);
		
		// 하이퍼링크 동작, 가장 마지막에 수행해야 합니다. 다른 동작 추가시 위로 추가하세요
		if (null != this.m_strHyperLinkName && 0 != this.m_strHyperLinkName.length && ContainsWebHyperDataAtom())
		{
			var objHyperLinkAtom = Model.getAtom(this.m_strHyperLinkName, this.m_strScrollName, this.m_heAtom);
			if (null != objHyperLinkAtom)
			{
				// 먼저 하이퍼 링크의 링크 동작을 제외한 onClick을 수행한다. (스크립트동작)
				if (-1 != objHyperLinkAtom.onLinkClick())
				{
					objHyperLinkAtom.connectLink(this.m_heAtom);
				}
			}
		}
	}
}

/**
 * 모델삽입된 QPG 인가?
 */
ButtonAtom.prototype.isEmbededQPG = function ()
{
	// 모델삽입 되었으면,
	// 부모(/ups/Model.html)와
	// 조부모(모델삽입아톰을 가진 폼 - QWP)까지 있음.
	if (!IsWebModel()
		&& self != parent 
		&& parent != top)
	{
		return true;
	}
	
	return false;
}

/**
 * 닫기 버튼 실행
 */
ButtonAtom.prototype.executeClose = function (bHelpMessage)
{
	if (this.isEmbededQPG())
	{
		return;
	}
	
	if (bHelpMessage && this.m_strHelp)
	{
		if (!this._showHelpMessage())
		{
			return;
		}
	}
	
	//부모폼 값 전달.
	if (this.m_bSendToParent)
	{
		var objParentWindow = ModelCore.getParentWindow();
		if (null != objParentWindow)
		{
			//넘겨줄 데이터 만들기
			var htSendedData = PQConnectionModel.makeSendedData(this.m_strRefVarName);
			
			objParentWindow.Model.receiveDataFromChildForm(htSendedData);
		}
	}
	
	Utils.close();
}

/**
 * 상세폼을 연다. 
 */
ButtonAtom.prototype.executeOpenModel = function ()
{
	// 자체정의팝업, 검색창 상세폼 열기	
	switch (this.m_nOpenFormType)
	{
		case ButtonAtom.OPENFORM_INPUT:
		{
			if (null == this.m_strConnectionModelName || 0 == this.m_strConnectionModelName.length)
			{
				return;
			}
			
			PQConnectionModel.open(this.m_strConnectionModelName, this.m_strRefVarName);
			break;
		}
		case ButtonAtom.OPENFORM_SEARCH:
		{
			var objReportBrowse = null;
			if(ContainsReportBrowseAtom())
			{
				objReportBrowse = ReportBrowseAtom.getAtom(this.m_strRefVarName);
				if (null == objReportBrowse)
				{
					// 참조 변수 명에 해당하는 검색창을 찾지 못하면, 기본으로 첫번째 검색창 아톰을 가져온다
					objReportBrowse = ReportBrowseAtom.getFirstAtom();
				}
			}
			
			if (null != objReportBrowse)
			{					
				objReportBrowse.executeConnectionModel(this.m_strConnectionModelName);
			}
			
			break;
		}
		case ButtonAtom.OPENFORM_POPUP:
		{
			var objPopupAtom = null;
			if (ContainsPopupAtom())
			{
				objPopupAtom = PopupAtom.getAtom(this.m_strRefVarName);
			}
			if (null != objPopupAtom)
			{
				objPopupAtom.executeConnectionModel(true);
			}
			break;
		}
	}
}

// 출력물 폼을 연다.
ButtonAtom.prototype.executeOpenReportModel = function ()
{
	switch (this.m_nOpenFormType)
	{
		case ButtonAtom.OPENFORM_INPUT:
		{
			if (null == this.m_strConnectionModelName || 0 == this.m_strConnectionModelName.length)
			{
				return;
			}
			
			PQConnectionModel.openReport(this.m_strConnectionModelName, this.m_strRefVarName);
			break;
		}
	}
}

////////////////////////////////////////////////////////////
// private method
/**
 * 도움말 메시지를 표시한다.
 */
ButtonAtom.prototype._showHelpMessage = function()
{
	switch (this.m_nButtonType)
	{
		case ButtonAtom.SAVE:	// 저장
		case ButtonAtom.SAVECLOSE:	// 저장후닫기
		case ButtonAtom.DELETE:	// 삭제
		case ButtonAtom.RETPARENT: //호출처 회귀
		{
			if ("" == this.m_strHelp && ButtonAtom.DELETE == this.m_nButtonType)
			{
				this.m_strHelp = ButtonAtom.DELETEMESSAGE;
			}
			
			if (null != this.m_strHelp && 0 < this.m_strHelp.length)
			{
				return confirm(this.m_strHelp);
			}
			break;
		}			
	}
	
	return true;
}

/**
 * 스크롤에 묶이지 않은 아톰의 필수 입력 체크
 */
ButtonAtom.prototype._checkSureInput = function ()
{
	/**
	 * 데이터 입력란, 날짜입력란, 이미지입력란,라디오의 필수입력을 처리함
	 */
	// 아톰이 모델에 없는 경우에는 그 아톰의 javascript도 import되지 않기 때문에 항상 체크 해준다.
	if (ContainsInputDataAtom())
	{
		InputDataAtom.checkSureInput();
	}
	if (ContainsInputTimeAtom())
	{
		InputTimeAtom.checkSureInput();
	}
	if (ContainsInputImageAtom())
	{
		InputImageAtom.checkSureInput();
	}
	if (ContainsRadioAtom())
	{
		RadioAtomGroup.checkSureInput();
	}
	if (ContainsComboAtom())
	{
		ComboAtom.checkSureInput();
	}
}

/**
 * 스크롤에 묶인 아톰의 필수 입력 및 유효성 체크
 */
ButtonAtom.prototype.checkSureInputScroll = function ()
{
	if (ContainsScrollAtom())
	{
		// 유효성 체크가 우선이므로 순서를 지켜야 한다. 
		ScrollAtom.checkSureInputScroll();
	
		ScrollAtom.checkSureInput();
	}
}

/**
 *	스크롤에 묶였는지 여부
 */
ButtonAtom.prototype.isScroll = function ()
{
	return this.m_bScroll;
}

/**
 * 버튼 동작전 사전 체크를 하는 논리들
 * : 저장전 필수, 유효 체크
 * : 검색전 필수 체크
 */
ButtonAtom.prototype._inspectionForAction = function ()
{
	// 저장 타입인 경우 사전에 필수 입력 및 유효성 체크를 실시한다. 
	// 호출처 회기 타입인 경우도 사전 필수 입력 및 유효성 체크 실시한다. 
	if (ButtonAtom.SAVE == this.m_nButtonType || ButtonAtom.RETPARENT == this.m_nButtonType)
	{
		this._checkSureInput();
			
		this.checkSureInputScroll();
	}
	// 검색인 경우 데이터 입력란의 필수 입력을 체크한다. 
	else if (ButtonAtom.SEARCH == this.m_nButtonType)
	{
		if (true == this.m_bCheckForignKey && ContainsInputDataAtom())
		{
			InputDataAtom.checkSureInput();
		}
	}
}

/*
 * 저장버튼 실행
 *
 * @return 저장결과 성공이면 true, 실패면 false
 */
ButtonAtom.prototype._executeSave = function ()
{
	var bComplete = false;
	
	GlobalField.setServiceName(ButtonAtom.SAVEACTION);
	
	var xnRequest = MakeRequest.createRequestNode();
	try
	{
		MakeRequest.makeServiceRequest(xnRequest);
		MakeRequest.makeInputAtomRequest(xnRequest);
		MakeRequest.makeDecoAtomRequest(xnRequest);
		MakeRequest.makeWebAtomRequest(xnRequest);
		
		if (IsNtoaModel())
		{
			TransmitAtom.makeRequest(xnRequest);
		}
		if(ContainsScheduleAtom())
		{
			ScheduleAtom.makeSaveRequest(ScheduleAtom.SAVE);
		}
		
		// touch atom request에 넣으면 검색시 request 2번 만들어 지므로 임시로 여기에 넣음
		var xnAtomRequest = MakeRequest.getAtomRequestNode(xnRequest);
		
		if (ContainsGridExAtom())
		{
			GridExAtom.makeRequest(xnAtomRequest);
		}
		if (ContainsReceiverAtom())
		{
			ReceiverAtom.makeRequest(xnAtomRequest);
		}
		if (ContainsDHtmlAtom())
		{
			DHtmlAtom.makeRequest(xnAtomRequest);
		}
	}
	catch (e)
	{
		HandleException(e);
	}
	
	try
	{	
		var xnRequestDoc = xnRequest.ownerDocument;
		if (null != xnRequestDoc)
		{
			var xnResultDoc = null;
				xnResultDoc = PQService.executeService(xnRequestDoc);
			
			if (null != xnResultDoc)
			{
				Model.startWaitMessage("첨부파일을 업로드 중입니다.");
				Model.uploadFile();				
				Model.saveAttachAtom();				
				Model.stopWaitMessage();
				
				// 정상적인 저장 동작이 일어 났다면, 스케줄 저장동작을 수행합니다 
				if (ContainsScheduleAtom())
				{
					ScheduleAtom.execute();
				}
				
				/**
				 * Bpm모델의 저장일 경우에 입력된 정보를 다음 업무로 전달될  Argument에 저장한다.
				 * 또한 저장 버튼에 할당된 Event데로 업무의 보류, 취소, 완료를 설정한다. 
				 */
				if (Model.isBpmModel())
				{
					//저장 버튼의 Event 정보를 저장한다.
					this._setButtonEventForBpmModel("저장");	
					//다음업무로 넘어가는 Argument를 만든다.
					this._makeNextArgumentForBpmModel();
				}
				
				// 저장동작 중에 자동증가에 의해 기본검색키 값이 변경될수 있음
				HandleResult.execute(xnResultDoc);
					
				// 폼_저장완료 스크립트
				ScriptFormEvent.onEndSave();
	
				// '저장 후 화면 보존'이 아니면 refresh
				if (false == this.m_bAfterSave)
				{
					// 화면을 지우지 않고 리프레시를 하면 저장 당시 아톰값이 
					// 리프레시 동작에서 요청으로 갔다가 결과로 다시 나오게 된다.
					g_objModelCore.clearAtomValue();
					Model.executeRefresh();
				}
				
				bComplete = true;
			}
		}
	}
	catch (e)
	{
		HandleException(e);
	}
	
	this._executeSearch();
	
	//폼_저장결과 스크립트. 저장완료후로 바뀌었다고 함.
	ScriptFormEvent.onResultSave(bComplete);
		
	return bComplete;
}

/**
* 호출처회귀
*/
ButtonAtom.prototype._executeSaveParent = function ()
{
	var bComplete = false;
	
	GlobalField.setServiceName(ButtonAtom.RETPARENTACTION);
	
	var xnRequest = MakeRequest.createRequestNode();
	
	try
	{
		MakeRequest.makeServiceRequest(xnRequest);
		MakeRequest.makeInputAtomRequest(xnRequest);
		MakeRequest.makeDecoAtomRequest(xnRequest);
		MakeRequest.makeWebAtomRequest(xnRequest);
		
		if (IsNtoaModel())
		{
			TransmitAtom.makeRequest(xnRequest);
		}
		if(ContainsScheduleAtom())
		{
			ScheduleAtom.makeSaveRequest(ScheduleAtom.SAVE);
		}
		
		// touch atom request에 넣으면 검색시 request 2번 만들어 지므로 임시로 여기에 넣음
		var xnAtomRequest = MakeRequest.getAtomRequestNode(xnRequest);
		
		if (ContainsGridExAtom())
		{
			GridExAtom.makeRequest(xnAtomRequest);
		}
		if (ContainsReceiverAtom())
		{
			ReceiverAtom.makeRequest(xnAtomRequest);
		}
		if (ContainsDHtmlAtom())
		{
			DHtmlAtom.makeRequest(xnAtomRequest);
		}
	}
	catch (e)
	{
		HandleException(e);
	}
	
	try
	{	
		var xnRequestDoc = xnRequest.ownerDocument;
		if (null != xnRequestDoc)
		{
			var xnResultDoc = null;
				xnResultDoc = PQService.executeService(xnRequestDoc);
			
			if (null != xnResultDoc)
			{
				bComplete = true;
			}
		}
	}
	catch (e)
	{
		HandleException(e);
	}		
	return bComplete;
}
/**
 * 삭제버튼 실행
 */
ButtonAtom.prototype._executeDelete = function ()
{		
	var bComplete = false;
		
	GlobalField.setServiceName(ButtonAtom.DELETEACTION);

	var xnRequest = MakeRequest.createRequestNode();
	try
	{
		MakeRequest.makeServiceRequest(xnRequest);
		MakeRequest.makeTouchAtomRequest(xnRequest);
		MakeRequest.makeDecoAtomRequest(xnRequest);
		
		if(ContainsScheduleAtom())
		{
			ScheduleAtom.makeDeleteRequest(ScheduleAtom.DELETE);
		}
	}
	catch (e)
	{
		HandleException(e);
	}
	
	try
	{	
		var xnRequestDoc = xnRequest.ownerDocument;
		if (null != xnRequestDoc)
		{
			var xnResultDoc = PQService.executeService(xnRequestDoc);				
			if (null != xnResultDoc)
			{
				// 정상적인 저장 동작이 일어 났다면, 스케줄삭제 동작을 수행 합니다
				if (ContainsScheduleAtom())
				{
					ScheduleAtom.execute();
				}
				/**
				 * Bpm모델의 삭제일 경우에 삭제 버튼에 할당된 Event데로 업무의 보류, 취소, 완료를 설정한다. 
				 */
				if (Model.isBpmModel())
				{
					this._setButtonEventForBpmModel("삭제");	
				}
				
				//기본키 아톰의 저장속성에 삭제를 세팅한다.
				//결과값은 반영하지않는다. 폼_저장완료 스크립트에서 아톰의 값을 사용할 수 있어야 한다.
				HandleResult.setSaveType(xnResultDoc);
				// 폼_저장완료 스크립트
				ScriptFormEvent.onEndSave();
				
				bComplete = true;
			}
		}
	}
	catch(e)
	{
		HandleException(e);
	}
	
	// 화면을 지우지 않고 리프레시를 하면 삭제 당시 아톰값이 
	// 리프레시 동작에서 요청으로 갔다가 결과로 다시 나오게 된다.
	g_objModelCore.clearAtomValue();				
	Model.executeRefresh();
	
	this._executeSearch()
					
	//폼_저장결과 스크립트. 저장완료후로 바뀌었다고 함.
	ScriptFormEvent.onResultSave(bComplete);
}

ButtonAtom.prototype._executeRefresh = function ()
{
	/*GlobalField.setServiceName(ButtonAtom.INQUIRYACTION);
	GlobalField.setServiceEventName("Refresh");
	
	var xnRequest = MakeRequest.createRequestNode();		
	try
	{
		MakeRequest.makeServiceRequest(xnRequest);
		MakeRequest.makeInputAtomRequest(xnRequest);
		MakeRequest.makeDecoAtomRequest(xnRequest);
	}
	catch (e)
	{
		HandleException(e);
		return;
	}
	
	var xnRequestDoc = xnRequest.ownerDocument;
	if (null != xnRequestDoc)
	{
		var xnResultDoc = null;
		try
		{	
			xnResultDoc = PQService.executeService(xnRequestDoc);
		}
		catch (e)
		{
			HandleException(e);
		}
		
		if (null != xnResultDoc)
		{
			HandleResult.execute(xnResultDoc);				
		}
	}*/
}

/**
 * 앞장/뒷장버튼 실행
 */
ButtonAtom.prototype._executeInquiry = function ()
{
	// 폼_검색완료 스크립트 인자
	// #지금, #이전, #다음
	var nSearchEndType = 0;
	GlobalField.setServiceName(ButtonAtom.INQUIRYACTION);
	if (ButtonAtom.PREV == this.m_nButtonType)
	{
		GlobalField.setServiceEventName(ButtonAtom.PREVACTION);
		nSearchEndType = ScriptEvent.PREV_SEARCH_END;
	}
	else if (ButtonAtom.NEXT == this.m_nButtonType)
	{
		GlobalField.setServiceEventName(ButtonAtom.NEXTACTION);
		nSearchEndType = ScriptEvent.NEXT_SEARCH_END;
	}
	
	var xnRequest = MakeRequest.createRequestNode();		
	MakeRequest.makeServiceRequest(xnRequest);
	MakeRequest.makeTouchAtomRequest(xnRequest);
	MakeRequest.makeDecoAtomRequest(xnRequest);
	MakeRequest.makeWebAtomRequest(xnRequest);
			
	var xnResultDoc = null;
	try
	{
		var xnRequestDoc = xnRequest.ownerDocument;
		if (null == xnRequestDoc)
		{
			return;
		}
		
		xnResultDoc = PQService.executeService(xnRequestDoc);
		
		if (null == xnResultDoc)
		{
			return;
		}
	}
	catch(e)
	{
		HandleException(e);
		return;
	}		
	
	var strInfoMsg = this._getInfoMessage(xnResultDoc)
	if (null != strInfoMsg && 0 < strInfoMsg.length)
	{
		// 폼_검색완료(#앞장/#뒷장)
		ScriptFormEvent.onEndSearch(nSearchEndType, ScriptEvent.SEARCH_NORESULT);
	
		// 맨 앞장이거나 뒷장이면 끝.
		this._showInfoMessage(strInfoMsg);
		return;
	}
	
	/**
	 * Bpm모델의 앞장 뒷장일 경우에 앞장 뒷장 버튼에 할당된 Event데로 업무의 보류, 취소, 완료를 설정한다. 
	 */
	if (Model.isBpmModel())
	{
		if (ButtonAtom.PREV == this.m_nButtonType) // 앞장
		{
			this._setButtonEventForBpmModel("앞장");	
		}
		else if (ButtonAtom.NEXT == this.m_nButtonType) // 뒷장
		{
			this._setButtonEventForBpmModel("뒷장");	
		}
	}
	
	HandleResult.execute(xnResultDoc);
	
	// 폼_검색완료(#앞장/#뒷장)
	ScriptFormEvent.onEndSearch(nSearchEndType, ScriptEvent.SEARCH_SUCCEED);
}

ButtonAtom.prototype._executeInquiryDoc = function ()
{
	if (null != g_objDoc)
	{
		if (ButtonAtom.PREV == this.m_nButtonType)
		{
			g_objDoc.loadData(true, SQL_RECORD_TYPE.PREV_RECORD);
		}
		else if (ButtonAtom.NEXT == this.m_nButtonType)
		{
			g_objDoc.loadData(true, SQL_RECORD_TYPE.NEXT_RECORD);
		}
	}
}

/**
 * 챠트 연결 버튼 실행
 */
ButtonAtom.prototype._executeConnectChart = function ()
 {
 	var strRefVarName = this.m_strRefVarName;
 	
 	if ("" == strRefVarName)
 	{
 		return ;
 	}
 	
 	var objAtom = Model.getAtom(strRefVarName);
 	if (null == objAtom)
 	{
 		return ;
 	}
 	else
 	{
		if (!objAtom.getSearchInfo())
		{
			alert("검색결과가 존재하지 않습니다.");
			return;
		}
		else
		{
			var xnAtomDoc = objAtom.makeValueAttribForChartConnect();

			var arResult = new Array();
			
			var objExecuteConnection = new ExecuteConnectionChart();

			// 실행시 지정 다이얼로그를 뛰우고 그 값을 속성에 설정
			var xnAtom = xnAtomDoc.documentElement;
			
			var bExecuteChart = objExecuteConnection.execute(xnAtom);
			
			arResult[0] = window.document.title;
			arResult[1] = xnAtom;
			
			if (bExecuteChart)
			{
				Utils.showModalDialog(
					"/ups/sys/html/support/ChartFrame.html", 
					arResult, 
					-1, -1, 440, 420);
			}
		}
	}
 }
 
/**
 * 검색버튼 실행
 */
ButtonAtom.prototype._executeSearch = function ()
{
	var objRefAtom = this._findRefAtomForSearch();
	
	if (null == objRefAtom)
	{
		return;
	}
	
	var strRefVarName = objRefAtom.getVarName();
	
	if (g_bQWPClientMode)
	{
		g_objDoc.executeSearchAtom(strRefVarName);
		return;
	}
	
	GlobalField.setEventVarName(strRefVarName);
	GlobalField.setServiceName(ButtonAtom.SEARCHACTION);
	
	if (ContainsReportBrowseAtom() && null != ReportBrowseAtom.getAtom(strRefVarName))
	{
		GlobalField.setServiceEventName(ButtonAtom.REPORTBROWSEACTION);
	}
	else if (ContainsTreeAtom() && null != TreeAtom.getAtom(strRefVarName))
	{
		GlobalField.setServiceEventName(ButtonAtom.TREEACTION);
	}
	else if (ContainsGridExAtom() && null != GridExAtom.getAtom(strRefVarName))
	{
		GlobalField.setServiceEventName(ButtonAtom.GRIDEXACTION);
	}
	else if (ContainsChartAtom() && ChartAtom.getAtom(strRefVarName))
	{
		GlobalField.setServiceEventName(ButtonAtom.CHARTACTION);
	}
	else if (ContainsWebBoardAtom() && WebBoardAtom.getAtom(strRefVarName))
	{
		GlobalField.setServiceEventName(ButtonAtom.WEBBOARD);
	}

	var xnRequest = MakeRequest.createRequestNode();

	MakeRequest.makeServiceRequest(xnRequest);
	
	// 스크롤, 검색창, 트리의 변수 값을 치환하기 위해
	MakeRequest.makeAtomRequest(xnRequest, true);
	
	var xnResultDoc = null;
	try
	{
		MakeRequest.makeSearchAtomRequest(xnRequest, strRefVarName, ButtonAtom.SEARCHACTION);
		
		var xnRequestDoc = xnRequest.ownerDocument;
		if (null == xnRequestDoc)
		{
			return;
		}
		
		xnResultDoc = PQService.executeService(xnRequestDoc);
		
		if (null == xnResultDoc)
		{
			return;
		}
	}
	catch (e)
	{
		HandleException(e);
		return;
	}
	
	HandleResult.execute(xnResultDoc);
	
	if (ContainsReportBrowseAtom() || ContainsGridExAtom()) 
	{
		objRefAtom.onEndSearchAfter();
	}
}

/**
 *	엑셀값 받기
 */
ButtonAtom.prototype._executeExcelImport = function ()
{
	var objAtom = GridExAtom.getAtom(this.m_strRefVarName);
	
	if (null == objAtom)
	{
		return;
	}
	
	if (null == this.m_objExcelImport)
	{
		this.m_objExcelImport = new ExcelImport();	
	}
	
	this.m_objExcelImport.execute(objAtom);
	// 엑셀 출력 객체로 부터 출력 값을 가져온다
	// 참조 아톰을 자저온다
	// 아톰에 값을 뿌리기위한 형식으로 xml을 가공한다
	// 아톰에 값을 설정한다
}

/**
 * 검색필터 실행
 */
ButtonAtom.prototype._executeSearchFilter = function ()
{
	//검색필터의 타겟 검색창의 컬럼정보를 얻어온다.
	var objBrowseColumnList = this._getBrowseColumnList();
	if (null == objBrowseColumnList)
		return;
	
	//컬럼정보를 가지고 검색필터창을 띄운다.
	//리턴값형태: 항목변수명$쿼리
	var arReturnValue = Utils.showModalDialog(
		g_strServerURL + "sys/html/support/SearchFilter.html",
		objBrowseColumnList,
		-1, -1, 310, 325);
	
	if (null == arReturnValue)
	{
		return;
	}
	g_htSearchFilterResult[this.m_strRefVarName] = arReturnValue;
	
	var objAtom = null;
	if (ContainsReportBrowseAtom())
	{
		objAtom = ReportBrowseAtom.getAtom(this.m_strRefVarName);
	}
	if (null == objAtom && ContainsGridExAtom())
	{
		objAtom = GridExAtom.getAtom(this.m_strRefVarName);
	}
	
	if (null == objAtom)
	{
		return;
	}
	
	objAtom.setSupportType(ButtonAtom.SEARCHFILTER);
	
	//검색필터에서 넘어온 값으로 버튼의 검색기능을 수행한다.
	this._executeSearch();
}

/**
 * 검색식 실행
 */
ButtonAtom.prototype._executeSearchFormula = function ()
{
	var objSearchFormula = g_htSearchFormulaList[this.m_strRefVarName];
	if (null != objSearchFormula)
	{
		if (!objSearchFormula.closed)
		{
			return;
		}
	}
		
	var objBrowseColumnList = this._getBrowseColumnList(this.m_strRefVarName);
	if (null == objBrowseColumnList)
	{
		return;
	}
	objBrowseColumnList.push(this.m_strVarName);
	objBrowseColumnList.push(this.m_strRefVarName);
	
	var objResult = Utils.showModelessDialog(
		g_strServerURL + "sys/html/support/SearchFormula.html",
		objBrowseColumnList,
		-1, -1, 670, 275);
	
	if (null == objResult)
	{
		//TODO: 창을 열었는데 반환 핸들이 null 이라면?
		return;
	}
	
	objResult.opener = self;
	g_htSearchFormulaList[this.m_strRefVarName] = objResult;
}

/**
 *	@return 참조변수명에 해당되는 아톰이 있는지 확인해보고,
 *			없으면 트리, 검색창, 확장그리드, 웹게시판, 챠트, 스크롤 순으로
 *			제일 처음 발견되는 아톰을 리턴
 * 	- 빌더에서 테스트해 본 결과, 항목순서(탭순서)가 빠른 아톰이 검색되는것이 아니라, 먼저 그린 검색계열 아톰이 검색되었다.. 
 *    참조아톰명을 사용하도록 해야함
 */
ButtonAtom.prototype._findRefAtomForSearch = function ()
{
	var objAtom = null;
	
	if (null == objAtom && ContainsTreeAtom()) // 트리
	{
		objAtom = TreeAtom.getAtom(this.m_strRefVarName);
	}
	// 검색아톰중에서 참조아톰명에 해당되는 아톰이 있는지 찾는다.
	if (null == objAtom && ContainsReportBrowseAtom())		// 검색창
	{
		objAtom = ReportBrowseAtom.getAtom(this.m_strRefVarName);
	}
	if (null == objAtom && ContainsGridExAtom()) // 확장그리드
	{
		objAtom = GridExAtom.getAtom(this.m_strRefVarName);
	}
	if (null == objAtom && ContainsWebBoardAtom()) // 웹게시판
	{
		objAtom = WebBoardAtom.getAtom(this.m_strRefVarName);
	}
	if (null == objAtom && ContainsChartAtom()) // 차트
	{
		objAtom = ChartAtom.getAtom(this.m_strRefVarName);
	}
	if (null == objAtom && ContainsScrollAtom()) // 스크롤
	{
		objAtom = ScrollAtom.getAtom(this.m_strRefVarName);
	}
	
	// 그래도 없으면 제일 처음 발견되는 아톰을 찾는다.
	if (null == objAtom)
	{
		if (ContainsTreeAtom()) // 트리
		{
			objAtom = TreeAtom.getFirstAtom();
		}
		else if (ContainsReportBrowseAtom ()) // 검색창
		{
			objAtom = ReportBrowseAtom.getFirstAtom();
		}
		else if (ContainsGridExAtom()) // 확장그리드
		{
			objAtom = GridExAtom.getFirstAtom();
		}
		else if (ContainsWebBoardAtom()) // 웹게시판
		{
			objAtom = WebBoardAtom.getFirstAtom();
		}
		else if (ContainsChartAtom()) // 챠트
		{
			objAtom = ChartAtom.getFirstAtom();
		}
		else if (ContainsScrollAtom()) // 스크롤
		{
			objAtom = ScrollAtom.getFirstAtom();
		}
	}
	
	return objAtom;
}

/**
 * 웹페이지 모델 출력 기능.
 */
ButtonAtom.prototype._printWebModel = function ()
{
	var objAtom = null;
	if (ContainsWebModelAtom())
	{
		objAtom = WebModelAtom.getAtom(this.m_strRefVarName);
	}
	
	if (null != objAtom)
	{
		objAtom.printModel();
	}
	else
	{
		Model.printModel();		
	}
}

/**
 * 엑셀 출력.
 */
ButtonAtom.prototype._exportExcel = function ()
{
	var objAtom = this._findRefAtomForSearch();
		
	try
	{
		if (null != objAtom)
		{
			if (!objAtom.getSearchInfo())
			{
				alert("검색결과가 존재하지 않습니다.");
				return;
			}
			else
			{
				var strVarName = objAtom.getVarName();
				
				var arArgs = new Array();
				arArgs[0] = strVarName;
				arArgs[1] = self;
				
				Utils.showModalDialog(g_strServerURL + "sys/html/support/ExportExcel.html",
						arArgs, -1, -1, 310, 160);
			}
		}
	}
	catch (e)
	{
		HandleException(e);
		return;
	}
}

/**
 * 결재기능버튼 - 회수 기능을 수행한다.
 */
ButtonAtom.prototype._excuteNtoaActionReclaim = function ()
{
	var bResult = false;
	
	// 회수 수행
	var strRegisterNum = this._getMasterRegisterNum();
	if (null != strRegisterNum && "" != strRegisterNum)
	{
		bResult = Sanction.excuteReclaimAction(strRegisterNum);
	}
	
	// _저장결과 스크립트 이벤트 발생
	ScriptAtomEvent.onSaveResult(this.m_nScriptIndex, bResult ? "true" : "false");
}

/**
 * 결재기능버튼 - 송신 기능을 수행한다.
 */
ButtonAtom.prototype._executeNtoaActionSend = function ()
{
	var bResult = Sanction.executeSendAction();
	if (bResult)
	{
		//문서첨부 아톰 저장.
		Model.saveAttachAtom();
	}
	
	//_저장결과 스크립트 이벤트 발생
	ScriptAtomEvent.onSaveResult(this.m_nScriptIndex, bResult ? "true" : "false");
}

/**
 * 결재기능버튼일때 참조아톰의 값으로 결재등록번호를 구한다.
 */
ButtonAtom.prototype._getMasterRegisterNum = function () 
{
	var strRegisterNum = "";

	var strProperVar = this.m_strRefVarName;
	if (null != strProperVar && "" != strProperVar)
	{
		strRegisterNum = Model.getAtomValue(strProperVar);
	}
	else
	{
		// strProper 없다면 연산식으로 값을 찾을 필요도 있다. 
		// TODO 버튼의 m_strOperate를 js로 가져와야함.
		// 가지고 왔다면 #제거 해야함.
	}
	return strRegisterNum;
}

/**
 * 검색창컬럼리스트를 반환한다.
 */
ButtonAtom.prototype._getBrowseColumnList = function()
{
	var objBrowseAtom = null;
	var objBrowseColumnList = null;
	
	if(ContainsReportBrowseAtom())
	{
		objBrowseAtom = ReportBrowseAtom.getAtom(this.m_strRefVarName);
	}
	if (null != objBrowseAtom)
	{
		var objBrowseColumnList = objBrowseAtom.getBrowseColumnList();
		return objBrowseColumnList;
	}
	
	if (ContainsGridExAtom())
	{
		objBrowseAtom = GridExAtom.getAtom(this.m_strRefVarName);
	}
	if (null != objBrowseAtom)
	{
		var objBrowseColumnList = objBrowseAtom.getGridExColumnList();
		return objBrowseColumnList;
	}
}

ButtonAtom.prototype._getInfoMessage = function (xnResultDoc)
{
	var xnResult = HandleResult.getResultNode(xnResultDoc);
	var xnInfoMessage = XmlLib.selectSingleNode(xnResult, "./Message/InfoMessage");
	if (null == xnInfoMessage)
	{
		return null;
	}
	
	return XmlLib.getTextValue(xnInfoMessage);
}

/**
 * 사용자 정보 메시지를 출력한다.
 */
ButtonAtom.prototype._showInfoMessage = function (strInfoMessage)
{
	//기입한 속성 메시지가 있으면 메시지를 출력, 아니면 기본메시지(앞/뒷장입니다)출력
	if (null != this.m_strHelp && 0 < this.m_strHelp.length)
	{
		strInfoMessage = this.m_strHelp;
	}
	if (null != strInfoMessage && 0 < strInfoMessage.length)
	{
		alert(strInfoMessage);
	}
}

/**
 * Bpm모델의 저장일 경우에 입력된 정보를 다음 업무로 전달될  Argument를 만든다.
 */
ButtonAtom.prototype._makeNextArgumentForBpmModel = function ()
 {
 	var objParentWindow = ModelCore.getParentWindow();
		
	var htBpmExecuteInfoList = objParentWindow.GlobalField.getBpmExcuteInfoList();
	var objBpmExecuteInfo = htBpmExecuteInfoList[GetModelName()];
	var htReturnValues = objBpmExecuteInfo.getReturnValues();
	
	var strArgument = "";
	for (var strKey in htReturnValues)
	{
		var strValue = htReturnValues[strKey];
		
		//해당 인자를 사용하면
		if ("1" == strValue)
		{
			var objAtom = null;
			if (ContainsInputDataAtom())
			{
				objAtom = InputDataAtom.getAtom(strKey);
			}
			if (null != objAtom)
			{
				var strInputValue = objAtom.getValue();
				
				if ("" == strArgument)
				{
					strArgument = strKey + "$" + strInputValue;
				}
				else
				{
					strArgument = strArgument + "," + strKey + "$" + strInputValue;
				}
			}
		}
	}
	objBpmExecuteInfo.setPassArgument(strArgument);
 }

/**
 * Bpm모델의 버튼에 할당된 Event데로 업무의 보류, 취소, 완료를 설정한다. 
 */
ButtonAtom.prototype._setButtonEventForBpmModel = function (strButtonVarName)
{
	var objParentWindow = ModelCore.getParentWindow();
		
	var htBpmExecuteInfoList = objParentWindow.GlobalField.getBpmExcuteInfoList();
	var htBpmContentList = objParentWindow.GlobalField.getBpmContentList();
	 		
	var objBpmExecuteInfo = htBpmExecuteInfoList[GetModelName()];
	var objBpmContent = htBpmContentList[GetModelName()];
	
	//버튼의 Event가 완료이면 해당 업무가 수행되었다는 정보를 저장한다.
	var htActionEvents = objBpmExecuteInfo.getActionEvents();
	
	//버튼에 할당된 Event가 없을 때 (1:이벤트 없음)
	if ("1" == htActionEvents[strButtonVarName])
	{
			objBpmExecuteInfo.setEventState(1); //1:없음, 2:취소, 3:보류, 4:완료
	}
	//버튼에 할당된 Event가 취소일 때 (2:해당업무 취소)
	else if ("2" == htActionEvents[strButtonVarName])
	{
		objBpmExecuteInfo.setEventState(2); //1:없음, 2:취소, 3:보류, 4:완료
		//해당업무를 취소 시킨다.
		objParentWindow.ScheduleGlobalManager.getProgessMenuManager().onClickCancle(objBpmContent);
		//폼을 닫는다.
		this.executeClose(true);
	}
	//버튼에 할당된 Event가 보류일 때 (3:해당업무 보류)
	else if ("3" == htActionEvents[strButtonVarName])
	{
		objBpmExecuteInfo.setEventState(3); //1:없음, 2:취소, 3:보류, 4:완료
		//해당 업무를 보류 시킨다.
		objParentWindow.ScheduleGlobalManager.getProgessMenuManager().onClickReservation(objBpmContent)
		//폼을 닫는다.
		this.executeClose(true);
	}
	//버튼에 할당된 Event가 완료일 때 (4:해당업무 완료)
	else if ("4" == htActionEvents[strButtonVarName])
	{
		objBpmExecuteInfo.setEventState(4); //1:없음, 2:취소, 3:보류, 4:완료
		//해당 업무를 완료 시킨다.
		objParentWindow.ScheduleGlobalManager.getProgessMenuManager().onClickCompletion(objBpmContent);
		//폼을 닫는다.
		this.executeClose(true);
	}
}

ButtonAtom.prototype._checkPopupForeignKey = function ()
{
	
}

ButtonAtom.prototype.getProperty = function (wNameID, pvaArgs, pRetVal)
{
	switch (wNameID)
	{
		case 13:case 286: return this.get_GdiProperty (286, pvaArgs, pRetVal);
		case 15:case 253: return this.get_GdiProperty (253, pvaArgs, pRetVal);
		default : return StdCore.E_NOT_DEF_PROPERTY;
	}
}

ButtonAtom.prototype.setProperty = function (wNameID, pvaArgs, pRetVal)
{		
	switch (wNameID)
	{
		case 13 : case 286: return this.set_GdiProperty (286, pvaArgs, pRetVal);
		case 15 : case 253: return this.set_GdiProperty (253, pvaArgs, pRetVal);
		default : return StdCore.E_NOT_DEF_PROPERTY;
	}
}
	
ButtonAtom.prototype.action = function (wPropID, pvaArgs, pRetVal)
{
	switch (wPropID)
	{
	case 25 : case 289 :return this.raw_SaveDB (pvaArgs, pRetVal);
	case 27 : case 217 :return this.raw_Delete (pvaArgs, pRetVal);
	case 30 : case 224 :return this.raw_Action (224, pvaArgs, pRetVal);		
	default : return this.getProperty (wPropID, pvaArgs, pRetVal);
	}
}

ButtonAtom.prototype.raw_Delete = function (pvaArgs, pRetVal)
{
	g_objDoc.executeDelete();
	
	pRetVal.setValueType(CVariantX._vtInt, 1);

	return StdCore.S_OK;
}

ButtonAtom.prototype.raw_SaveDB = function (pvaArgs, pRetVal)
{
	g_objDoc.executeSave();
	
	pRetVal.setValueType(CVariantX._vtInt, 1);
	
	return StdCore.S_OK;
}

ButtonAtom.prototype.raw_Action = function (nNameId, pvaArgs, pRetVal)
{
	switch (nNameId)
	{
	case 224: // 검색()
		this._executeSearch();
		pRetVal.setValueType(CVariantX._vtInt, 1);
		break;
	}
	return StdCore.S_OK;
}

/**
 * 버튼식별상수
 */
ButtonAtom.OK = 0; // 확인
ButtonAtom.CLOSE = 1; // 닫기
ButtonAtom.SAVE = 2; // 저장
ButtonAtom.SAVECLOSE = 3; // 저장후닫기
ButtonAtom.DELETE = 4; // 삭제
ButtonAtom.PREV = 5;  // 이전
ButtonAtom.NEXT = 6; // 다음
ButtonAtom.SEARCH = 7; // 검색
ButtonAtom.CONNECTCHART = 8; // 차트연결
ButtonAtom.PRINT = 9; //출력
ButtonAtom.SEARCHFILTER = 14; // 검색필터
ButtonAtom.SEARCHFORMULA = 15; // 검색식
ButtonAtom.OPENMODEL = 11; // 상세폼열기
ButtonAtom.RETPARENT = 12; //호출처 회귀
ButtonAtom.CHART = 13; // 챠트그리기
ButtonAtom.EXCEL_IMPORT = 19; // 엑셀파일 가져오기
ButtonAtom.OPENFORM_INPUT = 20;
ButtonAtom.OPENFORM_SEARCH = 21;
ButtonAtom.OPENFORM_POPUP = 22;
ButtonAtom.LOGIN = 23;

ButtonAtom.NTOA_NTOAACTION_RECLAIM = 101; //결재기능버튼 - 회수
ButtonAtom.NTOA_NTOAACTION_SEND = 104; //결재기능버튼 - 송신

/*
* 서비스명
*/
ButtonAtom.SAVEACTION = "SaveAction";
ButtonAtom.DELETEACTION = "DeleteAction";
ButtonAtom.INQUIRYACTION = "InquiryAction";
ButtonAtom.PREVACTION = "Prev";
ButtonAtom.NEXTACTION = "Next";
ButtonAtom.SEARCHACTION = "SearchAction";
ButtonAtom.BROWSEACTION = "Browse";
ButtonAtom.REPORTBROWSEACTION = "ReportBrowse";
ButtonAtom.TREEACTION = "Tree";
ButtonAtom.GRIDEXACTION = "GridEx";
ButtonAtom.CHARTACTION = "Chart";
ButtonAtom.WEBBOARD = "WebBoard";
ButtonAtom.RETPARENTACTION = "RetParentAction"; // 호출처 회귀 서비스명 

ButtonAtom.DELETEMESSAGE = "이 문서를 삭제하시겠습니까 ?";

/**
 * 아톰리스트
 */
ButtonAtom._atoms = new Object();

/**
 *	초기화
 */
ButtonAtom.init = function ()
{
	for (var strVarName in ButtonAtom._atoms)
	{
		var objAtom = ButtonAtom._atoms[strVarName];
		if (null != objAtom)
		{
			objAtom.init();
		}
	}
}

/**
 * 저장버튼 텍스트 처리
 * @param strSaveType SaveType속성
 */
ButtonAtom.changeButtonTitle = function ()
{
	if (!ContainsInputDataAtom())
	{
		return;
	}
	
	var arDefaultKeyAtomList = InputDataAtom.getDefaultKeyAtoms();
	
	if (null == arDefaultKeyAtomList || 0 == arDefaultKeyAtomList.length)
	{
		return;
	}
	
	var objDefaultKeyAtom = arDefaultKeyAtomList[0];
	
	var bInsertMode = ("INSERT" == objDefaultKeyAtom.getSaveType()) ? true : false;
	
	// 제목을 변경할 버튼 찾기...
	var strButtonName = objDefaultKeyAtom.getRefVarName();
	if (null == strButtonName || "" == strButtonName)
	{
		strButtonName = "저장";
	}
	
	var objButton = ButtonAtom.getAtom(strButtonName); //'저장'버튼
	if (null == objButton)
	{
		return;
	}
	
	// 버튼의 참조변수명에 참조하고 있는 아톰이 있을 경우 이를 기준으로 한다..
	var strRefVarName = objButton.getRefVarName();
	if (null != strRefVarName && "" != strRefVarName)
	{
		var objAtom = InputDataAtom.getAtom(strRefVarName)
		
		if (null != objAtom)
		{
			bInsertMode  = ("INSERT" == objAtom.getSaveType()) ? true : false;
		}
	}
	
	var strButtonText = bInsertMode ? "저 장" : "수 정";
	
	objButton.setValue(strButtonText);
}

/**
 *	삭제버튼의 (비)활성화 처리
 *	모델이 InsertMode일때 삭제 버튼을 비활성화 시켜줍니다.
 */
ButtonAtom.disableDeleteButton = function ()
{
	if (!ContainsInputDataAtom())
	{
		return;
	}
	
	var arDefaultKeyAtomList = InputDataAtom.getDefaultKeyAtoms();
	
	if (null == arDefaultKeyAtomList || 0 == arDefaultKeyAtomList.length)
	{
		return;
	}
	
	var objDefaultKeyAtom = arDefaultKeyAtomList[0];
	
	var bInsertMode = ("INSERT" == objDefaultKeyAtom.getSaveType()) ? true : false;
	
	for (var strVarName in ButtonAtom._atoms)
	{
		var objAtom = ButtonAtom._atoms[strVarName];
		
		if (ButtonAtom.DELETE == objAtom.getButtonType())
		{
			objAtom.getHTML().disabled = bInsertMode ? true : false;
		}
	}
}

/*
* 버튼리스트에서 변수명으로 아톰을 검색해서 반환함
* @param 변수명 strVarName
* @param 스크롤이름  strScrollName
* @param 아톰 HTML Element  heAtom
* @return 변수명에 해당하는 버튼 아톰
*/
ButtonAtom.getAtom = function (strVarName, strScrollName, heAtom)
{
	if (null != strScrollName && 0 < strScrollName.length)
	{
		var objScrollAtom = null;
		if (ContainsScrollAtom())
		{
			objScrollAtom = ScrollAtom.getAtom(strScrollName);
		}
		if (null != objScrollAtom)
		{
			var nRowIndex = objScrollAtom.getRowIndex(heAtom);
			if (0 <= nRowIndex)
				return objScrollAtom.getBindedAtom(strVarName, nRowIndex);
		}
	}
	else
	{
		return ButtonAtom._atoms[strVarName];
	}
	
	return null;
}

/**
 * 저장 기능 버튼 아톰을 리턴 한다.
 */
ButtonAtom.getSaveButtonAtom = function ()
{
	for (var strVarName in ButtonAtom._atoms)
	{
		var objAtom = ButtonAtom._atoms[strVarName];
		
		if (null != objAtom)
		{
			if (objAtom.getButtonType() == ButtonAtom.SAVE)
			{
				return objAtom;
			}
		}
	}
	return null;
}

/**
 * 검색식 수행후 결과 처리
 *
 * @param strVarName 변수명
 * @param strRefVarName 참조변수명
 */
ButtonAtom.executeSearchFormulaResult = function (strVarName, strRefVarName)
{
	var objButtonAtom = ButtonAtom.getAtom(strVarName);
	if (null == objButtonAtom)
	{
		return;
	}
	objButtonAtom.executeSearchFormulaResult(strRefVarName);
}

/**
 * 버튼의 상세폼 기능을 실행한다.
 * @param strVarName 버튼 아톰명.
 * @param strRefVarName 참조변수명.
 * @param strModelName 연결모델명.
 */
ButtonAtom.executeConnectionModel = function (strVarName, strRefVarName, strModelName)
{
	var objAtom = ButtonAtom.getAtom(strVarName);
	if (null != objAtom)
	{
		objAtom.setRefVarName(strRefVarName);
		objAtom.setConnectionModelName(strModelName);
		objAtom.executeOpenModel();
	}
}

/**
 * 버튼의 닫기 기능을 실행한다.
 * @param strVarName 버튼 아톰명.
 */
ButtonAtom.executeFormClose = function (strVarName)
{
	var objAtom = ButtonAtom.getAtom(strVarName);
	if (null != objAtom)
	{
		objAtom.executeClose(true);
	}
}

/**
 * onfocus 이벤트
 *
 * @param strVarName 변수명 
 */
ButtonAtom.onFocus = function (strVarName, strScrollName, heAtom)
{
	var objButtonAtom = ButtonAtom.getAtom(strVarName, strScrollName, heAtom);
	if (null != objButtonAtom)
	{
		objButtonAtom.onFocus();
	}
}

/**
 * onclick 이벤트
 *
 * @param strVarName 변수명 
 * @param objEvent html 이벤트
 */
ButtonAtom.onClick = function (strVarName, strScrollName, heAtom, objEvent)
{
	objEvent = HTMLLib.getEvent(objEvent);

	var objButtonAtom = ButtonAtom.getAtom(strVarName, strScrollName, heAtom);
	if (null != objButtonAtom)
	{
		objButtonAtom.onClick(objEvent);
	}
}