/**
 * 웹게시판 Javascript 클래스 목록
 * 	- WebBoardAtom
 *	- WebBoardAttrib
 *	- WebBoardSelectRowStyle
 *	- PictureInfomation
 */
function WebBoardAtom (strVarName, // 1
					nScriptIndex, // 2
					nSQLIndex, // 3
					nDBIndex,
					strRefVarName, // 4
					strConnectionModelName, // 5
					nAtomHeight, // 6
					bAutoSize, // 7
					bOneClickExecute, // 8
					strTabID, // 9
					objColumnInfoList, // 10
					objWebBoardAttrib, // 11
					objWebBoardAtomPager, // 12
					objSelectRowStyle, // 13
					objWebBoardFont, // 14
					objResizableObject, // 15
					objPictureInfomation, // 16
					htColumnParameter, // 17
					strInquiryCountItemVarName, // 18
					strInquiryCountWhereItemVarNames, // 19
					strLinkedVariable,
					bIsShowSearch, arSearchIndex)
{
	this.Atom (strVarName, strRefVarName, "", -1, nScriptIndex, nSQLIndex, nDBIndex);
	
	this.m_bSearchStart = false;
	this.m_bDBIO = true;
    this.m_strConnectionModelName = strConnectionModelName; // 연결모델명
    this.m_nCurrentHeight = nAtomHeight;
    this.m_bAutoSize = bAutoSize;
    this.m_bOneClickExecute = bOneClickExecute; // 한번누름실행
    
    // 게시판 아톰이 웹탭뷰에 속한 경우 웹탭뷰의 탭 인덱스를 부여받는다.
    // 웹탭뷰에 속한 경우 이 값이 없어야 게시판이 활성화되고 검색동작이 됩니다.
    this.m_strTabID = strTabID;
    this.m_arColumnInfoList = objColumnInfoList; // 컬럼정보목록
    this.m_objWebBoardAttrib = objWebBoardAttrib; // 속성
    this.m_objWebBoardAtomPager = objWebBoardAtomPager; // 페이지목차
    this.m_objSelectRowStyle = objSelectRowStyle; // 선택행 스타일
    this.m_objWebBoardFont = objWebBoardFont; // 폰트 스타일
    this.m_objResizableObject = objResizableObject;
    this.m_objPictureInfomation = objPictureInfomation; // 갤러리형 게시판의 사진정보
   	this.m_htColumnParameter = htColumnParameter; // 웹 게시판 Column별 모델연결 정보
   	this.m_strInquiryCountItemVarName = strInquiryCountItemVarName;
   	this.m_strInquiryCountWhereItemVarNames = strInquiryCountWhereItemVarNames;
   	
   	this.m_strLinkedVariable = strLinkedVariable;	// 검색 결과 설정하기 위한 칼럼별 항목명 연결 정보
   	this.m_bColumnPositionEqual = true;
   	this.m_arColIndex = null;
   	this.m_bIsShowSearch = bIsShowSearch;
   	this.m_arSearchIndex = arSearchIndex;
    
    this.m_heAtom = document.getElementById(this.m_strVarName);
    
    // 검색결과가 담길 엘리먼트
    this.m_heBody = document.getElementById("__WEBBOARD_BODY_" + this.m_strVarName);
   	
    // 데이터 테이블
    this.m_heContents;
    
    this.m_nSelectedIndex = -1; // 선택된 행
    this.m_arCheckedRowList; // 체크된 행
    
    // 헤더 컬럼 마우스 다운 되었는가?
    this.m_bHeaderColumnMouseDown = false;
    
    this.m_nMaxResizeHeight = 0;
    this.m_nOldXPos = 0;
	this.m_bMouseDown = false;
	this.m_nSelectedColumnIndex = 0;
	
	// 컬럼 헤더가 마우스에 의해 리사이즈 되었는지의 여부
	this.m_bColumnHeaderResized = false;
	
	// 검색결과 xml.
	// 요청정보를 만들때 사용되고, 결과처리할 때 갱신된다.
	this.m_xnValue;
	
	// 검색결과 데이터셋
	// 갤러리형 게시판은 모든 값을 html 엘리먼트에 저장하지 않기 때문에
	// 데이터셋이 필요함.
	this.m_arValues;
	
	// 모델연결 하는지 여부
	this.m_bConnectModel = true;;
	
	this.m_heSearchCombo = document.getElementById("__WEBATOM_SEARCHCONTROL_SELECT_" + this.m_strVarName);
	this.m_heSearchInput = document.getElementById("__WEBATOM_SEARCHCONTROL_INPUT_" + this.m_strVarName);
	this.m_heSearchButton = document.getElementById("__WEBATOM_SEARCHCONTROL_BUTTON_" + this.m_strVarName);
}

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

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

WebBoardAtom.prototype.getAttrib = function ()
{
	return this.m_objWebBoardAttrib;
}

WebBoardAtom.prototype.isDirectExec = function ()
{
	return this.m_objWebBoardAttrib.isDirectExec();
}

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

WebBoardAtom.prototype.init = function ()
{
	this.m_objWebBoardAtomPager.init();
	
	if (g_bQWPClientMode)
	{
		var strPrimary = this.m_objWebBoardAttrib.getPrimaryItem();
	
		var strPrimaryField = this.getFieldName(strPrimary);
		if (0 < strPrimaryField.length)
		{
			strPrimary = strPrimaryField;
		}
		
		if (null == strPrimary || 0 == strPrimary.length)
		{
			strPrimary = this.m_arColumnInfoList[0].getFieldName();
		}
		
		var objAtomPageQuery;
		var arReplyFilterList = this.getReplyFieldList();
		
		if (null != arReplyFilterList && 1 == arReplyFilterList.length)
		{
			objAtomPageQuery = new WebAtomPageQueryEx(strPrimary, this.m_objWebBoardAttrib.getReplyItem(), this.getReplyFieldList());
		}
		else
		{
			objAtomPageQuery = new WebAtomPageQuery(strPrimary, this.m_objWebBoardAttrib.getReplyItem(), this.getReplyFieldList());
		}
		
		this.m_objWebBoardAtomPager.setAtomPageQuery(objAtomPageQuery);
		
		this.m_alCondIconInfoList = this.m_objWebBoardAttrib.initConditionInfo();
		
		this._checkColumnDataPosition();
	}
}

WebBoardAtom.prototype.initSearchInfo = function ()
{
	this.m_objWebBoardAtomPager.init();	
}
/**
 * 요청정보를 생성합니다
 */
WebBoardAtom.prototype.makeRequest = function (xnAtomRequest, bConnectionSearch)
{
	var xnWebBoardAtom = XmlLib.createChild(xnAtomRequest, "WebBoard");
	
	xnWebBoardAtom.setAttribute("VarName", this.m_strVarName);
	xnWebBoardAtom.setAttribute("SQLIndex", this.m_nSQLIndex);
	
	// 게시판 속성정보
	this.m_objWebBoardAttrib.makeRequest(xnWebBoardAtom, this.m_objPictureInfomation);
	
	// 페이지 정보
	this.m_objWebBoardAtomPager.makeRequest(xnWebBoardAtom);
	
	// 사진 정보
	this.m_objPictureInfomation.makeRequest(xnWebBoardAtom);
	
	// 컬럼 정보
	this._makeColuumnAttrib(xnWebBoardAtom);
	
	// 데이터
	if (null != this.m_xnValue)
	{
		XmlLib.importChildNode(xnWebBoardAtom, this.m_xnValue, true);
	}
	
	//선택행,체크행등을 요청정보에 저장
	this._makeRowAttrib(xnWebBoardAtom);
	
	this._makeWhereClause(xnWebBoardAtom, bConnectionSearch);
}

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

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

/**
 * 검색결과값 설정
 */
WebBoardAtom.prototype.setValue = function (xnWebBoardAtom)
{
	if (!this.isActivation())
	{
		return;
	}
	
	var bSetValue = ("Y" == XmlLib.getAttribute(xnWebBoardAtom, "IsDoSearch"));
	if (bSetValue)
	{
		var xnWebBoardPager = XmlLib.selectSingleNode(xnWebBoardAtom, "./WebAtomPager");
		
		if (xnWebBoardPager)
		{
			this.m_objWebBoardAtomPager.handleResult(xnWebBoardPager);
		}
		
		this.m_objWebBoardFont.makeFontAttrib(xnWebBoardAtom);
		this.m_arValues = this._extractValues(xnWebBoardAtom);
		this._makeBody(xnWebBoardAtom);
		
		if (this.m_bAutoSize)
		{
			// 페이지 컨트롤의 위치 변경은 반드시 body를 생성한 다음 수행되어야 합니다
			if (this.m_objWebBoardAttrib.isShowPager())
			{
				this._replacePagerPosition();
			}
			
			if(this.m_bIsShowSearch)
			{
				this._replaceSearcherposition();
			}
			
			this._changeAttributeRelationAtom();
		}
		else
		{
			var nAtomHeight = this.m_heAtom.offsetHeight;
			
			if(this.m_objWebBoardAttrib.isShowPager() && this.m_bIsShowSearch)
			{
				var nPageHeight = document.getElementById("__WEBATOM_PAGECONTROL_" + this.m_strVarName).offsetHeight;
				var objSearchControl = document.getElementById("__WEBATOM_SEARCHCONTROL_" + this.m_strVarName);
				
				this.m_objWebBoardAtomPager.replacePosition(nAtomHeight);
				objSearchControl.style.top = nAtomHeight + nPageHeight +  "px";
			}
			else
			{
				if (this.m_objWebBoardAttrib.isShowPager())
				{
					this.m_objWebBoardAtomPager.replacePosition(nAtomHeight);
				}
			
				if(this.m_bIsShowSearch)
				{
					var objSearchControl = document.getElementById("__WEBATOM_SEARCHCONTROL_" + this.m_strVarName);
					objSearchControl.style.top = nAtomHeight + "px";
				}
			}
		}
		
		
		// 선택행 설정
		var xnRowAttrib = XmlLib.selectSingleNode(xnWebBoardAtom, "./RowAttrib");
		var strSelectedRow = xnRowAttrib.getAttribute("SelectedRow");
		this.m_nSelectedIndex = Utils.parseInt(strSelectedRow) - 1; // 1베이스이므로 감소
	}
	
	// 체크 속성 처리
	this._setCheckedRow(xnWebBoardAtom);
}

/**
 * @return 결과XML로 구성한 데이터셋
 */
WebBoardAtom.prototype._extractValues = function (xnResult)
{
	var arValues = new Array();
	var xlRows = XmlLib.selectNodeList(xnResult, "Value/Row")
	
	for (var nRowIndex = 0; nRowIndex < xlRows.length; nRowIndex += 1)
	{
		var arRows = new Array();
		var xnRow = xlRows[nRowIndex];
		var xlCells = XmlLib.selectNodeList(xnRow, "ColData")
		
		for (var nColumnIndex = 0; nColumnIndex < xlCells.length; nColumnIndex += 1)
		{
			var xnCell = xlCells[nColumnIndex];
			var strCellData = XmlLib.getTextValue(xnCell);
			arRows.push(strCellData);
		}
		
		arValues.push(arRows);
	}
	
	return arValues;
}

WebBoardAtom.prototype._makeRowAttrib = function (xnWebBoardAtom)
{
	var xnRowAttrib = XmlLib.createChild(xnWebBoardAtom, "RowAttrib");
	XmlLib.createChildWithValue(xnRowAttrib, "SelectedRow", this.m_nSelectedIndex);
	
	// 체크행 정보
	var strCheck = "";
	var arCheckedRow = new Array();
	var heCheck = null;
	
	if (null != this.m_arCheckedRowList && 0 < this.m_arCheckedRowList.length)
	{
		for(var i = 0, chkLen = this.m_arCheckedRowList.length; i < chkLen ; i++)
		{
			heCheck = this.m_arCheckedRowList[i];
			heCheck.checked = true;
			
			var nIndex = heCheck.index;
			if (heCheck.checked && 0 <= nIndex)
			{
				arCheckedRow.push(nIndex);
			}
		}
		
		// 체크된 행의 값을 순서대로 정렬
		arCheckedRow.sort(function (A, B) { return A - B });		
		strCheck = arCheckedRow.join(",");
	}
	
	XmlLib.createChildWithValue(xnRowAttrib, "CheckedRow", strCheck);
}

// 연결검색 조건절 생성, 검색식, 검색필터 조건은 생성하지 않는다.
WebBoardAtom.prototype._makeWhereClause = function (xnRequest, bConnectionSearch)
{
	if (true == bConnectionSearch)
	{
		var xnWhereClause = XmlLib.createChild(xnRequest, "WhereClause");
	
		// 연결 검색 Where절 
		var arConnectionWhere = null;
	
		strWhere = PQConnectionSearch.makeWhereClause(this.m_strVarName);
		
		XmlLib.createChildWithValue(xnWhereClause, "ConnectionWhere", strWhere);
	}
}

/**
* 체크행을 설정한다.
* @param xnResult 결과정보
*/
WebBoardAtom.prototype._setCheckedRow = function (xnWebBoardAtom)
{
	// 데이터 행들을 감싸고 있는 부모 (TBODY)
	var heRowParent = this._getRowElementList(); 
	if (!heRowParent)
	{
		return;
	}
		
	var strCheckedRowIndex = XmlLib.getTextValue(XmlLib.selectSingleNode(xnWebBoardAtom, "RowsetAttrib/CheckedRow"));
	if (!strCheckedRowIndex)
	{
		return;
	}
	
	//체크된 행은 서버에서 1,2,3,.. 의 형식으로 넘어오는데 이것을 split연산으로 배열로 만듦	
	var arCheckedRow = strCheckedRowIndex.split(",");
	
	// 넘어온 값이 체크가 됬으면 양의정수 (1,2,3,...) 예전의 체크가 된 행이 체크를 거짓으로 하면 음의정수 (바뀌었으므로 저장해야 함) 로 바뀌는데,
	// 이에 따라 양의 정수면 체크를 설정하고, 음의정수이면 체크를 false시킨다. 
	// 이렇게 되면 모든 행을 다 돌지 않고 현재행 기준으로 바뀐행 또는 조작을 한 행만 취급하므로 효율적으로 작성할 수 있음
	for (var i = 0, len = arCheckedRow.length; i < len; i++)
	{
		var rowIndex = -1;
		var bChecked = true;
		
		if (null == arCheckedRow[i])
		{
			return ;
		}
		
		if (0 > Utils.parseInt(arCheckedRow[i]))
		{
			rowIndex = (-1) * (Utils.parseInt(arCheckedRow[i]) + 1);
			bChecked = false;
		}
		else
		{
			rowIndex = Utils.parseInt(arCheckedRow[i]) - 1;
		}
		
		for (var j = rowIndex; j < heRowParent.childNodes.length; j++)
		{
			if (j>=0 && heRowParent.children(j).rowIndex == rowIndex)
			{
				var heCheck = heRowParent.children(j).firstChild.firstChild.firstChild.firstChild.firstChild.firstChild;
				
				if (heCheck.tagName == "INPUT")
				{
					heCheck.checked = bChecked;
				}
				
				this._addCheckList(heCheck, bChecked);
			}			
		}
	}
}

/**
 * 검색창 결과행 html 리스트를 받아온다.
 * @return
 */
WebBoardAtom.prototype._getRowElementList = function ()
{
	var heContents = document.getElementById("__WEBBOARD_BODY_CONTENT_" + this.m_strVarName);
	if (!heContents)
	{
		return null;
	}
	
	// Row의 부모
	var heTBODY = heContents.getElementsByTagName("TBODY")[0];
	
	// 데이터 행이 존재할 경우
	if (0 < heTBODY.childNodes.length)
	{
		return heTBODY;
	}
	
	return null;
}

/**
 * 웹게시판에서 연결모델정보가 페이지 번호가 넘어 온다.
 */
WebBoardAtom.prototype.setRefPage = function (nPage)
{
	if (null != this.m_objWebBoardAtomPager)
	{
		this.m_objWebBoardAtomPager.setRefPage(nPage);
	}
}

/**
 * 웹 게시판의 크기 변화에 관계된 아톰들의 위치 및 크기를 변경 한다
 */ 
WebBoardAtom.prototype._changeAttributeRelationAtom = function ()
{
	this.m_heContents = document.getElementById("__WEBBOARD_BODY_CONTENT_" + this.m_strVarName);
	
	if (null != this.m_heContents && 0 != this.m_heContents.offsetHeight)
	{
		var nResizeHeight = this.m_heContents.offsetHeight - this.m_nCurrentHeight;
		
		if (0 != nResizeHeight)	// 최소높이 : 아톰의 높이는 유지해야함.
		{
			// 헤더 보임인경우 헤더의 높이를 항상 생각 해야 한다 
			// 크기 변화를 body 크기 반으로 판단하기 때문이다
			if (this.m_objWebBoardAttrib.isShowHeader())
			{
				nResizeHeight += 20/*헤더 높이*/;
			}
			
			this.m_objResizableObject.commitBoundsStatus(nResizeHeight, 0);
			
			this.m_nCurrentHeight = this.m_heContents.offsetHeight;
			this.m_heBody.style.height = this.m_nCurrentHeight;
			this.m_heAtom.style.height = document.getElementById(WebBoardAtom.WEBBOARD_HEADER + this.m_strVarName).offsetHeight + this.m_heBody.offsetHeight;
		}
	}
}

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

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

/**
 * 인자로 받은 값만큼 높이를 변화시킨다
 * 
 * @param nResizeValue (높이 변경 값)
 */
WebBoardAtom.prototype.resizeHeight = function (nResizeValue)
{
	// 다이어리 아톰은 위치, 크기이동이 없고 열기/닫기  버튼만 적용된다.
	var nHeight = this.m_heAtom.offsetHeight;
	
	this.m_heAtom.style.height = (nHeight + nResizeValue) + "px";
}

/**
 * 인자로 받은 값만큼 넓이를 변화시킨다
 * 
 * @param nResizeValue (높이 변경 값)
 */
WebBoardAtom.prototype.resizeWidth = function (nResizeValue)
{
	// 다이어리 아톰은 위치, 크기이동이 없고 열기/닫기  버튼만 적용된다.
	var nWidth = this.m_heAtom.offsetWidth;
	
	this.m_heAtom.style.width = (nWidth + nResizeValue) + "px";
}

/**
 * 모델 실행
 */
WebBoardAtom.prototype.executeConnectionModel = function (heColumn)
{
	if (!this.m_bConnectModel
		|| !this.m_heBody.hasChildNodes()
		|| this.m_nSelectedIndex < 0
		|| this.m_arValues.length <= this.m_nSelectedIndex)
	{
		return;
	}
	
	var strRunPath = this.m_strConnectionModelName;
	var strEmbedModelAtom = null;
	
	if (heColumn)
	{
		var nColumnIndex = heColumn.cellIndex;
		var strColumnVarName = this.m_arColumnInfoList[nColumnIndex].getItemVarName();
		var strColumnParam = this.m_htColumnParameter[strColumnVarName];
		
		// 해당 컬럼의 연결모델 정보가 있다면
		if (null != strColumnParam && 0 != strColumnParam.length)
		{
			// Column별 연결모델 정보를 이용한다.
			var arParam = strColumnParam.split("$");
			if (3 == arParam.length)
			{
				strRunPath = arParam[1];
				strEmbedModelAtom = arParam[2];
			}
		}
		
		this._updateInquiryCount();
	}
	
	if (strRunPath)
	{
		var objConnectionModelInfo = this._makeConnectionModelInfo();
		var nLinkType = this.m_objWebBoardAttrib.getLinkType();
		
		WebConnectionModel.execute(strRunPath, objConnectionModelInfo, nLinkType, strEmbedModelAtom);
	}
}

WebBoardAtom.prototype.executeConnectionSearch = function (heColumn)
{
	GlobalField.setServiceName("SearchAction");
	GlobalField.setServiceEventName("WebBoard");
	GlobalField.setEventVarName(this.m_strVarName);
	
	var xnRequest = MakeRequest.createRequestNode();
	
	MakeRequest.makeServiceRequest(xnRequest);
	var xnAtomRequest = MakeRequest.getAtomRequestNode(xnRequest);
	
	MakeRequest.makeAtomRequest(xnRequest, true);
	this.makeRequest(xnAtomRequest, true);
	
	var xnResultDoc = PQService.executeService(xnRequest.ownerDocument);
	
	//this._clearAtom();
	
	HandleResult.execute(xnResultDoc);
	
	this.m_bConnectionSearched = true;
}

/**
 * 조회수를 업데이트 합니다. 조회필드와 조건절은 동일한 테이블의 필드여야합니다.
 */
WebBoardAtom.prototype._updateInquiryCount = function ()
{
	if ("" != this.m_strInquiryCountItemVarName && "" == this.m_strInquiryCountWhereItemVarNames)
	{
		return ;
	}
	
	var nIndex = this._getItemVarIndexByName(this.m_strInquiryCountItemVarName);	
	if (-1 < nIndex)
	{
		var objInquiryCountColumn = this.m_arColumnInfoList[nIndex];
		if (objInquiryCountColumn)
		{
			var xnRequest = MakeRequest.createRequestNode();
			
			var strInquiryCountField = objInquiryCountColumn.getFieldName();
			var strInquiryCountTable = objInquiryCountColumn.getTableName();
			if (!strInquiryCountField || !strInquiryCountTable)
			{
				return;
			}
			
			//조회필드 요청정보 만들기
			var xnInquiryCount = XmlLib.createChild(xnRequest, "InquiryCountField");	
			XmlLib.setAttribute(xnInquiryCount, "Field", strInquiryCountField);
			XmlLib.setAttribute(xnInquiryCount, "Table", strInquiryCountTable);
			XmlLib.setAttribute(xnInquiryCount, "DBIndex", objInquiryCountColumn.getDbIndex());
			
			var alWhereItemVarNames = this.m_strInquiryCountWhereItemVarNames.split(',');
			if (0 == alWhereItemVarNames.length)
			{
				return;
			}
			
			var strWhereItemVarName = "";
			var objWhereColumn = null;
			for (var i = 0, nLen = alWhereItemVarNames.length; i != nLen; i++)
			{
				var strWhereItemVarName = Utils.trim(alWhereItemVarNames[i]);
				nIndex = this._getItemVarIndexByName(strWhereItemVarName);
				if (-1 < nIndex)
				{
					var objWhereColumn = this.m_arColumnInfoList[nIndex];
					if (null != objWhereColumn)
					{
						var strWhereField = objWhereColumn.getFieldName();
						var strWhereFieldType = objWhereColumn.getFieldType();
						var strWhereValue = this._getItemValue(this.m_nSelectedIndex, nIndex);
						
						//조건절 요청정보 만들기
						var xnWhereField = XmlLib.createChild(xnRequest, "WhereField");	
						XmlLib.setAttribute(xnWhereField, "Field", strWhereField);
						XmlLib.setAttribute(xnWhereField, "FieldType", strWhereFieldType);
						XmlLib.setAttribute(xnWhereField, "Value", strWhereValue);
					}
				}
			}
			
			try
			{
				PQPortalService.executeWebBoardAtomService(xnRequest.ownerDocument);
			}
			catch (e)
			{
			}
		}
	}
	
}

/**
 * 검색동작을 할 수 있는 상태인가?
 * 웹탭뷰에 속하지 않은 경우는 항상 활성화 상태입니다.
 * 웹탭뷰에 속한 경우 웹탭뷰 아톰에서 활성화를 시켜줍니다.
 */
WebBoardAtom.prototype.isActivation = function ()
{
	return null != this.m_strTabID && 0 == this.m_strTabID.length;
}

/**
 * 웹탭뷰에 속한 게시판 아톰을 활성화한다.  
 * 웹탭뷰에 속한 활성화가 되어야 검색동작이 일어날 수 있다.
 */
WebBoardAtom.prototype.setActivation = function ()
{
	this.m_strTabID = "";
}

WebBoardAtom.prototype.executeSearch = function ()
{
	this._executeSearch();
}

WebBoardAtom.prototype.onclickIndex = function (bExecuteSearch)//objEvent)
{
	if (bExecuteSearch)
	{
		this._executeSearch();
	}
}

/**
 * 첫 페이지로 버튼 클릭
 */
WebBoardAtom.prototype.onclickFirstPage = function ()
{
	this._executeSearch();
}

/**
 * 앞 페이지로 버튼 클릭
 */
WebBoardAtom.prototype.onclickPrePage = function ()
{
	this._executeSearch();
}

/**
 * 뒷 페이지로 버튼 클릭
 */
WebBoardAtom.prototype.onclickNextPage = function ()
{
	this._executeSearch();
}

/**
 * 마지막 페이지로 버튼 클릭
 */
WebBoardAtom.prototype.onclickLastPage = function ()
{
	this._executeSearch();
}

/**
 * @return 엘리먼트의 인덱스
 */
WebBoardAtom.prototype._extractSelectedIndex = function (heRow)
{
	var arRows = heRow.parentNode.children;
	
	for (var i = 0; i < arRows.length; i += 1)
	{
		if (arRows[i] == heRow)
		{
			return i;
		}
	}
	
	return -1;
}

WebBoardAtom.prototype.onMouseDown = function (heRow, objEvent, heCell)
{
	// 접근활성화가 아니면
	if (!this.m_objWebBoardAttrib.isHotTracking())
	{
		this._setSelectRowStyle(heRow, heCell.cellIndex + 1);
	}
	
	// 선택행
	this.m_nSelectedIndex = this._extractSelectedIndex(heRow);
	
	// 연결검색
	this._executeConnectionInput(heRow);
	
	// _선택변경 스크립트
	if (-1 == ScriptAtomEvent.onChangeSelect(this.m_nScriptIndex))
	{
		if (null != objEvent)
		{
			objEvent.returnValue = false;
		}
		return;
	}
	else
	{
		ScriptAtomEvent.onChangeSelectAfter(this.m_nScriptIndex);
	}
	
	// _선택변경완료 스크립트 
	if (-1 == ScriptAtomEvent.onEndChangeSelect(this.m_nScriptIndex))
	{
		if (null != objEvent)
		{
			objEvent.returnValue = false;
		}
		return;
	}
}

WebBoardAtom.prototype.onMouseUp = function ()
{
	// 접근활성화가 아닐 때에만 동작
	if (!this.m_objWebBoardAttrib.isHotTracking() && this._hasDataRow())
	{
		var arRows = this.m_heBody.firstChild.rows;
		
		for (var i = 0; i < arRows.length; i += 1)
		{
			this._setUnSelectRowStyle(arRows[i]);
		}
	}
}

WebBoardAtom.prototype.onmouseover = function (heRow, objEvent, nCell)
{
	// 접근활성화일 때에만 동작
	if (this.m_objWebBoardAttrib.isHotTracking())
	{
		this._setSelectRowStyle(heRow, nCell);
	}
}

WebBoardAtom.prototype.onClick = function (heRow, objEvent, heCell)
{
	// _누름 스크립트
	if (-1 == ScriptAtomEvent.onClick(this.m_nScriptIndex))
	{
		if (null != objEvent)
		{
			objEvent.returnValue = false;
		}
		return;
	}
	else
	{
		ScriptAtomEvent.onClickAfter(this.m_nScriptIndex);
	}
	
	if (this.m_bOneClickExecute)
	{
		// 연결모델
		this.executeConnectionModel(heCell);
	}
	
	this.m_bConnectModel = true;
}

WebBoardAtom.prototype.onmouseout = function (heRow, objEvent)
{
	// 접근활성화일 때만 동작
	if (this.m_objWebBoardAttrib.isHotTracking())
	{
		this._setUnSelectRowStyle(heRow);
	}
}


WebBoardAtom.prototype.onMouseUpBrowseHeaderColumn = function (heColumn)
{
	if (false == this.m_bHeaderColumnMouseDown)
	{
		this._setBrowseHeaderUpStyle(heColumn);
	}
}

WebBoardAtom.prototype.onMouseDownBrowseHeaderColumn = function (heColumn)
{
	if (false == this.m_bHeaderColumnMouseDown)
	{
		this._setBrowseHeaderDownStyle(heColumn);
	}
}

WebBoardAtom.prototype.onMouseOverBrowseResizer = function ()
{
	// 마우스 커서를  '<-->' 형태로 바꾼다.
	this._setHeaderCursor("e-resize");
}


/*
 * 컬럼 너비를 조절할 수 있는 부분에서 마우스가 나갔을 때.
 */
WebBoardAtom.prototype.onMouseOutBrowseResizer = function ()
{
	// 마우스 커서를 기본 형태로 바꾼다.
	this._setHeaderCursor("default");
}

/*
 * 컬럼 너비를 조절할 수 있는 부분에서 클릭이 일어났을때.
 * @param nColumnIndex 너비가 조정될 컬럼의 인덱스
 * @param objEvent 이벤트 객체
 */
WebBoardAtom.prototype.onMouseDownBrowseResizer = function (nColumnIndex, objEvent)
{
	if (null != objEvent)
	{
		this.m_nOldXPos = objEvent.screenX;
		this.m_bMouseDown = true;
		this.m_nSelectedColumnIndex = nColumnIndex;
	}
}

/*
 * 브라우져 헤더 상에서 마우스를 움직일 때.
 * @param objEvent 이벤트 객체
 */
WebBoardAtom.prototype.onMouseMoveBrowseHeader = function (objEvent)
{
	if (this.m_bMouseDown && null != objEvent)
	{
		this._setHeaderCursor("e-resize");
		// 이전 위치에서 변경된 만큼 너비를 변경한다.
		this._plusColumnWidth(objEvent.screenX - this.m_nOldXPos);
		// 현재 위치를 이전 위치에 저장한다.
		this.m_nOldXPos = objEvent.screenX;

		this.m_bColumnHeaderResized = true;
	}
}

/*
 * 브라우져 헤더 상에서 마우스가 업 되었을 때.
 */
WebBoardAtom.prototype.onMouseUpBrowseHeader = function (objEvent)
{
	// 마우스 클릭 상태를 푼다.
	this.m_bMouseDown = false;
	this._setHeaderCursor("default");
}

/**
 * 검색창 헤더 클릭 동작
 * @param nColumnIndex
 */
WebBoardAtom.prototype.onClickBrowseHeader = function (nColumnIndex)
{
	if (false == this.m_bColumnHeaderResized)
	{
		// 헤더동작 락 풀기가  false 인 경우나, 질의문 정의일 경우 컬럼을 통한 다시정렬 동작 안한다 
		if (this.m_objWebBoardAttrib.isUnLockHeader() && this.m_nSelectedIndex)
		{
			var objColumn = this.m_arColumnInfoList[nColumnIndex];
		
			var strColumnName = objColumn.getCompleteFieldName();
		}
	}
	
	this.m_bColumnHeaderResized = false;
}

/**
 * _두번누름 스크립트 -> 상세폼 연결
 */
WebBoardAtom.prototype.onDblClick = function (heRow, objEvent, heColumn)
{
	if (null == heRow)
	{
		return;
	}
	
	this.executeConnectionModel(heColumn);
}

/**
 * 체크박스를 직접 클릭했을 때 이벤트 처리를 한다.
 */
WebBoardAtom.prototype.onClickCheck = function (heCheck)
{
	this._addCheckList(heCheck, heCheck.checked);
	
	// 체크를 클릭했을 때는 모델연결하지 않는다.
	this.m_bConnectModel = false;
}

/**
 * 조건 검색 버튼을 눌렀을때, 기본조건 수정후 검색 동작 수행
 */
WebBoardAtom.prototype.onClickSearchButton = function ()
{
	var strAppendWhere = "";
	var strValue = this.m_heSearchInput.value;
	
	if (null != strValue && 0 < strValue.length)
	{
		var nRealIndex = this.m_arSearchIndex[this.m_heSearchCombo.selectedIndex];
		var strField = this.m_arColumnInfoList[nRealIndex].getFieldName();
		
		strAppendWhere = strField + " LIKE '%" + strValue + "%'";
		strAppendWhere = this.modifyDefaultCond(strAppendWhere);
	}
	
	var objAtomQuery = g_objPQQuery.getOuterQueryByIndex(this.m_nSQLIndex);
	objAtomQuery.setAppendWhere(strAppendWhere);
	
	this.m_objWebBoardAtomPager.initCurrentPage();
	
	this._executeSearch();
}

WebBoardAtom.prototype.onSearchInputKeyUp = function ()
{
	// 엔터키 눌렀을 경우
	if (13 == event.keyCode)
	{
		this.onClickSearchButton();
	}
}

WebBoardAtom.prototype._addCheckList = function (heCheck, bChecked)
{
	if (!heCheck)
	{
		return;
	}
		
	if (!this.m_arCheckedRowList)
	{
		this.m_arCheckedRowList = new Array();
	}
	
	// 체크되어 있는 row의 index 속성
	var nIndex = heCheck.index;
	
	//체크행이 있는지 검사.. 
	for (var i = 0; i < this.m_arCheckedRowList.length; i += 1)
	{
		if (heCheck.index == this.m_arCheckedRowList[i].index)
		{
			if (!heCheck.checked)
			{
				// checked가 false인 데이터는 배열에서 제거
				this.m_arCheckedRowList.splice(i, 1);
			}
			return;
		}
	}
	
	// 체크가 풀린 상태이면 리스트에 추가될 필요가 없음. (bChecked 에는 null, true, false 3가지 경우가 올 수 있음)
	if (bChecked)
	{
		this.m_arCheckedRowList.push(heCheck);
	}
}

/**
 * 현재 그리드 타입 그림게시판인지를 판단한다
 */
WebBoardAtom.prototype._isGridType = function ()
{
	return (this.m_objPictureInfomation.hasPictureInfo() && 1 == this.m_objPictureInfomation.getPictureType());
}

WebBoardAtom.prototype._executeSearch = function ()
{
	if (g_bQWPClientMode)
	{
		this.browseStart();
		return;
	}
	
	GlobalField.setServiceName("SearchAction");
	GlobalField.setServiceEventName("WebBoard");
	GlobalField.setEventVarName(this.m_strVarName);
	
	var xnRequest = MakeRequest.createRequestNode();
	var xnResultDoc = null;
	try
	{
		MakeRequest.makeServiceRequest(xnRequest);
		MakeRequest.makeAtomRequest(xnRequest, true);
		
		var xnAtomRequest = MakeRequest.getAtomRequestNode(xnRequest);		
		if (null != xnAtomRequest)
		{
			this.makeRequest(xnAtomRequest);			
			xnResultDoc = PQService.executeService(xnRequest.ownerDocument);
		}
	}
	catch (e)
	{
		HandleException(e);
		return;
	}
	
	if (null != xnResultDoc && null != xnResultDoc.documentElement)
	{		
		var xnWebBoardList = XmlLib.selectNodeList(xnResultDoc.documentElement, "//WebBoard");
		for (var i = 0, nLen = xnWebBoardList.length; i < nLen; i++)
		{
			var xnWebBoard = xnWebBoardList[i];
			var strVarName = XmlLib.getAttribute(xnWebBoard, "VarName");
			if (strVarName == this.m_strVarName)
			{
				this.setValue(xnWebBoard);
				break;
			}
		}	
	}
}

WebBoardAtom.prototype._getPagerYPos = function (nRowLen, nRowHeight)
{
	var nPagerYPos = nRowLen * nRowHeight + (14/*리스트 끝과 컨트롤러 사이의 간경*/);
	
	if(this.m_objWebBoardAttrib.isShowHeader())
	{
		 nPagerYPos += (20/*헤더높이*/)
	}
	
	return nPagerYPos;
}

/**
 *	페이지 컨트롤의 위치 변경
 */
WebBoardAtom.prototype._replacePagerPosition = function ()
{
	this.m_heContents = document.getElementById("__WEBBOARD_BODY_CONTENT_" + this.m_strVarName);
	
	var nRowHeight = 0;
	
	// 행의 요소중 행의 높이 보다 큰 요소가 존해하는 경우(ex: 큰 이미지) 행이 정해진 크기보다 커지기 때문에
	// 행이 존재 한다면 행의 높이를 행의 offsetHeight 로 넘긴다
	if (0 < this.m_heContents.rows.length)
	{
		nRowHeight = this.m_heContents.rows[0].offsetHeight;
	}
	
	var nHeight = this._getPagerYPos(this.m_heContents.rows.length, nRowHeight)
	
	// 페이지 컨트롤에 결과를 위치를 변경한다
	this.m_objWebBoardAtomPager.replacePosition(nHeight);
}

/**
 *	페이지 컨트롤의 위치 변경
 */
WebBoardAtom.prototype._replaceSearcherposition = function ()
{
	this.m_heContents = document.getElementById("__WEBBOARD_BODY_CONTENT_" + this.m_strVarName);
	
	var nRowHeight = 0;
	
	// 행의 요소중 행의 높이 보다 큰 요소가 존해하는 경우(ex: 큰 이미지) 행이 정해진 크기보다 커지기 때문에
	// 행이 존재 한다면 행의 높이를 행의 offsetHeight 로 넘긴다
	if (0 < this.m_heContents.rows.length)
	{
		nRowHeight = this.m_heContents.rows[0].offsetHeight;
	}
	
	var nHeight = this._getPagerYPos(this.m_heContents.rows.length, nRowHeight)
	
	var objSearchControl = document.getElementById("__WEBATOM_SEARCHCONTROL_" + this.m_strVarName);
	
	// 검색 컨트롤 위치를 변경한다
	if(this.m_objWebBoardAttrib.isShowPager())
	{
		var nPageHeight = document.getElementById("__WEBATOM_PAGECONTROL_" + this.m_strVarName).offsetHeight;
		objSearchControl.style.top = nHeight + nPageHeight +  "px";
	}
	else
	{
		objSearchControl.style.top = nHeight + "px";
	}
}

WebBoardAtom.prototype._setResizeHeight = function (nHeight)
{
	if (this.m_nMaxResizeHeight < nHeight)
	{
		this.m_nMaxResizeHeight = nHeight;
		
		this.m_heContents.style.pixelHeight = nHeight + "px;";
		this.m_heBody.style.pixelHeight = nHeight + "px;";
		
		var nHeight = this._getPagerYPos(this.m_heContents.rows.length, nHeight)
	
		// 페이지 컨트롤에 결과를 위치를 변경한다
		this.m_objWebBoardAtomPager.replacePosition(nHeight);
	}
}

/**
 * 웹 게시판 body 생성 
 *
 * @param xnWebBoardAtom (결과)
 */
WebBoardAtom.prototype._makeBody = function (xnWebBoardAtom)
{
	this.m_nMaxResizeHeight = 0;
	this.m_xnValue = XmlLib.selectSingleNode(xnWebBoardAtom, "./Value");
	
	var xnWebBoardValue = null;
	if (this._isGridType()) // 그리드 게시판이면
	{
		xnWebBoardValue = XmlLib.selectSingleNode(xnWebBoardAtom, "./GridValue");
	}
	else
	{
		xnWebBoardValue = XmlLib.selectSingleNode(xnWebBoardAtom, "./Value");
	}
	
	if (null == xnWebBoardAtom || null == xnWebBoardValue)
	{
		return;
	}
	
	this._purgeBody();
	
	// XSL 사용 안하고 만들기.
	this._makeBodyWithDom(xnWebBoardAtom);
	
	this.m_heContents = document.getElementById("__WEBBOARD_BODY_CONTENT_" + this.m_strVarName);
}

WebBoardAtom.prototype._makeBodyWithDom = function (xnWebBoardAtom)
{
	var strVarName = XmlLib.getAttribute(xnWebBoardAtom, "VarName");

	var xnWebBoardAttrib = XmlLib.selectSingleNode(xnWebBoardAtom, "WebBoardAttrib");
	var hasGridLine = XmlLib.getAttribute(xnWebBoardAttrib, "GridLine") == "Y";
	var nRowHeight = Utils.parseInt(XmlLib.getAttribute(xnWebBoardAttrib, "RowHeight"));
	var hasCheckBox = XmlLib.getAttribute(xnWebBoardAttrib, "ViewCheckBox") == "Y";
	var isBackgroundTransparent = XmlLib.getAttribute(xnWebBoardAttrib, "BackgroundTransparent") == "Y";

	var xnPictureInfo = XmlLib.selectSingleNode(xnWebBoardAtom, "PictureInfo");
	var nPictureWidth = Utils.parseInt(XmlLib.getAttribute(xnPictureInfo, "PictureWidth"));
	

	var xnFont = XmlLib.selectSingleNode(xnWebBoardAtom, "Font");
	var strFontFamily = XmlLib.getAttribute(xnFont, "Family");
	var nFontSize = Utils.parseInt(XmlLib.getAttribute(xnFont, "Size"));
	var strFontColor = XmlLib.getAttribute(xnFont, "Color");
	var isFontBold = XmlLib.getAttribute(xnFont, "Bold") == "Y";
	var isFontItalic = XmlLib.getAttribute(xnFont, "Italic") == "Y";
	var isFontUnderline = XmlLib.getAttribute(xnFont, "Underline") == "Y";
	var isFontStrikeout = XmlLib.getAttribute(xnFont, "Strikeout") == "Y";

	var heTable = document.createElement("table");
	heTable.cellPadding = "0px";
	heTable.cellSpacing = "0px";
	heTable.id = "__WEBBOARD_BODY_CONTENT_" + strVarName;
	heTable.bgColor = XmlLib.getAttribute(xnWebBoardAttrib, "BackgroundColor");
	heTable.style.cursor = "pointer";
	heTable.style.tableLayout = "fixed";
	
	var heHeader = document.getElementById("__WEBBOARD_HEADER_" + strVarName);
	
	var heColgroup = document.createElement("colgroup");
	heTable.appendChild(heColgroup);
	var xnColumnAttribList = XmlLib.selectNodeList(xnWebBoardAtom, "ColumnAttrib");
	var totalWidth = 0;
	for (var i = 0, nLen = xnColumnAttribList.length; i < nLen; i++)
	{
		
		var xnColumnAttrib = xnColumnAttribList[i];
		var nColumnWidth = XmlLib.getAttribute(xnColumnAttrib, "Width");
		totalWidth += Number(nColumnWidth);
		var isColumnVisible = XmlLib.getAttribute(xnColumnAttrib, "Visibility") == "Y";

		var heCol = document.createElement("col");
		heColgroup.appendChild(heCol);
		heCol.id = "__WEBBOARD_BODY_CONTENT_" + strVarName + "_" + i;
		if (isColumnVisible)
		{
			heCol.style.width = nColumnWidth + "px";
		}
		else
		{
			heCol.style.display = "none";
		}
	}
	/*아톰의 크기보다 보여지는 부분이 넚으면
	* heTable의 너비를 100%로 설정해서
	* 모두 보여지도록 함
	*/  
	if(heHeader.offsetWidth < totalWidth)
	{
		heTable.style.width = "100%";
	}
	this.m_heBody.appendChild(heTable);

	var heTbody = document.createElement("tbody");
	heTable.appendChild(heTbody);
	var xnValue = XmlLib.selectSingleNode(xnWebBoardAtom, "Value");
	var xnRowList = XmlLib.selectNodeList(xnValue, "Row");
	for (var nRowIndex = 0, nLen = xnRowList.length; nRowIndex < nLen; nRowIndex++)
	{
		var xnRow = xnRowList[nRowIndex];

		var heTr = document.createElement("tr");
		heTr.id = "_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex; 
		heTbody.appendChild(heTr);
		heTr.style.height = nRowHeight + "px";
		
		if (hasGridLine)
		{
			heTr.style.backgroundImage = "url('" +
					(g_nUPSType == MOBILE_COMMON_UPS ? g_strMobileCommonUpsUrl : "") + 
					"/ups/sys/image/pq/webatom/webboard/notice_line.gif')";
			heTr.style.backgroundRepeat = "repeat-x";
			heTr.style.backgroundPosition = "bottom";
		}

		if (XmlLib.getAttribute(xnRow, "ShowSeparate") == "Y")
		{
			heTr.style.backgroundColor = isBackgroundTransparent ? "transparent" : "#ffffff";
		}

		var xnColDataList = XmlLib.selectNodeList(xnRow, "ColData");
		for (var colIndex = 0, nColLen = xnColDataList.length; colIndex < nColLen; colIndex++)
		{
			var xnColData = xnColDataList[colIndex];
			
			var heTd = document.createElement("td");
			heTd.id = "_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex + "_Cell_" + colIndex;
			heTr.appendChild(heTd);
		

			if (heTd.attachEvent)
			{
				heTd.attachEvent(
					"onmouseover", 
					new Function("WebBoardAtom.onmouseover('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)"));
				
				heTd.attachEvent(
					"onmouseout",
					new Function("WebBoardAtom.onmouseout('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)"));
				
				heTd.attachEvent(
						"onmousedown", 
						new Function("WebBoardAtom.onMouseDown('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)"));
				heTd.attachEvent(
						"onclick", 
						new Function("WebBoardAtom.onClick('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)"));
				heTd.attachEvent(
						"ondblclick",
						new Function("event","WebBoardAtom.onDblClickBody('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)"));
				
			}
			else
			{
				
				heTd["onmouseover"] = new Function("event","WebBoardAtom.onmouseover('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)");
				heTd["onmouseout"] = new Function("event","WebBoardAtom.onmouseout('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)");
				heTd["onmousedown"] = new Function("event","WebBoardAtom.onMouseDown('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)");
				heTd["onclick"] = new Function("event","WebBoardAtom.onClick('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)");
				heTd["ondblclick"] = new Function("event","WebBoardAtom.onDblClickBody('" + strVarName + "', " + nRowIndex + "," + colIndex + ", event)");
			}

			heTd.style.paddingLeft = Utils.parseInt(XmlLib.getAttribute(xnColData, "Indent")) + "px";

			if (XmlLib.getAttribute(xnColData, "Visibility") == "N")
			{
				heTd.style.display = "none";
			}

			if (XmlLib.getAttribute(xnColData, "Width") == "0")
			{
				heTd.style.visibility = "hidden";
			}
			
			if (XmlLib.getAttribute(xnColumnAttribList[colIndex], "Width") == "0")
			{
				heTd.style.visibility = "hidden";
			}
			var heInnerTable = document.createElement("table");
			heTd.appendChild(heInnerTable);
			heInnerTable.cellPadding = "0";
			heInnerTable.cellSpacing = "0";
		//	heInnerTable.style.display = "none";
			heInnerTable.style.tableLayout = "fixed";
			heInnerTable.style.fontFamily = strFontFamily;
			heInnerTable.style.fontSize = nFontSize + "pt";
			heInnerTable.style.color = strFontColor;
			heInnerTable.style.width = "100%";

			if (isFontBold)
			{
				heInnerTable.style.fontWeight = "bold";
			}

			if (isFontItalic)
			{
				heInnerTable.style.fontStyle = "italic";
			}

			if (isFontUnderline && isFontStrikeout)
			{
				heInnerTable.style.textDecoration = "underline line-through";
			}
			else if (isFontUnderline)
			{
				heInnerTable.style.textDecoration = "underline";
			}
			else if (isFontStrikeout)
			{
				heInnerTable.style.textDecoration = "line-through";
			}

			if (XmlLib.getAttribute(xnColData, "Hidden") == "Y")
			{
				heInnerTable.style.visibility = "hidden";
			}

		
			var heInnerTbody = document.createElement("tbody");
			heInnerTable.appendChild(heInnerTbody);
			var heInnerTr = document.createElement("tr");
			heInnerTbody.appendChild(heInnerTr);

			var strPicturePath = XmlLib.getAttribute(xnColData, "PicturePath");
			if (null != strPicturePath)
			{
				var heInnerTd = document.createElement("td");
				heInnerTr.appendChild(heInnerTd);
				heInnerTd.align = "middle";
				
				if ("" != strPicturePath)
				{
					var heImg = document.createElement("img");
					heInnerTd.appendChild(heImg);
					//heImg.style.visibility = "hidden";
					
					heImg.width = nPictureWidth;
					heImg.height = nRowHeight;
					
					if (heImg.attachEvent)
					{	
						heImg.attachEvent("onload", 
						new Function("WebBoardAtom.resizeImage('" + strVarName + "', this, '"+nPictureWidth+"', " + nRowHeight + ")"));
					}
					else
					{
						heImg["onload"] = new Function("WebBoardAtom.resizeImage('" + strVarName + "', this, '"+nPictureWidth+"', " + nRowHeight + ")");
					}

					heImg.src = strPicturePath;
					heImg.alt = XmlLib.getAttribute(xnColData, "OrgFileName");
				}
			}
			else
			{
				if (0 == colIndex)
				{
					if (hasCheckBox)
					{
						var heInnerTd = document.createElement("td");
						heInnerTr.appendChild(heInnerTd);
						heInnerTd.style.width = "17px";

						var heInnerInput = document.createElement("input");
						heInnerInput.type = "checkbox";//append전에 해야 IE에서 동작함.
						heInnerTd.appendChild(heInnerInput);						
						heInnerInput.style.verticalAlign = "middle";
						heInnerInput.index = nRowIndex + 1;
						if (heInnerInput.attachEvent)
						{
							heInnerInput.attachEvent("onclick", 
								new Function("WebBoardAtom.onClickCheck('" + strVarName + "', this)"));
						}
						else
						{
							heInnerInput["onclick"] = new Function("WebBoardAtom.onClickCheck('" + strVarName + "', this)");
						}

						heInnerInput.checked = XmlLib.getAttribute(xnValue, "Checked") == "Y";
						heInnerInput.checked = XmlLib.getAttribute(xnRow, "DisplayChecked") == "Y";
					}
				}
				if (XmlLib.getAttribute(xnColData, "BodyIcon") == "Y")
				{
					var heInnerTd = document.createElement("td");
					heInnerTr.appendChild(heInnerTd);
					heInnerTd.align = "center";

					var xnBodyIcon = XmlLib.selectSingleNode(xnColData, "BodyIcon");
					var strIconPath = XmlLib.getAttribute(xnBodyIcon, "IconPath");
					if (null == strIconPath || "" == strIconPath)
					{
						var heInnerDiv = document.createElement("div");
						heInnerTd.appendChild(heInnerDiv);
					}
					else
					{
						heInnerTd.style.height = "100%";
						heInnerTd.style.width = "100%";

						var heInnerImg = document.createElement("img");
						heInnerTd.appendChild(heInnerImg);
						heInnerImg.src = strIconPath;

					}
				}
				else
				{
					var xnHeadIconList = XmlLib.selectNodeList(xnColData, "HeadIcon");
					for (var nHeadIconIndex = 0, nHeadIconLen = xnHeadIconList.length; nHeadIconIndex < nHeadIconLen; nHeadIconIndex++)
					{
						var xnHeadIcon = xnHeadIconList[nHeadIconIndex];
						var strIconPath = XmlLib.getAttribute(xnHeadIcon, "IconPath");
						if (null != strIconPath && "" != strIconPath)
						{
							var heInnerTd = document.createElement("td");
							heInnerTr.appendChild(heInnerTd);
							heInnerTd.align = "right";
							heInnerTd.style.height = "100%";
							heInnerTd.style.paddingRight = "3px";

							var heInnerImg = document.createElement("img");
							heInnerTd.appendChild(heInnerImg);
							heInnerImg.src = strIconPath;
							if (heInnerImg.attachEvent)
							{
								heInnerImg.parentNode.style.width = heInnerImg.offsetWidth + 3;
							}
							else
							{
								heInnerImg["onload"] = new Function("this.parentNode.style.width = this.offsetWidth + 3;");
							}
							
						}
					}

					var heInnerTd = document.createElement("td");
					heInnerTr.appendChild(heInnerTd);
					heInnerTd.style.width = "100%";
					heInnerTd.style.height = "100%";
					heInnerTd.style.overflow = "hidden";
					heInnerTd.style.whiteSpace = "nowrap";
					heInnerTd.style.textOverflow = "ellipsis";
					heInnerTd.style.padding = "0px 5px 0px 5px";
					heInnerTd.style.textAlign = XmlLib.getAttribute(xnColData, "Align");
					
					var heNobr = document.createElement("nobr");
					heInnerTd.appendChild(heNobr);
					heNobr.innerHTML = XmlLib.getTextValue(xnColData);

					var xnTailIconList = XmlLib.selectNodeList(xnColData, "TailIcon");
					for (var nTailIconIndex = 0, nTailIconLen = xnTailIconList.length; nTailIconIndex < nTailIconLen; nTailIconIndex++)
					{
						var xnTailIcon = xnTailIconList[nTailIconIndex];
						var strIconPath = XmlLib.getAttribute(xnTailIcon, "IconPath");
						if (null != strIconPath && "" != strIconPath)
						{
							var heInnerTd = document.createElement("td");
							heInnerTr.appendChild(heInnerTd);								
							heInnerTd.style.height = "100%";
							heInnerTd.style.paddingLeft = "3px";

							var heInnerImg = document.createElement("img");
							heInnerTd.appendChild(heInnerImg);
							heInnerImg.src = strIconPath;
							
							if (heInnerImg.attachEvent)
							{
								heInnerImg.parentNode.style.width = heInnerImg.offsetWidth + 3;
							}
							else
							{
								heInnerImg["onload"] = new Function("this.parentNode.style.width = this.offsetWidth + 3;");
							}
							
						}
					}
				}
			}			
		}
	}
	
	//자동크기조절일때 아톰크기를 조절한다.
	//행 높이 + 헤더높이
	if(this.m_bAutoSize)
	{
		this.m_heAtom.style.height = heTable.offsetHeight + 20 + "px";
	}
}

/**
 * 이전 검색 결과 DOM 객체를 해제 하기 위해 쓰레기통에 넣음 
 */
WebBoardAtom.prototype._purgeBody = function ()
{
	if (this.m_heBody.hasChildNodes())
	{
		var heTable = this.m_heBody.childNodes[0];
		
		g_heGarbageBin.appendChild(heTable);
		heTable = null;
	}
}

WebBoardAtom.prototype.getItemValue = function (strItemVarName)
{
	var strValue = "";
	
	if (null != strItemVarName)
	{
		var nColumnIndex = this._getItemVarIndexByName(strItemVarName);
		strValue = this._getItemValue(this.m_nSelectedIndex, nColumnIndex);
	}
	return strValue;
}

WebBoardAtom.prototype.getFieldName = function (strItemVarName)
{
	var strFieldName = "";
	
	if (null != strItemVarName)
	{
		var nColumnIndex = this._getItemVarIndexByName(strItemVarName);
		if (0 <= nColumnIndex)
		{
			strFieldName = this.m_arColumnInfoList[nColumnIndex].getFieldName();
		}
	}
	return strFieldName;
}

WebBoardAtom.prototype.getTableFieldName = function (strItemVarName)
{
	for (var i = 0; i < this.m_arColumnInfoList.length; i++)
	{
		if (strItemVarName == this.m_arColumnInfoList[i].getItemVarName())
		{
			return this.m_arColumnInfoList[i].getCompleteFieldName();
		}
	}
	
	return "";
}

/**
 * @return 인자로 넘겨진 행과 열에 해당되는 항목 값
 */
WebBoardAtom.prototype._getItemValue = function (nRowIndex, nColumnIndex)
{
	if (nRowIndex < 0
		|| this.m_arValues.length <= nRowIndex
		|| nColumnIndex < 0
		|| this.m_arColumnInfoList.length <= nColumnIndex)
	{
		return "";
	}
	
	return this.m_arValues[nRowIndex][nColumnIndex];
}

/*
 * 상세폼 열기에 필요한 정보를 만든다.
 */
WebBoardAtom.prototype._makeConnectionModelInfo = function ()
{
	var objConnectionModelInfo = new Object();
	this._makeConnectionModeInfoByItemValue(objConnectionModelInfo);
	this._makeConnectionModelInfoByRefValue(objConnectionModelInfo);

	return objConnectionModelInfo;
}

/**
 * 항목 변수를 이용한 상세폼 정보 수집
 * @param objConnectionModelInfo (상세폼 정보를 저장하게 될 Hashtable)
 */
WebBoardAtom.prototype._makeConnectionModeInfoByItemValue = function (objConnectionModelInfo)
{
	for (var i = 0; i < this.m_arColumnInfoList.length; i++)
	{
		var objWebBoardColumn = this.m_arColumnInfoList[i];
		if (!objWebBoardColumn
			|| !objWebBoardColumn.isReferenceKey()
			|| !objWebBoardColumn.getItemVarName()) // 항목변수명이 설정 안되어 있으면 상세폼 동작 안합니다.
		{
			continue;
		}
		
		var strItemVarName = objWebBoardColumn.getItemVarName();
		var arConnectionInfo = [
			this._getItemValue(this.m_nSelectedIndex, i),
			objWebBoardColumn.getFieldName()
		];
		objConnectionModelInfo[strItemVarName] = arConnectionInfo;
	}
}

WebBoardAtom.prototype._setBrowseHeaderUpStyle = function (heColumn)
{
	heColumn.style.borderTopWidth = "1px";
	heColumn.style.borderLeftWidth = "1px";
	heColumn.style.borderTopColor = "#FFFFFF";
	heColumn.style.borderTopColor = "#FFFFFF";
	
	heColumn.style.borderRightWidth = "2px";
	heColumn.style.borderBottomWidth = "2px";
	heColumn.style.borderRightColor = "#999999";
	heColumn.style.borderBottomColor = "#999999";
}

/**
 * 마우스 다운 이벤트에서 검색창 해더 컬럼의 디자인을 설정 한다
 */
WebBoardAtom.prototype._setBrowseHeaderDownStyle = function (heBrowseHeaderColumn)
{
	heBrowseHeaderColumn.style.borderTopWidth = "2px";
	heBrowseHeaderColumn.style.borderLeftWidth = "2px";
	heBrowseHeaderColumn.style.borderTopColor = "#999999";
	heBrowseHeaderColumn.style.borderTopColor = "#999999";
	
	heBrowseHeaderColumn.style.borderRightWidth = "1px";
	heBrowseHeaderColumn.style.borderBottomWidth = "1px";
	heBrowseHeaderColumn.style.borderRightColor = "#999999";
	heBrowseHeaderColumn.style.borderBottomColor = "#999999";
	
}

WebBoardAtom.prototype._makeColuumnAttrib = function (xnWebBoardAtom)
{
	var nLen = this.m_arColumnInfoList.length;
	
	for (var i = 0; i < nLen; i++)
	{
		var objColumn = this.m_arColumnInfoList[i];
		
		objColumn.makeColumnRequest(xnWebBoardAtom);
	}
}

/**
 * 항목변수의 이름을 통해 해당 인덱스를 얻는다
 * @param 항목변수명
 * @return nItemValueIndex (항목변수 인덱스)
 */
WebBoardAtom.prototype._getItemVarIndexByName = function (strItemVarName)
{
	for (var i = 0; i < this.m_arColumnInfoList.length; i++)
	{
		var objWebBoardColumn = this.m_arColumnInfoList[i];

		if (null == objWebBoardColumn)
		{
			continue;
		}

		if (strItemVarName == objWebBoardColumn.getItemVarName())
		{
			return i;
		}
	}

	return -1;
}

/**
 * 참조정보를 이용한 상세폼 정보 수집
 * @param objConnectionModelInfo (상세폼 정보를 저장하게 될 Hashtable)
 */
WebBoardAtom.prototype._makeConnectionModelInfoByRefValue = function (objConnectionModelInfo)
{
	var strRefValue = this.m_strRefVarName;
	
	if (!strRefValue)
	{
		return;
	}
	
	// PQ 5.0 - 검색창@항목변수 -> 검색창.항목변수
	strRefValue = Utils.replace(strRefValue, "\\.", "@");
	// PQ 5.0 - 부모폼입력란$자식폼입력란 -> 부모폼입력란=자식폼입력란
	strRefValue = Utils.replace(strRefValue, "=", "$");

	var alConnectionInfos = strRefValue.split(',');

	var strVarName = "";
	var arConnectionInfo = null;

	for (var i = 0, nLen = alConnectionInfos.length; i < nLen; i++)
	{
		var strConnectionInfo = Utils.trim(alConnectionInfos[i]);
		
		// 검색창의 특정 항목 변수값을 넘기는 형식인가?
		// 검색창@항목변수$자식폼입력란 => 다음과 같은 형식
		if (-1 < strConnectionInfo.indexOf('@'))
		{
			var alConnectionInfo = strConnectionInfo.split('$');
			var alWebBoardItemValue = alConnectionInfo[0].split('@');
			var objWebBoardAtom = WebBoardAtom.getAtom(alWebBoardItemValue[0]);

			if (null == objWebBoardAtom)
			{
				continue;
			}
			
			strVarName = alConnectionInfo[1];
			
			// hashTable에 들어갈 값은 [아톰값][필드명]으로 된 배열이 된다.
			// 상세폼에서 hashTable의 key인 "아톰변수명"으로 아톰을 찾다가 없으면 [필드명]으로 찾아서 [아톰값]을 넣어준다.
			arConnectionInfo = new Array(
				objWebBoardAtom.getItemValue(alWebBoardItemValue[1]), 
				objWebBoardAtom.getFieldName(alWebBoardItemValue[1]));
		}
		// 동일하지 않은 부모, 자식폼 입력란 간의 값전달
		// 부모폼입력란$자식폼입력란, 부모폼입력란1$자식폼입력란1
		else if (-1 < strConnectionInfo.indexOf('$'))
		{
			var alConnectionInfo = strConnectionInfo.split('$');
			var objInputData = null;
			
			// 변수명이 웹게시판의 아톰명이면 웹 게시판의 현제 페이지 값을 전달한다.
			if (alConnectionInfo[0] == this.m_strVarName && null != this.m_objWebBoardAtomPager)
			{
				strVarName = alConnectionInfo[1];
				arConnectionInfo = new Array(this.m_objWebBoardAtomPager.getCurrentPage(), "");
			}
			else
			{
				if (ContainsInputDataAtom())
				{
					objInputData = InputDataAtom.getAtom(alConnectionInfo[0]);
				}
				
				if (null == objInputData && ContainsRectangleAtom())
				{
					objInputData = RectangleAtom.getAtom(alConnectionInfo[0]);
				}
	
				if (null != objInputData)
				{
					strVarName = alConnectionInfo[1];
					
					// hashTable에 들어갈 값은 [아톰값][필드명]으로 된 배열이 된다.
					// 상세폼에서 hashTable의 key인 "아톰변수명"으로 아톰을 찾다가 없으면 [필드명]으로 찾아서 [아톰값]을 넣어준다.
					arConnectionInfo = new Array(objInputData.getValue(), objInputData.getFieldName());
				}
			}
			
		}
		// 동일한 부모, 자식폼 입력란 간의 값전달
		// 입력란,입력란1,입력란
		else
		{
			// 변수명이 웹게시판의 아톰명이면 웹 게시판의 현제 페이지 값을 전달한다.
			if (strConnectionInfo == this.m_strVarName && null != this.m_objWebBoardAtomPager)
			{
				strVarName = strConnectionInfo;
				arConnectionInfo = new Array(this.m_objWebBoardAtomPager.getCurrentPage(), "");
			}
			else
			{
				// 데이터 입력란 또는 날짜입력란에서 값을 가져온다.  
				var objAtom = null;
				if(ContainsInputDataAtom())
				{
					objAtom = InputDataAtom.getAtom(strConnectionInfo);
				}
				if (null == objAtom && ContainsRectangleAtom())
				{
					objAtom = RectangleAtom.getAtom(strConnectionInfo);
				}
				
				if (null != objAtom)
				{
					strVarName = strConnectionInfo;
					arConnectionInfo = new Array(objAtom.getValue(), objAtom.getFieldName());
				}
				else 
				{
					if(ContainsInputTimeAtom())
					{
						objAtom = InputTimeAtom.getAtom(strConnectionInfo);
					}
					
					if (null != objAtom)
					{
						strVarName = strConnectionInfo;
						
						// hashTable에 들어갈 값은 [아톰값][필드명]으로 된 배열이 된다.
						// 상세폼에서 hashTable의 key인 "아톰변수명"으로 아톰을 찾다가 없으면 [필드명]으로 찾아서 [아톰값]을 넣어준다.
						arConnectionInfo = new Array(objAtom.getValue(), objAtom.getFieldName());
					}
					// 아톰에서 찾지 못한다면 검색창 자신의 항목변수에서 찾는다.
					else
					{
						// 항목을 찾는다.
						var nIndex = this._getItemVarIndexByName(strConnectionInfo);
						
						if (-1 != nIndex)
						{
							strVarName = strConnectionInfo;
							
							// hashTable에 들어갈 값은 [아톰값][필드명]으로 된 배열이 된다.
							// 상세폼에서 hashTable의 key인 "아톰변수명"으로 아톰을 찾다가 없으면 [필드명]으로 찾아서 [아톰값]을 넣어준다.
							arConnectionInfo = new Array(this._getItemValue(this.m_nSelectedIndex, nIndex), this._getColumnFieldType(nIndex));
						}
						else
						{
							continue;
						}
					}
				}
			}
		}
		
		if (arConnectionInfo)
		{
			objConnectionModelInfo[strVarName] = arConnectionInfo;
		}
	}
}

//웹게시판이  데이터를 가지고 있는지 판단한다. 
WebBoardAtom.prototype._hasDataRow = function ()
{
	if(null == this.m_heBody.firstChild)
		return false;
	else
		return true;
}


/**
 * 인덱스에 해당하는  column의 FieldType을 가지고 온다.
 * @param column의 인덱스 
 */
WebBoardAtom.prototype._getColumnFieldType = function (nIndex)
{
	var objWebBoardColumn = this.m_arColumnInfoList[nIndex];
	if (null != objWebBoardColumn)
	{
		return objWebBoardColumn.getFieldName();
	}
	
	return null;
}

/**
 * 입력란 연결검색 실행
 * @param heRow
 */
WebBoardAtom.prototype._executeConnectionInput = function (heRow)
{
	var heColumList = heRow.childNodes;
	var arConInputInfo = new Array();
	
	for (var i = 0; i < this.m_arColumnInfoList.length; i++)
	{
		var objWebBoardColumn = this.m_arColumnInfoList[i];
		
		if (objWebBoardColumn && objWebBoardColumn.isReferenceKey())
		{
			if (this._isGridType())
			{
				// 그리드 타입은 ROW당 하나의 HTML Column이 만들어진다.
				var strRowValue = heColumList[0].RowValue;
				var arRowValue = strRowValue.split("^");
				
				if (i < arRowValue.length)
				{
					var objConInputInfo = new PQConnectionInputInfo(
						objWebBoardColumn.getItemVarName(), objWebBoardColumn.getTableName(), 
					    objWebBoardColumn.getFieldName(), arRowValue[i]);
					    
					arConInputInfo.push(objConInputInfo);
				}
			}
			else
			{
				var heColumn = heColumList[i];
				if (heColumn)
				{
					var objConInputInfo = new PQConnectionInputInfo(
						objWebBoardColumn.getItemVarName(), objWebBoardColumn.getTableName(), 
					    objWebBoardColumn.getFieldName(), this._getColumnValue(heColumn));
					    
					arConInputInfo.push(objConInputInfo);
				}
			}
		}
	}
	
	if (0 < arConInputInfo.length)
	{
		PQConnectionInput.execute(arConInputInfo);
	}
}

/**
 * @param heColumn(Column(TD))HTML
 * @return column의 값.
 */
WebBoardAtom.prototype._getColumnValue = function (heColumn)
{			
	return heColumn.firstChild.innerText;
}

WebBoardAtom.prototype._setSelectRowStyle = function (heRow, nCell)
{
	// 선택행 스타일 지정
	this.m_objSelectRowStyle.setStyle(heRow, nCell);
	
	// 그리트 형일경우 이미지 테두리 제어
	if (this._isGridType() && this.m_objWebBoardAttrib.isShowSeparate())
	{
		heRow.getElementsByTagName("table")[0].style.borderColor = this.m_objSelectRowStyle.getBackColor();
	}
}

WebBoardAtom.prototype._setUnSelectRowStyle = function (heRow)
{
	if (null == heRow)
	{
		return;
	}
	
	this.m_objWebBoardFont.setDefaultRowStyle(heRow);
	
	this._setDefaultRowBackColor(heRow);
}

/**
 * 행의 기본 스타일중 행배경을 설정한다
 * 행 구분인 경우를 고려하여야 한다
 *
 * @param heRow (선택된 행)
 */
WebBoardAtom.prototype._setDefaultRowBackColor = function (heRow)
{
	if (this._isGridType() && this.m_objWebBoardAttrib.isShowSeparate())
	{
		heRow.getElementsByTagName("table")[0].style.borderColor = "#F0F0F0";
	}
	else
	{
		if (this.m_objWebBoardAttrib.isShowSeparate() && (0 == (heRow.rowIndex % 2)) && 
				false == this.m_objWebBoardAttrib.isTransparent())
		{
			heRow.style.backgroundColor = "#ffffff";
		}
		else
		{
			heRow.style.backgroundColor = "transparent";
		}
	}
}

/*
 * 마우스 커서 모양을 지정한다.
 * @param strCursorType 마우스 커서 형태를 나타내는 키워드. ex) "e-resize", "default", etc.
 */
WebBoardAtom.prototype._setHeaderCursor = function (strCursorType)
{	
	document.getElementById(WebBoardAtom.WEBBOARD_HEADER + this.m_strVarName).style.cursor = strCursorType;
}

/*
 * 컬럼의 너비를 offset만큼 더한다. 
 * @param nOffset 변경될 너비
 */
WebBoardAtom.prototype._plusColumnWidth = function (nOffset)
{
	var heColumnHeader = this._getHeaderElementByColumnIndex(this.m_nSelectedColumnIndex);
	
	var MIN_WIDTH = 50;
	
	var nWidth = heColumnHeader.style.posWidth + nOffset;
	
	// 변경후 컬럼 너비가 최소값 미만이면 변경하지 않는다.
	if (MIN_WIDTH > nWidth)
	{
		return;
	}
	
	this._changeColumnWidth(this.m_nSelectedColumnIndex, nWidth);
}

/**
 * 컬럼 인덱스를 통헤 컬럼헤더 요소를 반환한다
 * @param nColumnIndex (컬럼 인덱스)
 */
WebBoardAtom.prototype._getHeaderElementByColumnIndex = function (nColumnIndex)
{
	var strHearderColumnName = WebBoardAtom.WEBBOARD_HEADER + this.m_strVarName + "_" + nColumnIndex;
			
	return document.getElementById(strHearderColumnName);
}

/**
 * 컬럼의 너비를 변경한다.
 * 변경 대상은 헤더의 colgroup의 col, tr의 td, 바디의 colgroup의 col이다.
 * @param nColumnIndex 변경 대상 컬럼의 인덱스
 * @param nWidth 변경할 너비 
 */
WebBoardAtom.prototype._changeColumnWidth = function (nColumnIndex, nWidth)
{
	var strHearderColumnName = WebBoardAtom.WEBBOARD_HEADER + this.m_strVarName + "_" + nColumnIndex;

	// 검색창 헤더의 컬럼 너비를 변경한다.
	document.getElementById(strHearderColumnName).style.width = nWidth + "px";

	var strBodyColumnName = WebBoardAtom.WEBBOARD_BODY_CONTENT + this.m_strVarName + "_" + nColumnIndex;
	var heBodyColumn = document.getElementById(strBodyColumnName)
	// 검색창 바디에 컬럼이 있다면 검색창 바디의 컬럼 너비를 변경한다.
	if (null != heBodyColumn)
	{
		heBodyColumn.style.width = nWidth + "px";
	}
}

/**
 * 인덱스에 해당하는 행을 반환합니다
 * @param nIndex
 * @return heRow
 */
WebBoardAtom.prototype._getRow = function (nIndex)
{
	if (this._isGridType())
	{
		var heRow = this.m_heContents.firstChild.firstChild.firstChild.firstChild;
		
		return heRow;
	}
	else
	{
		var strName = WebBoardAtom.WEBBOARD_BODY_CONTENT + this.m_strVarName;
	
		var heBody = document.getElementById(strName);
	
		if (0 > heBody.rows.length)
		{
			return;
		}
		
		return heBody.rows[nIndex];
	}
}

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

/**
 * 게시판 검색동작
 */
WebBoardAtom.prototype.browseStart = function (bInitPage)
{
	if (bInitPage)
	{
		this.m_objWebBoardAtomPager.m_nCurrentPage = 0;
	}
	
	var objLoadQuery = g_objQueryAtom.getBrowseQuery(this.m_nSQLIndex);
	if (null == objLoadQuery)
	{
		return;
	}
	
	var nDBIndex = objLoadQuery.getDBIndex();
	
	var strQuery = objLoadQuery.getQuery();
	strQuery = this._getPreProcessedQuery(strQuery, objLoadQuery);
	
	var strModuleKey = PQQuery.getModuleKey(nDBIndex);
	
	strQuery = this.m_objWebBoardAtomPager.searchEnablePageBoard(strQuery, nDBIndex, strModuleKey, this.m_objWebBoardAttrib.getVisibleRow());
	
	if (false == Utils.isEmpty(strQuery))
	{
		var objDataTable = g_objDataService.executeOpenX(strQuery, 12, this.m_nDBIndex, strModuleKey);
		
		objLoadQuery.initModify();
		
		this._handleDataTable(objDataTable, objLoadQuery);
		
		this.m_objWebBoardAtomPager.handleDataResult();
	}
}


WebBoardAtom.prototype._getPreProcessedQuery = function (strQueryStatement, objOuterQuery)
{
	var nDBIndex = objOuterQuery.getDBIndex();
	var strQuery = g_objPQQuery.convertQuery(strQueryStatement, nDBIndex);

	// 공통문법, 고유변수 치환
	strQuery = g_objQueryAtom.replaceSearchQuery(strQuery);

	return strQuery;
}

WebBoardAtom.prototype._handleDataTable = function (objDataTable, objSelectQuery)
{
	if (!this.isActivation() || null == objDataTable)
	{
		return;
	}
	
	if (false == this.m_bColumnPositionEqual)
	{
		this._changeColumnPosition(objDataTable);
	}
	
	var xnWebBoard = this.makeSimpleRequest();
	
	this._makeSearchDataResult(xnWebBoard, objDataTable);
	
	var xnRowAttr = XmlLib.createChild(xnWebBoard, "RowAttrib");
	XmlLib.setAttribute(xnRowAttr, "SeletedRow", "1");
	
	this.setValue(xnWebBoard);
}

/**
 * 쿼리 검색결과의 항목 순서와, 게시판에 설정된 항목의 순서가 틀릴 경우에는, 항목명을 비교해서 순서 맟춰야 한다.
 */
WebBoardAtom.prototype._checkColumnDataPosition = function ()
{
	if (null == this.m_strLinkedVariable || this.m_strLinkedVariable.length < 1)
	{
		this.m_bColumnPositionEqual = true;
		return;
	}
	
	// "#게시판.수주번호,#게시판.등록일,#게시판.거래처명" 형식임
	var arColName = this.m_strLinkedVariable.split(",")
	for (var i = 0; i < arColName.length; i++)
	{
		var strName = arColName[i];
		arColName[i] = strName.substring(strName.indexOf(".") + 1);
	}
	
	var bEqual = true;
	var nVariableCount = arColName.length;
	var arColIndex = new Array(nVariableCount);
	
	var nColInfoCount = this.m_arColumnInfoList.length;
	for (var i = 0; i < nColInfoCount; i++)
	{
		var strColName =  this.m_arColumnInfoList[i].getItemVarName();
		if (strColName != arColName[i])
		{
			bEqual = false;
			arColIndex[i] = -1;
			
			for (var j = 0; j < nVariableCount; j++)
			{
				if (strColName == arColName[j])
				{
					arColIndex[i] = j;
					break;
				}
			}
		}
		else
		{
			arColIndex[i] = i;
		}
	}
	
	this.m_arColIndex = arColIndex;
	this.m_bColumnPositionEqual = bEqual;
}

WebBoardAtom.prototype._changeColumnPosition = function (objDataTable)
{
	var arRows = objDataTable.getRows();
	var arNewRows = new Array();
	var nColInfoCount = this.m_arColumnInfoList.length;
	
	for (var i = 0; i < arRows.length; i++)
	{
		var arRowData = arRows[i];
		var arNewRowData = new Array(arRowData.length);
		
		for (var j = 0; j < nColInfoCount; j++)
		{
			arNewRowData[j] = arRowData[this.m_arColIndex[j]];
		}
		
		arNewRows.push(arNewRowData);
	}
	
	objDataTable.setRows(arNewRows);
}

/**
 * 검색결과를 xsl 처리 하기위한 형태로 xml 정보 설정한다.
 */
WebBoardAtom.prototype._makeSearchDataResult = function (xnWebBoard, objDataTable)
{
	var xnValue = XmlLib.createChild(xnWebBoard, "Value");
	
	var arSearchResult = objDataTable.getRowData()
	if (null == arSearchResult || 0 == arSearchResult.length)
	{
		return;
	}
	var nResultLen = arSearchResult.length;
	
	var strPrimary = this.m_objWebBoardAttrib.getPrimaryItem();
	var nPictureType = this.m_objPictureInfomation.getPictureType();
	var bShowSeparate = this.m_objWebBoardAttrib.isShowSeparate();
	var nVisibleRow = this.m_objWebBoardAttrib.getVisibleRow();
	
	var arReplyFilterIndexList = this.getReplyFilterColumnIndex();
	var nReplyContentIndex = this.getColumnIndexByVarName(this.m_objWebBoardAttrib.getReplyContent());

	for (var nRowIndex = 0; nRowIndex < arSearchResult.length; nRowIndex+=1)
	{
		var arResultRow = arSearchResult[nRowIndex];

		// m_nPictureType 0 은 일반 사진게시판 
		// m_nPictureType 1 은 그리드형 게시판
		if (false == Utils.isEmpty(strPrimary) && 1 == nPictureType)
		{
			// 그리드 게시판은 GridValue에 값을 넣는다.
			var xnGridValue = XmlLib.createChild(xnWebBoard, "GridValue");
			var xnImgInfo = XmlLib.createChild(xnGridValue, "ImgInfo");
			
			var strPictueItem = this.m_objPictureInfomation.getPictureItem();
			var strPictureText = this.m_objPictureInfomation.getPictureText();
			
			// 연결검색이나, 모델연결 동작시 각 컬럼의 값이 필요하다.
			var strRowValue = "";
			for (var nColIndex = 0; nColIndex < arResultRow.length; nColIndex+=1)
			{
				var strValue = arResultRow[nColIndex];
				strRowValue += strValue + "^";
				
				var strColumnVarName = this.m_arColumnInfoList[nColIndex].getItemVarName();
				
				if (strPrimary == strColumnVarName)
				{
					XmlLib.setAttribute(xnImgInfo, "id", 
							"__WEBBOARD_BODY_CONTENT_GRIDTYPE_ROW_" + this.m_strVarName + "_" + strValue);
				}

				// 노드의 TextValue로 이미지의 경로를 저장 한다 
				if (strPictueItem == strColumnVarName)
				{
					this.setResultForGridTypePicture(xnImgInfo, strValue);
				}

				// 지정 텍스트를 저장 한다
				if (strPictureText == strColumnVarName)
				{
					XmlLib.setAttribute(xnImgInfo, "ImgText", strValue);
				}
			}
			XmlLib.setAttribute(xnImgInfo, "RowValue", strRowValue);

			var xnRow = XmlLib.createChild(xnValue, "Row");
			this.insertRow(xnRow, arResultRow, nRowIndex);
		}
		else
		{
			var xnRow = XmlLib.createChild(xnValue, "Row");

			if (bShowSeparate && ((nRowIndex % 2) == 0))
			{
				XmlLib.setAttribute(xnRow, "ShowSeparate", "Y");
			}
			
			if (nRowIndex < nVisibleRow)	// 설정한 행 수만큼만 추가한다.
			{
				this.insertRow(xnRow, arResultRow, nRowIndex, arReplyFilterIndexList, nReplyContentIndex);
			}
		}
	}
}

WebBoardAtom.prototype.makeSimpleRequest = function ()
{
	var xnResultDoc = XmlLib.createXML("AtomResult");
	var xnResult = xnResultDoc.documentElement;
	var xnWebBoardAtom = XmlLib.createChild(xnResult, "WebBoard");
	
	xnWebBoardAtom.setAttribute("VarName", this.m_strVarName);
	xnWebBoardAtom.setAttribute("SQLIndex", this.m_nSQLIndex);
	
	// 게시판 속성정보
	this.m_objWebBoardAttrib.makeRequest(xnWebBoardAtom, this.m_objPictureInfomation);
	
	// 페이지 정보
	this.m_objWebBoardAtomPager.makeRequest(xnWebBoardAtom);
	
	// 사진 정보
	this.m_objPictureInfomation.makeRequest(xnWebBoardAtom);
	
	// 컬럼 정보
	this._makeColuumnAttrib(xnWebBoardAtom);
	
	XmlLib.setAttribute(xnWebBoardAtom, "IsDoSearch", "Y");
	
	return xnWebBoardAtom;
}

/**
 * 답글 필터 컬럼들의 인덱스를 수집하여 반환한다
 * @return
 */
WebBoardAtom.prototype.getReplyFilterColumnIndex = function ()
{
	var arFilterIndexLists = null;
	var strReplyFilter = this.m_objWebBoardAttrib.getReplyFilter();

	if (false == Utils.isEmpty(strReplyFilter))
	{
		var arFilters = strReplyFilter.split(",");

		arFilterIndexLists = new Array(arFilters.length);

		for (var i = 0, nLen = arFilters.length; i < nLen; i = i + 1)
		{
			var nColumnIndex = this.getColumnIndexByVarName(arFilters[i]);

			arFilterIndexLists[i] = nColumnIndex;
		}
	}

	return arFilterIndexLists;
}

/**
 * 답변의 단계 필드 정보리스트를 생성하여 반환한다
 */
WebBoardAtom.prototype.getReplyFieldList = function ()
{
	var arReplyFilterList = new Array();

	var strReplyFilter = this.m_objWebBoardAttrib.getReplyFilter();

	if (false == Utils.isEmpty(strReplyFilter))
	{
		var arFilters = strReplyFilter.split(",");

		for (var i = 0; i < arFilters.length; i++)
		{
			var strBrowseVar = arFilters[i];
			
			var strTableWithColumn = this.getFieldName(strBrowseVar);
			 
			arReplyFilterList.push(strTableWithColumn);
		}
	}

	return arReplyFilterList;
}

WebBoardAtom.prototype.getColumnIndexByVarName = function (strVarName)
{
	for (var i = 0; i < this.m_arColumnInfoList.length; i++)
	{
		if (strVarName == this.m_arColumnInfoList[i].getItemVarName())
		{
			return i;
		}
	}
	return -1;
}

WebBoardAtom.prototype.insertRow = function (xnRow, arRow, nRowIndex, arReplyFilterIndexList, nReplyContentIndex)
{
	var strPictureItem = this.m_objPictureInfomation.getPictureItem();
	var strPictureText = this.m_objPictureInfomation.getPictureText();
	
	var strValue = "&nbsp;";
	var arRowData = this.processRow(arRow);
	
	for (var i = 0, nColLen = arRowData.length; i < nColLen && i < this.m_arColumnInfoList.length; i++)
	{
		if (null != arRowData[i])
		{
			strValue = Utils.trim(arRowData[i]);
		}

		var xnColData = XmlLib.createChildWithValue(xnRow, "ColData", strValue);

		if (i == nReplyContentIndex && null != arReplyFilterIndexList)
		{
			var nIndent;
			if (1 == arReplyFilterIndexList.length)
			{
				nIndent = this.getReplyIndentEx(nRowIndex, arRowData, arReplyFilterIndexList[0]);
			}
			else
			{
				nIndent = this.getReplyIndent(nRowIndex, arRowData, arReplyFilterIndexList);
			}

			XmlLib.setAttribute(xnColData, "Indent", nIndent);
		}
		
		var objColumn = this.m_arColumnInfoList[i];
		XmlLib.setAttribute(xnColData, "Align", objColumn.getAlign());
		XmlLib.setAttribute(xnColData, "Visibility",  objColumn.getVisibility());
		
		this._setPictureResultInfo(xnColData, i, strValue, strPictureItem, strPictureText);
		
		//writeAttributeRowChecked(i, xnRow, strValue);
	}

	this._setColumnCondition(xnRow);
}

/**
 * 표현형식에 맞게 가공한다.
 */
WebBoardAtom.prototype.processRow = function (arDataRow) 
{
	var arResult = new Array(arDataRow.length);

	var objResult = null;
	var strValue = null;
	var nColCount = this.m_arColumnInfoList.length;

	for (var i = 0, n = arDataRow.length ; i < n ; i+=1)
	{
		var objColumn = null;

		if (i < nColCount)
		{
			objColumn = this.m_arColumnInfoList[i];
		}

		if (null == objColumn)
			continue;

		objResult = arDataRow[i];

		if (null != objResult) 
			strValue = objResult.toString();
		else
			strValue = "";
		
		var strDisplay = objColumn.getDisplay();
		strValue = this.processUserDisplay(strValue, strDisplay);

		var strFieldType = objColumn.getFieldType();
		if (strFieldType == "int" || strFieldType == "float" || strFieldType == "double")
		{
//			var period = objColumn.getPeriod();
//			strValue = processPeriodAndComma(strValue, period, true);
		}
		else
		{
			strValue = this.processDateType(strDisplay, strValue);
		}

		arResult[i] = strValue;
	}

	return arResult;
}

/**
 * 표현형식을 적용한다.
 */
WebBoardAtom.prototype.processUserDisplay = function (strValue, strDisplay)
{
	strValue = Utils.trim(strValue);
	
	if (Utils.isEmpty(strValue) || 0 > strDisplay.indexOf("$USER:"))
	{
		return strValue;
	}
	
	var result = strValue;
	strDisplay = strDisplay.substring(6);
	strDisplay = Utils.replaceAll(strDisplay, '=', '$');

	var userStmts = strDisplay.split(",");
	var stmt = "";
	for (var i = 0; i != userStmts.length; i+=1)
	{
		stmt = Utils.trim(userStmts[i]);
		var index = stmt.indexOf("$");
		if (0 < stmt.length && -1 < index)
		{
			if (strValue.toLowerCase() == stmt.substring(0, index).toLowerCase())
			{
				result = stmt.substring(index + 1);
				break;
			}
		}
	}
	
	return result;
}

/**
 * 날짜유형을 처리한다
 * @param strFormat $DATE:날짜유형
 * @param strValue 숫자로 이루어진 스트링
 * @return 변환된 값
 */
WebBoardAtom.prototype.processDateType = function (strFormat, strValue)
{
	if (Utils.isEmpty(strValue) || 0 > strFormat.indexOf("$DATE:"))
		return strValue;
	
	var arValue = new Array();
	arValue[0] = strValue.substring(0, 4);
	arValue[1] = strValue.substring(4, 6);
	arValue[2] = strValue.substring(6, 8);
	arValue[3] = strValue.substring(8, 10);
	arValue[4] = strValue.substring(10, 12);
	
	var result = strFormat.substring(6);
	result = Utils.replaceAll(result, "년", arValue[0]);
	result = Utils.replaceAll(result, "월", arValue[1]);
	result = Utils.replaceAll(result, "일", arValue[2]);
	result = Utils.replaceAll(result, "시", arValue[3]);
	result = Utils.replaceAll(result, "분", arValue[4]);

	result = Utils.replaceAll(result, "YYYY", arValue[0]);
	result = Utils.replaceAll(result, "YY", arValue[0].substring(2));
	result = Utils.replaceFirst(result, "MM", arValue[1]);
	result = Utils.replaceAll(result, "DD", arValue[2]);
	result = Utils.replaceAll(result, "HH", arValue[3]);
	result = Utils.replaceAll(result, "MM", arValue[4]);
	
	return result;
}

WebBoardAtom.prototype.getReplyIndentEx = function (nRow, arRow, nReplyFilterIndexList)
{
	var nOffset = 10;
	
	var strReply = Utils.trim(arRow[nReplyFilterIndexList]);
	
	return (strReply.length - 1) * nOffset; 
}

/**
 * 답글의 인덴트를 값을 반환한다
 * @param nRow
 * @param nColumn
 * @param arRow
 * @return
 */
WebBoardAtom.prototype.getReplyIndent = function (nRow, arRow, arReplyFilterIndexList)
{
	var nIndent = 0;
	var nOffset = 10;

	var nReplyItem = this.getColumnIndexByVarName(this.m_strReplyItem);

	if (0 < nReplyItem && 0 < arReplyFilterIndexList.length)
	{
		for (var i = 0; i < arReplyFilterIndexList.length; i++)
		{
			var nColumnIndex = arReplyFilterIndexList[i];
			
			if (nColumnIndex < arRow.length)
			{
				var strReplyItem = arRow[nColumnIndex];
				
				if (0 < strReplyItem.length)
				{
					nIndent += nOffset;
				}
				else
				{
					break;
				}
			}
		}
	}

	return nIndent;
}

/**
 * 그리드 형식의 사진계시판 결과를 설정한다
 */
WebBoardAtom.prototype.setResultForGridTypePicture = function (xnImgInfo, strValue)
{
	//'업로드된 파일명$원본 파일명' 형식으로 저장되어 있다
	var arFileNames = strValue.split("$");

	if (null != arFileNames)
	{
		if (2 <= arFileNames.length)
		{
			var strFilePath = "/ups/Download.do?ServiceName=WebPictureAtom&FileName=" + arFileNames[0];
			XmlLib.setTextValue(xnImgInfo, strFilePath);
			XmlLib.setAttribute(xnImgInfo, "OrgFileName", arFileNames[1]);
		}
		else if (1 == arFileNames.length)
		{
			XmlLib.setTextValue(xnImgInfo, arFileNames[0]);
		}
	}
}

WebBoardAtom.prototype._setPictureResultInfo = function (xnColData, nColumnIndex, strValue, strPictureItem, strPictureText)
{
	if (null == strPictureItem || Utils.isEmpty(strPictureItem))
	{
		return;
	}

	var strColVar = this.m_arColumnInfoList[nColumnIndex].getItemVarName();
	if (strColVar == strPictureItem)
	{
		// '업로드된 파일명$원본 파일명' 형식으로 저장되어 있다
		var arFileNames = strValue.split("$");

		if (null != arFileNames && 2 == arFileNames.length)
		{
			var strUploadFileName = arFileNames[0];
			var strOrgFileName = arFileNames[1];

			XmlLib.setAttribute(xnColData, "PicturePath", this._getImageFilePath(strUploadFileName));
			XmlLib.setAttribute(xnColData, "OrgFileName", strOrgFileName);
			XmlLib.setAttribute(xnColData, "PictureText", strPictureText);
		}
	}
}

WebBoardAtom.prototype._getImageFilePath = function (strFileName)
{
	// 사진게시 아톰의 이미지는 서블릿을 이용해서 표시한다.
	return "/ups/Download.do?ServiceName=WebPictureAtom&FileName=" + strFileName;
}


/***
 * 행의 컬럼 마다 조건식을 검사하고, 그에 해당하는 조건 속성을 설정한다
 * @param xnRow 조건을 적용할 행
 * @param arRowData
 */
WebBoardAtom.prototype._setColumnCondition = function (xnRow)
{
	if (null == this.m_alCondIconInfoList || 0 == this.m_alCondIconInfoList.length)
	{
		return;
	}

	var xlColDataList = xnRow.childNodes;

	for (var i = 0, nLen = this.m_alCondIconInfoList.length; i < nLen; i++)
	{
		var objIconInfomation = this.m_alCondIconInfoList[i];
		var strBrowseVarName = objIconInfomation.m_strBrowseVarName;
		
		var nColumnIndex = this.getColumnIndexByVarName(strBrowseVarName);
		var xnColData = xlColDataList[nColumnIndex];

		var eIconType = objIconInfomation.m_eAlignType;

		if (null != xnColData && null != eIconType)
		{
			var xnIcon = XmlLib.createChild(xnColData, eIconType);

			var strResult = this._getConditionImgPath(xnRow, xnColData, objIconInfomation);
			if ("" == strResult)
				continue;

			// 조건식에 의한 이미지경로 정보가 있을 때만 XML에 추가
			XmlLib.setAttribute(xnIcon, "IconPath", strResult);
		}
	}
}

WebBoardAtom.prototype._getConditionImgPath = function (xnRowNode, xnColData, objIconInfomation) 
{
	var strResult = "";

	var alConditionToken = objIconInfomation.m_alTokens;
	var strLeftOperand = alConditionToken[0];
	var strOperator = alConditionToken[1];
	var strRightOperand = alConditionToken[2];

	var bNum = false;

	if (this._isNumericColumn(strLeftOperand) || this._isNumericColumn(strRightOperand))
	{
		bNum = true;

		strLeftOperand = this._replaceOperandByValue(strLeftOperand, xnRowNode);
		strRightOperand = this._replaceOperandByValue(strRightOperand, xnRowNode);

		strLeftOperand = strLeftOperand.replace(",", "");
		strRightOperand = strRightOperand.replace(",", "");
	}
	else
	{
		strLeftOperand = this._replaceOperandByValue(strLeftOperand, xnRowNode);
		strRightOperand = this._replaceOperandByValue(strRightOperand, xnRowNode);
	}

	if (this._compareCondition(strLeftOperand, strOperator, strRightOperand, bNum))
	{
		strResult = objIconInfomation.m_strImgPath;

		if ("BodyIcon" == objIconInfomation.m_eAlignType)
		{
			XmlLib.setAttribute(xnColData, "BodyIcon", "Y");
		}
	} 

	return strResult;
}

WebBoardAtom.prototype._isNumericColumn = function (columnName) 
{
	var bResult = false;
	var nIndex = this.getColumnIndexByVarName(columnName);
	
	if (-1 < nIndex)
	{
		var strColType = this.m_arColumnInfoList[nIndex].getFieldType()
		
		if (strColType == "int" || strColType == "float" || strColType == "double")
		{
			bResult = true;
		}
	}
	
	return bResult;
}

/**
 * 검색창에서 피연사자에 해당하는 컬럼의 값을 가져온다.
 */
WebBoardAtom.prototype._replaceOperandByValue = function (strOperand, xnRowNode) 
{
	var strResult = "";
	
	var nIndex = this.getColumnIndexByVarName(strOperand);

	if (-1 < nIndex)
	{
		var xnData = xnRowNode.childNodes[nIndex];
		
		var strValue = XmlLib.getTextValue(xnData);
		if (null != strValue)
		{
			strResult = Utils.trim(strValue);
		}
		else
		{
			strResult = "";
		}

		// 사용자정의 표현형식일 경우
		var strColDisplay = this.m_arColumnInfoList[nIndex].getDisplay();
		if (null != strColDisplay && 0 < strColDisplay.length)
		{
			//strResult = processUserDisplay(strResult, strColDisplay);
		}
	}
	else
	{
		strResult = strOperand;
	}

	return strResult;
}

/**
 * 조건식 연산.
 */  
WebBoardAtom.prototype._compareCondition = function (strLeftOperand, strOperator, strRightOperand, bNum)
{
	strRightOperand = Utils.replaceAll(strRightOperand, "'", "");
	var bResult = false;

	if (bNum)
	{
		var dLeft = 0;
		var dRight = 0;

		try
		{
			dLeft = parseFloat(strLeftOperand);
			dRight = parseFloat(strRightOperand);
		}
		catch(e)
		{
		}

		if (strOperator == "<")
		{
			if (dLeft < dRight)
				bResult = true;
		}
		else if (strOperator == "<=" || strOperator == "=<")
		{
			if (dLeft <= dRight)
				bResult = true;
		}
		else if (strOperator == ">")
		{
			if (dLeft > dRight)   
				bResult = true;
		}
		else if (strOperator == ">=" || strOperator == "=>")
		{
			if (dLeft >= dRight)  
				bResult = true;
		}
		else if (strOperator == "!=" || strOperator == "<>")
		{
			if (dLeft != dRight)  
				bResult = true;
		}
		else if (strOperator == "=")
		{
			if (dLeft == dRight)  
				bResult = true;
		}
	}
	else
	{
		if (strOperator == "<")
		{
			if (strLeftOperand < strRightOperand)
				bResult = true;
		}
		else if (strOperator == "<=" || strOperator == "=<")
		{
			if (strLeftOperand <= strRightOperand)
				bResult = true;
		}
		else if (strOperator == ">")
		{
			if (strLeftOperand > strRightOperand)
				bResult = true;
		}
		else if (strOperator == ">=" || strOperator == "=>")
		{
			if (strLeftOperand >= strRightOperand)
				bResult = true;
		}
		else if (strOperator == "!=" || strOperator == "<>")
		{
			if (strLeftOperand != strRightOperand)
				bResult = true;
		}
		else if (strOperator == "=")
		{
			if (strLeftOperand == strRightOperand)
				bResult = true;
		}
	}

	return bResult;
}


WebBoardAtom.prototype.getProperty = function (nNameID, arArgs, objRetVal)
{
	switch (nNameID)
	{
		case 0 : case 203 : return this.get_Value (arArgs, objRetVal);
		case 2 : case 369 : return this.get_BrowseProperty (369, arArgs, objRetVal);
		case 3 : case 370 : return this.get_BrowseProperty (370, arArgs, objRetVal);	
		case 15 :case 355 : return this.get_ItemProperty (355, arArgs, objRetVal);
		case 16 :case 356 : return this.get_ItemProperty (356, arArgs, objRetVal);
		case 17 :case 357 : return this.get_ItemProperty (357, arArgs, objRetVal);
		case 35 :case 302 : return this.get_RefProperty (302, arArgs, objRetVal);
		case 36 :case 303 : return this.get_RefProperty (303, arArgs, objRetVal);
		case 37 :case 304 : return this.get_RefProperty (304, arArgs, objRetVal);
		case 58 :case 202 : return this.get_BrowseProperty (202, pvaArgs, pRetVal);
		default : return StdCore.E_NOT_DEF_PROPERTY;		
	}
}

WebBoardAtom.prototype.setProperty = function (nNameID, arArgs, objRetVal) 
{
	switch (nNameID)
	{
		case 2 : case 369 : return this.set_BrowseProperty (369, arArgs, objRetVal);
		case 3 : case 370 : return this.set_BrowseProperty (370, arArgs, objRetVal);
		case 15 :case 355 : return this.set_ItemProperty (355, arArgs, objRetVal);
		case 16 :case 356 : return this.set_ItemProperty (356, arArgs, objRetVal);
		case 17 :case 357 : return this.set_ItemProperty (357, arArgs, objRetVal);
		case 36 :case 303 : return this.set_RefProperty (303, arArgs, objRetVal);
		case 37 :case 304 : return this.set_RefProperty (304, arArgs, objRetVal);
		default : return StdCore.E_NOT_DEF_PROPERTY;
	}
}
WebBoardAtom.prototype.action = function (wPropID, pvaArgs, pRetVal)
{
	switch (wPropID)
	{	
		case 42:case 371: return this.raw_Search (371, pvaArgs, pRetVal);
		case 43:case 372: return this.raw_Search (372, pvaArgs, pRetVal);
		case 44:case 373: return this.raw_SelectAction (373, pvaArgs, pRetVal);
		case 45:case 374: return this.raw_SelectAction (374, pvaArgs, pRetVal);
		case 52:case 273: case 64: case 218: return this.raw_Action (273, pvaArgs, pRetVal); 
		case 68:case 237: 
		{
			pRetVal.setValue (0);
			
			this.goPrevPage (); // 이전으로
			
			return StdCore.S_OK;
		} 
		case 67:case 238:
		{
			pRetVal.setValue (0);
			
			this.goNextPage ();	// 다음으로
			
			return StdCore.S_OK;
		}
		default : return this.getProperty (wPropID, pvaArgs, pRetVal);
	}
}

WebBoardAtom.prototype.get_ItemProperty = function (nNameID, arArgs, objRetVal)
{
	objRetVal.setValueType(CVariantX._vtString, "");

	// 인덱스가 없는 속성...(기본조건, 그룹필드, 정렬필드)
	switch (nNameID)
	{
	case 355 : // 기본조건
		objRetVal.setValueType(CVariantX._vtString, this.getAtomQueryAttribute("WHERE"));
		break; 
	case 356 :// 그룹필드
		objRetVal.setValueType(CVariantX._vtString, this.getAtomQueryAttribute("GROUPBY"));
		break; 
	case 357 : // 정렬필드
		objRetVal.setValueType(CVariantX._vtString, this.getAtomQueryAttribute("ORDERBY"));
		break; 
	default  : 
		return StdCore.E_NOT_DEF_PROPERTY;
	}

	return StdCore.S_OK;
}

WebBoardAtom.prototype.set_ItemProperty = function (nNameID, arArgs, objValue)
{
	switch (nNameID)
	{
		case 355 : // 기본조건
		{
			var strWhere = this.modifyDefaultCond(objValue.toStringX());
			this.setAtomQueryAttribute("WHERE", strWhere);
		}	break; 
		case 356 : // 그룹필드 
		{
			var strTable = this.getAtomQueryAttribute("TABLE");
			var strGroupBy = this.modifyTableAlias(objValue.toStringX(), strTable);
			this.setAtomQueryAttribute("GROUPBY", strGroupBy);
		}	break;
		case 357 : // 정렬필드 
		{
			var strTable = this.getAtomQueryAttribute("TABLE");
			var strOrderBy = this.modifyTableAlias(objValue.toStringX(), strTable);
			this.setAtomQueryAttribute("ORDERBY", strOrderBy);
		}	break;
		default : 
			return StdCore.E_NOT_DEF_PROPERTY;
	}

	return StdCore.S_OK;
}

WebBoardAtom.prototype.getAtomQueryAttribute = function (strAtomQueryKind)
{
	var strQueryStatement = "";
	var objAtomQuery = g_objPQQuery.getOuterQueryByIndex(this.m_nSQLIndex);
	
	if (null != objOuterQuery)
	{
		switch (strAtomQueryKnd)
		{
			case "FIELD":
				strQueryStatement = objAtomQuery.getField();
			break;
			case "GROUPBY":
				strQueryStatement = objAtomQuery.getGroupBy();
				break;
			case "HAVING":
				strQueryStatement = objAtomQuery.getHaving();
				break;
			case "ORDERBY":
				strQueryStatement = objAtomQuery.getOrderBy();
				break;
			case "TABLE":
				strQueryStatement = objAtomQuery.getTable();
				break;
			case "WHERE" :
				strQueryStatement = objAtomQuery.getWhere();
				break;
			case "DBINDEX":
				strQueryStatement = objAtomQuery.getDBIndex() + "";
				break;
			case "DEFINED":
				strQueryStatement = objAtomQuery.getWholeQuery();
				break;
			default:
		}
	}
	
	return strQueryStatement;
}

WebBoardAtom.prototype.setAtomQueryAttribute = function (strAtomQueryKind, strQueryStatement)
{
	var objAtomQuery = g_objPQQuery.getOuterQueryByIndex(this.m_nSQLIndex);
	
	if (null != strAtomQueryKind)
	{
		switch (strAtomQueryKind)
		{
		case "FIELD":
			objAtomQuery.setField(strQueryStatement);
			break;
		case "GROUPBY":
			objAtomQuery.setGroupBy(strQueryStatement);
			break;
		case "HAVING":
			objAtomQuery.setHaving(strQueryStatement);
			break;
		case "ORDERBY":
			objAtomQuery.setOrderBy(strQueryStatement);
			break;
		case "TABLE":
			objAtomQuery.setTable(strQueryStatement);
			break;
		case "WHERE":
			objAtomQuery.setScriptWhere(strQueryStatement);
			break;
		case "DBINDEX":
			objAtomQuery.setDBIndex(strQueryStatement);
			break;
		case "DEFINED":
			objAtomQuery.setTable(strQueryStatement);
			break;
		default:
		}
	}
}

WebBoardAtom.prototype.modifyDefaultCond = function (strCond)
{
	var sDefaultCond = strCond;
	var strTemp = strCond.toUpperCase();

	if (-1 < strTemp.indexOf("$LEFT") || -1 < strTemp.indexOf("$ LEFT") ||
			-1 < strTemp.indexOf("$[J_") || -1 < strTemp.indexOf("$ [J_") ) 
	{
		var nRoot = sDefaultCond.indexOf ("#ROOT:");
		if (-1 < nRoot)
			sDefaultCond = sDefaultCond.substring (0, nRoot);
	}

	return sDefaultCond;
}

WebBoardAtom.prototype.modifyTableAlias = function (strSQLStatement, strTable)
{
	var strSQL = strSQLStatement;
	var arTables = strTable.split(",");

	if (0 < strTables.length)
	{
		try
		{
			var hmTables = new Hashtable();
			var nMapCount = 0;
			var nTableLength = strTables.length;
			var strTab = "", strOwner = "", strAlias = "";

			for (var i = 0 ; i < nTableLength ; i++)
			{
				strTab = Utils.trim(arTables[i]);

				var nBlankIndex = strTab.indexOf(" ");

				if (-1 < nBlankIndex)
				{
					strOwner = Utils.trim(strTab.substring(0, nBlankIndex));
					strAlias = Utils.trim(strTab.substring(strTab.indexOf(" ")));
					strOwner = strOwner.substring(strOwner.lastIndexOf(".") + 1);

					hmTables[strOwner] = strAlias;
					nMapCount += 1;
				}
			}

			strSQL = g_objQueryLib.tableAliasingByKeyword (strSQL, hmTables, nMapCount);
			strSQL = g_objQueryLib.tableAliasingByMap     (strSQL, hmTables, nMapCount);
		}
		catch (e)
		{
			strSQL = "";
		}
	}

	return strSQL;
}

WebBoardAtom.prototype.get_BrowseProperty = function (wNameID, pvaArgs, pRetVal)
{
	pRetVal.setValueType(CVariantX._vtInt, 0);

	switch (wNameID)
	{
	case 202: //크기, 행수
		if (null != this.m_heContents)
		{
			pRetVal.setValueType(CVariantX._vtInt, this.m_heContents.rows.length);
		}
		break;
	case 369 : // 체크
	case 370 : // 선택	
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		var nRowID = pvaArgs[1].toInt();
		nRowID = this.getRealIndex(nRowID);
		
		if (-1 < nRowID)
		{
			var nResult = 0;
			if (369 == wNameID) // 체크
			{
				
				arValue = this.getCheckedRowArray(0);
				
				for (var i = 0, nLen = arValue.length; i != nLen; i+=1)
				{
					var nReturn = arValue[i];
					nReturn = this.getRealReturnIndex(nReturn);
					
					if (nReturn == nRowID)
					{
						nResult = 1;
						break;
					}
				}
			}
			else		//선택
			{
			}
			pRetVal.setValueType(CVariantX._vtInt, nResult);
		}
		else
		{
			// 행번호가 -1인 경우에는 전체 행에 대한 체크 여부를 배열로 반환해 준다.
			var arValue = this.getCheckedRowArray(nBaseRow);
			
			pRetVal.makeVarArray();
			var objArray = pRetVal.toArray();
			
			for (var i = 0, nLen = arValue.length; i != nLen; i+=1)
			{
				var nReturn = arValue[i];
				nReturn = this.getRealReturnIndex(nReturn);
				objArray.setAtGrow(i, new CVariantX(CVariantX._vtInt, nReturn));
			}
		}
		break;
	default : 
		return StdCore.E_NOT_DEF_PROPERTY;
	}
	return StdCore.S_OK;
}

WebBoardAtom.prototype.set_BrowseProperty = function (nNameID, arArgs, objValue)
{
	switch (nNameID)
	{
	default : 
		return StdCore.E_NOT_DEF_PROPERTY;
	}
	return StdCore.S_OK;
}
	

WebBoardAtom.prototype.raw_Search = function (wNameID, pvaArgs, pRetVal)
{
	switch (wNameID)
	{
		case 371 : // 검색준비
			this.m_bSearchStart = true;
			
			// 검색창에서는 검색준비와 검색시작 사이에 검색된 데이터를 가공할수 있게 하지만
			// 게시판에서는 의미가 없으므로, 검색준비에서 db i/o를 하지 않고, 검색 시작에서 쿼리 수행 하도록 수정함
			break;
		case 372: // 검색시작
			if (this.m_bSearchStart)
			{
				this.m_bSearchStart = false;
				this.browseStart(false);
			}
			break;
		default : 
			return StdCore.E_NOT_DEF_PROPERTY;
	}
	return StdCore.S_OK;
}

WebBoardAtom.prototype.raw_SelectAction = function (wNameID, pvaArgs, pRetVal)
{
	pRetVal.setValueType(CVariantX._vtInt, 0);

	switch (wNameID)
	{
	case 373 : // 선택행수 : 검색된 데이터에서 선택된(체크된) 모든 행의 수를 받아온다.
		var nArgCnt = (null != pvaArgs) ? pvaArgs[0].toInt() : 0;

		// #선택(1160), #체크(1161)
		var nChecked = ( 0 < nArgCnt ) ? pvaArgs[1].toInt() : 1160; 

		if (1161 == nChecked) // #체크행
		{
			for(var i = 0, chkLen = this.m_arCheckedRowList.length; i < chkLen ; i++)
			{
				
			}
			
			pRetVal.setValueType(CVariantX._vtInt, this.m_arCheckedRowList.length);
		}
		else
		{
			var nCount = (0 < this.m_nSelectedIndex) ? 1 : 0
			pRetVal.setValueType(CVariantX._vtInt, nCount);
		}
		break;
	case 374 : // 선택행 : 검색된 데이터에서 선택된(체크된) 모든 행의 번호를 배열로 받아온다.
		this.executeSelectedRow(pvaArgs, pRetVal);
		break;
	default : 
		return StdCore.E_NOT_DEF_PROPERTY;
	}

	return StdCore.S_OK;
}

WebBoardAtom.prototype.raw_Action = function (wNameID, pvaArgs, pRetVal)
{
	pRetVal.setValue (0);
	
	switch (wNameID)
	{
		case 273 : // 모두지우기
			this.executeClearAll();
		break;
		default : 
			return StdCore.E_NOT_DEF_PROPERTY;
	}
	
	return StdCore.S_OK;
}

WebBoardAtom.prototype.goPrevPage = function ()
{
	//최초검색시나 현재 페이지 숫자가 1일경우 이전으로를 실행하지 않음
	if((0 != this.m_objWebBoardAtomPager.m_nCurrentPage) && (1 != this.m_objWebBoardAtomPager.m_nCurrentPage))
	{
		this.m_objWebBoardAtomPager.m_nCurrentPage -= 1;
		this.browseStart();
	}
}

WebBoardAtom.prototype.goNextPage = function ()
{
	//최초검색시 다음페이지 숫자는 시작 페이지 + 1
	if(0 == this.m_objWebBoardAtomPager.m_nCurrentPage)
	{
		this.m_objWebBoardAtomPager.m_nCurrentPage = this.m_objWebBoardAtomPager.m_nStartPage + 1;
	}
	//페이지번호가 마지막번호일경우 다음페이지 숫자는 첫페이지  
	else if(this.m_objWebBoardAtomPager.m_nCurrentPage == this.m_objWebBoardAtomPager.m_nTotalPageCount)
	{
		this.m_objWebBoardAtomPager.m_nCurrentPage = 1;
	}
	else
	{
		this.m_objWebBoardAtomPager.m_nCurrentPage += 1;
	}
	this.browseStart();
}

WebBoardAtom.prototype.executeClearAll = function ()
{
	//게시판이 페이지목차 속성을 가지고 있을때만 실행
	//페이지목차를 초기화
	if(this.m_objWebBoardAtomPager.m_bShowPager)
	{
		this.m_objWebBoardAtomPager.m_nCurrentPage = 1;
		this.m_objWebBoardAtomPager.m_nStartPage = 1;
		this.m_objWebBoardAtomPager._refreshPageIndex();
	}
	
	//게시판 내용을 초기화
	this.m_heBody.innerText = "";
}

WebBoardAtom.prototype.executeSelectedRow = function (pvaArgs, pRetVal)
{
	var nArgCnt = (null != pvaArgs) ? pvaArgs[0].toInt() : 0;
	var nChecked = ( 0 < nArgCnt ) ? pvaArgs[1].toInt() : 1160; // #선택(1160), #체크(1161)
	var nBaseRow = (1 < nArgCnt) ? pvaArgs[2].toInt() : 0; // 기준행
	nBaseRow = this.getRealIndex(nBaseRow);

	// 일반 선택만 합니다.
	if (1160 == nChecked )
	{
		var nReturn = this.getRealReturnIndex(this.m_nSelectedIndex);
		pRetVal.setValueType(CVariantX._vtInt, nReturn);
	}
	else if (1161 == nChecked || 1162 == nChecked) // #체크 , #다중선택.
	{
		var arValue = null;
		if (1161 == nChecked)
		{
			arValue = this.getCheckedRowArray(nBaseRow);
		}
		else if (1162 == nChecked)
		{
			arValue = this.getMultiSelectRowArray(nBaseRow);
		}

		pRetVal.makeVarArray();
		var objArray = pRetVal.toArray();
		
		for (var i = 0, nLen = arValue.length; i != nLen; i+=1)
		{
			var nReturn = arValue[i];
			nReturn = this.getRealReturnIndex(nReturn);
			objArray.setAtGrow(i, new CVariantX(CVariantX._vtInt, nReturn));
		}
	}

	return StdCore.S_OK;
}

WebBoardAtom.prototype.getCheckedRowArray = function (nBaseRow)
{
	var arResult = new Array();
	
	if (null != this.m_arCheckedRowList && 0 < this.m_arCheckedRowList.length)
	{
		for(var i = 0, chkLen = this.m_arCheckedRowList.length; i < chkLen ; i++)
		{
			heCheck = this.m_arCheckedRowList[i];
			
			var nIndex = Utils.parseInt(heCheck.index);
			if (heCheck.checked && 0 <= nIndex && nBaseRow < nIndex)
			{
				arResult.push(nIndex);
			}
		}
		
		arResult.sort(function (A, B) { return A - B });	
	}
	
	return arResult;
}

WebBoardAtom.prototype.getMultiSelectRowArray = function (nBaseRow)
{
	var arResult = new Array();
	
	if (-1 < this.m_nSelectedIndex)
	{
		arResult.push(this.m_nSelectedIndex);
	}
	
	return arResult;
}

/**
 * @return 1베이스일 때 1 더하고 리턴
 */
WebBoardAtom.prototype.getRealReturnIndex = function (nIndex)
{
	if (g_objDoc.isEBLSource() && 0 <= nIndex)
	{
		nIndex += 1;
	}

	return nIndex;
}

WebBoardAtom.prototype.makeDataTable = function ()
{
	var arColName = new Array ();
	var arColType = new Array ();
	
	for (var i = 0; i < this.m_arColumnInfoList.length; i++)
	{
		arColName.push(this.m_arColumnInfoList[i].getFieldName());
		arColType.push(this.m_arColumnInfoList[i].getFieldType());
	}
	
	return new DataTable("", null, arColName, arColType);
}

/**
 * 검색창.값 스크립트 구현 
 * 
 * 검색창.값(모든값) 
 * 검색창.값[행](해당행의 값) 
 * 검색창.값[행,열](해당[행,열]의 값)
 * @param pvaArgs
 * @param pRetVal
 * @return 스크립트 수행결과 코드
 * @throws PQScriptException
 */
WebBoardAtom.prototype.get_Value = function (pvaArgs, pRetVal)
{
	pRetVal.setValueType(CVariantX._vtString, "");

	var nArgCnt = (null != pvaArgs) ? pvaArgs[0].toInt() : 0;
	var nRow = -1;
	var nCol = -1;

	if (nArgCnt == 1 && pvaArgs[1].getType() == CVariantX._vtInt)
	{
		//행번호만
		nRow = this.getRealIndex(pvaArgs[1].toInt());
		nCol = -1;
	}
	else if (nArgCnt == 2)
	{
		if (pvaArgs[1].getType() == CVariantX._vtInt && pvaArgs[2].getType() == CVariantX._vtInt)
		{ //행번호, 열번호
			nRow = this.getRealIndex(pvaArgs[1].toInt());
			nCol = this.getRealIndex(pvaArgs[2].toInt());
		}
		else if (pvaArgs[1].getType() == CVariantX._vtString && pvaArgs[2].getType() == CVariantX._vtInt)
		{  //열이름, 행번호
			nRow = this.getRealIndex(pvaArgs[2].toInt());
			nCol = this.getColumnIndexByVarName(pvaArgs[1].toStringX()); 
		}
		else if (pvaArgs[1].getType() == CVariantX._vtInt && pvaArgs[2].getType() == CVariantX._vtString)
		{ //행번호, 열이름
			nRow = this.getRealIndex(pvaArgs[1].toInt());
			nCol = this.getColumnIndexByVarName(pvaArgs[2].toStringX()); 
		}
	}

	if (-1 == nRow && -1 == nCol) // 모든 값
	{
	}
	else if (-1 < nRow && -1 == nCol) // 주어진 행의 값
	{
		var objTable = this.makeDataTable();
		
		objTable.setRows(this.m_arValues);

		var objRowServer = new CDataRowServer (objTable, nRow)
		
		pRetVal.setValueType(CVariantX._vtExeServer, objRowServer);
	}
	else if (-1 == nRow && -1 < nCol) // 주어진 열의 값
	{
//		CStringArray saColData = m_objDataSet.getColumnData(nCol);
//		pRetVal.setValue(saColData);
	}
	else if (-1 < nRow && -1 < nCol) // 주어진 행과 열의 값
	{
		var objData = this.getCellVaraint(nRow, nCol);

		if (null != objData)
		{
			pRetVal.setValue(objData);
		}
	}

	return StdCore.S_OK;
}

WebBoardAtom.prototype.getCellVaraint = function (nRow, nCol)
{
	var objCellValue = null;
	
	if (null == this.m_arValues || this.m_arValues.length < nRow || this.m_arColumnInfoList.length <= nCol)
	{
		return null;
	}
	
	var strValue = this.m_arValues[nRow][nCol];
	
	var strType = this.m_arColumnInfoList[nCol].getFieldType();
	if ("int" == strType)
	{
		var nValue = Utils.parseInt(strValue);
		objCellValue = new CVariantX(CVariantX._vtInt, nValue);
	}
	else if ("float" == strType || "double" == strType)
	{
		var dValue = parseFloat(strValue);
		objCellValue = new CVariantX(CVariantX._vtReal, dValue);
	}
	else if("string" == strType)
	{
		// 사용자정의 표현형식일 경우, 스크립트 엔진에서 변수 값을, 화면에 보이는 값을 사용함
		var strColDisplay = this.m_arColumnInfoList[nCol].getDisplay();
		if (null != strColDisplay && 0 < strColDisplay.length)
		{
			//strValue = ExpressionFormatter.userDisplay(strColDisplay, strValue);
		}
		
		objCellValue = new CVariantX(CVariantX._vtString, strValue);
	}
	else
	{
		objCellValue = new CVariantX(CVariantX._vtString, strValue);
	}
	
	return objCellValue; 
}

WebBoardAtom.WEBBOARD_HEADER = "__WEBBOARD_HEADER_";
WebBoardAtom.WEBBOARD_BODY_CONTENT = "__WEBBOARD_BODY_CONTENT_";

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

WebBoardAtom.init = function ()
{
	for (var strVarName in WebBoardAtom._atoms)
	{
		var objAtom = WebBoardAtom._atoms[strVarName];
		
		if (null != objAtom)
		{
			objAtom.init();
		}
	}
}

WebBoardAtom.getAtom = function (strVarName)
{
	return WebBoardAtom._atoms[strVarName];
}

WebBoardAtom.makeRequest = function (xnAtomRequest)
{
	for (var strVarName in WebBoardAtom._atoms)
	{
		var objAtom = WebBoardAtom._atoms[strVarName];
		
		if (null != objAtom)
		{
			objAtom.makeRequest(xnAtomRequest);
		}
	}
}

WebBoardAtom.makeDirectExecRequest = function (xnAtomRequest)
{
	for (var strVarName in WebBoardAtom._atoms)
	{
		var objAtom = WebBoardAtom._atoms[strVarName];
		
		if (objAtom.isActivation())
		{
			if (objAtom.isDirectExec())
			{			
				objAtom.makeRequest(xnAtomRequest);
			}
		}
	}
}

WebBoardAtom.getFirstAtom = function ()
{
	var objAtom = null;
	
	for (var strVarName in WebBoardAtom._atoms)
	{
		objAtom = WebBoardAtom._atoms[strVarName];
		
		if (null != objAtom)
		{
			break;
		}
	}
	
	return objAtom;
}

WebBoardAtom.onMouseMoveBrowseHeader = function (strVarName, objEvent)
{
	objEvent = HTMLLib.getEvent(objEvent);
	
	var objAtom = WebBoardAtom._atoms[strVarName];
	if (null != objAtom)
	{
		objAtom.onMouseMoveBrowseHeader(objEvent);
	}
}

WebBoardAtom.onMouseUpBrowseHeader = function (strVarName, objEvent)
{
	objEvent = HTMLLib.getEvent(objEvent);
	
	var objAtom = WebBoardAtom._atoms[strVarName];
	if (null != objAtom)
	{
		objAtom.onMouseUpBrowseHeader(objEvent);
	}
}

WebBoardAtom.onClickBrowseHeader = function (strVarName, nColumnIndex)
{
	var objOpenFormula = g_htSearchFormulaList[strVarName];

	// 검색식 객체가 있고, 닫혀있지 않으면...
	if (null != objOpenFormula && !objOpenFormula.closed)
	{
		objOpenFormula.SearchFormulaHandler.onClickBrowseColumn(nColumnIndex);
	}
	else
	{
		var objAtom = WebBoardAtom._atoms[strVarName];
		
		if (null != objAtom)
		{
			objAtom.onClickBrowseHeader(nColumnIndex);
		}
	}
}

WebBoardAtom.onMouseUpBrowseHeaderColumn = function (strVarName, heColumn)
{
	var objAtom = WebBoardAtom._atoms[strVarName];
	
	if (null != objAtom)
	{
		objAtom.onMouseUpBrowseHeaderColumn(heColumn);
	}
}

WebBoardAtom.onMouseDownBrowseHeaderColumn = function (strVarName, heColumn)
{
	var objAtom = WebBoardAtom._atoms[strVarName];
	
	if (null != objAtom)
	{
		objAtom.onMouseDownBrowseHeaderColumn(heColumn);
	}
}

WebBoardAtom.onMouseOverBrowseResizer = function (srtVarName)
{
	var objAtom = WebBoardAtom._atoms[srtVarName];
		
	if (null != objAtom)
	{
		objAtom.onMouseOverBrowseResizer();
	}
}

WebBoardAtom.onMouseOutBrowseResizer = function (srtVarName)
{
	var objAtom = WebBoardAtom._atoms[srtVarName];
		
	if (null != objAtom)
	{
		objAtom.onMouseOutBrowseResizer();
	}
}

WebBoardAtom.onMouseDownBrowseResizer = function (strVarName, nColumnIndex, objEvent)
{
	objEvent = HTMLLib.getEvent(objEvent);
	
	var objAtom = WebBoardAtom._atoms[strVarName];
	
	if (null != objAtom)
	{
		objAtom.onMouseDownBrowseResizer(nColumnIndex, objEvent);
	}
}

WebBoardAtom.onScroll = function (strVarName)
{
}

WebBoardAtom.onMouseDown = function (strVarName, nRowIndex, nColIndex, objEvent)
{
	var objAtom = WebBoardAtom._atoms[strVarName];
	
	if (objAtom)
	{
		var heRow = document.getElementById("_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex);
		var heCell = document.getElementById("_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex + "_Cell_" + nColIndex); 
		objAtom.onMouseDown(heRow, objEvent, heCell);
	}
}

WebBoardAtom.onMouseUp = function ()
{
	for (var strVarName in WebBoardAtom._atoms)
	{
		WebBoardAtom._atoms[strVarName].onMouseUp();
	}
}

WebBoardAtom.onClick = function (strVarName, nRowIndex, nColIndex, objEvent)
{
	var objAtom = WebBoardAtom._atoms[strVarName];
	
	if (objAtom)
	{
		var heRow = document.getElementById("_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex);
		var heCell = document.getElementById("_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex + "_Cell_" + nColIndex);
		objAtom.onClick(heRow, objEvent, heCell);
	}
}

WebBoardAtom.onmouseover = function(strVarName, nRowIndex, nColIndex, objEvent)
{
	
	var objAtom = WebBoardAtom._atoms[strVarName];
	if (objAtom)
	{
		var heRow = document.getElementById("_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex);
		
		objAtom.onmouseover(heRow, objEvent,  nColIndex);
	}
}

WebBoardAtom.onmouseout =  function (strVarName, nRowIndex, nColIndex, objEvent)
{
	var objAtom = WebBoardAtom._atoms[strVarName];
	
	if (objAtom)
	{
		var heRow = document.getElementById("_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex);
	
		objAtom.onmouseout(heRow, objEvent);
	}
}

WebBoardAtom.onDblClickBody = function (strVarName, nRowIndex, nColIndex, objEvent)
{
	var objAtom = WebBoardAtom._atoms[strVarName];
	
	if (objAtom)
	{
		var heRow = document.getElementById("_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex);
		var heCell = document.getElementById("_WebBoardAtom_" + strVarName + "_Row_" + nRowIndex + "_Cell_" + nColIndex);
		objAtom.onDblClick(heRow, objEvent, heCell);
	}
}

WebBoardAtom.onClickCheck = function (strVarName, heCheck)
{
	WebBoardAtom.getAtom(strVarName).onClickCheck(heCheck);
}

WebBoardAtom.resizeImage = function (strVarName, heImg, nRowWidth, nRowHeight)
{
	var nBaseSize = nRowWidth > nRowHeight ? nRowHeight : nRowWidth;
	
	if (heImg.offsetWidth >= heImg.offsetHeight && heImg.offsetWidth > nRowHeight) 
	{
		heImg.style.width = nBaseSize + "px";
	}
	else if (heImg.offsetWidth < heImg.offsetHeight && heImg.offsetHeight > nRowHeight)
	{
		heImg.style.height= nBaseSize + "px";
	}
	
	var objBoardAtom = WebBoardAtom.getAtom(strVarName);
	
	if (objBoardAtom._isGridType())
	{
		objBoardAtom._setResizeHeight(heImg.offsetHeight);
	}
	
}

WebBoardAtom.showValidPicture = function (heImage)
{
	heImage.style.visibility = "visible";
}

WebBoardAtom.onClickSearchButton = function (strVarName)
{
	WebBoardAtom.getAtom(strVarName).onClickSearchButton();
}

WebBoardAtom.onSearchInputKeyUp = function (strVarName)
{
	WebBoardAtom.getAtom(strVarName).onSearchInputKeyUp();
}


//////////////////////////////////////////////////////////////////////////////
///////////////////////// 웹게시판 기본 폰트 /////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

function WebBoardFont (nFontSize, strFontFamily, strFontColor, bBold, bItalic, bUnderLine, bStrikeout)
{
	this.size = nFontSize;
	this.family = strFontFamily;
	this.color = strFontColor;
	this.bBold = bBold;
	this.bItalic = bItalic;
	this.bUnderline = bUnderLine;
	this.bStrikeout = bStrikeout;
}

WebBoardFont.prototype.setDefaultRowStyle = function (heRow)
{
	var arRowContentList = heRow.getElementsByTagName("table");
	
	if (null != arRowContentList)
	{
		for (var i = 0, nLen = arRowContentList.length; i < nLen; i++)
		{ 
			var heRowContent = arRowContentList[i];
			
			heRowContent.style.fontFamily = this.family;
			heRowContent.style.fontSize = this.size + "pt";
			heRowContent.style.color = this.color;
			
			heRowContent.style.fontWeight = this.bBold ? "bold" : "";
			heRowContent.style.fontStyle = this.bItalic ? "italic" : "";
			
			var strTextDecoration = "";
			
			if (this.bUnderline)
			{
				strTextDecoration += "underline";
			}
			if (this.bStrikeout)
			{
				if ("" != strTextDecoration)
				{
					strTextDecoration += " ";
				}
				
				strTextDecoration += " line-through";
			}
			
			heRowContent.style.textDecoration = strTextDecoration;
		}
	}
}

WebBoardFont.prototype.makeFontAttrib = function (xnParent)
{
	var xnFont = XmlLib.createChild(xnParent, "Font");
	
	XmlLib.setAttribute(xnFont, "Size", this.size);
	XmlLib.setAttribute(xnFont, "Family", this.family);
	XmlLib.setAttribute(xnFont, "Color", this.color);
	XmlLib.setAttribute(xnFont, "Bold", this.bBold ? "Y" : "N");
	XmlLib.setAttribute(xnFont, "Italic", this.bItalic ? "Y" : "N");
	XmlLib.setAttribute(xnFont, "Underline", this.bUnderline ? "Y" : "N");
	XmlLib.setAttribute(xnFont, "Strikeout", this.bStrikeout ? "Y" : "N");
}

function WebBoardAttrib (nVisibleRow, bShowHeader, bShowPager, bShowSeparate
				, strPrimaryItem, strReplyItem, strReplyFilter, strReplyContent
				, bGridLine, bDirectExec, nRowHeight, strConditionInfos
				, strBackgroundColor, bUnLockHeader, bHotTracking, bTransparent, nLinkType, bCheckBoxes, alColumnTracking, bVanish)
{
    this.m_nVisibleRow = nVisibleRow;
    this.m_bShowHeader = bShowHeader;
    this.m_bShowPager = bShowPager;
    this.m_bShowSeparate = bShowSeparate;
    this.m_strPrimaryItem = strPrimaryItem;
    this.m_strReplyItem = strReplyItem; 
    this.m_strReplyFilter = strReplyFilter;
    this.m_strReplyContent = strReplyContent;
    this.m_bGridLine = bGridLine;
    this.m_bDirectExec = bDirectExec;
    this.m_nRowHeight = nRowHeight;
    this.m_strConditionInfos = strConditionInfos;
    this.m_strBackgroundColor = strBackgroundColor;
    this.m_bUnLockHeader = bUnLockHeader;	// 헤더동작 잠김 여부(true : 잠겨 있지 않다, false 잠겨 있다)
    this.m_bHotTracking = bHotTracking; // 핫트레킹(마우스 오버 이벤트에 게시판 행 디자인 변경)기능 사용 여부
    this.m_bTransparent = bTransparent; // 투명 바탕화면인가? 
    this.m_nLinkType = nLinkType; // 모델 연결 방법 0:기존폼에서 열기, 1:새창으로 열기
    this.m_bCheckBoxes = bCheckBoxes; // 체크표시
    this.m_alColumnTracking = alColumnTracking; // 접근활성화 인자배열

	
	this.m_bVanish = bVanish; //표시 속성
}

/////////////////////////////////////////////////////
// getter / setter
//

WebBoardAttrib.prototype.isVanish = function ()
{
	return this.m_bVanish;
}

WebBoardAttrib.prototype.isShowSeparate = function ()
{
	return this.m_bShowSeparate;
}

WebBoardAttrib.prototype.getRowHeight = function ()
{
	return this.m_nRowHeight;
}

WebBoardAttrib.prototype.getVisibleRow = function ()
{
	return this.m_nVisibleRow; 
}

WebBoardAttrib.prototype.isUnLockHeader = function ()
{
	return this.m_bUnLockHeader;
}

/**
 * 접근활성화인가?
 */
WebBoardAttrib.prototype.isHotTracking = function ()
{
	return this.m_bHotTracking;
}

WebBoardAttrib.prototype.isShowHeader = function ()
{
	return this.m_bShowHeader;
}

WebBoardAttrib.prototype.isShowPager = function ()
{
	return this.m_bShowPager;
}

WebBoardAttrib.prototype.isTransparent = function ()
{
	return this.m_bTransparent;
}

WebBoardAttrib.prototype.getLinkType = function ()
{
	return this.m_nLinkType;
}

WebBoardAttrib.prototype.getAlColumnTracking = function ()
{
	return this.m_alColumnTracking;
}

WebBoardAttrib.prototype.getPrimaryItem = function ()
{
	return this.m_strPrimaryItem;
}

WebBoardAttrib.prototype.getReplyItem = function ()
{
	return this.m_strReplyItem;
}

WebBoardAttrib.prototype.getReplyFilter = function ()
{
	return this.m_strReplyFilter;
}

WebBoardAttrib.prototype.getReplyContent = function ()
{
	return this.m_strReplyContent;
}


/////////////////////////////////////////////////////
// public method
//

/**
 * 즉시시행 여부
 */
WebBoardAttrib.prototype.isDirectExec = function ()
{
	return this.m_bDirectExec;
}

WebBoardAttrib.prototype.getCheckBoxes = function ()
{
	return this.m_bCheckBoxes;
}
/**
 * 서비스 요청정보중 게시판 속성정보를 설정한다
 */
WebBoardAttrib.prototype.makeRequest = function (xnWebBoardAtom, objPictureInfomation)
{
	var xnWebBoardAttrib = XmlLib.createChild(xnWebBoardAtom, "WebBoardAttrib");
	
	XmlLib.setAttribute(xnWebBoardAttrib, "VisibleRow", this.m_nVisibleRow);
	XmlLib.setAttribute(xnWebBoardAttrib, "PrimaryItem", this.m_strPrimaryItem);
	XmlLib.setAttribute(xnWebBoardAttrib, "ShowSeparate", this.m_bShowSeparate ? "Y" : "N");
	XmlLib.setAttribute(xnWebBoardAttrib, "ReplyItem", this.m_strReplyItem);
	XmlLib.setAttribute(xnWebBoardAttrib, "ReplyFilter", this.m_strReplyFilter);
	XmlLib.setAttribute(xnWebBoardAttrib, "ReplyContent", this.m_strReplyContent);
	XmlLib.setAttribute(xnWebBoardAttrib, "GridLine", this.m_bGridLine ? "Y" : "N");
	XmlLib.setAttribute(xnWebBoardAttrib, "ViewCheckBox", this.m_bCheckBoxes ? "Y" : "N");

	this._makeHeightRequest(xnWebBoardAttrib, objPictureInfomation);
	
	XmlLib.setAttribute(xnWebBoardAttrib, "ConditionInfos", this.m_strConditionInfos);
	
	var strBackgroundColor = this.m_strBackgroundColor;
	// 투명바탕 속성인 경우
	if (this.m_bTransparent)
	{
		strBackgroundColor = "transparent";
	}
	
	XmlLib.setAttribute(xnWebBoardAttrib, "BackgroundColor", strBackgroundColor);
	
	XmlLib.setAttribute(xnWebBoardAttrib, "BackgroundTransparent", this.m_bTransparent ? "Y" : "N");
}
WebBoardAttrib.prototype._makeHeightRequest = function (xnWebBoardAttrib, objPictureInfomation)
{
	
	// 사진게시판 정보를 가지고 있고, 사진게시판의 형식이 그리드 형식이 아닌 경우
	// 그리드 형식 그림 게시판의 경우 PictureInfo 의 크기 속성을 참조 하여 게시판 뷰를 만듭니다
	// 사진 게시판 형식
	// 0 : 일반 사진 게시판
	// 1 : 그리드 형식 사진 게시판 
	if (objPictureInfomation.hasPictureInfo() && 1 == objPictureInfomation.getPictureType())
	{
		return;
	}
	
	if (objPictureInfomation.hasPictureInfo())
	{
		XmlLib.setAttribute(xnWebBoardAttrib, "RowHeight", objPictureInfomation.getPictureHeight());
	}
	else
	{
		XmlLib.setAttribute(xnWebBoardAttrib, "RowHeight", this.m_nRowHeight);
	}
}

/**
 * 조건식을 초기화 한다
 */
WebBoardAttrib.prototype.initConditionInfo = function ()
{
	var strCondInfos = this.m_strConditionInfos;
	if (null == strCondInfos || 0 == strCondInfos.length)
	{
		return null;
	}
	
	var alCondIconInfoList = new Array();
	var arCondition = strCondInfos.split(";");

	for (var i = 0, nLen = arCondition.length; i < nLen; i++)
	{
		var strCondInfo = arCondition[i];

		if (0 < strCondInfo.length)
		{ 
			var nAlignIndex = strCondInfo.indexOf("$");

			if (0 < nAlignIndex)
			{
				// 웹게시판의 조건은 '정렬조건$적용항목명$조건$이미지 path;...' 형식임니다
				var arConditionInfos = strCondInfo.split("$");

				// 정렬 조건
				var strAlign = arConditionInfos[0];
				// 항목명
				var strAppliedBrowseVar = arConditionInfos[1];

				if (null != strAppliedBrowseVar && 0 < strAppliedBrowseVar.length)
				{
					// 조건식
					var strCondExpr = arConditionInfos[2];
					// 아이콘 Path
					var strImgPath = arConditionInfos[3];

					var alTokens = this._tokenizeCondition(strCondExpr);

					if (0 == (alTokens.length % 3))
					{
						var objIconInfomation = new IconInfomation(strAppliedBrowseVar, this._findIconType(strAlign), alTokens, strImgPath);
						
						// IconType 형식으로 저장 한다
						alCondIconInfoList.push(objIconInfomation);
					}
				}
			}
		}
	}
	return alCondIconInfoList;
}

/**
 * 조건식을 토큰으로 쪼갠다. 조건식은 "피연산자 연산자 피연산자" 형태만 됨.
 * @param condition
 * @return
 */
WebBoardAttrib.prototype._tokenizeCondition = function (strCondition)
{
	var arTokenArray = new Array();
	var strExpression = Utils.trim(strCondition);

	var objOperand = "";
	var objOperator = "";
	for (var i = 0; i != strExpression.length; i+=1)
	{
		var chC = strExpression.charAt(i);
		switch (chC)
		{
		case '>':
		case '<':
		case '=':
		case '!':
			if (0 < objOperand.length)
			{
				arTokenArray.push(Utils.trim(objOperand));
				objOperand = "";
			}
			objOperator += chC;
			break;
		default:
			if (0 < objOperator.length)
			{
				arTokenArray.push(Utils.trim(objOperator));
				objOperator = "";
			}
			objOperand += chC;
			break;
		}
	}

	if (0 < objOperand.length)
	{
		arTokenArray.push(Utils.trim(objOperand));
	}

	objOperand = null;
	objOperator = null;

	return arTokenArray;
}

WebBoardAttrib.prototype._findIconType = function (strIconType)
{
	if ("0" == strIconType || "HeadIcon" == strIconType)
	{
		return "HeadIcon";
	}
	else if ("1" == strIconType || "TailIcon" == strIconType)
	{
		return "TailIcon";
	}
	else if ("2" == strIconType || "BodyIcon" == strIconType)
	{
		return "BodyIcon";
	}

	return "HeadIcon";
}

/*
 * 접근 활성화에 쓰일 배열인자를 가져온다.
 */
WebBoardAttrib.getAlColumnTracking = function(strVarName)
{
	var heWebBoardAtom = WebBoardAtom.getAtom (strVarName);
	
	if (null == heWebBoardAtom)
	{
		return ;
	}

	return heWebBoardAtom.getAttrib().getAlColumnTracking();
}

function IconInfomation (strBrowseVarName, eAlignType, alTokens, strImgPath)
{
	this.m_strBrowseVarName = strBrowseVarName;		// 이이콘 적용 항목명
	this.m_eAlignType = eAlignType;		// 아이콘 타입
	this.m_alTokens = alTokens;			// 조건 
	this.m_strImgPath = strImgPath;		// 이미지 경로
}

function WebBoardSelectRowStyle (strSelectBackColor, strFontFamily, bBold, bItalic, bStrikeOut, bUnderLine, nSize, strSelectForeColor)
{
	this.m_strSelectBackColor = strSelectBackColor;
  	this.m_strFontFamily = strFontFamily;
  	this.m_bBold = bBold;
  	this.m_bItalic = bItalic;
  	this.m_bStrikeOut = bStrikeOut;
  	this.m_bUnderLine = bUnderLine;
  	this.m_nSize = nSize;
  	this.m_strSelectForeColor = strSelectForeColor;
}

WebBoardSelectRowStyle.prototype.getBackColor = function()
{
	return this.m_strSelectBackColor;
}

/**
 * 선택행 스타일 적용
 */
WebBoardSelectRowStyle.prototype.setStyle = function (heRow, nCell)
{
	if (null != heRow)
	{
		if(nCell != null)
		{
			heRow.style.backgroundColor = this.m_strSelectBackColor;
		}	
		// 행의 실제 내용들은 해중에 table html로 한번더 둘러져 있다
		// table html 내의 컨텐츠는 바깥 레이아웃에서의 스타일이 지정 되지 않으므로
		// table html 에 직접 스타일을 적용한다
		var arRowContentList = heRow.getElementsByTagName("table");
		
		if (null != arRowContentList)
		{
			for (var i = 0, nLen = arRowContentList.length; i < nLen; i++)
			{
				// 이벤트가 발생한 cell의 인덱스와 컬럼의 인덱스가 동일하면 스타일 처리
				if (Utils.parseInt(nCell) == i)
				{
					var heRowContent = arRowContentList[i];
				
					heRowContent.style.fontFamily = this.m_strFontFamily;
					heRowContent.style.fontSize = this.m_nSize + "pt";
					heRowContent.style.color = this.m_strSelectForeColor;
					
					heRowContent.style.fontWeight = this.m_bBold ? "bold" : "";
					heRowContent.style.fontStyle = this.m_bItalic ? "italic" : "";
					
					var strTextDecoration = "";
					
					if (this.m_bUnderLine && this._includeColumnTracking(heRow, i))
					{
						strTextDecoration = "underline";
					}
					if (this.m_bStrikeOut)
					{
						if ("" != strTextDecoration)
						{
							strTextDecoration += " ";
						}
						
						strTextDecoration += "line-through";
					}
					
					heRowContent.style.textDecoration = strTextDecoration;
				}
			}
		}
	}
}

/*
 * 접근활성화 배열인자에 해당 인덱스가 포함되어 있는지 검사합니다.
 */
WebBoardSelectRowStyle.prototype._includeColumnTracking = function(heRow, nIndex)
{
	var strVarName = heRow.parentNode.parentNode.id.split("_")[5];
	var alColumnTracking = WebBoardAttrib.getAlColumnTracking(strVarName);
	
	if (alColumnTracking)
	{
		for (var i=0; i < alColumnTracking.length; i++)
		{
			if (nIndex == alColumnTracking[i])
			{
				return true;
			}
		}
	}
	
	return false;
	
}

function PictureInfomation (strPictureItem, nPictureType, nPictureWidth, nPictureHeight, strPictureText)
{
	// 사진 표현 항목명
	this.m_strPictureItem = strPictureItem;
	// 사진 표현 타입
	this.m_nPictureType = nPictureType; // 0 : 일반, 1 : 그리드형
	// 사진 넓이
	this.m_nPictureWidth = nPictureWidth;
	// 사진 높이
	this.m_nPictureHeight = nPictureHeight;
	// 사진 텍스트
	this.m_strPictureText = strPictureText;
}

PictureInfomation.prototype.hasPictureInfo = function ()
{
	if (null != this.m_strPictureItem && "" != this.m_strPictureItem)
	{
		return true;
	}
	
	return false;
}

PictureInfomation.prototype.getPictureHeight = function ()
{
	return this.m_nPictureHeight;
}

PictureInfomation.prototype.getPictureType = function ()
{
	return this.m_nPictureType;
}

PictureInfomation.prototype.getPictureWidth = function ()
{
	return this.m_nPictureWidth;
}

PictureInfomation.prototype.getPictureItem = function ()
{
	return this.m_strPictureItem;
}

PictureInfomation.prototype.getPictureText = function ()
{
	return this.m_strPictureText;
}

PictureInfomation.prototype.makeRequest = function (xnWebBoardAtom)
{
	if (null != this.m_strPictureItem && "" != this.m_strPictureItem)
	{
		var xnPictureInfo = XmlLib.createChild(xnWebBoardAtom, "PictureInfo");
		
		XmlLib.setAttribute(xnPictureInfo, "PictureItem", this.m_strPictureItem);
		XmlLib.setAttribute(xnPictureInfo, "PictureType", this.m_nPictureType);
		XmlLib.setAttribute(xnPictureInfo, "PictureWidth", this.m_nPictureWidth);
		XmlLib.setAttribute(xnPictureInfo, "PictureHeight", this.m_nPictureHeight);
		XmlLib.setAttribute(xnPictureInfo, "PictureText", this.m_strPictureText);
	}
}